chore: release v0.26.4

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

@@ -55,6 +55,7 @@ import (
 	"hamlog/internal/psu"
 	"hamlog/internal/qslcard"
 	"hamlog/internal/qso"
+	"hamlog/internal/rda"
 	"hamlog/internal/relaydev"
 	"hamlog/internal/rigctld"
 	"hamlog/internal/rotator/dcu1"
@@ -793,6 +794,15 @@ type App struct {
 	catFlexDVKDax      bool // raise the Flex transmit DAX button around a voice message
 	catFlexDecodeSpots bool // push WSJT-X decodes (heard stations) to the panadapter
 	catFlexDecodeSecs  int  // decode spot display duration (seconds)
+	// The panadapter palette, parsed once and re-read when it is saved. Guarded
+	// because the cluster read loop touches it on every spot.
+	spotColorsMu    sync.Mutex
+	spotColorsCache *SpotColors
+	// catSig / catShareSig fingerprint the last APPLIED link and share
+	// configuration, so re-applying an identical one is a no-op instead of a
+	// reconnection. Empty at startup, which is what makes the first call connect.
+	catSig           string
+	catShareSig      string
 	liveActMu        sync.Mutex // guards the entry-strip activity reported for live status
 	liveFreqHz       int64      // last freq/band/mode the UI reported (fallback when CAT is off)
 	liveBand         string
@@ -807,6 +817,8 @@ type App struct {
 	awardSnap        []qso.QSO      // light-scanned + enriched logbook snapshot reused across award computations
 	awardSnapRev     string         // logbook revision the snapshot was built at ("" = none)
 	awardSnapUsed    time.Time      // last read — the snapshot is dropped once it goes cold (see awardSnapshotJanitor)
+	workedRefMu      sync.Mutex     // guards the worked-reference sets
+	workedRef        workedRefIndex // per-award references already in the log — see awardnew.go
 	webpub           webPublisher   // log-to-website publishing: debounce timer, periodic ticker, last result
 	bandOpen         bandOpenState  // sporadic-E / band-opening detector over the spot stream
 	dataDir          string         // <exeDir>/data — holds config.json, logs, cty.dat
@@ -1197,6 +1209,7 @@ func (a *App) startup(ctx context.Context) {
 	applog.Printf("startup: logbook backend = %s", backend)
 	a.logDb = logbookConn
 	a.qso = qso.NewRepo(logbookConn)
+	a.tidyLogbookSchema(logbookConn)
 	a.backfillAwardRefsOnce()                     // one-time: materialise award_refs for pre-existing QSOs
 	go a.rebuildWorkedIndex()                     // in-memory worked-index for per-spot alert checks
 	go a.adifMonitorLoop()                        // watch external ADIF files (fldigi, N1MM…) for new QSOs
@@ -1545,6 +1558,22 @@ func (a *App) GetStartupStatus() StartupStatus {
 	}
 }
 
+// armExitWatchdog guarantees the process dies.
+//
+// A graceful shutdown is preferable and is what everything below attempts; this
+// only fires when that has already failed. By then the log says which step never
+// returned, and the databases are either closed or safe to leave — SQLite's WAL
+// survives a hard exit, which a zombie process does not.
+func (a *App) armExitWatchdog(after time.Duration) {
+	go func() {
+		time.Sleep(after)
+		applog.Printf("shutdown: still not finished after %s — forcing exit "+
+			"(the last 'shutdown:' line above names the step that hung)", after)
+		applog.Close()
+		os.Exit(0)
+	}()
+}
+
 // beforeClose intercepts the window-close event so we can run shutdown
 // tasks (backup, future LoTW upload, ...) while showing a progress modal
 // to the user. Returns true the first time to block the close; the
@@ -1555,6 +1584,13 @@ func (a *App) beforeClose(ctx context.Context) bool {
 		return false
 	}
 	a.shuttingDown = true
+	applog.Printf("shutdown: close requested")
+	// From here the application MUST end. Everything below waits on hardware and
+	// databases, and any one of them hanging used to leave a window that would
+	// not close and a process the operator had to kill from the task manager —
+	// which then blocked the next launch (single-instance guard) and the restart
+	// after an update. The watchdog is the promise that it ends anyway.
+	a.armExitWatchdog(30 * time.Second)
 
 	// Capture geometry now, before any shutdown UI can resize the window, so the
 	// next launch reopens exactly here.
@@ -1636,6 +1672,7 @@ func (a *App) runShutdownTasks(ctx context.Context, steps []shutdownStep) {
 			steps[i].Status = "done"
 		}
 		a.emitShutdownEvent("shutdown:update", steps)
+		applog.Printf("shutdown: step %q %s %s", steps[i].ID, steps[i].Status, steps[i].Detail)
 	}
 	a.emitShutdownEvent("shutdown:done", steps)
 	// Cleanly tear down hardware links before quitting. Especially the CAT
@@ -1643,11 +1680,14 @@ func (a *App) runShutdownTasks(ctx context.Context, steps []shutdownStep) {
 	// TCP is gone, and just letting the process exit left the slot stale — the
 	// NEXT launch then spent ~30s retrying the connect before the radio freed it.
 	// cat.Stop() closes the socket with a proper FIN so the radio drops us at once.
+	applog.Printf("shutdown: stopping CAT")
 	if a.cat != nil {
 		a.cat.Stop()
 	}
+	applog.Printf("shutdown: releasing relay drivers")
 	a.closeRelayDrivers() // release FTDI/serial relay handles for the next launch
 	time.Sleep(600 * time.Millisecond)
+	applog.Printf("shutdown: calling Quit")
 	wruntime.Quit(ctx)
 }
 
@@ -1706,12 +1746,23 @@ func (a *App) shutdown(ctx context.Context) {
 	// If the user managed to skip beforeClose (force kill, OS shutdown,
 	// crash recovery) we still try the backup here as a best-effort
 	// safety net. HasBackupToday makes a double-run a no-op.
+	applog.Printf("shutdown: teardown starting")
+	// Covers the paths beforeClose never saw (force kill of the window, OS
+	// shutdown) — and re-arms a shorter fuse for the teardown itself.
+	a.armExitWatchdog(15 * time.Second)
 	if !a.shuttingDown {
 		a.maybeShutdownBackup()
 	}
+	// Before the hardware and the databases: a program asked to close with
+	// OpsLog should get its request while everything is still up, not after the
+	// logger has spent seconds tearing down ports.
+	applog.Printf("shutdown: closing autostart programs")
+	a.CloseAutostartPrograms()
+	applog.Printf("shutdown: stopping UDP")
 	if a.udp != nil {
 		a.udp.StopAll()
 	}
+	applog.Printf("shutdown: stopping solar")
 	if a.solar != nil {
 		a.solar.Stop()
 	}
@@ -1719,6 +1770,7 @@ func (a *App) shutdown(ctx context.Context) {
 	// backend: without this the rig never gets a disconnect and holds its single
 	// control session for minutes, refusing every new login (even from the Icom
 	// Remote Utility) until it times out on its own.
+	applog.Printf("shutdown: stopping CAT sharing")
 	if a.catShare != nil {
 		// Before the CAT stop, so no client is mid-command against a backend that
 		// is disconnecting — and so the port is free for the next launch.
@@ -1729,29 +1781,35 @@ func (a *App) shutdown(ctx context.Context) {
 		a.catShareTCI.Stop()
 		a.catShareTCI = nil
 	}
+	applog.Printf("shutdown: stopping CAT")
 	if a.cat != nil {
 		a.cat.Stop()
 	}
+	applog.Printf("shutdown: stopping WinKeyer")
 	if a.winkeyer != nil {
 		a.winkeyer.Disconnect()
 	}
+	applog.Printf("shutdown: stopping QSO recorder")
 	if a.qsoRec != nil {
 		a.qsoRec.Stop()
 	}
 	// Before the databases: Close flushes what the last minute learnt, and a
 	// restart is exactly when the grid cache is worth the most.
+	applog.Printf("shutdown: closing grid cache")
 	if a.gridStore != nil {
 		if err := a.gridStore.Close(); err != nil {
 			applog.Printf("gridcache: close: %v", err)
 		}
 		a.gridStore = nil
 	}
+	applog.Printf("shutdown: closing databases")
 	if a.logDb != nil && a.logDb != a.db {
 		_ = a.logDb.Close() // shared MySQL logbook (separate from the local config DB)
 	}
 	if a.db != nil {
 		_ = a.db.Close()
 	}
+	applog.Printf("shutdown: teardown done")
 }
 
 // userDataDir returns the OpsLog data directory: always "<exe dir>/data".
@@ -2262,6 +2320,11 @@ func (a *App) connectLogbook(cfg profile.ProfileDB) (*sql.DB, string, error) {
 	}
 	if lp == "" {
 		a.logDbPath = "" // settings db serves as the logbook (split failed) — backup snapshots a.db
+		// It may have had its unused qso table dropped while a separate logbook
+		// was in use (see tidyLogbookSchema); rebuild it before handing it over.
+		if err := db.EnsureQSOTable(a.db); err != nil {
+			return nil, "", err
+		}
 		return a.db, "sqlite", nil
 	}
 	// Resolve against THIS install before opening. Without it, a profile carried
@@ -2273,7 +2336,7 @@ func (a *App) connectLogbook(cfg profile.ProfileDB) (*sql.DB, string, error) {
 		applog.Printf("logbook: profile path %q resolved to %q", lp, r)
 		lp = r
 	}
-	c, err := db.Open(lp)
+	c, err := db.OpenLogbook(lp)
 	if err != nil {
 		return nil, "", fmt.Errorf("open logbook %s: %w", lp, err)
 	}
@@ -3590,7 +3653,8 @@ func (a *App) SaveAwardDefs(defs []award.Def) error {
 	if a.settings == nil {
 		return fmt.Errorf("db not initialized")
 	}
-	markUserEdited(defs, a.awardDefs())
+	prev := a.awardDefs()
+	markUserEdited(defs, prev)
 	b, err := json.Marshal(defs)
 	if err != nil {
 		return err
@@ -3599,10 +3663,55 @@ func (a *App) SaveAwardDefs(defs []award.Def) error {
 		return err
 	}
 	go a.mirrorAwardsToFolder(defs)
+	// A change that only alters HOW a match is written — reference, description
+	// or both in the grid column — cannot change WHICH QSOs match. Recomputing
+	// every award for every contact then produces a known answer at the cost of
+	// reading the whole logbook, and the operator waits minutes to see a column
+	// they expected to change at once.
+	if codes, ok := relabelOnly(prev, defs); ok {
+		a.recomputeAwardRefsForCodesAsync(codes)
+		return nil
+	}
 	a.recomputeAwardRefsAsync() // definitions changed → refresh every row's award_refs
 	return nil
 }
 
+// relabelOnly reports whether the only difference between two definition sets is
+// the RefDisplay of some awards, and names them.
+//
+// Conservative by construction: it compares the two definitions with RefDisplay
+// blanked out, so ANY other difference — a new field, a pattern, a band, an
+// award added or removed — fails the test and the full recompute runs. A wrong
+// "yes" here would leave stale references in the log, which is far worse than a
+// slow save.
+func relabelOnly(prev, next []award.Def) ([]string, bool) {
+	if len(prev) != len(next) {
+		return nil, false
+	}
+	byCode := map[string]award.Def{}
+	for _, d := range prev {
+		byCode[strings.ToUpper(strings.TrimSpace(d.Code))] = d
+	}
+	var codes []string
+	for _, n := range next {
+		o, ok := byCode[strings.ToUpper(strings.TrimSpace(n.Code))]
+		if !ok {
+			return nil, false
+		}
+		if n.RefDisplay != o.RefDisplay {
+			codes = append(codes, strings.ToUpper(strings.TrimSpace(n.Code)))
+		}
+		a, b := n, o
+		a.RefDisplay, b.RefDisplay = "", ""
+		ja, err1 := json.Marshal(a)
+		jb, err2 := json.Marshal(b)
+		if err1 != nil || err2 != nil || string(ja) != string(jb) {
+			return nil, false
+		}
+	}
+	return codes, len(codes) > 0
+}
+
 // mirrorAwards refreshes the awards folder from the database.
 //
 // It is called from EVERY path that can change an award — the definitions AND the
@@ -4637,6 +4746,9 @@ func (a *App) invalidateAwardStats() {
 	a.qsoNumMu.Lock()
 	a.qsoNumbers = nil
 	a.qsoNumMu.Unlock()
+	// Reference lists, award definitions and bulk edits all land here, and any of
+	// them can change what counts as already worked.
+	a.invalidateWorkedRefs()
 	// Bulk QSO changes (import, delete, bulk edit) also land here — refresh the
 	// worked-index so alert "needed" checks stay accurate. Async: never block the
 	// mutation, and it's a single lightweight query.
@@ -5016,9 +5128,14 @@ func (a *App) materializeAwardRefs(q qso.QSO) {
 		return
 	}
 	ac := a.newAwardMatCtx()
-	if err := a.qso.SetAwardRefs(a.ctx, q.ID, a.awardRefsJSONFor(ac, q)); err != nil {
+	refs := a.awardRefsJSONFor(ac, q)
+	if err := a.qso.SetAwardRefs(a.ctx, q.ID, refs); err != nil {
 		applog.Printf("award_refs: store for qso %d failed: %v", q.ID, err)
 	}
+	// Keep the NEW-badge sets in step with the contact just logged, rather than
+	// letting the revision change discard them while the operator types the next
+	// callsign. Off the logging path: it re-matches the QSO against every award.
+	go a.noteWorkedQSO(q)
 }
 
 // materializeAwardRefsForIDs recomputes award_refs for a specific set of QSOs
@@ -5058,8 +5175,13 @@ func (a *App) RecomputeAllAwardRefs() (int, error) {
 	ac := a.newAwardMatCtx()
 	// Collect updates during the scan; DON'T write mid-iteration (a nested query on
 	// the same connection can deadlock SQLite / trip MySQL "commands out of sync").
+	//
+	// The LEAN projection: award computation reads twenty-seven columns and the
+	// full record has a hundred and fifty. It used to take the whole row only
+	// because it needed award_refs to compare against, which the projection now
+	// carries — on a remote MySQL that was most of the wait.
 	changes := map[int64]string{}
-	err := a.qso.IterateAll(a.ctx, func(q qso.QSO) error {
+	err := a.qso.IterateForAwards(a.ctx, func(q qso.QSO) error {
 		if js := a.awardRefsJSONFor(ac, q); js != q.AwardRefs {
 			changes[q.ID] = js
 		}
@@ -5074,6 +5196,96 @@ func (a *App) RecomputeAllAwardRefs() (int, error) {
 	return len(changes), nil
 }
 
+// RecomputeAwardRefsForCode refreshes the stored label of ONE award, on the rows
+// that already carry it.
+//
+// For a change that cannot alter which QSOs match — switching the grid column
+// between the reference, its description and both — recomputing every award for
+// every QSO is work with a known answer. This does the only part that can
+// differ: it recomputes that one award for the rows whose award_refs already
+// mention it, and merges the result into their stored object, leaving every
+// other award's label exactly as it was.
+func (a *App) RecomputeAwardRefsForCode(code string) (int, error) {
+	if a.qso == nil {
+		return 0, fmt.Errorf("db not initialized")
+	}
+	code = strings.ToUpper(strings.TrimSpace(code))
+	if code == "" {
+		return 0, nil
+	}
+	// One definition, so award.Compute does not re-run twenty awards per row.
+	full := a.newAwardMatCtx()
+	one := full
+	one.defs = nil
+	for _, d := range full.defs {
+		if strings.EqualFold(d.Code, code) {
+			one.defs = []award.Def{d}
+			break
+		}
+	}
+	if len(one.defs) == 0 {
+		return 0, nil // award gone — a full recompute will clear the stale label
+	}
+	changes := map[int64]string{}
+	err := a.qso.IterateForAwardsWithRef(a.ctx, code, func(q qso.QSO) error {
+		var stored map[string]string
+		if strings.TrimSpace(q.AwardRefs) != "" {
+			if err := json.Unmarshal([]byte(q.AwardRefs), &stored); err != nil {
+				return nil // unreadable value — leave it for the full recompute
+			}
+		}
+		if stored == nil {
+			stored = map[string]string{}
+		}
+		fresh := a.awardRefLabels(one, q)
+		if fresh[code] == stored[code] {
+			return nil
+		}
+		if lbl := fresh[code]; lbl != "" {
+			stored[code] = lbl
+		} else {
+			delete(stored, code)
+		}
+		if len(stored) == 0 {
+			changes[q.ID] = ""
+			return nil
+		}
+		b, err := json.Marshal(stored)
+		if err != nil {
+			return nil
+		}
+		changes[q.ID] = string(b)
+		return nil
+	})
+	if err != nil {
+		return 0, err
+	}
+	if err := a.qso.SetAwardRefsBatch(a.ctx, changes); err != nil {
+		return 0, err
+	}
+	return len(changes), nil
+}
+
+// recomputeAwardRefsForCodesAsync relabels a few awards and tells the frontend,
+// the cheap counterpart of recomputeAwardRefsAsync.
+func (a *App) recomputeAwardRefsForCodesAsync(codes []string) {
+	go func() {
+		total := 0
+		for _, c := range codes {
+			n, err := a.RecomputeAwardRefsForCode(c)
+			if err != nil {
+				applog.Printf("award_refs: relabel of %s failed: %v", c, err)
+				continue
+			}
+			applog.Printf("award_refs: %s relabelled on %d QSO(s)", c, n)
+			total += n
+		}
+		if a.ctx != nil {
+			wruntime.EventsEmit(a.ctx, "awards:recomputed", total)
+		}
+	}()
+}
+
 // recomputeAwardRefsAsync runs a full recompute off the UI goroutine and, when
 // done, tells the frontend to reload so the refreshed award columns show. Used
 // wherever the set of matches could shift for MANY rows at once: an award
@@ -7474,6 +7686,19 @@ func (a *App) lookupCallsign(callsign string, force bool, qsoDate string) (looku
 	if r.IOTA == "" && r.DXCC != 0 {
 		r.IOTA = awardref.IOTAForDXCC(r.DXCC)
 	}
+	// The Russian district, from the offline database, for the DAY of the QSO.
+	//
+	// It overrides what a callbook said rather than filling a blank, which is the
+	// opposite of every other enrichment here — and deliberately. HamQTH carries
+	// the district a station operates from TODAY and nothing more; this database
+	// carries dated activity records, so on a contact from an expedition or from
+	// a station that has since moved it is right where the callbook is wrong.
+	// For everyone else the two agree.
+	if when := lookupWhen(qsoDate); r.DXCC == 15 || r.DXCC == 54 || r.DXCC == 126 {
+		if m, ok := rda.Lookup(callsign, when); ok {
+			r.RDA = m.District
+		}
+	}
 	// Custom outbound rows bound to a lookup. After the enrichment, so a
 	// template sees the same grid and county the entry panel is about to show —
 	// two answers for one callsign is how a rotator ends up pointed elsewhere
@@ -8476,11 +8701,20 @@ func (a *App) clusterEventWorker() {
 		// panadapter tunes AND switches mode — a DX cluster line carries no mode,
 		// so without this the radio only moved frequency.
 		if a.catFlexSpots && a.cat != nil {
+			mode := alerts.InferMode(s.Comment, s.FreqHz)
+			// Coloured by what the spot IS, which is the only thing worth knowing
+			// at a glance on a waterfall. Resolved from the same index the cluster
+			// grid uses, so a spot is never one colour on screen and another on
+			// the radio — and the index is cached, so this costs a map lookup.
+			status := a.spotStatusName(s.DXCall, s.Band, mode, s.POTARef)
+			col := a.spotColorFor(status)
 			a.cat.SendSpot(cat.SpotInfo{
 				FreqHz:          s.FreqHz,
 				Callsign:        s.DXCall,
-				Mode:     alerts.InferMode(s.Comment, s.FreqHz),
+				Mode:            mode,
-				Comment:  s.Comment,
+				Comment:         spotComment(s.Comment, status),
+				Color:           col.Text,
+				BackgroundColor: col.Bg,
 			})
 		}
 	}
@@ -11447,6 +11681,100 @@ func (a *App) BackfillUSCounties() (BackfillUSCountiesResult, error) {
 	return res, nil
 }
 
+// BackfillRDAResult reports what a district backfill did.
+type BackfillRDAResult struct {
+	Scanned int `json:"scanned"` // Russian QSOs examined
+	Dated   int `json:"dated"`   // filled from an activity record covering the QSO day
+	Current int `json:"current"` // filled from the callsign's current district (no history)
+	Unknown int `json:"unknown"` // callsign not in the database, or no record for that day
+	Skipped int `json:"skipped"` // already carried an RDA reference — never overwritten
+}
+
+// BackfillRDA stamps the Russian District on existing QSOs from the offline RDA
+// database, which is the one source that knows WHERE a callsign was on a GIVEN
+// DAY rather than only where it is now.
+//
+// useCurrent decides what happens for the 43 294 callsigns the database records
+// with a district and no history at all. With it off, only a dated activity
+// record covering the QSO's own day is written — every stamp is then a fact.
+// With it on, a callsign the database knows of no move for also gets its
+// district; that is true for the great majority of stations and an assumption
+// for the rest, which is why it is the operator's decision and not ours.
+//
+// An existing reference is never overwritten. A district assigned by hand, or
+// read from the far end at the time, outranks any database.
+func (a *App) BackfillRDA(useCurrent bool) (BackfillRDAResult, error) {
+	var res BackfillRDAResult
+	if a.qso == nil {
+		return res, fmt.Errorf("db not initialized")
+	}
+	rows, err := a.qso.List(a.ctx, qso.ListFilter{Limit: 1_000_000})
+	if err != nil {
+		return res, err
+	}
+	for i := range rows {
+		q := &rows[i]
+		// The three entities the award covers. Filtering on DXCC rather than on
+		// the callsign shape keeps a Russian station worked under a foreign
+		// prefix out, which is right: the database files them by callsign and a
+		// non-Russian one is not in it.
+		if q.DXCC == nil {
+			continue
+		}
+		switch *q.DXCC {
+		case 15, 54, 126:
+		default:
+			continue
+		}
+		res.Scanned++
+		if strings.TrimSpace(manualRefFor(q.Extras[award.ManualRefsKey], "RDA")) != "" {
+			res.Skipped++
+			continue
+		}
+		m, ok := rda.Lookup(q.Callsign, q.QSODate)
+		if !ok || (!m.Dated && !useCurrent) {
+			res.Unknown++
+			continue
+		}
+		if q.Extras == nil {
+			q.Extras = map[string]string{}
+		}
+		q.Extras[award.ManualRefsKey] = setOverrideRef(q.Extras[award.ManualRefsKey], "RDA", m.District)
+		if err := a.qso.Update(a.ctx, *q); err != nil {
+			applog.Printf("rda backfill: update qso %d failed: %v", q.ID, err)
+			continue
+		}
+		if m.Dated {
+			res.Dated++
+		} else {
+			res.Current++
+		}
+	}
+	applog.Printf("rda backfill: %d Russian QSOs — %d dated, %d current, %d unknown, %d already set",
+		res.Scanned, res.Dated, res.Current, res.Unknown, res.Skipped)
+	if res.Dated+res.Current > 0 {
+		a.invalidateAwardStats()
+	}
+	return res, nil
+}
+
+// RDADatabaseCount is how many callsigns the embedded district database holds,
+// so the panel offering the backfill can say what it is about to use.
+func (a *App) RDADatabaseCount() int { return rda.Count() }
+
+// manualRefFor returns the reference already assigned to one award code in a
+// "CODE@REF;CODE@REF" override string, or "".
+func manualRefFor(existing, code string) string {
+	for _, entry := range strings.Split(existing, ";") {
+		entry = strings.TrimSpace(entry)
+		at := strings.IndexByte(entry, '@')
+		if at > 0 && strings.EqualFold(strings.TrimSpace(entry[:at]), code) {
+			return strings.TrimSpace(entry[at+1:])
+		}
+	}
+	return ""
+}
+
 // DownloadConfirmations pulls confirmed QSOs from a service and updates the
 // matching local QSOs' received status. LoTW only for now (the canonical
 // confirmation system); runs in the background emitting the same
@@ -12861,6 +13189,34 @@ func (a *App) consumeUDPEvents() {
 	// 15 s. Single-goroutine loop → the map needs no lock.
 	const decodeSpotWindow = 20 * time.Second
 	lastDecodeSpot := map[string]time.Time{}
+	// The sending application's transmit state, as last logged.
+	//
+	// "Enable Tx" is the one thing that decides whether a Reply we sent turns
+	// into a transmission, and it lives entirely in WSJT-X/JTDX — we can ask for
+	// a station, we cannot arm the transmitter. When an operator reports "OpsLog
+	// called it and nothing went out", the only honest way to tell which side
+	// stopped is to see whether the far end ever armed at all. Status carries it
+	// every second; logging the CHANGES costs a line a QSO and answers the
+	// question without watching a button.
+	type txFlags struct{ enabled, transmitting bool }
+	lastTxFlags := map[string]txFlags{}
+	// Panadapter spots go out on their OWN goroutine.
+	//
+	// SendSpot writes to the radio's TCP socket, and this loop is the only
+	// consumer of the UDP event channel — which drops on backpressure. A period
+	// hands over twenty-odd decodes at once, so one slow write to the Flex was
+	// enough to fill that queue and lose decodes the panel was meant to show.
+	// The spot is an ornament; the decode is the point. Buffered and
+	// non-blocking, so a radio that stops reading costs spots and nothing else.
+	spotQ := make(chan cat.SpotInfo, 64)
+	go func() {
+		for si := range spotQ {
+			if a.cat != nil {
+				a.cat.SendSpot(si)
+			}
+		}
+	}()
+	defer close(spotQ)
 	for ev := range a.udp.Events() {
 		if a.ctx == nil {
 			continue
@@ -12877,6 +13233,13 @@ func (a *App) consumeUDPEvents() {
 		if ev.DECall != "" || ev.TxMessage != "" {
 			if ev.ProgramID != "" {
 				a.lastTxID.Store(ev.ProgramID)
+				now := txFlags{enabled: ev.TxEnabled, transmitting: ev.Transmitting}
+				if was, seen := lastTxFlags[ev.ProgramID]; !seen || was != now {
+					lastTxFlags[ev.ProgramID] = now
+					applog.Printf("udp: [%s] tx enable=%v transmitting=%v dx=%q%s",
+						ev.ProgramID, now.enabled, now.transmitting, ev.DXCall,
+						map[bool]string{true: "", false: " — nothing we send can start a transmission while this is false"}[now.enabled])
+				}
 			}
 			wruntime.EventsEmit(a.ctx, "udp:tx_state", map[string]any{
 				"msg":          ev.TxMessage,
@@ -12954,14 +13317,20 @@ func (a *App) consumeUDPEvents() {
 				if secs <= 0 {
 					secs = 120
 				}
-				a.cat.SendSpot(cat.SpotInfo{
+				select {
+				case spotQ <- cat.SpotInfo{
 					FreqHz:      ev.DecodeFreqHz,
 					Callsign:    ev.DecodeCall,
 					Mode:        ev.Mode,
 					Color:       "#FF34C759", // green — distinct from cluster orange
 					Comment:     fmt.Sprintf("%s %+ddB", ev.Mode, ev.DecodeSNR),
 					LifetimeSec: secs,
-				})
+				}:
+				default:
+					// Radio not keeping up: skip the spot rather than stall the
+					// decode stream behind it.
+					delete(lastDecodeSpot, key) // not spotted after all — let the next one try
+				}
 			}
 		case ev.LoggedADIF != "":
 			// The RECORD, not just its size. "Was the grid in what WSJT-X sent, or
@@ -14373,6 +14742,73 @@ func (a *App) SwitchCATRig(n int) error {
 	return nil
 }
 
+// catLinkSig fingerprints everything that shapes the PHYSICAL rig link.
+//
+// Two settings that produce the same string produce the same connection, so
+// there is nothing to gain by tearing the old one down — and a great deal to
+// lose: rebuilding the link drops the rig for a second or two, and with it
+// every client of the shared CAT server. Pressing Save in Preferences (or
+// switching profile, which re-applies the same settings) therefore threw
+// WSJT-X and JTDX off their rig, mid-QSO, with an error box — for a change
+// they had usually made somewhere else entirely.
+//
+// Deliberately does NOT include the poll interval, the command delay, the
+// transverter offset or the spot options: those are applied to the running
+// manager without reconnecting anything.
+func catLinkSig(s CATSettings) string {
+	if !s.Enabled {
+		return "off"
+	}
+	return strings.Join([]string{
+		s.Backend, s.DigitalDefault,
+		strconv.Itoa(s.OmniRigNum), s.OmniRigVFO,
+		s.FlexHost, strconv.Itoa(s.FlexPort), strconv.FormatBool(s.FlexSpots),
+		s.XieguPort, strconv.Itoa(s.XieguBaud), strconv.Itoa(s.XieguAddr), s.XieguPTTLine,
+		s.YaesuPort, strconv.Itoa(s.YaesuBaud), strconv.FormatBool(s.YaesuLowLines),
+		s.KenwoodHost, s.KenwoodPort, strconv.Itoa(s.KenwoodBaud),
+		s.KenwoodDataMode, strconv.FormatBool(s.KenwoodLowLines),
+		s.IcomPort, strconv.Itoa(s.IcomBaud), strconv.Itoa(s.IcomAddr),
+		s.IcomNetHost, s.IcomNetUser, s.IcomNetPass, strconv.FormatBool(s.IcomNetAudio),
+		s.TCIHost, strconv.Itoa(s.TCIPort), strconv.FormatBool(s.TCISpots),
+	}, "|")
+}
+
+// catShareKeyed reports whether the running share server is holding the rig
+// keyed for a client.
+func (a *App) catShareKeyed() bool {
+	if a.catShare != nil && a.catShare.Keyed() {
+		return true
+	}
+	return a.catShareTCI != nil && a.catShareTCI.Keyed()
+}
+
+// reloadCATShareWhenUnkeyed waits for the transmission to end, then applies the
+// change. Bounded, because a rig left keyed by a client that went away must not
+// postpone the operator's setting for ever — after a minute the change wins and
+// the emergency unkey in Stop() covers the radio.
+func (a *App) reloadCATShareWhenUnkeyed(s CATSettings) {
+	for i := 0; i < 120; i++ { // 120 × 500 ms = 1 minute
+		time.Sleep(500 * time.Millisecond)
+		if !a.catShareKeyed() {
+			break
+		}
+	}
+	// The signature was already recorded by the caller, so clear it: this IS the
+	// rebuild it stood for, and leaving it set would make the call below a no-op.
+	a.catShareSig = ""
+	applog.Printf("cat share: transmission over — applying the deferred rebuild")
+	a.reloadCATShare(s)
+}
+
+// catShareSig does the same for the shared-CAT server: which protocol, which
+// port, on or off. Restarting it is what actually disconnects WSJT-X.
+func catShareSig(s CATSettings) string {
+	if !s.Enabled || !s.ShareEnabled {
+		return "off"
+	}
+	return fmt.Sprintf("%s|%d|%d", s.ShareProto, s.SharePort, s.ShareTCIPort)
+}
+
 // reloadCAT (re)starts the CAT manager based on the current settings.
 // Called at startup and after the user saves new CAT config.
 // restartAsync runs a hardware (re)start off the caller's goroutine.
@@ -14420,6 +14856,13 @@ func (a *App) reloadCAT() {
 	a.catFlexDecodeSecs = s.FlexDecodeSecs
 	a.catFlexDVKDax = s.Enabled && s.Backend == "flex" && s.FlexDVKDax
 	a.reloadCATShare(s)
+	// Nothing about the link changed → leave it connected. See catLinkSig.
+	if sig := catLinkSig(s); sig == a.catSig {
+		applog.Printf("cat: settings saved, link unchanged — staying connected")
+		return
+	} else {
+		a.catSig = sig
+	}
 	if !s.Enabled {
 		a.cat.Stop()
 		return
@@ -14436,10 +14879,16 @@ func (a *App) reloadCAT() {
 		// Native FlexRadio (SmartSDR) TCP API — no OmniRig needed.
 		fb := cat.NewFlex(s.FlexHost, s.FlexPort, s.FlexSpots)
 		// Clicking one of our spots on the panadapter fills the entry form.
-		fb.OnSpotClick = func(call string, hz int64) {
+		fb.OnSpotClick = func(call string, hz int64, mode string) {
 			if a.ctx != nil {
-				wruntime.EventsEmit(a.ctx, "flex:spot_clicked", map[string]any{"call": call, "freq_hz": hz})
+				wruntime.EventsEmit(a.ctx, "flex:spot_clicked", map[string]any{
+					"call": call, "freq_hz": hz, "pota_ref": a.potaRefFor(call),
+				})
 			}
+			// A spot clicked ON the panadapter deserves the same zoom as one
+			// clicked in the band map: the operator did the same thing and is
+			// looking at the same signal, and only the click's origin differs.
+			a.FlexZoomForSpot(mode, hz)
 		}
 		a.cat.Start(fb)
 	case "xiegu":
@@ -14529,7 +14978,9 @@ func (a *App) reloadCAT() {
 		// Clicking one of our spots on the ExpertSDR panorama fills the entry form.
 		tb.OnSpotClick = func(call string, hz int64) {
 			if a.ctx != nil {
-				wruntime.EventsEmit(a.ctx, "tci:spot_clicked", map[string]any{"call": call, "freq_hz": hz})
+				wruntime.EventsEmit(a.ctx, "tci:spot_clicked", map[string]any{
+					"call": call, "freq_hz": hz, "pota_ref": a.potaRefFor(call),
+				})
 			}
 		}
 		a.cat.Start(tb)
@@ -14806,6 +15257,13 @@ func (a *App) ActivateProfile(id int64) error {
 // stays as-is (the operator connects it explicitly). The frontend reloads its
 // panels via profile:changed.
 func (a *App) reloadAfterProfileSwitch() {
+	// Logged because this rebuilds EVERY settings-dependent subsystem, and a
+	// shared operator's log showed it running 54 times in one session — each one
+	// dropping WSJT-X's rigctl connection, three of them while the rig was
+	// keyed. The teardown itself is now guarded (see catLinkSig), but a re-apply
+	// arriving every few minutes still means something is asking for it, and
+	// nothing in the log said so.
+	applog.Printf("profile: re-applying every subsystem for the active profile")
 	a.reloadLookupProviders()
 	if a.extsvc != nil {
 		a.extsvc.SetConfig(a.loadExternalServices())
@@ -16091,11 +16549,17 @@ func newMotorClient(s UltrabeamSettings) motorAntenna {
 		}
 		return steppirAdapter{c: steppir.New(tr), freqMin: s.FreqMinMHz, freqMax: s.FreqMaxMHz}
 	}
-	// Ultrabeam is TCP only.
+	// Ultrabeam: serial or TCP, same as the SteppIR. The controller has an RS232
-	if strings.TrimSpace(s.Host) == "" {
+	// port, so a plain FTDI cable is the direct route; the Ethernet adapter is
+	// for putting the antenna at the far end of a link.
+	tr := ultrabeam.Transport{Mode: s.Transport, Host: strings.TrimSpace(s.Host), Port: s.Port, COM: strings.TrimSpace(s.COM), Baud: s.Baud}
+	if tr.Mode == "serial" && tr.COM == "" {
 		return nil
 	}
-	return ubAdapter{c: ultrabeam.New(s.Host, s.Port), freqMin: s.FreqMinMHz, freqMax: s.FreqMaxMHz}
+	if tr.Mode != "serial" && tr.Host == "" {
+		return nil
+	}
+	return ubAdapter{c: ultrabeam.New(tr), freqMin: s.FreqMinMHz, freqMax: s.FreqMaxMHz}
 }
 
 // startUltrabeam stops any existing client and starts a fresh one if the
@@ -16714,7 +17178,11 @@ func (a *App) restartMotorFollow(s UltrabeamSettings) {
 		return
 	}
 	if !s.Follow {
-		applog.Printf("antenna: %s connected, but TRACKING IS OFF in Settings — it will not follow the rig, and only moves when you tune it by hand", s.Type)
+		// "configured", not "connected": nothing here has talked to the antenna
+		// yet. The poll loop has only just been started, and it reports its own
+		// failures ("steppir: cannot open COM5…"). Saying connected made an
+		// unopenable port look like a working link with tracking switched off.
+		applog.Printf("antenna: %s configured, but TRACKING IS OFF in Settings — it will not follow the rig, and only moves when you tune it by hand", s.Type)
 		return
 	}
 	stop := make(chan struct{})
@@ -18371,11 +18839,18 @@ type SpotQuery struct {
 // SpotStatus is the per-tuple result. Status is one of:
 //
 //	"new"            — entity never worked
-//	"new-band"   — entity worked but never on this band
+//	"new-band-mode"  — entity worked, but neither this band NOR this mode
+//	"new-band"       — entity worked in this mode, never on this band
 //	"new-mode"       — band worked, but this MODE never worked on the entity (any band)
 //	"new-slot"       — band & mode each worked before, but not this band+mode together
 //	"worked"         — exact band+mode already in the log
 //	""               — couldn't resolve the entity (no cty.dat match)
+//
+// They are EXCLUSIVE and tested in that order, from most wanted to least. The
+// distinction that matters and used to be missing: an entity that is new on
+// both counts is not the same catch as one that is new on the band alone, and
+// neither is a "slot" — a slot is the pair still missing when each half is
+// already in the log.
 type SpotStatus struct {
 	Call      string `json:"call"`
 	Band      string `json:"band"`
@@ -18768,6 +19243,88 @@ func (a *App) lookupDecodeGrid(call string) string {
 	return a.decodeGridsOld[call]
 }
 
+// spotEntityStatus decides ONE spot's status from what the entity already has
+// in the log. Pure, and separate from the query that feeds it, because the
+// ORDER of these tests is the whole meaning of the answer and it deserves to be
+// read — and tested — without a database.
+//
+// Most wanted first, exclusive:
+//
+//	new            the entity has never been worked at all
+//	new-band-mode  worked, but neither this band nor this mode
+//	new-band       worked in this mode, never on this band
+//	new-mode       worked on this band, never in this mode (on any band)
+//	new-slot       both halves already in the log, never this pair
+//	worked         this exact band and mode
+//
+// new-band-mode is NOT a slot, and that is the distinction that was missing:
+// a slot is the pair still missing when each half is already worked. A station
+// that is new on both counts is a better catch than either, and it used to be
+// reported as a plain "new band".
+func spotEntityStatus(entityWorked, haveBand, haveMode, haveSlot bool, mode string) string {
+	if !entityWorked {
+		return "new"
+	}
+	// Without a mode nothing below "band" can be told apart from worked, and
+	// claiming "new" on a guess is the one mistake that costs a QSO.
+	if mode == "" {
+		if !haveBand {
+			return "new-band"
+		}
+		return "worked"
+	}
+	switch {
+	case !haveBand && !haveMode:
+		return "new-band-mode"
+	case !haveBand:
+		return "new-band"
+	case !haveMode:
+		return "new-mode"
+	case !haveSlot:
+		return "new-slot"
+	}
+	return "worked"
+}
+
+// spotStatusName resolves ONE spot to the palette key it should be drawn with.
+//
+// The entity status first — it is the headline — then the orthogonal markers,
+// which only speak when the entity says nothing new: a park is worth a colour
+// on a station you have already worked, and worth nothing on one you have not,
+// where "new entity" is the better thing to say.
+func (a *App) spotStatusName(call, band, mode, potaRef string) string {
+	if a.qso == nil {
+		return "none"
+	}
+	st := a.ClusterSpotStatuses([]SpotQuery{{Call: call, Band: band, Mode: mode, POTARef: potaRef}})
+	if len(st) == 0 {
+		return "none"
+	}
+	r := st[0]
+	if a.profiles != nil {
+		if p, err := a.profiles.Active(a.ctx); err == nil &&
+			strings.EqualFold(strings.TrimSpace(p.Callsign), strings.TrimSpace(call)) {
+			return "my-call"
+		}
+	}
+	switch r.Status {
+	case "new", "new-band-mode", "new-band", "new-mode", "new-slot":
+		return r.Status
+	}
+	switch {
+	case r.NewPOTA:
+		return "new-pota"
+	case r.NewCounty:
+		return "new-county"
+	case r.NewPfx:
+		return "new-pfx"
+	}
+	if r.Status == "worked" {
+		return "worked"
+	}
+	return "none"
+}
+
 func (a *App) ClusterSpotStatuses(spots []SpotQuery) []SpotStatus {
 	out := make([]SpotStatus, len(spots))
 	if a.qso == nil {
@@ -18932,33 +19489,18 @@ func (a *App) ClusterSpotStatuses(spots []SpotQuery) []SpotStatus {
 			out[i].Status = "new"
 			continue
 		}
-		if _, b := e.Bands[out[i].Band]; !b {
+		// The check mode goes through the same normaliser as the slot map
-			out[i].Status = "new-band"
+		// (digital grouping), and is resolved before the band test because
-			continue
+		// "new band" and "new mode" are now asked TOGETHER.
-		}
-		// Without a mode we can't distinguish the rest from "worked";
-		// the safer default is "worked" so we never falsely claim "new".
-		if out[i].Mode == "" {
-			out[i].Status = "worked"
-			continue
-		}
-		// Band already worked. If this MODE was never worked on the entity (any
-		// band) → new-mode. If the mode was worked elsewhere but not on THIS
-		// band+mode → new-slot. Otherwise → worked. The check mode goes through
-		// the same normaliser as the slot map (digital grouping).
 		checkMode := out[i].Mode
 		if normMode != nil {
 			checkMode = normMode(checkMode)
 		}
-		if _, m := e.Modes[checkMode]; !m {
+		_, haveBand := e.Bands[out[i].Band]
-			out[i].Status = "new-mode"
+		_, haveMode := e.Modes[checkMode]
-			continue
+
-		}
+		_, haveSlot := e.Slots[out[i].Band][checkMode]
-		if _, ok := e.Slots[out[i].Band][checkMode]; !ok {
+		out[i].Status = spotEntityStatus(true, haveBand, haveMode, haveSlot, out[i].Mode)
-			out[i].Status = "new-slot"
-			continue
-		}
-		out[i].Status = "worked"
 	}
 	return out
 }
@@ -19036,6 +19578,28 @@ func (r catShareRig) SetSplit(on bool, txHz int64) error {
 // port clash or a confused client can go wrong, and no program speaks both.
 func (a *App) reloadCATShare(s CATSettings) {
 	want := s.Enabled && s.ShareEnabled
+	// Same protocol on the same port → the running server is already the one
+	// asked for. Rebuilding it closes the socket WSJT-X is sitting on, which is
+	// the error box an operator sees on pressing Save.
+	if sig := catShareSig(s); sig == a.catShareSig && (a.catShare != nil || a.catShareTCI != nil || !want) {
+		return
+	} else {
+		a.catShareSig = sig
+	}
+	// NEVER while the rig is transmitting.
+	//
+	// Everything above decides that the server genuinely has to be rebuilt; this
+	// decides WHEN. Closing the socket mid-over is the one moment it costs
+	// something: WSJT-X is inside a run of Hamlib calls — VFO, split, PTT, which
+	// with Fake It all land at the start of a transmission — and an operator's
+	// log showed it happening three times in a session, followed by wsjtx.exe
+	// dying on a null pointer. The transmission is seconds long; the new port
+	// can wait for it.
+	if a.catShareKeyed() {
+		applog.Printf("cat share: rebuild deferred — the rig is transmitting")
+		go a.reloadCATShareWhenUnkeyed(s)
+		return
+	}
 	// Always tear down first: the port — or the protocol — may have changed, and
 	// a listener bound to the old one would keep answering while the client is
 	// told to use the new.
@@ -19439,3 +20003,57 @@ func lookupWhen(qsoDate string) time.Time {
 	}
 	return t
 }
+
+// potaRefFor returns the park a callsign is currently activating, or "".
+//
+// A spot clicked on the RADIO's panadapter arrives as a callsign and a
+// frequency — the radio knows nothing of parks — so the park has to be found
+// again here, from the same live POTA index that tags the cluster spots. Without
+// it the Awards tab stayed empty for a click on the panadapter while the very
+// same spot clicked in OpsLog filled it in, which is a difference the operator
+// has no way to explain.
+func (a *App) potaRefFor(call string) string {
+	if a.pota == nil || strings.TrimSpace(call) == "" {
+		return ""
+	}
+	if info, ok := a.pota.Lookup(call); ok {
+		return info.Reference
+	}
+	return ""
+}
+
+// tidyLogbookSchema removes settings tables that an older OpsLog left inside the
+// logbook.
+//
+// Two ways they got there: every database used to receive the full migration set
+// (fixed in internal/db/roles.go, which now filters by role), and the one-time
+// legacy split copies the whole settings database with VACUUM INTO and then
+// treats the copy as the logbook. Empty ones are already dropped when the
+// logbook is opened; the copies from the split have ROWS, and are dropped here
+// because we can see the settings database still holding the originals.
+//
+// The check is the whole point: only when the logbook is a DIFFERENT database
+// from the settings one, and that settings database still has its own profiles,
+// is a profile row inside the logbook provably a duplicate. A profile pointing
+// at a genuine legacy combined database as its logbook fails that test and keeps
+// everything.
+func (a *App) tidyLogbookSchema(logbookConn *sql.DB) {
+	if logbookConn == nil || a.db == nil || logbookConn == a.db {
+		return // the settings database IS the logbook: everything in it is in use
+	}
+	if a.dbBackend == "sqlite" && a.logDbPath != "" &&
+		strings.EqualFold(filepath.Clean(a.logDbPath), filepath.Clean(a.dbPath)) {
+		return // same file reached twice
+	}
+	var profiles int
+	if err := a.db.QueryRowContext(a.ctx, "SELECT COUNT(*) FROM station_profiles").Scan(&profiles); err != nil || profiles == 0 {
+		// No authoritative copy to point at — leave the logbook exactly as it is.
+		return
+	}
+	db.DropRedundantSettingsTables(logbookConn, "logbook")
+	// And the mirror image: the settings database keeps an empty qso table from
+	// the days when every database got the whole schema. It is not needed while
+	// the contacts have a database of their own, and EnsureQSOTable puts it back
+	// if this one is ever asked to serve as the logbook again.
+	db.DropEmptyQSOTable(a.db, filepath.Base(a.dbPath))
+}

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

autostart.go

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

awardnew.go

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

awardnew_test.go

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

awardrelabel_test.go

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

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,148 @@
 [
+  {
+    "version": "0.26.4",
+    "date": "",
+    "en": [
+      "Clicking a spot on the radio panadapter now carries its POTA park into the Awards tab, like a click in OpsLog does.",
+      "Ultrabeam over serial: the COM port field now has a chevron that opens the list of detected ports. It was a combo box that only opened on a keystroke, so it looked like a plain text box.",
+      "The logbook database now contains only the contacts. Settings, station profiles, award reference lists and the lookup cache were being created in every database, including a shared MySQL logbook, which made the two look interchangeable; the unused tables are dropped on the next start, and any that hold data are left alone.",
+      "And the mirror image: the settings database drops its own unused, empty qso table once the contacts have a database of their own. It is rebuilt automatically if that database is ever pressed into service as the logbook again.",
+      "Settings → Database: a Compact button on each database. SQLite frees deleted pages inside the file and never shrinks it, so this is what gives the disk space back; the result shows the size before and after. A shared MySQL logbook has the button too, running OPTIMIZE TABLE instead."
+    ],
+    "fr": [
+      "Cliquer un spot sur le panadapter de la radio reporte maintenant son parc POTA dans l’onglet Diplômes, comme un clic dans OpsLog.",
+      "Ultrabeam en série : le champ du port COM a maintenant un chevron qui ouvre la liste des ports détectés. C'était une liste déroulante qui ne s'ouvrait qu'en tapant, donc indiscernable d'un simple champ texte.",
+      "La base du journal ne contient plus que les contacts. Les réglages, profils station, listes de références et le cache de recherche étaient créés dans toutes les bases, y compris un MySQL partagé, ce qui laissait croire que les deux étaient interchangeables ; les tables inutilisées sont supprimées au prochain démarrage, et celles qui contiennent des données sont laissées telles quelles.",
+      "Et l'inverse : la base de réglages supprime sa propre table qso, vide et inutilisée, dès lors que les contacts ont leur base à eux. Elle est reconstruite automatiquement si cette base doit à nouveau servir de journal.",
+      "Réglages → Base de données : un bouton Compacter sur chaque base. SQLite libère les pages supprimées à l'intérieur du fichier sans jamais le réduire ; c'est donc ce qui rend l'espace disque, et le résultat affiche la taille avant et après. Un journal MySQL partagé a aussi le bouton, avec un OPTIMIZE TABLE à la place."
+    ]
+  },
+  {
+    "version": "0.26.3",
+    "date": "",
+    "en": [
+      "Ultrabeam: the controller can be reached over a plain serial port, not only over the network. It has an RS232 port and the PC is usually beside it, so an FTDI cable is the direct route — the RS232-to-Ethernet adapter is now only needed to put the antenna at the far end of a link. Same choice the SteppIR has always had, in the same place.",
+      "Docked band map: FIT and FTx are now two labelled buttons in its header. Fit-to-band was hidden behind the px/kHz readout — a control whose label is a measurement does not look like one, and switching it off left nothing on screen saying the option existed. Hiding the digital spots is available there too, and both follow the Band Map tab.",
+      "Stats: the Entities tile now says which entity was added to the log most recently, with the callsign and date that did it. Judged against the whole log — a contact is the first with its country once, and does not become the first again because a date filter hides the ones before it.",
+      "Docked band map: in fit-to-band the header no longer printed FIT twice, once as the readout and once as the button beside it.",
+      "Settings: what OpsLog does with a FlexRadio — panadapter spots, decode spots and the DAX switch for voice messages — now lives in the FlexRadio page with the per-band antennas and power, instead of at the foot of the CAT page. CAT keeps the link itself: an address and a port, as for every other backend.",
+      "Cluster settings: four paragraphs of explanation removed. The options they described are unchanged.",
+      "A spot that is a new band AND a new mode for an entity is now its own status, NEW BAND+MODE, ranked with NEW DXCC. It used to be reported as a plain new band, which reads as \"you have worked this entity in this mode, just not here\" — the opposite of the truth. It is not a new slot either: a slot is the pair still missing when each half is already in the log. The cluster, the band map, the decodes panel, the filters and the auto-call criteria all tell the two apart now.",
+      "Cluster filters: a \"my bands\" link selects every band from your own band list in one click. With nothing selected the filter lets every band through — including 4 m and 70 cm off the RBN feeds, which the list could not offer you to untick because they are not bands you have.",
+      "FlexRadio: cluster spots on the panadapter are now coloured by what they are. A text colour and a background colour per status — new entity, new band+mode, new band, new mode, new slot, new park, new county, new prefix, your own callsign, already worked — set in Settings → FlexRadio, with a preview of each pair. Every spot used to be the same orange, which threw away the only thing worth knowing at a glance on a waterfall.",
+      "FlexRadio: clicking a spot can resize the panadapter to suit the mode — 25 kHz for CW, 200 for phone, 50 for digital by default, each configurable, with an option to re-centre on the spot as well. A CW signal is a hair at 200 kHz and an FT8 window shows an eighth of its sub-band at 25 kHz; one width cannot serve all three. Settings → FlexRadio, off by default.",
+      "FlexRadio: panadapter spots now carry their status in the comment as well as their colour — [NEW DXCC], [NEW BAND+MODE], [NEW BAND] and so on.",
+      "FlexRadio: the panadapter zoom now also applies when you click a spot on the panadapter itself, not just in the band map or cluster.",
+      "FlexRadio: fixed the panadapter zoom leaving the clicked spot off screen. The display now re-centres whenever the spot would fall outside the new window, and stays put when it would not.",
+      "Awards (F3): a NEW badge marks each award reference on the current QSO that has never been worked, picked or detected alike."
+    ],
+    "fr": [
+      "Ultrabeam : le contrôleur se joint par un simple port série, plus seulement par le réseau. Il a une prise RS232 et le PC est en général juste à côté : un câble FTDI suffit — l'adaptateur RS232 vers Ethernet ne sert plus qu'à mettre l'antenne au bout d'une liaison. Le même choix que le SteppIR a toujours eu, au même endroit.",
+      "Bandmap ancrée : FIT et FTx sont désormais deux boutons nommés dans son en-tête. L'ajustement à la bande se cachait derrière l'indicateur px/kHz — un contrôle dont le libellé est une mesure n'a pas l'air d'un contrôle, et une fois désactivé plus rien à l'écran ne disait que l'option existait. Le masquage des spots numériques y est aussi, et les deux suivent l'onglet Bandmap.",
+      "Statistiques : la tuile Entités indique désormais quelle entité a été ajoutée au journal en dernier, avec l'indicatif et la date qui l'ont fait. Jugé sur le journal entier — un contact n'est le premier avec son pays qu'une fois, et ne le redevient pas parce qu'un filtre de date masque ceux d'avant.",
+      "Bandmap ancrée : en mode ajusté, l'en-tête n'affiche plus FIT deux fois, une comme indicateur et une comme bouton juste à côté.",
+      "Réglages : ce qu'OpsLog fait avec un FlexRadio — spots panadapter, spots de décodages et la bascule DAX pour les messages vocaux — se trouve désormais sur la page FlexRadio, avec les antennes et la puissance par bande, au lieu du bas de la page CAT. La page CAT garde la liaison elle-même : une adresse et un port, comme pour tous les autres backends.",
+      "Réglages du cluster : quatre pavés d'explication retirés. Les options qu'ils décrivaient sont inchangées.",
+      "Un spot qui est à la fois une nouvelle bande ET un nouveau mode pour une entité a désormais son propre statut, NOUVEAU BANDE+MODE, au même rang que NOUVEAU DXCC. Il était annoncé comme une simple nouvelle bande, ce qui se lit « tu as déjà fait cette entité dans ce mode, juste pas ici » — l'inverse de la vérité. Ce n'est pas non plus un nouveau slot : un slot est la paire qui manque quand chaque moitié est déjà au journal. Le cluster, la bandmap, le panneau des décodages, les filtres et les critères d'appel automatique font maintenant la différence.",
+      "Filtres du cluster : un lien « mes bandes » sélectionne d'un clic toutes les bandes de ta propre liste. Sans sélection, le filtre laisse passer toutes les bandes — y compris le 4 m et le 70 cm des flux RBN, que la liste ne pouvait pas te proposer de décocher puisque ce ne sont pas des bandes que tu as.",
+      "FlexRadio : les spots cluster sur le panadapter sont désormais colorés selon ce qu'ils sont. Une couleur de texte et une couleur de fond par statut — nouvelle entité, nouvelle bande+mode, nouvelle bande, nouveau mode, nouveau slot, nouveau parc, nouveau comté, nouveau préfixe, ton propre indicatif, déjà contacté — réglées dans Réglages → FlexRadio, avec un aperçu de chaque paire. Tous les spots étaient de la même couleur orange, ce qui jetait la seule chose qui compte au premier coup d'œil sur une cascade.",
+      "FlexRadio : cliquer un spot peut redimensionner le panadapter selon le mode — 25 kHz en CW, 200 en phonie, 50 en numérique par défaut, chacun réglable, avec une option pour recentrer aussi sur le spot. Un signal CW est un cheveu à 200 kHz et une fenêtre FT8 montre un huitième de sa sous-bande à 25 kHz ; une seule largeur ne peut pas servir les trois. Réglages → FlexRadio, désactivé par défaut.",
+      "FlexRadio : les spots du panadapter portent maintenant leur statut dans le commentaire en plus de la couleur — [NEW DXCC], [NEW BAND+MODE], [NEW BAND], etc.",
+      "FlexRadio : le zoom du panadapter s'applique aussi quand on clique un spot sur le panadapter lui-même, et plus seulement dans la bandmap ou le cluster.",
+      "FlexRadio : correction du zoom du panadapter qui laissait parfois le spot hors écran. L'affichage se recentre désormais dès que le spot sortirait de la nouvelle fenêtre, et ne bouge pas sinon.",
+      "Diplômes (F3) : un badge NEW signale chaque référence du QSO en cours jamais contactée, choisie à la main ou détectée."
+    ]
+  },
+  {
+    "version": "0.26.2",
+    "date": "",
+    "en": [
+      "Saving preferences no longer drops the rig. The CAT link — and the shared CAT server WSJT-X and JTDX connect to — is now rebuilt only when something about the connection itself changed, so pressing Save mid-QSO no longer throws them off with an error. The same restart was what wiped the spots off a FlexRadio panadapter on every save.",
+      "The log now records when WSJT-X or JTDX arms and disarms its transmitter. When a station is called and nothing goes out, that line says whether the far end ever enabled Tx — the one thing OpsLog asks for but cannot do itself.",
+      "Grid squares map: the world is drawn once instead of repeating east and west, it can be zoomed out far enough to hold Greenland and Antarctica at the same time, and the space beside the planet is the panel's own background instead of a wall of grey \"map data not yet available\" tiles.",
+      "Grid squares map: All, Phone and CW join Digital and FTx in the mode filter.",
+      "Motorised antenna over serial: the COM port is now picked from a list of the ports actually present, with a refresh button — and still accepts one typed by hand, for an adapter that is not plugged in yet.",
+      "Awards: choosing \"no field\" now clears the fallback searches with it. They kept running on their own fields while the panel no longer showed them, so an award declared to match nothing still found references.",
+      "Callbook lookup now reads the Russian district (RDA) from HamQTH and fills it as the contact's RDA reference. Only on the QSO being typed, never on one already logged: the callbook gives the district a station operates from today, and stamping that on an older contact would rewrite a correct entry into a false one.",
+      "FlexRadio: when the meters stay dead, the log now says why. The meter stream is UDP sent from the radio to OpsLog, and a firewall blocking it leaves a perfectly healthy TCP link with meters at zero and no explanation — the line names the port and what to allow.",
+      "The Russian district database is now built in: 58 188 callsigns, with the dated periods each operated from each district. It fills the RDA reference while you type a Russian callsign — for the day of the contact, not for today — and Settings → Awards fills it on every Russian QSO already in the log. A reference you assigned by hand is never overwritten.",
+      "New Settings → Maintenance → Databases: every reference database OpsLog keeps on disk on its own line — country file, Club Log exceptions, LoTW users, Super Check Partial, US counties, Russian districts — plus one line per updatable award reference list (IOTA, POTA, SOTA, WWFF). Each says what it holds and when it was refreshed. The updaters were scattered across the Awards manager and three settings pages before. Tools no longer carries \"Refresh cty.dat\" and \"Download reference lists\" — both are lines on that page now.",
+      "FT decodes: the auto-call no longer offers a SOTA criterion. It was declared and translated but could never be ticked, and a decode carries no summit reference for it to test — a setting that promised something the feature cannot do.",
+      "Auto-call: the slot criterion is named \"a new slot (band+mode never worked together)\" — the same word the cluster and the decodes panel already badge it with. \"A new band+mode slot\" read as \"a new band AND a new mode\", which is the one thing it is not.",
+      "Voice keyer: typing a callsign stops the auto-CQ. It stopped the CW auto-call and left the voice keyer calling CQ over the station that had just answered — the reason to stop has nothing to do with Morse, so both engines now stop on the same event.",
+      "The motorised antenna (Ultrabeam / SteppIR) now has a docked widget of its own, with a dish icon beside the entry strip: pattern (Normal / 180° / Bi), band buttons, ±25 kHz nudge and Retract — what you touch between contacts. Tracking, its mode and step, and the per-element lengths stay in the Station Control tab, where they are set once. The icon pulses amber while the elements travel.",
+      "FT decodes: a station with a compound callsign is no longer invisible. FT8 sends such a call as a hash, printed between angle brackets — \"F4BPO <ZA/IW2JOP> -24\" — and every decode carrying one was discarded as unparseable, including the reply telling you that station had answered. The two-message form (\"… RR73; … <call> -08\") is read correctly too.",
+      "The log now records when a profile re-applies every subsystem. That rebuild is what dropped WSJT-X's CAT connection — an operator's log showed it happening 54 times in one session, three of them while the rig was keyed — and nothing said it was happening at all.",
+      "The shared CAT server is never torn down while the rig is transmitting. A rebuild that really is needed now waits for the over to end — closing the socket mid-transmission is what left WSJT-X inside a run of Hamlib calls with nothing at the other end.",
+      "Autostart: a program can be closed when OpsLog closes. Per program, so the rotator controller can stay while WSJT-X goes, and only ever a polite close — the way clicking its cross would — of a program OpsLog itself started.",
+      "Awards: switching a column between the reference and its description is now immediate. It rebuilt every award for every contact in the log — work with a known answer, since a relabel cannot change which QSOs match. Only that award is recomputed, and only on the rows that already carry it. The full recompute also reads twenty-seven columns per QSO instead of a hundred and fifty."
+    ],
+    "fr": [
+      "Enregistrer les préférences ne coupe plus la radio. La liaison CAT — et le serveur CAT partagé auquel WSJT-X et JTDX se connectent — n'est reconstruite que si la connexion elle-même a changé, si bien qu'un Enregistrer en plein QSO ne les éjecte plus avec une erreur. C'est ce même redémarrage qui effaçait les spots du panadapter FlexRadio à chaque enregistrement.",
+      "Le journal enregistre désormais quand WSJT-X ou JTDX arme et désarme son émetteur. Quand une station est appelée et que rien ne part, cette ligne dit si le logiciel distant a seulement activé Tx — la seule chose qu'OpsLog demande sans pouvoir la faire à sa place.",
+      "Carte des carrés locator : le monde est dessiné une seule fois au lieu de se répéter d'est en ouest, le zoom arrière descend assez bas pour tenir le Groenland et l'Antarctique en même temps, et l'espace à côté de la planète est le fond du panneau au lieu d'un mur de tuiles grises « map data not yet available ».",
+      "Carte des carrés locator : Tout, Phonie et CW rejoignent Numérique et FTx dans le filtre de mode.",
+      "Antenne motorisée en liaison série : le port COM se choisit maintenant dans la liste des ports réellement présents, avec un bouton d'actualisation — et accepte toujours une saisie à la main, pour un adaptateur qui n'est pas encore branché.",
+      "Diplômes : choisir « aucun champ » efface désormais les recherches de repli avec lui. Elles continuaient de tourner sur leurs propres champs alors que le panneau ne les affichait plus, si bien qu'un diplôme déclaré ne rien reconnaître trouvait quand même des références.",
+      "La recherche callbook lit désormais le district russe (RDA) chez HamQTH et le renseigne comme référence RDA du contact. Uniquement sur le QSO en cours de saisie, jamais sur un QSO déjà journalisé : le callbook donne le district d'où la station émet aujourd'hui, et l'appliquer à un contact ancien transformerait une entrée correcte en entrée fausse.",
+      "FlexRadio : quand les mesures restent mortes, le journal dit maintenant pourquoi. Le flux de mesures est un envoi UDP de la radio vers OpsLog, et un pare-feu qui le bloque laisse une liaison TCP parfaitement saine avec des aiguilles à zéro et aucune explication — la ligne nomme le port et ce qu'il faut autoriser.",
+      "La base des districts russes est désormais intégrée : 58 188 indicatifs, avec les périodes datées passées dans chaque district. Elle renseigne la référence RDA pendant que tu tapes un indicatif russe — pour le jour du contact, pas pour aujourd'hui — et Réglages → Diplômes la renseigne sur tous les QSO russes déjà journalisés. Une référence attribuée à la main n'est jamais écrasée.",
+      "Nouveau Réglages → Maintenance → Bases de données : chaque base de référence qu'OpsLog garde sur disque a sa ligne — fichier pays, exceptions Club Log, utilisateurs LoTW, Super Check Partial, comtés US, districts russes — plus une ligne par liste de références de diplôme actualisable (IOTA, POTA, SOTA, WWFF). Chacune dit ce qu'elle contient et sa dernière actualisation. Les mises à jour étaient jusqu'ici dispersées entre le gestionnaire de diplômes et trois pages de réglages. Le menu Outils ne porte plus « Refresh cty.dat » ni « Download reference lists » — les deux sont des lignes de cette page.",
+      "Décodages FT : l'appel automatique ne propose plus de critère SOTA. Il était déclaré et traduit mais impossible à cocher, et un décodage ne porte aucune référence de sommet à tester — un réglage qui promettait ce que la fonction ne sait pas faire.",
+      "Appel automatique : le critère de slot s'appelle désormais « un nouveau slot (bande+mode jamais faits ensemble) » — le mot que le cluster et le panneau des décodages emploient déjà sur leur pastille. « Un nouveau couple bande+mode » se lisait comme « une nouvelle bande ET un nouveau mode », ce qu'il n'est justement pas.",
+      "Manipulateur vocal : taper un indicatif arrête l'appel automatique. Il arrêtait l'auto-call CW et laissait le DVK appeler CQ par-dessus la station qui venait de répondre — la raison de s'arrêter n'a rien à voir avec la télégraphie, les deux moteurs s'arrêtent donc sur le même événement.",
+      "L'antenne motorisée (Ultrabeam / SteppIR) a désormais son widget ancré, avec une icône de parabole à côté de la barre de saisie : diagramme (Normal / 180° / Bi), boutons de bande, décalage ±25 kHz et Rétracter — ce qu'on touche entre deux contacts. Le suivi, son mode et son pas, ainsi que les longueurs d'éléments restent dans l'onglet Station, où ils se règlent une fois pour toutes. L'icône clignote en ambre pendant que les éléments se déplacent.",
+      "Décodages FT : une station à indicatif composé n'est plus invisible. Le FT8 transmet un tel indicatif sous forme de hachage, affiché entre chevrons — « F4BPO <ZA/IW2JOP> -24 » — et tout décodage en contenant un était jeté comme illisible, y compris la réponse qui t'annonçait que cette station t'avait répondu. La forme à deux messages (« … RR73; … <indicatif> -08 ») est également lue correctement.",
+      "Le journal enregistre désormais quand un profil ré-applique tous ses sous-systèmes. C'est cette reconstruction qui coupait la liaison CAT de WSJT-X — le journal d'un opérateur en montre 54 dans une seule session, dont trois pendant que la radio émettait — et rien n'indiquait qu'elle avait lieu.",
+      "Le serveur CAT partagé n'est plus jamais démonté pendant que la radio émet. Une reconstruction réellement nécessaire attend la fin de l'émission — fermer la socket en pleine transmission, c'est ce qui laissait WSJT-X au milieu d'une série d'appels Hamlib sans personne à l'autre bout.",
+      "Démarrage auto : un programme peut être fermé à la fermeture d'OpsLog. Au cas par cas, pour que le contrôleur de rotor reste pendant que WSJT-X s'en va, et toujours une demande de fermeture polie — comme un clic sur sa croix — d'un programme lancé par OpsLog lui-même.",
+      "Diplômes : basculer une colonne entre la référence et sa description est désormais immédiat. L'opération reconstruisait tous les diplômes de tous les contacts du journal — un travail au résultat connu d'avance, puisqu'un changement d'étiquette ne change pas quels QSO correspondent. Seul ce diplôme est recalculé, et seulement sur les lignes qui le portent déjà. Le recalcul complet lit aussi vingt-sept colonnes par QSO au lieu de cent cinquante."
+    ]
+  },
+  {
+    "version": "0.26.1",
+    "date": "",
+    "en": [
+      "Auto-call: a QSO in progress is now held by OpsLog itself, so a new station is no longer called in the middle of an exchange. The hold is released when that QSO is logged, when you halt or click another decode, and after four minutes without a contact.",
+      "Rotor widget: the Stop button now lights up when pressed, like the direction presets, so there is no doubt the order went out.",
+      "FT decodes: a decode could go missing from the panel when a period arrived as one burst — the internal queue discarded it in silence. It is now deep enough for a full period, panadapter spots no longer hold the stream up, and anything still lost is written to the log.",
+      "Closing OpsLog can no longer leave a process behind. Each shutdown step is written to the log, and if one of them hangs the application now forces its own exit instead of staying open — which also unblocks the restart after an update.",
+      "CAT: a rig link whose polling loop got stuck no longer freezes every later reconnection attempt in silence. The wait is now bounded and the problem is written to the log, instead of a radio that never comes back and no explanation anywhere.",
+      "Cluster console: the replies to your commands are no longer buried under the spot flood. A Replies button — on by default — hides the DX spots, which the list above already shows.",
+      "Cluster: twelve named command buttons beside the command box — name one \"Show filters\", give it SH/FILTER, and one click sends it. They are set up in Settings → Cluster; a button with no command is not shown.",
+      "Cluster console: a Follow button decides whether the view sticks to the newest line, and sending a command re-arms it — a long reply is now scrolled to instead of landing out of sight. Switch Follow off to read without being pulled back down; the arrow beside it returns to the end.",
+      "Band map: the docked map can be switched to fit-to-band from its own header — click the px/kHz readout. It is the same setting the Band Map tab drives, so the two always agree.",
+      "Awards: an award can now be set to search in NO field. The matching options disappear with it, and the award counts only the references you assign to a contact by hand — for a reference like WWBOTA, which has no ADIF field anywhere.",
+      "New award: WWBOTA (World Wide Bunkers on the Air), with its full reference list — 31 342 bunkers. References are assigned to a contact by hand, the award having no ADIF field of its own.",
+      "Grid squares map: the map now fills its panel. It measured its container once, while the tab was still hidden, and kept that size — leaving a blank band under it whatever the window size.",
+      "Grid squares map: the fill colours for confirmed and worked squares can be chosen, beside the basemap selector. Left alone they follow the theme, and one click puts them back.",
+      "QSL cards: the QSO box now carries the frequency in megahertz alongside the band, and the designer lets you choose which columns it shows — date, UTC, band, frequency, mode, submode, RST.",
+      "Main view: up to four panes instead of two. A third and a fourth can be chosen — or left empty, in which case they are not drawn — and with four you pick between quarters (2 × 2) and four columns. Every divider is draggable, each arrangement is remembered for its own pane count, and a double-click evens it out.",
+      "Appearance: the alternating row shading in Recent QSOs can be switched off — every row the same colour — or given a colour of its own. It is independent of the QSL row colours, which still take precedence on the rows they paint.",
+      "QSL row colours: the \"left stripe\" style no longer draws a coloured hairline along the top and bottom of every coloured row. The stripe is painted differently — it is a stripe again, and nothing else.",
+      "QSL designer: the preview contact now fills every column the QSO box can show, frequency and submode included. A blank column promised room the printed card would not have."
+    ],
+    "fr": [
+      "Appel automatique : le QSO en cours est désormais verrouillé par OpsLog lui-même, si bien qu'une nouvelle station n'est plus appelée au milieu d'un échange. Le verrou est levé quand ce QSO est journalisé, quand tu fais Stop ou cliques un autre décodage, et au bout de quatre minutes sans contact.",
+      "Widget rotor : le bouton Stop s'allume maintenant quand on l'enfonce, comme les présélections de direction, pour ne plus douter que l'ordre est parti.",
+      "Décodages FT : un décodage pouvait manquer dans le panneau quand une période arrivait d'un bloc — la file interne le jetait sans rien dire. Elle est désormais dimensionnée pour une période entière, les spots panadapter ne retiennent plus le flux, et ce qui serait encore perdu est écrit dans le journal.",
+      "Fermer OpsLog ne peut plus laisser un processus derrière. Chaque étape d'arrêt est écrite dans le journal, et si l'une d'elles se bloque l'application force désormais sa propre sortie au lieu de rester ouverte — ce qui débloque aussi le redémarrage après une mise à jour.",
+      "CAT : une liaison radio dont la boucle d'interrogation se bloquait figeait en silence toutes les tentatives de reconnexion suivantes. L'attente est désormais bornée et le problème écrit dans le journal, au lieu d'une radio qui ne revient jamais sans la moindre explication.",
+      "Console cluster : les réponses à tes commandes ne sont plus noyées sous le flot de spots. Un bouton Réponses — actif par défaut — masque les spots DX, que la liste au-dessus affiche déjà.",
+      "Cluster : douze boutons de commande nommés à côté du champ de saisie — nomme-en un « Voir filtres », donne-lui SH/FILTER, et un clic l'envoie. Ils se règlent dans Réglages → Cluster ; un bouton sans commande n'est pas affiché.",
+      "Console cluster : un bouton Suivre décide si la vue reste collée à la dernière ligne, et envoyer une commande le réarme — une longue réponse défile maintenant jusqu'à elle au lieu d'arriver hors champ. Désactive Suivre pour lire sans être ramené en bas ; la flèche à côté revient à la fin.",
+      "Bandmap : la carte ancrée peut passer en ajustement à la bande depuis son propre en-tête — cliquer l'indicateur px/kHz. C'est le même réglage que celui de l'onglet Bandmap, les deux sont donc toujours d'accord.",
+      "Diplômes : un diplôme peut désormais ne chercher dans AUCUN champ. Les options de reconnaissance disparaissent avec lui, et le diplôme ne compte que les références attribuées à la main sur un contact — pour une référence comme WWBOTA, qui n'a de champ ADIF nulle part.",
+      "Nouveau diplôme : WWBOTA (World Wide Bunkers on the Air), avec sa liste de références complète — 31 342 bunkers. Les références s'attribuent à la main sur un contact, le diplôme n'ayant pas de champ ADIF propre.",
+      "Carte des carrés locator : la carte occupe enfin tout son panneau. Elle mesurait son conteneur une seule fois, alors que l'onglet était encore masqué, et gardait cette taille — d'où la bande vide en dessous quelle que soit la taille de la fenêtre.",
+      "Carte des carrés locator : les couleurs des carrés confirmés et contactés se choisissent, à côté du sélecteur de fond de carte. Laissées telles quelles, elles suivent le thème, et un clic les y ramène.",
+      "Cartes QSL : le tableau du QSO porte désormais la fréquence en mégahertz à côté de la bande, et le concepteur permet de choisir les colonnes affichées — date, UTC, bande, fréquence, mode, sous-mode, RST.",
+      "Vue principale : jusqu'à quatre volets au lieu de deux. Un troisième et un quatrième se choisissent — ou se laissent vides, auquel cas ils ne sont pas dessinés — et avec quatre tu choisis entre les quarts (2 × 2) et quatre colonnes. Chaque séparateur se glisse, chaque disposition est mémorisée pour son propre nombre de volets, et un double-clic la remet à égalité.",
+      "Apparence : l'alternance de teinte une ligne sur deux dans QSO récents peut être désactivée — toutes les lignes de la même couleur — ou recevoir sa propre couleur. Elle est indépendante des couleurs de ligne QSL, qui restent prioritaires sur les lignes qu'elles peignent.",
+      "Couleurs de ligne QSL : le style « barre à gauche » ne trace plus un filet coloré en haut et en bas de chaque ligne colorée. La barre est peinte autrement — c'est de nouveau une barre, et rien d'autre.",
+      "Concepteur QSL : le contact d'aperçu remplit maintenant toutes les colonnes que le tableau peut afficher, fréquence et sous-mode compris. Une colonne vide promettait une place que la carte imprimée n'avait pas."
+    ]
+  },
   {
     "version": "0.26.0",
     "date": "",

compact.go

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

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

@@ -1,7 +1,7 @@
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { Fragment, useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import {
   Activity, AlertCircle, Antenna, Bell, Check, CheckCircle2, ChevronDown, Clock, CloudOff, Compass, Database, Ear, Eraser, Flame, Gauge, Hash, Loader2, Lock,
-  Maximize2, Minimize2, Mic, MessageSquare, Pencil, Radar, Radio, RadioTower, RefreshCw, Satellite, Send, Settings, SlidersHorizontal, SpellCheck, Square, Terminal, Trash2, Unlock, X, Zap,
+  Maximize2, Minimize2, Mic, MessageSquare, Pencil, Radar, Radio, RadioTower, RefreshCw, Satellite, Send, SatelliteDish, Settings, SlidersHorizontal, SpellCheck, Square, Terminal, Trash2, Unlock, X, Zap,
 } from 'lucide-react';
 
 import {
@@ -20,10 +20,9 @@ import {
   RotatorGoToPath,
   GetCATState, SetCATFrequency, SetCATMode, SwitchCATRig, EntryBandChanged, FlexApplyBandAntenna, FlexApplyBandPower,
   GetSecretStatus, UnlockSecrets,
-  RefreshCtyDat, DownloadAllReferenceLists,
   RotatorGoTo, RotatorStop, SetActiveRotor,
   GetDBConnectionInfo, GetLogbookRevision,
-  GetUltrabeamStatus, SetUltrabeamDirection, UILog,
+  GetUltrabeamStatus, SetUltrabeamDirection, UILog, FlexZoomForSpot,
   GetAntGeniusStatus, GetAntGeniusSettings, AntGeniusActivate,
   GetTunerGeniusStatus, GetTunerGeniusSettings, TunerGeniusAutotune, TunerGeniusSetBypass, TunerGeniusSetOperate, TunerGeniusActivate,
   GetScpStatus, ScpLookup,
@@ -56,7 +55,7 @@ import {
   QSLViaRepairStatus, RepairQSLVia, DismissQSLViaRepair,
 } from '../wailsjs/go/main/App';
 import { Combobox } from '@/components/ui/combobox';
-import { applyAwardRefs, parseAwardRefs as parseManualRefs, spotRefList , withIOTARef } from '@/lib/awardRefs';
+import { applyAwardRefs, parseAwardRefs as parseManualRefs, spotRefList , withIOTARef, withRDARef } from '@/lib/awardRefs';
 import { EventsOn, BrowserOpenURL, WindowMinimise, WindowToggleMaximise, WindowIsMaximised, Quit } from '../wailsjs/runtime/runtime';
 import type { adif as adifModels, lookup as lookupModels, cat as catModels } from '../wailsjs/go/models';
 import type { QSOForm, WorkedBeforeView, StationSettingsForm, ListsSettingsForm, ModePresetForm } from '@/types';
@@ -80,6 +79,7 @@ import { FlexPanel } from '@/components/FlexPanel';
 import { IcomPanel } from '@/components/IcomPanel';
 import { YaesuPanel } from '@/components/YaesuPanel';
 import { AntGeniusPanel, type AGStatus } from '@/components/AntGeniusPanel';
+import { MotorAntennaWidget, type AntStatus } from '@/components/MotorAntennaWidget';
 import { TunerGeniusPanel, type TGStatus } from '@/components/TunerGeniusPanel';
 import { AmpWidget } from '@/components/AmpWidget';
 import { ScpPanel, type ScpResult } from '@/components/ScpPanel';
@@ -110,6 +110,7 @@ import { WinkeyerPanel, type WKStatus, type WKMacro } from '@/components/Winkeye
 import { RotorCompass } from '@/components/RotorCompass';
 import { GridSquareMap } from '@/components/GridSquareMap';
 import { loadAutoCall, shouldAutoCall, autoCallKey, type AutoCallSettings } from '@/lib/autocall';
+import { loadClusterMacros, visibleClusterMacros } from '@/lib/clusterMacros';
 import { DecodesPanel, type Decode as DecodeRow, type TxMsg as TxMsgRow } from '@/components/DecodesPanel';
 import { subscribeRotorHeading, pokeRotorHeading } from '@/lib/rotorHeading';
 import { writeUiPref } from '@/lib/uiPref';
@@ -597,7 +598,14 @@ export default function App() {
     return () => { window.clearTimeout(t); off(); };
   }, [callsign]);
   const [rotatorHeading, setRotatorHeading] = useState<{ enabled: boolean; ok: boolean; azimuth: number }>({ enabled: false, ok: false, azimuth: 0 });
-  const [ubStatus, setUbStatus] = useState<{ enabled: boolean; connected: boolean; direction: number; moving: boolean }>({ enabled: false, connected: false, direction: 0, moving: false });
+  // The FULL antenna status, not the four fields the beam overlay needed: the
+  // docked widget shows frequency, bands and tracking too, and polling the same
+  // controller twice for two shapes of the same answer is how the two views end
+  // up disagreeing. One poll, one object.
+  const [ubStatus, setUbStatus] = useState<AntStatus>({
+    enabled: false, type: '', connected: false, direction: 0, frequency: 0, moving: false, elements: [],
+  });
+  const [showMotorAnt, setShowMotorAnt] = useState(() => localStorage.getItem('opslog.showMotorAnt') === '1');
   const [agStatus, setAgStatus] = useState<AGStatus>({ connected: false, port_a: 0, port_b: 0, antennas: [] });
   const [agEnabled, setAgEnabled] = useState(false);
   const [tgStatus, setTgStatus] = useState<TGStatus>({ connected: false });
@@ -943,14 +951,55 @@ export default function App() {
   });
   useEffect(() => { writeUiPref('opslog.activeTab', activeTab); }, [activeTab]);
 
-  // Main tab: how much width the LEFT pane gets, in percent. Clamped to 15..85
+  // Main tab column shares, in percent, kept PER COLUMN COUNT.
-  // so a pane can be made small but never dragged out of existence — recovering
+  //
-  // from that means finding a divider that is no longer on screen.
+  // One list per count and not a single one that is rescaled: going from three
-  const [mainSplit, setMainSplit] = useState<number>(() => {
+  // panes to two and back should give you the three-pane layout you arranged,
-    const n = parseFloat(localStorage.getItem('opslog.mainSplit') || '');
+  // not something derived from the two-pane one. The old single 'mainSplit' key
-    return Number.isFinite(n) && n >= 15 && n <= 85 ? n : 50;
+  // is still read so an existing two-pane arrangement survives the upgrade.
+  //
+  // MIN_SHARE is what keeps a pane recoverable: a column dragged to nothing
+  // takes its divider off screen with it, and there is then no way back.
+  const MIN_SHARE = 10;
+  const evenShares = (n: number) => Array.from({ length: n }, () => 100 / n);
+  const [mainShares, setMainShares] = useState<Record<number, number[]>>(() => {
+    const out: Record<number, number[]> = { 2: evenShares(2), 3: evenShares(3), 4: evenShares(4) };
+    try {
+      const v = JSON.parse(localStorage.getItem('opslog.mainShares') || '{}');
+      for (const n of [2, 3, 4]) {
+        const a = v?.[n];
+        if (Array.isArray(a) && a.length === n && a.every((x: any) => Number.isFinite(x) && x >= MIN_SHARE)) {
+          out[n] = a.map(Number);
+        }
+      }
+    } catch { /* a corrupt preference must not cost the layout */ }
+    // Legacy: the two-pane percentage from before there were more than two.
+    const old = parseFloat(localStorage.getItem('opslog.mainSplit') || '');
+    if (!Array.isArray(JSON.parse(localStorage.getItem('opslog.mainShares') || 'null')?.[2])
+      && Number.isFinite(old) && old >= MIN_SHARE && old <= 100 - MIN_SHARE) {
+      out[2] = [old, 100 - old];
+    }
+    return out;
   });
-  useEffect(() => { writeUiPref('opslog.mainSplit', String(Math.round(mainSplit))); }, [mainSplit]);
+  const saveShares = (next: Record<number, number[]>) => {
+    setMainShares(next);
+    writeUiPref('opslog.mainShares', JSON.stringify(next));
+  };
+  // The quadrant cross: one vertical split and one horizontal split, each
+  // shared by both rows/columns. Two independent row heights would let the
+  // panes stop lining up, which reads as a rendering fault rather than a choice.
+  const [mainQuad, setMainQuad] = useState<{ col: number; row: number }>(() => {
+    try {
+      const v = JSON.parse(localStorage.getItem('opslog.mainQuad') || '{}');
+      const ok = (x: any) => Number.isFinite(x) && x >= MIN_SHARE && x <= 100 - MIN_SHARE;
+      if (ok(v?.col) && ok(v?.row)) return { col: Number(v.col), row: Number(v.row) };
+    } catch { /* same */ }
+    return { col: 50, row: 50 };
+  });
+  const saveQuad = (next: { col: number; row: number }) => {
+    setMainQuad(next);
+    writeUiPref('opslog.mainQuad', JSON.stringify(next));
+  };
 
   // Band-map widths. Two of them, because they are two different things: the
   // docked map sits beside the tables and competes with them for room, while
@@ -995,22 +1044,60 @@ export default function App() {
   };
 
   const mainSplitRef = useRef<HTMLDivElement | null>(null);
-  const startMainSplitDrag = (e: React.PointerEvent) => {
+  // Drag the divider between column i and column i+1.
+  //
+  // Only those two columns change, and their SUM is held constant: pushing a
+  // divider must not shuffle the columns further along, which is what makes a
+  // three-way split impossible to arrange one divider at a time.
+  const startMainSplitDrag = (e: React.PointerEvent, i: number, count: number) => {
     e.preventDefault();
     const host = mainSplitRef.current;
     if (!host) return;
     // Pointer capture on the divider, so dragging over a map keeps working —
     // Leaflet would otherwise swallow the moves the moment the cursor entered it.
     (e.currentTarget as HTMLElement).setPointerCapture(e.pointerId);
+    const start = (mainShares[count] ?? evenShares(count)).slice();
+    const pair = start[i] + start[i + 1];
+    const before = start.slice(0, i).reduce((a, b) => a + b, 0);
     const onMove = (ev: PointerEvent) => {
       const r = host.getBoundingClientRect();
       if (r.width <= 0) return;
       const pct = ((ev.clientX - r.left) / r.width) * 100;
-      setMainSplit(Math.min(85, Math.max(15, pct)));
+      const first = Math.min(pair - MIN_SHARE, Math.max(MIN_SHARE, pct - before));
+      const next = start.slice();
+      next[i] = first;
+      next[i + 1] = pair - first;
+      setMainShares((m) => ({ ...m, [count]: next }));
     };
     const onUp = () => {
       window.removeEventListener('pointermove', onMove);
       window.removeEventListener('pointerup', onUp);
+      // Persisted on release, not on every move: the pointer fires dozens of
+      // events a second and each one would be a database write.
+      setMainShares((m) => { writeUiPref('opslog.mainShares', JSON.stringify(m)); return m; });
+    };
+    window.addEventListener('pointermove', onMove);
+    window.addEventListener('pointerup', onUp);
+  };
+  // The quadrant cross. Same shape, one axis at a time.
+  const startQuadDrag = (e: React.PointerEvent, axis: 'col' | 'row') => {
+    e.preventDefault();
+    const host = mainSplitRef.current;
+    if (!host) return;
+    (e.currentTarget as HTMLElement).setPointerCapture(e.pointerId);
+    const onMove = (ev: PointerEvent) => {
+      const r = host.getBoundingClientRect();
+      if (r.width <= 0 || r.height <= 0) return;
+      const pct = axis === 'col'
+        ? ((ev.clientX - r.left) / r.width) * 100
+        : ((ev.clientY - r.top) / r.height) * 100;
+      const v = Math.min(100 - MIN_SHARE, Math.max(MIN_SHARE, pct));
+      setMainQuad((q) => ({ ...q, [axis]: v }));
+    };
+    const onUp = () => {
+      window.removeEventListener('pointermove', onMove);
+      window.removeEventListener('pointerup', onUp);
+      setMainQuad((q) => { writeUiPref('opslog.mainQuad', JSON.stringify(q)); return q; });
     };
     window.addEventListener('pointermove', onMove);
     window.addEventListener('pointerup', onUp);
@@ -1499,7 +1586,42 @@ export default function App() {
   const CONSOLE_CAP = 2000; // a busy cluster runs for hours — don't grow forever
   const [clusterLines, setClusterLines] = useState<ClusterLine[]>([]);
   const [clusterConsoleOpen, setClusterConsoleOpen] = useState(false);
+  // Hide the spot flood in the console, on by default.
+  //
+  // The spots have a grid of their own two panels up; what the console is FOR is
+  // the traffic that is not a spot — the reply to SH/DX, the filter listing, the
+  // node's complaint about a command it did not understand. On a busy node those
+  // answers scrolled out of sight in under a second, which made the command box
+  // look inert even though it had worked.
+  const [clusterHideSpots, setClusterHideSpots] = useState(() => lsBool('opslog.clusterHideSpots', true));
+  // Follow the tail, or stay where you put it.
+  //
+  // The console used to follow the bottom whenever you happened to be at the
+  // bottom, which is not the same as being asked to: reading a long SH/DX reply
+  // meant scrolling up and hoping nothing pulled you back. This is the explicit
+  // switch — off means the view never moves on its own, however much traffic
+  // arrives, and the button below jumps back down when you want it.
+  const [clusterFollow, setClusterFollow] = useState(() => lsBool('opslog.clusterConsoleFollow', true));
+  // What the console actually renders. A spot line is the node's own "DX de …"
+  // announcement — the one shape every cluster software agrees on — and it is
+  // matched on that alone: guessing more (WCY, WWV, a node's chatter) would hide
+  // traffic the operator asked to see. Lines WE sent are never hidden; they are
+  // the anchor for reading the reply that follows.
+  const clusterShown = useMemo(
+    () => (clusterHideSpots ? clusterLines.filter((l) => l.sent || !/^\s*DX de /i.test(l.text)) : clusterLines),
+    [clusterLines, clusterHideSpots],
+  );
   const clusterConsoleRef = useRef<HTMLDivElement | null>(null);
+  // Whether the view was at the bottom BEFORE the new lines landed.
+  //
+  // Measuring it inside the effect — after React had committed them — is what
+  // broke following a command reply: a ten-line answer to SH/FILTER makes the
+  // distance to the bottom jump past any threshold in the same frame, so the
+  // console concluded the operator had scrolled up and stayed where it was.
+  // Exactly the case the feature exists for. The scroll event is the only
+  // honest source: it fires when the OPERATOR moves, and not when content grows
+  // underneath them.
+  const clusterAtBottomRef = useRef(true);
   // Console lines are STAGED and flushed on a timer, never applied one by one.
   //
   // Every line of cluster traffic reaches this handler — spots, MOTD, WHO, the
@@ -1540,11 +1662,26 @@ export default function App() {
   // Follow the tail, but ONLY when already at the bottom — otherwise scrolling up
   // to read a SH/DX reply would yank you back down on the next spot.
   useEffect(() => {
+    if (!clusterFollow) return; // pinned by the operator — never move the view
+    // Even while following, a view the operator scrolled up is left alone: they
+    // are mid-sentence, and scrolling back to the bottom re-arms it by itself.
+    if (!clusterAtBottomRef.current) return;
     const el = clusterConsoleRef.current;
-    if (!el) return;
+    if (el) el.scrollTop = el.scrollHeight;
-    const atBottom = el.scrollHeight - el.scrollTop - el.clientHeight < 40;
+    // clusterShown, not clusterLines: with the spots hidden, the rendered list
-    if (atBottom) el.scrollTop = el.scrollHeight;
+    // is the only thing whose change can move the view.
-  }, [clusterLines]);
+  }, [clusterShown, clusterFollow]);
+  const clusterScrollToBottom = () => {
+    clusterAtBottomRef.current = true;
+    const el = clusterConsoleRef.current;
+    if (el) el.scrollTop = el.scrollHeight;
+  };
+  // Sending a command is a request to SEE its answer: it re-arms the follow
+  // whatever the scroll position was, then the reply lands and is followed.
+  const clusterSend = (cmd: string) => {
+    clusterScrollToBottom();
+    return SendClusterCommand(cmd).catch((err) => setError(String(err?.message ?? err)));
+  };
   // Multi-band filter: empty set = all bands. The user toggles chips.
   const [clusterBands, setClusterBands] = useState<Set<string>>(() => lsSet<string>('opslog.clusterBands'));
   // Lock-to-entry: when on, the band filter follows the entry's current
@@ -1553,7 +1690,7 @@ export default function App() {
   const [clusterLockMode, setClusterLockMode] = useState(() => lsBool('opslog.clusterLockMode', false));
   // Status filter chips. Empty set = show every status (including
   // already-worked). Otherwise only matching spots pass.
-  type SpotStatusKey = 'new' | 'new-band' | 'new-mode' | 'new-slot' | 'worked';
+  type SpotStatusKey = 'new' | 'new-band-mode' | 'new-band' | 'new-mode' | 'new-slot' | 'worked';
   // What the cluster can be FILTERED on. A superset of the entity status: a new
   // county or a new park is not a DXCC state, it is another dimension of the
   // same spot — which is why the grid shows them as separate badges. Filtering
@@ -1674,18 +1811,32 @@ export default function App() {
   // map ("map1"), the locator street map ("map2"), the cluster grid or the
   // worked-before grid. Per-profile (stored via SetUIPref → profile-prefixed),
   // so it's loaded async on mount and re-read on profile:changed below.
-  type MainPaneKind = 'map1' | 'map2' | 'cluster' | 'worked' | 'flex' | 'recent' | 'icom' | 'yaesu' | 'netcontrol' | 'decodes';
+  // 'none' is only ever stored for the third and fourth panes: the first two are
+  // the Main view, and a layout with no panes at all is not a layout.
+  type MainPaneKind = 'map1' | 'map2' | 'cluster' | 'worked' | 'flex' | 'recent' | 'icom' | 'yaesu' | 'netcontrol' | 'decodes' | 'none';
   const [mapZoomSignal, setMapZoomSignal] = useState(0); // bump → world map auto-zooms now
   const [mainPaneLeft, setMainPaneLeft] = useState<MainPaneKind>('map1');
   const [mainPaneRight, setMainPaneRight] = useState<MainPaneKind>('map2');
+  const [mainPane3, setMainPane3] = useState<MainPaneKind>('none');
+  const [mainPane4, setMainPane4] = useState<MainPaneKind>('none');
+  // With four panes: side by side, or the screen quartered. Both are wanted —
+  // four columns on a 65" desk display, quadrants on an ordinary one, where a
+  // quarter-width map is unreadable.
+  const [mainLayout4, setMainLayout4] = useState<'cols' | 'quad'>('quad');
   const loadMainPanes = useCallback(async () => {
     const valid = (v: string): v is MainPaneKind => v === 'map1' || v === 'map2' || v === 'cluster' || v === 'worked' || v === 'flex' || v === 'recent' || v === 'icom' || v === 'yaesu' || v === 'netcontrol' || v === 'decodes';
-    const [l, r] = await Promise.all([
+    const [l, r, p3, p4, lay] = await Promise.all([
       GetUIPref('mainPaneLeft').catch(() => ''),
       GetUIPref('mainPaneRight').catch(() => ''),
+      GetUIPref('mainPane3').catch(() => ''),
+      GetUIPref('mainPane4').catch(() => ''),
+      GetUIPref('mainPaneLayout').catch(() => ''),
     ]);
     setMainPaneLeft(valid(l) ? l : 'map1');
     setMainPaneRight(valid(r) ? r : 'map2');
+    setMainPane3(valid(p3) ? p3 : 'none');
+    setMainPane4(valid(p4) ? p4 : 'none');
+    setMainLayout4(lay === 'cols' ? 'cols' : 'quad');
   }, []);
   useEffect(() => { loadMainPanes(); }, [loadMainPanes]);
   // Report the current entry-strip band/mode/freq to the backend so the live
@@ -1803,15 +1954,17 @@ export default function App() {
   const spotsVisibleRef = useRef(false);
   const spotsDirtyRef = useRef(false);
   useEffect(() => {
-    const vis = mainPaneLeft === 'cluster' || mainPaneRight === 'cluster'
+    // Every pane, not just the first two — a cluster list in the third pane is
-      || mainPaneLeft === 'decodes' || mainPaneRight === 'decodes'
+    // just as visible, and missing it left a spot's NEW pill stale.
+    const shown = [mainPaneLeft, mainPaneRight, mainPane3, mainPane4];
+    const vis = shown.includes('cluster') || shown.includes('decodes')
       || activeTab === 'cluster' || activeTab === 'bandmap' || activeTab === 'decodes' || showBandMap;
     if (vis && !spotsVisibleRef.current && spotsDirtyRef.current) {
       spotsDirtyRef.current = false;
       void refreshSpotStatuses();
     }
     spotsVisibleRef.current = vis;
-  }, [mainPaneLeft, mainPaneRight, activeTab, showBandMap, refreshSpotStatuses]);
+  }, [mainPaneLeft, mainPaneRight, mainPane3, mainPane4, activeTab, showBandMap, refreshSpotStatuses]);
   useEffect(() => {
     let t: number | undefined;
     const off = EventsOn('qso:logged', () => {
@@ -1983,8 +2136,6 @@ export default function App() {
     }
   }, [updateInfo]);
   const [deletingAll, setDeletingAll] = useState(false);
-  const [ctyRefreshing, setCtyRefreshing] = useState(false);
-  const [refsDownloading, setRefsDownloading] = useState(false);
 
   // === ADIF ===
   const [importing, setImporting] = useState(false);
@@ -2100,6 +2251,11 @@ export default function App() {
   // argued with); this is only the plumbing that runs it and keys the radio.
   //
   // Re-read when Preferences closes, like every other setting edited there.
+  // The named command buttons, re-read when Preferences closes like every other
+  // setting edited there.
+  const [clusterMacros, setClusterMacros] = useState(loadClusterMacros);
+  useEffect(() => { if (!showSettings) setClusterMacros(loadClusterMacros()); }, [showSettings]);
+  const clusterMacrosShown = useMemo(() => visibleClusterMacros(clusterMacros), [clusterMacros]);
   const [autoCall, setAutoCall] = useState<AutoCallSettings>(loadAutoCall);
   useEffect(() => { if (!showSettings) setAutoCall(loadAutoCall()); }, [showSettings]);
   // When each callsign was last answered, so a station still calling CQ is not
@@ -2112,6 +2268,22 @@ export default function App() {
   // Set when a call goes out, so nothing else fires until the receiver's own
   // status catches up and `busy` can be trusted again.
   const autoHoldUntilRef = useRef(0);
+  // The station auto-call is currently working, and when it started.
+  //
+  // This is OpsLog's OWN record of "a QSO is running", and it exists because
+  // deriving that from the sender's Status was not enough: the moment
+  // WSJT-X/JTDX drops the DX call or the Enable-Tx flag between overs — which
+  // they do — the exchange looks finished and the next CQ gets answered,
+  // interleaving two and then three QSOs on one slice. A lock we set ourselves
+  // cannot be cleared by a flag we do not control.
+  //
+  // Released when that station's QSO is logged, when the operator halts or
+  // takes over by clicking a decode, and by the watchdog below.
+  const autoTargetRef = useRef<{ call: string; at: number } | null>(null);
+  // An exchange abandoned mid-way must not lock auto-call out for ever: four
+  // minutes covers a repeated FT8 QSO and still frees the next period soon
+  // enough to matter.
+  const AUTO_TARGET_MAX_MS = 240_000;
   // Per receiver, when the carrier was last up. Feeds the stale-exchange
   // backstop below.
   const lastTxAtRef = useRef<Map<string, number>>(new Map());
@@ -2141,6 +2313,13 @@ export default function App() {
       // it has acted on it — about a second. Without it the OTHER instance still
       // looks idle in that window and gets a call of its own.
       || now < autoHoldUntilRef.current;
+    // Our own lock, evaluated after the watchdog so an abandoned exchange does
+    // not hold the transmitter shut.
+    if (autoTargetRef.current && now - autoTargetRef.current.at > AUTO_TARGET_MAX_MS) {
+      LogUIError('auto-call', `giving up on ${autoTargetRef.current.call} — nothing logged in four minutes`, '');
+      autoTargetRef.current = null;
+    }
+    const locked = busy || autoTargetRef.current !== null;
     for (const d of decodes) {
       const seenKey = `${d.call}|${d.ms ?? d.at}|${d.instance ?? ''}`;
       if (autoSeenRef.current.has(seenKey)) continue;
@@ -2155,7 +2334,7 @@ export default function App() {
       if (!e) continue;
       autoSeenRef.current.add(seenKey);
       const verdict = shouldAutoCall(autoCall, d, e as any, {
-        busy,
+        busy: locked,
         calledAt: autoCalledRef.current,
         now,
         myCall: station.callsign,
@@ -2163,6 +2342,7 @@ export default function App() {
       if (!verdict.call) continue;
       autoCalledRef.current.set(d.call.toUpperCase(), now);
       autoHoldUntilRef.current = now + 12_000; // an FT8 slot, near enough
+      autoTargetRef.current = { call: d.call.toUpperCase(), at: now };
       // Same reason as a manual click: put the transmitter on the decode's band
       // before answering, or a second slice answers on the wrong one.
       FlexTXOnBand(d.band ?? '').catch(() => {});
@@ -2584,7 +2764,14 @@ export default function App() {
   // open, and every poll opens and closes the port.
   useEffect(() => subscribeRotorHeading((h) => setRotatorHeading(h as any)), []);
 
-  // Poll the Ultrabeam antenna for its connection + pattern direction.
+  // Poll the motorised antenna: connection, pattern, frequency, tracking.
+  //
+  // pokeUbStatus re-reads it NOW rather than waiting for the next tick, so a
+  // button in the docked widget shows its effect immediately instead of three
+  // seconds later — long enough to press it a second time.
+  const pokeUbStatus = useCallback(async () => {
+    try { const s: any = await GetUltrabeamStatus(); if (s) setUbStatus(s); } catch { /* transient */ }
+  }, []);
   useEffect(() => {
     let alive = true;
     const tick = async () => {
@@ -2872,6 +3059,10 @@ export default function App() {
     }
     if (s.band) setBand(s.band);
     if (catState.connected) tuneRigCAT(s.freq_hz, m);
+    // The panadapter width follows the MODE of the spot, when the option is on.
+    // AFTER the tune, deliberately: a view change must never delay the frequency
+    // change the operator is waiting for. A no-op on any backend but a Flex.
+    FlexZoomForSpot(m ?? '', s.freq_hz ?? 0).catch(() => {});
     if (m) applyModeFromSpot(m);
     onCallsignInput(s.dx_call, { force: true });
     applySpotPOTA((s as any).pota_ref);
@@ -3324,12 +3515,18 @@ export default function App() {
     // An explicit click always wins over whatever call is currently in the field.
     const unsubFlexSpot = EventsOn('flex:spot_clicked', (p: any) => {
       const call = String(p?.call ?? '');
-      if (applyUdpCall(call, true)) restartRecordingForNewTarget(call);
+      if (!applyUdpCall(call, true)) return;
+      restartRecordingForNewTarget(call);
+      // The park, like a click in the band map: the radio reports only a
+      // callsign, so the backend looks it up again before sending the event.
+      applySpotPOTA(String(p?.pota_ref ?? ''));
     });
     // Clicking a spot on the ExpertSDR (TCI) panorama fills the call, like Flex.
     const unsubTciSpot = EventsOn('tci:spot_clicked', (p: any) => {
       const call = String(p?.call ?? '');
-      if (applyUdpCall(call, true)) restartRecordingForNewTarget(call);
+      if (!applyUdpCall(call, true)) return;
+      restartRecordingForNewTarget(call);
+      applySpotPOTA(String(p?.pota_ref ?? ''));
     });
     const unsubBulk = EventsOn('bulkupdate:progress', (p: any) => {
       const total = Number(p?.total ?? 0);
@@ -3348,6 +3545,11 @@ export default function App() {
       try {
         await LogUDPLoggedADIF(text);
         await refresh();
+        // The QSO auto-call started has finished — release the lock so the next
+        // CQ can be answered. Matched on the callsign: a QSO logged from
+        // somewhere else must not free a run that is still going.
+        const logged = /<call:d+(?::[^>]*)?>([^<s]+)/i.exec(text)?.[1]?.toUpperCase();
+        if (logged && autoTargetRef.current?.call === logged) autoTargetRef.current = null;
       } catch (e: any) {
         const msg = String(e?.message ?? e);
         // A re-broadcast of an already-logged QSO (Log4OM/WSJT-X) is benign —
@@ -4225,7 +4427,13 @@ export default function App() {
         // previous contact with the call, so the island appeared for stations
         // already in the log and never for the new one on the island — which is
         // the entire point of the feature.
-        award_refs: withIOTARef(d.award_refs ?? '', String((r as any)?.iota ?? '')),
+        // The island, then the Russian district — both from the callbook, both
+        // only ever applied to the contact being typed. See withRDARef for why
+        // that restriction is the whole design.
+        award_refs: withRDARef(
+          withIOTARef(d.award_refs ?? '', String((r as any)?.iota ?? '')),
+          String((r as any)?.rda ?? ''),
+        ),
       }));
       // Backfill anything the provider didn't supply from the last time we worked
       // this call (call not found on QRZ/HamQTH, or lookup off → cty.dat only).
@@ -4301,11 +4509,21 @@ export default function App() {
     // the first keystroke, so we only abort once.)
     if (v.trim() !== '') {
       // Someone answered: on the FIRST character of a new call (the field was
-      // empty), abort whatever CW is being sent — a single macro OR an auto-call
+      // empty), abort whatever is being sent — a single macro OR an auto-call
       // CQ loop — routed to the ACTIVE engine (was WinKeyer-only, so a Flex CWX /
       // Icom macro kept keying over the answering station).
-      if (callsignValRef.current.trim() === '') stopKeyerTx();
+      //
+      // The VOICE keyer gets the same treatment, and did not: typing a callsign
+      // stopped the CW auto-call and left the DVK cheerfully calling CQ over the
+      // station that had just answered. Nothing about the reason is specific to
+      // Morse — it is "somebody is there, stop calling" — so both engines stop
+      // on the same event.
+      if (callsignValRef.current.trim() === '') {
+        stopKeyerTx();
+        DVKStop().catch(() => { /* nothing playing */ });
+      }
       stopAutoCall();
+      stopDvkAutoCq();
     }
     // No-op guard: external apps (MSHV/WSJT-X) re-broadcast the same DX call
     // on every status packet. If it matches what's already in the entry,
@@ -4449,11 +4667,10 @@ export default function App() {
       { type: 'item', label: t('tools.alerts'), action: 'tools.alerts' },
       { type: 'separator' },
       { type: 'item', label: t('tools.duplicates'), action: 'tools.duplicates', disabled: total === 0 },
-      { type: 'separator' },
+      // The two maintenance entries that used to sit here — refresh cty.dat and
-      // Maintenance — bumped here while we only have one entry. Will move
+      // download the reference lists — moved to Settings → Maintenance →
-      // to a Tools → Maintenance submenu once Clublog + LoTW refresh land.
+      // Databases, where every other database already lives. One place to look
-      { type: 'item', label: ctyRefreshing ? 'Refreshing cty.dat…' : 'Refresh cty.dat', action: 'tools.refreshCty', disabled: ctyRefreshing },
+      // beats two, and the Tools menu is for what you DO with the log.
-      { type: 'item', label: refsDownloading ? 'Downloading reference lists…' : 'Download reference lists (IOTA/POTA/WWFF/SOTA)', action: 'tools.downloadRefs', disabled: refsDownloading },
     ]},
     { name: 'help', label: t('menu.help'), items: [
       { type: 'item', label: t('whatsnew.title'), action: 'help.whatsnew' },
@@ -4469,7 +4686,7 @@ export default function App() {
       { type: 'separator' },
       { type: 'item', label: t('help.about'), action: 'help.about' },
     ]},
-  ], [total, selectedId, selectedIds, ctyRefreshing, refsDownloading, exporting, wkEnabled, dvkEnabled, cwEnabled, netEnabled, contestTabEnabled, smtpConfigured, sendingLog, t]);
+  ], [total, selectedId, selectedIds, exporting, wkEnabled, dvkEnabled, cwEnabled, netEnabled, contestTabEnabled, smtpConfigured, sendingLog, t]);
 
   function handleMenu(action: string) {
     switch (action) {
@@ -4497,8 +4714,6 @@ export default function App() {
       case 'tools.contest':     setContestTabEnabled((v) => { const nv = !v; if (nv) setActiveTab('contest'); else setActiveTab((tb) => (tb === 'contest' ? 'recent' : tb)); return nv; }); break;
       case 'tools.alerts':      setAlertsOpen(true); break;
       case 'tools.duplicates':  setShowDuplicates(true); break;
-      case 'tools.refreshCty':  refreshCtyDat(); break;
-      case 'tools.downloadRefs': downloadRefs(); break;
       case 'help.about':        setShowAbout(true); checkUpdateNow(); break;
       case 'help.log':          setShowLogViewer(true); break;
       case 'help.whatsnew':     GetChangelog().then((e: any) => { if (Array.isArray(e) && e.length) setWhatsNew(e); else showToast(t('whatsnew.none')); }).catch(() => {}); break;
@@ -4523,37 +4738,6 @@ export default function App() {
     }
   }
 
-  async function downloadRefs() {
-    if (refsDownloading) return;
-    setRefsDownloading(true);
-    setError('');
-    try {
-      const summary = await DownloadAllReferenceLists();
-      showToast(`Reference lists updated — ${summary}`);
-    } catch (e: any) {
-      setError(`Reference download failed: ${String(e?.message ?? e)}`);
-    } finally {
-      setRefsDownloading(false);
-    }
-  }
- 
-  async function refreshCtyDat() {
-    if (ctyRefreshing) return;
-    setCtyRefreshing(true);
-    setError('');
-    try {
-      const info = await RefreshCtyDat();
-      // Use the regular error banner area for a brief success note — keeps
-      // us from pulling in a toast system just for one maintenance action.
-      setError(`cty.dat refreshed — ${info.entities} entities loaded`);
-      setTimeout(() => setError((e) => e.startsWith('cty.dat refreshed') ? '' : e), 4000);
-    } catch (e: any) {
-      setError(`cty.dat refresh failed: ${String(e?.message ?? e)}`);
-    } finally {
-      setCtyRefreshing(false);
-    }
-  }
-
   useEffect(() => {
     function onKey(e: KeyboardEvent) {
       const tag = (e.target as HTMLElement)?.tagName;
@@ -5502,6 +5686,20 @@ export default function App() {
               >
                 {clusterLockBand ? <Lock className="size-2.5" /> : <Unlock className="size-2.5" />} {band}
               </button>
+              {/* "My bands" in one click.
+                  
+                  No selection means EVERY band, which is what an operator wants
+                  the first time and never again: an RBN feed carries 4 m and
+                  70 cm, and the list above can only offer the bands you have
+                  configured — so a band you do not own could not be unticked,
+                  because it was never there to tick. Selecting your own list
+                  makes the filter finite, and the spot goes. */}
+              {clusterBands.size !== bands.length && (
+                <button type="button"
+                  onClick={() => setClusterBands(new Set(bands))}
+                  title={t('clu.myBandsTitle')}
+                  className="text-[10px] text-muted-foreground hover:text-foreground underline">{t('clu.myBands')}</button>
+              )}
               {clusterBands.size > 0 && (
                 <button type="button" onClick={() => setClusterBands(new Set())} className="text-[10px] text-muted-foreground hover:text-foreground underline">{t('clu.clear')}</button>
               )}
@@ -5513,6 +5711,9 @@ export default function App() {
           <div className="flex flex-wrap gap-1">
             {([
               { k: 'new'      as SpotFilterKey, label: 'NEW',       cls: 'bg-danger-muted text-danger-muted-foreground border-danger-border' },
+              // NEW BAND+MODE sits between NEW and NEW BAND, which is where it
+              // ranks: the entity is worked, but neither this band nor this mode.
+              { k: 'new-band-mode' as SpotFilterKey, label: 'NEW B+M', cls: 'bg-danger-muted text-danger-muted-foreground border-danger-border' },
               { k: 'new-band' as SpotFilterKey, label: 'NEW BAND',  cls: 'bg-warning-muted text-warning-muted-foreground border-warning-border' },
               { k: 'new-mode' as SpotFilterKey, label: 'NEW MODE',  cls: 'bg-caution-muted text-caution-muted-foreground border-caution-border' },
               { k: 'new-slot' as SpotFilterKey, label: 'NEW SLOT',  cls: 'bg-caution-muted text-caution-muted-foreground border-caution-border' },
@@ -5609,6 +5810,9 @@ export default function App() {
       // who gets answered — and it would only fight the digital application
       // for the VFO. The entry is still filled, so the QSO can be logged here.
       onCall={(d) => {
+        // The operator has picked a station: that is now the QSO in progress, so
+        // auto-call must not answer someone else over the top of it.
+        autoTargetRef.current = { call: (d.call ?? '').toUpperCase(), at: Date.now() };
         onCallsignInput(d.call, { force: true });
         // With two slices on two bands, the Reply reaches the right INSTANCE but
         // the radio still transmits on whichever slice holds the TX flag. Move
@@ -5627,6 +5831,7 @@ export default function App() {
       // buffer goes too or the next flush would put back what was just cleared.
       onClear={(instance) => {
         if (!instance) {
+          autoTargetRef.current = null;
           pendingDecodesRef.current = [];
           setDecodes([]);
           setTxMsgs([]);
@@ -5644,6 +5849,8 @@ export default function App() {
       // An empty instance lets the backend fall back to whichever application
       // last reported its status — the normal single-receiver case.
       onHalt={(instance) => {
+        // Halt means stop, including whatever auto-call had started.
+        autoTargetRef.current = null;
         HaltDecodeTx(instance, false).catch((e: any) => setError(String(e?.message ?? e)));
       }}
     />
@@ -5971,6 +6178,25 @@ export default function App() {
             >
               <Compass className="size-4" />
             </button>
+            {ubStatus.enabled && (
+              <button
+                type="button"
+                onClick={() => { const v = !showMotorAnt; setShowMotorAnt(v); writeUiPref('opslog.showMotorAnt', v ? '1' : '0'); }}
+                title={showMotorAnt ? t('station.motorWidgetHide') : t('station.motorWidgetShow')}
+                className={cn(
+                  'relative inline-flex items-center justify-center size-7 rounded-md border transition-colors',
+                  showMotorAnt ? 'border-success-border bg-success-muted text-success-muted-foreground hover:bg-success-muted'
+                    : 'border-border text-muted-foreground hover:bg-muted',
+                )}
+              >
+                <SatelliteDish className="size-4" />
+                {/* Amber while the elements travel: on a SteppIR that is also
+                    when transmitting is a bad idea, so it is worth seeing from
+                    the icon without opening the widget. */}
+                {ubStatus.moving && <span className="absolute -top-0.5 -right-0.5 size-2 rounded-full bg-warning animate-pulse" />}
+                {!ubStatus.moving && showMotorAnt && ubStatus.connected && <span className="absolute -top-0.5 -right-0.5 size-2 rounded-full bg-success" />}
+              </button>
+            )}
             {agEnabled && (
               <button
                 type="button"
@@ -6602,7 +6828,7 @@ export default function App() {
       {/* Reserved free space to the right. The WinKeyer CW keyer and/or the
           Digital Voice Keyer take this slot when enabled (Log4OM-style);
           otherwise it shows the QRZ profile photo. */}
-      {!compact && (chatShown || wkEnabled || dvkEnabled || lookupResult?.image_url || (showRotor && (rotatorHeading.enabled || dxPath)) || (showAntGenius && agEnabled) || (showTuner && tgEnabled) || (showAmpWidget && ampSts.length > 0) || (showScp && scpEnabled) || (chaseNewOn && showChaseNew) || (showLiveStations && dbConn?.backend === 'mysql')) && (
+      {!compact && (chatShown || wkEnabled || dvkEnabled || lookupResult?.image_url || (showRotor && (rotatorHeading.enabled || dxPath)) || (showMotorAnt && ubStatus.enabled) || (showAntGenius && agEnabled) || (showTuner && tgEnabled) || (showAmpWidget && ampSts.length > 0) || (showScp && scpEnabled) || (chaseNewOn && showChaseNew) || (showLiveStations && dbConn?.backend === 'mysql')) && (
         // relative + absolute inner (like the F1-F5 panel): a taller widget (e.g.
         // the DVK with Auto CQ) can't grow the row — the row height stays set by
         // the entry strip and each widget fills that height, scrolling inside.
@@ -6686,6 +6912,17 @@ export default function App() {
               />
             </div>
           )}
+          {showMotorAnt && ubStatus.enabled && (
+            <div className="w-[230px] shrink-0 min-h-0">
+              <MotorAntennaWidget
+                ant={ubStatus}
+                refetch={pokeUbStatus}
+                t={t}
+                essentialsOnly
+                onClose={() => { setShowMotorAnt(false); writeUiPref('opslog.showMotorAnt', '0'); }}
+              />
+            </div>
+          )}
           {showAntGenius && agEnabled && (
             <div className="w-[230px] shrink-0 min-h-0">
               <AntGeniusPanel
@@ -7315,8 +7552,35 @@ export default function App() {
                     <span className="text-[11px] font-semibold uppercase tracking-wider text-muted-foreground">
                       {t('cluster.console')}
                     </span>
-                    <span className="text-[10px] text-muted-foreground tabular-nums">{clusterLines.length}</span>
+                    <span className="text-[10px] text-muted-foreground tabular-nums">{clusterShown.length}</span>
                     <div className="flex-1" />
+                    <button
+                      className={cn('text-[11px] px-1.5 rounded border',
+                        clusterHideSpots
+                          ? 'border-primary/60 bg-primary/15 text-primary'
+                          : 'border-transparent text-muted-foreground hover:text-foreground')}
+                      title={t('cluster.repliesOnlyTip')}
+                      onClick={() => {
+                        const v = !clusterHideSpots;
+                        setClusterHideSpots(v);
+                        writeUiPref('opslog.clusterHideSpots', v ? '1' : '0');
+                      }}>{t('cluster.repliesOnly')}</button>
+                    <button
+                      className={cn('text-[11px] px-1.5 rounded border',
+                        clusterFollow
+                          ? 'border-primary/60 bg-primary/15 text-primary'
+                          : 'border-transparent text-muted-foreground hover:text-foreground')}
+                      title={t('cluster.followTip')}
+                      onClick={() => {
+                        const v = !clusterFollow;
+                        setClusterFollow(v);
+                        writeUiPref('opslog.clusterConsoleFollow', v ? '1' : '0');
+                        if (v) clusterScrollToBottom(); // switching it on means "take me there"
+                      }}>{t('cluster.follow')}</button>
+                    <button
+                      className="text-[11px] px-1.5 rounded border border-transparent text-muted-foreground hover:text-foreground"
+                      title={t('cluster.toBottom')}
+                      onClick={clusterScrollToBottom}>↓</button>
                     <button className="text-[11px] text-muted-foreground hover:text-foreground"
                       onClick={() => setClusterLines([])}>{t('cluster.clear')}</button>
                     <button className="text-muted-foreground hover:text-foreground"
@@ -7324,10 +7588,17 @@ export default function App() {
                       <X className="size-3.5" />
                     </button>
                   </div>
-                  <div ref={clusterConsoleRef} className="flex-1 min-h-0 overflow-auto bg-background/40 px-2.5 py-1.5 font-mono text-[11px] leading-[1.45]">
+                  <div ref={clusterConsoleRef}
-                    {clusterLines.length === 0 ? (
+                    onScroll={(e) => {
-                      <p className="text-muted-foreground italic">{t('cluster.consoleEmpty')}</p>
+                      const el = e.currentTarget;
-                    ) : clusterLines.map((l, i) => (
+                      clusterAtBottomRef.current = el.scrollHeight - el.scrollTop - el.clientHeight < 40;
+                    }}
+                    className="flex-1 min-h-0 overflow-auto bg-background/40 px-2.5 py-1.5 font-mono text-[11px] leading-[1.45]">
+                    {clusterShown.length === 0 ? (
+                      <p className="text-muted-foreground italic">
+                        {t(clusterHideSpots && clusterLines.length > 0 ? 'cluster.consoleOnlySpots' : 'cluster.consoleEmpty')}
+                      </p>
+                    ) : clusterShown.map((l, i) => (
                       <div key={i} className={cn('whitespace-pre-wrap break-all', l.sent ? 'text-primary font-semibold' : 'text-foreground/85')}>
                         <span className="text-muted-foreground/60 mr-1.5 select-none">{l.at}</span>
                         {l.sent && <span className="text-muted-foreground/60 mr-1 select-none">»</span>}
@@ -7348,15 +7619,13 @@ export default function App() {
                 )}
                 <span className="text-xs text-muted-foreground font-mono whitespace-nowrap">→ master</span>
                 <Input
-                  className="font-mono text-xs h-8"
+                  className="font-mono text-xs h-8 w-64 shrink-0"
                   placeholder='sh/dx 30, set/needsdxcc, …'
                   value={clusterCmd}
                   onChange={(e) => setClusterCmd(e.target.value)}
                   onKeyDown={(e) => {
                     if (e.key === 'Enter' && clusterCmd.trim()) {
-                      SendClusterCommand(clusterCmd.trim())
+                      clusterSend(clusterCmd.trim()).then(() => setClusterCmd(''));
-                        .then(() => setClusterCmd(''))
-                        .catch((err) => setError(String(err?.message ?? err)));
                     }
                   }}
                 />
@@ -7364,14 +7633,38 @@ export default function App() {
                   variant="outline" size="sm"
                   onClick={() => {
                     if (!clusterCmd.trim()) return;
-                    SendClusterCommand(clusterCmd.trim())
+                    clusterSend(clusterCmd.trim()).then(() => setClusterCmd(''));
-                      .then(() => setClusterCmd(''))
-                      .catch((err) => setError(String(err?.message ?? err)));
                   }}
                   disabled={!clusterCmd.trim()}
                 >
                   Send
                 </Button>
+                {/* The macro buttons, in the space the command box used to take up
+                    for itself. After Send, so the two ways of sending a command
+                    are not interleaved and the eye finds Send where it has always
+                    been. Wraps rather than scrolls: twelve short labels fit on one
+                    line at any usable width, and a hidden button is a button that
+                    does not exist. */}
+                {clusterMacrosShown.length > 0 && (
+                  <div className="flex flex-wrap items-center gap-1 min-w-0">
+                    {clusterMacrosShown.map((m, i) => (
+                      <button
+                        key={`${m.label}-${i}`}
+                        type="button"
+                        title={m.cmd}
+                        onClick={() => {
+                          // Straight out, no round trip through the input box: the
+                          // point of the button is not to type the command for you.
+                          clusterSend(m.cmd);
+                        }}
+                        className="h-8 px-2 rounded-md border border-border bg-muted/40 text-xs font-medium
+                                   hover:bg-muted active:scale-95 transition-all duration-150 truncate max-w-[10rem]"
+                      >
+                        {m.label}
+                      </button>
+                    ))}
+                  </div>
+                )}
               </div>
               </div>{/* /left column */}
 
@@ -7424,21 +7717,79 @@ export default function App() {
                   different widths, and which one deserves the room changes with
                   what the operator is doing. The share is persisted (portable),
                   and a double-click puts it back to even. */}
+              {(() => {
+                // The panes actually configured, in order. 'none' is skipped
+                // rather than drawn empty: a blank quarter of the screen is not
+                // a layout choice anyone makes on purpose.
+                const panes = [mainPaneLeft, mainPaneRight, mainPane3, mainPane4]
+                  .filter((k) => k !== 'none') as MainPaneKind[];
+                const grip = (vertical: boolean) => (
+                  <span className={cn('rounded-full bg-border group-hover:bg-primary transition-colors',
+                    vertical ? 'h-10 w-1' : 'w-10 h-1')} />
+                );
+
+                // Four panes, quartered: ONE vertical divider and ONE horizontal
+                // one, each shared by both rows/columns, so the panes always line
+                // up. Independent per-row splits look like a rendering fault.
+                if (panes.length === 4 && mainLayout4 === 'quad') {
+                  return (
+                    <div ref={mainSplitRef} className="grid gap-2 h-full min-h-0 p-2"
+                      style={{
+                        gridTemplateColumns: `${mainQuad.col}fr 6px ${100 - mainQuad.col}fr`,
+                        gridTemplateRows: `${mainQuad.row}fr 6px ${100 - mainQuad.row}fr`,
+                      }}>
+                      {panes.map((k, i) => (
+                        <div key={i} className="min-h-0 min-w-0 flex"
+                          style={{ gridColumn: i % 2 === 0 ? 1 : 3, gridRow: i < 2 ? 1 : 3 }}>
+                          {renderMainPane(k)}
+                        </div>
+                      ))}
+                      <div role="separator" aria-orientation="vertical" title={t('main.splitTip')}
+                        style={{ gridColumn: 2, gridRow: '1 / span 3' }}
+                        onPointerDown={(e) => startQuadDrag(e, 'col')}
+                        onDoubleClick={() => saveQuad({ ...mainQuad, col: 50 })}
+                        className="group relative cursor-col-resize flex items-center justify-center -mx-1 px-1">
+                        {grip(true)}
+                      </div>
+                      <div role="separator" aria-orientation="horizontal" title={t('main.splitTip')}
+                        style={{ gridColumn: '1 / span 3', gridRow: 2 }}
+                        onPointerDown={(e) => startQuadDrag(e, 'row')}
+                        onDoubleClick={() => saveQuad({ ...mainQuad, row: 50 })}
+                        className="group relative cursor-row-resize flex items-center justify-center -my-1 py-1">
+                        {grip(false)}
+                      </div>
+                    </div>
+                  );
+                }
+
+                // One pane fills the tab; two, three or four sit side by side
+                // with a divider between each neighbouring pair.
+                const n = panes.length;
+                const shares = n >= 2 ? (mainShares[n] ?? evenShares(n)) : [100];
+                const cols = shares.map((w) => `${w}fr`).join(' 6px ');
+                return (
                   <div ref={mainSplitRef} className="grid grid-rows-1 gap-2 h-full min-h-0 p-2"
-                style={{ gridTemplateColumns: `${mainSplit}fr 6px ${100 - mainSplit}fr` }}>
+                    style={{ gridTemplateColumns: cols }}>
-                <div className="min-h-0 min-w-0 flex">{renderMainPane(mainPaneLeft)}</div>
+                    {panes.map((k, i) => (
+                      <Fragment key={i}>
+                        {i > 0 && (
                           <div
                             role="separator"
                             aria-orientation="vertical"
                             title={t('main.splitTip')}
-                  onPointerDown={startMainSplitDrag}
+                            onPointerDown={(e) => startMainSplitDrag(e, i - 1, n)}
-                  onDoubleClick={() => setMainSplit(50)}
+                            onDoubleClick={() => saveShares({ ...mainShares, [n]: evenShares(n) })}
                             className="group relative cursor-col-resize flex items-center justify-center -mx-1 px-1"
                           >
-                  <span className="h-10 w-1 rounded-full bg-border group-hover:bg-primary transition-colors" />
+                            {grip(true)}
                           </div>
-                <div className="min-h-0 min-w-0 flex">{renderMainPane(mainPaneRight)}</div>
+                        )}
+                        <div className="min-h-0 min-w-0 flex">{renderMainPane(k)}</div>
+                      </Fragment>
+                    ))}
                   </div>
+                );
+              })()}
             </TabsContent>
 
             <TabsContent value="awards" className="flex-1 min-h-0 p-0">
@@ -7611,6 +7962,13 @@ export default function App() {
               onSpotClick={handleSpotClick}
               onClose={() => setBandMapShown(false)}
               showLotw={!!rowColors?.bandmap_lotw}
+              // The SAME setting the Band Map tab drives, deliberately: one
+              // answer to "does a band map show the whole band", not one per
+              // place a band map happens to be drawn.
+              fitToBand={bandMapFit}
+              onToggleFit={toggleBandMapFit}
+              hideDigital={bandMapHideFt}
+              onToggleHideDigital={toggleBandMapHideFt}
               keyNav
             />
           </div>
@@ -7890,7 +8248,15 @@ export default function App() {
             // spot already on screen showing the answer to the OLD question.
             setSpotStatus({});
           }}
-          onMainPaneChanged={(side, v) => { if (side === 'left') setMainPaneLeft(v as MainPaneKind); else setMainPaneRight(v as MainPaneKind); }}
+          onMainPaneChanged={(side, v) => {
+            // Applied from the CHOSEN value, never from a re-read of the DB:
+            // the write is async and the layout must not lag a click behind.
+            if (side === 'left') setMainPaneLeft(v as MainPaneKind);
+            else if (side === 'right') setMainPaneRight(v as MainPaneKind);
+            else if (side === 'p3') setMainPane3(v as MainPaneKind);
+            else if (side === 'p4') setMainPane4(v as MainPaneKind);
+            else if (side === 'layout') setMainLayout4(v === 'cols' ? 'cols' : 'quad');
+          }}
           flexAvailable={catState.backend === 'flex'}
           icomAvailable={catState.backend === 'icom'}
           yaesuAvailable={catState.backend === 'yaesu'}

frontend/src/components/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>
+        {/* 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

@@ -174,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':
@@ -193,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);
 }
 
@@ -259,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'));
@@ -276,6 +278,7 @@ const makeColCatalog = (t: TFn): ColEntry[] => [
       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')
@@ -310,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');
@@ -338,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',
@@ -349,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;

frontend/src/components/DecodesPanel.tsx

@@ -132,6 +132,9 @@ function catsOf(e: StatusEntry | undefined): Set<NewCat> {
   if (!e) return out;
   switch (e.status) {
     case 'new': out.add('dxcc'); break;
+    // NEW BAND+MODE lights BOTH badges: the two facts are true at once, and
+    // showing one of them would say the entity is already worked in the other.
+    case 'new-band-mode': out.add('band'); out.add('mode'); break;
     case 'new-band': out.add('band'); break;
     case 'new-mode': out.add('mode'); break;
     case 'new-slot': out.add('slot'); break;

frontend/src/components/GridSquareMap.tsx

@@ -34,6 +34,10 @@ type Square = { grid: string; count: number; confirmed: boolean; band?: string;
 // 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();
@@ -41,20 +45,33 @@ function cssColour(token: string, fallback: string): string {
   } catch { return fallback; }
 }
 
-// Mode scope. Two, because the map lives beside a panel that decodes FTx: CW,
+// Mode scope. The names come straight from the backend's own classes ("ALL",
-// phone and "everything" answer a question nobody is asking here, and a row of
+// "PHONE", "CW", "DIGI") plus FTX, which is narrower than digital and usually
-// choices that are never the right one is just noise to read past.
+// the honest one beside an FTx panel — a square worked on RTTY in a contest is
-//
-// Digital is every digital mode; FTx is the FT family alone, which is the
-// narrower and usually the honest one — 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();
@@ -69,6 +86,8 @@ export function GridSquareMap({ myGrid, className }: { myGrid?: string; classNam
       ? (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.
@@ -100,12 +119,46 @@ export function GridSquareMap({ myGrid, className }: { myGrid?: string; classNam
       preferCanvas: true,
       zoomControl: true,
       attributionControl: true,
-      worldCopyJump: true,
+      // ONE world, not a row of them. worldCopyJump exists to make a path look
-      minZoom: 1,
+      // continuous across the date line; here it only meant the same continent
-    }).setView([25, 0], 2);
+      // 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);
-    return () => { m.remove(); mapRef.current = null; layerRef.current = null; };
+    // 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
@@ -115,7 +168,10 @@ export function GridSquareMap({ myGrid, className }: { myGrid?: string; classNam
   useEffect(() => {
     const m = mapRef.current;
     if (!m) return;
-    addBasemap(m, basemap, baseRef, labelsRef);
+    // 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]);
 
@@ -126,8 +182,8 @@ export function GridSquareMap({ myGrid, className }: { myGrid?: string; classNam
     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 = cssColour('--success', '#16a34a');
+    const confirmedColour = confColour || cssColour('--success', '#16a34a');
-    const workedColour = cssColour('--chart-1', '#2a78d6');
+    const workedFill = workedColour || cssColour('--chart-1', '#2a78d6');
     const meColour = cssColour('--warning', '#f59e0b');
     for (const sq of squares ?? []) {
       const b = gridSquareBounds(sq.grid);
@@ -135,7 +191,7 @@ export function GridSquareMap({ myGrid, className }: { myGrid?: string; classNam
       // 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 : workedColour;
+      const colour = sq.confirmed ? confirmedColour : workedFill;
       L.rectangle([[b.south, b.west], [b.north, b.east]], {
         color: colour,
         weight: 0.5,
@@ -159,7 +215,7 @@ export function GridSquareMap({ myGrid, className }: { myGrid?: string; classNam
         fillColor: meColour, fillOpacity: 1,
       }).bindTooltip(myGrid!.toUpperCase(), { sticky: true }).addTo(layer);
     }
-  }, [squares, myGrid, t, themeTick]);
+  }, [squares, myGrid, t, themeTick, confColour, workedColour]);
 
   const stats = useMemo(() => {
     const list = squares ?? [];
@@ -200,6 +256,28 @@ export function GridSquareMap({ myGrid, className }: { myGrid?: string; classNam
             <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">
@@ -209,16 +287,19 @@ export function GridSquareMap({ myGrid, className }: { myGrid?: string; classNam
       {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. */}
-      <div ref={hostRef} className="flex-1 min-h-0" />
+      {/* 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: 'var(--success)', opacity: 0.75 }} />
+            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: 'var(--chart-1)', opacity: 0.35 }} />
+            style={{ background: workedColour || 'var(--chart-1)', opacity: 0.35 }} />
           {t('gsm.worked')}
         </span>
       </footer>

frontend/src/components/MainMap.tsx

@@ -85,13 +85,27 @@ export function addBasemap(
   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/RecentQSOsGrid.tsx

@@ -720,7 +720,7 @@ 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>

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

@@ -4,6 +4,7 @@ import {
   ChevronDown, ChevronRight,
   User, Database, Radio, Cog, Server, Antenna as AntennaIcon,
   Compass, Wifi, Construction, UploadCloud, Loader2, FolderOpen, Play, Power, Check, Pencil,
+  Minimize2,
 } from 'lucide-react';
 import {
   GetLookupSettings, SaveLookupSettings, ClearLookupCache, TestLookupProvider,
@@ -12,7 +13,7 @@ import {
   ListProfiles, GetActiveProfile, SaveProfile, DeleteProfile, ActivateProfile, DuplicateProfile,
   GetRotators, SaveRotators, TestRotatorDevice, RotatorPark, RotatorStop,
   GetRotorPresets, SaveRotorPresets, ResetRotorPresets,
-  GetUltrabeamSettings, SaveUltrabeamSettings, TestUltrabeam,
+  GetUltrabeamSettings, SaveUltrabeamSettings, TestUltrabeam, CompactDatabase,
   GetAntGeniusSettings, SaveAntGeniusSettings,
   GetTunerGeniusSettings, SaveTunerGeniusSettings,
   GetPSUSettings, SavePSUSettings,
@@ -47,7 +48,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,
@@ -68,6 +71,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';
@@ -83,6 +87,7 @@ 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;
@@ -167,7 +172,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
@@ -201,6 +206,7 @@ type SectionId =
   | 'database'
   | 'autostart'
   | 'uscounties'
+  | 'databases'
   | 'awards'
   | 'cat'
   | 'ftx'
@@ -318,6 +324,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,
   },
@@ -333,6 +348,7 @@ const SECTION_KEY: Partial<Record<SectionId, string>> = {
   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',
@@ -626,6 +642,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>
         ))}
@@ -1028,15 +1057,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', '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,
@@ -1045,42 +1075,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>
-              {options.map((o) => <SelectItem key={o.value} value={o.value}>{o.label}</SelectItem>)}
-            </SelectContent>
-          </Select>
-        </label>
-        <label className="flex flex-col gap-1 text-xs">
-          <span className="text-muted-foreground">{t('settings.rightPane')}</span>
-          <Select value={right} onValueChange={(v) => pick('right', v)}>
               <SelectTrigger className="h-8 text-xs"><SelectValue /></SelectTrigger>
               <SelectContent>
+                {/* Only the third and fourth may be empty: the first two ARE the
+                    Main view, and a tab with nothing in it is not a layout. */}
+                {sd.canBeEmpty && <SelectItem value={PANE_NONE}>{t('settings.paneNone')}</SelectItem>}
                 {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>
   );
 }
@@ -1220,6 +1285,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.
 //
@@ -1530,6 +1643,9 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   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.
@@ -1679,6 +1795,75 @@ 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) : '—');
+  // Binary units, one decimal, because the point of showing a size here is to
+  // compare two of them: "412.7 MB → 38.4 MB" says what a bare byte count does not.
+  const fmtBytes = (n: number) => {
+    if (!n || n < 0) return '—';
+    const u = ['B', 'KB', 'MB', 'GB'];
+    let i = 0;
+    let v = n;
+    while (v >= 1024 && i < u.length - 1) { v /= 1024; i++; }
+    return `${i === 0 ? v : v.toFixed(1)} ${u[i]}`;
+  };
+  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 })); }
@@ -2878,27 +3063,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' && (
@@ -3375,7 +3544,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
@@ -3389,10 +3561,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>
@@ -3400,7 +3572,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'}
@@ -3418,12 +3590,26 @@ 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
+                    not the Select the other serial devices use: the port for a
+                    USB adapter that is currently unplugged does not appear in
+                    the list, and refusing to accept it typed means the antenna
+                    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 ?? ''}
-                  onChange={(e) => setUltrabeam((s) => ({ ...s, com: e.target.value }))}
+                    options={wkPorts}
+                    allowFreeText
+                    commitOnType
+                    showToggle
                     placeholder="COM3"
-                  className="font-mono"
+                    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>
@@ -4610,7 +4796,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
         {t(`ftx.c_${k}`)}
       </label>
     );
-    const KEYS: (keyof AutoCallCriteria)[] = ['dxcc', 'band', 'mode', 'slot', 'grid', 'county', 'pota', 'pfx'];
+    const KEYS: (keyof AutoCallCriteria)[] = ['dxcc', 'bandmode', 'band', 'mode', 'slot', 'grid', 'county', 'pota', 'pfx'];
     return (
       <>
         <SectionHeader title={t('sec.ftx')} hint={t('ftx.hint')} />
@@ -4677,6 +4863,14 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
 
   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
@@ -4769,6 +4963,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>,{' '}
@@ -4857,7 +5079,6 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                   </SelectContent>
                 </Select>
               </div>
-              <p className="text-[11px] text-muted-foreground leading-relaxed">{t('gsc.hint')}</p>
             </div>
           </div>
 
@@ -4919,7 +5140,6 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                   />
                   <span className="text-xs text-muted-foreground">km</span>
                 </div>
-                <p className="text-[11px] text-muted-foreground leading-relaxed">{t('bo.nearKmHint')}</p>
 
                 {/* A live count, because a feed that is connected but silent looks
                     exactly like one that is broken until a number moves. */}
@@ -4962,7 +5182,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>
 
@@ -5959,6 +6178,24 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   }
 
   function DatabasePanel() {
+    // Compacting: which database is running, and what the last one saved.
+    // SQLite frees pages inside the file and never shrinks it, so this is the
+    // only thing that gives the disk space back after a large delete.
+    const [compacting, setCompacting] = useState('');
+    const [compactMsg, setCompactMsg] = useState<Record<string, string>>({});
+    function compact(target: 'settings' | 'logbook') {
+      setCompacting(target);
+      setCompactMsg((m) => ({ ...m, [target]: '' }));
+      CompactDatabase(target)
+        .then((r: any) => {
+          const msg = r?.backend === 'mysql'
+            ? t('db.compactMysqlDone')
+            : t('db.compactDone', { before: fmtBytes(r?.before ?? 0), after: fmtBytes(r?.after ?? 0) });
+          setCompactMsg((m) => ({ ...m, [target]: msg }));
+        })
+        .catch((e: any) => setErr(String(e?.message ?? e)))
+        .finally(() => setCompacting(''));
+    }
     async function refreshDb() { try { setDbSettings(await GetDatabaseSettings() as any); } catch {} }
     async function refreshBackend() { try { setBackendStatus(await GetDBBackendStatus() as any); } catch {} }
     // The chosen file is persisted (config.json) the moment it's picked; dbMsg
@@ -6078,9 +6315,13 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             <Button variant="outline" size="sm" onClick={renameDb} title={t('db.renameTip')}><Pencil className="size-3.5" /> {t('db.rename')}</Button>
             {/* Pushed right: these two act on the file that is already there,
                 while the four on the left change WHICH file is in use. */}
-            <Button variant="outline" size="sm" className="ml-auto" onClick={revealFolder}><FolderOpen className="size-3.5" /> {t('db.openFolder')}</Button>
+            <Button variant="outline" size="sm" className="ml-auto" onClick={() => compact('settings')} disabled={compacting !== ''}>
+              {compacting === 'settings' ? <Loader2 className="size-3.5 animate-spin" /> : <Minimize2 className="size-3.5" />} {t('db.compact')}
+            </Button>
+            <Button variant="outline" size="sm" onClick={revealFolder}><FolderOpen className="size-3.5" /> {t('db.openFolder')}</Button>
             {dbSettings.is_custom && <Button variant="ghost" size="sm" onClick={resetDefault}>{t('db.resetDefault')}</Button>}
           </div>
+          {compactMsg.settings && <p className="text-[11px] text-success">{compactMsg.settings}</p>}
           {/* The DB pointer is only read at startup, so offer the restart inline. */}
           {dbMsg && (
             <div className="text-[11px] text-success space-y-1 pt-1">
@@ -6143,8 +6384,12 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             <Button variant="outline" size="sm" onClick={newLogbook}><Plus className="size-3.5" /> {t('db.newDb')}</Button>
             <Button variant="outline" size="sm" onClick={openLogbook}><FolderOpen className="size-3.5" /> {t('db.openExisting')}</Button>
             <Button variant="outline" size="sm" onClick={renameLogbook} title={t('db.renameLogbookTip')}><Pencil className="size-3.5" /> {t('db.renameLogbook')}</Button>
+            <Button variant="outline" size="sm" className="ml-auto" onClick={() => compact('logbook')} disabled={compacting !== ''}>
+              {compacting === 'logbook' ? <Loader2 className="size-3.5 animate-spin" /> : <Minimize2 className="size-3.5" />} {t('db.compact')}
+            </Button>
             {mysqlCfg.sqlite_path && <Button variant="ghost" size="sm" onClick={useLocalLogbook}>{t('db.useDefaultLogbook')}</Button>}
           </div>
+          {compactMsg.logbook && <p className="text-[11px] text-success">{compactMsg.logbook}</p>}
         </div>
         )}
 
@@ -6169,8 +6414,17 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
               {t('db.testCreate')}
             </Button>
             <Button size="sm" className="h-8" onClick={connectMysql}>{t('db.connectUse')}</Button>
+            {/* Compacting a shared logbook is OPTIMIZE TABLE, and it rebuilds the
+                table with everyone else waiting on it — hence the warning, and
+                hence its place here rather than beside the connection buttons of
+                a file only this operator uses. */}
+            <Button variant="outline" size="sm" className="h-8 ml-auto" title={t('db.compactMysqlWarn')}
+              onClick={() => compact('logbook')} disabled={compacting !== ''}>
+              {compacting === 'logbook' ? <Loader2 className="size-3.5 animate-spin" /> : <Minimize2 className="size-3.5" />} {t('db.compact')}
+            </Button>
             <span className="text-[11px] text-muted-foreground">{mysqlMsg}</span>
           </div>
+          {compactMsg.logbook && <p className="text-[11px] text-success">{compactMsg.logbook}</p>}
         </div>
         )}
 
@@ -6823,6 +7077,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,
@@ -6849,8 +7238,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,
@@ -6859,7 +7249,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/qsl/EditorPanel.tsx

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

frontend/src/components/qsl/qslTypes.ts

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

frontend/src/components/ui/combobox.tsx

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

frontend/src/lib/autocall.ts

@@ -9,13 +9,17 @@
 
 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
-  sota: boolean;      // summit never worked (spot-tagged only)
+  // 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
 };
 
@@ -34,8 +38,8 @@ export type AutoCallSettings = {
 };
 
 export const emptyCriteria: AutoCallCriteria = {
-  dxcc: false, band: false, mode: false, slot: false,
+  dxcc: false, bandmode: false, band: false, mode: false, slot: false,
-  grid: false, county: false, pota: false, sota: false, pfx: false,
+  grid: false, county: false, pota: false, pfx: false,
 };
 
 export const defaultAutoCall: AutoCallSettings = {
@@ -98,6 +102,10 @@ function anyCriterion(c: AutoCallCriteria): 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;

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

@@ -41,13 +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.26.0';
+export const APP_VERSION = '0.26.4';
 
 // Author / credits, shown in Help -> About.
 export const APP_AUTHOR = 'F4BPO';

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

@@ -89,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>>;
@@ -115,8 +119,12 @@ 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 CompactDatabase(arg1:string):Promise<main.CompactResult>;
+
 export function ComputeQSOAwardRefs(arg1:qso.QSO):Promise<Array<main.QSOAwardRef>>;
 
 export function ComputeStationInfo(arg1:string,arg2:string):Promise<main.StationInfoComputed>;
@@ -361,6 +369,8 @@ 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>;
@@ -455,6 +465,8 @@ 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>;
@@ -535,6 +547,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>;
@@ -863,8 +877,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>;
@@ -897,6 +915,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>;
@@ -959,6 +979,8 @@ 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>;
@@ -995,6 +1017,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>;

frontend/wailsjs/go/main/App.js

@@ -118,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']();
 }
@@ -126,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']();
 }
@@ -170,10 +178,18 @@ export function ClearLookupCache() {
   return window['go']['main']['App']['ClearLookupCache']();
 }
 
+export function CloseAutostartPrograms() {
+  return window['go']['main']['App']['CloseAutostartPrograms']();
+}
+
 export function ClusterSpotStatuses(arg1) {
   return window['go']['main']['App']['ClusterSpotStatuses'](arg1);
 }
 
+export function CompactDatabase(arg1) {
+  return window['go']['main']['App']['CompactDatabase'](arg1);
+}
+
 export function ComputeQSOAwardRefs(arg1) {
   return window['go']['main']['App']['ComputeQSOAwardRefs'](arg1);
 }
@@ -662,6 +678,10 @@ 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']();
 }
@@ -850,6 +870,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']();
 }
@@ -1010,6 +1034,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']();
 }
@@ -1666,10 +1694,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']();
 }
@@ -1734,6 +1770,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']();
 }
@@ -1858,6 +1898,10 @@ 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);
 }
@@ -1930,6 +1974,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);
 }

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;
@@ -2257,6 +2295,24 @@ export namespace main {
 	        this.count = source["count"];
 	    }
 	}
+	export class CompactResult {
+	    path: string;
+	    backend: string;
+	    before: number;
+	    after: number;
+	
+	    static createFrom(source: any = {}) {
+	        return new CompactResult(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.path = source["path"];
+	        this.backend = source["backend"];
+	        this.before = source["before"];
+	        this.after = source["after"];
+	    }
+	}
 	export class ContestBandRow {
 	    band: string;
 	    count: number;
@@ -2477,6 +2533,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;
@@ -3301,6 +3377,8 @@ export namespace main {
 	    style: string;
 	    intensity: number;
 	    bandmap_lotw: boolean;
+	    recent_zebra?: string;
+	    recent_zebra_color?: string;
 	    configured: boolean;
 	    rules: RowColorRule[];
 	
@@ -3314,6 +3392,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);
 	    }
@@ -3380,6 +3460,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;
@@ -4988,6 +5114,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;
@@ -5038,6 +5168,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"];

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)
+		}
 	}
 }
 
@@ -271,7 +293,15 @@ type SpotInfo struct {
 	FreqHz   int64
 	Callsign string
 	Mode     string
+	// Color is the TEXT colour of the callsign on the panadapter, BackgroundColor
+	// the plate behind it. Both are #AARRGGBB — the alpha channel first, which is
+	// SmartSDR's order and not the web's.
+	//
+	// Two colours rather than one because that is what makes a spot readable at a
+	// glance on a busy waterfall: the fill carries the status and the text stays
+	// legible against it. An empty background leaves the radio's own default.
 	Color           string
+	BackgroundColor string
 	Comment         string
 	LifetimeSec     int // panadapter display seconds before auto-removal (0 = backend default)
 }
@@ -453,6 +483,9 @@ type FlexController interface {
 	SetRXAntenna(string) error
 	SetTXAntenna(string) error
 	SetActiveSlice(int) error // focus slice idx so commands target it
+	// ZoomPan sets the visible width (MHz) of the active slice's panadapter and
+	// keeps freqMHz inside it, re-centring when it must. See Flex.ZoomPan.
+	ZoomPan(bandwidthMHz, freqMHz float64, centre bool) error
 	SetTXSlice(int) error // make slice idx the transmitter (tx=1)
 	SetSplit(bool) error
 	SetNB(bool) 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)
+	spotFreq        map[int]int64  // spot index → Hz, so a click can report where it was (the trigger message carries only the index)
+	pendingSpotFreq map[int]int64  // seq → Hz, paired with pendingSpot
+	// panWindow is what each panadapter is currently showing, from its own status
+	// (centre and width, both MHz). Tracked because a zoom that only changes the
+	// WIDTH keeps the old centre, and the frequency the operator just clicked can
+	// end up outside the new window — see ZoomPan.
+	panWindow map[string]panView
+
 	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/db/db.go

@@ -147,7 +147,17 @@ func NowISO() string { return time.Now().UTC().Format("2006-01-02T15:04:05.000Z"
 
 // Open opens (and creates if needed) the SQLite database at the given path,
 // enables performance PRAGMAs, and applies embedded migrations.
-func Open(path string) (*sql.DB, error) {
+//
+// This is the SETTINGS database, which gets the full schema — see roles.go for
+// why. Use OpenLogbook for a database that holds contacts only.
+func Open(path string) (*sql.DB, error) { return open(path, RoleAll) }
+
+// OpenLogbook opens a SQLite logbook: the qso table and nothing from the
+// settings side, and any unused settings tables an earlier version left in it
+// are dropped if they are empty.
+func OpenLogbook(path string) (*sql.DB, error) { return open(path, RoleLogbook) }
+
+func open(path string, role Role) (*sql.DB, error) {
 	// Escape only the two characters a path could contain that the DSN would
 	// otherwise read as its query/fragment delimiters. Windows separators
 	// (\\ and the drive ':') are left intact — url.PathEscape would mangle them.
@@ -162,10 +172,12 @@ func Open(path string) (*sql.DB, error) {
 		return nil, fmt.Errorf("ping sqlite: %w", err)
 	}
 	Dialect = "sqlite"
-	if err := migrate(conn, nil, path, filepath.Base(path)); err != nil {
+	label := filepath.Base(path)
+	if err := migrate(conn, nil, path, label, role); err != nil {
 		_ = conn.Close()
 		return nil, err
 	}
+	pruneForeignTables(conn, role, label)
 	return conn, nil
 }
 
@@ -236,7 +248,7 @@ func backupBeforeRewrite(conn *sql.DB, dbPath, migration string) {
 // interleaved migration runs in one log were indistinguishable — an operator
 // reported "migrations are very slow" and the lines gave no way to tell one
 // database migrated three times from three databases migrated once.
-func migrate(conn *sql.DB, translate func(string) string, dbPath, label string) error {
+func migrate(conn *sql.DB, translate func(string) string, dbPath, label string, role Role) error {
 	// A non-nil translator means this is the MySQL connection (use the
 	// per-statement, FK-aware path); nil means a SQLite connection. This is
 	// determined by the caller's argument, NOT the global Dialect, so the
@@ -331,10 +343,19 @@ func migrate(conn *sql.DB, translate func(string) string, dbPath, label string)
 		if err != nil {
 			return fmt.Errorf("begin tx for %s: %w", name, err)
 		}
-		if _, err := tx.Exec(sqlText); err != nil {
+		// Statement by statement rather than one Exec of the whole file: the role
+		// filter works per statement, and a settings-table statement must not
+		// reach a logbook database (see roles.go). Still one transaction, so the
+		// file remains atomic.
+		for _, stmt := range splitStatements(sqlText) {
+			if !keepForRole(stmt, role) {
+				continue
+			}
+			if _, err := tx.Exec(stmt); err != nil {
 				_ = tx.Rollback()
 				return fmt.Errorf("apply migration %s: %w", name, err)
 			}
+		}
 		if _, err := tx.Exec(`INSERT INTO schema_migrations(name) VALUES(?)`, name); err != nil {
 			_ = tx.Rollback()
 			return fmt.Errorf("record migration %s: %w", name, err)

internal/db/mysql.go

@@ -252,7 +252,7 @@ func OpenMySQL(c MySQLConfig) (*sql.DB, error) {
 			return nil, rerr
 		}
 		// Then apply only the migrations it's missing.
-		err = migrate(conn, mysqlDDL, "", "mysql:"+name)
+		err = migrate(conn, mysqlDDL, "", "mysql:"+name, RoleLogbook)
 	}
 	if err != nil {
 		_ = conn.Close()
@@ -343,7 +343,9 @@ func applyMySQLBaseline(conn *sql.DB) error {
 	// database. Labelled so its (fast) migration lines are not mistaken for a
 	// real database being migrated — in one operator's log this pass sat between
 	// two slow MySQL runs and looked like a third database.
-	if err := migrate(mem, nil, "", "baseline:memory"); err != nil {
+	// RoleLogbook: the baseline defines what a FRESH shared logbook gets, and a
+	// logbook has no business holding settings or station profiles.
+	if err := migrate(mem, nil, "", "baseline:memory", RoleLogbook); err != nil {
 		return fmt.Errorf("build baseline schema: %w", err)
 	}
 

internal/db/roles.go

@@ -0,0 +1,305 @@
+package db
+
+// Which tables belong in which database.
+//
+// OpsLog keeps settings and contacts apart — a settings database (settings.db /
+// opslog.db) and a logbook (logbook.db, a per-profile file, or a shared MySQL).
+// The SEPARATION of the data was real from the start; the SCHEMA was not: every
+// target got the whole migration set, so a shared MySQL logbook grew a settings
+// table and a station_profiles table that nothing ever wrote to. An operator
+// inspecting the server with phpMyAdmin had no way to tell which copy was
+// authoritative — a fair question, and the reason for this file.
+//
+// So a migration statement is now filtered by the ROLE of the database it is
+// being applied to. Only two rules, and both fail safe:
+//
+//   - RoleAll (the settings database) applies everything, exactly as before.
+//     It has to: a legacy single-file installation holds its QSOs there, and it
+//     still serves as the logbook when no separate one could be created.
+//   - RoleLogbook applies everything EXCEPT statements aimed at a table on the
+//     settings side. A table this file does not know about is kept, in both —
+//     an unrecognised future table behaves as it does today rather than
+//     silently going missing from one database.
+
+import (
+	"database/sql"
+	"fmt"
+	"strings"
+)
+
+// Role is what a database is for.
+type Role int
+
+const (
+	// RoleAll applies every migration statement. The settings database.
+	RoleAll Role = iota
+	// RoleLogbook applies only what the contacts need.
+	RoleLogbook
+)
+
+// settingsTables are owned by the settings database. Every one of them is
+// reached through the settings connection in app.go — grep NewRepo/NewStore
+// there: only qso.NewRepo is given the logbook connection.
+//
+// Ordered children-before-parents, because pruneForeignTables drops them in
+// this order and operating_antennas has a foreign key into operating_stations.
+var settingsTables = []string{
+	"operating_antenna_bands",
+	"operating_antennas",
+	"operating_antennas_new",
+	"operating_stations",
+	"operating_stations_new",
+	"award_references",
+	"qsl_templates",
+	"cluster_servers",
+	"integrations_udp",
+	"callsign_cache",
+	"station_profiles",
+	"settings",
+}
+
+// keepForRole reports whether one migration statement applies to this role.
+func keepForRole(stmt string, role Role) bool {
+	if role == RoleAll {
+		return true
+	}
+	t := stmtTable(stmt)
+	if t == "" {
+		return true // not a table statement (PRAGMA, or a shape we don't parse)
+	}
+	for _, s := range settingsTables {
+		if t == s {
+			return false
+		}
+	}
+	return true
+}
+
+// stmtTable returns the lower-cased table a statement acts on, or "".
+//
+// Deliberately literal: it recognises the handful of statement shapes the
+// migrations actually use, and returns "" for anything else — which keeps the
+// statement. Guessing would be the only way to drop something by accident.
+func stmtTable(stmt string) string {
+	f := strings.Fields(strings.ToLower(stmt))
+	at := func(i int) string {
+		if i < len(f) {
+			return f[i]
+		}
+		return ""
+	}
+	// Skip the leading keywords that carry no table name.
+	switch {
+	case at(0) == "create" || at(0) == "drop":
+		// CREATE [UNIQUE] INDEX <name> ON <table> …
+		// CREATE TABLE [IF NOT EXISTS] <table> …  /  DROP TABLE [IF EXISTS] <t>
+		//
+		// The "ON" search is confined to an INDEX statement on purpose: a CREATE
+		// TABLE body is full of "ON DELETE CASCADE", and scanning the whole
+		// statement for "on" once made every foreign-keyed table report itself as
+		// a table named "delete" — unrecognised, therefore kept, therefore created
+		// in a logbook that had no use for it.
+		if at(1) == "index" || (at(1) == "unique" && at(2) == "index") {
+			for i, w := range f {
+				if w == "on" && i+1 < len(f) {
+					return cleanIdent(f[i+1])
+				}
+			}
+		}
+		i := 1
+		for at(i) == "unique" || at(i) == "table" || at(i) == "index" ||
+			at(i) == "if" || at(i) == "not" || at(i) == "exists" || at(i) == "view" {
+			i++
+		}
+		return cleanIdent(at(i))
+	case at(0) == "alter":
+		return cleanIdent(at(2)) // ALTER TABLE <table> …
+	case at(0) == "insert" || at(0) == "replace":
+		i := 1
+		for at(i) == "or" || at(i) == "ignore" || at(i) == "into" || at(i) == "replace" {
+			i++
+		}
+		return cleanIdent(at(i))
+	case at(0) == "update":
+		return cleanIdent(at(1))
+	case at(0) == "delete":
+		return cleanIdent(at(2)) // DELETE FROM <table>
+	}
+	return ""
+}
+
+// cleanIdent strips quoting and anything glued to the name — "qso(id)" from an
+// index, `settings` from the MySQL translation, "qso;" from a split statement.
+func cleanIdent(s string) string {
+	s = strings.TrimSpace(s)
+	if i := strings.IndexAny(s, "(;"); i >= 0 {
+		s = s[:i]
+	}
+	return strings.Trim(s, "`\"'[]")
+}
+
+// pruneForeignTables removes settings tables from a logbook database that an
+// earlier version created there.
+//
+// ONLY WHEN EMPTY, without exception. A table with rows in it is data, whatever
+// this file thinks it is for: a profile pointing at a legacy combined database
+// as its logbook is a real configuration, and dropping its profiles because the
+// schema now says they belong elsewhere would be destroying a log-keeping
+// operator's work on the strength of a tidiness rule.
+//
+// Best effort throughout: a logbook the user cannot drop tables in (a restricted
+// MySQL grant) keeps its empty tables and works exactly as it does today.
+func pruneForeignTables(conn *sql.DB, role Role, label string) {
+	if role != RoleLogbook || conn == nil {
+		return
+	}
+	dropped := 0
+	for _, t := range settingsTables {
+		var n int
+		// A missing table errors here, which is the "nothing to do" answer.
+		if err := conn.QueryRow(`SELECT COUNT(*) FROM ` + quoteIdent(t)).Scan(&n); err != nil {
+			continue
+		}
+		if n != 0 {
+			logf("db[%s]: keeping %s — it has %d row(s)", label, t, n)
+			continue
+		}
+		if _, err := conn.Exec(`DROP TABLE ` + quoteIdent(t)); err != nil {
+			logf("db[%s]: could not drop unused %s: %v", label, t, err)
+			continue
+		}
+		dropped++
+	}
+	if dropped > 0 {
+		logf("db[%s]: dropped %d unused settings table(s) — this database holds contacts only", label, dropped)
+	}
+}
+
+// quoteIdent quotes one of OUR OWN table names for either dialect. Backticks
+// work in MySQL and in SQLite alike, which is why the migrations use them.
+func quoteIdent(s string) string { return "`" + s + "`" }
+
+// DropRedundantSettingsTables removes the settings tables from a logbook
+// database EVEN IF THEY HAVE ROWS.
+//
+// Reserved for the one case where those rows are provably a stale duplicate:
+// the logbook file was seeded by VACUUM INTO from the old combined database
+// (see the split at startup), so every profile and every setting in it is a
+// copy of what the settings database still holds and is authoritative for.
+// Nothing reads them — the settings connection is a different file entirely —
+// and leaving them behind is what made the two databases look interchangeable.
+//
+// The caller must have established that authority. pruneForeignTables is the
+// safe default for every other situation.
+func DropRedundantSettingsTables(conn *sql.DB, label string) {
+	if conn == nil {
+		return
+	}
+	dropped := 0
+	for _, t := range settingsTables {
+		if err := conn.QueryRow(`SELECT COUNT(*) FROM ` + quoteIdent(t)).Scan(new(int)); err != nil {
+			continue // not there: nothing to do
+		}
+		if _, err := conn.Exec(`DROP TABLE ` + quoteIdent(t)); err != nil {
+			logf("db[%s]: could not drop redundant %s: %v", label, t, err)
+			continue
+		}
+		dropped++
+	}
+	if dropped > 0 {
+		logf("db[%s]: dropped %d settings table(s) copied by the logbook split — the settings database keeps the originals", label, dropped)
+	}
+}
+
+// EnsureQSOTable recreates the contacts table if it is missing.
+//
+// It exists so dropping an EMPTY qso table from the settings database is a
+// reversible act. The settings database can still be pressed into service as the
+// logbook — that is the fallback when no separate logbook file can be created —
+// and the migrations that would have built the table are recorded as applied, so
+// nothing would ever build it again. This does, from the same migrations, on
+// demand.
+//
+// The schema is derived rather than duplicated: the migrations are replayed on a
+// throwaway in-memory SQLite whose sqlite_master then holds the FINAL shape of
+// the table with every ALTER-added column folded in. Same trick as the MySQL
+// baseline, and for the same reason — there is no second schema to drift.
+//
+// SQLite only: the shared MySQL logbook is never the settings database.
+func EnsureQSOTable(conn *sql.DB) error {
+	if conn == nil {
+		return nil
+	}
+	if err := conn.QueryRow(`SELECT COUNT(*) FROM qso`).Scan(new(int)); err == nil {
+		return nil // already there
+	}
+	stmts, err := qsoSchemaDDL()
+	if err != nil {
+		return err
+	}
+	for _, st := range stmts {
+		if _, err := conn.Exec(st); err != nil {
+			return fmt.Errorf("recreate qso table: %w", err)
+		}
+	}
+	logf("db: recreated the qso table — this database is being used as the logbook")
+	return nil
+}
+
+// qsoSchemaDDL returns the CREATE statements for the qso table and its indexes,
+// in that order.
+func qsoSchemaDDL() ([]string, error) {
+	mem, err := sql.Open("sqlite", "file:opslog_qsoschema?mode=memory&cache=shared")
+	if err != nil {
+		return nil, fmt.Errorf("open schema sqlite: %w", err)
+	}
+	defer mem.Close()
+	if err := migrate(mem, nil, "", "qso-schema:memory", RoleLogbook); err != nil {
+		return nil, fmt.Errorf("build qso schema: %w", err)
+	}
+	rows, err := mem.Query(`SELECT type, sql FROM sqlite_master
+	                        WHERE sql IS NOT NULL AND tbl_name = 'qso'`)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var tables, indexes []string
+	for rows.Next() {
+		var typ, s string
+		if err := rows.Scan(&typ, &s); err != nil {
+			return nil, err
+		}
+		if typ == "table" {
+			tables = append(tables, s)
+		} else {
+			indexes = append(indexes, s)
+		}
+	}
+	if len(tables) == 0 {
+		return nil, fmt.Errorf("qso table not found in the derived schema")
+	}
+	return append(tables, indexes...), rows.Err()
+}
+
+// DropEmptyQSOTable removes the contacts table from a database that is not the
+// logbook — the settings database, once its QSOs live in their own file.
+//
+// Only when empty, and reversible: EnsureQSOTable builds it again the moment
+// this database is asked to serve as the logbook.
+func DropEmptyQSOTable(conn *sql.DB, label string) {
+	if conn == nil {
+		return
+	}
+	var n int
+	if err := conn.QueryRow(`SELECT COUNT(*) FROM qso`).Scan(&n); err != nil {
+		return // not there: nothing to do
+	}
+	if n != 0 {
+		return // contacts: this table is data, whatever the schema says
+	}
+	if _, err := conn.Exec(`DROP TABLE qso`); err != nil {
+		logf("db[%s]: could not drop the unused qso table: %v", label, err)
+		return
+	}
+	logf("db[%s]: dropped the unused qso table — the contacts live in their own database", label)
+}

internal/db/roles_test.go

@@ -0,0 +1,215 @@
+package db
+
+import (
+	"path/filepath"
+	"sort"
+	"testing"
+)
+
+func TestStmtTable(t *testing.T) {
+	cases := map[string]string{
+		"CREATE TABLE station_profiles (\n id INTEGER PRIMARY KEY)":    "station_profiles",
+		"CREATE TABLE IF NOT EXISTS settings (`key` TEXT PRIMARY KEY)": "settings",
+		"CREATE UNIQUE INDEX idx_qso_uid ON qso(sync_uid)":             "qso",
+		"CREATE INDEX idx_ref ON award_references (award_code)":        "award_references",
+		"ALTER TABLE qso ADD COLUMN ant_path TEXT NOT NULL DEFAULT ''": "qso",
+		"ALTER TABLE `station_profiles` ADD COLUMN my_cq_zone TEXT":    "station_profiles",
+		"INSERT INTO settings(`key`, value) VALUES('x','y')":           "settings",
+		"INSERT OR IGNORE INTO cluster_servers(name) VALUES('dxc')":    "cluster_servers",
+		"UPDATE qso SET callsign = UPPER(callsign)":                    "qso",
+		"DELETE FROM operating_antennas WHERE station_id IS NULL":      "operating_antennas",
+		"DROP TABLE IF EXISTS operating_stations_new":                  "operating_stations_new",
+		"PRAGMA foreign_keys = off":                                    "",
+		"":                                                             "",
+	}
+	for in, want := range cases {
+		if got := stmtTable(in); got != want {
+			t.Errorf("stmtTable(%.40q) = %q, want %q", in, got, want)
+		}
+	}
+}
+
+func TestKeepForRole(t *testing.T) {
+	// The settings database takes everything, exactly as before this existed.
+	for _, s := range []string{"CREATE TABLE settings (a TEXT)", "CREATE TABLE qso (a TEXT)"} {
+		if !keepForRole(s, RoleAll) {
+			t.Fatalf("RoleAll dropped %q", s)
+		}
+	}
+	// A logbook takes the contacts and refuses the settings side.
+	if !keepForRole("CREATE INDEX i ON qso(callsign)", RoleLogbook) {
+		t.Fatal("logbook dropped a qso statement")
+	}
+	if keepForRole("CREATE TABLE station_profiles (id INTEGER)", RoleLogbook) {
+		t.Fatal("logbook accepted station_profiles")
+	}
+	// An unrecognised statement — a future table, a PRAGMA — is kept, so a new
+	// migration behaves as it does today rather than vanishing from one database.
+	if !keepForRole("CREATE TABLE something_new (id INTEGER)", RoleLogbook) {
+		t.Fatal("logbook dropped an unknown table")
+	}
+	if !keepForRole("PRAGMA foreign_keys = off", RoleLogbook) {
+		t.Fatal("logbook dropped a PRAGMA")
+	}
+}
+
+// tablesIn lists the tables of an open database.
+func tablesIn(t *testing.T, path string) []string {
+	t.Helper()
+	conn, err := Open(path) // RoleAll: opening must not change what is there
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer conn.Close()
+	rows, err := conn.Query(`SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer rows.Close()
+	var out []string
+	for rows.Next() {
+		var n string
+		if err := rows.Scan(&n); err != nil {
+			t.Fatal(err)
+		}
+		out = append(out, n)
+	}
+	sort.Strings(out)
+	return out
+}
+
+// A logbook opened through OpenLogbook holds the contacts and nothing else.
+func TestOpenLogbookSchema(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "logbook.db")
+	conn, err := OpenLogbook(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var n int
+	// The one table that matters has to be there and has to be usable.
+	if err := conn.QueryRow(`SELECT COUNT(*) FROM qso`).Scan(&n); err != nil {
+		t.Fatalf("qso table unusable: %v", err)
+	}
+	for _, forbidden := range settingsTables {
+		if err := conn.QueryRow(`SELECT COUNT(*) FROM ` + quoteIdent(forbidden)).Scan(&n); err == nil {
+			t.Errorf("%s was created in a logbook database", forbidden)
+		}
+	}
+	conn.Close()
+
+	// Reopening as a logbook is idempotent, and the migrations already recorded
+	// as applied must not be re-run into a half-schema.
+	conn2, err := OpenLogbook(path)
+	if err != nil {
+		t.Fatalf("reopen: %v", err)
+	}
+	if err := conn2.QueryRow(`SELECT COUNT(*) FROM qso`).Scan(&n); err != nil {
+		t.Fatalf("qso lost on reopen: %v", err)
+	}
+	conn2.Close()
+}
+
+// An existing logbook that an older version filled with the whole schema loses
+// the unused tables — and keeps any that hold rows.
+func TestPruneKeepsNonEmptyTables(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "legacy.db")
+	conn, err := Open(path) // the old behaviour: every table everywhere
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := conn.Exec(`INSERT INTO station_profiles(name) VALUES('Home')`); err != nil {
+		t.Fatal(err)
+	}
+	conn.Close()
+
+	if got := tablesIn(t, path); len(got) < 10 {
+		t.Fatalf("expected a full legacy schema, got %v", got)
+	}
+
+	conn, err = OpenLogbook(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer conn.Close()
+	var n int
+	// Rows are data: this one stays, whatever the schema says it is for.
+	if err := conn.QueryRow(`SELECT COUNT(*) FROM station_profiles`).Scan(&n); err != nil || n != 1 {
+		t.Fatalf("station_profiles dropped with a row in it (err=%v n=%d)", err, n)
+	}
+	// The empty ones go.
+	if err := conn.QueryRow(`SELECT COUNT(*) FROM settings`).Scan(&n); err == nil {
+		t.Error("empty settings table survived in a logbook")
+	}
+	// And the contacts are untouched throughout.
+	if err := conn.QueryRow(`SELECT COUNT(*) FROM qso`).Scan(&n); err != nil {
+		t.Fatalf("qso table lost: %v", err)
+	}
+}
+
+// A CREATE TABLE body is full of "ON DELETE CASCADE": the index rule must not
+// read it as a table name, or the table goes unrecognised and gets created in
+// every database.
+func TestStmtTableForeignKeyBody(t *testing.T) {
+	stmt := `CREATE TABLE operating_stations (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    profile_id INTEGER NOT NULL,
+    FOREIGN KEY (profile_id) REFERENCES station_profiles(id) ON DELETE CASCADE
+)`
+	if got := stmtTable(stmt); got != "operating_stations" {
+		t.Fatalf("got %q", got)
+	}
+	if keepForRole(stmt, RoleLogbook) {
+		t.Fatal("a settings table reached a logbook database")
+	}
+}
+
+// The settings database loses its unused qso table — and gets it back, in full,
+// the moment it has to serve as the logbook again.
+func TestDropAndRecreateQSOTable(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "settings.db")
+	conn, err := Open(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer conn.Close()
+
+	// A contact in it is data: the table must survive.
+	if _, err := conn.Exec(`INSERT INTO qso(callsign, qso_date, band, mode)
+	                        VALUES('F4BPO','2026-01-01T12:00:00Z','20m','SSB')`); err != nil {
+		t.Fatal(err)
+	}
+	DropEmptyQSOTable(conn, "settings")
+	var n int
+	if err := conn.QueryRow(`SELECT COUNT(*) FROM qso`).Scan(&n); err != nil || n != 1 {
+		t.Fatalf("dropped a qso table holding a contact (err=%v n=%d)", err, n)
+	}
+
+	// Empty, so it goes.
+	if _, err := conn.Exec(`DELETE FROM qso`); err != nil {
+		t.Fatal(err)
+	}
+	DropEmptyQSOTable(conn, "settings")
+	if err := conn.QueryRow(`SELECT COUNT(*) FROM qso`).Scan(&n); err == nil {
+		t.Fatal("empty qso table survived")
+	}
+
+	// And comes back complete when this database is pressed into service as the
+	// logbook — a late column and an index included, not just a bare table.
+	if err := EnsureQSOTable(conn); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := conn.Exec(`INSERT INTO qso(callsign, qso_date, band, mode, ant_path, sync_uid)
+	                        VALUES('F1TRF','2026-01-02T13:00:00Z','40m','CW','S','uid-1')`); err != nil {
+		t.Fatalf("recreated qso table is incomplete: %v", err)
+	}
+	if err := conn.QueryRow(`SELECT COUNT(*) FROM qso`).Scan(&n); err != nil || n != 1 {
+		t.Fatalf("recreated table unusable (err=%v n=%d)", err, n)
+	}
+	// Idempotent: a second call on a live table must not touch it.
+	if err := EnsureQSOTable(conn); err != nil {
+		t.Fatal(err)
+	}
+	if err := conn.QueryRow(`SELECT COUNT(*) FROM qso`).Scan(&n); err != nil || n != 1 {
+		t.Fatalf("EnsureQSOTable disturbed an existing table (err=%v n=%d)", err, n)
+	}
+}

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

@@ -223,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
@@ -663,10 +672,43 @@ func (s *Server) handle(pkt []byte, remote *net.UDPAddr) {
 	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 {
@@ -735,7 +777,11 @@ type Manager struct {
 func NewManager(repo *Repo) *Manager {
 	return &Manager{
 		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{},
 	}
 }

internal/integrations/udp/wsjt.go

@@ -372,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, ""
 	}
@@ -381,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
@@ -411,11 +432,13 @@ func wsjtSender(message string) (call string, isCQ bool, grid string) {
 	//
 	// 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 && looksLikeCall(f[1]) {
+	if len(f) >= 2 {
+		if c := unbracket(f[1]); looksLikeCall(c) {
 			if len(f) >= 3 && isGridField(f[2]) {
-			return f[1], false, f[2]
+				return c, false, f[2]
+			}
+			return c, false, ""
 		}
-		return f[1], false, ""
 	}
 	return "", false, ""
 }

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,6 +214,10 @@ type hamqthSearch struct {
 	AdrCountry string `xml:"adr_country"`
 	USState    string `xml:"us_state"`
 	USCounty   string `xml:"us_county"`
+	// Oblast is HamQTH's Russian district field; District is its generic one.
+	// Both are read because operators fill whichever their editor showed them.
+	Oblast    string `xml:"oblast"`
+	District  string `xml:"district"`
 	Grid      string `xml:"grid"`
 	Latitude  string `xml:"latitude"`
 	Longitude string `xml:"longitude"`

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

@@ -2301,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
@@ -2326,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) {
@@ -2341,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/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)

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

telemetry.go

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