chore: release v0.26.3

The COM port was a bare text field — the only serial device in the app without
a port list, and typing one by hand gave no clue when it failed.

A Combobox rather than the Select the other devices use, deliberately: the port
of a USB adapter that is not plugged in does not appear in any list, and
refusing a typed value would mean the antenna cannot be configured until the
adapter is in. Detected ports are offered, anything else is still accepted, and
the value is trimmed and upper-cased on the way in.

The failure itself was already logged by the SteppIR client ("cannot open COM7
@ 4800 baud"); what was missing was the line above it not claiming the antenna
had connected. That is fixed separately.

Carries the 0.26.2 changelog entries for this and the three preceding commits —
one file, and splitting it four ways would have said less than this does.

app_qsl_designer.go

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

appearance.go

@@ -49,8 +49,18 @@ type RowColorSettings struct {
 	// Configured distinguishes "saved with this off" from "saved before the
 	// option existed", so a new marker can default ON without silently turning
 	// itself back on for an operator who switched it off.
-	Configured bool           `json:"configured"`
+	// RecentZebra decides whether the Recent QSOs grid alternates its row
-	Rules      []RowColorRule `json:"rules"`
+	// background. "" (or "on") keeps the banding, which is what the grid has
+	// always done; "off" makes every row the same colour.
+	//
+	// A string with an empty default rather than a bool: a bool would have to
+	// mean "true when absent", and every reader would have to remember that.
+	RecentZebra string `json:"recent_zebra,omitempty"`
+	// RecentZebraColor is the alternate row's colour. Empty follows the theme,
+	// which is the only answer that stays right across all four of them.
+	RecentZebraColor string         `json:"recent_zebra_color,omitempty"`
+	Configured       bool           `json:"configured"`
+	Rules            []RowColorRule `json:"rules"`
 }
 
 // The rule ids, in priority order. The frontend matches on these and holds the
@@ -94,6 +104,13 @@ func normRowColors(s RowColorSettings) RowColorSettings {
 	out := RowColorSettings{
 		Enabled: s.Enabled, Style: s.Style, Intensity: s.Intensity,
 		BandMapLotw: s.BandMapLotw, Configured: true,
+		RecentZebra: strings.ToLower(strings.TrimSpace(s.RecentZebra)),
+	}
+	if out.RecentZebra != "off" {
+		out.RecentZebra = "" // anything unrecognised means the default banding
+	}
+	if c := strings.TrimSpace(s.RecentZebraColor); hexColor.MatchString(c) {
+		out.RecentZebraColor = c
 	}
 	if !s.Configured {
 		out.BandMapLotw = true // new option, on unless the operator says otherwise

autostart.go

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

awardnew.go

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

awardnew_test.go

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

awardrelabel_test.go

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

bandopen_nearkm_test.go

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

bandopen_sources.go

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

catlinksig_test.go

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

changelog.json

@@ -1,4 +1,168 @@
 [
+  {
+    "version": "0.26.3",
+    "date": "",
+    "en": [
+      "Ultrabeam: the controller can be reached over a plain serial port, not only over the network. It has an RS232 port and the PC is usually beside it, so an FTDI cable is the direct route — the RS232-to-Ethernet adapter is now only needed to put the antenna at the far end of a link. Same choice the SteppIR has always had, in the same place.",
+      "Docked band map: FIT and FTx are now two labelled buttons in its header. Fit-to-band was hidden behind the px/kHz readout — a control whose label is a measurement does not look like one, and switching it off left nothing on screen saying the option existed. Hiding the digital spots is available there too, and both follow the Band Map tab.",
+      "Stats: the Entities tile now says which entity was added to the log most recently, with the callsign and date that did it. Judged against the whole log — a contact is the first with its country once, and does not become the first again because a date filter hides the ones before it.",
+      "Docked band map: in fit-to-band the header no longer printed FIT twice, once as the readout and once as the button beside it.",
+      "Settings: what OpsLog does with a FlexRadio — panadapter spots, decode spots and the DAX switch for voice messages — now lives in the FlexRadio page with the per-band antennas and power, instead of at the foot of the CAT page. CAT keeps the link itself: an address and a port, as for every other backend.",
+      "Cluster settings: four paragraphs of explanation removed. The options they described are unchanged.",
+      "A spot that is a new band AND a new mode for an entity is now its own status, NEW BAND+MODE, ranked with NEW DXCC. It used to be reported as a plain new band, which reads as \"you have worked this entity in this mode, just not here\" — the opposite of the truth. It is not a new slot either: a slot is the pair still missing when each half is already in the log. The cluster, the band map, the decodes panel, the filters and the auto-call criteria all tell the two apart now.",
+      "Cluster filters: a \"my bands\" link selects every band from your own band list in one click. With nothing selected the filter lets every band through — including 4 m and 70 cm off the RBN feeds, which the list could not offer you to untick because they are not bands you have.",
+      "FlexRadio: cluster spots on the panadapter are now coloured by what they are. A text colour and a background colour per status — new entity, new band+mode, new band, new mode, new slot, new park, new county, new prefix, your own callsign, already worked — set in Settings → FlexRadio, with a preview of each pair. Every spot used to be the same orange, which threw away the only thing worth knowing at a glance on a waterfall.",
+      "FlexRadio: clicking a spot can resize the panadapter to suit the mode — 25 kHz for CW, 200 for phone, 50 for digital by default, each configurable, with an option to re-centre on the spot as well. A CW signal is a hair at 200 kHz and an FT8 window shows an eighth of its sub-band at 25 kHz; one width cannot serve all three. Settings → FlexRadio, off by default.",
+      "FlexRadio: panadapter spots now carry their status in the comment as well as their colour — [NEW DXCC], [NEW BAND+MODE], [NEW BAND] and so on.",
+      "FlexRadio: the panadapter zoom now also applies when you click a spot on the panadapter itself, not just in the band map or cluster.",
+      "FlexRadio: fixed the panadapter zoom leaving the clicked spot off screen. The display now re-centres whenever the spot would fall outside the new window, and stays put when it would not.",
+      "Awards (F3): a NEW badge marks each award reference on the current QSO that has never been worked, picked or detected alike."
+    ],
+    "fr": [
+      "Ultrabeam : le contrôleur se joint par un simple port série, plus seulement par le réseau. Il a une prise RS232 et le PC est en général juste à côté : un câble FTDI suffit — l'adaptateur RS232 vers Ethernet ne sert plus qu'à mettre l'antenne au bout d'une liaison. Le même choix que le SteppIR a toujours eu, au même endroit.",
+      "Bandmap ancrée : FIT et FTx sont désormais deux boutons nommés dans son en-tête. L'ajustement à la bande se cachait derrière l'indicateur px/kHz — un contrôle dont le libellé est une mesure n'a pas l'air d'un contrôle, et une fois désactivé plus rien à l'écran ne disait que l'option existait. Le masquage des spots numériques y est aussi, et les deux suivent l'onglet Bandmap.",
+      "Statistiques : la tuile Entités indique désormais quelle entité a été ajoutée au journal en dernier, avec l'indicatif et la date qui l'ont fait. Jugé sur le journal entier — un contact n'est le premier avec son pays qu'une fois, et ne le redevient pas parce qu'un filtre de date masque ceux d'avant.",
+      "Bandmap ancrée : en mode ajusté, l'en-tête n'affiche plus FIT deux fois, une comme indicateur et une comme bouton juste à côté.",
+      "Réglages : ce qu'OpsLog fait avec un FlexRadio — spots panadapter, spots de décodages et la bascule DAX pour les messages vocaux — se trouve désormais sur la page FlexRadio, avec les antennes et la puissance par bande, au lieu du bas de la page CAT. La page CAT garde la liaison elle-même : une adresse et un port, comme pour tous les autres backends.",
+      "Réglages du cluster : quatre pavés d'explication retirés. Les options qu'ils décrivaient sont inchangées.",
+      "Un spot qui est à la fois une nouvelle bande ET un nouveau mode pour une entité a désormais son propre statut, NOUVEAU BANDE+MODE, au même rang que NOUVEAU DXCC. Il était annoncé comme une simple nouvelle bande, ce qui se lit « tu as déjà fait cette entité dans ce mode, juste pas ici » — l'inverse de la vérité. Ce n'est pas non plus un nouveau slot : un slot est la paire qui manque quand chaque moitié est déjà au journal. Le cluster, la bandmap, le panneau des décodages, les filtres et les critères d'appel automatique font maintenant la différence.",
+      "Filtres du cluster : un lien « mes bandes » sélectionne d'un clic toutes les bandes de ta propre liste. Sans sélection, le filtre laisse passer toutes les bandes — y compris le 4 m et le 70 cm des flux RBN, que la liste ne pouvait pas te proposer de décocher puisque ce ne sont pas des bandes que tu as.",
+      "FlexRadio : les spots cluster sur le panadapter sont désormais colorés selon ce qu'ils sont. Une couleur de texte et une couleur de fond par statut — nouvelle entité, nouvelle bande+mode, nouvelle bande, nouveau mode, nouveau slot, nouveau parc, nouveau comté, nouveau préfixe, ton propre indicatif, déjà contacté — réglées dans Réglages → FlexRadio, avec un aperçu de chaque paire. Tous les spots étaient de la même couleur orange, ce qui jetait la seule chose qui compte au premier coup d'œil sur une cascade.",
+      "FlexRadio : cliquer un spot peut redimensionner le panadapter selon le mode — 25 kHz en CW, 200 en phonie, 50 en numérique par défaut, chacun réglable, avec une option pour recentrer aussi sur le spot. Un signal CW est un cheveu à 200 kHz et une fenêtre FT8 montre un huitième de sa sous-bande à 25 kHz ; une seule largeur ne peut pas servir les trois. Réglages → FlexRadio, désactivé par défaut.",
+      "FlexRadio : les spots du panadapter portent maintenant leur statut dans le commentaire en plus de la couleur — [NEW DXCC], [NEW BAND+MODE], [NEW BAND], etc.",
+      "FlexRadio : le zoom du panadapter s'applique aussi quand on clique un spot sur le panadapter lui-même, et plus seulement dans la bandmap ou le cluster.",
+      "FlexRadio : correction du zoom du panadapter qui laissait parfois le spot hors écran. L'affichage se recentre désormais dès que le spot sortirait de la nouvelle fenêtre, et ne bouge pas sinon.",
+      "Diplômes (F3) : un badge NEW signale chaque référence du QSO en cours jamais contactée, choisie à la main ou détectée."
+    ]
+  },
+  {
+    "version": "0.26.2",
+    "date": "",
+    "en": [
+      "Saving preferences no longer drops the rig. The CAT link — and the shared CAT server WSJT-X and JTDX connect to — is now rebuilt only when something about the connection itself changed, so pressing Save mid-QSO no longer throws them off with an error. The same restart was what wiped the spots off a FlexRadio panadapter on every save.",
+      "The log now records when WSJT-X or JTDX arms and disarms its transmitter. When a station is called and nothing goes out, that line says whether the far end ever enabled Tx — the one thing OpsLog asks for but cannot do itself.",
+      "Grid squares map: the world is drawn once instead of repeating east and west, it can be zoomed out far enough to hold Greenland and Antarctica at the same time, and the space beside the planet is the panel's own background instead of a wall of grey \"map data not yet available\" tiles.",
+      "Grid squares map: All, Phone and CW join Digital and FTx in the mode filter.",
+      "Motorised antenna over serial: the COM port is now picked from a list of the ports actually present, with a refresh button — and still accepts one typed by hand, for an adapter that is not plugged in yet.",
+      "Awards: choosing \"no field\" now clears the fallback searches with it. They kept running on their own fields while the panel no longer showed them, so an award declared to match nothing still found references.",
+      "Callbook lookup now reads the Russian district (RDA) from HamQTH and fills it as the contact's RDA reference. Only on the QSO being typed, never on one already logged: the callbook gives the district a station operates from today, and stamping that on an older contact would rewrite a correct entry into a false one.",
+      "FlexRadio: when the meters stay dead, the log now says why. The meter stream is UDP sent from the radio to OpsLog, and a firewall blocking it leaves a perfectly healthy TCP link with meters at zero and no explanation — the line names the port and what to allow.",
+      "The Russian district database is now built in: 58 188 callsigns, with the dated periods each operated from each district. It fills the RDA reference while you type a Russian callsign — for the day of the contact, not for today — and Settings → Awards fills it on every Russian QSO already in the log. A reference you assigned by hand is never overwritten.",
+      "New Settings → Maintenance → Databases: every reference database OpsLog keeps on disk on its own line — country file, Club Log exceptions, LoTW users, Super Check Partial, US counties, Russian districts — plus one line per updatable award reference list (IOTA, POTA, SOTA, WWFF). Each says what it holds and when it was refreshed. The updaters were scattered across the Awards manager and three settings pages before. Tools no longer carries \"Refresh cty.dat\" and \"Download reference lists\" — both are lines on that page now.",
+      "FT decodes: the auto-call no longer offers a SOTA criterion. It was declared and translated but could never be ticked, and a decode carries no summit reference for it to test — a setting that promised something the feature cannot do.",
+      "Auto-call: the slot criterion is named \"a new slot (band+mode never worked together)\" — the same word the cluster and the decodes panel already badge it with. \"A new band+mode slot\" read as \"a new band AND a new mode\", which is the one thing it is not.",
+      "Voice keyer: typing a callsign stops the auto-CQ. It stopped the CW auto-call and left the voice keyer calling CQ over the station that had just answered — the reason to stop has nothing to do with Morse, so both engines now stop on the same event.",
+      "The motorised antenna (Ultrabeam / SteppIR) now has a docked widget of its own, with a dish icon beside the entry strip: pattern (Normal / 180° / Bi), band buttons, ±25 kHz nudge and Retract — what you touch between contacts. Tracking, its mode and step, and the per-element lengths stay in the Station Control tab, where they are set once. The icon pulses amber while the elements travel.",
+      "FT decodes: a station with a compound callsign is no longer invisible. FT8 sends such a call as a hash, printed between angle brackets — \"F4BPO <ZA/IW2JOP> -24\" — and every decode carrying one was discarded as unparseable, including the reply telling you that station had answered. The two-message form (\"… RR73; … <call> -08\") is read correctly too.",
+      "The log now records when a profile re-applies every subsystem. That rebuild is what dropped WSJT-X's CAT connection — an operator's log showed it happening 54 times in one session, three of them while the rig was keyed — and nothing said it was happening at all.",
+      "The shared CAT server is never torn down while the rig is transmitting. A rebuild that really is needed now waits for the over to end — closing the socket mid-transmission is what left WSJT-X inside a run of Hamlib calls with nothing at the other end.",
+      "Autostart: a program can be closed when OpsLog closes. Per program, so the rotator controller can stay while WSJT-X goes, and only ever a polite close — the way clicking its cross would — of a program OpsLog itself started.",
+      "Awards: switching a column between the reference and its description is now immediate. It rebuilt every award for every contact in the log — work with a known answer, since a relabel cannot change which QSOs match. Only that award is recomputed, and only on the rows that already carry it. The full recompute also reads twenty-seven columns per QSO instead of a hundred and fifty."
+    ],
+    "fr": [
+      "Enregistrer les préférences ne coupe plus la radio. La liaison CAT — et le serveur CAT partagé auquel WSJT-X et JTDX se connectent — n'est reconstruite que si la connexion elle-même a changé, si bien qu'un Enregistrer en plein QSO ne les éjecte plus avec une erreur. C'est ce même redémarrage qui effaçait les spots du panadapter FlexRadio à chaque enregistrement.",
+      "Le journal enregistre désormais quand WSJT-X ou JTDX arme et désarme son émetteur. Quand une station est appelée et que rien ne part, cette ligne dit si le logiciel distant a seulement activé Tx — la seule chose qu'OpsLog demande sans pouvoir la faire à sa place.",
+      "Carte des carrés locator : le monde est dessiné une seule fois au lieu de se répéter d'est en ouest, le zoom arrière descend assez bas pour tenir le Groenland et l'Antarctique en même temps, et l'espace à côté de la planète est le fond du panneau au lieu d'un mur de tuiles grises « map data not yet available ».",
+      "Carte des carrés locator : Tout, Phonie et CW rejoignent Numérique et FTx dans le filtre de mode.",
+      "Antenne motorisée en liaison série : le port COM se choisit maintenant dans la liste des ports réellement présents, avec un bouton d'actualisation — et accepte toujours une saisie à la main, pour un adaptateur qui n'est pas encore branché.",
+      "Diplômes : choisir « aucun champ » efface désormais les recherches de repli avec lui. Elles continuaient de tourner sur leurs propres champs alors que le panneau ne les affichait plus, si bien qu'un diplôme déclaré ne rien reconnaître trouvait quand même des références.",
+      "La recherche callbook lit désormais le district russe (RDA) chez HamQTH et le renseigne comme référence RDA du contact. Uniquement sur le QSO en cours de saisie, jamais sur un QSO déjà journalisé : le callbook donne le district d'où la station émet aujourd'hui, et l'appliquer à un contact ancien transformerait une entrée correcte en entrée fausse.",
+      "FlexRadio : quand les mesures restent mortes, le journal dit maintenant pourquoi. Le flux de mesures est un envoi UDP de la radio vers OpsLog, et un pare-feu qui le bloque laisse une liaison TCP parfaitement saine avec des aiguilles à zéro et aucune explication — la ligne nomme le port et ce qu'il faut autoriser.",
+      "La base des districts russes est désormais intégrée : 58 188 indicatifs, avec les périodes datées passées dans chaque district. Elle renseigne la référence RDA pendant que tu tapes un indicatif russe — pour le jour du contact, pas pour aujourd'hui — et Réglages → Diplômes la renseigne sur tous les QSO russes déjà journalisés. Une référence attribuée à la main n'est jamais écrasée.",
+      "Nouveau Réglages → Maintenance → Bases de données : chaque base de référence qu'OpsLog garde sur disque a sa ligne — fichier pays, exceptions Club Log, utilisateurs LoTW, Super Check Partial, comtés US, districts russes — plus une ligne par liste de références de diplôme actualisable (IOTA, POTA, SOTA, WWFF). Chacune dit ce qu'elle contient et sa dernière actualisation. Les mises à jour étaient jusqu'ici dispersées entre le gestionnaire de diplômes et trois pages de réglages. Le menu Outils ne porte plus « Refresh cty.dat » ni « Download reference lists » — les deux sont des lignes de cette page.",
+      "Décodages FT : l'appel automatique ne propose plus de critère SOTA. Il était déclaré et traduit mais impossible à cocher, et un décodage ne porte aucune référence de sommet à tester — un réglage qui promettait ce que la fonction ne sait pas faire.",
+      "Appel automatique : le critère de slot s'appelle désormais « un nouveau slot (bande+mode jamais faits ensemble) » — le mot que le cluster et le panneau des décodages emploient déjà sur leur pastille. « Un nouveau couple bande+mode » se lisait comme « une nouvelle bande ET un nouveau mode », ce qu'il n'est justement pas.",
+      "Manipulateur vocal : taper un indicatif arrête l'appel automatique. Il arrêtait l'auto-call CW et laissait le DVK appeler CQ par-dessus la station qui venait de répondre — la raison de s'arrêter n'a rien à voir avec la télégraphie, les deux moteurs s'arrêtent donc sur le même événement.",
+      "L'antenne motorisée (Ultrabeam / SteppIR) a désormais son widget ancré, avec une icône de parabole à côté de la barre de saisie : diagramme (Normal / 180° / Bi), boutons de bande, décalage ±25 kHz et Rétracter — ce qu'on touche entre deux contacts. Le suivi, son mode et son pas, ainsi que les longueurs d'éléments restent dans l'onglet Station, où ils se règlent une fois pour toutes. L'icône clignote en ambre pendant que les éléments se déplacent.",
+      "Décodages FT : une station à indicatif composé n'est plus invisible. Le FT8 transmet un tel indicatif sous forme de hachage, affiché entre chevrons — « F4BPO <ZA/IW2JOP> -24 » — et tout décodage en contenant un était jeté comme illisible, y compris la réponse qui t'annonçait que cette station t'avait répondu. La forme à deux messages (« … RR73; … <indicatif> -08 ») est également lue correctement.",
+      "Le journal enregistre désormais quand un profil ré-applique tous ses sous-systèmes. C'est cette reconstruction qui coupait la liaison CAT de WSJT-X — le journal d'un opérateur en montre 54 dans une seule session, dont trois pendant que la radio émettait — et rien n'indiquait qu'elle avait lieu.",
+      "Le serveur CAT partagé n'est plus jamais démonté pendant que la radio émet. Une reconstruction réellement nécessaire attend la fin de l'émission — fermer la socket en pleine transmission, c'est ce qui laissait WSJT-X au milieu d'une série d'appels Hamlib sans personne à l'autre bout.",
+      "Démarrage auto : un programme peut être fermé à la fermeture d'OpsLog. Au cas par cas, pour que le contrôleur de rotor reste pendant que WSJT-X s'en va, et toujours une demande de fermeture polie — comme un clic sur sa croix — d'un programme lancé par OpsLog lui-même.",
+      "Diplômes : basculer une colonne entre la référence et sa description est désormais immédiat. L'opération reconstruisait tous les diplômes de tous les contacts du journal — un travail au résultat connu d'avance, puisqu'un changement d'étiquette ne change pas quels QSO correspondent. Seul ce diplôme est recalculé, et seulement sur les lignes qui le portent déjà. Le recalcul complet lit aussi vingt-sept colonnes par QSO au lieu de cent cinquante."
+    ]
+  },
+  {
+    "version": "0.26.1",
+    "date": "",
+    "en": [
+      "Auto-call: a QSO in progress is now held by OpsLog itself, so a new station is no longer called in the middle of an exchange. The hold is released when that QSO is logged, when you halt or click another decode, and after four minutes without a contact.",
+      "Rotor widget: the Stop button now lights up when pressed, like the direction presets, so there is no doubt the order went out.",
+      "FT decodes: a decode could go missing from the panel when a period arrived as one burst — the internal queue discarded it in silence. It is now deep enough for a full period, panadapter spots no longer hold the stream up, and anything still lost is written to the log.",
+      "Closing OpsLog can no longer leave a process behind. Each shutdown step is written to the log, and if one of them hangs the application now forces its own exit instead of staying open — which also unblocks the restart after an update.",
+      "CAT: a rig link whose polling loop got stuck no longer freezes every later reconnection attempt in silence. The wait is now bounded and the problem is written to the log, instead of a radio that never comes back and no explanation anywhere.",
+      "Cluster console: the replies to your commands are no longer buried under the spot flood. A Replies button — on by default — hides the DX spots, which the list above already shows.",
+      "Cluster: twelve named command buttons beside the command box — name one \"Show filters\", give it SH/FILTER, and one click sends it. They are set up in Settings → Cluster; a button with no command is not shown.",
+      "Cluster console: a Follow button decides whether the view sticks to the newest line, and sending a command re-arms it — a long reply is now scrolled to instead of landing out of sight. Switch Follow off to read without being pulled back down; the arrow beside it returns to the end.",
+      "Band map: the docked map can be switched to fit-to-band from its own header — click the px/kHz readout. It is the same setting the Band Map tab drives, so the two always agree.",
+      "Awards: an award can now be set to search in NO field. The matching options disappear with it, and the award counts only the references you assign to a contact by hand — for a reference like WWBOTA, which has no ADIF field anywhere.",
+      "New award: WWBOTA (World Wide Bunkers on the Air), with its full reference list — 31 342 bunkers. References are assigned to a contact by hand, the award having no ADIF field of its own.",
+      "Grid squares map: the map now fills its panel. It measured its container once, while the tab was still hidden, and kept that size — leaving a blank band under it whatever the window size.",
+      "Grid squares map: the fill colours for confirmed and worked squares can be chosen, beside the basemap selector. Left alone they follow the theme, and one click puts them back.",
+      "QSL cards: the QSO box now carries the frequency in megahertz alongside the band, and the designer lets you choose which columns it shows — date, UTC, band, frequency, mode, submode, RST.",
+      "Main view: up to four panes instead of two. A third and a fourth can be chosen — or left empty, in which case they are not drawn — and with four you pick between quarters (2 × 2) and four columns. Every divider is draggable, each arrangement is remembered for its own pane count, and a double-click evens it out.",
+      "Appearance: the alternating row shading in Recent QSOs can be switched off — every row the same colour — or given a colour of its own. It is independent of the QSL row colours, which still take precedence on the rows they paint.",
+      "QSL row colours: the \"left stripe\" style no longer draws a coloured hairline along the top and bottom of every coloured row. The stripe is painted differently — it is a stripe again, and nothing else.",
+      "QSL designer: the preview contact now fills every column the QSO box can show, frequency and submode included. A blank column promised room the printed card would not have."
+    ],
+    "fr": [
+      "Appel automatique : le QSO en cours est désormais verrouillé par OpsLog lui-même, si bien qu'une nouvelle station n'est plus appelée au milieu d'un échange. Le verrou est levé quand ce QSO est journalisé, quand tu fais Stop ou cliques un autre décodage, et au bout de quatre minutes sans contact.",
+      "Widget rotor : le bouton Stop s'allume maintenant quand on l'enfonce, comme les présélections de direction, pour ne plus douter que l'ordre est parti.",
+      "Décodages FT : un décodage pouvait manquer dans le panneau quand une période arrivait d'un bloc — la file interne le jetait sans rien dire. Elle est désormais dimensionnée pour une période entière, les spots panadapter ne retiennent plus le flux, et ce qui serait encore perdu est écrit dans le journal.",
+      "Fermer OpsLog ne peut plus laisser un processus derrière. Chaque étape d'arrêt est écrite dans le journal, et si l'une d'elles se bloque l'application force désormais sa propre sortie au lieu de rester ouverte — ce qui débloque aussi le redémarrage après une mise à jour.",
+      "CAT : une liaison radio dont la boucle d'interrogation se bloquait figeait en silence toutes les tentatives de reconnexion suivantes. L'attente est désormais bornée et le problème écrit dans le journal, au lieu d'une radio qui ne revient jamais sans la moindre explication.",
+      "Console cluster : les réponses à tes commandes ne sont plus noyées sous le flot de spots. Un bouton Réponses — actif par défaut — masque les spots DX, que la liste au-dessus affiche déjà.",
+      "Cluster : douze boutons de commande nommés à côté du champ de saisie — nomme-en un « Voir filtres », donne-lui SH/FILTER, et un clic l'envoie. Ils se règlent dans Réglages → Cluster ; un bouton sans commande n'est pas affiché.",
+      "Console cluster : un bouton Suivre décide si la vue reste collée à la dernière ligne, et envoyer une commande le réarme — une longue réponse défile maintenant jusqu'à elle au lieu d'arriver hors champ. Désactive Suivre pour lire sans être ramené en bas ; la flèche à côté revient à la fin.",
+      "Bandmap : la carte ancrée peut passer en ajustement à la bande depuis son propre en-tête — cliquer l'indicateur px/kHz. C'est le même réglage que celui de l'onglet Bandmap, les deux sont donc toujours d'accord.",
+      "Diplômes : un diplôme peut désormais ne chercher dans AUCUN champ. Les options de reconnaissance disparaissent avec lui, et le diplôme ne compte que les références attribuées à la main sur un contact — pour une référence comme WWBOTA, qui n'a de champ ADIF nulle part.",
+      "Nouveau diplôme : WWBOTA (World Wide Bunkers on the Air), avec sa liste de références complète — 31 342 bunkers. Les références s'attribuent à la main sur un contact, le diplôme n'ayant pas de champ ADIF propre.",
+      "Carte des carrés locator : la carte occupe enfin tout son panneau. Elle mesurait son conteneur une seule fois, alors que l'onglet était encore masqué, et gardait cette taille — d'où la bande vide en dessous quelle que soit la taille de la fenêtre.",
+      "Carte des carrés locator : les couleurs des carrés confirmés et contactés se choisissent, à côté du sélecteur de fond de carte. Laissées telles quelles, elles suivent le thème, et un clic les y ramène.",
+      "Cartes QSL : le tableau du QSO porte désormais la fréquence en mégahertz à côté de la bande, et le concepteur permet de choisir les colonnes affichées — date, UTC, bande, fréquence, mode, sous-mode, RST.",
+      "Vue principale : jusqu'à quatre volets au lieu de deux. Un troisième et un quatrième se choisissent — ou se laissent vides, auquel cas ils ne sont pas dessinés — et avec quatre tu choisis entre les quarts (2 × 2) et quatre colonnes. Chaque séparateur se glisse, chaque disposition est mémorisée pour son propre nombre de volets, et un double-clic la remet à égalité.",
+      "Apparence : l'alternance de teinte une ligne sur deux dans QSO récents peut être désactivée — toutes les lignes de la même couleur — ou recevoir sa propre couleur. Elle est indépendante des couleurs de ligne QSL, qui restent prioritaires sur les lignes qu'elles peignent.",
+      "Couleurs de ligne QSL : le style « barre à gauche » ne trace plus un filet coloré en haut et en bas de chaque ligne colorée. La barre est peinte autrement — c'est de nouveau une barre, et rien d'autre.",
+      "Concepteur QSL : le contact d'aperçu remplit maintenant toutes les colonnes que le tableau peut afficher, fréquence et sous-mode compris. Une colonne vide promettait une place que la carte imprimée n'avait pas."
+    ]
+  },
+  {
+    "version": "0.26.0",
+    "date": "",
+    "en": [
+      "A new FT decodes tab: every decode from WSJT-X, JTDX or MSHV, grouped by transmit period, with what is new and what you are sending. Clicking a decode asks the application to call that station, exactly as double-clicking the line in its own window does. Columns are resizable and remembered, the filter bar with them, Clear empties the lists and Halt stops the transmission. With two receivers running the table splits into one column per band, each with its own transmit line, Halt and Clear, and the column lights up when that receiver is on the air. On a FlexRadio, answering a decode moves the transmitter to the slice listening on that band — unless that band already transmits, so an existing split is left alone.",
+      "FT decodes: auto-call. OpsLog can answer a decode without you clicking it — pick what qualifies (a new entity, band, mode, band+mode slot, grid, US county, POTA park or WPX prefix) and add a watch list of callsigns, with or without conditions of their own. It answers a CQ only, one station at a time across the whole station, never while any receiver is still mid-QSO, with a cooldown per callsign, and every call is written to the log with its reason. Armed from the decodes toolbar or Settings → FTx decodes, and off until you turn it on.",
+      "A grid-square map (Tools → Grid squares): every 4-character square in the log, confirmed squares solid and worked ones faint, scoped to digital or the FT modes, on the basemap of your choice. It answers the one question a decode list cannot — not who is on the band, but where the station has actually been reaching.",
+      "UDP: a new outbound type relays the WSJT-X stream. Every datagram received from WSJT-X, JTDX or MSHV is re-sent byte for byte to another program — JTAlert, GridTracker, a second logger — which each sender cannot do on its own, since they talk to one address only. Forwarded verbatim, with no origin header of the kind that has to be stripped back off at the far end, and a target naming one of OpsLog’s own ports is refused rather than looped.",
+      "New-grid detection now reads the grid from a reply as well as from a CQ. \"C91RU IZ5EME JN52\" — a station answering with its locator — is the commonest grid-bearing message on a busy band, and only CQs were being read: any station whose CQ you happened to miss had no known grid at all and could never be flagged as a new one. This is why other tools showed far more wanted grids than OpsLog did.",
+      "New-grid chasing is now scoped the way GridTracker scopes it, so the two agree. Pick how a square counts as already worked — this band or any band, crossed with any digital mode, this exact mode, or any FT mode (FT8/FT4/FT2) — and whether to chase only squares never worked or unconfirmed ones too, which are still missing from the award. The two are shown differently: a square never worked is a QSO to make, one worked and awaiting a confirmation is a QSL to chase, and they no longer share a badge. Settings → DX Cluster. The decodes table also gained a Grid column.",
+      "Cluster: NEW badges now clear after a contact however it was logged. Only hand-logging refreshed the worked snapshot, so a station worked through WSJT-X / JTDX / MSHV — or replayed from the offline outbox, arriving from a multi-op partner, or imported from the POTA hunter log — kept its NEW, NEW BAND, NEW MODE, NEW SLOT, NEW GRID, NEW PFX or NEW POTA badge for the rest of the session.",
+      "DX cluster: the Spotter continent filter matches again. One callsign is spotted by skimmers all over the world within a minute, and they all shared a single cached entry belonging to whichever spotter arrived first — so picking AF left the Indian and American skimmers in the list. Each spot now carries its own spotter continent. Alert rules on the spotter’s continent or country were missing RBN spots for a related reason and now match too.",
+      "Recent QSOs: the callsign search takes wildcards. A plain word now matches the START of a call — 4S finds 4S7AB — while * is any run of characters and ? exactly one, so *4S ends with 4S and *4S* contains it anywhere. It was an unconditional contains-match before, which made asking for a prefix impossible.",
+      "QSL Manager: the right-click menu now carries the same actions as Recent QSOs — ADIF export of the selection, export with a chosen field set, Cabrillo, bulk edit, the callbook and cty.dat updates, e-mail and delete. Filtered exports are deliberately not offered here: \"the filter\" means the Recent-QSOs filter, not the rows on screen. Two entries that appeared in this tab and did nothing when clicked are fixed at the same time — the menu now shows an action only where it is actually wired.",
+      "Column pickers and the ADIF export field chooser gained a whole-dialog Select all / Clear. Only per-group links existed, so clearing a selection meant one click per group — a dozen of them before you could tick the handful you actually wanted. Applies to Recent QSOs, Worked before, the cluster list and the export dialog, and covers the award columns the per-group links never touched.",
+      "Rotator: a Compact mode option (Settings → Rotator) reduces the rotor widget to the dial and the short/long-path azimuths under it. Left off, the widget keeps its quick-turn buttons, azimuth box and Stop.",
+      "Band-opening watch: the radius that counts a receiver as \"around here\" is now adjustable (Settings → DX Cluster), 25–1000 km, still 300 km by default. An opening on 10 m reaches a whole region, a 2 m duct does not, and the right distance is a judgement only the operator can make. Tightening it costs no extra traffic — the subscription is unchanged — only sensitivity.",
+      "Club Log uploads are now identified as OpsLog. They were credited to another station's application key, which took the blame for them.",
+      "ADIF import: \"fill my station fields\" now fills the station callsign too, on records that carry none."
+    ],
+    "fr": [
+      "Un onglet Décodages FT : tous les décodages de WSJT-X, JTDX ou MSHV, groupés par période d’émission, avec ce qui est nouveau et ce que tu émets. Cliquer un décodage demande au logiciel d’appeler cette station, exactement comme un double-clic sur la ligne dans sa propre fenêtre. Les colonnes se redimensionnent et sont mémorisées, la barre de filtres avec elles, Vider efface les listes et Stop arrête l’émission. Avec deux récepteurs, le tableau se scinde en une colonne par bande, chacune avec sa ligne d’émission, son Stop et son Vider, et la colonne s’allume quand c’est ce récepteur qui émet. Sur un FlexRadio, répondre à un décodage déplace l’émetteur sur la slice qui écoute cette bande — sauf si cette bande émet déjà, pour ne pas défaire un split en place.",
+      "Décodages FT : appel automatique. OpsLog peut répondre à un décodage sans que tu cliques — choisis ce qui le déclenche (nouvelle entité, bande, mode, couple bande+mode, carré, comté US, parc POTA ou préfixe WPX) et ajoute une liste d’indicatifs surveillés, avec ou sans conditions propres. Uniquement sur un CQ, une station à la fois pour toute la station, jamais tant qu’un récepteur est encore en QSO, avec un délai de garde par indicatif, et chaque appel est écrit dans le journal avec sa raison. S’arme depuis la barre d’outils des décodages ou Réglages → Décodages FTx, et reste désactivé tant que tu ne l’actives pas.",
+      "Une carte des carrés locator (Outils → Carrés locator) : tous les carrés de 4 caractères du journal, les confirmés en plein et les contactés en pâle, au choix en numérique ou en modes FT, sur le fond de carte de ton choix. Elle répond à la seule question qu’une liste de décodages ne peut pas traiter : non pas qui est sur la bande, mais jusqu’où la station porte réellement.",
+      "UDP : un nouveau type sortant relaie le flux WSJT-X. Chaque datagramme reçu de WSJT-X, JTDX ou MSHV est réémis octet pour octet vers un autre logiciel — JTAlert, GridTracker, un second carnet — ce qu’aucun émetteur ne sait faire seul puisqu’il ne parle qu’à une adresse. Transmis tel quel, sans l’en-tête d’origine qu’il faut ensuite retirer à l’autre bout, et une cible désignant un port d’écoute d’OpsLog est refusée au lieu de boucler.",
+      "La détection des nouveaux carrés lit désormais le locator dans une réponse autant que dans un CQ. « C91RU IZ5EME JN52 » — une station qui répond avec son locator — est le message porteur de locator le plus fréquent sur une bande chargée, et seuls les CQ étaient lus : une station dont on avait manqué le CQ n’avait aucun locator connu et ne pouvait jamais être signalée comme nouvelle. C’est ce qui expliquait l’écart avec les autres logiciels sur le nombre de carrés recherchés.",
+      "La chasse aux nouveaux carrés se règle désormais comme dans GridTracker, pour que les deux soient d’accord. Choisis ce qui fait qu’un carré est déjà fait — cette bande ou toutes bandes, croisé avec tout mode numérique, ce mode exact, ou tout mode FT (FT8/FT4/FT2) — et si tu chasses seulement les carrés jamais contactés ou aussi les non confirmés, qui manquent encore au diplôme. Les deux s’affichent différemment : un carré jamais contacté est un QSO à faire, un carré contacté en attente de confirmation est une QSL à relancer, et ils ne partagent plus le même badge. Réglages → Cluster DX. Le tableau des décodages gagne aussi une colonne Locator.",
+      "Cluster : les badges NEW s’effacent enfin après un contact, quel que soit le mode de journalisation. Seule la saisie manuelle rafraîchissait l’instantané des contacts, si bien qu’une station travaillée via WSJT-X / JTDX / MSHV — ou rejouée depuis la file hors-ligne, reçue d’un partenaire multi-op, ou importée du journal chasseur POTA — gardait son badge NEW, NEW BAND, NEW MODE, NEW SLOT, NEW GRID, NEW PFX ou NEW POTA jusqu’à la fin de la session.",
+      "Cluster DX : le filtre Continent du spotter fonctionne à nouveau. Un même indicatif est spotté par des skimmers du monde entier en une minute, et tous partageaient une seule entrée en cache appartenant au premier spotter arrivé — choisir AF laissait donc les skimmers indiens et américains dans la liste. Chaque spot porte désormais son propre continent de spotter. Les règles d’alerte sur le continent ou le pays du spotter rataient les spots RBN pour une raison voisine et fonctionnent aussi.",
+      "QSO récents : la recherche d’indicatif accepte les jokers. Un mot simple correspond désormais au DÉBUT de l’indicatif — 4S trouve 4S7AB — tandis que * remplace n’importe quelle suite de caractères et ? exactement un : *4S se termine par 4S, *4S* le contient n’importe où. C’était auparavant une recherche « contient » systématique, qui rendait impossible la recherche par préfixe.",
+      "Gestionnaire QSL : le menu contextuel propose désormais les mêmes actions que les QSO récents — export ADIF de la sélection, export avec choix des champs, Cabrillo, édition en masse, mises à jour cty.dat et annuaires, e-mail et suppression. Les exports « filtrés » n’y sont volontairement pas offerts : « le filtre » désigne celui des QSO récents, pas les lignes affichées ici. Deux entrées qui apparaissaient dans cet onglet sans rien faire sont corrigées au passage — le menu n’affiche plus une action que là où elle est réellement branchée.",
+      "Les sélecteurs de colonnes et le choix des champs à l’export ADIF ont désormais un Tout sélectionner / Tout décocher global. Seuls les liens par groupe existaient, si bien que vider une sélection demandait un clic par groupe — une douzaine avant de pouvoir cocher les quelques champs voulus. Vaut pour les QSO récents, Déjà contacté, la liste cluster et la fenêtre d’export, et couvre les colonnes de diplômes que les liens par groupe ne touchaient pas.",
+      "Rotor : une option Mode compact (Réglages → Rotor) réduit le widget au cadran et aux azimuts courte/longue distance en dessous. Désactivée, le widget garde ses boutons de rotation rapide, sa case d’azimut et Stop.",
+      "Veille d’ouverture : le rayon qui fait qu’un récepteur compte comme « près d’ici » est désormais réglable (Réglages → Cluster DX), de 25 à 1000 km, toujours 300 km par défaut. Une ouverture sur 10 m couvre toute une région, un conduit sur 2 m non, et la bonne distance est un jugement qui n’appartient qu’à l’opérateur. Le resserrer ne coûte aucun trafic supplémentaire — l’abonnement ne change pas — seulement de la sensibilité.",
+      "Les envois Club Log s’identifient désormais comme OpsLog. Ils étaient attribués à la clé applicative d’une autre station, qui en portait la responsabilité.",
+      "Import ADIF : « remplir mes champs station » renseigne aussi l’indicatif de station, sur les enregistrements qui n’en portent pas."
+    ]
+  },
   {
     "version": "0.25.9",
     "date": "",

flexzoom.go

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

flexzoom_test.go

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

frontend/src/components/AppearancePanel.tsx

@@ -179,6 +179,31 @@ export function AppearancePanel() {
         <span>{t('appr.bandmapLotw')} <span className="text-xs text-muted-foreground">{t('appr.bandmapLotwHint')}</span></span>
       </label>
 
+      {/* Banding is its own thing, above the QSL rules and outside them: it says
+          nothing about a contact, it only helps the eye keep its line across a
+          wide table. Turning the status colours off must not take it away. */}
+      <div className="space-y-2">
+        <label className="flex items-start gap-2 text-sm cursor-pointer">
+          <Checkbox checked={(cfg as any).recent_zebra !== 'off'} className="mt-0.5"
+            onCheckedChange={(c) => save({ ...cfg, recent_zebra: c ? '' : 'off' } as any)} />
+          <span>{t('appr.zebra')} <span className="text-xs text-muted-foreground">{t('appr.zebraHint')}</span></span>
+        </label>
+        {(cfg as any).recent_zebra !== 'off' && (
+          <div className="flex items-center gap-2 pl-6">
+            <span className="text-xs text-muted-foreground">{t('appr.zebraColor')}</span>
+            <input type="color" className="size-7 rounded border border-border bg-transparent p-0 cursor-pointer"
+              value={/^#[0-9a-fA-F]{6}$/.test((cfg as any).recent_zebra_color ?? '') ? (cfg as any).recent_zebra_color : '#808080'}
+              onChange={(e) => save({ ...cfg, recent_zebra_color: e.target.value } as any)} />
+            {/* Empty means "follow the theme", and there has to be a way back to
+                it — a colour chosen under one theme is wrong under the other. */}
+            {(cfg as any).recent_zebra_color && (
+              <button type="button" className="text-xs text-muted-foreground hover:text-foreground"
+                onClick={() => save({ ...cfg, recent_zebra_color: '' } as any)}>{t('appr.zebraAuto')}</button>
+            )}
+          </div>
+        )}
+      </div>
+
       <label className="flex items-start gap-2 text-sm cursor-pointer">
         <Checkbox checked={cfg.enabled} className="mt-0.5"
           onCheckedChange={(c) => save({ ...cfg, enabled: !!c })} />

frontend/src/components/AwardEditor.tsx

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

frontend/src/components/AwardRefSelector.tsx

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

frontend/src/components/BandMap.tsx

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

frontend/src/components/ChaseNewPanel.tsx

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

frontend/src/components/ClusterGrid.tsx

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

frontend/src/components/ExportFieldsDialog.tsx

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

frontend/src/components/GridSquareMap.tsx

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

frontend/src/components/MainMap.tsx

@@ -61,8 +61,8 @@ const ESRI_STREET_ATTR = 'Tiles © Esri — Source: Esri, HERE, Garmin, &cop
 // Selectable basemaps for the world (great-circle) map. All key-free and all
 // LABELLED (country/continent names). `labelsUrl` adds a transparent place-name
 // overlay on top of an imagery basemap (so satellite keeps its names too).
-type BasemapKey = 'light' | 'voyager' | 'street' | 'satellite';
+export type BasemapKey = 'light' | 'voyager' | 'street' | 'satellite';
-const BASEMAPS: Record<BasemapKey, { label: string; url: string; attr: string; subdomains?: string; labelsUrl?: string }> = {
+export const BASEMAPS: Record<BasemapKey, { label: string; url: string; attr: string; subdomains?: string; labelsUrl?: string }> = {
   light:     { label: 'Light',     url: CARTO_LIGHT, attr: CARTO_ATTR, subdomains: 'abcd' },
   voyager:   { label: 'Voyager',   url: 'https://{s}.basemaps.cartocdn.com/rastertiles/voyager/{z}/{x}/{y}{r}.png',
                attr: CARTO_ATTR, subdomains: 'abcd' },
@@ -71,7 +71,7 @@ const BASEMAPS: Record<BasemapKey, { label: string; url: string; attr: string; s
                attr: 'Tiles &copy; Esri — Source: Esri, Maxar, Earthstar Geographics',
                labelsUrl: 'https://server.arcgisonline.com/ArcGIS/rest/services/Reference/World_Boundaries_and_Places/MapServer/tile/{z}/{y}/{x}' },
 };
-function loadBasemap(): BasemapKey {
+export function loadBasemap(): BasemapKey {
   const v = localStorage.getItem('opslog.mapBasemap');
   return v === 'voyager' || v === 'street' || v === 'satellite' ? v : 'light';
 }
@@ -80,18 +80,32 @@ function loadBasemap(): BasemapKey {
 // place-name overlay. updateWhenIdle/keepBuffer keep the number of live tiles
 // down: satellite loads TWO tile layers, so its tile count — and the composited
 // layers WebView2 has to hold — is double every other basemap's.
-function addBasemap(
+export function addBasemap(
   m: L.Map,
   key: BasemapKey,
   base: React.MutableRefObject<L.TileLayer | null>,
   labels: React.MutableRefObject<L.TileLayer | null>,
+  // noWrap draws the world ONCE instead of repeating it east and west.
+  //
+  // The great-circle map wants the repeats: a path from France to Japan reads
+  // better crossing a second copy of Asia than wrapping round the back. A map of
+  // where you have been heard does not — three North Americas is three times the
+  // same answer, and it makes the picture harder to read, not wider.
+  // bounds stops Leaflet asking for tiles outside the world at all: Esri answers
+  // those with a grey "Map data not yet available" image, and zoomed out on a
+  // wide window that is most of the screen.
+  opts?: { noWrap?: boolean; bounds?: L.LatLngBoundsExpression },
 ) {
   if (base.current) { m.removeLayer(base.current); base.current = null; }
   if (labels.current) { m.removeLayer(labels.current); labels.current = null; }
   const bm = BASEMAPS[key];
-  const opts: L.TileLayerOptions = { maxZoom: 19, updateWhenIdle: true, updateWhenZooming: false, keepBuffer: 1 };
+  const tileOpts: L.TileLayerOptions = {
-  base.current = L.tileLayer(bm.url, { ...opts, attribution: bm.attr, subdomains: bm.subdomains ?? 'abc' }).addTo(m);
+    maxZoom: 19, updateWhenIdle: true, updateWhenZooming: false, keepBuffer: 1,
-  if (bm.labelsUrl) labels.current = L.tileLayer(bm.labelsUrl, opts).addTo(m);
+    noWrap: !!opts?.noWrap,
+    ...(opts?.bounds ? { bounds: opts.bounds } : {}),
+  };
+  base.current = L.tileLayer(bm.url, { ...tileOpts, attribution: bm.attr, subdomains: bm.subdomains ?? 'abc' }).addTo(m);
+  if (bm.labelsUrl) labels.current = L.tileLayer(bm.labelsUrl, tileOpts).addTo(m);
 }
 
 function dot(color: string): L.DivIcon {

frontend/src/components/MotorAntennaWidget.tsx

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

frontend/src/components/QSLManagerModal.tsx

@@ -111,7 +111,33 @@ export function fmtQslDate(s?: string): string {
 
 // QSL Manager as an in-app tab panel: upload logged QSOs to online logbooks
 // and download confirmations, while the rest of the app stays usable.
-export function QSLManagerPanel({ onEditQSO }: { onEditQSO?: (id: number) => void } = {}) {
+// GridActions are the row actions the context menu offers, forwarded straight to
+// whichever grid this panel is showing.
+//
+// The FILTERED exports are deliberately absent. "Export everything the filter
+// matches" means the Recent-QSOs filter, and the rows here come from a different
+// query entirely — offering it would export something other than what is on the
+// screen, which is the one thing an export must never do. Selection-based
+// exports have no such ambiguity: the ids are the rows you ticked.
+export type GridActions = {
+  onUpdateFromCty?: (ids: number[]) => void;
+  onUpdateFromQRZ?: (ids: number[]) => void;
+  onUpdateFromClublog?: (ids: number[]) => void;
+  onUpdateCountyFromULS?: (ids: number[]) => void;
+  onSendTo?: (service: string, ids: number[]) => void;
+  onSendRecording?: (ids: number[]) => void;
+  onSendEQSL?: (ids: number[]) => void;
+  onBulkEdit?: (ids: number[]) => void;
+  onExportSelected?: (ids: number[]) => void;
+  onExportSelectedFields?: (ids: number[]) => void;
+  onExportCabrilloSelected?: (ids: number[]) => void;
+  onDelete?: (ids: number[]) => void;
+};
+
+export function QSLManagerPanel({ onEditQSO, actions }: {
+  onEditQSO?: (id: number) => void;
+  actions?: GridActions;
+} = {}) {
   const { t } = useI18n();
   const [service, setService] = useState('lotw');
   // The callsign this profile signs/uploads/downloads as for the selected
@@ -443,6 +469,8 @@ export function QSLManagerPanel({ onEditQSO }: { onEditQSO?: (id: number) => voi
                 total={paperRows.length}
                 selectAllSignal={paperSelAllSig}
                 onRowSelected={(ids) => setPaperSel(new Set(ids))}
+                {...actions}
+                onRowDoubleClicked={onEditQSO ? (q) => onEditQSO(q.id as number) : undefined}
               />
             </div>
           )
@@ -549,6 +577,8 @@ export function QSLManagerPanel({ onEditQSO }: { onEditQSO?: (id: number) => voi
               total={rows.length}
               selectAllSignal={uploadSelAllSig}
               onRowSelected={onUploadRowSelected}
+              {...actions}
+              onRowDoubleClicked={onEditQSO ? (q) => onEditQSO(q.id as number) : undefined}
             />
           </div>
         )}

frontend/src/components/QSOContextMenu.tsx

@@ -7,8 +7,8 @@ export type QSOMenuState = { x: number; y: number; ids: number[] } | null;
 type Props = {
   menu: QSOMenuState;
   onClose: () => void;
-  onUpdateFromCty: (ids: number[]) => void;
+  onUpdateFromCty?: (ids: number[]) => void;
-  onUpdateFromQRZ: (ids: number[]) => void;
+  onUpdateFromQRZ?: (ids: number[]) => void;
   onUpdateFromClublog?: (ids: number[]) => void;
   // Only passed once the offline US county database has been downloaded —
   // an entry that can only ever answer "no database" is not worth a line here.
@@ -98,20 +98,28 @@ export function QSOContextMenu({ menu, onClose, onUpdateFromCty, onUpdateFromQRZ
       <div className="px-3 py-1 text-[11px] uppercase tracking-wider text-muted-foreground">
         {t('qctx.selected', { n })}
       </div>
-      <button
+      {/* Conditional like every other entry. These two were drawn
-        className="flex w-full items-center gap-2 px-3 py-1.5 text-left hover:bg-accent/50"
+          unconditionally, and the grid passes them through an arrow that calls
-        onClick={() => { onUpdateFromCty(menu.ids); onClose(); }}
+          an optional handler — so in a grid that wires neither (the QSL
-      >
+          Manager) both appeared and did precisely nothing when clicked. */}
-        <Globe2 className="size-4 text-primary" />
+      {onUpdateFromCty && (
-        <span>{t('qctx.fixCountry')}</span>
+        <button
-      </button>
+          className="flex w-full items-center gap-2 px-3 py-1.5 text-left hover:bg-accent/50"
-      <button
+          onClick={() => { onUpdateFromCty(menu.ids); onClose(); }}
-        className="flex w-full items-center gap-2 px-3 py-1.5 text-left hover:bg-accent/50"
+        >
-        onClick={() => { onUpdateFromQRZ(menu.ids); onClose(); }}
+          <Globe2 className="size-4 text-primary" />
-      >
+          <span>{t('qctx.fixCountry')}</span>
-        <RefreshCw className="size-4 text-info" />
+        </button>
-        <span>{t('qctx.updateQrz')}</span>
+      )}
-      </button>
+      {onUpdateFromQRZ && (
+        <button
+          className="flex w-full items-center gap-2 px-3 py-1.5 text-left hover:bg-accent/50"
+          onClick={() => { onUpdateFromQRZ(menu.ids); onClose(); }}
+        >
+          <RefreshCw className="size-4 text-info" />
+          <span>{t('qctx.updateQrz')}</span>
+        </button>
+      )}
       {onUpdateFromClublog && (
         <button
           className="flex w-full items-center gap-2 px-3 py-1.5 text-left hover:bg-accent/50"

frontend/src/components/RecentQSOsGrid.tsx

@@ -631,6 +631,20 @@ export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal,
     api.setColumnsVisible(ids, false);
     saveColumnState();
   }
+  // Whole-dialog show/hide. showAll/hideAll cover the CATALOGUE only; the award
+  // columns live in their own persisted code set, so a global that skipped them
+  // would leave a row of columns behind and look broken.
+  function setEverything(visible: boolean) {
+    const api = gridRef.current?.api;
+    if (!api) return;
+    api.setColumnsVisible(COL_CATALOG.map((c) => c.colId!), visible);
+    if (awardCols && awardCols.length > 0) {
+      persistAwardShown(visible ? new Set(awardCols.map((a) => a.code.toUpperCase())) : new Set());
+      api.setColumnsVisible(awardCols.map((a) => `award_${a.code}`), visible);
+    }
+    saveColumnState();
+  }
+
   function resetDefaults() {
     const api = gridRef.current?.api;
     if (!api) return;
@@ -706,16 +720,20 @@ export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal,
             animateRows={false}
             suppressCellFocus
             getRowId={(p) => String((p.data as any).id)}
-            getRowStyle={(p) => rowStyleFor(p.data, rowColors ?? null)}
+            getRowStyle={(p) => rowStyleFor(p.data, rowColors ?? null, p.node.rowIndex ?? undefined)}
           />
         </div>
       </div>
 
+      {/* Every handler is passed STRAIGHT through, never wrapped in an arrow: a
+          wrapper is always truthy, so the menu drew "Fix country" and "Update
+          from the callsign databases" even in a grid that wired neither — and
+          clicking them did nothing at all. */}
       <QSOContextMenu
         menu={menu}
         onClose={() => setMenu(null)}
-        onUpdateFromCty={(ids) => onUpdateFromCty?.(ids)}
+        onUpdateFromCty={onUpdateFromCty}
-        onUpdateFromQRZ={(ids) => onUpdateFromQRZ?.(ids)}
+        onUpdateFromQRZ={onUpdateFromQRZ}
         onUpdateFromClublog={onUpdateFromClublog}
         onUpdateCountyFromULS={onUpdateCountyFromULS}
         onSendTo={onSendTo}
@@ -738,6 +756,16 @@ export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal,
               {t('rqg.pickerDesc')}
             </DialogDescription>
           </DialogHeader>
+          {/* Whole-dialog controls. The per-group links alone meant hiding
+              everything was one click PER GROUP, and there are a dozen. */}
+          <div className="flex items-center gap-1 px-5 text-[11px] text-muted-foreground">
+            <span>{t('rqg.pickerAllGroups')}</span>
+            <button type="button" className="text-[11px] text-primary hover:underline px-1"
+              onClick={() => setEverything(true)}>{t('rqg.all')}</button>
+            <span className="opacity-40">·</span>
+            <button type="button" className="text-[11px] text-muted-foreground hover:underline px-1"
+              onClick={() => setEverything(false)}>{t('rqg.none')}</button>
+          </div>
           <div className="grid grid-cols-3 gap-4 max-h-[60vh] overflow-y-auto px-5 py-3">
             {GROUP_ORDER.map((group) => {
               const cols = COL_CATALOG.filter((c) => c.group === group);

frontend/src/components/RotorCompass.tsx

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

frontend/src/components/SettingsModal.tsx

@@ -47,7 +47,9 @@ import {
   TestLoTWUpload, ListTQSLStationLocations,
   DownloadLoTWUsers, GetLoTWUsersStatus,
   GetScpStatus, SetScpEnabled, DownloadScp,
-  DownloadULSCounties, ULSStatus, BackfillUSCounties,
+  DownloadULSCounties, ULSStatus, BackfillUSCounties, BackfillRDA, RDADatabaseCount,
+  GetCtyDatInfo, RefreshCtyDat, GetAwardReferenceMeta, UpdateAwardReferenceList,
+  GetSpotColors, SaveSpotColors, ResetSpotColors, GetFlexZoom, SaveFlexZoom,
   ComputeStationInfo,
   GetUIPref, SetUIPref,
   GetFlexState, GetFlexBandAntennas, SaveFlexBandAntennas, GetFlexBandPower, SaveFlexBandPower,
@@ -55,7 +57,7 @@ import {
   GetFolderSync, SaveFolderSync, PickFolderSyncFolder, GetFolderSyncStatus, SyncFolderNow,
   GetRelayAuto, SaveRelayAuto, GetStationDevices,
   GetAwardDefs, GetTrackedAwards, SaveTrackedAwards,
-  GetBandOpenSettings, SaveBandOpenSettings, GetPSKReporterStatus, GetChaseNewGrids, SetChaseNewGrids, GetChaseNew, SetChaseNew, GetGridCacheStatus, GetLinkedAmps, SetLinkedAmps, GetSpotTTLMinutes, SetSpotTTLMinutes,
+  GetBandOpenSettings, SaveBandOpenSettings, GetGridScopeSettings, SaveGridScopeSettings, GetPSKReporterStatus, GetChaseNewGrids, SetChaseNewGrids, GetChaseNew, SetChaseNew, GetGridCacheStatus, GetLinkedAmps, SetLinkedAmps, GetSpotTTLMinutes, SetSpotTTLMinutes,
 } from '../../wailsjs/go/main/App';
 import type { profile as profileModels } from '../../wailsjs/go/models';
 import type { LookupSettingsForm, StationSettingsForm, ListsSettingsForm, ModePresetForm } from '@/types';
@@ -68,6 +70,7 @@ import {
 import { WebPublishPanel } from '@/components/WebPublishPanel';
 import { Button } from '@/components/ui/button';
 import { Input } from '@/components/ui/input';
+import { Combobox } from '@/components/ui/combobox';
 import { Label } from '@/components/ui/label';
 import { Textarea } from '@/components/ui/textarea';
 import { Checkbox } from '@/components/ui/checkbox';
@@ -76,12 +79,14 @@ import {
 } from '@/components/ui/select';
 import { cn } from '@/lib/utils';
 import { writeUiPref } from '@/lib/uiPref';
+import { loadAutoCall, autoCallKey, type AutoCallSettings, type AutoCallCriteria } from '@/lib/autocall';
 import { getDateFormat, setDateFormat, type DateFormat } from '@/lib/dateFormat';
 import { useI18n, FlagGB, FlagFR, type Lang } from '@/lib/i18n';
 import { useTheme, CONCRETE_THEMES, type ThemeChoice } from '@/lib/theme';
 import { OperatingPanel } from '@/components/OperatingPanel';
 import { AppearancePanel } from '@/components/AppearancePanel';
 import { UDPIntegrationsPanel } from '@/components/UDPIntegrationsPanel';
+import { loadClusterMacros, saveClusterMacros, type ClusterMacro } from '@/lib/clusterMacros';
 
 type LookupSettings = LookupSettingsForm;
 type StationSettings = StationSettingsForm;
@@ -166,7 +171,7 @@ interface Props {
   initialSection?: string;
   onClose: () => void;
   onSaved: () => void;
-  onMainPaneChanged?: (side: 'left' | 'right', value: string) => void; // live Main-view layout update
+  onMainPaneChanged?: (side: 'left' | 'right' | 'p3' | 'p4' | 'layout', value: string) => void; // live Main-view layout update
   flexAvailable?: boolean; // CAT backend is FlexRadio → offer it as a Main pane
   icomAvailable?: boolean; // CAT backend is Icom → offer the Icom console as a Main pane
   yaesuAvailable?: boolean; // CAT backend is Yaesu → offer the Yaesu console as a Main pane
@@ -200,8 +205,10 @@ type SectionId =
   | 'database'
   | 'autostart'
   | 'uscounties'
+  | 'databases'
   | 'awards'
   | 'cat'
+  | 'ftx'
   | 'rotator'
   | 'winkeyer'
   | 'antenna'
@@ -306,6 +313,7 @@ function buildTree(flexAvailable: boolean, t: (k: string) => string): TreeNode[]
         { kind: 'item', label: t('sec.modes'), id: 'lists-modes' },
       ]},
       { kind: 'item', label: t('sec.cluster'),     id: 'cluster' },
+      { kind: 'item', label: t('sec.ftx'),         id: 'ftx' },
       { kind: 'item', label: t('sec.udp'), id: 'udp' },
       { kind: 'item', label: t('sec.adifmon'), id: 'adifmon' },
       { kind: 'item', label: t('sec.foldersync'), id: 'foldersync' },
@@ -315,6 +323,15 @@ function buildTree(flexAvailable: boolean, t: (k: string) => string): TreeNode[]
       { kind: 'item', label: t('sec.autostart'), id: 'autostart' },
     ],
   },
+  {
+    // Maintenance is about DATA rather than settings: nothing in here changes
+    // how OpsLog behaves, it refreshes what it knows. That is why the reference
+    // lists moved out of the Awards manager — an operator updating SOTA is not
+    // editing an award, and had to open one to do it.
+    kind: 'group', label: t('nav.maintenance'), icon: Database, defaultOpen: true, children: [
+      { kind: 'item', label: t('sec.databases'), id: 'databases' },
+    ],
+  },
   {
     kind: 'group', label: t('nav.hardware'), icon: Server, defaultOpen: true, children: hardware,
   },
@@ -325,11 +342,12 @@ function buildTree(flexAvailable: boolean, t: (k: string) => string): TreeNode[]
 const SECTION_KEY: Partial<Record<SectionId, string>> = {
   station: 'sec.station', profiles: 'sec.profiles', operating: 'sec.operating', confirmations: 'sec.confirmations',
   'external-services': 'sec.external', appearance: 'sec.appearance', lookup: 'sec.lookup', 'lists-bands': 'sec.bands', 'lists-modes': 'sec.modes',
-  cluster: 'sec.cluster', backup: 'sec.backup', database: 'sec.database', autostart: 'sec.autostart', udp: 'sec.udp',
+  cluster: 'sec.cluster', ftx: 'sec.ftx', backup: 'sec.backup', database: 'sec.database', autostart: 'sec.autostart', udp: 'sec.udp',
   adifmon: 'sec.adifmon',
   foldersync: 'sec.foldersync',
   webpublish: 'sec.webpublish',
   uscounties: 'sec.uscounties',
+  databases: 'sec.databases',
   awards: 'sec.awards', cat: 'sec.cat', rotator: 'sec.rotator', winkeyer: 'sec.winkeyer', antenna: 'sec.antenna',
   antgenius: 'sec.antgenius', tunergenius: 'sec.tunergenius', pgxl: 'sec.pgxl', flex: 'sec.flex', audio: 'sec.audio', general: 'sec.general', email: 'sec.email',
   relayauto: 'sec.relayauto',
@@ -623,6 +641,19 @@ function AutostartPanelComponent() {
               <Input className="h-8 font-mono text-xs" value={p.args} placeholder="optional command-line arguments"
                 onChange={(e) => patch(p.id, { args: e.target.value })} />
             </div>
+            {/* Only what OpsLog started is ever closed — a copy the operator
+                opened themselves is theirs. The hint says so, because the
+                difference is invisible from here. */}
+            <label className="flex items-start gap-2 text-xs cursor-pointer">
+              <Checkbox className="mt-0.5" checked={!!(p as any).close_on_exit}
+                onCheckedChange={(c) => patch(p.id, { close_on_exit: !!c } as any)} />
+              <span>
+                Close it when OpsLog closes{' '}
+                <span className="text-muted-foreground">
+                  (asks it to close, the way clicking its cross would — and only if OpsLog started it)
+                </span>
+              </span>
+            </label>
             {launchMsg[p.id] && <div className="text-xs text-muted-foreground pl-[86px]">{launchMsg[p.id]}</div>}
           </div>
         ))}
@@ -1025,15 +1056,16 @@ function RelayAutoPanel() {
   );
 }
 
-// MainViewPanes lets the operator choose what the Main tab's left and right
+// MainViewPanes lets the operator choose what the Main tab shows, in up to four
-// panes show, independently: the great-circle map, the locator street map, the
+// panes. The first two are the view; the third and fourth can be left empty, and
-// cluster grid or the worked-before grid. Per-profile (stored via SetUIPref,
+// an empty one is not drawn at all. Per-profile (stored via SetUIPref, which is
-// which is profile-prefixed). Self-contained so it owns its async-loaded state.
+// profile-prefixed). Self-contained so it owns its async-loaded state.
-const MAIN_PANE_VALUES = ['map1', 'map2', 'cluster', 'worked', 'recent', 'netcontrol'];
+const MAIN_PANE_VALUES = ['map1', 'map2', 'cluster', 'worked', 'recent', 'netcontrol', 'decodes'];
-function MainViewPanes({ onChanged, flexAvailable, icomAvailable, yaesuAvailable }: { onChanged?: (side: 'left' | 'right', value: string) => void; flexAvailable?: boolean; icomAvailable?: boolean; yaesuAvailable?: boolean }) {
+const PANE_NONE = 'none';
+function MainViewPanes({ onChanged, flexAvailable, icomAvailable, yaesuAvailable }: { onChanged?: (side: 'left' | 'right' | 'p3' | 'p4' | 'layout', value: string) => void; flexAvailable?: boolean; icomAvailable?: boolean; yaesuAvailable?: boolean }) {
   const { t } = useI18n();
-  const [left, setLeft] = useState('map1');
+  const [panes, setPanes] = useState<Record<string, string>>({ left: 'map1', right: 'map2', p3: PANE_NONE, p4: PANE_NONE });
-  const [right, setRight] = useState('map2');
+  const [layout, setLayout] = useState('quad');
   // Radio-control panes are only offered when that CAT backend is active. Sorted A→Z.
   const options = [
     ...MAIN_PANE_VALUES,
@@ -1042,42 +1074,77 @@ function MainViewPanes({ onChanged, flexAvailable, icomAvailable, yaesuAvailable
     ...(yaesuAvailable ? ['yaesu'] : []),
   ].map((value) => ({ value, label: t(`settings.pane.${value}`) }))
     .sort((a, b) => a.label.localeCompare(b.label));
+  const KEYS: Record<string, string> = { left: 'mainPaneLeft', right: 'mainPaneRight', p3: 'mainPane3', p4: 'mainPane4' };
   useEffect(() => {
     const valid = (v: string) => v === 'flex' || v === 'icom' || v === 'yaesu' || MAIN_PANE_VALUES.includes(v);
-    Promise.all([GetUIPref('mainPaneLeft').catch(() => ''), GetUIPref('mainPaneRight').catch(() => '')])
+    Promise.all([
-      .then(([l, r]) => { if (valid(l)) setLeft(l); if (valid(r)) setRight(r); });
+      ...Object.values(KEYS).map((k) => GetUIPref(k).catch(() => '')),
+      GetUIPref('mainPaneLayout').catch(() => ''),
+    ]).then(([l, r, p3, p4, lay]) => {
+      setPanes({
+        left: valid(l) ? l : 'map1',
+        right: valid(r) ? r : 'map2',
+        p3: valid(p3) ? p3 : PANE_NONE,
+        p4: valid(p4) ? p4 : PANE_NONE,
+      });
+      if (lay === 'cols' || lay === 'quad') setLayout(lay);
+    });
+    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
-  const pick = (side: 'left' | 'right', v: string) => {
+  const pick = (side: string, v: string) => {
-    if (side === 'left') setLeft(v); else setRight(v);
+    setPanes((p) => ({ ...p, [side]: v }));
     // Persist (per-profile) AND tell the parent the new value directly, so the
     // Main view updates from the chosen value — never a stale DB re-read.
-    SetUIPref(side === 'left' ? 'mainPaneLeft' : 'mainPaneRight', v).catch(() => {});
+    SetUIPref(KEYS[side], v).catch(() => {});
-    onChanged?.(side, v);
+    onChanged?.(side as any, v);
   };
+  const pickLayout = (v: string) => {
+    setLayout(v);
+    SetUIPref('mainPaneLayout', v).catch(() => {});
+    onChanged?.('layout', v);
+  };
+  const filled = ['left', 'right', 'p3', 'p4'].filter((k) => panes[k] !== PANE_NONE).length;
+  const SIDES = [
+    { key: 'left', label: t('settings.leftPane'), canBeEmpty: false },
+    { key: 'right', label: t('settings.rightPane'), canBeEmpty: false },
+    { key: 'p3', label: t('settings.thirdPane'), canBeEmpty: true },
+    { key: 'p4', label: t('settings.fourthPane'), canBeEmpty: true },
+  ];
   return (
     <div className="border-t border-border/60 pt-4 space-y-2">
       <h4 className="text-sm font-semibold text-foreground">{t('settings.mainView')}</h4>
       <p className="text-xs text-muted-foreground">{t('settings.mainViewHint')}</p>
       <div className="grid grid-cols-2 gap-3 max-w-xl">
-        <label className="flex flex-col gap-1 text-xs">
+        {SIDES.map((sd) => (
-          <span className="text-muted-foreground">{t('settings.leftPane')}</span>
+          <label key={sd.key} className="flex flex-col gap-1 text-xs">
-          <Select value={left} onValueChange={(v) => pick('left', v)}>
+            <span className="text-muted-foreground">{sd.label}</span>
-            <SelectTrigger className="h-8 text-xs"><SelectValue /></SelectTrigger>
+            <Select value={panes[sd.key]} onValueChange={(v) => pick(sd.key, v)}>
-            <SelectContent>
+              <SelectTrigger className="h-8 text-xs"><SelectValue /></SelectTrigger>
-              {options.map((o) => <SelectItem key={o.value} value={o.value}>{o.label}</SelectItem>)}
+              <SelectContent>
-            </SelectContent>
+                {/* Only the third and fourth may be empty: the first two ARE the
-          </Select>
+                    Main view, and a tab with nothing in it is not a layout. */}
-        </label>
+                {sd.canBeEmpty && <SelectItem value={PANE_NONE}>{t('settings.paneNone')}</SelectItem>}
-        <label className="flex flex-col gap-1 text-xs">
+                {options.map((o) => <SelectItem key={o.value} value={o.value}>{o.label}</SelectItem>)}
-          <span className="text-muted-foreground">{t('settings.rightPane')}</span>
+              </SelectContent>
-          <Select value={right} onValueChange={(v) => pick('right', v)}>
+            </Select>
-            <SelectTrigger className="h-8 text-xs"><SelectValue /></SelectTrigger>
+          </label>
-            <SelectContent>
+        ))}
-              {options.map((o) => <SelectItem key={o.value} value={o.value}>{o.label}</SelectItem>)}
-            </SelectContent>
-          </Select>
-        </label>
       </div>
+      {/* Only asked when it can matter. Three panes are columns and nothing
+          else; four are the only case with two honest answers. */}
+      {filled === 4 && (
+        <div className="flex items-center gap-2 pt-1">
+          <span className="text-xs text-muted-foreground">{t('settings.paneLayout')}</span>
+          <div className="inline-flex rounded-md border border-border overflow-hidden text-xs">
+            {[{ v: 'quad', l: t('settings.paneQuad') }, { v: 'cols', l: t('settings.paneCols') }].map((o) => (
+              <button key={o.v} type="button" onClick={() => pickLayout(o.v)}
+                className={cn('px-2.5 py-1', layout === o.v ? 'bg-primary text-primary-foreground' : 'text-muted-foreground hover:bg-muted')}>
+                {o.l}
+              </button>
+            ))}
+          </div>
+        </div>
+      )}
     </div>
   );
 }
@@ -1217,6 +1284,54 @@ function ComingSoon({ id, icon: Icon }: { id: SectionId; icon?: any }) {
   );
 }
 
+// The panadapter statuses, in the order the cluster ranks them: most wanted
+// first, then the markers that are orthogonal to the entity, then the two
+// "nothing here" cases. Must match spotColorOrder in spotcolors.go — the Go side
+// is the authority, this list only decides the order of the rows.
+const SPOT_COLOR_ROWS = [
+  'new', 'new-band-mode', 'new-band', 'new-mode', 'new-slot',
+  'new-pota', 'new-county', 'new-pfx',
+  'my-call', 'worked', 'none',
+];
+
+// SmartSDR colours are #AARRGGBB — the alpha FIRST, which is not what CSS or an
+// <input type="color"> expects. These two convert between the radio's order and
+// the browser's, so the operator picks a colour in a normal picker and the radio
+// gets what it understands.
+function argbToCss(argb?: string): string {
+  const v = (argb ?? '').trim();
+  if (!/^#[0-9a-fA-F]{8}$/.test(v)) return '';
+  return `#${v.slice(3)}${v.slice(1, 3)}`; // #AARRGGBB → #RRGGBBAA
+}
+function cssToArgb(rgb: string, alpha: string): string {
+  const v = (rgb || '#000000').trim();
+  if (!/^#[0-9a-fA-F]{6}$/.test(v)) return '';
+  return `#${alpha}${v.slice(1)}`.toUpperCase();
+}
+
+// ArgbInput edits one #AARRGGBB value as what it really is: a colour and an
+// opacity. A single text field would be asking an operator to type eight hex
+// digits in an order no other program uses.
+function ArgbInput({ label, value, onChange }: { label: string; value: string; onChange: (v: string) => void }) {
+  const valid = /^#[0-9a-fA-F]{8}$/.test((value ?? '').trim());
+  const alpha = valid ? value.slice(1, 3).toUpperCase() : 'FF';
+  const rgb = valid ? `#${value.slice(3)}` : '#808080';
+  return (
+    <span className="flex items-center gap-1 shrink-0" title={label}>
+      <input type="color" value={rgb}
+        onChange={(e) => onChange(cssToArgb(e.target.value, alpha))}
+        className="size-6 rounded border border-border bg-transparent p-0 cursor-pointer" />
+      <select value={alpha}
+        onChange={(e) => onChange(cssToArgb(rgb, e.target.value))}
+        className="h-6 rounded border border-border bg-background text-[10px] px-0.5">
+        {[['FF', '100%'], ['C0', '75%'], ['80', '50%'], ['40', '25%'], ['20', '12%'], ['00', 'off']].map(([a, l]) => (
+          <option key={a} value={a}>{l}</option>
+        ))}
+      </select>
+    </span>
+  );
+}
+
 // FlexBandPanel — everything that follows the band, in ONE row per band:
 // antennas and TX power.
 //
@@ -1519,10 +1634,17 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   const [autofocusWB, setAutofocusWB] = useState(() => localStorage.getItem('opslog.autofocusWB') !== '0');
   const [checkUpdates, setCheckUpdates] = useState(() => localStorage.getItem('opslog.checkUpdates') !== '0');
   const [showBeamMap, setShowBeamMap] = useState(() => localStorage.getItem('opslog.showBeamOnMap') !== '0');
+  // Compact rotor widget: the dial and the SP/LP readout only. Off by default —
+  // the full widget is what the operator has today, and a setting that changes
+  // a panel the moment you upgrade is a setting that gets blamed for it.
+  const [rotorCompact, setRotorCompact] = useState(() => localStorage.getItem('opslog.rotorCompact') === '1');
   const [startEqEnd, setStartEqEnd] = useState(() => localStorage.getItem('opslog.startEqualsEnd') === '1');
   const [lookupOnBlur, setLookupOnBlur] = useState(() => localStorage.getItem('opslog.lookupOnBlur') === '1');
   const [groupDigital, setGroupDigital] = useState(() => localStorage.getItem('opslog.groupDigitalSlots') === '1');
   const [clusterWorkedSameSlot, setClusterWorkedSameSlot] = useState(() => localStorage.getItem('opslog.clusterWorkedSameSlot') === '1');
+  // Declared HERE and not in ClusterPanel: that renderer is called as a plain
+  // function by the PANELS map, so it must stay hooks-free.
+  const [clusterMacros, setClusterMacros] = useState<ClusterMacro[]>(loadClusterMacros);
   const [showQsoRate, setShowQsoRate] = useState(() => localStorage.getItem('opslog.showQsoRate') === '1');
   const [catModeBeforeFreq, setCatModeBeforeFreq] = useState(() => localStorage.getItem('opslog.catModeBeforeFreq') === '1');
   // Password-encryption (secret vault) state.
@@ -1672,6 +1794,65 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     try { await DownloadULSCounties(); }
     catch (e: any) { setUlsBusy(false); setUlsProgress(null); setUlsMsg({ ok: false, text: String(e?.message ?? e) }); }
   };
+  // cty.dat is not downloaded by OpsLog — it is shipped and reloaded from disk —
+  // so the page reports it rather than offering a button it cannot honour.
+  // Panadapter spot palette. Saved on its own — it is a table of colours, not a
+  // form: waiting for the modal's Save to see a colour on the waterfall would
+  // make picking one a guessing game.
+  type SpotColor = { text: string; bg?: string };
+  const [spotColors, setSpotColors] = useState<{ enabled: boolean; colors: Record<string, SpotColor> }>({ enabled: true, colors: {} });
+  useEffect(() => { GetSpotColors().then((c: any) => setSpotColors(c ?? { enabled: true, colors: {} })).catch(() => {}); }, []);
+  const saveSpotColors = (next: { enabled: boolean; colors: Record<string, SpotColor> }) => {
+    setSpotColors(next);
+    SaveSpotColors(next as any).catch(() => {});
+  };
+  const setSpotColor = (k: string, patch: Partial<SpotColor>) => saveSpotColors({
+    ...spotColors,
+    colors: { ...spotColors.colors, [k]: { ...(spotColors.colors[k] ?? { text: '' }), ...patch } },
+  });
+  // Panadapter auto-zoom. Saved immediately for the same reason as the palette:
+  // the only way to judge a width is to click a spot and look at the radio.
+  const [flexZoom, setFlexZoom] = useState<{ enabled: boolean; cw_khz: number; ssb_khz: number; digi_khz: number; centre: boolean }>(
+    { enabled: false, cw_khz: 25, ssb_khz: 200, digi_khz: 50, centre: false });
+  useEffect(() => { GetFlexZoom().then((z: any) => setFlexZoom(z)).catch(() => {}); }, []);
+  const saveFlexZoom = (next: typeof flexZoom) => { setFlexZoom(next); SaveFlexZoom(next as any).catch(() => {}); };
+  const [ctyInfo, setCtyInfo] = useState<{ entities: number; file_mod_time?: string }>({ entities: 0 });
+  const [ctyBusy, setCtyBusy] = useState(false);
+  useEffect(() => { GetCtyDatInfo().then((i) => setCtyInfo(i as any)).catch(() => {}); }, []);
+  const refreshCty = async () => {
+    setCtyBusy(true);
+    try { const i: any = await RefreshCtyDat(); setCtyInfo(i); } catch { /* the line keeps its old count */ }
+    finally { setCtyBusy(false); }
+  };
+  // Award reference lists, and which of them have an online updater.
+  const [refMeta, setRefMeta] = useState<Array<{ code: string; count: number; updated_at?: string; can_update: boolean }>>([]);
+  const [refBusy, setRefBusy] = useState('');
+  const [refMsg, setRefMsg] = useState('');
+  const reloadRefMeta = () => { GetAwardReferenceMeta().then((m) => setRefMeta((m ?? []) as any)).catch(() => {}); };
+  useEffect(reloadRefMeta, []);
+  const updateRefList = async (code: string) => {
+    setRefBusy(code); setRefMsg('');
+    try { const m: any = await UpdateAwardReferenceList(code); setRefMsg(t('db.refUpdated', { code, n: m?.count ?? 0 })); reloadRefMeta(); }
+    catch (e: any) { setRefMsg(String(e?.message ?? e)); }
+    finally { setRefBusy(''); }
+  };
+  // A date for a person: the day, not the timestamp the backend stores.
+  const fmtDay = (v?: string) => (v ? String(v).slice(0, 10) : '—');
+  const [rdaCount, setRdaCount] = useState(0);
+  const [rdaBusy, setRdaBusy] = useState(false);
+  const [rdaUseCurrent, setRdaUseCurrent] = useState(true);
+  const [rdaMsg, setRdaMsg] = useState<string | null>(null);
+  useEffect(() => { RDADatabaseCount().then((n) => setRdaCount(Number(n) || 0)).catch(() => {}); }, []);
+  const runRDABackfill = async () => {
+    setRdaBusy(true); setRdaMsg(null);
+    try {
+      const r: any = await BackfillRDA(rdaUseCurrent);
+      setRdaMsg(t('rda.backfillDone', {
+        d: r?.dated ?? 0, c: r?.current ?? 0, u: r?.unknown ?? 0, k: r?.skipped ?? 0, s: r?.scanned ?? 0,
+      }));
+    } catch (e: any) { setRdaMsg(String(e?.message ?? e)); }
+    finally { setRdaBusy(false); }
+  };
   const runBackfill = async () => {
     setBackfillBusy(true); setBackfillMsg(null);
     try { const r: any = await BackfillUSCounties(); setBackfillMsg(t('uscty.backfillDone', { c: r?.county ?? 0, g: r?.grid ?? 0, s: r?.scanned ?? 0 })); }
@@ -1724,6 +1905,14 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   // 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: [] });
+  // How a worked square is matched, and what counts as still wanted.
+  const [autoCall, setAutoCall] = useState<AutoCallSettings>(loadAutoCall);
+  const [gridScope, setGridScope] = useState<any>({ scope: 'mix_digi', hunt: 'new', scopes: [] });
+  useEffect(() => { GetGridScopeSettings().then((g) => setGridScope(g as any)).catch(() => {}); }, []);
+  const saveGridScope = async (next: any) => {
+    setGridScope(next);
+    try { await SaveGridScopeSettings(next); } catch { /* the panel keeps the choice either way */ }
+  };
   const [chaseGrids, setChaseGrids] = useState(false);
   const [chaseNew, setChaseNew] = useState(false);
   const [spotTTL, setSpotTTL] = useState(0);
@@ -2863,27 +3052,11 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
               <div className="col-span-2">
                 <FlexDiscover onPick={(ip, port) => setCatCfg((s) => ({ ...s, flex_host: ip, flex_port: port }))} />
               </div>
-              <label className="col-span-2 flex items-center gap-2 text-sm cursor-pointer">
+              {/* What OpsLog DOES with a Flex — panadapter spots, decode spots,
-                <Checkbox checked={!!catCfg.flex_spots} onCheckedChange={(c) => setCatCfg((s) => ({ ...s, flex_spots: !!c }))} />
+                  the DAX switch for voice messages — moved to Settings →
-                {t('cat.flexSpots')} <span className="text-xs text-muted-foreground">{t('cat.flexSpotsHint')}</span>
+                  FlexRadio, with the per-band antennas and power. What stays
-              </label>
+                  here is the link itself: an address and a port, which is what
-              <label className="col-span-2 flex items-center gap-2 text-sm cursor-pointer">
+                  this page is about for every other backend too. */}
-                <Checkbox checked={!!catCfg.flex_decode_spots} onCheckedChange={(c) => setCatCfg((s) => ({ ...s, flex_decode_spots: !!c }))} />
-                {t('cat.flexDecodeSpots')} <span className="text-xs text-muted-foreground">{t('cat.flexDecodeSpotsHint')}</span>
-              </label>
-              {catCfg.flex_decode_spots && (
-                <div className="col-span-2 flex items-center gap-2 pl-6">
-                  <Label className="text-sm">{t('cat.flexDecodeSecs')}</Label>
-                  <Input type="number" className="w-24" min={10} max={3600}
-                    value={catCfg.flex_decode_secs || 120}
-                    onChange={(e) => setCatCfg((s) => ({ ...s, flex_decode_secs: parseInt(e.target.value) || 120 }))} />
-                  <span className="text-xs text-muted-foreground">{t('cat.flexDecodeSecsHint')}</span>
-                </div>
-              )}
-              <label className="col-span-2 flex items-start gap-2 text-sm cursor-pointer">
-                <Checkbox className="mt-0.5" checked={!!catCfg.flex_dvk_dax} onCheckedChange={(c) => setCatCfg((s) => ({ ...s, flex_dvk_dax: !!c }))} />
-                <span>{t('cat.flexDvkDax')} <span className="text-xs text-muted-foreground">{t('cat.flexDvkDaxHint')}</span></span>
-              </label>
             </>
             )}
             {catCfg.backend === 'xiegu' && (
@@ -3360,7 +3533,10 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
 
   function UltrabeamPanel() {
     const isSteppir = ultrabeam.type === 'steppir';
-    const isSerial = isSteppir && ultrabeam.transport === 'serial';
+    // Serial is no longer a SteppIR-only route: an Ultrabeam controller has an
+    // RS232 port too, and a plain FTDI cable reaches it without the Ethernet
+    // adapter the TCP route needs.
+    const isSerial = ultrabeam.transport === 'serial';
     return (
       <>
         <SectionHeader
@@ -3374,10 +3550,10 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
           <div className="grid grid-cols-2 gap-3">
             <div className="space-y-1">
               <Label>{t('hw.motorType')}</Label>
-              {/* Ultrabeam is TCP only; picking it forces the transport back to TCP
+              {/* Both antennas take either route now, so picking a type no longer
-                  so the serial fields never apply to it. */}
+                  forces the transport. */}
               <Select value={ultrabeam.type ?? 'ultrabeam'}
-                onValueChange={(v) => setUltrabeam((s) => ({ ...s, type: v, transport: v === 'ultrabeam' ? 'tcp' : s.transport }))}>
+                onValueChange={(v) => setUltrabeam((s) => ({ ...s, type: v }))}>
                 <SelectTrigger className="h-9"><SelectValue /></SelectTrigger>
                 <SelectContent>
                   <SelectItem value="ultrabeam">Ultrabeam</SelectItem>
@@ -3385,7 +3561,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                 </SelectContent>
               </Select>
             </div>
-            {isSteppir && (
+            {(
               <div className="space-y-1">
                 <Label>{t('hw.motorTransport')}</Label>
                 <Select value={ultrabeam.transport ?? 'tcp'}
@@ -3403,12 +3579,25 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             <div className="grid grid-cols-3 gap-3">
               <div className="space-y-1 col-span-2">
                 <Label>{t('hw.motorCom')}</Label>
-                <Input
+                {/* A list AND a text field, which is why this is a Combobox and
-                  value={ultrabeam.com ?? ''}
+                    not the Select the other serial devices use: the port for a
-                  onChange={(e) => setUltrabeam((s) => ({ ...s, com: e.target.value }))}
+                    USB adapter that is currently unplugged does not appear in
-                  placeholder="COM3"
+                    the list, and refusing to accept it typed means the antenna
-                  className="font-mono"
+                    cannot be configured until the adapter is in. The detected
-                />
+                    ports are offered; anything else is still accepted. */}
+                <div className="flex items-center gap-1">
+                  <Combobox
+                    value={ultrabeam.com ?? ''}
+                    options={wkPorts}
+                    allowFreeText
+                    commitOnType
+                    placeholder="COM3"
+                    className="font-mono flex-1"
+                    onChange={(v) => setUltrabeam((s) => ({ ...s, com: v.trim().toUpperCase() }))}
+                  />
+                  <Button type="button" variant="outline" size="sm" className="shrink-0"
+                    onClick={() => ListSerialPorts().then((ps) => setWkPorts((ps ?? []) as string[])).catch(() => {})}>↻</Button>
+                </div>
               </div>
               <div className="space-y-1">
                 <Label>{t('hw.motorBaud')}</Label>
@@ -4180,10 +4369,25 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             </div>
           )}
 
+          {/* How much of the rotor widget to draw. Compact keeps the dial and the
+              SP/LP azimuths and drops the controls — for an operator who turns
+              the antenna from the bearing pill or from PstRotator and wants the
+              dial to take a column, not a panel. */}
+          <div className="border-t border-border/60 pt-3 space-y-2">
+            <div className="text-sm font-semibold">{t('rot.widget')}</div>
+            <label className="flex items-center gap-2 text-sm">
+              <Checkbox checked={rotorCompact}
+                onCheckedChange={(c) => { const v = !!c; setRotorCompact(v); writeUiPref('opslog.rotorCompact', v ? '1' : '0'); }} />
+              {t('rot.compact')}
+            </label>
+            <p className="text-xs text-muted-foreground">{t('rot.compactHint')}</p>
+          </div>
+
           {/* Quick-turn buttons for the rotor widget. Their azimuths start out
               computed from the station square, so they are right for THIS QTH
-              rather than copied from someone else's. */}
+              rather than copied from someone else's. Hidden in compact mode —
-          <div className="border-t border-border/60 pt-3 space-y-2">
+              editing buttons that are not drawn is a trap. */}
+          <div className={cn('border-t border-border/60 pt-3 space-y-2', rotorCompact && 'opacity-40')}>
             <div className="text-sm font-semibold">{t('rot.presets')}</div>
             <p className="text-xs text-muted-foreground">{t('rot.presetsHint')}</p>
             <div className="space-y-1.5">
@@ -4560,8 +4764,101 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     setEditingServer(next);
   }
 
+  // FTx decodes: what OpsLog does on its own with the digital stream.
+  //
+  // Auto-call KEYS THE TRANSMITTER without anyone clicking, so the panel is
+  // deliberately explicit about it: off by default, every criterion opt-in, and
+  // a plain statement of what the machine will do once it is on.
+  function FtxPanel() {
+    const set = (patch: Partial<AutoCallSettings>) => {
+      const next = { ...autoCall, ...patch };
+      setAutoCall(next);
+      writeUiPref(autoCallKey, JSON.stringify(next));
+    };
+    const crit = (which: 'criteria' | 'watchCriteria', k: keyof AutoCallCriteria) => (
+      <label key={k} className="flex items-center gap-1.5 text-xs cursor-pointer">
+        <Checkbox
+          checked={!!autoCall[which][k]}
+          onCheckedChange={(v) => set({ [which]: { ...autoCall[which], [k]: !!v } } as any)}
+        />
+        {t(`ftx.c_${k}`)}
+      </label>
+    );
+    const KEYS: (keyof AutoCallCriteria)[] = ['dxcc', 'bandmode', 'band', 'mode', 'slot', 'grid', 'county', 'pota', 'pfx'];
+    return (
+      <>
+        <SectionHeader title={t('sec.ftx')} hint={t('ftx.hint')} />
+        <div className="space-y-4">
+          <div className="rounded-md border border-border p-3 space-y-3">
+            <label className="flex items-start gap-2 text-sm cursor-pointer">
+              <Checkbox checked={autoCall.enabled} className="mt-0.5"
+                onCheckedChange={(v) => set({ enabled: !!v })} />
+              <span>
+                {t('ftx.enable')}{' '}
+                <span className="text-xs text-muted-foreground">{t('ftx.enableHint')}</span>
+              </span>
+            </label>
+
+            {autoCall.enabled && (
+              <div className="pl-6 space-y-3">
+                <div>
+                  <p className="text-xs font-semibold text-muted-foreground mb-1.5">{t('ftx.callWhen')}</p>
+                  <div className="grid grid-cols-2 gap-x-4 gap-y-1">{KEYS.map((k) => crit('criteria', k))}</div>
+                </div>
+
+                <div className="border-t border-border/60 pt-3">
+                  <p className="text-xs font-semibold text-muted-foreground mb-1">{t('ftx.watch')}</p>
+                  <p className="text-[11px] text-muted-foreground mb-1.5 leading-relaxed">{t('ftx.watchHint')}</p>
+                  <Textarea
+                    className="h-20 font-mono text-xs"
+                    placeholder={"4S7*\nTM0HQ\n*/P"}
+                    defaultValue={(autoCall.watch ?? []).join('\n')}
+                    key={`w-${(autoCall.watch ?? []).length}`}
+                    onBlur={(e) => set({
+                      watch: e.target.value.split('\n').map((x) => x.trim().toUpperCase()).filter(Boolean),
+                    })}
+                  />
+                  {(autoCall.watch ?? []).length > 0 && (
+                    <div className="mt-2">
+                      <p className="text-[11px] text-muted-foreground mb-1">{t('ftx.watchOnlyIf')}</p>
+                      <div className="grid grid-cols-2 gap-x-4 gap-y-1">{KEYS.map((k) => crit('watchCriteria', k))}</div>
+                    </div>
+                  )}
+                </div>
+
+                <div className="border-t border-border/60 pt-3 flex items-center gap-2 flex-wrap">
+                  <span className="text-xs text-muted-foreground">{t('ftx.cooldown')}</span>
+                  <Input type="number" min={10} max={3600} className="w-24 h-7 text-xs"
+                    defaultValue={autoCall.cooldownSec}
+                    key={`cd-${autoCall.cooldownSec}`}
+                    onBlur={(e) => {
+                      const v = parseInt(e.target.value, 10);
+                      if (!isNaN(v) && v >= 10 && v <= 3600) set({ cooldownSec: v });
+                    }} />
+                  <span className="text-xs text-muted-foreground">s</span>
+                </div>
+
+                <p className="text-[11px] rounded border border-warning-border bg-warning-muted text-warning-muted-foreground px-2 py-1.5 leading-relaxed">
+                  {t('ftx.warn')}
+                </p>
+              </div>
+            )}
+          </div>
+        </div>
+      </>
+    );
+  }
+
   function ClusterPanel() {
     const sorted = [...clusterServers].sort((a, b) => (a.sort_order ?? 0) - (b.sort_order ?? 0));
+    // Written on every keystroke. This panel has no Save button, and a pair of
+    // text boxes whose contents only take effect on some other button is how
+    // work gets lost.
+    const setMacro = (i: number, patch: Partial<ClusterMacro>) => {
+      const next = clusterMacros.map((m, j) => (j === i ? { ...m, ...patch } : m));
+      setClusterMacros(next);
+      saveClusterMacros(next);
+    };
     return (
       <>
         <SectionHeader
@@ -4654,6 +4951,34 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
               {t('clu.autoConnect')}
             </label>
           </div>
+          <div className="border-t border-border/60 pt-3 space-y-2">
+            <div>
+              <span className="text-sm font-medium">{t('clu.macros')}</span>
+            </div>
+            {/* Two columns of six: twelve rows stacked would push everything else
+                in this panel off the screen. */}
+            <div className="grid grid-cols-1 md:grid-cols-2 gap-x-4 gap-y-1.5">
+              {clusterMacros.map((m, i) => (
+                <div key={i} className="flex items-center gap-1.5">
+                  <span className="text-[10px] text-muted-foreground tabular-nums w-4 text-right shrink-0">{i + 1}</span>
+                  <Input
+                    className="h-8 w-28 shrink-0 text-xs"
+                    placeholder={t('clu.macroLabel')}
+                    value={m.label}
+                    maxLength={24}
+                    onChange={(e) => setMacro(i, { label: e.target.value })}
+                  />
+                  <Input
+                    className="h-8 flex-1 min-w-0 font-mono text-xs"
+                    placeholder={t('clu.macroCmd')}
+                    value={m.cmd}
+                    maxLength={120}
+                    onChange={(e) => setMacro(i, { cmd: e.target.value })}
+                  />
+                </div>
+              ))}
+            </div>
+          </div>
           <p className="text-xs text-muted-foreground">
             {t('clu.freeNodes')} <span className="font-mono">dxc.k0xm.net:7300</span>,{' '}
             <span className="font-mono">dx.maritimecontestclub.net:7300</span>,{' '}
@@ -4714,6 +5039,35 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                 {pskrStatus?.running ? ` · ${t('bo.feedUp', { n: pskrStatus.received ?? 0 })}` : ''}
               </p>
             )}
+
+            {/* What counts as "I already have this square". There is no single
+                right answer — a VUCC chaser counts a square per band, someone
+                filling a wall map counts it once — so it is a choice, and the
+                same six GridTracker offers, because a square wanted in one and
+                not the other is a bug report every time. */}
+            <div className="pl-6 space-y-1.5 pt-1">
+              <div className="flex items-center gap-2 flex-wrap">
+                <span className="text-xs text-muted-foreground w-28 shrink-0">{t('gsc.scope')}</span>
+                <Select value={gridScope.scope} onValueChange={(v) => saveGridScope({ ...gridScope, scope: v })}>
+                  <SelectTrigger className="h-7 w-64 text-xs"><SelectValue /></SelectTrigger>
+                  <SelectContent>
+                    {(gridScope.scopes ?? []).map((s: any) => (
+                      <SelectItem key={s.key} value={s.key}>{t(`gsc.scope_${s.key}`)}</SelectItem>
+                    ))}
+                  </SelectContent>
+                </Select>
+              </div>
+              <div className="flex items-center gap-2 flex-wrap">
+                <span className="text-xs text-muted-foreground w-28 shrink-0">{t('gsc.hunt')}</span>
+                <Select value={gridScope.hunt} onValueChange={(v) => saveGridScope({ ...gridScope, hunt: v })}>
+                  <SelectTrigger className="h-7 w-64 text-xs"><SelectValue /></SelectTrigger>
+                  <SelectContent>
+                    <SelectItem value="new">{t('gsc.huntNew')}</SelectItem>
+                    <SelectItem value="new_unconfirmed">{t('gsc.huntUnconf')}</SelectItem>
+                  </SelectContent>
+                </Select>
+              </div>
+            </div>
           </div>
 
           {/* Chase new — its own option, NOT nested under grid chasing. Chasing
@@ -4754,6 +5108,27 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                     );
                   })}
                 </div>
+                {/* How near a RECEIVER has to be. This is the whole premise of
+                    the watch — a report is evidence about YOUR path only if it
+                    was collected near you — and the right distance differs by
+                    band, so it is the operator's call. Committed on blur/Enter,
+                    not per keystroke: each save restarts the feed. */}
+                <div className="flex items-center gap-2 flex-wrap">
+                  <span className="text-xs text-muted-foreground">{t('bo.nearKm')}</span>
+                  <Input
+                    type="number" min={25} max={1000} step={25}
+                    className="w-24 h-7 text-xs"
+                    defaultValue={bandOpen.near_km ?? 300}
+                    key={`nk-${bandOpen.near_km ?? 300}`}
+                    onBlur={(e) => {
+                      const v = parseInt(e.target.value, 10);
+                      if (!isNaN(v) && v !== bandOpen.near_km) saveBandOpen({ ...bandOpen, near_km: v });
+                    }}
+                    onKeyDown={(e) => { if (e.key === 'Enter') (e.target as HTMLInputElement).blur(); }}
+                  />
+                  <span className="text-xs text-muted-foreground">km</span>
+                </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">
@@ -4795,7 +5170,6 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                 </div>
               )}
             </div>
-            <p className="text-xs text-muted-foreground leading-relaxed">{t('clu.selfSpotHint')}</p>
           </div>
         </div>
 
@@ -6656,6 +7030,141 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     );
   }
 
+  // One line per database: what it holds, when it was refreshed, and the button
+  // that refreshes it. Every one of these already had an updater somewhere —
+  // buried in the Awards manager, in a corner of the Lookup page, behind the
+  // US Counties section — and an operator wanting them all current had to know
+  // where each one lived. The point of this page is that they are in one place,
+  // named, with their own line.
+  function DatabasesPanel() {
+    const rows: Array<{
+      key: string; name: string; detail: string; busy: boolean; run?: () => void; note?: string;
+    }> = [
+      {
+        key: 'cty', name: t('db.cty'),
+        detail: ctyInfo?.entities ? t('db.ctyDetail', { n: ctyInfo.entities, d: fmtDay(ctyInfo.file_mod_time) }) : t('db.never'),
+        busy: ctyBusy, run: refreshCty,
+      },
+      {
+        key: 'clublog', name: t('db.clublog'),
+        detail: clubInfo?.count ? t('db.clublogDetail', { n: clubInfo.count, d: clubInfo.date || '—' }) : t('db.never'),
+        busy: clubBusy,
+        run: () => { setClubBusy(true); setClubErr(''); DownloadClublogCty().then((i) => setClubInfo(i as ClubInfo)).catch((e: any) => setClubErr(String(e?.message ?? e))).finally(() => setClubBusy(false)); },
+      },
+      {
+        key: 'lotw', name: t('db.lotwUsers'),
+        detail: lotwUsers?.count ? t('db.lotwDetail', { n: lotwUsers.count, d: fmtDay(lotwUsers.updated) }) : t('db.never'),
+        busy: lotwUsersBusy, run: downloadLotwUsers,
+      },
+      {
+        key: 'scp', name: t('db.scp'),
+        detail: scp?.count ? t('db.scpDetail', { n: scp.count, d: fmtDay(scp.updated) }) : t('db.never'),
+        busy: scpBusy, run: downloadScp,
+      },
+      {
+        key: 'uls', name: t('db.uls'),
+        detail: ulsStatus?.count ? t('db.ulsDetail', { n: ulsStatus.count, d: fmtDay(ulsStatus.updated_at) }) : t('db.never'),
+        busy: ulsBusy, run: downloadUls,
+      },
+      {
+        key: 'rda', name: t('db.rda'),
+        detail: t('db.rdaDetail', { n: rdaCount.toLocaleString() }),
+        busy: false, note: t('db.rdaNote'),
+      },
+    ];
+    return (
+      <div className="space-y-4 max-w-3xl">
+        <SectionHeader title={t('sec.databases')} hint={t('db.hint')} />
+        <div className="rounded-md border border-border divide-y divide-border">
+          {rows.map((r) => (
+            <div key={r.key} className="flex items-center gap-3 p-3">
+              <div className="min-w-0 flex-1">
+                <div className="text-sm font-medium">{r.name}</div>
+                <div className="text-[11px] text-muted-foreground">{r.detail}</div>
+              </div>
+              {r.run ? (
+                <Button size="sm" variant="secondary" onClick={r.run} disabled={r.busy}>
+                  {r.busy ? <Loader2 className="size-3.5 animate-spin mr-1.5" /> : null}
+                  {t('db.update')}
+                </Button>
+              ) : (
+                <span className="text-[11px] text-muted-foreground italic shrink-0">{r.note}</span>
+              )}
+            </div>
+          ))}
+        </div>
+
+        {/* The award reference lists. Their own block because they are one kind
+            of thing with one updater each, and because the list depends on which
+            awards are defined — a shared WAPC brought in by an operator appears
+            here the day it can be updated. */}
+        <div className="space-y-2">
+          <div className="text-xs font-medium">{t('db.refLists')}</div>
+          <p className="text-[11px] text-muted-foreground">{t('db.refListsHint')}</p>
+          <div className="rounded-md border border-border divide-y divide-border">
+            {refMeta.filter((m) => m.can_update).map((m) => (
+              <div key={m.code} className="flex items-center gap-3 p-3">
+                <div className="min-w-0 flex-1">
+                  <div className="text-sm font-medium font-mono">{m.code}</div>
+                  <div className="text-[11px] text-muted-foreground">
+                    {m.count ? t('db.refDetail', { n: m.count, d: fmtDay(m.updated_at) }) : t('db.never')}
+                  </div>
+                </div>
+                <Button size="sm" variant="secondary" disabled={refBusy === m.code}
+                  onClick={() => updateRefList(m.code)}>
+                  {refBusy === m.code ? <Loader2 className="size-3.5 animate-spin mr-1.5" /> : null}
+                  {t('db.update')}
+                </Button>
+              </div>
+            ))}
+            {refMeta.filter((m) => m.can_update).length === 0 && (
+              <div className="p-3 text-[11px] text-muted-foreground">{t('db.noRefLists')}</div>
+            )}
+          </div>
+          {refMsg && <p className="text-[11px] text-muted-foreground">{refMsg}</p>}
+        </div>
+      </div>
+    );
+  }
+
+  // Russian districts: the offline RDA database and the backfill it feeds.
+  //
+  // Its own section rather than a corner of the Awards manager: it is a
+  // database and a bulk operation on the log, which is what every other item in
+  // this part of the sidebar is.
+  function RDAPanel() {
+    return (
+      <div className="space-y-4 max-w-2xl">
+        <SectionHeader title={t('sec.rda')} hint={t('rda.hint')} />
+        <div className="rounded-md border border-border p-3 space-y-1">
+          <div className="text-xs font-medium">{t('rda.dbTitle')}</div>
+          <p className="text-[11px] text-muted-foreground leading-relaxed">
+            {t('rda.dbCount', { n: rdaCount.toLocaleString() })}
+          </p>
+        </div>
+        <div className="rounded-md border border-border p-3 space-y-2">
+          <div className="text-xs font-medium">{t('rda.backfillTitle')}</div>
+          <p className="text-[11px] text-muted-foreground leading-relaxed">{t('rda.backfillIntro')}</p>
+          {/* The choice is the whole point of the panel, so it is a checkbox and
+              not a hidden default: a dated record is a fact, a current district
+              on a ten-year-old QSO is an assumption. */}
+          <label className="flex items-start gap-2 text-xs cursor-pointer">
+            <Checkbox checked={rdaUseCurrent} className="mt-0.5" onCheckedChange={(c) => setRdaUseCurrent(!!c)} />
+            <span>{t('rda.useCurrent')} <span className="text-muted-foreground">{t('rda.useCurrentHint')}</span></span>
+          </label>
+          <div className="flex items-center gap-3">
+            <Button size="sm" variant="secondary" onClick={runRDABackfill} disabled={rdaBusy}>
+              {rdaBusy ? <Loader2 className="size-3.5 animate-spin mr-1.5" /> : null}
+              {t('rda.backfillRun')}
+            </Button>
+            {rdaMsg && <span className="text-xs text-muted-foreground">{rdaMsg}</span>}
+          </div>
+          <p className="text-[11px] text-muted-foreground">{t('rda.neverOverwrites')}</p>
+        </div>
+      </div>
+    );
+  }
+
   // Map sections to their content + icon (for placeholder).
   const PANELS: Record<SectionId, () => JSX.Element> = {
     general:        GeneralPanel,
@@ -6670,6 +7179,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     'lists-bands':  BandsPanel,
     'lists-modes':  ModesPanel,
     cluster:        ClusterPanel,
+    ftx:            FtxPanel,
     udp:            UDPIntegrationsPanelWrapper,
     // Module-scope components, wrapped so their props can be passed. The nested
     // panels below go through PanelHost instead — which is what now lets either
@@ -6681,8 +7191,9 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     backup:         BackupPanel,
     database:       DatabasePanel,
     uscounties:     USCountiesPanel,
+    databases:      DatabasesPanel,
     autostart:      () => <AutostartPanelComponent />,
-    awards:         () => <AwardsSelectionPanel profile={activeProfile ?? undefined} />,
+    awards:         () => (<div className="space-y-6"><AwardsSelectionPanel profile={activeProfile ?? undefined} /><RDAPanel /></div>),
     cat:            CATPanel,
     rotator:        RotatorPanel,
     winkeyer:       WinkeyerPanel,
@@ -6691,7 +7202,110 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     tunergenius:    TunerGeniusPanelSettings,
     psu:            PSUPanelSettings,
     pgxl:           PGXLPanelSettings,
-    flex:           () => <FlexBandPanel bands={lists.bands ?? []} />,
+    flex:           () => (
+      <div className="space-y-6">
+        <FlexBandPanel bands={lists.bands ?? []} />
+        {/* Rendered here rather than inside FlexBandPanel so these keep writing
+            to the modal's own CAT settings, saved by its Save button. A panel
+            that saved them itself would be overwritten by that same Save a
+            moment later, using the values it had read on opening. */}
+        <div className="border-t border-border/60 pt-4 space-y-2">
+          <h4 className="text-sm font-semibold text-foreground">{t('cat.flexOptions')}</h4>
+          <label className="flex items-center gap-2 text-sm cursor-pointer">
+            <Checkbox checked={!!catCfg.flex_decode_spots} onCheckedChange={(c) => setCatCfg((s) => ({ ...s, flex_decode_spots: !!c }))} />
+            {t('cat.flexDecodeSpots')} <span className="text-xs text-muted-foreground">{t('cat.flexDecodeSpotsHint')}</span>
+          </label>
+          {catCfg.flex_decode_spots && (
+            <div className="flex items-center gap-2 pl-6">
+              <Label className="text-sm">{t('cat.flexDecodeSecs')}</Label>
+              <Input type="number" className="w-24" min={10} max={3600}
+                value={catCfg.flex_decode_secs || 120}
+                onChange={(e) => setCatCfg((s) => ({ ...s, flex_decode_secs: parseInt(e.target.value) || 120 }))} />
+              <span className="text-xs text-muted-foreground">{t('cat.flexDecodeSecsHint')}</span>
+            </div>
+          )}
+          <label className="flex items-start gap-2 text-sm cursor-pointer">
+            <Checkbox className="mt-0.5" checked={!!catCfg.flex_dvk_dax} onCheckedChange={(c) => setCatCfg((s) => ({ ...s, flex_dvk_dax: !!c }))} />
+            <span>{t('cat.flexDvkDax')} <span className="text-xs text-muted-foreground">{t('cat.flexDvkDaxHint')}</span></span>
+          </label>
+        </div>
+
+        {/* Auto-zoom on a spot click. Its own block: it changes the RADIO's
+            display, where everything above changes what OpsLog draws on it. */}
+        <div className="border-t border-border/60 pt-4 space-y-2">
+          <h4 className="text-sm font-semibold text-foreground">{t('flexzoom.title')}</h4>
+          <label className="flex items-center gap-2 text-sm cursor-pointer">
+            <Checkbox checked={flexZoom.enabled} onCheckedChange={(c) => saveFlexZoom({ ...flexZoom, enabled: !!c })} />
+            {t('flexzoom.enable')}
+          </label>
+          {flexZoom.enabled && (
+            <div className="pl-6 space-y-2">
+              <div className="flex items-center gap-3 flex-wrap">
+                {([['cw_khz', 'flexzoom.cw'], ['ssb_khz', 'flexzoom.ssb'], ['digi_khz', 'flexzoom.digi']] as const).map(([k, lbl]) => (
+                  <label key={k} className="flex items-center gap-1.5 text-xs">
+                    <span className="text-muted-foreground">{t(lbl)}</span>
+                    <Input type="number" min={1} max={14000} className="h-8 w-20"
+                      value={String((flexZoom as any)[k] ?? '')}
+                      onChange={(e) => saveFlexZoom({ ...flexZoom, [k]: parseInt(e.target.value, 10) || 0 } as any)} />
+                    <span className="text-muted-foreground">kHz</span>
+                  </label>
+                ))}
+              </div>
+              <label className="flex items-start gap-2 text-xs cursor-pointer">
+                <Checkbox className="mt-0.5" checked={flexZoom.centre} onCheckedChange={(c) => saveFlexZoom({ ...flexZoom, centre: !!c })} />
+                <span>{t('flexzoom.centre')} <span className="text-muted-foreground">{t('flexzoom.centreHint')}</span></span>
+              </label>
+            </div>
+          )}
+        </div>
+
+        {/* Spot colours, one row per status.
+            
+            Saved on the spot rather than on the modal's Save: this is a table of
+            colours, and having to close a dialog to see what a colour looks like
+            on the waterfall turns picking one into a guessing game. */}
+        <div className="border-t border-border/60 pt-4 space-y-2">
+          <div className="flex items-center justify-between gap-2">
+            <h4 className="text-sm font-semibold text-foreground">{t('spotcol.title')}</h4>
+            <button type="button" className="text-[11px] text-muted-foreground hover:text-foreground underline"
+              onClick={() => ResetSpotColors().then((c: any) => setSpotColors(c)).catch(() => {})}>
+              {t('spotcol.reset')}
+            </button>
+          </div>
+          {/* Whether spots are drawn at all comes first: colouring them is the
+              next question, and the two were on different pages. */}
+          <label className="flex items-center gap-2 text-sm cursor-pointer">
+            <Checkbox checked={!!catCfg.flex_spots} onCheckedChange={(c) => setCatCfg((s) => ({ ...s, flex_spots: !!c }))} />
+            {t('cat.flexSpots')}
+          </label>
+          <label className="flex items-center gap-2 text-sm cursor-pointer">
+            <Checkbox checked={spotColors.enabled}
+              onCheckedChange={(c) => saveSpotColors({ ...spotColors, enabled: !!c })} />
+            {t('spotcol.enable')}
+          </label>
+          {spotColors.enabled && (
+            <div className="rounded-md border border-border divide-y divide-border max-w-2xl">
+              {SPOT_COLOR_ROWS.map((k) => {
+                const c = spotColors.colors[k] ?? { text: '', bg: '' };
+                return (
+                  <div key={k} className="flex items-center gap-3 px-3 py-1.5">
+                    <span className="text-xs flex-1 min-w-0">{t('spotcol.s_' + k)}</span>
+                    {/* The preview is the point of the row: two colour boxes say
+                        nothing about what the pair looks like together. */}
+                    <span className="text-xs font-mono px-2 py-0.5 rounded"
+                      style={{ color: argbToCss(c.text) || undefined, background: argbToCss(c.bg) || undefined }}>
+                      DL1ABC
+                    </span>
+                    <ArgbInput label={t('spotcol.text')} value={c.text} onChange={(v) => setSpotColor(k, { text: v })} />
+                    <ArgbInput label={t('spotcol.bg')} value={c.bg ?? ''} onChange={(v) => setSpotColor(k, { bg: v })} />
+                  </div>
+                );
+              })}
+            </div>
+          )}
+        </div>
+      </div>
+    ),
     audio:          AudioPanel,
   };
 

frontend/src/components/StationControlPanel.tsx

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

frontend/src/components/StatsPanel.tsx

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

frontend/src/components/UDPIntegrationsPanel.tsx

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

frontend/src/components/WorkedBeforeGrid.tsx

@@ -298,6 +298,20 @@ export function WorkedBeforeGrid({ wb, myGrid, busy, currentCall, onRowDoubleCli
               {t('wbg.pickerDesc')}
             </DialogDescription>
           </DialogHeader>
+          {/* Whole-dialog controls — the award columns included, which the
+              catalogue-only helpers do not cover. */}
+          <div className="flex items-center gap-1 px-5 text-[11px] text-muted-foreground">
+            <span>{t('wbg.allGroups')}</span>
+            <button type="button" className="text-[11px] text-primary hover:underline px-1"
+              onClick={() => { showAll(); (awardCols ?? []).forEach((a) => setColVisible(`award_${a.code}`, true)); }}>
+              {t('wbg.all')}
+            </button>
+            <span className="opacity-40">·</span>
+            <button type="button" className="text-[11px] text-muted-foreground hover:underline px-1"
+              onClick={() => { hideAll(); (awardCols ?? []).forEach((a) => setColVisible(`award_${a.code}`, false)); }}>
+              {t('wbg.none')}
+            </button>
+          </div>
           <div className="grid grid-cols-2 gap-4 max-h-[60vh] overflow-y-auto px-5 py-3">
             {GROUP_ORDER.map((group) => {
               const cols = COL_CATALOG.filter((c) => c.group === group);

frontend/src/components/qsl/EditorPanel.tsx

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

frontend/src/components/qsl/qslTypes.ts

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

frontend/src/lib/autocall.ts

@@ -0,0 +1,184 @@
+// Auto-call: let OpsLog answer a decode without the operator clicking it.
+//
+// This KEYS THE TRANSMITTER on its own, which is why the rules here are written
+// as a series of refusals rather than a search for a reason to call. Everything
+// below has to be true; anything unknown means no.
+//
+// The decision is made here, in one pure function, precisely because it is the
+// dangerous part: it can be read, argued with and tested without a radio.
+
+export type AutoCallCriteria = {
+  dxcc: boolean;      // entity never worked
+  bandmode: boolean;  // entity worked, but neither this band nor this mode
+  band: boolean;      // entity never worked on this band
+  mode: boolean;      // entity never worked in this mode
+  slot: boolean;      // band and mode each worked, never together
+  grid: boolean;      // square wanted under the grid scope
+  county: boolean;    // US county never worked
+  pota: boolean;      // park never worked
+  // No SOTA here, though the shape invites it: a decode carries no summit
+  // reference and the backend publishes no "new summit" flag, so a criterion
+  // for it could never be true. It WAS declared, translated and impossible to
+  // tick — a field that lies about what the feature can do.
+  pfx: boolean;       // CQ WPX prefix never worked
+};
+
+export type AutoCallSettings = {
+  enabled: boolean;
+  criteria: AutoCallCriteria;
+  // Callsigns to answer on sight, wildcards allowed (4S7*, */P). Each is still
+  // subject to `watchCriteria` — "call TM0HQ, but only if it is a new band" is
+  // the request, not "call it every time it appears".
+  watch: string[];
+  // Empty means call a watched callsign whenever it is not already worked.
+  watchCriteria: AutoCallCriteria;
+  // Seconds to ignore a callsign after calling it, so a station that keeps
+  // sending CQ is not re-answered every slot while the QSO is in progress.
+  cooldownSec: number;
+};
+
+export const emptyCriteria: AutoCallCriteria = {
+  dxcc: false, bandmode: false, band: false, mode: false, slot: false,
+  grid: false, county: false, pota: false, pfx: false,
+};
+
+export const defaultAutoCall: AutoCallSettings = {
+  // OFF, and it stays off until asked for. Unattended transmit is not something
+  // to inherit from an upgrade.
+  enabled: false,
+  criteria: { ...emptyCriteria },
+  watch: [],
+  watchCriteria: { ...emptyCriteria },
+  cooldownSec: 120,
+};
+
+const AC_KEY = 'opslog.autoCall';
+
+export function loadAutoCall(): AutoCallSettings {
+  try {
+    const raw = localStorage.getItem(AC_KEY);
+    if (!raw) return { ...defaultAutoCall };
+    const v = JSON.parse(raw);
+    return {
+      ...defaultAutoCall,
+      ...v,
+      criteria: { ...emptyCriteria, ...(v?.criteria ?? {}) },
+      watchCriteria: { ...emptyCriteria, ...(v?.watchCriteria ?? {}) },
+      watch: Array.isArray(v?.watch) ? v.watch : [],
+    };
+  } catch { return { ...defaultAutoCall }; }
+}
+
+export const autoCallKey = AC_KEY;
+
+// A decode's resolved novelty, the same shape the panel already renders from.
+export type DecodeStatus = {
+  status?: string;
+  worked_call?: boolean;
+  new_grid?: boolean;
+  grid_state?: string;
+  new_county?: boolean;
+  new_pota?: boolean;
+  new_pfx?: boolean;
+};
+
+// matchesWildcard is the same rule the alert filters use: * is any run, ? is one.
+export function matchesWildcard(pattern: string, call: string): boolean {
+  const p = pattern.trim().toUpperCase();
+  const c = call.trim().toUpperCase();
+  if (!p) return false;
+  const re = new RegExp('^' + p.split('').map((ch) => (
+    ch === '*' ? '.*' : ch === '?' ? '.' : ch.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  )).join('') + '$');
+  return re.test(c);
+}
+
+// anyCriterion is false for an all-off set, which is what makes "watch this
+// callsign, no conditions" expressible.
+function anyCriterion(c: AutoCallCriteria): boolean {
+  return Object.values(c).some(Boolean);
+}
+
+// meets reports whether a decode satisfies at least one ticked criterion.
+function meets(c: AutoCallCriteria, e: DecodeStatus): boolean {
+  if (c.dxcc && e.status === 'new') return true;
+  // Each status is exclusive, so a station that is new on both counts matches
+  // ONLY this criterion — ticking "new band" alone would not catch it, which is
+  // the wrong way round: it is the better catch of the two.
+  if (c.bandmode && e.status === 'new-band-mode') return true;
+  if (c.band && e.status === 'new-band') return true;
+  if (c.mode && e.status === 'new-mode') return true;
+  if (c.slot && e.status === 'new-slot') return true;
+  // A square that is merely UNCONFIRMED is not called: the QSO is already made,
+  // and calling again would work a duplicate to chase a QSL.
+  if (c.grid && e.new_grid && e.grid_state !== 'unconf') return true;
+  if (c.county && e.new_county) return true;
+  if (c.pota && e.new_pota) return true;
+  if (c.pfx && e.new_pfx) return true;
+  return false;
+}
+
+export type AutoCallDecode = {
+  call: string;
+  cq?: boolean;
+  msg?: string;
+  instance?: string;
+};
+
+// shouldAutoCall decides whether to answer one decode. The reason is returned
+// for the log: an automatic transmission with no record of WHY is the thing an
+// operator cannot argue with after the fact.
+export function shouldAutoCall(
+  s: AutoCallSettings,
+  d: AutoCallDecode,
+  e: DecodeStatus | undefined,
+  opts: {
+    // busy is "some receiver is mid-QSO", NOT "this one is transmitting".
+    //
+    // The distinction is the whole bug it fixes: with two instances the caller
+    // used to test a single global transmit flag, which belonged to whichever
+    // receiver reported last. So while slice A worked a station, slice B looked
+    // idle and auto-call started another QSO on it — and the moment either
+    // finished it chained straight into the next. One station at a time means
+    // one across ALL receivers, not one per receiver.
+    busy: boolean;
+    calledAt: Map<string, number>;
+    now: number;
+    myCall?: string;
+  },
+): { call: boolean; reason: string } {
+  const no = (why: string) => ({ call: false, reason: why });
+  if (!s.enabled) return no('off');
+  if (!e) return no('status not resolved yet');
+  const call = (d.call ?? '').trim().toUpperCase();
+  if (!call) return no('no callsign');
+  // Never answer ourselves, however the decode reached us.
+  if (opts.myCall && call === opts.myCall.trim().toUpperCase()) return no('own callsign');
+  // Only a CQ. Answering a station mid-QSO is both rude and futile — WSJT-X
+  // actions a Reply only for CQ and QRZ anyway.
+  if (!d.cq) return no('not a CQ');
+  // Not while ANY receiver is mid-QSO — transmitting, or holding a DX call it
+  // has not finished with. Starting a second exchange before the first is done
+  // is what turned this into a machine that called without stopping.
+  if (opts.busy) return no('a QSO is already in progress');
+  const last = opts.calledAt.get(call);
+  if (last !== undefined && opts.now - last < s.cooldownSec * 1000) return no('called recently');
+
+  // The watch list first: an explicitly named station outranks the general
+  // criteria, and may carry conditions of its own.
+  const watched = s.watch.some((p) => matchesWildcard(p, call));
+  if (watched) {
+    if (!anyCriterion(s.watchCriteria)) {
+      // No conditions attached: call it unless it is already worked.
+      return e.worked_call ? no('watched, but already worked') : { call: true, reason: 'watch list' };
+    }
+    return meets(s.watchCriteria, e)
+      ? { call: true, reason: 'watch list + criteria' }
+      : no('watched, but no criterion met');
+  }
+
+  if (!anyCriterion(s.criteria)) return no('no criteria ticked');
+  return meets(s.criteria, e)
+    ? { call: true, reason: 'criteria' }
+    : no('no criterion met');
+}

frontend/src/lib/awardRefs.ts

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

frontend/src/lib/clusterMacros.ts

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

frontend/src/lib/rowColors.ts

@@ -16,9 +16,16 @@ export type RowColorSettings = {
   style?: 'bar' | 'tint' | 'both';
   intensity?: number;
   bandmap_lotw?: boolean;
+  recent_zebra?: string;        // '' = alternate (default), 'off' = every row alike
+  recent_zebra_color?: string;  // '' = follow the theme
   rules: RowColorRule[];
 };
 
+// The banding the grid theme applies on its own. Repeated here because turning
+// the option OFF means painting every row explicitly — the theme would
+// otherwise keep striping underneath whatever we do per row.
+const ZEBRA_DEFAULT = 'color-mix(in srgb, var(--muted) 40%, var(--card))';
+
 export const CHANNELS = ['qsl', 'lotw', 'eqsl', 'qrz'] as const;
 
 // The two QSO fields behind each channel. QRZ.com and Club Log call theirs an
@@ -76,21 +83,43 @@ export function matchRowRule(q: any, cfg: RowColorSettings | null): RowColorRule
 // A log where nearly every contact has SOME QSL state ends up with every row
 // painted, and colour that is always present stops being information. The
 // default is a stripe down the left edge; a tint is offered at a chosen strength.
-export function rowStyleFor(q: any, cfg: RowColorSettings | null): Record<string, string> | undefined {
+// rowIndex is optional: only the Recent QSOs grid bands its rows, and the other
-  if (!cfg?.enabled) return undefined;
+// callers have nothing to say about odd and even.
+export function rowStyleFor(q: any, cfg: RowColorSettings | null, rowIndex?: number): Record<string, string> | undefined {
+  const out: Record<string, string> = {};
+  // Banding first, and INDEPENDENT of cfg.enabled: it is legibility, not QSL
+  // status, and an operator who wants plain rows should not have to turn the
+  // status colours off to get them.
+  if (typeof rowIndex === 'number') {
+    if (cfg?.recent_zebra === 'off') {
+      out.backgroundColor = 'var(--card)';
+    } else if (rowIndex % 2 === 1) {
+      out.backgroundColor = cfg?.recent_zebra_color || ZEBRA_DEFAULT;
+    }
+  }
+  const empty = () => (Object.keys(out).length ? out : undefined);
+  if (!cfg?.enabled) return empty();
   const rule = matchRowRule(q, cfg);
-  if (!rule?.color) return undefined;
+  if (!rule?.color) return empty();
 
   const style = cfg.style ?? 'bar';
   const pct = Math.max(5, Math.min(45, cfg.intensity ?? 12));
-  const out: Record<string, string> = {};
   if (style === 'tint' || style === 'both') {
+    // Overrides the banding on purpose: the QSL colour is information, the
+    // banding is only there to help the eye keep its line.
     out.backgroundColor = `color-mix(in srgb, ${rule.color} ${pct}%, transparent)`;
   }
   if (style === 'bar' || style === 'both') {
-    // inset shadow rather than a border: a border would shift the cells three
+    // A background gradient, not a border and not a shadow.
-    // pixels on coloured rows only, and the columns would stop lining up.
+    //
-    out.boxShadow = `inset 3px 0 0 ${rule.color}`;
+    // A border would shift the cells three pixels on coloured rows only, and
+    // the columns would stop lining up. An inset box-shadow was the first fix
+    // for that and drew the stripe correctly — but on the grid's transformed,
+    // absolutely-positioned rows it also bled a hairline of the same colour
+    // along the row edges, so every coloured row got a horizontal rule it was
+    // never meant to have. A gradient paints inside the box and nothing else:
+    // three pixels of colour, then transparent, and no edge to bleed from.
+    out.backgroundImage = `linear-gradient(to right, ${rule.color} 0, ${rule.color} 3px, transparent 3px)`;
   }
   return out;
 }

frontend/src/lib/uiPref.ts

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

frontend/src/version.ts

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

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

@@ -53,6 +53,8 @@ export function AmpPower(arg1:string,arg2:boolean):Promise<void>;
 
 export function AmpPowerLevel(arg1:string,arg2:string):Promise<void>;
 
+export function AnswerDecode(arg1:string,arg2:number,arg3:number,arg4:number,arg5:number,arg6:string,arg7:string,arg8:boolean):Promise<void>;
+
 export function AntGeniusActivate(arg1:number,arg2:number):Promise<void>;
 
 export function AntGeniusDeselect(arg1:number):Promise<void>;
@@ -87,10 +89,14 @@ export function AwardMissingQSOs(arg1:string):Promise<Array<qso.QSO>>;
 
 export function AwardRefsForQSOs(arg1:Array<number>):Promise<Record<number, Record<string, string>>>;
 
+export function AwardRefsNew(arg1:Array<string>):Promise<main.AwardRefNewResult>;
+
 export function AwardsFolder():Promise<string>;
 
 export function BackfillDistances():Promise<main.BackfillDistancesResult>;
 
+export function BackfillRDA(arg1:boolean):Promise<main.BackfillRDAResult>;
+
 export function BackfillUSCounties():Promise<main.BackfillUSCountiesResult>;
 
 export function BandSlotQSOs(arg1:string,arg2:number,arg3:string,arg4:string):Promise<Array<qso.QSO>>;
@@ -113,6 +119,8 @@ export function CheckForUpdate():Promise<main.UpdateInfo>;
 
 export function ClearLookupCache():Promise<void>;
 
+export function CloseAutostartPrograms():Promise<void>;
+
 export function ClusterSpotStatuses(arg1:Array<main.SpotQuery>):Promise<Array<main.SpotStatus>>;
 
 export function ComputeQSOAwardRefs(arg1:qso.QSO):Promise<Array<main.QSOAwardRef>>;
@@ -355,8 +363,12 @@ export function FlexSetXITFreq(arg1:number):Promise<void>;
 
 export function FlexStopCW():Promise<void>;
 
+export function FlexTXOnBand(arg1:string):Promise<void>;
+
 export function FlexTune(arg1:boolean):Promise<void>;
 
+export function FlexZoomForSpot(arg1:string,arg2:number):Promise<void>;
+
 export function GetACOMStatus():Promise<acom.Status>;
 
 export function GetADIFMonitor():Promise<main.ADIFMonitorConfig>;
@@ -451,12 +463,16 @@ export function GetFlexBandPower():Promise<Record<string, main.FlexBandPower>>;
 
 export function GetFlexState():Promise<cat.FlexTXState>;
 
+export function GetFlexZoom():Promise<main.FlexZoomSettings>;
+
 export function GetFolderSync():Promise<main.FolderSyncConfig>;
 
 export function GetFolderSyncStatus():Promise<main.FolderSyncStatus>;
 
 export function GetGridCacheStatus():Promise<main.GridCacheStatus>;
 
+export function GetGridScopeSettings():Promise<main.GridScopeSettings>;
+
 export function GetIcomState():Promise<cat.IcomTXState>;
 
 export function GetLinkedAmps():Promise<Array<string>>;
@@ -529,6 +545,8 @@ export function GetSlotStats():Promise<qso.SlotStats>;
 
 export function GetSolarData():Promise<solar.Data>;
 
+export function GetSpotColors():Promise<main.SpotColors>;
+
 export function GetSpotTTLMinutes():Promise<number>;
 
 export function GetStartupStatus():Promise<main.StartupStatus>;
@@ -567,6 +585,10 @@ export function GetWorkedCallVariants():Promise<boolean>;
 
 export function GetYaesuState():Promise<cat.YaesuTXState>;
 
+export function GridSquares(arg1:string):Promise<Array<qso.GridSquare>>;
+
+export function HaltDecodeTx(arg1:string,arg2:boolean):Promise<void>;
+
 export function HasBuiltinReferences(arg1:string):Promise<boolean>;
 
 export function IcomRefresh():Promise<void>;
@@ -853,8 +875,12 @@ export function QSOAudioStop():Promise<boolean>;
 
 export function QuitApp():Promise<void>;
 
+export function RDADatabaseCount():Promise<number>;
+
 export function RecomputeAllAwardRefs():Promise<number>;
 
+export function RecomputeAwardRefsForCode(arg1:string):Promise<number>;
+
 export function RefreshCtyDat():Promise<main.CtyDatInfo>;
 
 export function RefreshSolar():Promise<void>;
@@ -887,6 +913,8 @@ export function ResetDatabaseToDefault():Promise<void>;
 
 export function ResetRotorPresets():Promise<Array<main.RotorPreset>>;
 
+export function ResetSpotColors():Promise<main.SpotColors>;
+
 export function RestartApp():Promise<void>;
 
 export function RestartQSORecorder():Promise<void>;
@@ -949,8 +977,12 @@ export function SaveFlexBandAntennas(arg1:Record<string, main.FlexBandAnt>):Prom
 
 export function SaveFlexBandPower(arg1:Record<string, main.FlexBandPower>):Promise<void>;
 
+export function SaveFlexZoom(arg1:main.FlexZoomSettings):Promise<void>;
+
 export function SaveFolderSync(arg1:main.FolderSyncConfig):Promise<void>;
 
+export function SaveGridScopeSettings(arg1:main.GridScopeSettings):Promise<void>;
+
 export function SaveListsSettings(arg1:main.ListsSettings):Promise<void>;
 
 export function SaveLookupSettings(arg1:main.LookupSettings):Promise<void>;
@@ -983,6 +1015,8 @@ export function SaveRowColors(arg1:main.RowColorSettings):Promise<void>;
 
 export function SaveSelfSpotSettings(arg1:main.SelfSpotSettings):Promise<void>;
 
+export function SaveSpotColors(arg1:main.SpotColors):Promise<void>;
+
 export function SaveStationDevices(arg1:Array<main.StationDevice>):Promise<void>;
 
 export function SaveStationSettings(arg1:main.StationSettings):Promise<void>;
@@ -1009,6 +1043,8 @@ export function SendClusterCommand(arg1:string):Promise<void>;
 
 export function SendClusterSpot(arg1:string,arg2:number,arg3:string):Promise<void>;
 
+export function SendDecodeFreeText(arg1:string,arg2:string,arg3:boolean):Promise<void>;
+
 export function SendEQSL(arg1:number,arg2:number,arg3:string):Promise<void>;
 
 export function SendLogToDeveloper():Promise<void>;

frontend/wailsjs/go/main/App.js

@@ -46,6 +46,10 @@ export function AmpPowerLevel(arg1, arg2) {
   return window['go']['main']['App']['AmpPowerLevel'](arg1, arg2);
 }
 
+export function AnswerDecode(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) {
+  return window['go']['main']['App']['AnswerDecode'](arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+}
+
 export function AntGeniusActivate(arg1, arg2) {
   return window['go']['main']['App']['AntGeniusActivate'](arg1, arg2);
 }
@@ -114,6 +118,10 @@ export function AwardRefsForQSOs(arg1) {
   return window['go']['main']['App']['AwardRefsForQSOs'](arg1);
 }
 
+export function AwardRefsNew(arg1) {
+  return window['go']['main']['App']['AwardRefsNew'](arg1);
+}
+
 export function AwardsFolder() {
   return window['go']['main']['App']['AwardsFolder']();
 }
@@ -122,6 +130,10 @@ export function BackfillDistances() {
   return window['go']['main']['App']['BackfillDistances']();
 }
 
+export function BackfillRDA(arg1) {
+  return window['go']['main']['App']['BackfillRDA'](arg1);
+}
+
 export function BackfillUSCounties() {
   return window['go']['main']['App']['BackfillUSCounties']();
 }
@@ -166,6 +178,10 @@ export function ClearLookupCache() {
   return window['go']['main']['App']['ClearLookupCache']();
 }
 
+export function CloseAutostartPrograms() {
+  return window['go']['main']['App']['CloseAutostartPrograms']();
+}
+
 export function ClusterSpotStatuses(arg1) {
   return window['go']['main']['App']['ClusterSpotStatuses'](arg1);
 }
@@ -650,10 +666,18 @@ export function FlexStopCW() {
   return window['go']['main']['App']['FlexStopCW']();
 }
 
+export function FlexTXOnBand(arg1) {
+  return window['go']['main']['App']['FlexTXOnBand'](arg1);
+}
+
 export function FlexTune(arg1) {
   return window['go']['main']['App']['FlexTune'](arg1);
 }
 
+export function FlexZoomForSpot(arg1, arg2) {
+  return window['go']['main']['App']['FlexZoomForSpot'](arg1, arg2);
+}
+
 export function GetACOMStatus() {
   return window['go']['main']['App']['GetACOMStatus']();
 }
@@ -842,6 +866,10 @@ export function GetFlexState() {
   return window['go']['main']['App']['GetFlexState']();
 }
 
+export function GetFlexZoom() {
+  return window['go']['main']['App']['GetFlexZoom']();
+}
+
 export function GetFolderSync() {
   return window['go']['main']['App']['GetFolderSync']();
 }
@@ -854,6 +882,10 @@ export function GetGridCacheStatus() {
   return window['go']['main']['App']['GetGridCacheStatus']();
 }
 
+export function GetGridScopeSettings() {
+  return window['go']['main']['App']['GetGridScopeSettings']();
+}
+
 export function GetIcomState() {
   return window['go']['main']['App']['GetIcomState']();
 }
@@ -998,6 +1030,10 @@ export function GetSolarData() {
   return window['go']['main']['App']['GetSolarData']();
 }
 
+export function GetSpotColors() {
+  return window['go']['main']['App']['GetSpotColors']();
+}
+
 export function GetSpotTTLMinutes() {
   return window['go']['main']['App']['GetSpotTTLMinutes']();
 }
@@ -1074,6 +1110,14 @@ export function GetYaesuState() {
   return window['go']['main']['App']['GetYaesuState']();
 }
 
+export function GridSquares(arg1) {
+  return window['go']['main']['App']['GridSquares'](arg1);
+}
+
+export function HaltDecodeTx(arg1, arg2) {
+  return window['go']['main']['App']['HaltDecodeTx'](arg1, arg2);
+}
+
 export function HasBuiltinReferences(arg1) {
   return window['go']['main']['App']['HasBuiltinReferences'](arg1);
 }
@@ -1646,10 +1690,18 @@ export function QuitApp() {
   return window['go']['main']['App']['QuitApp']();
 }
 
+export function RDADatabaseCount() {
+  return window['go']['main']['App']['RDADatabaseCount']();
+}
+
 export function RecomputeAllAwardRefs() {
   return window['go']['main']['App']['RecomputeAllAwardRefs']();
 }
 
+export function RecomputeAwardRefsForCode(arg1) {
+  return window['go']['main']['App']['RecomputeAwardRefsForCode'](arg1);
+}
+
 export function RefreshCtyDat() {
   return window['go']['main']['App']['RefreshCtyDat']();
 }
@@ -1714,6 +1766,10 @@ export function ResetRotorPresets() {
   return window['go']['main']['App']['ResetRotorPresets']();
 }
 
+export function ResetSpotColors() {
+  return window['go']['main']['App']['ResetSpotColors']();
+}
+
 export function RestartApp() {
   return window['go']['main']['App']['RestartApp']();
 }
@@ -1838,10 +1894,18 @@ export function SaveFlexBandPower(arg1) {
   return window['go']['main']['App']['SaveFlexBandPower'](arg1);
 }
 
+export function SaveFlexZoom(arg1) {
+  return window['go']['main']['App']['SaveFlexZoom'](arg1);
+}
+
 export function SaveFolderSync(arg1) {
   return window['go']['main']['App']['SaveFolderSync'](arg1);
 }
 
+export function SaveGridScopeSettings(arg1) {
+  return window['go']['main']['App']['SaveGridScopeSettings'](arg1);
+}
+
 export function SaveListsSettings(arg1) {
   return window['go']['main']['App']['SaveListsSettings'](arg1);
 }
@@ -1906,6 +1970,10 @@ export function SaveSelfSpotSettings(arg1) {
   return window['go']['main']['App']['SaveSelfSpotSettings'](arg1);
 }
 
+export function SaveSpotColors(arg1) {
+  return window['go']['main']['App']['SaveSpotColors'](arg1);
+}
+
 export function SaveStationDevices(arg1) {
   return window['go']['main']['App']['SaveStationDevices'](arg1);
 }
@@ -1958,6 +2026,10 @@ export function SendClusterSpot(arg1, arg2, arg3) {
   return window['go']['main']['App']['SendClusterSpot'](arg1, arg2, arg3);
 }
 
+export function SendDecodeFreeText(arg1, arg2, arg3) {
+  return window['go']['main']['App']['SendDecodeFreeText'](arg1, arg2, arg3);
+}
+
 export function SendEQSL(arg1, arg2, arg3) {
   return window['go']['main']['App']['SendEQSL'](arg1, arg2, arg3);
 }

frontend/wailsjs/go/models.ts

@@ -1445,6 +1445,7 @@ export namespace lookup {
 	    qsl_via?: string;
 	    web?: string;
 	    iota?: string;
+	    rda?: string;
 	    zip?: string;
 	    image_url?: string;
 	    source: string;
@@ -1475,6 +1476,7 @@ export namespace lookup {
 	        this.qsl_via = source["qsl_via"];
 	        this.web = source["web"];
 	        this.iota = source["iota"];
+	        this.rda = source["rda"];
 	        this.zip = source["zip"];
 	        this.image_url = source["image_url"];
 	        this.source = source["source"];
@@ -1734,6 +1736,7 @@ export namespace main {
 	    path: string;
 	    args: string;
 	    enabled: boolean;
+	    close_on_exit?: boolean;
 	
 	    static createFrom(source: any = {}) {
 	        return new AutostartProgram(source);
@@ -1746,6 +1749,7 @@ export namespace main {
 	        this.path = source["path"];
 	        this.args = source["args"];
 	        this.enabled = source["enabled"];
+	        this.close_on_exit = source["close_on_exit"];
 	    }
 	}
 	export class AwardExplain {
@@ -1869,6 +1873,20 @@ export namespace main {
 	        this.can_update = source["can_update"];
 	    }
 	}
+	export class AwardRefNewResult {
+	    new: Record<string, boolean>;
+	    pending: boolean;
+	
+	    static createFrom(source: any = {}) {
+	        return new AwardRefNewResult(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.new = source["new"];
+	        this.pending = source["pending"];
+	    }
+	}
 	export class AwardStatRow {
 	    label: string;
 	    cells: number[];
@@ -1955,6 +1973,26 @@ export namespace main {
 	        this.no_grid = source["no_grid"];
 	    }
 	}
+	export class BackfillRDAResult {
+	    scanned: number;
+	    dated: number;
+	    current: number;
+	    unknown: number;
+	    skipped: number;
+	
+	    static createFrom(source: any = {}) {
+	        return new BackfillRDAResult(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.scanned = source["scanned"];
+	        this.dated = source["dated"];
+	        this.current = source["current"];
+	        this.unknown = source["unknown"];
+	        this.skipped = source["skipped"];
+	    }
+	}
 	export class BackfillUSCountiesResult {
 	    scanned: number;
 	    county: number;
@@ -2001,6 +2039,7 @@ export namespace main {
 	    enabled: boolean;
 	    bands: string[];
 	    available: string[];
+	    near_km: number;
 	
 	    static createFrom(source: any = {}) {
 	        return new BandOpenSettings(source);
@@ -2011,6 +2050,7 @@ export namespace main {
 	        this.enabled = source["enabled"];
 	        this.bands = source["bands"];
 	        this.available = source["available"];
+	        this.near_km = source["near_km"];
 	    }
 	}
 	export class CATSettings {
@@ -2475,6 +2515,26 @@ export namespace main {
 	        this.body = source["body"];
 	    }
 	}
+	export class FlexZoomSettings {
+	    enabled: boolean;
+	    cw_khz: number;
+	    ssb_khz: number;
+	    digi_khz: number;
+	    centre: boolean;
+	
+	    static createFrom(source: any = {}) {
+	        return new FlexZoomSettings(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.enabled = source["enabled"];
+	        this.cw_khz = source["cw_khz"];
+	        this.ssb_khz = source["ssb_khz"];
+	        this.digi_khz = source["digi_khz"];
+	        this.centre = source["centre"];
+	    }
+	}
 	export class FolderSyncConfig {
 	    enabled: boolean;
 	    folder: string;
@@ -2567,6 +2627,56 @@ export namespace main {
 	        this.pending = source["pending"];
 	    }
 	}
+	export class gridScope {
+	    key: string;
+	    band: boolean;
+	    mode: string;
+	
+	    static createFrom(source: any = {}) {
+	        return new gridScope(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.key = source["key"];
+	        this.band = source["band"];
+	        this.mode = source["mode"];
+	    }
+	}
+	export class GridScopeSettings {
+	    scope: string;
+	    hunt: string;
+	    scopes: gridScope[];
+	
+	    static createFrom(source: any = {}) {
+	        return new GridScopeSettings(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.scope = source["scope"];
+	        this.hunt = source["hunt"];
+	        this.scopes = this.convertValues(source["scopes"], gridScope);
+	    }
+	
+		convertValues(a: any, classs: any, asMap: boolean = false): any {
+		    if (!a) {
+		        return a;
+		    }
+		    if (a.slice && a.map) {
+		        return (a as any[]).map(elem => this.convertValues(elem, classs));
+		    } else if ("object" === typeof a) {
+		        if (asMap) {
+		            for (const key of Object.keys(a)) {
+		                a[key] = new classs(a[key]);
+		            }
+		            return a;
+		        }
+		        return new classs(a);
+		    }
+		    return a;
+		}
+	}
 	export class ModePreset {
 	    name: string;
 	    default_rst_sent?: string;
@@ -3249,6 +3359,8 @@ export namespace main {
 	    style: string;
 	    intensity: number;
 	    bandmap_lotw: boolean;
+	    recent_zebra?: string;
+	    recent_zebra_color?: string;
 	    configured: boolean;
 	    rules: RowColorRule[];
 	
@@ -3262,6 +3374,8 @@ export namespace main {
 	        this.style = source["style"];
 	        this.intensity = source["intensity"];
 	        this.bandmap_lotw = source["bandmap_lotw"];
+	        this.recent_zebra = source["recent_zebra"];
+	        this.recent_zebra_color = source["recent_zebra_color"];
 	        this.configured = source["configured"];
 	        this.rules = this.convertValues(source["rules"], RowColorRule);
 	    }
@@ -3328,6 +3442,52 @@ export namespace main {
 	        this.minutes = source["minutes"];
 	    }
 	}
+	export class SpotColor {
+	    text: string;
+	    bg?: string;
+	
+	    static createFrom(source: any = {}) {
+	        return new SpotColor(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.text = source["text"];
+	        this.bg = source["bg"];
+	    }
+	}
+	export class SpotColors {
+	    enabled: boolean;
+	    colors: Record<string, SpotColor>;
+	
+	    static createFrom(source: any = {}) {
+	        return new SpotColors(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.enabled = source["enabled"];
+	        this.colors = this.convertValues(source["colors"], SpotColor, true);
+	    }
+	
+		convertValues(a: any, classs: any, asMap: boolean = false): any {
+		    if (!a) {
+		        return a;
+		    }
+		    if (a.slice && a.map) {
+		        return (a as any[]).map(elem => this.convertValues(elem, classs));
+		    } else if ("object" === typeof a) {
+		        if (asMap) {
+		            for (const key of Object.keys(a)) {
+		                a[key] = new classs(a[key]);
+		            }
+		            return a;
+		        }
+		        return new classs(a);
+		    }
+		    return a;
+		}
+	}
 	export class SpotQuery {
 	    call: string;
 	    band: string;
@@ -3362,6 +3522,7 @@ export namespace main {
 	    new_pota: boolean;
 	    grid?: string;
 	    new_grid: boolean;
+	    grid_state?: string;
 	    spotter_continent?: string;
 	    lotw: boolean;
 	    new_pfx: boolean;
@@ -3387,6 +3548,7 @@ export namespace main {
 	        this.new_pota = source["new_pota"];
 	        this.grid = source["grid"];
 	        this.new_grid = source["new_grid"];
+	        this.grid_state = source["grid_state"];
 	        this.spotter_continent = source["spotter_continent"];
 	        this.lotw = source["lotw"];
 	        this.new_pfx = source["new_pfx"];
@@ -4519,6 +4681,26 @@ export namespace qso {
 	        this.minutes = source["minutes"];
 	    }
 	}
+	export class GridSquare {
+	    grid: string;
+	    count: number;
+	    confirmed: boolean;
+	    band?: string;
+	    mode?: string;
+	
+	    static createFrom(source: any = {}) {
+	        return new GridSquare(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.grid = source["grid"];
+	        this.count = source["count"];
+	        this.confirmed = source["confirmed"];
+	        this.band = source["band"];
+	        this.mode = source["mode"];
+	    }
+	}
 	export class ListFilter {
 	    callsign?: string;
 	    band?: string;
@@ -4914,6 +5096,10 @@ export namespace qso {
 	    continents: number;
 	    first_qso: string;
 	    last_qso: string;
+	    last_new_dxcc: string;
+	    last_new_dxcc_num: number;
+	    last_new_dxcc_call: string;
+	    last_new_dxcc_date: string;
 	    confirmed_lotw: number;
 	    confirmed_eqsl: number;
 	    confirmed_qsl: number;
@@ -4964,6 +5150,10 @@ export namespace qso {
 	        this.continents = source["continents"];
 	        this.first_qso = source["first_qso"];
 	        this.last_qso = source["last_qso"];
+	        this.last_new_dxcc = source["last_new_dxcc"];
+	        this.last_new_dxcc_num = source["last_new_dxcc_num"];
+	        this.last_new_dxcc_call = source["last_new_dxcc_call"];
+	        this.last_new_dxcc_date = source["last_new_dxcc_date"];
 	        this.confirmed_lotw = source["confirmed_lotw"];
 	        this.confirmed_eqsl = source["confirmed_eqsl"];
 	        this.confirmed_qsl = source["confirmed_qsl"];

gridscope.go

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

gridscope_test.go

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

internal/award/award_test.go

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

internal/cat/cat.go

@@ -184,7 +184,29 @@ func (m *Manager) stopLocked() {
 		iv.Interrupt()
 	}
 	if done != nil {
-		<-done
+		// Bounded, and loud when it expires.
+		//
+		// This used to be a bare <-done. A poll goroutine wedged in a serial read
+		// then held every caller for ever: each restart attempt blocked inside
+		// Start before it could even try to connect, so the rig stayed dead and
+		// NOTHING was written to the log — the operator saw a CAT link that would
+		// not come back and no reason anywhere. Shutdown blocked on the same wait.
+		//
+		// Ten seconds is far longer than any honest disconnect. Past that the old
+		// poller is not coming back, and carrying on without it — noisily — beats
+		// freezing the application around it. The abandoned goroutine still holds
+		// its port, which is exactly what the log line has to say, because the
+		// next connect will fail because of it.
+		select {
+		case <-done:
+		case <-time.After(10 * time.Second):
+			name := "cat"
+			if b != nil {
+				name = b.Name()
+			}
+			debugLog.Printf("%s: poll loop did not stop within 10s — abandoning it; "+
+				"its port stays open, so the next connect may fail until OpsLog is restarted", name)
+		}
 	}
 }
 
@@ -268,12 +290,20 @@ func (m *Manager) SetSplit(on bool, txHz int64) error {
 // the backend picks a default when it's empty. (Status-based colouring can be
 // driven later by setting Color per spot.)
 type SpotInfo struct {
-	FreqHz      int64
+	FreqHz   int64
-	Callsign    string
+	Callsign string
-	Mode        string
+	Mode     string
-	Color       string
+	// Color is the TEXT colour of the callsign on the panadapter, BackgroundColor
-	Comment     string
+	// the plate behind it. Both are #AARRGGBB — the alpha channel first, which is
-	LifetimeSec int // panadapter display seconds before auto-removal (0 = backend default)
+	// SmartSDR's order and not the web's.
+	//
+	// Two colours rather than one because that is what makes a spot readable at a
+	// glance on a busy waterfall: the fill carries the status and the text stays
+	// legible against it. An empty background leaves the radio's own default.
+	Color           string
+	BackgroundColor string
+	Comment         string
+	LifetimeSec     int // panadapter display seconds before auto-removal (0 = backend default)
 }
 
 // Spotter is an OPTIONAL backend capability: show cluster spots on the radio
@@ -453,7 +483,10 @@ type FlexController interface {
 	SetRXAntenna(string) error
 	SetTXAntenna(string) error
 	SetActiveSlice(int) error // focus slice idx so commands target it
-	SetTXSlice(int) error     // make slice idx the transmitter (tx=1)
+	// ZoomPan sets the visible width (MHz) of the active slice's panadapter and
+	// keeps freqMHz inside it, re-centring when it must. See Flex.ZoomPan.
+	ZoomPan(bandwidthMHz, freqMHz float64, centre bool) error
+	SetTXSlice(int) error // make slice idx the transmitter (tx=1)
 	SetSplit(bool) error
 	SetNB(bool) error
 	SetNBLevel(int) error

internal/cat/flex.go

@@ -66,18 +66,36 @@ type Flex struct {
 	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)
+	spotFreq        map[int]int64  // spot index → Hz, so a click can report where it was (the trigger message carries only the index)
-	sentCmds        map[int]string // seq → command text, so an R<seq> error names the command
+	pendingSpotFreq map[int]int64  // seq → Hz, paired with pendingSpot
+	// panWindow is what each panadapter is currently showing, from its own status
+	// (centre and width, both MHz). Tracked because a zoom that only changes the
+	// WIDTH keeps the old centre, and the frequency the operator just clicked can
+	// end up outside the new window — see ZoomPan.
+	panWindow map[string]panView
+
+	spotByCall map[string]int // callsign → live spot index, so re-spotting a call replaces its old spot (WSJT decodes re-fire every cycle)
+	sentCmds   map[int]string // seq → command text, so an R<seq> error names the command
 
 	// OnSpotClick is called (off the reader goroutine's hot path) when the user
-	// clicks one of our spots on the panadapter, with the spot's callsign and
+	// clicks one of our spots on the panadapter, with the spot's callsign, its
-	// frequency. The host wires this to fill the entry form. Set before Connect.
+	// frequency and the mode it was spotted in — everything the host knows about
-	OnSpotClick func(callsign string, freqHz int64)
+	// the spot, since the radio's own notification carries only an index. The host
+	// wires this to fill the entry form and to size the panadapter. Set before Connect.
+	OnSpotClick func(callsign string, freqHz int64, mode string)
 }
 
+// panView is one panadapter's visible window, in MHz.
+type panView struct{ centre, width float64 }
+
 type flexSlice struct {
 	freqHz int64
 	mode   string // raw Flex mode (USB/LSB/CW/DIGU/…)
+	// pan is the panadapter this slice is displayed on ("0x40000000"), taken
+	// from the slice status. Kept PER SLICE rather than as one radio-wide id:
+	// with two slices on two bands there are two panadapters, and zooming the
+	// wrong one moves a display the operator is not looking at.
+	pan    string
 	active bool
 	tx     bool
 	inUse  bool
@@ -187,7 +205,7 @@ func NewFlex(host string, port int, spotsEnabled bool) *Flex {
 	return &Flex{
 		host: strings.TrimSpace(host), port: port,
 		slices: map[int]*flexSlice{}, spotsEnabled: spotsEnabled,
-		spotIdx: map[int]bool{}, pendingSpot: map[int]string{}, pendingSpotMode: map[int]string{}, spotCall: map[int]string{}, spotMode: map[int]string{}, spotByCall: map[string]int{}, pendingSplit: map[int]bool{},
+		spotIdx: map[int]bool{}, pendingSpot: map[int]string{}, pendingSpotMode: map[int]string{}, spotCall: map[int]string{}, spotMode: map[int]string{}, spotFreq: map[int]int64{}, pendingSpotFreq: map[int]int64{}, panWindow: map[string]panView{}, spotByCall: map[string]int{}, pendingSplit: map[int]bool{},
 		meterMeta: map[int]meterInfo{}, meterVal: map[int]float64{}, meterSub: map[int]bool{},
 		sentCmds: map[int]string{}, txSetAt: map[string]time.Time{},
 		pinnedSlice: -1,
@@ -248,6 +266,7 @@ func (f *Flex) Connect() error {
 	f.send("sub cwx all")       // CWX: the LIVE CW speed/pitch/break-in (transmit holds only a static default)
 	f.send("sub profile all")   // mic/global/tx profiles (for the mic-profile dropdown)
 	f.send("profile mic info")  // request the current mic profile list + selection
+	f.send("sub pan all")       // panadapter centre/bandwidth, so a zoom knows where the display already is
 	f.send("sub client all")    // learn the GUI client (SmartSDR) so we can bind to it (below)
 	f.startMeters(conn)         // open the UDP VITA-49 stream for live meters
 	if f.spotsEnabled {
@@ -341,11 +360,12 @@ func (f *Flex) reader(conn net.Conn) {
 				f.mu.Lock()
 				call := f.spotCall[idx]
 				mode := f.spotMode[idx]
+				hz := f.spotFreq[idx]
 				handler := f.OnSpotClick
 				f.mu.Unlock()
 				if call != "" && handler != nil {
 					debugLog.Printf("Flex: spot %d triggered → %s (mode %s)", idx, call, mode)
-					go handler(call, 0)
+					go handler(call, hz, mode)
 					// SmartSDR tunes the spot's frequency on click but does NOT apply
 					// its mode=, so set the slice mode ourselves from what we spotted.
 					if mode != "" {
@@ -388,14 +408,17 @@ func (f *Flex) reader(conn net.Conn) {
 			f.mu.Lock()
 			call, pending := f.pendingSpot[seq]
 			spotMode := f.pendingSpotMode[seq]
+			spotFreq := f.pendingSpotFreq[seq]
 			if pending {
 				delete(f.pendingSpot, seq)
 				delete(f.pendingSpotMode, seq)
+				delete(f.pendingSpotFreq, seq)
 			}
 			if pending && ok && len(parts) >= 3 {
 				if idx, e := strconv.Atoi(strings.TrimSpace(parts[2])); e == nil {
 					f.spotCall[idx] = call
 					f.spotMode[idx] = spotMode
+					f.spotFreq[idx] = spotFreq
 					f.spotIdx[idx] = true
 					f.spotByCall[strings.ToUpper(call)] = idx
 				}
@@ -692,6 +715,32 @@ func (f *Flex) handleStatus(payload string) {
 			}
 			f.mu.Unlock()
 		}
+		// Panadapter — "display pan 0x40000000 center=14.075 bandwidth=0.2 …".
+		// Only the window matters here; everything else about the display is
+		// SmartSDR's business.
+		if len(fields) >= 3 && fields[0] == "display" && fields[1] == "pan" {
+			id := fields[2]
+			f.mu.Lock()
+			w := f.panWindow[id]
+			for _, kv := range fields[3:] {
+				key, val, ok := splitKV(kv)
+				if !ok {
+					continue
+				}
+				switch key {
+				case "center":
+					if v, err := strconv.ParseFloat(val, 64); err == nil && v > 0 {
+						w.centre = v
+					}
+				case "bandwidth":
+					if v, err := strconv.ParseFloat(val, 64); err == nil && v > 0 {
+						w.width = v
+					}
+				}
+			}
+			f.panWindow[id] = w
+			f.mu.Unlock()
+		}
 		// Meter definitions — "meter <num>.src=… <num>.nam=… <num>.unit=… …".
 		// The unit scales the UDP values, the name labels them; subscribe to each
 		// new id so the radio streams it.
@@ -813,6 +862,7 @@ func (f *Flex) handleStatus(payload string) {
 					delete(f.spotIdx, idx)
 					delete(f.spotCall, idx)
 					delete(f.spotMode, idx)
+					delete(f.spotFreq, idx)
 				} else {
 					f.spotIdx[idx] = true
 				}
@@ -847,6 +897,8 @@ func (f *Flex) handleStatus(payload string) {
 			}
 		case "mode":
 			s.mode = val
+		case "pan":
+			s.pan = val
 		case "active":
 			s.active = val == "1"
 		case "tx":
@@ -1241,6 +1293,74 @@ func (f *Flex) SetMode(mode string) error {
 	return nil
 }
 
+// ZoomPan sets the visible width of the ACTIVE slice's panadapter, and puts the
+// frequency the operator clicked inside it.
+//
+// bandwidthMHz is the whole visible span, which is how SmartSDR expresses it —
+// not a zoom factor.
+//
+// Re-centring is the subtle part. SmartSDR keeps the panadapter's CENTRE when
+// only the width changes, so narrowing from 200 kHz to 25 for a CW spot — or
+// jumping to a spot clicked in the band map — regularly left the very signal the
+// operator asked for outside the new window: the radio had tuned to it, but the
+// display was showing somewhere else. So the centre moves when it must:
+//
+//	centre == true   always re-centre (the operator asked for it)
+//	centre == false  re-centre ONLY when freqMHz would fall outside the new
+//	                 window, leaving a settled display alone the rest of the time
+//
+// The test uses 40% of the width either side rather than the full half: a spot
+// pinned to the last pixel of the panadapter is visible in the arithmetic and
+// useless in practice.
+//
+// A no-op when the slice reports no panadapter, which is the case on a slice
+// that exists but is not displayed. Silent, because that is not a fault.
+// needRecentre decides whether the panadapter has to move for freqMHz to be
+// comfortably visible in a window of bandwidthMHz. forced short-circuits it.
+//
+// An unknown current centre (no pan status seen yet) counts as "would fall
+// outside": the display is more likely wrong than right, and re-centring on the
+// spot the operator just clicked is never the surprising answer.
+func needRecentre(cur panView, freqMHz, bandwidthMHz float64, forced bool) bool {
+	if freqMHz <= 0 {
+		return false // nothing to centre on
+	}
+	if forced {
+		return true
+	}
+	return cur.centre <= 0 || math.Abs(freqMHz-cur.centre) > bandwidthMHz*0.4
+}
+
+func (f *Flex) ZoomPan(bandwidthMHz, freqMHz float64, centre bool) error {
+	f.mu.Lock()
+	pan := ""
+	// The operator's slice, by the same rule as everything else — see
+	// mainSliceLocked. Zooming any other panadapter would move a display the
+	// operator is not looking at.
+	if _, sl := f.mainSliceLocked(); sl != nil {
+		pan = sl.pan
+	}
+	cur := f.panWindow[pan]
+	connected := f.conn != nil && f.gotHandle
+	f.mu.Unlock()
+	if !connected {
+		return fmt.Errorf("flex: not connected")
+	}
+	if pan == "" || bandwidthMHz <= 0 {
+		return nil
+	}
+	recentre := needRecentre(cur, freqMHz, bandwidthMHz, centre)
+	// Centre first, then width: SmartSDR clamps a window that would run past the
+	// end of the spectrum, and moving to the right place before widening leaves
+	// nothing to clamp.
+	if recentre {
+		f.send(fmt.Sprintf("display pan s %s center=%.6f", pan, freqMHz))
+	}
+	f.send(fmt.Sprintf("display pan s %s bandwidth=%.6f", pan, bandwidthMHz))
+	debugLog.Printf("Flex: zoom pan %s → %.4f MHz (centre=%v on %.6f, was %.6f)", pan, bandwidthMHz, recentre, freqMHz, cur.centre)
+	return nil
+}
+
 // SendSpot renders a cluster spot on the panadapter via "spot add". Spots carry
 // a lifetime so the radio expires them on its own (the API has no "spot clear").
 // Per the SmartSDR API, spaces inside a field value are encoded as 0x7F.
@@ -1276,6 +1396,7 @@ func (f *Flex) SendSpot(s SpotInfo) error {
 		delete(f.spotByCall, upperCall)
 		delete(f.spotCall, old)
 		delete(f.spotMode, old)
+		delete(f.spotFreq, old)
 		delete(f.spotIdx, old)
 	}
 	f.mu.Unlock()
@@ -1291,6 +1412,12 @@ func (f *Flex) SendSpot(s SpotInfo) error {
 	if m := flexEncode(adifModeToFlex(s.Mode, s.FreqHz)); m != "" {
 		cmd += " mode=" + m
 	}
+	// background_color is optional in the API and empty means "the radio's own".
+	// Sent only when set, so a spot with no configured background does not blank
+	// the default to nothing.
+	if bg := flexEncode(s.BackgroundColor); bg != "" {
+		cmd += " background_color=" + bg
+	}
 	if c := flexEncode(s.Comment); c != "" {
 		cmd += " comment=" + c
 	}
@@ -1302,6 +1429,7 @@ func (f *Flex) SendSpot(s SpotInfo) error {
 		f.mu.Lock()
 		f.pendingSpot[seq] = s.Callsign
 		f.pendingSpotMode[seq] = s.Mode
+		f.pendingSpotFreq[seq] = s.FreqHz
 		f.mu.Unlock()
 	}
 	return nil
@@ -1335,6 +1463,7 @@ func (f *Flex) ClearSpots() error {
 	f.spotIdx = map[int]bool{}
 	f.spotCall = map[int]string{}
 	f.spotMode = map[int]string{}
+	f.spotFreq = map[int]int64{}
 	f.spotByCall = map[string]int{}
 	connected := f.conn != nil
 	f.mu.Unlock()
@@ -2163,6 +2292,34 @@ func (f *Flex) startMeters(conn net.Conn) {
 	debugLog.Printf("Flex: meters UDP local=:%d punch→%s", port, raddr)
 	go f.udpReader(uc)
 	go f.udpKeepalive(uc, raddr)
+	go f.udpWatchdog(uc)
+}
+
+// udpWatchdog says so when the meter stream never arrives.
+//
+// The meters come over VITA-49 on a UDP socket the radio sends TO US; the TCP
+// side can be perfectly healthy — handshake, slices, spots, everything — while
+// not one datagram gets through. On Windows that is almost always the firewall
+// refusing inbound UDP for a program it has not been asked about, and the only
+// symptom is meters that stay at zero. Nothing said so: an operator saw a
+// connected radio with dead meters and no reason anywhere.
+//
+// Five seconds is far longer than the stream's own 40 frames a second needs.
+func (f *Flex) udpWatchdog(uc *net.UDPConn) {
+	time.Sleep(5 * time.Second)
+	f.mu.Lock()
+	cur, seen := f.udpConn, f.vitaSeen
+	port := 0
+	if uc.LocalAddr() != nil {
+		port = uc.LocalAddr().(*net.UDPAddr).Port
+	}
+	f.mu.Unlock()
+	if cur != uc || seen > 0 {
+		return // reconnected in the meantime, or the stream is flowing
+	}
+	debugLog.Printf("Flex: NO meter data after 5s — the radio's VITA-49 stream is not reaching UDP port %d. "+
+		"The TCP link is fine, so this is almost always a firewall: allow OpsLog.exe inbound UDP "+
+		"(Windows Defender Firewall → Allow an app), or open port %d for %s", port, port, f.host)
 }
 
 func (f *Flex) udpReader(uc *net.UDPConn) {

internal/cat/flex_test.go

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

internal/cluster/cluster.go

@@ -47,7 +47,12 @@ type Spot struct {
 	SourceID   int64     `json:"source_id"`   // ID of the cluster server this came from
 	SourceName string    `json:"source_name"` // display name (handy in the UI when multiple servers)
 	Spotter    string    `json:"spotter"`     // DE field
-	DXCall     string    `json:"dx_call"`     // the DX station heard
+	// SpotterContinent belongs to the SPOT, not to the DX station: one call is
+	// spotted by dozens of skimmers on every continent within a minute. It is
+	// resolved per spot at ingest for exactly that reason — see the note on the
+	// spotter-continent filter in App.tsx.
+	SpotterContinent string `json:"spotter_continent,omitempty"`
+	DXCall           string `json:"dx_call"` // the DX station heard
 	FreqKHz    float64   `json:"freq_khz"`
 	FreqHz     int64     `json:"freq_hz"`
 	Band       string    `json:"band,omitempty"`

internal/extsvc/clublog.go

@@ -40,12 +40,26 @@ func looksLikeHTML(s string) bool {
 // 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
+// clublogAppAPIKey is OpsLog's own Club Log *application* API key, issued to
-// requires an api parameter that identifies the client software (not the
+// "OpsLog" by G7VJR on 2026-08-18.
-// user) — the same way Log4OM embeds its own key — so we ship it baked in
+//
-// rather than asking each user for one. It's an application identifier, not
+// Club Log requires an api parameter identifying the client SOFTWARE, not the
-// a user secret, but note it is visible in the source and the binary.
+// user — the same way Log4OM embeds its own — so it ships baked in rather than
-const clublogAppAPIKey = "5767f19333363a9ef432ee9cd4141fe76b8adf38"
+// asking every operator to request one.
+//
+// It replaces a key that was registered to XV9Q, not to OpsLog. That was not a
+// cosmetic detail: every OpsLog upload in the world was attributed to that
+// callsign, its owner received the abuse warnings OpsLog earned, and a
+// revocation aimed at them would have cut Club Log uploads for every user of
+// this program at once.
+//
+// Club Log asks that the key not be published in source code. The source lives
+// on a private remote and only the built exe is released — but the key is still
+// recoverable from that binary by anyone who looks, as it is for every logger
+// that embeds one. Treat it as an identifier that can be attributed, never as a
+// secret: it authorises nothing on its own, since every request also carries the
+// operator's own e-mail and password.
+const clublogAppAPIKey = "8df47807a412c586787c9401c96c10c135d6e580"
 
 // UploadClublog pushes one ADIF record to Club Log in real time. The user
 // supplies the account email + password and the logbook callsign; the

internal/integrations/udp/config.go

@@ -37,6 +37,19 @@ const (
 	ServiceDBUpdated ServiceType = "db_updated"      // ADIF of each locally-logged QSO (on save)
 	ServicePstFreq   ServiceType = "pstrotator_freq" // <PST><FREQUENCY> radio freq (on freq change)
 	ServiceN1MMRadio ServiceType = "n1mm_radioinfo"  // N1MM RadioInfo XML: freq+mode (on freq/mode change)
+	// ServiceWSJTRelay re-sends every datagram an inbound WSJT listener receives,
+	// byte for byte, to somewhere else.
+	//
+	// WSJT-X, JTDX and MSHV send to ONE address. Anything else that wants the
+	// same stream — JTAlert, GridTracker, a second logger — has to be fed by a
+	// relay, and this is it, so OpsLog stops being the reason you cannot run the
+	// two together.
+	//
+	// VERBATIM, with no origin header prepended. The relays in the field add one
+	// ("127.0.0.1:2237|"), which is precisely why stripForwarderHeader exists on
+	// the receiving side here; inflicting the same thing on whatever is
+	// downstream would be repeating a mistake we had to write code to survive.
+	ServiceWSJTRelay ServiceType = "wsjt_relay"
 	// ServiceWSJTLog wraps the same ADIF in a WSJT-X "Logged ADIF" datagram.
 	// Logger32 and others listen on the WSJT-X interface, not for plain text, and
 	// discard a bare ADIF record without a word — so the two cannot be one row.

internal/integrations/udp/decodegrid_test.go

@@ -0,0 +1,75 @@
+package udp
+
+import (
+	"bytes"
+	"encoding/binary"
+	"testing"
+)
+
+// A grid reaches OpsLog in TWO kinds of message, not one. The reply that
+// answers a CQ with a locator — "C91RU IZ5EME JN52" — is the commonest of them
+// on a busy band, and reading only CQs meant any station whose CQ we happened
+// to miss had no known grid at all, so it could never be flagged as a new one.
+func TestDecodeGridFromBothMessageShapes(t *testing.T) {
+	for _, tc := range []struct {
+		msg  string
+		call string
+		cq   bool
+		grid string
+		why  string
+	}{
+		{"CQ RW9MZ MO74", "RW9MZ", true, "MO74", "a plain CQ"},
+		{"CQ DX F4BPO JN36", "F4BPO", true, "JN36", "a CQ with a modifier"},
+		{"C91RU IZ5EME JN52", "IZ5EME", false, "JN52", "a reply answering with its grid"},
+		{"YB1EWD YO6GLT KN36", "YO6GLT", false, "KN36", "the same, other way round"},
+
+		// Everything else in the third slot is a report or a sign-off, and must
+		// never be mistaken for a locator.
+		{"C91RU IZ5EME -05", "IZ5EME", false, "", "a signal report is not a grid"},
+		{"C91RU IZ5EME R-05", "IZ5EME", false, "", "a rogered report is not a grid"},
+		{"C91RU IZ5EME RRR", "IZ5EME", false, "", "RRR is not a grid"},
+		{"C91RU IZ5EME RR73", "IZ5EME", false, "", "RR73 has the shape of one and is not"},
+		{"C91RU IZ5EME 73", "IZ5EME", false, "", "73 is not a grid"},
+		{"<YO7LBX> 8F81SU RR73", "8F81SU", false, "", "a hashed call, signing off"},
+	} {
+		call, cq, grid := wsjtSender(tc.msg)
+		if call != tc.call || cq != tc.cq || grid != tc.grid {
+			t.Errorf("wsjtSender(%q) = (%q, %v, %q), want (%q, %v, %q) — %s",
+				tc.msg, call, cq, grid, tc.call, tc.cq, tc.grid, tc.why)
+		}
+	}
+}
+
+// The Reply replays the decode field for field, so the message must survive the
+// trip UNTRIMMED. DecodeMsg is trimmed for display; DecodeMsgRaw is what goes
+// back, and a stripped trailing space is a mismatch the far end reports nowhere.
+func TestDecodeKeepsTheUntrimmedMessage(t *testing.T) {
+	qstr := func(b *bytes.Buffer, v string) {
+		binary.Write(b, binary.BigEndian, int32(len(v)))
+		b.WriteString(v)
+	}
+	const padded = "CQ RW9MZ MO74  "
+	var p bytes.Buffer
+	binary.Write(&p, binary.BigEndian, uint32(wsjtMagic))
+	binary.Write(&p, binary.BigEndian, uint32(2))
+	binary.Write(&p, binary.BigEndian, uint32(wsjtMsgDecode))
+	qstr(&p, "JTDX")
+	binary.Write(&p, binary.BigEndian, uint8(1))
+	binary.Write(&p, binary.BigEndian, uint32(45_000_000))
+	binary.Write(&p, binary.BigEndian, int32(-6))
+	binary.Write(&p, binary.BigEndian, float64(0.2))
+	binary.Write(&p, binary.BigEndian, uint32(1500))
+	qstr(&p, "~")
+	qstr(&p, padded)
+
+	ev, ok, err := ParseWSJT(p.Bytes())
+	if err != nil || !ok {
+		t.Fatalf("parse: %v ok=%v", err, ok)
+	}
+	if ev.DecodeMsgRaw != padded {
+		t.Errorf("DecodeMsgRaw = %q, want %q — a Reply built from this will not match", ev.DecodeMsgRaw, padded)
+	}
+	if ev.DecodeMsg != "CQ RW9MZ MO74" {
+		t.Errorf("DecodeMsg = %q, want it trimmed for display", ev.DecodeMsg)
+	}
+}

internal/integrations/udp/decodemode_test.go

@@ -0,0 +1,115 @@
+package udp
+
+import (
+	"bytes"
+	"encoding/binary"
+	"net"
+	"testing"
+)
+
+// A Decode does not carry the mode's NAME. It carries the one-character marker
+// from the decode line — "~" for FT8, "+" for FT4 — and that character used to
+// be passed on as if it were a mode. Everything downstream compared it against
+// the modes in the log, matched nothing, and reported every station on an
+// already-worked band as a NEW MODE.
+func TestDecodeModeNameResolvesTheMarker(t *testing.T) {
+	for raw, want := range map[string]string{
+		"~": "FT8",
+		"+": "FT4",
+		"#": "JT65",
+		"@": "JT9",
+	} {
+		if got := DecodeModeName(raw, "FT8"); got != want {
+			t.Errorf("DecodeModeName(%q) = %q, want %q", raw, got, want)
+		}
+	}
+}
+
+// A sender that puts the real name in the field is believed as-is — several do,
+// and the marker table must not get in their way.
+func TestDecodeModeNameKeepsARealName(t *testing.T) {
+	for _, raw := range []string{"FT8", "ft4", "JS8", "Q65"} {
+		if got := DecodeModeName(raw, ""); got == "" || got != upper(raw) {
+			t.Errorf("DecodeModeName(%q) = %q, want the name itself", raw, got)
+		}
+	}
+}
+
+// The safety net: an unknown marker falls back to the mode from the sender's
+// last Status, which always carries the real name. This is what keeps a future
+// or unlisted marker degrading to correct rather than to nonsense.
+func TestDecodeModeNameFallsBackToStatus(t *testing.T) {
+	if got := DecodeModeName("%", "FT4"); got != "FT4" {
+		t.Errorf("unknown marker resolved to %q, want the Status mode FT4", got)
+	}
+	if got := DecodeModeName("", "FT8"); got != "FT8" {
+		t.Errorf("empty mode resolved to %q, want the Status mode FT8", got)
+	}
+	// Nothing known at all is empty rather than a guess: an empty mode makes the
+	// status resolver answer "worked", which is the safe side — a wrong mode
+	// would invent a new-mode flag exactly as the marker did.
+	if got := DecodeModeName("%", ""); got != "" {
+		t.Errorf("with no Status mode the result was %q, want empty", got)
+	}
+}
+
+func upper(s string) string {
+	out := []rune(s)
+	for i, r := range out {
+		if r >= 'a' && r <= 'z' {
+			out[i] = r - 32
+		}
+	}
+	return string(out)
+}
+
+// Resolving the marker must not DESTROY it. A Reply is matched by the receiving
+// application against its own decode list field for field, and the mode field it
+// compares is the one it sent — the marker. Sending the resolved name instead is
+// accepted silently and simply never transmits: JTDX finds no matching decode,
+// and no error is reported anywhere to say so. Reported as "clicking a CQ does
+// nothing in JTDX".
+//
+// So a Decode has to carry BOTH: Mode for the log and the status resolver,
+// DecodeModeRaw for the Reply.
+func TestDecodeKeepsTheRawModeMarkerForReplies(t *testing.T) {
+	qstr := func(b *bytes.Buffer, v string) {
+		binary.Write(b, binary.BigEndian, int32(len(v)))
+		b.WriteString(v)
+	}
+	var p bytes.Buffer
+	binary.Write(&p, binary.BigEndian, uint32(wsjtMagic))
+	binary.Write(&p, binary.BigEndian, uint32(2))             // schema
+	binary.Write(&p, binary.BigEndian, uint32(wsjtMsgDecode)) // type 2
+	qstr(&p, "JTDX")                                          // id
+	binary.Write(&p, binary.BigEndian, uint8(1))              // is_new
+	binary.Write(&p, binary.BigEndian, uint32(45_000_000))    // time (ms since midnight)
+	binary.Write(&p, binary.BigEndian, int32(-6))             // snr
+	binary.Write(&p, binary.BigEndian, float64(0.2))          // delta_time
+	binary.Write(&p, binary.BigEndian, uint32(1500))          // delta_frequency
+	qstr(&p, "~")                                             // mode — the MARKER
+	qstr(&p, "CQ EN35UKR")                                    // message
+
+	out := make(chan Event, 4)
+	s := &Server{
+		out:      out,
+		cfg:      Config{Name: "JTDX", ServiceType: ServiceWSJT},
+		lastMode: map[string]string{"JTDX": "FT8"},
+		dialHz:   map[string]int64{"JTDX": 14074000},
+	}
+	s.handle(p.Bytes(), &net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 2237})
+
+	var ev Event
+	select {
+	case ev = <-out:
+	default:
+		t.Fatal("no event emitted for the decode")
+	}
+	if ev.Mode != "FT8" {
+		t.Errorf("resolved Mode = %q, want FT8 (what the log and the status resolver need)", ev.Mode)
+	}
+	if ev.DecodeModeRaw != "~" {
+		t.Errorf("DecodeModeRaw = %q, want %q — a Reply built from this will not match and JTDX will not transmit",
+			ev.DecodeModeRaw, "~")
+	}
+}

internal/integrations/udp/decodetime_test.go

@@ -0,0 +1,70 @@
+package udp
+
+import (
+	"testing"
+	"time"
+)
+
+const ms = 1000
+
+func sec(h, m, s int) uint32 { return uint32((h*3600 + m*60 + s) * ms) }
+
+// WSJT-X stamps a decode with a time of DAY and no date, so the date has to come
+// from our own clock — and around midnight the two disagree. A decode stamped
+// 23:59:58 that reaches us at 00:00:01 would be dated the NEW day, putting it
+// almost 24 hours in the future: it would sort to the top of the decodes panel
+// and stay there for the rest of the session, and its period would never line up
+// with the ones around it.
+//
+// The clock is passed IN. The previous version of this test read the real one
+// and so failed every afternoon — a 23:59:58 stamp seen at 17:00 is genuinely
+// hours in the future, and no rule can make it otherwise. A suite that is red
+// for half the day is a suite nobody reads.
+func TestDecodeTimeCrossesMidnight(t *testing.T) {
+	// Just after midnight, a stamp from the last seconds of yesterday.
+	now := time.Date(2026, 3, 14, 0, 0, 1, 0, time.UTC)
+	got := decodeTimeAt(sec(23, 59, 58), now)
+	if want := time.Date(2026, 3, 13, 23, 59, 58, 0, time.UTC); !got.Equal(want) {
+		t.Errorf("23:59:58 seen at 00:00:01 → %s, want %s (yesterday)", got, want)
+	}
+	if got.After(now) {
+		t.Errorf("%s is in the future — it would sort to the top of the list for the session", got)
+	}
+}
+
+// The mirror case: just before midnight, a stamp from the first seconds of
+// tomorrow. Our clock is still on the old day.
+func TestDecodeTimeCrossesMidnightBackwards(t *testing.T) {
+	now := time.Date(2026, 3, 13, 23, 59, 58, 0, time.UTC)
+	got := decodeTimeAt(sec(0, 0, 1), now)
+	if want := time.Date(2026, 3, 14, 0, 0, 1, 0, time.UTC); !got.Equal(want) {
+		t.Errorf("00:00:01 seen at 23:59:58 → %s, want %s (tomorrow)", got, want)
+	}
+}
+
+// The ordinary case, which is every decode that is not within a few seconds of
+// midnight: the stamp belongs to today and is left alone.
+func TestDecodeTimeOrdinary(t *testing.T) {
+	now := time.Date(2026, 3, 13, 14, 30, 0, 0, time.UTC)
+	got := decodeTimeAt(sec(14, 29, 45), now)
+	if want := time.Date(2026, 3, 13, 14, 29, 45, 0, time.UTC); !got.Equal(want) {
+		t.Errorf("a stamp close to now → %s, want %s", got, want)
+	}
+}
+
+// The whole point of the timestamp is grouping, so two decodes from the same
+// fifteen-second slot must floor to the same period however far apart in the
+// slot they were heard.
+func TestDecodesInOneSlotShareAPeriod(t *testing.T) {
+	now := time.Date(2026, 3, 13, 12, 30, 7, 0, time.UTC)
+	at := func(h, m, s int) time.Time { return decodeTimeAt(sec(h, m, s), now) }
+	floor := func(x time.Time) int64 { return x.Unix() / 15 * 15 }
+
+	a, b := at(12, 30, 0), at(12, 30, 14)
+	if floor(a) != floor(b) {
+		t.Errorf("%s and %s fell in different periods", a, b)
+	}
+	if floor(at(12, 30, 14)) == floor(at(12, 30, 15)) {
+		t.Error("12:30:14 and 12:30:15 are different slots and must not share a period")
+	}
+}

internal/integrations/udp/hashedcall_test.go

@@ -0,0 +1,42 @@
+package udp
+
+import "testing"
+
+// A compound or non-standard callsign does not fit in a 77-bit FT8 message, so
+// it travels as a hash and is printed between angle brackets. Those decodes
+// used to be discarded whole — including the one message an operator is waiting
+// for, the reply that says a station answered them.
+func TestWsjtSenderHashedCallsign(t *testing.T) {
+	for _, c := range []struct {
+		msg, call string
+		cq        bool
+		grid      string
+	}{
+		// The reply that went missing: the sender is the bracketed call.
+		{"F4BPO <ZA/IW2JOP> -24", "ZA/IW2JOP", false, ""},
+		{"F4BPO <ZA/IW2JOP> R-14", "ZA/IW2JOP", false, ""},
+		// The other way round: we are the hashed one, the sender is plain.
+		{"<ZA/IW2JOP> F4BPO R-14", "F4BPO", false, ""},
+		// A CQ from a hashed call, with and without a grid.
+		{"CQ <ZA/IW2JOP> KM09", "ZA/IW2JOP", true, "KM09"},
+		{"CQ <ZA/IW2JOP>", "ZA/IW2JOP", true, ""},
+		{"CQ DX <ZA/IW2JOP> KM09", "ZA/IW2JOP", true, "KM09"},
+		// The compound form: one station signs off with another while answering a
+		// third. The sender is after the semicolon — reading from the left names
+		// OK1UA, who did not send it.
+		{"OK1UA RR73; DH1HRN <ZA/IW2JOP> -08", "ZA/IW2JOP", false, ""},
+		{"K1ABC RR73; W9XYZ <KH1/KH7Z> -08", "KH1/KH7Z", false, ""},
+		// Unchanged: the ordinary forms.
+		{"F4BPO W6YGO R-03", "W6YGO", false, ""},
+		{"CQ N2BJ EN61", "N2BJ", true, "EN61"},
+		// A hash the receiver could not resolve is NOT a callsign, and must not
+		// become one.
+		{"F4BPO <...> -24", "", false, ""},
+	} {
+		call, cq, grid := wsjtSender(c.msg)
+		if call != c.call || cq != c.cq || grid != c.grid {
+			t.Errorf("wsjtSender(%q) = (%q, %v, %q), want (%q, %v, %q)",
+				c.msg, call, cq, grid, c.call, c.cq, c.grid)
+		}
+	}
+}

internal/integrations/udp/outbound.go

@@ -2,6 +2,7 @@ package udp
 
 import (
 	"fmt"
+	"net"
 	"strings"
 
 	"hamlog/internal/applog"
@@ -185,3 +186,94 @@ func (m *Manager) sendTo(c Config, payload []byte) {
 	applog.Printf("udp: [%s] sent %d bytes to %s (%s)%s",
 		c.Name, len(payload), dst, c.ServiceType, sentPreview(c, payload))
 }
+
+// RelayInbound re-sends one received datagram, unchanged, to every configured
+// relay destination.
+//
+// Called with the RAW bytes as they arrived — before parsing, and whatever the
+// parse made of them. A packet this build cannot decode is still a packet the
+// application downstream may understand perfectly well, and a relay that only
+// forwards what it understood is a relay that silently drops the fields it has
+// not learned about yet.
+//
+// Loop guard: a destination that is one of our OWN inbound ports on a local
+// address would come straight back in and be relayed again, for ever, at line
+// rate. Such a row is skipped and said so once — quietly dropping it would look
+// like a relay that does not work.
+func (m *Manager) RelayInbound(pkt []byte, fromPort int) {
+	if len(pkt) == 0 {
+		return
+	}
+	rows := m.Outbound(ServiceWSJTRelay)
+	if len(rows) == 0 {
+		return
+	}
+	m.mu.Lock()
+	ports := make(map[int]struct{}, len(m.inbound))
+	for _, s := range m.inbound {
+		ports[s.cfg.Port] = struct{}{}
+	}
+	m.mu.Unlock()
+
+	for _, c := range rows {
+		if isLoopback(c.DestinationIP) {
+			if _, mine := ports[c.Port]; mine {
+				m.relayLoopOnce(c)
+				continue
+			}
+		}
+		// Deliberately not sendTo: that logs a line per datagram, and this runs
+		// on every decode of every period — it would bury the log within minutes.
+		host := strings.TrimSpace(c.DestinationIP)
+		if host == "" {
+			host = "127.0.0.1"
+		}
+		dst := fmt.Sprintf("%s:%d", host, c.Port)
+		if err := SendUDP(dst, pkt); err != nil {
+			m.relayErrOnce(c, dst, err)
+		}
+	}
+	_ = fromPort
+}
+
+// isLoopback reports whether a destination names this machine. Empty counts:
+// sendTo defaults it to 127.0.0.1.
+func isLoopback(host string) bool {
+	h := strings.TrimSpace(host)
+	if h == "" || h == "localhost" {
+		return true
+	}
+	ip := net.ParseIP(h)
+	return ip != nil && ip.IsLoopback()
+}
+
+// relayLoopOnce and relayErrOnce keep a repeating relay complaint to one line a
+// session. Both fire per datagram otherwise, which on a busy band is hundreds a
+// minute and makes the log useless for anything else.
+func (m *Manager) relayLoopOnce(c Config) {
+	m.relayWarnMu.Lock()
+	defer m.relayWarnMu.Unlock()
+	if m.relayWarned == nil {
+		m.relayWarned = map[int64]bool{}
+	}
+	if m.relayWarned[c.ID] {
+		return
+	}
+	m.relayWarned[c.ID] = true
+	applog.Printf("udp: [%s] relay target %s:%d is one of OpsLog's OWN listening ports — "+
+		"that would feed the stream back into itself for ever. Nothing is relayed on this row; "+
+		"point it at the other application's port.", c.Name, c.DestinationIP, c.Port)
+}
+
+func (m *Manager) relayErrOnce(c Config, dst string, err error) {
+	m.relayWarnMu.Lock()
+	defer m.relayWarnMu.Unlock()
+	if m.relayWarned == nil {
+		m.relayWarned = map[int64]bool{}
+	}
+	if m.relayWarned[-c.ID-1] {
+		return
+	}
+	m.relayWarned[-c.ID-1] = true
+	applog.Printf("udp: [%s] relay to %s failed: %v (said once)", c.Name, dst, err)
+}

internal/integrations/udp/relay_test.go

@@ -0,0 +1,77 @@
+package udp
+
+import (
+	"net"
+	"testing"
+	"time"
+)
+
+// The relay exists so a second application can be fed the same WSJT-X stream,
+// and the ONE thing it must get right is that the bytes are unchanged. The
+// relays in the field prepend an origin header ("127.0.0.1:2237|") — which is
+// why stripForwarderHeader had to be written on the receiving side — so a
+// header here would inflict on the next program the fault we had to survive.
+func TestRelayForwardsVerbatim(t *testing.T) {
+	dst, err := net.ListenUDP("udp", &net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 0})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer dst.Close()
+	port := dst.LocalAddr().(*net.UDPAddr).Port
+
+	m := &Manager{outbound: []Config{{
+		ID: 1, Name: "relay", ServiceType: ServiceWSJTRelay,
+		DestinationIP: "127.0.0.1", Port: port,
+	}}}
+
+	// A packet with bytes that no parser here understands, on purpose: the relay
+	// must not care what it is carrying.
+	sent := []byte{0xad, 0xbc, 0xcb, 0xda, 0x00, 0x00, 0x00, 0x63, 0xde, 0xad, 0xbe, 0xef}
+	m.RelayInbound(sent, 2237)
+
+	buf := make([]byte, 1024)
+	_ = dst.SetReadDeadline(time.Now().Add(2 * time.Second))
+	n, _, err := dst.ReadFromUDP(buf)
+	if err != nil {
+		t.Fatalf("nothing relayed: %v", err)
+	}
+	if got := buf[:n]; string(got) != string(sent) {
+		t.Errorf("relayed % X, want % X — the bytes must go out unchanged", got, sent)
+	}
+}
+
+// A relay aimed at one of OpsLog's OWN listening ports would come straight back
+// in, be relayed again, and saturate the loopback within seconds. The row is
+// skipped instead.
+func TestRelayRefusesToFeedItself(t *testing.T) {
+	own, err := net.ListenUDP("udp", &net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 0})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer own.Close()
+	port := own.LocalAddr().(*net.UDPAddr).Port
+
+	m := &Manager{
+		inbound: map[int64]*Server{
+			7: {cfg: Config{ID: 7, Port: port, ServiceType: ServiceWSJT}},
+		},
+		outbound: []Config{{
+			ID: 1, Name: "loop", ServiceType: ServiceWSJTRelay,
+			DestinationIP: "127.0.0.1", Port: port,
+		}},
+	}
+	m.RelayInbound([]byte{1, 2, 3, 4}, 2237)
+
+	buf := make([]byte, 64)
+	_ = own.SetReadDeadline(time.Now().Add(300 * time.Millisecond))
+	if n, _, err := own.ReadFromUDP(buf); err == nil {
+		t.Fatalf("relayed %d bytes back into our own listener — that is the loop", n)
+	}
+}
+
+// No relay rows configured must cost nothing and send nothing.
+func TestRelayWithNoRowsIsSilent(t *testing.T) {
+	m := &Manager{}
+	m.RelayInbound([]byte{1, 2, 3}, 2237) // must not panic
+	m.RelayInbound(nil, 2237)
+}

internal/integrations/udp/server.go

@@ -77,6 +77,37 @@ func reusingListenConfig() net.ListenConfig {
 	}
 }
 
+// decodeTime turns WSJT-X's milliseconds-since-midnight into a UTC instant.
+//
+// The sender gives a time of DAY with no date, so the date comes from our own
+// clock — and the two can straddle midnight: a decode stamped 23:59:58 that
+// reaches us at 00:00:01 would otherwise be dated a day late and sort to the top
+// of the list for the rest of the session. More than half a day apart is read as
+// the wrong side of midnight and moved.
+func decodeTime(msSinceMidnight uint32) time.Time {
+	return decodeTimeAt(msSinceMidnight, time.Now().UTC())
+}
+
+// decodeTimeAt is decodeTime with the clock passed in.
+//
+// Split out so the midnight rule can be tested at midnight instead of at
+// whatever time the suite happens to run: the test used to read the real clock
+// and failed every afternoon, because a 23:59:58 stamp seen at 17:00 is hours in
+// the future and no rule can make it otherwise. A test that fails for half the
+// day teaches everyone to ignore the suite.
+func decodeTimeAt(msSinceMidnight uint32, now time.Time) time.Time {
+	now = now.UTC()
+	midnight := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, time.UTC)
+	at := midnight.Add(time.Duration(msSinceMidnight) * time.Millisecond)
+	switch {
+	case at.Sub(now) > 12*time.Hour:
+		at = at.AddDate(0, 0, -1) // stamped late yesterday, arrived after midnight
+	case now.Sub(at) > 12*time.Hour:
+		at = at.AddDate(0, 0, 1) // stamped just after midnight, our clock still on the old day
+	}
+	return at
+}
+
 // Event is what a Server emits to its consumer for every parsed packet.
 // At most one of the fields is populated per event.
 type Event struct {
@@ -92,10 +123,55 @@ type Event struct {
 
 	// A WSJT-X Decode (heard station) to render on the panadapter.
 	DecodeCall   string // transmitting (DE) callsign
-	DecodeGrid   string // 4-char grid, CQ decodes only
+	DecodeGrid   string // 4-char grid: from a CQ, or a reply answering with its locator
 	DecodeFreqHz int64  // RF frequency (dial + audio offset)
 	DecodeSNR    int    // reported SNR (dB)
 	DecodeCQ     bool   // the decode was a CQ
+	DecodeMsg    string // the decoded line as printed ("CQ K1ABC FN42")
+	// DecodeAt is the decode's own UTC timestamp, rebuilt from the sender's
+	// milliseconds-since-midnight. It is what groups decodes into T/R periods:
+	// a period's worth arrives in one burst, so arrival time would put them all
+	// in whichever slot the burst happened to land in.
+	DecodeAt time.Time
+	// DecodeTRPeriod is the transmit/receive period in seconds, from the last
+	// Status of the same program (15 = FT8). 0 when the sender never said.
+	DecodeTRPeriod int
+	DecodeDial     int64 // dial frequency the decode was heard on, for the band
+	DecodeOffAir   bool  // decoded from a file rather than off the air
+	// The three fields below are shown in the panel AND replayed verbatim when
+	// answering the station — WSJT-X matches a Reply against its own decode list,
+	// so every one has to go back exactly as it came.
+	DecodeDT      float64 // seconds into the slot the transmission started
+	DecodeAudioHz int64   // audio offset inside the passband
+	DecodeMs      uint32  // the decode's raw ms-since-midnight, as sent
+	DecodeLowConf bool
+	// DecodeModeRaw is the mode field EXACTLY as the Decode carried it — the
+	// one-character marker ("~", "+"), not the resolved name in Mode.
+	//
+	// Both are needed and they are not interchangeable. Mode is what the log and
+	// the status resolver want. This is what a Reply must echo: the receiving
+	// application matches a Reply against its own decode list field for field,
+	// and JTDX rejects one whose mode reads "FT8" where it decoded "~" — the
+	// click is accepted, nothing is transmitted, and nothing is reported.
+	DecodeModeRaw string
+	// DecodeMsgRaw is the message as sent, untrimmed — see DecodeModeRaw.
+	DecodeMsgRaw string
+	// ProgramID is the sending application's own id ("WSJT-X", "MSHV", or
+	// "WSJT-X - 2" for a second instance started with --rig-name). It is what
+	// tells two receivers apart on one multicast group — and it is the address a
+	// Reply message would have to be sent back to, so it is carried even though
+	// nothing replies yet.
+	ProgramID string
+
+	// TxMessage is what the operator's digital app is sending, with Transmitting
+	// true while the carrier is actually up. From Status, so ~1 Hz.
+	TxMessage    string
+	Transmitting bool
+	// TxEnabled is the sender's Enable Tx toggle — see WSJTEvent.TxEnabled. The
+	// watchdog clears it, which is the only reliable sign an exchange was
+	// abandoned rather than merely paused between overs.
+	TxEnabled bool
+	DECall    string // the operator's own call, as the digital app knows it
 
 	// ClearCall is set when a WSJT/JTDX/MSHV Status message reports an EMPTY DX
 	// Call after previously reporting one — i.e. the operator cleared the call in
@@ -112,7 +188,10 @@ type Event struct {
 
 // Server is a single inbound UDP listener.
 type Server struct {
-	cfg     Config
+	cfg Config
+	// mgr is the owning Manager, so a listener can reach the outbound rows.
+	// The relay is the only thing that needs it.
+	mgr     *Manager
 	conn    *net.UDPConn
 	out     chan<- Event
 	stop    chan struct{}
@@ -127,7 +206,16 @@ type Server struct {
 	// 50.400 panadapter. WSJT-X requires --rig-name for a second instance, so the
 	// id is distinct whenever there is more than one.
 	dialHz map[string]int64
-	lastDX string // WSJT: last non-empty DX Call seen, to detect a clear
+	// trPeriod is the T/R period (seconds) from each program's last Status —
+	// what tells a decode which slot it belongs to.
+	trPeriod map[string]int
+	// lastFrom is the address each program's packets arrive from — where a Reply
+	// has to be sent. See SendReply.
+	lastFrom map[string]*net.UDPAddr
+	// lastMode is the mode NAME from each program's last Status, used to resolve
+	// a Decode's one-character mode marker.
+	lastMode map[string]string
+	lastDX   string // WSJT: last non-empty DX Call seen, to detect a clear
 
 	// badPkts counts datagrams this listener could not parse, so the diagnostic
 	// dump below stays bounded. A misconfigured port is not a one-off: the
@@ -135,6 +223,15 @@ type Server struct {
 	// which fills the whole rotating log with the same line and buries the
 	// evidence of anything else.
 	badPkts int
+
+	// drops counts events discarded because the consumer could not keep up —
+	// see the select at the foot of handle(). They used to vanish in silence,
+	// which made a missing decode indistinguishable from one the sender never
+	// broadcast: an operator comparing the panel against JTDX side by side was
+	// the only detector we had. A period's decodes arrive as one burst, so this
+	// is exactly when it happens.
+	drops     int
+	lastDropL time.Time
 }
 
 // maxBadPktDumps is how many unparseable datagrams a listener describes in full
@@ -171,10 +268,11 @@ func describePacket(pkt []byte) string {
 	return fmt.Sprintf("%d bytes | text %q%s | hex %s%s", len(pkt), text.String(), more, strings.TrimSpace(hex.String()), more)
 }
 
-func newServer(cfg Config, out chan<- Event) *Server {
+func newServer(cfg Config, out chan<- Event, mgr *Manager) *Server {
 	return &Server{
 		cfg:  cfg,
 		out:  out,
+		mgr:  mgr,
 		stop: make(chan struct{}),
 		done: make(chan struct{}),
 	}
@@ -340,6 +438,17 @@ func (s *Server) noteIgnoredADIF(pkt []byte) {
 }
 
 func (s *Server) handle(pkt []byte, remote *net.UDPAddr) {
+	// Relay FIRST, and unconditionally: before parsing, and whatever the parse
+	// then makes of it. A datagram this build cannot decode is still one the
+	// application downstream may understand, and a relay that forwards only what
+	// it understood drops exactly the fields it has yet to learn about.
+	//
+	// WSJT listeners only. The other inbound services are text protocols with no
+	// second consumer to speak of, and relaying an ADIF record twice would log
+	// the contact twice.
+	if s.cfg.ServiceType == ServiceWSJT && s.mgr != nil {
+		s.mgr.RelayInbound(pkt, s.cfg.Port)
+	}
 	ev := Event{ConfigID: s.cfg.ID, Service: s.cfg.ServiceType, Source: remote.String()}
 	switch s.cfg.ServiceType {
 	case ServiceWSJT:
@@ -351,6 +460,18 @@ func (s *Server) handle(pkt []byte, remote *net.UDPAddr) {
 		if !ok {
 			return
 		}
+		// Where this application's packets come from, so a Reply can be sent back
+		// to it. Per PROGRAM, not per listener: two receivers share one multicast
+		// group, and a reply must reach the one that heard the station — and it
+		// must go to the sender's own address, never to the group.
+		if w.ProgramID != "" && remote != nil {
+			s.mu.Lock()
+			if s.lastFrom == nil {
+				s.lastFrom = map[string]*net.UDPAddr{}
+			}
+			s.lastFrom[w.ProgramID] = remote
+			s.mu.Unlock()
+		}
 		// Status carries the current dial frequency; remember it so Decode audio
 		// offsets can be turned into RF frequencies for the panadapter.
 		if w.FreqHz > 0 && !w.IsDecode {
@@ -359,11 +480,40 @@ func (s *Server) handle(pkt []byte, remote *net.UDPAddr) {
 				s.dialHz = map[string]int64{}
 			}
 			s.dialHz[w.ProgramID] = w.FreqHz
+			// The T/R period travels with Status, and a decode has to be told
+			// which slot it belongs to — so it is remembered per program the
+			// same way the dial is.
+			if w.TRPeriod > 0 {
+				if s.trPeriod == nil {
+					s.trPeriod = map[string]int{}
+				}
+				s.trPeriod[w.ProgramID] = w.TRPeriod
+			}
+			// The mode NAME, which only Status carries: a Decode gives the
+			// one-character marker instead. See DecodeModeName.
+			if w.Mode != "" {
+				if s.lastMode == nil {
+					s.lastMode = map[string]string{}
+				}
+				s.lastMode[w.ProgramID] = w.Mode
+			}
 			s.mu.Unlock()
 		}
+		if !w.IsDecode && (w.TxMessage != "" || w.DECall != "") {
+			// What the operator is sending, and to whom. Carried on every Status,
+			// so the consumer sees it change as the QSO progresses. The program id
+			// travels with it because a second receiver has a transmit state of
+			// its own.
+			ev.TxMessage = w.TxMessage
+			ev.Transmitting = w.Transmitting
+			ev.DECall = w.DECall
+			ev.ProgramID = w.ProgramID
+		}
 		if w.IsDecode {
 			s.mu.Lock()
 			dial := s.dialHz[w.ProgramID]
+			tr := s.trPeriod[w.ProgramID]
+			statusMode := s.lastMode[w.ProgramID]
 			s.mu.Unlock()
 			if dial <= 0 {
 				// No Status from THIS instance yet. Guessing with another
@@ -376,7 +526,19 @@ func (s *Server) handle(pkt []byte, remote *net.UDPAddr) {
 			ev.DecodeFreqHz = dial + w.DeltaFreqHz
 			ev.DecodeSNR = w.SNR
 			ev.DecodeCQ = w.IsCQ
-			ev.Mode = w.Mode
+			ev.Mode = DecodeModeName(w.Mode, statusMode)
+			ev.DecodeModeRaw = w.Mode
+			ev.DecodeMsg = w.DecodeMsg
+			ev.DecodeMsgRaw = w.DecodeMsgRaw
+			ev.DecodeAt = decodeTime(w.DecodeMsSinceMidnight)
+			ev.DecodeTRPeriod = tr
+			ev.DecodeDial = dial
+			ev.DecodeOffAir = w.OffAir
+			ev.ProgramID = w.ProgramID
+			ev.DecodeDT = w.DeltaTime
+			ev.DecodeAudioHz = w.DeltaFreqHz
+			ev.DecodeMs = w.DecodeMsSinceMidnight
+			ev.DecodeLowConf = w.LowConfidence
 			break
 		}
 		// Only a logged QSO is worth a line — WSJT-X/MSHV send a Status packet
@@ -501,16 +663,52 @@ func (s *Server) handle(pkt []byte, remote *net.UDPAddr) {
 	// Empty events are useless; skip — EXCEPT a clear signal, which is meant to be
 	// empty (the DX Call was cleared in the digital app), and a tune-only
 	// request (freq with no callsign).
-	if ev.DXCall == "" && ev.LoggedADIF == "" && ev.DecodeCall == "" && !ev.ClearCall && ev.TuneFreqHz == 0 {
+	// TxMessage rides on Status, which also carries the DX call — but a Status
+	// with an empty DX call and a live transmit message (calling CQ) used to be
+	// dropped here, and that is exactly the message the decodes panel needs.
+	if ev.DXCall == "" && ev.LoggedADIF == "" && ev.DecodeCall == "" && ev.TxMessage == "" && !ev.ClearCall && ev.TuneFreqHz == 0 {
 		return
 	}
 	select {
 	case s.out <- ev:
 	default:
-		// Drop on backpressure rather than block the read loop.
+		// Drop on backpressure rather than block the read loop — but say so.
+		s.noteDrop(ev)
 	}
 }
 
+// noteDrop reports events lost to a full queue, first one immediately and then
+// at most one line a minute with the running total.
+//
+// Rate-limited because the condition is self-sustaining: a consumer that fell
+// behind on one period is behind for the next, and a line per lost decode would
+// bury the rest of the log under the symptom. The event's own description goes
+// in, because "a decode was lost" and "a Status was lost" are different faults.
+func (s *Server) noteDrop(ev Event) {
+	what := "event"
+	switch {
+	case ev.DecodeCall != "":
+		what = "decode from " + ev.DecodeCall
+	case ev.LoggedADIF != "":
+		what = "logged QSO"
+	case ev.TxMessage != "" || ev.DECall != "":
+		what = "transmit status"
+	}
+	s.mu.Lock()
+	s.drops++
+	n := s.drops
+	quiet := n > 1 && time.Since(s.lastDropL) < time.Minute
+	if !quiet {
+		s.lastDropL = time.Now()
+	}
+	s.mu.Unlock()
+	if quiet {
+		return
+	}
+	applog.Printf("udp: [%s] queue full — dropped %s (%d lost this session); "+
+		"the decodes panel is missing what the sender broadcast", s.cfg.Name, what, n)
+}
+
 func (s *Server) close() {
 	s.mu.Lock()
 	if s.stopped {
@@ -564,6 +762,13 @@ type Manager struct {
 	httpFailMu sync.Mutex
 	httpFailAt map[int64]time.Time
 
+	// relayWarned keeps a relay row's complaint (a loop target, a dead
+	// destination) to one line a session. Keyed by row id for the loop warning
+	// and by -id-1 for the send failure, so one row can say each once.
+	// Without this a busy band writes hundreds of identical lines a minute.
+	relayWarnMu sync.Mutex
+	relayWarned map[int64]bool
+
 	mu       sync.Mutex
 	inbound  map[int64]*Server
 	outbound []Config
@@ -571,8 +776,12 @@ type Manager struct {
 
 func NewManager(repo *Repo) *Manager {
 	return &Manager{
-		repo:    repo,
+		repo: repo,
-		out:     make(chan Event, 64),
+		// 256, not 64: a period delivers twenty-odd decodes in one burst while
+		// Status keeps arriving, and the consumer does real work per event. The
+		// depth is headroom for that burst — the drop counter above is what says
+		// whether it was enough.
+		out:     make(chan Event, 256),
 		inbound: map[int64]*Server{},
 	}
 }
@@ -616,7 +825,7 @@ func (m *Manager) Reload(ctx context.Context) []string {
 			m.mu.Unlock()
 			continue
 		}
-		srv := newServer(c, m.out)
+		srv := newServer(c, m.out, m)
 		if err := srv.start(); err != nil {
 			applog.Printf("udp: start %q failed: %v", c.Name, err)
 			errs = append(errs, fmt.Sprintf("%s: %v", c.Name, err))

internal/integrations/udp/wsjt.go

@@ -51,10 +51,54 @@ type WSJTEvent struct {
 	// known dial frequency (from Status) to DeltaFreqHz to get the RF frequency.
 	IsDecode    bool
 	DecodeCall  string // the sender (DE) callsign extracted from the message text
-	DecodeGrid  string // 4-char grid, CQ decodes only — the exchange carries none
+	DecodeGrid  string // 4-char grid: from a CQ, or a reply that answers with its locator
 	DeltaFreqHz int64  // audio offset within the passband (Hz)
 	SNR         int    // reported signal-to-noise (dB)
 	IsCQ        bool   // the decode was a CQ call
+	// DeltaTime is how far into the slot the transmission started, in seconds —
+	// WSJT-X's "DT" column. Read and discarded before; kept now because it is
+	// shown, and because a Reply has to replay the decode field for field.
+	DeltaTime float64
+	// DecodeMsg is the decoded text as WSJT-X printed it ("CQ K1ABC FN42",
+	// "F4BPO K1ABC -07"). Kept whole rather than only its parsed pieces: the
+	// exchange is what tells an operator where a station is in a QSO, and no set
+	// of extracted fields says "R-09" the way the line itself does.
+	DecodeMsg string
+	// DecodeMsgRaw is the message EXACTLY as the datagram carried it, trailing
+	// spaces and all. DecodeMsg above is trimmed for display; a Reply has to
+	// send this one, because the receiving application matches a Reply against
+	// its own decode list field for field and a stripped space is a mismatch it
+	// reports nowhere.
+	DecodeMsgRaw string
+	// DecodeMsSinceMidnight is the decode's own timestamp, in milliseconds since
+	// 00:00 UTC, as the sender reported it. It is what groups decodes into T/R
+	// PERIODS — arrival time cannot, since a whole period's decodes land in one
+	// burst and a slow link shifts the lot into the next slot.
+	DecodeMsSinceMidnight uint32
+	DecodeIsNew           bool // sender's "is_new": first time this line was decoded
+	LowConfidence         bool // sender is unsure of the decode
+	OffAir                bool // decoded from a file, not off the air
+
+	// ---- Status extras ----
+
+	// TxMessage is what the operator is sending right now ("CQ F4BPO JN18"),
+	// with Transmitting saying whether the carrier is actually up. Both come
+	// from Status, so they arrive about once a second.
+	TxMessage    string
+	Transmitting bool
+	// TxEnabled is the sender's "Enable Tx" toggle. It is what the WATCHDOG
+	// turns off: the application stops transmitting but leaves the DX call set,
+	// so a caller that reads only the DX call believes the QSO is still running
+	// and waits for ever. This is the difference between "between overs" and
+	// "given up".
+	TxEnabled bool
+	DECall    string // the operator's own callsign, as the digital app knows it
+	DEGrid    string // and their square
+	// TRPeriod is the transmit/receive period in seconds (15 for FT8, 7 or 8 for
+	// FT4 depending on the sender's rounding). The authority on how long a slot
+	// is — better than inferring it from the mode name, which says nothing about
+	// a custom period.
+	TRPeriod int
 }
 
 // maxFwdHeader bounds how far into a packet the WSJT-X magic may sit behind a
@@ -166,40 +210,81 @@ func ParseWSJT(pkt []byte) (WSJTEvent, bool, error) {
 			return WSJTEvent{}, false, err
 		}
 		ev.DXCall = strings.ToUpper(strings.TrimSpace(dxCall))
-		// Skip report, tx_mode (QUtf8), tx_enabled (bool), transmitting,
+		// report, tx_mode → skipped.
-		// decoding, rx_df (qint32), tx_df (qint32), de_call (QUtf8),
-		// de_grid (QUtf8) → then dx_grid.
 		for _, name := range []string{"report", "tx_mode"} {
 			if _, err := readQString(r); err != nil {
 				return ev, true, fmt.Errorf("read %s: %w", name, err)
 			}
 		}
-		// 3 booleans (each 1 byte)
+		// tx_enabled, transmitting, decoding (1 byte each). The middle one is
-		for i := 0; i < 3; i++ {
+		// worth keeping: it says the carrier is up, which is what turns TxMessage
-			var b uint8
+		// from "what I would send" into "what is going out".
-			if err := binary.Read(r, binary.BigEndian, &b); err != nil {
+		var txEnabled, transmitting, decoding uint8
+		for _, p := range []*uint8{&txEnabled, &transmitting, &decoding} {
+			if err := binary.Read(r, binary.BigEndian, p); err != nil {
 				return ev, true, err
 			}
 		}
-		// 2 int32
+		ev.Transmitting = transmitting != 0
+		ev.TxEnabled = txEnabled != 0
+		// rx_df, tx_df
 		var i32 int32
 		for i := 0; i < 2; i++ {
 			if err := binary.Read(r, binary.BigEndian, &i32); err != nil {
 				return ev, true, err
 			}
 		}
-		// de_call, de_grid, dx_grid
+		deCall, err := readQString(r)
-		if _, err := readQString(r); err != nil {
+		if err != nil {
 			return ev, true, err
 		}
-		if _, err := readQString(r); err != nil {
+		ev.DECall = strings.ToUpper(strings.TrimSpace(deCall))
+		deGrid, err := readQString(r)
+		if err != nil {
 			return ev, true, err
 		}
+		ev.DEGrid = strings.ToUpper(strings.TrimSpace(deGrid))
 		dxGrid, err := readQString(r)
 		if err != nil {
 			return ev, true, err
 		}
 		ev.DXGrid = strings.ToUpper(strings.TrimSpace(dxGrid))
+
+		// Everything past here was APPENDED to the schema over successive
+		// releases, and JTDX and MSHV each stop at their own point. A short
+		// packet is therefore normal, not an error: read as far as the sender
+		// went and keep what we got. That is why the tail below swallows its
+		// errors instead of reporting them — the fields already parsed are good.
+		var b uint8
+		if binary.Read(r, binary.BigEndian, &b) != nil { // tx_watchdog
+			return ev, true, nil
+		}
+		if _, err := readQString(r); err != nil { // sub_mode
+			return ev, true, nil
+		}
+		if binary.Read(r, binary.BigEndian, &b) != nil { // fast_mode
+			return ev, true, nil
+		}
+		if binary.Read(r, binary.BigEndian, &b) != nil { // special_operation_mode
+			return ev, true, nil
+		}
+		var u32 uint32
+		if binary.Read(r, binary.BigEndian, &u32) != nil { // frequency_tolerance
+			return ev, true, nil
+		}
+		if binary.Read(r, binary.BigEndian, &u32) != nil { // tr_period (seconds)
+			return ev, true, nil
+		}
+		// 0xFFFFFFFF is WSJT-X's "not applicable" for the quint32 fields.
+		if u32 > 0 && u32 < 3600 {
+			ev.TRPeriod = int(u32)
+		}
+		if _, err := readQString(r); err != nil { // configuration_name
+			return ev, true, nil
+		}
+		if txMsg, err := readQString(r); err == nil {
+			ev.TxMessage = strings.TrimSpace(txMsg)
+		}
 		return ev, true, nil
 
 	case wsjtMsgDecode:
@@ -217,6 +302,7 @@ func ParseWSJT(pkt []byte) (WSJTEvent, bool, error) {
 		if err := binary.Read(r, binary.BigEndian, &b); err != nil { // is_new
 			return WSJTEvent{}, false, err
 		}
+		ev.DecodeIsNew = b != 0
 		var t32, df uint32
 		var snr int32
 		if err := binary.Read(r, binary.BigEndian, &t32); err != nil { // time
@@ -229,6 +315,7 @@ func ParseWSJT(pkt []byte) (WSJTEvent, bool, error) {
 		if err := binary.Read(r, binary.BigEndian, &dt); err != nil { // delta_time
 			return WSJTEvent{}, false, err
 		}
+		ev.DeltaTime = dt
 		if err := binary.Read(r, binary.BigEndian, &df); err != nil { // delta_frequency
 			return WSJTEvent{}, false, err
 		}
@@ -240,6 +327,11 @@ func ParseWSJT(pkt []byte) (WSJTEvent, bool, error) {
 		if err != nil {
 			return WSJTEvent{}, false, err
 		}
+		// low_confidence and off_air were appended later; absent on older senders.
+		var lowConf, offAir uint8
+		_ = binary.Read(r, binary.BigEndian, &lowConf)
+		_ = binary.Read(r, binary.BigEndian, &offAir)
+
 		call, isCQ, grid := wsjtSender(msg)
 		if call == "" {
 			return WSJTEvent{}, false, nil // free-text / telemetry / unparseable → ignore
@@ -251,6 +343,11 @@ func ParseWSJT(pkt []byte) (WSJTEvent, bool, error) {
 		ev.DeltaFreqHz = int64(df)
 		ev.SNR = int(snr)
 		ev.Mode = strings.ToUpper(strings.TrimSpace(mode))
+		ev.DecodeMsg = strings.TrimSpace(msg)
+		ev.DecodeMsgRaw = msg
+		ev.DecodeMsSinceMidnight = t32
+		ev.LowConfidence = lowConf != 0
+		ev.OffAir = offAir != 0
 		return ev, true, nil
 
 	case wsjtMsgLoggedADIF:
@@ -275,8 +372,29 @@ func ParseWSJT(pkt []byte) (WSJTEvent, bool, error) {
 // third slot, never a locator.
 //
 // Returns "" for free-text / telemetry / hashed-call messages we can't resolve.
+// unbracket strips the angle brackets FT8 puts around a HASHED callsign.
+//
+// A compound or non-standard call does not fit in a 77-bit message, so the
+// protocol sends a hash of it and the receiving software prints what it
+// resolved between angle brackets: "F4BPO <ZA/IW2JOP> -24". The brackets are
+// notation, not part of the callsign — but every character test here rejected
+// them, so the whole decode was thrown away as unparseable. Every reply from a
+// station with a compound call was invisible: precisely the stations worth
+// seeing, and precisely the message that says one of them answered you.
+func unbracket(s string) string {
+	return strings.TrimSuffix(strings.TrimPrefix(s, "<"), ">")
+}
+
 func wsjtSender(message string) (call string, isCQ bool, grid string) {
-	f := strings.Fields(strings.ToUpper(strings.TrimSpace(message)))
+	msg := strings.ToUpper(strings.TrimSpace(message))
+	// The compound form — "OK1UA RR73; DH1HRN <ZA/IW2JOP> -08" — is one station
+	// signing off with another while answering a third. The sender is in the
+	// part AFTER the semicolon; reading the line from the left names OK1UA, who
+	// did not send it.
+	if i := strings.LastIndexByte(msg, ';'); i >= 0 {
+		msg = strings.TrimSpace(msg[i+1:])
+	}
+	f := strings.Fields(msg)
 	if len(f) == 0 {
 		return "", false, ""
 	}
@@ -284,11 +402,11 @@ func wsjtSender(message string) (call string, isCQ bool, grid string) {
 		// Skip an optional modifier after CQ (DX / a region like NA / a zone like
 		// 020) — it never looks like a callsign (no letter+digit mix).
 		idx := 1
-		if len(f) > 2 && !looksLikeCall(f[1]) {
+		if len(f) > 2 && !looksLikeCall(unbracket(f[1])) {
 			idx = 2
 		}
 		if idx < len(f) {
-			c := f[idx]
+			c := unbracket(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
@@ -303,8 +421,24 @@ func wsjtSender(message string) (call string, isCQ bool, grid string) {
 		return "", true, ""
 	}
 	// Standard exchange: the DE (sender) call is the second token.
-	if len(f) >= 2 && looksLikeCall(f[1]) {
+	//
-		return f[1], false, ""
+	// And the THIRD token is a grid whenever the station is answering with its
+	// locator — "C91RU IZ5EME JN52", the ordinary first reply to a CQ. This used
+	// to return no grid at all on the grounds that "the exchange carries none",
+	// which is simply not true: it is the commonest grid-bearing message on a
+	// busy band, and only a CQ being read meant a station whose CQ we missed had
+	// no known grid — so it could never be flagged as a new one. GridTracker
+	// reads both, which is why its wanted-grid count ran so far ahead of ours.
+	//
+	// isGridField is what keeps the reports and sign-offs out: -05, R-05, RRR,
+	// 73 and RR73 all fail it, on length, charset or by name.
+	if len(f) >= 2 {
+		if c := unbracket(f[1]); looksLikeCall(c) {
+			if len(f) >= 3 && isGridField(f[2]) {
+				return c, false, f[2]
+			}
+			return c, false, ""
+		}
 	}
 	return "", false, ""
 }
@@ -370,3 +504,50 @@ func readQString(r *bytes.Reader) (string, error) {
 	}
 	return string(buf), nil
 }
+
+// decodeModeChar maps the single character WSJT-X puts in a Decode's mode field
+// to the mode it stands for.
+//
+// A Decode does NOT carry the mode's name. It carries the one-character marker
+// that appears in the decode line and in ALL.TXT — "~" for FT8, "+" for FT4 —
+// and that character was being passed straight through as if it were a mode.
+// Everything downstream then compared "~" against the modes in the log, matched
+// nothing, and called every station on an already-worked band a new MODE.
+//
+// The table covers what is common; anything missing falls back to the mode from
+// the sender's last Status, which carries the real name — so an unlisted or
+// future marker degrades to correct rather than to nonsense.
+var decodeModeChar = map[string]string{
+	"~": "FT8",
+	"+": "FT4",
+	"#": "JT65",
+	"@": "JT9",
+	"&": "MSK144",
+	":": "Q65",
+	"`": "FST4",
+}
+
+// DecodeModeName resolves a Decode's mode field to a real mode name. statusMode
+// is the mode from the same program's last Status, used when the field is a
+// marker we do not know, or empty.
+func DecodeModeName(raw, statusMode string) string {
+	raw = strings.TrimSpace(raw)
+	if m, ok := decodeModeChar[raw]; ok {
+		return m
+	}
+	// A mode name is at least two alphanumeric characters ("FT8", "JS8", "Q65").
+	// Anything shorter, or carrying punctuation, is a marker rather than a name.
+	if len(raw) >= 2 {
+		named := true
+		for _, r := range raw {
+			if !(r >= 'A' && r <= 'Z') && !(r >= 'a' && r <= 'z') && !(r >= '0' && r <= '9') {
+				named = false
+				break
+			}
+		}
+		if named {
+			return strings.ToUpper(raw)
+		}
+	}
+	return strings.ToUpper(strings.TrimSpace(statusMode))
+}

internal/integrations/udp/wsjtfreetext.go

@@ -0,0 +1,78 @@
+package udp
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"strings"
+
+	"hamlog/internal/applog"
+)
+
+// WSJT-X Free Text (message type 9) — "put this in the free-text box, and send".
+//
+//	Free Text  type 9
+//	  id    utf8  the target application's own id
+//	  text  utf8  the message
+//	  send  bool  true = transmit it now, false = only fill the box
+//
+// What this is FOR, and what it is not:
+//
+// It is the one "transmit this now" primitive that behaves the same on WSJT-X,
+// WSJT-Z, JTDX, JTDX-Improved and MSHV, because it needs no decode to match
+// against — unlike Reply, which the receiving application will only action if it
+// can find the exact decode being answered.
+//
+// It is NOT a way to call a station. FT8 free text is 13 characters, so a
+// standard "<DX> <ME> <GRID>" does not fit, and more importantly the text goes
+// out AS free text without setting the DX Call — so the sequencer never takes
+// over, and no report, RR73 or logging prompt follows. Use it for a 73, a short
+// note or a CQ; use Reply to start a QSO.
+const wsjtMsgFreeText = 9
+
+// EncodeFreeText builds the datagram. send=false fills the box without keying.
+func EncodeFreeText(programID, text string, send bool) []byte {
+	var b bytes.Buffer
+	_ = binary.Write(&b, binary.BigEndian, uint32(wsjtMagic))
+	_ = binary.Write(&b, binary.BigEndian, uint32(2)) // schema 2 — what every current sender speaks
+	_ = binary.Write(&b, binary.BigEndian, uint32(wsjtMsgFreeText))
+	writeQString(&b, programID)
+	writeQString(&b, text)
+	var s uint8
+	if send {
+		s = 1
+	}
+	_ = binary.Write(&b, binary.BigEndian, s)
+	return b.Bytes()
+}
+
+// SendFreeText hands a free-text message to one decoding application.
+//
+// Routed by program id to the address that instance's packets arrive from, for
+// the same reason as SendReply and SendHaltTx: two receivers can share one
+// multicast group, and transmitting from the wrong one is worse than not
+// transmitting at all.
+func (m *Manager) SendFreeText(programID, text string, send bool) error {
+	if strings.TrimSpace(programID) == "" {
+		return fmt.Errorf("no application id — cannot tell which receiver to send with")
+	}
+	m.mu.Lock()
+	servers := make([]*Server, 0, len(m.inbound))
+	for _, s := range m.inbound {
+		servers = append(servers, s)
+	}
+	m.mu.Unlock()
+
+	for _, s := range servers {
+		conn, addr := s.replyTarget(programID)
+		if conn == nil || addr == nil {
+			continue
+		}
+		if _, err := conn.WriteToUDP(EncodeFreeText(programID, text, send), addr); err != nil {
+			return fmt.Errorf("send free text to %s at %s: %w", programID, addr, err)
+		}
+		applog.Printf("udp: free text sent to %s at %s — %q (send=%v)", programID, addr, text, send)
+		return nil
+	}
+	return fmt.Errorf("no packet has arrived from %q yet — nothing to send to", programID)
+}

internal/integrations/udp/wsjtfreetext_test.go

@@ -0,0 +1,45 @@
+package udp
+
+import (
+	"bytes"
+	"testing"
+)
+
+// The wire format, byte for byte. A malformed Free Text is discarded in silence
+// by the far end, exactly like a malformed Reply — so a wrong byte here shows up
+// as a button that does nothing.
+func TestEncodeFreeText(t *testing.T) {
+	got := EncodeFreeText("JTDX", "73 GL", true)
+	want := []byte{
+		0xad, 0xbc, 0xcb, 0xda, // magic
+		0x00, 0x00, 0x00, 0x02, // schema 2
+		0x00, 0x00, 0x00, 0x09, // type 9 — Free Text
+		0x00, 0x00, 0x00, 0x04, 'J', 'T', 'D', 'X',
+		0x00, 0x00, 0x00, 0x05, '7', '3', ' ', 'G', 'L',
+		0x01, // send now
+	}
+	if !bytes.Equal(got, want) {
+		t.Errorf("EncodeFreeText\n got %#v\nwant %#v", got, want)
+	}
+}
+
+// send=false fills the box without keying — the difference is one byte, and
+// getting it backwards would transmit when the operator only meant to prepare.
+func TestEncodeFreeTextWithoutSending(t *testing.T) {
+	got := EncodeFreeText("MSHV", "", false)
+	if got[len(got)-1] != 0x00 {
+		t.Errorf("send flag = %#x, want 0 — this would transmit unasked", got[len(got)-1])
+	}
+	// An empty text is a zero-length QString, never the -1 that means null:
+	// WSJT-X drops a packet with a null where it expects text.
+	if !bytes.Equal(got[len(got)-5:len(got)-1], []byte{0, 0, 0, 0}) {
+		t.Errorf("empty text was not encoded as a zero-length string: % X", got)
+	}
+}
+
+func TestSendFreeTextRejectsEmptyID(t *testing.T) {
+	m := &Manager{}
+	if err := m.SendFreeText("  ", "73", true); err == nil {
+		t.Fatal("expected an error for a blank program id")
+	}
+}

internal/integrations/udp/wsjthalt.go

@@ -0,0 +1,73 @@
+package udp
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"strings"
+
+	"hamlog/internal/applog"
+)
+
+// WSJT-X Halt Tx (message type 8) — "stop transmitting".
+//
+// The same two things the Halt Tx button and the Enable Tx toggle do in the
+// application's own window:
+//
+//	Halt Tx  type 8
+//	  id            utf8  the target application's own id
+//	  auto_tx_only  bool  false = stop the transmission NOW
+//	                      true  = let this over finish, then stop auto-Tx
+//
+// Both are useful and they are not the same operation. Stopping mid-over is what
+// you want when you have called the wrong station or realised the frequency is
+// occupied; finishing the over first is what you want when the QSO is complete
+// and cutting the transmission would leave the other end waiting for a report
+// that never lands.
+const wsjtMsgHaltTx = 8
+
+// EncodeHaltTx builds the datagram. autoTxOnly false halts immediately.
+func EncodeHaltTx(programID string, autoTxOnly bool) []byte {
+	var b bytes.Buffer
+	_ = binary.Write(&b, binary.BigEndian, uint32(wsjtMagic))
+	_ = binary.Write(&b, binary.BigEndian, uint32(2)) // schema 2 — what every current sender speaks
+	_ = binary.Write(&b, binary.BigEndian, uint32(wsjtMsgHaltTx))
+	writeQString(&b, programID)
+	var auto uint8
+	if autoTxOnly {
+		auto = 1
+	}
+	_ = binary.Write(&b, binary.BigEndian, auto)
+	return b.Bytes()
+}
+
+// SendHaltTx tells one decoding application to stop transmitting.
+//
+// Routed by PROGRAM ID and answered back to the address that instance's packets
+// arrive from, exactly like SendReply: two receivers can share one multicast
+// group, and halting the 20 m instance because the 6 m one is transmitting would
+// be worse than doing nothing.
+func (m *Manager) SendHaltTx(programID string, autoTxOnly bool) error {
+	if strings.TrimSpace(programID) == "" {
+		return fmt.Errorf("no application id — cannot tell which receiver to halt")
+	}
+	m.mu.Lock()
+	servers := make([]*Server, 0, len(m.inbound))
+	for _, s := range m.inbound {
+		servers = append(servers, s)
+	}
+	m.mu.Unlock()
+
+	for _, s := range servers {
+		conn, addr := s.replyTarget(programID)
+		if conn == nil || addr == nil {
+			continue
+		}
+		if _, err := conn.WriteToUDP(EncodeHaltTx(programID, autoTxOnly), addr); err != nil {
+			return fmt.Errorf("send halt to %s at %s: %w", programID, addr, err)
+		}
+		applog.Printf("udp: halt tx sent to %s at %s (auto_tx_only=%v)", programID, addr, autoTxOnly)
+		return nil
+	}
+	return fmt.Errorf("no packet has arrived from %q yet — nothing to halt", programID)
+}

internal/integrations/udp/wsjthalt_test.go

@@ -0,0 +1,75 @@
+package udp
+
+import (
+	"bytes"
+	"testing"
+)
+
+// The Halt Tx datagram, byte for byte. A wrong byte here does not fail loudly —
+// WSJT-X drops a malformed packet in silence, and the operator sees a Halt
+// button that simply does nothing.
+func TestEncodeHaltTx(t *testing.T) {
+	tests := []struct {
+		name       string
+		id         string
+		autoTxOnly bool
+		want       []byte
+	}{
+		{
+			name: "halt now",
+			id:   "WSJT-X",
+			want: []byte{
+				0xad, 0xbc, 0xcb, 0xda, // magic
+				0x00, 0x00, 0x00, 0x02, // schema 2
+				0x00, 0x00, 0x00, 0x08, // type 8 — Halt Tx
+				0x00, 0x00, 0x00, 0x06, // id length
+				'W', 'S', 'J', 'T', '-', 'X',
+				0x00, // auto_tx_only = false → stop mid-over
+			},
+		},
+		{
+			name:       "finish the over first",
+			id:         "MSHV",
+			autoTxOnly: true,
+			want: []byte{
+				0xad, 0xbc, 0xcb, 0xda,
+				0x00, 0x00, 0x00, 0x02,
+				0x00, 0x00, 0x00, 0x08,
+				0x00, 0x00, 0x00, 0x04,
+				'M', 'S', 'H', 'V',
+				0x01,
+			},
+		},
+		{
+			// An empty id is length 0, never the -1 that means a null QString:
+			// a null where text is expected makes WSJT-X discard the packet.
+			name: "empty id is a zero-length string",
+			id:   "",
+			want: []byte{
+				0xad, 0xbc, 0xcb, 0xda,
+				0x00, 0x00, 0x00, 0x02,
+				0x00, 0x00, 0x00, 0x08,
+				0x00, 0x00, 0x00, 0x00,
+				0x00,
+			},
+		},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			got := EncodeHaltTx(tc.id, tc.autoTxOnly)
+			if !bytes.Equal(got, tc.want) {
+				t.Errorf("EncodeHaltTx(%q, %v)\n got %#v\nwant %#v", tc.id, tc.autoTxOnly, got, tc.want)
+			}
+		})
+	}
+}
+
+// SendHaltTx must refuse an empty id rather than broadcast a halt at whatever
+// application happens to answer: with two receivers sharing a multicast group,
+// halting the wrong one is worse than doing nothing.
+func TestSendHaltTxRejectsEmptyID(t *testing.T) {
+	m := &Manager{}
+	if err := m.SendHaltTx("   ", false); err == nil {
+		t.Fatal("expected an error for a blank program id")
+	}
+}

internal/integrations/udp/wsjtreply.go

@@ -0,0 +1,138 @@
+package udp
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"net"
+	"strings"
+
+	"hamlog/internal/applog"
+)
+
+// WSJT-X Reply (message type 4) — "answer this station".
+//
+// It is the same thing as double-clicking the line in WSJT-X's own Band
+// Activity window: the application looks the decode up in its list, sets its
+// transmit frequency to the caller's, fills the DX call and starts the exchange.
+// Which is why OpsLog cannot do this by tuning the radio — on FT8 the whole band
+// sits inside one passband, so moving the dial changes nothing about who gets
+// answered. The decision belongs to the decoding application, and this is the
+// only way to hand it over.
+//
+// The payload REPLAYS the decode being answered, and WSJT-X matches it against
+// what it decoded. Every field has to come back exactly as it went out — which
+// is why the parser now keeps the time, the delta time, the audio offset and the
+// message text rather than only what the panadapter needed.
+//
+//	Reply    type 4
+//	  id                utf8    the target application's own id
+//	  time              quint32 ms since midnight, from the decode
+//	  snr               qint32
+//	  delta_time        double  seconds
+//	  delta_frequency   quint32 audio offset in the passband, Hz
+//	  mode              utf8
+//	  message           utf8
+//	  low_confidence    bool
+//	  modifiers         quint8  keyboard modifiers (0 = a plain click)
+const wsjtMsgReply = 4
+
+// Reply is one "call this station" request, rebuilt from a decode.
+type Reply struct {
+	ProgramID     string // which application to talk to ("WSJT-X", "MSHV", "WSJT-X - 2")
+	MsSinceMidnig uint32
+	SNR           int32
+	DeltaTime     float64
+	DeltaFreqHz   uint32
+	Mode          string
+	Message       string
+	LowConfidence bool
+}
+
+// writeQString writes a Qt QString/QUtf8: a big-endian int32 length then the
+// bytes. An EMPTY string is length 0, not the -1 that means null — WSJT-X reads
+// a null where it expects text as a malformed packet and drops the whole reply.
+func writeQString(b *bytes.Buffer, s string) {
+	_ = binary.Write(b, binary.BigEndian, int32(len(s)))
+	b.WriteString(s)
+}
+
+// EncodeReply builds the datagram.
+func EncodeReply(r Reply) []byte {
+	var b bytes.Buffer
+	_ = binary.Write(&b, binary.BigEndian, uint32(wsjtMagic))
+	_ = binary.Write(&b, binary.BigEndian, uint32(2)) // schema 2 — the one every current sender speaks
+	_ = binary.Write(&b, binary.BigEndian, uint32(wsjtMsgReply))
+	writeQString(&b, r.ProgramID)
+	_ = binary.Write(&b, binary.BigEndian, r.MsSinceMidnig)
+	_ = binary.Write(&b, binary.BigEndian, r.SNR)
+	_ = binary.Write(&b, binary.BigEndian, r.DeltaTime)
+	_ = binary.Write(&b, binary.BigEndian, r.DeltaFreqHz)
+	writeQString(&b, r.Mode)
+	writeQString(&b, r.Message)
+	var low uint8
+	if r.LowConfidence {
+		low = 1
+	}
+	_ = binary.Write(&b, binary.BigEndian, low)
+	_ = binary.Write(&b, binary.BigEndian, uint8(0)) // modifiers: a plain click
+	return b.Bytes()
+}
+
+// SendReply hands a Reply to the application that produced the decode.
+//
+// Routed by PROGRAM ID, not by listener: two receivers can share one multicast
+// group, and answering a station heard on the 6 m instance by talking to the
+// 20 m one would start a call on the wrong band. The id is what tells them
+// apart, and the address the reply goes to is the one that instance's packets
+// actually arrive from — a multicast listener must answer back to the sender,
+// not to the group.
+func (m *Manager) SendReply(r Reply) error {
+	if strings.TrimSpace(r.ProgramID) == "" {
+		return fmt.Errorf("no application id — cannot tell which receiver to answer with")
+	}
+	m.mu.Lock()
+	servers := make([]*Server, 0, len(m.inbound))
+	for _, s := range m.inbound {
+		servers = append(servers, s)
+	}
+	m.mu.Unlock()
+
+	for _, s := range servers {
+		conn, addr := s.replyTarget(r.ProgramID)
+		if conn == nil || addr == nil {
+			continue
+		}
+		pkt := EncodeReply(r)
+		if _, err := conn.WriteToUDP(pkt, addr); err != nil {
+			return fmt.Errorf("send reply to %s at %s: %w", r.ProgramID, addr, err)
+		}
+		// Says whether the decode being answered was a CQ, because that is what
+		// decides whether the far end will act on it at all: the protocol only
+		// requires a Reply to be honoured for a CQ or QRZ. Without this the log
+		// showed a reply going out and nothing happening, and the reason had to
+		// be deduced from the message text by eye.
+		kind := "not a CQ — the far end may ignore it"
+		if strings.HasPrefix(strings.TrimSpace(strings.ToUpper(r.Message)), "CQ ") {
+			kind = "CQ"
+		}
+		applog.Printf("udp: reply sent to %s at %s — %q (%s)", r.ProgramID, addr, r.Message, kind)
+		return nil
+	}
+	return fmt.Errorf("no packet has arrived from %q yet — nothing to answer to", r.ProgramID)
+}
+
+// replyTarget returns this listener's socket and the address the given program
+// last sent from, or nils when it has never been heard here.
+func (s *Server) replyTarget(programID string) (*net.UDPConn, *net.UDPAddr) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if s.conn == nil || s.lastFrom == nil {
+		return nil, nil
+	}
+	addr, ok := s.lastFrom[programID]
+	if !ok {
+		return nil, nil
+	}
+	return s.conn, addr
+}

internal/lookup/hamqth.go

@@ -7,6 +7,7 @@ import (
 	"io"
 	"net/http"
 	"net/url"
+	"regexp"
 	"strconv"
 	"strings"
 	"sync"
@@ -142,6 +143,7 @@ func parseHamQTHSearch(body []byte) (Result, error) {
 		QSLVia:    s.QSLVia,
 		Web:       s.Web,
 		ImageURL:  s.Picture,
+		RDA:       rdaRef(s.Oblast, s.District),
 	}
 	r.Lat, _ = strconv.ParseFloat(s.Latitude, 64)
 	r.Lon, _ = strconv.ParseFloat(s.Longitude, 64)
@@ -151,6 +153,27 @@ func parseHamQTHSearch(body []byte) (Result, error) {
 	return r, nil
 }
 
+// rdaRefRe matches a Russian district reference: two letters, a hyphen, two
+// digits. Searched for rather than anchored, because the field is filled by
+// hand and arrives as "KE-29", "KE-29 Kemerovskaya obl." or with stray spaces
+// depending on which editor the operator used.
+var rdaRefRe = regexp.MustCompile(`\b([A-Z]{2}-[0-9]{2})\b`)
+
+// rdaRef extracts a district reference from HamQTH's oblast/district fields.
+//
+// Strict about the SHAPE and silent otherwise: a value that is not a district
+// reference — an oblast name, a postal code, free text — must yield nothing.
+// Writing it into the award anyway would create a reference no list contains,
+// which counts for zero and has to be found and removed by hand later.
+func rdaRef(fields ...string) string {
+	for _, f := range fields {
+		if m := rdaRefRe.FindStringSubmatch(strings.ToUpper(strings.TrimSpace(f))); m != nil {
+			return m[1]
+		}
+	}
+	return ""
+}
+
 func (h *HamQTH) get(ctx context.Context, u string) ([]byte, error) {
 	req, err := http.NewRequestWithContext(ctx, "GET", u, nil)
 	if err != nil {
@@ -191,15 +214,19 @@ type hamqthSearch struct {
 	AdrCountry string `xml:"adr_country"`
 	USState    string `xml:"us_state"`
 	USCounty   string `xml:"us_county"`
-	Grid       string `xml:"grid"`
+	// Oblast is HamQTH's Russian district field; District is its generic one.
-	Latitude   string `xml:"latitude"`
+	// Both are read because operators fill whichever their editor showed them.
-	Longitude  string `xml:"longitude"`
+	Oblast    string `xml:"oblast"`
-	DXCC       string `xml:"adif"` // HamQTH exposes the ADIF/DXCC number under <adif>
+	District  string `xml:"district"`
-	CQ         string `xml:"cq"`
+	Grid      string `xml:"grid"`
-	ITU        string `xml:"itu"`
+	Latitude  string `xml:"latitude"`
-	Continent  string `xml:"continent"`
+	Longitude string `xml:"longitude"`
-	Email      string `xml:"email"`
+	DXCC      string `xml:"adif"` // HamQTH exposes the ADIF/DXCC number under <adif>
-	QSLVia     string `xml:"qsl_via"`
+	CQ        string `xml:"cq"`
+	ITU       string `xml:"itu"`
+	Continent string `xml:"continent"`
+	Email     string `xml:"email"`
+	QSLVia    string `xml:"qsl_via"`
 	// AdrName is the full postal name. Many records carry it and no <name> at
 	// all, so building the name from <nick> + <name> silently kept the first
 	// name and dropped the rest.

internal/lookup/lookup.go

@@ -45,6 +45,17 @@ type Result struct {
 	// and nothing used to read it — and since no live activation feed exists for
 	// IOTA the way it does for POTA, the callbook record is the practical source.
 	IOTA string `json:"iota,omitempty"`
+	// RDA is the Russian District Award reference (KE-29). HamQTH publishes it
+	// as <oblast>, described in their own documentation as "something like
+	// district (Russian stations)"; QRZ.com has no equivalent — its county and
+	// state fields are USA-only.
+	//
+	// It is the CURRENT district, which is why it may only ever be applied to a
+	// contact being made now. A Russian station can move, and stamping today's
+	// district on a three-year-old QSO rewrites a correct contact into a wrong
+	// one. DXLab solves the general case with dated activity records; we solve
+	// the case that matters by never dating anything but the present.
+	RDA string `json:"rda,omitempty"`
 	// Zip is the postal code. HamQTH and QRZ both send one.
 	Zip       string    `json:"zip,omitempty"`
 	ImageURL  string    `json:"image_url,omitempty"` // profile picture URL

internal/lookup/rdaref_test.go

@@ -0,0 +1,35 @@
+package lookup
+
+import "testing"
+
+// The district only ever reaches the log if it has the RIGHT SHAPE. HamQTH's
+// oblast field is filled by hand, so it arrives in whatever form the operator's
+// editor encouraged — and anything that is not a district reference must yield
+// nothing at all rather than a reference no list contains.
+func TestRDARef(t *testing.T) {
+	for _, c := range []struct{ in, want string }{
+		{"KE-29", "KE-29"},
+		{"ke-29", "KE-29"},
+		{"  KE-29  ", "KE-29"},
+		{"KE-29 Kemerovskaya obl.", "KE-29"},
+		{"Kemerovskaya obl. (KE-29)", "KE-29"},
+		{"", ""},
+		{"Kemerovskaya oblast", ""}, // a name, not a reference
+		{"KE", ""},                  // the oblast alone carries no district
+		{"KE-1", ""},                // one digit is not an RDA
+		{"KE-291", ""},              // three digits is not one either
+		{"650000", ""},              // a postal code
+		{"EU-064", ""},              // an IOTA reference in the wrong field
+	} {
+		if got := rdaRef(c.in); got != c.want {
+			t.Errorf("rdaRef(%q) = %q, want %q", c.in, got, c.want)
+		}
+	}
+	// oblast wins over district; an empty first field falls through to the next.
+	if got := rdaRef("", "MO-19"); got != "MO-19" {
+		t.Errorf("fallback to district = %q, want MO-19", got)
+	}
+	if got := rdaRef("KE-29", "MO-19"); got != "KE-29" {
+		t.Errorf("oblast must win, got %q", got)
+	}
+}

internal/qslcard/placement.go

@@ -733,7 +733,11 @@ func placeQSOBox(profile ProfileInfo, zone pxRect, occupied []pxRect) QSOBox {
 		Enabled: true, W: 760, H: 220,
 		BG: "#ffffff", BGOpacity: 0.88, Radius: 12,
 		Title:  "Confirming QSO with {qso.callsign}",
-		Fields: []string{"qso_date", "time_on", "band", "mode", "rst_sent"},
+		// The frequency belongs on a card: "20m" says which band the QSL is for,
+		// the megahertz say where the contact actually was — and a card is often
+		// the only record the OTHER station keeps. Removable in the designer for
+		// anyone who wants the band alone.
+		Fields: []string{"qso_date", "time_on", "band", "freq", "mode", "rst_sent"},
 		// PSE/TNX stamp (auto: TNX if a QSL was received, else PSE QSL) leads the
 		// message. {qso.pse_tnx} is a normal token — it can be moved to its own
 		// element anywhere on the card in the designer.

internal/qso/lastnewdxcc_test.go

@@ -0,0 +1,54 @@
+package qso
+
+import (
+	"testing"
+	"time"
+)
+
+// "When did I last add an entity" is judged against the whole log. A QSO that
+// was the fifth with its country must not become the first because the four
+// before it fall outside a date filter — that would announce a new one every
+// time the operator changed the period.
+func TestLastNewDXCCIgnoresThePeriodFilter(t *testing.T) {
+	firstByEntity := map[int]entityFirst{}
+	// Two entities, worked twice each, out of chronological order on purpose.
+	rows := []struct {
+		dxcc    int
+		at      string
+		call    string
+		country string
+	}{
+		{227, "2019-03-01", "F5ABC", "France"},
+		{291, "2021-07-04", "W1AW", "United States"},
+		{227, "2024-06-01", "F6XYZ", "France"},        // later, same entity
+		{291, "2018-01-01", "K1ZZ", "United States"},  // EARLIER than the one above
+	}
+	for _, r := range rows {
+		at, _ := time.Parse("2006-01-02", r.at)
+		if cur, seen := firstByEntity[r.dxcc]; !seen || at.Before(cur.at) {
+			firstByEntity[r.dxcc] = entityFirst{at: at, call: r.call, country: r.country}
+		}
+	}
+	if got := firstByEntity[291].call; got != "K1ZZ" {
+		t.Errorf("first US contact = %q, want K1ZZ (the earliest, whatever the row order)", got)
+	}
+	if got := firstByEntity[227].call; got != "F5ABC" {
+		t.Errorf("first French contact = %q, want F5ABC", got)
+	}
+
+	// The last new entity is the NEWEST of those firsts: France in 2019, not the
+	// 2024 French contact, and not the 2021 US one.
+	var s Stats
+	for num, f := range firstByEntity {
+		if f.at.After(parseTimeLoose(s.LastNewDXCCDate)) {
+			s.LastNewDXCC, s.LastNewDXCCNum, s.LastNewDXCCCall = f.country, num, f.call
+			s.LastNewDXCCDate = f.at.Format(time.RFC3339)
+		}
+	}
+	if s.LastNewDXCC != "France" || s.LastNewDXCCNum != 227 || s.LastNewDXCCCall != "F5ABC" {
+		t.Errorf("last new entity = %q/%d/%q, want France/227/F5ABC", s.LastNewDXCC, s.LastNewDXCCNum, s.LastNewDXCCCall)
+	}
+	if s.LastNewDXCCDate[:10] != "2019-03-01" {
+		t.Errorf("date = %q, want 2019-03-01", s.LastNewDXCCDate)
+	}
+}

internal/qso/qso.go

@@ -1475,13 +1475,67 @@ func conditionSQL(c Condition) (string, []any, error) {
 	}
 }
 
+// quickCallsignLike turns the Recent-QSOs search box into a SQL LIKE pattern.
+//
+// The rule, which is the one an operator already has in their head from the
+// alert filters:
+//
+//	4S     → starts with 4S      (4S%)
+//	*4S    → ends with 4S        (%4S)
+//	*4S*   → contains 4S         (%4S%)
+//	4S?    → 4S and one more     (4S_)
+//
+// So a plain word is a PREFIX — the common case, and what makes typing a call
+// feel like a call sign lookup rather than a text search. The moment a wildcard
+// appears the pattern is taken literally end to end, which is the only way
+// "*4S" can mean "ends with" while "4S" means "starts with".
+//
+// This used to be an unconditional contains-match, so there was no way to ask
+// for a prefix at all: searching 4S returned every call with 4S buried in it.
+//
+// % and _ typed by the operator are escaped to literals — otherwise a search
+// for "_" would quietly match everything.
+func quickCallsignLike(pattern string) string {
+	p := strings.TrimSpace(pattern)
+	var b strings.Builder
+	esc := func(r rune) {
+		switch r {
+		case '%', '_', '!':
+			b.WriteByte('!')
+		}
+		b.WriteRune(r)
+	}
+	if !strings.ContainsAny(p, "*?") {
+		for _, r := range p {
+			esc(r)
+		}
+		b.WriteByte('%') // plain text = prefix
+		return b.String()
+	}
+	for _, r := range p {
+		switch r {
+		case '*':
+			b.WriteByte('%')
+		case '?':
+			b.WriteByte('_')
+		default:
+			esc(r)
+		}
+	}
+	return b.String()
+}
+
 // buildWhere assembles the predicate (everything after WHERE) + args.
 func buildWhere(f QueryFilter) (string, []any, error) {
 	pred := "1=1"
 	var args []any
 	if qc := strings.TrimSpace(f.QuickCallsign); qc != "" {
-		pred += " AND callsign LIKE ?"
+		// ESCAPE '!' rather than the usual backslash: the clause is a literal in
-		args = append(args, "%"+qc+"%")
+		// the SQL text, and '\\' is one character to MySQL but two to SQLite,
+		// which rejects it. '!' is one character to both and appears in no
+		// callsign.
+		pred += " AND callsign LIKE ? ESCAPE '!'"
+		args = append(args, quickCallsignLike(qc))
 	}
 	if len(f.Conditions) > 0 {
 		joiner := " AND "
@@ -1605,6 +1659,136 @@ func (r *Repo) IterateByIDs(ctx context.Context, ids []int64, fn func(QSO) error
 	return rows.Err()
 }
 
+// GridKey builds the lookup key for the worked-grid index.
+//
+// band is "" for a "mix bands" scope, which is why the index stores BOTH forms
+// for every contact: asking "worked anywhere" must not mean walking the map.
+func GridKey(grid, band, class string) string {
+	return grid + "|" + strings.ToLower(band) + "|" + class
+}
+
+// GridWorkedIndex maps every worked square to whether it is CONFIRMED, under
+// every band-and-mode scope the operator can choose between.
+//
+// One QSO lands in several buckets, because the scopes overlap: an FT8 contact
+// counts for "this exact mode", for "any FTx mode" and for "any digital mode",
+// and each of those under both its own band and the any-band form. classesOf is
+// supplied by the caller — the meaning of DIGI and FTx belongs upstairs with the
+// rest of the mode vocabulary, not here.
+//
+// The value is "confirmed", not merely "present", so the same index answers both
+// hunting modes: chase what has never been worked, or chase what is not yet
+// confirmed. Confirmed means LoTW, a card or eQSL — the three the award engine
+// counts, so a square cannot be confirmed here and unconfirmed there.
+func (r *Repo) GridWorkedIndex(ctx context.Context, classesOf func(mode string) []string) (map[string]bool, error) {
+	rows, err := r.db.QueryContext(ctx, `
+		SELECT COALESCE(grid,''), UPPER(COALESCE(mode,'')), LOWER(COALESCE(band,'')),
+		       COALESCE(lotw_rcvd,''), COALESCE(qsl_rcvd,''), COALESCE(eqsl_rcvd,'')
+		FROM qso
+		WHERE grid IS NOT NULL AND grid != ''`)
+	if err != nil {
+		return nil, fmt.Errorf("query worked grids: %w", err)
+	}
+	defer rows.Close()
+	out := make(map[string]bool, 8192)
+	for rows.Next() {
+		var grid, mode, band, lotw, card, eqsl string
+		if err := rows.Scan(&grid, &mode, &band, &lotw, &card, &eqsl); err != nil {
+			return nil, err
+		}
+		g := strings.ToUpper(strings.TrimSpace(grid))
+		if len(g) < 4 {
+			continue
+		}
+		g = g[:4]
+		confirmed := lotw == "Y" || card == "Y" || eqsl == "Y"
+		for _, cls := range classesOf(mode) {
+			if cls == "" {
+				continue
+			}
+			// || is never a downgrade: one confirmed contact confirms the square
+			// for that scope, whatever the others say.
+			for _, k := range []string{GridKey(g, band, cls), GridKey(g, "", cls)} {
+				out[k] = out[k] || confirmed
+			}
+		}
+	}
+	return out, rows.Err()
+}
+
+// GridSquare is one 4-character Maidenhead square in the log.
+type GridSquare struct {
+	Grid      string `json:"grid"`
+	Count     int    `json:"count"`
+	Confirmed bool   `json:"confirmed"`
+	// Band and Mode of the most recent contact in the square, for the tooltip.
+	// The square is the subject here, not the QSO, so one example is enough —
+	// listing every band a square was worked on turns a map into a table.
+	Band string `json:"band,omitempty"`
+	Mode string `json:"mode,omitempty"`
+}
+
+// GridSquares aggregates the log into 4-character squares, newest contact
+// deciding the example band/mode.
+//
+// modeOf filters and is supplied by the caller (it owns what "digital" means):
+// return false to drop a QSO. Aggregation to 4 characters happens HERE rather
+// than in SQL — the column holds 4, 6 and 8-character grids, and lower(substr)
+// in SQL would differ between SQLite and MySQL for no gain.
+func (r *Repo) GridSquares(ctx context.Context, keep func(mode string) bool) ([]GridSquare, error) {
+	rows, err := r.db.QueryContext(ctx, `
+		SELECT COALESCE(grid,''), UPPER(COALESCE(mode,'')), LOWER(COALESCE(band,'')),
+		       COALESCE(lotw_rcvd,''), COALESCE(qsl_rcvd,''), COALESCE(eqsl_rcvd,'')
+		FROM qso
+		WHERE grid IS NOT NULL AND grid != ''
+		ORDER BY qso_date ASC, id ASC`)
+	if err != nil {
+		return nil, fmt.Errorf("query grid squares: %w", err)
+	}
+	defer rows.Close()
+	out := map[string]*GridSquare{}
+	for rows.Next() {
+		var grid, mode, band, lotw, card, eqsl string
+		if err := rows.Scan(&grid, &mode, &band, &lotw, &card, &eqsl); err != nil {
+			return nil, err
+		}
+		if keep != nil && !keep(mode) {
+			continue
+		}
+		g := strings.ToUpper(strings.TrimSpace(grid))
+		if len(g) < 4 {
+			continue
+		}
+		g = g[:4]
+		// Guard the shape: a malformed grid would draw a rectangle somewhere
+		// arbitrary, and a map with one square in the sea is a map nobody trusts.
+		if g[0] < 'A' || g[0] > 'R' || g[1] < 'A' || g[1] > 'R' ||
+			g[2] < '0' || g[2] > '9' || g[3] < '0' || g[3] > '9' {
+			continue
+		}
+		sq := out[g]
+		if sq == nil {
+			sq = &GridSquare{Grid: g}
+			out[g] = sq
+		}
+		sq.Count++
+		// Ascending order, so the last write wins = the most recent contact.
+		sq.Band, sq.Mode = band, mode
+		if lotw == "Y" || card == "Y" || eqsl == "Y" {
+			sq.Confirmed = true
+		}
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	list := make([]GridSquare, 0, len(out))
+	for _, sq := range out {
+		list = append(list, *sq)
+	}
+	sort.Slice(list, func(i, j int) bool { return list[i].Grid < list[j].Grid })
+	return list, nil
+}
+
 // BandSlotQSOs returns every contact on one band that belongs to a slot of the
 // entry matrix: the exact callsign, or any callsign in the same DXCC entity.
 // Mode is NOT filtered here — the class (phone / CW / digital) is a derived
@@ -2117,7 +2301,7 @@ func (r *Repo) IterateAll(ctx context.Context, fn func(QSO) error) error {
 const awardCols = `id, callsign, qso_date, band, freq_hz, mode, ` +
 	`grid, vucc_grids, country, state, cnty, cont, cqz, ituz, dxcc, iota, sota_ref, pota_ref, ` +
 	`name, qth, address, comment, notes, ` +
-	`qsl_rcvd, lotw_rcvd, eqsl_rcvd, extras_json`
+	`qsl_rcvd, lotw_rcvd, eqsl_rcvd, extras_json, award_refs`
 
 // IterateForAwards streams a lightweight projection of every QSO — only the
 // fields award computation reads (see awardCols). All other QSO fields are left
@@ -2142,6 +2326,37 @@ func (r *Repo) IterateForAwards(ctx context.Context, fn func(QSO) error) error {
 	return rows.Err()
 }
 
+// IterateForAwardsWithRef streams only the QSOs whose stored award_refs already
+// mention one award code.
+//
+// For a change that RELABELS an award rather than re-matching it — the grid
+// column switching from the reference to its description — the rows that can
+// possibly change are exactly these. On a 30 000-QSO log with 2 488 French
+// departments in it, that is the difference between reading the whole logbook
+// and reading a twelfth of it.
+//
+// Matched with LIKE on the JSON key, which is exact enough: award_refs is a
+// compact object written by us, so a code appears as "DDFM": and nowhere else.
+func (r *Repo) IterateForAwardsWithRef(ctx context.Context, code string, fn func(QSO) error) error {
+	like := "%\"" + strings.ToUpper(strings.TrimSpace(code)) + "\":%"
+	rows, err := r.db.QueryContext(ctx,
+		`SELECT `+awardCols+` FROM qso WHERE award_refs LIKE ? ORDER BY qso_date ASC, id ASC`, like)
+	if err != nil {
+		return fmt.Errorf("query qso (awards, one code): %w", err)
+	}
+	defer rows.Close()
+	for rows.Next() {
+		q, err := scanAwardQSO(rows)
+		if err != nil {
+			return err
+		}
+		if err := fn(q); err != nil {
+			return err
+		}
+	}
+	return rows.Err()
+}
+
 // scanAwardQSO reads one row produced by awardCols into a QSO, populating only
 // the award-relevant fields. Column order MUST match awardCols.
 func scanAwardQSO(s scanner) (QSO, error) {
@@ -2157,16 +2372,21 @@ func scanAwardQSO(s scanner) (QSO, error) {
 		comment, notes              sql.NullString
 		qslRcvd, lotwRcvd, eqslRcvd sql.NullString
 		extrasJSON                  sql.NullString
+		awardRefs                   sql.NullString
 	)
 	if err := s.Scan(
 		&q.ID, &q.Callsign, &qsoDateStr, &q.Band, &freqHz, &q.Mode,
 		&grid, &vucc, &country, &state, &cnty, &cont, &cqz, &ituz, &dxcc, &iotaRef, &sota, &pota,
 		&name, &qth, &address, &comment, &notes,
-		&qslRcvd, &lotwRcvd, &eqslRcvd, &extrasJSON,
+		&qslRcvd, &lotwRcvd, &eqslRcvd, &extrasJSON, &awardRefs,
 	); err != nil {
 		return QSO{}, fmt.Errorf("scan qso (awards): %w", err)
 	}
 	q.QSODate = parseTimeLoose(qsoDateStr)
+	// award_refs rides along so a recompute can compare what it produced against
+	// what is stored WITHOUT falling back to the full-record scan — the whole
+	// point of this projection.
+	q.AwardRefs = awardRefs.String
 	if freqHz.Valid {
 		v := freqHz.Int64
 		q.FreqHz = &v

internal/qso/quickcall_test.go

@@ -0,0 +1,28 @@
+package qso
+
+import "testing"
+
+// The search box is the one place an operator types a callsign fragment, and
+// the three shapes below are what they expect from every other logger. A plain
+// word is a PREFIX: it used to be an unconditional contains-match, so asking
+// for "calls starting with 4S" was impossible.
+func TestQuickCallsignLike(t *testing.T) {
+	for _, tc := range []struct{ in, want, why string }{
+		{"4S", "4S%", "plain text is a prefix"},
+		{"*4S", "%4S", "a leading star means ends-with"},
+		{"*4S*", "%4S%", "stars both ends mean contains"},
+		{"4S*", "4S%", "a trailing star is the same prefix, written out"},
+		{"4S?", "4S_", "? is exactly one character"},
+		{"*", "%", "a lone star matches everything"},
+		{"  4S  ", "4S%", "surrounding space is not part of the call"},
+		// Escaping: a LIKE metacharacter the operator typed is a literal.
+		{"A_B", "A!_B%", "_ typed by hand is a literal underscore"},
+		{"50%", "50!%%", "% typed by hand is a literal percent"},
+		{"A!B", "A!!B%", "the escape character escapes itself"},
+		{"*A_B*", "%A!_B%", "escaping still applies inside a wildcard pattern"},
+	} {
+		if got := quickCallsignLike(tc.in); got != tc.want {
+			t.Errorf("quickCallsignLike(%q) = %q, want %q — %s", tc.in, got, tc.want, tc.why)
+		}
+	}
+}

internal/qso/stats.go

@@ -137,6 +137,13 @@ const gapThreshold = 30 * time.Minute
 const rateMaxHours = 7 * 24
 
 // Stats is the whole dashboard payload.
+// entityFirst is the first contact ever made with one DXCC entity.
+type entityFirst struct {
+	at      time.Time
+	call    string
+	country string
+}
+
 type Stats struct {
 	// Headline figures.
 	Total       int    `json:"total"`
@@ -146,6 +153,19 @@ type Stats struct {
 	FirstQSO    string `json:"first_qso"`  // RFC3339, "" when the log is empty
 	LastQSO     string `json:"last_qso"`
 
+	// The most recent entity worked for the FIRST time, and the contact that did
+	// it. "When did I last add one" is the question a DX chaser asks of a log,
+	// and it was the one figure the panel could not answer.
+	//
+	// Judged against the WHOLE log, never the selected period: an entity is new
+	// once, and a QSO that was the fifth with its country does not become the
+	// first because the four before it fall outside a date filter. Only the
+	// period filter decides whether that contact is SHOWN.
+	LastNewDXCC     string `json:"last_new_dxcc"`     // country name
+	LastNewDXCCNum  int    `json:"last_new_dxcc_num"` // ADIF entity number
+	LastNewDXCCCall string `json:"last_new_dxcc_call"`
+	LastNewDXCCDate string `json:"last_new_dxcc_date"` // RFC3339, "" if none
+
 	// Confirmations (of Total).
 	ConfirmedLoTW int `json:"confirmed_lotw"`
 	ConfirmedEQSL int `json:"confirmed_eqsl"`
@@ -331,6 +351,8 @@ func (r *Repo) Stats(ctx context.Context, from, to time.Time, contestID string,
 		monthC      = map[string]int{}
 		times       []entry // every dated QSO (+ its operator), for the rate / gap maths
 		first, last time.Time
+		// The earliest contact with each entity, for "last new DXCC".
+		firstByEntity = map[int]entityFirst{}
 	)
 
 	for rows.Next() {
@@ -346,6 +368,22 @@ func (r *Repo) Stats(ctx context.Context, from, to time.Time, contestID string,
 			return s, err
 		}
 
+		// The first contact with each entity, over the WHOLE log — recorded before
+		// every filter below, because being new is a property of the log and not
+		// of the period on screen.
+		if dxcc.Valid && dxcc.Int64 > 0 {
+			if t := parseTimeLoose(dateStr.String).UTC(); !t.IsZero() {
+				n := int(dxcc.Int64)
+				if cur, seen := firstByEntity[n]; !seen || t.Before(cur.at) {
+					firstByEntity[n] = entityFirst{
+						at:      t,
+						call:    strings.ToUpper(strings.TrimSpace(call.String)),
+						country: strings.TrimSpace(country.String),
+					}
+				}
+			}
+		}
+
 		// Contest filter first — same reasoning as the window below: a QSO that
 		// isn't in this contest must not reach ANY bucket.
 		if contestID != "" && strings.ToUpper(strings.TrimSpace(contestID2.String)) != contestID {
@@ -459,6 +497,16 @@ func (r *Repo) Stats(ctx context.Context, from, to time.Time, contestID string,
 		return s, err
 	}
 
+	// The newest of the first-contacts: the last entity added to the log.
+	for num, f := range firstByEntity {
+		if f.at.After(parseTimeLoose(s.LastNewDXCCDate)) {
+			s.LastNewDXCC = f.country
+			s.LastNewDXCCNum = num
+			s.LastNewDXCCCall = f.call
+			s.LastNewDXCCDate = f.at.Format(time.RFC3339)
+		}
+	}
+
 	s.UniqueCalls = len(calls)
 	s.Entities = len(entities)
 	s.Continents = len(contC)

internal/rda/rda.go

@@ -0,0 +1,189 @@
+// Package rda resolves a Russian callsign to the RDA district it operated from
+// ON A GIVEN DAY.
+//
+// # Why the day matters
+//
+// A Russian station can move district, and an expedition operates from a dozen
+// in a fortnight. Asking "which district is this callsign in?" therefore has no
+// single answer, and answering it with today's district would rewrite a correct
+// three-year-old contact into a false one — silently, with nothing downstream
+// able to tell. Every lookup here takes a date for that reason.
+//
+// # The data
+//
+// Compiled from RDA.mdb, the reference database distributed for the award
+// (58 188 callsigns). Two shapes live in its RDA column and they mean different
+// things:
+//
+//	KK-08                              the district the station operates from,
+//	                                   with no history — the compiler knows of
+//	                                   no change for this call
+//	<2021-07-29,2021-07-29,TO-16>…     dated activity records, one per period
+//
+// 43 294 callsigns are of the first kind and 14 894 of the second. A dated
+// record covering the QSO day is an ANSWER; a bare current district is an
+// assumption, true for a station that never moved and wrong for one that did.
+// Lookup reports which it gave, and the caller decides whether an assumption is
+// good enough — see Match.Dated.
+//
+// # Regenerating
+//
+// There is no updater: the source is an Access database, and reading one needs
+// cgo, which this project does not use. It is converted once, by hand, and the
+// result embedded. To redo it with a newer RDA.mdb (PowerShell, needs the ACE
+// OLEDB provider that ships with Office):
+//
+//	$conn = New-Object System.Data.OleDb.OleDbConnection(
+//	  "Provider=Microsoft.ACE.OLEDB.12.0;Data Source=RDA.mdb;")
+//	SELECT CallSign, RDA, DXCCID FROM [RDACallsigns] ORDER BY CallSign
+//
+// writing one line per callsign as
+//
+//	CALL;DXCC;CURRENT;YYYYMMDD,YYYYMMDD,DIST;YYYYMMDD,YYYYMMDD,DIST…
+//
+// where CURRENT may be empty, then gzip it to rdadb.txt.gz.
+package rda
+
+import (
+	"bufio"
+	"compress/gzip"
+	"embed"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+)
+
+//go:embed rdadb.txt.gz
+var files embed.FS
+
+// span is one dated activity record: the district, and the inclusive day range
+// it applies to as YYYYMMDD integers (comparing those is comparing dates, with
+// no timezone to get wrong).
+type span struct {
+	from, to uint32
+	district string
+}
+
+type entry struct {
+	dxcc    int
+	current string // district with no history; "" when only dated records exist
+	spans   []span
+}
+
+var (
+	once  sync.Once
+	byCal map[string]entry
+	loadN int
+)
+
+// Match is what a lookup found.
+type Match struct {
+	// District is the RDA reference, e.g. "KE-29".
+	District string
+	// Dated is true when a dated activity record covered the day asked for.
+	//
+	// False means the district came from the callsign's CURRENT entry, which
+	// carries no dates at all. For the great majority of stations that is the
+	// same thing — the database records a history precisely for the ones that
+	// moved — but it is an assumption and not a fact, and a caller writing into
+	// a log years old should be told which of the two it is getting.
+	Dated bool
+	// DXCC is the entity the database files the callsign under (15, 54 or 126).
+	DXCC int
+}
+
+func load() {
+	byCal = make(map[string]entry, 60000)
+	f, err := files.Open("rdadb.txt.gz")
+	if err != nil {
+		return
+	}
+	defer f.Close()
+	zr, err := gzip.NewReader(f)
+	if err != nil {
+		return
+	}
+	defer zr.Close()
+	sc := bufio.NewScanner(zr)
+	sc.Buffer(make([]byte, 0, 64*1024), 1024*1024) // one expedition's history is long
+	for sc.Scan() {
+		line := strings.TrimSpace(sc.Text())
+		if line == "" {
+			continue
+		}
+		parts := strings.Split(line, ";")
+		if len(parts) < 3 {
+			continue
+		}
+		e := entry{current: parts[2]}
+		e.dxcc, _ = strconv.Atoi(parts[1])
+		for _, p := range parts[3:] {
+			f := strings.Split(p, ",")
+			if len(f) != 3 {
+				continue
+			}
+			from, err1 := strconv.ParseUint(f[0], 10, 32)
+			to, err2 := strconv.ParseUint(f[1], 10, 32)
+			if err1 != nil || err2 != nil {
+				continue
+			}
+			e.spans = append(e.spans, span{from: uint32(from), to: uint32(to), district: f[2]})
+		}
+		byCal[parts[0]] = e
+		loadN++
+	}
+}
+
+// Count returns how many callsigns the database holds (0 before the first use).
+func Count() int {
+	once.Do(load)
+	return loadN
+}
+
+// Lookup resolves a callsign on a given day.
+//
+// The match is EXACT on the callsign, deliberately. A suffix is not decoration:
+// RA3YG/P is somewhere other than RA3YG by definition, and quietly falling back
+// to the base call would answer with the home district for a contact made from
+// a field — which is the precise error this package exists to avoid.
+func Lookup(call string, day time.Time) (Match, bool) {
+	once.Do(load)
+	c := strings.ToUpper(strings.TrimSpace(call))
+	if c == "" {
+		return Match{}, false
+	}
+	e, ok := byCal[c]
+	if !ok {
+		return Match{}, false
+	}
+	d := ymd(day)
+	// A dated record wins whenever one covers the day. Several can overlap — an
+	// expedition working two districts in a day — and the FIRST is taken rather
+	// than a guess between them: the database lists them in the order its
+	// compiler recorded them, and inventing a tie-break here would be inventing
+	// data.
+	if d != 0 {
+		for _, s := range e.spans {
+			if d >= s.from && d <= s.to {
+				return Match{District: s.district, Dated: true, DXCC: e.dxcc}, true
+			}
+		}
+	}
+	if e.current != "" {
+		return Match{District: e.current, Dated: false, DXCC: e.dxcc}, true
+	}
+	// Dated records exist but none covers this day. That is an answer in itself
+	// — the station was somewhere the database does not know about — and it is
+	// reported as "not found" rather than by handing back a neighbouring period.
+	return Match{}, false
+}
+
+// ymd turns a time into YYYYMMDD, or 0 for the zero time.
+func ymd(t time.Time) uint32 {
+	if t.IsZero() {
+		return 0
+	}
+	t = t.UTC()
+	return uint32(t.Year())*10000 + uint32(t.Month())*100 + uint32(t.Day())
+}

internal/rda/rda_test.go

@@ -0,0 +1,64 @@
+package rda
+
+import (
+	"testing"
+	"time"
+)
+
+func day(s string) time.Time {
+	t, err := time.Parse("2006-01-02", s)
+	if err != nil {
+		panic(err)
+	}
+	return t
+}
+
+func TestLoad(t *testing.T) {
+	if n := Count(); n < 50000 {
+		t.Fatalf("loaded %d callsigns, want the whole database (~58k)", n)
+	}
+}
+
+// A station with no history: the current district, reported as an assumption.
+func TestCurrentDistrict(t *testing.T) {
+	m, ok := Lookup("R0AA", day("2020-05-01"))
+	if !ok || m.District != "KK-08" {
+		t.Fatalf("R0AA = %+v ok=%v, want KK-08", m, ok)
+	}
+	if m.Dated {
+		t.Errorf("a district with no date range must not be reported as dated")
+	}
+}
+
+// An expedition: the day decides, and a day outside every period is NOT
+// answered with a neighbouring one.
+func TestDatedDistrict(t *testing.T) {
+	m, ok := Lookup("4K4/EK250RA", day("1991-09-15"))
+	if !ok || m.District != "CK-05" || !m.Dated {
+		t.Fatalf("got %+v ok=%v, want CK-05 dated", m, ok)
+	}
+	m, ok = Lookup("4K4/EK250RA", day("1991-08-07"))
+	if !ok || m.District != "CK-08" {
+		t.Fatalf("got %+v ok=%v, want CK-08 on the one-day period", m, ok)
+	}
+	if _, ok := Lookup("4K4/EK250RA", day("2020-01-01")); ok {
+		t.Errorf("a day outside every recorded period must find nothing")
+	}
+}
+
+// The callsign is matched exactly: a suffix means somewhere else.
+func TestExactCallsign(t *testing.T) {
+	if _, ok := Lookup("R0AA/P", day("2020-05-01")); ok {
+		t.Errorf("R0AA/P must not resolve to R0AA's district")
+	}
+	if _, ok := Lookup("", day("2020-05-01")); ok {
+		t.Errorf("an empty callsign must find nothing")
+	}
+	if _, ok := Lookup("F4BPO", day("2020-05-01")); ok {
+		t.Errorf("a non-Russian callsign must find nothing")
+	}
+	// Case and stray spaces are the operator's, not the data's.
+	if m, ok := Lookup("  r0aa  ", day("2020-05-01")); !ok || m.District != "KK-08" {
+		t.Errorf("lookup must be case- and space-insensitive, got %+v ok=%v", m, ok)
+	}
+}

internal/rigctld/rigctld.go

@@ -187,6 +187,13 @@ func (s *Server) selfTest() {
 // what Stop() does on every settings save. Seen in the field: a K3 sat in
 // transmit for 29 s, until the CAT link happened to be rebuilt.
 //
+// Keyed reports whether a client currently has the rig transmitting.
+//
+// Asked before the server is torn down: pulling the socket out from under
+// WSJT-X mid-over is the one moment that costs a QSO — and, on the log that
+// prompted this, sometimes the whole application.
+func (s *Server) Keyed() bool { return s.ptt.Load() }
+
 // Swap makes this once-only, so the Stop() path and the per-connection defer it
 // triggers can both call it without double-unkeying.
 func (s *Server) releasePTT(why string) {

internal/tciserver/tciserver.go

@@ -190,6 +190,14 @@ func (s *Server) Start() error {
 // pttKnown is cleared whatever happens: after an emergency unkey the radio's
 // state is a guess, and the next command must reach it rather than be dismissed
 // as a repeat.
+// Keyed reports whether a client currently has the rig transmitting. See the
+// rigctld server's own Keyed for why the caller wants to know.
+func (s *Server) Keyed() bool {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	return s.ptt
+}
+
 func (s *Server) releasePTT(why string) {
 	s.mu.Lock()
 	keyed := s.ptt

internal/ultrabeam/transport_test.go

@@ -0,0 +1,57 @@
+package ultrabeam
+
+import (
+	"errors"
+	"io"
+	"net"
+	"testing"
+	"time"
+)
+
+// The two transports report a slow reply differently, and neither means the
+// link is gone: a remote TCP hop and a controller busy moving its motors both
+// look like silence. Getting this wrong tears the connection down on every poll.
+func TestTransientRead(t *testing.T) {
+	if !transientRead(timeoutErr{}) {
+		t.Errorf("a TCP read timeout must be transient")
+	}
+	// A serial port that stays silent returns (0, nil) forever; bufio gives up
+	// after a hundred empty reads with ErrNoProgress.
+	if !transientRead(io.ErrNoProgress) {
+		t.Errorf("a silent serial port must be transient")
+	}
+	if transientRead(io.EOF) {
+		t.Errorf("EOF is the link closing, not a slow reply")
+	}
+	if transientRead(errors.New("access denied")) {
+		t.Errorf("an open failure is not a slow reply")
+	}
+}
+
+// open must refuse a configuration it cannot honour rather than dial nothing.
+func TestOpenRejectsEmptyConfig(t *testing.T) {
+	if _, err := New(Transport{Mode: "serial"}).open(); err == nil {
+		t.Errorf("serial with no COM port must fail")
+	}
+	if _, err := New(Transport{Mode: "tcp"}).open(); err == nil {
+		t.Errorf("tcp with no host must fail")
+	}
+}
+
+// A missing baud is the controller's default, not zero — serial.Open would
+// reject 0 and the operator would see "invalid speed" for a field they never
+// knew existed.
+func TestDefaultBaud(t *testing.T) {
+	if got := New(Transport{Mode: "serial", COM: "COM3"}).tr.Baud; got != 9600 {
+		t.Errorf("default baud = %d, want 9600", got)
+	}
+}
+
+type timeoutErr struct{}
+
+func (timeoutErr) Error() string   { return "i/o timeout" }
+func (timeoutErr) Timeout() bool   { return true }
+func (timeoutErr) Temporary() bool { return true }
+
+var _ net.Error = timeoutErr{}
+var _ = time.Second

internal/ultrabeam/ultrabeam.go

@@ -1,19 +1,39 @@
-// Package ultrabeam drives an Ultrabeam remote-controlled antenna over TCP
+// Package ultrabeam drives an Ultrabeam remote-controlled antenna over SERIAL
-// (typically via an RS232↔Ethernet adapter). The wire protocol (STX/ETX
+// or TCP. The wire protocol (STX/ETX framing, DLE escaping, XOR checksum) and
-// framing, DLE escaping, XOR checksum) and command codes are the manufacturer's.
+// command codes are the manufacturer's, and identical on both: the Ethernet
+// route is an RS232↔Ethernet adapter passing the same bytes.
+//
+// Serial came second, which is the wrong way round for most stations: the
+// controller has an RS232 port and the PC is usually right next to it, so a
+// plain FTDI cable does the job and the adapter is only needed to put the
+// antenna at the other end of a link.
 package ultrabeam
 
 import (
 	"bufio"
 	"errors"
 	"fmt"
+	"io"
 	"log"
 	"net"
 	"runtime"
 	"sync"
 	"time"
+
+	"go.bug.st/serial"
 )
 
+// Transport says how to reach the controller. Mirrors internal/steppir, which
+// has had both routes from the start — one shape for the two antennas rather
+// than two shapes to remember.
+type Transport struct {
+	Mode string // "tcp" | "serial"
+	Host string // tcp
+	Port int    // tcp
+	COM  string // serial device (COM3, /dev/ttyUSB0)
+	Baud int    // serial baud
+}
+
 // Connection tuning. Remote operation (the antenna controller reached over the
 // internet, not the LAN) sees real latency and jitter, so the read timeout is
 // generous and a few transient timeouts are tolerated before the link is torn
@@ -64,9 +84,8 @@ const (
 )
 
 type Client struct {
-	host       string
+	tr         Transport
-	port       int
+	conn       io.ReadWriteCloser
-	conn       net.Conn
 	connMu     sync.Mutex
 	reader     *bufio.Reader
 	lastStatus *Status
@@ -129,15 +148,75 @@ type Status struct {
 	Connected        bool  `json:"connected"`
 }
 
-func New(host string, port int) *Client {
+func New(tr Transport) *Client {
+	if tr.Baud <= 0 {
+		tr.Baud = 9600
+	}
 	return &Client{
-		host:     host,
+		tr:       tr,
-		port:     port,
 		stopChan: make(chan struct{}),
 		seqNum:   0,
 	}
 }
 
+// open dials the transport. Callers hold connMu.
+func (c *Client) open() (io.ReadWriteCloser, error) {
+	if c.tr.Mode == "serial" {
+		if c.tr.COM == "" {
+			return nil, fmt.Errorf("ultrabeam: no serial port configured")
+		}
+		p, err := serial.Open(c.tr.COM, &serial.Mode{BaudRate: c.tr.Baud})
+		if err != nil {
+			return nil, err
+		}
+		// A finite read timeout so a silent controller cannot wedge the poll
+		// loop. Replaced per exchange by setReadTimeout below.
+		_ = p.SetReadTimeout(ubReadTimeout)
+		return p, nil
+	}
+	if c.tr.Host == "" {
+		return nil, fmt.Errorf("ultrabeam: no host configured")
+	}
+	dialer := net.Dialer{Timeout: 5 * time.Second, KeepAlive: ubKeepAlive}
+	return dialer.Dial("tcp", net.JoinHostPort(c.tr.Host, fmt.Sprintf("%d", c.tr.Port)))
+}
+
+// target names what the client is talking to, for the log.
+func (c *Client) target() string {
+	if c.tr.Mode == "serial" {
+		return fmt.Sprintf("%s @ %d baud", c.tr.COM, c.tr.Baud)
+	}
+	return fmt.Sprintf("%s:%d", c.tr.Host, c.tr.Port)
+}
+
+// setReadTimeout bounds the next read, whichever transport is open.
+//
+// TCP takes a deadline (an instant) and serial a timeout (a duration) — the two
+// libraries disagree, and the caller should not have to care.
+func (c *Client) setReadTimeout(d time.Duration) {
+	switch t := c.conn.(type) {
+	case net.Conn:
+		_ = t.SetReadDeadline(time.Now().Add(d))
+	case serial.Port:
+		_ = t.SetReadTimeout(d)
+	}
+}
+
+// transientRead reports a read that timed out rather than failed.
+//
+// The two transports say it differently. TCP returns a net.Error with
+// Timeout(); a serial port that stays silent returns (0, nil) on every read,
+// which bufio turns into io.ErrNoProgress after a hundred empty attempts.
+// Neither means the link is gone — over a remote link, or with a controller
+// busy moving its motors, a slow reply is ordinary.
+func transientRead(err error) bool {
+	var ne net.Error
+	if errors.As(err, &ne) && ne.Timeout() {
+		return true
+	}
+	return errors.Is(err, io.ErrNoProgress)
+}
+
 func (c *Client) Start() error {
 	c.running = true
 	go c.pollLoop()
@@ -174,9 +253,8 @@ func (c *Client) pollLoop() {
 			// Try to connect if not connected
 			c.connMu.Lock()
 			if c.conn == nil {
-				log.Printf("Ultrabeam: Not connected, attempting connection...")
+				log.Printf("Ultrabeam: Not connected, attempting connection to %s...", c.target())
-				dialer := net.Dialer{Timeout: 5 * time.Second, KeepAlive: ubKeepAlive}
+				conn, err := c.open()
-				conn, err := dialer.Dial("tcp", net.JoinHostPort(c.host, fmt.Sprintf("%d", c.port)))
 				if err != nil {
 					log.Printf("Ultrabeam: Connection failed: %v", err)
 					c.connMu.Unlock()
@@ -190,7 +268,7 @@ func (c *Client) pollLoop() {
 				c.conn = conn
 				c.reader = bufio.NewReader(c.conn)
 				pollFails = 0
-				log.Printf("Ultrabeam: Connected to %s:%d", c.host, c.port)
+				log.Printf("Ultrabeam: Connected to %s", c.target())
 			}
 			c.connMu.Unlock()
 
@@ -200,8 +278,7 @@ func (c *Client) pollLoop() {
 				// A single slow/lost reply over a remote link is normal — keep
 				// the connection (and the last status) for a few tries before
 				// tearing it down, so we don't churn reconnect/disconnect.
-				var ne net.Error
+				transient := transientRead(err)
-				transient := errors.As(err, &ne) && ne.Timeout()
 				pollFails++
 				if transient && pollFails < ubMaxPollTimeout {
 					log.Printf("Ultrabeam: status timeout (%d/%d), keeping link: %v", pollFails, ubMaxPollTimeout, err)
@@ -430,7 +507,7 @@ func (c *Client) sendCommand(cmd byte, data []byte) ([]byte, error) {
 	}
 
 	// Read the reply with a timeout generous enough for a remote link.
-	c.conn.SetReadDeadline(time.Now().Add(ubReadTimeout))
+	c.setReadTimeout(ubReadTimeout)
 	buffer, err := c.readPacket()
 	if err != nil {
 		return nil, err
@@ -467,7 +544,8 @@ func (c *Client) sendCommand(cmd byte, data []byte) ([]byte, error) {
 // behind by a command that timed out. A short read deadline lets it consume what
 // is there and stop quickly when the stream is clean. Caller holds connMu.
 func (c *Client) drainStale() {
-	c.conn.SetReadDeadline(time.Now().Add(5 * time.Millisecond))
+	c.setReadTimeout(5 * time.Millisecond)
+	defer c.setReadTimeout(ubReadTimeout) // leave the link on its normal budget
 	buf := make([]byte, 256)
 	for {
 		n, err := c.reader.Read(buf)

offline.go

@@ -161,6 +161,11 @@ func (a *App) replayOfflineQueue() (int, error) {
 			failed = append(failed, q)
 			continue
 		}
+		// These are contacts the operator MADE — the worked indexes have to learn
+		// them, or every one of them keeps its NEW badge in the cluster and decode
+		// lists until the next restart. a.qso.Add is the raw insert; only AddQSO
+		// does this for you, and the outbox replay does not go through it.
+		a.noteWorked(q.Callsign, q.Band, q.Mode)
 		imported++
 	}
 

spotcolors.go

@@ -0,0 +1,225 @@
+package main
+
+// Panadapter spot colours, per status.
+//
+// A FlexRadio draws every OpsLog spot in one colour today, which throws away the
+// only thing worth knowing at a glance on a waterfall: whether the station is
+// worth stopping for. The radio's own API has always taken a text colour AND a
+// background colour per spot — see internal/cat/flex.go — so the information can
+// be carried without a single extra pixel of screen.
+//
+// The statuses are the ones the cluster already computes (see spotEntityStatus),
+// plus the three orthogonal markers an operator chases separately.
+
+import (
+	"encoding/json"
+	"strings"
+)
+
+// keySpotColors holds the per-status palette.
+const keySpotColors = "flex.spot_colors"
+
+// SpotColor is one status's pair. Both are #AARRGGBB — alpha FIRST, which is
+// SmartSDR's order, not the web's. An empty background leaves the radio's own.
+type SpotColor struct {
+	Text string `json:"text"`
+	Bg   string `json:"bg,omitempty"`
+}
+
+// SpotColors is the whole palette, keyed by the status names the cluster uses.
+//
+// Stored as a map rather than a struct with nine fields so a status added later
+// (a new award marker, say) needs no migration: an unknown key is ignored and a
+// missing one falls back to the default below.
+type SpotColors struct {
+	// Enabled off sends no colour at all, which is the behaviour before this
+	// existed: every spot in the radio's default orange. Kept as a real switch so
+	// turning it off is a genuine revert rather than "some other palette".
+	Enabled bool                 `json:"enabled"`
+	Colors  map[string]SpotColor `json:"colors"`
+}
+
+// spotColorOrder is the palette's canonical order — most wanted first, then the
+// orthogonal markers, then the two "nothing here" cases. The settings panel
+// renders it in this order, and it is the order the resolver tries.
+var spotColorOrder = []string{
+	"new", "new-band-mode", "new-band", "new-mode", "new-slot",
+	"new-pota", "new-county", "new-pfx",
+	"my-call", "worked", "none",
+}
+
+// defaultSpotColors is the shipped palette.
+//
+// Text colours are opaque and bright, backgrounds are the same hue at a fifth of
+// the alpha: a waterfall is dark and busy, and a solid plate behind the callsign
+// hides the very signal the operator is looking at. The scale runs red → amber →
+// blue for "never had it" → "missing a piece" → "already yours".
+var defaultSpotColors = map[string]SpotColor{
+	"new":           {Text: "#FFFF3B30", Bg: "#40FF3B30"}, // entity never worked — the one you stop for
+	"new-band-mode": {Text: "#FFFF6B22", Bg: "#40FF6B22"}, // neither band nor mode: nearly as good
+	"new-band":      {Text: "#FFFFCC00", Bg: "#40FFCC00"},
+	"new-mode":      {Text: "#FFFFA500", Bg: "#40FFA500"},
+	"new-slot":      {Text: "#FF5AC8FA", Bg: "#405AC8FA"},
+	"new-pota":      {Text: "#FF34C759", Bg: "#4034C759"},
+	"new-county":    {Text: "#FF30D158", Bg: "#4030D158"},
+	"new-pfx":       {Text: "#FFAF52DE", Bg: "#40AF52DE"},
+	"my-call":       {Text: "#FFFF2D55", Bg: "#60FF2D55"}, // someone spotted YOU
+	"worked":        {Text: "#FF9CA3AF", Bg: "#209CA3AF"}, // already in the log — present, quiet
+	"none":          {Text: "#FF9CA3AF", Bg: ""},          // status unresolved
+}
+
+// hexARGB accepts #AARRGGBB and nothing else. The Flex refuses anything shorter
+// with a command error the operator never sees, so a half-typed value must not
+// reach the radio — it is dropped here and the default is used instead.
+func hexARGB(s string) bool {
+	s = strings.TrimSpace(s)
+	if len(s) != 9 || s[0] != '#' {
+		return false
+	}
+	for i := 1; i < len(s); i++ {
+		c := s[i]
+		if !(c >= '0' && c <= '9' || c >= 'a' && c <= 'f' || c >= 'A' && c <= 'F') {
+			return false
+		}
+	}
+	return true
+}
+
+// normSpotColors drops anything that is not a valid colour, so the stored
+// palette can never make the radio reject a spot.
+func normSpotColors(s SpotColors) SpotColors {
+	out := SpotColors{Enabled: s.Enabled, Colors: map[string]SpotColor{}}
+	known := map[string]bool{}
+	for _, k := range spotColorOrder {
+		known[k] = true
+	}
+	for k, v := range s.Colors {
+		if !known[k] {
+			continue
+		}
+		c := SpotColor{}
+		if hexARGB(v.Text) {
+			c.Text = strings.ToUpper(strings.TrimSpace(v.Text))
+		}
+		if hexARGB(v.Bg) {
+			c.Bg = strings.ToUpper(strings.TrimSpace(v.Bg))
+		}
+		if c.Text != "" || c.Bg != "" {
+			out.Colors[k] = c
+		}
+	}
+	return out
+}
+
+// GetSpotColors returns the palette, filled with the defaults for every status
+// the operator has not overridden — so the panel always has a colour to show and
+// the resolver never has to decide what "unset" looks like.
+func (a *App) GetSpotColors() SpotColors {
+	out := SpotColors{Enabled: true, Colors: map[string]SpotColor{}}
+	if raw := a.settingOr(keySpotColors, ""); raw != "" {
+		var stored SpotColors
+		if err := json.Unmarshal([]byte(raw), &stored); err == nil {
+			stored = normSpotColors(stored)
+			out.Enabled = stored.Enabled
+			out.Colors = stored.Colors
+		}
+	}
+	for _, k := range spotColorOrder {
+		if _, ok := out.Colors[k]; !ok {
+			out.Colors[k] = defaultSpotColors[k]
+		}
+	}
+	return out
+}
+
+// SaveSpotColors persists the palette.
+func (a *App) SaveSpotColors(s SpotColors) error {
+	b, err := json.Marshal(normSpotColors(s))
+	if err != nil {
+		return err
+	}
+	a.setSetting(keySpotColors, string(b))
+	a.spotColorsMu.Lock()
+	a.spotColorsCache = nil // re-read on the next spot
+	a.spotColorsMu.Unlock()
+	return nil
+}
+
+// ResetSpotColors puts the shipped palette back.
+func (a *App) ResetSpotColors() SpotColors {
+	a.setSetting(keySpotColors, "")
+	a.spotColorsMu.Lock()
+	a.spotColorsCache = nil
+	a.spotColorsMu.Unlock()
+	return a.GetSpotColors()
+}
+
+// spotColorFor picks the pair for one spot status.
+//
+// Cached, because this runs on EVERY spot from every cluster — a busy evening is
+// several a second, and re-reading and re-parsing the settings JSON for each one
+// would put a database round trip in the middle of the cluster read loop.
+func (a *App) spotColorFor(status string) SpotColor {
+	a.spotColorsMu.Lock()
+	if a.spotColorsCache == nil {
+		c := a.GetSpotColors()
+		a.spotColorsCache = &c
+	}
+	p := a.spotColorsCache
+	a.spotColorsMu.Unlock()
+	if !p.Enabled {
+		return SpotColor{}
+	}
+	if c, ok := p.Colors[status]; ok {
+		return c
+	}
+	return p.Colors["none"]
+}
+
+// spotStatusTag is the short label appended to a panadapter spot's comment.
+//
+// The colour says WHAT a spot is only to someone who has learnt the palette; the
+// word says it to everyone, including the operator who set the colours a month
+// ago. Both, then — the same choice DXHunter makes, whose spots read
+// "10 dB 18 WPM CQ [AC0C] [United States] [NEW CTY]".
+//
+// Short on purpose: the comment shares a panadapter with the signals, and a
+// spot label that runs over its neighbours hides the very thing it describes.
+// "worked" and an unresolved entity get nothing at all — there is no news in
+// either, and the absence of a tag is itself the answer.
+func spotStatusTag(status string) string {
+	switch status {
+	case "new":
+		return "NEW DXCC"
+	case "new-band-mode":
+		return "NEW BAND+MODE"
+	case "new-band":
+		return "NEW BAND"
+	case "new-mode":
+		return "NEW MODE"
+	case "new-slot":
+		return "NEW SLOT"
+	case "new-pota":
+		return "NEW POTA"
+	case "new-county":
+		return "NEW COUNTY"
+	case "new-pfx":
+		return "NEW PFX"
+	case "my-call":
+		return "ME"
+	}
+	return ""
+}
+
+// spotComment appends the status tag to the cluster's own comment.
+func spotComment(comment, status string) string {
+	c := strings.TrimSpace(comment)
+	tag := spotStatusTag(status)
+	if tag == "" {
+		return c
+	}
+	if c == "" {
+		return "[" + tag + "]"
+	}
+	return c + " [" + tag + "]"
+}

spotcolors_test.go

@@ -0,0 +1,76 @@
+package main
+
+import "testing"
+
+// A colour the Flex refuses is a spot that never appears, and the command error
+// goes to a log nobody is reading. Anything that is not #AARRGGBB must be
+// dropped here rather than sent.
+func TestHexARGB(t *testing.T) {
+	for _, ok := range []string{"#FFFF3B30", "#00000000", "#ffabcdef", "#40FF6B22"} {
+		if !hexARGB(ok) {
+			t.Errorf("%q should be accepted", ok)
+		}
+	}
+	for _, bad := range []string{
+		"", "#FFF", "#FF3B30", "FFFF3B30", "#FFFF3B3", "#FFFF3B300",
+		"#GGFF3B30", "#FFFF3B3G", "red", "rgb(255,0,0)",
+	} {
+		if hexARGB(bad) {
+			t.Errorf("%q should be refused", bad)
+		}
+	}
+}
+
+// The stored palette must survive a round trip, and must not carry a status the
+// resolver does not know — an unknown key would be a colour nothing can ever use
+// and a field nobody can remove from the panel.
+func TestNormSpotColors(t *testing.T) {
+	in := SpotColors{Enabled: true, Colors: map[string]SpotColor{
+		"new":      {Text: "#FFFF3B30", Bg: "#40FF3B30"},
+		"new-band": {Text: "not a colour", Bg: "#40FFCC00"}, // half valid
+		"worked":   {Text: "", Bg: ""},                      // nothing at all
+		"invented": {Text: "#FF000000"},                     // not a status
+	}}
+	out := normSpotColors(in)
+	if got := out.Colors["new"].Text; got != "#FFFF3B30" {
+		t.Errorf("valid pair lost: %q", got)
+	}
+	if c := out.Colors["new-band"]; c.Text != "" || c.Bg != "#40FFCC00" {
+		t.Errorf("half-valid pair = %+v, want the background kept and the text dropped", c)
+	}
+	if _, ok := out.Colors["worked"]; ok {
+		t.Errorf("an entry with no colour at all must not be stored")
+	}
+	if _, ok := out.Colors["invented"]; ok {
+		t.Errorf("an unknown status must not be stored")
+	}
+}
+
+func TestSpotComment(t *testing.T) {
+	// The cluster's own text is kept: it carries the signal report and the
+	// operator's note, which is why the spot is readable in the first place.
+	if got := spotComment("CQ up 2", "new"); got != "CQ up 2 [NEW DXCC]" {
+		t.Fatalf("got %q", got)
+	}
+	// An empty comment must not produce a leading space on the panadapter.
+	if got := spotComment("", "new-band"); got != "[NEW BAND]" {
+		t.Fatalf("got %q", got)
+	}
+	// Nothing to say about a station already in the log.
+	if got := spotComment("loud", "worked"); got != "loud" {
+		t.Fatalf("got %q", got)
+	}
+	if got := spotComment("loud", "none"); got != "loud" {
+		t.Fatalf("got %q", got)
+	}
+	// Every colourable status except the two quiet ones is labelled, or the
+	// palette would say something the text does not.
+	for _, s := range spotColorOrder {
+		if s == "worked" || s == "none" {
+			continue
+		}
+		if spotStatusTag(s) == "" {
+			t.Fatalf("status %q has a colour but no tag", s)
+		}
+	}
+}

spotstatus_test.go

@@ -0,0 +1,59 @@
+package main
+
+import "testing"
+
+// The order of these tests IS the meaning of the answer, and it was wrong: a
+// station new on both the band and the mode was reported as a plain "new band",
+// which reads as "you have worked this entity in this mode, just not here" —
+// the opposite of the truth. It is also not a slot: a slot is the pair still
+// missing when each half is already in the log.
+func TestSpotEntityStatus(t *testing.T) {
+	for _, c := range []struct {
+		name                             string
+		worked, haveBand, haveMode, slot bool
+		mode                             string
+		want                             string
+	}{
+		{"entity never worked", false, false, false, false, "SSB", "new"},
+		{"entity never worked, no mode known", false, false, false, false, "", "new"},
+
+		// The case this exists for.
+		{"new band AND new mode", true, false, false, false, "SSB", "new-band-mode"},
+
+		// New band, but the mode is already in the log on another band.
+		{"new band only", true, false, true, false, "SSB", "new-band"},
+		// New mode, on a band already worked.
+		{"new mode only", true, true, false, false, "SSB", "new-mode"},
+		// Each half worked, never together: THAT is a slot.
+		{"new slot", true, true, true, false, "SSB", "new-slot"},
+		{"fully worked", true, true, true, true, "SSB", "worked"},
+
+		// No mode: only the band can be judged, and a guess must never claim new.
+		{"no mode, new band", true, false, false, false, "", "new-band"},
+		{"no mode, band worked", true, true, false, false, "", "worked"},
+	} {
+		if got := spotEntityStatus(c.worked, c.haveBand, c.haveMode, c.slot, c.mode); got != c.want {
+			t.Errorf("%s: got %q, want %q", c.name, got, c.want)
+		}
+	}
+}
+
+// Every status is reachable, and no two inputs collide on a status that should
+// be exclusive — the guard against someone "simplifying" the chain later.
+func TestSpotEntityStatusIsExhaustive(t *testing.T) {
+	seen := map[string]bool{}
+	for _, worked := range []bool{true, false} {
+		for _, band := range []bool{true, false} {
+			for _, mode := range []bool{true, false} {
+				for _, slot := range []bool{true, false} {
+					seen[spotEntityStatus(worked, band, mode, slot, "CW")] = true
+				}
+			}
+		}
+	}
+	for _, want := range []string{"new", "new-band-mode", "new-band", "new-mode", "new-slot", "worked"} {
+		if !seen[want] {
+			t.Errorf("no combination produces %q — the status is dead", want)
+		}
+	}
+}

syncfolder.go

@@ -507,6 +507,10 @@ func (a *App) applySyncRecord(rec syncfolder.Record) bool {
 	if err := a.qso.SetSyncUID(a.ctx, newID, rec.UID); err != nil {
 		applog.Printf("foldersync: stamping the new QSO %d: %v", newID, err)
 	}
+	// A partner's contact counts as worked for this station too — that is the
+	// point of a multi-op log — so the worked indexes must learn it exactly as
+	// they do for our own. Raw insert, so nothing else does it.
+	a.noteWorked(q.Callsign, q.Band, q.Mode)
 	return true
 }
 

telemetry.go

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