chore: release v0.24.5

A saved band selection outlives the code that made it. 12 m was removed from the
watched set, but every operator who had already enabled the watch kept
subscribing to it — paying for a firehose whose messages the detector then threw
away. The stored list is filtered against the offered one now.

The badge appeared on the next poll rather than on the event, up to twenty
seconds after the announcement, so the two read as unrelated things that happened
to mention the same band. It appears immediately.

And the toast is gone. It said the same thing as the badge and vanished after
five seconds — an operator who was tuning when it passed had no way back to it,
which is precisely what the badge was built to fix. Keeping both announced an
opening twice and still lost it once.

app.go

@@ -49,6 +49,7 @@ import (
 	"hamlog/internal/pota"
 	"hamlog/internal/powergenius"
 	"hamlog/internal/profile"
+	"hamlog/internal/pskr"
 	"hamlog/internal/qslcard"
 	"hamlog/internal/qso"
 	"hamlog/internal/relaydev"
@@ -609,6 +610,10 @@ type App struct {
 	// air now, not a database.
 	decodeGrids   map[string]string
 	decodeGridsMu sync.RWMutex
+	// pskr is the PSK Reporter MQTT feed, up only while the opening watch is on.
+	// It is the source that makes VHF detection work at all: the cluster and RBN
+	// carry a handful of 6 m spots where PSK Reporter carries hundreds.
+	pskr *pskr.Watcher
 	// Self-spot throttle: when and on what frequency we last announced ourselves.
 	// Held in memory only — a restart legitimately re-announces the station.
 	selfSpotMu     sync.Mutex
@@ -1399,6 +1404,9 @@ func (a *App) startup(ctx context.Context) {
 	go a.sendTelemetryHeartbeat()
 	go a.liveStatusLoop() // multi-op: heartbeat current activity to shared MySQL
 	go a.chatLoop()       // multi-op: poll the shared chat + heartbeat presence
+	// PSK Reporter, when the opening watch is on. After the operator's grid is
+	// known: without it there is no distance to measure and the feed stays down.
+	a.startBandOpenFeed()
 
 	fmt.Println("OpsLog: db ready at", a.dbPath)
 }
@@ -14714,12 +14722,10 @@ func (a *App) startUltrabeam() {
 	}
 	a.motorAnt = c
 	_ = a.motorAnt.Start()
-	if s.Follow {
-		stop := make(chan struct{})
-		a.ubFollowStop = stop
-		applog.Printf("ultrabeam: follow loop starting — covered bands %v, step %d kHz", s.Bands, s.StepKHz)
-		go a.ultrabeamFollowLoop(a.motorAnt, s.StepKHz, s.Bands, stop)
-	}
+	// One place starts the follow loop, whether the antenna just connected or the
+	// operator flipped tracking from the Station Control widget. Two copies of
+	// this drifting apart is how a step change quietly stops taking effect.
+	a.restartMotorFollow(s)
 	if s.TXInhibit {
 		stop := make(chan struct{})
 		a.motorInhibStop = stop
@@ -14978,6 +14984,14 @@ type UltrabeamStatusInfo struct {
 	Band      int    `json:"band"`
 	Moving    bool   `json:"moving"`
 	Elements  []int  `json:"elements"` // per-element lengths (mm); empty when unsupported
+	// Follow and StepKHz are mirrored here so the Station Control widget can show
+	// and change tracking without loading the whole settings block for a poll.
+	Follow  bool `json:"follow"`
+	StepKHz int  `json:"step_khz"`
+	// Bands the antenna is configured to cover — the widget offers exactly these
+	// as buttons rather than inventing its own list, so a band dropped in Settings
+	// cannot be clicked here.
+	Bands []string `json:"bands"`
 }
 
 // GetUltrabeamStatus returns the antenna's current state for the UI poll.
@@ -14986,6 +15000,9 @@ func (a *App) GetUltrabeamStatus() UltrabeamStatusInfo {
 	s, _ := a.GetUltrabeamSettings()
 	out.Enabled = s.Enabled
 	out.Type = s.Type
+	out.Follow = s.Follow
+	out.StepKHz = s.StepKHz
+	out.Bands = append(out.Bands, s.Bands...)
 	if a.motorAnt == nil {
 		return out
 	}
@@ -15043,6 +15060,107 @@ func (a *App) SetUltrabeamDirection(direction int) error {
 	return a.motorAnt.SetDirection(direction)
 }
 
+// MotorTuneKHz points the antenna at a frequency, in kHz.
+//
+// The direction is carried over from the antenna's current state rather than
+// reset: both controllers set frequency and pattern in the same command, so
+// sending a bare frequency would silently drop a 180° or bidirectional pattern
+// the operator had chosen — a beam quietly turning round is not an acceptable
+// side effect of clicking a band.
+func (a *App) MotorTuneKHz(khz int) error {
+	if a.motorAnt == nil {
+		return fmt.Errorf("antenna not connected — enable it in Settings → Antenna")
+	}
+	// A generous envelope rather than a band table: the antennas differ, some
+	// carry extensions, and refusing a frequency the hardware would have accepted
+	// is worse than letting the controller say no itself.
+	if khz < 1000 || khz > 60000 {
+		return fmt.Errorf("frequency %d kHz is outside anything these antennas tune", khz)
+	}
+	a.noteMotorMoveCommanded()
+	return a.motorAnt.SetFrequency(khz, a.motorAnt.Status().Direction)
+}
+
+// MotorNudgeKHz moves the antenna's commanded frequency by a step, up or down.
+//
+// Works from the ANTENNA's frequency, not the rig's: this exists so an operator
+// can walk the antenna across a band while the rig stays where it is, and
+// starting from the rig would undo that on the first press. Falls back to the
+// rig only when the antenna has not reported a frequency yet.
+func (a *App) MotorNudgeKHz(deltaKHz int) error {
+	if a.motorAnt == nil {
+		return fmt.Errorf("antenna not connected — enable it in Settings → Antenna")
+	}
+	cur := a.motorAnt.Status().Frequency
+	if cur <= 0 && a.cat != nil {
+		if rs := a.cat.State(); rs.Connected && rs.FreqHz > 0 {
+			cur = int(rs.FreqHz / 1000)
+		}
+	}
+	if cur <= 0 {
+		return fmt.Errorf("the antenna has not reported a frequency yet")
+	}
+	return a.MotorTuneKHz(cur + deltaKHz)
+}
+
+// SetMotorFollow turns frequency tracking on or off and sets its step, without
+// opening Settings. Both are ordinary operating decisions — an operator turns
+// tracking off to park the antenna and back on to resume — and a preferences
+// dialog is the wrong place for something changed that often.
+func (a *App) SetMotorFollow(on bool, stepKHz int) error {
+	s, err := a.GetUltrabeamSettings()
+	if err != nil {
+		return err
+	}
+	switch stepKHz {
+	case 25, 50, 100:
+		s.StepKHz = stepKHz
+	case 0: // leave the step alone
+	default:
+		return fmt.Errorf("step must be 25, 50 or 100 kHz")
+	}
+	s.Follow = on
+
+	// Persist WITHOUT the restart. SaveUltrabeamSettings tears the client down and
+	// dials again, which is right when the transport changed and absurd here: the
+	// operator toggling tracking watched the antenna drop off and reconnect, and
+	// on a remote controller that is several seconds of a link that was working.
+	//
+	// The follow loop is a goroutine with its own stop channel, so it can be
+	// replaced on its own — the connection underneath never knows.
+	// Only the two keys this call actually changes. Writing the whole block would
+	// mean re-normalising host, port, baud and bands to change a checkbox, and
+	// every one of those is a chance to alter something nobody asked to alter.
+	if a.settings == nil {
+		return fmt.Errorf("db not initialized")
+	}
+	if err := a.settings.Set(a.ctx, keyUltrabeamFollow, boolStr(s.Follow)); err != nil {
+		return err
+	}
+	if err := a.settings.Set(a.ctx, keyUltrabeamStep, strconv.Itoa(s.StepKHz)); err != nil {
+		return err
+	}
+	a.restartMotorFollow(s)
+	return nil
+}
+
+// restartMotorFollow swaps the follow loop for one matching the settings, leaving
+// the antenna connection alone.
+func (a *App) restartMotorFollow(s UltrabeamSettings) {
+	if a.ubFollowStop != nil {
+		close(a.ubFollowStop)
+		a.ubFollowStop = nil
+	}
+	if !s.Follow || a.motorAnt == nil {
+		applog.Printf("ultrabeam: follow loop stopped")
+		return
+	}
+	stop := make(chan struct{})
+	a.ubFollowStop = stop
+	applog.Printf("ultrabeam: follow loop restarting — covered bands %v, step %d kHz", s.Bands, s.StepKHz)
+	go a.ultrabeamFollowLoop(a.motorAnt, s.StepKHz, s.Bands, stop)
+}
+
 // UltrabeamRetract retracts all elements (storage / safe position).
 func (a *App) UltrabeamRetract() error {
 	if a.motorAnt == nil {
@@ -16812,6 +16930,14 @@ func (r catShareRig) SetFreq(hz int64) error { return r.a.cat.SetFrequency(hz) }
 func (r catShareRig) SetMode(m string) error { return r.a.cat.SetMode(m) }
 func (r catShareRig) SetPTT(on bool) error   { return r.a.cat.SetPTT(on) }
 
+// SetSplit passes the client's split request through to the radio, and passes
+// the refusal back when the backend cannot do it. That refusal is the feature:
+// WSJT-X can tell the operator to use "Fake It" instead, where before it was
+// told everything had worked and transmitted on the receive frequency.
+func (r catShareRig) SetSplit(on bool, txHz int64) error {
+	return r.a.cat.SetSplit(on, txHz)
+}
+
 // reloadCATShare starts, stops or restarts the sharing server to match the
 // settings. Called from reloadCAT so one "Save & Close" settles both.
 func (a *App) reloadCATShare(s CATSettings) {

app_gate.go

@@ -16,6 +16,8 @@ var deniedCallHashes = map[string]struct{}{
 	"2282a88b3e5e4eebc6b8174d005bb46d32025758b7741bdcf34f2b3621c02205": {},
 	"0ee09fe60817a2a4982f5e5b14a60b8dbb11cff55b3d36661213c4cbdd0933ea": {},
 	"46fb61e71afb40627cb6493a6a59c9d4d0231ee3cad1a2bf3fcc4cdfce36fabc": {},
+	"d1ae6212ec057f9d5c6f379fb57acedac7c94142c9d49667dc04b2016d03d1b6": {},
+	"0741c9e394b42f43191899105553b47155ddc3026da12b5360701f9c181ff123": {},
 }
 
 // callDenied reports whether a callsign is on deniedCallHashes. The call is

bandopen_sources.go

@@ -0,0 +1,219 @@
+package main
+
+// The data sources band-opening detection depends on, and the settings that
+// switch them on.
+//
+// The detection shipped reading whatever the operator's cluster nodes happened
+// to carry. That was a design mistake of the worst kind: the feature depended
+// on RBN feeds and a PSK Reporter subscription that nobody could know were
+// needed, so it looked broken rather than unconfigured. Nexus showed a 6 m
+// opening with 869 stations while OpsLog, on the same PC, showed nothing.
+//
+// So enabling the watch ARRANGES ITS OWN SOURCES: it adds the two RBN nodes if
+// they are missing and brings the PSK Reporter feed up. Turning it off leaves
+// the nodes alone — they may have been wanted for their own sake, and silently
+// removing a cluster node an operator is using would be worse than leaving one
+// they no longer need.
+
+import (
+	"strings"
+
+	"hamlog/internal/applog"
+	"hamlog/internal/bandopen"
+	"hamlog/internal/cluster"
+	"hamlog/internal/pskr"
+)
+
+const (
+	keyBandOpenEnabled = "bandopen.enabled"
+	keyBandOpenBands   = "bandopen.bands" // comma-separated; empty = the default set
+)
+
+// rbnNodes are the two Reverse Beacon Network endpoints the watch wants: CW and
+// digital are separate ports and carry different skimmers.
+var rbnNodes = []cluster.ServerConfig{
+	{Name: "RBN CW", Host: "telnet.reversebeacon.net", Port: 7000, Enabled: true},
+	{Name: "RBN FTx", Host: "telnet.reversebeacon.net", Port: 7001, Enabled: true},
+}
+
+// BandOpenSettings is the panel's shape.
+type BandOpenSettings struct {
+	Enabled bool     `json:"enabled"`
+	Bands   []string `json:"bands"`
+	// 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"`
+}
+
+func (a *App) GetBandOpenSettings() BandOpenSettings {
+	s := BandOpenSettings{
+		Enabled:   a.settingOr(keyBandOpenEnabled, "") == "1",
+		Bands:     splitCSV(a.settingOr(keyBandOpenBands, "")),
+		Available: pskr.Bands,
+	}
+	// 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
+	// had already enabled the watch kept subscribing to it — paying for a firehose
+	// whose messages the detector then threw away.
+	s.Bands = keepKnownBands(s.Bands)
+	if len(s.Bands) == 0 {
+		s.Bands = append(s.Bands, pskr.Bands...)
+	}
+	return s
+}
+
+func keepKnownBands(want []string) []string {
+	ok := make(map[string]bool, len(pskr.Bands))
+	for _, b := range pskr.Bands {
+		ok[b] = true
+	}
+	out := make([]string, 0, len(want))
+	for _, b := range want {
+		if ok[strings.ToLower(strings.TrimSpace(b))] {
+			out = append(out, b)
+		}
+	}
+	return out
+}
+
+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, ","))
+	if s.Enabled {
+		a.ensureRBNNodes()
+	}
+	a.startBandOpenFeed()
+	return nil
+}
+
+// ensureRBNNodes adds the RBN endpoints when they are absent.
+//
+// Matched on host AND port rather than on name: an operator who renamed theirs
+// "Skimmers CW" has the node, and adding a second one pointed at the same
+// server would give them every spot twice — which the detector would read as
+// twice as many stations, i.e. an opening that is not there.
+func (a *App) ensureRBNNodes() {
+	have, err := a.ListClusterServers()
+	if err != nil {
+		applog.Printf("bandopen: cannot read the cluster nodes (%v) — not adding RBN", err)
+		return
+	}
+	for _, want := range rbnNodes {
+		found := false
+		for _, h := range have {
+			if strings.EqualFold(strings.TrimSpace(h.Host), want.Host) && h.Port == want.Port {
+				found = true
+				break
+			}
+		}
+		if found {
+			continue
+		}
+		if _, err := a.SaveClusterServer(want); err != nil {
+			applog.Printf("bandopen: could not add %s: %v", want.Name, err)
+			continue
+		}
+		applog.Printf("bandopen: added cluster node %s (%s:%d) — the watch needs it",
+			want.Name, want.Host, want.Port)
+	}
+}
+
+// startBandOpenFeed brings the PSK Reporter subscription up or down to match
+// the setting. Called at startup and whenever the setting is saved.
+func (a *App) startBandOpenFeed() {
+	if a.pskr != nil {
+		a.pskr.Stop()
+		a.pskr = nil
+	}
+	s := a.GetBandOpenSettings()
+	if !s.Enabled {
+		return
+	}
+	// Every spot is measured from the operator's position. Without one there is
+	// nothing to measure, and a detector fed unmeasurable spots reports nothing
+	// while looking like it is working.
+	if !a.opSet {
+		applog.Printf("bandopen: no station grid set — the opening watch needs one to measure a path")
+		return
+	}
+	a.pskr = pskr.New(pskr.Config{
+		Bands: s.Bands,
+		OpLat: a.opLat, OpLon: a.opLon,
+		Geo: func(grid string) (int, int, bool) {
+			lat, lon, ok := gridToLatLon(grid)
+			if !ok {
+				return 0, 0, false
+			}
+			// The same arithmetic the cluster path uses, so one spot cannot be
+			// 2000 km away down one road and 2100 km down the other.
+			d := int(haversineKm(a.opLat, a.opLon, lat, lon) + 0.5)
+			b := int(initialBearingDeg(a.opLat, a.opLon, lat, lon) + 0.5)
+			return d, b, true
+		},
+		OnSpot: a.feedBandOpen,
+		Logf:   applog.Printf,
+	})
+	if err := a.pskr.Start(); err != nil {
+		applog.Printf("bandopen: PSK Reporter feed did not start: %v", err)
+	}
+}
+
+// feedBandOpen hands one PSK Reporter decode to the detector.
+//
+// Called from the MQTT goroutine at up to thousands a minute when 6 m is open,
+// so it does the least possible: the detector's own window and de-duplication
+// by callsign are what turn that flood into one announcement.
+func (a *App) feedBandOpen(s pskr.Spot) {
+	if !bandopen.Watched(s.Band) {
+		return
+	}
+	a.bandOpen.mu.Lock()
+	if a.bandOpen.det == nil {
+		a.bandOpen.det = bandopen.New(bandopen.DefaultConfig())
+	}
+	op := a.bandOpen.det.Add(bandopen.Spot{
+		Call: s.Call, Band: s.Band, DistKm: s.DistKm, Bearing: s.Bearing, At: s.At,
+	}, a.opLat)
+	if op != nil {
+		a.rememberOpening(*op)
+	}
+	if s.DistKm >= bandopen.DefaultConfig().MinKm {
+		a.markBandAlive(s.Band, s.At)
+	}
+	a.bandOpen.mu.Unlock()
+	if op != nil {
+		a.announceOpening(*op)
+	}
+}
+
+// GetPSKReporterStatus is what the settings panel polls.
+func (a *App) GetPSKReporterStatus() pskr.Status {
+	if a.pskr == nil {
+		return pskr.Status{Bands: pskr.Bands}
+	}
+	return a.pskr.Status()
+}
+
+// settingOr reads one key, falling back when the store is not up yet or the
+// value is blank. The settings store is a plain string key/value and every
+// caller does this by hand; two of them here earn the helper.
+func (a *App) settingOr(key, def string) string {
+	if a.settings == nil {
+		return def
+	}
+	v, _ := a.settings.Get(a.ctx, key)
+	if strings.TrimSpace(v) == "" {
+		return def
+	}
+	return v
+}
+
+func splitCSV(s string) []string {
+	var out []string
+	for _, p := range strings.Split(s, ",") {
+		if p = strings.TrimSpace(p); p != "" {
+			out = append(out, p)
+		}
+	}
+	return out
+}

bandopening.go

@@ -11,6 +11,7 @@ import (
 	"fmt"
 	"strings"
 	"sync"
+	"time"
 
 	"hamlog/internal/applog"
 	"hamlog/internal/bandopen"
@@ -23,8 +24,23 @@ type bandOpenState struct {
 	mu   sync.Mutex
 	det  *bandopen.Detector
 	last []bandopen.Opening // most recent first, for the UI
+	// live holds the announced openings that are still going, keyed by band, and
+	// aliveUntil says when each stops counting as current.
+	//
+	// The detector announces an opening ONCE and then goes quiet for 45 minutes,
+	// which is right for a message but useless for a badge that has to stay lit
+	// while the band is open and go out when it closes. Nothing tells us an
+	// opening ended, so it is inferred: every qualifying spot on that band pushes
+	// the deadline out, and when they stop arriving the badge fades by itself.
+	live       map[string]bandopen.Opening
+	aliveUntil map[string]time.Time
 }
 
+// openingIdle is how long a band may go without a qualifying spot before its
+// badge goes out. Longer than the detector's own 12-minute window, so a quiet
+// couple of minutes mid-opening does not blink the badge off and on again.
+const openingIdle = 15 * time.Minute
+
 const maxRememberedOpenings = 20
 
 // detectBandOpening feeds one spot to the detector and announces a hit.
@@ -43,16 +59,73 @@ func (a *App) detectBandOpening(s cluster.Spot) {
 		Bearing: s.ShortPath, At: s.ReceivedAt,
 	}, a.opLat)
 	if op != nil {
-		a.bandOpen.last = append([]bandopen.Opening{*op}, a.bandOpen.last...)
-		if len(a.bandOpen.last) > maxRememberedOpenings {
-			a.bandOpen.last = a.bandOpen.last[:maxRememberedOpenings]
-		}
+		a.rememberOpening(*op)
+	}
+	// Keeps a lit badge lit. Gated on the same floor the detector uses, or a
+	// band busy with short-range tropo would hold an Es badge on for ever.
+	if s.DistanceKm >= bandopen.DefaultConfig().MinKm {
+		a.markBandAlive(s.Band, s.ReceivedAt)
 	}
 	a.bandOpen.mu.Unlock()
-	if op == nil {
-		return
+	if op != nil {
+		a.announceOpening(*op)
 	}
+}
 
+// markBandAlive pushes a band's badge deadline out. Called for every spot the
+// detector accepted, from either feed. Cheap on purpose: this runs on the MQTT
+// goroutine at thousands a minute when 6 m is open.
+//
+// Caller holds bandOpen.mu.
+func (a *App) markBandAlive(band string, at time.Time) {
+	if _, lit := a.bandOpen.live[strings.ToLower(band)]; !lit {
+		return // nothing announced for this band, nothing to keep alive
+	}
+	if a.bandOpen.aliveUntil == nil {
+		a.bandOpen.aliveUntil = map[string]time.Time{}
+	}
+	a.bandOpen.aliveUntil[strings.ToLower(band)] = at.Add(openingIdle)
+}
+
+// rememberOpening files a detection and lights its badge. Caller holds the mutex.
+func (a *App) rememberOpening(op bandopen.Opening) {
+	a.bandOpen.last = append([]bandopen.Opening{op}, a.bandOpen.last...)
+	if len(a.bandOpen.last) > maxRememberedOpenings {
+		a.bandOpen.last = a.bandOpen.last[:maxRememberedOpenings]
+	}
+	if a.bandOpen.live == nil {
+		a.bandOpen.live = map[string]bandopen.Opening{}
+		a.bandOpen.aliveUntil = map[string]time.Time{}
+	}
+	b := strings.ToLower(op.Band)
+	a.bandOpen.live[b] = op
+	a.bandOpen.aliveUntil[b] = op.At.Add(openingIdle)
+}
+
+// GetLiveOpenings returns the openings still under way, for the status-bar
+// badge. Expired ones are dropped as they are noticed — there is no janitor for
+// something that holds at most five entries.
+func (a *App) GetLiveOpenings() []bandopen.Opening {
+	now := time.Now()
+	a.bandOpen.mu.Lock()
+	defer a.bandOpen.mu.Unlock()
+	out := make([]bandopen.Opening, 0, len(a.bandOpen.live))
+	for b, op := range a.bandOpen.live {
+		if until, ok := a.bandOpen.aliveUntil[b]; !ok || now.After(until) {
+			delete(a.bandOpen.live, b)
+			delete(a.bandOpen.aliveUntil, b)
+			applog.Printf("bandopen: %s opening has gone quiet", strings.ToUpper(b))
+			continue
+		}
+		out = append(out, op)
+	}
+	return out
+}
+
+// announceOpening logs and pushes one detection. Shared by both feeds — the
+// cluster path here and the PSK Reporter path in bandopen_sources.go — so an
+// opening reads the same however it was noticed.
+func (a *App) announceOpening(op bandopen.Opening) {
 	applog.Printf("bandopen: %s opening — %d stations, ~%d km, %s%s (%s)",
 		op.Band, op.Calls, op.MedianKm, op.Sector(),
 		map[bool]string{true: "", false: " — UNUSUAL for the season"}[op.InSeason],

changelog.json

@@ -1,4 +1,30 @@
 [
+  {
+    "version": "0.24.5",
+    "date": "",
+    "en": [
+      "Digital decodes: a station's grid square could be logged as its callsign when the message text was unusual. A grid in the callsign position is now refused.",
+      "CW over CAT now works on a Kenwood. The KY command was sent in Elecraft's variable-length form; a Kenwood needs exactly 24 characters, so every message was refused.",
+      "Shared CAT is steadier and now diagnoses itself. It survives a rig answering \"busy\" just after transmit instead of dropping the link, stops repeating a PTT state the client never changed, and logs a plain explanation when another program has taken its port or when a client is set to a rig model instead of Hamlib NET rigctl. It also answers the lock-mode and stop-morse commands some clients send around every transmit, instead of refusing them.",
+      "Web publishing now offers every field a QSO carries, awards included — 123 instead of 23 — from a searchable dropdown, with the chosen columns listed above it in publication order. Choose carefully: the page is public and the list includes addresses and e-mail.",
+      "Band-opening detection now works on the bands it was meant for. Switching on \"Watch for band openings\" (Settings › DX Cluster) subscribes to the PSK Reporter feed and adds the two RBN nodes it needs — it was reading a handful of VHF cluster spots while thousands of stations were reporting. It watches 10, 6, 4 and 2 m, counts only reports collected within 300 km of you so an opening means an opening HERE, no longer throws away paths beyond 2400 km, and looks for the busiest direction instead of demanding that every station heard sit in one sector. An opening under way shows as a blinking badge beside the clock the moment it is found — band, direction and typical distance, with a mark when it is unusual for the season — and stays until the band goes quiet, and the direction it names is right — a sector crossing north used to be announced as its opposite.",
+      "Test connection now actually tests. Club Log checked that the three fields were not empty and reported success without contacting anyone, so a wrong password looked exactly like a right one; it now signs in for real, through the read-only endpoint so a test can never add a record. LoTW reports its two credentials separately: TQSL signs uploads and never uses the website password, so a wrong one used to break nothing until the day confirmations were downloaded.",
+      "The Ultrabeam / SteppIR widget in Station Control can now drive the antenna, not just describe it: a button per configured band tunes it there, up and down move it 25 kHz at a time, and tracking can be switched on or off with its 25 / 50 / 100 kHz threshold beside it. The band you are on lights up, and the commanded frequency is shown in the header.",
+      "The QSO filter can express a real question. Every condition was joined by one global AND or OR, so \"2 m or 70 cm, in FT8, since January\" had no form: AND killed the two bands, OR let every FT8 QSO through. Two operators — is one of / is none of — take a comma-separated list, so the OR sits inside one condition and the rest keeps ANDing.",
+      "Split works properly on a Kenwood. Split Operating: Rig in WSJT-X and JTDX did nothing at all through the shared CAT — OpsLog answered \"done\" to both split commands and left the radio on the receive frequency, so on a pileup you transmitted straight onto the DX while the software showed exactly what you had asked for. A radio whose backend cannot set split now refuses, so WSJT-X says so and you can switch to Fake It. And the two frequencies no longer swap the moment you key up: the rig reports the VFO in use, which is the receive one on receive and the transmit one on transmit, and that decided which frequency a split QSO was logged on."
+    ],
+    "fr": [
+      "Décodes digitaux : le carré locator d une station pouvait être enregistré comme son indicatif quand le texte du message sortait de l ordinaire. Un grid à la place de l indicatif est maintenant refusé.",
+      "Le CW par CAT fonctionne sur Kenwood. La commande KY partait sous la forme Elecraft à longueur libre ; un Kenwood exige exactement 24 caractères, donc chaque message était refusé.",
+      "Le CAT partagé est plus solide et se diagnostique tout seul. Il survit à un rig qui répond « occupé » juste après une émission au lieu de lâcher le lien, cesse de répéter un état PTT que le client n a pas changé, et écrit une explication claire quand un autre programme lui a pris son port ou qu un client est réglé sur un modèle de rig au lieu de Hamlib NET rigctl. Il répond aussi aux commandes de verrouillage et d arrêt du morse que certains logiciels envoient à chaque émission, au lieu de les refuser.",
+      "La publication web propose désormais tous les champs d un QSO, awards compris — 123 au lieu de 23 — depuis une liste déroulante cherchable, les colonnes choisies étant listées au-dessus dans l ordre de publication. À choisir avec soin : la page est publique et la liste contient adresses et e-mails.",
+      "La détection d ouverture de bande fonctionne enfin sur les bandes visées. Activer « Surveiller les ouvertures de bande » (Paramètres › Cluster DX) souscrit au flux PSK Reporter et ajoute les deux nœuds RBN nécessaires — elle lisait quelques spots VHF du cluster alors que des milliers de stations rapportaient. Elle surveille le 10, 6, 4 et 2 m, ne retient que les reports collectés à moins de 300 km de toi pour qu une ouverture veuille dire une ouverture ICI, ne jette plus les chemins au-delà de 2400 km, et cherche la direction la plus dense au lieu d exiger que toutes les stations entendues soient dans un même secteur. Une ouverture en cours s affiche en pastille clignotante à côté de l heure dès qu elle est détectée — bande, direction et distance typique, avec une marque si elle est inhabituelle pour la saison — et y reste jusqu à ce que la bande se taise, et la direction annoncée est juste — un secteur traversant le nord était auparavant annoncé à l opposé.",
+      "Le bouton Tester la connexion teste vraiment. Club Log vérifiait que les trois champs n étaient pas vides et annonçait la réussite sans contacter personne : un mauvais mot de passe ressemblait exactement à un bon. Il s authentifie maintenant pour de vrai, via le point d accès en lecture seule pour qu un test ne puisse jamais ajouter un enregistrement. LoTW annonce ses deux identifiants séparément : TQSL signe les envois et n utilise jamais le mot de passe du site, donc un mauvais ne cassait rien jusqu au jour du téléchargement des confirmations.",
+      "Le widget Ultrabeam / SteppIR de Station Control pilote enfin l antenne au lieu de seulement la décrire : un bouton par bande configurée l accorde dessus, haut et bas la déplacent par pas de 25 kHz, et le suivi s active ou se coupe avec son seuil de 25 / 50 / 100 kHz à côté. La bande courante s allume, et la fréquence commandée s affiche dans l en-tête.",
+      "Le filtre des QSO sait exprimer une vraie question. Toutes les conditions étaient jointes par un seul ET ou OU global, donc « 2 m ou 70 cm, en FT8, depuis janvier » n avait aucune forme : le ET tuait les deux bandes, le OU laissait passer tous les QSO FT8. Deux opérateurs — est parmi / n est pas parmi — acceptent une liste séparée par des virgules, le OU tient donc dans une seule condition et le reste continue de se combiner en ET.",
+      "Le split fonctionne correctement sur Kenwood. Split Operating: Rig dans WSJT-X et JTDX ne faisait rien du tout via le CAT partagé — OpsLog répondait « fait » aux deux commandes et laissait la radio sur la fréquence de réception, donc sur un pileup tu émettais en plein sur le DX pendant que le logiciel affichait exactement ce que tu avais demandé. Une radio dont le backend ne sait pas régler le split refuse désormais, WSJT-X le dit et tu peux passer en Fake It. Et les deux fréquences ne s inversent plus dès le passage en émission : le rig annonce le VFO en service, celui de réception à l écoute et celui d émission en émission, ce qui décidait sur quelle fréquence un QSO en split était enregistré."
+    ]
+  },
   {
     "version": "0.24.4",
     "date": "",

frontend/src/App.tsx

@@ -51,6 +51,7 @@ import {
   ReportLiveActivity, LiveLastQSOAgeSec,
   GetAmpStatuses, AmpOperate,
   GetFlexState, FlexAmpOperate,
+  GetPSKReporterStatus, GetLiveOpenings,
 } from '../wailsjs/go/main/App';
 import { Combobox } from '@/components/ui/combobox';
 import { applyAwardRefs } from '@/lib/awardRefs';
@@ -1709,6 +1710,27 @@ export default function App() {
   const [showSettings, setShowSettings] = useState(false);
   // Re-read the "beam on map" toggle when Preferences closes (it's edited there).
   useEffect(() => { if (!showSettings) setShowBeamOnMap(localStorage.getItem('opslog.showBeamOnMap') !== '0'); }, [showSettings]);
+  // Openings under way, for the blinking status-bar badge. Polled rather than
+  // event-driven: the badge also has to go OUT when a band goes quiet, and
+  // nothing emits an event for something that stopped happening.
+  const [liveOpenings, setLiveOpenings] = useState<any[]>([]);
+  useEffect(() => {
+    const load = () => { GetLiveOpenings().then((v: any) => setLiveOpenings(v ?? [])).catch(() => {}); };
+    load();
+    const t = window.setInterval(load, 20000);
+    return () => window.clearInterval(t);
+  }, []);
+
+  // PSK Reporter feed, for the status-bar chip. Polled slowly: the chip only
+  // says up or down, and the count behind it is a tooltip.
+  const [pskr, setPskr] = useState<any>(null);
+  useEffect(() => {
+    const load = () => { GetPSKReporterStatus().then(setPskr).catch(() => {}); };
+    load();
+    const t = window.setInterval(load, 10000);
+    return () => window.clearInterval(t);
+  }, []);
+
   // "ON AIR" status-bar badge: mirrors the multi-op live status this operator
   // publishes — online (blinking) when a QSO was logged in the last 5 min, else
   // offline. Publishing is always on for a shared MySQL logbook (no user toggle:
@@ -2104,13 +2126,18 @@ export default function App() {
   useEffect(() => {
     const off = EventsOn('bandopen:detected', (o: any) => {
       if (!o?.band) return;
-      const season = o.in_season ? '' : ` — ${t('bmp.openUnusual')}`;
-      showToast(`📡 ${t('bmp.openToast', {
-        band: String(o.band).toUpperCase(), n: o.calls, km: o.median_km,
-      })}${season}`);
+      // The badge appears on the EVENT, not on the next poll. It used to wait for
+      // one, so the announcement and the badge were up to twenty seconds apart and
+      // read as two unrelated things happening to mention the same band.
+      //
+      // No toast any more: the badge says the same thing and does not vanish after
+      // five seconds. An operator who was tuning when the toast passed had no way
+      // back to it, which is exactly what the badge was built to fix — keeping
+      // both meant announcing an opening twice and still losing it once.
+      setLiveOpenings((cur) => [...cur.filter((x: any) => x.band !== o.band), o]);
     });
     return () => { off(); };
-  }, [showToast, t]);
+  }, []);
 
   // DX-cluster spot alerts: a matched rule fires here. Play a beep (WebAudio, no
   // asset needed — CSP-safe) and/or show a toast, per the rule's chosen actions.
@@ -6854,6 +6881,26 @@ export default function App() {
                 </button>
               );
             })}
+            {/* PSK Reporter, next to the hardware chips because it is the same
+                kind of fact: a link that is either up or it is not. Shown ONLY
+                when the opening watch is on — a permanently grey chip for a
+                feature nobody enabled is clutter, and the bar is 28 px.
+
+                The decode count is in the tooltip rather than the chip: it moves
+                several times a second on an open band, and a number flickering in
+                the corner of the eye is not information, it is a distraction. */}
+            {pskr?.running && (
+              <button
+                type="button"
+                title={t('pskr.tip', { n: pskr.received ?? 0, bands: (pskr.bands ?? []).join(' ') })}
+                onClick={() => { setSettingsSection('cluster'); setShowSettings(true); }}
+                className="inline-flex items-center gap-1.5 px-2 h-5 rounded border text-[11px] transition-colors border-border hover:bg-muted cursor-pointer shrink-0"
+              >
+                <span className={cn('size-2 rounded-full',
+                  (pskr.received ?? 0) > 0 ? 'bg-success' : 'bg-warning')} />
+                MQTT
+              </button>
+            )}
             {/* ON AIR badge: "did I log a QSO in the last 5 min" — meaningful on ANY
                 logbook backend (only the live_status PUBLISHING is MySQL-specific),
                 so it is always shown. Gating it on MySQL made it vanish for
@@ -6911,6 +6958,45 @@ export default function App() {
             {/* UTC clock — moved out of the header, where it competed with the
                 frequency for the eye. It belongs with the other passive
                 indicators. */}
+            {/* Openings under way. Right-hand end, before the clock, because it is
+                a state of the world rather than a state of this station — the
+                same side as the time and the logbook.
+
+                It BLINKS and it stays. The toast that announces an opening is
+                gone in seconds, and an operator who was tuning at that moment
+                had no way back to it; a band opening lasts hours and deserves
+                something that lasts with it. It goes out by itself when the
+                spots stop arriving. */}
+            {liveOpenings.map((o: any) => (
+              <button
+                key={o.band}
+                type="button"
+                onClick={() => { setActiveTab('bandmap'); }}
+                title={t('bo.liveTip', {
+                  band: String(o.band).toUpperCase(), n: o.calls, km: o.median_km,
+                  sector: `${o.compass ?? ''} ${o.bearing_min}–${o.bearing_max}°`,
+                  season: o.in_season ? '' : ' — ' + t('bmp.openUnusual'),
+                })}
+                className="inline-flex items-center gap-1.5 rounded-md border px-2 py-0.5 text-[11px] font-bold uppercase tracking-wider shrink-0
+                           border-warning-border bg-warning-muted text-warning-muted-foreground hover:bg-warning-muted/70 animate-pulse"
+              >
+                <Radio className="size-3 shrink-0" />
+                {/* The three facts that decide whether to act: which band, which
+                    way to point, how far it reaches. They were in a tooltip
+                    nobody hovers, which made the badge an alarm with no content —
+                    it said something was happening and refused to say what. */}
+                <span>{String(o.band).toUpperCase()}</span>
+                <span className="font-mono">{o.compass}</span>
+                {/* Plain kilometres. An earlier attempt abbreviated 1500 to
+                    "1.5k" and then appended the unit, giving "1.5kkm" — and even
+                    written correctly, "1.5k km" makes a reader do arithmetic to
+                    recover a number that was four characters long to begin with. */}
+                <span className="font-mono opacity-80">{o.median_km} km</span>
+                {/* Out of season is the one an operator must not learn last, so it
+                    earns a mark on the badge rather than a line in the tooltip. */}
+                {!o.in_season && <span className="opacity-90">!</span>}
+              </button>
+            ))}
             <span className="inline-flex items-center gap-1 font-mono text-[11px] text-muted-foreground shrink-0" title="UTC">
               <Clock className="size-3" />
               {utcNow}<span className="text-[9px]">Z</span>

frontend/src/components/FilterBuilder.tsx

@@ -13,7 +13,8 @@ import { useI18n } from '@/lib/i18n';
 
 export type FilterOp =
   | 'eq' | 'ne' | 'gt' | 'lt' | 'ge' | 'le'
-  | 'contains' | 'startswith' | 'endswith' | 'empty' | 'notempty';
+  | 'contains' | 'startswith' | 'endswith' | 'empty' | 'notempty'
+  | 'in' | 'notin';
 
 export interface FilterCondition { field: string; op: FilterOp; value: string }
 export interface QueryFilter {
@@ -121,9 +122,15 @@ const OPS: { value: FilterOp; label: string }[] = [
   { value: 'le', label: 'fltb.opLe' },
   { value: 'empty', label: 'fltb.opEmpty' },
   { value: 'notempty', label: 'fltb.opNotEmpty' },
+  // 'in' is what makes a real question askable. Every condition is joined by ONE
+  // AND or OR, so "2 m or 70 cm, in FT8, since January" had no expression: AND
+  // killed the two bands, OR let every FT8 QSO through. The OR lives inside the
+  // condition instead, and the rest keeps ANDing.
+  { value: 'in', label: 'fltb.opIn' },
+  { value: 'notin', label: 'fltb.opNotIn' },
 ];
 
-const TEXT_OPS: FilterOp[] = ['contains', 'startswith', 'endswith', 'eq', 'ne', 'empty', 'notempty'];
+const TEXT_OPS: FilterOp[] = ['contains', 'startswith', 'endswith', 'eq', 'ne', 'in', 'notin', 'empty', 'notempty'];
 const NUM_OPS: FilterOp[] = ['eq', 'ne', 'gt', 'lt', 'ge', 'le', 'empty', 'notempty'];
 
 function opsFor(field: string): { value: FilterOp; label: string }[] {
@@ -257,6 +264,7 @@ export function FilterBuilder({ open, initial, onApply, onClose }: Props) {
           )}
           {conditions.map((c, i) => {
             const needsValue = c.op !== 'empty' && c.op !== 'notempty';
+            const isList = c.op === 'in' || c.op === 'notin';
             const fieldType = FIELDS.find((f) => f.value === c.field)?.type ?? 'text';
             return (
               <div key={i} className="flex items-center gap-2">
@@ -281,19 +289,28 @@ export function FilterBuilder({ open, initial, onApply, onClose }: Props) {
                   // An ADIF date is picked with a calendar but STORED as the
                   // 8-digit form the column holds, so the comparison stays a
                   // plain string one on both sides.
-                  type={fieldType === 'date' || fieldType === 'adifdate' ? 'date' : fieldType === 'number' ? 'number' : 'text'}
+                  // A list is typed by hand, commas and all, so it stays a text
+                  // box even on a date or number field: a calendar cannot express
+                  // "any one of these".
+                  type={isList ? 'text'
+                    : fieldType === 'date' || fieldType === 'adifdate' ? 'date'
+                      : fieldType === 'number' ? 'number' : 'text'}
                   className="h-8 flex-1 text-xs"
                   disabled={!needsValue}
-                  placeholder={needsValue ? (fieldType === 'date' ? 'YYYY-MM-DD' : t('fltb.valuePh')) : '—'}
+                  placeholder={!needsValue ? '—'
+                    : isList ? t('fltb.listPh')
+                      : fieldType === 'date' ? 'YYYY-MM-DD' : t('fltb.valuePh')}
                   // \d, not d: the escape was missing, so the test never matched
                   // an 8-digit ADIF date and the calendar input was handed
                   // "20260728" — which type=date rejects, showing an empty box
                   // over a value that was really there.
-                  value={fieldType === 'adifdate' && /^\d{8}$/.test(c.value)
+                  // The ADIF reshaping is skipped for a list: it would eat the
+                  // commas and leave one unreadable run of digits.
+                  value={!isList && fieldType === 'adifdate' && /^\d{8}$/.test(c.value)
                     ? `${c.value.slice(0, 4)}-${c.value.slice(4, 6)}-${c.value.slice(6, 8)}`
                     : c.value}
                   onChange={(e) => setCond(i, {
-                    value: fieldType === 'adifdate' ? e.target.value.replace(/-/g, '') : e.target.value,
+                    value: !isList && fieldType === 'adifdate' ? e.target.value.replace(/-/g, '') : e.target.value,
                   })}
                   onKeyDown={(e) => { if (e.key === 'Enter') apply(); }}
                 />

frontend/src/components/SettingsModal.tsx

@@ -52,6 +52,7 @@ import {
   GetADIFMonitor, SaveADIFMonitor, PickADIFMonitorFile,
   GetRelayAuto, SaveRelayAuto, GetStationDevices,
   GetAwardDefs, GetTrackedAwards, SaveTrackedAwards,
+  GetBandOpenSettings, SaveBandOpenSettings, GetPSKReporterStatus,
 } from '../../wailsjs/go/main/App';
 import type { profile as profileModels } from '../../wailsjs/go/models';
 import type { LookupSettingsForm, StationSettingsForm, ListsSettingsForm, ModePresetForm } from '@/types';
@@ -1540,6 +1541,26 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   // blur, not per keystroke, or typing "10" would be rewritten to "5" the moment
   // the "1" landed and the field would fight the operator.
   const SELF_SPOT_MIN_MIN = 5;
+  // Band-opening watch. Saved through the backend rather than as a UI pref: it
+  // has side effects there — adding the RBN nodes, bringing the PSK Reporter
+  // feed up or down — so the write has to go where those live.
+  const [bandOpen, setBandOpen] = useState<any>({ enabled: false, bands: [], available: [] });
+  const [pskrStatus, setPskrStatus] = useState<any>(null);
+  const saveBandOpen = async (next: any) => {
+    setBandOpen(next);
+    try { await SaveBandOpenSettings(next); } catch { /* the status line shows the result */ }
+  };
+  useEffect(() => {
+    (async () => {
+      try { setBandOpen(await GetBandOpenSettings()); } catch { /* defaults stand */ }
+    })();
+    // Poll the feed while the panel is open: a live count is the only thing that
+    // distinguishes "connected" from "connected and receiving nothing".
+    const t = window.setInterval(async () => {
+      try { setPskrStatus(await GetPSKReporterStatus()); } catch { /* ignore */ }
+    }, 3000);
+    return () => window.clearInterval(t);
+  }, []);
   const [selfSpot, setSelfSpot] = useState({ enabled: false, minutes: SELF_SPOT_MIN_MIN });
   const [selfSpotText, setSelfSpotText] = useState(String(SELF_SPOT_MIN_MIN));
   const [clusterStatuses, setClusterStatuses] = useState<ClusterServerStatus[]>([]);
@@ -4148,6 +4169,44 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
               things set up once. A preferences dialog you reopen every ten minutes
               is a filter in the wrong place. */}
 
+          {/* Band-opening watch. It lives HERE, with the cluster nodes, because
+              switching it on adds two of them — the operator should see that
+              happen where it happens rather than find nodes they did not add. */}
+          <div className="border-t border-border/60 pt-3 space-y-2">
+            <label className="flex items-start gap-2 text-sm cursor-pointer">
+              <Checkbox checked={bandOpen.enabled} className="mt-0.5"
+                onCheckedChange={(c) => saveBandOpen({ ...bandOpen, enabled: !!c })} />
+              <span>{t('bo.enable')} <span className="text-xs text-muted-foreground">{t('bo.enableHint')}</span></span>
+            </label>
+            {bandOpen.enabled && (
+              <div className="pl-6 space-y-2">
+                <div className="flex flex-wrap gap-1.5">
+                  {(bandOpen.available ?? []).map((b: string) => {
+                    const on = (bandOpen.bands ?? []).includes(b);
+                    return (
+                      <button key={b} type="button"
+                        onClick={() => saveBandOpen({
+                          ...bandOpen,
+                          bands: on ? bandOpen.bands.filter((x: string) => x !== b) : [...(bandOpen.bands ?? []), b],
+                        })}
+                        className={cn('px-2 py-0.5 rounded-md border text-[11px] font-bold tracking-wider font-mono',
+                          on ? 'bg-primary text-primary-foreground border-primary' : 'text-muted-foreground border-border hover:bg-muted')}>
+                        {b}
+                      </button>
+                    );
+                  })}
+                </div>
+                {/* A live count, because a feed that is connected but silent looks
+                    exactly like one that is broken until a number moves. */}
+                <p className="text-xs text-muted-foreground">
+                  {pskrStatus?.running
+                    ? t('bo.feedUp', { n: pskrStatus.received ?? 0 })
+                    : t('bo.feedDown')}
+                </p>
+              </div>
+            )}
+          </div>
+
           {/* Self-spot. The interval only shows once it's on — an interval for
               something switched off is just a question the operator can't act on. */}
           <div className="border-t border-border/60 pt-3 space-y-2">

frontend/src/components/StationControlPanel.tsx

@@ -1,5 +1,5 @@
 import { useCallback, useEffect, useLayoutEffect, useRef, useState } from 'react';
-import { Plus, Pencil, Trash2, Power, PlugZap, Loader2, Check, X, Compass, Square, Antenna as AntennaIcon, ArrowDownToLine, Minus, RefreshCw, GripVertical } from 'lucide-react';
+import { Plus, Pencil, Trash2, Power, PlugZap, Loader2, Check, X, Compass, Square, Antenna as AntennaIcon, ArrowDownToLine, Minus, RefreshCw, GripVertical, ChevronUp, ChevronDown } from 'lucide-react';
 import { Button } from '@/components/ui/button';
 import { Input } from '@/components/ui/input';
 import { Label } from '@/components/ui/label';
@@ -15,6 +15,7 @@ import {
   GetStationDevices, SaveStationDevices, GetStationStatus, StationSetRelay,
   GetRotatorHeading, RotatorGoTo, RotatorStop, SetActiveRotor,
   GetUltrabeamStatus, SetUltrabeamDirection, UltrabeamRetract, MotorSetElement, MotorReadElements,
+  MotorTuneKHz, MotorNudgeKHz, SetMotorFollow,
   ListDenkoviDevices, ListSerialPorts, TestStationDevice,
   GetAmpStatuses, GetFlexState,
   GetTunerGeniusStatus, GetTunerGeniusSettings,
@@ -115,7 +116,37 @@ 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[] };
+type AntStatus = { enabled: boolean; type: string; connected: boolean; direction: number; frequency: number; moving: boolean; elements: number[]; follow?: boolean; step_khz?: number; bands?: string[] };
+
+// 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
@@ -203,6 +234,70 @@ function MotorAntennaWidget({ ant, refetch, t }: { ant: AntStatus; refetch: () =
             ))}
           </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) => {
+              const khz = 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. The step only shows when tracking is on: a threshold for
+            something switched off is a question the operator cannot act on. */}
+        <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 && (
+            <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>
+
         <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">

frontend/src/components/WebPublishPanel.tsx

@@ -1,5 +1,5 @@
 import { useEffect, useState } from 'react';
-import { Upload, FolderOpen, Loader2 } from 'lucide-react';
+import { Upload, FolderOpen, Loader2, ChevronsUpDown } from 'lucide-react';
 import {
   GetWebPublishConfig, SaveWebPublishConfig, WebPublishColumns,
   TestWebPublishFTP, PublishLogNow, GetWebPublishStatus, PickBackupFolder,
@@ -9,6 +9,9 @@ import { Input } from '@/components/ui/input';
 import { Label } from '@/components/ui/label';
 import { Checkbox } from '@/components/ui/checkbox';
 import { Select, SelectTrigger, SelectValue, SelectContent, SelectItem } from '@/components/ui/select';
+import {
+  DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuCheckboxItem,
+} from '@/components/ui/dropdown-menu';
 import { useI18n } from '@/lib/i18n';
 import { cn } from '@/lib/utils';
 
@@ -18,12 +21,17 @@ type Cfg = {
   ftp_enabled: boolean; ftp_host: string; ftp_port: number; ftp_user: string;
   ftp_password: string; ftp_tls: boolean; ftp_folder: string; ftp_file_name: string;
 };
-type Col = { key: string; header: string };
+type Col = { key: string; header: string; group: string };
 
 export function WebPublishPanel() {
   const { t } = useI18n();
   const [cfg, setCfg] = useState<Cfg | null>(null);
   const [cols, setCols] = useState<Col[]>([]);
+  // The catalogue is 123 fields, so the picker is a dropdown with a search box
+  // rather than anything laid out on the page. Chosen columns stay visible above
+  // it, in publication order: after picking eight out of a hundred the question
+  // stops being 'what exists' and becomes 'what did I pick, and how will it print'.
+  const [colSearch, setColSearch] = useState('');
   const [busy, setBusy] = useState<'' | 'test' | 'publish'>('');
   const [msg, setMsg] = useState('');
   const [err, setErr] = useState('');
@@ -137,19 +145,75 @@ export function WebPublishPanel() {
 
         {/* ── Columns ── */}
         <div className="space-y-2 border-t border-border/60 pt-3">
-          <Label className="text-xs font-semibold">{t('wpub.columns')}</Label>
-          <div className="flex flex-wrap gap-1.5">
-            {cols.map((c) => {
-              const on = cfg.columns?.includes(c.key);
-              return (
-                <button key={c.key} type="button" onClick={() => toggleCol(c.key)}
-                  className={cn('px-2 py-0.5 rounded-full border text-[11px] font-medium transition-colors',
-                    on ? 'border-primary bg-primary text-primary-foreground' : 'border-border text-muted-foreground hover:bg-muted')}>
-                  {c.header}
-                </button>
-              );
-            })}
+          <div className="flex items-center justify-between">
+            <Label className="text-xs font-semibold">{t('wpub.columns')}</Label>
+            <span className="text-[11px] text-muted-foreground">
+              {t('wpub.columnsCount', { n: cfg.columns?.length ?? 0, total: cols.length })}
+            </span>
           </div>
+
+          {/* CHOSEN, in publication order — this is the list that answers "what
+              will the page look like", which a sectioned catalogue cannot. */}
+          {(cfg.columns?.length ?? 0) > 0 && (
+            <div className="flex flex-wrap gap-1.5">
+              {cfg.columns.map((k) => {
+                const c = cols.find((x) => x.key === k);
+                return (
+                  <button key={k} type="button" onClick={() => toggleCol(k)}
+                    title={t('wpub.removeColumn')}
+                    className="px-2 py-0.5 rounded-full border border-primary bg-primary text-primary-foreground text-[11px] font-medium">
+                    {c?.header ?? k} ×
+                  </button>
+                );
+              })}
+            </div>
+          )}
+
+          {/* One dropdown, alphabetical, filtered as you type. The catalogue is
+              123 fields: laid out on the page it buries every other setting, and
+              sorting by anything but the alphabet means hunting. The menu stays
+              open while ticking — picking eight columns should be one visit. */}
+          <DropdownMenu>
+            <DropdownMenuTrigger asChild>
+              <Button variant="outline" size="sm" className="w-full justify-between h-8 text-xs font-normal">
+                {t('wpub.columnsPick')}
+                <ChevronsUpDown className="size-3.5 opacity-60" />
+              </Button>
+            </DropdownMenuTrigger>
+            {/* The search box is OUTSIDE the scrolling area, not sticky inside it.
+                Sticky kept it in place but the rows scrolled over it: a menu item
+                carries its own background and its own stacking, so it wins over a
+                sticky sibling however high its z-index. A header that never
+                scrolls has nothing to lose the fight with. */}
+            <DropdownMenuContent align="start" className="w-72 p-0 flex flex-col max-h-80">
+              <div className="p-1.5 border-b border-border/60 bg-popover shrink-0">
+                <Input className="h-7 text-xs" placeholder={t('wpub.columnsSearch')}
+                  value={colSearch}
+                  onChange={(e) => setColSearch(e.target.value)}
+                  onKeyDown={(e) => e.stopPropagation()} />
+              </div>
+              <div className="overflow-y-auto p-1">
+              {[...cols]
+                .sort((a, b) => a.header.localeCompare(b.header))
+                .filter((c) => {
+                  const q = colSearch.trim().toLowerCase();
+                  return !q || c.header.toLowerCase().includes(q) || c.key.toLowerCase().includes(q);
+                })
+                .map((c) => (
+                  <DropdownMenuCheckboxItem
+                    key={c.key}
+                    checked={cfg.columns?.includes(c.key) ?? false}
+                    onCheckedChange={() => toggleCol(c.key)}
+                    onSelect={(e) => e.preventDefault()}
+                    className="text-xs"
+                  >
+                    {c.header}
+                    <span className="ml-auto pl-2 text-[10px] text-muted-foreground font-mono">{c.group}</span>
+                  </DropdownMenuCheckboxItem>
+                ))}
+              </div>
+            </DropdownMenuContent>
+          </DropdownMenu>
           <p className="text-[11px] text-muted-foreground">{t('wpub.columnsHint')}</p>
         </div>
 

frontend/src/lib/i18n.tsx

@@ -15,7 +15,7 @@ const en: Dict = {
   // Menu bar
   'prop.title': 'Propagation', 'prop.geomag': 'Geomag', 'prop.refresh': 'Refresh space weather',
   'live.onAir': 'On air', 'live.offline': 'Offline',
-  'live.onAirTip': 'On air — a QSO was logged in the last 5 minutes (published to the live status)',
+  'pskr.tip': 'PSK Reporter — {n} decodes received on {bands}. Click for settings.', 'live.onAirTip': 'On air — a QSO was logged in the last 5 minutes (published to the live status)',
   'live.offlineTip': 'Offline — no QSO logged in the last 5 minutes',
   'live.stationsTitle': 'Stations on air', 'live.stationsEmpty': 'No station reporting yet.', 'live.stationsHide': 'Hide',
   'upd.available': 'OpsLog v{v} available', 'upd.current': "You're on v{v}.",
@@ -117,7 +117,7 @@ const en: Dict = {
   'sec.general': 'General', 'sec.email': 'E-mail (SMTP)', 'sec.lookup': 'Callsign Lookup',
   'sec.bands': 'Bands', 'sec.modes': 'Modes & default RST', 'sec.cluster': 'DX Cluster',
   'sec.udp': 'UDP integrations', 'sec.database': 'Database', 'sec.autostart': 'Autostart', 'sec.backup': 'Database backup', 'sec.uscounties': 'US Counties',
-  'sec.webpublish': 'Web publishing', 'wpub.hint': 'Publishes your log as a file for a website: a standalone HTML page or a CSV, written locally and optionally uploaded by FTP. It is refreshed when you log a QSO and, if you set an interval, on a timer.', 'wpub.enable': 'Publish the log to a file', 'wpub.fileSection': 'The file', 'wpub.format': 'Format', 'wpub.formatHtml': 'HTML page', 'wpub.formatCsv': 'CSV', 'wpub.folder': 'Output folder', 'wpub.browse': 'Browse…', 'wpub.fileName': 'File name', 'wpub.title': 'Page title', 'wpub.titlePh': 'blank = your callsign', 'wpub.count': 'Last N QSOs', 'wpub.every': 'Refresh every', 'wpub.everyHint': 'minutes — 0 = only when a QSO is logged', 'wpub.columns': 'Columns', 'wpub.columnsHint': 'Click to add or remove. The order shown here is the order in the file.', 'wpub.ftpEnable': 'Upload by FTP', 'wpub.ftpHost': 'Server / port', 'wpub.ftpUser': 'User', 'wpub.ftpPassword': 'Password', 'wpub.ftpFolder': 'Remote folder', 'wpub.ftpFileName': 'Remote file name', 'wpub.ftpTls': 'Use TLS (FTPS)', 'wpub.publishNow': 'Publish now', 'wpub.testFtp': 'Test connection', 'wpub.lastRun': 'Last run:', 'sec.adifmon': 'ADIF monitor',
+  'sec.webpublish': 'Web publishing', 'wpub.hint': 'Publishes your log as a file for a website: a standalone HTML page or a CSV, written locally and optionally uploaded by FTP. It is refreshed when you log a QSO and, if you set an interval, on a timer.', 'wpub.enable': 'Publish the log to a file', 'wpub.fileSection': 'The file', 'wpub.format': 'Format', 'wpub.formatHtml': 'HTML page', 'wpub.formatCsv': 'CSV', 'wpub.folder': 'Output folder', 'wpub.browse': 'Browse…', 'wpub.fileName': 'File name', 'wpub.title': 'Page title', 'wpub.titlePh': 'blank = your callsign', 'wpub.count': 'Last N QSOs', 'wpub.every': 'Refresh every', 'wpub.everyHint': 'minutes — 0 = only when a QSO is logged', 'wpub.columns': 'Columns', 'wpub.columnsCount': '{n} of {total} chosen', 'wpub.columnsPick': 'Choose columns…', 'wpub.columnsSearch': 'Search a field…', 'wpub.removeColumn': 'Click to remove', 'wpub.columnsHint': 'Click to add or remove. The order shown here is the order in the file.', 'wpub.ftpEnable': 'Upload by FTP', 'wpub.ftpHost': 'Server / port', 'wpub.ftpUser': 'User', 'wpub.ftpPassword': 'Password', 'wpub.ftpFolder': 'Remote folder', 'wpub.ftpFileName': 'Remote file name', 'wpub.ftpTls': 'Use TLS (FTPS)', 'wpub.publishNow': 'Publish now', 'wpub.testFtp': 'Test connection', 'wpub.lastRun': 'Last run:', 'sec.adifmon': 'ADIF monitor',
   'adifmon.hint': 'Watch external ADIF files and import new QSOs automatically — e.g. fldigi logging RTTY, or N1MM/VarAC. Imported QSOs are enriched, de-duplicated and uploaded to your external services just like a QSO logged here.',
   'adifmon.enable': 'Enable ADIF monitor',
   'adifmon.empty': 'No file watched yet. Add an ADIF file below.',
@@ -155,7 +155,7 @@ const en: Dict = {
   'uscty.backfillIntro': 'Resolve county (and grid) for US QSOs already in your log that are missing them. Existing values are kept — only blanks are filled.',
   'uscty.backfillRun': 'Fill missing counties',
   'uscty.backfillDone': '{s} US QSOs scanned · {c} counties, {g} grids filled.',
-  'station.title': 'Station Control', 'station.rotator': 'Rotator', 'station.rotatorNoRead': 'No heading read', 'station.pattern': 'Pattern', 'station.bi': 'Bi', 'station.retract': 'Retract elements', 'station.moving': 'MOVING', 'station.elements': 'Elements (mm)', 'station.read': 'Read', 'station.readLengths': 'Read current element lengths from the controller', 'station.noLengths': 'Lengths unknown — click Read to fetch them from the controller.', 'station.element': 'Element', 'station.reflector': 'Reflector', 'station.driven': 'Driven', 'station.director': 'Dir', 'station.set': 'Set', 'station.elementsHint': 'Each press lengthens/shortens the element by 2 mm (like the physical console). Verify which element responds on your antenna.', 'station.setExactLen': 'Click to type the exact current length (fixes the baseline if the auto-read is off).', 'station.atMax': 'Controller refused — the element is likely at its maximum length for this band, so it can\'t extend further.', 'station.go': 'Go', 'station.stop': 'Stop', 'station.dragHint': 'Drag the grip handle on the left of a panel to move it. Pick a column count to lay them out in a grid.', 'station.dragMove': 'Drag to move this panel', 'station.colsAuto': 'Auto', 'station.addDevice': 'Add device', 'station.editDevice': 'Edit device', 'station.empty': 'No relay boards yet. Add a WebSwitch 1216H or a KMTronic 8-relay board to control your station power and accessories.', 'station.online': 'Online', 'station.offline': 'Offline', 'station.edit': 'Edit', 'station.delete': 'Delete', 'station.relay': 'Relay', 'station.on': 'ON', 'station.off': 'OFF', 'station.type': 'Device type', 'station.name': 'Name', 'station.host': 'Host / IP', 'station.hostHint': 'LAN IP for local use. To reach the board from OUTSIDE, put a full URL here — e.g. https://relay.yourdomain.com — pointing at a reverse proxy (Nginx Proxy Manager…) that fronts the board’s HTTP port.', 'station.user': 'Username', 'station.pass': 'Password', 'station.optional': 'optional', 'station.ftdiSerial': 'FTDI serial number', 'station.detect': 'Detect', 'station.ftdiHint': 'The Denkovi board is driven via FTDI bit-bang (not the COM port). Pick its serial (e.g. DAE0006K). Needs the FTDI D2XX driver installed.', 'station.channels': 'Relays', 'station.comPort': 'COM port', 'station.noPorts': 'No ports found', 'station.usbRelayHint': 'Cheap USB-serial relay boards (CH340/LCUS) using the A0 command protocol. If yours does not switch, tell me its model / command set.', 'station.labels': 'Relay labels', 'station.cancel': 'Cancel', 'station.save': 'Save', 'station.test': 'Test connection', 'station.testOk': 'Connected — {n} relays', 'station.testFail': 'Not connected', 'station.detectNone': 'No FTDI board found — check the cable and that the D2XX driver is installed.', 'station.detectFound': '{n} board(s) detected.',
+  'station.title': 'Station Control', 'station.rotator': 'Rotator', 'station.rotatorNoRead': 'No heading read', 'station.bands': 'Bands', 'station.nudgeUp': 'Up {n} kHz', 'station.nudgeDown': 'Down {n} kHz', 'station.trackOn': 'Tracking on', 'station.trackOff': 'Tracking off', 'station.trackStepTip': 'Re-tune only when the rig has moved this far', 'station.pattern': 'Pattern', 'station.bi': 'Bi', 'station.retract': 'Retract elements', 'station.moving': 'MOVING', 'station.elements': 'Elements (mm)', 'station.read': 'Read', 'station.readLengths': 'Read current element lengths from the controller', 'station.noLengths': 'Lengths unknown — click Read to fetch them from the controller.', 'station.element': 'Element', 'station.reflector': 'Reflector', 'station.driven': 'Driven', 'station.director': 'Dir', 'station.set': 'Set', 'station.elementsHint': 'Each press lengthens/shortens the element by 2 mm (like the physical console). Verify which element responds on your antenna.', 'station.setExactLen': 'Click to type the exact current length (fixes the baseline if the auto-read is off).', 'station.atMax': 'Controller refused — the element is likely at its maximum length for this band, so it can\'t extend further.', 'station.go': 'Go', 'station.stop': 'Stop', 'station.dragHint': 'Drag the grip handle on the left of a panel to move it. Pick a column count to lay them out in a grid.', 'station.dragMove': 'Drag to move this panel', 'station.colsAuto': 'Auto', 'station.addDevice': 'Add device', 'station.editDevice': 'Edit device', 'station.empty': 'No relay boards yet. Add a WebSwitch 1216H or a KMTronic 8-relay board to control your station power and accessories.', 'station.online': 'Online', 'station.offline': 'Offline', 'station.edit': 'Edit', 'station.delete': 'Delete', 'station.relay': 'Relay', 'station.on': 'ON', 'station.off': 'OFF', 'station.type': 'Device type', 'station.name': 'Name', 'station.host': 'Host / IP', 'station.hostHint': 'LAN IP for local use. To reach the board from OUTSIDE, put a full URL here — e.g. https://relay.yourdomain.com — pointing at a reverse proxy (Nginx Proxy Manager…) that fronts the board’s HTTP port.', 'station.user': 'Username', 'station.pass': 'Password', 'station.optional': 'optional', 'station.ftdiSerial': 'FTDI serial number', 'station.detect': 'Detect', 'station.ftdiHint': 'The Denkovi board is driven via FTDI bit-bang (not the COM port). Pick its serial (e.g. DAE0006K). Needs the FTDI D2XX driver installed.', 'station.channels': 'Relays', 'station.comPort': 'COM port', 'station.noPorts': 'No ports found', 'station.usbRelayHint': 'Cheap USB-serial relay boards (CH340/LCUS) using the A0 command protocol. If yours does not switch, tell me its model / command set.', 'station.labels': 'Relay labels', 'station.cancel': 'Cancel', 'station.save': 'Save', 'station.test': 'Test connection', 'station.testOk': 'Connected — {n} relays', 'station.testFail': 'Not connected', 'station.detectNone': 'No FTDI board found — check the cable and that the D2XX driver is installed.', 'station.detectFound': '{n} board(s) detected.',
   'awards.followHint': 'Awards shown in the Awards tab. Leave the right side empty to show them all.', 'awards.available': 'All awards', 'awards.followed': 'Followed', 'awards.search': 'Filter…', 'awards.addAll': 'Add all', 'awards.clear': 'Clear', 'awards.allTracked': 'All awards are followed.', 'awards.noneFollowed': 'Nothing followed yet — the Awards tab shows all.',
   'sec.awards': 'Awards', 'sec.cat': 'CAT interface', 'sec.rotator': 'Rotator', 'sec.winkeyer': 'CW Keyer',
   'sec.antenna': 'Ultrabeam / Steppir', 'sec.antgenius': 'Antenna Genius', 'sec.tunergenius': 'Tuner Genius', 'sec.pgxl': 'Amplifier', 'sec.flex': 'FlexRadio', 'sec.audio': 'Audio devices',
@@ -270,7 +270,7 @@ const en: Dict = {
   'clu.muteWorkedHint': '(they stay in the list, just quiet — leaves the colour for what is left to do)',
   'clu.slotHighlight': 'Colour the stations not worked on this band and mode',
   'clu.slotHighlightHint': '(by callsign, whatever the entity status says)',
-  'clu.workedSameSlot': 'Already worked only on the same slot',
+  'bo.open': 'open', 'bo.liveTip': '{band} is open — {n} stations, ~{km} km, {sector}{season}. Click for the band map.', 'bo.enable': 'Watch for band openings', 'bo.enableHint': '(10, 12, 6, 4 and 2 m. Switching this on adds the two RBN nodes and subscribes to the PSK Reporter feed — the detection needs far more ears than a cluster can give it.)', 'bo.feedUp': 'PSK Reporter feed up — {n} decodes seen', 'bo.feedDown': 'PSK Reporter feed down — needs your station grid, and a moment to connect', 'clu.workedSameSlot': 'Already worked only on the same slot',
   'clu.workedSameSlotHint': '— a spot shows "worked" only if you worked that call on the SAME band and mode, not just anywhere. Combines with digital-mode grouping (Settings → General): with it on, a call worked on 20m FT8 also counts as worked for a 20m FT4 spot; with it off, FT8 and FT4 are separate slots.',
   // Backup panel
   'bk.hintMysql': 'On close (once/day) OpsLog snapshots the local SQLite (config) AND exports the shared MySQL log to ADIF — opslog-log-<date>.adi — so your contacts are protected even though they live on the server. Rotation keeps the last N of each.',
@@ -347,7 +347,7 @@ const en: Dict = {
   'bmp.statusWorked': 'Worked (this band + mode already in log)', 'bmp.statusUnresolved': 'Entity not resolved', 'bmp.bandMap': 'Band map', 'bmp.notConfigured': 'Not configured for {band}.',
   'bmp.map': 'Map', 'bmp.zoomOut': 'Zoom out', 'bmp.zoomIn': 'Zoom in', 'bmp.scrollToRig': 'Scroll to current rig frequency', 'bmp.moveLeft': 'Move band map to the left', 'bmp.moveRight': 'Move band map to the right', 'bmp.hide': 'Hide band map',
   'bmp.bandsLabel': 'Bands:', 'bmp.fit': 'FIT', 'bmp.hideFt': 'Hide FTx', 'bmp.hideFtTitle': 'Hide all digital (FT8/FT4/JS8/…) spots on every band map', 'bmp.fitBand': 'Fit to band', 'bmp.widthTip': 'Drag to resize — double-click to reset', 'bmp.fitTitle': 'Size each band map to show the whole band edge-to-edge',
-  'bmp.legendNewDxcc': 'New DXCC', 'bmp.legendNewBand': 'New band', 'bmp.legendNewSlot': 'New slot (mode)', 'bmp.openToast': '{band} is open — {n} stations around {km} km', 'bmp.openUnusual': 'unusual for the season', 'bmp.legendWorked': 'Worked', 'bmp.legendNewPota': 'New POTA', 'bmp.legendNewCounty': 'New county', 'bmp.legendWorkedCall': 'Callsign already worked', 'bmp.legendCW': 'CW', 'bmp.legendData': 'Data', 'bmp.legendPhone': 'Phone', 'bmp.footerHint': 'scroll · ctrl+wheel = zoom · ◎ = jump to rig', 'bmp.spotsHidden': '{n} FT8/FT4 spots hidden — top {max} kept (CW/SSB all shown)',
+  'bmp.legendNewDxcc': 'New DXCC', 'bmp.legendNewBand': 'New band', 'bmp.legendNewSlot': 'New slot (mode)', 'bmp.openUnusual': 'unusual for the season', 'bmp.legendWorked': 'Worked', 'bmp.legendNewPota': 'New POTA', 'bmp.legendNewCounty': 'New county', 'bmp.legendWorkedCall': 'Callsign already worked', 'bmp.legendCW': 'CW', 'bmp.legendData': 'Data', 'bmp.legendPhone': 'Phone', 'bmp.footerHint': 'scroll · ctrl+wheel = zoom · ◎ = jump to rig', 'bmp.spotsHidden': '{n} FT8/FT4 spots hidden — top {max} kept (CW/SSB all shown)',
   'frm.welcome': 'Welcome to OpsLog', 'frm.intro': 'Set up your station to start logging. These fields stamp every QSO and can be changed later in Preferences → Station Information (and per profile).',
   'frm.callsign': 'Callsign', 'frm.locator': 'Locator', 'frm.operator': 'Operator', 'frm.operatorPh': 'same as callsign', 'frm.owner': 'Owner', 'frm.ownerPh': 'station owner callsign', 'frm.name': 'Name', 'frm.namePh': 'your first name',
   'frm.awardRefs': 'Award reference lists', 'frm.awardRefsHint': 'IOTA · POTA · WWFF · SOTA — names & totals for those awards (optional, can take a minute).', 'frm.downloading': 'Downloading…', 'frm.reDownload': 'Re-download', 'frm.download': 'Download', 'frm.required': 'Callsign and locator are required.', 'frm.saving': 'Saving…', 'frm.startLogging': 'Start logging',
@@ -381,7 +381,7 @@ const en: Dict = {
   'spm.callRequired': 'Callsign required', 'spm.freqRequired': 'Frequency (kHz) required', 'spm.title': 'Send DX Spot', 'spm.callsign': 'Callsign', 'spm.callPh': 'DX call', 'spm.frequency': 'Frequency (kHz)', 'spm.message': 'Message', 'spm.messagePh': 'e.g. CW · TNX QSO', 'spm.latestQsos': 'Latest QSOs', 'spm.spotSent': 'Spot sent ✓', 'spm.masterCluster': 'Master cluster', 'spm.cancel': 'Cancel', 'spm.sending': 'Sending…', 'spm.sendSpot': 'Send spot',
   'ncp.newNetPrompt': 'New NET name:', 'ncp.renamePrompt': 'Rename NET:', 'ncp.deleteConfirm': 'Delete NET "{name}" and its roster? This cannot be undone.', 'ncp.closeConfirm': "{n} station(s) still on the air will be dropped WITHOUT logging. Close anyway?", 'ncp.removeConfirm': "Remove {n} station(s) from this NET's roster?", 'ncp.colCallsign': 'Callsign', 'ncp.colName': 'Name', 'ncp.colTimeOn': 'Time on', 'ncp.colBand': 'Band', 'ncp.colMode': 'Mode', 'ncp.colComment': 'Comment', 'ncp.colCountry': 'Country', 'ncp.colDate': 'Date', 'ncp.workedBefore': 'Worked before', 'ncp.wbHint': 'Click a station (on air or roster) to see prior QSOs', 'ncp.wbNone': 'No prior QSO with', 'ncp.wbFirst': 'first', 'ncp.wbLast': 'last', 'ncp.wbResize': 'Drag to resize', 'ncp.newNet': 'New NET', 'ncp.closeToSwitch': 'Close the NET to switch', 'ncp.selectNetTitle': 'Select a NET', 'ncp.selectNetOption': '— select a NET —', 'ncp.closeNet': 'Close NET', 'ncp.openNet': 'Open NET', 'ncp.rename': 'Rename', 'ncp.delete': 'Delete', 'ncp.netOpenBadge': 'NET OPEN', 'ncp.onAir': 'On air:', 'ncp.roster': 'Roster:', 'ncp.onAirActive': 'On air — active QSOs', 'ncp.activeHint': 'mic-pass order · ⬆⬇ to reorder · double-click → edit · "Log & end" to save', 'ncp.moveUp': 'Move up the mic-pass order', 'ncp.moveDown': 'Move down the mic-pass order', 'ncp.logEndSelected': 'Log & end selected', 'ncp.logAll': 'Log everyone ({n})', 'ncp.logAllConfirm': 'Log all {n} on-air station(s) to the logbook?', 'ncp.netUsersRoster': 'NET users — roster', 'ncp.rosterHint': 'double-click → put on air', 'ncp.addContact': 'Add contact', 'ncp.remove': 'Remove', 'ncp.putOnAir': 'Put selected on air', 'ncp.addContactTitle': 'Add contact to NET', 'ncp.addContactDesc': "Saved in this NET's roster (reused next time you open it).", 'ncp.callsign': 'Callsign', 'ncp.search': 'Search', 'ncp.name': 'Name', 'ncp.country': 'Country', 'ncp.cancel': 'Cancel', 'ncp.saveInNet': 'Save in NET',
   'udpp.svcWsjtLabel': 'WSJT-X / JTDX / MSHV', 'udpp.svcWsjtHint': 'Auto-logs FT8/FT4/etc. QSOs and fills the entry callsign live.', 'udpp.svcAdifLabel': 'ADIF message (JTAlert, GridTracker)', 'udpp.svcAdifHint': 'Receives a single ADIF record per packet and logs it.', 'udpp.svcN1mmLabel': 'N1MM Logger+ (contest XML)', 'udpp.svcN1mmHint': 'Receives contest QSOs as XML messages.', 'udpp.svcRemoteLabel': 'Remote callsign (DXHunter, custom)', 'udpp.svcRemoteHint': 'A short text packet containing just a callsign — fills the entry field.', 'udpp.svcDbLabel': 'ADIF Message', 'udpp.svcDbHint': 'Sends the ADIF of every QSO you log to a remote listener (Cloudlog UDP, N1MM, …).', 'udpp.svcPstLabel': 'PstRotator frequency', 'udpp.svcPstHint': 'Sends the rig frequency as <PST><FREQUENCY> whenever it changes — set PstRotatorAz tracker to DXLog.net (default port 12040).', 'udpp.svcN1mmRadioLabel': 'N1MM RadioInfo (freq + mode)', 'udpp.svcN1mmRadioHint': 'Broadcasts the rig frequency/mode as N1MM Logger+ RadioInfo XML on every change — consumed by PstRotator (N1MM tracker) and many other tools.', 'udpp.deleteConfirm': 'Delete this UDP connection?', 'udpp.loading': 'Loading…', 'udpp.intro': 'UDP connections let OpsLog talk to other ham radio software. Inbound connections receive QSOs or callsigns and update the logbook live; outbound connections notify other apps when you log a QSO locally. Enable multicast to share a port with another listener without conflict — required for the typical WSJT-X 2237 setup.', 'udpp.inboundTitle': 'Inbound — OpsLog listens', 'udpp.outboundTitle': 'Outbound — OpsLog sends', 'udpp.reloadAll': 'Reload all', 'udpp.reloadHint': 'Restarts every enabled listener after a manual change.', 'udpp.add': 'Add', 'udpp.noConnection': 'No connection.', 'udpp.unnamed': '(unnamed)', 'udpp.dialogTitle': '{action} {direction} connection', 'udpp.new': 'New', 'udpp.edit': 'Edit', 'udpp.directionInbound': 'inbound', 'udpp.directionOutbound': 'outbound', 'udpp.name': 'Name', 'udpp.namePhInbound': 'WSJT-X log', 'udpp.namePhOutbound': 'Cloudlog notify', 'udpp.serviceType': 'Service type', 'udpp.port': 'Port', 'udpp.multicast': 'Multicast', 'udpp.multicastGroup': 'Multicast group', 'udpp.multicastHint': 'Use the same group address as the sending app. WSJT-X default is 224.0.0.1.', 'udpp.destinationIp': 'Destination IP', 'udpp.enabled': 'Enabled', 'udpp.cancel': 'Cancel', 'udpp.save': 'Save',
-  'fltb.fCallsign': 'Callsign', 'fltb.fDate': 'Date / time (UTC)', 'fltb.fEndDate': 'End date / time', 'fltb.fBand': 'Band', 'fltb.fRxBand': 'RX band', 'fltb.fMode': 'Mode', 'fltb.fSubmode': 'Submode', 'fltb.fFreq': 'Frequency (Hz)', 'fltb.fRxFreq': 'RX frequency (Hz)', 'fltb.fRstSent': 'RST sent', 'fltb.fRstRcvd': 'RST rcvd', 'fltb.fName': 'Name', 'fltb.fQth': 'QTH', 'fltb.fAddress': 'Address', 'fltb.fEmail': 'E-mail', 'fltb.fGrid': 'Grid', 'fltb.fCountry': 'Country', 'fltb.fState': 'State', 'fltb.fCounty': 'County', 'fltb.fDxcc': 'DXCC #', 'fltb.fContinent': 'Continent', 'fltb.fCqz': 'CQ zone', 'fltb.fItuz': 'ITU zone', 'fltb.fIota': 'IOTA', 'fltb.fSota': 'SOTA ref', 'fltb.fPota': 'POTA ref', 'fltb.fWwff': 'WWFF ref', 'fltb.fRig': 'Rig', 'fltb.fAntenna': 'Antenna', 'fltb.fQslSent': 'Paper QSL sent status', 'fltb.fQslSentDate': 'Paper QSL sent date', 'fltb.fQslRcvd': 'Paper QSL received status', 'fltb.fQslRcvdDate': 'Paper QSL received date', 'fltb.fQslVia': 'QSL via', 'fltb.fLotwSent': 'LoTW sent status', 'fltb.fLotwSentDate': 'LoTW sent date', 'fltb.fLotwRcvd': 'LoTW received status', 'fltb.fLotwRcvdDate': 'LoTW received date', 'fltb.fEqslSent': 'eQSL sent status', 'fltb.fEqslSentDate': 'eQSL sent date', 'fltb.fEqslRcvd': 'eQSL received status', 'fltb.fEqslRcvdDate': 'eQSL received date', 'fltb.fQrzSent': 'QRZ.com sent status', 'fltb.fQrzSentDate': 'QRZ.com sent date', 'fltb.fQrzRcvd': 'QRZ.com received status', 'fltb.fQrzRcvdDate': 'QRZ.com received date', 'fltb.fClublogSent': 'Club Log sent status', 'fltb.fClublogSentDate': 'Club Log sent date', 'fltb.fHrdlogSent': 'HRDLog sent status', 'fltb.fHrdlogSentDate': 'HRDLog sent date', 'fltb.fContestId': 'Contest ID', 'fltb.fSerialRcvd': 'Serial rcvd', 'fltb.fSerialSent': 'Serial sent', 'fltb.fPropMode': 'Propagation mode', 'fltb.fSatellite': 'Satellite', 'fltb.fMyCallsign': 'Station callsign (my call)', 'fltb.fOperator': 'Operator', 'fltb.fOwnerCallsign': 'Owner callsign', 'fltb.fMyGrid': 'My grid', 'fltb.fMyCountry': 'My country', 'fltb.fMyState': 'My state', 'fltb.fMyCounty': 'My county', 'fltb.fMyIota': 'My IOTA', 'fltb.fMySota': 'My SOTA ref', 'fltb.fMyPota': 'My POTA ref', 'fltb.fMyWwff': 'My WWFF ref', 'fltb.fMyStreet': 'My street', 'fltb.fMyCity': 'My city', 'fltb.fMyPostal': 'My postal code', 'fltb.fMyRig': 'My rig', 'fltb.fMyAntenna': 'My antenna', 'fltb.fTxPower': 'TX power (W)', 'fltb.fComment': 'Comment', 'fltb.fNotes': 'Notes', 'fltb.opEq': 'equals (=)', 'fltb.opNe': 'not equal (≠)', 'fltb.opContains': 'contains', 'fltb.opStartsWith': 'starts with', 'fltb.opEndsWith': 'ends with', 'fltb.opGt': 'greater than (>)', 'fltb.opLt': 'less than (<)', 'fltb.opGe': 'greater or equal (≥)', 'fltb.opLe': 'less or equal (≤)', 'fltb.opEmpty': 'is empty', 'fltb.opNotEmpty': 'is not empty', 'fltb.title': 'QSO filter', 'fltb.match': 'Match', 'fltb.all': 'ALL (AND)', 'fltb.any': 'ANY (OR)', 'fltb.loadPreset': 'Load preset…', 'fltb.noConditions': 'No conditions — the list shows all QSOs. Add one below.', 'fltb.where': 'WHERE', 'fltb.valuePh': 'value', 'fltb.remove': 'Remove', 'fltb.addCondition': 'Add condition', 'fltb.presetNamePh': 'Preset name…', 'fltb.savePreset': 'Save preset', 'fltb.clear': 'Clear', 'fltb.cancel': 'Cancel', 'fltb.applyClose': 'Apply & close',
+  'fltb.fCallsign': 'Callsign', 'fltb.fDate': 'Date / time (UTC)', 'fltb.fEndDate': 'End date / time', 'fltb.fBand': 'Band', 'fltb.fRxBand': 'RX band', 'fltb.fMode': 'Mode', 'fltb.fSubmode': 'Submode', 'fltb.fFreq': 'Frequency (Hz)', 'fltb.fRxFreq': 'RX frequency (Hz)', 'fltb.fRstSent': 'RST sent', 'fltb.fRstRcvd': 'RST rcvd', 'fltb.fName': 'Name', 'fltb.fQth': 'QTH', 'fltb.fAddress': 'Address', 'fltb.fEmail': 'E-mail', 'fltb.fGrid': 'Grid', 'fltb.fCountry': 'Country', 'fltb.fState': 'State', 'fltb.fCounty': 'County', 'fltb.fDxcc': 'DXCC #', 'fltb.fContinent': 'Continent', 'fltb.fCqz': 'CQ zone', 'fltb.fItuz': 'ITU zone', 'fltb.fIota': 'IOTA', 'fltb.fSota': 'SOTA ref', 'fltb.fPota': 'POTA ref', 'fltb.fWwff': 'WWFF ref', 'fltb.fRig': 'Rig', 'fltb.fAntenna': 'Antenna', 'fltb.fQslSent': 'Paper QSL sent status', 'fltb.fQslSentDate': 'Paper QSL sent date', 'fltb.fQslRcvd': 'Paper QSL received status', 'fltb.fQslRcvdDate': 'Paper QSL received date', 'fltb.fQslVia': 'QSL via', 'fltb.fLotwSent': 'LoTW sent status', 'fltb.fLotwSentDate': 'LoTW sent date', 'fltb.fLotwRcvd': 'LoTW received status', 'fltb.fLotwRcvdDate': 'LoTW received date', 'fltb.fEqslSent': 'eQSL sent status', 'fltb.fEqslSentDate': 'eQSL sent date', 'fltb.fEqslRcvd': 'eQSL received status', 'fltb.fEqslRcvdDate': 'eQSL received date', 'fltb.fQrzSent': 'QRZ.com sent status', 'fltb.fQrzSentDate': 'QRZ.com sent date', 'fltb.fQrzRcvd': 'QRZ.com received status', 'fltb.fQrzRcvdDate': 'QRZ.com received date', 'fltb.fClublogSent': 'Club Log sent status', 'fltb.fClublogSentDate': 'Club Log sent date', 'fltb.fHrdlogSent': 'HRDLog sent status', 'fltb.fHrdlogSentDate': 'HRDLog sent date', 'fltb.fContestId': 'Contest ID', 'fltb.fSerialRcvd': 'Serial rcvd', 'fltb.fSerialSent': 'Serial sent', 'fltb.fPropMode': 'Propagation mode', 'fltb.fSatellite': 'Satellite', 'fltb.fMyCallsign': 'Station callsign (my call)', 'fltb.fOperator': 'Operator', 'fltb.fOwnerCallsign': 'Owner callsign', 'fltb.fMyGrid': 'My grid', 'fltb.fMyCountry': 'My country', 'fltb.fMyState': 'My state', 'fltb.fMyCounty': 'My county', 'fltb.fMyIota': 'My IOTA', 'fltb.fMySota': 'My SOTA ref', 'fltb.fMyPota': 'My POTA ref', 'fltb.fMyWwff': 'My WWFF ref', 'fltb.fMyStreet': 'My street', 'fltb.fMyCity': 'My city', 'fltb.fMyPostal': 'My postal code', 'fltb.fMyRig': 'My rig', 'fltb.fMyAntenna': 'My antenna', 'fltb.fTxPower': 'TX power (W)', 'fltb.fComment': 'Comment', 'fltb.fNotes': 'Notes', 'fltb.opEq': 'equals (=)', 'fltb.opNe': 'not equal (≠)', 'fltb.opContains': 'contains', 'fltb.opStartsWith': 'starts with', 'fltb.opEndsWith': 'ends with', 'fltb.opGt': 'greater than (>)', 'fltb.opLt': 'less than (<)', 'fltb.opGe': 'greater or equal (≥)', 'fltb.opLe': 'less or equal (≤)', 'fltb.opEmpty': 'is empty', 'fltb.opIn': 'is one of', 'fltb.opNotIn': 'is none of', 'fltb.listPh': '2m, 70cm — comma separated', 'fltb.opNotEmpty': 'is not empty', 'fltb.title': 'QSO filter', 'fltb.match': 'Match', 'fltb.all': 'ALL (AND)', 'fltb.any': 'ANY (OR)', 'fltb.loadPreset': 'Load preset…', 'fltb.noConditions': 'No conditions — the list shows all QSOs. Add one below.', 'fltb.where': 'WHERE', 'fltb.valuePh': 'value', 'fltb.remove': 'Remove', 'fltb.addCondition': 'Add condition', 'fltb.presetNamePh': 'Preset name…', 'fltb.savePreset': 'Save preset', 'fltb.clear': 'Clear', 'fltb.cancel': 'Cancel', 'fltb.applyClose': 'Apply & close',
   'detp.propAS': 'Aircraft Scatter', 'detp.propAUR': 'Aurora', 'detp.propAUE': 'Aurora-E', 'detp.propBS': 'Back Scatter', 'detp.propEME': 'Earth-Moon-Earth', 'detp.propES': 'Sporadic E', 'detp.propFAI': 'Field Aligned Irregularities', 'detp.propF2': 'F2 Reflection', 'detp.propGWAVE': 'Ground Wave', 'detp.propINTERNET': 'Internet-assisted', 'detp.propION': 'Ionoscatter', 'detp.propLOS': 'Line of Sight', 'detp.propMS': 'Meteor Scatter', 'detp.propRPT': 'Terrestrial / atmospheric repeater', 'detp.propRS': 'Rain Scatter', 'detp.propSAT': 'Satellite', 'detp.propTEP': 'Trans-Equatorial', 'detp.propTR': 'Tropospheric Ducting', 'detp.pathShort': 'Short Path', 'detp.pathLong': 'Long Path', 'detp.pathGrayline': 'Grayline', 'detp.pathOther': 'Other', 'detp.tabStats': 'Stats', 'detp.tabInfo': 'Info', 'detp.tabAwards': 'Awards', 'detp.tabMy': 'My', 'detp.tabExtended': 'Extended', 'detp.statePref': 'State / pref', 'detp.county': 'County', 'detp.newCounty': 'NEW', 'detp.newCountyTip': 'County never worked before', 'detp.prefix': 'Prefix', 'detp.cqZone': 'CQ', 'detp.ituZone': 'ITU', 'detp.dxcc': 'DXCC #', 'detp.azimuthLp': 'Azimuth LP', 'detp.distanceSp': 'Distance SP', 'detp.distanceLp': 'Distance LP', 'detp.address': 'Address', 'detp.qslMessage': 'QSL message', 'detp.qslVia': 'QSL via', 'detp.detected': 'Detected — this contact will count for:', 'detp.ambiguous': 'Ambiguous — pick one:', 'detp.azimuth': 'Azimuth (°)', 'detp.elevation': 'Elevation (°)', 'detp.txPower': 'TX power (W)', 'detp.satelliteMode': 'Satellite mode', 'detp.antPath': 'Ant. path', 'detp.propagation': 'Propagation', 'detp.rig': 'Rig', 'detp.antenna': 'Antenna', 'detp.satName': 'Satellite name', 'detp.contestId': 'Contest ID', 'detp.rcvdExchangePh': 'rcvd exchange', 'detp.sentExchangePh': 'sent exchange', 'detp.contactedEmail': 'Contacted email',
   // Awards (ref picker / ref selector / awards panel / award editor)
   'awrp.remove': 'Remove', 'awrp.searchLabel': 'Search {label}…', 'awrp.searching': 'Searching…', 'awrp.noMatch': 'No match.', 'awrp.noMatchDxcc': 'No match for this DXCC.',
@@ -451,7 +451,7 @@ const en: Dict = {
 const fr: Dict = {
   'prop.title': 'Propagation', 'prop.geomag': 'Géomag', 'prop.refresh': 'Actualiser la météo spatiale',
   'live.onAir': 'On air', 'live.offline': 'Hors ligne',
-  'live.onAirTip': "On air — un QSO a été loggé dans les 5 dernières minutes (publié dans le statut live)",
+  'pskr.tip': 'PSK Reporter — {n} décodages reçus sur {bands}. Cliquer pour les réglages.', 'live.onAirTip': "On air — un QSO a été loggé dans les 5 dernières minutes (publié dans le statut live)",
   'live.offlineTip': 'Hors ligne — aucun QSO loggé depuis 5 minutes',
   'live.stationsTitle': 'Stations on air', 'live.stationsEmpty': 'Aucune station ne reporte pour le moment.', 'live.stationsHide': 'Masquer',
   'rate.title': 'Rythme QSO (QSO/heure) — projeté sur les 10 / 60 dernières minutes',
@@ -544,7 +544,7 @@ const fr: Dict = {
   'sec.general': 'Général', 'sec.email': 'E-mail (SMTP)', 'sec.lookup': "Recherche d'indicatif",
   'sec.bands': 'Bandes', 'sec.modes': 'Modes & RST par défaut', 'sec.cluster': 'DX Cluster',
   'sec.udp': 'Intégrations UDP', 'sec.database': 'Base de données', 'sec.autostart': 'Démarrage auto', 'sec.backup': 'Sauvegarde base', 'sec.uscounties': 'Comtés US',
-  'sec.webpublish': 'Publication web', 'wpub.hint': "Publie ton journal dans un fichier destiné à un site web : une page HTML autonome ou un CSV, écrit en local et envoyé par FTP si tu le souhaites. Il est rafraîchi à chaque QSO enregistré et, si tu règles un intervalle, périodiquement.", 'wpub.enable': 'Publier le journal dans un fichier', 'wpub.fileSection': 'Le fichier', 'wpub.format': 'Format', 'wpub.formatHtml': 'Page HTML', 'wpub.formatCsv': 'CSV', 'wpub.folder': 'Dossier de sortie', 'wpub.browse': 'Parcourir…', 'wpub.fileName': 'Nom du fichier', 'wpub.title': 'Titre de la page', 'wpub.titlePh': 'vide = ton indicatif', 'wpub.count': 'N derniers QSO', 'wpub.every': 'Rafraîchir toutes les', 'wpub.everyHint': 'minutes — 0 = seulement à chaque QSO', 'wpub.columns': 'Colonnes', 'wpub.columnsHint': 'Clique pour ajouter ou retirer. L ordre affiché ici est celui du fichier.', 'wpub.ftpEnable': 'Envoyer par FTP', 'wpub.ftpHost': 'Serveur / port', 'wpub.ftpUser': 'Utilisateur', 'wpub.ftpPassword': 'Mot de passe', 'wpub.ftpFolder': 'Dossier distant', 'wpub.ftpFileName': 'Nom du fichier distant', 'wpub.ftpTls': 'Utiliser TLS (FTPS)', 'wpub.publishNow': 'Publier maintenant', 'wpub.testFtp': 'Tester la connexion', 'wpub.lastRun': 'Dernière exécution :', 'sec.adifmon': 'Moniteur ADIF',
+  'sec.webpublish': 'Publication web', 'wpub.hint': "Publie ton journal dans un fichier destiné à un site web : une page HTML autonome ou un CSV, écrit en local et envoyé par FTP si tu le souhaites. Il est rafraîchi à chaque QSO enregistré et, si tu règles un intervalle, périodiquement.", 'wpub.enable': 'Publier le journal dans un fichier', 'wpub.fileSection': 'Le fichier', 'wpub.format': 'Format', 'wpub.formatHtml': 'Page HTML', 'wpub.formatCsv': 'CSV', 'wpub.folder': 'Dossier de sortie', 'wpub.browse': 'Parcourir…', 'wpub.fileName': 'Nom du fichier', 'wpub.title': 'Titre de la page', 'wpub.titlePh': 'vide = ton indicatif', 'wpub.count': 'N derniers QSO', 'wpub.every': 'Rafraîchir toutes les', 'wpub.everyHint': 'minutes — 0 = seulement à chaque QSO', 'wpub.columns': 'Colonnes', 'wpub.columnsCount': '{n} sur {total} choisis', 'wpub.columnsPick': 'Choisir les colonnes…', 'wpub.columnsSearch': 'Chercher un champ…', 'wpub.removeColumn': 'Cliquer pour retirer', 'wpub.columnsHint': 'Clique pour ajouter ou retirer. L ordre affiché ici est celui du fichier.', 'wpub.ftpEnable': 'Envoyer par FTP', 'wpub.ftpHost': 'Serveur / port', 'wpub.ftpUser': 'Utilisateur', 'wpub.ftpPassword': 'Mot de passe', 'wpub.ftpFolder': 'Dossier distant', 'wpub.ftpFileName': 'Nom du fichier distant', 'wpub.ftpTls': 'Utiliser TLS (FTPS)', 'wpub.publishNow': 'Publier maintenant', 'wpub.testFtp': 'Tester la connexion', 'wpub.lastRun': 'Dernière exécution :', 'sec.adifmon': 'Moniteur ADIF',
   'adifmon.hint': "Surveille des fichiers ADIF externes et importe les nouveaux QSO automatiquement — ex. fldigi en RTTY, ou N1MM/VarAC. Les QSO importés sont enrichis, dédoublonnés et envoyés à tes services externes comme un QSO loggé ici.",
   'adifmon.enable': 'Activer le moniteur ADIF',
   'adifmon.empty': 'Aucun fichier surveillé. Ajoute un fichier ADIF ci-dessous.',
@@ -582,7 +582,7 @@ const fr: Dict = {
   'uscty.backfillIntro': "Résout le comté (et le locator) pour les QSO US déjà dans ton log qui n'en ont pas. Les valeurs existantes sont conservées — seuls les vides sont remplis.",
   'uscty.backfillRun': 'Remplir les comtés manquants',
   'uscty.backfillDone': '{s} QSO US analysés · {c} comtés, {g} locators remplis.',
-  'station.title': 'Contrôle station', 'station.rotator': 'Rotator', 'station.rotatorNoRead': 'Azimut non lu', 'station.pattern': 'Diagramme', 'station.bi': 'Bi', 'station.retract': 'Rétracter les éléments', 'station.moving': 'EN MOUVEMENT', 'station.elements': 'Éléments (mm)', 'station.read': 'Lire', 'station.readLengths': 'Lire les longueurs actuelles depuis le contrôleur', 'station.noLengths': 'Longueurs inconnues — clique sur Lire pour les récupérer depuis le contrôleur.', 'station.element': 'Élément', 'station.reflector': 'Réflecteur', 'station.driven': 'Radiateur', 'station.director': 'Dir', 'station.set': 'Régler', 'station.elementsHint': "Chaque appui allonge/raccourcit l'élément de 2 mm (comme le pupitre). Vérifie quel élément répond sur ton antenne.", 'station.setExactLen': "Clique pour taper la longueur actuelle exacte (recale la base si la lecture auto est fausse).", 'station.atMax': "Refusé par le contrôleur — l'élément est probablement en butée (longueur max pour cette bande), il ne peut plus s'allonger.", 'station.go': 'Aller', 'station.stop': 'Stop', 'station.dragHint': 'Glisse la poignée à gauche d un panneau pour le déplacer. Choisis un nombre de colonnes pour la disposition.', 'station.dragMove': 'Glisser pour déplacer ce panneau', 'station.colsAuto': 'Auto', 'station.addDevice': 'Ajouter un appareil', 'station.editDevice': "Modifier l'appareil", 'station.empty': "Aucune carte relais. Ajoute un WebSwitch 1216H ou une carte KMTronic 8 relais pour piloter l'alimentation et les accessoires de ta station.", 'station.online': 'En ligne', 'station.offline': 'Hors ligne', 'station.edit': 'Modifier', 'station.delete': 'Supprimer', 'station.relay': 'Relais', 'station.on': 'ON', 'station.off': 'OFF', 'station.type': "Type d'appareil", 'station.name': 'Nom', 'station.host': 'Hôte / IP', 'station.hostHint': "IP du LAN en local. Pour joindre la carte depuis L'EXTÉRIEUR, saisis une URL complète ici — ex. https://relais.tondomaine.com — pointant vers un reverse proxy (Nginx Proxy Manager…) qui expose le port HTTP de la carte.", 'station.user': "Nom d'utilisateur", 'station.pass': 'Mot de passe', 'station.optional': 'optionnel', 'station.ftdiSerial': 'Numéro de série FTDI', 'station.detect': 'Détecter', 'station.ftdiHint': "La carte Denkovi se pilote en FTDI bit-bang (pas via le port COM). Choisis son numéro de série (ex. DAE0006K). Nécessite le driver FTDI D2XX installé.", 'station.channels': 'Relais', 'station.comPort': 'Port COM', 'station.noPorts': 'Aucun port', 'station.usbRelayHint': "Cartes USB-série bon marché (CH340/LCUS) protocole A0. Si la tienne ne commute pas, donne-moi le modèle / jeu de commandes.", 'station.labels': 'Libellés des relais', 'station.cancel': 'Annuler', 'station.save': 'Enregistrer', 'station.test': 'Tester la connexion', 'station.testOk': 'Connecté — {n} relais', 'station.testFail': 'Non connecté', 'station.detectNone': 'Aucune carte FTDI trouvée — vérifie le câble et que le driver D2XX est installé.', 'station.detectFound': '{n} carte(s) détectée(s).',
+  'station.title': 'Contrôle station', 'station.rotator': 'Rotator', 'station.rotatorNoRead': 'Azimut non lu', 'station.bands': 'Bandes', 'station.nudgeUp': 'Monter de {n} kHz', 'station.nudgeDown': 'Descendre de {n} kHz', 'station.trackOn': 'Suivi actif', 'station.trackOff': 'Suivi inactif', 'station.trackStepTip': 'Ne réaccorder que si le rig a bougé d au moins ça', 'station.pattern': 'Diagramme', 'station.bi': 'Bi', 'station.retract': 'Rétracter les éléments', 'station.moving': 'EN MOUVEMENT', 'station.elements': 'Éléments (mm)', 'station.read': 'Lire', 'station.readLengths': 'Lire les longueurs actuelles depuis le contrôleur', 'station.noLengths': 'Longueurs inconnues — clique sur Lire pour les récupérer depuis le contrôleur.', 'station.element': 'Élément', 'station.reflector': 'Réflecteur', 'station.driven': 'Radiateur', 'station.director': 'Dir', 'station.set': 'Régler', 'station.elementsHint': "Chaque appui allonge/raccourcit l'élément de 2 mm (comme le pupitre). Vérifie quel élément répond sur ton antenne.", 'station.setExactLen': "Clique pour taper la longueur actuelle exacte (recale la base si la lecture auto est fausse).", 'station.atMax': "Refusé par le contrôleur — l'élément est probablement en butée (longueur max pour cette bande), il ne peut plus s'allonger.", 'station.go': 'Aller', 'station.stop': 'Stop', 'station.dragHint': 'Glisse la poignée à gauche d un panneau pour le déplacer. Choisis un nombre de colonnes pour la disposition.', 'station.dragMove': 'Glisser pour déplacer ce panneau', 'station.colsAuto': 'Auto', 'station.addDevice': 'Ajouter un appareil', 'station.editDevice': "Modifier l'appareil", 'station.empty': "Aucune carte relais. Ajoute un WebSwitch 1216H ou une carte KMTronic 8 relais pour piloter l'alimentation et les accessoires de ta station.", 'station.online': 'En ligne', 'station.offline': 'Hors ligne', 'station.edit': 'Modifier', 'station.delete': 'Supprimer', 'station.relay': 'Relais', 'station.on': 'ON', 'station.off': 'OFF', 'station.type': "Type d'appareil", 'station.name': 'Nom', 'station.host': 'Hôte / IP', 'station.hostHint': "IP du LAN en local. Pour joindre la carte depuis L'EXTÉRIEUR, saisis une URL complète ici — ex. https://relais.tondomaine.com — pointant vers un reverse proxy (Nginx Proxy Manager…) qui expose le port HTTP de la carte.", 'station.user': "Nom d'utilisateur", 'station.pass': 'Mot de passe', 'station.optional': 'optionnel', 'station.ftdiSerial': 'Numéro de série FTDI', 'station.detect': 'Détecter', 'station.ftdiHint': "La carte Denkovi se pilote en FTDI bit-bang (pas via le port COM). Choisis son numéro de série (ex. DAE0006K). Nécessite le driver FTDI D2XX installé.", 'station.channels': 'Relais', 'station.comPort': 'Port COM', 'station.noPorts': 'Aucun port', 'station.usbRelayHint': "Cartes USB-série bon marché (CH340/LCUS) protocole A0. Si la tienne ne commute pas, donne-moi le modèle / jeu de commandes.", 'station.labels': 'Libellés des relais', 'station.cancel': 'Annuler', 'station.save': 'Enregistrer', 'station.test': 'Tester la connexion', 'station.testOk': 'Connecté — {n} relais', 'station.testFail': 'Non connecté', 'station.detectNone': 'Aucune carte FTDI trouvée — vérifie le câble et que le driver D2XX est installé.', 'station.detectFound': '{n} carte(s) détectée(s).',
   'awards.followHint': 'Diplômes affichés dans l’onglet Awards. Laisse la colonne de droite vide pour tous les afficher.', 'awards.available': 'Tous les diplômes', 'awards.followed': 'Suivis', 'awards.search': 'Filtrer…', 'awards.addAll': 'Tout ajouter', 'awards.clear': 'Vider', 'awards.allTracked': 'Tous les diplômes sont suivis.', 'awards.noneFollowed': 'Aucun pour l’instant — l’onglet Awards les montre tous.',
   'sec.awards': 'Diplômes', 'sec.cat': 'Interface CAT', 'sec.rotator': 'Rotator', 'sec.winkeyer': 'Manipulateur CW',
   'sec.antenna': 'Antenne motorisée', 'sec.antgenius': 'Antenna Genius', 'sec.tunergenius': 'Tuner Genius', 'sec.pgxl': 'Amplificateur', 'sec.flex': 'FlexRadio', 'sec.audio': 'Périphériques audio',
@@ -690,7 +690,7 @@ const fr: Dict = {
   'clu.muteWorkedHint': '(elles restent dans la liste, simplement discrètes — la couleur reste pour ce qui est à faire)',
   'clu.slotHighlight': 'Colorer les stations non contactées sur cette bande et ce mode',
   'clu.slotHighlightHint': "(par indicatif, quel que soit le statut de l'entité)",
-  'clu.workedSameSlot': 'Déjà contacté seulement sur le même slot',
+  'bo.open': 'ouvert', 'bo.liveTip': '{band} est ouvert — {n} stations, ~{km} km, {sector}{season}. Cliquer pour le bandmap.', 'bo.enable': 'Surveiller les ouvertures de bande', 'bo.enableHint': "(10, 12, 6, 4 et 2 m. Activer ajoute les deux nœuds RBN et souscrit au flux PSK Reporter — la détection a besoin de bien plus d oreilles qu un cluster ne peut en fournir.)", 'bo.feedUp': 'Flux PSK Reporter actif — {n} décodages vus', 'bo.feedDown': 'Flux PSK Reporter inactif — il faut ton locator, et un instant pour se connecter', 'clu.workedSameSlot': 'Déjà contacté seulement sur le même slot',
   'clu.workedSameSlotHint': '— un spot n\'affiche « contacté » que si vous avez contacté cet indicatif sur la MÊME bande et le MÊME mode, pas juste n\'importe où. Se combine avec le groupage des modes numériques (Réglages → Général) : activé, un indicatif contacté en 20m FT8 compte aussi comme contacté pour un spot 20m FT4 ; désactivé, FT8 et FT4 sont des slots distincts.',
   'bk.hintMysql': "À la fermeture (1×/jour) OpsLog sauvegarde le SQLite local (config) ET exporte le log MySQL partagé en ADIF — opslog-log-<date>.adi — pour protéger tes contacts même s'ils sont sur le serveur. La rotation garde les N derniers de chaque.",
   'bk.hint': "OpsLog peut copier la base SQLite dans un dossier de ton choix à la fermeture, une fois par jour. La rotation garde les N dernières copies et supprime les plus anciennes.",
@@ -759,7 +759,7 @@ const fr: Dict = {
   'bmp.statusWorked': 'Contacté (cette bande + mode déjà au log)', 'bmp.statusUnresolved': 'Entité non résolue', 'bmp.bandMap': 'Carte de bande', 'bmp.notConfigured': 'Non configurée pour {band}.',
   'bmp.map': 'Carte', 'bmp.zoomOut': 'Dézoomer', 'bmp.zoomIn': 'Zoomer', 'bmp.scrollToRig': 'Aller à la fréquence actuelle du poste', 'bmp.moveLeft': 'Déplacer la carte de bande à gauche', 'bmp.moveRight': 'Déplacer la carte de bande à droite', 'bmp.hide': 'Masquer la carte de bande',
   'bmp.bandsLabel': 'Bandes :', 'bmp.fit': 'FIT', 'bmp.hideFt': 'Masquer FTx', 'bmp.hideFtTitle': 'Masquer tous les spots numériques (FT8/FT4/JS8/…) sur toutes les cartes', 'bmp.fitBand': 'Ajuster à la bande', 'bmp.widthTip': 'Glisser pour redimensionner — double-clic pour réinitialiser', 'bmp.fitTitle': 'Dimensionner chaque carte pour afficher toute la bande',
-  'bmp.legendNewDxcc': 'Nouveau DXCC', 'bmp.legendNewBand': 'Nouvelle bande', 'bmp.legendNewSlot': 'Nouveau mode', 'bmp.openToast': 'Ouverture {band} — {n} stations vers {km} km', 'bmp.openUnusual': 'inhabituel pour la saison', 'bmp.legendWorked': 'Contacté', 'bmp.legendNewPota': 'Nouveau POTA', 'bmp.legendNewCounty': 'Nouveau comté', 'bmp.legendWorkedCall': 'Indicatif déjà contacté', 'bmp.legendCW': 'CW', 'bmp.legendData': 'Numérique', 'bmp.legendPhone': 'Phonie', 'bmp.footerHint': 'défiler · ctrl+molette = zoom · ◎ = aller au poste', 'bmp.spotsHidden': '{n} spots FT8/FT4 masqués — {max} meilleurs conservés (CW/SSB tous affichés)',
+  'bmp.legendNewDxcc': 'Nouveau DXCC', 'bmp.legendNewBand': 'Nouvelle bande', 'bmp.legendNewSlot': 'Nouveau mode', 'bmp.openUnusual': 'inhabituel pour la saison', 'bmp.legendWorked': 'Contacté', 'bmp.legendNewPota': 'Nouveau POTA', 'bmp.legendNewCounty': 'Nouveau comté', 'bmp.legendWorkedCall': 'Indicatif déjà contacté', 'bmp.legendCW': 'CW', 'bmp.legendData': 'Numérique', 'bmp.legendPhone': 'Phonie', 'bmp.footerHint': 'défiler · ctrl+molette = zoom · ◎ = aller au poste', 'bmp.spotsHidden': '{n} spots FT8/FT4 masqués — {max} meilleurs conservés (CW/SSB tous affichés)',
   'frm.welcome': 'Bienvenue dans OpsLog', 'frm.intro': 'Configure ta station pour commencer à logger. Ces champs sont inscrits sur chaque QSO et peuvent être modifiés plus tard dans Préférences → Informations station (et par profil).',
   'frm.callsign': 'Indicatif', 'frm.locator': 'Locator', 'frm.operator': 'Opérateur', 'frm.operatorPh': "identique à l'indicatif", 'frm.owner': 'Propriétaire', 'frm.ownerPh': 'indicatif du propriétaire de la station', 'frm.name': 'Nom', 'frm.namePh': 'ton prénom',
   'frm.awardRefs': 'Listes de références des diplômes', 'frm.awardRefsHint': 'IOTA · POTA · WWFF · SOTA — noms et totaux pour ces diplômes (optionnel, peut prendre une minute).', 'frm.downloading': 'Téléchargement…', 'frm.reDownload': 'Retélécharger', 'frm.download': 'Télécharger', 'frm.required': "L'indicatif et le locator sont obligatoires.", 'frm.saving': 'Enregistrement…', 'frm.startLogging': 'Commencer à logger',
@@ -791,7 +791,7 @@ const fr: Dict = {
   'spm.callRequired': 'Indicatif requis', 'spm.freqRequired': 'Fréquence (kHz) requise', 'spm.title': 'Envoyer un spot DX', 'spm.callsign': 'Indicatif', 'spm.callPh': 'Indicatif DX', 'spm.frequency': 'Fréquence (kHz)', 'spm.message': 'Message', 'spm.messagePh': 'ex. CW · TNX QSO', 'spm.latestQsos': 'Derniers QSO', 'spm.spotSent': 'Spot envoyé ✓', 'spm.masterCluster': 'Cluster maître', 'spm.cancel': 'Annuler', 'spm.sending': 'Envoi…', 'spm.sendSpot': 'Envoyer le spot',
   'ncp.newNetPrompt': 'Nom du nouveau NET :', 'ncp.renamePrompt': 'Renommer le NET :', 'ncp.deleteConfirm': 'Supprimer le NET « {name} » et son répertoire ? Cette action est irréversible.', 'ncp.closeConfirm': "{n} station(s) encore en l'air seront retirées SANS être enregistrées. Fermer quand même ?", 'ncp.removeConfirm': 'Retirer {n} station(s) du répertoire de ce NET ?', 'ncp.colCallsign': 'Indicatif', 'ncp.colName': 'Nom', 'ncp.colTimeOn': 'Heure début', 'ncp.colBand': 'Bande', 'ncp.colMode': 'Mode', 'ncp.colComment': 'Commentaire', 'ncp.colCountry': 'Pays', 'ncp.colDate': 'Date', 'ncp.workedBefore': 'Déjà contacté', 'ncp.wbHint': 'Cliquer une station (on air ou roster) pour voir les QSO précédents', 'ncp.wbNone': 'Aucun QSO précédent avec', 'ncp.wbFirst': 'premier', 'ncp.wbLast': 'dernier', 'ncp.wbResize': 'Glisser pour redimensionner', 'ncp.newNet': 'Nouveau NET', 'ncp.closeToSwitch': 'Ferme le NET pour changer', 'ncp.selectNetTitle': 'Sélectionne un NET', 'ncp.selectNetOption': '— sélectionner un NET —', 'ncp.closeNet': 'Fermer le NET', 'ncp.openNet': 'Ouvrir le NET', 'ncp.rename': 'Renommer', 'ncp.delete': 'Supprimer', 'ncp.netOpenBadge': 'NET OUVERT', 'ncp.onAir': "En l'air :", 'ncp.roster': 'Répertoire :', 'ncp.onAirActive': "En l'air — QSO actifs", 'ncp.activeHint': 'ordre de passage du micro · ⬆⬇ pour réordonner · double-clic → éditer · « Logger & terminer »', 'ncp.moveUp': "Monter dans l'ordre de passage", 'ncp.moveDown': "Descendre dans l'ordre de passage", 'ncp.logEndSelected': 'Logger & terminer la sélection', 'ncp.logAll': 'Logger tout le monde ({n})', 'ncp.logAllConfirm': 'Logger les {n} station(s) on air dans le logbook ?', 'ncp.netUsersRoster': 'Membres du NET — répertoire', 'ncp.rosterHint': "double-clic → mettre en l'air", 'ncp.addContact': 'Ajouter un contact', 'ncp.remove': 'Retirer', 'ncp.putOnAir': "Mettre la sélection en l'air", 'ncp.addContactTitle': 'Ajouter un contact au NET', 'ncp.addContactDesc': 'Enregistré dans le répertoire de ce NET (réutilisé à la prochaine ouverture).', 'ncp.callsign': 'Indicatif', 'ncp.search': 'Rechercher', 'ncp.name': 'Nom', 'ncp.country': 'Pays', 'ncp.cancel': 'Annuler', 'ncp.saveInNet': 'Enregistrer dans le NET',
   'udpp.svcWsjtLabel': 'WSJT-X / JTDX / MSHV', 'udpp.svcWsjtHint': "Logue automatiquement les QSO FT8/FT4/etc. et remplit l'indicatif de saisie en direct.", 'udpp.svcAdifLabel': 'Message ADIF (JTAlert, GridTracker)', 'udpp.svcAdifHint': 'Reçoit un seul enregistrement ADIF par paquet et le logue.', 'udpp.svcN1mmLabel': 'N1MM Logger+ (XML contest)', 'udpp.svcN1mmHint': 'Reçoit les QSO de contest sous forme de messages XML.', 'udpp.svcRemoteLabel': 'Indicatif distant (DXHunter, personnalisé)', 'udpp.svcRemoteHint': 'Un court paquet texte contenant juste un indicatif — remplit le champ de saisie.', 'udpp.svcDbLabel': "ADIF Message", 'udpp.svcDbHint': "Envoie l'ADIF de chaque QSO enregistré vers un écouteur distant (Cloudlog UDP, N1MM…).", 'udpp.svcPstLabel': 'Fréquence PstRotator', 'udpp.svcPstHint': "Envoie la fréquence du poste en <PST><FREQUENCY> à chaque changement — règle le tracker de PstRotatorAz sur DXLog.net (port 12040 par défaut).", 'udpp.svcN1mmRadioLabel': 'N1MM RadioInfo (fréq + mode)', 'udpp.svcN1mmRadioHint': "Diffuse la fréquence/mode du poste en XML RadioInfo N1MM Logger+ à chaque changement — lu par PstRotator (tracker N1MM) et beaucoup d'autres outils.", 'udpp.deleteConfirm': 'Supprimer cette connexion UDP ?', 'udpp.loading': 'Chargement…', 'udpp.intro': "Les connexions UDP permettent à OpsLog de dialoguer avec d'autres logiciels radioamateurs. Les connexions entrantes reçoivent des QSO ou des indicatifs et mettent le journal à jour en direct ; les connexions sortantes notifient d'autres apps quand tu enregistres un QSO localement. Active le multicast pour partager un port avec un autre écouteur sans conflit — nécessaire pour la config WSJT-X 2237 classique.", 'udpp.inboundTitle': 'Entrant — OpsLog écoute', 'udpp.outboundTitle': 'Sortant — OpsLog envoie', 'udpp.reloadAll': 'Tout recharger', 'udpp.reloadHint': 'Redémarre chaque écouteur activé après une modification manuelle.', 'udpp.add': 'Ajouter', 'udpp.noConnection': 'Aucune connexion.', 'udpp.unnamed': '(sans nom)', 'udpp.dialogTitle': '{action} connexion {direction}', 'udpp.new': 'Nouvelle', 'udpp.edit': 'Modifier', 'udpp.directionInbound': 'entrante', 'udpp.directionOutbound': 'sortante', 'udpp.name': 'Nom', 'udpp.namePhInbound': 'Log WSJT-X', 'udpp.namePhOutbound': 'Notification Cloudlog', 'udpp.serviceType': 'Type de service', 'udpp.port': 'Port', 'udpp.multicast': 'Multicast', 'udpp.multicastGroup': 'Groupe multicast', 'udpp.multicastHint': "Utilise la même adresse de groupe que l'app émettrice. Le défaut WSJT-X est 224.0.0.1.", 'udpp.destinationIp': 'IP de destination', 'udpp.enabled': 'Activé', 'udpp.cancel': 'Annuler', 'udpp.save': 'Enregistrer',
-  'fltb.fCallsign': 'Callsign', 'fltb.fDate': 'Date / time (UTC)', 'fltb.fEndDate': 'End date / time', 'fltb.fBand': 'Band', 'fltb.fRxBand': 'RX band', 'fltb.fMode': 'Mode', 'fltb.fSubmode': 'Submode', 'fltb.fFreq': 'Frequency (Hz)', 'fltb.fRxFreq': 'RX frequency (Hz)', 'fltb.fRstSent': 'RST sent', 'fltb.fRstRcvd': 'RST rcvd', 'fltb.fName': 'Name', 'fltb.fQth': 'QTH', 'fltb.fAddress': 'Address', 'fltb.fEmail': 'E-mail', 'fltb.fGrid': 'Grid', 'fltb.fCountry': 'Country', 'fltb.fState': 'State', 'fltb.fCounty': 'County', 'fltb.fDxcc': 'DXCC #', 'fltb.fContinent': 'Continent', 'fltb.fCqz': 'CQ zone', 'fltb.fItuz': 'ITU zone', 'fltb.fIota': 'IOTA', 'fltb.fSota': 'SOTA ref', 'fltb.fPota': 'POTA ref', 'fltb.fWwff': 'WWFF ref', 'fltb.fRig': 'Rig', 'fltb.fAntenna': 'Antenna', 'fltb.fQslSent': 'Paper QSL sent status', 'fltb.fQslSentDate': 'Paper QSL sent date', 'fltb.fQslRcvd': 'Paper QSL received status', 'fltb.fQslRcvdDate': 'Paper QSL received date', 'fltb.fQslVia': 'QSL via', 'fltb.fLotwSent': 'LoTW sent status', 'fltb.fLotwSentDate': 'LoTW sent date', 'fltb.fLotwRcvd': 'LoTW received status', 'fltb.fLotwRcvdDate': 'LoTW received date', 'fltb.fEqslSent': 'eQSL sent status', 'fltb.fEqslSentDate': 'eQSL sent date', 'fltb.fEqslRcvd': 'eQSL received status', 'fltb.fEqslRcvdDate': 'eQSL received date', 'fltb.fQrzSent': 'QRZ.com sent status', 'fltb.fQrzSentDate': 'QRZ.com sent date', 'fltb.fQrzRcvd': 'QRZ.com received status', 'fltb.fQrzRcvdDate': 'QRZ.com received date', 'fltb.fClublogSent': 'Club Log sent status', 'fltb.fClublogSentDate': 'Club Log sent date', 'fltb.fHrdlogSent': 'HRDLog sent status', 'fltb.fHrdlogSentDate': 'HRDLog sent date', 'fltb.fContestId': 'Contest ID', 'fltb.fSerialRcvd': 'Serial rcvd', 'fltb.fSerialSent': 'Serial sent', 'fltb.fPropMode': 'Propagation mode', 'fltb.fSatellite': 'Satellite', 'fltb.fMyCallsign': 'Station callsign (my call)', 'fltb.fOperator': 'Operator', 'fltb.fOwnerCallsign': 'Owner callsign', 'fltb.fMyGrid': 'My grid', 'fltb.fMyCountry': 'My country', 'fltb.fMyState': 'My state', 'fltb.fMyCounty': 'My county', 'fltb.fMyIota': 'My IOTA', 'fltb.fMySota': 'My SOTA ref', 'fltb.fMyPota': 'My POTA ref', 'fltb.fMyWwff': 'My WWFF ref', 'fltb.fMyStreet': 'My street', 'fltb.fMyCity': 'My city', 'fltb.fMyPostal': 'My postal code', 'fltb.fMyRig': 'My rig', 'fltb.fMyAntenna': 'My antenna', 'fltb.fTxPower': 'TX power (W)', 'fltb.fComment': 'Comment', 'fltb.fNotes': 'Notes', 'fltb.opEq': 'égal (=)', 'fltb.opNe': 'différent (≠)', 'fltb.opContains': 'contient', 'fltb.opStartsWith': 'commence par', 'fltb.opEndsWith': 'finit par', 'fltb.opGt': 'supérieur à (>)', 'fltb.opLt': 'inférieur à (<)', 'fltb.opGe': 'supérieur ou égal (≥)', 'fltb.opLe': 'inférieur ou égal (≤)', 'fltb.opEmpty': 'est vide', 'fltb.opNotEmpty': "n'est pas vide", 'fltb.title': 'Filtre QSO', 'fltb.match': 'Correspondance', 'fltb.all': 'TOUS (ET)', 'fltb.any': 'AU MOINS UN (OU)', 'fltb.loadPreset': 'Charger un préréglage…', 'fltb.noConditions': 'Aucune condition — la liste affiche tous les QSO. Ajoutes-en une ci-dessous.', 'fltb.where': 'OÙ', 'fltb.valuePh': 'valeur', 'fltb.remove': 'Retirer', 'fltb.addCondition': 'Ajouter une condition', 'fltb.presetNamePh': 'Nom du préréglage…', 'fltb.savePreset': 'Enregistrer le préréglage', 'fltb.clear': 'Effacer', 'fltb.cancel': 'Annuler', 'fltb.applyClose': 'Appliquer & fermer',
+  'fltb.fCallsign': 'Callsign', 'fltb.fDate': 'Date / time (UTC)', 'fltb.fEndDate': 'End date / time', 'fltb.fBand': 'Band', 'fltb.fRxBand': 'RX band', 'fltb.fMode': 'Mode', 'fltb.fSubmode': 'Submode', 'fltb.fFreq': 'Frequency (Hz)', 'fltb.fRxFreq': 'RX frequency (Hz)', 'fltb.fRstSent': 'RST sent', 'fltb.fRstRcvd': 'RST rcvd', 'fltb.fName': 'Name', 'fltb.fQth': 'QTH', 'fltb.fAddress': 'Address', 'fltb.fEmail': 'E-mail', 'fltb.fGrid': 'Grid', 'fltb.fCountry': 'Country', 'fltb.fState': 'State', 'fltb.fCounty': 'County', 'fltb.fDxcc': 'DXCC #', 'fltb.fContinent': 'Continent', 'fltb.fCqz': 'CQ zone', 'fltb.fItuz': 'ITU zone', 'fltb.fIota': 'IOTA', 'fltb.fSota': 'SOTA ref', 'fltb.fPota': 'POTA ref', 'fltb.fWwff': 'WWFF ref', 'fltb.fRig': 'Rig', 'fltb.fAntenna': 'Antenna', 'fltb.fQslSent': 'Paper QSL sent status', 'fltb.fQslSentDate': 'Paper QSL sent date', 'fltb.fQslRcvd': 'Paper QSL received status', 'fltb.fQslRcvdDate': 'Paper QSL received date', 'fltb.fQslVia': 'QSL via', 'fltb.fLotwSent': 'LoTW sent status', 'fltb.fLotwSentDate': 'LoTW sent date', 'fltb.fLotwRcvd': 'LoTW received status', 'fltb.fLotwRcvdDate': 'LoTW received date', 'fltb.fEqslSent': 'eQSL sent status', 'fltb.fEqslSentDate': 'eQSL sent date', 'fltb.fEqslRcvd': 'eQSL received status', 'fltb.fEqslRcvdDate': 'eQSL received date', 'fltb.fQrzSent': 'QRZ.com sent status', 'fltb.fQrzSentDate': 'QRZ.com sent date', 'fltb.fQrzRcvd': 'QRZ.com received status', 'fltb.fQrzRcvdDate': 'QRZ.com received date', 'fltb.fClublogSent': 'Club Log sent status', 'fltb.fClublogSentDate': 'Club Log sent date', 'fltb.fHrdlogSent': 'HRDLog sent status', 'fltb.fHrdlogSentDate': 'HRDLog sent date', 'fltb.fContestId': 'Contest ID', 'fltb.fSerialRcvd': 'Serial rcvd', 'fltb.fSerialSent': 'Serial sent', 'fltb.fPropMode': 'Propagation mode', 'fltb.fSatellite': 'Satellite', 'fltb.fMyCallsign': 'Station callsign (my call)', 'fltb.fOperator': 'Operator', 'fltb.fOwnerCallsign': 'Owner callsign', 'fltb.fMyGrid': 'My grid', 'fltb.fMyCountry': 'My country', 'fltb.fMyState': 'My state', 'fltb.fMyCounty': 'My county', 'fltb.fMyIota': 'My IOTA', 'fltb.fMySota': 'My SOTA ref', 'fltb.fMyPota': 'My POTA ref', 'fltb.fMyWwff': 'My WWFF ref', 'fltb.fMyStreet': 'My street', 'fltb.fMyCity': 'My city', 'fltb.fMyPostal': 'My postal code', 'fltb.fMyRig': 'My rig', 'fltb.fMyAntenna': 'My antenna', 'fltb.fTxPower': 'TX power (W)', 'fltb.fComment': 'Comment', 'fltb.fNotes': 'Notes', 'fltb.opEq': 'égal (=)', 'fltb.opNe': 'différent (≠)', 'fltb.opContains': 'contient', 'fltb.opStartsWith': 'commence par', 'fltb.opEndsWith': 'finit par', 'fltb.opGt': 'supérieur à (>)', 'fltb.opLt': 'inférieur à (<)', 'fltb.opGe': 'supérieur ou égal (≥)', 'fltb.opLe': 'inférieur ou égal (≤)', 'fltb.opEmpty': 'est vide', 'fltb.opIn': 'est parmi', 'fltb.opNotIn': 'n est pas parmi', 'fltb.listPh': '2m, 70cm — séparés par des virgules', 'fltb.opNotEmpty': "n'est pas vide", 'fltb.title': 'Filtre QSO', 'fltb.match': 'Correspondance', 'fltb.all': 'TOUS (ET)', 'fltb.any': 'AU MOINS UN (OU)', 'fltb.loadPreset': 'Charger un préréglage…', 'fltb.noConditions': 'Aucune condition — la liste affiche tous les QSO. Ajoutes-en une ci-dessous.', 'fltb.where': 'OÙ', 'fltb.valuePh': 'valeur', 'fltb.remove': 'Retirer', 'fltb.addCondition': 'Ajouter une condition', 'fltb.presetNamePh': 'Nom du préréglage…', 'fltb.savePreset': 'Enregistrer le préréglage', 'fltb.clear': 'Effacer', 'fltb.cancel': 'Annuler', 'fltb.applyClose': 'Appliquer & fermer',
   'detp.propAS': 'Diffusion par avion', 'detp.propAUR': 'Aurore', 'detp.propAUE': 'Aurore-E', 'detp.propBS': 'Rétrodiffusion', 'detp.propEME': 'Terre-Lune-Terre', 'detp.propES': 'Sporadique E', 'detp.propFAI': 'Irrégularités alignées au champ', 'detp.propF2': 'Réflexion F2', 'detp.propGWAVE': 'Onde de sol', 'detp.propINTERNET': 'Assisté par Internet', 'detp.propION': 'Diffusion ionosphérique', 'detp.propLOS': 'Vue directe', 'detp.propMS': 'Diffusion météoritique', 'detp.propRPT': 'Répéteur terrestre / atmosphérique', 'detp.propRS': 'Diffusion par la pluie', 'detp.propSAT': 'Satellite', 'detp.propTEP': 'Trans-équatorial', 'detp.propTR': 'Conduit troposphérique', 'detp.pathShort': 'Chemin court', 'detp.pathLong': 'Chemin long', 'detp.pathGrayline': 'Ligne grise', 'detp.pathOther': 'Autre', 'detp.tabStats': 'Stats', 'detp.tabInfo': 'Info', 'detp.tabAwards': 'Diplômes', 'detp.tabMy': 'Moi', 'detp.tabExtended': 'Étendu', 'detp.statePref': 'État / préf', 'detp.county': 'Comté', 'detp.newCounty': 'NOUV', 'detp.newCountyTip': 'Comté jamais contacté', 'detp.prefix': 'Préfixe', 'detp.cqZone': 'CQ', 'detp.ituZone': 'ITU', 'detp.dxcc': 'DXCC #', 'detp.azimuthLp': 'Azimut LP', 'detp.distanceSp': 'Distance SP', 'detp.distanceLp': 'Distance LP', 'detp.address': 'Adresse', 'detp.qslMessage': 'Message QSL', 'detp.qslVia': 'QSL via', 'detp.detected': 'Détecté — ce contact comptera pour :', 'detp.ambiguous': 'Ambigu — choisissez :', 'detp.azimuth': 'Azimut (°)', 'detp.elevation': 'Élévation (°)', 'detp.txPower': 'Puissance TX (W)', 'detp.satelliteMode': 'Mode satellite', 'detp.antPath': 'Chemin ant.', 'detp.propagation': 'Propagation', 'detp.rig': 'Station', 'detp.antenna': 'Antenne', 'detp.satName': 'Nom du satellite', 'detp.contestId': 'ID contest', 'detp.rcvdExchangePh': 'échange reçu', 'detp.sentExchangePh': 'échange envoyé', 'detp.contactedEmail': 'E-mail du contact',
   'awrp.remove': 'Retirer', 'awrp.searchLabel': 'Rechercher {label}…', 'awrp.searching': 'Recherche…', 'awrp.noMatch': 'Aucune correspondance.', 'awrp.noMatchDxcc': 'Aucune correspondance pour ce DXCC.',
   'awrs.group': 'Groupe', 'awrs.sub': 'Sous', 'awrs.pickReference': '← choisis une référence', 'awrs.add': 'Ajouter', 'awrs.enterCallsignFirst': "Saisis d'abord un indicatif", 'awrs.noRefsAdded': 'Aucune référence ajoutée', 'awrs.references': 'Références', 'awrs.autoMatchTitle': 'Le champ {field} vaut {code} — ce diplôme le compte automatiquement', 'awrs.fromField': 'depuis {field}', 'awrs.autoClickToAdd': 'auto — clic pour ajouter', 'awrs.search': 'Rechercher…', 'awrs.addUnlistedTitle': "Ajouter cette référence même si elle n'est pas encore dans la liste (nouvelle / non listée)", 'awrs.addPrefix': '+ Ajouter', 'awrs.unlisted': '(non listée)', 'awrs.searching': 'Recherche…', 'awrs.typeToSearch': 'Tape 2+ caractères pour chercher', 'awrs.enterCallsignOrSearch': 'Saisis un indicatif, ou tape pour chercher.', 'awrs.noRefsForEntity': 'Aucune référence pour cette entité.', 'awrs.noResults': 'Aucun résultat.', 'awrs.downloadLists': 'Télécharge les listes de références dans le panneau Diplômes → Importer les données.',

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

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

@@ -14,6 +14,7 @@ import {bandopen} from '../models';
 import {cluster} from '../models';
 import {extsvc} from '../models';
 import {powergenius} from '../models';
+import {pskr} from '../models';
 import {spe} from '../models';
 import {solar} from '../models';
 import {tunergenius} from '../models';
@@ -387,6 +388,8 @@ export function GetAwards():Promise<Array<award.Result>>;
 
 export function GetBackupSettings():Promise<main.BackupSettings>;
 
+export function GetBandOpenSettings():Promise<main.BandOpenSettings>;
+
 export function GetBandOpenings():Promise<Array<bandopen.Opening>>;
 
 export function GetCATSettings():Promise<main.CATSettings>;
@@ -439,6 +442,8 @@ export function GetIcomState():Promise<cat.IcomTXState>;
 
 export function GetListsSettings():Promise<main.ListsSettings>;
 
+export function GetLiveOpenings():Promise<Array<bandopen.Opening>>;
+
 export function GetLiveStations():Promise<Array<main.LiveStation>>;
 
 export function GetLoTWUsersStatus():Promise<main.LoTWUsersStatus>;
@@ -465,6 +470,8 @@ export function GetPGXLStatus():Promise<powergenius.Status>;
 
 export function GetPOTAToken():Promise<string>;
 
+export function GetPSKReporterStatus():Promise<pskr.Status>;
+
 export function GetPendingQSOs():Promise<Array<qso.QSO>>;
 
 export function GetQSLDefaults():Promise<main.QSLDefaults>;
@@ -675,10 +682,14 @@ export function LookupCallsign(arg1:string):Promise<lookup.Result>;
 
 export function LookupCallsignFresh(arg1:string):Promise<lookup.Result>;
 
+export function MotorNudgeKHz(arg1:number):Promise<void>;
+
 export function MotorReadElements():Promise<Array<number>>;
 
 export function MotorSetElement(arg1:number,arg2:number):Promise<void>;
 
+export function MotorTuneKHz(arg1:number):Promise<void>;
+
 export function MoveDatabase(arg1:string):Promise<void>;
 
 export function NetActivate(arg1:string):Promise<qso.QSO>;
@@ -873,6 +884,8 @@ export function SaveAwardReference(arg1:string,arg2:awardref.Ref):Promise<void>;
 
 export function SaveBackupSettings(arg1:main.BackupSettings):Promise<void>;
 
+export function SaveBandOpenSettings(arg1:main.BandOpenSettings):Promise<void>;
+
 export function SaveCATSettings(arg1:main.CATSettings):Promise<void>;
 
 export function SaveCabrilloFile():Promise<string>;
@@ -967,6 +980,8 @@ export function SetDVKLabel(arg1:number,arg2:string):Promise<void>;
 
 export function SetKenwoodKeySpeed(arg1:number):Promise<void>;
 
+export function SetMotorFollow(arg1:boolean,arg2:number):Promise<void>;
+
 export function SetOpsLogQSLReceived(arg1:number,arg2:boolean):Promise<void>;
 
 export function SetPassphrase(arg1:string):Promise<void>;

frontend/wailsjs/go/main/App.js

@@ -718,6 +718,10 @@ export function GetBackupSettings() {
   return window['go']['main']['App']['GetBackupSettings']();
 }
 
+export function GetBandOpenSettings() {
+  return window['go']['main']['App']['GetBandOpenSettings']();
+}
+
 export function GetBandOpenings() {
   return window['go']['main']['App']['GetBandOpenings']();
 }
@@ -822,6 +826,10 @@ export function GetListsSettings() {
   return window['go']['main']['App']['GetListsSettings']();
 }
 
+export function GetLiveOpenings() {
+  return window['go']['main']['App']['GetLiveOpenings']();
+}
+
 export function GetLiveStations() {
   return window['go']['main']['App']['GetLiveStations']();
 }
@@ -874,6 +882,10 @@ export function GetPOTAToken() {
   return window['go']['main']['App']['GetPOTAToken']();
 }
 
+export function GetPSKReporterStatus() {
+  return window['go']['main']['App']['GetPSKReporterStatus']();
+}
+
 export function GetPendingQSOs() {
   return window['go']['main']['App']['GetPendingQSOs']();
 }
@@ -1294,6 +1306,10 @@ export function LookupCallsignFresh(arg1) {
   return window['go']['main']['App']['LookupCallsignFresh'](arg1);
 }
 
+export function MotorNudgeKHz(arg1) {
+  return window['go']['main']['App']['MotorNudgeKHz'](arg1);
+}
+
 export function MotorReadElements() {
   return window['go']['main']['App']['MotorReadElements']();
 }
@@ -1302,6 +1318,10 @@ export function MotorSetElement(arg1, arg2) {
   return window['go']['main']['App']['MotorSetElement'](arg1, arg2);
 }
 
+export function MotorTuneKHz(arg1) {
+  return window['go']['main']['App']['MotorTuneKHz'](arg1);
+}
+
 export function MoveDatabase(arg1) {
   return window['go']['main']['App']['MoveDatabase'](arg1);
 }
@@ -1690,6 +1710,10 @@ export function SaveBackupSettings(arg1) {
   return window['go']['main']['App']['SaveBackupSettings'](arg1);
 }
 
+export function SaveBandOpenSettings(arg1) {
+  return window['go']['main']['App']['SaveBandOpenSettings'](arg1);
+}
+
 export function SaveCATSettings(arg1) {
   return window['go']['main']['App']['SaveCATSettings'](arg1);
 }
@@ -1878,6 +1902,10 @@ export function SetKenwoodKeySpeed(arg1) {
   return window['go']['main']['App']['SetKenwoodKeySpeed'](arg1);
 }
 
+export function SetMotorFollow(arg1, arg2) {
+  return window['go']['main']['App']['SetMotorFollow'](arg1, arg2);
+}
+
 export function SetOpsLogQSLReceived(arg1, arg2) {
   return window['go']['main']['App']['SetOpsLogQSLReceived'](arg1, arg2);
 }

frontend/wailsjs/go/models.ts

@@ -685,6 +685,7 @@ export namespace bandopen {
 	    median_km: number;
 	    bearing_min: number;
 	    bearing_max: number;
+	    compass: string;
 	    in_season: boolean;
 	    // Go type: time
 	    at: any;
@@ -701,6 +702,7 @@ export namespace bandopen {
 	        this.median_km = source["median_km"];
 	        this.bearing_min = source["bearing_min"];
 	        this.bearing_max = source["bearing_max"];
+	        this.compass = source["compass"];
 	        this.in_season = source["in_season"];
 	        this.at = this.convertValues(source["at"], null);
 	        this.examples = source["examples"];
@@ -1971,6 +1973,22 @@ export namespace main {
 	        this.default_folder = source["default_folder"];
 	    }
 	}
+	export class BandOpenSettings {
+	    enabled: boolean;
+	    bands: string[];
+	    available: string[];
+	
+	    static createFrom(source: any = {}) {
+	        return new BandOpenSettings(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.enabled = source["enabled"];
+	        this.bands = source["bands"];
+	        this.available = source["available"];
+	    }
+	}
 	export class CATSettings {
 	    enabled: boolean;
 	    backend: string;
@@ -3284,6 +3302,9 @@ export namespace main {
 	    band: number;
 	    moving: boolean;
 	    elements: number[];
+	    follow: boolean;
+	    step_khz: number;
+	    bands: string[];
 	
 	    static createFrom(source: any = {}) {
 	        return new UltrabeamStatusInfo(source);
@@ -3299,6 +3320,9 @@ export namespace main {
 	        this.band = source["band"];
 	        this.moving = source["moving"];
 	        this.elements = source["elements"];
+	        this.follow = source["follow"];
+	        this.step_khz = source["step_khz"];
+	        this.bands = source["bands"];
 	    }
 	}
 	export class UpdateInfo {
@@ -3791,6 +3815,52 @@ export namespace profile {
 
 }
 
+export namespace pskr {
+	
+	export class Status {
+	    running: boolean;
+	    received: number;
+	    // Go type: time
+	    last_at: any;
+	    last_err?: string;
+	    broker: string;
+	    bands: string[];
+	
+	    static createFrom(source: any = {}) {
+	        return new Status(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.running = source["running"];
+	        this.received = source["received"];
+	        this.last_at = this.convertValues(source["last_at"], null);
+	        this.last_err = source["last_err"];
+	        this.broker = source["broker"];
+	        this.bands = source["bands"];
+	    }
+	
+		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 namespace qslcard {
 	
 	export class Bevel {

go.mod

@@ -4,6 +4,7 @@ go 1.25.0
 
 require (
 	github.com/braheezy/shine-mp3 v0.1.0
+	github.com/eclipse/paho.mqtt.golang v1.5.1
 	github.com/go-ole/go-ole v1.3.0
 	github.com/go-sql-driver/mysql v1.10.0
 	github.com/gorilla/websocket v1.5.3
@@ -12,7 +13,7 @@ require (
 	github.com/wailsapp/wails/v2 v2.11.0
 	github.com/wneessen/go-mail v0.7.3
 	go.bug.st/serial v1.7.1
-	golang.org/x/net v0.35.0
+	golang.org/x/net v0.44.0
 	golang.org/x/sys v0.45.0
 	golang.org/x/text v0.37.0
 	modernc.org/sqlite v1.50.1
@@ -44,7 +45,8 @@ require (
 	github.com/valyala/fasttemplate v1.2.2 // indirect
 	github.com/wailsapp/go-webview2 v1.0.22 // indirect
 	github.com/wailsapp/mimetype v1.4.1 // indirect
-	golang.org/x/crypto v0.33.0 // indirect
+	golang.org/x/crypto v0.42.0 // indirect
+	golang.org/x/sync v0.20.0 // indirect
 	modernc.org/libc v1.72.3 // indirect
 	modernc.org/mathutil v1.7.1 // indirect
 	modernc.org/memory v1.11.0 // indirect

go.sum

@@ -8,6 +8,8 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
 github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
+github.com/eclipse/paho.mqtt.golang v1.5.1 h1:/VSOv3oDLlpqR2Epjn1Q7b2bSTplJIeV2ISgCl2W7nE=
+github.com/eclipse/paho.mqtt.golang v1.5.1/go.mod h1:1/yJCneuyOoCOzKSsOTUc0AJfpsItBGWvYpBLimhArU=
 github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
 github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE=
 github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78=
@@ -84,13 +86,13 @@ github.com/wneessen/go-mail v0.7.3 h1:g3DravXC5SMlVdboFrQA8Jx95A8sOzoBeS5F+vzNRK
 github.com/wneessen/go-mail v0.7.3/go.mod h1:QGhBX0yNbc1J+Mkjcu7z2rpj4B4l+BmDY8gYznPC9sk=
 go.bug.st/serial v1.7.1 h1:5aP8wYL0UjEYOVs3oPAGscjaSfRQLHtCvBFXNN/rwtc=
 go.bug.st/serial v1.7.1/go.mod h1:d0MmS16Qt9b1m06yoYRNUXhRRTJV5Qg2S5EKqQtnayQ=
-golang.org/x/crypto v0.33.0 h1:IOBPskki6Lysi0lo9qQvbxiQ+FvsCC/YWOecCHAixus=
-golang.org/x/crypto v0.33.0/go.mod h1:bVdXmD7IV/4GdElGPozy6U7lWdRXA4qyRVGJV57uQ5M=
+golang.org/x/crypto v0.42.0 h1:chiH31gIWm57EkTXpwnqf8qeuMUi0yekh6mT2AvFlqI=
+golang.org/x/crypto v0.42.0/go.mod h1:4+rDnOTJhQCx2q7/j6rAN5XDw8kPjeaXEUR2eL94ix8=
 golang.org/x/mod v0.35.0 h1:Ww1D637e6Pg+Zb2KrWfHQUnH2dQRLBQyAtpr/haaJeM=
 golang.org/x/mod v0.35.0/go.mod h1:+GwiRhIInF8wPm+4AoT6L0FA1QWAad3OMdTRx4tFYlU=
 golang.org/x/net v0.0.0-20210505024714-0287a6fb4125/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.35.0 h1:T5GQRQb2y08kTAByq9L4/bz8cipCdA8FbRTXewonqY8=
-golang.org/x/net v0.35.0/go.mod h1:EglIi67kWsHKlRzzVMUD93VMSWGFOMSZgxFjparz1Qk=
+golang.org/x/net v0.44.0 h1:evd8IRDyfNBMBTTY5XRF1vaZlD+EmWx6x8PkhR04H/I=
+golang.org/x/net v0.44.0/go.mod h1:ECOoLqd5U3Lhyeyo/QDCEVQ4sNgYsqvCZ722XogGieY=
 golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
 golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
 golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=

internal/bandopen/bandopen.go

@@ -36,46 +36,66 @@ type Spot struct {
 type Config struct {
 	Window        time.Duration // how far back a burst may span
 	MinCalls      int           // distinct DX calls before it counts as an opening
-	MinKm, MaxKm  int           // single-hop Es range
+	MinKm, MaxKm  int           // path length accepted; MaxKm 0 = no ceiling
 	BearingSpread int           // widest arc (degrees) the spots may cover
 	Requiet       time.Duration // silence after announcing a band, so it is announced once
 }
 
-// DefaultConfig is the single-hop Es envelope.
+// DefaultConfig is the Es envelope.
 //
-// 500–2400 km: below ~500 km a 6 m contact is ordinary tropo or ground wave and
-// says nothing about the ionosphere; beyond ~2400 km it is no longer one hop, so
-// the bearing test stops meaning anything. 90° of spread because a genuine Es
-// cloud illuminates a sector, not the whole horizon — the constraint that
-// separates an opening from a merely busy evening.
+// Below ~500 km a 6 m contact is ordinary tropo or ground wave and says nothing
+// about the ionosphere, so that floor stays.
+//
+// There is NO ceiling. There used to be one at 2400 km, on the reasoning that
+// past a single hop the bearing test stops meaning anything. That was wrong, and
+// it silently threw away exactly the openings worth hearing about: multi-hop Es
+// is ordinary on 6 m, 5000 km paths are common and 10000 km happens. Those are
+// still directional — a double hop leaves the same sector it entered — so the
+// bearing test holds perfectly well, and it is the test doing the real work here.
+//
+// 90° of spread because a genuine Es cloud illuminates a sector, not the whole
+// horizon: the constraint that separates an opening from a merely busy evening.
 func DefaultConfig() Config {
 	return Config{
 		Window:        12 * time.Minute,
 		MinCalls:      4,
 		MinKm:         500,
-		MaxKm:         2400,
+		MaxKm:         0, // no ceiling — see above
 		BearingSpread: 90,
 		Requiet:       45 * time.Minute,
 	}
 }
 
-// Bands watched. HF is deliberately absent: an "opening" on 20 m is the normal
-// state of the band and announcing it would be noise.
-var watched = map[string]bool{"6m": true, "4m": true, "2m": true}
+// Bands watched.
+//
+// 10 m is in, and it is HF. The line is not "HF versus VHF" but "is an opening
+// here an event": 20 m being open is the normal state of the band and saying so
+// is noise, while 10 m spends most of a solar cycle shut and opens sharply when
+// it goes — which is what an operator wants interrupting them for.
+//
+// 12 m was tried and dropped. It behaves too much like 20 m at this point in the
+// cycle: open often enough that announcing it is a notification rather than
+// news, and every band that cries wolf costs the ones that do not.
+var watched = map[string]bool{"10m": true, "6m": true, "4m": true, "2m": true}
 
 // Watched reports whether a band is one the detector looks at.
 func Watched(band string) bool { return watched[strings.ToLower(strings.TrimSpace(band))] }
 
 // Opening is a detected opening, ready to be announced.
 type Opening struct {
-	Band       string    `json:"band"`
-	Calls      int       `json:"calls"`       // distinct DX stations seen
-	MedianKm   int       `json:"median_km"`   // typical hop length
-	BearingMin int       `json:"bearing_min"` // sector, degrees
-	BearingMax int       `json:"bearing_max"`
-	InSeason   bool      `json:"in_season"` // false = unusual for the time of year
-	At         time.Time `json:"at"`
-	Examples   []string  `json:"examples"` // a few callsigns, for the announcement
+	Band       string `json:"band"`
+	Calls      int    `json:"calls"`       // distinct DX stations seen
+	MedianKm   int    `json:"median_km"`   // typical hop length
+	BearingMin int    `json:"bearing_min"` // sector, degrees
+	BearingMax int    `json:"bearing_max"`
+	// Compass is the sector as a point of the compass ("NE"), computed here so
+	// the UI never has to redo the wrap-round-north arithmetic that Sector()
+	// already gets right — two answers to that question is how a badge ends up
+	// naming the opposite direction.
+	Compass  string    `json:"compass"`
+	InSeason bool      `json:"in_season"` // false = unusual for the time of year
+	At       time.Time `json:"at"`
+	Examples []string  `json:"examples"` // a few callsigns, for the announcement
 }
 
 // Detector keeps the rolling window and the per-band quiet period.
@@ -107,7 +127,7 @@ func (d *Detector) Add(s Spot, lat float64) *Opening {
 	}
 	// Out-of-range spots are dropped rather than stored: they can never be part
 	// of a single-hop detection, and keeping them only grows the window.
-	if s.DistKm < d.cfg.MinKm || s.DistKm > d.cfg.MaxKm {
+	if s.DistKm < d.cfg.MinKm || (d.cfg.MaxKm > 0 && s.DistKm > d.cfg.MaxKm) {
 		return nil
 	}
 	d.recent = append(d.recent, s)
@@ -169,23 +189,90 @@ func evaluate(band string, spots []Spot, cfg Config) *Opening {
 		dists = append(dists, s.DistKm)
 		calls = append(calls, c)
 	}
-	lo, hi, spread := arc(bearings)
-	if spread > cfg.BearingSpread {
-		return nil // spots all round the compass — a busy band, not an opening
+	// The DENSEST sector, not the sector covering everything.
+	//
+	// This used to demand that EVERY station fit inside one 90° arc, which is the
+	// right shape for a sporadic-E cloud and hopeless for anything else. With 10
+	// and 12 m open on F2 the reports come from all round the compass, the arc is
+	// 360°, and the test can never pass — so the busier the band, the less likely
+	// an opening was announced. Backwards.
+	//
+	// Finding the busiest 90° instead keeps the Es signature intact — a cloud
+	// still makes one direction dense — and lets an F2 opening toward South
+	// America be seen through the handful of Europeans that are always there.
+	lo, hi, n := densestSector(bearings, cfg.BearingSpread)
+	if n < cfg.MinCalls {
+		return nil // nothing concentrated anywhere: a busy band, not an opening
 	}
 	sort.Ints(dists)
 	sort.Strings(calls)
 	if len(calls) > 5 {
 		calls = calls[:5]
 	}
-	return &Opening{
+	op := &Opening{
 		Band: band, Calls: len(seen), MedianKm: dists[len(dists)/2],
 		BearingMin: lo, BearingMax: hi, Examples: calls,
 	}
+	op.Compass = compass(midBearing(lo, hi))
+	return op
 }
 
 // arc returns the smallest compass sector containing every bearing, coping with
 // the wrap at north: 350° and 10° are 20° apart, not 340°.
+// densestSector returns the width-degree arc containing the most bearings, as
+// its start, end and count.
+//
+// Brute force over each bearing as a starting edge. n is at most a few hundred
+// distinct callsigns in a twelve-minute window, so n² is nothing, and it runs
+// once per accepted spot rather than once per decode.
+//
+// The arc STARTS on a real bearing rather than sweeping every degree: the
+// densest window can always be slid until its leading edge sits on a station, so
+// nothing is missed and there are 360 fewer positions to try.
+func densestSector(b []int, width int) (lo, hi, count int) {
+	if len(b) == 0 {
+		return 0, 0, 0
+	}
+	s := append([]int(nil), b...)
+	sort.Ints(s)
+	best, bestAt := 0, 0
+	for i, start := range s {
+		n := 0
+		for _, x := range s {
+			// Distance clockwise from start to x, so the wrap through 0° needs no
+			// special case — which is where the old arc() logic earned its keep and
+			// this one has to match it.
+			d := x - start
+			if d < 0 {
+				d += 360
+			}
+			if d <= width {
+				n++
+			}
+		}
+		if n > best {
+			best, bestAt = n, i
+		}
+	}
+	lo = s[bestAt]
+	// The end is the furthest station actually inside the window, not lo+width:
+	// reporting an empty 90° when every station sits in the first 20° would
+	// overstate the opening's width by four times.
+	hi = lo
+	for _, x := range s {
+		d := x - lo
+		if d < 0 {
+			d += 360
+		}
+		if d <= width {
+			if e := (lo + d) % 360; d >= ((hi-lo)+360)%360 {
+				hi = e
+			}
+		}
+	}
+	return lo, hi, best
+}
+
 func arc(b []int) (lo, hi, spread int) {
 	if len(b) == 0 {
 		return 0, 0, 0
@@ -239,10 +326,25 @@ func InSeason(band string, t time.Time, lat float64) bool {
 
 // Sector renders the bearing range for a human, e.g. "NE (35–75°)".
 func (o *Opening) Sector() string {
-	return compass(float64(o.BearingMin+o.BearingMax)/2) +
+	return compass(midBearing(o.BearingMin, o.BearingMax)) +
 		" (" + strconv.Itoa(o.BearingMin) + "–" + strconv.Itoa(o.BearingMax) + "°)"
 }
 
+// midBearing is the middle of the arc running CLOCKWISE from min to max.
+//
+// Not the arithmetic mean, which is wrong for every sector crossing north and
+// wrong by the worst possible amount: an opening reported as 353–61° averaged to
+// 207° and was announced as SW when it was NE — the exact opposite direction, to
+// an operator who might turn a beam on it. The detector itself has handled the
+// 0/360 wrap since it was written; only this label did not.
+func midBearing(min, max int) float64 {
+	span := max - min
+	if span < 0 {
+		span += 360
+	}
+	return math.Mod(float64(min)+float64(span)/2, 360)
+}
+
 func compass(deg float64) string {
 	names := []string{"N", "NE", "E", "SE", "S", "SW", "W", "NW"}
 	i := int(math.Round(deg/45)) % 8

internal/bandopen/bandopen_test.go

@@ -1,6 +1,7 @@
 package bandopen
 
 import (
+	"strings"
 	"testing"
 	"time"
 )
@@ -182,3 +183,128 @@ func TestBearingArcWrapsAtNorth(t *testing.T) {
 		t.Errorf("bearings on all four quadrants should span nearly the circle, got %d", s)
 	}
 }
+
+// Multi-hop must be detected, not thrown away.
+//
+// The detector used to cap paths at 2400 km, on the reasoning that past one hop
+// the bearing test stops meaning anything. Nexus flagged a 6 m opening at
+// 5477 km that OpsLog never saw: the spots were discarded before any test ran.
+// Multi-hop Es is directional — a second hop leaves the sector the first one
+// entered — so distance is not what tells an opening from noise. The sector is.
+func TestMultiHopOpeningIsDetected(t *testing.T) {
+	d := New(DefaultConfig())
+	base := time.Date(2026, 6, 15, 18, 0, 0, 0, time.UTC)
+	var got *Opening
+	for i, call := range []string{"LU1AA", "PY2BB", "LU3CC", "PY4DD"} {
+		if op := d.Add(Spot{
+			Call: call, Band: "6m",
+			DistKm:  5400 + i*40, // double hop, far past the old ceiling
+			Bearing: +i * 5,      // one sector, as a real cloud illuminates
+			At:      base.Add(time.Duration(i) * time.Minute),
+		}, 47.0); op != nil {
+			got = op
+		}
+	}
+	if got == nil {
+		t.Fatal("a four-station 5400 km burst in one sector was not reported as an opening")
+	}
+	if got.Band != "6m" {
+		t.Errorf("band = %q, want 6m", got.Band)
+	}
+}
+
+// The floor stays: a short path says nothing about the ionosphere.
+func TestGroundWaveIsStillIgnored(t *testing.T) {
+	d := New(DefaultConfig())
+	base := time.Date(2026, 6, 15, 18, 0, 0, 0, time.UTC)
+	for i, call := range []string{"F1AA", "F2BB", "F3CC", "F4DD"} {
+		if op := d.Add(Spot{
+			Call: call, Band: "6m", DistKm: 120, Bearing: 90,
+			At: base.Add(time.Duration(i) * time.Minute),
+		}, 47.0); op != nil {
+			t.Fatalf("a 120 km burst was reported as an opening: %+v", op)
+		}
+	}
+}
+
+// A sector crossing north must not be labelled by its opposite.
+//
+// Sector() averaged the two bearings arithmetically, so 353–61° — plainly north
+// — came out as (353+61)/2 = 207°, announced as SW. The worst possible error:
+// not vague, but exactly reversed, to an operator who may turn a beam on it.
+func TestSectorAcrossNorth(t *testing.T) {
+	cases := []struct {
+		min, max int
+		want     string
+	}{
+		{353, 61, "NE"}, // the one seen in the field
+		{303, 11, "NW"}, // the other one
+		{35, 75, "NE"},  // no wrap, unchanged
+		{170, 190, "S"}, // due south, no wrap
+		{340, 20, "N"},  // straddling north evenly
+		{260, 300, "W"}, // due west
+	}
+	for _, c := range cases {
+		o := Opening{BearingMin: c.min, BearingMax: c.max}
+		got := o.Sector()
+		if !strings.HasPrefix(got, c.want+" ") {
+			t.Errorf("Sector(%d–%d°) = %q, want it to start with %q", c.min, c.max, got, c.want)
+		}
+	}
+}
+
+// A band open in one direction must be found THROUGH the everyday noise.
+//
+// The detector used to demand that every station fit inside one 90° arc. On 10
+// and 12 m with F2 open, reports arrive from all round the compass, the arc is
+// 360°, and the test could never pass: the busier the band, the less likely an
+// opening was announced. Reported from the field — 70 000 decodes, 10 and 12 m
+// plainly open, nothing said.
+func TestOpeningFoundThroughAllRoundNoise(t *testing.T) {
+	d := New(DefaultConfig())
+	base := time.Date(2026, 8, 11, 14, 0, 0, 0, time.UTC)
+	// Four stations concentrated to the south-west — the opening.
+	south := []struct {
+		call string
+		deg  int
+	}{{"PY2AA", 220}, {"LU3BB", 228}, {"PY5CC", 235}, {"CX4DD", 240}}
+	// And the usual Europeans scattered everywhere, which is what used to veto it.
+	noise := []struct {
+		call string
+		deg  int
+	}{{"DL1XX", 40}, {"SM2YY", 20}, {"EA3ZZ", 190}, {"UA9QQ", 70}, {"G4WW", 320}}
+
+	var got *Opening
+	for i, s := range noise {
+		d.Add(Spot{Call: s.call, Band: "10m", DistKm: 1200, Bearing: s.deg,
+			At: base.Add(time.Duration(i) * time.Second)}, 47.0)
+	}
+	for i, s := range south {
+		if op := d.Add(Spot{Call: s.call, Band: "10m", DistKm: 9800, Bearing: s.deg,
+			At: base.Add(time.Duration(10+i) * time.Second)}, 47.0); op != nil {
+			got = op
+		}
+	}
+	if got == nil {
+		t.Fatal("an opening concentrated to the SW was not found among stations all round the compass")
+	}
+	mid := midBearing(got.BearingMin, got.BearingMax)
+	if mid < 200 || mid > 260 {
+		t.Errorf("sector middle %.0f° — the reported sector is not the busy one (%d–%d°)",
+			mid, got.BearingMin, got.BearingMax)
+	}
+}
+
+// Stations evenly all round the compass and nothing concentrated: still nothing.
+// The point of the change was to stop requiring global agreement, not to start
+// calling every busy band an opening.
+func TestScatteredBandIsNotAnOpening(t *testing.T) {
+	d := New(DefaultConfig())
+	base := time.Date(2026, 8, 11, 14, 0, 0, 0, time.UTC)
+	for i, deg := range []int{0, 60, 120, 180, 240, 300} {
+		if op := d.Add(Spot{Call: string(rune('A'+i)) + "1AAA", Band: "10m",
+			DistKm: 3000, Bearing: deg, At: base.Add(time.Duration(i) * time.Second)}, 47.0); op != nil {
+			t.Fatalf("evenly scattered stations were called an opening: %+v", op)
+		}
+	}
+}

internal/cat/cat.go

@@ -200,6 +200,31 @@ func (m *Manager) SetPTT(on bool) error {
 	return m.exec(func(b Backend) error { return b.SetPTT(on) })
 }
 
+// splitSetter is implemented by the backends that can arm split AND place the
+// transmit frequency. Both together: arming without setting the dial transmits
+// on whatever the transmit VFO happened to hold, which is worse than refusing.
+type splitSetter interface {
+	SetSplit(on bool, txHz int64) error
+}
+
+// SetSplit arms or clears split on the rig, with the transmit frequency.
+//
+// Returns a plain error on a backend that cannot do it, and that is the point.
+// The shared-CAT server used to answer "done" to WSJT-X's split commands while
+// doing nothing at all — the software then believed it was transmitting up the
+// band when it was transmitting on the DX's own frequency. A refusal WSJT-X can
+// report is worth far more than a success it cannot check.
+func (m *Manager) SetSplit(on bool, txHz int64) error {
+	return m.exec(func(b Backend) error {
+		s, ok := b.(splitSetter)
+		if !ok {
+			return fmt.Errorf("cat: this radio's backend cannot set split from software — " +
+				"use Split Operating: Fake It in WSJT-X/JTDX, or set split on the radio itself")
+		}
+		return s.SetSplit(on, txHz)
+	})
+}
+
 // SpotInfo is one cluster spot to render on a backend that supports a spot
 // overlay (the FlexRadio panadapter). Color is an optional "#AARRGGBB" string;
 // the backend picks a default when it's empty. (Status-based colouring can be

internal/cat/flex.go

@@ -59,15 +59,15 @@ type Flex struct {
 	meterRawLogged bool         // log the first raw meter-definition status once
 	txRawLogged    bool         // log the first raw transmit status once (field-name audit)
 
-	spotsEnabled bool           // push cluster spots + manage the panadapter overlay
-	spotIdx      map[int]bool   // panadapter spot indices currently known to the radio
+	spotsEnabled    bool           // push cluster spots + manage the panadapter overlay
+	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)
 	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
+	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

internal/cat/kenwood.go

@@ -130,8 +130,30 @@ type Kenwood struct {
 	tx        bool
 	txAt      time.Time
 	lastState RigState
+	// ifRejects counts consecutive "?;" answers to IF;. See State().
+	ifRejects int
 }
 
+// errRigRejected marks a "?;" — the rig understood the frame and declined it.
+// Distinct from a serial fault on purpose: one is "ask again in a moment", the
+// other is "the link is gone", and collapsing them is what dropped CAT sharing.
+var errRigRejected = errors.New("rejected by rig")
+
+// ifRejectGrace is how many consecutive "?;" answers to IF; are ridden out
+// before the link is called dead.
+//
+// A Kenwood answers "?;" while it is busy — the tail of a transmission, a menu
+// open on the front panel. The TS-590SG does it for a moment after RX;, which is
+// exactly when the poll resumes: WSJT-X keyed through shared CAT, dropped PTT,
+// and the very next IF; came back "?;". One rejected poll then tore down the
+// whole link, WSJT-X lost the rig, and Hamlib went on to send an uninitialised
+// frequency (2^63) that OpsLog rightly refused — an alarming error message whose
+// real cause was three lines earlier in the log.
+//
+// Three at 250 ms is under a second of tolerance: long enough for the rig to
+// finish whatever it was doing, far too short to hide an unplugged cable.
+const ifRejectGrace = 3
+
 // SetLowerLines chooses whether DTR and RTS are deasserted on connect. Set
 // before Connect.
 func (k *Kenwood) SetLowerLines(v bool) {
@@ -281,8 +303,21 @@ func (k *Kenwood) ReadState() (RigState, error) {
 	}
 	raw, err := k.ask("IF;")
 	if err != nil {
+		// A "?;" is the rig saying "busy", not "gone". Ride out a few and keep
+		// serving the last known state, so the CAT link the digital software keys
+		// through survives the moment after a transmission. A serial fault is NOT
+		// covered: that returns a different error and drops through at once.
+		if errors.Is(err, errRigRejected) && k.lastState.Connected && k.ifRejects < ifRejectGrace {
+			k.ifRejects++
+			debugLog.Printf("kenwood: IF; rejected (%d/%d) — rig busy, keeping the link", k.ifRejects, ifRejectGrace)
+			s := k.lastState
+			s.Connected = true
+			return s, nil
+		}
+		k.ifRejects = 0
 		return RigState{}, err
 	}
+	k.ifRejects = 0
 	f, ok := parseKenwoodIF(raw)
 	if !ok {
 		return RigState{}, fmt.Errorf("kenwood: unparsable IF frame %q", raw)
@@ -342,16 +377,36 @@ func (k *Kenwood) ReadState() (RigState, error) {
 	f.Split = split
 
 	if f.Split {
-		// The transmit VFO is the other one. Read it rather than assume, and fall
-		// back to simplex if it cannot be read: a wrong TX frequency is written
-		// into the log, which is worse than showing no split at all.
+		// The OTHER VFO is the one IF did not report. Read it rather than assume,
+		// and fall back to simplex if it cannot be read: a wrong TX frequency is
+		// written into the log, which is worse than showing no split at all.
 		other := "FB;"
 		if f.VFO == "B" {
 			other = "FA;"
 		}
+		var otherHz int64
 		if r, err := k.ask(other); err == nil {
 			if hz, ok := parseKenwoodFreq(r, strings.TrimSuffix(other, ";")); ok && hz > 0 && hz != rx {
-				tx = hz
+				otherHz = hz
+			}
+		}
+		if otherHz > 0 {
+			// WHICH of the two is the transmit frequency depends on whether the rig
+			// is transmitting RIGHT NOW.
+			//
+			// IF reports the VFO "in use", and in split that is the RECEIVE VFO on
+			// receive and the TRANSMIT VFO on transmit. The code took it as the
+			// receive VFO always, so the moment the operator keyed up the two
+			// frequencies swapped: correct on receive, reversed on transmit, which
+			// is exactly how it was reported from a TS-590 on USB.
+			//
+			// It matters beyond the display. FreqHz is what a QSO is logged on, and
+			// a contact made in split would have gone into the log on the DX's
+			// frequency instead of the operator's.
+			if f.TX {
+				tx, rx = rx, otherHz
+			} else {
+				tx = otherHz
 			}
 		}
 	}
@@ -458,6 +513,43 @@ func isKenwoodDataMode(mode string) bool {
 	return true
 }
 
+// SetSplit arms or clears split, and when arming puts txHz on the transmit VFO.
+//
+// Both halves in one call on purpose. WSJT-X sends "split on, VFO B" and "VFO B
+// to 14075300" as two commands, and honouring only the first is worse than
+// honouring neither: split would arm on whatever VFO B happened to hold, so the
+// operator transmits somewhere they never chose while the software reports
+// exactly what they asked for. Nothing is armed here until the frequency is on
+// the dial.
+//
+// FR selects the receive VFO, FT the transmit one — the same pair the poll loop
+// already reads to detect split, so this writes what State() knows how to read.
+func (k *Kenwood) SetSplit(on bool, txHz int64) error {
+	k.mu.Lock()
+	defer k.mu.Unlock()
+	if k.port == nil {
+		return fmt.Errorf("kenwood: not connected")
+	}
+	if !on {
+		// Transmit follows receive again. FR is left alone: which VFO the operator
+		// listens on is theirs to choose, and clearing split should not move them.
+		return k.write("FT0;")
+	}
+	if txHz <= 0 || txHz > 99_999_999_999 {
+		return fmt.Errorf("kenwood: split TX frequency %d out of the 11-digit CAT range", txHz)
+	}
+	// The transmit dial FIRST, then arm. Arming first would transmit on the old
+	// contents of VFO B for however long the next command takes to arrive — brief,
+	// but on the wrong frequency, and this runs the instant before a transmission.
+	if err := k.write(fmt.Sprintf("FB%011d;", txHz)); err != nil {
+		return err
+	}
+	if err := k.write("FR0;"); err != nil { // receive on A
+		return err
+	}
+	return k.write("FT1;") // transmit on B
+}
+
 func (k *Kenwood) SetPTT(on bool) error {
 	k.mu.Lock()
 	defer k.mu.Unlock()
@@ -524,6 +616,10 @@ func (k *Kenwood) ask(cmd string) (string, error) {
 			k.rx = k.rx[i+1:]
 			traceText("kenwood", "RX", frame)
 			if frame == "?;" {
+				// Sentinel-wrapped so the poll loop can tell "the rig said no" apart
+				// from a serial fault. The two look identical as plain errors and must
+				// not be handled the same way: one means try again in a moment, the
+				// other means the link is gone.
 				// IF; and ID; are universal on Kenwood/Elecraft — a "?;" to them is a
 				// transient "busy" (typically mid-transmit, or a menu open on the rig),
 				// NOT "unsupported". Latching them off would blind the poll loop for
@@ -533,7 +629,7 @@ func (k *Kenwood) ask(cmd string) (string, error) {
 					k.unsupported[want] = true
 					debugLog.Printf("kenwood: this rig does not support %q — not asking again", cmd)
 				}
-				return "", fmt.Errorf("kenwood: %s rejected", want)
+				return "", fmt.Errorf("kenwood: %s rejected: %w", want, errRigRejected)
 			}
 			if strings.HasPrefix(frame, want) {
 				return frame, nil

internal/cat/kenwood_cw.go

@@ -29,7 +29,30 @@ const kenwoodCWChunk = 24
 
 // kenwoodCWAllowed is what the keyer can send; anything else is dropped, since an
 // unsupported byte can abort the buffer and lose the rest of the message.
-const kenwoodCWAllowed = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 /?.,-=+:;()"
+// The semicolon is deliberately absent: it TERMINATES a CAT frame. The TS-590
+// manual says so outright for P2, and one in a macro would close the command
+// early and leave the rest of the text to be read as commands of its own.
+const kenwoodCWAllowed = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 /?.,-=+:()"
+
+// padCW pads a piece to the fixed 24-character P2 a Kenwood demands.
+//
+// This is where CW over CAT failed on a TS-590SG. The KY command was written
+// against Elecraft's, which takes a variable-length string, so "KY OH5CX;" went
+// out and the radio answered "?;" — read as "this rig refuses CW over CAT", and
+// the operator was told to go and buy a serial keyer.
+//
+// The TS-590 manual is explicit: P2 has a FIXED length of 24, and characters
+// left blank are filled with spaces which are NOT keyed. So the padding costs
+// nothing on air — it is simply the shape the command has to have.
+//
+// Elecraft is left variable-length: it accepts short strings, and padding there
+// would key the trailing spaces as word gaps.
+func (k *Kenwood) padCW(chunk string) string {
+	if k.elecraft || len(chunk) >= kenwoodCWChunk {
+		return chunk
+	}
+	return chunk + strings.Repeat(" ", kenwoodCWChunk-len(chunk))
+}
 
 // SendCW queues a message on the rig's keyer, fed in 24-character pieces, waiting
 // for buffer room between pieces so a long macro doesn't lose its tail.
@@ -51,7 +74,7 @@ func (k *Kenwood) SendCW(text string) error {
 		chunk := msg[:n]
 		msg = msg[n:]
 		k.waitCWBuffer(3 * time.Second)
-		if err := k.write("KY " + chunk + ";"); err != nil {
+		if err := k.write("KY " + k.padCW(chunk) + ";"); err != nil {
 			return err
 		}
 		if err := k.afterKY(); err != nil {

internal/cat/kenwood_cw_test.go

@@ -0,0 +1,42 @@
+package cat
+
+import (
+	"strings"
+	"testing"
+)
+
+// The TS-590 wants a FIXED 24-character P2. Sending the bare text is what made
+// CW over CAT fail on a real TS-590SG: "KY OH5CX;" came back "?;", which OpsLog
+// reported as "this radio rejected CW over CAT" and sent the operator off to buy
+// a serial keyer he did not need.
+func TestKenwoodCWPadsToTheFixedWidth(t *testing.T) {
+	k := &Kenwood{}
+	got := k.padCW("OH5CX")
+	if len(got) != kenwoodCWChunk {
+		t.Errorf("padCW(%q) is %d chars, want exactly %d — the rig rejects anything else",
+			"OH5CX", len(got), kenwoodCWChunk)
+	}
+	if got[:5] != "OH5CX" || strings.TrimRight(got, " ") != "OH5CX" {
+		t.Errorf("padCW = %q — the text must be intact and the rest spaces", got)
+	}
+	// A full piece is already the right width and must not grow.
+	full := strings.Repeat("A", kenwoodCWChunk)
+	if k.padCW(full) != full {
+		t.Error("a full 24-character piece was padded further")
+	}
+
+	// Elecraft takes variable length, and padding there would key the trailing
+	// spaces as word gaps.
+	e := &Kenwood{elecraft: true}
+	if e.padCW("OH5CX") != "OH5CX" {
+		t.Errorf("Elecraft piece was padded: %q", e.padCW("OH5CX"))
+	}
+}
+
+// ";" terminates a CAT frame. The manual forbids it in P2, and one arriving in a
+// macro would close the command early and leave the rest to be read as commands.
+func TestKenwoodCWDropsTheSemicolon(t *testing.T) {
+	if got := filterKenwoodCW("CQ; DE OH5CX"); strings.Contains(got, ";") {
+		t.Errorf("filterKenwoodCW kept a semicolon: %q", got)
+	}
+}

internal/cat/kenwood_loopback_test.go

@@ -108,6 +108,9 @@ type ts2000 struct {
 	mode       byte
 	onB        bool
 	split      bool
+	// tx models the rig KEYED. On a real Kenwood in split, IF then reports the
+	// TRANSMIT VFO as the one in use — which is the whole point of the test below.
+	tx bool
 	// lazyIF models a rig that answers FR/FT correctly but never fills IF's
 	// split bit — the behaviour reported on a Flex through its Kenwood CAT
 	// emulation, where the frequency reads perfectly and split never appears.
@@ -138,8 +141,12 @@ func (r *ts2000) answer(cmd string) string {
 		}
 		// The catemu layout: IF | freq(11) | step(4) | RIT(±5) | 3 | mem(2) |
 		// rx/tx | mode | VFO | scan | split | tone | tone#(2) | shift | ;
+		txByte := 0
+		if r.tx {
+			txByte = 1
+		}
 		return fmt.Sprintf("IF%011d%04d%+06d%03d%02d%01d%c%c%01d%c%01d%02d%01d;",
-			cur, 0, 0, 0, 0, 0, r.mode, vfoDigit, 0, split, 0, 0, 0)
+			cur, 0, 0, 0, 0, txByte, r.mode, vfoDigit, 0, split, 0, 0, 0)
 	case strings.HasPrefix(cmd, "FA") && len(cmd) > 3:
 		fmt.Sscanf(cmd, "FA%d;", &r.vfoA)
 		return ""
@@ -174,6 +181,19 @@ func dialTo(rig *ts2000) func() (serial.Port, error) {
 	}
 }
 
+// dialToBusy is dialTo with a hook that makes the rig answer "?;" instead —
+// what a real Kenwood does while it is busy, rather than staying silent.
+func dialToBusy(rig *ts2000, busy func(cmd string) bool) func() (serial.Port, error) {
+	return func() (serial.Port, error) {
+		return &fakeSerial{toRig: &strings.Builder{}, answer: func(cmd string) string {
+			if busy(cmd) {
+				return "?;"
+			}
+			return rig.answer(cmd)
+		}}, nil
+	}
+}
+
 func TestKenwoodAgainstEmulatedRig(t *testing.T) {
 	rig := &ts2000{vfoA: 14250000, vfoB: 14260000, mode: '2'} // 20 m USB
 	k := NewKenwood("COM-TEST", 9600, "FT8")
@@ -383,3 +403,103 @@ func TestKenwoodNoisyRigIsReportedAsNoiseNotSilence(t *testing.T) {
 		t.Errorf("error was %q — it should say data arrived, and quote it", err)
 	}
 }
+
+// A "?;" to IF; must not tear the link down.
+//
+// The TS-590SG answers "?;" for a moment after coming out of transmit, which is
+// exactly when the poll resumes. In the field that single rejected poll dropped
+// the whole CAT link: WSJT-X, keying through shared CAT, lost the rig, and
+// Hamlib then sent an uninitialised frequency (2^63) that OpsLog refused — an
+// alarming error whose real cause was three lines earlier.
+func TestKenwoodBusyRigKeepsTheLink(t *testing.T) {
+	rig := &ts2000{vfoA: 14250000, vfoB: 14260000, mode: '2'}
+	busy := 0
+	k := NewKenwood("COM-TEST", 9600, "FT8")
+	k.dialPort = dialToBusy(rig, func(cmd string) bool {
+		if strings.HasPrefix(cmd, "IF") && busy > 0 {
+			busy--
+			return true
+		}
+		return false
+	})
+	if err := k.Connect(); err != nil {
+		t.Fatalf("connect: %v", err)
+	}
+	defer k.Disconnect()
+
+	// One good read establishes the state the busy window will keep serving.
+	first, err := k.ReadState()
+	if err != nil || !first.Connected {
+		t.Fatalf("first read: %+v err=%v", first, err)
+	}
+
+	// Inside the grace: still connected, still reporting the last good frequency.
+	busy = ifRejectGrace
+	for i := 1; i <= ifRejectGrace; i++ {
+		s, err := k.ReadState()
+		if err != nil {
+			t.Fatalf("reject %d dropped the link: %v", i, err)
+		}
+		if !s.Connected || s.FreqHz != first.FreqHz {
+			t.Errorf("reject %d gave %+v — want the last good state, still connected", i, s)
+		}
+	}
+
+	// The rig answers again → the tolerance resets, so a later busy spell gets
+	// the full allowance instead of inheriting the previous one.
+	if s, err := k.ReadState(); err != nil || !s.Connected {
+		t.Fatalf("recovery read failed: %+v err=%v", s, err)
+	}
+
+	// Past the grace, a persistent refusal IS a fault and must surface.
+	busy = ifRejectGrace + 1
+	var lastErr error
+	for i := 0; i <= ifRejectGrace; i++ {
+		if _, lastErr = k.ReadState(); lastErr != nil {
+			break
+		}
+	}
+	if lastErr == nil {
+		t.Error("a rig refusing IF; forever was still reported as healthy")
+	}
+}
+
+// In split, the two frequencies must not swap the moment the operator keys up.
+//
+// IF reports the VFO "in use", and in split that is the RECEIVE VFO on receive
+// and the TRANSMIT VFO on transmit. The backend took it as the receive VFO
+// always, so everything read correctly until the PTT closed and then reversed —
+// reported from a TS-590 on USB.
+//
+// It matters beyond the display: FreqHz is what a QSO is LOGGED on, so a split
+// contact would have been logged on the DX's frequency instead of the operator's.
+func TestKenwoodSplitDoesNotSwapOnTransmit(t *testing.T) {
+	rig := &ts2000{vfoA: 14200000, vfoB: 14205000, mode: '2', split: true}
+	k := NewKenwood("COM-TEST", 9600, "FT8")
+	k.dialPort = dialTo(rig)
+	if err := k.Connect(); err != nil {
+		t.Fatalf("connect: %v", err)
+	}
+	defer k.Disconnect()
+
+	// Receiving: IF reports VFO A, the receive dial.
+	s, err := k.ReadState()
+	if err != nil {
+		t.Fatalf("read on receive: %v", err)
+	}
+	if !s.Split || s.FreqHz != 14205000 || s.RxFreqHz != 14200000 {
+		t.Fatalf("on receive: split=%v tx=%d rx=%d — want tx 14205000, rx 14200000",
+			s.Split, s.FreqHz, s.RxFreqHz)
+	}
+
+	// Keyed: the rig switches to the transmit VFO and sets IF's TX byte.
+	rig.onB, rig.tx = true, true
+	s, err = k.ReadState()
+	if err != nil {
+		t.Fatalf("read on transmit: %v", err)
+	}
+	if s.FreqHz != 14205000 || s.RxFreqHz != 14200000 {
+		t.Errorf("on transmit: tx=%d rx=%d — the two swapped; want tx 14205000, rx 14200000",
+			s.FreqHz, s.RxFreqHz)
+	}
+}

internal/cat/kenwood_test.go

@@ -102,7 +102,7 @@ func TestKenwoodModeDigit(t *testing.T) {
 		{"FM", 145000000, '4'},
 		{"FT8", 7074000, '2'},  // data is ALWAYS USB, even below 10 MHz (K3 "DATA REV" otherwise)
 		{"FT8", 14074000, '2'}, // …and above
-		{"", 14074000, 0}, // nothing to set
+		{"", 14074000, 0},      // nothing to set
 	}
 	for _, c := range cases {
 		if got := kenwoodModeDigit(c.mode, c.hz); got != c.want {

internal/extsvc/clublog.go

@@ -27,6 +27,19 @@ const clublogBatchURL = "https://clublog.org/putlogs.php"
 // must send a real, app-identifying User-Agent.
 const clublogUserAgent = "OpsLog/1.0 (+https://github.com/GregTroar/OpsLog)"
 
+// looksLikeHTML reports a body that is a web page rather than an answer. Club
+// Log serves its normal site for refusals and blocks, so this is what separates
+// "here is what went wrong" from 4 KB of markup an operator cannot act on.
+func looksLikeHTML(s string) bool {
+	l := strings.ToLower(strings.TrimSpace(s))
+	return strings.HasPrefix(l, "<!doctype html") || strings.HasPrefix(l, "<html")
+}
+
+// clublogDownloadURL is Club Log's ADIF export. Used ONLY to verify credentials
+// (see TestClublog): it is the one authenticated endpoint that cannot change
+// anything in the operator's log, which is what a test button must never do.
+const clublogDownloadURL = "https://clublog.org/getadif.php"
+
 // clublogAppAPIKey is OpsLog's Club Log *application* API key. Club Log
 // requires an api parameter that identifies the client software (not the
 // user) — the same way Log4OM embeds its own key — so we ship it baked in
@@ -204,17 +217,84 @@ func stripHTMLBrief(s string) string {
 // TestClublog validates the configured credentials by attempting a no-op
 // style check. Club Log has no dedicated status endpoint, so we report the
 // fields look complete; a real failure surfaces on the first upload.
+// TestClublog checks the credentials against Club Log, not against themselves.
+//
+// It used to verify that the three fields were non-empty and then report
+// "Ready — <call> via <email>". Nothing was sent anywhere, so a wrong password
+// produced exactly the same green message as a right one. That is worse than
+// having no button: it is confidence the test never earned, and it cost an
+// operator the one moment they were actually looking for the problem.
+//
+// The download endpoint is used because it is READ-ONLY: testing a password
+// must not put a record into someone's log. Club Log answers a rejected login
+// with 403 before sending any body, so the answer arrives immediately; on
+// success the body is a log, and we read a few bytes and hang up rather than
+// pull it down to prove a point.
 func TestClublog(ctx context.Context, cfg ServiceConfig) (string, error) {
-	_ = ctx
+	email := strings.TrimSpace(cfg.Email)
+	call := strings.ToUpper(strings.TrimSpace(cfg.Callsign))
 	switch {
-	case strings.TrimSpace(cfg.Email) == "":
+	case email == "":
 		return "", fmt.Errorf("clublog: account email not set")
 	case cfg.Password == "":
 		return "", fmt.Errorf("clublog: password not set")
-	case strings.TrimSpace(cfg.Callsign) == "":
+	case call == "":
 		return "", fmt.Errorf("clublog: logbook callsign not set")
 	}
-	return fmt.Sprintf("Ready — %s via %s", strings.ToUpper(strings.TrimSpace(cfg.Callsign)), strings.TrimSpace(cfg.Email)), nil
+
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
+	defer cancel()
+
+	form := url.Values{}
+	form.Set("email", email)
+	form.Set("password", cfg.Password)
+	form.Set("call", call)
+	// No date filter. A "startyear=2099" was tried to keep the reply small, but
+	// Club Log answers an unrecognised request with the SAME 403 it uses for a
+	// refused login — so an unverified parameter would have made every correct
+	// password look wrong, which is the failure this whole change exists to end.
+	// The reply is capped at 4 KB and the body closed immediately instead; the
+	// status code arrives before any of it.
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, clublogDownloadURL, strings.NewReader(form.Encode()))
+	if err != nil {
+		return "", fmt.Errorf("clublog: build request: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	req.Header.Set("User-Agent", clublogUserAgent)
+
+	resp, err := (&http.Client{Timeout: 30 * time.Second}).Do(req)
+	if err != nil {
+		return "", fmt.Errorf("clublog: could not reach Club Log: %w", err)
+	}
+	defer resp.Body.Close()
+	body, _ := io.ReadAll(io.LimitReader(resp.Body, 4096))
+	msg := strings.TrimSpace(string(body))
+
+	switch resp.StatusCode {
+	case http.StatusOK:
+		return fmt.Sprintf("Ready — %s via %s (Club Log accepted the login)", call, email), nil
+	case http.StatusUnauthorized, http.StatusForbidden:
+		// Club Log refuses with its ordinary web page, not an error string, so the
+		// body is 4 KB of markup that says nothing to an operator. It goes to the
+		// log — that is where a real diagnosis happens — and the message says the
+		// one thing there is to do about it.
+		LogSink("clublog: login refused (http %d), body: %s", resp.StatusCode, msg)
+		return "", fmt.Errorf("Club Log refused the login — check the account e-mail, " +
+			"the password and the logbook callsign. They are the Club Log website's own credentials")
+	default:
+		LogSink("clublog: unexpected http %d, body: %s", resp.StatusCode, msg)
+		if looksLikeHTML(msg) {
+			return "", fmt.Errorf("clublog: Club Log answered with a web page (http %d) instead of a log — see the log file", resp.StatusCode)
+		}
+		if len(msg) > 200 {
+			msg = msg[:200] + "…"
+		}
+		return "", fmt.Errorf("clublog: http %d %s", resp.StatusCode, msg)
+	}
 }
 
 // clublogPost performs the form POST and maps the HTTP status to a result.

internal/extsvc/clublog_test.go

@@ -0,0 +1,26 @@
+package extsvc
+
+import "testing"
+
+// Club Log answers a refused login with its ordinary web page. The operator must
+// get a sentence they can act on, not four kilobytes of markup — that was the
+// first thing reported once the test started working at all.
+func TestLooksLikeHTML(t *testing.T) {
+	cases := []struct {
+		body string
+		want bool
+	}{
+		{"<!DOCTYPE html>\n<html lang='en'>…403 - Access denied…", true},
+		{"  <html><head><title>403</title></head></html>", true},
+		{"<HTML>", true},
+		{"Invalid credentials", false},
+		{"", false},
+		// An ADIF answer must never be mistaken for a page.
+		{"<eoh>\n<call:5>F4BPO <band:3>20m <eor>", false},
+	}
+	for _, c := range cases {
+		if got := looksLikeHTML(c.body); got != c.want {
+			t.Errorf("looksLikeHTML(%.40q) = %v, want %v", c.body, got, c.want)
+		}
+	}
+}

internal/extsvc/lotw.go

@@ -277,10 +277,33 @@ func TestLoTW(cfg ServiceConfig, stationDataPath string) (string, error) {
 	if err != nil {
 		return "", fmt.Errorf("lotw: can't read station locations: %w", err)
 	}
+	found := ""
 	for _, l := range locs {
 		if strings.EqualFold(l.Name, loc) {
-			return fmt.Sprintf("Ready — TQSL found, location %q (%s)", l.Name, l.Call), nil
+			found = l.Call
+			break
 		}
 	}
-	return "", fmt.Errorf("lotw: station location %q not found in TQSL", loc)
+	if found == "" {
+		return "", fmt.Errorf("lotw: station location %q not found in TQSL", loc)
+	}
+
+	// LoTW is TWO credentials doing two jobs, and the button used to report only
+	// the first. Uploading goes through TQSL and is signed by the certificate —
+	// the website password is never involved, so a wrong one breaks nothing until
+	// the day confirmations are downloaded and nobody connects the two events.
+	//
+	// So the download login is tested separately, and said separately. A future
+	// "since" date makes LoTW return an empty report rather than the whole
+	// account: the credentials are what is being checked, not the log.
+	up := fmt.Sprintf("Ready — TQSL found, location %q (%s)", loc, found)
+	if strings.TrimSpace(cfg.Username) == "" || cfg.Password == "" {
+		return up + ". Download login not set — confirmations cannot be fetched.", nil
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+	if _, err := DownloadLoTWConfirmations(ctx, nil, cfg, "2099-01-01", ""); err != nil {
+		return "", fmt.Errorf("%s — but the DOWNLOAD login failed: %w", up, err)
+	}
+	return up + ". Download login accepted.", nil
 }

internal/integrations/udp/config.go

@@ -41,16 +41,16 @@ const (
 
 // Config is one user-defined UDP connection.
 type Config struct {
-	ID             int64     `json:"id"`
-	Direction      Direction `json:"direction"`
-	Name           string    `json:"name"`
-	Port           int       `json:"port"`
+	ID             int64       `json:"id"`
+	Direction      Direction   `json:"direction"`
+	Name           string      `json:"name"`
+	Port           int         `json:"port"`
 	ServiceType    ServiceType `json:"service_type"`
-	Multicast      bool      `json:"multicast"`
-	MulticastGroup string    `json:"multicast_group"`
-	DestinationIP  string    `json:"destination_ip"` // outbound only
-	Enabled        bool      `json:"enabled"`
-	SortOrder      int       `json:"sort_order"`
+	Multicast      bool        `json:"multicast"`
+	MulticastGroup string      `json:"multicast_group"`
+	DestinationIP  string      `json:"destination_ip"` // outbound only
+	Enabled        bool        `json:"enabled"`
+	SortOrder      int         `json:"sort_order"`
 }
 
 // Repo is the persistence layer for UDP integration rows.

internal/integrations/udp/n1mm_test.go

@@ -37,19 +37,19 @@ func TestParseN1MMContactInfo(t *testing.T) {
 		t.Fatal("expected a loggable contact, got ok=false")
 	}
 	want := map[string]string{
-		"<call:5>VE9AA":     "callsign",
+		"<call:5>VE9AA":        "callsign",
 		"<qso_date:8>20240315": "date",
-		"<time_on:6>142530": "time",
-		"<band:3>20m":       "band",
-		"<mode:2>CW":        "mode",
-		"<freq:9>14.025000": "freq",
-		"<rst_sent:3>599":   "rst sent",
-		"<rst_rcvd:3>599":   "rst rcvd",
-		"<gridsquare:4>FN65": "grid",
-		"<name:4>Mike":      "name",
-		"<stx:1>1":          "stx serial",
-		"<srx:2>42":         "srx serial",
-		"<eor>":             "terminator",
+		"<time_on:6>142530":    "time",
+		"<band:3>20m":          "band",
+		"<mode:2>CW":           "mode",
+		"<freq:9>14.025000":    "freq",
+		"<rst_sent:3>599":      "rst sent",
+		"<rst_rcvd:3>599":      "rst rcvd",
+		"<gridsquare:4>FN65":   "grid",
+		"<name:4>Mike":         "name",
+		"<stx:1>1":             "stx serial",
+		"<srx:2>42":            "srx serial",
+		"<eor>":                "terminator",
 	}
 	for sub, label := range want {
 		if !strings.Contains(adif, sub) {

internal/integrations/udp/wsjt.go

@@ -287,11 +287,18 @@ func wsjtSender(message string) (call string, isCQ bool, grid string) {
 		if len(f) > 2 && !looksLikeCall(f[1]) {
 			idx = 2
 		}
-		if idx < len(f) && looksLikeCall(f[idx]) {
-			if idx+1 < len(f) && isGridField(f[idx+1]) {
-				grid = f[idx+1]
+		if idx < len(f) {
+			c := f[idx]
+			// A GRID sitting in the callsign slot means the real call was
+			// unparseable and the skip above went one word too far. JN36 has letters
+			// and digits and passes every shape test there is, so without this the
+			// station's grid gets logged, spotted and coloured as its callsign.
+			if looksLikeCall(c) && !isGridField(c) {
+				if idx+1 < len(f) && isGridField(f[idx+1]) {
+					grid = f[idx+1]
+				}
+				return c, true, grid
 			}
-			return f[idx], true, grid
 		}
 		return "", true, ""
 	}

internal/integrations/udp/wsjt_sender_test.go

@@ -24,6 +24,9 @@ func TestWSJTSender(t *testing.T) {
 		{"CQ K1ABC FN42AB", "K1ABC", true, ""},         // 6-char: WSJT-X never sends it here
 		{"CQ K1ABC 73", "K1ABC", true, ""},             // bare sign-off
 		{"CQ K1ABC SS42", "K1ABC", true, ""},           // S is past R — no such field
+		// An unknown word after CQ made the parser skip a slot; a grid passes every
+		// shape test a callsign does, so it came back AS the callsign.
+		{"CQ FOO JN36", "", true, ""},
 		// Non-callsign / free text → no sender.
 		{"TNX 73 GL", "", false, ""},
 		{"K1ABC RR73", "", false, ""}, // only one call + a token → 2nd token not a call

internal/pskr/pskr.go

@@ -0,0 +1,264 @@
+// Package pskr subscribes to PSK Reporter's MQTT feed and turns it into the
+// spots the band-opening detector already eats.
+//
+// Why this exists at all: the detector was fed from the DX cluster and the RBN,
+// and on VHF that is a few hundred skimmers, nearly all of them on HF. A 6 m
+// opening carrying 869 stations reached OpsLog as a handful of spots, or none.
+// PSK Reporter is every ordinary station running WSJT-X and reporting what it
+// decodes — the difference is two orders of magnitude, not a threshold.
+//
+// The feed's shape happens to suit us exactly:
+//
+//	topic   pskr/filter/v2/<band>/<mode>/<tx call>/<rx call>/...
+//	payload {"f":50313000,"md":"FT8","rp":-12,"sc":"F4BPO","sl":"JN36",
+//	         "rc":"OH5CX","rl":"KP30","b":"6m"}
+//
+// BOTH grids are in the message, so distance and bearing are arithmetic. No
+// lookup, no DXCC-centre approximation, no extra network call — which is what
+// made the cluster path's bearings coarse.
+//
+// Volume is the real design constraint. Six metres open is thousands of
+// messages a minute, and OpsLog runs on some very old PCs. So: no history is
+// kept here, nothing is persisted, each message is parsed and handed on or
+// dropped, and the callback does the deciding.
+package pskr
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+	"sync"
+	"time"
+
+	mqtt "github.com/eclipse/paho.mqtt.golang"
+)
+
+// DefaultBroker is PSK Reporter's public MQTT endpoint, TLS.
+const DefaultBroker = "tls://mqtt.pskreporter.info:1884"
+
+// DefaultNearKm is the radius that counts as "around here" for a receiver.
+const DefaultNearKm = 300
+
+// Bands offered. Anything below 10 m is deliberately absent, 12 m included: an
+// "opening" on 20 m is the normal state of the band and announcing it says
+// nothing, and 12 m is close enough to that at this point in the cycle to be the
+// same problem. These are the bands where an opening is an event.
+//
+// Fewer subscriptions is also less traffic, which matters here: the operator's
+// PC pays for every message the broker sends, whether or not anything comes of it.
+var Bands = []string{"10m", "6m", "4m", "2m"}
+
+// Spot is one decode, already reduced to what a detector needs.
+type Spot struct {
+	Call    string // the transmitting station
+	Band    string
+	Mode    string
+	Grid    string // transmitter's grid, 4 characters
+	DistKm  int    // from the operator
+	Bearing int    // degrees from the operator, short path
+	At      time.Time
+}
+
+// Config is what the watcher needs to run.
+type Config struct {
+	Broker string
+	Bands  []string
+	// OpLat/OpLon are the operator's position: every spot is measured from it,
+	// so with no position there is nothing to measure and the watcher stays down.
+	OpLat, OpLon float64
+	// NearKm is how close a RECEIVER must be to count as "around here". A report
+	// collected further away proves a path that is not the operator's.
+	//
+	// 300 km by default: far enough to borrow the ears of a whole region, which
+	// is the point — an opening reaches an area, not a postcode, and waiting for
+	// a decode at one's own station is just working the band. Close enough that
+	// the ionosphere doing something there is the ionosphere doing it here.
+	NearKm int
+	// Geo turns two grids into distance and bearing. Injected rather than
+	// implemented here so it stays the SAME arithmetic the cluster path uses —
+	// two answers for one question is how a bearing quietly becomes wrong.
+	Geo func(grid string) (distKm int, bearing int, ok bool)
+	// OnSpot receives every accepted decode. Called from the MQTT goroutine, so
+	// it must not block: the broker's buffer is what pays for it if it does.
+	OnSpot func(Spot)
+	Logf   func(string, ...any)
+}
+
+// Watcher owns the MQTT connection and its subscriptions.
+type Watcher struct {
+	mu      sync.Mutex
+	cfg     Config
+	client  mqtt.Client
+	running bool
+
+	// received counts accepted spots since start, for the status panel: a
+	// connection that is up but silent looks identical to one that is working
+	// until you can see a number moving.
+	received uint64
+	lastAt   time.Time
+	lastErr  string
+}
+
+func New(cfg Config) *Watcher {
+	if cfg.Broker == "" {
+		cfg.Broker = DefaultBroker
+	}
+	if len(cfg.Bands) == 0 {
+		cfg.Bands = Bands
+	}
+	if cfg.NearKm <= 0 {
+		cfg.NearKm = DefaultNearKm
+	}
+	if cfg.Logf == nil {
+		cfg.Logf = func(string, ...any) {}
+	}
+	return &Watcher{cfg: cfg}
+}
+
+// Start connects and subscribes. Safe to call when already running.
+func (w *Watcher) Start() error {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	if w.running {
+		return nil
+	}
+	if w.cfg.Geo == nil || w.cfg.OnSpot == nil {
+		return fmt.Errorf("pskr: Geo and OnSpot are required")
+	}
+
+	opts := mqtt.NewClientOptions().
+		AddBroker(w.cfg.Broker).
+		// A stable client id would collide with another OpsLog on the same
+		// account; the broker is anonymous, so uniqueness is ours to provide.
+		SetClientID(fmt.Sprintf("opslog-%d", time.Now().UnixNano())).
+		SetCleanSession(true).
+		SetAutoReconnect(true).
+		SetConnectRetry(true).
+		SetConnectRetryInterval(30 * time.Second).
+		SetConnectTimeout(15 * time.Second).
+		// No message is worth keeping if we cannot handle it now: an opening is
+		// a thing happening at this moment, and a queue of stale decodes would
+		// announce one that finished twenty minutes ago.
+		SetOrderMatters(false)
+
+	opts.OnConnect = func(c mqtt.Client) {
+		w.cfg.Logf("pskr: connected to %s", w.cfg.Broker)
+		for _, b := range w.cfg.Bands {
+			// Every mode, every pair of stations, on this band. That firehose IS
+			// the point: the detector's job is to find the shape in it.
+			topic := "pskr/filter/v2/" + b + "/#"
+			if tok := c.Subscribe(topic, 0, w.handle); tok.Wait() && tok.Error() != nil {
+				w.cfg.Logf("pskr: subscribe %s failed: %v", topic, tok.Error())
+				continue
+			}
+			w.cfg.Logf("pskr: watching %s", topic)
+		}
+	}
+	opts.OnConnectionLost = func(_ mqtt.Client, err error) {
+		w.mu.Lock()
+		w.lastErr = err.Error()
+		w.mu.Unlock()
+		w.cfg.Logf("pskr: connection lost: %v (will retry)", err)
+	}
+
+	c := mqtt.NewClient(opts)
+	// Deliberately NOT waiting on the connect token: the broker may be slow or
+	// unreachable and startup must not hang on a feature that is decoration.
+	// ConnectRetry brings it up in the background when it can.
+	c.Connect()
+	w.client = c
+	w.running = true
+	return nil
+}
+
+// Stop disconnects. Safe to call when already stopped.
+func (w *Watcher) Stop() {
+	w.mu.Lock()
+	c, running := w.client, w.running
+	w.client, w.running = nil, false
+	w.mu.Unlock()
+	if running && c != nil {
+		c.Disconnect(250)
+	}
+}
+
+// wire is the payload as PSK Reporter sends it — short keys, no nesting.
+type wire struct {
+	Freq   int64  `json:"f"`
+	Mode   string `json:"md"`
+	SNR    int    `json:"rp"`
+	TxCall string `json:"sc"`
+	TxGrid string `json:"sl"`
+	RxCall string `json:"rc"`
+	RxGrid string `json:"rl"`
+	Band   string `json:"b"`
+}
+
+func (w *Watcher) handle(_ mqtt.Client, m mqtt.Message) {
+	var p wire
+	if err := json.Unmarshal(m.Payload(), &p); err != nil {
+		return // malformed payloads are not worth a log line at this rate
+	}
+	call := strings.ToUpper(strings.TrimSpace(p.TxCall))
+	grid := strings.ToUpper(strings.TrimSpace(p.TxGrid))
+	rxGrid := strings.ToUpper(strings.TrimSpace(p.RxGrid))
+	if call == "" || len(grid) < 4 || len(rxGrid) < 4 {
+		return
+	}
+
+	// THE RECEIVER HAS TO BE NEAR THE OPERATOR. This is the whole difference
+	// between a useful feed and a world map.
+	//
+	// A PSK Reporter message says "X was heard BY Y". Without this check, a
+	// station 1400 km from here heard by somebody in Japan counted as evidence
+	// of an opening — it proves the path from X to JAPAN, and says nothing at all
+	// about whether anything reaches this station. That is how a "2 m opening"
+	// came to be announced from a KX9X in the United States.
+	//
+	// Only reports collected by a receiver in the operator's own region show that
+	// signals are actually arriving HERE, which is the only question worth asking.
+	if rxDist, _, ok := w.cfg.Geo(rxGrid[:4]); !ok || rxDist > w.cfg.NearKm {
+		return
+	}
+
+	// The TRANSMITTER is the station on the air, so it is the transmitter's grid
+	// that gives the direction and length of the path that just proved itself.
+	dist, brg, ok := w.cfg.Geo(grid[:4])
+	if !ok {
+		return
+	}
+	s := Spot{
+		Call: call, Band: strings.ToLower(strings.TrimSpace(p.Band)),
+		Mode: strings.ToUpper(strings.TrimSpace(p.Mode)), Grid: grid[:4],
+		DistKm: dist, Bearing: brg,
+		// Stamped on receipt: the broker's own timestamps vary between payload
+		// versions, and the window this feeds is measured in minutes.
+		At: time.Now(),
+	}
+	w.mu.Lock()
+	w.received++
+	w.lastAt = s.At
+	w.mu.Unlock()
+	w.cfg.OnSpot(s)
+}
+
+// Status is the snapshot the settings panel shows.
+type Status struct {
+	Running  bool      `json:"running"`
+	Received uint64    `json:"received"`
+	LastAt   time.Time `json:"last_at"`
+	LastErr  string    `json:"last_err,omitempty"`
+	Broker   string    `json:"broker"`
+	Bands    []string  `json:"bands"`
+}
+
+func (w *Watcher) Status() Status {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	st := Status{
+		Running: w.running, Received: w.received, LastAt: w.lastAt,
+		LastErr: w.lastErr, Broker: w.cfg.Broker,
+	}
+	st.Bands = append(st.Bands, w.cfg.Bands...)
+	return st
+}

internal/qso/filter_in_test.go

@@ -0,0 +1,57 @@
+package qso
+
+import (
+	"strings"
+	"testing"
+)
+
+// "2 m or 70 cm, in FT8, since January" could not be asked before: the filter
+// joins every condition with ONE AND or OR, so AND killed the two bands and OR
+// let every FT8 QSO through. The OR now lives inside a single condition.
+func TestInConditionExpressesSeveralValuesForOneField(t *testing.T) {
+	sql, args, err := conditionSQL(Condition{Field: "band", Op: "in", Value: "2m, 70cm"})
+	if err != nil {
+		t.Fatalf("in: %v", err)
+	}
+	if !strings.Contains(sql, "IN (?,?)") {
+		t.Errorf("sql = %q, want an IN with two placeholders", sql)
+	}
+	if len(args) != 2 || args[0] != "2m" || args[1] != "70cm" {
+		t.Errorf("args = %v, want [2m 70cm] trimmed", args)
+	}
+}
+
+// A trailing comma while typing must not add an empty value that matches nothing.
+func TestInIgnoresBlanks(t *testing.T) {
+	_, args, err := conditionSQL(Condition{Field: "mode", Op: "in", Value: "FT8, ,FT4,"})
+	if err != nil {
+		t.Fatalf("in: %v", err)
+	}
+	if len(args) != 2 {
+		t.Errorf("args = %v, want the two real values only", args)
+	}
+}
+
+// An empty list matches nothing. Dropping the condition instead would WIDEN the
+// result set — the opposite of what someone typing a filter expects.
+func TestEmptyInMatchesNothing(t *testing.T) {
+	sql, _, err := conditionSQL(Condition{Field: "band", Op: "in", Value: "  , "})
+	if err != nil {
+		t.Fatalf("in: %v", err)
+	}
+	if sql != "1=0" {
+		t.Errorf("sql = %q, want 1=0", sql)
+	}
+}
+
+// NOT IN must keep rows whose column is NULL: the row is not one of the listed
+// values, so it belongs in the answer. Raw SQL NOT IN drops them.
+func TestNotInKeepsNulls(t *testing.T) {
+	sql, _, err := conditionSQL(Condition{Field: "band", Op: "notin", Value: "2m"})
+	if err != nil {
+		t.Fatalf("notin: %v", err)
+	}
+	if !strings.HasPrefix(sql, "IFNULL(") {
+		t.Errorf("sql = %q, want the column wrapped in IFNULL", sql)
+	}
+}

internal/qso/qso.go

@@ -1289,6 +1289,23 @@ func columnExpr(field string) (string, bool) {
 }
 
 // conditionSQL turns one condition into a parameterised predicate.
+// splitList parses the comma-separated value of an "in" / "not in" condition.
+//
+// Blanks are dropped, so a trailing comma or a stray space while typing does not
+// silently add an empty value that matches nothing. Case is left alone: the
+// columns this is used on (band, mode, country) are stored in the case the log
+// was written in, and forcing it here would break the ones that are not.
+func splitList(v string) []string {
+	parts := strings.Split(v, ",")
+	out := make([]string, 0, len(parts))
+	for _, p := range parts {
+		if p = strings.TrimSpace(p); p != "" {
+			out = append(out, p)
+		}
+	}
+	return out
+}
+
 func conditionSQL(c Condition) (string, []any, error) {
 	col, ok := columnExpr(c.Field)
 	if !ok {
@@ -1322,6 +1339,36 @@ func conditionSQL(c Condition) (string, []any, error) {
 		return col + " LIKE ?", []any{v + "%"}, nil
 	case "endswith":
 		return col + " LIKE ?", []any{"%" + v}, nil
+	case "in", "notin":
+		// Several values for ONE field, comma-separated.
+		//
+		// This is what makes a real question expressible. The filter joins every
+		// condition with a single AND or OR, so "2 m or 70 cm, in FT8, since
+		// January" could not be asked: AND killed the two bands, OR let every FT8
+		// QSO through. Rather than grow the model nested groups — a tree in the UI
+		// to answer a question that is nearly always "this field, any of these
+		// values" — the OR lives INSIDE one condition and everything else keeps
+		// ANDing.
+		vals := splitList(v)
+		if len(vals) == 0 {
+			// An empty list matches nothing, which is the honest reading. Silently
+			// dropping the condition would widen the result set instead.
+			if c.Op == "in" {
+				return "1=0", nil, nil
+			}
+			return "1=1", nil, nil
+		}
+		ph := strings.TrimSuffix(strings.Repeat("?,", len(vals)), ",")
+		args := make([]any, 0, len(vals))
+		for _, s := range vals {
+			args = append(args, s)
+		}
+		if c.Op == "notin" {
+			// IFNULL, or a NULL column would fail "NOT IN" and vanish from the
+			// result — the row is not one of the listed values, so it belongs.
+			return "IFNULL(" + col + ",'') NOT IN (" + ph + ")", args, nil
+		}
+		return col + " IN (" + ph + ")", args, nil
 	case "empty":
 		return "IFNULL(" + col + ",'') = ''", nil, nil
 	case "notempty":

internal/rigctld/rigctld.go

@@ -49,6 +49,10 @@ type Rig interface {
 	SetFreq(hz int64) error
 	SetMode(mode string) error
 	SetPTT(on bool) error
+	// SetSplit arms or clears split and places the transmit frequency. Returns an
+	// error on a rig that cannot: a refusal the client can report is worth far
+	// more than a success it has no way to check.
+	SetSplit(on bool, txHz int64) error
 }
 
 type Server struct {
@@ -61,12 +65,24 @@ type Server struct {
 	conns  map[net.Conn]struct{}
 	closed bool
 
+	// accepted counts every connection this listener has taken. Only selfTest
+	// reads it, to tell "a client reached us" from "a client reached someone
+	// else on our port".
+	accepted atomic.Int64
+
 	// ptt mirrors the last PTT state a client commanded via set_ptt. WSJT-X/JTDX
 	// poll get_ptt DURING transmit to confirm the rig is keyed; if get_ptt reads
 	// RX they conclude PTT failed and abort the over after a second or two. We
 	// don't read PTT back from every backend, so echo what the client last set —
 	// always consistent with its own command, and enough to satisfy the check.
 	ptt atomic.Bool
+	// pttKnown says ptt reflects a state we actually commanded, so a repeat can
+	// be told from the very first call — where the radio's state is unknown and
+	// the command must go through.
+	pttKnown atomic.Bool
+	// splitWanted remembers a set_split_vfo that arrived before the frequency it
+	// needs, so the pair can be honoured in the order the client sends them.
+	splitWanted atomic.Bool
 }
 
 func New(port int, rig Rig, logf func(string, ...any)) *Server {
@@ -109,15 +125,58 @@ func (s *Server) Start() error {
 				}
 				return
 			}
+			s.accepted.Add(1)
 			s.mu.Lock()
 			s.conns[c] = struct{}{}
 			s.mu.Unlock()
 			go s.serve(c)
 		}
 	}()
+	go s.selfTest()
 	return nil
 }
 
+// selfTest checks that a client connecting to 127.0.0.1:<port> actually reaches
+// THIS listener, and says so in the log when it does not.
+//
+// Binding successfully is not the same as being reachable. OpsLog listens on
+// 0.0.0.0, and Windows lets a second program bind the SAME port on the specific
+// address 127.0.0.1. Connections to localhost then go to the MORE SPECIFIC
+// listener — the other program — while ours sits there having logged "sharing
+// CAT on port 4532" and never seeing a single client.
+//
+// Seen in the field with Nexus, which starts its own rigctld on 127.0.0.1:4532
+// and connects to it. Neither program reports anything wrong; the operator gets
+// a CAT timeout from a daemon with no radio behind it, and OpsLog's log is
+// silent because nothing ever arrived. Three exchanges went into finding that,
+// so it is worth one line at startup.
+//
+// The counter can only be raised by our own accept loop, so a real client
+// arriving during the probe makes this pass, never fail wrongly.
+func (s *Server) selfTest() {
+	before := s.accepted.Load()
+	addr := fmt.Sprintf("127.0.0.1:%d", s.port)
+	c, err := net.DialTimeout("tcp", addr, 2*time.Second)
+	if err != nil {
+		s.log("rigctld: WARNING — could not reach our own CAT port at %s (%v); "+
+			"clients on this PC will not find OpsLog", addr, err)
+		return
+	}
+	defer c.Close()
+	// Give the accept loop a moment: the dial returns as soon as the handshake
+	// completes, which can be marginally before Accept hands the connection over.
+	for i := 0; i < 20; i++ {
+		if s.accepted.Load() > before {
+			return // it reached us — nothing to say
+		}
+		time.Sleep(50 * time.Millisecond)
+	}
+	s.log("rigctld: WARNING — another program is already answering on %s. "+
+		"It will receive the CAT connections meant for OpsLog, which will look "+
+		"like a timeout in that program and silence here. Close it, or move "+
+		"OpsLog's shared CAT to a different port.", addr)
+}
+
 // releasePTT drops the transmitter when whoever was holding it goes away.
 //
 // Nothing else will. The Kenwood/Elecraft backend deliberately suspends its
@@ -224,6 +283,24 @@ func (s *Server) handle(line string) (resp string, quit bool) {
 		return "CHKVFO 0\n", false
 	case "\\get_powerstat", "get_powerstat":
 		return "1\n", false
+
+	// Three commands a client may issue as a matter of course. Refusing them with
+	// RPRT -11 is allowed, and a tolerant client carries on — but nothing obliges
+	// it to, and Nexus sends all three around every transmit. Answering costs
+	// nothing and removes them as suspects when something really is wrong.
+	case "\\get_lock_mode", "get_lock_mode":
+		// Truthful: OpsLog never locks the dial against its own clients.
+		return "0\n", false
+	case "\\set_lock_mode", "set_lock_mode":
+		// Accepted and ignored, like set_vfo below: there is no lock to set, and
+		// failing here would abort a client's whole transmit sequence over a
+		// setting that has no effect either way.
+		return rprt(0), false
+	case "\\stop_morse", "stop_morse":
+		// Nothing is queued here — CW over CAT is keyed by the rig's own keyer
+		// through the backend, not buffered in this server. "Stopped" is therefore
+		// accurate rather than polite.
+		return rprt(0), false
 	case "q", "Q", "\\quit":
 		return "", true
 
@@ -275,11 +352,27 @@ func (s *Server) handle(line string) (resp string, quit bool) {
 			return rprt(-1), false
 		}
 		on := args[0] != "0"
+		// Only touch the radio on a CHANGE.
+		//
+		// A client is free to restate PTT as often as it likes, and one does:
+		// Nexus sends set_ptt 0 about sixteen times a second, so the Flex was
+		// getting "xmit 0" every 60 ms forever. Worse than wasteful — its own
+		// "xmit 1" landed between two of them and was overwritten in the same
+		// millisecond, so the radio never stayed keyed and the operator saw a
+		// transmit request that simply did nothing.
+		//
+		// Repeating a state is not a request to change it. The first call always
+		// goes through, since we cannot know how the radio was left.
+		if s.pttKnown.Load() && s.ptt.Load() == on {
+			return rprt(0), false
+		}
 		if err := s.rig.SetPTT(on); err != nil {
 			s.log("rigctld: set_ptt %v failed: %v", on, err)
 			return rprt(-9), false
 		}
 		s.ptt.Store(on)
+		s.pttKnown.Store(true)
+		s.log("rigctld: PTT %s", map[bool]string{true: "ON", false: "off"}[on])
 		return rprt(0), false
 
 	case "v", "\\get_vfo":
@@ -297,7 +390,31 @@ func (s *Server) handle(line string) (resp string, quit bool) {
 		}
 		return fmt.Sprintf("%d\nVFOB\n", n), false
 	case "S", "\\set_split_vfo":
-		return rprt(0), false // see set_vfo — split is driven from the rig
+		// "S <0|1> <VFO>". The VFO argument is ignored: which dial transmits is the
+		// rig's own business, and every backend here puts it on the second one.
+		//
+		// This used to answer RPRT 0 and do NOTHING. WSJT-X in "Split Operating:
+		// Rig" sends this and set_split_freq, believed both, and transmitted on the
+		// RECEIVE frequency — on a pileup, straight onto the DX, while the software
+		// showed exactly what the operator had asked for. A lie that leaves no
+		// trace anywhere is the worst kind of bug, so it now works or says so.
+		if len(args) < 1 {
+			return rprt(-1), false
+		}
+		if args[0] != "0" {
+			// Arming needs a frequency, and WSJT-X sends set_split_freq AFTER this.
+			// Remember the request and let that command do the work: alone, this
+			// would arm split on whatever the transmit VFO happens to hold.
+			s.splitWanted.Store(true)
+			return rprt(0), false
+		}
+		s.splitWanted.Store(false)
+		if err := s.rig.SetSplit(false, 0); err != nil {
+			s.log("rigctld: split off failed: %v", err)
+			return rprt(-9), false
+		}
+		s.log("rigctld: split off")
+		return rprt(0), false
 	case "i", "\\get_split_freq":
 		_, tx := s.rig.Split()
 		if tx <= 0 {
@@ -305,9 +422,37 @@ func (s *Server) handle(line string) (resp string, quit bool) {
 		}
 		return fmt.Sprintf("%d\n", tx), false
 	case "I", "\\set_split_freq":
+		if len(args) < 1 {
+			return rprt(-1), false
+		}
+		// Hamlib sends a float ("14075300.000000"), so parse as one.
+		hz, err := strconv.ParseFloat(args[0], 64)
+		if err != nil || hz <= 0 {
+			return rprt(-1), false
+		}
+		if err := s.rig.SetSplit(true, int64(hz)); err != nil {
+			s.log("rigctld: split TX %.0f Hz failed: %v", hz, err)
+			return rprt(-9), false
+		}
+		s.splitWanted.Store(true)
+		s.log("rigctld: split ON, TX %.0f Hz", hz)
 		return rprt(0), false
 
 	default:
+		// A frame ending in ';' is not a rigctl command at all — it is raw rig
+		// dialect (Kenwood/Elecraft/Yaesu), which means the client is configured
+		// with a RIG MODEL pointing at this port instead of "Hamlib NET rigctl".
+		//
+		// Worth naming, because the symptom hides the cause completely: we answer
+		// RPRT -11 like any unknown command, but that reply has no ';' to terminate
+		// on, so the client's parser waits and then reports "reply incomplete, got
+		// nothing". The operator sees a timeout and concludes the CAT share is
+		// broken, when it is a one-line setting in the other program.
+		if strings.HasSuffix(line, ";") && !strings.Contains(line, " ") {
+			s.log("rigctld: %q is a raw rig command, not rigctl — the client is set to a RIG MODEL; "+
+				"it must be set to \"Hamlib NET rigctl\" (rig 2) at this address", line)
+			return rprt(-11), false
+		}
 		// RPRT -11 is "command not implemented". Answering something is essential:
 		// a client waiting on a silent socket hangs rather than degrading.
 		s.log("rigctld: unimplemented command %q", line)

internal/rigctld/rigctld_selftest_test.go

@@ -0,0 +1,94 @@
+package rigctld
+
+import (
+	"fmt"
+	"net"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+)
+
+// A listener that binds successfully is not necessarily the one clients reach.
+// Windows lets a second program bind the same port on the specific address
+// 127.0.0.1 while ours holds 0.0.0.0, and localhost connections then go to the
+// more specific one. Seen with Nexus, which starts its own rigctld on 4532.
+func TestSelfTestWarnsWhenAnotherProgramHoldsLocalhost(t *testing.T) {
+	// Squat 127.0.0.1 first, the way the other program does.
+	squat, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Skipf("cannot bind localhost here: %v", err)
+	}
+	defer squat.Close()
+	port := squat.Addr().(*net.TCPAddr).Port
+	go func() {
+		for {
+			c, err := squat.Accept()
+			if err != nil {
+				return
+			}
+			c.Close()
+		}
+	}()
+
+	var mu sync.Mutex
+	var lines []string
+	s := New(port, nil, func(f string, a ...any) {
+		mu.Lock()
+		lines = append(lines, fmt.Sprintf(f, a...))
+		mu.Unlock()
+	})
+	if err := s.Start(); err != nil {
+		// The wildcard bind is refused on some setups; nothing to prove then.
+		t.Skipf("wildcard bind refused: %v", err)
+	}
+	defer s.Stop()
+
+	deadline := time.Now().Add(4 * time.Second)
+	for time.Now().Before(deadline) {
+		mu.Lock()
+		got := strings.Join(lines, "\n")
+		mu.Unlock()
+		if strings.Contains(got, "another program is already answering") {
+			return
+		}
+		time.Sleep(50 * time.Millisecond)
+	}
+	mu.Lock()
+	defer mu.Unlock()
+	t.Errorf("no warning was logged while another listener owned localhost:%d.\nlog was:\n%s",
+		port, strings.Join(lines, "\n"))
+}
+
+// The healthy case must stay silent: a warning on every clean start would be
+// noise, and noise in a log is what makes the real line easy to miss.
+func TestSelfTestIsSilentWhenReachable(t *testing.T) {
+	// A real, free port: with 0 the OS picks one but s.port stays 0, so the probe
+	// would dial 127.0.0.1:0 and prove nothing.
+	probe, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Skipf("cannot bind: %v", err)
+	}
+	port := probe.Addr().(*net.TCPAddr).Port
+	probe.Close()
+
+	var mu sync.Mutex
+	var lines []string
+	s := New(port, nil, func(f string, a ...any) {
+		mu.Lock()
+		lines = append(lines, fmt.Sprintf(f, a...))
+		mu.Unlock()
+	})
+	if err := s.Start(); err != nil {
+		t.Skipf("start: %v", err)
+	}
+	defer s.Stop()
+	time.Sleep(1500 * time.Millisecond)
+	mu.Lock()
+	defer mu.Unlock()
+	for _, l := range lines {
+		if strings.Contains(l, "WARNING") {
+			t.Errorf("a reachable port still warned: %q", l)
+		}
+	}
+}

internal/rigctld/rigctld_test.go

@@ -2,6 +2,7 @@ package rigctld
 
 import (
 	"bufio"
+	"errors"
 	"fmt"
 	"net"
 	"strings"
@@ -21,11 +22,26 @@ type fakeRig struct {
 	setFreqs []int64
 	setModes []string
 	failSet  bool
+	// noSplit models a backend that cannot set split — the case that must reach
+	// the client as a refusal instead of a silent success.
+	noSplit    bool
+	splitCalls []string
 }
 
 func (f *fakeRig) Freq() int64          { f.mu.Lock(); defer f.mu.Unlock(); return f.freq }
 func (f *fakeRig) Mode() string         { f.mu.Lock(); defer f.mu.Unlock(); return f.mode }
 func (f *fakeRig) Split() (bool, int64) { f.mu.Lock(); defer f.mu.Unlock(); return f.split, f.txFreq }
+
+func (f *fakeRig) SetSplit(on bool, txHz int64) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	if f.noSplit {
+		return errors.New("this radio cannot set split from software")
+	}
+	f.splitCalls = append(f.splitCalls, fmt.Sprintf("%v:%d", on, txHz))
+	f.split, f.txFreq = on, txHz
+	return nil
+}
 func (f *fakeRig) SetFreq(hz int64) error {
 	f.mu.Lock()
 	defer f.mu.Unlock()

internal/rigctld/split_test.go

@@ -0,0 +1,52 @@
+package rigctld
+
+import (
+	"strings"
+	"testing"
+)
+
+// WSJT-X in "Split Operating: Rig" sends set_split_vfo then set_split_freq. Both
+// used to answer RPRT 0 and do NOTHING: the software believed it was
+// transmitting up the band while the radio stayed on the receive frequency —
+// on a pileup, straight onto the DX, with no trace anywhere.
+func TestSetSplitReachesTheRig(t *testing.T) {
+	rig := &fakeRig{freq: 14074000, mode: "FT8"}
+	s := New(0, rig, func(string, ...any) {})
+
+	if got, _ := s.handle("S 1 VFOB"); !strings.HasPrefix(got, "RPRT 0") {
+		t.Fatalf("set_split_vfo answered %q", got)
+	}
+	// Arming alone must NOT touch the rig: without a frequency it would transmit
+	// on whatever the second VFO happened to hold.
+	if len(rig.splitCalls) != 0 {
+		t.Errorf("split was armed before a frequency arrived: %v", rig.splitCalls)
+	}
+
+	if got, _ := s.handle("I 14075300.000000"); !strings.HasPrefix(got, "RPRT 0") {
+		t.Fatalf("set_split_freq answered %q", got)
+	}
+	if len(rig.splitCalls) != 1 || rig.splitCalls[0] != "true:14075300" {
+		t.Fatalf("rig saw %v, want one call arming split on 14075300", rig.splitCalls)
+	}
+
+	if got, _ := s.handle("S 0 VFOA"); !strings.HasPrefix(got, "RPRT 0") {
+		t.Fatalf("split off answered %q", got)
+	}
+	if len(rig.splitCalls) != 2 || !strings.HasPrefix(rig.splitCalls[1], "false:") {
+		t.Errorf("rig saw %v, want split cleared", rig.splitCalls)
+	}
+}
+
+// A backend that cannot do split must produce an ERROR the client can report.
+// Answering success and doing nothing is what caused the original fault, and it
+// is the one outcome that must never come back.
+func TestSetSplitRefusalIsReported(t *testing.T) {
+	rig := &fakeRig{freq: 14074000, noSplit: true}
+	s := New(0, rig, func(string, ...any) {})
+
+	s.handle("S 1 VFOB")
+	got, _ := s.handle("I 14075300.000000")
+	if strings.HasPrefix(got, "RPRT 0") {
+		t.Errorf("a rig that cannot split answered %q — the client will transmit on the wrong frequency", got)
+	}
+}

internal/webpub/webpub.go

@@ -10,9 +10,13 @@
 //   - The page is self-contained: no external CSS, font or script. It has to
 //     work dropped into any hosting, including one that blocks third-party
 //     requests, and it must not leak the reader's visit to anyone.
-//   - Columns are a fixed, curated set rather than "every ADIF field". This is
-//     a page shown to the public: RST and QSL status belong, the operator's
-//     home address does not.
+//   - Every ADIF field is offered, because an operator publishing a county hunt
+//     or an award chase needs fields no curated list would have guessed. That
+//     puts the judgement on them, and it is a real one: this page is PUBLIC, and
+//     the catalogue includes the correspondent's address, e-mail and the
+//     operator's own street. Nothing is published unless it is chosen, and the
+//     default selection stays the eight columns a reader of someone else's log
+//     actually looks for.
 package webpub
 
 import (
@@ -60,7 +64,10 @@ type Config struct {
 type Column struct {
 	Key    string
 	Header string
-	Value  func(q *qso.QSO) string
+	// Group is the section a picker shows this under. With every ADIF field on
+	// offer, a flat list is unusable — the grouping IS what makes it navigable.
+	Group string
+	Value func(q *qso.QSO) string
 }
 
 func str(p *int) string {
@@ -70,43 +77,188 @@ func str(p *int) string {
 	return strconv.Itoa(*p)
 }
 
-// Columns is the curated set, in default display order. Add here to offer a new
-// one; the stored config keeps keys, so order changes are safe.
+func str64(p *int64) string {
+	if p == nil {
+		return ""
+	}
+	return strconv.FormatInt(*p, 10)
+}
+
+// flt drops a trailing ".0": a distance reads better as "1420" than "1420.0",
+// and a bearing as "142.5" keeps the half-degree that matters.
+func flt(p *float64) string {
+	if p == nil {
+		return ""
+	}
+	return strconv.FormatFloat(*p, 'f', -1, 64)
+}
+
+func stamp(t time.Time) string {
+	if t.IsZero() {
+		return ""
+	}
+	return t.UTC().Format("2006-01-02 15:04")
+}
+
+// Columns is every field a QSO can carry, in ADIF order, grouped for the picker.
+//
+// Generated from the qso.QSO struct rather than curated by hand: the previous
+// list held 23 of them, so anyone wanting to publish a county, a satellite pass
+// or an award reference simply could not. A hand list also silently rots — a new
+// ADIF field is added to the struct and nobody remembers this file exists.
+//
+// The stored configuration keeps KEYS, so order and grouping can change freely.
 var Columns = []Column{
-	{"date", "Date", func(q *qso.QSO) string { return q.QSODate.UTC().Format("2006-01-02") }},
-	{"time", "UTC", func(q *qso.QSO) string { return q.QSODate.UTC().Format("15:04") }},
-	{"callsign", "Call", func(q *qso.QSO) string { return q.Callsign }},
-	{"band", "Band", func(q *qso.QSO) string { return q.Band }},
-	{"mode", "Mode", func(q *qso.QSO) string { return q.Mode }},
-	{"freq", "Freq", func(q *qso.QSO) string {
+	// Date and time are one column in the database and two here: a log reads by
+	// day, and a reader scanning for "that evening" should not have to parse a
+	// timestamp. Frequency is stored in Hz and published in MHz.
+	{"date", "Date", "QSO", func(q *qso.QSO) string { return q.QSODate.UTC().Format("2006-01-02") }},
+	{"time", "UTC", "QSO", func(q *qso.QSO) string { return q.QSODate.UTC().Format("15:04") }},
+	{"freq", "Freq", "QSO", func(q *qso.QSO) string {
 		if q.FreqHz == nil || *q.FreqHz == 0 {
 			return ""
 		}
 		return strconv.FormatFloat(float64(*q.FreqHz)/1e6, 'f', 3, 64)
 	}},
-	{"rst_sent", "RST S", func(q *qso.QSO) string { return q.RSTSent }},
-	{"rst_rcvd", "RST R", func(q *qso.QSO) string { return q.RSTRcvd }},
-	{"name", "Name", func(q *qso.QSO) string { return q.Name }},
-	{"qth", "QTH", func(q *qso.QSO) string { return q.QTH }},
-	{"country", "Country", func(q *qso.QSO) string { return q.Country }},
-	{"grid", "Grid", func(q *qso.QSO) string { return q.Grid }},
-	{"dxcc", "DXCC", func(q *qso.QSO) string { return str(q.DXCC) }},
-	{"cqz", "CQ", func(q *qso.QSO) string { return str(q.CQZ) }},
-	{"ituz", "ITU", func(q *qso.QSO) string { return str(q.ITUZ) }},
-	{"iota", "IOTA", func(q *qso.QSO) string { return q.IOTA }},
-	{"pota", "POTA", func(q *qso.QSO) string { return q.POTARef }},
-	{"sota", "SOTA", func(q *qso.QSO) string { return q.SOTARef }},
-	{"qsl_sent", "QSL S", func(q *qso.QSO) string { return q.QSLSent }},
-	{"qsl_rcvd", "QSL R", func(q *qso.QSO) string { return q.QSLRcvd }},
-	{"lotw_rcvd", "LoTW", func(q *qso.QSO) string { return q.LOTWRcvd }},
-	{"station", "Station", func(q *qso.QSO) string { return q.StationCallsign }},
-	{"comment", "Comment", func(q *qso.QSO) string { return q.Comment }},
+	{"callsign", "Callsign", "QSO", func(q *qso.QSO) string { return q.Callsign }},
+	{"qso_date_off", "End", "QSO", func(q *qso.QSO) string { return stamp(q.QSODateOff) }},
+	{"band", "Band", "QSO", func(q *qso.QSO) string { return q.Band }},
+	{"band_rx", "Band RX", "QSO", func(q *qso.QSO) string { return q.BandRX }},
+	{"mode", "Mode", "QSO", func(q *qso.QSO) string { return q.Mode }},
+	{"submode", "Submode", "QSO", func(q *qso.QSO) string { return q.Submode }},
+	{"freq_rx_hz", "Freq RX", "QSO", func(q *qso.QSO) string { return str64(q.FreqRXHz) }},
+	{"rst_sent", "RST S", "QSO", func(q *qso.QSO) string { return q.RSTSent }},
+	{"rst_rcvd", "RST R", "QSO", func(q *qso.QSO) string { return q.RSTRcvd }},
+	{"name", "Name", "QSO", func(q *qso.QSO) string { return q.Name }},
+	{"qth", "QTH", "QSO", func(q *qso.QSO) string { return q.QTH }},
+	{"address", "Address", "QSO", func(q *qso.QSO) string { return q.Address }},
+	{"email", "Email", "QSO", func(q *qso.QSO) string { return q.Email }},
+	{"web", "Web", "QSO", func(q *qso.QSO) string { return q.Web }},
+	{"grid", "Grid", "Location", func(q *qso.QSO) string { return q.Grid }},
+	{"gridsquare_ext", "Grid ext", "Location", func(q *qso.QSO) string { return q.GridExt }},
+	{"vucc_grids", "VUCC", "Location", func(q *qso.QSO) string { return q.VUCCGrids }},
+	{"country", "Country", "Location", func(q *qso.QSO) string { return q.Country }},
+	{"state", "State", "Location", func(q *qso.QSO) string { return q.State }},
+	{"cnty", "County", "Location", func(q *qso.QSO) string { return q.County }},
+	{"dxcc", "Dxcc", "Location", func(q *qso.QSO) string { return str(q.DXCC) }},
+	{"cont", "Cont", "Location", func(q *qso.QSO) string { return q.Continent }},
+	{"cqz", "CQ", "Location", func(q *qso.QSO) string { return str(q.CQZ) }},
+	{"ituz", "ITU", "Location", func(q *qso.QSO) string { return str(q.ITUZ) }},
+	{"iota", "Iota", "Awards", func(q *qso.QSO) string { return q.IOTA }},
+	{"sota_ref", "SOTA", "Awards", func(q *qso.QSO) string { return q.SOTARef }},
+	{"pota_ref", "POTA", "Awards", func(q *qso.QSO) string { return q.POTARef }},
+	{"age", "Age", "QSO", func(q *qso.QSO) string { return str(q.Age) }},
+	{"lat", "Lat", "Location", func(q *qso.QSO) string { return flt(q.Lat) }},
+	{"lon", "Lon", "Location", func(q *qso.QSO) string { return flt(q.Lon) }},
+	{"rig", "Rig", "QSO", func(q *qso.QSO) string { return q.Rig }},
+	{"ant", "Ant", "QSO", func(q *qso.QSO) string { return q.Ant }},
+	{"qsl_sent", "QSL S", "QSL", func(q *qso.QSO) string { return q.QSLSent }},
+	{"qsl_rcvd", "QSL R", "QSL", func(q *qso.QSO) string { return q.QSLRcvd }},
+	{"qsl_sent_date", "Qsl sent date", "QSL", func(q *qso.QSO) string { return q.QSLSentDate }},
+	{"qsl_rcvd_date", "Qsl rcvd date", "QSL", func(q *qso.QSO) string { return q.QSLRcvdDate }},
+	{"qsl_via", "Qsl via", "QSL", func(q *qso.QSO) string { return q.QSLVia }},
+	{"qsl_msg", "Qsl msg", "QSL", func(q *qso.QSO) string { return q.QSLMsg }},
+	{"qslmsg_rcvd", "Qslmsg rcvd", "QSL", func(q *qso.QSO) string { return q.QSLMsgRcvd }},
+	{"lotw_sent", "LoTW S", "QSL", func(q *qso.QSO) string { return q.LOTWSent }},
+	{"lotw_rcvd", "LoTW R", "QSL", func(q *qso.QSO) string { return q.LOTWRcvd }},
+	{"lotw_sent_date", "Lotw sent date", "QSL", func(q *qso.QSO) string { return q.LOTWSentDate }},
+	{"lotw_rcvd_date", "Lotw rcvd date", "QSL", func(q *qso.QSO) string { return q.LOTWRcvdDate }},
+	{"eqsl_sent", "eQSL S", "QSL", func(q *qso.QSO) string { return q.EQSLSent }},
+	{"eqsl_rcvd", "eQSL R", "QSL", func(q *qso.QSO) string { return q.EQSLRcvd }},
+	{"eqsl_sent_date", "Eqsl sent date", "QSL", func(q *qso.QSO) string { return q.EQSLSentDate }},
+	{"eqsl_rcvd_date", "Eqsl rcvd date", "QSL", func(q *qso.QSO) string { return q.EQSLRcvdDate }},
+	{"clublog_qso_upload_date", "Clublog qso upload date", "QSL", func(q *qso.QSO) string { return q.ClublogUploadDate }},
+	{"clublog_qso_upload_status", "Clublog qso upload status", "QSL", func(q *qso.QSO) string { return q.ClublogUploadStatus }},
+	{"hrdlog_qso_upload_date", "Hrdlog qso upload date", "QSL", func(q *qso.QSO) string { return q.HRDLogUploadDate }},
+	{"hrdlog_qso_upload_status", "Hrdlog qso upload status", "QSL", func(q *qso.QSO) string { return q.HRDLogUploadStatus }},
+	{"qrzcom_qso_upload_date", "Qrzcom qso upload date", "QSL", func(q *qso.QSO) string { return q.QRZComUploadDate }},
+	{"qrzcom_qso_upload_status", "Qrzcom qso upload status", "QSL", func(q *qso.QSO) string { return q.QRZComUploadStatus }},
+	{"qrzcom_qso_download_date", "Qrzcom qso download date", "QSL", func(q *qso.QSO) string { return q.QRZComDownloadDate }},
+	{"qrzcom_qso_download_status", "Qrzcom qso download status", "QSL", func(q *qso.QSO) string { return q.QRZComDownloadStatus }},
+	{"contest_id", "Contest", "Contest", func(q *qso.QSO) string { return q.ContestID }},
+	{"srx", "Srx", "Contest", func(q *qso.QSO) string { return str(q.SRX) }},
+	{"stx", "Stx", "Contest", func(q *qso.QSO) string { return str(q.STX) }},
+	{"srx_string", "SRX str", "QSO", func(q *qso.QSO) string { return q.SRXString }},
+	{"stx_string", "STX str", "QSO", func(q *qso.QSO) string { return q.STXString }},
+	{"check", "Check", "Contest", func(q *qso.QSO) string { return q.Check }},
+	{"precedence", "Precedence", "Contest", func(q *qso.QSO) string { return q.Precedence }},
+	{"arrl_sect", "Section", "Contest", func(q *qso.QSO) string { return q.ARRLSect }},
+	{"prop_mode", "Prop", "QSO", func(q *qso.QSO) string { return q.PropMode }},
+	{"sat_name", "Sat", "QSO", func(q *qso.QSO) string { return q.SatName }},
+	{"sat_mode", "Sat mode", "QSO", func(q *qso.QSO) string { return q.SatMode }},
+	{"ant_az", "Ant az", "QSO", func(q *qso.QSO) string { return flt(q.AntAz) }},
+	{"ant_el", "Ant el", "QSO", func(q *qso.QSO) string { return flt(q.AntEl) }},
+	{"ant_path", "Ant path", "QSO", func(q *qso.QSO) string { return q.AntPath }},
+	{"station_callsign", "Station", "QSO", func(q *qso.QSO) string { return q.StationCallsign }},
+	{"operator", "Operator", "QSO", func(q *qso.QSO) string { return q.Operator }},
+	{"my_grid", "My grid", "My station", func(q *qso.QSO) string { return q.MyGrid }},
+	{"my_gridsquare_ext", "My gridsquare ext", "My station", func(q *qso.QSO) string { return q.MyGridExt }},
+	{"my_country", "My country", "My station", func(q *qso.QSO) string { return q.MyCountry }},
+	{"my_state", "My state", "My station", func(q *qso.QSO) string { return q.MyState }},
+	{"my_cnty", "My cnty", "My station", func(q *qso.QSO) string { return q.MyCounty }},
+	{"my_iota", "My iota", "My station", func(q *qso.QSO) string { return q.MyIOTA }},
+	{"my_sota_ref", "My sota ref", "My station", func(q *qso.QSO) string { return q.MySOTARef }},
+	{"my_pota_ref", "My pota ref", "My station", func(q *qso.QSO) string { return q.MyPOTARef }},
+	{"my_dxcc", "My dxcc", "My station", func(q *qso.QSO) string { return str(q.MyDXCC) }},
+	{"my_cq_zone", "My cq zone", "My station", func(q *qso.QSO) string { return str(q.MyCQZone) }},
+	{"my_itu_zone", "My itu zone", "My station", func(q *qso.QSO) string { return str(q.MyITUZone) }},
+	{"my_lat", "My lat", "My station", func(q *qso.QSO) string { return flt(q.MyLat) }},
+	{"my_lon", "My lon", "My station", func(q *qso.QSO) string { return flt(q.MyLon) }},
+	{"my_street", "My street", "My station", func(q *qso.QSO) string { return q.MyStreet }},
+	{"my_city", "My city", "My station", func(q *qso.QSO) string { return q.MyCity }},
+	{"my_postal_code", "My postal code", "My station", func(q *qso.QSO) string { return q.MyPostalCode }},
+	{"my_rig", "My rig", "My station", func(q *qso.QSO) string { return q.MyRig }},
+	{"my_antenna", "My antenna", "My station", func(q *qso.QSO) string { return q.MyAntenna }},
+	{"tx_pwr", "TX pwr", "QSO", func(q *qso.QSO) string { return flt(q.TXPower) }},
+	{"comment", "Comment", "QSO", func(q *qso.QSO) string { return q.Comment }},
+	{"notes", "Notes", "QSO", func(q *qso.QSO) string { return q.Notes }},
+	{"sig", "Sig", "Awards", func(q *qso.QSO) string { return q.SIG }},
+	{"sig_info", "Sig info", "Awards", func(q *qso.QSO) string { return q.SIGInfo }},
+	{"my_sig", "My sig", "My station", func(q *qso.QSO) string { return q.MySIG }},
+	{"my_sig_info", "My sig info", "My station", func(q *qso.QSO) string { return q.MySIGInfo }},
+	{"wwff_ref", "WWFF", "Awards", func(q *qso.QSO) string { return q.WWFFRef }},
+	{"my_wwff_ref", "My wwff ref", "My station", func(q *qso.QSO) string { return q.MyWWFFRef }},
+	{"distance", "Distance", "Location", func(q *qso.QSO) string { return flt(q.Distance) }},
+	{"rx_pwr", "RX pwr", "QSO", func(q *qso.QSO) string { return flt(q.RXPower) }},
+	{"a_index", "A", "QSO", func(q *qso.QSO) string { return flt(q.AIndex) }},
+	{"k_index", "K", "QSO", func(q *qso.QSO) string { return flt(q.KIndex) }},
+	{"sfi", "SFI", "QSO", func(q *qso.QSO) string { return flt(q.SFI) }},
+	{"skcc", "Skcc", "Awards", func(q *qso.QSO) string { return q.SKCC }},
+	{"fists", "Fists", "Awards", func(q *qso.QSO) string { return q.FISTS }},
+	{"ten_ten", "10-10", "Awards", func(q *qso.QSO) string { return q.TenTen }},
+	{"contacted_op", "Op worked", "QSO", func(q *qso.QSO) string { return q.ContactedOp }},
+	{"eq_call", "Eq call", "QSO", func(q *qso.QSO) string { return q.EqCall }},
+	{"pfx", "Pfx", "Location", func(q *qso.QSO) string { return q.PFX }},
+	{"my_name", "My name", "My station", func(q *qso.QSO) string { return q.MyName }},
+	{"class", "Class", "Contest", func(q *qso.QSO) string { return q.Class }},
+	{"darc_dok", "DOK", "Awards", func(q *qso.QSO) string { return q.DarcDOK }},
+	{"my_darc_dok", "My darc dok", "My station", func(q *qso.QSO) string { return q.MyDarcDOK }},
+	{"region", "Region", "Location", func(q *qso.QSO) string { return q.Region }},
+	{"silent_key", "SK", "QSO", func(q *qso.QSO) string { return q.SilentKey }},
+	{"swl", "Swl", "QSO", func(q *qso.QSO) string { return q.SWL }},
+	{"qso_complete", "Complete", "QSO", func(q *qso.QSO) string { return q.QSOComplete }},
+	{"qso_random", "Random", "QSO", func(q *qso.QSO) string { return q.QSORandom }},
+	{"credit_granted", "Credit granted", "QSL", func(q *qso.QSO) string { return q.CreditGranted }},
+	{"credit_submitted", "Credit sub.", "QSL", func(q *qso.QSO) string { return q.CreditSubmitted }},
+	{"my_arrl_sect", "My arrl sect", "My station", func(q *qso.QSO) string { return q.MyARRLSect }},
+	{"my_vucc_grids", "My vucc grids", "My station", func(q *qso.QSO) string { return q.MyVUCCGrids }},
+	{"award_refs", "Award refs", "Awards", func(q *qso.QSO) string { return q.AwardRefs }},
 }
 
 // DefaultColumns is what a fresh configuration publishes — the columns a reader
 // of someone else's log actually looks for.
 var DefaultColumns = []string{"date", "time", "callsign", "band", "mode", "rst_sent", "rst_rcvd", "country"}
 
+// legacyKeys maps the short names the hand-written table used onto the ADIF
+// names the generated one uses. A configuration saved before this change still
+// publishes the same columns; without it, three of them would vanish silently on
+// upgrade, which is the worst way for a setting to change.
+var legacyKeys = map[string]string{
+	"pota":    "pota_ref",
+	"sota":    "sota_ref",
+	"station": "station_callsign",
+}
+
 func columnsFor(keys []string) []Column {
 	if len(keys) == 0 {
 		keys = DefaultColumns
@@ -117,7 +269,11 @@ func columnsFor(keys []string) []Column {
 	}
 	out := make([]Column, 0, len(keys))
 	for _, k := range keys {
-		if c, ok := byKey[strings.TrimSpace(k)]; ok {
+		k = strings.TrimSpace(k)
+		if alias, ok := legacyKeys[k]; ok {
+			k = alias
+		}
+		if c, ok := byKey[k]; ok {
 			out = append(out, c)
 		}
 	}

telemetry.go

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