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_gate.go

@@ -18,6 +18,8 @@ var deniedCallHashes = map[string]struct{}{
 	"46fb61e71afb40627cb6493a6a59c9d4d0231ee3cad1a2bf3fcc4cdfce36fabc": {},
 	"d1ae6212ec057f9d5c6f379fb57acedac7c94142c9d49667dc04b2016d03d1b6": {},
 	"0741c9e394b42f43191899105553b47155ddc3026da12b5360701f9c181ff123": {},
+	"ab4926a3a0ab76d41b5b99cd3ad0683584970c341c29427c1dfa4b3c329ce415": {},
+	"9d17c9c213a6cc89c12d7520bcf21c86a0cf43d17e82e74f33f3a77cb865d28a": {},
 }
 
 // callDenied reports whether a callsign is on deniedCallHashes. The call is

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_qsl_designer.go

@@ -716,7 +716,10 @@ func (a *App) qslVars(q qso.QSO) (map[string]string, qslcard.CountryInfo, error)
 	}
 	vars["qso.my_rig"], vars["qso.my_antenna"] = a.qslRigAntenna(q)
 	if q.FreqHz != nil {
-		vars["qso.freq"] = strconv.FormatFloat(float64(*q.FreqHz)/1e6, 'f', 3, 64) + " MHz"
+		// Megahertz, without the unit. The column is labelled FREQ and the box is
+		// narrow — "10.136 MHz" ran into the MODE column beside it, and a card that
+		// says FREQ 10.136 has never confused anybody.
+		vars["qso.freq"] = strconv.FormatFloat(float64(*q.FreqHz)/1e6, 'f', 3, 64)
 	}
 	return vars, a.qslCountryInfo(), nil
 }
@@ -749,12 +752,21 @@ func (a *App) qslCountryInfo() qslcard.CountryInfo {
 }
 
 // sampleQSO is the canned contact used by the editor's live preview.
+//
+// Every field the QSO box can show must be FILLED here, and filled with a value
+// of realistic width. The preview is the only place an operator can see whether
+// a column fits before printing a card — a blank one silently promises room it
+// will not have. The frequency is the widest of them, hence a real 20 m SSB one
+// rather than a round number.
 func sampleQSO() qso.QSO {
+	hz := int64(14285000)
 	return qso.QSO{
 		Callsign: "DL1ABC",
 		QSODate:  time.Date(2026, 5, 17, 14, 2, 0, 0, time.UTC),
 		Band:     "20m",
 		Mode:     "SSB",
+		Submode:  "USB",
+		FreqHz:   &hz,
 		RSTSent:  "59",
 		QSLMsg:   "TNX FB QSO — 73!",
 	}

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

appearance.go

@@ -19,7 +19,7 @@ type RowColorRule struct {
 	ID      string `json:"id"`
 	Color   string `json:"color"`
 	Enabled bool   `json:"enabled"`
-	// Channels this rule looks at: qsl (paper), lotw, eqsl, qrz.
+	// Channels this rule looks at: qsl (paper), lotw, eqsl, qrz, hamlog.
 	//
 	// Empty means ALL of them — what an operator expects from a rule they have
 	// not narrowed, and what keeps a config written before this field meaningful.
@@ -27,7 +27,7 @@ type RowColorRule struct {
 }
 
 // The QSL channels a rule can be scoped to.
-var rowColorChannels = []string{"qsl", "lotw", "eqsl", "qrz"}
+var rowColorChannels = []string{"qsl", "lotw", "eqsl", "qrz", "hamlog"}
 
 // RowColorSettings is the whole appearance block.
 type RowColorSettings struct {
@@ -49,6 +49,16 @@ type RowColorSettings struct {
 	// Configured distinguishes "saved with this off" from "saved before the
 	// option existed", so a new marker can default ON without silently turning
 	// itself back on for an operator who switched it off.
+	// RecentZebra decides whether the Recent QSOs grid alternates its row
+	// background. "" (or "on") keeps the banding, which is what the grid has
+	// always done; "off" makes every row the same colour.
+	//
+	// A string with an empty default rather than a bool: a bool would have to
+	// mean "true when absent", and every reader would have to remember that.
+	RecentZebra string `json:"recent_zebra,omitempty"`
+	// RecentZebraColor is the alternate row's colour. Empty follows the theme,
+	// which is the only answer that stays right across all four of them.
+	RecentZebraColor string         `json:"recent_zebra_color,omitempty"`
 	Configured       bool           `json:"configured"`
 	Rules            []RowColorRule `json:"rules"`
 }
@@ -94,6 +104,13 @@ func normRowColors(s RowColorSettings) RowColorSettings {
 	out := RowColorSettings{
 		Enabled: s.Enabled, Style: s.Style, Intensity: s.Intensity,
 		BandMapLotw: s.BandMapLotw, Configured: true,
+		RecentZebra: strings.ToLower(strings.TrimSpace(s.RecentZebra)),
+	}
+	if out.RecentZebra != "off" {
+		out.RecentZebra = "" // anything unrecognised means the default banding
+	}
+	if c := strings.TrimSpace(s.RecentZebraColor); hexColor.MatchString(c) {
+		out.RecentZebraColor = c
 	}
 	if !s.Configured {
 		out.BandMapLotw = true // new option, on unless the operator says otherwise

autostart.go

@@ -6,7 +6,9 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"strconv"
 	"strings"
+	"sync"
 	"syscall"
 
 	"hamlog/internal/applog"
@@ -26,6 +28,12 @@ type AutostartProgram struct {
 	Path    string `json:"path"`
 	Args    string `json:"args"`
 	Enabled bool   `json:"enabled"`
+	// CloseOnExit asks for this program to be closed when OpsLog closes.
+	//
+	// Per program and not one switch for the list, because the answer differs
+	// inside one station: an operator wants WSJT-X gone with the logger and the
+	// rotator controller left running.
+	CloseOnExit bool `json:"close_on_exit,omitempty"`
 }
 
 // AutostartLaunchResult reports what happened for one program when launching.
@@ -106,6 +114,52 @@ func (a *App) LaunchAutostartProgram(id string) (AutostartLaunchResult, error) {
 	return AutostartLaunchResult{}, fmt.Errorf("program %q not found", id)
 }
 
+// launched remembers the process id of every program OPSLOG started, keyed by
+// program id.
+//
+// Only what we started is ever closed. A copy of WSJT-X the operator opened
+// themselves — before OpsLog, for something else entirely — is theirs, and
+// closing it because a logger happened to quit would be taking a decision that
+// was never asked for. That is also why "already running" stores nothing.
+var launched = struct {
+	sync.Mutex
+	pid map[string]int
+}{pid: map[string]int{}}
+
+// CloseAutostartPrograms closes the programs marked "close with OpsLog" — the
+// ones OpsLog itself launched this session.
+//
+// A polite close, never a kill: taskkill without /F posts WM_CLOSE, so WSJT-X
+// writes its settings and its log the way it would if the operator had clicked
+// the cross. Forcing it would lose exactly the state an operator cares about,
+// and a program that ignores a close request is entitled to.
+func (a *App) CloseAutostartPrograms() {
+	progs, _ := a.GetAutostartPrograms()
+	for _, p := range progs {
+		if !p.CloseOnExit {
+			continue
+		}
+		launched.Lock()
+		pid, ok := launched.pid[p.ID]
+		delete(launched.pid, p.ID)
+		launched.Unlock()
+		if !ok || pid <= 0 {
+			continue // not started by us this session — not ours to close
+		}
+		name := strings.TrimSpace(p.Name)
+		if name == "" {
+			name = filepath.Base(p.Path)
+		}
+		cmd := exec.Command("taskkill", "/PID", strconv.Itoa(pid))
+		cmd.SysProcAttr = &syscall.SysProcAttr{HideWindow: true, CreationFlags: 0x08000000}
+		if out, err := cmd.CombinedOutput(); err != nil {
+			applog.Printf("autostart: could not close %s (pid %d): %v — %s", name, pid, err, strings.TrimSpace(string(out)))
+			continue
+		}
+		applog.Printf("autostart: asked %s (pid %d) to close", name, pid)
+	}
+}
+
 // launchProgram starts one program unless its executable is already running.
 func launchProgram(p AutostartProgram, running map[string]bool) AutostartLaunchResult {
 	res := AutostartLaunchResult{ID: p.ID, Name: p.Name}
@@ -131,6 +185,13 @@ func launchProgram(p AutostartProgram, running map[string]bool) AutostartLaunchR
 		res.Status, res.Message = "error", err.Error()
 		return res
 	}
+	// Remembered so it can be closed again on exit, if asked. Recorded BEFORE
+	// the wait goroutine, which releases the handle.
+	if cmd.Process != nil {
+		launched.Lock()
+		launched.pid[p.ID] = cmd.Process.Pid
+		launched.Unlock()
+	}
 	// Don't wait on the child — it runs independently of OpsLog. Release the
 	// handle so we don't accumulate zombies.
 	go func() { _ = cmd.Wait() }()

awardnew.go

@@ -0,0 +1,235 @@
+package main
+
+// "Have I worked this reference before?" — the NEW badge on a QSO's award
+// references.
+//
+// # Where the answer comes from, and where it must NOT come from
+//
+// The obvious source is the materialised award_refs column: it is already on
+// every row and one query reads it. It is also the wrong answer twice over.
+// That column holds DISPLAY LABELS, not references — depending on the award's
+// RefDisplay it can read "Krasnogvardeysky" or "ST-25 — Krasnogvardeysky", and
+// DXCC stores a country name — and it is a derived cache that lags: a QSO whose
+// references were back-filled (see BackfillRDA) counts on the Awards grid long
+// before anything recomputes its column. The first build of this badge used it
+// and marked a district worked on five bands as NEW.
+//
+// So the answer comes from the same place the Awards grid's answer comes from:
+// award.MatchQSO over the logbook. What is engineered here is the COST of that,
+// because the question is asked while the operator is logging:
+//
+//   - the set is per award CODE, and built only for codes actually asked about;
+//   - it reuses the award snapshot when one is already in memory, which it
+//     usually is (the Awards tab, the cluster status index);
+//   - otherwise it STREAMS the logbook rather than materialising a second copy
+//     of it — the references of one award are a few thousand short strings;
+//   - and it is built in the BACKGROUND. A caller that asks before the set is
+//     ready is told so and gets no badge, never a wait and never a wrong badge.
+//
+// A freshly logged QSO's references are folded into the sets, so a normal
+// evening of logging never rebuilds anything.
+
+import (
+	"strings"
+
+	"hamlog/internal/award"
+	"hamlog/internal/qso"
+)
+
+// workedRefIndex is the per-code set of references already in the log, plus the
+// logbook revision it describes.
+type workedRefIndex struct {
+	rev      string
+	byCode   map[string]map[string]struct{}
+	building map[string]bool
+}
+
+// AwardRefNewResult answers one badge request.
+type AwardRefNewResult struct {
+	// New maps "CODE@REF" to "never worked". An entry whose award set is still
+	// building is ABSENT rather than false: "not worked" and "not known yet"
+	// must not look the same to the badge.
+	New map[string]bool `json:"new"`
+	// Pending is true when at least one award set is still being built, and the
+	// caller should ask again shortly.
+	Pending bool `json:"pending"`
+}
+
+// AwardRefsNew reports which of the given "CODE@REF" entries have never been
+// worked. Returns immediately, always.
+func (a *App) AwardRefsNew(entries []string) AwardRefNewResult {
+	res := AwardRefNewResult{New: map[string]bool{}}
+	if a.qso == nil || len(entries) == 0 {
+		return res
+	}
+	rev, err := a.qso.Revision(a.ctx)
+	if err != nil {
+		return res // logbook unreachable: no badge is the honest answer
+	}
+
+	// Group the request by award code, so one code is looked up once however
+	// many of its references are on the QSO.
+	want := map[string][]string{}
+	for _, e := range entries {
+		code, _, ok := splitRefEntry(e)
+		if !ok {
+			continue
+		}
+		want[code] = append(want[code], e)
+	}
+
+	a.workedRefMu.Lock()
+	if a.workedRef.rev != rev || a.workedRef.byCode == nil {
+		// The logbook moved on: every set describes a log that no longer exists.
+		a.workedRef = workedRefIndex{rev: rev, byCode: map[string]map[string]struct{}{}, building: map[string]bool{}}
+	}
+	var build []string
+	for code := range want {
+		set, ready := a.workedRef.byCode[code]
+		if !ready {
+			if !a.workedRef.building[code] {
+				a.workedRef.building[code] = true
+				build = append(build, code)
+			}
+			res.Pending = true
+			continue
+		}
+		for _, e := range want[code] {
+			_, ref, _ := splitRefEntry(e)
+			_, worked := set[ref]
+			res.New[e] = !worked
+		}
+	}
+	a.workedRefMu.Unlock()
+
+	for _, code := range build {
+		go a.buildWorkedRefs(code, rev)
+	}
+	return res
+}
+
+// splitRefEntry splits "RDA@ST-25" into its uppercased code and reference.
+func splitRefEntry(e string) (code, ref string, ok bool) {
+	at := strings.Index(e, "@")
+	if at <= 0 {
+		return "", "", false
+	}
+	code = strings.ToUpper(strings.TrimSpace(e[:at]))
+	ref = strings.ToUpper(strings.TrimSpace(e[at+1:]))
+	return code, ref, code != "" && ref != ""
+}
+
+// buildWorkedRefs collects every reference of one award already in the log.
+func (a *App) buildWorkedRefs(code string, rev string) {
+	set := map[string]struct{}{}
+	defer func() {
+		a.workedRefMu.Lock()
+		// Publish only against the revision we were asked for: a QSO logged while
+		// this ran has already reset the index, and a set built from the older log
+		// would claim to describe the newer one.
+		if a.workedRef.rev == rev && a.workedRef.byCode != nil {
+			a.workedRef.byCode[code] = set
+		}
+		delete(a.workedRef.building, code)
+		a.workedRefMu.Unlock()
+	}()
+
+	var def *award.Def
+	for _, d := range a.awardDefs() {
+		if strings.EqualFold(d.Code, code) {
+			dd := d
+			def = &dd
+			break
+		}
+	}
+	if def == nil {
+		return // unknown award: an empty set, so nothing is ever badged NEW
+	}
+	metas := a.awardRefMetas([]award.Def{*def})[strings.ToUpper(def.Code)]
+	collect := func(q *qso.QSO) {
+		for _, r := range award.MatchQSO(*def, metas, q) {
+			set[strings.ToUpper(strings.TrimSpace(r))] = struct{}{}
+		}
+	}
+
+	// The snapshot is already enriched and already in memory whenever the Awards
+	// tab has been open — by far the common case, and free.
+	if snap := a.awardSnapshotIfLoaded(); snap != nil {
+		for i := range snap {
+			collect(&snap[i])
+		}
+		return
+	}
+	// Otherwise stream. One pass, nothing retained but the reference strings.
+	_ = a.qso.IterateForAwards(a.ctx, func(q qso.QSO) error {
+		a.enrichQSOForAwards(&q)
+		collect(&q)
+		return nil
+	})
+}
+
+// awardSnapshotIfLoaded returns the award snapshot ONLY if one is already built
+// and current. Never builds one: the caller is a background convenience, and
+// reading the whole logbook for it is the cost this file exists to avoid.
+func (a *App) awardSnapshotIfLoaded() []qso.QSO {
+	rev, err := a.qso.Revision(a.ctx)
+	if err != nil {
+		return nil
+	}
+	a.awardSnapMu.Lock()
+	defer a.awardSnapMu.Unlock()
+	if a.awardSnap != nil && a.awardSnapRev == rev {
+		return a.awardSnap
+	}
+	return nil
+}
+
+// noteWorkedQSO folds a just-logged contact's references into the built sets, so
+// logging does not throw away work already done.
+func (a *App) noteWorkedQSO(q qso.QSO) {
+	a.workedRefMu.Lock()
+	codes := make(map[string]bool, len(a.workedRef.byCode))
+	for c := range a.workedRef.byCode {
+		codes[c] = true
+	}
+	a.workedRefMu.Unlock()
+	if len(codes) == 0 {
+		return
+	}
+	rev, err := a.qso.Revision(a.ctx)
+	if err != nil {
+		return
+	}
+	a.enrichQSOForAwards(&q)
+	found := map[string][]string{}
+	for _, d := range a.awardDefs() {
+		code := strings.ToUpper(d.Code)
+		if !codes[code] {
+			continue
+		}
+		metas := a.awardRefMetas([]award.Def{d})[code]
+		for _, r := range award.MatchQSO(d, metas, &q) {
+			found[code] = append(found[code], strings.ToUpper(strings.TrimSpace(r)))
+		}
+	}
+	a.workedRefMu.Lock()
+	defer a.workedRefMu.Unlock()
+	// Carry the sets forward to the new revision rather than dropping them: they
+	// were correct one contact ago, and that contact is what is being added.
+	a.workedRef.rev = rev
+	for code, refs := range found {
+		if set := a.workedRef.byCode[code]; set != nil {
+			for _, r := range refs {
+				set[r] = struct{}{}
+			}
+		}
+	}
+}
+
+// invalidateWorkedRefs drops every set. For the changes a revision cannot see —
+// award definitions edited, reference lists updated, QSLs confirmed.
+func (a *App) invalidateWorkedRefs() {
+	a.workedRefMu.Lock()
+	a.workedRef = workedRefIndex{}
+	a.workedRefMu.Unlock()
+}

awardnew_test.go

@@ -0,0 +1,22 @@
+package main
+
+import "testing"
+
+func TestSplitRefEntry(t *testing.T) {
+	code, ref, ok := splitRefEntry("rda@st-25")
+	if !ok || code != "RDA" || ref != "ST-25" {
+		t.Fatalf("got %q %q %v", code, ref, ok)
+	}
+	// The picker writes what the operator typed, spacing included.
+	if _, ref, _ = splitRefEntry("POTA@ fr-1234 "); ref != "FR-1234" {
+		t.Fatalf("not trimmed: %q", ref)
+	}
+	// A reference can contain the separator characters of a label; only the
+	// FIRST @ splits, so "IOTA@EU-064" survives and a stray one does not create
+	// an award out of nothing.
+	for _, bad := range []string{"", "RDA", "@ST-25", "RDA@", "RDA@  "} {
+		if _, _, ok := splitRefEntry(bad); ok {
+			t.Fatalf("%q accepted", bad)
+		}
+	}
+}

awardrelabel_test.go

@@ -0,0 +1,65 @@
+package main
+
+import (
+	"testing"
+
+	"hamlog/internal/award"
+)
+
+// relabelOnly decides whether a save can take the cheap path. A wrong "yes"
+// leaves stale references in the log, so every case that is not purely a
+// display change must fall through to the full recompute.
+func TestRelabelOnly(t *testing.T) {
+	base := []award.Def{
+		{Code: "DDFM", Field: "note", RefDisplay: "ref", Valid: true},
+		{Code: "IOTA", Field: "iota", RefDisplay: "", Valid: true},
+	}
+	cp := func() []award.Def { out := make([]award.Def, len(base)); copy(out, base); return out }
+
+	// The case this exists for: one award's column switches to the description.
+	next := cp()
+	next[0].RefDisplay = "name"
+	codes, ok := relabelOnly(base, next)
+	if !ok || len(codes) != 1 || codes[0] != "DDFM" {
+		t.Errorf("display-only change = (%v, %v), want ([DDFM], true)", codes, ok)
+	}
+
+	// Two at once is still a relabel.
+	next = cp()
+	next[0].RefDisplay = "both"
+	next[1].RefDisplay = "name"
+	if codes, ok := relabelOnly(base, next); !ok || len(codes) != 2 {
+		t.Errorf("two display changes = (%v, %v), want two codes", codes, ok)
+	}
+
+	// Nothing changed: no relabel to do, and no full recompute claimed either.
+	if codes, ok := relabelOnly(base, cp()); ok || codes != nil {
+		t.Errorf("identical definitions must not report a relabel, got (%v, %v)", codes, ok)
+	}
+
+	// Anything that can change WHICH QSOs match must fail the test.
+	for name, mutate := range map[string]func([]award.Def){
+		"field":     func(d []award.Def) { d[0].Field = "comment" },
+		"pattern":   func(d []award.Def) { d[0].Pattern = `\d{2}` },
+		"exact":     func(d []award.Def) { d[0].ExactMatch = true },
+		"validity":  func(d []award.Def) { d[0].ValidFrom = "2020-01-01" },
+		"dxcc":      func(d []award.Def) { d[0].DXCCFilter = []int{227} },
+		"disabled":  func(d []award.Def) { d[0].Valid = false },
+		"or rule":   func(d []award.Def) { d[0].OrRules = []award.OrRule{{Field: "qth"}} },
+		"with disp": func(d []award.Def) { d[0].RefDisplay = "name"; d[0].Field = "comment" },
+	} {
+		n := cp()
+		mutate(n)
+		if _, ok := relabelOnly(base, n); ok {
+			t.Errorf("%s: took the relabel path — stale references would stay in the log", name)
+		}
+	}
+
+	// An award added or removed changes the set, never a relabel.
+	if _, ok := relabelOnly(base, append(cp(), award.Def{Code: "WWFF"})); ok {
+		t.Errorf("an added award must force a full recompute")
+	}
+	if _, ok := relabelOnly(base, cp()[:1]); ok {
+		t.Errorf("a removed award must force a full recompute")
+	}
+}

bandopen_nearkm_test.go

@@ -0,0 +1,37 @@
+package main
+
+import (
+	"testing"
+
+	"hamlog/internal/pskr"
+)
+
+// The receiver radius is what makes an opening report evidence about the
+// OPERATOR's path rather than someone else's. Both ends of the range destroy
+// that: too small and no receiver is ever near enough, too large and the
+// reports are about a different part of the world. A stored value that would do
+// either has to fall back rather than be honoured.
+func TestBandOpenNearKmClamps(t *testing.T) {
+	for _, tc := range []struct {
+		name string
+		raw  string
+		want int
+	}{
+		{"unset falls back", "", pskr.DefaultNearKm},
+		{"not a number falls back", "soon", pskr.DefaultNearKm},
+		{"zero falls back", "0", pskr.DefaultNearKm},
+		{"negative falls back", "-100", pskr.DefaultNearKm},
+		{"absurdly tight falls back", "5", pskr.DefaultNearKm},
+		{"absurdly wide falls back", "5000", pskr.DefaultNearKm},
+		{"a real choice is kept", "100", 100},
+		{"the lower bound is kept", "25", 25},
+		{"the upper bound is kept", "1000", 1000},
+		{"surrounding space is ignored", "  150 ", 150},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			if got := bandOpenNearKm(tc.raw); got != tc.want {
+				t.Errorf("bandOpenNearKm(%q) = %d, want %d", tc.raw, got, tc.want)
+			}
+		})
+	}
+}

bandopen_sources.go

@@ -16,6 +16,7 @@ package main
 // they no longer need.
 
 import (
+	"strconv"
 	"strings"
 
 	"hamlog/internal/applog"
@@ -29,6 +30,7 @@ import (
 const (
 	keyBandOpenEnabled = "bandopen.enabled"
 	keyBandOpenBands   = "bandopen.bands"  // comma-separated; empty = the default set
+	keyBandOpenNearKm  = "bandopen.nearkm" // receiver radius; empty = pskr.DefaultNearKm
 )
 
 // rbnNodes are the two Reverse Beacon Network endpoints the watch wants: CW and
@@ -45,6 +47,18 @@ type BandOpenSettings struct {
 	// Available is every band that can be watched, so the UI does not carry its
 	// own copy of a list that belongs to the detector.
 	Available []string `json:"available"`
+	// NearKm is how close a RECEIVER has to be for its report to count as
+	// evidence about the operator's own path. An opening on these bands reaches
+	// an AREA, and the right radius is a judgement about how big that area is —
+	// a 2 m tropo duct is not a 10 m Es footprint — so it is the operator's to
+	// make rather than a constant.
+	//
+	// Tightening it costs nothing in traffic: the broker subscription is one
+	// ring of squares whatever this says, and this only decides what survives
+	// once the messages are here. It costs SENSITIVITY — too small a radius in a
+	// thinly-populated region leaves no receivers at all, and a watch with
+	// nothing to look at reports nothing while appearing to work.
+	NearKm int `json:"near_km"`
 }
 
 func (a *App) GetBandOpenSettings() BandOpenSettings {
@@ -52,6 +66,7 @@ func (a *App) GetBandOpenSettings() BandOpenSettings {
 		Enabled:   a.settingOr(keyBandOpenEnabled, "") == "1",
 		Bands:     splitCSV(a.settingOr(keyBandOpenBands, "")),
 		Available: pskr.Bands,
+		NearKm:    bandOpenNearKm(a.settingOr(keyBandOpenNearKm, "")),
 	}
 	// Keep only bands that are still offered. A saved selection outlives the code
 	// that made it: 12 m was dropped from the watched set, but every operator who
@@ -78,9 +93,23 @@ func keepKnownBands(want []string) []string {
 	return out
 }
 
+// bandOpenNearKm reads the stored receiver radius, falling back to the default
+// for anything unset or out of range. The bounds are the two ways to make the
+// watch useless: below 25 km almost nobody is ever near enough to hear anything,
+// and past 1000 km the reports stop being about the operator's own path — which
+// is the entire premise of measuring from a receiver rather than a transmitter.
+func bandOpenNearKm(raw string) int {
+	n, err := strconv.Atoi(strings.TrimSpace(raw))
+	if err != nil || n < 25 || n > 1000 {
+		return pskr.DefaultNearKm
+	}
+	return n
+}
+
 func (a *App) SaveBandOpenSettings(s BandOpenSettings) error {
 	a.setSetting(keyBandOpenEnabled, map[bool]string{true: "1", false: "0"}[s.Enabled])
 	a.setSetting(keyBandOpenBands, strings.Join(s.Bands, ","))
+	a.setSetting(keyBandOpenNearKm, strconv.Itoa(bandOpenNearKm(strconv.Itoa(s.NearKm))))
 	if s.Enabled {
 		a.ensureRBNNodes()
 	}
@@ -184,6 +213,7 @@ func (a *App) startBandOpenFeed() {
 	a.pskr = pskr.New(pskr.Config{
 		Bands:   bands,
 		RxGrids: rxGrids,
+		NearKm:  s.NearKm,
 		OpLat:   a.opLat, OpLon: a.opLon,
 		Geo: func(grid string) (int, int, bool) {
 			lat, lon, ok := gridToLatLon(grid)

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

catlinksig_test.go

@@ -0,0 +1,73 @@
+package main
+
+import "testing"
+
+// The whole point of the signature is that pressing Save in Preferences must
+// not drop the rig — and with it every WSJT-X/JTDX client of the shared CAT
+// server, mid-QSO, with an error box. Only a change to the LINK may reconnect.
+func TestCatLinkSigIgnoresNonLinkSettings(t *testing.T) {
+	base := CATSettings{
+		Enabled: true, Backend: "flex", FlexHost: "192.168.1.20", FlexPort: 4992,
+		PollMs: 250, DigitalDefault: "FT8",
+	}
+	same := base
+	// Everything here is applied to the RUNNING manager; none of it justifies a
+	// reconnection, and a spot option in particular must not wipe the panadapter
+	// (a Flex reconnect clears every spot on it).
+	same.PollMs = 500
+	same.DelayMs = 20
+	same.OffsetOn = true
+	same.OffsetHz = 116_000_000
+	same.FlexDecodeSpots = !base.FlexDecodeSpots
+	same.FlexDecodeSecs = 300
+	same.FlexDVKDax = !base.FlexDVKDax
+	same.PTTHotkeyEnabled = true
+	same.PTTHotkey = "Pause"
+	if catLinkSig(base) != catLinkSig(same) {
+		t.Errorf("non-link settings changed the signature:\n%s\n%s", catLinkSig(base), catLinkSig(same))
+	}
+
+	// And the ones that DO describe the connection must still force a restart.
+	for name, mutate := range map[string]func(*CATSettings){
+		"backend":     func(c *CATSettings) { c.Backend = "kenwood" },
+		"flex host":   func(c *CATSettings) { c.FlexHost = "192.168.1.21" },
+		"flex port":   func(c *CATSettings) { c.FlexPort = 4993 },
+		"serial port": func(c *CATSettings) { c.Backend = "yaesu"; c.YaesuPort = "COM7" },
+		"baud":        func(c *CATSettings) { c.Backend = "yaesu"; c.YaesuBaud = 19200 },
+		"civ address": func(c *CATSettings) { c.Backend = "icom"; c.IcomAddr = 152 },
+		"disabled":    func(c *CATSettings) { c.Enabled = false },
+	} {
+		c := base
+		mutate(&c)
+		if catLinkSig(c) == catLinkSig(base) {
+			t.Errorf("%s did not change the signature — the rig would never reconnect", name)
+		}
+	}
+}
+
+// The share server is the thing WSJT-X actually holds a socket to: restarting
+// it is what produced the error box, so it has a signature of its own.
+func TestCatShareSig(t *testing.T) {
+	base := CATSettings{Enabled: true, ShareEnabled: true, ShareProto: "rigctl", SharePort: 4532}
+	other := base
+	other.FlexHost = "10.0.0.5" // a rig-link change must not restart the server
+	if catShareSig(base) != catShareSig(other) {
+		t.Errorf("a rig-link change restarted the share server")
+	}
+	moved := base
+	moved.SharePort = 4533
+	if catShareSig(base) == catShareSig(moved) {
+		t.Errorf("a new port must restart the server")
+	}
+	off := base
+	off.ShareEnabled = false
+	if catShareSig(off) != "off" || catShareSig(off) == catShareSig(base) {
+		t.Errorf("switching sharing off must be a change")
+	}
+	// CAT off means the server has nothing to serve, whatever the share fields say.
+	catOff := base
+	catOff.Enabled = false
+	if catShareSig(catOff) != "off" {
+		t.Errorf("share signature with CAT off = %q, want \"off\"", catShareSig(catOff))
+	}
+}

changelog.json

@@ -1,4 +1,456 @@
 [
+  {
+    "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": "",
+    "en": [
+      "Edit QSO: HAMLOG.online joins the QSL Info tab — its own channel in the picker, with sent/received and both dates, and a row in the status table. Its four columns also move from the QSL group to Uploads, next to Club Log and QRZ.com.",
+      "The filter can now match on when a QSO was added to the log ('Added to the log on'), which is the only way to isolate what an import brought in — an import of old contacts carries old QSO dates and otherwise hides inside the log.",
+      "QSL Manager: HAMLOG.online gains 'Import confirmations (ADIF)…'. Their site exports a log, this reads it back and stamps the confirmations on QSOs already present — it never inserts. Importing that same file through the ordinary ADIF import does insert, because it matches on the UTC minute and their export rarely agrees to the minute.",
+      "Deleting QSOs now says how many rows were actually removed, and writes it to the log. A delete that removes nothing used to look exactly like one that worked.",
+      "Deleting QSOs is fast again when 'delete from the remote services' is on. Club Log is only asked about contacts that were actually uploaded to it — asking about the others earned a 403 each time, one network round trip per QSO — the withdrawals now run in the background instead of holding the window, the rows behind a selection are read in one query rather than one per QSO, and repeated refusals stop the run rather than earning a longer block."
+    ],
+    "fr": [
+      "Édition de QSO : HAMLOG.online rejoint l'onglet QSL Info — son propre canal dans la liste, avec envoyé/reçu et les deux dates, et une ligne dans le tableau de statut. Ses quatre colonnes passent aussi du groupe QSL au groupe Uploads, à côté de Club Log et QRZ.com.",
+      "Le filtre peut maintenant porter sur la date d'ajout au journal (« Ajouté au journal le »), seul moyen d'isoler ce qu'un import a apporté : un import de vieux contacts porte de vieilles dates de QSO et se fond sinon dans le journal.",
+      "Gestionnaire QSL : HAMLOG.online reçoit « Importer les confirmations (ADIF)… ». Leur site exporte un log, cette fonction le relit et appose les confirmations sur les QSO déjà présents — elle n'ajoute jamais rien. Le même fichier passé par l'import ADIF ordinaire, lui, ajoute : il compare à la minute UTC près et leur export s'accorde rarement à la minute.",
+      "La suppression de QSO indique maintenant combien de lignes ont réellement été supprimées, et l'écrit dans le journal. Une suppression sans effet ressemblait exactement à une suppression réussie.",
+      "La suppression de QSO redevient rapide quand « supprimer aussi des services externes » est activé. Club Log n'est plus interrogé que pour les contacts qui y ont réellement été envoyés — pour les autres il répondait 403, un aller-retour réseau par QSO — les retraits se font désormais en arrière-plan au lieu de bloquer la fenêtre, les lignes d'une sélection sont lues en une seule requête au lieu d'une par QSO, et une série de refus interrompt le traitement au lieu d'aggraver le blocage."
+    ]
+  },
+  {
+    "version": "0.26.8",
+    "date": "",
+    "en": [
+      "Yaesu: an ANT row in the rig panel selects the antenna jack, and the choice is remembered for the band it was made on — change band and the antenna follows. There is no page to configure: picking the antenna once on a band says it perfectly well. Rigs with a single socket never show the row.",
+      "HAMLOG.online: QSOs can be uploaded as they are logged, like QRZ.com or Club Log. The API key is checked in the settings before the first contact — the answer names the account it belongs to, so a key pasted from another callsign or an expired one is caught at once instead of after a week of silent refusals.",
+      "HAMLOG.online is also a confirmation source for awards, alongside LoTW, QSL, eQSL and QRZ.com — tick it under Confirmed, under Validated, or both.",
+      "A rig whose serial port is refused now says who is likely holding it — OmniRig stays resident and keeps the port of the rig configured in it, which is what a native backend then never gets. \"Serial port busy\" alone named nobody.",
+      "The row colours in Appearance can be scoped to HAMLOG.online as well, alongside paper, LoTW, eQSL and QRZ.com.",
+      "HAMLOG.online appears in the QSL Manager too: pick it to see every QSO never sent there and upload the backlog in one go. A contact already sent carries the date it went, so a second sweep does not send it twice.",
+      "Right-clicking QSOs offers HAMLOG.online among the upload targets, and the toast names each service properly instead of echoing its internal id.",
+      "Bulk edit can set HAMLOG.online sent and received, each with its status and its date — the same four fields every other service has there. A log uploaded to their site by hand had no way to be marked as sent, so OpsLog kept offering to upload every contact again.",
+      "HAMLOG.online joins the Confirmations defaults and the QSO grid columns — sent and received, each with its status and date, hidden by default like the other extras-backed columns.",
+      "Removed the explanatory paragraph from the Confirmations page.",
+      "HAMLOG.online confirmations are read from the site's own ADIF field, APP_HAMLOG_QSO_CFM, taken from a real export. Import a log downloaded from HAMLOG and its confirmations count for awards straight away, with nothing to rename and no mapping to configure.",
+      "The four HAMLOG.online fields are filterable too, so 'never sent there' is a filter and not a guess.",
+      "RDA: a read-only comparison of the two district sources — the offline RDA database against the CNTY carried by a log imported from HAMLOG.online — reporting how many agree, how many differ, and listing the disagreements with the contact, both districts, and whether the database answer was a dated record or an assumption.",
+      "The QSO right-click menu can now export the selection to ADIF with the OpsLog fields, so the award references (RDA@KR-04 and the like) travel with the contacts. The existing entry still writes standard ADIF for other loggers.",
+      "The filtered-view export gets the same treatment: a second right-click entry writes the whole filtered view to ADIF with the OpsLog fields."
+    ],
+    "fr": [
+      "Yaesu : une ligne ANT dans le panneau du poste sélectionne la prise d'antenne, et le choix est mémorisé pour la bande sur laquelle il a été fait — on change de bande, l'antenne suit. Aucune page à configurer : choisir l'antenne une fois sur une bande le dit très bien. Les postes à une seule prise n'affichent jamais la ligne.",
+      "HAMLOG.online : les QSO peuvent être envoyés au fil de leur enregistrement, comme QRZ.com ou Club Log. La clé API se vérifie dans les réglages avant le premier contact — la réponse nomme le compte auquel elle appartient, donc une clé d'un autre indicatif ou expirée se voit tout de suite au lieu d'après une semaine de refus silencieux.",
+      "HAMLOG.online est aussi une source de confirmation pour les diplômes, aux côtés de LoTW, QSL, eQSL et QRZ.com — à cocher dans Confirmé, dans Validé, ou les deux.",
+      "Un poste dont le port série est refusé indique maintenant qui le détient vraisemblablement — OmniRig reste résident et garde le port de la radio configurée chez lui, que le backend natif n'obtient alors jamais. « Serial port busy » ne désignait personne.",
+      "Les couleurs de lignes dans Apparence peuvent aussi être limitées à HAMLOG.online, aux côtés du papier, de LoTW, d'eQSL et de QRZ.com.",
+      "HAMLOG.online figure aussi dans le gestionnaire QSL : on le choisit pour voir tous les QSO jamais envoyés là-bas et expédier l'arriéré d'un coup. Un contact déjà envoyé porte la date de son départ, donc un second passage ne le renvoie pas.",
+      "Le clic droit sur des QSO propose HAMLOG.online parmi les destinations d'envoi, et la notification nomme correctement chaque service au lieu d'afficher son identifiant interne.",
+      "L'édition en masse peut renseigner HAMLOG.online envoyé et reçu, chacun avec son statut et sa date — les mêmes quatre champs que les autres services. Un journal téléversé à la main sur leur site n'avait aucun moyen d'être marqué comme envoyé, et OpsLog proposait donc de renvoyer tous les contacts.",
+      "HAMLOG.online rejoint les valeurs par défaut des Confirmations et les colonnes de la grille des QSO — envoyé et reçu, chacun avec son statut et sa date, masquées par défaut comme les autres colonnes issues des extras.",
+      "Suppression du paragraphe explicatif de la page Confirmations.",
+      "Les confirmations HAMLOG.online sont lues dans le champ ADIF du site lui-même, APP_HAMLOG_QSO_CFM, relevé sur un export réel. Il suffit d'importer un journal téléchargé depuis HAMLOG pour que ses confirmations comptent aussitôt pour les diplômes, sans rien renommer ni configurer.",
+      "Les quatre champs HAMLOG.online sont aussi filtrables, pour que « jamais envoyé là-bas » soit un filtre et non une supposition.",
+      "RDA : une comparaison en lecture seule des deux sources de district — la base RDA hors ligne face au CNTY d'un journal importé depuis HAMLOG.online — indiquant combien concordent, combien divergent, et listant les désaccords avec le contact, les deux districts, et si la réponse de la base était un enregistrement daté ou une hypothèse.",
+      "Le menu contextuel des QSO peut maintenant exporter la sélection en ADIF avec les champs OpsLog, pour que les références de diplômes (RDA@KR-04 et compagnie) suivent les contacts. L'entrée existante écrit toujours de l'ADIF standard pour les autres carnets.",
+      "L'export de la vue filtrée reçoit le même traitement : une seconde entrée du menu contextuel écrit toute la vue filtrée en ADIF avec les champs OpsLog."
+    ]
+  },
+  {
+    "version": "0.26.7",
+    "date": "",
+    "en": [
+      "The NEW badge on a county now shows in the entry form itself, inside the field, and not only on the Info tab — it answers the question at the moment the operator is deciding whether to call.",
+      "OmniRig: a Yaesu is no longer sent OmniRig's SetSimplexMode when tuning. It is a no-op on some (an FT-891 never moved) and harmful on others — on an FT-2000 it turned split on and moved reception to VFO B, which is why OpsLog then showed B instead of A. The direct frequency write, which is what tunes these rigs, is unchanged.",
+      "The basemap buttons on the main map are shifted clear of the zoom controls — Light sat a few pixels from the minus button and was being clicked by mistake.",
+      "Cluster, French interface: the WKD CALL status now reads DÉJÀ QSO instead of DÉJÀ CTC.",
+      "Icom over LAN: the receive audio streamed by the rig now feeds the QSO recorder as well as the speakers. On a network connection Windows sees no radio sound card at all — the audio settings could only offer the PC microphone — so the stream is pushed straight into the recorder, with no virtual cable to set up."
+    ],
+    "fr": [
+      "Le badge NOUV du comté s'affiche maintenant dans le formulaire de saisie lui-même, à l'intérieur du champ, et plus seulement dans l'onglet Info — il répond au moment où l'opérateur décide d'appeler ou non.",
+      "OmniRig : le SetSimplexMode d'OmniRig n'est plus envoyé aux Yaesu lors d'un changement de fréquence. Il est sans effet sur certains (un FT-891 ne bougeait pas) et nuisible sur d'autres — sur un FT-2000 il activait le split et faisait passer la réception sur le VFO B, d'où l'affichage du B au lieu du A. L'écriture directe de la fréquence, qui est ce qui accorde réellement ces postes, ne change pas.",
+      "Les boutons de fond de carte sont décalés à l'écart des commandes de zoom — Light était à quelques pixels du bouton moins et se faisait cliquer par erreur.",
+      "Cluster, interface française : le statut « DÉJÀ CTC » devient « DÉJÀ QSO ».",
+      "Icom en réseau : l'audio reçu diffusé par le poste alimente maintenant l'enregistreur de QSO en plus des haut-parleurs. Sur une liaison réseau, Windows ne voit aucune carte son de la radio — les réglages audio ne proposaient que le micro du PC — donc le flux est injecté directement dans l'enregistreur, sans câble virtuel à installer."
+    ]
+  },
+  {
+    "version": "0.26.6",
+    "date": "",
+    "en": [
+      "FT decodes: the continent filter is now a multiple choice — click AF, AS, OC and SA to keep those four. It still lists only the continents actually being decoded, plus any you have selected, so a filter can never strand itself with no chip left to switch it off.",
+      "A QSO logged by WSJT-X, JTDX or MSHV now raises a notice in the corner naming the station. Watching the decodes, nothing else on screen said it had happened: the entry form never cleared, because nobody typed in it.",
+      "Icom CI-V: a reply the rig sent to another controller on the same bus is no longer mistaken for ours, and a PTT command whose acknowledgement goes missing is verified by reading the rig instead of being reported as a failure. WSJT-X and JTDX answer a failed set_ptt with a Rig Control Error and drop the link mid-over, which is what an IC-7850 was doing three times a session. The check itself waits 700 ms rather than the poll's 150: the rig has just failed to answer twice, usually because it is retuning — JTDX moves the transmit frequency and keys in the same breath — and a short probe would fail for the same reason. Both outcomes are logged, so a failure that remains can be told from a fix that did not fire.",
+      "FlexRadio: each spot status can now be kept off the panadapter entirely, with a switch beside its colours — and WSJT-X decode spots obey the same switches and the same colours. The palette governs the panadapter, not just one of the two things that feed it: statuses switched off still piled up on the waterfall because the decodes were pushed by another path.",
+      "Panadapter spot comments now read like DXHunter's: the cluster text, then the spotter, the entity and the status — \"CQ up 2 [F4BPO] [Franz Josef Land] [New Slot]\". The words were running together because SmartSDR splits its command line on spaces; non-breaking spaces get them through.",
+      "\"Already worked\" on a panadapter spot now means the CALLSIGN is in the log, not the entity. An entity worked on that band and mode is no news, and saying \"already worked\" of a station never contacted was wrong.",
+      "FT decodes: a compound MSHV message that answers two stations in one line — \"DM8BJF RR73; F4BPO <RI1FJL> +14\" — is now recognised as addressed to you when your callsign is in the second half.",
+      "Edit QSO: your own transmit power can be edited at last — the field was saved and written back but had no box, so a contact logged at the wrong power could never be corrected. The contacted station's extended locator gained a box for the same reason, and the power labels now say WHOSE power they are.",
+      "FlexRadio: a spot is no longer removed and redrawn when nothing about it has changed. A busy skimmer feed re-spots the same station every few seconds — one two-minute session sent 2128 spot adds, 88 of them for a single callsign — and the panadapter did not move a pixel for any of them.",
+      "Panadapter spot comments are kept within what the radio will accept: SmartSDR was cutting the longest ones mid-word, losing the entity and the status. The cluster's own words are trimmed first, the spotter, entity and status always survive. The column padding of an RBN line is collapsed to single spaces too — kept as non-breaking spaces it opened a gap wide enough to push the rest of the comment off the screen.",
+      "Auto-call is withdrawn — it duplicated DXHunter, which already answers decodes. Clicking a decode to answer it is unchanged.",
+      "The elastic bounce at the end of a list is gone, and a two-finger horizontal swipe no longer navigates the window away from the app. Both are browser behaviours that only appear on a touchpad or a touchscreen.",
+      "The interface zoom now says what it is doing: a badge shows the factor while it changes, clicking it returns to 100%, and View → Zoom in / Zoom out / Actual size makes it findable. Ctrl+wheel and Ctrl+0 always worked, but nothing announced them — zoom by accident and there was no way back.",
+      "Icom CI-V: a frequency or mode change whose acknowledgement goes missing is now verified by reading the rig back, like the PTT already was. All three are commands WSJT-X and JTDX answer with a Rig Control Error and a dropped link, and an IC-7850 log shows a set_freq doing exactly that.",
+      "The log file now rotates while OpsLog is running, not only at startup. It was bounded on the belief that a session writes a few kilobytes; with the CI-V wire trace left on, one wrote 416 MB and nothing would have stopped it before the disk did."
+    ],
+    "fr": [
+      "Décodes FT : le filtre par continent est maintenant multiple — clique AF, AS, OC et SA pour garder ces quatre-là. Il ne liste toujours que les continents réellement décodés, plus ceux que tu as sélectionnés, pour qu'un filtre ne puisse pas se bloquer sans pastille pour le désactiver.",
+      "Un QSO enregistré par WSJT-X, JTDX ou MSHV affiche maintenant une notification dans le coin, avec le nom de la station. En regardant les décodes, rien d'autre à l'écran ne le signalait : le formulaire ne se vidait pas, puisque personne n'y avait tapé.",
+      "Icom CI-V : une réponse que la radio adresse à un autre contrôleur du même bus n'est plus prise pour la nôtre, et un ordre de PTT dont l'accusé de réception se perd est vérifié en interrogeant la radio au lieu d'être déclaré en échec. WSJT-X et JTDX répondent à un set_ptt en échec par une erreur de contrôle radio et coupent la liaison en pleine émission — ce que faisait un IC-7850 trois fois par session. La vérification attend 700 ms et non les 150 de la scrutation : la radio vient d'échouer deux fois, en général parce qu'elle se réaccorde — JTDX décale la fréquence d'émission et passe en émission dans la foulée — et une interrogation brève échouerait pour la même raison. Les deux issues sont journalisées, pour distinguer un échec réel d'un correctif qui n'a pas agi.",
+      "FlexRadio : chaque statut de spot peut désormais être totalement exclu du panadapter, par un interrupteur à côté de ses couleurs — et les spots issus des décodes WSJT-X obéissent aux mêmes interrupteurs et aux mêmes couleurs. La palette régit le panadapter, pas seulement l'une des deux sources qui l'alimentent : les statuts décochés continuaient de s'entasser sur la cascade parce que les décodes passaient par un autre chemin.",
+      "Les commentaires des spots du panadapter se lisent maintenant comme ceux de DXHunter : le texte du cluster, puis le spotteur, l'entité et le statut — « CQ up 2 [F4BPO] [Franz Josef Land] [New Slot] ». Les mots se collaient parce que SmartSDR découpe sa ligne de commande sur les espaces ; des espaces insécables les font passer.",
+      "« Déjà contacté » sur un spot du panadapter désigne désormais l'INDICATIF présent dans le journal, et non l'entité. Une entité déjà faite sur cette bande et ce mode n'est pas une nouvelle, et annoncer « déjà contacté » pour une station jamais travaillée était faux.",
+      "Décodes FT : un message composé MSHV qui répond à deux stations sur une seule ligne — « DM8BJF RR73; F4BPO <RI1FJL> +14 » — est maintenant reconnu comme vous étant adressé quand votre indicatif est dans la seconde moitié.",
+      "Édition de QSO : sa propre puissance d'émission est enfin modifiable — le champ était enregistré et réécrit mais n'avait aucune case, donc un contact loggé à la mauvaise puissance ne pouvait pas être corrigé. Le locator étendu du correspondant gagne une case pour la même raison, et les libellés de puissance disent maintenant à QUI elle appartient.",
+      "FlexRadio : un spot n'est plus supprimé puis redessiné quand rien n'a changé. Un flux de skimmers actif re-spotte la même station toutes les quelques secondes — une session de deux minutes envoyait 2128 ajouts, dont 88 pour un seul indicatif — sans que le panadapter bouge d'un pixel.",
+      "Les commentaires des spots du panadapter tiennent maintenant dans ce que la radio accepte : SmartSDR coupait les plus longs en plein mot, perdant l'entité et le statut. Le texte du cluster est rogné en premier, le spotteur, l'entité et le statut survivent toujours. L'alignement en colonnes des lignes RBN est aussi ramené à une seule espace : conservé en espaces insécables, il ouvrait un trou assez large pour repousser le reste du commentaire hors de l'écran.",
+      "L'appel automatique est retiré — il faisait doublon avec DXHunter, qui répond déjà aux décodages. Cliquer un décodage pour répondre ne change pas.",
+      "Le rebond élastique en fin de liste a disparu, et un balayage horizontal à deux doigts ne fait plus quitter l'application. Deux comportements de navigateur qui n'apparaissent qu'au pavé tactile ou sur écran tactile.",
+      "Le zoom de l'interface s'annonce enfin : une pastille affiche le facteur pendant qu'il change, un clic dessus revient à 100 %, et le menu Affichage → Zoom avant / Zoom arrière / Taille réelle le rend trouvable. Ctrl+molette et Ctrl+0 fonctionnaient déjà, mais rien ne le disait — un zoom involontaire et on ne savait plus revenir.",
+      "Icom CI-V : un changement de fréquence ou de mode dont l'accusé de réception se perd est désormais vérifié en interrogeant la radio, comme l'était déjà le PTT. Les trois sont des ordres auxquels WSJT-X et JTDX répondent par une erreur de contrôle radio et une liaison coupée, et un log d'IC-7850 montre un set_freq faire précisément cela.",
+      "Le fichier de log tourne maintenant en cours d'exécution, et plus seulement au démarrage. Sa limite reposait sur l'idée qu'une session écrit quelques kilo-octets ; avec la trace CI-V laissée active, l'une d'elles a écrit 416 Mo sans que rien ne l'arrête avant le disque."
+    ]
+  },
+  {
+    "version": "0.26.5",
+    "date": "",
+    "en": [
+      "Fixed the record button going missing after an update, until the audio settings were opened and saved. Whether a manual recording is possible depends on a per-profile setting, and the question was asked once at startup — before the profile was known on a launch that had more work to do.",
+      "Switching profile is quicker on a shared MySQL logbook: the one-off cleanup of unused settings tables is now recorded as done instead of being re-checked on every connection.",
+      "A profile switch now logs how long it took, and any device slower than half a second names itself — a switch that feels sluggish can be diagnosed from the log file.",
+      "Saving an alert rule or a filter preset now says so, with the name, for a few seconds. Both used to save in silence, leaving the dialog looking exactly as it did before the click.",
+      "Awards: the callsigns listed behind an award cell are now links. Clicking one opens the QSL Manager on Paper QSL with that station searched, ready for the card sent/received dates — chasing a missing confirmation no longer means retyping the callsign into another tab.",
+      "Motorised antennas over serial: the line format is now stated explicitly as 8N1, the baud list covers 1200 to 115200, and the first exchange after each connect is dumped to the log — which separates a silent controller from a wrong baud rate from a frame we misread.",
+      "Fixed a motorised antenna on a serial port failing with \"Serial port busy\" for ever. OpsLog was holding the port itself: stopping a client did not wait for its poll loop to leave, and the new client was started while the old one still owned the COM port — every settings save added another loop to the fight.",
+      "A serial antenna controller whose port is held by another program now says so by name in the log, instead of repeating \"Serial port busy\" — a COM port has one owner, usually the manufacturer control window left open.",
+      "Fixed \"Test connection\" on a serial motorised antenna taking the COM port away from the running antenna. A port has one owner, so the test now reports the live link's own status instead of opening a second connection to it.",
+      "A serial antenna controller that never answers now fails after four seconds with \"nothing came back\", instead of freezing the poll loop for minutes with nothing in the log. A silent serial port returns no bytes AND no error, and the buffered reader retried that a hundred times before giving up.",
+      "Ultrabeam over USB now works. The cable presents TWO COM ports and only the second reaches the controller, at 19200 baud — so the speed is now fixed at 19200 and the port field says which one to pick. Stopping a client no longer waits out the read timeout either, so changing port takes effect at once instead of leaving the old one held."
+    ],
+    "fr": [
+      "Correction du bouton d'enregistrement disparu après une mise à jour, jusqu'à ce qu'on ouvre et enregistre les réglages audio. La possibilité d'enregistrer dépend d'un réglage par profil, et la question n'était posée qu'une fois au démarrage — avant que le profil soit connu, sur un lancement qui avait plus de travail à faire.",
+      "Le changement de profil est plus rapide sur un journal MySQL partagé : le nettoyage ponctuel des tables de réglages inutilisées est désormais marqué comme fait, au lieu d'être revérifié à chaque connexion.",
+      "Un changement de profil enregistre maintenant sa durée dans le journal, et tout appareil dépassant la demi-seconde se nomme — un changement qui traîne peut donc être diagnostiqué depuis le fichier de log.",
+      "L'enregistrement d'une règle d'alerte ou d'un filtre affiche maintenant une confirmation avec son nom, quelques secondes. Les deux enregistraient en silence, la fenêtre restant identique à ce qu'elle était avant le clic.",
+      "Diplômes : les indicatifs listés derrière une case sont désormais cliquables. Un clic ouvre le gestionnaire QSL sur QSL papier avec la station déjà recherchée, prête pour les dates d'envoi et de réception — relancer une confirmation manquante ne demande plus de retaper l'indicatif dans un autre onglet.",
+      "Antennes motorisées en série : le format de ligne est désormais fixé explicitement en 8N1, la liste des vitesses va de 1200 à 115200, et le premier échange après chaque connexion est écrit dans le log — ce qui distingue un contrôleur muet d'une mauvaise vitesse et d'une trame mal relue.",
+      "Correction d'une antenne motorisée en série qui échouait indéfiniment sur « Serial port busy ». OpsLog occupait le port lui-même : l'arrêt d'un client n'attendait pas la sortie de sa boucle de scrutation, et le nouveau client démarrait alors que l'ancien détenait encore le port COM — chaque enregistrement des réglages ajoutait une boucle à la mêlée.",
+      "Un contrôleur d'antenne en série dont le port est occupé par un autre programme le dit maintenant explicitement dans le log, au lieu de répéter « Serial port busy » — un port COM n'a qu'un propriétaire, le plus souvent la fenêtre de contrôle du fabricant restée ouverte.",
+      "Correction du « Test de connexion » d'une antenne motorisée en série qui prenait le port COM à l'antenne en service. Un port n'a qu'un propriétaire : le test rapporte désormais l'état du lien en cours au lieu d'ouvrir une seconde connexion dessus.",
+      "Un contrôleur d'antenne en série qui ne répond jamais échoue maintenant en quatre secondes sur « rien n'est revenu », au lieu de figer la boucle de scrutation pendant des minutes sans rien écrire dans le log. Un port série muet ne renvoie ni octet ni erreur, et le lecteur tamponné réessayait cent fois avant d'abandonner.",
+      "Ultrabeam en USB fonctionne. Le câble présente DEUX ports COM et seul le second atteint le contrôleur, à 19200 bauds — la vitesse est donc fixée à 19200 et le champ du port indique lequel choisir. L'arrêt d'un client n'attend plus la fin du délai de lecture, donc un changement de port prend effet immédiatement au lieu de laisser l'ancien occupé."
+    ]
+  },
+  {
+    "version": "0.26.4",
+    "date": "",
+    "en": [
+      "Clicking a spot on the radio panadapter now carries its POTA park into the Awards tab, like a click in OpsLog does.",
+      "Ultrabeam over serial: the COM port field now has a chevron that opens the list of detected ports. It was a combo box that only opened on a keystroke, so it looked like a plain text box.",
+      "The logbook database now contains only the contacts. Settings, station profiles, award reference lists and the lookup cache were being created in every database, including a shared MySQL logbook, which made the two look interchangeable; the unused tables are dropped on the next start, and any that hold data are left alone.",
+      "And the mirror image: the settings database drops its own unused, empty qso table once the contacts have a database of their own. It is rebuilt automatically if that database is ever pressed into service as the logbook again.",
+      "Settings → Database: a Compact button on each database. SQLite frees deleted pages inside the file and never shrinks it, so this is what gives the disk space back; the result shows the size before and after. A shared MySQL logbook has the button too, running OPTIMIZE TABLE instead."
+    ],
+    "fr": [
+      "Cliquer un spot sur le panadapter de la radio reporte maintenant son parc POTA dans l’onglet Diplômes, comme un clic dans OpsLog.",
+      "Ultrabeam en série : le champ du port COM a maintenant un chevron qui ouvre la liste des ports détectés. C'était une liste déroulante qui ne s'ouvrait qu'en tapant, donc indiscernable d'un simple champ texte.",
+      "La base du journal ne contient plus que les contacts. Les réglages, profils station, listes de références et le cache de recherche étaient créés dans toutes les bases, y compris un MySQL partagé, ce qui laissait croire que les deux étaient interchangeables ; les tables inutilisées sont supprimées au prochain démarrage, et celles qui contiennent des données sont laissées telles quelles.",
+      "Et l'inverse : la base de réglages supprime sa propre table qso, vide et inutilisée, dès lors que les contacts ont leur base à eux. Elle est reconstruite automatiquement si cette base doit à nouveau servir de journal.",
+      "Réglages → Base de données : un bouton Compacter sur chaque base. SQLite libère les pages supprimées à l'intérieur du fichier sans jamais le réduire ; c'est donc ce qui rend l'espace disque, et le résultat affiche la taille avant et après. Un journal MySQL partagé a aussi le bouton, avec un OPTIMIZE TABLE à la place."
+    ]
+  },
+  {
+    "version": "0.26.3",
+    "date": "",
+    "en": [
+      "Ultrabeam: the controller can be reached over a plain serial port, not only over the network. It has an RS232 port and the PC is usually beside it, so an FTDI cable is the direct route — the RS232-to-Ethernet adapter is now only needed to put the antenna at the far end of a link. Same choice the SteppIR has always had, in the same place.",
+      "Docked band map: FIT and FTx are now two labelled buttons in its header. Fit-to-band was hidden behind the px/kHz readout — a control whose label is a measurement does not look like one, and switching it off left nothing on screen saying the option existed. Hiding the digital spots is available there too, and both follow the Band Map tab.",
+      "Stats: the Entities tile now says which entity was added to the log most recently, with the callsign and date that did it. Judged against the whole log — a contact is the first with its country once, and does not become the first again because a date filter hides the ones before it.",
+      "Docked band map: in fit-to-band the header no longer printed FIT twice, once as the readout and once as the button beside it.",
+      "Settings: what OpsLog does with a FlexRadio — panadapter spots, decode spots and the DAX switch for voice messages — now lives in the FlexRadio page with the per-band antennas and power, instead of at the foot of the CAT page. CAT keeps the link itself: an address and a port, as for every other backend.",
+      "Cluster settings: four paragraphs of explanation removed. The options they described are unchanged.",
+      "A spot that is a new band AND a new mode for an entity is now its own status, NEW BAND+MODE, ranked with NEW DXCC. It used to be reported as a plain new band, which reads as \"you have worked this entity in this mode, just not here\" — the opposite of the truth. It is not a new slot either: a slot is the pair still missing when each half is already in the log. The cluster, the band map, the decodes panel, the filters and the auto-call criteria all tell the two apart now.",
+      "Cluster filters: a \"my bands\" link selects every band from your own band list in one click. With nothing selected the filter lets every band through — including 4 m and 70 cm off the RBN feeds, which the list could not offer you to untick because they are not bands you have.",
+      "FlexRadio: cluster spots on the panadapter are now coloured by what they are. A text colour and a background colour per status — new entity, new band+mode, new band, new mode, new slot, new park, new county, new prefix, your own callsign, already worked — set in Settings → FlexRadio, with a preview of each pair. Every spot used to be the same orange, which threw away the only thing worth knowing at a glance on a waterfall.",
+      "FlexRadio: clicking a spot can resize the panadapter to suit the mode — 25 kHz for CW, 200 for phone, 50 for digital by default, each configurable, with an option to re-centre on the spot as well. A CW signal is a hair at 200 kHz and an FT8 window shows an eighth of its sub-band at 25 kHz; one width cannot serve all three. Settings → FlexRadio, off by default.",
+      "FlexRadio: panadapter spots now carry their status in the comment as well as their colour — [NEW DXCC], [NEW BAND+MODE], [NEW BAND] and so on.",
+      "FlexRadio: the panadapter zoom now also applies when you click a spot on the panadapter itself, not just in the band map or cluster.",
+      "FlexRadio: fixed the panadapter zoom leaving the clicked spot off screen. The display now re-centres whenever the spot would fall outside the new window, and stays put when it would not.",
+      "Awards (F3): a NEW badge marks each award reference on the current QSO that has never been worked, picked or detected alike."
+    ],
+    "fr": [
+      "Ultrabeam : le contrôleur se joint par un simple port série, plus seulement par le réseau. Il a une prise RS232 et le PC est en général juste à côté : un câble FTDI suffit — l'adaptateur RS232 vers Ethernet ne sert plus qu'à mettre l'antenne au bout d'une liaison. Le même choix que le SteppIR a toujours eu, au même endroit.",
+      "Bandmap ancrée : FIT et FTx sont désormais deux boutons nommés dans son en-tête. L'ajustement à la bande se cachait derrière l'indicateur px/kHz — un contrôle dont le libellé est une mesure n'a pas l'air d'un contrôle, et une fois désactivé plus rien à l'écran ne disait que l'option existait. Le masquage des spots numériques y est aussi, et les deux suivent l'onglet Bandmap.",
+      "Statistiques : la tuile Entités indique désormais quelle entité a été ajoutée au journal en dernier, avec l'indicatif et la date qui l'ont fait. Jugé sur le journal entier — un contact n'est le premier avec son pays qu'une fois, et ne le redevient pas parce qu'un filtre de date masque ceux d'avant.",
+      "Bandmap ancrée : en mode ajusté, l'en-tête n'affiche plus FIT deux fois, une comme indicateur et une comme bouton juste à côté.",
+      "Réglages : ce qu'OpsLog fait avec un FlexRadio — spots panadapter, spots de décodages et la bascule DAX pour les messages vocaux — se trouve désormais sur la page FlexRadio, avec les antennes et la puissance par bande, au lieu du bas de la page CAT. La page CAT garde la liaison elle-même : une adresse et un port, comme pour tous les autres backends.",
+      "Réglages du cluster : quatre pavés d'explication retirés. Les options qu'ils décrivaient sont inchangées.",
+      "Un spot qui est à la fois une nouvelle bande ET un nouveau mode pour une entité a désormais son propre statut, NOUVEAU BANDE+MODE, au même rang que NOUVEAU DXCC. Il était annoncé comme une simple nouvelle bande, ce qui se lit « tu as déjà fait cette entité dans ce mode, juste pas ici » — l'inverse de la vérité. Ce n'est pas non plus un nouveau slot : un slot est la paire qui manque quand chaque moitié est déjà au journal. Le cluster, la bandmap, le panneau des décodages, les filtres et les critères d'appel automatique font maintenant la différence.",
+      "Filtres du cluster : un lien « mes bandes » sélectionne d'un clic toutes les bandes de ta propre liste. Sans sélection, le filtre laisse passer toutes les bandes — y compris le 4 m et le 70 cm des flux RBN, que la liste ne pouvait pas te proposer de décocher puisque ce ne sont pas des bandes que tu as.",
+      "FlexRadio : les spots cluster sur le panadapter sont désormais colorés selon ce qu'ils sont. Une couleur de texte et une couleur de fond par statut — nouvelle entité, nouvelle bande+mode, nouvelle bande, nouveau mode, nouveau slot, nouveau parc, nouveau comté, nouveau préfixe, ton propre indicatif, déjà contacté — réglées dans Réglages → FlexRadio, avec un aperçu de chaque paire. Tous les spots étaient de la même couleur orange, ce qui jetait la seule chose qui compte au premier coup d'œil sur une cascade.",
+      "FlexRadio : cliquer un spot peut redimensionner le panadapter selon le mode — 25 kHz en CW, 200 en phonie, 50 en numérique par défaut, chacun réglable, avec une option pour recentrer aussi sur le spot. Un signal CW est un cheveu à 200 kHz et une fenêtre FT8 montre un huitième de sa sous-bande à 25 kHz ; une seule largeur ne peut pas servir les trois. Réglages → FlexRadio, désactivé par défaut.",
+      "FlexRadio : les spots du panadapter portent maintenant leur statut dans le commentaire en plus de la couleur — [NEW DXCC], [NEW BAND+MODE], [NEW BAND], etc.",
+      "FlexRadio : le zoom du panadapter s'applique aussi quand on clique un spot sur le panadapter lui-même, et plus seulement dans la bandmap ou le cluster.",
+      "FlexRadio : correction du zoom du panadapter qui laissait parfois le spot hors écran. L'affichage se recentre désormais dès que le spot sortirait de la nouvelle fenêtre, et ne bouge pas sinon.",
+      "Diplômes (F3) : un badge NEW signale chaque référence du QSO en cours jamais contactée, choisie à la main ou détectée."
+    ]
+  },
+  {
+    "version": "0.26.2",
+    "date": "",
+    "en": [
+      "Saving preferences no longer drops the rig. The CAT link — and the shared CAT server WSJT-X and JTDX connect to — is now rebuilt only when something about the connection itself changed, so pressing Save mid-QSO no longer throws them off with an error. The same restart was what wiped the spots off a FlexRadio panadapter on every save.",
+      "The log now records when WSJT-X or JTDX arms and disarms its transmitter. When a station is called and nothing goes out, that line says whether the far end ever enabled Tx — the one thing OpsLog asks for but cannot do itself.",
+      "Grid squares map: the world is drawn once instead of repeating east and west, it can be zoomed out far enough to hold Greenland and Antarctica at the same time, and the space beside the planet is the panel's own background instead of a wall of grey \"map data not yet available\" tiles.",
+      "Grid squares map: All, Phone and CW join Digital and FTx in the mode filter.",
+      "Motorised antenna over serial: the COM port is now picked from a list of the ports actually present, with a refresh button — and still accepts one typed by hand, for an adapter that is not plugged in yet.",
+      "Awards: choosing \"no field\" now clears the fallback searches with it. They kept running on their own fields while the panel no longer showed them, so an award declared to match nothing still found references.",
+      "Callbook lookup now reads the Russian district (RDA) from HamQTH and fills it as the contact's RDA reference. Only on the QSO being typed, never on one already logged: the callbook gives the district a station operates from today, and stamping that on an older contact would rewrite a correct entry into a false one.",
+      "FlexRadio: when the meters stay dead, the log now says why. The meter stream is UDP sent from the radio to OpsLog, and a firewall blocking it leaves a perfectly healthy TCP link with meters at zero and no explanation — the line names the port and what to allow.",
+      "The Russian district database is now built in: 58 188 callsigns, with the dated periods each operated from each district. It fills the RDA reference while you type a Russian callsign — for the day of the contact, not for today — and Settings → Awards fills it on every Russian QSO already in the log. A reference you assigned by hand is never overwritten.",
+      "New Settings → Maintenance → Databases: every reference database OpsLog keeps on disk on its own line — country file, Club Log exceptions, LoTW users, Super Check Partial, US counties, Russian districts — plus one line per updatable award reference list (IOTA, POTA, SOTA, WWFF). Each says what it holds and when it was refreshed. The updaters were scattered across the Awards manager and three settings pages before. Tools no longer carries \"Refresh cty.dat\" and \"Download reference lists\" — both are lines on that page now.",
+      "FT decodes: the auto-call no longer offers a SOTA criterion. It was declared and translated but could never be ticked, and a decode carries no summit reference for it to test — a setting that promised something the feature cannot do.",
+      "Auto-call: the slot criterion is named \"a new slot (band+mode never worked together)\" — the same word the cluster and the decodes panel already badge it with. \"A new band+mode slot\" read as \"a new band AND a new mode\", which is the one thing it is not.",
+      "Voice keyer: typing a callsign stops the auto-CQ. It stopped the CW auto-call and left the voice keyer calling CQ over the station that had just answered — the reason to stop has nothing to do with Morse, so both engines now stop on the same event.",
+      "The motorised antenna (Ultrabeam / SteppIR) now has a docked widget of its own, with a dish icon beside the entry strip: pattern (Normal / 180° / Bi), band buttons, ±25 kHz nudge and Retract — what you touch between contacts. Tracking, its mode and step, and the per-element lengths stay in the Station Control tab, where they are set once. The icon pulses amber while the elements travel.",
+      "FT decodes: a station with a compound callsign is no longer invisible. FT8 sends such a call as a hash, printed between angle brackets — \"F4BPO <ZA/IW2JOP> -24\" — and every decode carrying one was discarded as unparseable, including the reply telling you that station had answered. The two-message form (\"… RR73; … <call> -08\") is read correctly too.",
+      "The log now records when a profile re-applies every subsystem. That rebuild is what dropped WSJT-X's CAT connection — an operator's log showed it happening 54 times in one session, three of them while the rig was keyed — and nothing said it was happening at all.",
+      "The shared CAT server is never torn down while the rig is transmitting. A rebuild that really is needed now waits for the over to end — closing the socket mid-transmission is what left WSJT-X inside a run of Hamlib calls with nothing at the other end.",
+      "Autostart: a program can be closed when OpsLog closes. Per program, so the rotator controller can stay while WSJT-X goes, and only ever a polite close — the way clicking its cross would — of a program OpsLog itself started.",
+      "Awards: switching a column between the reference and its description is now immediate. It rebuilt every award for every contact in the log — work with a known answer, since a relabel cannot change which QSOs match. Only that award is recomputed, and only on the rows that already carry it. The full recompute also reads twenty-seven columns per QSO instead of a hundred and fifty."
+    ],
+    "fr": [
+      "Enregistrer les préférences ne coupe plus la radio. La liaison CAT — et le serveur CAT partagé auquel WSJT-X et JTDX se connectent — n'est reconstruite que si la connexion elle-même a changé, si bien qu'un Enregistrer en plein QSO ne les éjecte plus avec une erreur. C'est ce même redémarrage qui effaçait les spots du panadapter FlexRadio à chaque enregistrement.",
+      "Le journal enregistre désormais quand WSJT-X ou JTDX arme et désarme son émetteur. Quand une station est appelée et que rien ne part, cette ligne dit si le logiciel distant a seulement activé Tx — la seule chose qu'OpsLog demande sans pouvoir la faire à sa place.",
+      "Carte des carrés locator : le monde est dessiné une seule fois au lieu de se répéter d'est en ouest, le zoom arrière descend assez bas pour tenir le Groenland et l'Antarctique en même temps, et l'espace à côté de la planète est le fond du panneau au lieu d'un mur de tuiles grises « map data not yet available ».",
+      "Carte des carrés locator : Tout, Phonie et CW rejoignent Numérique et FTx dans le filtre de mode.",
+      "Antenne motorisée en liaison série : le port COM se choisit maintenant dans la liste des ports réellement présents, avec un bouton d'actualisation — et accepte toujours une saisie à la main, pour un adaptateur qui n'est pas encore branché.",
+      "Diplômes : choisir « aucun champ » efface désormais les recherches de repli avec lui. Elles continuaient de tourner sur leurs propres champs alors que le panneau ne les affichait plus, si bien qu'un diplôme déclaré ne rien reconnaître trouvait quand même des références.",
+      "La recherche callbook lit désormais le district russe (RDA) chez HamQTH et le renseigne comme référence RDA du contact. Uniquement sur le QSO en cours de saisie, jamais sur un QSO déjà journalisé : le callbook donne le district d'où la station émet aujourd'hui, et l'appliquer à un contact ancien transformerait une entrée correcte en entrée fausse.",
+      "FlexRadio : quand les mesures restent mortes, le journal dit maintenant pourquoi. Le flux de mesures est un envoi UDP de la radio vers OpsLog, et un pare-feu qui le bloque laisse une liaison TCP parfaitement saine avec des aiguilles à zéro et aucune explication — la ligne nomme le port et ce qu'il faut autoriser.",
+      "La base des districts russes est désormais intégrée : 58 188 indicatifs, avec les périodes datées passées dans chaque district. Elle renseigne la référence RDA pendant que tu tapes un indicatif russe — pour le jour du contact, pas pour aujourd'hui — et Réglages → Diplômes la renseigne sur tous les QSO russes déjà journalisés. Une référence attribuée à la main n'est jamais écrasée.",
+      "Nouveau Réglages → Maintenance → Bases de données : chaque base de référence qu'OpsLog garde sur disque a sa ligne — fichier pays, exceptions Club Log, utilisateurs LoTW, Super Check Partial, comtés US, districts russes — plus une ligne par liste de références de diplôme actualisable (IOTA, POTA, SOTA, WWFF). Chacune dit ce qu'elle contient et sa dernière actualisation. Les mises à jour étaient jusqu'ici dispersées entre le gestionnaire de diplômes et trois pages de réglages. Le menu Outils ne porte plus « Refresh cty.dat » ni « Download reference lists » — les deux sont des lignes de cette page.",
+      "Décodages FT : l'appel automatique ne propose plus de critère SOTA. Il était déclaré et traduit mais impossible à cocher, et un décodage ne porte aucune référence de sommet à tester — un réglage qui promettait ce que la fonction ne sait pas faire.",
+      "Appel automatique : le critère de slot s'appelle désormais « un nouveau slot (bande+mode jamais faits ensemble) » — le mot que le cluster et le panneau des décodages emploient déjà sur leur pastille. « Un nouveau couple bande+mode » se lisait comme « une nouvelle bande ET un nouveau mode », ce qu'il n'est justement pas.",
+      "Manipulateur vocal : taper un indicatif arrête l'appel automatique. Il arrêtait l'auto-call CW et laissait le DVK appeler CQ par-dessus la station qui venait de répondre — la raison de s'arrêter n'a rien à voir avec la télégraphie, les deux moteurs s'arrêtent donc sur le même événement.",
+      "L'antenne motorisée (Ultrabeam / SteppIR) a désormais son widget ancré, avec une icône de parabole à côté de la barre de saisie : diagramme (Normal / 180° / Bi), boutons de bande, décalage ±25 kHz et Rétracter — ce qu'on touche entre deux contacts. Le suivi, son mode et son pas, ainsi que les longueurs d'éléments restent dans l'onglet Station, où ils se règlent une fois pour toutes. L'icône clignote en ambre pendant que les éléments se déplacent.",
+      "Décodages FT : une station à indicatif composé n'est plus invisible. Le FT8 transmet un tel indicatif sous forme de hachage, affiché entre chevrons — « F4BPO <ZA/IW2JOP> -24 » — et tout décodage en contenant un était jeté comme illisible, y compris la réponse qui t'annonçait que cette station t'avait répondu. La forme à deux messages (« … RR73; … <indicatif> -08 ») est également lue correctement.",
+      "Le journal enregistre désormais quand un profil ré-applique tous ses sous-systèmes. C'est cette reconstruction qui coupait la liaison CAT de WSJT-X — le journal d'un opérateur en montre 54 dans une seule session, dont trois pendant que la radio émettait — et rien n'indiquait qu'elle avait lieu.",
+      "Le serveur CAT partagé n'est plus jamais démonté pendant que la radio émet. Une reconstruction réellement nécessaire attend la fin de l'émission — fermer la socket en pleine transmission, c'est ce qui laissait WSJT-X au milieu d'une série d'appels Hamlib sans personne à l'autre bout.",
+      "Démarrage auto : un programme peut être fermé à la fermeture d'OpsLog. Au cas par cas, pour que le contrôleur de rotor reste pendant que WSJT-X s'en va, et toujours une demande de fermeture polie — comme un clic sur sa croix — d'un programme lancé par OpsLog lui-même.",
+      "Diplômes : basculer une colonne entre la référence et sa description est désormais immédiat. L'opération reconstruisait tous les diplômes de tous les contacts du journal — un travail au résultat connu d'avance, puisqu'un changement d'étiquette ne change pas quels QSO correspondent. Seul ce diplôme est recalculé, et seulement sur les lignes qui le portent déjà. Le recalcul complet lit aussi vingt-sept colonnes par QSO au lieu de cent cinquante."
+    ]
+  },
+  {
+    "version": "0.26.1",
+    "date": "",
+    "en": [
+      "Auto-call: a QSO in progress is now held by OpsLog itself, so a new station is no longer called in the middle of an exchange. The hold is released when that QSO is logged, when you halt or click another decode, and after four minutes without a contact.",
+      "Rotor widget: the Stop button now lights up when pressed, like the direction presets, so there is no doubt the order went out.",
+      "FT decodes: a decode could go missing from the panel when a period arrived as one burst — the internal queue discarded it in silence. It is now deep enough for a full period, panadapter spots no longer hold the stream up, and anything still lost is written to the log.",
+      "Closing OpsLog can no longer leave a process behind. Each shutdown step is written to the log, and if one of them hangs the application now forces its own exit instead of staying open — which also unblocks the restart after an update.",
+      "CAT: a rig link whose polling loop got stuck no longer freezes every later reconnection attempt in silence. The wait is now bounded and the problem is written to the log, instead of a radio that never comes back and no explanation anywhere.",
+      "Cluster console: the replies to your commands are no longer buried under the spot flood. A Replies button — on by default — hides the DX spots, which the list above already shows.",
+      "Cluster: twelve named command buttons beside the command box — name one \"Show filters\", give it SH/FILTER, and one click sends it. They are set up in Settings → Cluster; a button with no command is not shown.",
+      "Cluster console: a Follow button decides whether the view sticks to the newest line, and sending a command re-arms it — a long reply is now scrolled to instead of landing out of sight. Switch Follow off to read without being pulled back down; the arrow beside it returns to the end.",
+      "Band map: the docked map can be switched to fit-to-band from its own header — click the px/kHz readout. It is the same setting the Band Map tab drives, so the two always agree.",
+      "Awards: an award can now be set to search in NO field. The matching options disappear with it, and the award counts only the references you assign to a contact by hand — for a reference like WWBOTA, which has no ADIF field anywhere.",
+      "New award: WWBOTA (World Wide Bunkers on the Air), with its full reference list — 31 342 bunkers. References are assigned to a contact by hand, the award having no ADIF field of its own.",
+      "Grid squares map: the map now fills its panel. It measured its container once, while the tab was still hidden, and kept that size — leaving a blank band under it whatever the window size.",
+      "Grid squares map: the fill colours for confirmed and worked squares can be chosen, beside the basemap selector. Left alone they follow the theme, and one click puts them back.",
+      "QSL cards: the QSO box now carries the frequency in megahertz alongside the band, and the designer lets you choose which columns it shows — date, UTC, band, frequency, mode, submode, RST.",
+      "Main view: up to four panes instead of two. A third and a fourth can be chosen — or left empty, in which case they are not drawn — and with four you pick between quarters (2 × 2) and four columns. Every divider is draggable, each arrangement is remembered for its own pane count, and a double-click evens it out.",
+      "Appearance: the alternating row shading in Recent QSOs can be switched off — every row the same colour — or given a colour of its own. It is independent of the QSL row colours, which still take precedence on the rows they paint.",
+      "QSL row colours: the \"left stripe\" style no longer draws a coloured hairline along the top and bottom of every coloured row. The stripe is painted differently — it is a stripe again, and nothing else.",
+      "QSL designer: the preview contact now fills every column the QSO box can show, frequency and submode included. A blank column promised room the printed card would not have."
+    ],
+    "fr": [
+      "Appel automatique : le QSO en cours est désormais verrouillé par OpsLog lui-même, si bien qu'une nouvelle station n'est plus appelée au milieu d'un échange. Le verrou est levé quand ce QSO est journalisé, quand tu fais Stop ou cliques un autre décodage, et au bout de quatre minutes sans contact.",
+      "Widget rotor : le bouton Stop s'allume maintenant quand on l'enfonce, comme les présélections de direction, pour ne plus douter que l'ordre est parti.",
+      "Décodages FT : un décodage pouvait manquer dans le panneau quand une période arrivait d'un bloc — la file interne le jetait sans rien dire. Elle est désormais dimensionnée pour une période entière, les spots panadapter ne retiennent plus le flux, et ce qui serait encore perdu est écrit dans le journal.",
+      "Fermer OpsLog ne peut plus laisser un processus derrière. Chaque étape d'arrêt est écrite dans le journal, et si l'une d'elles se bloque l'application force désormais sa propre sortie au lieu de rester ouverte — ce qui débloque aussi le redémarrage après une mise à jour.",
+      "CAT : une liaison radio dont la boucle d'interrogation se bloquait figeait en silence toutes les tentatives de reconnexion suivantes. L'attente est désormais bornée et le problème écrit dans le journal, au lieu d'une radio qui ne revient jamais sans la moindre explication.",
+      "Console cluster : les réponses à tes commandes ne sont plus noyées sous le flot de spots. Un bouton Réponses — actif par défaut — masque les spots DX, que la liste au-dessus affiche déjà.",
+      "Cluster : douze boutons de commande nommés à côté du champ de saisie — nomme-en un « Voir filtres », donne-lui SH/FILTER, et un clic l'envoie. Ils se règlent dans Réglages → Cluster ; un bouton sans commande n'est pas affiché.",
+      "Console cluster : un bouton Suivre décide si la vue reste collée à la dernière ligne, et envoyer une commande le réarme — une longue réponse défile maintenant jusqu'à elle au lieu d'arriver hors champ. Désactive Suivre pour lire sans être ramené en bas ; la flèche à côté revient à la fin.",
+      "Bandmap : la carte ancrée peut passer en ajustement à la bande depuis son propre en-tête — cliquer l'indicateur px/kHz. C'est le même réglage que celui de l'onglet Bandmap, les deux sont donc toujours d'accord.",
+      "Diplômes : un diplôme peut désormais ne chercher dans AUCUN champ. Les options de reconnaissance disparaissent avec lui, et le diplôme ne compte que les références attribuées à la main sur un contact — pour une référence comme WWBOTA, qui n'a de champ ADIF nulle part.",
+      "Nouveau diplôme : WWBOTA (World Wide Bunkers on the Air), avec sa liste de références complète — 31 342 bunkers. Les références s'attribuent à la main sur un contact, le diplôme n'ayant pas de champ ADIF propre.",
+      "Carte des carrés locator : la carte occupe enfin tout son panneau. Elle mesurait son conteneur une seule fois, alors que l'onglet était encore masqué, et gardait cette taille — d'où la bande vide en dessous quelle que soit la taille de la fenêtre.",
+      "Carte des carrés locator : les couleurs des carrés confirmés et contactés se choisissent, à côté du sélecteur de fond de carte. Laissées telles quelles, elles suivent le thème, et un clic les y ramène.",
+      "Cartes QSL : le tableau du QSO porte désormais la fréquence en mégahertz à côté de la bande, et le concepteur permet de choisir les colonnes affichées — date, UTC, bande, fréquence, mode, sous-mode, RST.",
+      "Vue principale : jusqu'à quatre volets au lieu de deux. Un troisième et un quatrième se choisissent — ou se laissent vides, auquel cas ils ne sont pas dessinés — et avec quatre tu choisis entre les quarts (2 × 2) et quatre colonnes. Chaque séparateur se glisse, chaque disposition est mémorisée pour son propre nombre de volets, et un double-clic la remet à égalité.",
+      "Apparence : l'alternance de teinte une ligne sur deux dans QSO récents peut être désactivée — toutes les lignes de la même couleur — ou recevoir sa propre couleur. Elle est indépendante des couleurs de ligne QSL, qui restent prioritaires sur les lignes qu'elles peignent.",
+      "Couleurs de ligne QSL : le style « barre à gauche » ne trace plus un filet coloré en haut et en bas de chaque ligne colorée. La barre est peinte autrement — c'est de nouveau une barre, et rien d'autre.",
+      "Concepteur QSL : le contact d'aperçu remplit maintenant toutes les colonnes que le tableau peut afficher, fréquence et sous-mode compris. Une colonne vide promettait une place que la carte imprimée n'avait pas."
+    ]
+  },
+  {
+    "version": "0.26.0",
+    "date": "",
+    "en": [
+      "A new FT decodes tab: every decode from WSJT-X, JTDX or MSHV, grouped by transmit period, with what is new and what you are sending. Clicking a decode asks the application to call that station, exactly as double-clicking the line in its own window does. Columns are resizable and remembered, the filter bar with them, Clear empties the lists and Halt stops the transmission. With two receivers running the table splits into one column per band, each with its own transmit line, Halt and Clear, and the column lights up when that receiver is on the air. On a FlexRadio, answering a decode moves the transmitter to the slice listening on that band — unless that band already transmits, so an existing split is left alone.",
+      "FT decodes: auto-call. OpsLog can answer a decode without you clicking it — pick what qualifies (a new entity, band, mode, band+mode slot, grid, US county, POTA park or WPX prefix) and add a watch list of callsigns, with or without conditions of their own. It answers a CQ only, one station at a time across the whole station, never while any receiver is still mid-QSO, with a cooldown per callsign, and every call is written to the log with its reason. Armed from the decodes toolbar or Settings → FTx decodes, and off until you turn it on.",
+      "A grid-square map (Tools → Grid squares): every 4-character square in the log, confirmed squares solid and worked ones faint, scoped to digital or the FT modes, on the basemap of your choice. It answers the one question a decode list cannot — not who is on the band, but where the station has actually been reaching.",
+      "UDP: a new outbound type relays the WSJT-X stream. Every datagram received from WSJT-X, JTDX or MSHV is re-sent byte for byte to another program — JTAlert, GridTracker, a second logger — which each sender cannot do on its own, since they talk to one address only. Forwarded verbatim, with no origin header of the kind that has to be stripped back off at the far end, and a target naming one of OpsLog’s own ports is refused rather than looped.",
+      "New-grid detection now reads the grid from a reply as well as from a CQ. \"C91RU IZ5EME JN52\" — a station answering with its locator — is the commonest grid-bearing message on a busy band, and only CQs were being read: any station whose CQ you happened to miss had no known grid at all and could never be flagged as a new one. This is why other tools showed far more wanted grids than OpsLog did.",
+      "New-grid chasing is now scoped the way GridTracker scopes it, so the two agree. Pick how a square counts as already worked — this band or any band, crossed with any digital mode, this exact mode, or any FT mode (FT8/FT4/FT2) — and whether to chase only squares never worked or unconfirmed ones too, which are still missing from the award. The two are shown differently: a square never worked is a QSO to make, one worked and awaiting a confirmation is a QSL to chase, and they no longer share a badge. Settings → DX Cluster. The decodes table also gained a Grid column.",
+      "Cluster: NEW badges now clear after a contact however it was logged. Only hand-logging refreshed the worked snapshot, so a station worked through WSJT-X / JTDX / MSHV — or replayed from the offline outbox, arriving from a multi-op partner, or imported from the POTA hunter log — kept its NEW, NEW BAND, NEW MODE, NEW SLOT, NEW GRID, NEW PFX or NEW POTA badge for the rest of the session.",
+      "DX cluster: the Spotter continent filter matches again. One callsign is spotted by skimmers all over the world within a minute, and they all shared a single cached entry belonging to whichever spotter arrived first — so picking AF left the Indian and American skimmers in the list. Each spot now carries its own spotter continent. Alert rules on the spotter’s continent or country were missing RBN spots for a related reason and now match too.",
+      "Recent QSOs: the callsign search takes wildcards. A plain word now matches the START of a call — 4S finds 4S7AB — while * is any run of characters and ? exactly one, so *4S ends with 4S and *4S* contains it anywhere. It was an unconditional contains-match before, which made asking for a prefix impossible.",
+      "QSL Manager: the right-click menu now carries the same actions as Recent QSOs — ADIF export of the selection, export with a chosen field set, Cabrillo, bulk edit, the callbook and cty.dat updates, e-mail and delete. Filtered exports are deliberately not offered here: \"the filter\" means the Recent-QSOs filter, not the rows on screen. Two entries that appeared in this tab and did nothing when clicked are fixed at the same time — the menu now shows an action only where it is actually wired.",
+      "Column pickers and the ADIF export field chooser gained a whole-dialog Select all / Clear. Only per-group links existed, so clearing a selection meant one click per group — a dozen of them before you could tick the handful you actually wanted. Applies to Recent QSOs, Worked before, the cluster list and the export dialog, and covers the award columns the per-group links never touched.",
+      "Rotator: a Compact mode option (Settings → Rotator) reduces the rotor widget to the dial and the short/long-path azimuths under it. Left off, the widget keeps its quick-turn buttons, azimuth box and Stop.",
+      "Band-opening watch: the radius that counts a receiver as \"around here\" is now adjustable (Settings → DX Cluster), 25–1000 km, still 300 km by default. An opening on 10 m reaches a whole region, a 2 m duct does not, and the right distance is a judgement only the operator can make. Tightening it costs no extra traffic — the subscription is unchanged — only sensitivity.",
+      "Club Log uploads are now identified as OpsLog. They were credited to another station's application key, which took the blame for them.",
+      "ADIF import: \"fill my station fields\" now fills the station callsign too, on records that carry none."
+    ],
+    "fr": [
+      "Un onglet Décodages FT : tous les décodages de WSJT-X, JTDX ou MSHV, groupés par période d’émission, avec ce qui est nouveau et ce que tu émets. Cliquer un décodage demande au logiciel d’appeler cette station, exactement comme un double-clic sur la ligne dans sa propre fenêtre. Les colonnes se redimensionnent et sont mémorisées, la barre de filtres avec elles, Vider efface les listes et Stop arrête l’émission. Avec deux récepteurs, le tableau se scinde en une colonne par bande, chacune avec sa ligne d’émission, son Stop et son Vider, et la colonne s’allume quand c’est ce récepteur qui émet. Sur un FlexRadio, répondre à un décodage déplace l’émetteur sur la slice qui écoute cette bande — sauf si cette bande émet déjà, pour ne pas défaire un split en place.",
+      "Décodages FT : appel automatique. OpsLog peut répondre à un décodage sans que tu cliques — choisis ce qui le déclenche (nouvelle entité, bande, mode, couple bande+mode, carré, comté US, parc POTA ou préfixe WPX) et ajoute une liste d’indicatifs surveillés, avec ou sans conditions propres. Uniquement sur un CQ, une station à la fois pour toute la station, jamais tant qu’un récepteur est encore en QSO, avec un délai de garde par indicatif, et chaque appel est écrit dans le journal avec sa raison. S’arme depuis la barre d’outils des décodages ou Réglages → Décodages FTx, et reste désactivé tant que tu ne l’actives pas.",
+      "Une carte des carrés locator (Outils → Carrés locator) : tous les carrés de 4 caractères du journal, les confirmés en plein et les contactés en pâle, au choix en numérique ou en modes FT, sur le fond de carte de ton choix. Elle répond à la seule question qu’une liste de décodages ne peut pas traiter : non pas qui est sur la bande, mais jusqu’où la station porte réellement.",
+      "UDP : un nouveau type sortant relaie le flux WSJT-X. Chaque datagramme reçu de WSJT-X, JTDX ou MSHV est réémis octet pour octet vers un autre logiciel — JTAlert, GridTracker, un second carnet — ce qu’aucun émetteur ne sait faire seul puisqu’il ne parle qu’à une adresse. Transmis tel quel, sans l’en-tête d’origine qu’il faut ensuite retirer à l’autre bout, et une cible désignant un port d’écoute d’OpsLog est refusée au lieu de boucler.",
+      "La détection des nouveaux carrés lit désormais le locator dans une réponse autant que dans un CQ. « C91RU IZ5EME JN52 » — une station qui répond avec son locator — est le message porteur de locator le plus fréquent sur une bande chargée, et seuls les CQ étaient lus : une station dont on avait manqué le CQ n’avait aucun locator connu et ne pouvait jamais être signalée comme nouvelle. C’est ce qui expliquait l’écart avec les autres logiciels sur le nombre de carrés recherchés.",
+      "La chasse aux nouveaux carrés se règle désormais comme dans GridTracker, pour que les deux soient d’accord. Choisis ce qui fait qu’un carré est déjà fait — cette bande ou toutes bandes, croisé avec tout mode numérique, ce mode exact, ou tout mode FT (FT8/FT4/FT2) — et si tu chasses seulement les carrés jamais contactés ou aussi les non confirmés, qui manquent encore au diplôme. Les deux s’affichent différemment : un carré jamais contacté est un QSO à faire, un carré contacté en attente de confirmation est une QSL à relancer, et ils ne partagent plus le même badge. Réglages → Cluster DX. Le tableau des décodages gagne aussi une colonne Locator.",
+      "Cluster : les badges NEW s’effacent enfin après un contact, quel que soit le mode de journalisation. Seule la saisie manuelle rafraîchissait l’instantané des contacts, si bien qu’une station travaillée via WSJT-X / JTDX / MSHV — ou rejouée depuis la file hors-ligne, reçue d’un partenaire multi-op, ou importée du journal chasseur POTA — gardait son badge NEW, NEW BAND, NEW MODE, NEW SLOT, NEW GRID, NEW PFX ou NEW POTA jusqu’à la fin de la session.",
+      "Cluster DX : le filtre Continent du spotter fonctionne à nouveau. Un même indicatif est spotté par des skimmers du monde entier en une minute, et tous partageaient une seule entrée en cache appartenant au premier spotter arrivé — choisir AF laissait donc les skimmers indiens et américains dans la liste. Chaque spot porte désormais son propre continent de spotter. Les règles d’alerte sur le continent ou le pays du spotter rataient les spots RBN pour une raison voisine et fonctionnent aussi.",
+      "QSO récents : la recherche d’indicatif accepte les jokers. Un mot simple correspond désormais au DÉBUT de l’indicatif — 4S trouve 4S7AB — tandis que * remplace n’importe quelle suite de caractères et ? exactement un : *4S se termine par 4S, *4S* le contient n’importe où. C’était auparavant une recherche « contient » systématique, qui rendait impossible la recherche par préfixe.",
+      "Gestionnaire QSL : le menu contextuel propose désormais les mêmes actions que les QSO récents — export ADIF de la sélection, export avec choix des champs, Cabrillo, édition en masse, mises à jour cty.dat et annuaires, e-mail et suppression. Les exports « filtrés » n’y sont volontairement pas offerts : « le filtre » désigne celui des QSO récents, pas les lignes affichées ici. Deux entrées qui apparaissaient dans cet onglet sans rien faire sont corrigées au passage — le menu n’affiche plus une action que là où elle est réellement branchée.",
+      "Les sélecteurs de colonnes et le choix des champs à l’export ADIF ont désormais un Tout sélectionner / Tout décocher global. Seuls les liens par groupe existaient, si bien que vider une sélection demandait un clic par groupe — une douzaine avant de pouvoir cocher les quelques champs voulus. Vaut pour les QSO récents, Déjà contacté, la liste cluster et la fenêtre d’export, et couvre les colonnes de diplômes que les liens par groupe ne touchaient pas.",
+      "Rotor : une option Mode compact (Réglages → Rotor) réduit le widget au cadran et aux azimuts courte/longue distance en dessous. Désactivée, le widget garde ses boutons de rotation rapide, sa case d’azimut et Stop.",
+      "Veille d’ouverture : le rayon qui fait qu’un récepteur compte comme « près d’ici » est désormais réglable (Réglages → Cluster DX), de 25 à 1000 km, toujours 300 km par défaut. Une ouverture sur 10 m couvre toute une région, un conduit sur 2 m non, et la bonne distance est un jugement qui n’appartient qu’à l’opérateur. Le resserrer ne coûte aucun trafic supplémentaire — l’abonnement ne change pas — seulement de la sensibilité.",
+      "Les envois Club Log s’identifient désormais comme OpsLog. Ils étaient attribués à la clé applicative d’une autre station, qui en portait la responsabilité.",
+      "Import ADIF : « remplir mes champs station » renseigne aussi l’indicatif de station, sur les enregistrements qui n’en portent pas."
+    ]
+  },
   {
     "version": "0.25.9",
     "date": "",

compact.go

@@ -0,0 +1,102 @@
+package main
+
+// Compacting a database.
+//
+// SQLite never shrinks a file on its own: deleting rows — or dropping a table,
+// which is what the schema-role cleanup does — frees pages INSIDE the file and
+// leaves the file the size it always was. A logbook that held 200 000 imported
+// QSOs for a day is still a 200 MB file the day after they are gone, and the
+// only thing that reclaims the space is a VACUUM, which rewrites the database
+// from scratch.
+//
+// Offered as a button rather than done automatically: a VACUUM rewrites the
+// whole file, needs room for a second copy of it while it runs, and takes real
+// time on a large logbook. That is a decision for the operator, at a moment they
+// choose — not something to spring on them during startup.
+
+import (
+	"database/sql"
+	"fmt"
+	"os"
+	"strings"
+
+	"hamlog/internal/applog"
+)
+
+// CompactResult is what one compaction did.
+type CompactResult struct {
+	// Path of the file compacted, empty for MySQL.
+	Path string `json:"path"`
+	// Backend is "sqlite" or "mysql" — a shared server is optimised, not vacuumed.
+	Backend string `json:"backend"`
+	// Before and After are file sizes in bytes; both 0 when there is no file.
+	Before int64 `json:"before"`
+	After  int64 `json:"after"`
+}
+
+// CompactDatabase reclaims the unused space in one of the two databases.
+//
+// target is "settings" or "logbook". They are separate on purpose: they are
+// different files, of very different sizes, and an operator compacting a 400 MB
+// logbook has no reason to wait on a 2 MB settings file as well.
+func (a *App) CompactDatabase(target string) (CompactResult, error) {
+	switch strings.ToLower(strings.TrimSpace(target)) {
+	case "settings":
+		if a.db == nil {
+			return CompactResult{}, fmt.Errorf("the settings database is not open")
+		}
+		return a.vacuumSQLite(a.db, a.dbPath)
+	case "logbook":
+		if a.logDb == nil {
+			return CompactResult{}, fmt.Errorf("the logbook is not open")
+		}
+		if a.dbBackend == "mysql" {
+			// A shared server's storage is the admin's business, and OPTIMIZE TABLE
+			// locks the table for the length of a rebuild — every other operator
+			// waits. Still offered, because a logbook that has had a large import
+			// deleted benefits from it just as much; it simply reports no sizes,
+			// which the server alone knows.
+			if _, err := a.logDb.ExecContext(a.ctx, "OPTIMIZE TABLE qso"); err != nil {
+				return CompactResult{}, fmt.Errorf("optimize qso: %w", err)
+			}
+			applog.Printf("compact: OPTIMIZE TABLE qso on the shared MySQL logbook")
+			return CompactResult{Backend: "mysql"}, nil
+		}
+		// No separate file: the settings database is serving as the logbook, and
+		// compacting it is the same operation.
+		if a.logDbPath == "" {
+			return a.vacuumSQLite(a.db, a.dbPath)
+		}
+		return a.vacuumSQLite(a.logDb, a.logDbPath)
+	}
+	return CompactResult{}, fmt.Errorf("unknown database %q", target)
+}
+
+// vacuumSQLite checkpoints the write-ahead log, then rewrites the file.
+func (a *App) vacuumSQLite(conn *sql.DB, path string) (CompactResult, error) {
+	res := CompactResult{Path: path, Backend: "sqlite", Before: fileSizeOf(path)}
+	// Fold the WAL back into the main file first. Without it the pages freed by a
+	// recent DELETE can still be sitting in the -wal, and the vacuum reports a
+	// saving the file on disk does not show.
+	if _, err := conn.ExecContext(a.ctx, "PRAGMA wal_checkpoint(TRUNCATE)"); err != nil {
+		applog.Printf("compact: wal checkpoint on %s: %v", path, err)
+	}
+	if _, err := conn.ExecContext(a.ctx, "VACUUM"); err != nil {
+		return res, fmt.Errorf("vacuum: %w", err)
+	}
+	res.After = fileSizeOf(path)
+	applog.Printf("compact: %s %d → %d bytes", path, res.Before, res.After)
+	return res, nil
+}
+
+// fileSizeOf returns a file's size, or 0 if it cannot be read.
+func fileSizeOf(path string) int64 {
+	if strings.TrimSpace(path) == "" {
+		return 0
+	}
+	fi, err := os.Stat(path)
+	if err != nil {
+		return 0
+	}
+	return fi.Size()
+}

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

flexzoom.go

@@ -0,0 +1,122 @@
+package main
+
+// Panadapter auto-zoom on a spot click.
+//
+// A CW signal is 100 Hz wide, an FT8 slot 50 Hz in a 3 kHz sub-band, an SSB
+// station 2.7 kHz. One panadapter width cannot serve all three: at 200 kHz the
+// CW station you clicked is a hair, and at 25 kHz an FT8 window shows one
+// eighth of the traffic. So the width follows the MODE of the spot, which is
+// the only thing that determines how much spectrum is worth looking at.
+//
+// The command is SmartSDR's own: "display pan s <pan> bandwidth=<MHz>", with an
+// optional re-centre. Same approach as DXHunter, which is where the defaults
+// below come from.
+
+import (
+	"encoding/json"
+	"strings"
+
+	"hamlog/internal/cat"
+)
+
+const keyFlexZoom = "flex.spot_zoom"
+
+// FlexZoomSettings is the per-mode-group visible width, in kHz.
+//
+// kHz and not MHz: an operator thinks "25 kHz of CW", and a form asking for
+// 0.025 invites a zero too many — which on a panadapter is not an error message
+// but a display that has silently gone somewhere else.
+type FlexZoomSettings struct {
+	Enabled bool `json:"enabled"`
+	CWkHz   int  `json:"cw_khz"`
+	SSBkHz  int  `json:"ssb_khz"`
+	DigikHz int  `json:"digi_khz"`
+	// Centre re-centres the panadapter on EVERY spot, not just the ones that
+	// would otherwise fall outside the new window — the display always follows.
+	// Off by default: an operator who has arranged their window around a run
+	// frequency does not necessarily want it moved every time they look at
+	// someone else, and a spot already on screen stays where it is either way.
+	Centre bool `json:"centre"`
+}
+
+// defaultFlexZoom — the widths DXHunter settled on, in kHz.
+var defaultFlexZoom = FlexZoomSettings{Enabled: false, CWkHz: 25, SSBkHz: 200, DigikHz: 50, Centre: false}
+
+// flexZoomGroup maps a spot's mode to the three widths worth distinguishing.
+//
+// The mode arrives as whatever the cluster comment implied — "CW", "FT8",
+// "USB", "RTTY" — so this takes the ADIF-ish name, not the Flex one. Anything
+// unrecognised is digital, which is the safe end: a 50 kHz window is readable
+// for every mode, where 25 kHz is not.
+func flexZoomGroup(mode string) string {
+	switch strings.ToUpper(strings.TrimSpace(mode)) {
+	case "CW", "CWR", "CWL", "CWU":
+		return "cw"
+	case "SSB", "USB", "LSB", "AM", "FM", "NFM", "DFM", "SAM", "PHONE", "DV":
+		return "ssb"
+	}
+	return "digi"
+}
+
+// GetFlexZoom returns the settings, defaults included.
+func (a *App) GetFlexZoom() FlexZoomSettings {
+	out := defaultFlexZoom
+	if raw := a.settingOr(keyFlexZoom, ""); raw != "" {
+		var s FlexZoomSettings
+		if err := json.Unmarshal([]byte(raw), &s); err == nil {
+			out = normFlexZoom(s)
+		}
+	}
+	return out
+}
+
+// normFlexZoom clamps the widths to something a panadapter can actually show.
+// 1 kHz is narrower than most filters; 14 MHz is a whole HF spectrum.
+func normFlexZoom(s FlexZoomSettings) FlexZoomSettings {
+	clamp := func(v, def int) int {
+		if v < 1 || v > 14000 {
+			return def
+		}
+		return v
+	}
+	s.CWkHz = clamp(s.CWkHz, defaultFlexZoom.CWkHz)
+	s.SSBkHz = clamp(s.SSBkHz, defaultFlexZoom.SSBkHz)
+	s.DigikHz = clamp(s.DigikHz, defaultFlexZoom.DigikHz)
+	return s
+}
+
+// SaveFlexZoom persists the settings.
+func (a *App) SaveFlexZoom(s FlexZoomSettings) error {
+	b, err := json.Marshal(normFlexZoom(s))
+	if err != nil {
+		return err
+	}
+	a.setSetting(keyFlexZoom, string(b))
+	return nil
+}
+
+// FlexZoomForSpot resizes the panadapter for a spot that was just clicked.
+//
+// Called from the click handler, AFTER the rig has been tuned: the zoom is a
+// view change and must never delay the frequency change an operator is waiting
+// for. Does nothing at all unless the option is on and the backend is a Flex —
+// no other radio has a panadapter to zoom.
+func (a *App) FlexZoomForSpot(mode string, freqHz int64) {
+	if a.cat == nil {
+		return
+	}
+	z := a.GetFlexZoom()
+	if !z.Enabled {
+		return
+	}
+	khz := z.DigikHz
+	switch flexZoomGroup(mode) {
+	case "cw":
+		khz = z.CWkHz
+	case "ssb":
+		khz = z.SSBkHz
+	}
+	_ = a.cat.FlexDo(func(fc cat.FlexController) error {
+		return fc.ZoomPan(float64(khz)/1000, float64(freqHz)/1e6, z.Centre)
+	})
+}

flexzoom_test.go

@@ -0,0 +1,32 @@
+package main
+
+import "testing"
+
+// The width follows the mode, and an unrecognised mode must land on the widest
+// of the three: a 50 kHz window is readable for everything, where 25 kHz shows
+// one eighth of an FT8 sub-band.
+func TestFlexZoomGroup(t *testing.T) {
+	for mode, want := range map[string]string{
+		"CW": "cw", "cw": "cw", "CWR": "cw",
+		"SSB": "ssb", "USB": "ssb", "LSB": "ssb", "FM": "ssb", "AM": "ssb",
+		"FT8": "digi", "FT4": "digi", "RTTY": "digi", "JS8": "digi", "PSK31": "digi",
+		"": "digi", "something new": "digi",
+	} {
+		if got := flexZoomGroup(mode); got != want {
+			t.Errorf("flexZoomGroup(%q) = %q, want %q", mode, got, want)
+		}
+	}
+}
+
+// A width of zero would command "bandwidth=0.000000" and take the panadapter
+// somewhere the operator cannot get back from by eye.
+func TestNormFlexZoomClamps(t *testing.T) {
+	got := normFlexZoom(FlexZoomSettings{CWkHz: 0, SSBkHz: -5, DigikHz: 99999})
+	if got.CWkHz != defaultFlexZoom.CWkHz || got.SSBkHz != defaultFlexZoom.SSBkHz || got.DigikHz != defaultFlexZoom.DigikHz {
+		t.Errorf("out-of-range widths not replaced by the defaults: %+v", got)
+	}
+	ok := normFlexZoom(FlexZoomSettings{CWkHz: 10, SSBkHz: 150, DigikHz: 40})
+	if ok.CWkHz != 10 || ok.SSBkHz != 150 || ok.DigikHz != 40 {
+		t.Errorf("valid widths must be kept as they are: %+v", ok)
+	}
+}

frontend/src/components/AlertsModal.tsx

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { Bell, Plus, Trash2, Volume2, Mail, Eye, X, Search } from 'lucide-react';
 import {
   Dialog, DialogContent, DialogHeader, DialogTitle, DialogDescription,
@@ -102,17 +102,40 @@ export function AlertsModal({ onClose, bands, modes, countries }: {
     return alerts.Rule.createFrom({ ...d, [key]: next });
   });
 
+  // Saving used to be silent: the dialog stays open and the rule looks exactly
+  // as it did a second earlier, so there was nothing to tell an operator whether
+  // the click had registered. A line that says so, and clears itself.
+  const [savedMsg, setSavedMsg] = useState('');
+  const savedTimer = useRef(0);
+  function flashSaved(text: string) {
+    setSavedMsg(text);
+    window.clearTimeout(savedTimer.current);
+    savedTimer.current = window.setTimeout(() => setSavedMsg(''), 3000);
+  }
+  useEffect(() => () => window.clearTimeout(savedTimer.current), []);
+
   async function save() {
     if (!draft) return;
     if (!draft.name.trim()) { setErr(t('altm.giveName')); return; }
-    try { const saved = await SaveAlertRule(draft); await refresh(); loadDraft(saved as Rule); setErr(''); }
+    try {
-    catch (e: any) { setErr(String(e?.message ?? e)); }
+      const saved = await SaveAlertRule(draft);
+      await refresh();
+      loadDraft(saved as Rule);
+      setErr('');
+      flashSaved(t('altm.saved', { name: draft.name.trim() }));
+    } catch (e: any) { setErr(String(e?.message ?? e)); }
   }
   async function del() {
     if (!draft) return;
     if (!draft.id) { loadDraft(null); return; }
     if (!window.confirm(t('altm.deleteConfirm', { name: draft.name }))) return;
-    try { await DeleteAlertRule(draft.id); loadDraft(null); await refresh(); }
+    try {
+      const name = draft.name;
+      await DeleteAlertRule(draft.id);
+      loadDraft(null);
+      await refresh();
+      flashSaved(t('altm.deleted', { name }));
+    }
     catch (e: any) { setErr(String(e?.message ?? e)); }
   }
 
@@ -257,6 +280,7 @@ export function AlertsModal({ onClose, bands, modes, countries }: {
                 {/* Editor actions */}
                 <div className="flex items-center gap-2 px-3 py-2 border-t border-border/60">
                   {err && <span className="text-[11px] text-danger flex-1 truncate">{err}</span>}
+                  {!err && savedMsg && <span className="text-[11px] text-success flex-1 truncate">{savedMsg}</span>}
                   <div className="flex-1" />
                   <Button variant="ghost" size="sm" className="text-danger" onClick={del}><Trash2 className="size-3.5" /> {t('altm.delete')}</Button>
                   <Button size="sm" onClick={save}>{t('altm.saveRule')}</Button>

frontend/src/components/AppearancePanel.tsx

@@ -29,9 +29,9 @@ const LABELS: Record<string, string> = {
 
 // The channels a rule can be scoped to. "worked" is the catch-all — it means
 // nothing on ANY channel — so narrowing it would say nothing.
-const CHANNELS = ['qsl', 'lotw', 'eqsl', 'qrz'] as const;
+const CHANNELS = ['qsl', 'lotw', 'eqsl', 'qrz', 'hamlog'] as const;
 const CHANNEL_LABELS: Record<string, string> = {
-  qsl: 'appr.chQsl', lotw: 'LoTW', eqsl: 'eQSL', qrz: 'QRZ.com',
+  qsl: 'appr.chQsl', lotw: 'LoTW', eqsl: 'eQSL', qrz: 'QRZ.com', hamlog: 'HAMLOG.online',
 };
 
 // MatrixColorsSection recolours the band/mode matrix — the PH/CW/DIG grid in the
@@ -179,6 +179,31 @@ export function AppearancePanel() {
         <span>{t('appr.bandmapLotw')} <span className="text-xs text-muted-foreground">{t('appr.bandmapLotwHint')}</span></span>
       </label>
 
+      {/* Banding is its own thing, above the QSL rules and outside them: it says
+          nothing about a contact, it only helps the eye keep its line across a
+          wide table. Turning the status colours off must not take it away. */}
+      <div className="space-y-2">
+        <label className="flex items-start gap-2 text-sm cursor-pointer">
+          <Checkbox checked={(cfg as any).recent_zebra !== 'off'} className="mt-0.5"
+            onCheckedChange={(c) => save({ ...cfg, recent_zebra: c ? '' : 'off' } as any)} />
+          <span>{t('appr.zebra')} <span className="text-xs text-muted-foreground">{t('appr.zebraHint')}</span></span>
+        </label>
+        {(cfg as any).recent_zebra !== 'off' && (
+          <div className="flex items-center gap-2 pl-6">
+            <span className="text-xs text-muted-foreground">{t('appr.zebraColor')}</span>
+            <input type="color" className="size-7 rounded border border-border bg-transparent p-0 cursor-pointer"
+              value={/^#[0-9a-fA-F]{6}$/.test((cfg as any).recent_zebra_color ?? '') ? (cfg as any).recent_zebra_color : '#808080'}
+              onChange={(e) => save({ ...cfg, recent_zebra_color: e.target.value } as any)} />
+            {/* Empty means "follow the theme", and there has to be a way back to
+                it — a colour chosen under one theme is wrong under the other. */}
+            {(cfg as any).recent_zebra_color && (
+              <button type="button" className="text-xs text-muted-foreground hover:text-foreground"
+                onClick={() => save({ ...cfg, recent_zebra_color: '' } as any)}>{t('appr.zebraAuto')}</button>
+            )}
+          </div>
+        )}
+      </div>
+
       <label className="flex items-start gap-2 text-sm cursor-pointer">
         <Checkbox checked={cfg.enabled} className="mt-0.5"
           onCheckedChange={(c) => save({ ...cfg, enabled: !!c })} />

frontend/src/components/AwardEditor.tsx

@@ -62,9 +62,14 @@ type Preset = { key: string; name: string; field: string; dxcc: number; refs: Aw
 // organizational only; matching is driven by the field/pattern/dynamic options,
 // so there's no need for separate GRID/DXCC types (use QSOFIELDS + the field).
 const AWARD_TYPES = ['REFERENCE', 'QSOFIELDS', 'CALLSIGN'];
+// Sentinel for "no QSO field at all". The definition stores an empty field, and
+// the matcher already treats that as "nothing to scan" — this only gives the
+// operator a way to ASK for it.
+const NO_FIELD = '__none__';
 const CONFIRM_SRC = [
   { id: 'lotw', label: 'LoTW' }, { id: 'qsl', label: 'QSL' }, { id: 'eqsl', label: 'eQSL' },
-  { id: 'qrzcom', label: 'QRZ.com' }, { id: 'custom', label: 'Custom' },
+  { id: 'qrzcom', label: 'QRZ.com' }, { id: 'hamlog', label: 'HAMLOG.online' },
+  { id: 'custom', label: 'Custom' },
 ];
 const BANDS = ['2190m','630m','160m','80m','60m','40m','30m','20m','17m','15m','12m','10m','6m','4m','2m','1.25m','70cm','33cm','23cm','13cm','9cm','6cm','3cm','1.25cm','6mm','4mm','2.5mm','2mm','1mm'];
 const MODES = ['CW','SSB','USB','LSB','AM','FM','RTTY','PSK31','FT8','FT4','JT65','JT9','MFSK','OLIVIA','DIGITALVOICE'];
@@ -277,6 +282,7 @@ export function AwardEditor({ open, onClose, onSaved }: Props) {
     }
     return groups;
   }, [testRows]);
+  const noField = !String(cur?.field ?? '').trim();
   const patch = (p: Partial<AwardDef>) => setDefs((ds) => ds.map((d, j) => (j === sel ? { ...d, ...p } : d)));
   const toggleIn = (key: keyof AwardDef, v: string) => {
     const arr = ((cur?.[key] as string[]) ?? []);
@@ -566,11 +572,30 @@ export function AwardEditor({ open, onClose, onSaved }: Props) {
                     <div className="border-t pt-2.5 mt-1 space-y-2.5">
                       <p className="text-[11px] text-muted-foreground">{t('awed.qsoParams')}</p>
                       <Field2 label={t('awed.searchInField')}>
-                        <Select value={cur.field} onValueChange={(v) => patch({ field: v })}>
+                        {/* NO_FIELD is a sentinel because the stored value is the
+                            empty string and a Select cannot carry one — an empty
+                            item value means "show the placeholder" to Radix. */}
+                        {/* Picking "no field" clears the fallbacks too: it promises that
+                            nothing is matched automatically, and an OR rule left behind goes
+                            on scanning its own field — worse than a visible one, because the
+                            panel stops showing it. */}
+                        <Select value={cur.field || NO_FIELD}
+                          onValueChange={(v) => patch(v === NO_FIELD ? { field: '', or_rules: [] } : { field: v })}>
                           <SelectTrigger className="h-8 text-xs w-56"><SelectValue /></SelectTrigger>
-                          <SelectContent className="max-h-72">{fields.map((f) => <SelectItem key={f} value={f}>{f}</SelectItem>)}</SelectContent>
+                          <SelectContent className="max-h-72">
+                            <SelectItem value={NO_FIELD}>{t('awed.fieldNone')}</SelectItem>
+                            {fields.map((f) => <SelectItem key={f} value={f}>{f}</SelectItem>)}
+                          </SelectContent>
                         </Select>
                       </Field2>
+                      {/* An award whose references live in no ADIF field at all —
+                          WWBOTA has no column anywhere — has nothing to match on,
+                          and every control below would be a question with no
+                          answer. Hiding them is the point: the references are the
+                          ones the operator assigns to a QSO by hand. */}
+                      {noField ? (
+                        <p className="text-[11px] text-muted-foreground pl-[128px]">{t('awed.fieldNoneHint')}</p>
+                      ) : (<>
                       <Field2 label={t('awed.matchBy')}>
                         <div className="flex items-center gap-3 text-xs">
                           {['code', 'description', 'pattern'].map((m) => (
@@ -589,10 +614,17 @@ export function AwardEditor({ open, onClose, onSaved }: Props) {
                         <Field2 label={t('awed.prefix')}><Input className="h-8 font-mono text-xs" value={cur.prefix ?? ''} onChange={(e) => patch({ prefix: e.target.value })} placeholder={t('awed.prefixPlaceholder')} title={t('awed.prefixTitle')} /></Field2>
                       </div>
 
+                      </>)}
                       {/* Fallback searches: tried in order, only while nothing
                           has matched yet — the first that hits wins (short-circuit),
                           so a value already resolved by the primary rule isn't
-                          re-derived differently by a later one. */}
+                          re-derived differently by a later one.
+                          
+                          Shown even with no field when rules survive from an
+                          imported definition: a rule that still runs must still
+                          be visible, or the award finds references the panel
+                          says it cannot. */}
+                      {(!noField || (cur.or_rules?.length ?? 0) > 0) && (
                       <div className="border-t pt-2.5 space-y-2">
                         <div className="flex items-center justify-between">
                           <p className="text-[11px] text-muted-foreground">{t('awed.additionalSearches')} <span className="font-semibold">(OR)</span> {t('awed.orAlsoMatch')}</p>
@@ -630,6 +662,7 @@ export function AwardEditor({ open, onClose, onSaved }: Props) {
                           );
                         })}
                       </div>
+                      )}
                     </div>
                   </TabsContent>
 

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 } 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/…)
@@ -54,6 +54,34 @@ export function AwardRefSelector({ dxcc, value, onChange, fieldValues, heightCla
 
   const entries = value ? value.split(';').filter(Boolean) : [];
 
+  // Which of the picked references have never been worked. Asked of the backend
+  // only when the list of references actually changes — a handful of times per
+  // QSO — and it answers from an in-memory set (see awardnew.go).
+  //
+  // The first question about an award may arrive before its set is built, in
+  // which case the answer is "pending" and carries no verdict for it: we ask
+  // again rather than badge on a guess. Attempts are capped so a logbook that
+  // never finishes building cannot leave a timer running for the session.
+  const [isNew, setIsNew] = useState<Record<string, boolean>>({});
+  const entriesKey = entries.join(';');
+  useEffect(() => {
+    if (!entriesKey) { setIsNew({}); return; }
+    let alive = true;
+    let timer: number | undefined;
+    let tries = 0;
+    const ask = () => {
+      AwardRefsNew(entriesKey.split(';'))
+        .then((r: any) => {
+          if (!alive) return;
+          setIsNew(r?.new ?? {});
+          if (r?.pending && ++tries < 10) timer = window.setTimeout(ask, 700);
+        })
+        .catch(() => { if (alive) setIsNew({}); }); // no badge beats a wrong one
+    };
+    ask();
+    return () => { alive = false; if (timer) window.clearTimeout(timer); };
+  }, [entriesKey]);
+
   // When the reference set is cleared (a QSO was logged or the call was reset),
   // also blank the picker's own state — the search box and the highlighted /
   // selected reference — so the Awards tab starts fresh for the next contact.
@@ -66,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(() => {});
   }, []);
@@ -83,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
@@ -94,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(() => {
@@ -256,7 +295,16 @@ export function AwardRefSelector({ dxcc, value, onChange, fieldValues, heightCla
                 }`}
                 onClick={() => setSelectedEntry(selectedEntry === entry ? null : entry)}
               >
-                <span className="font-mono font-semibold flex-1 truncate">{entry}</span>
+                <span className="font-mono font-semibold truncate">{entry}</span>
+                {isNew[entry] && (
+                  <span
+                    title={t('awrs.newRefHint')}
+                    className="shrink-0 px-1 rounded-sm text-[9px] leading-[14px] font-semibold tracking-wide bg-success-muted text-success border border-success-border"
+                  >
+                    {t('awrs.new')}
+                  </span>
+                )}
+                <span className="flex-1" />
                 <button
                   className="shrink-0 hover:text-destructive"
                   onClick={(e) => { e.stopPropagation(); removeEntry(entry); }}

frontend/src/components/AwardsPanel.tsx

@@ -68,7 +68,11 @@ function ProgressBar({ worked, confirmed, total }: { worked: number; confirmed:
 // detection only means anything for those — see the Missing refs button.
 type AwardListItem = { code: string; name: string; valid?: boolean; bands?: string[]; emission?: string[]; scoped?: boolean };
 
-export function AwardsPanel({ onEditQSO, onAwardsChanged }: { onEditQSO?: (id: number) => void; onAwardsChanged?: () => void } = {}) {
+export function AwardsPanel({ onEditQSO, onAwardsChanged, onPaperQSL }: {
+  onEditQSO?: (id: number) => void;
+  onAwardsChanged?: () => void;
+  onPaperQSL?: (call: string) => void;
+} = {}) {
   const { t } = useI18n();
   const [awardList, setAwardList] = useState<AwardListItem[]>([]);
   // Computed results are cached per award code — each award is scanned only the
@@ -604,7 +608,7 @@ export function AwardsPanel({ onEditQSO, onAwardsChanged }: { onEditQSO?: (id: n
       </div>
 
       {cell && current && (
-        <CellQSOModal code={current.code} cell={cell} modeClass={modeFilter === 'all' ? '' : modeFilter} onClose={() => setCell(null)} />
+        <CellQSOModal code={current.code} cell={cell} modeClass={modeFilter === 'all' ? '' : modeFilter} onClose={() => setCell(null)} onPaperQSL={onPaperQSL} />
       )}
       {showMissing && current && (
         <MissingQSOModal code={current.code} name={current.name} onClose={() => setShowMissing(false)} onEditQSO={onEditQSO} />
@@ -835,7 +839,14 @@ function MissingQSOModal({ code, name, onClose, onEditQSO }: { code: string; nam
 }
 
 // CellQSOModal lists the QSOs behind one award-grid cell (reference × band).
-function CellQSOModal({ code, cell, modeClass, onClose }: { code: string; cell: { ref: string; band: string; name?: string }; modeClass: string; onClose: () => void }) {
+function CellQSOModal({ code, cell, modeClass, onClose, onPaperQSL }: {
+  code: string; cell: { ref: string; band: string; name?: string }; modeClass: string;
+  onClose: () => void;
+  // Send this callsign to the QSL Manager's Paper QSL view. Chasing a
+  // confirmation starts here — an unconfirmed entity, the contact behind it —
+  // and used to continue by retyping the callsign into another tab.
+  onPaperQSL?: (call: string) => void;
+}) {
   const { t } = useI18n();
   const [qsos, setQsos] = useState<any[]>([]);
   const [loading, setLoading] = useState(true);
@@ -872,7 +883,15 @@ function CellQSOModal({ code, cell, modeClass, onClose }: { code: string; cell:
                 {qsos.map((q, i) => (
                   <tr key={q.id ?? i} className="border-b border-border/30">
                     <td className="py-1 px-3 font-mono">{fmt(q.qso_date)}</td>
-                    <td className="py-1 pr-2 font-mono font-semibold">{q.callsign}</td>
+                    <td className="py-1 pr-2 font-mono font-semibold">
+                      {onPaperQSL ? (
+                        <button type="button" className="hover:underline text-primary"
+                          title={t('awp.paperQslTip')}
+                          onClick={() => { onPaperQSL(String(q.callsign ?? '')); onClose(); }}>
+                          {q.callsign}
+                        </button>
+                      ) : q.callsign}
+                    </td>
                     <td className="py-1 pr-2">{q.band}</td>
                     <td className="py-1 pr-2">{q.mode}</td>
                     <td className="py-1 pr-3 text-muted-foreground">{[isQSLConfirmed(q.lotw_rcvd) && 'LoTW', isQSLConfirmed(q.qsl_rcvd) && 'QSL', isQSLConfirmed(q.eqsl_rcvd) && 'eQSL'].filter(Boolean).join(', ')}</td>

frontend/src/components/BandMap.tsx

@@ -25,6 +25,16 @@ interface Spot {
   band?: string;
   comment?: string;
   spotter?: string;
+  // The park reference the POTA poller tagged this spot with. The map never
+  // reads it — the click handler upstream turns it into the QSO's POTA award
+  // reference — but it is declared so it cannot be lost by accident.
+  //
+  // It travelled only because the spot objects are passed through by reference
+  // and the type was erased. The first refactor to copy a spot field by field
+  // would have dropped the park silently, and the only symptom would be an
+  // activation logged without its reference. Same mistake as the status entry
+  // below, whose extra markers were arriving and undeclared.
+  pota_ref?: string;
 }
 
 // The FULL status entry, not the two fields the map used to declare. The extra
@@ -83,6 +93,12 @@ interface Props {
   // globally from the band-map tab toolbar.
   hideDigital?: boolean;
   fitToBand?: boolean;
+  // onToggleFit and onToggleHideDigital add the two switches to this map's own
+  // header. Only the docked map passes them: the Band Map tab has both in its
+  // toolbar, above maps that all obey them at once, and a switch inside each
+  // card as well would be four ways to change one setting.
+  onToggleFit?: () => void;
+  onToggleHideDigital?: () => void;
   // Mark stations that upload to LoTW (Settings → Appearance).
   showLotw?: boolean;
   // keyNav enables Ctrl+↑ / Ctrl+↓ to hop to the next spot above / below the rig
@@ -159,6 +175,7 @@ function LegendDot({ cls, colour, label }: { cls?: string; colour?: string; labe
 function statusLabel(s: string, t: (k: string) => string): string {
   switch (s) {
     case 'new':      return t('bmp.statusNew');
+    case 'new-band-mode': return t('bmp.statusNewBandMode');
     case 'new-band': return t('bmp.statusNewBand');
     case 'new-mode': return t('bmp.statusNewMode');
     case 'new-slot': return t('bmp.statusNewSlot');
@@ -186,7 +203,11 @@ function statusStyle(s: string): { pill: string; bar: string; line: string; dot:
   // line = SVG leader stroke (visible on hover)
   // dot  = small marker on the freq scale
   switch (s) {
-    case 'new':      return {
+    // NEW and NEW BAND+MODE share the strongest colour: both mean "there is
+    // something here you have never had", and a sixth shade in a palette read at
+    // a glance is a shade nobody can name.
+    case 'new':
+    case 'new-band-mode': return {
       pill: 'bg-danger-muted text-danger-muted-foreground border-danger-border hover:bg-danger-muted',
       bar:  'bg-danger',
       line: 'stroke-danger',
@@ -263,7 +284,7 @@ const BOT_PAD = 14;    // the top-most freq label isn't clipped at y=0
 // last; ties broken by closeness to the rig freq).
 const MAX_VISIBLE_SPOTS = 30;
 
-export function BandMap({ band, spots, spotStatus: spotStatusRaw, currentFreqHz, onSpotClick, onClose, side = 'right', onToggleSide, hideDigital = false, fitToBand = false, keyNav = false, showLotw = false }: Props) {
+export function BandMap({ band, spots, spotStatus: spotStatusRaw, currentFreqHz, onSpotClick, onClose, side = 'right', onToggleSide, hideDigital = false, fitToBand = false, onToggleFit, onToggleHideDigital, keyNav = false, showLotw = false }: Props) {
   const { t } = useI18n();
 
   // The two display options are applied ONCE here, on the whole map, so the
@@ -361,6 +382,7 @@ export function BandMap({ band, spots, spotStatus: spotStatusRaw, currentFreqHz,
       const k = spotStatusKey(s.dx_call, s.band ?? '', s.comment ?? '', s.freq_hz);
       switch (spotStatus[k]?.status ?? '') {
         case 'new':      return 0;
+        case 'new-band-mode': return 0;
         case 'new-band': return 1;
         case 'new-slot': return 2;
         case 'new-call': return 2;
@@ -559,12 +581,39 @@ export function BandMap({ band, spots, spotStatus: spotStatusRaw, currentFreqHz,
           title={t('bmp.zoomOut')}>
           <Minus className="size-3" />
         </button>
+        {/* A readout, not a switch.
+            
+            It WAS the switch for a day: clicking the px/kHz value toggled
+            fit-to-band, and in fit it read "FIT". Nobody found it — a control
+            whose label is a measurement does not look like a control, and once
+            switched off there was no longer anything on screen saying the option
+            existed. The switches below say what they are. */}
+        {/* In fit mode the readout has nothing left to say — the lit FIT button
+            says it, and printing the word twice side by side is just noise. The
+            Band Map tab's cards have no button, so there the readout keeps
+            reporting both states. */}
+        {(!fitToBand || !onToggleFit) && (
           <span className="shrink-0 font-mono text-[10px] normal-case tracking-normal whitespace-nowrap px-0.5">{fitToBand ? t('bmp.fit') : `${pxPerKHz}px/kHz`}</span>
+        )}
         <button type="button" onClick={() => changeZoom(1)} disabled={fitToBand || zoomIdx === PX_PER_KHZ.length - 1}
           className="size-5 shrink-0 inline-flex items-center justify-center rounded hover:bg-muted disabled:opacity-30"
           title={t('bmp.zoomIn')}>
           <Plus className="size-3" />
         </button>
+        {onToggleFit && (
+          <button type="button" onClick={onToggleFit} title={t('bmp.fitTitle')}
+            className={cn('shrink-0 text-[10px] font-semibold normal-case tracking-normal px-1 rounded border transition-colors',
+              fitToBand ? 'border-primary bg-primary text-primary-foreground' : 'border-border text-muted-foreground hover:bg-muted')}>
+            {t('bmp.fit')}
+          </button>
+        )}
+        {onToggleHideDigital && (
+          <button type="button" onClick={onToggleHideDigital} title={t('bmp.hideFtTitle')}
+            className={cn('shrink-0 text-[10px] font-semibold normal-case tracking-normal px-1 rounded border transition-colors',
+              hideDigital ? 'border-primary bg-primary text-primary-foreground' : 'border-border text-muted-foreground hover:bg-muted')}>
+            {t('bmp.ftx')}
+          </button>
+        )}
         <button type="button" onClick={recenterOnRig}
           className="size-5 inline-flex items-center justify-center rounded hover:bg-muted"
           title={t('bmp.scrollToRig')}>

frontend/src/components/BulkEditModal.tsx

@@ -48,6 +48,12 @@ const FIELDS: FieldDef[] = [
   { id: 'clublog_sent_date', label: 'bulk.fClublogSentDate', group: 'QSL / upload', kind: 'date' },
   { id: 'hrdlog_sent',       label: 'bulk.fHrdlogSent',      group: 'QSL / upload', kind: 'status' },
   { id: 'hrdlog_sent_date',  label: 'bulk.fHrdlogSentDate',  group: 'QSL / upload', kind: 'date' },
+  // HAMLOG.online: no promoted column, written into extras_json (see
+  // qso.bulkEditableExtras). Status and date, like every other service here.
+  { id: 'hamlog_sent',       label: 'bulk.fHamlogSent',      group: 'QSL / upload', kind: 'status' },
+  { id: 'hamlog_sent_date',  label: 'bulk.fHamlogSentDate',  group: 'QSL / upload', kind: 'date' },
+  { id: 'hamlog_rcvd',       label: 'bulk.fHamlogRcvd',      group: 'QSL / upload', kind: 'status' },
+  { id: 'hamlog_rcvd_date',  label: 'bulk.fHamlogRcvdDate',  group: 'QSL / upload', kind: 'date' },
   // My station / operator
   { id: 'station_callsign', label: 'bulk.fStationCall',  group: 'My station', kind: 'text', upper: true },
   { id: 'operator',         label: 'bulk.fOperator',     group: 'My station', kind: 'text', upper: true },

frontend/src/components/ChaseNewPanel.tsx

@@ -62,6 +62,7 @@ const CATEGORIES: Array<{ key: Category; labelKey: string; colour: string }> = [
 function categoryOf(s: ChaseNewSpot): Category | null {
   switch (s.status) {
     case 'new': return 'dxcc';
+    case 'new-band-mode': return 'band';
     case 'new-band': return 'band';
     case 'new-mode': return 'mode';
     case 'new-slot': return 'slot';

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';
@@ -69,12 +69,19 @@ export type SpotStatusEntry = {
   spotter_continent?: string;
   grid?: string;
   new_grid?: boolean;
+  grid_state?: string;
 };
 
 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';
@@ -173,6 +180,7 @@ function cellText(value: any, color: string | null): any {
 function statusColor(s: SpotStatusEntry | undefined): string | null {
   switch (s?.status) {
     case 'new':
+    case 'new-band-mode':
     case 'new-band':
     case 'new-mode':
     case 'new-slot':
@@ -192,7 +200,7 @@ function statusColor(s: SpotStatusEntry | undefined): string | null {
 // (still loading, or entity unknown) are NOT dimmed — that would flicker.
 function isDull(s: SpotStatusEntry | undefined): boolean {
   if (!s || !s.status) return false;
-  if (s.status === 'new' || s.status === 'new-band' || s.status === 'new-mode' || s.status === 'new-slot' || s.status === 'new-call') return false;
+  if (s.status === 'new' || s.status === 'new-band-mode' || s.status === 'new-band' || s.status === 'new-mode' || s.status === 'new-slot' || s.status === 'new-call') return false;
   return !(s.worked_call || s.new_pota || s.new_county || s.new_pfx || s.new_grid);
 }
 
@@ -258,6 +266,7 @@ const makeColCatalog = (t: TFn): ColEntry[] => [
       const s = statusFor(p);
       const parts: string[] = [];
       if (s?.status === 'new') parts.push(t('clg2.newDxcc'));
+      else if (s?.status === 'new-band-mode') parts.push(t('clg2.newBandMode'));
       else if (s?.status === 'new-band') parts.push(t('clg2.newBand'));
       else if (s?.status === 'new-mode') parts.push(t('clg2.newMode'));
       else if (s?.status === 'new-slot') parts.push(t('clg2.newSlot'));
@@ -266,15 +275,16 @@ const makeColCatalog = (t: TFn): ColEntry[] => [
       if (s?.new_county) parts.push(t('clg2.newCounty'));
       if (s?.new_pota) parts.push(t('clg2.newPota'));
       if (s?.new_pfx) parts.push(t('clg2.newPfx'));
-      if (s?.new_grid) parts.push(t('clg2.newGrid'));
+      if (s?.new_grid) parts.push(s.grid_state === 'unconf' ? t('clg2.newGridUnconf') : t('clg2.newGrid'));
       return parts.join(' ');
     },
     cellRenderer: (p: any) => {
       const s = statusFor(p);
-      const parts: { text: string; color: string }[] = [];
+      const parts: { text: string; color: string; dim?: boolean }[] = [];
       const main = statusColor(s);
       if (main) {
         const label = s?.status === 'new' ? t('clg2.newDxcc')
+          : s?.status === 'new-band-mode' ? t('clg2.newBandMode')
           : s?.status === 'new-band' ? t('clg2.newBand')
             : s?.status === 'new-mode' ? t('clg2.newMode')
               : s?.status === 'new-slot' ? t('clg2.newSlot')
@@ -287,12 +297,19 @@ const makeColCatalog = (t: TFn): ColEntry[] => [
       if (s?.new_county) parts.push({ text: t('clg2.newCounty'), color: markerColour('new_county') });
       if (s?.new_pota) parts.push({ text: t('clg2.newPota'), color: markerColour('new_pota') });
       if (s?.new_pfx) parts.push({ text: t('clg2.newPfx'), color: markerColour('new_pfx') });
-      if (s?.new_grid) parts.push({ text: t('clg2.newGrid'), color: markerColour('new_grid') });
+      // Worked-but-unconfirmed is a QSL to chase, not a QSO to make. Same hue
+      // held back, so it reads as "less" of the same thing rather than a
+      // different fact — and the label says which.
+      if (s?.new_grid) {
+        parts.push(s.grid_state === 'unconf'
+          ? { text: t('clg2.newGridUnconf'), color: markerColour('new_grid'), dim: true }
+          : { text: t('clg2.newGrid'), color: markerColour('new_grid') });
+      }
       if (parts.length === 0) return <span style={{ color: 'var(--muted-foreground)', fontSize: 10 }}>—</span>;
       return (
         <span style={{ whiteSpace: 'nowrap' }}>
           {parts.map((pt, i) => (
-            <span key={i} style={{ color: pt.color, fontWeight: 700 }}>
+            <span key={i} style={{ color: pt.color, fontWeight: 700, opacity: pt.dim ? 0.5 : 1 }}>
               {i > 0 ? ' · ' : ''}{pt.text}
             </span>
           ))}
@@ -302,6 +319,7 @@ const makeColCatalog = (t: TFn): ColEntry[] => [
     tooltipValueGetter: (p: any) => {
       const s = statusFor(p);
       if (s?.status === 'new') return t('clg2.tipNewDxcc', { country: s?.country ?? '' });
+      if (s?.status === 'new-band-mode') return t('clg2.tipNewBandMode');
       if (s?.status === 'new-band') return t('clg2.tipNewBand');
       if (s?.status === 'new-slot') return t('clg2.tipNewSlotBand');
       if (s?.status === 'new-call') return t('clg2.tipNewCall');
@@ -330,10 +348,18 @@ const makeColCatalog = (t: TFn): ColEntry[] => [
     headerName: t('clg2.c.band'), field: 'band' as any, width: 75,
     defaultVisible: true,
     cellClass: 'font-mono',
-    // NEW BAND for this entity → the band cell is filled.
+    // NEW BAND for this entity → the band cell is filled. NEW BAND+MODE fills
-    cellStyle: (p: any) => (statusFor(p)?.status === 'new-band' ? fillStyle(NEW) : null) as any,
+    // it too: the band really is new, and leaving it plain would say the
+    // opposite of the status column beside it.
+    cellStyle: (p: any) => {
+      const st = statusFor(p)?.status;
+      return (st === 'new-band' || st === 'new-band-mode' ? fillStyle(NEW) : null) as any;
+    },
     cellRenderer: (p: any) => cellText(p.value, null),
-    tooltipValueGetter: (p: any) => (statusFor(p)?.status === 'new-band' ? t('clg2.tipNewBand') : undefined),
+    tooltipValueGetter: (p: any) => {
+      const st = statusFor(p)?.status;
+      return st === 'new-band-mode' ? t('clg2.tipNewBandMode') : st === 'new-band' ? t('clg2.tipNewBand') : undefined;
+    },
   },
   {
     group: 'Spot', label: t('clg2.c.mode'), colId: 'mode',
@@ -341,14 +367,18 @@ const makeColCatalog = (t: TFn): ColEntry[] => [
     defaultVisible: true,
     cellClass: 'font-mono',
     valueGetter: (p: any) => p.data ? inferSpotMode(p.data.comment ?? '', p.data.freq_hz) : '',
-    // Only NEW MODE pills the mode cell — there the mode itself is genuinely new
+    // NEW MODE and NEW BAND+MODE pill the mode cell — in both the mode itself is
-    // for the entity. NEW SLOT means band AND mode were each worked before (just
+    // genuinely new for the entity. NEW SLOT means band AND mode were each worked
-    // not together), so highlighting the mode cell would wrongly imply "CW is new";
+    // before (just not together), so highlighting the mode cell would wrongly
-    // that case is signalled by the Status badge alone.
+    // imply "CW is new"; that case is signalled by the Status badge alone.
-    cellStyle: (p: any) => (statusFor(p)?.status === 'new-mode' ? fillStyle('var(--caution)') : null) as any,
+    cellStyle: (p: any) => {
+      const st = statusFor(p)?.status;
+      return (st === 'new-mode' || st === 'new-band-mode' ? fillStyle('var(--caution)') : null) as any;
+    },
     cellRenderer: (p: any) => cellText(p.value, null),
     tooltipValueGetter: (p: any) => {
       const st = statusFor(p)?.status;
+      if (st === 'new-band-mode') return t('clg2.tipNewBandMode');
       if (st === 'new-mode') return t('clg2.tipNewMode');
       if (st === 'new-slot') return t('clg2.tipNewSlot');
       return undefined;
@@ -476,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);
@@ -558,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);
   }
 
@@ -612,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}
@@ -623,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}>
@@ -638,6 +720,17 @@ export function ClusterGrid({ rows, spotStatus, onSpotClick }: Props) {
               {t('clg2.pickerDesc')}
             </DialogDescription>
           </DialogHeader>
+          {/* Whole-dialog controls. showAll/hideAll with no group already mean
+              "every column"; only the buttons were missing, so hiding the lot
+              took one click per group. */}
+          <div className="flex items-center gap-1 px-1 text-[11px] text-muted-foreground">
+            <span>{t('clg2.allGroups')}</span>
+            <button type="button" className="text-[11px] text-primary hover:underline px-1"
+              onClick={() => showAll()}>{t('clg2.all')}</button>
+            <span className="opacity-40">·</span>
+            <button type="button" className="text-[11px] text-muted-foreground hover:underline px-1"
+              onClick={() => hideAll()}>{t('clg2.none')}</button>
+          </div>
           <div className="max-h-[60vh] overflow-y-auto py-2">
             {GROUP_ORDER.map((group) => {
               const cols = COL_CATALOG.filter((c) => c.group === group);

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

@@ -86,6 +86,13 @@ export function ExportFieldsDialog({ open, count, onExport, onClose }: {
     return [...m.entries()];
   }, [official]);
 
+  // Every tag the dialog can offer — the extras AND every group — so "select
+  // all" means what it says rather than "all the official ones".
+  const everyTag = useMemo(
+    () => [...extras, ...groups.flatMap(([, list]) => list.map((d) => d.name))],
+    [extras, groups],
+  );
+
   const toggle = (name: string, on: boolean) =>
     setSel((s) => { const n = new Set(s); if (on) n.add(name); else n.delete(name); return n; });
   const setMany = (names: string[], on: boolean) =>
@@ -114,11 +121,25 @@ export function ExportFieldsDialog({ open, count, onExport, onClose }: {
           <DialogDescription>{t('exf.desc')}</DialogDescription>
         </DialogHeader>
 
+        {/* Whole-dialog select/clear, next to the count they change. Per-group
+            links alone meant clearing the selection was one click PER GROUP —
+            a dozen of them to get to "just the handful I want". */}
         <div className="flex items-center gap-2 px-1 text-[11px] text-muted-foreground">
           <span>{t('exf.chosen', { n: sel.size })}</span>
-          <Button variant="ghost" size="sm" className="ml-auto h-6 text-[11px]" onClick={() => setSel(defaultSet(official))}>
+          <span className="ml-auto inline-flex items-center gap-1">
+            <Button variant="ghost" size="sm" className="h-6 text-[11px]"
+              onClick={() => setSel(new Set(everyTag))}>
+              {t('exf.selectAll')}
+            </Button>
+            <Button variant="ghost" size="sm" className="h-6 text-[11px]"
+              disabled={sel.size === 0}
+              onClick={() => setSel(new Set())}>
+              {t('exf.selectNone')}
+            </Button>
+            <Button variant="ghost" size="sm" className="h-6 text-[11px]" onClick={() => setSel(defaultSet(official))}>
               {t('exf.defaults')}
             </Button>
+          </span>
         </div>
 
         <div className="grid grid-cols-3 gap-3 max-h-[56vh] overflow-y-auto pr-1">

frontend/src/components/FilterBuilder.tsx

@@ -1,4 +1,4 @@
-import { useEffect, useMemo, useState } from 'react';
+import { useEffect, useMemo, useRef, useState } from 'react';
 import { Plus, Trash2, Save, FolderOpen, X } from 'lucide-react';
 import { writeUiPref } from '@/lib/uiPref';
 import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter } from '@/components/ui/dialog';
@@ -33,6 +33,8 @@ type FieldType = 'text' | 'number' | 'date' | 'adifdate';
 const FIELDS: { value: string; label: string; type: FieldType }[] = [
   { value: 'callsign', label: 'fltb.fCallsign', type: 'text' },
   { value: 'qso_date', label: 'fltb.fDate', type: 'date' },
+  // When the record entered the logbook — the way to isolate what an import added.
+  { value: 'created_at', label: 'fltb.fCreated', type: 'date' },
   { value: 'qso_date_off', label: 'fltb.fEndDate', type: 'date' },
   { value: 'band', label: 'fltb.fBand', type: 'text' },
   { value: 'band_rx', label: 'fltb.fRxBand', type: 'text' },
@@ -86,6 +88,12 @@ const FIELDS: { value: string; label: string; type: FieldType }[] = [
   { value: 'clublog_qso_upload_date', label: 'fltb.fClublogSentDate', type: 'adifdate' },
   { value: 'hrdlog_qso_upload_status', label: 'fltb.fHrdlogSent', type: 'text' },
   { value: 'hrdlog_qso_upload_date', label: 'fltb.fHrdlogSentDate', type: 'adifdate' },
+  // HAMLOG.online: no promoted column, filtered through extras_json (see
+  // qso.filterableExtras).
+  { value: 'hamlog_sent', label: 'fltb.fHamlogSent', type: 'text' },
+  { value: 'hamlog_sent_date', label: 'fltb.fHamlogSentDate', type: 'adifdate' },
+  { value: 'hamlog_rcvd', label: 'fltb.fHamlogRcvd', type: 'text' },
+  { value: 'hamlog_rcvd_date', label: 'fltb.fHamlogRcvdDate', type: 'adifdate' },
   { value: 'contest_id', label: 'fltb.fContestId', type: 'text' },
   { value: 'srx', label: 'fltb.fSerialRcvd', type: 'number' },
   { value: 'stx', label: 'fltb.fSerialSent', type: 'number' },
@@ -192,6 +200,17 @@ export function FilterBuilder({ open, initial, onApply, onClose }: Props) {
 
   function apply() { onApply(buildFilter()); }
 
+  // Same silence as the alert rules: the preset landed in the list, but the list
+  // is not where the operator is looking when they press Save.
+  const [savedMsg, setSavedMsg] = useState('');
+  const savedTimer = useRef(0);
+  function flashSaved(text: string) {
+    setSavedMsg(text);
+    window.clearTimeout(savedTimer.current);
+    savedTimer.current = window.setTimeout(() => setSavedMsg(''), 3000);
+  }
+  useEffect(() => () => window.clearTimeout(savedTimer.current), []);
+
   function saveCurrentPreset() {
     const name = presetName.trim();
     if (!name) return;
@@ -199,6 +218,7 @@ export function FilterBuilder({ open, initial, onApply, onClose }: Props) {
     savePresets(next);
     setPresets(next);
     setPresetName('');
+    flashSaved(t('fltb.presetSaved', { name }));
   }
   function loadPreset(name: string) {
     const f = presets[name];
@@ -335,6 +355,7 @@ export function FilterBuilder({ open, initial, onApply, onClose }: Props) {
           <Button variant="outline" size="sm" className="h-8" disabled={!presetName.trim()} onClick={saveCurrentPreset}>
             <Save className="size-3.5 mr-1" /> {t('fltb.savePreset')}
           </Button>
+          {savedMsg && <span className="text-[11px] text-success truncate">{savedMsg}</span>}
         </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/GridSquareMap.tsx

@@ -0,0 +1,308 @@
+import { useEffect, useMemo, useRef, useState } from 'react';
+import L from 'leaflet';
+import 'leaflet/dist/leaflet.css';
+import { Loader2, RefreshCw } from 'lucide-react';
+import { GridSquares } from '../../wailsjs/go/main/App';
+import { gridSquareBounds, gridToLatLon } from '@/lib/maidenhead';
+import { useI18n } from '@/lib/i18n';
+import { cn } from '@/lib/utils';
+import { BASEMAPS, addBasemap, loadBasemap, type BasemapKey } from '@/components/MainMap';
+import { writeUiPref } from '@/lib/uiPref';
+
+// GridSquareMap — every Maidenhead square in the log, drawn on a world map.
+//
+// A square, not a marker. The question this answers is "where have I been
+// heard", and the shape of the answer is an area: a wall of squares across the
+// Atlantic and a bare Pacific says something about an antenna that a scatter of
+// pins does not. Confirmed and merely worked are two fills of the same hue —
+// the distinction is a STATE of one thing, not two categories, so it must not
+// be two unrelated colours.
+//
+// 4 characters, never 6: at world zoom a 6-character square is sub-pixel, and
+// aggregating to the big square is also how the count means "contacts in this
+// square" rather than "contacts at this exact spot".
+
+type Square = { grid: string; count: number; confirmed: boolean; band?: string; mode?: string };
+
+// The SAME basemaps the Main-tab world map offers, imported rather than copied:
+// two lists of tile servers is how one map ends up on a provider the other has
+// already been blocked by. This map opened on a hardcoded dark Carto, which is
+// the least legible of the four under translucent squares.
+
+// Leaflet geometry is painted onto a CANVAS, and canvas takes a colour, not a
+// stylesheet: "var(--success)" handed to fillStyle is simply invalid and the
+// shape is silently not drawn — a map with a correct square count and nothing
+// on it. So the token is RESOLVED to its literal value here, once per theme,
+// which is also why every other map in this app passes hex.
+// The Earth, in the projection's own terms. Latitude stops at ±85.0511 because
+// that is where Web Mercator does.
+const WORLD_BOUNDS = L.latLngBounds(L.latLng(-85.0511, -180), L.latLng(85.0511, 180));
+
+function cssColour(token: string, fallback: string): string {
+  try {
+    const v = getComputedStyle(document.documentElement).getPropertyValue(token).trim();
+    return v || fallback;
+  } catch { return fallback; }
+}
+
+// Mode scope. The names come straight from the backend's own classes ("ALL",
+// "PHONE", "CW", "DIGI") plus FTX, which is narrower than digital and usually
+// the honest one beside an FTx panel — a square worked on RTTY in a contest is
+// not a square worked on FT8.
+const SCOPES = [
+  { key: 'ALL', label: 'gsm.all' },
+  { key: 'PHONE', label: 'gsm.phone' },
+  { key: 'CW', label: 'gsm.cw' },
+  { key: 'DIGI', label: 'gsm.digital' },
+  { key: 'FTX', label: 'gsm.ftx' },
+] as const;
+type ScopeKey = typeof SCOPES[number]['key'];
+
+const SCOPE_KEY = 'opslog.gridMapScope';
+// Chosen fill colours. Empty means "follow the theme", which is the default and
+// stays the default: the tokens already track the four themes, and freezing a
+// hex at first run would leave a dark-theme map painted in the light palette.
+const COL_CONFIRMED_KEY = 'opslog.gridMapColorConfirmed';
+const COL_WORKED_KEY = 'opslog.gridMapColorWorked';
+
+// A colour input only accepts #rrggbb. The theme tokens ARE plain hex today, so
+// this normally just passes them through — but a token that ever becomes oklch()
+// or a named colour would silently drive the swatch to black, and a fallback is
+// cheaper than that debugging session.
+function asHex(v: string, fallback: string): string {
+  return /^#[0-9a-f]{6}$/i.test(v.trim()) ? v.trim() : fallback;
+}
+
+export function GridSquareMap({ myGrid, className }: { myGrid?: string; className?: string }) {
+  const { t } = useI18n();
+  const hostRef = useRef<HTMLDivElement>(null);
+  const mapRef = useRef<L.Map | null>(null);
+  const layerRef = useRef<L.LayerGroup | null>(null);
+  const [squares, setSquares] = useState<Square[] | null>(null);
+  const [busy, setBusy] = useState(false);
+  const [err, setErr] = useState('');
+  const [scope, setScope] = useState<ScopeKey>(
+    () => (SCOPES.some((s) => s.key === localStorage.getItem(SCOPE_KEY))
+      ? (localStorage.getItem(SCOPE_KEY) as ScopeKey) : 'DIGI'));
+
+  const [basemap, setBasemap] = useState<BasemapKey>(loadBasemap);
+  const [confColour, setConfColour] = useState(() => localStorage.getItem(COL_CONFIRMED_KEY) ?? '');
+  const [workedColour, setWorkedColour] = useState(() => localStorage.getItem(COL_WORKED_KEY) ?? '');
+  // Repaint the squares when the THEME changes, not the basemap: the fills come
+  // from theme tokens resolved at draw time, so a theme switch leaves them on
+  // the old palette until something forces a redraw.
+  const [themeTick, setThemeTick] = useState(0);
+  useEffect(() => {
+    const obs = new MutationObserver(() => setThemeTick((n) => n + 1));
+    obs.observe(document.documentElement, { attributes: true, attributeFilter: ['data-theme'] });
+    return () => obs.disconnect();
+  }, []);
+
+  const load = async (sc: ScopeKey = scope) => {
+    setBusy(true); setErr('');
+    try {
+      const r = (await GridSquares(sc)) as any;
+      setSquares((Array.isArray(r) ? r : []) as Square[]);
+    } catch (e: any) {
+      setErr(String(e?.message ?? e));
+      setSquares([]);
+    } finally { setBusy(false); }
+  };
+  useEffect(() => { void load(scope); /* eslint-disable-next-line react-hooks/exhaustive-deps */ }, [scope]);
+
+  // One-time map creation. preferCanvas: a busy digital log is a few thousand
+  // rectangles, and as SVG that is a few thousand DOM nodes to lay out on every
+  // pan.
+  useEffect(() => {
+    if (!hostRef.current || mapRef.current) return;
+    const m = L.map(hostRef.current, {
+      preferCanvas: true,
+      zoomControl: true,
+      attributionControl: true,
+      // ONE world, not a row of them. worldCopyJump exists to make a path look
+      // continuous across the date line; here it only meant the same continent
+      // appeared two or three times, each carrying the same squares.
+      worldCopyJump: false,
+      // Zoom 0 is the whole planet in 256 pixels — the level at which Greenland
+      // and Antarctica are both on screen. The old floor of 1 made that
+      // impossible on any window wider than it is tall: one step out was already
+      // too far in.
+      minZoom: 0,
+      maxBoundsViscosity: 1, // don't let a drag slide the world off to one side
+    }).setView([20, 0], 2);
+    // The whole world, once, whatever the window is shaped like — computed by
+    // Leaflet from the container rather than guessed with a zoom number.
+    m.fitWorld({ animate: false });
+    // Latitude only: the poles are the edge of the projection and there is
+    // nothing beyond them, while leaving longitude free keeps a drag from
+    // fighting the operator near the date line.
+    m.setMaxBounds(L.latLngBounds(L.latLng(-85, -Infinity), L.latLng(85, Infinity)));
+    mapRef.current = m;
+    layerRef.current = L.layerGroup().addTo(m);
+    // Leaflet measures its container ONCE, when the map is created, and never
+    // looks again. Here that measurement happens while the panel is still
+    // laying out — so the map kept the height it had at that instant and the
+    // rest of the panel stayed blank underneath it, whatever the window size.
+    // Watching the host is the only fix that also survives a window resize, a
+    // split-pane drag and the tab being shown for the first time.
+    // fitWorld above ran against a container that may still have had no size —
+    // the tab is mounted hidden. Fit ONCE more the first time it really has one,
+    // and never again: after that the view belongs to the operator.
+    let fitted = false;
+    const ro = new ResizeObserver(() => {
+      m.invalidateSize({ animate: false });
+      const el = hostRef.current;
+      if (!fitted && el && el.clientWidth > 0 && el.clientHeight > 0) {
+        fitted = true;
+        m.fitWorld({ animate: false });
+      }
+    });
+    ro.observe(hostRef.current);
+    return () => { ro.disconnect(); m.remove(); mapRef.current = null; layerRef.current = null; };
+  }, []);
+
+  // The chosen basemap, shared with the Main-tab map so picking one there and
+  // finding another here cannot happen.
+  const baseRef = useRef<L.TileLayer | null>(null);
+  const labelsRef = useRef<L.TileLayer | null>(null);
+  useEffect(() => {
+    const m = mapRef.current;
+    if (!m) return;
+    // noWrap stops the world REPEATING; bounds stops Leaflet asking for the
+    // empty columns either side of it. What is left beside the planet is then
+    // the panel's own background rather than a wall of grey apologies.
+    addBasemap(m, basemap, baseRef, labelsRef, { noWrap: true, bounds: WORLD_BOUNDS });
+    baseRef.current?.bringToBack();
+  }, [basemap]);
+
+  // Redraw the squares.
+  useEffect(() => {
+    const layer = layerRef.current;
+    if (!layer) return;
+    layer.clearLayers();
+    // Resolved once for the whole redraw, not per square: getComputedStyle
+    // forces a style flush, and doing that a thousand times is a visible stall.
+    const confirmedColour = confColour || cssColour('--success', '#16a34a');
+    const workedFill = workedColour || cssColour('--chart-1', '#2a78d6');
+    const meColour = cssColour('--warning', '#f59e0b');
+    for (const sq of squares ?? []) {
+      const b = gridSquareBounds(sq.grid);
+      if (!b) continue;
+      // One hue, two states. Confirmed is the solid, saturated one; worked is
+      // the same colour held back — so the eye reads "more" and "less" of the
+      // same thing rather than two unrelated facts.
+      const colour = sq.confirmed ? confirmedColour : workedFill;
+      L.rectangle([[b.south, b.west], [b.north, b.east]], {
+        color: colour,
+        weight: 0.5,
+        opacity: sq.confirmed ? 0.9 : 0.5,
+        fillColor: colour,
+        fillOpacity: sq.confirmed ? 0.55 : 0.22,
+      })
+        .bindTooltip(
+          `${sq.grid} — ${sq.count} QSO${sq.count > 1 ? 's' : ''}` +
+          `${sq.band ? ` · ${sq.band}` : ''}${sq.mode ? ` ${sq.mode}` : ''}` +
+          `${sq.confirmed ? ` · ${t('gsm.confirmed')}` : ''}`,
+          { sticky: true },
+        )
+        .addTo(layer);
+    }
+    // The operator's own square, so the pattern has an origin to be read from.
+    const me = myGrid ? gridToLatLon(myGrid) : null;
+    if (me) {
+      L.circleMarker([me.lat, me.lon], {
+        radius: 4, color: meColour, weight: 2,
+        fillColor: meColour, fillOpacity: 1,
+      }).bindTooltip(myGrid!.toUpperCase(), { sticky: true }).addTo(layer);
+    }
+  }, [squares, myGrid, t, themeTick, confColour, workedColour]);
+
+  const stats = useMemo(() => {
+    const list = squares ?? [];
+    return { total: list.length, confirmed: list.filter((s) => s.confirmed).length };
+  }, [squares]);
+
+  return (
+    // isolate is load-bearing, not tidiness. Leaflet puts its panes at z-index
+    // 400 and its zoom control at 1000, in the PAGE's stacking context — and the
+    // modals here are z-50. Without a stacking context of its own the map floats
+    // over Preferences and hides the Save and Close buttons. isolation:isolate
+    // confines every z-index Leaflet sets to this element.
+    <section className={cn('isolate relative flex flex-col min-h-0 rounded-lg border border-border bg-card overflow-hidden', className)}>
+      <header className="flex items-center gap-2 px-2.5 py-1.5 border-b border-border bg-muted/40 shrink-0 flex-wrap">
+        <span className="text-xs font-semibold uppercase tracking-wider text-muted-foreground">
+          {t('gsm.title')}
+        </span>
+        <div className="inline-flex rounded-md border border-border overflow-hidden">
+          {SCOPES.map((s, i) => (
+            <button key={s.key} type="button"
+              onClick={() => { setScope(s.key); try { localStorage.setItem(SCOPE_KEY, s.key); } catch { /* quota */ } }}
+              className={cn('px-1.5 h-6 text-[11px] whitespace-nowrap', i > 0 && 'border-l border-border',
+                scope === s.key ? 'bg-primary text-primary-foreground' : 'hover:bg-muted text-muted-foreground')}>
+              {t(s.label)}
+            </button>
+          ))}
+        </div>
+        <span className="text-[11px] text-muted-foreground tabular-nums">
+          {t('gsm.count', { n: stats.total, c: stats.confirmed })}
+        </span>
+        <select
+          value={basemap}
+          onChange={(e) => { const v = e.target.value as BasemapKey; setBasemap(v); writeUiPref('opslog.mapBasemap', v); }}
+          title={t('gsm.basemap')}
+          className="h-6 rounded border border-border bg-background px-1 text-[11px]"
+        >
+          {(Object.keys(BASEMAPS) as BasemapKey[]).map((k) => (
+            <option key={k} value={k}>{BASEMAPS[k].label}</option>
+          ))}
+        </select>
+        {/* Beside the basemap, because they answer the same question: what this
+            map looks like. Written straight through — there is no Save here. */}
+        <label className="inline-flex items-center gap-1 text-[11px] text-muted-foreground" title={t('gsm.colConfirmed')}>
+          <input type="color" className="size-5 rounded border border-border bg-transparent p-0 cursor-pointer"
+            value={asHex(confColour || cssColour('--success', '#16a34a'), '#16a34a')}
+            onChange={(e) => { setConfColour(e.target.value); writeUiPref(COL_CONFIRMED_KEY, e.target.value); }} />
+          {t('gsm.confirmed')}
+        </label>
+        <label className="inline-flex items-center gap-1 text-[11px] text-muted-foreground" title={t('gsm.colWorked')}>
+          <input type="color" className="size-5 rounded border border-border bg-transparent p-0 cursor-pointer"
+            value={asHex(workedColour || cssColour('--chart-1', '#2a78d6'), '#2a78d6')}
+            onChange={(e) => { setWorkedColour(e.target.value); writeUiPref(COL_WORKED_KEY, e.target.value); }} />
+          {t('gsm.worked')}
+        </label>
+        {(confColour || workedColour) && (
+          <button type="button" title={t('gsm.colReset')}
+            onClick={() => {
+              setConfColour(''); setWorkedColour('');
+              writeUiPref(COL_CONFIRMED_KEY, ''); writeUiPref(COL_WORKED_KEY, '');
+            }}
+            className="text-[11px] text-muted-foreground hover:text-foreground px-1">↺</button>
+        )}
+        <span className="flex-1" />
+        <button type="button" onClick={() => void load()} disabled={busy} title={t('gsm.refresh')}
+          className="inline-flex items-center justify-center size-6 rounded border border-border hover:bg-muted disabled:opacity-50">
+          {busy ? <Loader2 className="size-3 animate-spin" /> : <RefreshCw className="size-3" />}
+        </button>
+      </header>
+      {err && <p className="px-2.5 py-1 text-[11px] text-destructive shrink-0">{err}</p>}
+      {/* The map host must have a real height or Leaflet renders nothing at all
+          — flex-1 + min-h-0, never a percentage. */}
+      {/* The ground beside the planet is the panel's own background: Leaflet
+          paints its container, and left to its default that surround was a
+          bright white slab against a dark theme. */}
+      <div ref={hostRef} className="flex-1 min-h-0 bg-card" />
+      <footer className="flex items-center gap-3 px-2.5 py-1 border-t border-border bg-muted/30 shrink-0 text-[10px] text-muted-foreground">
+        <span className="inline-flex items-center gap-1.5">
+          <span className="inline-block size-2.5 rounded-[2px]"
+            style={{ background: confColour || 'var(--success)', opacity: 0.75 }} />
+          {t('gsm.confirmed')}
+        </span>
+        <span className="inline-flex items-center gap-1.5">
+          <span className="inline-block size-2.5 rounded-[2px]"
+            style={{ background: workedColour || 'var(--chart-1)', opacity: 0.35 }} />
+          {t('gsm.worked')}
+        </span>
+      </footer>
+    </section>
+  );
+}

frontend/src/components/MainMap.tsx

@@ -61,8 +61,8 @@ const ESRI_STREET_ATTR = 'Tiles © Esri — Source: Esri, HERE, Garmin, &cop
 // Selectable basemaps for the world (great-circle) map. All key-free and all
 // LABELLED (country/continent names). `labelsUrl` adds a transparent place-name
 // overlay on top of an imagery basemap (so satellite keeps its names too).
-type BasemapKey = 'light' | 'voyager' | 'street' | 'satellite';
+export type BasemapKey = 'light' | 'voyager' | 'street' | 'satellite';
-const BASEMAPS: Record<BasemapKey, { label: string; url: string; attr: string; subdomains?: string; labelsUrl?: string }> = {
+export const BASEMAPS: Record<BasemapKey, { label: string; url: string; attr: string; subdomains?: string; labelsUrl?: string }> = {
   light:     { label: 'Light',     url: CARTO_LIGHT, attr: CARTO_ATTR, subdomains: 'abcd' },
   voyager:   { label: 'Voyager',   url: 'https://{s}.basemaps.cartocdn.com/rastertiles/voyager/{z}/{x}/{y}{r}.png',
                attr: CARTO_ATTR, subdomains: 'abcd' },
@@ -71,7 +71,7 @@ const BASEMAPS: Record<BasemapKey, { label: string; url: string; attr: string; s
                attr: 'Tiles &copy; Esri — Source: Esri, Maxar, Earthstar Geographics',
                labelsUrl: 'https://server.arcgisonline.com/ArcGIS/rest/services/Reference/World_Boundaries_and_Places/MapServer/tile/{z}/{y}/{x}' },
 };
-function loadBasemap(): BasemapKey {
+export function loadBasemap(): BasemapKey {
   const v = localStorage.getItem('opslog.mapBasemap');
   return v === 'voyager' || v === 'street' || v === 'satellite' ? v : 'light';
 }
@@ -80,18 +80,32 @@ function loadBasemap(): BasemapKey {
 // place-name overlay. updateWhenIdle/keepBuffer keep the number of live tiles
 // down: satellite loads TWO tile layers, so its tile count — and the composited
 // layers WebView2 has to hold — is double every other basemap's.
-function addBasemap(
+export function addBasemap(
   m: L.Map,
   key: BasemapKey,
   base: React.MutableRefObject<L.TileLayer | null>,
   labels: React.MutableRefObject<L.TileLayer | null>,
+  // noWrap draws the world ONCE instead of repeating it east and west.
+  //
+  // The great-circle map wants the repeats: a path from France to Japan reads
+  // better crossing a second copy of Asia than wrapping round the back. A map of
+  // where you have been heard does not — three North Americas is three times the
+  // same answer, and it makes the picture harder to read, not wider.
+  // bounds stops Leaflet asking for tiles outside the world at all: Esri answers
+  // those with a grey "Map data not yet available" image, and zoomed out on a
+  // wide window that is most of the screen.
+  opts?: { noWrap?: boolean; bounds?: L.LatLngBoundsExpression },
 ) {
   if (base.current) { m.removeLayer(base.current); base.current = null; }
   if (labels.current) { m.removeLayer(labels.current); labels.current = null; }
   const bm = BASEMAPS[key];
-  const opts: L.TileLayerOptions = { maxZoom: 19, updateWhenIdle: true, updateWhenZooming: false, keepBuffer: 1 };
+  const tileOpts: L.TileLayerOptions = {
-  base.current = L.tileLayer(bm.url, { ...opts, attribution: bm.attr, subdomains: bm.subdomains ?? 'abc' }).addTo(m);
+    maxZoom: 19, updateWhenIdle: true, updateWhenZooming: false, keepBuffer: 1,
-  if (bm.labelsUrl) labels.current = L.tileLayer(bm.labelsUrl, opts).addTo(m);
+    noWrap: !!opts?.noWrap,
+    ...(opts?.bounds ? { bounds: opts.bounds } : {}),
+  };
+  base.current = L.tileLayer(bm.url, { ...tileOpts, attribution: bm.attr, subdomains: bm.subdomains ?? 'abc' }).addTo(m);
+  if (bm.labelsUrl) labels.current = L.tileLayer(bm.labelsUrl, tileOpts).addTo(m);
 }
 
 function dot(color: string): L.DivIcon {
@@ -352,7 +366,10 @@ export function WorldMap({ fromGrid, toGrid, fromLabel, toLabel, beamAzimuths, b
     <div className="relative isolate h-full w-full rounded-lg overflow-hidden border border-border">
       <div ref={worldRef} className="absolute inset-0" />
       {/* Basemap picker — Light / Street / Satellite (key-free tiles). */}
-      <div className="absolute top-1 left-12 z-[500] flex rounded-md overflow-hidden shadow border border-border backdrop-blur">
+      {/* Clear of the zoom buttons, not merely next to them: at left-12 the
+          first basemap sat a few pixels from the − button and operators kept
+          hitting Light when they meant to zoom out. */}
+      <div className="absolute top-1 left-[4.5rem] z-[500] flex rounded-md overflow-hidden shadow border border-border backdrop-blur">
         {(Object.keys(BASEMAPS) as BasemapKey[]).map((k) => (
           <button
             key={k}

frontend/src/components/MotorAntennaWidget.tsx

@@ -0,0 +1,298 @@
+// MotorAntennaWidget — the Ultrabeam / SteppIR control, in one place.
+//
+// Lives in its own file because it is shown in TWO: the Station Control tab and
+// the dock beside the entry strip. Two copies of a control that keys hardware is
+// how one of them quietly stops matching the other — a pattern button that sets
+// a different direction, a band list that tunes somewhere else.
+import { useCallback, useEffect, useState } from 'react';
+import { ArrowDownToLine, ChevronDown, ChevronUp, Loader2, Minus, Plus, RefreshCw, Antenna as AntennaIcon, X } from 'lucide-react';
+import { cn } from '@/lib/utils';
+import {
+  SetUltrabeamDirection, UltrabeamRetract, MotorSetElement, MotorReadElements,
+  MotorTuneKHz, MotorNudgeKHz, SetMotorFollow,
+} from '../../wailsjs/go/main/App';
+
+export type AntStatus = { enabled: boolean; type: string; connected: boolean; direction: number; frequency: number; moving: boolean; elements: number[]; follow?: boolean; step_khz?: number; track_mode?: string; bands?: string[]; band_freqs?: Record<string, number> };
+
+// Where each band button points the antenna.
+//
+// Not the arithmetic centre of the band. An antenna is tuned for where people
+// actually work: 20 m centres on 14175 but nobody lives there, and 10 m spans
+// 1.7 MHz of which the top half is empty. These are the points that leave the
+// elements closest to right for the whole band, and one nudge away from the rest.
+const ANT_BAND_KHZ: Record<string, number> = {
+  '40m': 7100, '30m': 10125, '20m': 14150, '17m': 18110,
+  '15m': 21150, '12m': 24930, '10m': 28400, '6m': 50150,
+};
+
+// NUDGE_KHZ is the up/down step. 25 kHz because that is also the finest tracking
+// threshold: a nudge smaller than the tracking step would be undone by the next
+// poll while tracking is on.
+const NUDGE_KHZ = 25;
+
+// bandOfKHz names the band a frequency sits in, so a band button can light up
+// when the ANTENNA is already there. Deliberately generous at the edges: the
+// antenna's reported frequency is where it was commanded, which can sit slightly
+// outside the allocation.
+function bandOfKHz(khz: number): string {
+  const edges: [number, number, string][] = [
+    [6900, 7300, '40m'], [10050, 10200, '30m'], [13900, 14400, '20m'],
+    [18000, 18200, '17m'], [20900, 21500, '15m'], [24800, 25000, '12m'],
+    [27900, 29800, '10m'], [49900, 50600, '6m'],
+  ];
+  for (const [lo, hi, b] of edges) if (khz >= lo && khz <= hi) return b;
+  return '';
+}
+
+// MotorAntennaWidget controls a motorized antenna (Ultrabeam / SteppIR) from the
+// Station Control tab: pattern (Normal / 180° / Bi), Retract, and — Ultrabeam
+// only — per-element length adjustment. Heading/state is polled by the panel.
+const ELEMENT_STEP = 2; // the physical console adjusts 2 mm per press
+
+// elementName maps an element index to a ham-radio name: 0 = reflector,
+// 1 = driven element, then Director 1, 2, 3…
+function elementName(i: number, t: (k: string, v?: any) => string): string {
+  if (i === 0) return t('station.reflector');
+  if (i === 1) return t('station.driven');
+  return `${t('station.director')} ${i - 1}`;
+}
+
+export function MotorAntennaWidget({ ant, refetch, t, onClose, essentialsOnly }: {
+  ant: AntStatus;
+  refetch: () => void;
+  t: (k: string, v?: any) => string;
+  // onClose adds the dock's close button. The Station Control tab passes none:
+  // there the widget is a tile in a grid, and a tile that closes itself would
+  // leave a hole the operator cannot fill back in.
+  onClose?: () => void;
+  // essentialsOnly drops what an operator sets once and then leaves alone:
+  // tracking with its mode and step, and the per-element lengths. They belong in
+  // Station Control, where there is room to think; in the dock they are height
+  // spent on controls nobody touches between contacts, pushing the ones they do
+  // touch — pattern, bands, nudge — off the bottom.
+  essentialsOnly?: boolean;
+}) {
+  const [err, setErr] = useState('');
+  const [lengths, setLengths] = useState<number[]>([]); // current element lengths (mm), from ReadElements
+  const [reading, setReading] = useState(false);
+  const [busyEl, setBusyEl] = useState<number | null>(null);
+  const [editingEl, setEditingEl] = useState<number | null>(null); // element whose mm is being typed
+  const [editVal, setEditVal] = useState('');
+  const run = (p: Promise<any>) => p.then(refetch).catch((e) => setErr(String(e?.message ?? e)));
+  const isUB = ant.type !== 'steppir';
+
+  const readLengths = useCallback(async () => {
+    setReading(true); setErr('');
+    try { setLengths(((await MotorReadElements()) ?? []) as number[]); }
+    catch (e: any) { setErr(String(e?.message ?? e)); }
+    finally { setReading(false); }
+  }, []);
+  // Read the current lengths once when the Ultrabeam widget mounts/connects, so
+  // +/- starts from the real values rather than blind.
+  useEffect(() => { if (isUB && ant.connected) readLengths(); }, [isUB, ant.connected, readLengths]);
+
+  // Send an absolute length to one element and remember it as the new baseline.
+  const setLen = async (i: number, mm: number) => {
+    const next = Math.max(0, Math.round(mm));
+    const prev = lengths[i] ?? 0;
+    setBusyEl(i); setErr('');
+    setLengths((ls) => { const c = [...ls]; c[i] = next; return c; }); // optimistic
+    try { await MotorSetElement(i, next); refetch(); }
+    catch (e: any) {
+      // Rejected by the controller — most often the element is at its travel
+      // limit for this band (extending on a low band). Revert the optimistic
+      // value so the display stays truthful, and explain the likely cause when
+      // the failed move was an extension.
+      setLengths((ls) => { const c = [...ls]; c[i] = prev; return c; });
+      setErr(next > prev ? t('station.atMax') : String(e?.message ?? e));
+    }
+    finally { setBusyEl(null); }
+  };
+  // Nudge one element by ±2 mm from its current known length.
+  const nudge = (i: number, delta: number) => setLen(i, (lengths[i] ?? 0) + delta);
+  // Commit a typed exact length (click on the mm value). Lets the operator fix
+  // the baseline when the auto-read is off, so +/- then work reliably.
+  const commitEdit = (i: number) => {
+    const v = parseInt(editVal, 10);
+    setEditingEl(null);
+    if (!isNaN(v) && v >= 0 && v !== lengths[i]) setLen(i, v);
+  };
+  const dirs: [number, string][] = [[0, 'N'], [1, '180°'], [2, t('station.bi')]];
+  return (
+    <div className="rounded-xl border border-border bg-card shadow-sm overflow-hidden h-full flex flex-col min-h-0">
+      <div className="flex items-center gap-2 px-2 py-1.5 border-b border-border/60 bg-muted/30 shrink-0">
+        <AntennaIcon className="size-4 text-primary" />
+        <div className="min-w-0">
+          <div className="text-sm font-semibold truncate">{isUB ? 'Ultrabeam' : 'SteppIR'}</div>
+          {ant.frequency > 0 && <div className="text-[10px] text-muted-foreground font-mono">{(ant.frequency / 1000).toFixed(3)} MHz</div>}
+        </div>
+        {ant.moving && <span className="ml-auto text-[10px] font-semibold text-warning animate-pulse">{t('station.moving')}</span>}
+        <span className={cn('size-2 rounded-full shrink-0', ant.moving ? '' : 'ml-auto', ant.connected ? 'bg-success' : 'bg-muted-foreground/40')}
+          title={ant.connected ? t('station.online') : t('station.offline')} />
+        {onClose && (
+          <button type="button" onClick={onClose} title={t('station.hideWidget')}
+            className="text-muted-foreground hover:text-foreground shrink-0">
+            <X className="size-3.5" />
+          </button>
+        )}
+      </div>
+      <div className="p-2 space-y-2 flex-1 min-h-0 overflow-auto">
+        <div>
+          {/* No heading: N / 180° / Bi say what they are, and in a docked widget
+              a line of height costs more than the word explains. */}
+          <div className="flex gap-1">
+            {dirs.map(([d, lbl]) => (
+              <button key={d} type="button" disabled={!ant.connected}
+                onClick={() => run(SetUltrabeamDirection(d))}
+                className={cn('flex-1 rounded-md border py-1 text-xs font-semibold transition-colors disabled:opacity-40',
+                  ant.direction === d ? 'bg-primary text-primary-foreground border-primary' : 'border-border hover:bg-muted')}>
+                {lbl}
+              </button>
+            ))}
+          </div>
+        </div>
+        {/* Bands, then a nudge, then tracking — in the order an operator uses
+            them: get to the band, fine-tune inside it, decide whether the
+            antenna should follow the rig from here. */}
+        <div>
+          <div className="text-[10px] font-semibold uppercase tracking-wider text-muted-foreground mb-0.5">{t('station.bands')}</div>
+          <div className="grid grid-cols-5 gap-1">
+            {(ant.bands ?? []).map((b: string) => {
+              // Where this band tunes is resolved by the backend — the operator's
+              // per-band choice from Settings, or the default. ANT_BAND_KHZ is only
+              // the floor for a status poll that hasn't landed yet.
+              const khz = ant.band_freqs?.[b] || ANT_BAND_KHZ[b];
+              if (!khz) return null;
+              // "On this band" from the antenna's own frequency, not the rig's:
+              // the widget must show where the ANTENNA is, which is the whole
+              // reason for tuning it by hand.
+              const here = ant.frequency > 0 && bandOfKHz(ant.frequency) === b;
+              return (
+                <button key={b} type="button" disabled={!ant.connected}
+                  onClick={() => run(MotorTuneKHz(khz))}
+                  title={`${(khz / 1000).toFixed(3)} MHz`}
+                  className={cn('rounded-md border py-0.5 text-[11px] font-mono font-semibold transition-colors disabled:opacity-40',
+                    here ? 'bg-primary text-primary-foreground border-primary' : 'border-border hover:bg-muted')}>
+                  {b}
+                </button>
+              );
+            })}
+          </div>
+        </div>
+
+        <div className="flex items-center gap-1">
+          <button type="button" disabled={!ant.connected}
+            onClick={() => run(MotorNudgeKHz(-NUDGE_KHZ))}
+            title={t('station.nudgeDown', { n: NUDGE_KHZ })}
+            className="flex-1 flex items-center justify-center gap-1 rounded-md border border-border py-1 text-xs font-semibold hover:bg-muted disabled:opacity-40">
+            <ChevronDown className="size-3.5" /> {NUDGE_KHZ}
+          </button>
+          <button type="button" disabled={!ant.connected}
+            onClick={() => run(MotorNudgeKHz(NUDGE_KHZ))}
+            title={t('station.nudgeUp', { n: NUDGE_KHZ })}
+            className="flex-1 flex items-center justify-center gap-1 rounded-md border border-border py-1 text-xs font-semibold hover:bg-muted disabled:opacity-40">
+            <ChevronUp className="size-3.5" /> {NUDGE_KHZ}
+          </button>
+        </div>
+
+        {/* Tracking. Here rather than only in Settings because it is an operating
+            decision — off to park the antenna, on to resume — not something set
+            up once. Mode and step only show when tracking is on: settings for
+            something switched off are questions the operator cannot act on. And
+            the step only shows in step mode, where it is the one thing it means. */}
+        {!essentialsOnly && (
+        <div className="space-y-1.5">
+          <div className="flex items-center gap-2">
+            <button type="button"
+              onClick={() => run(SetMotorFollow(!ant.follow, 0, ''))}
+              className={cn('flex-1 rounded-md border py-1 text-xs font-semibold transition-colors',
+                ant.follow ? 'bg-success-muted text-success-muted-foreground border-success-border' : 'border-border hover:bg-muted')}>
+              {ant.follow ? t('station.trackOn') : t('station.trackOff')}
+            </button>
+            {ant.follow && (ant.track_mode || 'step') === 'step' && (
+              <select
+                value={String(ant.step_khz || 50)}
+                onChange={(e) => run(SetMotorFollow(true, parseInt(e.target.value, 10), ''))}
+                className="h-[30px] rounded-md border border-border bg-background px-1 text-xs font-mono"
+                title={t('station.trackStepTip')}
+              >
+                {[25, 50, 100].map((s) => <option key={s} value={s}>{s} kHz</option>)}
+              </select>
+            )}
+          </div>
+          {ant.follow && (
+            <select
+              value={ant.track_mode || 'step'}
+              onChange={(e) => run(SetMotorFollow(true, 0, e.target.value))}
+              className="w-full h-[30px] rounded-md border border-border bg-background px-1.5 text-xs"
+              title={t('station.trackModeTip')}
+            >
+              <option value="always" title={t('station.trackAlwaysTip')}>{t('station.trackAlways')}</option>
+              <option value="step" title={t('station.trackStepTipMode')}>{t('station.trackStep')}</option>
+              <option value="band" title={t('station.trackBandTip')}>{t('station.trackBand')}</option>
+            </select>
+          )}
+        </div>
+        )}
+
+        <button type="button" disabled={!ant.connected}
+          onClick={() => run(UltrabeamRetract())}
+          className="w-full flex items-center justify-center gap-1.5 rounded-md border border-warning-border bg-warning-muted text-warning-muted-foreground py-1 text-xs font-semibold hover:brightness-95 disabled:opacity-40">
+          <ArrowDownToLine className="size-3.5" /> {t('station.retract')}
+        </button>
+
+        {isUB && !essentialsOnly && (
+          <div>
+            <div className="flex items-center gap-2 mb-1.5">
+              <span className="text-[10px] font-semibold uppercase tracking-wider text-muted-foreground">{t('station.elements')}</span>
+              <button type="button" onClick={readLengths} disabled={!ant.connected || reading}
+                className="text-[10px] text-primary hover:underline inline-flex items-center gap-1 disabled:opacity-40" title={t('station.readLengths')}>
+                <RefreshCw className={cn('size-3', reading && 'animate-spin')} /> {t('station.read')}
+              </button>
+            </div>
+            {lengths.length === 0 ? (
+              <p className="text-[11px] text-muted-foreground">{t('station.noLengths')}</p>
+            ) : (
+              <div className="space-y-1.5">
+                {/* The READ_BANDS reply is undocumented and its 16-bit parse picks
+                    up structural bytes past the real data (varying by band), which
+                    made 6+ bogus "elements" appear. Ultrabeam beams are 3-element,
+                    and ModifyElement addresses elements 0..2 — so show just those. */}
+                {lengths.map((mm, i) => ({ mm, i })).slice(0, 3).map(({ mm, i }) => (
+                  <div key={i} className="flex items-center gap-2">
+                    <span className="text-xs w-20 shrink-0 text-muted-foreground truncate">{elementName(i, t)}</span>
+                    <button type="button" disabled={!ant.connected || busyEl !== null}
+                      onClick={() => nudge(i, -ELEMENT_STEP)}
+                      className="flex items-center justify-center size-7 rounded-md border border-border hover:bg-muted disabled:opacity-40 shrink-0">
+                      <Minus className="size-3.5" />
+                    </button>
+                    {editingEl === i ? (
+                      <input autoFocus type="number" value={editVal}
+                        onChange={(e) => setEditVal(e.target.value)}
+                        onBlur={() => commitEdit(i)}
+                        onKeyDown={(e) => { if (e.key === 'Enter') commitEdit(i); if (e.key === 'Escape') setEditingEl(null); }}
+                        className="text-sm font-mono font-bold flex-1 min-w-0 text-center tabular-nums bg-transparent border border-primary rounded px-1" />
+                    ) : (
+                      <span className="text-sm font-mono font-bold flex-1 min-w-0 text-center tabular-nums cursor-pointer hover:underline"
+                        title={t('station.setExactLen')}
+                        onClick={() => { setEditingEl(i); setEditVal(String(mm)); }}>
+                        {busyEl === i ? <Loader2 className="size-3.5 animate-spin inline" /> : `${mm} mm`}
+                      </span>
+                    )}
+                    <button type="button" disabled={!ant.connected || busyEl !== null}
+                      onClick={() => nudge(i, ELEMENT_STEP)}
+                      className="flex items-center justify-center size-7 rounded-md border border-border hover:bg-muted disabled:opacity-40 shrink-0">
+                      <Plus className="size-3.5" />
+                    </button>
+                  </div>
+                ))}
+              </div>
+            )}
+            <p className="text-[10px] text-muted-foreground mt-1">{t('station.elementsHint')}</p>
+          </div>
+        )}
+        {err && <div className="text-[11px] text-destructive break-words">{err}</div>}
+      </div>
+    </div>
+  );
+}

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, 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';
@@ -41,6 +41,7 @@ const SERVICES = [
   { v: 'hrdlog',  label: 'HRDLog.net' },
   { v: 'eqsl',    label: 'eQSL.cc' },
   { v: 'lotw',    label: 'LoTW' },
+  { v: 'hamlog',  label: 'HAMLOG.online' },
   { v: 'pota',    label: 'POTA hunter log' },
   { v: 'paper',   label: 'Paper QSL' },
 ];
@@ -111,7 +112,38 @@ export function fmtQslDate(s?: string): string {
 
 // QSL Manager as an in-app tab panel: upload logged QSOs to online logbooks
 // and download confirmations, while the rest of the app stays usable.
-export function QSLManagerPanel({ onEditQSO }: { onEditQSO?: (id: number) => void } = {}) {
+// GridActions are the row actions the context menu offers, forwarded straight to
+// whichever grid this panel is showing.
+//
+// The FILTERED exports are deliberately absent. "Export everything the filter
+// matches" means the Recent-QSOs filter, and the rows here come from a different
+// query entirely — offering it would export something other than what is on the
+// screen, which is the one thing an export must never do. Selection-based
+// exports have no such ambiguity: the ids are the rows you ticked.
+export type GridActions = {
+  onUpdateFromCty?: (ids: number[]) => void;
+  onUpdateFromQRZ?: (ids: number[]) => void;
+  onUpdateFromClublog?: (ids: number[]) => void;
+  onUpdateCountyFromULS?: (ids: number[]) => void;
+  onSendTo?: (service: string, ids: number[]) => void;
+  onSendRecording?: (ids: number[]) => void;
+  onSendEQSL?: (ids: number[]) => void;
+  onBulkEdit?: (ids: number[]) => void;
+  onExportSelected?: (ids: number[]) => void;
+  onExportSelectedFields?: (ids: number[]) => void;
+  onExportCabrilloSelected?: (ids: number[]) => void;
+  onDelete?: (ids: number[]) => void;
+};
+
+export function QSLManagerPanel({ onEditQSO, actions, paperRequest }: {
+  onEditQSO?: (id: number) => void;
+  actions?: GridActions;
+  // A callsign to open the Paper QSL view on, sent from elsewhere in the app
+  // (the awards grid). Carries a counter rather than being a bare string: the
+  // panel is force-mounted and keeps its state, so asking twice for the SAME
+  // callsign has to be two requests, not one unchanged prop.
+  paperRequest?: { call: string; n: number };
+} = {}) {
   const { t } = useI18n();
   const [service, setService] = useState('lotw');
   // The callsign this profile signs/uploads/downloads as for the selected
@@ -172,6 +204,27 @@ export function QSLManagerPanel({ onEditQSO }: { onEditQSO?: (id: number) => voi
   }, [paperCall]);
 
 
+  // Honour an incoming request: switch to Paper QSL, fill the callsign, search.
+  // The search runs from the effect below once paperCall has actually changed —
+  // searchPaper closes over paperCall, so calling it here would search the
+  // PREVIOUS callsign.
+  // The pending request's callsign, so the search fires for THAT callsign and
+  // for nothing else: the effect below also wakes on every keystroke in the
+  // field, and searching on each of them would query the log letter by letter.
+  const pendingPaperCall = useRef('');
+  useEffect(() => {
+    const call = paperRequest?.call?.trim().toUpperCase();
+    if (!call) return;
+    setService('paper');
+    setPaperCall(call);
+    pendingPaperCall.current = call;
+  }, [paperRequest?.call, paperRequest?.n]);
+  useEffect(() => {
+    if (!pendingPaperCall.current || paperCall !== pendingPaperCall.current) return;
+    pendingPaperCall.current = '';
+    searchPaper();
+  }, [paperCall, searchPaper]);
+
   async function applyPaper() {
     const ids = paperRows.filter((r) => paperSel.has(r.id)).map((r) => r.id);
     if (ids.length === 0) return;
@@ -297,6 +350,34 @@ export function QSLManagerPanel({ onEditQSO }: { onEditQSO?: (id: number) => voi
     catch (e: any) { setLogLines((p) => [...p, 'Error: ' + String(e?.message ?? e)]); setBusy(false); }
   }
 
+  // HAMLOG.online has no download verb — their agent protocol only uploads —
+  // so confirmations come back as an ADIF exported from their site. It is read
+  // here rather than through the ordinary ADIF import because that one matches
+  // on the UTC minute and INSERTS whatever fails to match: a few hundred copies
+  // of contacts already in the log. This path only ever stamps QSOs it finds.
+  async function importHamlogCfm() {
+    const path = await OpenADIFFile();
+    if (!path) return;
+    setLogLines([]); setBusy(true); setLogAction('download'); setShowLog(true);
+    try { await ImportHamlogConfirmations(path); }
+    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();
@@ -443,6 +524,8 @@ export function QSLManagerPanel({ onEditQSO }: { onEditQSO?: (id: number) => voi
                 total={paperRows.length}
                 selectAllSignal={paperSelAllSig}
                 onRowSelected={(ids) => setPaperSel(new Set(ids))}
+                {...actions}
+                onRowDoubleClicked={onEditQSO ? (q) => onEditQSO(q.id as number) : undefined}
               />
             </div>
           )
@@ -549,6 +632,8 @@ export function QSLManagerPanel({ onEditQSO }: { onEditQSO?: (id: number) => voi
               total={rows.length}
               selectAllSignal={uploadSelAllSig}
               onRowSelected={onUploadRowSelected}
+              {...actions}
+              onRowDoubleClicked={onEditQSO ? (q) => onEditQSO(q.id as number) : undefined}
             />
           </div>
         )}
@@ -609,11 +694,25 @@ export function QSLManagerPanel({ onEditQSO }: { onEditQSO?: (id: number) => voi
       {service !== 'pota' && service !== 'paper' && (
       <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')}>
             <DownloadCloud className="size-3.5" /> {t('qslm.downloadConf')}
           </Button>
+          )}
           {/* Date window */}
+          {service !== 'hamlog' && (<>
           <Select value={sinceMode} onValueChange={(v) => setSinceMode(v as any)}>
             <SelectTrigger className="h-8 w-[150px] text-xs" title={t('qslm.downloadRangeTitle')}>
               <SelectValue />
@@ -637,6 +736,7 @@ export function QSLManagerPanel({ onEditQSO }: { onEditQSO?: (id: number) => voi
             <Checkbox checked={addNotFound} onCheckedChange={(c) => setAddNotFound(!!c)} />
             {t('qslm.addNotFound')}
           </label>
+          </>)}
         </div>
         <Button size="sm" onClick={upload} disabled={selectedCount === 0 || busy}>
           <UploadCloud className="size-3.5" /> {t('qslm.uploadTo', { n: selectedCount, service: serviceLabel })}

frontend/src/components/QSOContextMenu.tsx

@@ -7,8 +7,8 @@ export type QSOMenuState = { x: number; y: number; ids: number[] } | null;
 type Props = {
   menu: QSOMenuState;
   onClose: () => void;
-  onUpdateFromCty: (ids: number[]) => void;
+  onUpdateFromCty?: (ids: number[]) => void;
-  onUpdateFromQRZ: (ids: number[]) => void;
+  onUpdateFromQRZ?: (ids: number[]) => void;
   onUpdateFromClublog?: (ids: number[]) => void;
   // Only passed once the offline US county database has been downloaded —
   // an entry that can only ever answer "no database" is not worth a line here.
@@ -18,8 +18,11 @@ type Props = {
   onSendEQSL?: (ids: number[]) => void;
   onBulkEdit?: (ids: number[]) => void;
   onExportSelected?: (ids: number[]) => void;
+  // Same rows, but keeping the APP_OPSLOG_* tags — award references above all.
+  onExportSelectedFull?: (ids: number[]) => void;
   onExportSelectedFields?: (ids: number[]) => void;
   onExportFiltered?: () => void;
+  onExportFilteredFull?: () => void;
   onExportCabrilloSelected?: (ids: number[]) => void;
   onExportCabrilloFiltered?: () => void;
   onDelete?: (ids: number[]) => void;
@@ -31,6 +34,7 @@ const UPLOAD_TARGETS: { service: string; name: string }[] = [
   { service: 'hrdlog', name: 'HRDLog.net' },
   { service: 'eqsl', name: 'eQSL.cc' },
   { service: 'lotw', name: 'LoTW' },
+  { service: 'hamlog', name: 'HAMLOG.online' },
 ];
 
 // Lightweight right-click menu for the QSO grids. AG Grid's native context
@@ -39,7 +43,7 @@ const UPLOAD_TARGETS: { service: string; name: string }[] = [
 // or picks a command. (We deliberately do NOT close on scroll/resize: the QSO
 // list auto-refreshes and AG Grid fires internal scroll events on refresh,
 // which used to dismiss the menu the instant it appeared.)
-export function QSOContextMenu({ menu, onClose, onUpdateFromCty, onUpdateFromQRZ, onUpdateFromClublog, onUpdateCountyFromULS, onSendTo, onSendRecording, onSendEQSL, onBulkEdit, onExportSelected, onExportSelectedFields, onExportFiltered, onExportCabrilloSelected, onExportCabrilloFiltered, onDelete }: Props) {
+export function QSOContextMenu({ menu, onClose, onUpdateFromCty, onUpdateFromQRZ, onUpdateFromClublog, onUpdateCountyFromULS, onSendTo, onSendRecording, onSendEQSL, onBulkEdit, onExportSelected, onExportSelectedFull, onExportSelectedFields, onExportFiltered, onExportFilteredFull, onExportCabrilloSelected, onExportCabrilloFiltered, onDelete }: Props) {
   const { t } = useI18n();
   const boxRef = useRef<HTMLDivElement>(null);
   // Starts at the cursor; the layout effect corrects it once the real size is
@@ -98,6 +102,11 @@ export function QSOContextMenu({ menu, onClose, onUpdateFromCty, onUpdateFromQRZ
       <div className="px-3 py-1 text-[11px] uppercase tracking-wider text-muted-foreground">
         {t('qctx.selected', { n })}
       </div>
+      {/* Conditional like every other entry. These two were drawn
+          unconditionally, and the grid passes them through an arrow that calls
+          an optional handler — so in a grid that wires neither (the QSL
+          Manager) both appeared and did precisely nothing when clicked. */}
+      {onUpdateFromCty && (
         <button
           className="flex w-full items-center gap-2 px-3 py-1.5 text-left hover:bg-accent/50"
           onClick={() => { onUpdateFromCty(menu.ids); onClose(); }}
@@ -105,6 +114,8 @@ export function QSOContextMenu({ menu, onClose, onUpdateFromCty, onUpdateFromQRZ
           <Globe2 className="size-4 text-primary" />
           <span>{t('qctx.fixCountry')}</span>
         </button>
+      )}
+      {onUpdateFromQRZ && (
         <button
           className="flex w-full items-center gap-2 px-3 py-1.5 text-left hover:bg-accent/50"
           onClick={() => { onUpdateFromQRZ(menu.ids); onClose(); }}
@@ -112,6 +123,7 @@ export function QSOContextMenu({ menu, onClose, onUpdateFromCty, onUpdateFromQRZ
           <RefreshCw className="size-4 text-info" />
           <span>{t('qctx.updateQrz')}</span>
         </button>
+      )}
       {onUpdateFromClublog && (
         <button
           className="flex w-full items-center gap-2 px-3 py-1.5 text-left hover:bg-accent/50"
@@ -181,6 +193,20 @@ export function QSOContextMenu({ menu, onClose, onUpdateFromCty, onUpdateFromQRZ
               <span>{t('qctx.exportSelectedAdif', { n })}</span>
             </button>
           )}
+          {/* The same rows WITH the OpsLog fields.
+              The export above is standard ADIF — what another logger should be
+              given — and it drops every APP_ tag, award references included. A
+              backup, or a move to another OpsLog, needs them: RDA@KR-04 lives in
+              APP_OPSLOG_AWARDREFS and nowhere else. */}
+          {onExportSelectedFull && (
+            <button
+              className="flex w-full items-center gap-2 px-3 py-1.5 text-left hover:bg-accent/50"
+              onClick={() => { onExportSelectedFull(menu.ids); onClose(); }}
+            >
+              <FileDown className="size-4 text-info" />
+              <span>{t('qctx.exportSelectedAdifFull', { n })}</span>
+            </button>
+          )}
           {onExportSelectedFields && (
             <button
               className="flex w-full items-center gap-2 px-3 py-1.5 text-left hover:bg-accent/50"
@@ -199,6 +225,15 @@ export function QSOContextMenu({ menu, onClose, onUpdateFromCty, onUpdateFromQRZ
               <span>{t('qctx.exportFilteredAdif')}</span>
             </button>
           )}
+          {onExportFilteredFull && (
+            <button
+              className="flex w-full items-center gap-2 px-3 py-1.5 text-left hover:bg-accent/50"
+              onClick={() => { onExportFilteredFull(); onClose(); }}
+            >
+              <FileDown className="size-4 text-info" />
+              <span>{t('qctx.exportFilteredAdifFull')}</span>
+            </button>
+          )}
           {onExportCabrilloSelected && (
             <button
               className="flex w-full items-center gap-2 px-3 py-1.5 text-left hover:bg-accent/50"

frontend/src/components/QSOEditModal.tsx

@@ -85,6 +85,19 @@ const CONF_LABEL_KEYS: Record<string, string> = {
 // the channel picker and the status table alongside the rest.
 const OPSLOG_CONF = 'OPSLOG';
 
+// HAMLOG.online. Out of CONFIRMATIONS for the same reason as the OpsLog card —
+// it is stored in the ADIF extras, not in QSO columns — but it is an upload
+// service like QRZ.com or Club Log, so it gets the ordinary sent/received/date
+// editor rather than a special one. The received key is THEIR field name, the
+// one their ADIF export writes; see award.HamlogQSLKey.
+const HAMLOG_CONF = 'HAMLOG';
+const HAMLOG_KEYS = {
+  sent: 'APP_OPSLOG_HAMLOG_SENT',
+  sentDate: 'APP_OPSLOG_HAMLOG_SENT_DATE',
+  rcvd: 'APP_HAMLOG_QSO_CFM',
+  rcvdDate: 'APP_OPSLOG_HAMLOG_QSL_DATE',
+};
+
 // Colour-coded status cell for the confirmation grid.
 function StatusCell({ value }: { value?: string }) {
   const { t } = useI18n();
@@ -626,6 +639,7 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
                   </div>
                   <div className="flex items-end gap-2">
                     <div className="flex flex-col flex-1"><Label>{t('qedit.grid')}</Label><Input value={draft.grid ?? ''} onChange={(e) => set('grid', e.target.value)} className="font-mono uppercase" /></div>
+                    <div className="flex flex-col w-24"><Label>{t('qedit.gridExt')}</Label><Input title={t('qedit.gridExtTip')} value={draft.gridsquare_ext ?? ''} onChange={(e) => set('gridsquare_ext', e.target.value)} className="font-mono uppercase" /></div>
                     <div className="flex flex-col w-24"><Label>PFX</Label><Input readOnly value={pfxOf(draft.callsign ?? '')} className="font-mono bg-muted/40" /></div>
                   </div>
                   <div><Label>{t('qedit.comment')}</Label><Input value={draft.comment ?? ''} onChange={(e) => set('comment', e.target.value)}
@@ -714,6 +728,16 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
                 const def = CONFIRMATIONS.find((c) => c.key === confSel) ?? CONFIRMATIONS[0];
                 const val = (k?: keyof QSOForm) => (k ? ((draft as any)[k] ?? '') : '');
                 const put = (k: keyof QSOForm | undefined, v: any) => { if (k) (set as any)(k, v); };
+                // The extras-backed channel reads and writes the same way, one
+                // level down. Save merges the extras rather than replacing them,
+                // so an emptied field keeps its stored value — which is why the
+                // statuses are written as explicit Y/N and never removed.
+                const exVal = (k: string) => String(draft.extras?.[k] ?? '');
+                const exPut = (k: string, v: any) => {
+                  const next = { ...(draft.extras ?? {}) };
+                  next[k] = String(v ?? '');
+                  set('extras', next as any);
+                };
                 return (
                   <div className="flex gap-6">
                     {/* Left: edit one confirmation channel at a time */}
@@ -730,11 +754,24 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
                                 generic sent/received/date grid, which has no field
                                 to bind to. */}
                             <SelectItem value={OPSLOG_CONF}>{t('qedit.confOpsLog')}</SelectItem>
+                            <SelectItem value={HAMLOG_CONF}>HAMLOG.online</SelectItem>
                           </SelectContent>
                         </Select>
                       </div>
 
-                      {confSel === OPSLOG_CONF ? (
+                      {confSel === HAMLOG_CONF ? (
+                        <>
+                          <div className="grid grid-cols-2 gap-3">
+                            <div><Label>{t('qedit.sent')}</Label><QslSelect value={exVal(HAMLOG_KEYS.sent)} onChange={(v) => exPut(HAMLOG_KEYS.sent, v)} /></div>
+                            <div><Label>{t('qedit.received')}</Label><QslSelect value={exVal(HAMLOG_KEYS.rcvd)} onChange={(v) => exPut(HAMLOG_KEYS.rcvd, v)} /></div>
+                            <div><Label>{t('qedit.dateSent')}</Label><AdifDateInput value={exVal(HAMLOG_KEYS.sentDate)} onChange={(v) => exPut(HAMLOG_KEYS.sentDate, v)} /></div>
+                            <div><Label>{t('qedit.dateReceived')}</Label><AdifDateInput value={exVal(HAMLOG_KEYS.rcvdDate)} onChange={(v) => exPut(HAMLOG_KEYS.rcvdDate, v)} /></div>
+                          </div>
+                          <p className="text-[11px] text-muted-foreground">
+                            {t('qedit.qslPanelHint')} <strong>{t('qedit.saveChanges')}</strong>.
+                          </p>
+                        </>
+                      ) : confSel === OPSLOG_CONF ? (
                         /* OpsLog's own card. "Sent" is stamped when the card
                            actually goes out, so it is shown, not offered: ticking
                            it by hand would record something that never happened.
@@ -826,6 +863,12 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
                             <td className="w-24"><StatusCell value={opslogQslSent ? 'Y' : 'N'} /></td>
                             <td className="w-24"><StatusCell value={qslReceived ? 'Y' : 'N'} /></td>
                           </tr>
+                          {/* HAMLOG.online — extras again, same hand-written row. */}
+                          <tr className="text-xs">
+                            <td className="font-medium pr-3 py-0.5 whitespace-nowrap">HAMLOG.online</td>
+                            <td className="w-24"><StatusCell value={exVal(HAMLOG_KEYS.sent)} /></td>
+                            <td className="w-24"><StatusCell value={exVal(HAMLOG_KEYS.rcvd)} /></td>
+                          </tr>
                         </tbody>
                       </table>
                     </div>
@@ -867,7 +910,7 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
                 <F label={t('qedit.stationCallsign')} span={3}><Input value={draft.station_callsign ?? ''} onChange={(e) => set('station_callsign', e.target.value)} /></F>
                 <F label={t('qedit.operator')} span={3}><Input value={draft.operator ?? ''} onChange={(e) => set('operator', e.target.value)} /></F>
                 <F label={t('qedit.myGrid')}><Input value={draft.my_grid ?? ''} onChange={(e) => set('my_grid', e.target.value)} /></F>
-                <F label={t('qedit.gridExt')}><Input value={draft.my_gridsquare_ext ?? ''} onChange={(e) => set('my_gridsquare_ext', e.target.value)} /></F>
+                <F label={t('qedit.myGridExt')}><Input title={t('qedit.gridExtTip')} value={draft.my_gridsquare_ext ?? ''} onChange={(e) => set('my_gridsquare_ext', e.target.value)} /></F>
                 <F label={t('qedit.country')} span={2}><Combobox value={draft.my_country ?? ''} options={countries} placeholder={t('qedit.country')} onChange={(v) => set('my_country', v)} /></F>
                 <F label={t('qedit.state')}><Input value={draft.my_state ?? ''} onChange={(e) => set('my_state', e.target.value)} /></F>
                 <F label={t('qedit.county')}><Input value={draft.my_cnty ?? ''} onChange={(e) => set('my_cnty', e.target.value)} /></F>
@@ -903,6 +946,10 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
               <div>
                 <p className="text-[11px] font-semibold text-muted-foreground uppercase tracking-wider mb-2">{t('qedit.powerWeather')}</p>
                 <div className="grid grid-cols-6 gap-3">
+                  {/* YOUR power first, then theirs. tx_pwr was saved by this
+                      editor but had no field: a contact logged at the wrong
+                      power could be read back and never corrected. */}
+                  <F label={t('qedit.txPower')}><Input type="number" value={draft.tx_pwr ?? ''} onChange={(e) => set('tx_pwr', numOrUndef(e.target.value) as any)} /></F>
                   <F label={t('qedit.rxPower')}><Input type="number" value={draft.rx_pwr ?? ''} onChange={(e) => set('rx_pwr', numOrUndef(e.target.value) as any)} /></F>
                   <F label={t('qedit.distance')}><Input type="number" value={draft.distance ?? ''} onChange={(e) => set('distance', numOrUndef(e.target.value) as any)} /></F>
                   <F label={t('qedit.aIndex')}><Input type="number" value={draft.a_index ?? ''} onChange={(e) => set('a_index', numOrUndef(e.target.value) as any)} /></F>

frontend/src/components/RecentQSOsGrid.tsx

@@ -70,8 +70,10 @@ type Props = {
   onSendEQSL?: (ids: number[]) => void;
   onBulkEdit?: (ids: number[]) => void;
   onExportSelected?: (ids: number[]) => void;
+  onExportSelectedFull?: (ids: number[]) => void;
   onExportSelectedFields?: (ids: number[]) => void;
   onExportFiltered?: () => void;
+  onExportFilteredFull?: () => void;
   onExportCabrilloSelected?: (ids: number[]) => void;
   onExportCabrilloFiltered?: () => void;
   onDelete?: (ids: number[]) => void;
@@ -207,6 +209,14 @@ export const makeColCatalog = (t: TFn, myGrid?: string): ColEntry[] => [
   { group: 'QSL', label: t('rqg.c.opslog_qsl_card_sent'), colId: 'opslog_qsl_card_sent', headerName: t('rqg.c.opslog_qsl_card_sent'), width: 100, cellClass: qslStatusCellClass, valueGetter: (p) => { const e = (p.data as any)?.extras ?? {}; return (e['APP_OPSLOG_QSL_SENT'] || e['APP_OPSLOG_QSL_CARD_SENT']) ? 'Y' : 'N'; }, defaultVisible: true },
   // App-specific: operator marked a QSL as RECEIVED for this QSO (drives PSE/TNX).
   { group: 'QSL', label: t('rqg.c.opslog_qsl_card_rcvd'), colId: 'opslog_qsl_card_rcvd', headerName: t('rqg.c.opslog_qsl_card_rcvd'), width: 100, cellClass: qslStatusCellClass, valueGetter: (p) => { const e = (p.data as any)?.extras ?? {}; return e['APP_OPSLOG_QSL_RCVD'] ? 'Y' : 'N'; }, defaultVisible: false },
+  // HAMLOG.online. No promoted column — the ADIF standard names a field for
+  // hamlog.EU and none for hamlog.ONLINE — so these read the extras, exactly
+  // like the OpsLog card columns above. Hidden by default: a column per
+  // service, shown to everyone, is how a grid becomes unreadable.
+  { group: 'Uploads', label: t('rqg.c.hamlog_sent'), colId: 'hamlog_sent', headerName: t('rqg.h.hamlog_sent'), width: 100, cellClass: qslStatusCellClass, valueGetter: (p) => { const e = (p.data as any)?.extras ?? {}; return e['APP_OPSLOG_HAMLOG_SENT'] || 'N'; }, defaultVisible: false },
+  { group: 'Uploads', label: t('rqg.c.hamlog_sent_date'), colId: 'hamlog_sent_date', headerName: t('rqg.h.hamlog_sent_date'), width: 110, valueGetter: (p) => fmtDateOnly((p.data as any)?.extras?.['APP_OPSLOG_HAMLOG_SENT_DATE']), defaultVisible: false },
+  { group: 'Uploads', label: t('rqg.c.hamlog_rcvd'), colId: 'hamlog_rcvd', headerName: t('rqg.h.hamlog_rcvd'), width: 100, cellClass: qslStatusCellClass, valueGetter: (p) => { const e = (p.data as any)?.extras ?? {}; return e['APP_HAMLOG_QSO_CFM'] || e['APP_OPSLOG_HAMLOG_QSL'] || 'N'; }, defaultVisible: false },
+  { group: 'Uploads', label: t('rqg.c.hamlog_rcvd_date'), colId: 'hamlog_rcvd_date', headerName: t('rqg.h.hamlog_rcvd_date'), width: 110, valueGetter: (p) => fmtDateOnly((p.data as any)?.extras?.['APP_OPSLOG_HAMLOG_QSL_DATE']), defaultVisible: false },
   // App-specific: when the QSO's audio recording was e-mailed to the station.
   { group: 'QSL', label: t('rqg.c.opslog_recording_sent'), colId: 'opslog_recording_sent', headerName: t('rqg.h.opslog_recording_sent'), width: 100, cellClass: qslStatusCellClass, valueGetter: (p) => { const e = (p.data as any)?.extras ?? {}; return e['APP_OPSLOG_RECORDING_SENT'] ? 'Y' : 'N'; }, defaultVisible: false },
 
@@ -309,7 +319,7 @@ const sanitizeAwardCols = (st: any[] | null | undefined): any[] =>
     return rest;
   });
 
-export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal, rowDragCall, passOrder, onGridApi, storageKey, onRowDoubleClicked, onRowClicked, onRowSelected, onRowSelectedQso, onUpdateFromCty, onUpdateFromQRZ, onUpdateFromClublog, onUpdateCountyFromULS, onSendTo, onSendRecording, onSendEQSL, onBulkEdit, onExportSelected, onExportSelectedFields, onExportFiltered, onExportCabrilloSelected, onExportCabrilloFiltered, onDelete, onFilteredCountChange, awardCols, rowColors }: Props) {
+export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal, rowDragCall, passOrder, onGridApi, storageKey, onRowDoubleClicked, onRowClicked, onRowSelected, onRowSelectedQso, onUpdateFromCty, onUpdateFromQRZ, onUpdateFromClublog, onUpdateCountyFromULS, onSendTo, onSendRecording, onSendEQSL, onBulkEdit, onExportSelected, onExportSelectedFull, onExportSelectedFields, onExportFiltered, onExportFilteredFull, onExportCabrilloSelected, onExportCabrilloFiltered, onDelete, onFilteredCountChange, awardCols, rowColors }: Props) {
   const { t } = useI18n();
   const gridRef = useRef<any>(null);
   const [pickerOpen, setPickerOpen] = useState(false);
@@ -631,6 +641,20 @@ export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal,
     api.setColumnsVisible(ids, false);
     saveColumnState();
   }
+  // Whole-dialog show/hide. showAll/hideAll cover the CATALOGUE only; the award
+  // columns live in their own persisted code set, so a global that skipped them
+  // would leave a row of columns behind and look broken.
+  function setEverything(visible: boolean) {
+    const api = gridRef.current?.api;
+    if (!api) return;
+    api.setColumnsVisible(COL_CATALOG.map((c) => c.colId!), visible);
+    if (awardCols && awardCols.length > 0) {
+      persistAwardShown(visible ? new Set(awardCols.map((a) => a.code.toUpperCase())) : new Set());
+      api.setColumnsVisible(awardCols.map((a) => `award_${a.code}`), visible);
+    }
+    saveColumnState();
+  }
+
   function resetDefaults() {
     const api = gridRef.current?.api;
     if (!api) return;
@@ -706,16 +730,20 @@ export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal,
             animateRows={false}
             suppressCellFocus
             getRowId={(p) => String((p.data as any).id)}
-            getRowStyle={(p) => rowStyleFor(p.data, rowColors ?? null)}
+            getRowStyle={(p) => rowStyleFor(p.data, rowColors ?? null, p.node.rowIndex ?? undefined)}
           />
         </div>
       </div>
 
+      {/* Every handler is passed STRAIGHT through, never wrapped in an arrow: a
+          wrapper is always truthy, so the menu drew "Fix country" and "Update
+          from the callsign databases" even in a grid that wired neither — and
+          clicking them did nothing at all. */}
       <QSOContextMenu
         menu={menu}
         onClose={() => setMenu(null)}
-        onUpdateFromCty={(ids) => onUpdateFromCty?.(ids)}
+        onUpdateFromCty={onUpdateFromCty}
-        onUpdateFromQRZ={(ids) => onUpdateFromQRZ?.(ids)}
+        onUpdateFromQRZ={onUpdateFromQRZ}
         onUpdateFromClublog={onUpdateFromClublog}
         onUpdateCountyFromULS={onUpdateCountyFromULS}
         onSendTo={onSendTo}
@@ -723,8 +751,10 @@ export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal,
         onSendEQSL={onSendEQSL}
         onBulkEdit={onBulkEdit}
         onExportSelected={onExportSelected}
+        onExportSelectedFull={onExportSelectedFull}
         onExportSelectedFields={onExportSelectedFields}
         onExportFiltered={onExportFiltered}
+        onExportFilteredFull={onExportFilteredFull}
         onExportCabrilloSelected={onExportCabrilloSelected}
         onExportCabrilloFiltered={onExportCabrilloFiltered}
         onDelete={onDelete}
@@ -738,6 +768,16 @@ export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal,
               {t('rqg.pickerDesc')}
             </DialogDescription>
           </DialogHeader>
+          {/* Whole-dialog controls. The per-group links alone meant hiding
+              everything was one click PER GROUP, and there are a dozen. */}
+          <div className="flex items-center gap-1 px-5 text-[11px] text-muted-foreground">
+            <span>{t('rqg.pickerAllGroups')}</span>
+            <button type="button" className="text-[11px] text-primary hover:underline px-1"
+              onClick={() => setEverything(true)}>{t('rqg.all')}</button>
+            <span className="opacity-40">·</span>
+            <button type="button" className="text-[11px] text-muted-foreground hover:underline px-1"
+              onClick={() => setEverything(false)}>{t('rqg.none')}</button>
+          </div>
           <div className="grid grid-cols-3 gap-4 max-h-[60vh] overflow-y-auto px-5 py-3">
             {GROUP_ORDER.map((group) => {
               const cols = COL_CATALOG.filter((c) => c.group === group);

frontend/src/components/RotorCompass.tsx

@@ -72,6 +72,21 @@ export function RotorCompass({ bearing, headings, boomHeading, pattern, centerLa
     onGoto(az);
   };
 
+  // Stop needs the same acknowledgement, for the same reason and one more: it
+  // is pressed when something is already wrong, and a button that stays inert
+  // gets hit again and again. Its own flag, so stopping does not blank a preset
+  // that is still lit.
+  const [stopFlash, setStopFlash] = useState(false);
+  const stopTimer = useRef<number | undefined>(undefined);
+  useEffect(() => () => window.clearTimeout(stopTimer.current), []);
+  const pressStop = () => {
+    if (!onStop) return;
+    setStopFlash(true);
+    window.clearTimeout(stopTimer.current);
+    stopTimer.current = window.setTimeout(() => setStopFlash(false), 450);
+    onStop();
+  };
+
   // 0-359 and nothing else. 360 is refused rather than folded to 0 — it is
   // almost always a typo for 36 or 306, and a rotor swinging through north on a
   // slip of the finger is worth one rejected keypress.
@@ -332,9 +347,16 @@ export function RotorCompass({ bearing, headings, boomHeading, pattern, centerLa
           {onStop && (
             <button
               type="button"
-              onClick={onStop}
+              onClick={pressStop}
               title={t('rotor.stop')}
-              className="flex items-center justify-center gap-1.5 rounded-md border border-destructive/60 bg-destructive/15 py-1 text-xs font-bold text-destructive hover:bg-destructive/25"
+              className={cn(
+                'flex items-center justify-center gap-1.5 rounded-md border py-1 text-xs font-bold transition-all duration-150 active:scale-95',
+                stopFlash
+                  // Solid, not a tint: STOP reads the same in both languages, so
+                  // the fill is the whole acknowledgement.
+                  ? 'border-destructive bg-destructive text-destructive-foreground scale-95'
+                  : 'border-destructive/60 bg-destructive/15 text-destructive hover:bg-destructive/25',
+              )}
             >
               <Square className="size-3 fill-current" /> {t('rotor.stop')}
             </button>

frontend/src/components/StationControlPanel.tsx

@@ -6,6 +6,7 @@ import { Label } from '@/components/ui/label';
 import { Checkbox } from '@/components/ui/checkbox';
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select';
 import { cn } from '@/lib/utils';
+import { MotorAntennaWidget, type AntStatus } from '@/components/MotorAntennaWidget';
 import { useI18n } from '@/lib/i18n';
 import { writeUiPref } from '@/lib/uiPref';
 import { subscribeRotorHeading, pokeRotorHeading } from '@/lib/rotorHeading';
@@ -185,267 +186,6 @@ function RotatorWidget({ hd, refetch, centerLat, centerLon, bearing, t }: Rotato
   );
 }
 
-type AntStatus = { enabled: boolean; type: string; connected: boolean; direction: number; frequency: number; moving: boolean; elements: number[]; follow?: boolean; step_khz?: number; track_mode?: string; bands?: string[]; band_freqs?: Record<string, number> };
-
-// Where each band button points the antenna.
-//
-// Not the arithmetic centre of the band. An antenna is tuned for where people
-// actually work: 20 m centres on 14175 but nobody lives there, and 10 m spans
-// 1.7 MHz of which the top half is empty. These are the points that leave the
-// elements closest to right for the whole band, and one nudge away from the rest.
-const ANT_BAND_KHZ: Record<string, number> = {
-  '40m': 7100, '30m': 10125, '20m': 14150, '17m': 18110,
-  '15m': 21150, '12m': 24930, '10m': 28400, '6m': 50150,
-};
-
-// NUDGE_KHZ is the up/down step. 25 kHz because that is also the finest tracking
-// threshold: a nudge smaller than the tracking step would be undone by the next
-// poll while tracking is on.
-const NUDGE_KHZ = 25;
-
-// bandOfKHz names the band a frequency sits in, so a band button can light up
-// when the ANTENNA is already there. Deliberately generous at the edges: the
-// antenna's reported frequency is where it was commanded, which can sit slightly
-// outside the allocation.
-function bandOfKHz(khz: number): string {
-  const edges: [number, number, string][] = [
-    [6900, 7300, '40m'], [10050, 10200, '30m'], [13900, 14400, '20m'],
-    [18000, 18200, '17m'], [20900, 21500, '15m'], [24800, 25000, '12m'],
-    [27900, 29800, '10m'], [49900, 50600, '6m'],
-  ];
-  for (const [lo, hi, b] of edges) if (khz >= lo && khz <= hi) return b;
-  return '';
-}
-
-// MotorAntennaWidget controls a motorized antenna (Ultrabeam / SteppIR) from the
-// Station Control tab: pattern (Normal / 180° / Bi), Retract, and — Ultrabeam
-// only — per-element length adjustment. Heading/state is polled by the panel.
-const ELEMENT_STEP = 2; // the physical console adjusts 2 mm per press
-
-// elementName maps an element index to a ham-radio name: 0 = reflector,
-// 1 = driven element, then Director 1, 2, 3…
-function elementName(i: number, t: (k: string, v?: any) => string): string {
-  if (i === 0) return t('station.reflector');
-  if (i === 1) return t('station.driven');
-  return `${t('station.director')} ${i - 1}`;
-}
-
-function MotorAntennaWidget({ ant, refetch, t }: { ant: AntStatus; refetch: () => void; t: (k: string, v?: any) => string }) {
-  const [err, setErr] = useState('');
-  const [lengths, setLengths] = useState<number[]>([]); // current element lengths (mm), from ReadElements
-  const [reading, setReading] = useState(false);
-  const [busyEl, setBusyEl] = useState<number | null>(null);
-  const [editingEl, setEditingEl] = useState<number | null>(null); // element whose mm is being typed
-  const [editVal, setEditVal] = useState('');
-  const run = (p: Promise<any>) => p.then(refetch).catch((e) => setErr(String(e?.message ?? e)));
-  const isUB = ant.type !== 'steppir';
-
-  const readLengths = useCallback(async () => {
-    setReading(true); setErr('');
-    try { setLengths(((await MotorReadElements()) ?? []) as number[]); }
-    catch (e: any) { setErr(String(e?.message ?? e)); }
-    finally { setReading(false); }
-  }, []);
-  // Read the current lengths once when the Ultrabeam widget mounts/connects, so
-  // +/- starts from the real values rather than blind.
-  useEffect(() => { if (isUB && ant.connected) readLengths(); }, [isUB, ant.connected, readLengths]);
-
-  // Send an absolute length to one element and remember it as the new baseline.
-  const setLen = async (i: number, mm: number) => {
-    const next = Math.max(0, Math.round(mm));
-    const prev = lengths[i] ?? 0;
-    setBusyEl(i); setErr('');
-    setLengths((ls) => { const c = [...ls]; c[i] = next; return c; }); // optimistic
-    try { await MotorSetElement(i, next); refetch(); }
-    catch (e: any) {
-      // Rejected by the controller — most often the element is at its travel
-      // limit for this band (extending on a low band). Revert the optimistic
-      // value so the display stays truthful, and explain the likely cause when
-      // the failed move was an extension.
-      setLengths((ls) => { const c = [...ls]; c[i] = prev; return c; });
-      setErr(next > prev ? t('station.atMax') : String(e?.message ?? e));
-    }
-    finally { setBusyEl(null); }
-  };
-  // Nudge one element by ±2 mm from its current known length.
-  const nudge = (i: number, delta: number) => setLen(i, (lengths[i] ?? 0) + delta);
-  // Commit a typed exact length (click on the mm value). Lets the operator fix
-  // the baseline when the auto-read is off, so +/- then work reliably.
-  const commitEdit = (i: number) => {
-    const v = parseInt(editVal, 10);
-    setEditingEl(null);
-    if (!isNaN(v) && v >= 0 && v !== lengths[i]) setLen(i, v);
-  };
-  const dirs: [number, string][] = [[0, 'N'], [1, '180°'], [2, t('station.bi')]];
-  return (
-    <div className="rounded-xl border border-border bg-card shadow-sm overflow-hidden h-full">
-      <div className="flex items-center gap-2 px-3 py-2 border-b border-border/60 bg-muted/30">
-        <AntennaIcon className="size-4 text-primary" />
-        <div className="min-w-0">
-          <div className="text-sm font-semibold truncate">{isUB ? 'Ultrabeam' : 'SteppIR'}</div>
-          {ant.frequency > 0 && <div className="text-[10px] text-muted-foreground font-mono">{(ant.frequency / 1000).toFixed(3)} MHz</div>}
-        </div>
-        {ant.moving && <span className="ml-auto text-[10px] font-semibold text-warning animate-pulse">{t('station.moving')}</span>}
-        <span className={cn('size-2 rounded-full shrink-0', ant.moving ? '' : 'ml-auto', ant.connected ? 'bg-success' : 'bg-muted-foreground/40')}
-          title={ant.connected ? t('station.online') : t('station.offline')} />
-      </div>
-      <div className="p-3 space-y-3">
-        <div>
-          <div className="text-[10px] font-semibold uppercase tracking-wider text-muted-foreground mb-1">{t('station.pattern')}</div>
-          <div className="flex gap-1">
-            {dirs.map(([d, lbl]) => (
-              <button key={d} type="button" disabled={!ant.connected}
-                onClick={() => run(SetUltrabeamDirection(d))}
-                className={cn('flex-1 rounded-md border py-1.5 text-xs font-semibold transition-colors disabled:opacity-40',
-                  ant.direction === d ? 'bg-primary text-primary-foreground border-primary' : 'border-border hover:bg-muted')}>
-                {lbl}
-              </button>
-            ))}
-          </div>
-        </div>
-        {/* Bands, then a nudge, then tracking — in the order an operator uses
-            them: get to the band, fine-tune inside it, decide whether the
-            antenna should follow the rig from here. */}
-        <div>
-          <div className="text-[10px] font-semibold uppercase tracking-wider text-muted-foreground mb-1">{t('station.bands')}</div>
-          <div className="grid grid-cols-5 gap-1">
-            {(ant.bands ?? []).map((b: string) => {
-              // Where this band tunes is resolved by the backend — the operator's
-              // per-band choice from Settings, or the default. ANT_BAND_KHZ is only
-              // the floor for a status poll that hasn't landed yet.
-              const khz = ant.band_freqs?.[b] || ANT_BAND_KHZ[b];
-              if (!khz) return null;
-              // "On this band" from the antenna's own frequency, not the rig's:
-              // the widget must show where the ANTENNA is, which is the whole
-              // reason for tuning it by hand.
-              const here = ant.frequency > 0 && bandOfKHz(ant.frequency) === b;
-              return (
-                <button key={b} type="button" disabled={!ant.connected}
-                  onClick={() => run(MotorTuneKHz(khz))}
-                  title={`${(khz / 1000).toFixed(3)} MHz`}
-                  className={cn('rounded-md border py-1 text-[11px] font-mono font-semibold transition-colors disabled:opacity-40',
-                    here ? 'bg-primary text-primary-foreground border-primary' : 'border-border hover:bg-muted')}>
-                  {b}
-                </button>
-              );
-            })}
-          </div>
-        </div>
-
-        <div className="flex items-center gap-1">
-          <button type="button" disabled={!ant.connected}
-            onClick={() => run(MotorNudgeKHz(-NUDGE_KHZ))}
-            title={t('station.nudgeDown', { n: NUDGE_KHZ })}
-            className="flex-1 flex items-center justify-center gap-1 rounded-md border border-border py-1.5 text-xs font-semibold hover:bg-muted disabled:opacity-40">
-            <ChevronDown className="size-3.5" /> {NUDGE_KHZ}
-          </button>
-          <button type="button" disabled={!ant.connected}
-            onClick={() => run(MotorNudgeKHz(NUDGE_KHZ))}
-            title={t('station.nudgeUp', { n: NUDGE_KHZ })}
-            className="flex-1 flex items-center justify-center gap-1 rounded-md border border-border py-1.5 text-xs font-semibold hover:bg-muted disabled:opacity-40">
-            <ChevronUp className="size-3.5" /> {NUDGE_KHZ}
-          </button>
-        </div>
-
-        {/* Tracking. Here rather than only in Settings because it is an operating
-            decision — off to park the antenna, on to resume — not something set
-            up once. Mode and step only show when tracking is on: settings for
-            something switched off are questions the operator cannot act on. And
-            the step only shows in step mode, where it is the one thing it means. */}
-        <div className="space-y-1.5">
-          <div className="flex items-center gap-2">
-            <button type="button"
-              onClick={() => run(SetMotorFollow(!ant.follow, 0, ''))}
-              className={cn('flex-1 rounded-md border py-1.5 text-xs font-semibold transition-colors',
-                ant.follow ? 'bg-success-muted text-success-muted-foreground border-success-border' : 'border-border hover:bg-muted')}>
-              {ant.follow ? t('station.trackOn') : t('station.trackOff')}
-            </button>
-            {ant.follow && (ant.track_mode || 'step') === 'step' && (
-              <select
-                value={String(ant.step_khz || 50)}
-                onChange={(e) => run(SetMotorFollow(true, parseInt(e.target.value, 10), ''))}
-                className="h-[30px] rounded-md border border-border bg-background px-1 text-xs font-mono"
-                title={t('station.trackStepTip')}
-              >
-                {[25, 50, 100].map((s) => <option key={s} value={s}>{s} kHz</option>)}
-              </select>
-            )}
-          </div>
-          {ant.follow && (
-            <select
-              value={ant.track_mode || 'step'}
-              onChange={(e) => run(SetMotorFollow(true, 0, e.target.value))}
-              className="w-full h-[30px] rounded-md border border-border bg-background px-1.5 text-xs"
-              title={t('station.trackModeTip')}
-            >
-              <option value="always" title={t('station.trackAlwaysTip')}>{t('station.trackAlways')}</option>
-              <option value="step" title={t('station.trackStepTipMode')}>{t('station.trackStep')}</option>
-              <option value="band" title={t('station.trackBandTip')}>{t('station.trackBand')}</option>
-            </select>
-          )}
-        </div>
-
-        <button type="button" disabled={!ant.connected}
-          onClick={() => run(UltrabeamRetract())}
-          className="w-full flex items-center justify-center gap-1.5 rounded-md border border-warning-border bg-warning-muted text-warning-muted-foreground py-1.5 text-xs font-semibold hover:brightness-95 disabled:opacity-40">
-          <ArrowDownToLine className="size-3.5" /> {t('station.retract')}
-        </button>
-
-        {isUB && (
-          <div>
-            <div className="flex items-center gap-2 mb-1.5">
-              <span className="text-[10px] font-semibold uppercase tracking-wider text-muted-foreground">{t('station.elements')}</span>
-              <button type="button" onClick={readLengths} disabled={!ant.connected || reading}
-                className="text-[10px] text-primary hover:underline inline-flex items-center gap-1 disabled:opacity-40" title={t('station.readLengths')}>
-                <RefreshCw className={cn('size-3', reading && 'animate-spin')} /> {t('station.read')}
-              </button>
-            </div>
-            {lengths.length === 0 ? (
-              <p className="text-[11px] text-muted-foreground">{t('station.noLengths')}</p>
-            ) : (
-              <div className="space-y-1.5">
-                {/* The READ_BANDS reply is undocumented and its 16-bit parse picks
-                    up structural bytes past the real data (varying by band), which
-                    made 6+ bogus "elements" appear. Ultrabeam beams are 3-element,
-                    and ModifyElement addresses elements 0..2 — so show just those. */}
-                {lengths.map((mm, i) => ({ mm, i })).slice(0, 3).map(({ mm, i }) => (
-                  <div key={i} className="flex items-center gap-2">
-                    <span className="text-xs w-20 shrink-0 text-muted-foreground truncate">{elementName(i, t)}</span>
-                    <button type="button" disabled={!ant.connected || busyEl !== null}
-                      onClick={() => nudge(i, -ELEMENT_STEP)}
-                      className="flex items-center justify-center size-7 rounded-md border border-border hover:bg-muted disabled:opacity-40 shrink-0">
-                      <Minus className="size-3.5" />
-                    </button>
-                    {editingEl === i ? (
-                      <input autoFocus type="number" value={editVal}
-                        onChange={(e) => setEditVal(e.target.value)}
-                        onBlur={() => commitEdit(i)}
-                        onKeyDown={(e) => { if (e.key === 'Enter') commitEdit(i); if (e.key === 'Escape') setEditingEl(null); }}
-                        className="text-sm font-mono font-bold flex-1 min-w-0 text-center tabular-nums bg-transparent border border-primary rounded px-1" />
-                    ) : (
-                      <span className="text-sm font-mono font-bold flex-1 min-w-0 text-center tabular-nums cursor-pointer hover:underline"
-                        title={t('station.setExactLen')}
-                        onClick={() => { setEditingEl(i); setEditVal(String(mm)); }}>
-                        {busyEl === i ? <Loader2 className="size-3.5 animate-spin inline" /> : `${mm} mm`}
-                      </span>
-                    )}
-                    <button type="button" disabled={!ant.connected || busyEl !== null}
-                      onClick={() => nudge(i, ELEMENT_STEP)}
-                      className="flex items-center justify-center size-7 rounded-md border border-border hover:bg-muted disabled:opacity-40 shrink-0">
-                      <Plus className="size-3.5" />
-                    </button>
-                  </div>
-                ))}
-              </div>
-            )}
-            <p className="text-[10px] text-muted-foreground mt-1">{t('station.elementsHint')}</p>
-          </div>
-        )}
-        {err && <div className="text-[11px] text-destructive break-words">{err}</div>}
-      </div>
-    </div>
-  );
-}
 
 export function StationControlPanel({ centerLat, centerLon, bearing }: RotatorProps) {
   const { t } = useI18n();

frontend/src/components/StatsPanel.tsx

@@ -29,6 +29,7 @@ type ContestRun = { id: string; year: number; count: number; start: string; end:
 type Stats = {
   total: number; unique_calls: number; entities: number; continents: number;
   first_qso: string; last_qso: string;
+  last_new_dxcc: string; last_new_dxcc_num: number; last_new_dxcc_call: string; last_new_dxcc_date: string;
   confirmed_lotw: number; confirmed_eqsl: number; confirmed_qsl: number; confirmed_any: number;
   by_mode: Bucket[]; by_band: Bucket[]; by_band_category: BandCat[]; by_operator: Bucket[]; by_station: Bucket[];
   by_continent: Bucket[]; top_entities: Bucket[]; by_year: Bucket[]; by_month: Bucket[];
@@ -681,6 +682,16 @@ export function StatsPanel() {
   // real operating session (which is exactly when an hourly rate chart exists).
   const windowed = contest !== '' || (period === 'custom' && (stats?.rate?.length ?? 0) > 1);
 
+  // "last new: France - F5ABC - 2019-03-01": the entity most recently added to
+  // the log, and the contact that added it. Empty when no dated entity exists.
+  const lastNew = useMemo(() => {
+    if (!stats?.last_new_dxcc_date) return '';
+    const day = stats.last_new_dxcc_date.slice(0, 10);
+    const who = stats.last_new_dxcc_call ? ` · ${stats.last_new_dxcc_call}` : '';
+    const what = stats.last_new_dxcc || String(stats.last_new_dxcc_num || '');
+    return `${t('stats.lastNewDxcc')}: ${what}${who} · ${day}`;
+  }, [stats, t]);
+
   const span = useMemo(() => {
     if (!stats?.first_qso) return '';
     const f = new Date(stats.first_qso), l = new Date(stats.last_qso);
@@ -774,7 +785,11 @@ export function StatsPanel() {
       <div className="grid grid-cols-2 md:grid-cols-5 gap-2.5 mb-3">
         <StatTile label={t('stats.qsos')} value={nf(stats.total)} sub={span} accent="var(--chart-1)" />
         <StatTile label={t('stats.uniqueCalls')} value={nf(stats.unique_calls)} accent="var(--chart-2)" />
-        <StatTile label={t('stats.entities')} value={nf(stats.entities)} sub="DXCC" accent="var(--chart-5)" />
+        {/* The last one ADDED rides on the entities tile: it is the same
+            subject, and a tile of its own would push the five headline figures
+            onto two rows for one line of text. */}
+        <StatTile label={t('stats.entities')} value={nf(stats.entities)}
+          sub={lastNew || "DXCC"} accent="var(--chart-5)" />
         <StatTile label={t('stats.continents')} value={nf(stats.continents)} sub="/ 7" accent="var(--chart-8)" />
         <StatTile label={t('stats.confirmed')} value={`${stats.total ? ((stats.confirmed_any / stats.total) * 100).toFixed(0) : 0}%`}
           sub={`${nf(stats.confirmed_any)} / ${nf(stats.total)}`} accent="var(--success)" />

frontend/src/components/UDPIntegrationsPanel.tsx

@@ -24,7 +24,7 @@ type UDPConfig = {
   direction: 'inbound' | 'outbound';
   name: string;
   port: number;
-  service_type: 'wsjt' | 'adif' | 'n1mm' | 'remote_call' | 'db_updated' | 'pstrotator_freq' | 'n1mm_radioinfo' | 'wsjt_log' | 'custom';
+  service_type: 'wsjt' | 'adif' | 'n1mm' | 'remote_call' | 'db_updated' | 'pstrotator_freq' | 'n1mm_radioinfo' | 'wsjt_log' | 'wsjt_relay' | 'custom';
   // Custom rows only.
   trigger?: string;
   template?: string;
@@ -95,6 +95,19 @@ const SERVICE_TYPES: Array<{
     hint: 'udpp.svcWsjtLogHint',
     defaults: { port: 2250, destination_ip: '127.0.0.1' },
   },
+  {
+    // Feeds a SECOND application the stream this OpsLog receives. WSJT-X, JTDX
+    // and MSHV each send to ONE address, so without a relay the choice is
+    // between OpsLog and JTAlert/GridTracker rather than both.
+    //
+    // 2238 by default: beside the 2237 the sender uses, and free. Pointing it AT
+    // 2237 would name an OpsLog listener, which the relay refuses.
+    id: 'wsjt_relay',
+    direction: 'outbound',
+    label: 'udpp.svcWsjtRelayLabel',
+    hint: 'udpp.svcWsjtRelayHint',
+    defaults: { port: 2238, destination_ip: '127.0.0.1' },
+  },
   {
     // The general case: the operator picks the moment and writes the message.
     // Mainly for antenna switches, which are driven by a URL and want the band

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

@@ -41,6 +41,7 @@ type Props = {
   onSendEQSL?: (ids: number[]) => void;
   onBulkEdit?: (ids: number[]) => void;
   onExportSelected?: (ids: number[]) => void;
+  onExportSelectedFull?: (ids: number[]) => void;
   onExportSelectedFields?: (ids: number[]) => void;
   onExportCabrilloSelected?: (ids: number[]) => void;
   onDelete?: (ids: number[]) => void;
@@ -58,7 +59,7 @@ function fmtDate(s: any): string {
   return `${d.getUTCFullYear()}-${p(d.getUTCMonth() + 1)}-${p(d.getUTCDate())}`;
 }
 
-export function WorkedBeforeGrid({ wb, myGrid, busy, currentCall, onRowDoubleClicked, onUpdateFromCty, onUpdateFromQRZ, onUpdateFromClublog, onUpdateCountyFromULS, onSendTo, onSendRecording, onSendEQSL, onBulkEdit, onExportSelected, onExportSelectedFields, onExportCabrilloSelected, onDelete, awardCols }: Props) {
+export function WorkedBeforeGrid({ wb, myGrid, busy, currentCall, onRowDoubleClicked, onUpdateFromCty, onUpdateFromQRZ, onUpdateFromClublog, onUpdateCountyFromULS, onSendTo, onSendRecording, onSendEQSL, onBulkEdit, onExportSelected, onExportSelectedFull, onExportSelectedFields, onExportCabrilloSelected, onDelete, awardCols }: Props) {
   const { t } = useI18n();
   const gridRef = useRef<any>(null);
   const [pickerOpen, setPickerOpen] = useState(false);
@@ -279,6 +280,7 @@ export function WorkedBeforeGrid({ wb, myGrid, busy, currentCall, onRowDoubleCli
         onSendEQSL={onSendEQSL}
         onBulkEdit={onBulkEdit}
         onExportSelected={onExportSelected}
+        onExportSelectedFull={onExportSelectedFull}
         onExportSelectedFields={onExportSelectedFields}
         onExportCabrilloSelected={onExportCabrilloSelected}
         onDelete={onDelete}
@@ -298,6 +300,20 @@ export function WorkedBeforeGrid({ wb, myGrid, busy, currentCall, onRowDoubleCli
               {t('wbg.pickerDesc')}
             </DialogDescription>
           </DialogHeader>
+          {/* Whole-dialog controls — the award columns included, which the
+              catalogue-only helpers do not cover. */}
+          <div className="flex items-center gap-1 px-5 text-[11px] text-muted-foreground">
+            <span>{t('wbg.allGroups')}</span>
+            <button type="button" className="text-[11px] text-primary hover:underline px-1"
+              onClick={() => { showAll(); (awardCols ?? []).forEach((a) => setColVisible(`award_${a.code}`, true)); }}>
+              {t('wbg.all')}
+            </button>
+            <span className="opacity-40">·</span>
+            <button type="button" className="text-[11px] text-muted-foreground hover:underline px-1"
+              onClick={() => { hideAll(); (awardCols ?? []).forEach((a) => setColVisible(`award_${a.code}`, false)); }}>
+              {t('wbg.none')}
+            </button>
+          </div>
           <div className="grid grid-cols-2 gap-4 max-h-[60vh] overflow-y-auto px-5 py-3">
             {GROUP_ORDER.map((group) => {
               const cols = COL_CATALOG.filter((c) => c.group === group);

frontend/src/components/YaesuPanel.tsx

@@ -3,7 +3,7 @@ import { Radio, AudioLines, Mic, Activity, SlidersHorizontal, Antenna } from 'lu
 import {
   GetYaesuState, RefreshYaesuPanel,
   SetYaesuPower, SetYaesuMicGain, SetYaesuAFGain, SetYaesuRFGain, SetYaesuSquelch,
-  SetYaesuAGC, SetYaesuPreamp, SetYaesuAtt, SetYaesuNB, SetYaesuNR, SetYaesuNRLevel,
+  SetYaesuAGC, SetYaesuPreamp, SetYaesuAtt, SetYaesuAntenna, SetYaesuNB, SetYaesuNR, SetYaesuNRLevel,
   SetYaesuNarrow, SetYaesuVOX, SetYaesuSplit, SetYaesuBand, TuneYaesuATU,
   SetYaesuModeRaw, SetYaesuSplitOffset, SetYaesuKeySpeed, SetYaesuBreakIn, YaesuZeroIn, GetCATState,
 } from '../../wailsjs/go/main/App';
@@ -17,8 +17,9 @@ type YaesuState = {
   transmitting: boolean; split: boolean;
   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;
+  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;
 };
 
@@ -26,7 +27,7 @@ const ZERO: YaesuState = {
   available: false, transmitting: false, split: false,
   s_meter: 0, power_meter: 0, swr_meter: 0,
   rf_power: 0, mic_gain: 0, af_gain: 0, rf_gain: 0, squelch: 0,
-  preamp: 0, att: 0, nb: false, nr: false, nr_level: 0, narrow: false, vox: false,
+  preamp: 0, att: 0, antenna: 0, nb: false, nr: false, nr_level: 0, narrow: false, vox: false,
 };
 
 // Band buttons use the rig's OWN band memory (CAT "BS"), not a frequency we
@@ -74,6 +75,10 @@ function activeMode(raw?: string): { id: string; side: 'U' | 'L' } | null {
 // IPO bypasses the preamp entirely (best on a quiet, high-signal band), AMP1 and
 // AMP2 add gain. Presenting it as a toggle would hide the middle position.
 const PREAMPS = [{ v: '0', l: 'IPO' }, { v: '1', l: 'AMP1' }, { v: '2', l: 'AMP2' }];
+// Three jacks is the most any of these rigs has (FTDX101); an FTDX10 answers
+// with 1 or 2 and the third button simply never gets used. A rig with a single
+// socket answers nothing at all and reports 0, and the row is not drawn.
+const ANTENNAS = [{ v: '1', l: 'ANT1' }, { v: '2', l: 'ANT2' }, { v: '3', l: 'ANT3' }];
 const AGCS = [{ v: 'FAST', l: 'FAST' }, { v: 'MID', l: 'MID' }, { v: 'SLOW', l: 'SLOW' }, { v: 'AUTO', l: 'AUTO' }];
 // The attenuator is a three-step pad on these rigs (6/12/18 dB), not a toggle.
 const ATTS = [{ v: '0', l: 'OFF' }, { v: '6', l: '6dB' }, { v: '12', l: '12dB' }, { v: '18', l: '18dB' }];
@@ -424,6 +429,16 @@ export function YaesuPanel({ onReportRST, onKeySpeed }: {
         <Row label="ATT">
           <Segmented value={String(view.att)} options={ATTS} onChange={(v) => push('att', parseInt(v, 10), () => SetYaesuAtt(parseInt(v, 10)))} />
         </Row>
+        {/* Only on a rig that HAS a choice: 0 means the AN command went
+            unanswered, which is what a single-socket FT-891 does. And the
+            choice is remembered for the band it was made on — no table to
+            fill in anywhere, the backend learns it here. */}
+        {view.antenna > 0 && (
+          <Row label="ANT">
+            <Segmented value={String(view.antenna)} options={ANTENNAS}
+              onChange={(v) => push('antenna', parseInt(v, 10), () => SetYaesuAntenna(parseInt(v, 10)))} />
+          </Row>
+        )}
       </Card>
 
       {/* Noise + filter */}
@@ -431,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:
@@ -448,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/qsl/EditorPanel.tsx

@@ -10,6 +10,7 @@ import {
 } from '@/components/ui/select';
 import { Separator } from '@/components/ui/separator';
 import { cn } from '@/lib/utils';
+import { QSO_BOX_FIELDS, QSO_FIELD_LABELS } from './qslTypes';
 import type { CardTemplate, CardElement, QSOBox, QSLPresetInfo, StyleParams } from './qslTypes';
 import type { CardSelection } from './CardPreview';
 import { StylePresetPicker, NumberField } from './StylePresetPicker';
@@ -199,6 +200,26 @@ export function EditorPanel({ template, sel, presets, fontFamilies, onPatchEleme
               <Input className="h-7 w-44 font-mono text-xs" value={box.title ?? ''}
                 onChange={(ev) => onPatchBox({ title: ev.target.value })} />
             </div>
+            <div className="space-y-1">
+              <Label className="text-xs text-muted-foreground">Columns</Label>
+              {/* Rebuilt from the canonical order every time rather than
+                  appended to: a box whose columns come out in the order they
+                  were ticked reads as a bug, and the widths are tuned for this
+                  order. */}
+              <div className="grid grid-cols-2 gap-x-2">
+                {QSO_BOX_FIELDS.map((f) => (
+                  <label key={f} className="flex items-center gap-1.5 text-xs">
+                    <Checkbox
+                      checked={box.fields.includes(f)}
+                      onCheckedChange={(v) => onPatchBox({
+                        fields: QSO_BOX_FIELDS.filter((k) => (k === f ? v === true : box.fields.includes(k))),
+                      })}
+                    />
+                    {QSO_FIELD_LABELS[f] ?? f}
+                  </label>
+                ))}
+              </div>
+            </div>
             <div className="flex items-center justify-between gap-2">
               <Label className="text-xs text-muted-foreground">Footer</Label>
               <Input className="h-7 w-44 font-mono text-xs" value={box.footer}

frontend/src/components/qsl/qslTypes.ts

@@ -165,6 +165,12 @@ export interface QSLPresetInfo {
 }
 
 // Human labels for the QSO box fields the renderer knows.
+// QSO_BOX_FIELDS is the canonical COLUMN ORDER of the confirmation box, and
+// the whole list the designer offers. The renderer's column widths are tuned
+// for it, so a box is always rebuilt from this order rather than from the
+// order the operator happened to tick the boxes in.
+export const QSO_BOX_FIELDS = ['qso_date', 'time_on', 'band', 'freq', 'mode', 'submode', 'rst_sent'] as const;
+
 export const QSO_FIELD_LABELS: Record<string, string> = {
   qso_date: 'Date',
   time_on: 'UTC',

frontend/src/components/ui/combobox.tsx

@@ -1,4 +1,6 @@
-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';
 
@@ -7,6 +9,7 @@ import { cn } from '@/lib/utils';
 // can't hold a typo'd value that isn't in the list.
 export function Combobox({
   value, onChange, options, placeholder, className, allowFreeText = false, commitOnType = false,
+  showToggle = false,
 }: {
   value: string;
   onChange: (v: string) => void;
@@ -18,10 +21,26 @@ export function Combobox({
   // fields read live by other actions — e.g. RST, so a CW macro sent without
   // leaving the field uses the value just typed.
   commitOnType?: boolean;
+  // Draw a chevron that opens the full list on click.
+  //
+  // Without it this control is indistinguishable from a plain text box: it opens
+  // only on a keystroke or ArrowDown, both of which have to be known about
+  // first. That is fine for a field whose list is a convenience (RST), and wrong
+  // for one whose list is the ANSWER — the COM ports actually present on this
+  // machine, which nobody can be expected to recall.
+  showToggle?: boolean;
 }) {
   const [open, setOpen] = useState(false);
   const [query, setQuery] = useState('');
+  // Opened by the chevron rather than by typing: the whole list is on offer, not
+  // the part matching what is already in the field — a box holding COM7 would
+  // 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) {
@@ -31,20 +50,44 @@ export function Combobox({
     return () => document.removeEventListener('mousedown', onDoc);
   }, []);
 
-  const filtered = open
+  useLayoutEffect(() => {
-    ? options.filter((o) => o.toLowerCase().includes(query.toLowerCase())).slice(0, 60)
+    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);
 
   function commit(v: string) {
     onChange(v);
     setQuery(v);
     setOpen(false);
+    setBrowse(false);
   }
 
   function onBlur() {
     // Defer so a click on an option registers first.
     setTimeout(() => {
       setOpen(false);
+      setBrowse(false);
       const trimmed = query.trim();
       const exact = options.find((o) => o.toLowerCase() === trimmed.toLowerCase());
       // Only fire onChange when the value actually changed — committing an
@@ -68,6 +111,7 @@ export function Combobox({
           const v = e.target.value;
           setQuery(v);
           setOpen(true);
+          setBrowse(false); // typing filters again
           // Commit-on-type pushes the value live to the parent (so a CW macro sent
           // without leaving the field uses what was just typed). With free text that's
           // any input; a restricted field (allowFreeText=false) commits ONLY a value
@@ -76,16 +120,44 @@ export function Combobox({
           if (commitOnType && (allowFreeText || options.some((o) => o.toLowerCase() === v.trim().toLowerCase()))) onChange(v);
         }}
         onBlur={onBlur}
+        className={showToggle ? 'pr-7' : undefined}
         onKeyDown={(e) => {
-          if ((e.key === 'ArrowDown' || e.key === 'Alt') && !open) { setOpen(true); }
+          if ((e.key === 'ArrowDown' || e.key === 'Alt') && !open) { setOpen(true); setBrowse(true); }
           else if (e.key === 'Enter' && open && filtered.length > 0) { e.preventDefault(); commit(filtered[0]); }
           else if (e.key === 'Escape') { setQuery(value); setOpen(false); }
           // Tab: just let it move on; onBlur commits/closes. Options are
           // tabIndex=-1 so a single Tab leaves the field.
         }}
       />
-      {open && filtered.length > 0 && (
+      {showToggle && (
-        <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">
+        <button
+          type="button"
+          tabIndex={-1}
+          aria-label="Show list"
+          className="absolute inset-y-0 right-0 flex w-7 items-center justify-center text-muted-foreground hover:text-foreground"
+          // mousedown, not click: the input's blur fires first otherwise and
+          // closes the list the same instant this opens it.
+          onMouseDown={(e) => {
+            e.preventDefault();
+            if (open) { setOpen(false); setBrowse(false); return; }
+            setQuery(value);
+            setBrowse(true);
+            setOpen(true);
+          }}
+        >
+          <ChevronDown className="size-3.5" />
+        </button>
+      )}
+      {/* THE MENU IS PORTALLED to the body, and positioned from the field's own
+          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}
@@ -97,7 +169,8 @@ export function Combobox({
               {o}
             </button>
           ))}
-        </div>
+        </div>,
+        document.body,
       )}
     </div>
   );

frontend/src/lib/autocall.ts

@@ -0,0 +1,221 @@
+// Auto-call: let OpsLog answer a decode without the operator clicking it.
+//
+// WITHDRAWN FROM THE INTERFACE, because DXHunter already does it.
+//
+// Two programs from the same shack deciding on their own to answer the same
+// decode is worse than either doing it alone: they cannot see each other, so
+// they key over one another, and afterwards there is no telling which of them
+// called. The duplicate is the one to remove, and DXHunter is where this lives.
+//
+// There is no switch in Preferences and no button on the decodes toolbar, and
+// App.tsx returns before the loop can run. The file is kept whole: the rules
+// below are the delicate part, argued over and tested, and rewriting them from
+// memory later would be worse than leaving them here. Reinstating the feature
+// means restoring all three — the settings page, the button, and the guard.
+//
+// This KEYS THE TRANSMITTER on its own, which is why the rules here are written
+// as a series of refusals rather than a search for a reason to call. Everything
+// below has to be true; anything unknown means no.
+//
+// The decision is made here, in one pure function, precisely because it is the
+// dangerous part: it can be read, argued with and tested without a radio.
+
+export type AutoCallCriteria = {
+  dxcc: boolean;      // entity never worked
+  bandmode: boolean;  // entity worked, but neither this band nor this mode
+  band: boolean;      // entity never worked on this band
+  mode: boolean;      // entity never worked in this mode
+  slot: boolean;      // band and mode each worked, never together
+  grid: boolean;      // square wanted under the grid scope
+  county: boolean;    // US county never worked
+  pota: boolean;      // park never worked
+  // No SOTA here, though the shape invites it: a decode carries no summit
+  // reference and the backend publishes no "new summit" flag, so a criterion
+  // for it could never be true. It WAS declared, translated and impossible to
+  // tick — a field that lies about what the feature can do.
+  pfx: boolean;       // CQ WPX prefix never worked
+};
+
+export type AutoCallSettings = {
+  enabled: boolean;
+  criteria: AutoCallCriteria;
+  // Callsigns to answer on sight, wildcards allowed (4S7*, */P). Each is still
+  // subject to `watchCriteria` — "call TM0HQ, but only if it is a new band" is
+  // the request, not "call it every time it appears".
+  watch: string[];
+  // Empty means call a watched callsign whenever it is not already worked.
+  watchCriteria: AutoCallCriteria;
+  // Seconds to ignore a callsign after calling it, so a station that keeps
+  // sending CQ is not re-answered every slot while the QSO is in progress.
+  cooldownSec: number;
+};
+
+export const emptyCriteria: AutoCallCriteria = {
+  dxcc: false, bandmode: false, band: false, mode: false, slot: false,
+  grid: false, county: false, pota: false, pfx: false,
+};
+
+export const defaultAutoCall: AutoCallSettings = {
+  // OFF, and it stays off until asked for. Unattended transmit is not something
+  // to inherit from an upgrade.
+  enabled: false,
+  criteria: { ...emptyCriteria },
+  watch: [],
+  watchCriteria: { ...emptyCriteria },
+  cooldownSec: 120,
+};
+
+const AC_KEY = 'opslog.autoCall';
+
+export function loadAutoCall(): AutoCallSettings {
+  try {
+    const raw = localStorage.getItem(AC_KEY);
+    if (!raw) return { ...defaultAutoCall };
+    const v = JSON.parse(raw);
+    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 }; }
+}
+
+export const autoCallKey = AC_KEY;
+
+// A decode's resolved novelty, the same shape the panel already renders from.
+export type DecodeStatus = {
+  status?: string;
+  worked_call?: boolean;
+  new_grid?: boolean;
+  grid_state?: string;
+  new_county?: boolean;
+  new_pota?: boolean;
+  new_pfx?: boolean;
+};
+
+// matchesWildcard is the same rule the alert filters use: * is any run, ? is one.
+export function matchesWildcard(pattern: string, call: string): boolean {
+  const p = pattern.trim().toUpperCase();
+  const c = call.trim().toUpperCase();
+  if (!p) return false;
+  const re = new RegExp('^' + p.split('').map((ch) => (
+    ch === '*' ? '.*' : ch === '?' ? '.' : ch.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  )).join('') + '$');
+  return re.test(c);
+}
+
+// anyCriterion is false for an all-off set, which is what makes "watch this
+// callsign, no conditions" expressible.
+function anyCriterion(c: AutoCallCriteria): boolean {
+  return Object.values(c).some(Boolean);
+}
+
+// meets reports whether a decode satisfies at least one ticked criterion.
+function meets(c: AutoCallCriteria, e: DecodeStatus): boolean {
+  if (c.dxcc && e.status === 'new') return true;
+  // Each status is exclusive, so a station that is new on both counts matches
+  // ONLY this criterion — ticking "new band" alone would not catch it, which is
+  // the wrong way round: it is the better catch of the two.
+  if (c.bandmode && e.status === 'new-band-mode') return true;
+  if (c.band && e.status === 'new-band') return true;
+  if (c.mode && e.status === 'new-mode') return true;
+  if (c.slot && e.status === 'new-slot') return true;
+  // A square that is merely UNCONFIRMED is not called: the QSO is already made,
+  // and calling again would work a duplicate to chase a QSL.
+  if (c.grid && e.new_grid && e.grid_state !== 'unconf') return true;
+  if (c.county && e.new_county) return true;
+  if (c.pota && e.new_pota) return true;
+  if (c.pfx && e.new_pfx) return true;
+  return false;
+}
+
+export type AutoCallDecode = {
+  call: string;
+  cq?: boolean;
+  msg?: string;
+  instance?: string;
+};
+
+// shouldAutoCall decides whether to answer one decode. The reason is returned
+// for the log: an automatic transmission with no record of WHY is the thing an
+// operator cannot argue with after the fact.
+export function shouldAutoCall(
+  s: AutoCallSettings,
+  d: AutoCallDecode,
+  e: DecodeStatus | undefined,
+  opts: {
+    // busy is "some receiver is mid-QSO", NOT "this one is transmitting".
+    //
+    // The distinction is the whole bug it fixes: with two instances the caller
+    // used to test a single global transmit flag, which belonged to whichever
+    // receiver reported last. So while slice A worked a station, slice B looked
+    // idle and auto-call started another QSO on it — and the moment either
+    // finished it chained straight into the next. One station at a time means
+    // one across ALL receivers, not one per receiver.
+    busy: boolean;
+    calledAt: Map<string, number>;
+    now: number;
+    myCall?: string;
+  },
+): { call: boolean; reason: string } {
+  const no = (why: string) => ({ call: false, reason: why });
+  if (!s.enabled) return no('off');
+  if (!e) return no('status not resolved yet');
+  const call = (d.call ?? '').trim().toUpperCase();
+  if (!call) return no('no callsign');
+  // Never answer ourselves, however the decode reached us.
+  if (opts.myCall && call === opts.myCall.trim().toUpperCase()) return no('own callsign');
+  // NOT limited to a CQ, deliberately.
+  //
+  // It used to be, on the reasoning that answering a station mid-QSO is calling
+  // over somebody. That reasoning ignored the case the feature exists for: a
+  // DXpedition running a pileup never sends CQ at all — it works caller after
+  // caller — so the rule sat out the one contact auto-call was turned on for. A
+  // new entity on 15 m FT8, decode after decode, and not a single transmission.
+  //
+  // WHEN to transmit is not ours to decide either: the Reply goes to the
+  // decoder, and MSHV starts at once while JTDX waits for a CQ. Two correct
+  // behaviours, both belonging to the program that owns the timing. Here the
+  // question is only whether the station is one the operator wants — the
+  // criteria below answer that, and the cooldown and the busy check keep it from
+  // calling twice.
+  // Not while ANY receiver is mid-QSO — transmitting, or holding a DX call it
+  // has not finished with. Starting a second exchange before the first is done
+  // is what turned this into a machine that called without stopping.
+  if (opts.busy) return no('a QSO is already in progress');
+  const last = opts.calledAt.get(call);
+  if (last !== undefined && opts.now - last < s.cooldownSec * 1000) return no('called recently');
+
+  // The watch list first: an explicitly named station outranks the general
+  // criteria, and may carry conditions of its own.
+  const watched = s.watch.some((p) => matchesWildcard(p, call));
+  if (watched) {
+    if (!anyCriterion(s.watchCriteria)) {
+      // No conditions attached: call it unless it is already worked.
+      return e.worked_call ? no('watched, but already worked') : { call: true, reason: 'watch list' };
+    }
+    return meets(s.watchCriteria, e)
+      ? { call: true, reason: 'watch list + criteria' }
+      : no('watched, but no criterion met');
+  }
+
+  if (!anyCriterion(s.criteria)) return no('no criteria ticked');
+  return meets(s.criteria, e)
+    ? { call: true, reason: 'criteria' }
+    : no('no criterion met');
+}

frontend/src/lib/awardRefs.ts

@@ -205,6 +205,24 @@ export function spotRefList(byCode: Record<string, string>, fieldOf: Record<stri
 // A reference the operator typed or picked wins. A callbook entry can be years
 // old, and the operator in front of the radio has just been told where the
 // station is.
+// withRDARef adds a Russian district from the callbook to an entry's award
+// references, on the same terms as the island above.
+//
+// HamQTH publishes the district a station operates from TODAY. That is the
+// right answer for the contact being typed and the wrong one for any other, so
+// this is only ever called on the entry — never on a QSO already in the log.
+// A station can move district; stamping today's on last year's contact turns a
+// correct entry into a false one, and nothing downstream could tell.
+export function withRDARef(awardRefs: string, rda: string): string {
+  const ref = (rda || '').trim().toUpperCase();
+  // Two letters, a hyphen, two digits. Anything else is not a district.
+  if (!/^[A-Z]{2}-\d{2}$/.test(ref)) return awardRefs;
+  const byCode = parseAwardRefs(awardRefs);
+  if ((byCode['RDA'] ?? '').trim() !== '') return awardRefs; // already set: leave it
+  const sep = awardRefs.trim() === '' ? '' : ';';
+  return awardRefs + sep + 'RDA@' + ref;
+}
+
 export function withIOTARef(awardRefs: string, iota: string): string {
   const ref = (iota || '').trim().toUpperCase();
   // EU-048: two letters, a hyphen, three digits. Anything else is not an IOTA

frontend/src/lib/clusterMacros.ts

@@ -0,0 +1,57 @@
+// Cluster command macros — a named button for a command you would otherwise
+// retype.
+//
+// Twelve slots, fixed. A list you can grow needs add/remove/reorder controls and
+// a decision about what an empty row means; twelve boxes you fill in need
+// neither, and nobody has thirteen cluster commands they use daily. A slot with
+// no command is simply not drawn, so the toolbar is as long as the operator made
+// it and no longer.
+//
+// Stored through writeUiPref like every other portable preference, so the
+// buttons travel with data/ rather than living in one browser profile.
+
+import { writeUiPref } from '@/lib/uiPref';
+
+export type ClusterMacro = {
+  label: string; // what the button says
+  cmd: string;   // what is sent to the master server
+};
+
+export const CLUSTER_MACRO_COUNT = 12;
+export const clusterMacrosKey = 'opslog.clusterMacros';
+
+export const emptyClusterMacros = (): ClusterMacro[] =>
+  Array.from({ length: CLUSTER_MACRO_COUNT }, () => ({ label: '', cmd: '' }));
+
+// loadClusterMacros always returns exactly CLUSTER_MACRO_COUNT entries, whatever
+// was stored: a saved list from a build with fewer slots must not leave the
+// editor rendering undefined rows.
+export function loadClusterMacros(): ClusterMacro[] {
+  const out = emptyClusterMacros();
+  try {
+    const raw = localStorage.getItem(clusterMacrosKey);
+    if (!raw) return out;
+    const v = JSON.parse(raw);
+    if (!Array.isArray(v)) return out;
+    for (let i = 0; i < CLUSTER_MACRO_COUNT && i < v.length; i++) {
+      out[i] = {
+        label: String(v[i]?.label ?? '').slice(0, 24),
+        cmd: String(v[i]?.cmd ?? '').slice(0, 120),
+      };
+    }
+  } catch { /* a corrupt preference is not worth failing the panel over */ }
+  return out;
+}
+
+export function saveClusterMacros(macros: ClusterMacro[]): void {
+  writeUiPref(clusterMacrosKey, JSON.stringify(macros));
+}
+
+// visibleClusterMacros drops the slots that would send nothing. The COMMAND is
+// what decides: a slot with a label and no command is a button that lies, and a
+// command with no label still has something to show — its own text.
+export function visibleClusterMacros(macros: ClusterMacro[]): ClusterMacro[] {
+  return macros
+    .filter((m) => m.cmd.trim() !== '')
+    .map((m) => ({ label: m.label.trim() || m.cmd.trim(), cmd: m.cmd.trim() }));
+}

frontend/src/lib/rowColors.ts

@@ -16,10 +16,17 @@ export type RowColorSettings = {
   style?: 'bar' | 'tint' | 'both';
   intensity?: number;
   bandmap_lotw?: boolean;
+  recent_zebra?: string;        // '' = alternate (default), 'off' = every row alike
+  recent_zebra_color?: string;  // '' = follow the theme
   rules: RowColorRule[];
 };
 
-export const CHANNELS = ['qsl', 'lotw', 'eqsl', 'qrz'] as const;
+// The banding the grid theme applies on its own. Repeated here because turning
+// the option OFF means painting every row explicitly — the theme would
+// otherwise keep striping underneath whatever we do per row.
+const ZEBRA_DEFAULT = 'color-mix(in srgb, var(--muted) 40%, var(--card))';
+
+export const CHANNELS = ['qsl', 'lotw', 'eqsl', 'qrz', 'hamlog'] as const;
 
 // The two QSO fields behind each channel. QRZ.com and Club Log call theirs an
 // "upload status" rather than a QSL flag, but they carry the same Y / R letters.
@@ -30,6 +37,24 @@ const FIELDS: Record<string, { sent: string; rcvd: string }> = {
   qrz: { sent: 'qrzcom_qso_upload_status', rcvd: 'qrzcom_qso_download_status' },
 };
 
+// HAMLOG.online has no column of its own: the ADIF standard names a field for
+// hamlog.EU and none for hamlog.ONLINE, so its state lives in the extras — see
+// internal/award/award.go, which reads the same keys for award confirmations.
+// One vocabulary, two readers.
+const HAMLOG_SENT = 'APP_OPSLOG_HAMLOG_SENT';
+const HAMLOG_RCVD = ['APP_HAMLOG_QSO_CFM', 'APP_OPSLOG_HAMLOG_QSL', 'APP_HAMLOG_QSL', 'APP_HAMLOGONLINE_QSL', 'HAMLOG_QSL_RCVD'];
+
+// hamlogState reads a row's extras. Any value that is not an explicit "no"
+// counts, because their export could carry a date or a match id rather than Y.
+function hamlogState(q: any, which: 'sent' | 'rcvd'): boolean {
+  const e = (q?.extras ?? {}) as Record<string, string>;
+  const keys = which === 'sent' ? [HAMLOG_SENT] : HAMLOG_RCVD;
+  return keys.some((k) => {
+    const v = String(e[k] ?? '').trim();
+    return v !== '' && v.toUpperCase() !== 'N' && v.toUpperCase() !== 'NO';
+  });
+}
+
 // ADIF QSL fields are single letters. Y is the only one that means "yes";
 // R (requested) and Q (queued) mean it has not gone out yet — a different state,
 // and the one an operator looks for when deciding what to send.
@@ -48,14 +73,18 @@ function ruleMatches(q: any, r: RowColorRule): boolean {
   const cs = chansOf(r);
   switch (r.id) {
     case 'confirmed':
-      return cs.some((c) => yes(q[FIELDS[c]?.rcvd]));
+      return cs.some((c) => (c === 'hamlog' ? hamlogState(q, 'rcvd') : yes(q[FIELDS[c]?.rcvd])));
     case 'sent':
-      return cs.some((c) => yes(q[FIELDS[c]?.sent]));
+      return cs.some((c) => (c === 'hamlog' ? hamlogState(q, 'sent') : yes(q[FIELDS[c]?.sent])));
     case 'to_send':
-      return cs.some((c) => owed(q[FIELDS[c]?.sent]));
+      // Nothing to request from HAMLOG: a QSO is either uploaded or it is not,
+      // there is no "card asked for" state to be owed.
+      return cs.some((c) => c !== 'hamlog' && owed(q[FIELDS[c]?.sent]));
     case 'worked':
       // The catch-all: nothing sent, nothing asked for, nothing back.
-      return !CHANNELS.some((c) => yes(q[FIELDS[c].rcvd]) || yes(q[FIELDS[c].sent]) || owed(q[FIELDS[c].sent]));
+      return !CHANNELS.some((c) => (c === 'hamlog'
+        ? hamlogState(q, 'rcvd') || hamlogState(q, 'sent')
+        : yes(q[FIELDS[c].rcvd]) || yes(q[FIELDS[c].sent]) || owed(q[FIELDS[c].sent])));
     default:
       return false;
   }
@@ -76,21 +105,43 @@ export function matchRowRule(q: any, cfg: RowColorSettings | null): RowColorRule
 // A log where nearly every contact has SOME QSL state ends up with every row
 // painted, and colour that is always present stops being information. The
 // default is a stripe down the left edge; a tint is offered at a chosen strength.
-export function rowStyleFor(q: any, cfg: RowColorSettings | null): Record<string, string> | undefined {
+// rowIndex is optional: only the Recent QSOs grid bands its rows, and the other
-  if (!cfg?.enabled) return undefined;
+// callers have nothing to say about odd and even.
+export function rowStyleFor(q: any, cfg: RowColorSettings | null, rowIndex?: number): Record<string, string> | undefined {
+  const out: Record<string, string> = {};
+  // Banding first, and INDEPENDENT of cfg.enabled: it is legibility, not QSL
+  // status, and an operator who wants plain rows should not have to turn the
+  // status colours off to get them.
+  if (typeof rowIndex === 'number') {
+    if (cfg?.recent_zebra === 'off') {
+      out.backgroundColor = 'var(--card)';
+    } else if (rowIndex % 2 === 1) {
+      out.backgroundColor = cfg?.recent_zebra_color || ZEBRA_DEFAULT;
+    }
+  }
+  const empty = () => (Object.keys(out).length ? out : undefined);
+  if (!cfg?.enabled) return empty();
   const rule = matchRowRule(q, cfg);
-  if (!rule?.color) return undefined;
+  if (!rule?.color) return empty();
 
   const style = cfg.style ?? 'bar';
   const pct = Math.max(5, Math.min(45, cfg.intensity ?? 12));
-  const out: Record<string, string> = {};
   if (style === 'tint' || style === 'both') {
+    // Overrides the banding on purpose: the QSL colour is information, the
+    // banding is only there to help the eye keep its line.
     out.backgroundColor = `color-mix(in srgb, ${rule.color} ${pct}%, transparent)`;
   }
   if (style === 'bar' || style === 'both') {
-    // inset shadow rather than a border: a border would shift the cells three
+    // A background gradient, not a border and not a shadow.
-    // pixels on coloured rows only, and the columns would stop lining up.
+    //
-    out.boxShadow = `inset 3px 0 0 ${rule.color}`;
+    // A border would shift the cells three pixels on coloured rows only, and
+    // the columns would stop lining up. An inset box-shadow was the first fix
+    // for that and drew the stripe correctly — but on the grid's transformed,
+    // absolutely-positioned rows it also bled a hairline of the same colour
+    // along the row edges, so every coloured row got a horizontal rule it was
+    // never meant to have. A gradient paints inside the box and nothing else:
+    // three pixels of colour, then transparent, and no edge to bleed from.
+    out.backgroundImage = `linear-gradient(to right, ${rule.color} 0, ${rule.color} 3px, transparent 3px)`;
   }
   return out;
 }

frontend/src/lib/uiPref.ts

@@ -17,6 +17,8 @@ const PORTABLE_KEYS = [
   'opslog.autofocusWB',   // auto-focus Worked-before
   'hamlog.filterPresets', // Filter Builder saved presets
   'opslog.showRotor',     // rotor compass shown next to the keyers
+  'opslog.rotorCompact',  // rotor widget: dial + SP/LP only, no quick-turn buttons or Stop
+  'opslog.decodesGridMap',// FT decodes tab: grid-square map shown beside the table
   'opslog.showChaseNew',  // Chase New panel shown next to the keyers
   'opslog.showAmpWidget', // amplifier widget shown next to the keyers
   'opslog.ampSel.widget', // which amplifier that widget shows ("all" or an amp id)
@@ -39,12 +41,19 @@ const PORTABLE_KEYS = [
   'opslog.clusterLockBand', 'opslog.clusterLockMode', 'opslog.clusterStatusFilter',
   'opslog.clusterModeFilter', 'opslog.clusterSearch', 'opslog.clusterHideWorked',
   'opslog.activeTab',     // last selected tab
-  'opslog.mainSplit',    // Main tab: width share of the left pane (percent)
+  'opslog.mainSplit',    // Main tab: width share of the left pane (percent) — legacy, read once to seed mainShares
+  'opslog.mainShares',   // Main tab: column shares per column count, as {2:[..],3:[..],4:[..]}
+  'opslog.mainQuad',     // Main tab: the 2x2 cross, as {col,row} percentages
   'opslog.clusterMuteWorked',    // cluster/band map: no colour or badge on worked spots
   'opslog.clusterSlotHighlight', // cluster/band map: colour calls not worked on this band+mode
   'opslog.bandMapWidth',    // docked band map: column width (px)
   'opslog.bandMapTabWidth', // Band map tab: shared card width (px)
   'opslog.bandMapZoom',     // band map zoom (px/kHz step) remembered per band, as one {band: index} map
+  'opslog.decodeColWidths', // FT decodes table: per-column widths (px), as one {col: px} map
+  'opslog.clusterMacros',   // cluster console: the twelve named command buttons
+  'opslog.clusterHideSpots', // cluster console: hide the DX spot flood so replies are readable
+  'opslog.clusterConsoleFollow', // cluster console: keep the view pinned to the newest line
+  'opslog.gridMapColorConfirmed', 'opslog.gridMapColorWorked', // grid map: chosen fills (empty = follow the theme)
   // NOTE: 'hamlog.awardColsShown' and the grid column layouts are NOT listed here.
   // They are handled by lib/gridPrefs, which scopes the localStorage cache PER
   // PROFILE and mirrors to the DB (already per-profile) itself — mirroring them

frontend/src/style.css

@@ -991,6 +991,18 @@
 @layer base {
   * { @apply border-border; }
   html, body, #root { height: 100%; }
+  /* No rubber-band, and no swipe-to-navigate.
+
+     Chromium lets a scroll that has reached the end pull the content a few
+     pixels and spring back, and a two-finger horizontal swipe means "go back a
+     page". Both are browser behaviours that have no meaning in a logbook: the
+     first makes a table wobble at the bottom of a list, and the second can
+     navigate the WebView away from the app entirely — a blank window and a
+     restart. Neither shows up with a mouse, which is why they went unnoticed;
+     they arrive with a precision touchpad or a touchscreen.
+
+     A no-op wherever the effects don't occur. */
+  html, body { overscroll-behavior: none; }
   /* Root rem base. Tailwind sizing (text/heights/padding/gaps) is in rem, so
      this is the single global density knob — shrinks the whole UI uniformly
      while Leaflet maps (px-based) stay correct. Default browser base is 16px. */
@@ -1055,3 +1067,15 @@
   filter: invert(1) brightness(1.8);
   opacity: 0.9;
 }
+
+/* Every scrollable pane keeps its overscroll to itself.
+
+   "contain" (not "none") on the inside: the pane still scrolls normally, it
+   simply stops passing the leftover motion up to its parent — which is how
+   scrolling a grid to its end used to tug the panel behind it. */
+.overflow-auto,
+.overflow-y-auto,
+.overflow-x-auto,
+.overflow-scroll {
+  overscroll-behavior: contain;
+}

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.25.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

@@ -53,6 +53,8 @@ export function AmpPower(arg1:string,arg2:boolean):Promise<void>;
 
 export function AmpPowerLevel(arg1:string,arg2:string):Promise<void>;
 
+export function AnswerDecode(arg1:string,arg2:number,arg3:number,arg4:number,arg5:number,arg6:string,arg7:string,arg8:boolean):Promise<void>;
+
 export function AntGeniusActivate(arg1:number,arg2:number):Promise<void>;
 
 export function AntGeniusDeselect(arg1:number):Promise<void>;
@@ -87,10 +89,14 @@ export function AwardMissingQSOs(arg1:string):Promise<Array<qso.QSO>>;
 
 export function AwardRefsForQSOs(arg1:Array<number>):Promise<Record<number, Record<string, string>>>;
 
+export function AwardRefsNew(arg1:Array<string>):Promise<main.AwardRefNewResult>;
+
 export function AwardsFolder():Promise<string>;
 
 export function BackfillDistances():Promise<main.BackfillDistancesResult>;
 
+export function BackfillRDA(arg1:boolean):Promise<main.BackfillRDAResult>;
+
 export function BackfillUSCounties():Promise<main.BackfillUSCountiesResult>;
 
 export function BandSlotQSOs(arg1:string,arg2:number,arg3:string,arg4:string):Promise<Array<qso.QSO>>;
@@ -111,10 +117,20 @@ export function ChatAvailable():Promise<boolean>;
 
 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>;
+
 export function ClusterSpotStatuses(arg1:Array<main.SpotQuery>):Promise<Array<main.SpotStatus>>;
 
+export function CompactDatabase(arg1:string):Promise<main.CompactResult>;
+
+export function CompareRDASources():Promise<main.RDACompareResult>;
+
 export function ComputeQSOAwardRefs(arg1:qso.QSO):Promise<Array<main.QSOAwardRef>>;
 
 export function ComputeStationInfo(arg1:string,arg2:string):Promise<main.StationInfoComputed>;
@@ -219,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>>;
@@ -355,8 +373,14 @@ export function FlexSetXITFreq(arg1:number):Promise<void>;
 
 export function FlexStopCW():Promise<void>;
 
+export function FlexTXOnBand(arg1:string):Promise<void>;
+
 export function FlexTune(arg1:boolean):Promise<void>;
 
+export function FlexZoomForSpot(arg1:string,arg2:number):Promise<void>;
+
+export function ForgetYaesuBandAntenna(arg1:string):Promise<void>;
+
 export function GetACOMStatus():Promise<acom.Status>;
 
 export function GetADIFMonitor():Promise<main.ADIFMonitorConfig>;
@@ -449,16 +473,24 @@ 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>;
+
 export function GetFolderSync():Promise<main.FolderSyncConfig>;
 
 export function GetFolderSyncStatus():Promise<main.FolderSyncStatus>;
 
 export function GetGridCacheStatus():Promise<main.GridCacheStatus>;
 
+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>;
@@ -529,6 +561,10 @@ export function GetSlotStats():Promise<qso.SlotStats>;
 
 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>;
@@ -565,8 +601,14 @@ export function GetWinkeyerStatus():Promise<winkeyer.Status>;
 
 export function GetWorkedCallVariants():Promise<boolean>;
 
+export function GetYaesuBandAntennas():Promise<Record<string, number>>;
+
 export function GetYaesuState():Promise<cat.YaesuTXState>;
 
+export function GridSquares(arg1:string):Promise<Array<qso.GridSquare>>;
+
+export function HaltDecodeTx(arg1:string,arg2:boolean):Promise<void>;
+
 export function HasBuiltinReferences(arg1:string):Promise<boolean>;
 
 export function IcomRefresh():Promise<void>;
@@ -661,6 +703,8 @@ export function ImportAwardReferencesText(arg1:string,arg2:string):Promise<numbe
 
 export function ImportAwards():Promise<main.AwardImportResult>;
 
+export function ImportHamlogConfirmations(arg1:string):Promise<main.HamlogCfmResult>;
+
 export function InspectAwardImport():Promise<main.AwardImportPreview>;
 
 export function IsNewUSCounty(arg1:string,arg2:string):Promise<boolean>;
@@ -759,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>;
@@ -853,10 +899,16 @@ export function QSOAudioStop():Promise<boolean>;
 
 export function QuitApp():Promise<void>;
 
+export function RDADatabaseCount():Promise<number>;
+
 export function RecomputeAllAwardRefs():Promise<number>;
 
+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>;
@@ -887,6 +939,8 @@ export function ResetDatabaseToDefault():Promise<void>;
 
 export function ResetRotorPresets():Promise<Array<main.RotorPreset>>;
 
+export function ResetSpotColors():Promise<main.SpotColors>;
+
 export function RestartApp():Promise<void>;
 
 export function RestartQSORecorder():Promise<void>;
@@ -949,8 +1003,14 @@ 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>;
 
+export function SaveGridScopeSettings(arg1:main.GridScopeSettings):Promise<void>;
+
 export function SaveListsSettings(arg1:main.ListsSettings):Promise<void>;
 
 export function SaveLookupSettings(arg1:main.LookupSettings):Promise<void>;
@@ -983,6 +1043,8 @@ export function SaveRowColors(arg1:main.RowColorSettings):Promise<void>;
 
 export function SaveSelfSpotSettings(arg1:main.SelfSpotSettings):Promise<void>;
 
+export function SaveSpotColors(arg1:main.SpotColors):Promise<void>;
+
 export function SaveStationDevices(arg1:Array<main.StationDevice>):Promise<void>;
 
 export function SaveStationSettings(arg1:main.StationSettings):Promise<void>;
@@ -1009,6 +1071,8 @@ export function SendClusterCommand(arg1:string):Promise<void>;
 
 export function SendClusterSpot(arg1:string,arg2:number,arg3:string):Promise<void>;
 
+export function SendDecodeFreeText(arg1:string,arg2:string,arg3:boolean):Promise<void>;
+
 export function SendEQSL(arg1:number,arg2:number,arg3:string):Promise<void>;
 
 export function SendLogToDeveloper():Promise<void>;
@@ -1043,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>;
@@ -1057,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>;
@@ -1073,6 +1171,8 @@ export function SetYaesuAFGain(arg1:number):Promise<void>;
 
 export function SetYaesuAGC(arg1:string):Promise<void>;
 
+export function SetYaesuAntenna(arg1:number):Promise<void>;
+
 export function SetYaesuAtt(arg1:number):Promise<void>;
 
 export function SetYaesuBand(arg1:string):Promise<void>;
@@ -1149,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>;
@@ -1201,6 +1305,8 @@ export function WinkeyerTraceEnabled():Promise<boolean>;
 
 export function WorkedBefore(arg1:string,arg2:number):Promise<qso.WorkedBefore>;
 
+export function YaesuApplyBandAntenna(arg1:string):Promise<void>;
+
 export function YaesuSendCW(arg1:string):Promise<void>;
 
 export function YaesuStopCW():Promise<void>;

frontend/wailsjs/go/main/App.js

@@ -46,6 +46,10 @@ export function AmpPowerLevel(arg1, arg2) {
   return window['go']['main']['App']['AmpPowerLevel'](arg1, arg2);
 }
 
+export function AnswerDecode(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) {
+  return window['go']['main']['App']['AnswerDecode'](arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+}
+
 export function AntGeniusActivate(arg1, arg2) {
   return window['go']['main']['App']['AntGeniusActivate'](arg1, arg2);
 }
@@ -114,6 +118,10 @@ export function AwardRefsForQSOs(arg1) {
   return window['go']['main']['App']['AwardRefsForQSOs'](arg1);
 }
 
+export function AwardRefsNew(arg1) {
+  return window['go']['main']['App']['AwardRefsNew'](arg1);
+}
+
 export function AwardsFolder() {
   return window['go']['main']['App']['AwardsFolder']();
 }
@@ -122,6 +130,10 @@ export function BackfillDistances() {
   return window['go']['main']['App']['BackfillDistances']();
 }
 
+export function BackfillRDA(arg1) {
+  return window['go']['main']['App']['BackfillRDA'](arg1);
+}
+
 export function BackfillUSCounties() {
   return window['go']['main']['App']['BackfillUSCounties']();
 }
@@ -162,14 +174,34 @@ export function CheckForUpdate() {
   return window['go']['main']['App']['CheckForUpdate']();
 }
 
+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']();
 }
 
+export function CloseAutostartPrograms() {
+  return window['go']['main']['App']['CloseAutostartPrograms']();
+}
+
 export function ClusterSpotStatuses(arg1) {
   return window['go']['main']['App']['ClusterSpotStatuses'](arg1);
 }
 
+export function CompactDatabase(arg1) {
+  return window['go']['main']['App']['CompactDatabase'](arg1);
+}
+
+export function CompareRDASources() {
+  return window['go']['main']['App']['CompareRDASources']();
+}
+
 export function ComputeQSOAwardRefs(arg1) {
   return window['go']['main']['App']['ComputeQSOAwardRefs'](arg1);
 }
@@ -378,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']();
 }
@@ -650,10 +686,22 @@ export function FlexStopCW() {
   return window['go']['main']['App']['FlexStopCW']();
 }
 
+export function FlexTXOnBand(arg1) {
+  return window['go']['main']['App']['FlexTXOnBand'](arg1);
+}
+
 export function FlexTune(arg1) {
   return window['go']['main']['App']['FlexTune'](arg1);
 }
 
+export function FlexZoomForSpot(arg1, arg2) {
+  return window['go']['main']['App']['FlexZoomForSpot'](arg1, arg2);
+}
+
+export function ForgetYaesuBandAntenna(arg1) {
+  return window['go']['main']['App']['ForgetYaesuBandAntenna'](arg1);
+}
+
 export function GetACOMStatus() {
   return window['go']['main']['App']['GetACOMStatus']();
 }
@@ -838,10 +886,18 @@ 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']();
 }
 
+export function GetFlexZoom() {
+  return window['go']['main']['App']['GetFlexZoom']();
+}
+
 export function GetFolderSync() {
   return window['go']['main']['App']['GetFolderSync']();
 }
@@ -854,10 +910,18 @@ export function GetGridCacheStatus() {
   return window['go']['main']['App']['GetGridCacheStatus']();
 }
 
+export function GetGridScopeSettings() {
+  return window['go']['main']['App']['GetGridScopeSettings']();
+}
+
 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']();
 }
@@ -998,6 +1062,14 @@ export function GetSolarData() {
   return window['go']['main']['App']['GetSolarData']();
 }
 
+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']();
 }
@@ -1070,10 +1142,22 @@ export function GetWorkedCallVariants() {
   return window['go']['main']['App']['GetWorkedCallVariants']();
 }
 
+export function GetYaesuBandAntennas() {
+  return window['go']['main']['App']['GetYaesuBandAntennas']();
+}
+
 export function GetYaesuState() {
   return window['go']['main']['App']['GetYaesuState']();
 }
 
+export function GridSquares(arg1) {
+  return window['go']['main']['App']['GridSquares'](arg1);
+}
+
+export function HaltDecodeTx(arg1, arg2) {
+  return window['go']['main']['App']['HaltDecodeTx'](arg1, arg2);
+}
+
 export function HasBuiltinReferences(arg1) {
   return window['go']['main']['App']['HasBuiltinReferences'](arg1);
 }
@@ -1262,6 +1346,10 @@ export function ImportAwards() {
   return window['go']['main']['App']['ImportAwards']();
 }
 
+export function ImportHamlogConfirmations(arg1) {
+  return window['go']['main']['App']['ImportHamlogConfirmations'](arg1);
+}
+
 export function InspectAwardImport() {
   return window['go']['main']['App']['InspectAwardImport']();
 }
@@ -1458,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']();
 }
@@ -1646,14 +1738,26 @@ export function QuitApp() {
   return window['go']['main']['App']['QuitApp']();
 }
 
+export function RDADatabaseCount() {
+  return window['go']['main']['App']['RDADatabaseCount']();
+}
+
 export function RecomputeAllAwardRefs() {
   return window['go']['main']['App']['RecomputeAllAwardRefs']();
 }
 
+export function RecomputeAwardRefsForCode(arg1) {
+  return window['go']['main']['App']['RecomputeAwardRefsForCode'](arg1);
+}
+
 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']();
 }
@@ -1714,6 +1818,10 @@ export function ResetRotorPresets() {
   return window['go']['main']['App']['ResetRotorPresets']();
 }
 
+export function ResetSpotColors() {
+  return window['go']['main']['App']['ResetSpotColors']();
+}
+
 export function RestartApp() {
   return window['go']['main']['App']['RestartApp']();
 }
@@ -1838,10 +1946,22 @@ 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);
+}
+
 export function SaveFolderSync(arg1) {
   return window['go']['main']['App']['SaveFolderSync'](arg1);
 }
 
+export function SaveGridScopeSettings(arg1) {
+  return window['go']['main']['App']['SaveGridScopeSettings'](arg1);
+}
+
 export function SaveListsSettings(arg1) {
   return window['go']['main']['App']['SaveListsSettings'](arg1);
 }
@@ -1906,6 +2026,10 @@ export function SaveSelfSpotSettings(arg1) {
   return window['go']['main']['App']['SaveSelfSpotSettings'](arg1);
 }
 
+export function SaveSpotColors(arg1) {
+  return window['go']['main']['App']['SaveSpotColors'](arg1);
+}
+
 export function SaveStationDevices(arg1) {
   return window['go']['main']['App']['SaveStationDevices'](arg1);
 }
@@ -1958,6 +2082,10 @@ export function SendClusterSpot(arg1, arg2, arg3) {
   return window['go']['main']['App']['SendClusterSpot'](arg1, arg2, arg3);
 }
 
+export function SendDecodeFreeText(arg1, arg2, arg3) {
+  return window['go']['main']['App']['SendDecodeFreeText'](arg1, arg2, arg3);
+}
+
 export function SendEQSL(arg1, arg2, arg3) {
   return window['go']['main']['App']['SendEQSL'](arg1, arg2, arg3);
 }
@@ -2026,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);
 }
@@ -2054,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);
 }
@@ -2086,6 +2282,10 @@ export function SetYaesuAGC(arg1) {
   return window['go']['main']['App']['SetYaesuAGC'](arg1);
 }
 
+export function SetYaesuAntenna(arg1) {
+  return window['go']['main']['App']['SetYaesuAntenna'](arg1);
+}
+
 export function SetYaesuAtt(arg1) {
   return window['go']['main']['App']['SetYaesuAtt'](arg1);
 }
@@ -2238,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']();
 }
@@ -2342,6 +2550,10 @@ export function WorkedBefore(arg1, arg2) {
   return window['go']['main']['App']['WorkedBefore'](arg1, arg2);
 }
 
+export function YaesuApplyBandAntenna(arg1) {
+  return window['go']['main']['App']['YaesuApplyBandAntenna'](arg1);
+}
+
 export function YaesuSendCW(arg1) {
   return window['go']['main']['App']['YaesuSendCW'](arg1);
 }

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,12 +1222,15 @@ 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;
 	    squelch: number;
 	    agc?: string;
 	    preamp: number;
+	    antenna: number;
 	    att: number;
 	    nb: boolean;
 	    nr: boolean;
@@ -1188,12 +1259,15 @@ 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"];
 	        this.squelch = source["squelch"];
 	        this.agc = source["agc"];
 	        this.preamp = source["preamp"];
+	        this.antenna = source["antenna"];
 	        this.att = source["att"];
 	        this.nb = source["nb"];
 	        this.nr = source["nr"];
@@ -1367,6 +1441,7 @@ export namespace extsvc {
 	    hrdlog: ServiceConfig;
 	    eqsl: ServiceConfig;
 	    cloudlog: ServiceConfig;
+	    hamlog: ServiceConfig;
 	    delete_remote: boolean;
 	
 	    static createFrom(source: any = {}) {
@@ -1381,6 +1456,7 @@ export namespace extsvc {
 	        this.hrdlog = this.convertValues(source["hrdlog"], ServiceConfig);
 	        this.eqsl = this.convertValues(source["eqsl"], ServiceConfig);
 	        this.cloudlog = this.convertValues(source["cloudlog"], ServiceConfig);
+	        this.hamlog = this.convertValues(source["hamlog"], ServiceConfig);
 	        this.delete_remote = source["delete_remote"];
 	    }
 	
@@ -1445,6 +1521,7 @@ export namespace lookup {
 	    qsl_via?: string;
 	    web?: string;
 	    iota?: string;
+	    rda?: string;
 	    zip?: string;
 	    image_url?: string;
 	    source: string;
@@ -1475,6 +1552,7 @@ export namespace lookup {
 	        this.qsl_via = source["qsl_via"];
 	        this.web = source["web"];
 	        this.iota = source["iota"];
+	        this.rda = source["rda"];
 	        this.zip = source["zip"];
 	        this.image_url = source["image_url"];
 	        this.source = source["source"];
@@ -1660,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);
@@ -1670,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 {
@@ -1734,6 +1816,7 @@ export namespace main {
 	    path: string;
 	    args: string;
 	    enabled: boolean;
+	    close_on_exit?: boolean;
 	
 	    static createFrom(source: any = {}) {
 	        return new AutostartProgram(source);
@@ -1746,6 +1829,7 @@ export namespace main {
 	        this.path = source["path"];
 	        this.args = source["args"];
 	        this.enabled = source["enabled"];
+	        this.close_on_exit = source["close_on_exit"];
 	    }
 	}
 	export class AwardExplain {
@@ -1869,6 +1953,20 @@ export namespace main {
 	        this.can_update = source["can_update"];
 	    }
 	}
+	export class AwardRefNewResult {
+	    new: Record<string, boolean>;
+	    pending: boolean;
+	
+	    static createFrom(source: any = {}) {
+	        return new AwardRefNewResult(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.new = source["new"];
+	        this.pending = source["pending"];
+	    }
+	}
 	export class AwardStatRow {
 	    label: string;
 	    cells: number[];
@@ -1955,6 +2053,26 @@ export namespace main {
 	        this.no_grid = source["no_grid"];
 	    }
 	}
+	export class BackfillRDAResult {
+	    scanned: number;
+	    dated: number;
+	    current: number;
+	    unknown: number;
+	    skipped: number;
+	
+	    static createFrom(source: any = {}) {
+	        return new BackfillRDAResult(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.scanned = source["scanned"];
+	        this.dated = source["dated"];
+	        this.current = source["current"];
+	        this.unknown = source["unknown"];
+	        this.skipped = source["skipped"];
+	    }
+	}
 	export class BackfillUSCountiesResult {
 	    scanned: number;
 	    county: number;
@@ -2001,6 +2119,7 @@ export namespace main {
 	    enabled: boolean;
 	    bands: string[];
 	    available: string[];
+	    near_km: number;
 	
 	    static createFrom(source: any = {}) {
 	        return new BandOpenSettings(source);
@@ -2011,6 +2130,7 @@ export namespace main {
 	        this.enabled = source["enabled"];
 	        this.bands = source["bands"];
 	        this.available = source["available"];
+	        this.near_km = source["near_km"];
 	    }
 	}
 	export class CATSettings {
@@ -2032,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;
@@ -2083,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"];
@@ -2255,6 +2377,24 @@ export namespace main {
 	        this.count = source["count"];
 	    }
 	}
+	export class CompactResult {
+	    path: string;
+	    backend: string;
+	    before: number;
+	    after: number;
+	
+	    static createFrom(source: any = {}) {
+	        return new CompactResult(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.path = source["path"];
+	        this.backend = source["backend"];
+	        this.before = source["before"];
+	        this.after = source["after"];
+	    }
+	}
 	export class ContestBandRow {
 	    band: string;
 	    count: number;
@@ -2475,6 +2615,44 @@ 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;
+	    ssb_khz: number;
+	    digi_khz: number;
+	    centre: boolean;
+	
+	    static createFrom(source: any = {}) {
+	        return new FlexZoomSettings(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.enabled = source["enabled"];
+	        this.cw_khz = source["cw_khz"];
+	        this.ssb_khz = source["ssb_khz"];
+	        this.digi_khz = source["digi_khz"];
+	        this.centre = source["centre"];
+	    }
+	}
 	export class FolderSyncConfig {
 	    enabled: boolean;
 	    folder: string;
@@ -2567,6 +2745,78 @@ export namespace main {
 	        this.pending = source["pending"];
 	    }
 	}
+	export class gridScope {
+	    key: string;
+	    band: boolean;
+	    mode: string;
+	
+	    static createFrom(source: any = {}) {
+	        return new gridScope(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.key = source["key"];
+	        this.band = source["band"];
+	        this.mode = source["mode"];
+	    }
+	}
+	export class GridScopeSettings {
+	    scope: string;
+	    hunt: string;
+	    scopes: gridScope[];
+	
+	    static createFrom(source: any = {}) {
+	        return new GridScopeSettings(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.scope = source["scope"];
+	        this.hunt = source["hunt"];
+	        this.scopes = this.convertValues(source["scopes"], gridScope);
+	    }
+	
+		convertValues(a: any, classs: any, asMap: boolean = false): any {
+		    if (!a) {
+		        return a;
+		    }
+		    if (a.slice && a.map) {
+		        return (a as any[]).map(elem => this.convertValues(elem, classs));
+		    } else if ("object" === typeof a) {
+		        if (asMap) {
+		            for (const key of Object.keys(a)) {
+		                a[key] = new classs(a[key]);
+		            }
+		            return a;
+		        }
+		        return new classs(a);
+		    }
+		    return a;
+		}
+	}
+	export class HamlogCfmResult {
+	    total: number;
+	    confirmed: number;
+	    matched: number;
+	    by_class: number;
+	    unmatched: number;
+	    samples: string[];
+	
+	    static createFrom(source: any = {}) {
+	        return new HamlogCfmResult(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.total = source["total"];
+	        this.confirmed = source["confirmed"];
+	        this.matched = source["matched"];
+	        this.by_class = source["by_class"];
+	        this.unmatched = source["unmatched"];
+	        this.samples = source["samples"];
+	    }
+	}
 	export class ModePreset {
 	    name: string;
 	    default_rst_sent?: string;
@@ -2589,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);
@@ -2601,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 {
@@ -2900,6 +3152,8 @@ export namespace main {
 	    hrdlog_status: string;
 	    qrzcom_status: string;
 	    qrzcom_confirmed: string;
+	    hamlog_status: string;
+	    hamlog_confirmed: string;
 	
 	    static createFrom(source: any = {}) {
 	        return new QSLDefaults(source);
@@ -2917,6 +3171,8 @@ export namespace main {
 	        this.hrdlog_status = source["hrdlog_status"];
 	        this.qrzcom_status = source["qrzcom_status"];
 	        this.qrzcom_confirmed = source["qrzcom_confirmed"];
+	        this.hamlog_status = source["hamlog_status"];
+	        this.hamlog_confirmed = source["hamlog_confirmed"];
 	    }
 	}
 	export class QSLEmailTemplates {
@@ -3093,6 +3349,79 @@ export namespace main {
 	        this.team_last60 = source["team_last60"];
 	    }
 	}
+	export class RDAConflict {
+	    qso_id: number;
+	    callsign: string;
+	    date: string;
+	    band: string;
+	    mode: string;
+	    from_log: string;
+	    from_db: string;
+	    dated: boolean;
+	    confirmed: boolean;
+	
+	    static createFrom(source: any = {}) {
+	        return new RDAConflict(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.qso_id = source["qso_id"];
+	        this.callsign = source["callsign"];
+	        this.date = source["date"];
+	        this.band = source["band"];
+	        this.mode = source["mode"];
+	        this.from_log = source["from_log"];
+	        this.from_db = source["from_db"];
+	        this.dated = source["dated"];
+	        this.confirmed = source["confirmed"];
+	    }
+	}
+	export class RDACompareResult {
+	    scanned: number;
+	    both_known: number;
+	    agree: number;
+	    disagree: number;
+	    only_log: number;
+	    only_db: number;
+	    neither: number;
+	    conflicts: RDAConflict[];
+	
+	    static createFrom(source: any = {}) {
+	        return new RDACompareResult(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.scanned = source["scanned"];
+	        this.both_known = source["both_known"];
+	        this.agree = source["agree"];
+	        this.disagree = source["disagree"];
+	        this.only_log = source["only_log"];
+	        this.only_db = source["only_db"];
+	        this.neither = source["neither"];
+	        this.conflicts = this.convertValues(source["conflicts"], RDAConflict);
+	    }
+	
+		convertValues(a: any, classs: any, asMap: boolean = false): any {
+		    if (!a) {
+		        return a;
+		    }
+		    if (a.slice && a.map) {
+		        return (a as any[]).map(elem => this.convertValues(elem, classs));
+		    } else if ("object" === typeof a) {
+		        if (asMap) {
+		            for (const key of Object.keys(a)) {
+		                a[key] = new classs(a[key]);
+		            }
+		            return a;
+		        }
+		        return new classs(a);
+		    }
+		    return a;
+		}
+	}
+	
 	export class RelayAutoRule {
 	    device_id: string;
 	    relay: number;
@@ -3249,6 +3578,8 @@ export namespace main {
 	    style: string;
 	    intensity: number;
 	    bandmap_lotw: boolean;
+	    recent_zebra?: string;
+	    recent_zebra_color?: string;
 	    configured: boolean;
 	    rules: RowColorRule[];
 	
@@ -3262,6 +3593,8 @@ export namespace main {
 	        this.style = source["style"];
 	        this.intensity = source["intensity"];
 	        this.bandmap_lotw = source["bandmap_lotw"];
+	        this.recent_zebra = source["recent_zebra"];
+	        this.recent_zebra_color = source["recent_zebra_color"];
 	        this.configured = source["configured"];
 	        this.rules = this.convertValues(source["rules"], RowColorRule);
 	    }
@@ -3328,6 +3661,54 @@ export namespace main {
 	        this.minutes = source["minutes"];
 	    }
 	}
+	export class SpotColor {
+	    text: string;
+	    bg?: string;
+	    hide?: boolean;
+	
+	    static createFrom(source: any = {}) {
+	        return new SpotColor(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.text = source["text"];
+	        this.bg = source["bg"];
+	        this.hide = source["hide"];
+	    }
+	}
+	export class SpotColors {
+	    enabled: boolean;
+	    colors: Record<string, SpotColor>;
+	
+	    static createFrom(source: any = {}) {
+	        return new SpotColors(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.enabled = source["enabled"];
+	        this.colors = this.convertValues(source["colors"], SpotColor, true);
+	    }
+	
+		convertValues(a: any, classs: any, asMap: boolean = false): any {
+		    if (!a) {
+		        return a;
+		    }
+		    if (a.slice && a.map) {
+		        return (a as any[]).map(elem => this.convertValues(elem, classs));
+		    } else if ("object" === typeof a) {
+		        if (asMap) {
+		            for (const key of Object.keys(a)) {
+		                a[key] = new classs(a[key]);
+		            }
+		            return a;
+		        }
+		        return new classs(a);
+		    }
+		    return a;
+		}
+	}
 	export class SpotQuery {
 	    call: string;
 	    band: string;
@@ -3362,6 +3743,7 @@ export namespace main {
 	    new_pota: boolean;
 	    grid?: string;
 	    new_grid: boolean;
+	    grid_state?: string;
 	    spotter_continent?: string;
 	    lotw: boolean;
 	    new_pfx: boolean;
@@ -3387,6 +3769,7 @@ export namespace main {
 	        this.new_pota = source["new_pota"];
 	        this.grid = source["grid"];
 	        this.new_grid = source["new_grid"];
+	        this.grid_state = source["grid_state"];
 	        this.spotter_continent = source["spotter_continent"];
 	        this.lotw = source["lotw"];
 	        this.new_pfx = source["new_pfx"];
@@ -4519,6 +4902,26 @@ export namespace qso {
 	        this.minutes = source["minutes"];
 	    }
 	}
+	export class GridSquare {
+	    grid: string;
+	    count: number;
+	    confirmed: boolean;
+	    band?: string;
+	    mode?: string;
+	
+	    static createFrom(source: any = {}) {
+	        return new GridSquare(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.grid = source["grid"];
+	        this.count = source["count"];
+	        this.confirmed = source["confirmed"];
+	        this.band = source["band"];
+	        this.mode = source["mode"];
+	    }
+	}
 	export class ListFilter {
 	    callsign?: string;
 	    band?: string;
@@ -4914,6 +5317,10 @@ export namespace qso {
 	    continents: number;
 	    first_qso: string;
 	    last_qso: string;
+	    last_new_dxcc: string;
+	    last_new_dxcc_num: number;
+	    last_new_dxcc_call: string;
+	    last_new_dxcc_date: string;
 	    confirmed_lotw: number;
 	    confirmed_eqsl: number;
 	    confirmed_qsl: number;
@@ -4964,6 +5371,10 @@ export namespace qso {
 	        this.continents = source["continents"];
 	        this.first_qso = source["first_qso"];
 	        this.last_qso = source["last_qso"];
+	        this.last_new_dxcc = source["last_new_dxcc"];
+	        this.last_new_dxcc_num = source["last_new_dxcc_num"];
+	        this.last_new_dxcc_call = source["last_new_dxcc_call"];
+	        this.last_new_dxcc_date = source["last_new_dxcc_date"];
 	        this.confirmed_lotw = source["confirmed_lotw"];
 	        this.confirmed_eqsl = source["confirmed_eqsl"];
 	        this.confirmed_qsl = source["confirmed_qsl"];

gate_coverage_test.go

@@ -0,0 +1,64 @@
+package main
+
+import (
+	"os"
+	"strings"
+	"testing"
+)
+
+// The build gate is only as good as the moments it runs at.
+//
+// It used to run at startup alone, on the profile active then — and a fresh
+// install has NO callsign at that point. The operator typed theirs afterwards,
+// so a denied call ran for the whole session and reached the telemetry, which
+// reads the very same field. Every place that can make a denied callsign the
+// ACTIVE one has to re-ask.
+func TestCallGateRunsWhereverTheActiveCallsignChanges(t *testing.T) {
+	src, err := os.ReadFile("app.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, fn := range []string{
+		"func (a *App) startup(ctx context.Context) {",                 // launch
+		"func (a *App) SaveStationSettings(s StationSettings) error {", // the call is entered here
+		"func (a *App) SaveProfile(p profile.Profile) (profile.Profile, error) {",
+		"func (a *App) ActivateProfile(id int64) error {",
+	} {
+		body := funcBody(t, string(src), fn)
+		if !strings.Contains(body, "enforceCallGate(") {
+			t.Errorf("%s can change the active callsign but never re-checks the gate", fn)
+		}
+	}
+}
+
+// The hashes are the whole mechanism: a truncated or re-cased entry silently
+// matches nothing, and nothing in the running program would ever say so.
+func TestDeniedCallHashesAreWellFormed(t *testing.T) {
+	if len(deniedCallHashes) == 0 {
+		t.Fatal("the deny list is empty — the gate has stopped gating")
+	}
+	for h := range deniedCallHashes {
+		if len(h) != 64 {
+			t.Errorf("hash %q is %d chars, want 64", h, len(h))
+		}
+		if h != strings.ToLower(h) {
+			t.Errorf("hash %q is not lower-case, so it can never match", h)
+		}
+	}
+}
+
+// A slashed call must reduce to the real one, or /P is a way round the gate.
+func TestDenyBaseCall(t *testing.T) {
+	for in, want := range map[string]string{
+		"f4xyz":    "F4XYZ",
+		" F4XYZ ":  "F4XYZ",
+		"F4XYZ/P":  "F4XYZ",
+		"TM/F4XYZ": "F4XYZ",
+		"F4XYZ/MM": "F4XYZ",
+		"":         "",
+	} {
+		if got := denyBaseCall(in); got != want {
+			t.Errorf("denyBaseCall(%q) = %q, want %q", in, got, want)
+		}
+	}
+}

gridscope.go

@@ -0,0 +1,187 @@
+package main
+
+import (
+	"strings"
+
+	"hamlog/internal/award"
+	"hamlog/internal/qso"
+)
+
+// New-grid scoping: WHICH prior contacts count as "I already have this square".
+//
+// The question has no single right answer, which is why it is a setting rather
+// than a rule. A VUCC chaser counts a square per band; someone filling in a
+// wall map counts it once. GridTracker offers the same six combinations, and an
+// operator running both alongside each other needs them to agree — a square
+// "wanted" in one and not the other is a bug report every time.
+const (
+	keyGridScope = "grid.scope" // band+mode combination — see gridScopes
+	keyGridHunt  = "grid.hunt"  // "new" | "new_unconfirmed"
+)
+
+// gridScope is one band × mode combination.
+type gridScope struct {
+	Key string `json:"key"`
+	// Band is true when the square has to have been worked on THIS band. False
+	// is GridTracker's "Mix Bands": any band counts.
+	Band bool `json:"band"`
+	// Mode is how much of the mode matters:
+	//   "digi" — any digital mode at all
+	//   "ftx"  — any of the FT family (FT8/FT4/FT2)
+	//   "mode" — this exact mode and no other
+	Mode string `json:"mode"`
+}
+
+var gridScopes = []gridScope{
+	{Key: "band_digi", Band: true, Mode: "digi"},
+	{Key: "band_mode", Band: true, Mode: "mode"},
+	{Key: "band_ftx", Band: true, Mode: "ftx"},
+	{Key: "mix_digi", Band: false, Mode: "digi"},
+	{Key: "mix_mode", Band: false, Mode: "mode"},
+	{Key: "mix_ftx", Band: false, Mode: "ftx"},
+}
+
+// defaultGridScope matches what the panel showed before the setting existed:
+// any band, any digital mode. Changing an operator's badges on upgrade is worse
+// than offering them a choice they have not made yet.
+const defaultGridScope = "mix_digi"
+
+func lookupGridScope(key string) gridScope {
+	for _, s := range gridScopes {
+		if s.Key == key {
+			return s
+		}
+	}
+	for _, s := range gridScopes {
+		if s.Key == defaultGridScope {
+			return s
+		}
+	}
+	return gridScopes[0]
+}
+
+// ftxModes is the FT family, which is a narrower thing than "digital": an
+// operator chasing squares on FT8 does not count the RTTY contest contact, and
+// GridTracker draws the same line.
+var ftxModes = map[string]bool{"FT8": true, "FT4": true, "FT2": true}
+
+// gridClassesOf lists every bucket one logged mode belongs to. A single FT8
+// contact counts under its own name, under FTx and under digital — the scopes
+// overlap by construction, so the index stores all three and the lookup picks.
+func gridClassesOf(mode string) []string {
+	m := strings.ToUpper(strings.TrimSpace(mode))
+	if m == "" {
+		return nil
+	}
+	out := []string{"m:" + m}
+	if ftxModes[m] {
+		out = append(out, "ftx")
+	}
+	if award.ModeClass(m) == "DIGI" {
+		out = append(out, "digi")
+	}
+	return out
+}
+
+// gridClassFor turns the scope plus the mode being heard into the one class to
+// look up. Empty means "this scope cannot judge this mode" — a phone contact
+// under an FTx scope — and the caller then flags nothing rather than guessing.
+func gridClassFor(s gridScope, mode string) string {
+	m := strings.ToUpper(strings.TrimSpace(mode))
+	if m == "" {
+		return ""
+	}
+	switch s.Mode {
+	case "mode":
+		return "m:" + m
+	case "ftx":
+		if ftxModes[m] {
+			return "ftx"
+		}
+		return ""
+	default: // digi
+		if award.ModeClass(m) == "DIGI" {
+			return "digi"
+		}
+		return ""
+	}
+}
+
+// GridScopeSettings is the panel's shape.
+type GridScopeSettings struct {
+	Scope string `json:"scope"`
+	Hunt  string `json:"hunt"`
+	// Scopes is the list the UI renders, so it cannot drift from the one the
+	// lookup honours.
+	Scopes []gridScope `json:"scopes"`
+}
+
+func (a *App) GetGridScopeSettings() GridScopeSettings {
+	return GridScopeSettings{
+		Scope:  lookupGridScope(a.settingOr(keyGridScope, "")).Key,
+		Hunt:   gridHunt(a.settingOr(keyGridHunt, "")),
+		Scopes: gridScopes,
+	}
+}
+
+// gridHunt normalises the hunting mode. "new" is never-worked; "new_unconfirmed"
+// also chases a square worked but not yet confirmed — the same square is still
+// missing from the award either way.
+func gridHunt(v string) string {
+	if strings.TrimSpace(v) == "new_unconfirmed" {
+		return "new_unconfirmed"
+	}
+	return "new"
+}
+
+func (a *App) SaveGridScopeSettings(s GridScopeSettings) error {
+	a.setSetting(keyGridScope, lookupGridScope(s.Scope).Key)
+	a.setSetting(keyGridHunt, gridHunt(s.Hunt))
+	// The worked-grid index is built under these rules, so it is now stale.
+	a.clusterStatusMu.Lock()
+	a.clusterStatusIdx = nil
+	a.clusterStatusMu.Unlock()
+	return nil
+}
+
+// Grid states a heard square can be in, from the operator's point of view.
+//
+// "wanted" is not one state but two, and they call for different decisions: a
+// square never worked is a QSO to make, one worked and not yet confirmed is a
+// QSL to chase. Reporting both as plain NEW GRID — which is what this did when
+// the unconfirmed hunt was added — leaves an operator staring at a badge on a
+// station the log plainly says they worked an hour ago.
+const (
+	gridStateNew    = "new"    // never worked under this scope
+	gridStateUnconf = "unconf" // worked under this scope, not yet confirmed
+)
+
+// gridStateFor classifies one heard square. "" means nothing to chase: already
+// confirmed, or a mode this scope cannot judge.
+//
+// band is where it was heard and mode what it was heard in — the SCOPE decides
+// whether either is allowed to matter.
+func gridStateFor(idx map[string]bool, s gridScope, hunt, grid, band, mode string) string {
+	cls := gridClassFor(s, mode)
+	if cls == "" || len(grid) < 4 {
+		return ""
+	}
+	key := qso.GridKey(strings.ToUpper(grid[:4]), "", cls)
+	if s.Band {
+		key = qso.GridKey(strings.ToUpper(grid[:4]), band, cls)
+	}
+	confirmed, worked := idx[key]
+	switch {
+	case !worked:
+		return gridStateNew
+	case !confirmed && hunt == "new_unconfirmed":
+		return gridStateUnconf
+	default:
+		return ""
+	}
+}
+
+// gridIsWanted is gridStateFor reduced to the yes/no the filters need.
+func gridIsWanted(idx map[string]bool, s gridScope, hunt, grid, band, mode string) bool {
+	return gridStateFor(idx, s, hunt, grid, band, mode) != ""
+}

gridscope_test.go

@@ -0,0 +1,126 @@
+package main
+
+import (
+	"testing"
+
+	"hamlog/internal/qso"
+)
+
+// idx builds a worked-grid index the way GridWorkedIndex does, so the test
+// exercises the real key shape rather than a convenient one.
+func idx(entries ...struct {
+	grid, band, mode string
+	confirmed        bool
+}) map[string]bool {
+	m := map[string]bool{}
+	for _, e := range entries {
+		for _, cls := range gridClassesOf(e.mode) {
+			for _, k := range []string{qso.GridKey(e.grid, e.band, cls), qso.GridKey(e.grid, "", cls)} {
+				m[k] = m[k] || e.confirmed
+			}
+		}
+	}
+	return m
+}
+
+type entry = struct {
+	grid, band, mode string
+	confirmed        bool
+}
+
+// The six scopes are six different questions, and the whole point of offering
+// them is that the same square answers differently.
+func TestGridScopes(t *testing.T) {
+	// JN36 worked once: 20 m, FT8, not confirmed.
+	i := idx(entry{"JN36", "20m", "FT8", false})
+
+	for _, tc := range []struct {
+		scope string
+		band  string
+		mode  string
+		want  bool
+		why   string
+	}{
+		{"band_ftx", "20m", "FT8", false, "same band, same family — already mine"},
+		{"band_ftx", "15m", "FT8", true, "another band, and the scope counts bands"},
+		{"mix_ftx", "15m", "FT8", false, "another band, but this scope does not care"},
+		{"band_mode", "20m", "FT4", true, "same band, but FT4 is not FT8 under an exact-mode scope"},
+		{"band_ftx", "20m", "FT4", false, "same band, and FT4 is in the same FT family"},
+		{"band_digi", "20m", "RTTY", false, "digital counts every digital mode"},
+		{"band_ftx", "20m", "RTTY", false, "RTTY is outside an FTx scope — it is not evidence either way, so nothing is flagged"},
+		{"mix_digi", "15m", "FT4", false, "the widest scope: worked anywhere, any digital"},
+	} {
+		got := gridIsWanted(i, lookupGridScope(tc.scope), "new", "JN36", tc.band, tc.mode)
+		if got != tc.want {
+			t.Errorf("scope %s, %s %s → wanted=%v, want %v — %s", tc.scope, tc.band, tc.mode, got, tc.want, tc.why)
+		}
+	}
+}
+
+// "New + unconfirmed" chases a square that is worked but not yet confirmed: it
+// is still missing from the award, which is the only sense in which it is done.
+func TestGridHuntUnconfirmed(t *testing.T) {
+	unconf := idx(entry{"JN36", "20m", "FT8", false})
+	conf := idx(entry{"IO91", "20m", "FT8", true})
+
+	if gridIsWanted(unconf, lookupGridScope("band_ftx"), "new", "JN36", "20m", "FT8") {
+		t.Error("worked-but-unconfirmed must NOT be wanted when hunting only what is new")
+	}
+	if !gridIsWanted(unconf, lookupGridScope("band_ftx"), "new_unconfirmed", "JN36", "20m", "FT8") {
+		t.Error("worked-but-unconfirmed must BE wanted when hunting unconfirmed too")
+	}
+	if gridIsWanted(conf, lookupGridScope("band_ftx"), "new_unconfirmed", "IO91", "20m", "FT8") {
+		t.Error("a confirmed square is finished under either hunt")
+	}
+}
+
+// A mode the scope cannot judge flags nothing rather than guessing: a phone
+// contact under an FTx scope is not evidence either way.
+func TestGridScopeIgnoresModesItCannotJudge(t *testing.T) {
+	i := idx(entry{"JN36", "20m", "FT8", false})
+	for _, mode := range []string{"SSB", "CW", ""} {
+		if gridIsWanted(i, lookupGridScope("band_ftx"), "new", "KO01", "20m", mode) {
+			t.Errorf("mode %q is outside an FTx scope — nothing should be flagged", mode)
+		}
+	}
+}
+
+// An unknown or unset scope falls back rather than answering "wanted" for
+// everything, which is what an empty class would have done.
+func TestGridScopeFallsBack(t *testing.T) {
+	if got := lookupGridScope("").Key; got != defaultGridScope {
+		t.Errorf("unset scope = %q, want the default %q", got, defaultGridScope)
+	}
+	if got := lookupGridScope("nonsense").Key; got != defaultGridScope {
+		t.Errorf("unknown scope = %q, want the default %q", got, defaultGridScope)
+	}
+	if got := gridHunt("nonsense"); got != "new" {
+		t.Errorf("unknown hunt = %q, want new", got)
+	}
+}
+
+// The two wanted states must be told apart, not merged. A square worked an hour
+// ago and awaiting a QSL is a different job from one never worked, and reporting
+// both as plain NEW GRID is what made a station the log plainly shows as worked
+// still wear the badge.
+func TestGridStateSeparatesNewFromUnconfirmed(t *testing.T) {
+	i := idx(
+		entry{"JN74", "20m", "FT8", false}, // worked, no confirmation yet
+		entry{"IO91", "20m", "FT8", true},  // worked and confirmed
+	)
+	s := lookupGridScope("band_ftx")
+
+	if got := gridStateFor(i, s, "new_unconfirmed", "KO99", "20m", "FT8"); got != gridStateNew {
+		t.Errorf("never worked → %q, want %q", got, gridStateNew)
+	}
+	if got := gridStateFor(i, s, "new_unconfirmed", "JN74", "20m", "FT8"); got != gridStateUnconf {
+		t.Errorf("worked but unconfirmed → %q, want %q", got, gridStateUnconf)
+	}
+	if got := gridStateFor(i, s, "new_unconfirmed", "IO91", "20m", "FT8"); got != "" {
+		t.Errorf("confirmed → %q, want nothing to chase", got)
+	}
+	// Under the plain "new" hunt an unconfirmed square is finished business.
+	if got := gridStateFor(i, s, "new", "JN74", "20m", "FT8"); got != "" {
+		t.Errorf("unconfirmed under the new-only hunt → %q, want nothing", got)
+	}
+}

hamlogcfm.go

@@ -0,0 +1,264 @@
+package main
+
+// Reading confirmations back from a HAMLOG.online ADIF export.
+//
+// Their agent protocol only uploads — it has no verb for asking what has been
+// confirmed — so the return path is a file: their site exports an ADIF, and the
+// operator feeds it back here.
+//
+// That file must NOT be imported the ordinary way. A plain import matches a
+// record to a local QSO on callsign + UTC MINUTE + band + mode, and their
+// export is rebuilt from their own database: a minute of rounding, SSB where
+// the log says USB, and the key no longer matches. "Update duplicates" then
+// does what it is told — no duplicate found, so it inserts — and a few hundred
+// copies of contacts the operator already had land in the log. That is exactly
+// what happened once, and it is why this path exists instead.
+//
+// So: match only, never insert. Confirmations are stamped onto the QSOs already
+// in the log, and anything that cannot be matched is REPORTED rather than
+// added, because an unmatched confirmation is a question about the log (a
+// minute off, a portable call) and not a contact to create.
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"strings"
+	"time"
+
+	wruntime "github.com/wailsapp/wails/v2/pkg/runtime"
+
+	"hamlog/internal/adif"
+	"hamlog/internal/applog"
+	"hamlog/internal/award"
+	"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
+	Confirmed int `json:"confirmed"` // records carrying HAMLOG's confirmation flag
+	Matched   int `json:"matched"`   // local QSOs stamped
+	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. 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"`
+}
+
+// hamlogCfmSamples caps the reported list — enough to see the pattern, not so
+// many that the dialog becomes a log file.
+const hamlogCfmSamples = 30
+
+// ImportHamlogConfirmations stamps the confirmations from a HAMLOG.online ADIF
+// export onto the matching local QSOs. It inserts nothing.
+func (a *App) ImportHamlogConfirmations(path string) (HamlogCfmResult, error) {
+	var res HamlogCfmResult
+	if a.qso == nil {
+		return res, fmt.Errorf("db not initialized")
+	}
+	if strings.TrimSpace(path) == "" {
+		return res, fmt.Errorf("empty path")
+	}
+	f, err := os.Open(path)
+	if err != nil {
+		return res, err
+	}
+	defer f.Close()
+
+	ctx := a.ctx
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	// The same two indexes the LoTW download uses: the exact key, then the
+	// mode-CLASS key for the contacts whose mode was written differently at the
+	// other end (FT8 exported as DATA, SSB where the log says USB).
+	keyIDs, err := a.qso.DedupeKeyIDs(ctx)
+	if err != nil {
+		return res, fmt.Errorf("read local log: %w", err)
+	}
+	classIDs, _ := a.qso.DedupeClassKeyIDs(ctx)
+
+	emit := func(line string) {
+		if a.ctx != nil {
+			wruntime.EventsEmit(a.ctx, "qslmgr:log", line)
+		}
+	}
+	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 {
+			return nil
+		}
+		res.Total++
+		// Only the records they actually confirmed. The export carries the whole
+		// log, and stamping "confirmed" on all of it would turn every uploaded
+		// contact into a confirmed one.
+		if !hamlogRecordConfirmed(rec) {
+			return nil
+		}
+		res.Confirmed++
+
+		minute := q.QSODate.UTC().Format("2006-01-02T15:04")
+		id, found := keyIDs[qso.DedupeKey(q.Callsign, minute, q.Band, q.Mode)]
+		if !found {
+			// id 0 means the class key is ambiguous — several local QSOs share
+			// it — and guessing between them would stamp the wrong one.
+			if cid, ok := classIDs[qso.DedupeClassKey(q.Callsign, minute, q.Band, q.Mode)]; ok && cid != 0 {
+				id, found = cid, true
+				res.ByClass++
+			}
+		}
+		if !found {
+			res.Unmatched++
+			if len(res.Samples) < hamlogCfmSamples {
+				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)
+		if e := a.qso.SetExtra(ctx, id, award.HamlogQSLKey, "Y"); e != nil {
+			return nil
+		}
+		_ = a.qso.SetExtra(ctx, id, hamlogQSLDateKey, date)
+		// A confirmed contact is by definition one they hold, so the sent side
+		// is true whether or not OpsLog is what uploaded it — a log uploaded
+		// 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",
+		res.Total, res.Confirmed, res.Matched, res.ByClass, res.Unmatched))
+	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.
+const hamlogQSLDateKey = "APP_OPSLOG_HAMLOG_QSL_DATE"
+
+// hamlogRecordConfirmed reads their flag off a raw ADIF record. The primary key
+// is the one their own export writes; the alternates are the names OpsLog and
+// other tools have used, so a file that went through another logger still reads.
+func hamlogRecordConfirmed(rec adif.Record) bool {
+	keys := append([]string{award.HamlogQSLKey}, award.HamlogAltKeys()...)
+	for _, k := range keys {
+		v := strings.ToUpper(strings.TrimSpace(rec[strings.ToLower(k)]))
+		if v != "" && v != "N" && v != "NO" {
+			return true
+		}
+	}
+	return false
+}
+
+// hamlogCfmDate is the date to stamp: the import date, in ADIF form.
+func hamlogCfmDate(rec adif.Record) string {
+	// If a future export ever carries one, take it rather than today's date.
+	for _, k := range []string{"app_hamlog_qso_cfm_date", "qslrdate"} {
+		if v := strings.TrimSpace(rec[k]); len(v) == 8 {
+			return v
+		}
+	}
+	return time.Now().UTC().Format("20060102")
+}

internal/applog/applog.go

@@ -20,9 +20,15 @@ var (
 	mu        sync.Mutex
 	file      *os.File
 	path      string
+	written   int64    // bytes in the CURRENT file, for the size check in Printf
 	crashFile *os.File // kept open so the runtime can write a crash traceback to it
 )
 
+// maxLogBytes is where the file rolls over, at startup AND while running.
+// A variable, not a constant, so the rotation can be exercised in a test without
+// writing ten megabytes to do it.
+var maxLogBytes int64 = 10 * 1024 * 1024
+
 // Init opens (creates) the log file in dataDir. On rotation we truncate
 // at startup if the file is too big; for now it's a single file, no
 // rolling — the volume is low (a few KB per session).
@@ -47,11 +53,11 @@ func Init(dataDir string) (string, error) {
 			_ = os.Rename(oldLog, logPath)
 		}
 	}
-	// Rotate (don't delete) once the file grows past ~10MB: rename it to
+	// Rotate (don't delete) once the file grows past maxLogBytes: rename it to
 	// opslog.log.1 so the PREVIOUS session's log survives. Deleting it outright used
 	// to erase exactly the diagnostics we needed when a user reported an issue from
 	// the session that just ended. One generation kept — enough, without unbounded growth.
-	if fi, err := os.Stat(logPath); err == nil && fi.Size() > 10*1024*1024 {
+	if fi, err := os.Stat(logPath); err == nil && fi.Size() > maxLogBytes {
 		_ = os.Remove(logPath + ".1") // drop the older generation
 		if err := os.Rename(logPath, logPath+".1"); err != nil {
 			_ = os.Remove(logPath) // rename failed (locked?) → fall back to the old behaviour
@@ -96,13 +102,57 @@ func Printf(format string, args ...any) {
 		msg = msg[:len(msg)-1]
 	}
 	if file != nil {
-		fmt.Fprintf(file, "%s %s\n", stamp, msg)
+		n, _ := fmt.Fprintf(file, "%s %s\n", stamp, msg)
+		written += int64(n)
+		rotateIfBigLocked()
 	}
 	// Also dump to stderr in case the binary was launched with a console
 	// attached (wails dev, custom build).
 	fmt.Fprintf(os.Stderr, "%s %s\n", stamp, msg)
 }
 
+// rotateIfBigLocked rolls the file over mid-session once it passes maxLogBytes.
+//
+// The check used to happen at STARTUP only, on the reasonable belief that a
+// session writes a few kilobytes. The CI-V wire trace disproved it: left on for
+// a day it wrote 416 MB, and nothing would have stopped it before the disk did.
+// A log that has to be rotated by quitting the program is not a bound.
+//
+// Same one-generation scheme as the startup rotation, so the previous stretch
+// survives — which is the half an operator usually needs, the part just before
+// the thing they are reporting.
+//
+// Caller holds mu.
+func rotateIfBigLocked() {
+	if written < maxLogBytes || file == nil || path == "" {
+		return
+	}
+	fmt.Fprintf(file, "%s ── log reached %d MB, rotating to %s.1 ──\n",
+		time.Now().Format("15:04:05.000"), maxLogBytes/(1024*1024), filepath.Base(path))
+	_ = file.Close()
+	file = nil
+	_ = os.Remove(path + ".1")
+	if err := os.Rename(path, path+".1"); err != nil {
+		// Rename refused (the file is held open elsewhere, a virus scanner): keep
+		// writing to the old handle rather than losing the log entirely, and try
+		// again in another maxLogBytes rather than on every single line.
+		f, oerr := os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0o644)
+		if oerr == nil {
+			file = f
+		}
+		written = 0
+		return
+	}
+	f, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0o644)
+	if err != nil {
+		return // nothing more to be done; the next Printf simply writes nowhere
+	}
+	file = f
+	written = 0
+	fmt.Fprintf(file, "%s ── continued from %s.1 ──\n",
+		time.Now().Format("15:04:05.000"), filepath.Base(path))
+}
+
 // Path returns where the file is so the UI can surface it.
 func Path() string {
 	mu.Lock()
@@ -118,4 +168,19 @@ func Close() {
 		_ = file.Close()
 		file = nil
 	}
+	// The crash file is held open for the whole run so the runtime can dump a
+	// traceback into it without allocating; on the way out it has to be released
+	// like any other handle, or the data directory cannot be moved or removed.
+	if crashFile != nil {
+		// The RUNTIME holds its own duplicate of this handle (SetCrashOutput), so
+		// closing ours releases nothing on Windows — the data directory stays
+		// locked. Hand the runtime a nil first. Anything fatal in the last moments
+		// of shutdown is no longer captured, which is the right trade at a point
+		// where the databases are already closed.
+		_ = debug.SetCrashOutput(nil, debug.CrashOptions{})
+		_ = crashFile.Close()
+		crashFile = nil
+	}
+	path = ""
+	written = 0
 }

internal/applog/rotate_test.go

@@ -0,0 +1,49 @@
+package applog
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// The log has to be bounded WHILE RUNNING, not only at startup. The CI-V wire
+// trace left on for a day wrote 416 MB, and nothing would have stopped it
+// before the disk did.
+func TestRotatesMidSession(t *testing.T) {
+	orig := maxLogBytes
+	maxLogBytes = 8 * 1024 // small, so the test costs milliseconds
+	defer func() { maxLogBytes = orig }()
+
+	dir := t.TempDir()
+	p, err := Init(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer Close()
+
+	line := strings.Repeat("x", 256)
+	for i := 0; i < 100; i++ { // ~25 KB: several times the limit
+		Printf("%s", line)
+	}
+
+	if _, err := os.Stat(p + ".1"); err != nil {
+		t.Fatalf("no previous generation kept: %v", err)
+	}
+	fi, err := os.Stat(p)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if fi.Size() > maxLogBytes {
+		t.Fatalf("current log is %d bytes, over the %d limit — it did not roll over", fi.Size(), maxLogBytes)
+	}
+	// The new file says where the rest went: a log that starts mid-sentence with
+	// no explanation is how an operator concludes the app lost its history.
+	b, err := os.ReadFile(p)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(b), "continued from "+filepath.Base(p)+".1") {
+		t.Error("the new file does not point at the one it continues")
+	}
+}

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

@@ -168,7 +168,48 @@ func (r *Recorder) Start(fromDev, micDev string, prerollSec int) error {
 	twoSrc := r.twoSrc
 	r.mu.Unlock()
 
-	// Capture goroutine(s) feed the per-source queues.
+	// The radio side is either CAPTURED from a sound device or PUSHED in from
+	// somewhere else. Over the network there is no sound device at all: an
+	// IC-705 reached by LAN streams its receive audio over the Icom protocol,
+	// and the operator's audio settings can only offer the PC's own microphone
+	// and speakers. fromDev == PushedSource says "someone else will feed me",
+	// and PushRX is how they do it.
+	if fromDev == PushedSource {
+		LogSink("recorder: radio audio is pushed in (network), not captured from a device")
+	} else {
+		r.startRadioCapture(fromDev, stop)
+	}
+	if twoSrc {
+		r.startMicCapture(micDev, stop)
+	}
+	r.finishStart(fromDev, micDev, twoSrc, stop)
+	return nil
+}
+
+// PushedSource is the "device" name that means the radio audio arrives through
+// PushRX instead of a capture stream.
+const PushedSource = "\x00pushed"
+
+// PushRX feeds one chunk of 16-bit mono PCM from a non-device source.
+//
+// Safe to call when nothing is recording — the samples are dropped, which is
+// what should happen: the network stream runs whenever the rig is connected,
+// and the recorder only wants it between BeginQSO and the save.
+func (r *Recorder) PushRX(pcm []byte) {
+	r.mu.Lock()
+	running := r.running
+	r.mu.Unlock()
+	if !running || len(pcm) == 0 {
+		return
+	}
+	sm := bytesToInt16(pcm)
+	r.srcMu.Lock()
+	r.bufA = append(r.bufA, sm...)
+	r.lastA = time.Now()
+	r.srcMu.Unlock()
+}
+
+func (r *Recorder) startRadioCapture(fromDev string, stop chan struct{}) {
 	r.wg.Add(1)
 	go func() {
 		defer r.wg.Done()
@@ -187,7 +228,9 @@ func (r *Recorder) Start(fromDev, micDev string, prerollSec int) error {
 			LogSink("recorder: capture from %q failed: %v", DeviceName(fromDev), err)
 		}
 	}()
-	if twoSrc {
+}
+
+func (r *Recorder) startMicCapture(micDev string, stop chan struct{}) {
 	r.wg.Add(1)
 	go func() {
 		defer r.wg.Done()
@@ -202,8 +245,10 @@ func (r *Recorder) Start(fromDev, micDev string, prerollSec int) error {
 			LogSink("recorder: capture from %q failed: %v", DeviceName(micDev), err)
 		}
 	}()
-	}
+}
 
+// finishStart logs what is being recorded and arms the silence watchdog.
+func (r *Recorder) finishStart(fromDev, micDev string, twoSrc bool, stop chan struct{}) {
 	// Name the devices being recorded FROM, once, at the start.
 	//
 	// A station with two radios has two sets of endpoints, and the recorder will
@@ -262,7 +307,6 @@ func (r *Recorder) Start(fromDev, micDev string, prerollSec int) error {
 			}
 		}
 	}()
-	return nil
 }
 
 // mixTick drains the source queues, mixes what's available, and appends to the

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

@@ -109,7 +109,7 @@ type Def struct {
 	Emission   []string `json:"emission,omitempty"`    // CW | DIGITAL | PHONE (empty = all)
 
 	// --- Confirmation ---
-	Confirm  []string `json:"confirm"`            // worked-confirmed: lotw|qsl|eqsl|qrzcom|custom
+	Confirm  []string `json:"confirm"`            // worked-confirmed: lotw|qsl|eqsl|qrzcom|hamlog|custom
 	Validate []string `json:"validate,omitempty"` // validated/granted sources
 	// The "custom" source, for confirmations OpsLog has no dedicated column for:
 	// ConfirmField names a QSO field or an ADIF extras key, ConfirmValue the
@@ -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":
@@ -1481,6 +1488,18 @@ func confirmed(q *qso.QSO, sources []string, d *Def) bool {
 			if isYes(q.QRZComDownloadStatus) {
 				return true
 			}
+		case "hamlog":
+			// HAMLOG.online, a first-class source rather than something to express
+			// through "custom" — its confirmations feed its own award programme
+			// and operators reach for it the same way they reach for LoTW.
+			//
+			// Read from the ADIF EXTRAS, not a column: the ADIF standard names a
+			// field for hamlog.EU (HAMLOGEU_QSO_UPLOAD_STATUS) and none for
+			// hamlog.ONLINE, and borrowing the other site's field would write a
+			// falsehood into every exported log.
+			if hamlogConfirmed(q) {
+				return true
+			}
 		case "custom":
 			if customConfirmed(q, d) {
 				return true
@@ -1490,6 +1509,46 @@ func confirmed(q *qso.QSO, sources []string, d *Def) bool {
 	return false
 }
 
+// HamlogQSLKey is where a HAMLOG.online confirmation is recorded.
+//
+// THEIR field name, taken from a real export:
+//
+//	<APP_HAMLOG_QSO_CFM:1>Y
+//
+// Using the site's own key rather than one of ours is what makes an import
+// simply work: a log downloaded from HAMLOG carries its confirmations into
+// OpsLog with nothing to rename and no mapping to configure. The guesses this
+// replaced (APP_HAMLOG_QSL and friends) were all wrong, which is the argument
+// for reading a real file before naming a field.
+const HamlogQSLKey = "APP_HAMLOG_QSO_CFM"
+
+// hamlogAltKeys are older or hand-written spellings still honoured on read.
+// APP_OPSLOG_HAMLOG_QSL is the one OpsLog itself wrote before a real export was
+// available; a log stamped with it keeps counting.
+var hamlogAltKeys = []string{"APP_OPSLOG_HAMLOG_QSL", "APP_HAMLOG_QSL", "APP_HAMLOGONLINE_QSL", "HAMLOG_QSL_RCVD"}
+
+// hamlogConfirmed reports whether a QSO carries a HAMLOG.online confirmation.
+//
+// Any non-empty value counts, except an explicit "N": their export could carry
+// a date, a Y, or a match id, and demanding one of them would silently confirm
+// nothing on the two shapes we guessed wrong.
+func hamlogConfirmed(q *qso.QSO) bool {
+	if q == nil || q.Extras == nil {
+		return false
+	}
+	for _, k := range append([]string{HamlogQSLKey}, hamlogAltKeys...) {
+		v := strings.TrimSpace(q.Extras[k])
+		if v == "" {
+			continue
+		}
+		if strings.EqualFold(v, "N") || strings.EqualFold(v, "NO") {
+			continue
+		}
+		return true
+	}
+	return false
+}
+
 // customConfirmed answers the operator-defined confirmation source: the field
 // named by ConfirmField, optionally required to hold one of ConfirmValue's
 // comma-separated values.
@@ -1580,3 +1639,7 @@ func sortedBands(m map[string]int) []string {
 	})
 	return out
 }
+
+// HamlogAltKeys exposes the alternate spellings so a reader outside this package
+// (the confirmations import) accepts exactly what the award engine accepts.
+func HamlogAltKeys() []string { return append([]string(nil), hamlogAltKeys...) }

internal/award/award_test.go

@@ -684,3 +684,26 @@ func TestCatalogForcesBuiltin(t *testing.T) {
 		t.Fatal("empty catalog")
 	}
 }
+
+// An award with NO QSO field at all counts only what the operator assigned by
+// hand. WWBOTA is the case: bunker references have no ADIF field anywhere, so
+// the definition names no field and the matcher must scan nothing rather than
+// fall back on some default. The manual override still applies — it is the only
+// thing that can feed such an award.
+func TestComputeNoFieldManualOnly(t *testing.T) {
+	def := Def{Code: "WWBOTA", Type: TypeReference, Field: "", Dynamic: true, Valid: true}
+	qsos := []qso.QSO{
+		// Assigned by hand → counts.
+		{Callsign: "F4ABC", Band: "40m", Extras: map[string]string{ManualRefsKey: "WWBOTA@B/F-0123"}},
+		// Nothing assigned. The other fields are deliberately full: none of them
+		// may be scanned just because no field was named.
+		{Callsign: "F4DEF", Band: "20m", POTARef: "FF-0001", QTH: "B/F-0999", Comment: "B/F-0888"},
+	}
+	r := Compute([]Def{def}, qsos, nil, nil)[0]
+	if r.Worked != 1 {
+		t.Errorf("WWBOTA worked = %d, want 1 (%v)", r.Worked, refCodes(r))
+	}
+	if got := refCodes(r); len(got) != 1 || got[0] != "B/F-0123" {
+		t.Errorf("WWBOTA refs = %v, want [B/F-0123]", got)
+	}
+}

internal/award/confirm_test.go

@@ -64,3 +64,61 @@ func TestConfirmedSources(t *testing.T) {
 		}
 	}
 }
+
+// HAMLOG.online is a named confirmation source, not something to express through
+// "custom": an award ticks it the way it ticks LoTW.
+func TestHamlogConfirmationSource(t *testing.T) {
+	def := Def{Confirm: []string{"hamlog"}, Validate: []string{"hamlog"}}
+	yes := func(extras map[string]string) bool {
+		return Confirmed(&qso.QSO{Extras: extras}, def, def.Confirm)
+	}
+	if !yes(map[string]string{HamlogQSLKey: "Y"}) {
+		t.Error("our own key did not confirm")
+	}
+	// Their export's field name is unpublished, so the plausible shapes count too.
+	if !yes(map[string]string{"APP_HAMLOG_QSL": "20260823"}) {
+		t.Error("a date in an alternative key did not confirm")
+	}
+	// A value is not a confirmation when it says no.
+	if yes(map[string]string{HamlogQSLKey: "N"}) {
+		t.Error(`"N" was taken as a confirmation`)
+	}
+	if yes(map[string]string{HamlogQSLKey: "  "}) {
+		t.Error("blank was taken as a confirmation")
+	}
+	if yes(nil) || yes(map[string]string{"SOMETHING_ELSE": "Y"}) {
+		t.Error("confirmed with nothing to confirm it")
+	}
+	// And it does not leak into an award that never asked for it.
+	other := Def{Confirm: []string{"lotw"}}
+	if Confirmed(&qso.QSO{Extras: map[string]string{HamlogQSLKey: "Y"}}, other, other.Confirm) {
+		t.Error("a hamlog confirmation counted for an award that only accepts LoTW")
+	}
+}
+
+// The field name is theirs, taken from a real export:
+//
+//	<APP_HAMLOG_QSO_CFM:1>Y
+//
+// Pinned as a test because it was GUESSED wrong first — an import that carries
+// its confirmations into OpsLog with nothing to rename is the whole point, and
+// a renamed constant would break it in silence.
+func TestHamlogUsesTheSitesOwnFieldName(t *testing.T) {
+	if HamlogQSLKey != "APP_HAMLOG_QSO_CFM" {
+		t.Fatalf("HamlogQSLKey = %q — their export writes APP_HAMLOG_QSO_CFM", HamlogQSLKey)
+	}
+	def := Def{Confirm: []string{"hamlog"}}
+	// The record as HAMLOG exports it.
+	q := &qso.QSO{Extras: map[string]string{
+		"APP_HAMLOG_R150COUNTRY": "Russia",
+		"APP_HAMLOG_QSO_CFM":     "Y",
+	}}
+	if !Confirmed(q, def, def.Confirm) {
+		t.Error("a real HAMLOG export did not confirm")
+	}
+	// Anything OpsLog stamped before that export existed keeps counting.
+	old := &qso.QSO{Extras: map[string]string{"APP_OPSLOG_HAMLOG_QSL": "Y"}}
+	if !Confirmed(old, def, def.Confirm) {
+		t.Error("a QSO stamped with the older key stopped counting")
+	}
+}

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

@@ -184,7 +184,29 @@ func (m *Manager) stopLocked() {
 		iv.Interrupt()
 	}
 	if done != nil {
-		<-done
+		// Bounded, and loud when it expires.
+		//
+		// This used to be a bare <-done. A poll goroutine wedged in a serial read
+		// then held every caller for ever: each restart attempt blocked inside
+		// Start before it could even try to connect, so the rig stayed dead and
+		// NOTHING was written to the log — the operator saw a CAT link that would
+		// not come back and no reason anywhere. Shutdown blocked on the same wait.
+		//
+		// Ten seconds is far longer than any honest disconnect. Past that the old
+		// poller is not coming back, and carrying on without it — noisily — beats
+		// freezing the application around it. The abandoned goroutine still holds
+		// its port, which is exactly what the log line has to say, because the
+		// next connect will fail because of it.
+		select {
+		case <-done:
+		case <-time.After(10 * time.Second):
+			name := "cat"
+			if b != nil {
+				name = b.Name()
+			}
+			debugLog.Printf("%s: poll loop did not stop within 10s — abandoning it; "+
+				"its port stays open, so the next connect may fail until OpsLog is restarted", name)
+		}
 	}
 }
 
@@ -271,7 +293,15 @@ type SpotInfo struct {
 	FreqHz   int64
 	Callsign string
 	Mode     string
+	// Color is the TEXT colour of the callsign on the panadapter, BackgroundColor
+	// the plate behind it. Both are #AARRGGBB — the alpha channel first, which is
+	// SmartSDR's order and not the web's.
+	//
+	// Two colours rather than one because that is what makes a spot readable at a
+	// glance on a busy waterfall: the fill carries the status and the text stays
+	// legible against it. An empty background leaves the radio's own default.
 	Color           string
+	BackgroundColor string
 	Comment         string
 	LifetimeSec     int // panadapter display seconds before auto-removal (0 = backend default)
 }
@@ -453,7 +483,12 @@ type FlexController interface {
 	SetRXAntenna(string) error
 	SetTXAntenna(string) error
 	SetActiveSlice(int) error // focus slice idx so commands target it
+	// ZoomPan sets the visible width (MHz) of the active slice's panadapter and
+	// 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
@@ -955,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,24 +60,64 @@ 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
 	pendingSplit    map[int]bool   // seq → awaiting the new TX slice's index (split create)
 	spotCall        map[int]string // spot index → callsign (to fill the call on a panadapter click)
 	spotMode        map[int]string // spot index → ADIF mode, so a click can also set the slice mode (SmartSDR tunes the spot's freq but not its mode)
+	spotFreq        map[int]int64  // spot index → Hz, so a click can report where it was (the trigger message carries only the index)
+	pendingSpotFreq map[int]int64  // seq → Hz, paired with pendingSpot
+	// panWindow is what each panadapter is currently showing, from its own status
+	// (centre and width, both MHz). Tracked because a zoom that only changes the
+	// WIDTH keeps the old centre, and the frequency the operator just clicked can
+	// end up outside the new window — see ZoomPan.
+	panWindow map[string]panView
+
+	// spotSig is what each live spot LOOKS like, and when it was drawn. A
+	// callsign spotted again with the same frequency, colour and comment does not
+	// need to be removed and re-added: the panadapter would not change by one
+	// pixel, and a busy RBN feed re-spots the same station every few seconds. One
+	// two-minute session sent 2 128 adds and 1 634 removes, 88 of them for a
+	// single callsign — see SendSpot.
+	spotSig  map[string]string
+	spotSent map[string]time.Time
+
 	spotByCall map[string]int // callsign → live spot index, so re-spotting a call replaces its old spot (WSJT decodes re-fire every cycle)
 	sentCmds   map[int]string // seq → command text, so an R<seq> error names the command
 
 	// OnSpotClick is called (off the reader goroutine's hot path) when the user
-	// clicks one of our spots on the panadapter, with the spot's callsign and
+	// clicks one of our spots on the panadapter, with the spot's callsign, its
-	// frequency. The host wires this to fill the entry form. Set before Connect.
+	// frequency and the mode it was spotted in — everything the host knows about
-	OnSpotClick func(callsign string, freqHz int64)
+	// 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.
+type panView struct{ centre, width float64 }
+
 type flexSlice struct {
 	freqHz int64
 	mode   string // raw Flex mode (USB/LSB/CW/DIGU/…)
+	// pan is the panadapter this slice is displayed on ("0x40000000"), taken
+	// from the slice status. Kept PER SLICE rather than as one radio-wide id:
+	// with two slices on two bands there are two panadapters, and zooming the
+	// wrong one moves a display the operator is not looking at.
+	pan    string
 	active bool
 	tx     bool
 	inUse  bool
@@ -187,7 +227,7 @@ func NewFlex(host string, port int, spotsEnabled bool) *Flex {
 	return &Flex{
 		host: strings.TrimSpace(host), port: port,
 		slices: map[int]*flexSlice{}, spotsEnabled: spotsEnabled,
-		spotIdx: map[int]bool{}, pendingSpot: map[int]string{}, pendingSpotMode: map[int]string{}, spotCall: map[int]string{}, spotMode: map[int]string{}, spotByCall: map[string]int{}, pendingSplit: map[int]bool{},
+		spotIdx: map[int]bool{}, pendingSpot: map[int]string{}, pendingSpotMode: map[int]string{}, spotCall: map[int]string{}, spotMode: map[int]string{}, spotFreq: map[int]int64{}, pendingSpotFreq: map[int]int64{}, panWindow: map[string]panView{}, spotSig: map[string]string{}, spotSent: map[string]time.Time{}, spotByCall: map[string]int{}, pendingSplit: map[int]bool{},
 		meterMeta: map[int]meterInfo{}, meterVal: map[int]float64{}, meterSub: map[int]bool{},
 		sentCmds: map[int]string{}, txSetAt: map[string]time.Time{},
 		pinnedSlice: -1,
@@ -248,13 +288,21 @@ func (f *Flex) Connect() error {
 	f.send("sub cwx all")       // CWX: the LIVE CW speed/pitch/break-in (transmit holds only a static default)
 	f.send("sub profile all")   // mic/global/tx profiles (for the mic-profile dropdown)
 	f.send("profile mic info")  // request the current mic profile list + selection
+	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
-	if f.spotsEnabled {
+	// Always subscribed, even when OpsLog draws no spots of its own: the feed is
-		// Subscribe so the radio pushes existing spots (we learn their indices),
+	// read-only and it is how the spots posted by OTHER programs arrive — a CW
-		// then wipe the panadapter so stale spots from a previous session or
+	// skimmer's decoded reports, which the split chaser acts on. Tying the
-		// another logger are cleared before we start adding our own.
+	// 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 {
+		// Wipe the panadapter so stale spots from a previous session or another
+		// logger are cleared before we start adding our own. Only when the
+		// overlay is ours to manage: "spot clear" removes EVERY spot on the
+		// 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
@@ -341,11 +389,12 @@ func (f *Flex) reader(conn net.Conn) {
 				f.mu.Lock()
 				call := f.spotCall[idx]
 				mode := f.spotMode[idx]
+				hz := f.spotFreq[idx]
 				handler := f.OnSpotClick
 				f.mu.Unlock()
 				if call != "" && handler != nil {
 					debugLog.Printf("Flex: spot %d triggered → %s (mode %s)", idx, call, mode)
-					go handler(call, 0)
+					go handler(call, hz, mode)
 					// SmartSDR tunes the spot's frequency on click but does NOT apply
 					// its mode=, so set the slice mode ourselves from what we spotted.
 					if mode != "" {
@@ -388,14 +437,17 @@ func (f *Flex) reader(conn net.Conn) {
 			f.mu.Lock()
 			call, pending := f.pendingSpot[seq]
 			spotMode := f.pendingSpotMode[seq]
+			spotFreq := f.pendingSpotFreq[seq]
 			if pending {
 				delete(f.pendingSpot, seq)
 				delete(f.pendingSpotMode, seq)
+				delete(f.pendingSpotFreq, seq)
 			}
 			if pending && ok && len(parts) >= 3 {
 				if idx, e := strconv.Atoi(strings.TrimSpace(parts[2])); e == nil {
 					f.spotCall[idx] = call
 					f.spotMode[idx] = spotMode
+					f.spotFreq[idx] = spotFreq
 					f.spotIdx[idx] = true
 					f.spotByCall[strings.ToUpper(call)] = idx
 				}
@@ -692,6 +744,32 @@ func (f *Flex) handleStatus(payload string) {
 			}
 			f.mu.Unlock()
 		}
+		// Panadapter — "display pan 0x40000000 center=14.075 bandwidth=0.2 …".
+		// Only the window matters here; everything else about the display is
+		// SmartSDR's business.
+		if len(fields) >= 3 && fields[0] == "display" && fields[1] == "pan" {
+			id := fields[2]
+			f.mu.Lock()
+			w := f.panWindow[id]
+			for _, kv := range fields[3:] {
+				key, val, ok := splitKV(kv)
+				if !ok {
+					continue
+				}
+				switch key {
+				case "center":
+					if v, err := strconv.ParseFloat(val, 64); err == nil && v > 0 {
+						w.centre = v
+					}
+				case "bandwidth":
+					if v, err := strconv.ParseFloat(val, 64); err == nil && v > 0 {
+						w.width = v
+					}
+				}
+			}
+			f.panWindow[id] = w
+			f.mu.Unlock()
+		}
 		// Meter definitions — "meter <num>.src=… <num>.nam=… <num>.unit=… …".
 		// The unit scales the UDP values, the name labels them; subscribe to each
 		// new id so the radio streams it.
@@ -810,13 +888,25 @@ func (f *Flex) handleStatus(payload string) {
 				}
 				f.mu.Lock()
 				if removed {
+					// The radio expired or dropped this spot: forget what it looked
+					// like, or the next identical spot would be skipped as "already
+					// drawn" and the station would never come back.
+					if c, ok := f.spotCall[idx]; ok {
+						delete(f.spotSig, strings.ToUpper(c))
+						delete(f.spotSent, strings.ToUpper(c))
+					}
 					delete(f.spotIdx, idx)
 					delete(f.spotCall, idx)
 					delete(f.spotMode, idx)
+					delete(f.spotFreq, idx)
 				} else {
 					f.spotIdx[idx] = true
 				}
 				f.mu.Unlock()
+				if !removed {
+					f.probeForeignSpot(payload)
+					f.reportForeignSpot(payload)
+				}
 			}
 			debugLog.Printf("Flex: status %s", payload)
 		}
@@ -847,6 +937,8 @@ func (f *Flex) handleStatus(payload string) {
 			}
 		case "mode":
 			s.mode = val
+		case "pan":
+			s.pan = val
 		case "active":
 			s.active = val == "1"
 		case "tx":
@@ -1241,6 +1333,173 @@ func (f *Flex) SetMode(mode string) error {
 	return nil
 }
 
+// ZoomPan sets the visible width of the ACTIVE slice's panadapter, and puts the
+// frequency the operator clicked inside it.
+//
+// bandwidthMHz is the whole visible span, which is how SmartSDR expresses it —
+// not a zoom factor.
+//
+// Re-centring is the subtle part. SmartSDR keeps the panadapter's CENTRE when
+// only the width changes, so narrowing from 200 kHz to 25 for a CW spot — or
+// jumping to a spot clicked in the band map — regularly left the very signal the
+// operator asked for outside the new window: the radio had tuned to it, but the
+// display was showing somewhere else. So the centre moves when it must:
+//
+//	centre == true   always re-centre (the operator asked for it)
+//	centre == false  re-centre ONLY when freqMHz would fall outside the new
+//	                 window, leaving a settled display alone the rest of the time
+//
+// The test uses 40% of the width either side rather than the full half: a spot
+// pinned to the last pixel of the panadapter is visible in the arithmetic and
+// useless in practice.
+//
+// A no-op when the slice reports no panadapter, which is the case on a slice
+// that exists but is not displayed. Silent, because that is not a fault.
+// needRecentre decides whether the panadapter has to move for freqMHz to be
+// comfortably visible in a window of bandwidthMHz. forced short-circuits it.
+//
+// An unknown current centre (no pan status seen yet) counts as "would fall
+// outside": the display is more likely wrong than right, and re-centring on the
+// spot the operator just clicked is never the surprising answer.
+func needRecentre(cur panView, freqMHz, bandwidthMHz float64, forced bool) bool {
+	if freqMHz <= 0 {
+		return false // nothing to centre on
+	}
+	if forced {
+		return true
+	}
+	return cur.centre <= 0 || math.Abs(freqMHz-cur.centre) > bandwidthMHz*0.4
+}
+
+func (f *Flex) ZoomPan(bandwidthMHz, freqMHz float64, centre bool) error {
+	f.mu.Lock()
+	pan := ""
+	// The operator's slice, by the same rule as everything else — see
+	// mainSliceLocked. Zooming any other panadapter would move a display the
+	// operator is not looking at.
+	if _, sl := f.mainSliceLocked(); sl != nil {
+		pan = sl.pan
+	}
+	cur := f.panWindow[pan]
+	connected := f.conn != nil && f.gotHandle
+	f.mu.Unlock()
+	if !connected {
+		return fmt.Errorf("flex: not connected")
+	}
+	if pan == "" || bandwidthMHz <= 0 {
+		return nil
+	}
+	recentre := needRecentre(cur, freqMHz, bandwidthMHz, centre)
+	// Centre first, then width: SmartSDR clamps a window that would run past the
+	// end of the spectrum, and moving to the right place before widening leaves
+	// nothing to clamp.
+	if recentre {
+		f.send(fmt.Sprintf("display pan s %s center=%.6f", pan, freqMHz))
+	}
+	f.send(fmt.Sprintf("display pan s %s bandwidth=%.6f", pan, bandwidthMHz))
+	debugLog.Printf("Flex: zoom pan %s → %.4f MHz (centre=%v on %.6f, was %.6f)", pan, bandwidthMHz, recentre, freqMHz, cur.centre)
+	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.
@@ -1270,12 +1529,28 @@ func (f *Flex) SendSpot(s SpotInfo) error {
 	// and Go mutexes aren't reentrant (calling send while locked deadlocks the
 	// whole Flex goroutine → the radio drops OFFLINE).
 	upperCall := strings.ToUpper(s.Callsign)
+	// Unchanged and still fresh → leave it alone.
+	//
+	// Refreshed once past half its lifetime, so a long-lived spot still gets its
+	// timer wound on and never quietly expires off the panadapter; anything that
+	// actually differs (a new frequency, a status that has changed colour, a
+	// different comment) is redrawn at once.
+	sig := fmt.Sprintf("%d|%s|%s|%s|%s", s.FreqHz, s.Mode, s.Color, s.BackgroundColor, s.Comment)
 	f.mu.Lock()
+	if prev, ok := f.spotSig[upperCall]; ok && prev == sig {
+		if at, ok := f.spotSent[upperCall]; ok && time.Since(at) < time.Duration(life)*time.Second/2 {
+			f.mu.Unlock()
+			return nil
+		}
+	}
+	f.spotSig[upperCall] = sig
+	f.spotSent[upperCall] = time.Now()
 	old, hadOld := f.spotByCall[upperCall]
 	if hadOld {
 		delete(f.spotByCall, upperCall)
 		delete(f.spotCall, old)
 		delete(f.spotMode, old)
+		delete(f.spotFreq, old)
 		delete(f.spotIdx, old)
 	}
 	f.mu.Unlock()
@@ -1291,6 +1566,12 @@ func (f *Flex) SendSpot(s SpotInfo) error {
 	if m := flexEncode(adifModeToFlex(s.Mode, s.FreqHz)); m != "" {
 		cmd += " mode=" + m
 	}
+	// background_color is optional in the API and empty means "the radio's own".
+	// Sent only when set, so a spot with no configured background does not blank
+	// the default to nothing.
+	if bg := flexEncode(s.BackgroundColor); bg != "" {
+		cmd += " background_color=" + bg
+	}
 	if c := flexEncode(s.Comment); c != "" {
 		cmd += " comment=" + c
 	}
@@ -1302,6 +1583,7 @@ func (f *Flex) SendSpot(s SpotInfo) error {
 		f.mu.Lock()
 		f.pendingSpot[seq] = s.Callsign
 		f.pendingSpotMode[seq] = s.Mode
+		f.pendingSpotFreq[seq] = s.FreqHz
 		f.mu.Unlock()
 	}
 	return nil
@@ -1335,6 +1617,9 @@ func (f *Flex) ClearSpots() error {
 	f.spotIdx = map[int]bool{}
 	f.spotCall = map[int]string{}
 	f.spotMode = map[int]string{}
+	f.spotFreq = map[int]int64{}
+	f.spotSig = map[string]string{}
+	f.spotSent = map[string]time.Time{}
 	f.spotByCall = map[string]int{}
 	connected := f.conn != nil
 	f.mu.Unlock()
@@ -2163,6 +2448,34 @@ func (f *Flex) startMeters(conn net.Conn) {
 	debugLog.Printf("Flex: meters UDP local=:%d punch→%s", port, raddr)
 	go f.udpReader(uc)
 	go f.udpKeepalive(uc, raddr)
+	go f.udpWatchdog(uc)
+}
+
+// udpWatchdog says so when the meter stream never arrives.
+//
+// The meters come over VITA-49 on a UDP socket the radio sends TO US; the TCP
+// side can be perfectly healthy — handshake, slices, spots, everything — while
+// not one datagram gets through. On Windows that is almost always the firewall
+// refusing inbound UDP for a program it has not been asked about, and the only
+// symptom is meters that stay at zero. Nothing said so: an operator saw a
+// connected radio with dead meters and no reason anywhere.
+//
+// Five seconds is far longer than the stream's own 40 frames a second needs.
+func (f *Flex) udpWatchdog(uc *net.UDPConn) {
+	time.Sleep(5 * time.Second)
+	f.mu.Lock()
+	cur, seen := f.udpConn, f.vitaSeen
+	port := 0
+	if uc.LocalAddr() != nil {
+		port = uc.LocalAddr().(*net.UDPAddr).Port
+	}
+	f.mu.Unlock()
+	if cur != uc || seen > 0 {
+		return // reconnected in the meantime, or the stream is flowing
+	}
+	debugLog.Printf("Flex: NO meter data after 5s — the radio's VITA-49 stream is not reaching UDP port %d. "+
+		"The TCP link is fine, so this is almost always a firewall: allow OpsLog.exe inbound UDP "+
+		"(Windows Defender Firewall → Allow an app), or open port %d for %s", port, port, f.host)
 }
 
 func (f *Flex) udpReader(uc *net.UDPConn) {

internal/cat/flex_test.go

@@ -0,0 +1,34 @@
+package cat
+
+import "testing"
+
+func TestNeedRecentre(t *testing.T) {
+	pan := panView{centre: 14.100, width: 0.200}
+	// A spot the display is already showing comfortably: leave the window alone,
+	// which is the whole point of the option being off.
+	if needRecentre(pan, 14.110, 0.200, false) {
+		t.Fatal("moved a display that was already on the spot")
+	}
+	// Narrowing for a CW spot 40 kHz away: 25 kHz around the old centre would not
+	// reach it, so the centre must follow.
+	if !needRecentre(pan, 14.060, 0.025, false) {
+		t.Fatal("spot would have been left outside the new window")
+	}
+	// Near the very edge of the new window — visible in the arithmetic, useless
+	// in practice.
+	if !needRecentre(pan, 14.199, 0.200, false) {
+		t.Fatal("spot pinned to the edge counts as outside")
+	}
+	// The operator asked for it.
+	if !needRecentre(pan, 14.110, 0.200, true) {
+		t.Fatal("forced centring ignored")
+	}
+	// No pan status yet: assume the display is elsewhere.
+	if !needRecentre(panView{}, 14.110, 0.200, false) {
+		t.Fatal("unknown centre must re-centre")
+	}
+	// Nothing to centre on.
+	if needRecentre(pan, 0, 0.200, true) {
+		t.Fatal("centred on nothing")
+	}
+}

internal/cat/icom_foreign_test.go

@@ -0,0 +1,43 @@
+package cat
+
+import (
+	"testing"
+
+	"hamlog/internal/cat/civ"
+)
+
+// A CI-V bus can carry a second controller, and the rig answers each of them on
+// the same wire. A reply addressed to somebody else must not be taken for ours —
+// on an IC-7850 one arrived between a PTT command and its acknowledgement, the
+// acknowledgement was never matched, and the failure was handed to JTDX as a rig
+// control error.
+func TestForeignCIVRepliesAreIgnored(t *testing.T) {
+	const rig = 0x8E
+	frames, _ := civ.Scan([]byte{
+		0xFE, 0xFE, 0x01, rig, 0x1C, 0x00, 0x01, 0xFD, // to controller 01 — not ours
+		0xFE, 0xFE, civ.AddrController, rig, 0xFB, 0xFD, // to us: the acknowledgement
+		0xFE, 0xFE, 0x00, rig, 0x00, 0x00, 0x25, 0x09, 0x14, 0x00, 0xFD, // transceive broadcast
+	})
+	if len(frames) != 3 {
+		t.Fatalf("scanned %d frames, want 3", len(frames))
+	}
+	var kept []civ.Decoded
+	for _, f := range frames {
+		if f.From != rig {
+			continue
+		}
+		if f.To != civ.AddrController && f.To != 0x00 {
+			continue
+		}
+		kept = append(kept, f)
+	}
+	if len(kept) != 2 {
+		t.Fatalf("kept %d frames, want 2 (ours + the broadcast)", len(kept))
+	}
+	if kept[0].Cmd != 0xFB {
+		t.Errorf("the acknowledgement was not the first kept frame: % X", kept[0].Cmd)
+	}
+	if kept[1].To != 0x00 {
+		t.Errorf("the transceive broadcast was dropped")
+	}
+}

internal/cat/icomserial.go

@@ -189,7 +189,7 @@ func NewIcomSerial(portName string, baud, civAddr int, digitalDefault string) *I
 		}
 		p, err := serial.Open(b.portName, &serial.Mode{BaudRate: b.baud})
 		if err != nil {
-			return nil, fmt.Errorf("open %s @ %d baud: %w", b.portName, b.baud, err)
+			return nil, fmt.Errorf("open %s @ %d baud: %w%s", b.portName, b.baud, err, busyHint(b.portName, err))
 		}
 		return p, nil
 	}
@@ -514,8 +514,21 @@ func (b *IcomSerial) SetFrequency(hz int64) error {
 		return fmt.Errorf("invalid frequency")
 	}
 	b.lastSetFreq, b.lastSetFreqAt = hz, time.Now()
-	return b.execIdempotent(fmt.Sprintf("set frequency %d Hz", hz),
+	err := b.execIdempotent(fmt.Sprintf("set frequency %d Hz", hz),
 		append([]byte{civ.CmdSetFreq}, civ.FreqToBCD(hz)...)...)
+	// Same reasoning as SetPTT: a lost acknowledgement is not a failed command,
+	// and WSJT-X or JTDX answer a failed set_freq by dropping the link — an
+	// IC-7850 log shows exactly that at 15:16:15, the disconnect four seconds
+	// later. The rig is asked what frequency it is on rather than being called a
+	// failure on the strength of a missing "FB".
+	if err == nil || !errors.Is(err, errIcomAckLost) {
+		return err
+	}
+	if got, rerr := b.readFreq(); rerr == nil && got == hz {
+		applog.Printf("icom: frequency %d Hz not acknowledged, but the rig is on it — treating as done", hz)
+		return nil
+	}
+	return err
 }
 
 func (b *IcomSerial) SetMode(mode string) error {
@@ -526,8 +539,17 @@ func (b *IcomSerial) SetMode(mode string) error {
 	// Set the base mode (keeping the rig's current filter by sending only the
 	// mode byte), then set the data-mode flag for digital modes.
 	if err := b.execIdempotent("set mode "+mode, civ.CmdSetMode, code); err != nil {
+		// A lost acknowledgement is not a refused mode — see SetPTT. The mode is
+		// readable, so ask rather than report a failure that would cost the
+		// digital application its connection.
+		if !errors.Is(err, errIcomAckLost) {
 			return err
 		}
+		if got, ok := b.readMode(); !ok || got != code {
+			return err
+		}
+		applog.Printf("icom: mode %s not acknowledged, but the rig reports it — treating as done", mode)
+	}
 	dataByte := byte(0)
 	if data {
 		dataByte = 1
@@ -569,12 +591,43 @@ func (b *IcomSerial) execIdempotent(what string, payload ...byte) error {
 }
 
 // SetPTT keys or unkeys the transmitter (CI-V 0x1C 0x00).
+// A lost acknowledgement is NOT proof the rig ignored us, and treating it as one
+// is expensive: OpsLog fronts a Hamlib rigctl port, so the failure is handed
+// straight to WSJT-X or JTDX, which answer a failed set_ptt with a Rig Control
+// Error and drop the link mid-over. An IC-7850 log showed exactly that, three
+// times in a session, on a CI-V bus with a second controller corrupting frames.
+//
+// So when the acknowledgement does not arrive, ASK the rig what it is doing. PTT
+// is readable (0x1C 0x00), the answer is unambiguous, and a rig that is keyed
+// received the command whatever became of its reply.
 func (b *IcomSerial) SetPTT(on bool) error {
 	state := byte(0)
 	if on {
 		state = 1
 	}
-	return b.execIdempotent(fmt.Sprintf("PTT %v", on), civ.CmdPTT, civ.SubPTT, state)
+	err := b.execIdempotent(fmt.Sprintf("PTT %v", on), civ.CmdPTT, civ.SubPTT, state)
+	if err == nil || !errors.Is(err, errIcomAckLost) {
+		return err
+	}
+	// A GENEROUS window for the verification, not the poll's 150 ms.
+	//
+	// The rig has just failed to answer twice in 800 ms, and the reason seen on a
+	// real IC-7850 is that it was retuning: JTDX moves the transmit frequency and
+	// keys in the same breath. Asking it again with the short probe timeout would
+	// fail for exactly the same reason and prove nothing.
+	keyed, ok := b.readTXWithin(icomPTTVerifyTimeout)
+	if ok && keyed == on {
+		applog.Printf("icom: PTT %v not acknowledged, but the rig reports it — treating as done", on)
+		return nil
+	}
+	// Logged either way, because "the fix did not work" and "the rig really did
+	// not key" look identical from outside and need telling apart.
+	if ok {
+		applog.Printf("icom: PTT %v not acknowledged, and the rig reports %v — reporting the failure", on, keyed)
+	} else {
+		applog.Printf("icom: PTT %v not acknowledged, and the rig did not answer the check either", on)
+	}
+	return err
 }
 
 // SetPower turns the transceiver on or off (CI-V 0x18). Power-ON is prefixed with
@@ -686,6 +739,19 @@ func (b *IcomSerial) reader(port civTransport, done chan struct{}) {
 			if f.From != b.rigAddr {
 				continue // echo of our own command
 			}
+			// Addressed to US, or broadcast.
+			//
+			// A CI-V bus can carry a second controller — RS-BA1, wfview, another
+			// logger — and the rig answers each of them in turn on the same wire.
+			// Those replies come FROM the rig, so the check above lets them through,
+			// and one can be taken for the answer to our own command: an IC-7850 log
+			// showed "FE FE 01 8E …" (to controller 01) arriving between our PTT
+			// command and its acknowledgement, with bus collisions around it.
+			// Transceive broadcasts (to 0x00) stay welcome — that is how the rig
+			// announces a knob turn.
+			if f.To != civ.AddrController && f.To != 0x00 {
+				continue
+			}
 			if f.Cmd == civ.CmdScope {
 				b.route(b.specCh, f)
 				continue
@@ -1273,16 +1339,30 @@ func (b *IcomSerial) readTXFreq() (int64, bool) {
 
 // readTX reads the transmit state (CI-V 0x1C 0x00): non-zero data = keyed.
 func (b *IcomSerial) readTX() bool {
+	on, _ := b.readTXWithin(icomDSPTimeout)
+	return on
+}
+
+// icomPTTVerifyTimeout is how long the PTT check waits. Long, deliberately: it
+// runs only after a command was already given up on, so it costs nothing in the
+// normal case and everything depends on it in the abnormal one.
+const icomPTTVerifyTimeout = 700 * time.Millisecond
+
+// readTXWithin reads the transmit state, reporting whether the rig ANSWERED.
+//
+// The two are different questions and the caller usually needs both: "not
+// transmitting" and "did not say" are the same bool but not the same fact.
+func (b *IcomSerial) readTXWithin(timeout time.Duration) (on bool, answered bool) {
 	if err := b.write(civ.CmdPTT, civ.SubPTT); err != nil {
-		return false
+		return false, false
 	}
-	f, err := b.recv(icomDSPTimeout, func(d civ.Decoded) bool {
+	f, err := b.recv(timeout, func(d civ.Decoded) bool {
 		return d.Cmd == civ.CmdPTT && len(d.Data) >= 2 && d.Data[0] == civ.SubPTT
 	})
 	if err != nil {
-		return false
+		return false, false
 	}
-	return f.Data[1] != 0
+	return f.Data[1] != 0, true
 }
 
 // readMeter reads a meter (CI-V 0x15) and returns it scaled to 0-100.

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.
 	//
@@ -210,7 +227,7 @@ func (k *Kenwood) Connect() error {
 		if k.host != "" {
 			return fmt.Errorf("kenwood: connect %s: %w", k.host, err)
 		}
-		return fmt.Errorf("kenwood: open %s @ %d baud: %w", k.portName, k.baud, err)
+		return fmt.Errorf("kenwood: open %s @ %d baud: %w%s", k.portName, k.baud, err, busyHint(k.portName, err))
 	}
 	p.SetReadTimeout(300 * time.Millisecond)
 	k.port = p
@@ -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/omnirig.go

@@ -500,10 +500,30 @@ func (o *OmniRig) SetFrequency(hz int64) error {
 	// deliberately; a spot click is a request to change frequency, not to change
 	// VFO. On SUB the direct FreqB write below does the whole job.
 	onSubVFO := vfo == "B" || vfo == "BB" || vfo == "BA"
+	// …and NEVER on a Yaesu.
+	//
+	// On Yaesu the call is useless at best: an FT-891 logged "SetSimplexMode OK"
+	// on every spot click while FreqA never moved (see below — the direct property
+	// write is what actually tunes these rigs). On an FT-2000 it is worse than
+	// useless. From a log of one QSY, before and after the call:
+	//
+	//	Vfo="AB"(0x80)  Split=0x10000 (off)   → the operator's state
+	//	Vfo="BA"(0x100) Split=0x8000  (ON)    → after SetSimplexMode
+	//
+	// The rig-agnostic "receive and transmit HERE, simplex" method turned split ON
+	// and moved reception to VFO B, which is exactly what the operator reported:
+	// OpsLog showing B instead of A. OpsLog was not misreading the radio — it was
+	// reading it correctly after having moved it itself.
+	//
+	// Restricted to Yaesu because that is where the evidence is: on Icom the call
+	// is authoritative and the direct write is the unreliable one.
+	isYaesu := isYaesuRig(rigType)
 	simplexOK := false
 	switch {
 	case onSubVFO:
 		debugLog.Printf("OmniRig.SetFrequency: on VFO %q — skipping SetSimplexMode so the rig stays on SUB", vfo)
+	case isYaesu:
+		debugLog.Printf("OmniRig.SetFrequency: %q is a Yaesu — skipping SetSimplexMode (a no-op on some, and on an FT-2000 it turns split on and jumps to VFO B); the direct write below does the work", rigType)
 	default:
 		if _, err := oleutil.CallMethod(o.rig, "SetSimplexMode", int32(hz32)); err == nil {
 			simplexOK = true

internal/cat/omnirig_vfo_test.go

@@ -125,3 +125,24 @@ func TestOmniRigWriteTarget(t *testing.T) {
 		}
 	}
 }
+
+// SetSimplexMode is skipped on Yaesu, and that is not a preference.
+//
+// On an FT-891 it returned OK on every spot click while the rig never moved. On
+// an FT-2000 it did something worse — a log of one QSY shows the state going
+// from Vfo="AB" split off to Vfo="BA" split ON, so the operator's reception
+// jumped to VFO B and OpsLog, reading the radio correctly, displayed B. The
+// direct FreqA/Freq write does the tuning on these rigs.
+func TestYaesuRigsAreRecognisedForTheSimplexSkip(t *testing.T) {
+	for _, yes := range []string{"FT-2000", "FT-891", "FTDX10", "ftdx101", " FT-991A "} {
+		if !isYaesuRig(yes) {
+			t.Errorf("%q not recognised as a Yaesu — SetSimplexMode would still be called on it", yes)
+		}
+	}
+	// Everything else keeps the call: on Icom it is the authoritative one.
+	for _, no := range []string{"IC-7610", "TS-590", "K3", "", "Flex-6600"} {
+		if isYaesuRig(no) {
+			t.Errorf("%q wrongly treated as a Yaesu", no)
+		}
+	}
+}

internal/cat/portbusy.go

@@ -0,0 +1,39 @@
+package cat
+
+// "Serial port busy" is a true statement that helps nobody.
+//
+// A COM port has exactly one owner, and when a rig's port is refused the owner
+// is almost always another program on the same desktop — most often OmniRig,
+// which stays resident once any application has activated it and keeps the port
+// of the rig configured in it. An operator switching from OmniRig to a native
+// backend therefore hits this the moment they save: OpsLog is now asking for a
+// port OmniRig never let go of. The message named none of that.
+//
+// It also happens the other way round, and the wording says so rather than
+// accusing: a digital application (WSJT-X, JTDX, MSHV) configured on the rig's
+// port directly, rather than through OpsLog's CAT sharing, holds it just as
+// firmly.
+
+import "strings"
+
+// busyHint returns a sentence to append to an open error, or "" when the error
+// is not about the port being taken.
+//
+// Deliberately not a wrapped error: this is advice for a human reading a log,
+// and it must not change how any caller compares the error.
+func busyHint(port string, err error) string {
+	if err == nil {
+		return ""
+	}
+	msg := strings.ToLower(err.Error())
+	busy := strings.Contains(msg, "busy") ||
+		strings.Contains(msg, "access is denied") ||
+		strings.Contains(msg, "denied") ||
+		strings.Contains(msg, "in use")
+	if !busy {
+		return ""
+	}
+	return " — another program holds " + port +
+		". OmniRig is the usual one (it stays running and keeps the port of the rig configured in it, so a native backend can never have it);" +
+		" a digital application pointed straight at the rig instead of at OpsLog's CAT sharing does the same. Close it, then reconnect."
+}