chore: release v0.26.3

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

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

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

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

app.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"
@@ -789,27 +790,38 @@ type App struct {
 	offlineQ       *offlineq.Queue        // ADIF outbox: QSOs logged while the DB was unreachable
 	offlineMode    bool                   // last write failed because the DB was unreachable
 
-	catFlexSpots       bool       // push cluster spots to the FlexRadio panadapter
+	catFlexSpots       bool // push cluster spots to the FlexRadio panadapter
-	catFlexDVKDax      bool       // raise the Flex transmit DAX button around a voice message
+	catFlexDVKDax      bool // raise the Flex transmit DAX button around a voice message
-	catFlexDecodeSpots bool       // push WSJT-X decodes (heard stations) to the panadapter
+	catFlexDecodeSpots bool // push WSJT-X decodes (heard stations) to the panadapter
-	catFlexDecodeSecs  int        // decode spot display duration (seconds)
+	catFlexDecodeSecs  int  // decode spot display duration (seconds)
-	liveActMu          sync.Mutex // guards the entry-strip activity reported for live status
+	// The panadapter palette, parsed once and re-read when it is saved. Guarded
-	liveFreqHz         int64      // last freq/band/mode the UI reported (fallback when CAT is off)
+	// because the cluster read loop touches it on every spot.
-	liveBand           string
+	spotColorsMu    sync.Mutex
-	liveMode           string
+	spotColorsCache *SpotColors
-	livePublishTimer   *time.Timer   // debounced live-status publish on activity change
+	// catSig / catShareSig fingerprint the last APPLIED link and share
-	liveLastQSOAt      time.Time     // when this operator last logged a NEW contact — drives online/offline
+	// configuration, so re-applying an identical one is a no-op instead of a
-	liveTableMu        sync.Mutex    // guards liveTableFor
+	// reconnection. Empty at startup, which is what makes the first call connect.
-	liveTableFor       *sql.DB       // logbook whose live_status DDL has been ensured (once per connection, not per call)
+	catSig           string
-	awardSnapMu        sync.Mutex    // guards the award QSO snapshot
+	catShareSig      string
-	awardSnapBuild     sync.Mutex    // serialises BUILDING it — see awardSnapshot
+	liveActMu        sync.Mutex // guards the entry-strip activity reported for live status
-	awardSnapCap       int           // rows the last build produced, the capacity hint for the next
+	liveFreqHz       int64      // last freq/band/mode the UI reported (fallback when CAT is off)
-	awardSnap          []qso.QSO     // light-scanned + enriched logbook snapshot reused across award computations
+	liveBand         string
-	awardSnapRev       string        // logbook revision the snapshot was built at ("" = none)
+	liveMode         string
-	awardSnapUsed      time.Time     // last read — the snapshot is dropped once it goes cold (see awardSnapshotJanitor)
+	livePublishTimer *time.Timer    // debounced live-status publish on activity change
-	webpub             webPublisher  // log-to-website publishing: debounce timer, periodic ticker, last result
+	liveLastQSOAt    time.Time      // when this operator last logged a NEW contact — drives online/offline
-	bandOpen           bandOpenState // sporadic-E / band-opening detector over the spot stream
+	liveTableMu      sync.Mutex     // guards liveTableFor
-	dataDir            string        // <exeDir>/data — holds config.json, logs, cty.dat
+	liveTableFor     *sql.DB        // logbook whose live_status DDL has been ensured (once per connection, not per call)
+	awardSnapMu      sync.Mutex     // guards the award QSO snapshot
+	awardSnapBuild   sync.Mutex     // serialises BUILDING it — see awardSnapshot
+	awardSnapCap     int            // rows the last build produced, the capacity hint for the next
+	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
 
 	// shuttingDown gates beforeClose re-entry: the first user attempt to
 	// close fires shutdown tasks (backup, future LoTW upload, ...) while
@@ -1740,6 +1752,11 @@ func (a *App) shutdown(ctx context.Context) {
 	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()
@@ -3630,7 +3647,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
@@ -3639,10 +3657,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
@@ -4677,6 +4740,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.
@@ -5056,9 +5122,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
@@ -5098,8 +5169,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
 		}
@@ -5114,6 +5190,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
@@ -7514,6 +7680,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
@@ -8516,11 +8695,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,
+				FreqHz:          s.FreqHz,
-				Callsign: s.DXCall,
+				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,
 			})
 		}
 	}
@@ -11487,6 +11675,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
@@ -12901,6 +13183,17 @@ 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
@@ -12934,6 +13227,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,
@@ -14436,6 +14736,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.
@@ -14483,6 +14850,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
@@ -14499,10 +14873,14 @@ 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})
 			}
+			// 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":
@@ -14869,6 +15247,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())
@@ -16154,11 +16539,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
@@ -16777,7 +17168,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{})
@@ -18433,12 +18828,19 @@ type SpotQuery struct {
 
 // SpotStatus is the per-tuple result. Status is one of:
 //
-//	"new"        — entity never worked
+//	"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-mode"   — band worked, but this MODE never worked on the entity (any band)
+//	"new-band"       — entity worked in this mode, never on this band
-//	"new-slot"   — band & mode each worked before, but not this band+mode together
+//	"new-mode"       — band worked, but this MODE never worked on the entity (any band)
-//	"worked"     — exact band+mode already in the log
+//	"new-slot"       — band & mode each worked before, but not this band+mode together
-//	""           — couldn't resolve the entity (no cty.dat match)
+//	"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"`
@@ -18831,6 +19233,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 {
@@ -18995,33 +19479,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
 }
@@ -19099,6 +19568,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.

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,86 @@
 [
+  {
+    "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": "",

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 { 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';
@@ -598,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 });
@@ -1683,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
@@ -2129,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);
@@ -2759,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 () => {
@@ -3047,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);
@@ -4405,7 +4421,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).
@@ -4481,11 +4503,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,
@@ -4629,11 +4661,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' },
@@ -4649,7 +4680,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) {
@@ -4677,8 +4708,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;
@@ -4703,37 +4732,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;
@@ -5682,6 +5680,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>
               )}
@@ -5693,6 +5705,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' },
@@ -6157,6 +6172,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"
@@ -6788,7 +6822,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.
@@ -6872,6 +6906,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
@@ -7916,6 +7961,8 @@ export default function App() {
               // place a band map happens to be drawn.
               fitToBand={bandMapFit}
               onToggleFit={toggleBandMapFit}
+              hideDigital={bandMapHideFt}
+              onToggleHideDigital={toggleBandMapHideFt}
               keyNav
             />
           </div>

frontend/src/components/AwardEditor.tsx

@@ -574,8 +574,12 @@ export function AwardEditor({ open, onClose, onSaved }: Props) {
                         {/* 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({ field: v === NO_FIELD ? '' : v })}>
+                          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">
                             <SelectItem value={NO_FIELD}>{t('awed.fieldNone')}</SelectItem>
@@ -609,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>
@@ -650,7 +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,11 +93,12 @@ interface Props {
   // globally from the band-map tab toolbar.
   hideDigital?: boolean;
   fitToBand?: boolean;
-  // onToggleFit turns the zoom readout into the fit-to-band switch. Only the
+  // onToggleFit and onToggleHideDigital add the two switches to this map's own
-  // docked map passes it: the Band Map tab has the same control in its own
+  // header. Only the docked map passes them: the Band Map tab has both in its
-  // toolbar, above maps that all obey it at once, and a second switch inside
+  // toolbar, above maps that all obey them at once, and a switch inside each
-  // each card would be four ways to change one setting.
+  // 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
@@ -164,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');
@@ -191,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',
@@ -268,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, onToggleFit, 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
@@ -366,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;
@@ -564,16 +581,18 @@ export function BandMap({ band, spots, spotStatus: spotStatusRaw, currentFreqHz,
           title={t('bmp.zoomOut')}>
           <Minus className="size-3" />
         </button>
-        {/* The readout IS the switch when the parent offers one — the header is
+        {/* A readout, not a switch.
-            already tight with four maps side by side, and a separate chip would
+            
-            cost width to say what this text says anyway. */}
+            It WAS the switch for a day: clicking the px/kHz value toggled
-        {onToggleFit ? (
+            fit-to-band, and in fit it read "FIT". Nobody found it — a control
-          <button type="button" onClick={onToggleFit} title={t('bmp.fitTitle')}
+            whose label is a measurement does not look like a control, and once
-            className={cn('shrink-0 font-mono text-[10px] normal-case tracking-normal whitespace-nowrap px-1 rounded border transition-colors',
+            switched off there was no longer anything on screen saying the option
-              fitToBand ? 'border-primary bg-primary text-primary-foreground' : 'border-border hover:bg-muted')}>
+            existed. The switches below say what they are. */}
-            {fitToBand ? t('bmp.fit') : `${pxPerKHz}px/kHz`}
+        {/* In fit mode the readout has nothing left to say — the lit FIT button
-          </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}
@@ -581,6 +600,20 @@ export function BandMap({ band, spots, spotStatus: spotStatusRaw, currentFreqHz,
           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,14 +45,14 @@ 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;
@@ -115,9 +119,24 @@ 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);
     // Leaflet measures its container ONCE, when the map is created, and never
@@ -126,7 +145,18 @@ export function GridSquareMap({ myGrid, className }: { myGrid?: string; classNam
     // 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.
-    const ro = new ResizeObserver(() => m.invalidateSize({ animate: false }));
+    // 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; };
   }, []);
@@ -138,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]);
 
@@ -254,7 +287,10 @@ 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]"

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

@@ -47,7 +47,9 @@ import {
   TestLoTWUpload, ListTQSLStationLocations,
   DownloadLoTWUsers, GetLoTWUsersStatus,
   GetScpStatus, SetScpEnabled, DownloadScp,
-  DownloadULSCounties, ULSStatus, BackfillUSCounties,
+  DownloadULSCounties, ULSStatus, BackfillUSCounties, BackfillRDA, RDADatabaseCount,
+  GetCtyDatInfo, RefreshCtyDat, GetAwardReferenceMeta, UpdateAwardReferenceList,
+  GetSpotColors, SaveSpotColors, ResetSpotColors, GetFlexZoom, SaveFlexZoom,
   ComputeStationInfo,
   GetUIPref, SetUIPref,
   GetFlexState, GetFlexBandAntennas, SaveFlexBandAntennas, GetFlexBandPower, SaveFlexBandPower,
@@ -68,6 +70,7 @@ import {
 import { WebPublishPanel } from '@/components/WebPublishPanel';
 import { Button } from '@/components/ui/button';
 import { Input } from '@/components/ui/input';
+import { Combobox } from '@/components/ui/combobox';
 import { Label } from '@/components/ui/label';
 import { Textarea } from '@/components/ui/textarea';
 import { Checkbox } from '@/components/ui/checkbox';
@@ -202,6 +205,7 @@ type SectionId =
   | 'database'
   | 'autostart'
   | 'uscounties'
+  | 'databases'
   | 'awards'
   | 'cat'
   | 'ftx'
@@ -319,6 +323,15 @@ function buildTree(flexAvailable: boolean, t: (k: string) => string): TreeNode[]
       { kind: 'item', label: t('sec.autostart'), id: 'autostart' },
     ],
   },
+  {
+    // Maintenance is about DATA rather than settings: nothing in here changes
+    // how OpsLog behaves, it refreshes what it knows. That is why the reference
+    // lists moved out of the Awards manager — an operator updating SOTA is not
+    // editing an award, and had to open one to do it.
+    kind: 'group', label: t('nav.maintenance'), icon: Database, defaultOpen: true, children: [
+      { kind: 'item', label: t('sec.databases'), id: 'databases' },
+    ],
+  },
   {
     kind: 'group', label: t('nav.hardware'), icon: Server, defaultOpen: true, children: hardware,
   },
@@ -334,6 +347,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',
@@ -627,6 +641,19 @@ function AutostartPanelComponent() {
               <Input className="h-8 font-mono text-xs" value={p.args} placeholder="optional command-line arguments"
                 onChange={(e) => patch(p.id, { args: e.target.value })} />
             </div>
+            {/* Only what OpsLog started is ever closed — a copy the operator
+                opened themselves is theirs. The hint says so, because the
+                difference is invisible from here. */}
+            <label className="flex items-start gap-2 text-xs cursor-pointer">
+              <Checkbox className="mt-0.5" checked={!!(p as any).close_on_exit}
+                onCheckedChange={(c) => patch(p.id, { close_on_exit: !!c } as any)} />
+              <span>
+                Close it when OpsLog closes{' '}
+                <span className="text-muted-foreground">
+                  (asks it to close, the way clicking its cross would — and only if OpsLog started it)
+                </span>
+              </span>
+            </label>
             {launchMsg[p.id] && <div className="text-xs text-muted-foreground pl-[86px]">{launchMsg[p.id]}</div>}
           </div>
         ))}
@@ -1257,6 +1284,54 @@ function ComingSoon({ id, icon: Icon }: { id: SectionId; icon?: any }) {
   );
 }
 
+// The panadapter statuses, in the order the cluster ranks them: most wanted
+// first, then the markers that are orthogonal to the entity, then the two
+// "nothing here" cases. Must match spotColorOrder in spotcolors.go — the Go side
+// is the authority, this list only decides the order of the rows.
+const SPOT_COLOR_ROWS = [
+  'new', 'new-band-mode', 'new-band', 'new-mode', 'new-slot',
+  'new-pota', 'new-county', 'new-pfx',
+  'my-call', 'worked', 'none',
+];
+
+// SmartSDR colours are #AARRGGBB — the alpha FIRST, which is not what CSS or an
+// <input type="color"> expects. These two convert between the radio's order and
+// the browser's, so the operator picks a colour in a normal picker and the radio
+// gets what it understands.
+function argbToCss(argb?: string): string {
+  const v = (argb ?? '').trim();
+  if (!/^#[0-9a-fA-F]{8}$/.test(v)) return '';
+  return `#${v.slice(3)}${v.slice(1, 3)}`; // #AARRGGBB → #RRGGBBAA
+}
+function cssToArgb(rgb: string, alpha: string): string {
+  const v = (rgb || '#000000').trim();
+  if (!/^#[0-9a-fA-F]{6}$/.test(v)) return '';
+  return `#${alpha}${v.slice(1)}`.toUpperCase();
+}
+
+// ArgbInput edits one #AARRGGBB value as what it really is: a colour and an
+// opacity. A single text field would be asking an operator to type eight hex
+// digits in an order no other program uses.
+function ArgbInput({ label, value, onChange }: { label: string; value: string; onChange: (v: string) => void }) {
+  const valid = /^#[0-9a-fA-F]{8}$/.test((value ?? '').trim());
+  const alpha = valid ? value.slice(1, 3).toUpperCase() : 'FF';
+  const rgb = valid ? `#${value.slice(3)}` : '#808080';
+  return (
+    <span className="flex items-center gap-1 shrink-0" title={label}>
+      <input type="color" value={rgb}
+        onChange={(e) => onChange(cssToArgb(e.target.value, alpha))}
+        className="size-6 rounded border border-border bg-transparent p-0 cursor-pointer" />
+      <select value={alpha}
+        onChange={(e) => onChange(cssToArgb(rgb, e.target.value))}
+        className="h-6 rounded border border-border bg-background text-[10px] px-0.5">
+        {[['FF', '100%'], ['C0', '75%'], ['80', '50%'], ['40', '25%'], ['20', '12%'], ['00', 'off']].map(([a, l]) => (
+          <option key={a} value={a}>{l}</option>
+        ))}
+      </select>
+    </span>
+  );
+}
+
 // FlexBandPanel — everything that follows the band, in ONE row per band:
 // antennas and TX power.
 //
@@ -1719,6 +1794,65 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     try { await DownloadULSCounties(); }
     catch (e: any) { setUlsBusy(false); setUlsProgress(null); setUlsMsg({ ok: false, text: String(e?.message ?? e) }); }
   };
+  // cty.dat is not downloaded by OpsLog — it is shipped and reloaded from disk —
+  // so the page reports it rather than offering a button it cannot honour.
+  // Panadapter spot palette. Saved on its own — it is a table of colours, not a
+  // form: waiting for the modal's Save to see a colour on the waterfall would
+  // make picking one a guessing game.
+  type SpotColor = { text: string; bg?: string };
+  const [spotColors, setSpotColors] = useState<{ enabled: boolean; colors: Record<string, SpotColor> }>({ enabled: true, colors: {} });
+  useEffect(() => { GetSpotColors().then((c: any) => setSpotColors(c ?? { enabled: true, colors: {} })).catch(() => {}); }, []);
+  const saveSpotColors = (next: { enabled: boolean; colors: Record<string, SpotColor> }) => {
+    setSpotColors(next);
+    SaveSpotColors(next as any).catch(() => {});
+  };
+  const setSpotColor = (k: string, patch: Partial<SpotColor>) => saveSpotColors({
+    ...spotColors,
+    colors: { ...spotColors.colors, [k]: { ...(spotColors.colors[k] ?? { text: '' }), ...patch } },
+  });
+  // Panadapter auto-zoom. Saved immediately for the same reason as the palette:
+  // the only way to judge a width is to click a spot and look at the radio.
+  const [flexZoom, setFlexZoom] = useState<{ enabled: boolean; cw_khz: number; ssb_khz: number; digi_khz: number; centre: boolean }>(
+    { enabled: false, cw_khz: 25, ssb_khz: 200, digi_khz: 50, centre: false });
+  useEffect(() => { GetFlexZoom().then((z: any) => setFlexZoom(z)).catch(() => {}); }, []);
+  const saveFlexZoom = (next: typeof flexZoom) => { setFlexZoom(next); SaveFlexZoom(next as any).catch(() => {}); };
+  const [ctyInfo, setCtyInfo] = useState<{ entities: number; file_mod_time?: string }>({ entities: 0 });
+  const [ctyBusy, setCtyBusy] = useState(false);
+  useEffect(() => { GetCtyDatInfo().then((i) => setCtyInfo(i as any)).catch(() => {}); }, []);
+  const refreshCty = async () => {
+    setCtyBusy(true);
+    try { const i: any = await RefreshCtyDat(); setCtyInfo(i); } catch { /* the line keeps its old count */ }
+    finally { setCtyBusy(false); }
+  };
+  // Award reference lists, and which of them have an online updater.
+  const [refMeta, setRefMeta] = useState<Array<{ code: string; count: number; updated_at?: string; can_update: boolean }>>([]);
+  const [refBusy, setRefBusy] = useState('');
+  const [refMsg, setRefMsg] = useState('');
+  const reloadRefMeta = () => { GetAwardReferenceMeta().then((m) => setRefMeta((m ?? []) as any)).catch(() => {}); };
+  useEffect(reloadRefMeta, []);
+  const updateRefList = async (code: string) => {
+    setRefBusy(code); setRefMsg('');
+    try { const m: any = await UpdateAwardReferenceList(code); setRefMsg(t('db.refUpdated', { code, n: m?.count ?? 0 })); reloadRefMeta(); }
+    catch (e: any) { setRefMsg(String(e?.message ?? e)); }
+    finally { setRefBusy(''); }
+  };
+  // A date for a person: the day, not the timestamp the backend stores.
+  const fmtDay = (v?: string) => (v ? String(v).slice(0, 10) : '—');
+  const [rdaCount, setRdaCount] = useState(0);
+  const [rdaBusy, setRdaBusy] = useState(false);
+  const [rdaUseCurrent, setRdaUseCurrent] = useState(true);
+  const [rdaMsg, setRdaMsg] = useState<string | null>(null);
+  useEffect(() => { RDADatabaseCount().then((n) => setRdaCount(Number(n) || 0)).catch(() => {}); }, []);
+  const runRDABackfill = async () => {
+    setRdaBusy(true); setRdaMsg(null);
+    try {
+      const r: any = await BackfillRDA(rdaUseCurrent);
+      setRdaMsg(t('rda.backfillDone', {
+        d: r?.dated ?? 0, c: r?.current ?? 0, u: r?.unknown ?? 0, k: r?.skipped ?? 0, s: r?.scanned ?? 0,
+      }));
+    } catch (e: any) { setRdaMsg(String(e?.message ?? e)); }
+    finally { setRdaBusy(false); }
+  };
   const runBackfill = async () => {
     setBackfillBusy(true); setBackfillMsg(null);
     try { const r: any = await BackfillUSCounties(); setBackfillMsg(t('uscty.backfillDone', { c: r?.county ?? 0, g: r?.grid ?? 0, s: r?.scanned ?? 0 })); }
@@ -2918,27 +3052,11 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
               <div className="col-span-2">
                 <FlexDiscover onPick={(ip, port) => setCatCfg((s) => ({ ...s, flex_host: ip, flex_port: port }))} />
               </div>
-              <label className="col-span-2 flex items-center gap-2 text-sm cursor-pointer">
+              {/* What OpsLog DOES with a Flex — panadapter spots, decode spots,
-                <Checkbox checked={!!catCfg.flex_spots} onCheckedChange={(c) => setCatCfg((s) => ({ ...s, flex_spots: !!c }))} />
+                  the DAX switch for voice messages — moved to Settings →
-                {t('cat.flexSpots')} <span className="text-xs text-muted-foreground">{t('cat.flexSpotsHint')}</span>
+                  FlexRadio, with the per-band antennas and power. What stays
-              </label>
+                  here is the link itself: an address and a port, which is what
-              <label className="col-span-2 flex items-center gap-2 text-sm cursor-pointer">
+                  this page is about for every other backend too. */}
-                <Checkbox checked={!!catCfg.flex_decode_spots} onCheckedChange={(c) => setCatCfg((s) => ({ ...s, flex_decode_spots: !!c }))} />
-                {t('cat.flexDecodeSpots')} <span className="text-xs text-muted-foreground">{t('cat.flexDecodeSpotsHint')}</span>
-              </label>
-              {catCfg.flex_decode_spots && (
-                <div className="col-span-2 flex items-center gap-2 pl-6">
-                  <Label className="text-sm">{t('cat.flexDecodeSecs')}</Label>
-                  <Input type="number" className="w-24" min={10} max={3600}
-                    value={catCfg.flex_decode_secs || 120}
-                    onChange={(e) => setCatCfg((s) => ({ ...s, flex_decode_secs: parseInt(e.target.value) || 120 }))} />
-                  <span className="text-xs text-muted-foreground">{t('cat.flexDecodeSecsHint')}</span>
-                </div>
-              )}
-              <label className="col-span-2 flex items-start gap-2 text-sm cursor-pointer">
-                <Checkbox className="mt-0.5" checked={!!catCfg.flex_dvk_dax} onCheckedChange={(c) => setCatCfg((s) => ({ ...s, flex_dvk_dax: !!c }))} />
-                <span>{t('cat.flexDvkDax')} <span className="text-xs text-muted-foreground">{t('cat.flexDvkDaxHint')}</span></span>
-              </label>
             </>
             )}
             {catCfg.backend === 'xiegu' && (
@@ -3415,7 +3533,10 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
 
   function UltrabeamPanel() {
     const isSteppir = ultrabeam.type === 'steppir';
-    const isSerial = isSteppir && ultrabeam.transport === 'serial';
+    // Serial is no longer a SteppIR-only route: an Ultrabeam controller has an
+    // RS232 port too, and a plain FTDI cable reaches it without the Ethernet
+    // adapter the TCP route needs.
+    const isSerial = ultrabeam.transport === 'serial';
     return (
       <>
         <SectionHeader
@@ -3429,10 +3550,10 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
           <div className="grid grid-cols-2 gap-3">
             <div className="space-y-1">
               <Label>{t('hw.motorType')}</Label>
-              {/* Ultrabeam is TCP only; picking it forces the transport back to TCP
+              {/* Both antennas take either route now, so picking a type no longer
-                  so the serial fields never apply to it. */}
+                  forces the transport. */}
               <Select value={ultrabeam.type ?? 'ultrabeam'}
-                onValueChange={(v) => setUltrabeam((s) => ({ ...s, type: v, transport: v === 'ultrabeam' ? 'tcp' : s.transport }))}>
+                onValueChange={(v) => setUltrabeam((s) => ({ ...s, type: v }))}>
                 <SelectTrigger className="h-9"><SelectValue /></SelectTrigger>
                 <SelectContent>
                   <SelectItem value="ultrabeam">Ultrabeam</SelectItem>
@@ -3440,7 +3561,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                 </SelectContent>
               </Select>
             </div>
-            {isSteppir && (
+            {(
               <div className="space-y-1">
                 <Label>{t('hw.motorTransport')}</Label>
                 <Select value={ultrabeam.transport ?? 'tcp'}
@@ -3458,12 +3579,25 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             <div className="grid grid-cols-3 gap-3">
               <div className="space-y-1 col-span-2">
                 <Label>{t('hw.motorCom')}</Label>
-                <Input
+                {/* A list AND a text field, which is why this is a Combobox and
-                  value={ultrabeam.com ?? ''}
+                    not the Select the other serial devices use: the port for a
-                  onChange={(e) => setUltrabeam((s) => ({ ...s, com: e.target.value }))}
+                    USB adapter that is currently unplugged does not appear in
-                  placeholder="COM3"
+                    the list, and refusing to accept it typed means the antenna
-                  className="font-mono"
+                    cannot be configured until the adapter is in. The detected
-                />
+                    ports are offered; anything else is still accepted. */}
+                <div className="flex items-center gap-1">
+                  <Combobox
+                    value={ultrabeam.com ?? ''}
+                    options={wkPorts}
+                    allowFreeText
+                    commitOnType
+                    placeholder="COM3"
+                    className="font-mono flex-1"
+                    onChange={(v) => setUltrabeam((s) => ({ ...s, com: v.trim().toUpperCase() }))}
+                  />
+                  <Button type="button" variant="outline" size="sm" className="shrink-0"
+                    onClick={() => ListSerialPorts().then((ps) => setWkPorts((ps ?? []) as string[])).catch(() => {})}>↻</Button>
+                </div>
               </div>
               <div className="space-y-1">
                 <Label>{t('hw.motorBaud')}</Label>
@@ -4650,7 +4784,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')} />
@@ -4820,7 +4954,6 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
           <div className="border-t border-border/60 pt-3 space-y-2">
             <div>
               <span className="text-sm font-medium">{t('clu.macros')}</span>
-              <p className="text-xs text-muted-foreground">{t('clu.macrosHint')}</p>
             </div>
             {/* Two columns of six: twelve rows stacked would push everything else
                 in this panel off the screen. */}
@@ -4934,7 +5067,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>
 
@@ -4996,7 +5128,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. */}
@@ -5039,7 +5170,6 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                 </div>
               )}
             </div>
-            <p className="text-xs text-muted-foreground leading-relaxed">{t('clu.selfSpotHint')}</p>
           </div>
         </div>
 
@@ -6900,6 +7030,141 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     );
   }
 
+  // One line per database: what it holds, when it was refreshed, and the button
+  // that refreshes it. Every one of these already had an updater somewhere —
+  // buried in the Awards manager, in a corner of the Lookup page, behind the
+  // US Counties section — and an operator wanting them all current had to know
+  // where each one lived. The point of this page is that they are in one place,
+  // named, with their own line.
+  function DatabasesPanel() {
+    const rows: Array<{
+      key: string; name: string; detail: string; busy: boolean; run?: () => void; note?: string;
+    }> = [
+      {
+        key: 'cty', name: t('db.cty'),
+        detail: ctyInfo?.entities ? t('db.ctyDetail', { n: ctyInfo.entities, d: fmtDay(ctyInfo.file_mod_time) }) : t('db.never'),
+        busy: ctyBusy, run: refreshCty,
+      },
+      {
+        key: 'clublog', name: t('db.clublog'),
+        detail: clubInfo?.count ? t('db.clublogDetail', { n: clubInfo.count, d: clubInfo.date || '—' }) : t('db.never'),
+        busy: clubBusy,
+        run: () => { setClubBusy(true); setClubErr(''); DownloadClublogCty().then((i) => setClubInfo(i as ClubInfo)).catch((e: any) => setClubErr(String(e?.message ?? e))).finally(() => setClubBusy(false)); },
+      },
+      {
+        key: 'lotw', name: t('db.lotwUsers'),
+        detail: lotwUsers?.count ? t('db.lotwDetail', { n: lotwUsers.count, d: fmtDay(lotwUsers.updated) }) : t('db.never'),
+        busy: lotwUsersBusy, run: downloadLotwUsers,
+      },
+      {
+        key: 'scp', name: t('db.scp'),
+        detail: scp?.count ? t('db.scpDetail', { n: scp.count, d: fmtDay(scp.updated) }) : t('db.never'),
+        busy: scpBusy, run: downloadScp,
+      },
+      {
+        key: 'uls', name: t('db.uls'),
+        detail: ulsStatus?.count ? t('db.ulsDetail', { n: ulsStatus.count, d: fmtDay(ulsStatus.updated_at) }) : t('db.never'),
+        busy: ulsBusy, run: downloadUls,
+      },
+      {
+        key: 'rda', name: t('db.rda'),
+        detail: t('db.rdaDetail', { n: rdaCount.toLocaleString() }),
+        busy: false, note: t('db.rdaNote'),
+      },
+    ];
+    return (
+      <div className="space-y-4 max-w-3xl">
+        <SectionHeader title={t('sec.databases')} hint={t('db.hint')} />
+        <div className="rounded-md border border-border divide-y divide-border">
+          {rows.map((r) => (
+            <div key={r.key} className="flex items-center gap-3 p-3">
+              <div className="min-w-0 flex-1">
+                <div className="text-sm font-medium">{r.name}</div>
+                <div className="text-[11px] text-muted-foreground">{r.detail}</div>
+              </div>
+              {r.run ? (
+                <Button size="sm" variant="secondary" onClick={r.run} disabled={r.busy}>
+                  {r.busy ? <Loader2 className="size-3.5 animate-spin mr-1.5" /> : null}
+                  {t('db.update')}
+                </Button>
+              ) : (
+                <span className="text-[11px] text-muted-foreground italic shrink-0">{r.note}</span>
+              )}
+            </div>
+          ))}
+        </div>
+
+        {/* The award reference lists. Their own block because they are one kind
+            of thing with one updater each, and because the list depends on which
+            awards are defined — a shared WAPC brought in by an operator appears
+            here the day it can be updated. */}
+        <div className="space-y-2">
+          <div className="text-xs font-medium">{t('db.refLists')}</div>
+          <p className="text-[11px] text-muted-foreground">{t('db.refListsHint')}</p>
+          <div className="rounded-md border border-border divide-y divide-border">
+            {refMeta.filter((m) => m.can_update).map((m) => (
+              <div key={m.code} className="flex items-center gap-3 p-3">
+                <div className="min-w-0 flex-1">
+                  <div className="text-sm font-medium font-mono">{m.code}</div>
+                  <div className="text-[11px] text-muted-foreground">
+                    {m.count ? t('db.refDetail', { n: m.count, d: fmtDay(m.updated_at) }) : t('db.never')}
+                  </div>
+                </div>
+                <Button size="sm" variant="secondary" disabled={refBusy === m.code}
+                  onClick={() => updateRefList(m.code)}>
+                  {refBusy === m.code ? <Loader2 className="size-3.5 animate-spin mr-1.5" /> : null}
+                  {t('db.update')}
+                </Button>
+              </div>
+            ))}
+            {refMeta.filter((m) => m.can_update).length === 0 && (
+              <div className="p-3 text-[11px] text-muted-foreground">{t('db.noRefLists')}</div>
+            )}
+          </div>
+          {refMsg && <p className="text-[11px] text-muted-foreground">{refMsg}</p>}
+        </div>
+      </div>
+    );
+  }
+
+  // Russian districts: the offline RDA database and the backfill it feeds.
+  //
+  // Its own section rather than a corner of the Awards manager: it is a
+  // database and a bulk operation on the log, which is what every other item in
+  // this part of the sidebar is.
+  function RDAPanel() {
+    return (
+      <div className="space-y-4 max-w-2xl">
+        <SectionHeader title={t('sec.rda')} hint={t('rda.hint')} />
+        <div className="rounded-md border border-border p-3 space-y-1">
+          <div className="text-xs font-medium">{t('rda.dbTitle')}</div>
+          <p className="text-[11px] text-muted-foreground leading-relaxed">
+            {t('rda.dbCount', { n: rdaCount.toLocaleString() })}
+          </p>
+        </div>
+        <div className="rounded-md border border-border p-3 space-y-2">
+          <div className="text-xs font-medium">{t('rda.backfillTitle')}</div>
+          <p className="text-[11px] text-muted-foreground leading-relaxed">{t('rda.backfillIntro')}</p>
+          {/* The choice is the whole point of the panel, so it is a checkbox and
+              not a hidden default: a dated record is a fact, a current district
+              on a ten-year-old QSO is an assumption. */}
+          <label className="flex items-start gap-2 text-xs cursor-pointer">
+            <Checkbox checked={rdaUseCurrent} className="mt-0.5" onCheckedChange={(c) => setRdaUseCurrent(!!c)} />
+            <span>{t('rda.useCurrent')} <span className="text-muted-foreground">{t('rda.useCurrentHint')}</span></span>
+          </label>
+          <div className="flex items-center gap-3">
+            <Button size="sm" variant="secondary" onClick={runRDABackfill} disabled={rdaBusy}>
+              {rdaBusy ? <Loader2 className="size-3.5 animate-spin mr-1.5" /> : null}
+              {t('rda.backfillRun')}
+            </Button>
+            {rdaMsg && <span className="text-xs text-muted-foreground">{rdaMsg}</span>}
+          </div>
+          <p className="text-[11px] text-muted-foreground">{t('rda.neverOverwrites')}</p>
+        </div>
+      </div>
+    );
+  }
+
   // Map sections to their content + icon (for placeholder).
   const PANELS: Record<SectionId, () => JSX.Element> = {
     general:        GeneralPanel,
@@ -6926,8 +7191,9 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     backup:         BackupPanel,
     database:       DatabasePanel,
     uscounties:     USCountiesPanel,
+    databases:      DatabasesPanel,
     autostart:      () => <AutostartPanelComponent />,
-    awards:         () => <AwardsSelectionPanel profile={activeProfile ?? undefined} />,
+    awards:         () => (<div className="space-y-6"><AwardsSelectionPanel profile={activeProfile ?? undefined} /><RDAPanel /></div>),
     cat:            CATPanel,
     rotator:        RotatorPanel,
     winkeyer:       WinkeyerPanel,
@@ -6936,7 +7202,110 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     tunergenius:    TunerGeniusPanelSettings,
     psu:            PSUPanelSettings,
     pgxl:           PGXLPanelSettings,
-    flex:           () => <FlexBandPanel bands={lists.bands ?? []} />,
+    flex:           () => (
+      <div className="space-y-6">
+        <FlexBandPanel bands={lists.bands ?? []} />
+        {/* Rendered here rather than inside FlexBandPanel so these keep writing
+            to the modal's own CAT settings, saved by its Save button. A panel
+            that saved them itself would be overwritten by that same Save a
+            moment later, using the values it had read on opening. */}
+        <div className="border-t border-border/60 pt-4 space-y-2">
+          <h4 className="text-sm font-semibold text-foreground">{t('cat.flexOptions')}</h4>
+          <label className="flex items-center gap-2 text-sm cursor-pointer">
+            <Checkbox checked={!!catCfg.flex_decode_spots} onCheckedChange={(c) => setCatCfg((s) => ({ ...s, flex_decode_spots: !!c }))} />
+            {t('cat.flexDecodeSpots')} <span className="text-xs text-muted-foreground">{t('cat.flexDecodeSpotsHint')}</span>
+          </label>
+          {catCfg.flex_decode_spots && (
+            <div className="flex items-center gap-2 pl-6">
+              <Label className="text-sm">{t('cat.flexDecodeSecs')}</Label>
+              <Input type="number" className="w-24" min={10} max={3600}
+                value={catCfg.flex_decode_secs || 120}
+                onChange={(e) => setCatCfg((s) => ({ ...s, flex_decode_secs: parseInt(e.target.value) || 120 }))} />
+              <span className="text-xs text-muted-foreground">{t('cat.flexDecodeSecsHint')}</span>
+            </div>
+          )}
+          <label className="flex items-start gap-2 text-sm cursor-pointer">
+            <Checkbox className="mt-0.5" checked={!!catCfg.flex_dvk_dax} onCheckedChange={(c) => setCatCfg((s) => ({ ...s, flex_dvk_dax: !!c }))} />
+            <span>{t('cat.flexDvkDax')} <span className="text-xs text-muted-foreground">{t('cat.flexDvkDaxHint')}</span></span>
+          </label>
+        </div>
+
+        {/* Auto-zoom on a spot click. Its own block: it changes the RADIO's
+            display, where everything above changes what OpsLog draws on it. */}
+        <div className="border-t border-border/60 pt-4 space-y-2">
+          <h4 className="text-sm font-semibold text-foreground">{t('flexzoom.title')}</h4>
+          <label className="flex items-center gap-2 text-sm cursor-pointer">
+            <Checkbox checked={flexZoom.enabled} onCheckedChange={(c) => saveFlexZoom({ ...flexZoom, enabled: !!c })} />
+            {t('flexzoom.enable')}
+          </label>
+          {flexZoom.enabled && (
+            <div className="pl-6 space-y-2">
+              <div className="flex items-center gap-3 flex-wrap">
+                {([['cw_khz', 'flexzoom.cw'], ['ssb_khz', 'flexzoom.ssb'], ['digi_khz', 'flexzoom.digi']] as const).map(([k, lbl]) => (
+                  <label key={k} className="flex items-center gap-1.5 text-xs">
+                    <span className="text-muted-foreground">{t(lbl)}</span>
+                    <Input type="number" min={1} max={14000} className="h-8 w-20"
+                      value={String((flexZoom as any)[k] ?? '')}
+                      onChange={(e) => saveFlexZoom({ ...flexZoom, [k]: parseInt(e.target.value, 10) || 0 } as any)} />
+                    <span className="text-muted-foreground">kHz</span>
+                  </label>
+                ))}
+              </div>
+              <label className="flex items-start gap-2 text-xs cursor-pointer">
+                <Checkbox className="mt-0.5" checked={flexZoom.centre} onCheckedChange={(c) => saveFlexZoom({ ...flexZoom, centre: !!c })} />
+                <span>{t('flexzoom.centre')} <span className="text-muted-foreground">{t('flexzoom.centreHint')}</span></span>
+              </label>
+            </div>
+          )}
+        </div>
+
+        {/* Spot colours, one row per status.
+            
+            Saved on the spot rather than on the modal's Save: this is a table of
+            colours, and having to close a dialog to see what a colour looks like
+            on the waterfall turns picking one into a guessing game. */}
+        <div className="border-t border-border/60 pt-4 space-y-2">
+          <div className="flex items-center justify-between gap-2">
+            <h4 className="text-sm font-semibold text-foreground">{t('spotcol.title')}</h4>
+            <button type="button" className="text-[11px] text-muted-foreground hover:text-foreground underline"
+              onClick={() => ResetSpotColors().then((c: any) => setSpotColors(c)).catch(() => {})}>
+              {t('spotcol.reset')}
+            </button>
+          </div>
+          {/* Whether spots are drawn at all comes first: colouring them is the
+              next question, and the two were on different pages. */}
+          <label className="flex items-center gap-2 text-sm cursor-pointer">
+            <Checkbox checked={!!catCfg.flex_spots} onCheckedChange={(c) => setCatCfg((s) => ({ ...s, flex_spots: !!c }))} />
+            {t('cat.flexSpots')}
+          </label>
+          <label className="flex items-center gap-2 text-sm cursor-pointer">
+            <Checkbox checked={spotColors.enabled}
+              onCheckedChange={(c) => saveSpotColors({ ...spotColors, enabled: !!c })} />
+            {t('spotcol.enable')}
+          </label>
+          {spotColors.enabled && (
+            <div className="rounded-md border border-border divide-y divide-border max-w-2xl">
+              {SPOT_COLOR_ROWS.map((k) => {
+                const c = spotColors.colors[k] ?? { text: '', bg: '' };
+                return (
+                  <div key={k} className="flex items-center gap-3 px-3 py-1.5">
+                    <span className="text-xs flex-1 min-w-0">{t('spotcol.s_' + k)}</span>
+                    {/* The preview is the point of the row: two colour boxes say
+                        nothing about what the pair looks like together. */}
+                    <span className="text-xs font-mono px-2 py-0.5 rounded"
+                      style={{ color: argbToCss(c.text) || undefined, background: argbToCss(c.bg) || undefined }}>
+                      DL1ABC
+                    </span>
+                    <ArgbInput label={t('spotcol.text')} value={c.text} onChange={(v) => setSpotColor(k, { text: v })} />
+                    <ArgbInput label={t('spotcol.bg')} value={c.bg ?? ''} onChange={(v) => setSpotColor(k, { bg: v })} />
+                  </div>
+                );
+              })}
+            </div>
+          )}
+        </div>
+      </div>
+    ),
     audio:          AudioPanel,
   };
 

frontend/src/components/StationControlPanel.tsx

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

frontend/src/components/StatsPanel.tsx

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

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

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

@@ -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,6 +119,8 @@ export function CheckForUpdate():Promise<main.UpdateInfo>;
 
 export function ClearLookupCache():Promise<void>;
 
+export function CloseAutostartPrograms():Promise<void>;
+
 export function ClusterSpotStatuses(arg1:Array<main.SpotQuery>):Promise<Array<main.SpotStatus>>;
 
 export function ComputeQSOAwardRefs(arg1:qso.QSO):Promise<Array<main.QSOAwardRef>>;
@@ -361,6 +367,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 +463,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 +545,8 @@ export function GetSlotStats():Promise<qso.SlotStats>;
 
 export function GetSolarData():Promise<solar.Data>;
 
+export function GetSpotColors():Promise<main.SpotColors>;
+
 export function GetSpotTTLMinutes():Promise<number>;
 
 export function GetStartupStatus():Promise<main.StartupStatus>;
@@ -863,8 +875,12 @@ export function QSOAudioStop():Promise<boolean>;
 
 export function QuitApp():Promise<void>;
 
+export function RDADatabaseCount():Promise<number>;
+
 export function RecomputeAllAwardRefs():Promise<number>;
 
+export function RecomputeAwardRefsForCode(arg1:string):Promise<number>;
+
 export function RefreshCtyDat():Promise<main.CtyDatInfo>;
 
 export function RefreshSolar():Promise<void>;
@@ -897,6 +913,8 @@ export function ResetDatabaseToDefault():Promise<void>;
 
 export function ResetRotorPresets():Promise<Array<main.RotorPreset>>;
 
+export function ResetSpotColors():Promise<main.SpotColors>;
+
 export function RestartApp():Promise<void>;
 
 export function RestartQSORecorder():Promise<void>;
@@ -959,6 +977,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 +1015,8 @@ export function SaveRowColors(arg1:main.RowColorSettings):Promise<void>;
 
 export function SaveSelfSpotSettings(arg1:main.SelfSpotSettings):Promise<void>;
 
+export function SaveSpotColors(arg1:main.SpotColors):Promise<void>;
+
 export function SaveStationDevices(arg1:Array<main.StationDevice>):Promise<void>;
 
 export function SaveStationSettings(arg1:main.StationSettings):Promise<void>;

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,6 +178,10 @@ export function ClearLookupCache() {
   return window['go']['main']['App']['ClearLookupCache']();
 }
 
+export function CloseAutostartPrograms() {
+  return window['go']['main']['App']['CloseAutostartPrograms']();
+}
+
 export function ClusterSpotStatuses(arg1) {
   return window['go']['main']['App']['ClusterSpotStatuses'](arg1);
 }
@@ -662,6 +674,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 +866,10 @@ export function GetFlexState() {
   return window['go']['main']['App']['GetFlexState']();
 }
 
+export function GetFlexZoom() {
+  return window['go']['main']['App']['GetFlexZoom']();
+}
+
 export function GetFolderSync() {
   return window['go']['main']['App']['GetFolderSync']();
 }
@@ -1010,6 +1030,10 @@ export function GetSolarData() {
   return window['go']['main']['App']['GetSolarData']();
 }
 
+export function GetSpotColors() {
+  return window['go']['main']['App']['GetSpotColors']();
+}
+
 export function GetSpotTTLMinutes() {
   return window['go']['main']['App']['GetSpotTTLMinutes']();
 }
@@ -1666,10 +1690,18 @@ export function QuitApp() {
   return window['go']['main']['App']['QuitApp']();
 }
 
+export function RDADatabaseCount() {
+  return window['go']['main']['App']['RDADatabaseCount']();
+}
+
 export function RecomputeAllAwardRefs() {
   return window['go']['main']['App']['RecomputeAllAwardRefs']();
 }
 
+export function RecomputeAwardRefsForCode(arg1) {
+  return window['go']['main']['App']['RecomputeAwardRefsForCode'](arg1);
+}
+
 export function RefreshCtyDat() {
   return window['go']['main']['App']['RefreshCtyDat']();
 }
@@ -1734,6 +1766,10 @@ export function ResetRotorPresets() {
   return window['go']['main']['App']['ResetRotorPresets']();
 }
 
+export function ResetSpotColors() {
+  return window['go']['main']['App']['ResetSpotColors']();
+}
+
 export function RestartApp() {
   return window['go']['main']['App']['RestartApp']();
 }
@@ -1858,6 +1894,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 +1970,10 @@ export function SaveSelfSpotSettings(arg1) {
   return window['go']['main']['App']['SaveSelfSpotSettings'](arg1);
 }
 
+export function SaveSpotColors(arg1) {
+  return window['go']['main']['App']['SaveSpotColors'](arg1);
+}
+
 export function SaveStationDevices(arg1) {
   return window['go']['main']['App']['SaveStationDevices'](arg1);
 }

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;
@@ -2477,6 +2515,26 @@ export namespace main {
 	        this.body = source["body"];
 	    }
 	}
+	export class FlexZoomSettings {
+	    enabled: boolean;
+	    cw_khz: number;
+	    ssb_khz: number;
+	    digi_khz: number;
+	    centre: boolean;
+	
+	    static createFrom(source: any = {}) {
+	        return new FlexZoomSettings(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.enabled = source["enabled"];
+	        this.cw_khz = source["cw_khz"];
+	        this.ssb_khz = source["ssb_khz"];
+	        this.digi_khz = source["digi_khz"];
+	        this.centre = source["centre"];
+	    }
+	}
 	export class FolderSyncConfig {
 	    enabled: boolean;
 	    folder: string;
@@ -3384,6 +3442,52 @@ export namespace main {
 	        this.minutes = source["minutes"];
 	    }
 	}
+	export class SpotColor {
+	    text: string;
+	    bg?: string;
+	
+	    static createFrom(source: any = {}) {
+	        return new SpotColor(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.text = source["text"];
+	        this.bg = source["bg"];
+	    }
+	}
+	export class SpotColors {
+	    enabled: boolean;
+	    colors: Record<string, SpotColor>;
+	
+	    static createFrom(source: any = {}) {
+	        return new SpotColors(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.enabled = source["enabled"];
+	        this.colors = this.convertValues(source["colors"], SpotColor, true);
+	    }
+	
+		convertValues(a: any, classs: any, asMap: boolean = false): any {
+		    if (!a) {
+		        return a;
+		    }
+		    if (a.slice && a.map) {
+		        return (a as any[]).map(elem => this.convertValues(elem, classs));
+		    } else if ("object" === typeof a) {
+		        if (asMap) {
+		            for (const key of Object.keys(a)) {
+		                a[key] = new classs(a[key]);
+		            }
+		            return a;
+		        }
+		        return new classs(a);
+		    }
+		    return a;
+		}
+	}
 	export class SpotQuery {
 	    call: string;
 	    band: string;
@@ -4992,6 +5096,10 @@ export namespace qso {
 	    continents: number;
 	    first_qso: string;
 	    last_qso: string;
+	    last_new_dxcc: string;
+	    last_new_dxcc_num: number;
+	    last_new_dxcc_call: string;
+	    last_new_dxcc_date: string;
 	    confirmed_lotw: number;
 	    confirmed_eqsl: number;
 	    confirmed_qsl: number;
@@ -5042,6 +5150,10 @@ export namespace qso {
 	        this.continents = source["continents"];
 	        this.first_qso = source["first_qso"];
 	        this.last_qso = source["last_qso"];
+	        this.last_new_dxcc = source["last_new_dxcc"];
+	        this.last_new_dxcc_num = source["last_new_dxcc_num"];
+	        this.last_new_dxcc_call = source["last_new_dxcc_call"];
+	        this.last_new_dxcc_date = source["last_new_dxcc_date"];
 	        this.confirmed_lotw = source["confirmed_lotw"];
 	        this.confirmed_eqsl = source["confirmed_eqsl"];
 	        this.confirmed_qsl = source["confirmed_qsl"];

internal/cat/cat.go

@@ -290,12 +290,20 @@ func (m *Manager) SetSplit(on bool, txHz int64) error {
 // the backend picks a default when it's empty. (Status-based colouring can be
 // driven later by setting Color per spot.)
 type SpotInfo struct {
-	FreqHz      int64
+	FreqHz   int64
-	Callsign    string
+	Callsign string
-	Mode        string
+	Mode     string
-	Color       string
+	// Color is the TEXT colour of the callsign on the panadapter, BackgroundColor
-	Comment     string
+	// the plate behind it. Both are #AARRGGBB — the alpha channel first, which is
-	LifetimeSec int // panadapter display seconds before auto-removal (0 = backend default)
+	// SmartSDR's order and not the web's.
+	//
+	// Two colours rather than one because that is what makes a spot readable at a
+	// glance on a busy waterfall: the fill carries the status and the text stays
+	// legible against it. An empty background leaves the radio's own default.
+	Color           string
+	BackgroundColor string
+	Comment         string
+	LifetimeSec     int // panadapter display seconds before auto-removal (0 = backend default)
 }
 
 // Spotter is an OPTIONAL backend capability: show cluster spots on the radio
@@ -475,7 +483,10 @@ type FlexController interface {
 	SetRXAntenna(string) error
 	SetTXAntenna(string) error
 	SetActiveSlice(int) error // focus slice idx so commands target it
-	SetTXSlice(int) error     // make slice idx the transmitter (tx=1)
+	// ZoomPan sets the visible width (MHz) of the active slice's panadapter and
+	// keeps freqMHz inside it, re-centring when it must. See Flex.ZoomPan.
+	ZoomPan(bandwidthMHz, freqMHz float64, centre bool) error
+	SetTXSlice(int) error // make slice idx the transmitter (tx=1)
 	SetSplit(bool) error
 	SetNB(bool) error
 	SetNBLevel(int) error

internal/cat/flex.go

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

internal/cat/flex_test.go

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

internal/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/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 len(f) >= 3 && isGridField(f[2]) {
+		if c := unbracket(f[1]); looksLikeCall(c) {
-			return f[1], false, f[2]
+			if len(f) >= 3 && isGridField(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,15 +214,19 @@ type hamqthSearch struct {
 	AdrCountry string `xml:"adr_country"`
 	USState    string `xml:"us_state"`
 	USCounty   string `xml:"us_county"`
-	Grid       string `xml:"grid"`
+	// Oblast is HamQTH's Russian district field; District is its generic one.
-	Latitude   string `xml:"latitude"`
+	// Both are read because operators fill whichever their editor showed them.
-	Longitude  string `xml:"longitude"`
+	Oblast    string `xml:"oblast"`
-	DXCC       string `xml:"adif"` // HamQTH exposes the ADIF/DXCC number under <adif>
+	District  string `xml:"district"`
-	CQ         string `xml:"cq"`
+	Grid      string `xml:"grid"`
-	ITU        string `xml:"itu"`
+	Latitude  string `xml:"latitude"`
-	Continent  string `xml:"continent"`
+	Longitude string `xml:"longitude"`
-	Email      string `xml:"email"`
+	DXCC      string `xml:"adif"` // HamQTH exposes the ADIF/DXCC number under <adif>
-	QSLVia     string `xml:"qsl_via"`
+	CQ        string `xml:"cq"`
+	ITU       string `xml:"itu"`
+	Continent string `xml:"continent"`
+	Email     string `xml:"email"`
+	QSLVia    string `xml:"qsl_via"`
 	// AdrName is the full postal name. Many records carry it and no <name> at
 	// all, so building the name from <nick> + <name> silently kept the first
 	// name and dropped the rest.

internal/lookup/lookup.go

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

internal/lookup/rdaref_test.go

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

internal/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.1"
+	appVersion = "0.26.3"
 
 	// posthogHost is the PostHog ingestion endpoint. EU cloud by default; change
 	// to https://us.i.posthog.com for a US project.