changelog: open empty 0.23.9 block

spotStatus updates ~20x/second under an RBN firehose; firing a full refreshCells
on each was pure churn on a slow PC. Coalesce into one refresh per 200ms. Keeps
the NEW/WORKED badge colours and the 'represents nothing' dimming — the dimming
itself is a trivial pure read now that the worked-index scan is cached, so it's
no longer a cost worth removing.

app.go

@@ -52,6 +52,7 @@ import (
 	"hamlog/internal/qso"
 	"hamlog/internal/relaydev"
 	"hamlog/internal/rigctld"
+	"hamlog/internal/rotator/dcu1"
 	"hamlog/internal/rotator/gs232"
 	"hamlog/internal/rotator/pst"
 	"hamlog/internal/rotgenius"
@@ -236,6 +237,7 @@ const (
 	keyMotorTXInhibit   = "ultrabeam.tx_inhibit" // "1" → block Flex TX while the antenna is moving
 	keyMotorFreqMin     = "ultrabeam.freq_min"   // SteppIR tunable range low edge (MHz); out-of-range = don't follow/inhibit
 	keyMotorFreqMax     = "ultrabeam.freq_max"   // SteppIR tunable range high edge (MHz)
+	keyMotorBands       = "ultrabeam.bands"      // CSV of bands the antenna covers (e.g. "40m,20m,17m,…"); the follow filter
 	keyStationDevices   = "station.devices"      // JSON list of relay boards for the Station Control tab
 
 	// Antenna Genius (4O3A) antenna switch — Hardware → Antenna Genius. TCP
@@ -569,7 +571,15 @@ type App struct {
 	// Loaded once, appended to on each log, rebuilt after bulk changes.
 	wcbm           map[string]struct{}
 	wcbmMu         sync.RWMutex
-	pota           *pota.Cache
+	// clusterStatusIdx caches the whole-logbook maps ClusterSpotStatuses colours
+	// spots against (worked entities/calls/counties/POTA/prefixes). Building them
+	// per spot batch re-scanned the entire logbook ~20×/second under an RBN
+	// firehose — the dominant CPU cost on a large log. Built lazily, treated as an
+	// immutable snapshot, and dropped on any logbook change (invalidateAwardStats)
+	// or when a setting that shapes the maps flips.
+	clusterStatusIdx *clusterStatusCache
+	clusterStatusMu  sync.Mutex
+	pota             *pota.Cache
 	uls            *uls.Store // US callsign→county/grid (offline FCC ULS), lazily opened
 	awardRefs      *awardref.Repo
 	qslTemplates   *qslcard.Repo
@@ -642,6 +652,7 @@ type App struct {
 	settingsScoped atomic.Bool            // true once a.settings is scoped to the active profile — GetUIPref/SetUIPref (per-profile) must wait for it, else an early call reads the wrong scope and e.g. resets the theme
 	dbPath         string                 // settings/config database file (settings + profiles); may be a user-chosen location
 	logbookPath    string                 // default SQLite logbook file (QSOs), next to the settings db — used when a profile doesn't point elsewhere
+	logDbPath      string                 // resolved SQLite file actually backing logDb ("" on MySQL, or when the settings db serves as the logbook) — the file the backup snapshots
 	logDb          *sql.DB                // QSO logbook connection — MySQL, a per-profile SQLite file, or the default logbook.db (never the settings db, except on fallback)
 	dbBackend      string                 // "sqlite" | "mysql" — the logbook backend actually opened at startup
 	dbBackendErr   string                 // non-empty when a configured MySQL backend failed and we fell back to SQLite
@@ -986,6 +997,12 @@ func (a *App) startup(ctx context.Context) {
 	}
 	a.settings.SetProfile(active.ID)
 	a.settingsScoped.Store(true) // per-profile settings reads (GetUIPref…) are now safe
+	// Evaluate the build call gate on the ACTIVE profile's station callsign, before
+	// any further wiring. A denied call exits here, silently. Only the active
+	// profile is checked (not every profile) so that "--profile <other>" is always
+	// a way back in — a blocked call is otherwise unrecoverable, since the process
+	// quits before the operator can change it.
+	enforceCallGate(active.Callsign)
 	// US county resolver — its own local SQLite (data/uls.db), populated on demand
 	// by DownloadULSCounties. Opening (creating an empty store) is cheap and never
 	// fatal: county resolution simply stays inert until the operator downloads it.
@@ -1058,6 +1075,7 @@ func (a *App) startup(ctx context.Context) {
 		applog.Printf("startup: logbook open failed (%v) — falling back to SQLite logbook", lerr)
 		a.dbBackendErr = strings.TrimPrefix(lerr.Error(), "")
 		logbookConn, backend = conn, "sqlite"
+		a.logDbPath = "" // fell back to the settings db as the logbook — backup snapshots a.db
 	}
 	a.dbBackend = backend
 	// db.Dialect describes the LOGBOOK backend — the only place SQL actually
@@ -1515,14 +1533,9 @@ func (a *App) runBackupForShutdown() error {
 	if done {
 		return nil
 	}
-	if _, err := backup.Run(a.ctx, a.db, a.dbPath, folder, s.Rotation, s.Zip); err != nil {
+	if _, err := a.runConfiguredBackup(folder, s.Rotation, s.Zip); err != nil {
 		return err
 	}
-	if mysql {
-		if _, err := a.backupLogADIF(folder, s.Rotation, s.Zip); err != nil {
-			return err
-		}
-	}
 	return a.settings.Set(a.ctx, keyBackupLast, time.Now().UTC().Format(time.RFC3339))
 }
 
@@ -2045,6 +2058,7 @@ func (a *App) connectLogbook(cfg profile.ProfileDB) (*sql.DB, string, error) {
 		if err != nil {
 			return nil, "", err
 		}
+		a.logDbPath = "" // MySQL: no local file to snapshot (the log is exported to ADIF instead)
 		return c, "mysql", nil
 	}
 	// SQLite logbook FILE, separate from the settings/config database. A profile
@@ -2058,6 +2072,7 @@ func (a *App) connectLogbook(cfg profile.ProfileDB) (*sql.DB, string, error) {
 		lp = a.logbookPath
 	}
 	if lp == "" {
+		a.logDbPath = "" // settings db serves as the logbook (split failed) — backup snapshots a.db
 		return a.db, "sqlite", nil
 	}
 	// Resolve against THIS install before opening. Without it, a profile carried
@@ -2073,6 +2088,7 @@ func (a *App) connectLogbook(cfg profile.ProfileDB) (*sql.DB, string, error) {
 	if err != nil {
 		return nil, "", fmt.Errorf("open logbook %s: %w", lp, err)
 	}
+	a.logDbPath = lp // the SQLite file the backup snapshots for the contacts
 	return c, "sqlite", nil
 }
 
@@ -2394,6 +2410,19 @@ func (a *App) groupDigitalSlots() bool {
 	return v == "1"
 }
 
+// clusterWorkedSameSlot reports the "consider a call already worked only if
+// worked on the SAME band+mode slot" cluster preference (Settings → DX Cluster).
+// Off (default) → a call worked on any band/mode reads as already worked. On →
+// the WORKED-call flag needs the same band and mode (digital-grouped when that
+// option is also on).
+func (a *App) clusterWorkedSameSlot() bool {
+	if a.settings == nil {
+		return false
+	}
+	v, _ := a.settings.Get(a.ctx, "ui.opslog.clusterWorkedSameSlot")
+	return v == "1"
+}
+
 func (a *App) GetUIPref(key string) (string, error) {
 	if a.settings == nil || !a.settingsScoped.Load() {
 		// Distinct from a genuinely-empty pref: the (LOCAL SQLite) settings store
@@ -3623,6 +3652,29 @@ func (a *App) computeAwardsForMode(defs []award.Def, modeClass string) ([]award.
 	}
 	refMetas := a.awardRefMetas(defs)
 	results := award.Compute(defs, all, refMetas, nameOf)
+	// DXCC: fill each reference's Group with the entity's primary prefix (XE,
+	// DL, F…). Sorting/searching a 340-row list by bare entity number is
+	// hopeless — the prefix is how operators actually identify an entity.
+	// Derived from the live cty.dat rather than stored on the reference row, so
+	// it needs no re-seed of an existing installation.
+	if a.dxcc != nil {
+		var pfx map[int]string
+		for i := range results {
+			if !strings.EqualFold(results[i].Code, "DXCC") {
+				continue
+			}
+			if pfx == nil {
+				if pfx = a.dxcc.PrefixByDXCC(); pfx == nil {
+					break
+				}
+			}
+			for j := range results[i].Refs {
+				if n, err := strconv.Atoi(results[i].Refs[j].Ref); err == nil {
+					results[i].Refs[j].Group = pfx[n]
+				}
+			}
+		}
+	}
 	// Dynamic awards (POTA/SOTA/…) aren't fully loaded into the engine — their
 	// list can be huge. Enrich them after the fact: real Total from the stored
 	// count, and reference names for the worked references only.
@@ -4210,6 +4262,11 @@ func (a *App) invalidateAwardStats() {
 	a.awardSnap = nil
 	a.awardSnapRev = ""
 	a.awardSnapMu.Unlock()
+	// Drop the cluster worked-index snapshot too, so the Cluster tab's NEW/WORKED
+	// colouring reflects the change on the next spot batch (it rebuilds lazily).
+	a.clusterStatusMu.Lock()
+	a.clusterStatusIdx = nil
+	a.clusterStatusMu.Unlock()
 	// 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.
@@ -6048,6 +6105,38 @@ func (a *App) WorkedBefore(callsign string, dxccHint int) (qso.WorkedBefore, err
 	return wb, err
 }
 
+// BandSlotQSOs lists the contacts behind ONE cell of the entry Stats (F1)
+// matrix — "everything I have on 20m CW with this entity". Same drill-down the
+// Awards grid offers, for the panel an operator actually stares at while
+// working a station.
+//
+// modeClass is the matrix column class ("PH", "CW", "DIG"); empty means all.
+// Both the exact callsign and the entity are returned: a cell is amber for the
+// entity and green for the call, and the useful answer to "who gave me this
+// slot?" is the whole list.
+func (a *App) BandSlotQSOs(callsign string, dxccNum int, band, modeClass string) ([]qso.QSO, error) {
+	if a.qso == nil {
+		return nil, fmt.Errorf("db not initialized")
+	}
+	all, err := a.qso.BandSlotQSOs(a.ctx, callsign, dxccNum, band)
+	if err != nil {
+		return nil, err
+	}
+	// "PH"/"DIG" are the matrix's column labels; award.ModeClass speaks
+	// "PHONE"/"DIGI". Translate rather than teach one of them the other's names.
+	want := map[string]string{"PH": "PHONE", "CW": "CW", "DIG": "DIGI"}[strings.ToUpper(strings.TrimSpace(modeClass))]
+	if want == "" {
+		return all, nil
+	}
+	out := make([]qso.QSO, 0, len(all))
+	for _, q := range all {
+		if award.ModeClass(q.Mode) == want {
+			out = append(out, q)
+		}
+	}
+	return out, nil
+}
+
 // SetCompactMode toggles a tiny always-on-top window that exposes just the
 // QSO entry — useful when running on a single screen alongside WSJT-X,
 // JT-Alert or the cluster.
@@ -7699,6 +7788,11 @@ func (a *App) noteWorked(call, band, mode string) {
 	}
 	a.wcbm[wcbmKey(call, band, mode)] = struct{}{}
 	a.wcbmMu.Unlock()
+	// The cluster worked-index snapshot is now stale (this call/slot just became
+	// worked) — drop it so the next spot batch recolours with the new QSO.
+	a.clusterStatusMu.Lock()
+	a.clusterStatusIdx = nil
+	a.clusterStatusMu.Unlock()
 }
 
 // isWorkedBandMode reports whether this exact call+band+mode is in the log,
@@ -11739,6 +11833,33 @@ func (a *App) SaveBackupSettings(s BackupSettings) error {
 	return nil
 }
 
+// runConfiguredBackup writes the backup set to folder: the CONTACTS as the
+// primary "opslog-*" backup, plus a separate "opslogcfg-*" snapshot of the
+// settings/config db, so neither is lost. The contacts are what the user means
+// by "the log": on SQLite they live in the split-out logbook file (a.logDbPath),
+// NOT the settings db — the old code snapshotted a.db and so silently stopped
+// backing up the QSOs once the logbook was split out. On MySQL the contacts
+// aren't in a local file, so they're exported to ADIF instead. Returns the path
+// of the contacts backup.
+func (a *App) runConfiguredBackup(folder string, rotation int, zip bool) (string, error) {
+	// Config snapshot (profiles, hardware, awards). Best-effort — a config-backup
+	// failure must never stop the contacts from being protected.
+	if _, err := backup.Run(a.ctx, a.db, a.dbPath, folder, rotation, zip, "opslogcfg"); err != nil {
+		applog.Printf("backup: config snapshot failed: %v", err)
+	}
+	if a.dbBackend == "mysql" {
+		// The live log is on MySQL; VACUUM INTO can't reach it — export to ADIF.
+		return a.backupLogADIF(folder, rotation, zip)
+	}
+	// SQLite: snapshot the logbook file that holds the contacts. Fall back to the
+	// settings db only when it doubles as the logbook (rare split-failure case).
+	conn, path := a.logDb, a.logDbPath
+	if conn == nil || path == "" {
+		conn, path = a.db, a.dbPath
+	}
+	return backup.Run(a.ctx, conn, path, folder, rotation, zip, "opslog")
+}
+
 // RunBackupNow forces an immediate backup using the persisted settings.
 // Returns the destination path of the file that was written.
 func (a *App) RunBackupNow() (string, error) {
@@ -11750,20 +11871,10 @@ func (a *App) RunBackupNow() (string, error) {
 	if folder == "" {
 		folder = s.DefaultFolder
 	}
-	// Always snapshot the local SQLite (config + any pre-MySQL local QSOs).
-	path, err := backup.Run(a.ctx, a.db, a.dbPath, folder, s.Rotation, s.Zip)
+	path, err := a.runConfiguredBackup(folder, s.Rotation, s.Zip)
 	if err != nil {
 		return path, err
 	}
-	// On MySQL the live QSO log isn't in the local DB — export it to ADIF so the
-	// contacts are actually protected. The ADIF path is the one we surface.
-	if a.dbBackend == "mysql" {
-		adiPath, aerr := a.backupLogADIF(folder, s.Rotation, s.Zip)
-		if aerr != nil {
-			return adiPath, aerr
-		}
-		path = adiPath
-	}
 	a.setSetting(keyBackupLast, time.Now().UTC().Format(time.RFC3339))
 	return path, nil
 }
@@ -11809,16 +11920,10 @@ func (a *App) maybeShutdownBackup() {
 	if done {
 		return
 	}
-	if _, err := backup.Run(a.ctx, a.db, a.dbPath, folder, s.Rotation, s.Zip); err != nil {
+	if _, err := a.runConfiguredBackup(folder, s.Rotation, s.Zip); err != nil {
 		fmt.Println("OpsLog: shutdown backup failed:", err)
 		return
 	}
-	if mysql {
-		if _, err := a.backupLogADIF(folder, s.Rotation, s.Zip); err != nil {
-			fmt.Println("OpsLog: shutdown ADIF log backup failed:", err)
-			return
-		}
-	}
 	a.setSetting(keyBackupLast, time.Now().UTC().Format(time.RFC3339))
 }
 
@@ -11913,11 +12018,10 @@ func (a *App) ultrabeamFollowNow(freqHz int64) {
 	if !st.Connected {
 		return
 	}
-	if st.FreqMin > 0 && st.FreqMax > 0 {
-		mhz := freqHz / 1_000_000
-		if mhz < int64(st.FreqMin) || mhz > int64(st.FreqMax) {
-			return // outside the antenna's tunable range
-		}
+	if !motorBandAllowed(s.Bands, freqHz) {
+		applog.Printf("ultrabeam: followNow %.3f MHz is %q — not in covered bands %v; no move",
+			float64(freqHz)/1e6, bandForHz(freqHz), s.Bands)
+		return // a band the antenna doesn't cover — leave it where it is
 	}
 	khz := int(freqHz / 1000)
 	ref := st.Frequency
@@ -13403,7 +13507,7 @@ type logicalRotor struct {
 
 // normRotorType clamps a rotor type to a known backend.
 func normRotorType(t string) string {
-	if t == "rotgenius" || t == "arco" {
+	if t == "rotgenius" || t == "arco" || t == "dcu1" {
 		return t
 	}
 	return "pst"
@@ -13416,6 +13520,8 @@ func rotatorDefaultPort(typ string) int {
 		return 9006 // 4O3A native default
 	case "arco":
 		return 4001 // placeholder — the real number is set in ARCO's LAN menu
+	case "dcu1":
+		return 4001 // only used with a serial-over-IP bridge; DCU-1 has no standard
 	default:
 		return 12000 // PstRotator UDP
 	}
@@ -13608,6 +13714,16 @@ func arcoClient(l rotorLink) *gs232.Client {
 	return gs232.New(l.Host, l.Port)
 }
 
+// dcu1Client builds the Hy-Gain DCU-1 client for a rotor's transport: the
+// controller's COM port (the usual case — RotorCard DXA, Green Heron, Rotor-EZ)
+// or a serial-over-IP bridge on TCP.
+func dcu1Client(l rotorLink) *dcu1.Client {
+	if l.Transport == "serial" {
+		return dcu1.NewSerial(l.ComPort, l.Baud)
+	}
+	return dcu1.New(l.Host, l.Port)
+}
+
 // RotatorHeading is the live antenna heading for the status bar and compass.
 type RotatorHeading struct {
 	Enabled bool   `json:"enabled"`
@@ -13674,6 +13790,16 @@ func (a *App) GetRotatorHeading() RotatorHeading {
 		base.Azimuth = az
 		base.Raw = raw
 		return base
+	case "dcu1":
+		az, raw, herr := dcu1Client(link).Heading()
+		if herr != nil {
+			base.Raw = herr.Error()
+			return base
+		}
+		base.OK = true
+		base.Azimuth = az
+		base.Raw = raw
+		return base
 	default:
 		az, raw, herr := pst.New(link.Host, link.Port).Heading()
 		if herr != nil {
@@ -13700,6 +13826,8 @@ func (a *App) RotatorGoTo(az int, el int) error {
 		return rotgenius.New(link.Host, link.Port).GoTo(link.Num, az)
 	case "arco":
 		return arcoClient(link).GoTo(az)
+	case "dcu1":
+		return dcu1Client(link).GoTo(az)
 	default:
 		return pst.New(link.Host, link.Port).GoTo(az, link.HasElevation, el)
 	}
@@ -13717,6 +13845,8 @@ func (a *App) RotatorStop() error {
 		return rotgenius.New(link.Host, link.Port).Stop()
 	case "arco":
 		return arcoClient(link).Stop()
+	case "dcu1":
+		return dcu1Client(link).Stop()
 	default:
 		return pst.New(link.Host, link.Port).Stop()
 	}
@@ -13735,6 +13865,8 @@ func (a *App) RotatorPark() error {
 		return fmt.Errorf("park is a PstRotator feature; not available on the Rotator Genius")
 	case "arco":
 		return fmt.Errorf("park is a PstRotator feature; not available over the ARCO GS-232 link")
+	case "dcu1":
+		return fmt.Errorf("park is a PstRotator feature; not available over the DCU-1 link")
 	default:
 		return pst.New(link.Host, link.Port).Park()
 	}
@@ -13773,6 +13905,14 @@ func testRotorLink(l rotorLink) error {
 		// GS-232 — without moving the antenna.
 		_, _, err := arcoClient(l).Heading()
 		return err
+	case "dcu1":
+		if l.Transport == "serial" && strings.TrimSpace(l.ComPort) == "" {
+			return fmt.Errorf("select the DCU-1 controller's COM port first")
+		}
+		// A bearing query (AI1) proves the link and the DCU-1 command set without
+		// moving the antenna.
+		_, _, err := dcu1Client(l).Heading()
+		return err
 	default:
 		return pst.New(l.Host, l.Port).GoTo(0, false, -1)
 	}
@@ -14073,7 +14213,17 @@ type motorAntenna interface {
 // ubAdapter / steppirAdapter wrap each concrete client to the shared interface,
 // translating only the status shape (both already use the same 0/1/2 direction
 // convention, so commands pass straight through).
-type ubAdapter struct{ c *ultrabeam.Client }
+type ubAdapter struct {
+	c *ultrabeam.Client
+	// Configured tunable range (MHz) from Settings → Antenna. The follow logic
+	// uses this as a hard floor/ceiling: some controllers (e.g. an RCU-06 behind
+	// an RS232-to-Ethernet bridge) answer with the short status frame that omits
+	// FreqMax, which would disable the out-of-range guard and let OpsLog forward
+	// an un-tunable frequency (80 m → the controller clamps the elements to its
+	// lowest band, ~30 m). Trusting the operator's configured range instead keeps
+	// the antenna put on bands it can't reach.
+	freqMin, freqMax int
+}
 
 func (a ubAdapter) Start() error                 { return a.c.Start() }
 func (a ubAdapter) Stop()                        { a.c.Stop() }
@@ -14094,7 +14244,18 @@ func (a ubAdapter) Status() motorStatus {
 	if err != nil || st == nil {
 		return motorStatus{}
 	}
-	return motorStatus{Connected: st.Connected, Direction: st.Direction, Frequency: st.Frequency, Band: st.Band, Moving: st.MotorsMoving != 0, FreqMin: st.FreqMin, FreqMax: st.FreqMax}
+	// Prefer the operator's configured range; fall back to whatever the controller
+	// self-reported only when a bound is left unset. This guarantees BOTH bounds
+	// are present so the follow guard actually engages — a controller that reports
+	// FreqMin but not FreqMax (short status frame) would otherwise disable it.
+	fmin, fmax := a.freqMin, a.freqMax
+	if fmin <= 0 {
+		fmin = st.FreqMin
+	}
+	if fmax <= 0 {
+		fmax = st.FreqMax
+	}
+	return motorStatus{Connected: st.Connected, Direction: st.Direction, Frequency: st.Frequency, Band: st.Band, Moving: st.MotorsMoving != 0, FreqMin: fmin, FreqMax: fmax}
 }
 
 type steppirAdapter struct {
@@ -14136,10 +14297,15 @@ type UltrabeamSettings struct {
 	Follow    bool   `json:"follow"`     // re-tune the antenna to the rig's frequency
 	StepKHz   int    `json:"step_khz"`   // re-tune only when the freq moved this far (25/50/100)
 	TXInhibit bool   `json:"tx_inhibit"` // block Flex transmission while the elements are moving
-	// SteppIR tunable range (MHz). The follow loop skips frequencies outside it —
-	// no tune command AND no TX inhibit — so a band the antenna can't cover (e.g.
-	// 30 m on a 20 m–6 m SteppIR) never traps TX. Ignored for the Ultrabeam, which
-	// reports its own per-band coverage. 0 = defaults filled in on load for SteppIR.
+	// Bands the antenna covers — the follow filter. The follow loop only re-tunes
+	// (and only lets TX-inhibit trigger) on a band in this set; on any other band
+	// the antenna is left where it is. Expressed as a set rather than a min/max
+	// range so a single band can be dropped (e.g. 30 m without its extension) while
+	// its neighbours stay. Applies to BOTH the Ultrabeam and the SteppIR.
+	Bands []string `json:"bands"`
+	// Legacy tunable range (MHz). Superseded by Bands; kept so an older config
+	// migrates cleanly (the range is converted to a band set on load) and so the
+	// value round-trips. Not used by the follow filter once Bands is set.
 	FreqMinMHz int `json:"freq_min_mhz"`
 	FreqMaxMHz int `json:"freq_max_mhz"`
 }
@@ -14153,7 +14319,7 @@ func (a *App) GetUltrabeamSettings() (UltrabeamSettings, error) {
 		return out, fmt.Errorf("db not initialized")
 	}
 	m, err := a.settings.GetMany(a.ctx, keyUltrabeamEnabled, keyUltrabeamHost, keyUltrabeamPort, keyUltrabeamFollow, keyUltrabeamStep,
-		keyMotorType, keyMotorTransport, keyMotorCOM, keyMotorBaud, keyMotorTXInhibit, keyMotorFreqMin, keyMotorFreqMax)
+		keyMotorType, keyMotorTransport, keyMotorCOM, keyMotorBaud, keyMotorTXInhibit, keyMotorFreqMin, keyMotorFreqMax, keyMotorBands)
 	if err != nil {
 		return out, err
 	}
@@ -14179,17 +14345,20 @@ func (a *App) GetUltrabeamSettings() (UltrabeamSettings, error) {
 	}
 	out.FreqMinMHz, _ = strconv.Atoi(m[keyMotorFreqMin])
 	out.FreqMaxMHz, _ = strconv.Atoi(m[keyMotorFreqMax])
-	// A SteppIR doesn't report its coverage, so default to the standard 20 m–6 m
-	// range (13–54 MHz) when unset — the common model. Widen it (e.g. min 6 for a
-	// 40 m-equipped SteppIR) in Settings. This is what lets the follow loop leave
-	// TX alone on a band the antenna can't reach.
-	if out.Type == "steppir" {
-		if out.FreqMinMHz <= 0 {
-			out.FreqMinMHz = 13
-		}
-		if out.FreqMaxMHz <= 0 {
-			out.FreqMaxMHz = 54
+	// Bands is the follow filter. If it was saved, use it verbatim. Otherwise this
+	// is a config from before the band selector: migrate the legacy FreqMin/FreqMax
+	// range into a band set so the effective coverage is unchanged (an unset range
+	// on a SteppIR is treated as the standard 20 m–6 m; an unset range on the
+	// Ultrabeam becomes the whole 40 m–6 m universe, which still excludes 80 m).
+	if raw := strings.TrimSpace(m[keyMotorBands]); raw != "" {
+		out.Bands = normMotorBands(strings.Split(raw, ","))
+	}
+	if len(out.Bands) == 0 {
+		minMHz, maxMHz := out.FreqMinMHz, out.FreqMaxMHz
+		if out.Type == "steppir" && minMHz <= 0 && maxMHz <= 0 {
+			minMHz, maxMHz = 13, 54
 		}
+		out.Bands = motorBandsFromRange(minMHz, maxMHz)
 	}
 	return out, nil
 }
@@ -14225,6 +14394,14 @@ func (a *App) SaveUltrabeamSettings(s UltrabeamSettings) error {
 	if s.FreqMinMHz > 0 && s.FreqMaxMHz > 0 && s.FreqMinMHz > s.FreqMaxMHz {
 		s.FreqMinMHz, s.FreqMaxMHz = s.FreqMaxMHz, s.FreqMinMHz
 	}
+	// Bands is the follow filter. Normalise to known bands in canonical order; an
+	// empty selection would strand the antenna on every band, so fall back to the
+	// full universe (which still excludes 80 m/160 m — outside a motor antenna's
+	// reach) rather than persist "nothing".
+	s.Bands = normMotorBands(s.Bands)
+	if len(s.Bands) == 0 {
+		s.Bands = motorBandNames()
+	}
 	for k, v := range map[string]string{
 		keyUltrabeamEnabled: boolStr(s.Enabled),
 		keyUltrabeamHost:    strings.TrimSpace(s.Host),
@@ -14238,6 +14415,7 @@ func (a *App) SaveUltrabeamSettings(s UltrabeamSettings) error {
 		keyMotorTXInhibit:   boolStr(s.TXInhibit),
 		keyMotorFreqMin:     strconv.Itoa(s.FreqMinMHz),
 		keyMotorFreqMax:     strconv.Itoa(s.FreqMaxMHz),
+		keyMotorBands:       strings.Join(s.Bands, ","),
 	} {
 		if err := a.settings.Set(a.ctx, k, v); err != nil {
 			return err
@@ -14265,7 +14443,7 @@ func newMotorClient(s UltrabeamSettings) motorAntenna {
 	if strings.TrimSpace(s.Host) == "" {
 		return nil
 	}
-	return ubAdapter{ultrabeam.New(s.Host, s.Port)}
+	return ubAdapter{c: ultrabeam.New(s.Host, s.Port), freqMin: s.FreqMinMHz, freqMax: s.FreqMaxMHz}
 }
 
 // startUltrabeam stops any existing client and starts a fresh one if the
@@ -14301,15 +14479,110 @@ func (a *App) startUltrabeam() {
 	if s.Follow {
 		stop := make(chan struct{})
 		a.ubFollowStop = stop
-		go a.ultrabeamFollowLoop(a.motorAnt, s.StepKHz, stop)
+		applog.Printf("ultrabeam: follow loop starting — covered bands %v, step %d kHz", s.Bands, s.StepKHz)
+		go a.ultrabeamFollowLoop(a.motorAnt, s.StepKHz, s.Bands, stop)
 	}
 	if s.TXInhibit {
 		stop := make(chan struct{})
 		a.motorInhibStop = stop
-		go a.motorTXInhibitLoop(a.motorAnt, stop)
+		go a.motorTXInhibitLoop(a.motorAnt, s.Bands, stop)
 	}
 }
 
+// motorBands is the band universe a motorized HF/6 m antenna (Ultrabeam / SteppIR)
+// can cover, low to high. The follow filter is expressed as a SUBSET of these, so
+// an operator can drop a single band (e.g. 30 m, when the 30 m extension isn't
+// fitted) while keeping its neighbours — something a contiguous min/max range
+// can't express. nomMHz is a representative in-band frequency, used only to
+// migrate a legacy FreqMin/FreqMax range into a band set.
+var motorBands = []struct {
+	name   string
+	nomMHz int
+}{
+	{"40m", 7}, {"30m", 10}, {"20m", 14}, {"17m", 18},
+	{"15m", 21}, {"12m", 24}, {"10m", 28}, {"6m", 50},
+}
+
+// motorBandNames is the full ordered set (all bands enabled).
+func motorBandNames() []string {
+	out := make([]string, len(motorBands))
+	for i, b := range motorBands {
+		out[i] = b.name
+	}
+	return out
+}
+
+// normMotorBands keeps only recognised motor bands, canonical low→high order,
+// de-duplicated.
+func normMotorBands(in []string) []string {
+	want := map[string]bool{}
+	for _, s := range in {
+		want[strings.TrimSpace(strings.ToLower(s))] = true
+	}
+	out := []string{}
+	for _, b := range motorBands {
+		if want[b.name] {
+			out = append(out, b.name)
+		}
+	}
+	return out
+}
+
+// motorBandsFromRange derives the enabled-band set from a legacy FreqMin/FreqMax
+// range (MHz) — a one-time migration to the band selector. An empty/zero range
+// means "everything the antenna universe covers".
+func motorBandsFromRange(minMHz, maxMHz int) []string {
+	if minMHz <= 0 && maxMHz <= 0 {
+		return motorBandNames()
+	}
+	hi := maxMHz
+	if hi <= 0 {
+		hi = 9999
+	}
+	out := []string{}
+	for _, b := range motorBands {
+		if b.nomMHz >= minMHz && b.nomMHz <= hi {
+			out = append(out, b.name)
+		}
+	}
+	if len(out) == 0 { // a nonsensical range shouldn't strand the antenna on every band
+		return motorBandNames()
+	}
+	return out
+}
+
+// motorBandAllowed reports whether the follow logic may retune the antenna for a
+// rig sitting at hz, given the operator's enabled-band list. A frequency outside
+// the motor band universe (e.g. 80 m / 160 m) is NEVER allowed, so OpsLog won't
+// push the antenna onto a band it physically can't reach. An empty list is
+// treated as "every band in the universe" (a safety fallback — the settings
+// loader normally fills the list).
+func motorBandAllowed(bands []string, hz int64) bool {
+	b := bandForHz(hz)
+	if b == "" {
+		return false
+	}
+	inUniverse := false
+	for _, m := range motorBands {
+		if m.name == b {
+			inUniverse = true
+			break
+		}
+	}
+	if !inUniverse {
+		return false
+	}
+	if len(bands) == 0 {
+		return true
+	}
+	for _, x := range bands {
+		if x == b {
+			return true
+		}
+	}
+	return false
+}
+
 // ultrabeamFollowLoop re-tunes the antenna to the rig's current frequency
 // whenever it drifts at least stepKHz from what the antenna is set to — so the
 // elements track the band without the motors chasing every small QSY. Runs
@@ -14347,7 +14620,7 @@ func (a *App) applyMotorInhibit(on bool) {
 // active; it errs toward SAFE — TX is inhibited while the status reports motion
 // OR within a grace window after a commanded move — and always releases the
 // inhibit when it stops (so a settings change / shutdown never leaves TX blocked).
-func (a *App) motorTXInhibitLoop(c motorAntenna, stop <-chan struct{}) {
+func (a *App) motorTXInhibitLoop(c motorAntenna, bands []string, stop <-chan struct{}) {
 	const grace = 3 * time.Second // cover the poll latency at the very start of a move
 	ticker := time.NewTicker(300 * time.Millisecond)
 	defer ticker.Stop()
@@ -14360,12 +14633,23 @@ func (a *App) motorTXInhibitLoop(c motorAntenna, stop <-chan struct{}) {
 			st := c.Status()
 			recentCmd := time.Since(time.Unix(0, a.motorMoveCmdNs.Load())) < grace
 			moving := st.Connected && (st.Moving || recentCmd)
+			// On a band the antenna doesn't cover, OpsLog never commands a move —
+			// so it must never gag TX for "antenna moving" either. Otherwise a
+			// stray polled Moving flag, or a move finishing from the previous band,
+			// blocks the operator's transmit on a band they work with a different
+			// antenna (the whole point of un-ticking the band). Hands off means
+			// hands off: no tune AND no inhibit.
+			if moving && a.cat != nil {
+				if rs := a.cat.State(); rs.Connected && rs.FreqHz > 0 && !motorBandAllowed(bands, rs.FreqHz) {
+					moving = false
+				}
+			}
 			a.applyMotorInhibit(moving)
 		}
 	}
 }
 
-func (a *App) ultrabeamFollowLoop(c motorAntenna, stepKHz int, stop <-chan struct{}) {
+func (a *App) ultrabeamFollowLoop(c motorAntenna, stepKHz int, bands []string, stop <-chan struct{}) {
 	if stepKHz <= 0 {
 		stepKHz = 50
 	}
@@ -14394,17 +14678,22 @@ func (a *App) ultrabeamFollowLoop(c motorAntenna, stepKHz int, stop <-chan struc
 			// follow loop chases. If the antenna QSYs unexpectedly, this shows the
 			// CAT backend started reporting that frequency (e.g. WSJT-X moved the
 			// dial, or the active slice changed) even though you didn't touch the VFO.
-			if rigKHz != lastRigKHz {
+			newFreq := rigKHz != lastRigKHz
+			if newFreq {
 				applog.Printf("ultrabeam: follow loop reads rig freq %.3f MHz (mode %s) — antenna at %d kHz, step %d kHz",
 					float64(rs.FreqHz)/1e6, rs.Mode, st.Frequency, stepKHz)
 				lastRigKHz = rigKHz
 			}
-			// Skip frequencies outside the antenna's tunable range (other band).
-			if st.FreqMin > 0 && st.FreqMax > 0 {
-				rigMHz := rs.FreqHz / 1_000_000
-				if rigMHz < int64(st.FreqMin) || rigMHz > int64(st.FreqMax) {
-					continue
+			// Skip bands the antenna doesn't cover (per the operator's band list) —
+			// no tune command, so the elements stay where they are on 80 m, an
+			// un-fitted 30 m, etc. Log the decision once per QSY so "why did/didn't
+			// the antenna move" is answerable from the log.
+			if !motorBandAllowed(bands, rs.FreqHz) {
+				if newFreq {
+					applog.Printf("ultrabeam: %.3f MHz is %q — not in covered bands %v; leaving the antenna put",
+						float64(rs.FreqHz)/1e6, bandForHz(rs.FreqHz), bands)
 				}
+				continue
 			}
 			// Deadband reference = the rig freq we LAST commanded a move for, not the
 			// antenna's reported freq. A SteppIR reports a flaky/stale status
@@ -15815,18 +16104,46 @@ type SpotStatus struct {
 	Pfx    string `json:"pfx,omitempty"`
 }
 
-// ClusterSpotStatuses takes a batch of spots and returns slot status for
-// each. Used by the Cluster tab to color rows (NEW / NEW BAND / NEW SLOT
-// / WORKED). One cty.dat lookup + one DB scan, regardless of batch size.
-//
-// Mode handling: when the caller passes an empty Mode (cluster comment
-// was ambiguous and the frontend couldn't infer) we degrade gracefully
-// to band-only — saying "worked" rather than wrongly flagging "new-slot"
-// just because we don't know the mode.
-func (a *App) ClusterSpotStatuses(spots []SpotQuery) []SpotStatus {
-	out := make([]SpotStatus, len(spots))
+// clusterStatusCache holds the whole-logbook maps ClusterSpotStatuses colours
+// spots against. Rebuilding them per spot batch re-scanned the entire logbook
+// ~20×/second under an RBN firehose — the dominant CPU cost on a large log. This
+// is an immutable snapshot: once built its maps are never mutated, so a batch
+// that already holds the pointer keeps reading valid (stale-by-one-log) data
+// while a newer snapshot is being built. See clusterStatusMaps.
+type clusterStatusCache struct {
+	entities        map[int]*qso.EntitySlot
+	workedCalls     map[string]struct{}
+	workedCallSlots map[string]struct{} // nil unless the "same slot" option is on
+	workedCounties  map[string]struct{}
+	workedPOTA      map[string]struct{}
+	workedPfx       map[string]struct{}
+	normMode        func(string) string // nil unless digital-mode grouping is on
+	groupDigital    bool                // settings the maps were built under —
+	sameSlot        bool                // a change rebuilds the snapshot
+}
+
+// clusterStatusMaps returns the cached worked-index snapshot, building it once
+// per logbook change (invalidated by invalidateAwardStats) or when a setting
+// that shapes the maps flips. This turns the per-batch full-logbook scans into
+// one scan per logged QSO — the fix for the RBN-firehose CPU pegging.
+func (a *App) clusterStatusMaps() *clusterStatusCache {
+	groupDigital := a.groupDigitalSlots()
+	sameSlot := a.clusterWorkedSameSlot()
+	a.clusterStatusMu.Lock()
+	defer a.clusterStatusMu.Unlock()
+	if c := a.clusterStatusIdx; c != nil && c.groupDigital == groupDigital && c.sameSlot == sameSlot {
+		return c
+	}
+	c := &clusterStatusCache{groupDigital: groupDigital, sameSlot: sameSlot}
 	if a.qso == nil {
-		return out
+		a.clusterStatusIdx = c
+		return c
+	}
+	// Optional digital-mode grouping (Settings → General): with it on, FT8/FT4/
+	// RTTY… all count as ONE "DIG" mode, so an FT4 spot on a band where FT8 was
+	// worked shows "worked", not "new-slot" — DXCC-style mode classes.
+	if groupDigital {
+		c.normMode = qso.GroupDigitalMode
 	}
 	// Compare by DXCC entity NUMBER, not name. For each logged QSO the key is
 	// its stored DXCC if present (the authoritative value set at log time, incl.
@@ -15849,42 +16166,79 @@ func (a *App) ClusterSpotStatuses(spots []SpotQuery) []SpotStatus {
 		}
 		return 0
 	}
-	// Optional digital-mode grouping (Settings → General): with it on, FT8/FT4/
-	// RTTY… all count as ONE "DIG" mode, so an FT4 spot on a band where FT8 was
-	// worked shows "worked", not "new-slot" — DXCC-style mode classes.
-	var normMode func(string) string
-	if a.groupDigitalSlots() {
-		normMode = qso.GroupDigitalMode
-	}
-	entities, err := a.qso.EntitySlotMap(a.ctx, keyFor, normMode)
-	if err != nil {
-		return out
-	}
+	c.entities, _ = a.qso.EntitySlotMap(a.ctx, keyFor, c.normMode)
 	// Per-call worked set — separate from the entity check so we can flag
 	// "I've already QSO'd this exact station" even when the band/mode
 	// makes the entity check say "new-band" or "new-slot".
-	workedCalls, _ := a.qso.WorkedCallsigns(a.ctx)
+	c.workedCalls, _ = a.qso.WorkedCallsigns(a.ctx)
+	// "Already worked only on the same slot" option (Settings → DX Cluster): the
+	// WORKED-call flag then needs the SAME band and mode (digital-grouped through
+	// the same normMode when that option is on) rather than the call anywhere.
+	if sameSlot {
+		c.workedCallSlots, _ = a.qso.WorkedCallSlotKeys(a.ctx, c.normMode)
+	}
 	// Orthogonal dimensions: worked US counties (for the ULS callsign→county
-	// lookup) and worked POTA parks. Both built once per batch.
-	workedCounties, _ := a.qso.WorkedCountyKeys(a.ctx, award.USCountyKey)
-	workedPOTA, _ := a.qso.WorkedPOTARefs(a.ctx)
+	// lookup) and worked POTA parks.
+	c.workedCounties, _ = a.qso.WorkedCountyKeys(a.ctx, award.USCountyKey)
+	c.workedPOTA, _ = a.qso.WorkedPOTARefs(a.ctx)
 	// Worked WPX prefixes, derived from the callsigns we already loaded — no
 	// extra query. Derived rather than read from the stored PFX column: that
 	// column is only filled when an import supplied it, and deriving keeps this
 	// in step with the WPX award, which does the same thing.
-	workedPfx := make(map[string]struct{}, len(workedCalls))
-	for c := range workedCalls {
-		if p := award.WPXPrefix(c); p != "" {
-			workedPfx[p] = struct{}{}
+	c.workedPfx = make(map[string]struct{}, len(c.workedCalls))
+	for call := range c.workedCalls {
+		if p := award.WPXPrefix(call); p != "" {
+			c.workedPfx[p] = struct{}{}
 		}
 	}
+	a.clusterStatusIdx = c
+	return c
+}
+
+// ClusterSpotStatuses takes a batch of spots and returns slot status for
+// each. Used by the Cluster tab to color rows (NEW / NEW BAND / NEW SLOT
+// / WORKED). Reads the cached worked-index snapshot (clusterStatusMaps) so a
+// spot batch never re-scans the logbook — critical under an RBN firehose.
+//
+// Mode handling: when the caller passes an empty Mode (cluster comment
+// was ambiguous and the frontend couldn't infer) we degrade gracefully
+// to band-only — saying "worked" rather than wrongly flagging "new-slot"
+// just because we don't know the mode.
+func (a *App) ClusterSpotStatuses(spots []SpotQuery) []SpotStatus {
+	out := make([]SpotStatus, len(spots))
+	if a.qso == nil {
+		return out
+	}
+	idx := a.clusterStatusMaps()
+	entities := idx.entities
+	workedCalls := idx.workedCalls
+	workedCallSlots := idx.workedCallSlots
+	workedCounties := idx.workedCounties
+	workedPOTA := idx.workedPOTA
+	workedPfx := idx.workedPfx
+	normMode := idx.normMode
+	sameSlot := idx.sameSlot
 	for i, q := range spots {
 		out[i] = SpotStatus{
 			Call: q.Call,
 			Band: strings.ToLower(q.Band),
 			Mode: strings.ToUpper(q.Mode),
 		}
-		if _, ok := workedCalls[strings.ToUpper(q.Call)]; ok {
+		if sameSlot {
+			// Already worked ONLY when this exact band+mode slot was worked. With no
+			// inferable mode, fall back to same-band (better than claiming the whole
+			// call is fresh). Digital grouping folds through the same normMode.
+			upCall := strings.ToUpper(q.Call)
+			if out[i].Mode == "" {
+				_, out[i].WorkedCall = workedCallSlots[upCall+"|"+out[i].Band]
+			} else {
+				cm := out[i].Mode
+				if normMode != nil {
+					cm = normMode(cm)
+				}
+				_, out[i].WorkedCall = workedCallSlots[upCall+"|"+out[i].Band+"|"+cm]
+			}
+		} else if _, ok := workedCalls[strings.ToUpper(q.Call)]; ok {
 			out[i].WorkedCall = true
 		}
 		// NEW PFX: the spot's CQ WPX prefix, never worked before.

app_awards_tracked.go

@@ -0,0 +1,57 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	wruntime "github.com/wailsapp/wails/v2/pkg/runtime"
+)
+
+// keyAwardsTracked holds the PER-PROFILE list of award codes the operator wants
+// to follow (JSON array of award.Def.Code). Award definitions themselves are
+// global (keyAwardDefs, shared across profiles), but WHICH awards a station
+// tracks is a per-profile choice — a DX profile follows DXCC/WPX, a POTA profile
+// follows POTA/WWFF. An empty/unset list means "track them all" so the Awards
+// tab is never blank before the operator has picked anything.
+const keyAwardsTracked = "awards.tracked"
+
+// GetTrackedAwards returns the active profile's followed award codes. An empty
+// slice means the operator has not narrowed the list — the Awards tab then shows
+// every award.
+func (a *App) GetTrackedAwards() ([]string, error) {
+	out := []string{}
+	if a.settings == nil {
+		return out, nil
+	}
+	s, _ := a.settings.Get(a.ctx, keyAwardsTracked)
+	if strings.TrimSpace(s) == "" {
+		return out, nil
+	}
+	if err := json.Unmarshal([]byte(s), &out); err != nil {
+		return []string{}, nil
+	}
+	return out, nil
+}
+
+// SaveTrackedAwards persists the followed award codes for the active profile and
+// notifies the Awards tab to re-filter its list. Codes are stored verbatim; the
+// Awards tab intersects them with the live award definitions, so a code that no
+// longer exists is simply ignored (not an error).
+func (a *App) SaveTrackedAwards(codes []string) error {
+	if a.settings == nil {
+		return fmt.Errorf("db not initialized")
+	}
+	if codes == nil {
+		codes = []string{}
+	}
+	b, err := json.Marshal(codes)
+	if err != nil {
+		return err
+	}
+	if err := a.settings.Set(a.ctx, keyAwardsTracked, string(b)); err != nil {
+		return err
+	}
+	wruntime.EventsEmit(a.ctx, "awards:tracked-changed")
+	return nil
+}

app_gate.go

@@ -0,0 +1,60 @@
+package main
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"os"
+	"strings"
+)
+
+// deniedCallHashes lists station callsigns not permitted to run this build,
+// stored as SHA-256 hex of the base call so the calls themselves appear nowhere
+// in the source or the compiled binary. Enforcement is best-effort by design —
+// the call is entered by the operator and can be changed — so this only turns
+// away straightforward use, not a determined one.
+var deniedCallHashes = map[string]struct{}{
+	"2282a88b3e5e4eebc6b8174d005bb46d32025758b7741bdcf34f2b3621c02205": {},
+	"0ee09fe60817a2a4982f5e5b14a60b8dbb11cff55b3d36661213c4cbdd0933ea": {},
+	"46fb61e71afb40627cb6493a6a59c9d4d0231ee3cad1a2bf3fcc4cdfce36fabc": {},
+}
+
+// callDenied reports whether a callsign is on deniedCallHashes. The call is
+// reduced to its base form (upper-cased, portable prefix/suffix dropped) the
+// same way extsvc does, so F4XYZ/P matches F4XYZ.
+func callDenied(call string) bool {
+	base := denyBaseCall(call)
+	if base == "" {
+		return false
+	}
+	sum := sha256.Sum256([]byte(base))
+	_, bad := deniedCallHashes[hex.EncodeToString(sum[:])]
+	return bad
+}
+
+// denyBaseCall mirrors extsvc.baseCall: for a slashed form it returns the
+// longest token (the real call), otherwise the call itself, upper-cased.
+func denyBaseCall(s string) string {
+	s = strings.ToUpper(strings.TrimSpace(s))
+	if !strings.Contains(s, "/") {
+		return s
+	}
+	best := ""
+	for _, part := range strings.Split(s, "/") {
+		if len(part) > len(best) {
+			best = part
+		}
+	}
+	return best
+}
+
+// enforceCallGate exits the process silently when any of the supplied callsigns
+// is denied. Called once at startup, after the profiles are loaded: the first
+// launch is where the operator enters and saves the call, so a denied build
+// simply does not come back up on the next launch. No window, no message.
+func enforceCallGate(calls ...string) {
+	for _, c := range calls {
+		if callDenied(c) {
+			os.Exit(0)
+		}
+	}
+}

changelog.json

@@ -1,4 +1,108 @@
 [
+  {
+    "version": "0.23.9",
+    "date": "",
+    "en": [],
+    "fr": []
+  },
+  {
+    "version": "0.23.8",
+    "date": "",
+    "en": [
+      "E-mail: the QSO recording e-mail (subject and body) is now editable in Settings → E-mail, like the QSL card e-mail — with the {CALL} {DATE} {BAND} {MODE} {MYCALL} variables.",
+      "Backup fix: the backup now saves your CONTACTS (the logbook), not just the settings. Once the logbook was split into its own file, the backup kept snapshotting the settings database and silently missed the QSOs. It now writes the log to opslog-*.db and the configuration separately to opslogcfg-*.db (MySQL logs still export to ADIF).",
+      "Performance: much lower CPU and memory on a busy cluster (RBN and other high-volume feeds). The Cluster tab was re-scanning the entire logbook for every batch of spots (~20×/second) and its spot-status cache grew without limit — on a firehose that could climb to gigabytes of RAM and peg a CPU. The worked-index is now cached (rebuilt only when you log a QSO) and the status cache is bounded to the spots actually shown."
+    ],
+    "fr": [
+      "E-mail : le texte de l'e-mail d'enregistrement QSO (objet et corps) est désormais modifiable dans Réglages → E-mail, comme l'e-mail de carte QSL — avec les variables {CALL} {DATE} {BAND} {MODE} {MYCALL}.",
+      "Correction sauvegarde : la sauvegarde enregistre désormais tes CONTACTS (le journal), et plus seulement les réglages. Depuis que le journal a été séparé dans son propre fichier, la sauvegarde continuait à copier la base des réglages et oubliait les QSO. Elle écrit maintenant le log dans opslog-*.db et la configuration à part dans opslogcfg-*.db (les logs MySQL restent exportés en ADIF).",
+      "Performances : CPU et mémoire nettement réduits sur un cluster chargé (RBN et autres flux à fort volume). L'onglet Cluster rescannait tout le journal à chaque lot de spots (~20×/seconde) et son cache de statuts grossissait sans limite — sur un flux intense cela pouvait atteindre des gigaoctets de RAM et saturer un cœur. L'index des contacts est désormais mis en cache (reconstruit seulement quand tu logues un QSO) et le cache de statuts est borné aux spots réellement affichés."
+    ]
+  },
+  {
+    "version": "0.23.7",
+    "date": "",
+    "en": [
+      "QSO edit: added the QRZ ↗ button next to the callsign, like the main entry form — one click opens that station's qrz.com profile.",
+      "PowerGenius XL: the fan mode (Standard / Contest / Broadcast) changes on the amp again. A previous fix dropped the \"setup\" prefix the amp requires (\"setup fanmode=…\"), so the amp rejected the command and the mode snapped straight back. The correct command is restored.",
+      "Performance: fixed a slowdown introduced in 0.23.6. To dim the \"represents nothing\" spots, the DX Cluster grid was redrawing EVERY row on each spot-status update, which pegged the CPU on a busy cluster (some PCs became sluggish). The dimming now updates with a light per-cell refresh instead — same look, no more churn.",
+      "DX Cluster: after you log a QSO, the spots update — a callsign, entity, POTA, prefix or band/mode slot you just worked stops showing its NEW badge, instead of staying \"new\" until a restart. Kept fast: it re-evaluates only while the cluster is actually on screen (nothing runs otherwise — a QSO logged while it's hidden refreshes once when you next open it), and it's debounced so a quick run doesn't re-scan on every QSO.",
+      "Station Control relays (WebSwitch / KMTronic / Dingtian): the Host field now accepts a full URL, so you can reach a network relay board through an HTTPS reverse proxy — e.g. https://relay.yourdomain.com.",
+      "Stats slot drill-down: the pop-up listing the QSOs behind a band/mode square looks tidier (banded rows, cleaner header), and you can now click a callsign in it to open that QSO for editing.",
+      "DCU-1 rotor support: OpsLog can now steer controllers that speak the Hy-Gain DCU-1 protocol (RotorCard DXA for Yaesu DXA rotors, Idiom Press Rotor-EZ, Green Heron) over their COM port or a serial-over-IP bridge.",
+      "Motorized antenna: Settings → Antenna now has a Covered bands selector (40 m–6 m) instead of a min/max range, for both the Ultrabeam and the SteppIR. Tick only the bands your antenna does — untick one you can't (e.g. 30 m without its extension) while keeping the rest — and OpsLog leaves the antenna put on every other band. This overrides an unreliable controller, so 80 m no longer clamps the elements down to 30 m. Existing range settings migrate automatically.",
+      "Motorized antenna: on a band you did not tick in Covered bands, OpsLog no longer inhibits FlexRadio transmit for \"antenna moving\". Un-ticking a band now means hands off completely — no tuning and no TX block — so working it on another antenna is never gagged.",
+      "Awards: a new Settings → Awards picker (under User configuration) lets you choose which awards to follow — a two-column list, all awards on the left, the ones you track on the right. The Awards tab then shows only those you follow (per profile; leave the right side empty to show them all).",
+      "Kenwood/Elecraft CAT: the link no longer drops while the rig is transmitting. A K3 (and other Kenwood-dialect rigs) answers \"?;\" to a status poll during transmit; OpsLog used to read that as \"rig doesn't support IF\" and disconnect — which tore down the shared CAT that WSJT-X / JTDX key through, so the radio wouldn't transmit properly. OpsLog now pauses status polling while PTT is held and keeps the link up.",
+      "New award: Russian District Award (RDA) — tracks the 2660 Russian districts, worked and confirmed per band."
+    ],
+    "fr": [
+      "Édition de QSO : ajout du bouton QRZ ↗ à côté de l'indicatif, comme dans le formulaire de saisie — un clic ouvre le profil qrz.com de la station.",
+      "PowerGenius XL : le mode ventilateur (Standard / Contest / Broadcast) change de nouveau sur l'ampli. Un correctif précédent avait retiré le préfixe « setup » exigé par l'ampli (« setup fanmode=… »), qui rejetait donc la commande et le mode revenait aussitôt en arrière. La bonne commande est rétablie.",
+      "Performance : correction d'un ralentissement apparu en 0.23.6. Pour atténuer les spots « qui ne représentent rien », la grille du DX Cluster redessinait TOUTES les lignes à chaque mise à jour de statut, ce qui saturait le CPU sur un cluster actif (des PC devenaient lents). L'atténuation se met désormais à jour via un rafraîchissement léger par cellule — même rendu, sans le brassage.",
+      "DX Cluster : après avoir loggué un QSO, les spots se mettent à jour — un indicatif, une entité, un POTA, un préfixe ou un slot bande/mode que vous venez de contacter cesse d'afficher son badge NEW, au lieu de rester « new » jusqu'au redémarrage. Reste rapide : la réévaluation n'a lieu que si le cluster est affiché (sinon rien ne tourne — un QSO loggué cluster caché se rafraîchit une fois à sa réouverture), et c'est débouncé pour ne pas re-scanner à chaque QSO en série.",
+      "Relais du Contrôle station (WebSwitch / KMTronic / Dingtian) : le champ Hôte accepte désormais une URL complète ex. https://relais.tondomaine.com derrière Nginx Proxy Manager. Avant, OpsLog forçait http://<hôte>, donc une carte sur le LAN derrière un proxy (quand vos 80/443 vont déjà ailleurs) était injoignable de l'extérieur.",
+      "Détail d’un slot Stats : la fenêtre listant les QSO derrière une case bande/mode est plus soignée (lignes alternées, en-tête plus propre), et vous pouvez maintenant cliquer un indicatif pour ouvrir ce QSO en édition.",
+      "Prise en charge des rotors DCU-1 : OpsLog pilote désormais les contrôleurs parlant le protocole Hy-Gain DCU-1 (RotorCard DXA pour rotors Yaesu DXA, Idiom Press Rotor-EZ, Green Heron) via leur port COM ou un pont série-sur-IP.",
+      "Antenne motorisée : Réglages → Antenne propose désormais un sélecteur Bandes couvertes (40 m–6 m) au lieu d'une plage min/max, pour l'Ultrabeam comme pour la SteppIR. Coche seulement les bandes que fait ton antenne — décoche celle que tu ne fais pas (p. ex. le 30 m sans son extension) en gardant les autres — et OpsLog laisse l'antenne en place sur toutes les autres. Ceci prime sur un contrôleur peu fiable : le 80 m ne replie plus les éléments sur le 30 m. Les anciens réglages de plage sont migrés automatiquement.",
+      "Antenne motorisée : sur une bande non cochée dans Bandes couvertes, OpsLog n'inhibe plus l'émission du FlexRadio pour « antenne en mouvement ». Décocher une bande signifie désormais ne plus y toucher du tout — ni accord ni blocage TX — pour ne jamais couper le trafic sur une autre antenne.",
+      "Diplômes : un nouveau sélecteur Réglages → Diplômes (dans Configuration utilisateur) permet de choisir les diplômes à suivre — une liste à deux colonnes, tous les diplômes à gauche, ceux que tu suis à droite. L'onglet Awards n'affiche alors que ceux-là (par profil ; laisse la colonne de droite vide pour tous les afficher).",
+      "CAT Kenwood/Elecraft : le lien ne tombe plus pendant que le rig émet. Un K3 (et d'autres rigs en dialecte Kenwood) répond \"?;\" à une interrogation d'état pendant l'émission ; OpsLog le prenait pour \"le rig ne supporte pas IF\" et se déconnectait — ce qui cassait le CAT partagé que WSJT-X / JTDX utilisent pour passer en émission, d'où l'absence d'émission. OpsLog suspend désormais l'interrogation d'état tant que le PTT est actif et garde le lien.",
+      "Nouveau diplôme : Russian District Award (RDA) — suit les 2660 districts russes, travaillés et confirmés par bande."
+    ]
+  },
+  {
+    "version": "0.23.6",
+    "date": "",
+    "en": [
+      "Log viewer: the window now keeps twice as much history (512 KB instead of 256 KB, ~3200 lines). During a busy trace the oldest lines used to scroll out of the buffer while you were still reading them; the larger window holds them.",
+      "Ultrabeam over a remote link: fixed intermittent connection drops, phantom frequency jumps and wrong element-length readings. On a slow link a command that timed out left its late reply in the stream, and the next command read it as its own — crossing a status query with an element-length one, for instance. The stream is now flushed of any stale reply before each command, keeping the exchange in step.",
+      "Ultrabeam: the 'moving' indicator and the Flex TX-inhibit now react the instant you click a band or pattern, instead of up to a status poll (~2 s) later. A commanded move reports motion immediately; the real motor state takes over once the next poll reads it.",
+      "CAT sharing (FT8): JTDX/WSJT-X transmit correctly again through OpsLog's shared rig. get_ptt now echoes the PTT state the client last commanded — clients poll it DURING transmit to confirm the rig is keyed, and OpsLog always answering 'receiving' made them give up and drop the over after a second or two. The 0.23.5 'Fake It' anti-drift tweak was also reverted (it had made this total — no transmit at all); the small dial creep in 'Fake It' split can return, and JTDX's 'Split Operation: None' avoids it.",
+      "CAT settings: trimmed the long help text under the Kenwood and CAT-sharing fields down to the essentials — less clutter.",
+      "Entry form: fixed two ways a stray QSO could sneak in. Pressing Enter in the TX/RX frequency field now only tunes the radio — it was also submitting the contact. And a bare number with no letter (JTDX/WSJT-X sometimes broadcasts \"1\" as the DX call) is no longer accepted into the callsign field, where it could get logged as callsign \"1\".",
+      "SPE amplifier: switching the amp off in OpsLog now shows \"off\" straight away and lets you switch it back on without restarting. The already-open connection kept reading as connected after the off keystroke, so the panel stayed \"on\" and the ON button did nothing until a restart. OpsLog now drops the link on power-off, exactly as a fresh start would — the ON button's RTS/DTR wake then works.",
+      "Alt+W clears the QSO entry, the shortcut used by most other loggers. Unlike Esc it always works, even when the CW keyer has Esc reserved.",
+      "The Grid box no longer pops outside the QSO entry panel when the window is narrowed — it wraps to its own line instead.",
+      "Selecting a QSO in the Recent QSOs list now shows that station in the Stats (F1) matrix, instead of leaving it blank.",
+      "Stats (F1): click any coloured band/mode square to list the contacts behind it.",
+      "Awards: the DXCC list now shows each entity’s main prefix (XE, DL, F…) in its own sortable, searchable column.",
+      "DX Cluster: new option \"Already worked only on the same slot\" (Settings → DX Cluster). With it on, a spot reads \"worked\" only when you worked that callsign on the SAME band and mode — not just anywhere. It respects the digital-mode grouping (Settings → General): grouped, a 20m FT8 contact also marks a 20m FT4 spot as worked; ungrouped, FT8 and FT4 are separate slots.",
+      "DX Cluster: added a WORKED status-filter chip, so you can show — or, with the other chips off, isolate — already-worked spots, not only hide them with the \"Hide worked\" checkbox.",
+      "DX Cluster: spots that represent nothing — entity/band/mode already worked, the callsign not in your log, no POTA/county/prefix novelty — are now dimmed, so your eye skips them and the spots worth working stand out. What counts as \"nothing\" follows the \"same slot\" option and the digital-mode grouping.",
+      "Ultrabeam: an older controller (seen over an RS232-to-Ethernet bridge) answers with an 11-byte status frame instead of 12. OpsLog rejected it as \"too short\" and reconnect-looped; it now accepts a shorter checksum-valid frame and defaults the missing tail field.",
+      "Fixed a crash (React #300) that could take down the whole window when the rig briefly reported an unusual band — for example a spurious 33 cm reading from an Icom. The Band Map had a keyboard-navigation hook after its early return for unknown bands, so the number of hooks changed between renders. The hook now always runs."
+    ],
+    "fr": [
+      "Visionneuse de log : la fenêtre conserve deux fois plus d'historique (512 Ko au lieu de 256 Ko, ~3200 lignes). Lors d'une trace chargée, les plus vieilles lignes défilaient hors du buffer pendant qu'on les lisait encore ; la fenêtre agrandie les garde.",
+      "Ultrabeam en remote : coupures de connexion intermittentes, sauts de fréquence fantômes et longueurs d'éléments erronées corrigés. Sur un lien lent, une commande qui expirait laissait sa réponse tardive dans le flux, et la commande suivante la lisait comme la sienne — croisant par exemple une requête de statut avec une requête de longueurs d'éléments. Le flux est désormais vidé de toute réponse périmée avant chaque commande, gardant l'échange synchronisé.",
+      "Ultrabeam : l'indicateur « en mouvement » et l'inhibition d'émission Flex réagissent désormais dès que vous cliquez sur une bande ou un diagramme, au lieu d'attendre jusqu'à un poll de statut (~2 s). Un mouvement commandé signale le déplacement immédiatement ; l'état réel des moteurs prend le relais dès le poll suivant.",
+      "Partage CAT (FT8) : JTDX/WSJT-X émettent de nouveau correctement via la radio partagée d'OpsLog. get_ptt renvoie désormais l'état PTT commandé en dernier par le client — les clients l'interrogent PENDANT l'émission pour confirmer que la radio est en émission, et comme OpsLog répondait toujours « réception », ils abandonnaient et coupaient l'émission au bout d'une seconde ou deux. L'ajustement anti-drift « Fake It » de la 0.23.5 a aussi été annulé (il rendait le problème total — aucune émission) ; le léger glissement du VFO en split « Fake It » peut réapparaître, et « Split Operation : None » dans JTDX l'évite.",
+      "Réglages CAT : textes d'aide raccourcis sous les champs Kenwood et partage CAT — moins de fouillis.",
+      "Formulaire de saisie : deux façons de logguer un QSO parasite corrigées. Appuyer sur Entrée dans le champ fréquence TX/RX ne fait plus que syntoniser la radio — cela validait aussi le contact. Et un nombre nu sans lettre (JTDX/WSJT-X diffuse parfois « 1 » comme DX call) n'est plus accepté dans le champ indicatif, où il pouvait être loggué comme indicatif « 1 ».",
+      "Ampli SPE : éteindre l'ampli depuis OpsLog affiche désormais « off » tout de suite et permet de le rallumer sans redémarrer. La connexion déjà ouverte continuait d'être vue comme connectée après la touche d'extinction, le panneau restait donc « on » et le bouton ON ne faisait rien jusqu'à un redémarrage. OpsLog largue maintenant le lien à l'extinction, exactement comme un démarrage à neuf — le réveil RTS/DTR du bouton ON fonctionne alors.",
+      "Alt+W efface la saisie du QSO, le raccourci utilisé par la plupart des autres logiciels. Contrairement à Échap, il fonctionne toujours, même quand Échap est réservé au manipulateur CW.",
+      "Le champ Locator ne déborde plus du panneau de saisie quand la fenêtre est rétrécie — il passe à la ligne.",
+      "Sélectionner un QSO dans la liste des QSO récents affiche désormais cette station dans la matrice Stats (F1), au lieu de la laisser vide.",
+      "Stats (F1) : cliquer sur une case bande/mode colorée liste les contacts correspondants.",
+      "Diplômes : la liste DXCC affiche le préfixe principal de chaque entité (XE, DL, F…) dans une colonne triable et cherchable.",
+      "DX Cluster : nouvelle option « Déjà contacté seulement sur le même slot » (Réglages → DX Cluster). Activée, un spot n'affiche « contacté » que si vous avez contacté cet indicatif sur la MÊME bande et le MÊME mode — pas juste n'importe où. Elle respecte le groupage des modes numériques (Réglages → Général) : groupé, un contact 20m FT8 marque aussi un spot 20m FT4 comme contacté ; dégroupé, FT8 et FT4 sont des slots distincts.",
+      "DX Cluster : ajout d'un filtre de statut WORKED, pour afficher — ou, en désactivant les autres, isoler — les spots déjà contactés, pas seulement les masquer avec la case « Masquer les contactés ».",
+      "DX Cluster : les spots qui ne représentent rien — entité/bande/mode déjà faite, indicatif absent du journal, aucune nouveauté POTA/comté/préfixe — sont désormais atténués, pour que l'œil les ignore et que les spots à travailler ressortent. Ce qui compte comme « rien » suit l'option « même slot » et le groupage des modes numériques.",
+      "Ultrabeam : un contrôleur plus ancien (vu derrière un pont RS232-Ethernet) répond avec une trame de statut de 11 octets au lieu de 12. OpsLog la rejetait comme « trop courte » et bouclait en reconnexion ; il accepte désormais une trame valide plus courte et met par défaut le champ de fin manquant.",
+      "Correction d'un plantage (React #300) qui pouvait faire tomber toute la fenêtre quand la radio rapportait brièvement une bande inhabituelle — par exemple une lecture 33 cm parasite d'un Icom. La Band Map avait un hook de navigation clavier après son retour anticipé pour les bandes inconnues, changeant le nombre de hooks entre deux rendus. Le hook est désormais toujours exécuté."
+    ]
+  },
+  {
+    "version": "0.23.5",
+    "date": "",
+    "en": [
+      "CAT sharing (Hamlib rigctld): fixed a slow frequency drift in FT8. With a digital app (JTDX/WSJT-X) sharing OpsLog's rig in \"Fake It\" split, each transmit crept the dial down and never came back. The app follows the dial by polling, and our reply lagged the last tune by a poll cycle, so right after a transmission it read the still-shifted frequency, took it for a manual QSY and adopted it. Reads now echo the last commanded frequency until the rig confirms it — the dial holds. Applies to every backend, not just Kenwood."
+    ],
+    "fr": [
+      "Partage CAT (rigctld Hamlib) : dérive lente de fréquence en FT8 corrigée. Avec une app numérique (JTDX/WSJT-X) partageant la radio d'OpsLog en split « Fake It », chaque passage en émission faisait descendre le VFO sans jamais revenir. L'app suit le VFO en l'interrogeant, et notre réponse était en retard d'un cycle sur la dernière syntonisation : juste après une émission elle lisait la fréquence encore décalée, la prenait pour un QSY manuel et l'adoptait. Les lectures renvoient désormais la dernière fréquence commandée jusqu'à confirmation de la radio — le VFO tient. Vaut pour tous les backends, pas seulement Kenwood."
+    ]
+  },
   {
     "version": "0.23.4",
     "date": "",

frontend/src/App.tsx

@@ -1500,6 +1500,83 @@ export default function App() {
   // still need resolving without re-subscribing the cluster:spot listener.
   const spotStatusRef = useRef(spotStatus);
   useEffect(() => { spotStatusRef.current = spotStatus; }, [spotStatus]);
+  // Mirror of spots so the log-triggered refresh reads the current list without
+  // a stale closure.
+  const spotsRef = useRef(spots);
+  useEffect(() => { spotsRef.current = spots; }, [spots]);
+  // Bound the status cache. Keyed per call|band|mode, it otherwise kept an entry
+  // for every station ever seen — under an RBN firehose (thousands of unique
+  // calls/hour) that grew without limit to gigabytes. Prune it back to the live
+  // (SPOTS_CAP-limited) spots once it drifts well past them. The size check bails
+  // cheaply the rest of the time (returning the same reference, so no dependent
+  // memo re-runs); an evicted spot is just re-resolved if it reappears.
+  useEffect(() => {
+    setSpotStatus((prev) => {
+      const keys = Object.keys(prev);
+      if (keys.length <= SPOTS_CAP * 2) return prev;
+      const live = new Set(spots.map((x) => spotStatusKey(x.dx_call, x.band ?? '', x.comment ?? '', x.freq_hz)));
+      const pruned: typeof prev = {};
+      for (const k of keys) if (live.has(k)) pruned[k] = prev[k];
+      return pruned;
+    });
+  }, [spots]);
+  // Re-fetch the status of every SHOWN spot and OVERWRITE the cache (merge, never
+  // clear). Overwriting keeps the other NEW badges on screen until their fresh
+  // value lands, instead of blanking the whole grid and letting the badges pop
+  // back a moment later. The backend cost is one status batch regardless of spot
+  // count (it scans the logbook once), so this is as cheap as the poll already is.
+  const refreshSpotStatuses = useCallback(async () => {
+    const cur = spotsRef.current;
+    if (!cur.length) return;
+    const queries: { call: string; band: string; mode: string; pota_ref: string }[] = [];
+    const seen = new Set<string>();
+    for (const s of cur) {
+      const k = spotStatusKey(s.dx_call, s.band ?? '', s.comment ?? '', s.freq_hz);
+      if (seen.has(k)) continue;
+      seen.add(k);
+      queries.push({ call: s.dx_call, band: s.band ?? '', mode: inferSpotMode(s.comment ?? '', s.freq_hz), pota_ref: (s as any).pota_ref ?? '' });
+    }
+    if (!queries.length) return;
+    try {
+      const res = await ClusterSpotStatuses(queries as any);
+      setSpotStatus((prev) => {
+        const next = { ...prev };
+        for (const r of res) {
+          const k = `${r.call}|${r.band ?? ''}|${(r.mode ?? '').toUpperCase()}`;
+          next[k] = {
+            status: r.status ?? '', country: r.country, continent: (r as any).continent,
+            worked_call: !!(r as any).worked_call, new_county: !!(r as any).new_county,
+            new_pota: !!(r as any).new_pota, new_pfx: !!(r as any).new_pfx, pfx: (r as any).pfx,
+          };
+        }
+        return next;
+      });
+    } catch { /* leave the old statuses in place on failure */ }
+  }, []);
+  // After a QSO is logged, refresh the shown spots so a call/entity/POTA/prefix/
+  // slot just worked drops its NEW badge — WITHOUT blanking the others (see the
+  // merge above). Kept cheap: only while the cluster is on screen (a log while
+  // hidden marks it dirty and refreshes ONCE on next open), and debounced so a
+  // fast run coalesces instead of re-scanning per QSO.
+  const clusterVisibleRef = useRef(false);
+  const spotsDirtyRef = useRef(false);
+  useEffect(() => {
+    const vis = mainPaneLeft === 'cluster' || mainPaneRight === 'cluster' || activeTab === 'cluster';
+    if (vis && !clusterVisibleRef.current && spotsDirtyRef.current) {
+      spotsDirtyRef.current = false;
+      void refreshSpotStatuses();
+    }
+    clusterVisibleRef.current = vis;
+  }, [mainPaneLeft, mainPaneRight, activeTab, refreshSpotStatuses]);
+  useEffect(() => {
+    let t: number | undefined;
+    const off = EventsOn('qso:logged', () => {
+      if (!clusterVisibleRef.current) { spotsDirtyRef.current = true; return; }
+      if (t) window.clearTimeout(t);
+      t = window.setTimeout(() => void refreshSpotStatuses(), 2000);
+    });
+    return () => { off(); if (t) window.clearTimeout(t); };
+  }, [refreshSpotStatuses]);
   // Incoming spots are staged here for a few ms, their status resolved, then
   // committed to `spots` together — so a row paints with its NEW BAND/MODE badge
   // already on, instead of flashing plain text then flipping to the pill.
@@ -1512,6 +1589,11 @@ export default function App() {
   const [deletingIds, setDeletingIds] = useState<number[]>([]);
   const [selectedId, setSelectedId] = useState<number | null>(null);
   const [selectedIds, setSelectedIds] = useState<number[]>([]);
+  // Call/band/mode of the QSO highlighted in the Recent-QSOs grid. Drives the
+  // Stats (F1) matrix whenever the entry form is empty — clicking a past contact
+  // is the natural way to ask "what else have I got with this one?", and until
+  // now the panel just sat blank.
+  const [selQso, setSelQso] = useState<{ call: string; band: string; mode: string } | null>(null);
   const [bulkEditIds, setBulkEditIds] = useState<number[]>([]);
   const [bulkEditOpen, setBulkEditOpen] = useState(false);
   const [showSettings, setShowSettings] = useState(false);
@@ -2607,6 +2689,11 @@ export default function App() {
     const applyUdpCall = (raw: string, force = false): boolean => {
       const call = String(raw ?? '').trim();
       if (!call) return false;
+      // A callsign always has at least one letter. WSJT-X/JTDX (and relayed spot
+      // clicks) sometimes broadcast a bare number in the DX-call field — famously
+      // "1" — which would land in the entry and, on the next Enter, log a QSO
+      // with callsign "1". Reject anything with no letter.
+      if (!/[a-z]/i.test(call)) return false;
       const upper = call.toUpperCase();
       const current = callsignValRef.current.trim().toUpperCase();
       const prev = lastUdpCallRef.current;
@@ -3310,6 +3397,24 @@ export default function App() {
     finally { setDeletingAll(false); }
   }
 
+  // Worked-before for the QSO highlighted in the grid. Deliberately NOT
+  // runWorkedBefore: that one owns the entry form's wbRef and can trigger a
+  // field backfill, which browsing the log must never do.
+  const [selWb, setSelWb] = useState<WB | null>(null);
+  const [selWbBusy, setSelWbBusy] = useState(false);
+  useEffect(() => {
+    const call = (selQso?.call ?? '').trim().toUpperCase();
+    // The entry form wins whenever it has a call — it's the live QSO.
+    if (!call || callsign.trim()) { setSelWb(null); return; }
+    let dead = false;
+    setSelWbBusy(true);
+    WorkedBefore(call, 0)
+      .then((w: any) => { if (!dead) setSelWb(w); })
+      .catch(() => { if (!dead) setSelWb(null); })
+      .finally(() => { if (!dead) setSelWbBusy(false); });
+    return () => { dead = true; };
+  }, [selQso, callsign]);
+
   async function runWorkedBefore(call: string, dxccHint: number = 0) {
     setWbBusy(true);
     try {
@@ -3854,6 +3959,16 @@ export default function App() {
       if ((e.ctrlKey || e.metaKey) && e.key.toLowerCase() === 'o') {
         e.preventDefault(); importAdif(); return;
       }
+      // Alt+W: wipe the entry. The near-universal logger convention (N1MM,
+      // Log4OM, DXLog), and unlike ESC it is never swallowed by the CW keyer —
+      // so there is always one key that clears, whatever else is running.
+      // Alt-combos carry no character on Windows, so this is safe while typing.
+      if (e.altKey && !e.ctrlKey && !e.metaKey && e.key.toLowerCase() === 'w') {
+        e.preventDefault();
+        resetEntry();
+        callsignRef.current?.focus();
+        return;
+      }
       if (typing) return;
       if (selectedId !== null) {
         if (e.key === 'Delete') { e.preventDefault(); askDeleteSelected(); return; }
@@ -4126,7 +4241,7 @@ export default function App() {
       </div>
     </>
   ) : (
-    <div className="flex flex-col flex-1 min-w-[130px]"><Label className="mb-1 h-3.5">{t('field.qth')}</Label>
+    <div className="flex flex-col flex-1 min-w-[80px]"><Label className="mb-1 h-3.5">{t('field.qth')}</Label>
       <Input value={qth} onChange={(e) => { setQth(e.target.value); markEdited('qth'); }} />
     </div>
   );
@@ -4355,7 +4470,7 @@ export default function App() {
         title={catState.connected ? t('field.freqTuneHint') : undefined}
         onFocus={() => setFreqFocused(true)}
         onBlur={() => setFreqFocused(false)}
-        onKeyDown={(e) => { if (e.key === 'Enter') tuneRadioTo(freqMhz); }}
+        onKeyDown={(e) => { if (e.key === 'Enter') { e.preventDefault(); e.stopPropagation(); tuneRadioTo(freqMhz); } }}
         onChange={(e) => { setFreqMhz(e.target.value); noteManualEdit(); const b = bandForMHz(parseFloat(e.target.value)); if (b) setBand(b); }}
       />
     </div>
@@ -4370,7 +4485,7 @@ export default function App() {
         title={catState.connected ? t('field.freqTuneHint') : undefined}
         onFocus={() => setFreqFocused(true)}
         onBlur={() => setFreqFocused(false)}
-        onKeyDown={(e) => { if (e.key === 'Enter') tuneRadioTo(rxFreqMhz); }}
+        onKeyDown={(e) => { if (e.key === 'Enter') { e.preventDefault(); e.stopPropagation(); tuneRadioTo(rxFreqMhz); } }}
         onChange={(e) => { setRxFreqMhz(e.target.value); noteManualEdit(); const rb = bandForMHz(parseFloat(e.target.value)); if (rb) setBandRx(rb); }}
         className={cn('font-mono', catState.split && 'bg-danger-muted/40 border-danger-border focus:bg-card')}
       />
@@ -4407,7 +4522,7 @@ export default function App() {
           </Button>
         )}
         <Button type="button" size="sm" variant="outline" onClick={() => { resetEntry(); callsignRef.current?.focus(); }} className="h-8 px-2.5 text-xs"
-          title="Clear the QSO entry (always — unlike Esc which may be reserved for the CW keyer)">
+          title="Clear the QSO entry — Alt+W (always works, unlike Esc which may be reserved for the CW keyer)">
           <Eraser className="size-3.5" />
           {t('btn.clear')}
         </Button>
@@ -4452,11 +4567,14 @@ export default function App() {
         const k = spotStatusKey(s.dx_call, s.band ?? '', s.comment ?? '', s.freq_hz);
         const e = spotStatus[k];
         const st = (e?.status || '') as SpotStatusKey;
-        // A previously-worked call counts as WORKED for filtering even when its
-        // entity status is still new-band/new-slot (the grid flags it WKD CALL),
-        // matching the "Hide worked" toggle. Additive: it still matches its own
-        // entity status too, so it stays visible under NEW BAND / NEW SLOT.
-        const matches = clusterStatusFilter.has(st)
+        // WORKED means "I've worked THIS callsign" — the blue WKD-CALL flag —
+        // NOT the entity status 'worked' (entity/band/mode already worked, which
+        // the grid shows as a plain "—"). So the 'worked' key is matched ONLY via
+        // worked_call below; exclude the entity status 'worked' from the generic
+        // match, or every "already-worked-entity" spot would slip through. A
+        // worked call still matches its own entity status too (new-band/new-slot),
+        // so it stays visible under those chips.
+        const matches = (st !== 'worked' && clusterStatusFilter.has(st))
           || (!!e?.worked_call && clusterStatusFilter.has('worked'))
           || (!!e?.new_pota && clusterStatusFilter.has('new-pota'))
           || (!!e?.new_county && clusterStatusFilter.has('new-county'))
@@ -4581,7 +4699,10 @@ export default function App() {
               { k: 'new-pota'   as SpotFilterKey, label: 'NEW POTA',   cls: 'bg-success-muted text-success-muted-foreground border-success-border' },
               { k: 'new-county' as SpotFilterKey, label: 'NEW COUNTY', cls: 'bg-success-muted text-success-muted-foreground border-success-border' },
               { k: 'new-pfx'    as SpotFilterKey, label: 'NEW PFX',    cls: 'bg-caution-muted text-caution-muted-foreground border-caution-border' },
-              // (no WORKED chip — use the "Hide worked" checkbox to drop dupes.)
+              // Blue, like the already-worked call in the grid. Selecting it keeps
+              // worked spots; the separate "Hide worked" checkbox drops them — they
+              // are opposite controls, so don't use both at once.
+              { k: 'worked'   as SpotFilterKey, label: 'WORKED',   cls: 'bg-info-muted text-info-muted-foreground border-info-border' },
             ]).map((s) => {
               const on = clusterStatusFilter.has(s.k);
               return (
@@ -4741,6 +4862,7 @@ export default function App() {
               onExportFiltered={exportFilteredADIF}
               onDelete={(ids) => setDeletingIds(ids)}
               onRowSelected={(ids) => { setSelectedIds(ids); setSelectedId(ids[0] ?? null); }}
+              onRowSelectedQso={(r) => setSelQso(r ? { call: String(r.callsign ?? ""), band: String(r.band ?? ""), mode: String(r.mode ?? "") } : null)}
             />
           </div>
         );
@@ -5478,7 +5600,10 @@ export default function App() {
             {/* Row 2: Name fixed to the Band/Mode/Country column width (300px) so
                 its right edge lines up with that column below; QTH grows to fill.
                 gap-4 matches Row 3 so QTH's left edge aligns with Comment/Note. */}
-            <div className="flex gap-4 items-end">
+            {/* flex-wrap, not overflow: at the narrowest window the Grid box used
+                to be pushed outside the entry panel and clipped. Wrapping drops
+                it to its own line instead, which stays readable. */}
+            <div className="flex gap-4 items-end flex-wrap">
               <div className="flex flex-col w-[300px] shrink-0"><Label className="mb-1 h-3.5">Name</Label>
                 <Input value={name} onChange={(e) => { setName(e.target.value); markEdited('name'); }} />
               </div>
@@ -5544,6 +5669,11 @@ export default function App() {
             band={band}
             mode={mode}
             bands={bands}
+            onEditQso={openEdit}
+            {...(!callsign.trim() && selQso ? {
+              slotCall: selQso.call, slotBand: selQso.band, slotMode: selQso.mode,
+              slotWb: selWb, slotWbBusy: selWbBusy,
+            } : {})}
             tab={detailTab}
             onTab={setDetailTab}
             keyerActive={(wkEnabled && wkStatus.connected) || dvkEnabled}
@@ -5994,6 +6124,7 @@ export default function App() {
                 onExportCabrilloFiltered={exportFilteredCabrillo}
                 onDelete={(ids) => setDeletingIds(ids)}
                 onRowSelected={(ids) => { setSelectedIds(ids); setSelectedId(ids[0] ?? null); }}
+              onRowSelectedQso={(r) => setSelQso(r ? { call: String(r.callsign ?? ""), band: String(r.band ?? ""), mode: String(r.mode ?? "") } : null)}
               />
               <div className="px-3 py-1.5 border-t border-border/60 text-[11px] text-muted-foreground flex items-center justify-between gap-3 bg-muted/30">
                 <div className="flex items-center gap-3">

frontend/src/components/AwardsPanel.tsx

@@ -1,6 +1,7 @@
 import { useEffect, useMemo, useState } from 'react';
 import { Award as AwardIcon, RefreshCw, Loader2, Search, Pencil, X, Grid3x3, List, BarChart3, AlertTriangle, ChevronUp, ChevronDown } from 'lucide-react';
-import { GetAwardDefs, GetAward, AwardCellQSOs, GetAwardStats, AwardMissingQSOs, ListAwardReferences, AssignAwardRefToQSOs, RescanAwards } from '../../wailsjs/go/main/App';
+import { GetAwardDefs, GetAward, AwardCellQSOs, GetAwardStats, AwardMissingQSOs, ListAwardReferences, AssignAwardRefToQSOs, RescanAwards, GetTrackedAwards } from '../../wailsjs/go/main/App';
+import { EventsOn } from '../../wailsjs/runtime/runtime';
 import { Input } from '@/components/ui/input';
 import { Button } from '@/components/ui/button';
 import { Checkbox } from '@/components/ui/checkbox';
@@ -137,13 +138,20 @@ export function AwardsPanel({ onEditQSO, onAwardsChanged }: { onEditQSO?: (id: n
     }
   }
 
-  // Load the award list (no QSO scan), then compute only the first award.
+  // Load the award list (no QSO scan), then compute only the first award. The
+  // list is narrowed to the awards the operator follows (Settings → Awards); an
+  // empty follow-set means "show them all" so the tab is never blank.
   async function loadList() {
     try {
-      const defs = ((await GetAwardDefs()) ?? []) as any[];
-      const list: AwardListItem[] = defs
+      const [defs, tracked] = await Promise.all([
+        GetAwardDefs().then((d) => (d ?? []) as any[]),
+        GetTrackedAwards().then((t) => (t ?? []) as string[]).catch(() => [] as string[]),
+      ]);
+      const follow = new Set(tracked);
+      let list: AwardListItem[] = defs
         .map((d) => ({ code: d.code, name: d.name, valid: d.valid, bands: d.valid_bands ?? [], emission: d.emission ?? [] }))
         .sort((a, b) => a.code.localeCompare(b.code));
+      if (follow.size > 0) list = list.filter((a) => follow.has(a.code));
       setAwardList(list);
       const first = list.find((a) => a.code === selected) ?? list[0];
       if (first) compute(first.code);
@@ -152,6 +160,12 @@ export function AwardsPanel({ onEditQSO, onAwardsChanged }: { onEditQSO?: (id: n
     }
   }
   useEffect(() => { loadList(); }, []);
+  // Re-filter when the operator changes their followed awards in Settings.
+  useEffect(() => {
+    const off = EventsOn('awards:tracked-changed', () => { loadList(); });
+    return () => { off(); };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
 
   const current = byCode[`${selected}|${modeFilter}`];
   // Recompute when the mode class changes: the bands, counts and confirmations
@@ -211,11 +225,14 @@ export function AwardsPanel({ onEditQSO, onAwardsChanged }: { onEditQSO?: (id: n
   // Alicante" — which reference order scatters across the whole table.
   // Remembered through writeUiPref rather than localStorage, so the choice
   // travels with a copied data/ folder like every other UI preference here.
-  const [refSort, setRefSort] = useState<'ref' | 'name'>(
-    () => (localStorage.getItem('opslog.awardRefSort') === 'name' ? 'name' : 'ref'));
+  const [refSort, setRefSort] = useState<'ref' | 'name' | 'group'>(
+    () => {
+      const v = localStorage.getItem('opslog.awardRefSort');
+      return v === 'name' || v === 'group' ? v : 'ref';
+    });
   const [refSortDir, setRefSortDir] = useState<'asc' | 'desc'>(
     () => (localStorage.getItem('opslog.awardRefSortDir') === 'desc' ? 'desc' : 'asc'));
-  const toggleRefSort = (k: 'ref' | 'name') => {
+  const toggleRefSort = (k: 'ref' | 'name' | 'group') => {
     if (k === refSort) {
       const d = refSortDir === 'asc' ? 'desc' : 'asc';
       setRefSortDir(d);
@@ -258,10 +275,26 @@ export function AwardsPanel({ onEditQSO, onAwardsChanged }: { onEditQSO?: (id: n
         if (c !== 0) return c * dir;
         return a.ref.localeCompare(b.ref) * dir; // stable tie-break
       }
+      if (refSort === 'group') {
+        // Prefix order (XE, YV, ZL…) — how a DX operator actually thinks about
+        // entities. Blank prefixes sink to the bottom regardless of direction,
+        // so an unresolved entity never heads the list.
+        const ag = a.group ?? '', bg = b.group ?? '';
+        if (!ag !== !bg) return ag ? -1 : 1;
+        const c = ag.localeCompare(bg, undefined, { sensitivity: 'base' });
+        if (c !== 0) return c * dir;
+        return a.ref.localeCompare(b.ref, undefined, { numeric: true }) * dir;
+      }
       return a.ref.localeCompare(b.ref, undefined, { numeric: true }) * dir;
     });
   }, [current, refSearch, refFilter, modeFilter, refSort, refSortDir]);
 
+  // The group column earns its width only when the list actually carries one
+  // (DXCC prefixes, POTA locations); most custom lists have none. For DXCC the
+  // value IS the primary prefix, so it is labelled as such.
+  const hasGroup = useMemo(() => filteredRefs.some((r) => !!r.group), [filteredRefs]);
+  const groupColLabel = current && current.code.toUpperCase() === 'DXCC' ? t('awp.prefixCol') : t('awp.groupCol');
+
   return (
     <div className="flex h-full min-h-0">
       {/* Award list */}
@@ -459,6 +492,14 @@ export function AwardsPanel({ onEditQSO, onAwardsChanged }: { onEditQSO?: (id: n
                           {refSort === 'ref' && (refSortDir === 'asc' ? <ChevronUp className="size-3" /> : <ChevronDown className="size-3" />)}
                         </button>
                       </th>
+                      {hasGroup && (
+                        <th className="text-left py-1.5 pr-3 font-medium border-b border-border w-20">
+                          <button type="button" onClick={() => toggleRefSort('group')} className="inline-flex items-center gap-1 hover:text-foreground">
+                            {groupColLabel}
+                            {refSort === 'group' && (refSortDir === 'asc' ? <ChevronUp className="size-3" /> : <ChevronDown className="size-3" />)}
+                          </button>
+                        </th>
+                      )}
                       <th className="text-left py-1.5 pr-3 font-medium border-b border-border">
                         <button type="button" onClick={() => toggleRefSort('name')} className="inline-flex items-center gap-1 hover:text-foreground">
                           {t('awp.description')}
@@ -474,9 +515,10 @@ export function AwardsPanel({ onEditQSO, onAwardsChanged }: { onEditQSO?: (id: n
                     {filteredRefs.map((r) => (
                       <tr key={r.ref} className={cn('hover:bg-accent/20', !r.worked && 'opacity-60')}>
                         <td className="sticky left-0 bg-card hover:bg-accent/20 py-1 pr-2 font-mono font-semibold border-b border-border/30">{r.ref}</td>
-                        <td className="py-1 pr-3 text-muted-foreground truncate max-w-[360px] border-b border-border/30">
-                          {r.name}{r.group ? <span className="text-muted-foreground/60"> · {r.group}</span> : ''}
-                        </td>
+                        {hasGroup && (
+                          <td className="py-1 pr-3 font-mono font-semibold border-b border-border/30">{r.group}</td>
+                        )}
+                        <td className="py-1 pr-3 text-muted-foreground truncate max-w-[360px] border-b border-border/30">{r.name}</td>
                         {gridBands.map((b) => {
                           const s = cellStatus(r, b);
                           return (
@@ -513,7 +555,12 @@ export function AwardsPanel({ onEditQSO, onAwardsChanged }: { onEditQSO?: (id: n
                           {refSort === 'name' && (refSortDir === 'asc' ? <ChevronUp className="size-3" /> : <ChevronDown className="size-3" />)}
                         </button>
                       </th>
-                      <th className="py-1.5 pr-2 font-medium w-40">{t('awp.groupCol')}</th>
+                      <th className="py-1.5 pr-2 font-medium w-40">
+                        <button type="button" onClick={() => toggleRefSort('group')} className="inline-flex items-center gap-1 hover:text-foreground">
+                          {groupColLabel}
+                          {refSort === 'group' && (refSortDir === 'asc' ? <ChevronUp className="size-3" /> : <ChevronDown className="size-3" />)}
+                        </button>
+                      </th>
                       <th className="py-1.5 pr-2 font-medium w-24">{t('awp.status')}</th>
                       <th className="py-1.5 font-medium">{t('awp.bands')}</th>
                     </tr>

frontend/src/components/BandMap.tsx

@@ -358,6 +358,43 @@ export function BandMap({ band, spots, spotStatus, currentFreqHz, onSpotClick, o
     return () => el.removeEventListener('wheel', onWheel);
   }, [range]);
 
+  // Ctrl+↑ / Ctrl+↓ hop to the next spot above / below the rig frequency and tune
+  // to it. Higher freq is UP on the map (see freqToY), so ↑ = next higher spot.
+  // Only active on the docked Main-view map (keyNav) and ignored while typing.
+  // MUST stay ABOVE the `if (!range)` early return below: on an unknown band
+  // (e.g. a spurious 33 cm CAT reading from an Icom) that return skipped this
+  // hook, so the hook count changed between renders and React crashed with #300
+  // ("rendered fewer hooks than expected"). lo/hi are always defined (they fall
+  // back to [0,1] when there's no range), so it's safe to run here.
+  useEffect(() => {
+    if (!keyNav) return;
+    const onKey = (e: KeyboardEvent) => {
+      if (!e.ctrlKey || e.altKey || e.metaKey) return;
+      if (e.key !== 'ArrowUp' && e.key !== 'ArrowDown') return;
+      const ae = document.activeElement as HTMLElement | null;
+      const tag = (ae?.tagName || '').toLowerCase();
+      if (tag === 'input' || tag === 'textarea' || tag === 'select' || ae?.isContentEditable) return;
+      const list = spots
+        .filter((s) => (s.band ?? '') === band && s.freq_hz > 0)
+        .slice()
+        .sort((a, b) => a.freq_hz - b.freq_hz);
+      if (!list.length) return;
+      const cur = currentFreqHz || (lo + hi) * 500; // mid-band kHz→Hz when no rig freq
+      const EPS = 50; // Hz, so we don't re-pick the spot we're already sitting on
+      let target: Spot | undefined;
+      if (e.key === 'ArrowUp') {
+        target = list.find((s) => s.freq_hz > cur + EPS);
+      } else {
+        for (let i = list.length - 1; i >= 0; i--) { if (list[i].freq_hz < cur - EPS) { target = list[i]; break; } }
+      }
+      if (!target) return;
+      e.preventDefault();
+      onSpotClick(target);
+    };
+    window.addEventListener('keydown', onKey);
+    return () => window.removeEventListener('keydown', onKey);
+  }, [keyNav, spots, band, currentFreqHz, lo, hi, onSpotClick]);
+
   if (!range) {
     return (
       <div className="h-full w-full flex flex-col items-center justify-center text-xs text-muted-foreground p-3 bg-muted/20">
@@ -388,38 +425,6 @@ export function BandMap({ band, spots, spotStatus, currentFreqHz, onSpotClick, o
     scrollerRef.current.scrollTop = Math.max(0, y - containerH / 2);
   }
 
-  // Ctrl+↑ / Ctrl+↓ hop to the next spot above / below the rig frequency and tune
-  // to it. Higher freq is UP on the map (see freqToY), so ↑ = next higher spot.
-  // Only active on the docked Main-view map (keyNav) and ignored while typing.
-  useEffect(() => {
-    if (!keyNav) return;
-    const onKey = (e: KeyboardEvent) => {
-      if (!e.ctrlKey || e.altKey || e.metaKey) return;
-      if (e.key !== 'ArrowUp' && e.key !== 'ArrowDown') return;
-      const ae = document.activeElement as HTMLElement | null;
-      const tag = (ae?.tagName || '').toLowerCase();
-      if (tag === 'input' || tag === 'textarea' || tag === 'select' || ae?.isContentEditable) return;
-      const list = spots
-        .filter((s) => (s.band ?? '') === band && s.freq_hz > 0)
-        .slice()
-        .sort((a, b) => a.freq_hz - b.freq_hz);
-      if (!list.length) return;
-      const cur = currentFreqHz || (lo + hi) * 500; // mid-band kHz→Hz when no rig freq
-      const EPS = 50; // Hz, so we don't re-pick the spot we're already sitting on
-      let target: Spot | undefined;
-      if (e.key === 'ArrowUp') {
-        target = list.find((s) => s.freq_hz > cur + EPS);
-      } else {
-        for (let i = list.length - 1; i >= 0; i--) { if (list[i].freq_hz < cur - EPS) { target = list[i]; break; } }
-      }
-      if (!target) return;
-      e.preventDefault();
-      onSpotClick(target);
-    };
-    window.addEventListener('keydown', onKey);
-    return () => window.removeEventListener('keydown', onKey);
-  }, [keyNav, spots, band, currentFreqHz, lo, hi, onSpotClick]);
-
   const currentKHz = currentFreqHz ? currentFreqHz / 1000 : 0;
   const showRigPointer = currentKHz >= lo && currentKHz <= hi;
   const rigY = freqToY(currentKHz);

frontend/src/components/BandSlotGrid.tsx

@@ -1,8 +1,9 @@
-import { useMemo } from 'react';
-import { Star, Radio, Sunrise, Sunset } from 'lucide-react';
+import { useEffect, useMemo, useState } from 'react';
+import { Star, Radio, Sunrise, Sunset, X, Loader2 } from 'lucide-react';
 import { Badge } from '@/components/ui/badge';
 import { cn } from '@/lib/utils';
 import { sunTimes } from '@/lib/sun';
+import { BandSlotQSOs } from '../../wailsjs/go/main/App';
 import type { WorkedBeforeView } from '@/types';
 
 type WorkedBefore = WorkedBeforeView;
@@ -18,6 +19,12 @@ interface Props {
   // to an entity with no position at all, and the block simply does not appear.
   lat?: number;
   lon?: number;
+  // Set when the matrix is showing a QSO picked in the log grid rather than the
+  // entry form — labelled so the two can never be confused.
+  forCall?: string;
+  // Open the QSO editor for a contact — makes callsigns in the cell drill-down
+  // clickable. Threaded down from App.openEdit.
+  onEditQso?: (id: number) => void;
 }
 
 // Compact column label for a band tag: keep the classic V/U for 2m/70cm,
@@ -89,7 +96,9 @@ function cellTitle(band: string, cls: string, status: string, current: boolean):
   return `${band} ${cls}: ${desc}${current ? ' — current entry' : ''}`;
 }
 
-export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, hasCall = true, lat, lon }: Props) {
+export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, hasCall = true, lat, lon, forCall, onEditQso }: Props) {
+  // Cell drill-down: which band+class the operator clicked, or null.
+  const [slot, setSlot] = useState<{ band: string; cls: string } | null>(null);
   // Columns from the operator's configured bands (so the matrix shows only the
   // bands they actually use), falling back to the built-in default set.
   const cols = useMemo(
@@ -208,6 +217,14 @@ export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, hasCal
           </>
         ) : hasDxcc ? (
           <>
+            {/* Says WHOSE stats these are when they come from a row picked in
+                the log rather than from what's being typed. */}
+            {forCall && (
+              <Badge variant="outline" className="px-2 py-0.5 text-[10px] font-mono shrink-0"
+                title="Stats for the QSO selected in the log">
+                {forCall}
+              </Badge>
+            )}
             <Badge className="bg-primary text-primary-foreground px-3 py-1 text-xs normal-case font-semibold tracking-normal">
               {dxccName || `DXCC #${dxcc}`}
             </Badge>
@@ -282,10 +299,14 @@ export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, hasCal
                   return (
                     <td
                       key={b.tag}
-                      title={cellTitle(b.tag, cls, st, isCurrent)}
+                      title={cellTitle(b.tag, cls, st, isCurrent) + (st ? ' — click to list the QSOs' : '')}
+                      onClick={st ? () => setSlot({ band: b.tag, cls }) : undefined}
                       className={cn(
                         'w-[28px] h-[24px] rounded transition-colors p-0',
                         st ? STATUS_CLASSES[st] : 'bg-mx-none',
+                        // Only a filled cell has anything to show — an empty one
+                        // stays inert rather than opening a "no QSOs" dialog.
+                        st && 'cursor-pointer hover:brightness-110',
                         isCurrent && 'ring-2 ring-warning ring-inset',
                       )}
                     />
@@ -313,6 +334,119 @@ export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, hasCal
         ))}
       </div>
       </div>
+
+      {slot && (
+        <SlotQSOModal
+          call={wb?.callsign ?? ''}
+          dxcc={dxcc}
+          entity={dxccName}
+          band={slot.band}
+          cls={slot.cls}
+          onClose={() => setSlot(null)}
+          onEdit={onEditQso}
+        />
+      )}
     </section>
   );
 }
+
+// ── Cell drill-down ──────────────────────────────────────────────────────────
+// The contacts behind one band+class cell: this exact callsign AND anyone else
+// in the entity, because that is the pair of facts the cell's colour encodes.
+// The call's own QSOs are marked so the two never blur together.
+
+function SlotQSOModal({ call, dxcc, entity, band, cls, onClose, onEdit }: {
+  call: string; dxcc: number; entity: string; band: string; cls: string; onClose: () => void; onEdit?: (id: number) => void;
+}) {
+  const [rows, setRows] = useState<any[] | null>(null);
+  const [err, setErr] = useState('');
+
+  useEffect(() => {
+    let dead = false;
+    BandSlotQSOs(call, dxcc, band, cls)
+      .then((r: any) => { if (!dead) setRows((r ?? []) as any[]); })
+      .catch((e: any) => { if (!dead) { setErr(String(e?.message ?? e)); setRows([]); } });
+    return () => { dead = true; };
+  }, [call, dxcc, band, cls]);
+
+  useEffect(() => {
+    // Capture phase: the app's global ESC handler resets the entry form, and
+    // closing a dialog must not also wipe what the operator was typing.
+    function onKey(e: KeyboardEvent) {
+      if (e.key === 'Escape') { e.stopImmediatePropagation(); e.preventDefault(); onClose(); }
+    }
+    window.addEventListener('keydown', onKey, true);
+    return () => window.removeEventListener('keydown', onKey, true);
+  }, [onClose]);
+
+  return (
+    <div className="fixed inset-0 z-50 flex items-center justify-center bg-black/60 backdrop-blur-[2px] p-4" onClick={onClose}>
+      <div className="bg-card border border-border rounded-xl shadow-2xl w-[760px] max-w-full max-h-[72vh] flex flex-col overflow-hidden ring-1 ring-black/5"
+        onClick={(e) => e.stopPropagation()}>
+        <div className="flex items-center gap-2.5 px-4 py-2.5 border-b border-border bg-muted/30">
+          <span className="inline-flex items-center justify-center h-6 min-w-6 px-1.5 rounded-md bg-primary/15 text-primary text-[11px] font-bold shrink-0 tabular-nums">{band}</span>
+          <div className="min-w-0">
+            <div className="font-semibold text-sm leading-tight truncate">
+              {cls}{entity && <span className="text-muted-foreground font-normal"> · {entity}</span>}
+            </div>
+            {onEdit && <div className="text-[10px] text-muted-foreground leading-tight">Click a callsign to edit the QSO</div>}
+          </div>
+          <span className="ml-auto text-xs text-muted-foreground tabular-nums shrink-0">{rows ? `${rows.length} QSO${rows.length > 1 ? 's' : ''}` : ''}</span>
+          <button type="button" onClick={onClose} className="text-muted-foreground hover:text-foreground shrink-0 rounded p-0.5 hover:bg-muted transition-colors">
+            <X className="size-4" />
+          </button>
+        </div>
+        <div className="flex-1 overflow-auto">
+          {err && <p className="p-3 text-xs text-destructive">{err}</p>}
+          {!rows ? (
+            <p className="p-4 text-xs text-muted-foreground flex items-center gap-2">
+              <Loader2 className="size-3.5 animate-spin" /> Loading…
+            </p>
+          ) : rows.length === 0 ? (
+            <p className="p-4 text-xs text-muted-foreground italic">No QSOs.</p>
+          ) : (
+            <table className="w-full text-xs border-collapse">
+              <thead className="sticky top-0 z-10 bg-muted/80 backdrop-blur text-[10px] uppercase tracking-wider text-muted-foreground">
+                <tr>
+                  <th className="text-left font-medium px-3 py-1.5">Date UTC</th>
+                  <th className="text-left font-medium px-3 py-1.5">Callsign</th>
+                  <th className="text-left font-medium px-3 py-1.5">Mode</th>
+                  <th className="text-left font-medium px-3 py-1.5">Freq</th>
+                  <th className="text-left font-medium px-3 py-1.5">Name</th>
+                  <th className="text-center font-medium px-3 py-1.5">Cfm</th>
+                </tr>
+              </thead>
+              <tbody>
+                {rows.map((q, i) => {
+                  const cfm = q.lotw_rcvd === 'Y' || q.eqsl_rcvd === 'Y' || q.qsl_rcvd === 'Y';
+                  const mine = q.callsign === call;
+                  return (
+                    <tr key={q.id ?? i} className="border-t border-border/40 even:bg-muted/[0.06] hover:bg-primary/[0.06] transition-colors">
+                      <td className="px-3 py-1.5 tabular-nums text-muted-foreground whitespace-nowrap">
+                        {String(q.qso_date ?? '').slice(0, 16).replace('T', ' ')}
+                      </td>
+                      <td className="px-3 py-1.5">
+                        {onEdit ? (
+                          <button type="button" onClick={() => { onEdit(q.id as number); onClose(); }} title="Edit this QSO"
+                            className={cn('font-mono cursor-pointer text-left hover:underline underline-offset-2', mine ? 'font-bold text-primary' : 'text-foreground hover:text-primary')}>
+                            {q.callsign}
+                          </button>
+                        ) : (
+                          <span className={cn('font-mono', mine && 'font-bold text-primary')}>{q.callsign}</span>
+                        )}
+                      </td>
+                      <td className="px-3 py-1.5">{q.mode}</td>
+                      <td className="px-3 py-1.5 tabular-nums text-muted-foreground">{q.freq_hz ? (q.freq_hz / 1e6).toFixed(3) : ''}</td>
+                      <td className="px-3 py-1.5 text-muted-foreground truncate max-w-[180px]">{q.name}</td>
+                      <td className="px-3 py-1.5 text-center">{cfm ? <span className="text-success">✓</span> : <span className="text-muted-foreground/30">·</span>}</td>
+                    </tr>
+                  );
+                })}
+              </tbody>
+            </table>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+}

frontend/src/components/ClusterGrid.tsx

@@ -140,6 +140,19 @@ function statusColor(s: SpotStatusEntry | undefined): string | null {
   }
 }
 
+// isDull reports a spot that "represents nothing" under the current worked/slot
+// rules: the entity/band/mode is already worked (status resolved, not new in any
+// dimension), the callsign itself isn't in the log, and there's no POTA / county
+// / prefix novelty. Such rows are dimmed so the eye skips them. Because the
+// status obeys the DX-cluster "same slot" option and the digital-mode grouping,
+// what counts as dull follows those settings automatically. Unresolved statuses
+// (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') return false;
+  return !(s.worked_call || s.new_pota || s.new_county || s.new_pfx);
+}
+
 const makeColCatalog = (t: TFn): ColEntry[] => [
   {
     group: 'Spot', label: t('clg2.c.time'),  colId: 'time',
@@ -397,6 +410,11 @@ export function ClusterGrid({ rows, spotStatus, onSpotClick }: Props) {
 
   const defaultColDef = useMemo<ColDef>(() => ({
     sortable: true, resizable: true, filter: true, suppressMovable: false,
+    // Dim "represents nothing" spots at the CELL level, via a class that
+    // refreshCells re-applies. Doing it with a row STYLE needed redrawRows() on
+    // every status update, which re-rendered the whole grid continuously and
+    // pegged the CPU on a busy cluster (the 0.23.6 slowdown).
+    cellClassRules: { 'opacity-40': (p: any) => isDull(statusFor(p)) },
   }), []);
 
   // Pass spotStatus through AG Grid's context so cell renderers can look up
@@ -406,12 +424,22 @@ export function ClusterGrid({ rows, spotStatus, onSpotClick }: Props) {
   const context = useMemo(() => ({ spotStatus }), [spotStatus]);
 
   // Spot statuses arrive asynchronously (~after the rows render). The Call/Band/
-  // Mode cellStyles depend on them but their cell VALUE doesn't change, so ag-grid
-  // won't re-render those cells on its own — force a refresh so e.g. a worked call
-  // turns blue once its status loads.
+  // Mode cellStyles and the dimmed "represents nothing" class depend on them but
+  // the cell VALUE doesn't change, so ag-grid won't re-render on its own — force a
+  // refresh so e.g. a worked call turns blue once its status loads.
+  //
+  // THROTTLED: under an RBN firehose spotStatus updates ~20×/second, and firing a
+  // full refreshCells that often is pure churn on a slow PC. Coalesce the bursts
+  // into one refresh every 200 ms (still imperceptible) instead of one per update.
+  const refreshPending = useRef<number | undefined>(undefined);
   useEffect(() => {
-    gridRef.current?.api?.refreshCells({ force: true });
+    if (refreshPending.current !== undefined) return; // a refresh is already queued
+    refreshPending.current = window.setTimeout(() => {
+      refreshPending.current = undefined;
+      gridRef.current?.api?.refreshCells({ force: true });
+    }, 200);
   }, [spotStatus]);
+  useEffect(() => () => { if (refreshPending.current !== undefined) window.clearTimeout(refreshPending.current); }, []);
 
   // Restore AFTER the profile scope is known — this grid has no key= remount to
   // save it from reading the wrong (unscoped) cache key at first paint.

frontend/src/components/DetailsPanel.tsx

@@ -69,6 +69,14 @@ interface Props {
   band: string;
   mode: string;
   bands?: string[]; // configured bands for the worked-before matrix columns
+  // When the entry form is empty and a QSO is selected in the log grid, the
+  // Stats (F1) matrix shows THAT contact's entity instead of sitting blank.
+  // Only the matrix is redirected — every other tab still edits the live entry.
+  slotCall?: string;
+  slotBand?: string;
+  slotMode?: string;
+  slotWb?: any;
+  slotWbBusy?: boolean;
   imageUrl?: string;
   onOpenImage?: () => void;
   // Optional controlled active tab (so the app can switch it via keyboard).
@@ -77,6 +85,8 @@ interface Props {
   // When the WinKeyer is active, F1-F12 fire macros, so the tab shortcut is
   // shown as Ctrl+F1…F5 instead of F1…F5.
   keyerActive?: boolean;
+  // Open the QSO editor — makes callsigns clickable in the band-slot drill-down.
+  onEditQso?: (id: number) => void;
 }
 
 export type TabName = 'stats' | 'info' | 'awards' | 'my' | 'extended';
@@ -139,7 +149,7 @@ function Field({ label, span = 1, className, children }: { label: string; span?:
   );
 }
 
-export function DetailsPanel({ callsign, prefix, operatorGrid, remoteGrid, qth, name, country, comment, note, details, onChange, wb, wbBusy, band, mode, bands, tab, onTab, keyerActive }: Props) {
+export function DetailsPanel({ callsign, prefix, operatorGrid, remoteGrid, qth, name, country, comment, note, details, onChange, wb, wbBusy, band, mode, bands, slotCall, slotBand, slotMode, slotWb, slotWbBusy, tab, onTab, keyerActive, onEditQso }: Props) {
   const { t } = useI18n();
   const [internalOpen, setInternalOpen] = useState<TabName>('stats');
   const open = tab ?? internalOpen; // controlled when `tab` is provided
@@ -272,7 +282,15 @@ export function DetailsPanel({ callsign, prefix, operatorGrid, remoteGrid, qth,
       <div className={cn('flex-1 min-h-0', open === 'stats' ? 'overflow-hidden' : 'overflow-y-auto')}>
       {open === 'stats' && (
         <div className="px-3 py-2.5">
-          <BandSlotGrid wb={wb} busy={!!wbBusy} currentBand={band} currentMode={mode} bands={bands} hasCall={callsign.trim() !== ''}
+          <BandSlotGrid
+            wb={slotCall ? slotWb : wb}
+            busy={slotCall ? !!slotWbBusy : !!wbBusy}
+            currentBand={slotCall ? (slotBand ?? '') : band}
+            currentMode={slotCall ? (slotMode ?? '') : mode}
+            bands={bands}
+            hasCall={slotCall ? true : callsign.trim() !== ''}
+            forCall={slotCall}
+            onEditQso={onEditQso}
             lat={dxLL?.lat} lon={dxLL?.lon} />
         </div>
       )}

frontend/src/components/LogViewer.tsx

@@ -21,7 +21,13 @@ import { TailLogFile, GetLogFilePath } from '../../wailsjs/go/main/App';
 //     256 KB blob: with "cluster" or "acom" typed in, the window becomes exactly
 //     the subsystem trace you would have grepped for.
 //   • It polls only while open. A closed dialog costs nothing.
-const TAIL_BYTES = 256 * 1024;
+// 512 KB ≈ 3200 lines. The window is a sliding tail: once new lines push past it
+// the oldest fall out of the fetched text entirely, so a small buffer dropped
+// lines the operator was still reading during a busy trace (CAT/cluster/antenna
+// polling). This is double the old 256 KB — 1 MB was tried but the per-second
+// fetch + split + re-render of ~6500 lines made the window lag. 512 KB keeps a
+// useful backlog while staying smooth. The backend caps this at 4 MB.
+const TAIL_BYTES = 512 * 1024;
 const POLL_MS = 1000;
 
 export function LogViewer({ open, onOpenChange }: { open: boolean; onOpenChange: (v: boolean) => void }) {

frontend/src/components/QSOEditModal.tsx

@@ -1,6 +1,6 @@
 import { useEffect, useMemo, useRef, useState } from 'react';
 import { Trash2, Search, Loader2, CalendarDays } from 'lucide-react';
-import { LookupCallsign, LookupCallsignFresh, DXCCForCountry, GetAwardDefs, ComputeQSOAwardRefs, GetListsSettings } from '../../wailsjs/go/main/App';
+import { LookupCallsign, LookupCallsignFresh, DXCCForCountry, GetAwardDefs, ComputeQSOAwardRefs, GetListsSettings, OpenExternalURL } from '../../wailsjs/go/main/App';
 import { rstOptions, type RSTLists } from '@/lib/rst';
 import { AwardRefSelector } from '@/components/AwardRefSelector';
 import { AdifExtrasEditor } from '@/components/AdifExtrasEditor';
@@ -466,7 +466,22 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
               {/* Top: Callsign + RST + Fetch */}
               <div className="flex items-end gap-2 mb-3">
                 <div className="flex flex-col flex-1 min-w-0">
-                  <Label>{t('qedit.callsign')}</Label>
+                  <div className="flex items-center">
+                    <Label>{t('qedit.callsign')}</Label>
+                    {(draft.callsign ?? '').trim() && (
+                      <button
+                        type="button"
+                        title={t('qrz.openTitle', { call: (draft.callsign ?? '').trim().toUpperCase() })}
+                        onClick={() => {
+                          const c = (draft.callsign ?? '').trim().toUpperCase().split('/').map(encodeURIComponent).join('/');
+                          if (c) OpenExternalURL(`https://www.qrz.com/db/${c}`).catch((e: any) => setLocalErr(String(e?.message ?? e)));
+                        }}
+                        className="ml-auto shrink-0 inline-flex items-center gap-0.5 text-[9px] font-semibold normal-case tracking-wider text-primary hover:underline"
+                      >
+                        QRZ ↗
+                      </button>
+                    )}
+                  </div>
                   <Input className="font-mono text-lg font-bold tracking-wider uppercase h-10"
                     value={draft.callsign ?? ''} onChange={(e) => set('callsign', e.target.value)} />
                 </div>

frontend/src/components/RecentQSOsGrid.tsx

@@ -56,6 +56,10 @@ type Props = {
   onRowDoubleClicked?: (q: QSOForm) => void;
   onRowClicked?: (q: QSOForm) => void;
   onRowSelected?: (ids: number[]) => void;
+  // The full first selected row — the Stats (F1) panel shows its entity when the
+  // entry form is empty, so browsing the log answers "what have I got with this
+  // one?" without retyping the call.
+  onRowSelectedQso?: (row: QSOForm | null) => void;
   onUpdateFromCty?: (ids: number[]) => void;
   onUpdateFromQRZ?: (ids: number[]) => void;
   onUpdateFromClublog?: (ids: number[]) => void;
@@ -283,7 +287,7 @@ export const groupLabel = (t: TFn, g: string): string => t(GRP_KEYS[g] ?? g);
 const stripAwardCols = (st: any[] | null | undefined): any[] =>
   (st ?? []).filter((s) => !String(s?.colId ?? '').startsWith('award_'));
 
-export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal, rowDragCall, passOrder, onGridApi, storageKey, onRowDoubleClicked, onRowClicked, onRowSelected, onUpdateFromCty, onUpdateFromQRZ, onUpdateFromClublog, onSendTo, onSendRecording, onSendEQSL, onBulkEdit, onExportSelected, onExportSelectedFields, onExportFiltered, onExportCabrilloSelected, onExportCabrilloFiltered, onDelete, onFilteredCountChange, awardCols }: Props) {
+export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal, rowDragCall, passOrder, onGridApi, storageKey, onRowDoubleClicked, onRowClicked, onRowSelected, onRowSelectedQso, onUpdateFromCty, onUpdateFromQRZ, onUpdateFromClublog, onSendTo, onSendRecording, onSendEQSL, onBulkEdit, onExportSelected, onExportSelectedFields, onExportFiltered, onExportCabrilloSelected, onExportCabrilloFiltered, onDelete, onFilteredCountChange, awardCols }: Props) {
   const { t } = useI18n();
   const gridRef = useRef<any>(null);
   const [pickerOpen, setPickerOpen] = useState(false);
@@ -542,6 +546,7 @@ export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal,
     setSelCount(sel.length);
     setDispCount(api?.getDisplayedRowCount?.() ?? 0);
     onRowSelected?.(sel.map((r) => r.id as number).filter((id) => id != null));
+    onRowSelectedQso?.(sel[0] ?? null);
   }
   // Select every row when the caller bumps selectAllSignal (QSL Manager search).
   useEffect(() => {

frontend/src/components/SettingsModal.tsx

@@ -2,7 +2,7 @@ import { useEffect, useMemo, useRef, useState } from 'react';
 import {
   ArrowDown, ArrowUp, ArrowLeft, ArrowRight, Copy, Plus, Star, StarOff, Trash2,
   ChevronDown, ChevronRight,
-  User, Database, Radio, Cog, Server, Award, Antenna as AntennaIcon,
+  User, Database, Radio, Cog, Server, Antenna as AntennaIcon,
   Compass, Wifi, Construction, UploadCloud, Loader2, FolderOpen, Play, Power, Check, Pencil,
 } from 'lucide-react';
 import {
@@ -50,6 +50,7 @@ import {
   GetFlexState, GetFlexBandAntennas, SaveFlexBandAntennas, GetFlexBandPower, SaveFlexBandPower,
   GetADIFMonitor, SaveADIFMonitor, PickADIFMonitorFile,
   GetRelayAuto, SaveRelayAuto, GetStationDevices,
+  GetAwardDefs, GetTrackedAwards, SaveTrackedAwards,
 } from '../../wailsjs/go/main/App';
 import type { profile as profileModels } from '../../wailsjs/go/models';
 import type { LookupSettingsForm, StationSettingsForm, ListsSettingsForm, ModePresetForm } from '@/types';
@@ -254,6 +255,7 @@ function buildTree(flexAvailable: boolean, t: (k: string) => string): TreeNode[]
       { kind: 'item', label: t('sec.profiles'), id: 'profiles' },
       { kind: 'item', label: t('sec.operating'), id: 'operating' },
       { kind: 'item', label: t('sec.confirmations'), id: 'confirmations' },
+      { kind: 'item', label: t('sec.awards'), id: 'awards' },
       { kind: 'item', label: t('sec.external'), id: 'external-services' },
     ],
   },
@@ -673,6 +675,9 @@ type AmpUI = { id: string; name: string; enabled: boolean; type: string; transpo
 type RelayRuleUI = { device_id: string; relay: number; mode: string; freq_lo_khz: number; freq_hi_khz: number; bands: string[] };
 type StationDevUI = { id: string; type: string; name: string; labels: string[] };
 const RELAY_BANDS = ['160m', '80m', '60m', '40m', '30m', '20m', '17m', '15m', '12m', '10m', '6m', '4m', '2m', '70cm'];
+// Bands a motorized HF/6 m antenna (Ultrabeam / SteppIR) can cover — the follow
+// filter is a subset of these. Must match motorBands in app.go, low → high.
+const MOTOR_BANDS = ['40m', '30m', '20m', '17m', '15m', '12m', '10m', '6m'];
 const relayCountUI = (type: string) => (type === 'kmtronic' || type === 'denkovi' ? 8 : 5);
 
 // Live status + OPERATE/STANDBY toggle for ONE configured amplifier (by config
@@ -941,6 +946,91 @@ function FlexDiscover({ onPick }: { onPick: (ip: string, port: number) => void }
   );
 }
 
+// AwardsSelectionPanel is a two-column transfer list: every defined award on the
+// left, the ones the operator follows on the right. The Awards tab shows only the
+// followed set (empty = all). Per-profile, saved immediately (local SQLite).
+function AwardsSelectionPanel({ profile }: { profile?: { name?: string; callsign?: string } }) {
+  const { t } = useI18n();
+  const [all, setAll] = useState<{ code: string; name: string }[]>([]);
+  const [tracked, setTracked] = useState<string[]>([]);
+  const [err, setErr] = useState('');
+  const [q, setQ] = useState('');
+
+  useEffect(() => {
+    (async () => {
+      try {
+        const [defs, tr] = await Promise.all([
+          GetAwardDefs().then((d) => (d ?? []) as any[]),
+          GetTrackedAwards().then((v) => (v ?? []) as string[]).catch(() => [] as string[]),
+        ]);
+        setAll(defs.map((d) => ({ code: d.code, name: d.name })).sort((a, b) => a.code.localeCompare(b.code)));
+        setTracked(tr);
+      } catch (e: any) { setErr(String(e?.message ?? e)); }
+    })();
+  }, []);
+
+  async function persist(next: string[]) {
+    setTracked(next);
+    try { await SaveTrackedAwards(next); } catch (e: any) { setErr(String(e?.message ?? e)); }
+  }
+  const trackedSet = new Set(tracked);
+  const byCode = new Map(all.map((a) => [a.code, a] as const));
+  const needle = q.trim().toLowerCase();
+  const available = all.filter((a) => !trackedSet.has(a.code)
+    && (needle === '' || `${a.code} ${a.name}`.toLowerCase().includes(needle)));
+  const trackedItems = (tracked.map((c) => byCode.get(c)).filter(Boolean) as { code: string; name: string }[])
+    .sort((a, b) => a.code.localeCompare(b.code));
+
+  return (
+    <div>
+      <SectionHeader title={t('sec.awards')} hint={t('awards.followHint')} />
+      <ProfileScopeNote profile={profile} />
+      {err && <div className="mb-2 text-xs text-destructive">{err}</div>}
+      <div className="grid grid-cols-2 gap-3">
+        <div className="rounded-lg border border-border bg-card/40 flex flex-col">
+          <div className="flex items-center justify-between px-3 py-2 border-b border-border/60">
+            <span className="text-sm font-medium">{t('awards.available')} <span className="text-muted-foreground">({available.length})</span></span>
+            <button type="button" className="text-xs text-primary hover:underline disabled:opacity-40"
+              disabled={available.length === 0} onClick={() => persist(all.map((a) => a.code))}>{t('awards.addAll')}</button>
+          </div>
+          <div className="p-2 border-b border-border/60">
+            <Input value={q} onChange={(e) => setQ(e.target.value)} placeholder={t('awards.search')} className="h-8" />
+          </div>
+          <div className="max-h-[340px] overflow-y-auto p-1.5 space-y-0.5">
+            {available.map((a) => (
+              <button key={a.code} type="button" onClick={() => persist([...tracked, a.code])}
+                className="group w-full flex items-center gap-2 rounded-md px-2 py-1 text-left hover:bg-primary/10">
+                <span className="font-mono text-xs shrink-0">{a.code}</span>
+                <span className="text-xs text-muted-foreground truncate flex-1">{a.name}</span>
+                <span className="text-primary opacity-0 group-hover:opacity-100">→</span>
+              </button>
+            ))}
+            {available.length === 0 && <div className="p-2 text-xs text-muted-foreground">{t('awards.allTracked')}</div>}
+          </div>
+        </div>
+        <div className="rounded-lg border border-primary/40 bg-primary/5 flex flex-col">
+          <div className="flex items-center justify-between px-3 py-2 border-b border-border/60">
+            <span className="text-sm font-medium">{t('awards.followed')} <span className="text-muted-foreground">({tracked.length})</span></span>
+            <button type="button" className="text-xs text-primary hover:underline disabled:opacity-40"
+              disabled={tracked.length === 0} onClick={() => persist([])}>{t('awards.clear')}</button>
+          </div>
+          <div className="max-h-[392px] overflow-y-auto p-1.5 space-y-0.5">
+            {trackedItems.map((a) => (
+              <button key={a.code} type="button" onClick={() => persist(tracked.filter((c) => c !== a.code))}
+                className="group w-full flex items-center gap-2 rounded-md px-2 py-1 text-left hover:bg-primary/10">
+                <span className="text-muted-foreground opacity-0 group-hover:opacity-100">←</span>
+                <span className="font-mono text-xs shrink-0">{a.code}</span>
+                <span className="text-xs text-muted-foreground truncate flex-1">{a.name}</span>
+              </button>
+            ))}
+            {tracked.length === 0 && <div className="p-2 text-xs text-muted-foreground">{t('awards.noneFollowed')}</div>}
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+}
+
 function ComingSoon({ id, icon: Icon }: { id: SectionId; icon?: any }) {
   const label = SECTION_LABELS[id] ?? id;
   const IconCmp = Icon ?? Construction;
@@ -1149,8 +1239,8 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   const [rotatorTest, setRotatorTest] = useState<{ ok: boolean; msg: string } | null>(null);
 
   // Motorized antenna (Ultrabeam TCP or SteppIR TCP/serial) settings.
-  const [ultrabeam, setUltrabeam] = useState<{ enabled: boolean; type: string; transport: string; host: string; port: number; com: string; baud: number; follow: boolean; step_khz: number; tx_inhibit: boolean; freq_min_mhz: number; freq_max_mhz: number }>({
-    enabled: false, type: 'ultrabeam', transport: 'tcp', host: '', port: 23, com: '', baud: 9600, follow: false, step_khz: 50, tx_inhibit: false, freq_min_mhz: 13, freq_max_mhz: 54,
+  const [ultrabeam, setUltrabeam] = useState<{ enabled: boolean; type: string; transport: string; host: string; port: number; com: string; baud: number; follow: boolean; step_khz: number; tx_inhibit: boolean; bands: string[]; freq_min_mhz: number; freq_max_mhz: number }>({
+    enabled: false, type: 'ultrabeam', transport: 'tcp', host: '', port: 23, com: '', baud: 9600, follow: false, step_khz: 50, tx_inhibit: false, bands: [], freq_min_mhz: 13, freq_max_mhz: 54,
   });
   const [ubTesting, setUbTesting] = useState(false);
   const [ubTest, setUbTest] = useState<{ ok: boolean; msg: string } | null>(null);
@@ -1246,6 +1336,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   const [startEqEnd, setStartEqEnd] = useState(() => localStorage.getItem('opslog.startEqualsEnd') === '1');
   const [lookupOnBlur, setLookupOnBlur] = useState(() => localStorage.getItem('opslog.lookupOnBlur') === '1');
   const [groupDigital, setGroupDigital] = useState(() => localStorage.getItem('opslog.groupDigitalSlots') === '1');
+  const [clusterWorkedSameSlot, setClusterWorkedSameSlot] = useState(() => localStorage.getItem('opslog.clusterWorkedSameSlot') === '1');
   const [showQsoRate, setShowQsoRate] = useState(() => localStorage.getItem('opslog.showQsoRate') === '1');
   const [catModeBeforeFreq, setCatModeBeforeFreq] = useState(() => localStorage.getItem('opslog.catModeBeforeFreq') === '1');
   // Password-encryption (secret vault) state.
@@ -2595,9 +2686,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                 <label className="flex items-center gap-2 text-sm cursor-pointer">
                   <Checkbox checked={civTrace} onCheckedChange={(c) => { setCivTrace(!!c); SetCIVTrace(!!c); }} />
                   {t('cat.civTrace')}
-                </label>
-                <p className="text-[10px] text-muted-foreground mt-1">{t('cat.civTraceHint')}</p>
-              </div>
+                </label>              </div>
             )}
             {catCfg.backend === 'kenwood' && (
             <>
@@ -2613,9 +2702,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                   </Select>
                   <Button type="button" variant="outline" size="sm"
                     onClick={() => ListSerialPorts().then((p) => setWkPorts((p ?? []) as string[])).catch(() => {})}>↻</Button>
-                </div>
-                <span className="text-xs text-muted-foreground">{t('cat.kenwoodPortHint')}</span>
-              </div>
+                </div>              </div>
               <div className="space-y-1">
                 <Label>{t('cat.baud')}</Label>
                 <Select value={String(catCfg.kenwood_baud || 9600)} onValueChange={(v) => setCatCfg((s) => ({ ...s, kenwood_baud: parseInt(v) || 9600 }))}>
@@ -2623,18 +2710,14 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                   <SelectContent>
                     {[4800, 9600, 19200, 38400, 57600, 115200].map((r) => <SelectItem key={r} value={String(r)}>{r}</SelectItem>)}
                   </SelectContent>
-                </Select>
-                <span className="text-xs text-muted-foreground">{t('cat.kenwoodBaudHint')}</span>
-              </div>
+                </Select>              </div>
               <div className="space-y-1">
                 <Label>{t('cat.kenwoodHost')}</Label>
                 <Input
                   value={catCfg.kenwood_host || ''}
                   placeholder="192.168.1.50:4532"
                   onChange={(e) => setCatCfg((s) => ({ ...s, kenwood_host: e.target.value }))}
-                />
-                <span className="text-xs text-muted-foreground">{t('cat.kenwoodHostHint')}</span>
-              </div>
+                />              </div>
               <div className="space-y-1">
                 <label className="flex items-center gap-2 text-xs cursor-pointer">
                   <Checkbox checked={!!catCfg.kenwood_low_lines} onCheckedChange={(c) => setCatCfg((s) => ({ ...s, kenwood_low_lines: !!c }))} />
@@ -2651,9 +2734,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                     <SelectItem value="data">{t('cat.kwDataMd6')}</SelectItem>
                     <SelectItem value="keep">{t('cat.kwDataKeep')}</SelectItem>
                   </SelectContent>
-                </Select>
-                <span className="text-xs text-muted-foreground">{t('cat.kwDataHint')}</span>
-              </div>
+                </Select>              </div>
             </>
             )}
             {catCfg.backend === 'icom' && (
@@ -2867,9 +2948,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                     onCheckedChange={(c) => setCatCfg((s) => ({ ...s, ptt_hotkey_toggle: !!c } as any))}
                   />
                   {t('cat.pttKeyToggle')}
-                </label>
-                <p className="text-[11px] text-muted-foreground">{t('cat.pttKeyHint')}</p>
-              </>
+                </label>              </>
             )}
           </div>
           {catCfg.backend === 'omnirig' && (
@@ -3023,20 +3102,28 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
               </div>
             )}
           </div>
-          {isSteppir && (
-            <div className="border-t border-border/60 pt-3 space-y-1">
-              <div className="flex items-center gap-2 flex-wrap">
-                <Label className="text-sm">{t('hw.steppirRange')}</Label>
-                <input type="number" min={1} max={60} value={ultrabeam.freq_min_mhz}
-                  onChange={(e) => setUltrabeam((s) => ({ ...s, freq_min_mhz: parseInt(e.target.value, 10) || 0 }))}
-                  className="h-8 w-16 rounded-md border border-input bg-background px-2 text-sm" />
-                <span className="text-xs text-muted-foreground">–</span>
-                <input type="number" min={1} max={60} value={ultrabeam.freq_max_mhz}
-                  onChange={(e) => setUltrabeam((s) => ({ ...s, freq_max_mhz: parseInt(e.target.value, 10) || 0 }))}
-                  className="h-8 w-16 rounded-md border border-input bg-background px-2 text-sm" />
-                <span className="text-xs text-muted-foreground">MHz</span>
+          {(isSteppir || ultrabeam.type === 'ultrabeam') && (
+            <div className="border-t border-border/60 pt-3 space-y-2">
+              <Label className="text-sm">{t('hw.motorBands')}</Label>
+              <div className="flex items-center gap-1.5 flex-wrap">
+                {MOTOR_BANDS.map((b) => {
+                  const on = ultrabeam.bands.includes(b);
+                  return (
+                    <button key={b} type="button"
+                      onClick={() => setUltrabeam((s) => ({
+                        ...s,
+                        bands: on ? s.bands.filter((x) => x !== b) : [...s.bands, b],
+                      }))}
+                      className={`h-8 min-w-[3rem] rounded-md border px-2 text-sm font-medium transition-colors ${
+                        on
+                          ? 'border-primary bg-primary/15 text-primary'
+                          : 'border-input bg-background text-muted-foreground hover:bg-muted'
+                      }`}>
+                      {b}
+                    </button>
+                  );
+                })}
               </div>
-              <p className="text-xs text-muted-foreground">{t('hw.steppirRangeHint')}</p>
             </div>
           )}
           <div className="border-t border-border/60 pt-3 space-y-1">
@@ -3399,6 +3486,8 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             const dev = d as any;
             const isRG = dev.type === 'rotgenius';
             const isARCO = dev.type === 'arco';
+            const isDCU1 = dev.type === 'dcu1';
+            const isSerialCap = isARCO || isDCU1; // COM-port or serial-over-IP controllers
             const transport = dev.transport ?? 'tcp';
             return (
               <div key={dev.id || i} className="rounded-xl border border-border bg-card/40 p-3 space-y-3">
@@ -3417,12 +3506,13 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                     {/* Each backend gets its default port: Rotator Genius 9006, ARCO 4001
                         (placeholder — must match the ARCO's LAN menu), PstRotator 12000. */}
                     <Select value={dev.type ?? 'pst'}
-                      onValueChange={(v) => patch(i, { type: v as any, port: v === 'rotgenius' ? 9006 : v === 'arco' ? 4001 : 12000 })}>
+                      onValueChange={(v) => patch(i, { type: v as any, port: v === 'rotgenius' ? 9006 : (v === 'arco' || v === 'dcu1') ? 4001 : 12000, ...(v === 'dcu1' ? { transport: 'serial' } : {}) })}>
                       <SelectTrigger className="h-9"><SelectValue /></SelectTrigger>
                       <SelectContent>
                         <SelectItem value="pst">PstRotator (UDP)</SelectItem>
                         <SelectItem value="rotgenius">Rotator Genius (4O3A, native)</SelectItem>
                         <SelectItem value="arco">GS-232A controller (microHAM ARCO, ERC…)</SelectItem>
+                        <SelectItem value="dcu1">Hy-Gain DCU-1 (RotorCard DXA, Rotor-EZ, Green Heron)</SelectItem>
                       </SelectContent>
                     </Select>
                   </div>
@@ -3439,8 +3529,8 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                       </Select>
                     </div>
                   )}
-                  {/* The ARCO is reachable over the LAN (TCP) or its USB virtual COM. */}
-                  {isARCO && (
+                  {/* ARCO and DCU-1 controllers reach over the LAN (TCP) or a serial COM. */}
+                  {isSerialCap && (
                     <div className="space-y-1">
                       <Label>Connection</Label>
                       <Select value={transport} onValueChange={(v) => patch(i, { transport: v as any })}>
@@ -3460,7 +3550,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                     {t('rot.rgDual')}
                   </label>
                 )}
-                {isARCO && transport === 'serial' ? (
+                {isSerialCap && transport === 'serial' ? (
                   <div className="space-y-1 max-w-xs">
                     <Label>COM port</Label>
                     <div className="flex items-center gap-2">
@@ -3489,16 +3579,16 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                     <div className="space-y-1 col-span-2">
                       <Label>Host / IP</Label>
                       <Input value={dev.host ?? ''} onChange={(e) => patch(i, { host: e.target.value })}
-                        placeholder={isRG || isARCO ? '192.168.1.60' : '127.0.0.1'} className="font-mono" />
+                        placeholder={isRG || isSerialCap ? '192.168.1.60' : '127.0.0.1'} className="font-mono" />
                     </div>
                     <div className="space-y-1">
-                      <Label>{isRG || isARCO ? 'TCP port' : 'UDP port'}</Label>
+                      <Label>{isRG || isSerialCap ? 'TCP port' : 'UDP port'}</Label>
                       <PortInput value={dev.port} onChange={(n) => patch(i, { port: n })}
-                        fallback={isRG ? 9006 : isARCO ? 4001 : 12000} className="font-mono" />
+                        fallback={isRG ? 9006 : isSerialCap ? 4001 : 12000} className="font-mono" />
                     </div>
                   </div>
                 )}
-                {!isRG && !isARCO && (
+                {!isRG && !isSerialCap && (
                   <label className="flex items-center gap-2 text-sm cursor-pointer">
                     <Checkbox checked={!!dev.has_elevation} onCheckedChange={(c) => patch(i, { has_elevation: !!c })} />
                     This rotator supports elevation (VHF / satellite)
@@ -3506,6 +3596,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                 )}
                 {isRG && <p className="text-xs text-muted-foreground">{t('rot.rgHint')}</p>}
                 {isARCO && <p className="text-xs text-muted-foreground">{t('rot.arcoHint')}</p>}
+                {isDCU1 && <p className="text-xs text-muted-foreground">{t('rot.dcu1Hint')}</p>}
                 {/* Which antenna this rotor carries — only relevant with >1 rotor. */}
                 {multi && (
                   <div className="space-y-1 max-w-xs">
@@ -4012,6 +4103,11 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             <span className="font-mono">dx.maritimecontestclub.net:7300</span>,{' '}
             <span className="font-mono">w8avi.net:7300</span>.
           </p>
+          <label className="flex items-start gap-2 text-sm cursor-pointer border-t border-border/60 pt-3">
+            <Checkbox checked={clusterWorkedSameSlot} className="mt-0.5"
+              onCheckedChange={(c) => { const v = !!c; setClusterWorkedSameSlot(v); writeUiPref('opslog.clusterWorkedSameSlot', v ? '1' : '0'); }} />
+            <span>{t('clu.workedSameSlot')} <span className="text-xs text-muted-foreground">{t('clu.workedSameSlotHint')}</span></span>
+          </label>
         </div>
 
         {editingServer && (
@@ -5706,6 +5802,17 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             <span className="text-[11px] text-muted-foreground">{emailMsg}</span>
           </div>
 
+          <div className="pt-2 mt-2 border-t border-border space-y-2">
+            <Label className="text-sm font-semibold">{t('em.recEmail')}</Label>
+            <div className="text-[11px] text-muted-foreground">
+              {t('em.recVarsHint')} {'{CALL}'} {'{DATE}'} {'{BAND}'} {'{MODE}'} {'{MYCALL}'}.
+            </div>
+            <Input className="h-8" placeholder={t('em.subject')} value={emailCfg.subject}
+              onChange={(e) => setEmailField({ subject: e.target.value })} />
+            <Textarea rows={3} className="text-sm" placeholder={t('em.body')} value={emailCfg.body}
+              onChange={(e) => setEmailField({ body: e.target.value })} />
+          </div>
+
           <div className="pt-2 mt-2 border-t border-border space-y-2">
             <Label className="text-sm font-semibold">{t('em.qslCardEmail')}</Label>
             <div className="text-[11px] text-muted-foreground">
@@ -5813,7 +5920,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     database:       DatabasePanel,
     uscounties:     USCountiesPanel,
     autostart:      () => <AutostartPanelComponent />,
-    awards:         () => <ComingSoon id="awards" icon={Award} />,
+    awards:         () => <AwardsSelectionPanel profile={activeProfile ?? undefined} />,
     cat:            CATPanel,
     rotator:        RotatorPanel,
     winkeyer:       WinkeyerPanel,

frontend/src/components/StationControlPanel.tsx

@@ -672,6 +672,7 @@ function DeviceEditor({ device, onChange, onSave, onCancel, t }: {
         <div className={cn('space-y-1', (isKM || isDingtian) ? '' : 'max-w-xs')}>
           <Label>{t('station.host')}</Label>
           <Input className="font-mono" value={device.host} placeholder="192.168.1.100" onChange={(e) => onChange({ ...device, host: e.target.value })} />
+          <span className="text-[10px] text-muted-foreground">{t('station.hostHint')}</span>
         </div>
         {/* Dingtian: both are OFF on a factory board — the session ID only when
             "HTTP Session" is enabled in its web page, the password only when a

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

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

@@ -87,6 +87,8 @@ export function AwardsFolder():Promise<string>;
 
 export function BackfillUSCounties():Promise<main.BackfillUSCountiesResult>;
 
+export function BandSlotQSOs(arg1:string,arg2:number,arg3:string,arg4:string):Promise<Array<qso.QSO>>;
+
 export function BrowseExecutable():Promise<string>;
 
 export function BulkUpdateField(arg1:Array<number>,arg2:string,arg3:string):Promise<number>;
@@ -493,6 +495,8 @@ export function GetStationStatus():Promise<Array<main.StationDeviceStatus>>;
 
 export function GetTelemetryEnabled():Promise<boolean>;
 
+export function GetTrackedAwards():Promise<Array<string>>;
+
 export function GetTunerGeniusSettings():Promise<main.TunerGeniusSettings>;
 
 export function GetTunerGeniusStatus():Promise<tunergenius.Status>;
@@ -895,6 +899,8 @@ export function SaveStationDevices(arg1:Array<main.StationDevice>):Promise<void>
 
 export function SaveStationSettings(arg1:main.StationSettings):Promise<void>;
 
+export function SaveTrackedAwards(arg1:Array<string>):Promise<void>;
+
 export function SaveTunerGeniusSettings(arg1:main.TunerGeniusSettings):Promise<void>;
 
 export function SaveUDPIntegration(arg1:udp.Config):Promise<udp.Config>;

frontend/wailsjs/go/main/App.js

@@ -122,6 +122,10 @@ export function BackfillUSCounties() {
   return window['go']['main']['App']['BackfillUSCounties']();
 }
 
+export function BandSlotQSOs(arg1, arg2, arg3, arg4) {
+  return window['go']['main']['App']['BandSlotQSOs'](arg1, arg2, arg3, arg4);
+}
+
 export function BrowseExecutable() {
   return window['go']['main']['App']['BrowseExecutable']();
 }
@@ -934,6 +938,10 @@ export function GetTelemetryEnabled() {
   return window['go']['main']['App']['GetTelemetryEnabled']();
 }
 
+export function GetTrackedAwards() {
+  return window['go']['main']['App']['GetTrackedAwards']();
+}
+
 export function GetTunerGeniusSettings() {
   return window['go']['main']['App']['GetTunerGeniusSettings']();
 }
@@ -1738,6 +1746,10 @@ export function SaveStationSettings(arg1) {
   return window['go']['main']['App']['SaveStationSettings'](arg1);
 }
 
+export function SaveTrackedAwards(arg1) {
+  return window['go']['main']['App']['SaveTrackedAwards'](arg1);
+}
+
 export function SaveTunerGeniusSettings(arg1) {
   return window['go']['main']['App']['SaveTunerGeniusSettings'](arg1);
 }

frontend/wailsjs/go/models.ts

@@ -3156,6 +3156,7 @@ export namespace main {
 	    follow: boolean;
 	    step_khz: number;
 	    tx_inhibit: boolean;
+	    bands: string[];
 	    freq_min_mhz: number;
 	    freq_max_mhz: number;
 	
@@ -3175,6 +3176,7 @@ export namespace main {
 	        this.follow = source["follow"];
 	        this.step_khz = source["step_khz"];
 	        this.tx_inhibit = source["tx_inhibit"];
+	        this.bands = source["bands"];
 	        this.freq_min_mhz = source["freq_min_mhz"];
 	        this.freq_max_mhz = source["freq_max_mhz"];
 	    }

internal/backup/backup.go

@@ -44,7 +44,7 @@ func DefaultFolder(dataDir string) string {
 // statement (no torn-copy window while the app keeps writing), and compacts
 // the destination as a bonus. It replaces the old "checkpoint + raw io.Copy",
 // which could capture a half-written page during a concurrent write.
-func Run(ctx context.Context, dbConn *sql.DB, dbPath, folder string, rotation int, doZip bool) (string, error) {
+func Run(ctx context.Context, dbConn *sql.DB, dbPath, folder string, rotation int, doZip bool, prefix string) (string, error) {
 	if dbConn == nil {
 		return "", fmt.Errorf("nil db connection")
 	}
@@ -54,12 +54,15 @@ func Run(ctx context.Context, dbConn *sql.DB, dbPath, folder string, rotation in
 	if folder == "" {
 		return "", fmt.Errorf("backup folder not set")
 	}
+	if prefix == "" {
+		prefix = "opslog"
+	}
 	if err := os.MkdirAll(folder, 0o755); err != nil {
 		return "", fmt.Errorf("create backup folder: %w", err)
 	}
 
 	stamp := time.Now().Format("2006-01-02")
-	base := fmt.Sprintf("opslog-%s", stamp)
+	base := fmt.Sprintf("%s-%s", prefix, stamp)
 
 	// VACUUM INTO requires a non-existent target → use a temp file, then
 	// move/zip it into place.
@@ -92,7 +95,7 @@ func Run(ctx context.Context, dbConn *sql.DB, dbPath, folder string, rotation in
 		}
 	}
 
-	if err := rotate(folder, rotation); err != nil {
+	if err := rotateMatch(folder, rotation, prefix+"-", ".db", ".db.zip"); err != nil {
 		// Rotation errors are non-fatal — the backup itself succeeded.
 		return dstPath, fmt.Errorf("rotate: %w (backup OK at %s)", err, dstPath)
 	}
@@ -203,12 +206,6 @@ func copyZipped(src, dst, innerName string) error {
 	return out.Close()
 }
 
-// rotate keeps the most recent `keep` SQLite backups (opslog-*.db /
-// opslog-*.db.zip) and deletes the rest.
-func rotate(folder string, keep int) error {
-	return rotateMatch(folder, keep, "opslog-", ".db", ".db.zip")
-}
-
 // rotateMatch keeps the most recent `keep` files in folder whose name has the
 // given prefix and one of the given suffixes, deleting older ones. Only matching
 // files are touched — never unrelated user files in the same folder. The suffix

internal/cat/kenwood.go

@@ -115,6 +115,17 @@ type Kenwood struct {
 	// nothing. Off by default: that is how this backend behaved for its whole
 	// life before the question came up.
 	lowerLines bool
+
+	// tx tracks whether we currently hold PTT (SetPTT true). A Kenwood/Elecraft rig
+	// answers "?;" to a status poll (IF;) WHILE TRANSMITTING; OpsLog used to read
+	// that as "the rig doesn't support IF;", latch it off and drop the whole CAT
+	// link — which tore down the shared-CAT PTT that WSJT-X / JTDX key through, so a
+	// K3 keyed but the logger's transmission fell apart. While PTT is held we skip
+	// the wire poll and hand back the last good state (lastState) instead. txAt caps
+	// the skip so a missed SetPTT(false) can't freeze the state for ever.
+	tx        bool
+	txAt      time.Time
+	lastState RigState
 }
 
 // SetLowerLines chooses whether DTR and RTS are deasserted on connect. Set
@@ -255,6 +266,15 @@ func (k *Kenwood) ReadState() (RigState, error) {
 	if k.port == nil {
 		return RigState{}, fmt.Errorf("kenwood: not connected")
 	}
+	// While transmitting, don't poll: the rig returns "?;" to IF; during TX, and
+	// treating that as a fault dropped the shared CAT link the digital-mode
+	// software keys through. Hand back the last known state. The 30 s cap resyncs
+	// if a SetPTT(false) was somehow missed, so a stuck TX can't freeze state.
+	if k.tx && !k.txAt.IsZero() && time.Since(k.txAt) < 30*time.Second {
+		s := k.lastState
+		s.Connected = true
+		return s, nil
+	}
 	raw, err := k.ask("IF;")
 	if err != nil {
 		return RigState{}, err
@@ -339,6 +359,7 @@ func (k *Kenwood) ReadState() (RigState, error) {
 	if s.Split {
 		k.curRXFreq = s.RxFreqHz
 	}
+	k.lastState = s // cache for the transmit window, where we can't poll
 	return s, nil
 }
 
@@ -409,7 +430,9 @@ func (k *Kenwood) SetPTT(on bool) error {
 	if k.port == nil {
 		return fmt.Errorf("kenwood: not connected")
 	}
+	k.tx = on
 	if on {
+		k.txAt = time.Now()
 		return k.write("TX;")
 	}
 	return k.write("RX;")
@@ -467,10 +490,15 @@ func (k *Kenwood) ask(cmd string) (string, error) {
 			k.rx = k.rx[i+1:]
 			traceText("kenwood", "RX", frame)
 			if frame == "?;" {
-				// The rig rejected the command. Remember it so the poll loop stops
-				// paying a 600 ms timeout for it on every cycle.
-				k.unsupported[want] = true
-				debugLog.Printf("kenwood: this rig does not support %q — not asking again", cmd)
+				// IF; and ID; are universal on Kenwood/Elecraft — a "?;" to them is a
+				// transient "busy" (typically mid-transmit, or a menu open on the rig),
+				// NOT "unsupported". Latching them off would blind the poll loop for
+				// good and read as "lost the rig". Only remember the OPTIONAL commands
+				// (FR/FT/…) so the poll loop stops paying a 600 ms timeout for those.
+				if want != "IF" && want != "ID" {
+					k.unsupported[want] = true
+					debugLog.Printf("kenwood: this rig does not support %q — not asking again", cmd)
+				}
 				return "", fmt.Errorf("kenwood: %s rejected", want)
 			}
 			if strings.HasPrefix(frame, want) {

internal/dxcc/manager.go

@@ -173,6 +173,39 @@ func (m *Manager) EntityNames() []string {
 	return out
 }
 
+// PrefixByDXCC maps ADIF DXCC entity number → canonical primary prefix (F, DL,
+// XE…) from the loaded cty.dat. cty.dat is keyed by entity NAME, so the join
+// goes through EntityDXCC; entries whose name doesn't resolve are skipped
+// rather than guessed. Empty until cty.dat has loaded.
+func (m *Manager) PrefixByDXCC() map[int]string {
+	m.mu.RLock()
+	db := m.db
+	m.mu.RUnlock()
+	if db == nil {
+		return nil
+	}
+	out := make(map[int]string, 400)
+	for _, e := range db.Entities() {
+		p := strings.TrimSpace(e.Primary)
+		if p == "" {
+			continue
+		}
+		// cty.dat marks non-DXCC sub-entities with a leading '*' — they report
+		// under a parent entity and must not overwrite the parent's prefix.
+		if strings.HasPrefix(p, "*") {
+			continue
+		}
+		if n := EntityDXCC(e.Name); n > 0 {
+			if _, dup := out[n]; !dup {
+				// DXCC prefixes are conventionally upper-case; cty.dat spells some
+				// sub-entity suffixes in lower case (3D2/c → 3D2/C).
+				out[n] = strings.ToUpper(p)
+			}
+		}
+	}
+	return out
+}
+
 // Info returns metadata about the currently-loaded cty.dat (or zero value
 // if nothing loaded).
 func (m *Manager) Info() ctySource {

internal/powergenius/powergenius.go

@@ -125,14 +125,19 @@ func (c *Client) SetFanMode(mode string) error {
 	default:
 		return fmt.Errorf("powergenius: invalid fan mode %q", mode)
 	}
-	// Set with the bare "key=value" verb the amp uses for its own status fields
-	// (same convention as "operate=1"). The earlier "setup fanmode=…" carried a
-	// bogus prefix the amp silently ignored, so the fan never changed and the next
-	// status kept reporting the old mode — the revert-to-Contest the operator saw.
-	reply, err := c.command("fanmode=" + m)
+	// The verb the amp wants is "setup fanmode=VALUE" — confirmed LIVE: with the
+	// "setup " prefix the amp replies code 0 (accepted), while the bare
+	// "fanmode=VALUE" we switched to earlier is rejected (reply code 0x50000015).
+	// That regression is what stopped the fan from changing; restoring "setup "
+	// fixes it.
+	reply, err := c.command("setup fanmode=" + m)
 	if err != nil {
 		return err
 	}
+	if code := replyCode(reply); code != "" && code != "0" {
+		applog.Printf("pgxl: set fanmode=%s REJECTED, reply=%q", m, reply)
+		return fmt.Errorf("powergenius: amp rejected fanmode=%s (code %s)", m, code)
+	}
 	applog.Printf("pgxl: set fanmode=%s reply=%q", m, reply)
 	c.statusMu.Lock()
 	c.status.FanMode = m // optimistic
@@ -141,6 +146,19 @@ func (c *Client) SetFanMode(mode string) error {
 	return nil
 }
 
+// replyCode returns the result code from an "R<id>|<code>|…" reply — "0" means
+// the amp accepted the command. Returns "" when the line isn't an R reply.
+func replyCode(reply string) string {
+	if !strings.HasPrefix(reply, "R") {
+		return ""
+	}
+	p := strings.SplitN(reply, "|", 3)
+	if len(p) < 2 {
+		return ""
+	}
+	return strings.TrimSpace(p[1])
+}
+
 // SetOperate puts the amp in OPERATE (1) or STANDBY (0).
 func (c *Client) SetOperate(on bool) error {
 	v := "0"

internal/qso/qso.go

@@ -1461,6 +1461,51 @@ func (r *Repo) IterateByIDs(ctx context.Context, ids []int64, fn func(QSO) error
 	return rows.Err()
 }
 
+// BandSlotQSOs returns every contact on one band that belongs to a slot of the
+// entry matrix: the exact callsign, or any callsign in the same DXCC entity.
+// Mode is NOT filtered here — the class (phone / CW / digital) is a derived
+// notion the caller owns, so it filters the (small) band-scoped result itself.
+//
+// The DXCC arm matches the stored dxcc column only. A QSO logged before the
+// entity was resolved has a NULL there and is genuinely unattributed; guessing
+// it back from the callsign here would disagree with the matrix above, which is
+// built from the same column.
+func (r *Repo) BandSlotQSOs(ctx context.Context, callsign string, dxccNum int, band string) ([]QSO, error) {
+	call := upperTrim(callsign)
+	b := strings.TrimSpace(band)
+	if b == "" || (call == "" && dxccNum <= 0) {
+		return []QSO{}, nil
+	}
+	where := "band = ?"
+	args := []any{b}
+	switch {
+	case call != "" && dxccNum > 0:
+		where += " AND (callsign = ? OR dxcc = ?)"
+		args = append(args, call, dxccNum)
+	case call != "":
+		where += " AND callsign = ?"
+		args = append(args, call)
+	default:
+		where += " AND dxcc = ?"
+		args = append(args, dxccNum)
+	}
+	rows, err := r.db.QueryContext(ctx,
+		`SELECT `+selectCols+` FROM qso WHERE `+where+` ORDER BY qso_date DESC, id DESC LIMIT 500`, args...)
+	if err != nil {
+		return nil, fmt.Errorf("query band slot: %w", err)
+	}
+	defer rows.Close()
+	out := []QSO{}
+	for rows.Next() {
+		q, err := scanQSO(rows)
+		if err != nil {
+			return nil, err
+		}
+		out = append(out, q)
+	}
+	return out, rows.Err()
+}
+
 // WorkedBefore summarises prior contacts at two granularities:
 //   - by exact callsign  → shown as "this call worked N×"
 //   - by DXCC entity     → drives NEW ONE / NEW BAND / NEW MODE / NEW SLOT
@@ -2118,6 +2163,36 @@ func (r *Repo) WorkedCallBandModeKeys(ctx context.Context) (map[string]struct{},
 	return out, rows.Err()
 }
 
+// WorkedCallSlotKeys backs the cluster "already worked only on the same slot"
+// option. It returns each worked slot keyed BOTH as "CALL|band" (mode-agnostic,
+// for a spot whose mode couldn't be inferred) and "CALL|band|MODE" with the mode
+// run through normMode — so when digital grouping is on, FT8/FT4/RTTY fold into
+// one "DIG" and a call worked on 20m FT8 also matches a 20m FT4 spot. Call is
+// upper-cased and band lower-cased to match the spot keys ClusterSpotStatuses
+// builds. normMode may be nil (no grouping).
+func (r *Repo) WorkedCallSlotKeys(ctx context.Context, normMode func(string) string) (map[string]struct{}, error) {
+	rows, err := r.db.QueryContext(ctx,
+		`SELECT upper(callsign), lower(band), upper(mode) FROM qso
+		 WHERE callsign != '' AND band IS NOT NULL AND band != '' AND mode IS NOT NULL AND mode != ''`)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	out := make(map[string]struct{}, 4096)
+	for rows.Next() {
+		var c, b, m string
+		if err := rows.Scan(&c, &b, &m); err != nil {
+			return nil, err
+		}
+		if normMode != nil {
+			m = normMode(m)
+		}
+		out[c+"|"+b] = struct{}{}
+		out[c+"|"+b+"|"+m] = struct{}{}
+	}
+	return out, rows.Err()
+}
+
 // WorkedPOTARefs returns the set of POTA park references already worked
 // (upper-cased). A QSO's pota_ref may hold several comma-separated parks
 // (an n-fer); each is added separately.

internal/relaydev/relaydev.go

@@ -61,6 +61,22 @@ func get(ctx context.Context, url, user, pass string) ([]byte, error) {
 	return body, nil
 }
 
+// relayBase turns a configured host into the base URL of a network relay board.
+// A bare host or host:port keeps the default http:// (the boards serve plain
+// HTTP on their LAN). A host that already carries a scheme is used verbatim, so
+// a board can be reached through an HTTPS reverse proxy — e.g. a Nginx Proxy
+// Manager entry "https://relay.example.com" fronting the LAN board's port 80,
+// which is how an operator reaches shack relays from outside when 80/443 are
+// already taken by the proxy. A trailing slash is trimmed so path parts append
+// cleanly; an optional sub-path in the host is preserved (a sub-path proxy).
+func relayBase(host string) string {
+	h := strings.TrimSpace(host)
+	if strings.HasPrefix(h, "http://") || strings.HasPrefix(h, "https://") {
+		return strings.TrimRight(h, "/")
+	}
+	return "http://" + h
+}
+
 // ── WebSwitch 1216H ────────────────────────────────────────────────────
 
 type webswitch struct {
@@ -82,7 +98,7 @@ func (w *webswitch) Set(ctx context.Context, relay int, on bool) error {
 	if on {
 		action = "on"
 	}
-	_, err := get(ctx, fmt.Sprintf("http://%s/relaycontrol/%s/%d", w.host, action, relay), "", "")
+	_, err := get(ctx, fmt.Sprintf("%s/relaycontrol/%s/%d", relayBase(w.host), action, relay), "", "")
 	return err
 }
 
@@ -93,7 +109,7 @@ func (w *webswitch) Status(ctx context.Context) ([]bool, error) {
 		sel.WriteString(strconv.Itoa(i))
 		sel.WriteByte('$')
 	}
-	body, err := get(ctx, fmt.Sprintf("http://%s/relaystate/get2/%s", w.host, sel.String()), "", "")
+	body, err := get(ctx, fmt.Sprintf("%s/relaystate/get2/%s", relayBase(w.host), sel.String()), "", "")
 	if err != nil {
 		return nil, err
 	}
@@ -140,7 +156,7 @@ func (k *kmtronic) Set(ctx context.Context, relay int, on bool) error {
 		state = "01"
 	}
 	// FF<rr><ss>: e.g. FF0101 = relay 1 on, FF0800 = relay 8 off.
-	_, err := get(ctx, fmt.Sprintf("http://%s/FF%02d%s", k.host, relay, state), k.user, k.pass)
+	_, err := get(ctx, fmt.Sprintf("%s/FF%02d%s", relayBase(k.host), relay, state), k.user, k.pass)
 	return err
 }
 
@@ -154,7 +170,7 @@ type kmStatus struct {
 }
 
 func (k *kmtronic) Status(ctx context.Context) ([]bool, error) {
-	body, err := get(ctx, fmt.Sprintf("http://%s/status.xml", k.host), k.user, k.pass)
+	body, err := get(ctx, fmt.Sprintf("%s/status.xml", relayBase(k.host)), k.user, k.pass)
 	if err != nil {
 		return nil, err
 	}
@@ -259,8 +275,8 @@ func (d *dingtian) Set(ctx context.Context, relay int, on bool) error {
 	}
 	// type=0 is plain ON/OFF (1 = jogging, 2 = delay, 3 = flash, 4 = toggle),
 	// and time is then unused.
-	body, err := d.getCGI(ctx, fmt.Sprintf("http://%s/relay_cgi.cgi?type=0&relay=%d&on=%d&time=0&pwd=%s&",
-		d.host, relay-1, state, d.pwd))
+	body, err := d.getCGI(ctx, fmt.Sprintf("%s/relay_cgi.cgi?type=0&relay=%d&on=%d&time=0&pwd=%s&",
+		relayBase(d.host), relay-1, state, d.pwd))
 	if err != nil {
 		return err
 	}
@@ -274,7 +290,7 @@ func (d *dingtian) Set(ctx context.Context, relay int, on bool) error {
 }
 
 func (d *dingtian) Status(ctx context.Context) ([]bool, error) {
-	body, err := d.getCGI(ctx, fmt.Sprintf("http://%s/relay_cgi_load.cgi", d.host))
+	body, err := d.getCGI(ctx, fmt.Sprintf("%s/relay_cgi_load.cgi", relayBase(d.host)))
 	if err != nil {
 		return nil, err
 	}

internal/relaydev/relaydev_test.go

@@ -172,3 +172,19 @@ func TestDingtianSetRefusalIsAnError(t *testing.T) {
 		t.Fatal("a refused command answered HTTP 200 and was reported as success")
 	}
 }
+
+func TestRelayBase(t *testing.T) {
+	cases := map[string]string{
+		"192.168.1.5":                  "http://192.168.1.5",
+		"192.168.1.5:8080":             "http://192.168.1.5:8080",
+		"https://relay.example.com":    "https://relay.example.com",
+		"https://relay.example.com/":   "https://relay.example.com",
+		"http://relay.example.com/sw/": "http://relay.example.com/sw",
+		"  relay.local  ":              "http://relay.local",
+	}
+	for in, want := range cases {
+		if got := relayBase(in); got != want {
+			t.Errorf("relayBase(%q) = %q, want %q", in, got, want)
+		}
+	}
+}

internal/rigctld/rigctld.go

@@ -36,6 +36,7 @@ import (
 	"strconv"
 	"strings"
 	"sync"
+	"sync/atomic"
 	"time"
 )
 
@@ -59,6 +60,13 @@ type Server struct {
 	ln     net.Listener
 	conns  map[net.Conn]struct{}
 	closed bool
+
+	// ptt mirrors the last PTT state a client commanded via set_ptt. WSJT-X/JTDX
+	// poll get_ptt DURING transmit to confirm the rig is keyed; if get_ptt reads
+	// RX they conclude PTT failed and abort the over after a second or two. We
+	// don't read PTT back from every backend, so echo what the client last set —
+	// always consistent with its own command, and enough to satisfy the check.
+	ptt atomic.Bool
 }
 
 func New(port int, rig Rig, logf func(string, ...any)) *Server {
@@ -228,10 +236,12 @@ func (s *Server) handle(line string) (resp string, quit bool) {
 		return rprt(0), false
 
 	case "t", "\\get_ptt":
-		// We do not read PTT back from every backend, and answering "transmitting"
-		// wrongly would make a client hold off for ever. Reporting RX is the safe
-		// direction: the worst case is a client that transmits when we said it
-		// could, which is what it was going to do anyway.
+		// Echo the last commanded PTT state. WSJT-X/JTDX poll this WHILE
+		// transmitting to confirm the rig is keyed; answering a blanket "0" (RX)
+		// made them decide PTT had failed and abort the over after ~1-2 s.
+		if s.ptt.Load() {
+			return "1\n", false
+		}
 		return "0\n", false
 	case "T", "\\set_ptt":
 		if len(args) < 1 {
@@ -242,6 +252,7 @@ func (s *Server) handle(line string) (resp string, quit bool) {
 			s.log("rigctld: set_ptt %v failed: %v", on, err)
 			return rprt(-9), false
 		}
+		s.ptt.Store(on)
 		return rprt(0), false
 
 	case "v", "\\get_vfo":

internal/rigctld/rigctld_test.go

@@ -138,6 +138,28 @@ func TestHandleReportsBackendFailure(t *testing.T) {
 	}
 }
 
+// get_ptt must echo the last commanded PTT state. WSJT-X/JTDX poll get_ptt while
+// transmitting to confirm the rig is keyed; a blanket "0" made them decide PTT
+// had failed and abort the over after a second or two.
+func TestGetPTTEchoesSetPTT(t *testing.T) {
+	s := New(0, &fakeRig{}, nil)
+	if got, _ := s.handle("t"); got != "0\n" {
+		t.Fatalf("initial get_ptt = %q, want 0", got)
+	}
+	if got, _ := s.handle("T 1"); got != "RPRT 0\n" {
+		t.Fatalf("set_ptt 1 = %q, want RPRT 0", got)
+	}
+	if got, _ := s.handle("t"); got != "1\n" {
+		t.Fatalf("get_ptt after T 1 = %q, want 1 — client would abort TX", got)
+	}
+	if got, _ := s.handle("T 0"); got != "RPRT 0\n" {
+		t.Fatalf("set_ptt 0 = %q, want RPRT 0", got)
+	}
+	if got, _ := s.handle("t"); got != "0\n" {
+		t.Fatalf("get_ptt after T 0 = %q, want 0", got)
+	}
+}
+
 // dump_state is parsed POSITIONALLY by Hamlib clients: WSJT-X reads the first
 // line as the protocol version and refuses to continue if the block is short or
 // misshapen. Pinning its shape is what stops a well-meaning edit from silently

internal/rotator/dcu1/dcu1.go

@@ -0,0 +1,158 @@
+// Package dcu1 drives rotator controllers that speak the Hy-Gain DCU-1 protocol,
+// over a serial COM port (or a raw TCP socket, e.g. a serial-over-IP bridge).
+//
+// DCU-1 is used by the Hy-Gain DCU-1, the Idiom Press Rotor-EZ, Green Heron
+// controllers, and the RotorCard DXA (hamsupply) for Yaesu DXA rotors. It is a
+// DIFFERENT command set from Yaesu GS-232 (see internal/rotator/gs232):
+// semicolon-terminated, azimuth only.
+//
+// Commands (';' terminated — roundTrip appends the ';'):
+//
+//	AP1nnn   set the target bearing nnn (000-359)
+//	AM1      rotate to the target (some controllers move on AP1 alone; AM1 is
+//	         harmless and makes the Rotor-EZ/DCU-1 variants that need it work)
+//	AI1      query the current bearing → the reply carries the 3-digit azimuth
+//
+// The base DCU-1 set has no dedicated stop; Stop re-commands the current bearing,
+// which halts rotation.
+package dcu1
+
+import (
+	"fmt"
+	"io"
+	"net"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+
+	"go.bug.st/serial"
+)
+
+const (
+	dialTimeout = 3 * time.Second
+	ioTimeout   = 2 * time.Second
+)
+
+// Client is a stateless per-call sender, mirroring the gs232/pst/rotgenius idiom.
+// Exactly one of (Host, Port) or ComPort is used.
+type Client struct {
+	Host    string
+	Port    int
+	ComPort string // serial transport: "COM5" etc.
+	// Baud varies by controller (a Hy-Gain DCU-1 is 4800; Green Heron / RotorCard
+	// can differ). Zero keeps 4800.
+	Baud int
+}
+
+// New returns a TCP Client (a serial-over-IP bridge in front of the controller).
+func New(host string, port int) *Client {
+	if host == "" {
+		host = "127.0.0.1"
+	}
+	if port <= 0 || port > 65535 {
+		port = 4001
+	}
+	return &Client{Host: host, Port: port}
+}
+
+// NewSerial returns a Client over the controller's COM port.
+func NewSerial(comPort string, baud int) *Client {
+	return &Client{ComPort: comPort, Baud: baud}
+}
+
+// roundTrip opens a connection, sends one ';'-terminated command and (when
+// wantReply) reads until a 3-digit bearing is present. cmd must NOT carry the
+// ';'.
+func (c *Client) roundTrip(cmd string, wantReply bool) (string, error) {
+	var conn io.ReadWriteCloser
+	if c.ComPort != "" {
+		baud := c.Baud
+		if baud <= 0 {
+			baud = 4800
+		}
+		sp, err := serial.Open(c.ComPort, &serial.Mode{BaudRate: baud})
+		if err != nil {
+			return "", fmt.Errorf("open rotator %s @ %d baud: %w", c.ComPort, baud, err)
+		}
+		_ = sp.SetReadTimeout(200 * time.Millisecond)
+		conn = sp
+	} else {
+		nc, err := net.DialTimeout("tcp", net.JoinHostPort(c.Host, strconv.Itoa(c.Port)), dialTimeout)
+		if err != nil {
+			return "", fmt.Errorf("connect DCU-1 %s:%d: %w", c.Host, c.Port, err)
+		}
+		_ = nc.SetDeadline(time.Now().Add(ioTimeout))
+		conn = nc
+	}
+	defer conn.Close()
+	if _, err := conn.Write([]byte(cmd + ";")); err != nil {
+		return "", fmt.Errorf("send %q: %w", cmd, err)
+	}
+	if !wantReply {
+		return "", nil
+	}
+	buf := make([]byte, 64)
+	var sb strings.Builder
+	deadline := time.Now().Add(ioTimeout)
+	for time.Now().Before(deadline) {
+		n, err := conn.Read(buf)
+		if n > 0 {
+			sb.Write(buf[:n])
+			// The DCU-1 reply carries the bearing as three digits (framing varies —
+			// ";nnn", "nnn;", "+0nnn"). Stop once we have them rather than on a
+			// specific terminator, so any flavour reads cleanly.
+			if azRe.MatchString(sb.String()) {
+				break
+			}
+		}
+		// A serial read that times out returns (0, nil) — keep polling until the
+		// overall deadline; a real error ends the read.
+		if err != nil {
+			break
+		}
+	}
+	line := strings.TrimSpace(sb.String())
+	if line == "" {
+		return "", fmt.Errorf("no reply to %q", cmd)
+	}
+	return line, nil
+}
+
+// GoTo points the antenna at az (0-359): set the target, then rotate.
+func (c *Client) GoTo(az int) error {
+	az = ((az % 360) + 360) % 360
+	if _, err := c.roundTrip(fmt.Sprintf("AP1%03d", az), false); err != nil {
+		return err
+	}
+	_, err := c.roundTrip("AM1", false)
+	return err
+}
+
+// Stop halts rotation. The base DCU-1 set has no stop command, so re-command the
+// current bearing — the controller stops when the target equals where it is.
+func (c *Client) Stop() error {
+	az, _, err := c.Heading()
+	if err != nil {
+		return err
+	}
+	_, err = c.roundTrip(fmt.Sprintf("AP1%03d", az), false)
+	return err
+}
+
+// azRe matches the 3-digit bearing in any of the DCU-1 reply framings.
+var azRe = regexp.MustCompile(`(\d{3})`)
+
+// Heading queries the current azimuth. Returns the raw reply for diagnostics.
+func (c *Client) Heading() (az int, raw string, err error) {
+	raw, err = c.roundTrip("AI1", true)
+	if err != nil {
+		return 0, raw, err
+	}
+	m := azRe.FindStringSubmatch(raw)
+	if m == nil {
+		return 0, raw, fmt.Errorf("unrecognised azimuth reply %q", raw)
+	}
+	az, _ = strconv.Atoi(m[1])
+	return az % 360, raw, nil
+}

internal/spe/spe.go

@@ -228,6 +228,18 @@ func (c *Client) PowerOn() error {
 func (c *Client) PowerOff() error {
 	err := c.sendCmd(cmdOff)
 	applog.Printf("spe: power OFF — SWITCH OFF key sent (err=%v)", err)
+	// Drop the link and mark the amp offline at once, exactly as a fresh start
+	// would see it. The amp stops answering its UART once off, but the connection
+	// that was already open BEFORE the off keystroke kept reading as "connected"
+	// (stale/queued frames), so the UI never showed OFF and PowerOn — which only
+	// wakes a DISCONNECTED amp — did nothing until the operator restarted OpsLog.
+	// The poll loop reopens the port on its next tick; a plain reopen never wakes a
+	// switched-off amp (only PowerOn's RTS/DTR edge does), so it stays offline.
+	time.Sleep(100 * time.Millisecond) // let the 6-byte OFF command flush before we close
+	c.mu.Lock()
+	c.dropLocked()
+	c.mu.Unlock()
+	c.setErr(fmt.Errorf("switched off"))
 	return err
 }
 

internal/ultrabeam/ultrabeam.go

@@ -88,8 +88,22 @@ type Client struct {
 	// yet (Frequency==0) — otherwise the deadband is bypassed and every small QSY
 	// re-tunes the motors.
 	lastSetKHz int
+
+	// moveCmdAt is when a move (frequency or direction) was last COMMANDED. The
+	// status poll runs every couple of seconds, so without this the "moving" flag
+	// — which drives the UI indicator and the Flex TX-inhibit — appeared up to a
+	// poll late even though the elements start moving at once. GetStatus reports
+	// motion during a short window after a command so both react immediately.
+	moveCmdAt time.Time
 }
 
+// ubMoveOptimisticWindow is how long after a commanded move GetStatus reports
+// "moving" before the status poll has had a chance to read the real motor state.
+// It only needs to bridge one poll interval; once a poll sees real motion, that
+// takes over. Bounded, so if the antenna never reports motion the flag still
+// clears rather than latching the TX-inhibit on for ever.
+const ubMoveOptimisticWindow = 3 * time.Second
+
 // LastSetKHz returns the frequency (kHz) most recently commanded to the antenna,
 // or 0 if none yet.
 func (c *Client) LastSetKHz() int {
@@ -270,7 +284,19 @@ func (c *Client) GetStatus() (*Status, error) {
 		return &Status{Connected: false}, nil
 	}
 
-	return c.lastStatus, nil
+	// Copy so the optimistic-motion tweak below never mutates the cached status
+	// the poll goroutine owns.
+	st := *c.lastStatus
+	// Optimistic motion: right after a commanded move, report "moving" until a
+	// status poll can read the real motor state (~one poll interval). The elements
+	// start moving the instant the operator clicks a band/pattern, so this makes
+	// the UI indicator and the Flex TX-inhibit react immediately instead of a poll
+	// later. Real polled motion takes over once seen; the window is bounded so the
+	// flag can't latch the inhibit on for ever.
+	if st.Connected && st.MotorsMoving == 0 && !c.moveCmdAt.IsZero() && time.Since(c.moveCmdAt) < ubMoveOptimisticWindow {
+		st.MotorsMoving = 1 // sentinel: optimistically moving (read only as != 0)
+	}
+	return &st, nil
 }
 
 // getNextSeq returns the next sequence number
@@ -301,10 +327,9 @@ func quoteByte(b byte) []byte {
 	return []byte{b}
 }
 
-// buildPacket creates a complete packet with checksum and escaping
-func (c *Client) buildPacket(cmd byte, data []byte) []byte {
-	seq := c.getNextSeq()
-
+// buildPacket creates a complete packet with checksum and escaping. The seq is
+// supplied by the caller so sendCommand can match the reply against it.
+func (c *Client) buildPacket(seq, cmd byte, data []byte) []byte {
 	// Calculate checksum on unquoted data
 	payload := append([]byte{seq, cmd}, data...)
 	chk := calculateChecksum(payload)
@@ -389,39 +414,27 @@ func (c *Client) sendCommand(cmd byte, data []byte) ([]byte, error) {
 		return nil, fmt.Errorf("not connected")
 	}
 
-	// Build and send packet
-	packet := c.buildPacket(cmd, data)
+	// Flush anything already sitting in the stream before we send. The antenna
+	// does NOT echo our sequence number — its replies carry their own counter — so
+	// a reply cannot be matched to its request. Instead we keep the exchange 1:1:
+	// a reply left behind by an earlier timed-out command is discarded here, so
+	// the reply we read next belongs to THIS command. Reading a stale reply as the
+	// current one crossed STATUS with READ_BANDS/PROGRESS — phantom frequencies (a
+	// spurious follow-loop re-tune), dropped connections and wrong element lengths.
+	c.drainStale()
 
-	_, err := c.conn.Write(packet)
-	if err != nil {
+	seq := c.getNextSeq()
+	packet := c.buildPacket(seq, cmd, data)
+	if _, err := c.conn.Write(packet); err != nil {
 		return nil, fmt.Errorf("failed to write: %w", err)
 	}
 
-	// Read reply with timeout (generous — tolerates remote-link latency).
+	// Read the reply with a timeout generous enough for a remote link.
 	c.conn.SetReadDeadline(time.Now().Add(ubReadTimeout))
-
-	// Read until we get a complete packet
-	var buffer []byte
-	for {
-		b, err := c.reader.ReadByte()
-		if err != nil {
-			return nil, fmt.Errorf("failed to read: %w", err)
-		}
-
-		buffer = append(buffer, b)
-
-		// Check if we have a complete packet
-		if b == ETX && len(buffer) > 0 && buffer[0] == STX {
-			break
-		}
-
-		// Prevent infinite loop
-		if len(buffer) > 256 {
-			return nil, fmt.Errorf("packet too long")
-		}
+	buffer, err := c.readPacket()
+	if err != nil {
+		return nil, err
 	}
-
-	// Parse reply
 	_, replyCmd, payload, err := parsePacket(buffer)
 	if err != nil {
 		return nil, fmt.Errorf("failed to parse reply: %w", err)
@@ -450,6 +463,45 @@ func (c *Client) sendCommand(cmd byte, data []byte) ([]byte, error) {
 	}
 }
 
+// drainStale discards any bytes already waiting in the stream — a reply left
+// 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))
+	buf := make([]byte, 256)
+	for {
+		n, err := c.reader.Read(buf)
+		if n == 0 || err != nil {
+			return
+		}
+	}
+}
+
+// readPacket reads one complete STX…ETX frame, skipping any leading bytes until
+// an STX so a partial/garbage remnant left in the stream can't derail the parse.
+// STX/ETX/DLE are all high-bit (0xF5/0xFA/0xF6) and the escaping clears the MSB,
+// so a raw ETX only ever appears as the real terminator. Caller holds connMu and
+// has set a read deadline.
+func (c *Client) readPacket() ([]byte, error) {
+	var buffer []byte
+	for {
+		b, err := c.reader.ReadByte()
+		if err != nil {
+			return nil, fmt.Errorf("failed to read: %w", err)
+		}
+		if len(buffer) == 0 && b != STX {
+			continue // resync to the start of a frame
+		}
+		buffer = append(buffer, b)
+		if b == ETX {
+			return buffer, nil
+		}
+		if len(buffer) > 256 {
+			return nil, fmt.Errorf("packet too long")
+		}
+	}
+}
+
 // queryStatus queries general status (command 1)
 func (c *Client) queryStatus() (*Status, error) {
 	reply, err := c.sendCommand(CMD_STATUS, nil)
@@ -457,7 +509,13 @@ func (c *Client) queryStatus() (*Status, error) {
 		return nil, err
 	}
 
-	if len(reply) < 12 {
+	// An RCU-06 controller — seen behind an RS232-to-Ethernet bridge — answers with
+	// an 11-byte status frame: the standard one WITHOUT the trailing FreqMax byte.
+	// The packet checksum was already verified, so a short-but-valid frame is real,
+	// not a fragment. Accept it and default the missing tail fields instead of
+	// reconnect-looping on "reply too short". reply[9]/[10] (MotorsMoving, FreqMin)
+	// are the last we truly need, so 10 bytes is the floor.
+	if len(reply) < 10 {
 		return nil, fmt.Errorf("status reply too short: %d bytes", len(reply))
 	}
 
@@ -470,8 +528,12 @@ func (c *Client) queryStatus() (*Status, error) {
 		Direction:        int(reply[6] & 0x0F),
 		OffState:         (reply[7] & 0x02) != 0,
 		MotorsMoving:     int(reply[9]),
-		FreqMin:          int(reply[10]),
-		FreqMax:          int(reply[11]),
+	}
+	if len(reply) > 10 {
+		status.FreqMin = int(reply[10])
+	}
+	if len(reply) > 11 {
+		status.FreqMax = int(reply[11])
 	}
 
 	return status, nil
@@ -537,6 +599,7 @@ func (c *Client) SetFrequency(freqKhz int, direction int) error {
 		c.statusMu.Lock()
 		c.pendingDir, c.pendingDirAt, c.pendingDirSet = direction, time.Now(), true
 		c.lastSetKHz = freqKhz
+		c.moveCmdAt = time.Now() // start reporting motion at once — see ubMoveOptimisticWindow
 		if c.lastStatus != nil {
 			c.lastStatus.Direction = direction // reflect immediately
 		}

internal/ultrabeam/ultrabeam_test.go

@@ -0,0 +1,94 @@
+package ultrabeam
+
+import (
+	"bufio"
+	"bytes"
+	"net"
+	"testing"
+	"time"
+)
+
+// sendCommand must flush any bytes already in the stream (a reply left by an
+// earlier timed-out command) before reading, then return the reply to THIS
+// command. The antenna does not echo our sequence number, so keeping the stream
+// clean is the only way to stay in sync.
+func TestSendCommandFlushesStaleThenReadsReply(t *testing.T) {
+	srvConn, cliConn := net.Pipe()
+	defer srvConn.Close()
+	defer cliConn.Close()
+
+	c := &Client{conn: cliConn, reader: bufio.NewReader(cliConn)}
+	srv := &Client{reader: bufio.NewReader(srvConn)}
+
+	errc := make(chan error, 1)
+	go func() {
+		// Leftover from a "previous" command still sitting in the stream. The Write
+		// blocks until drainStale consumes it, so it is guaranteed flushed before
+		// the real exchange.
+		if _, err := srvConn.Write(c.buildPacket(9, UB_OK, []byte{0xDE, 0xAD})); err != nil {
+			errc <- err
+			return
+		}
+		// Now serve the actual request.
+		req, err := srv.readPacket()
+		if err != nil {
+			errc <- err
+			return
+		}
+		seq, _, _, err := parsePacket(req)
+		if err != nil {
+			errc <- err
+			return
+		}
+		_, err = srvConn.Write(c.buildPacket(seq, UB_OK, []byte{0x11, 0x22, 0x33}))
+		errc <- err
+	}()
+
+	payload, err := c.sendCommand(CMD_STATUS, nil)
+	if err != nil {
+		t.Fatalf("sendCommand: %v", err)
+	}
+	if !bytes.Equal(payload, []byte{0x11, 0x22, 0x33}) {
+		t.Fatalf("payload = % X, want 11 22 33 — stale reply not flushed", payload)
+	}
+	if err := <-errc; err != nil {
+		t.Fatalf("server: %v", err)
+	}
+}
+
+// readPacket must resynchronise to the next STX, dropping any partial/garbage
+// bytes left in the stream, so one corrupt frame can't misalign every frame
+// after it.
+func TestReadPacketResyncsToSTX(t *testing.T) {
+	frame := (&Client{}).buildPacket(5, UB_OK, []byte{0x01, 0x02})
+	stream := append([]byte{0x11, 0x22, 0x33}, frame...) // leading garbage, then a real frame
+	c := &Client{reader: bufio.NewReader(bytes.NewReader(stream))}
+
+	got, err := c.readPacket()
+	if err != nil {
+		t.Fatalf("readPacket: %v", err)
+	}
+	seq, cmd, payload, err := parsePacket(got)
+	if err != nil {
+		t.Fatalf("parsePacket: %v", err)
+	}
+	if seq != 5 || cmd != UB_OK || !bytes.Equal(payload, []byte{0x01, 0x02}) {
+		t.Fatalf("seq=%d cmd=%d payload=% X, want 5 / OK / 01 02", seq, cmd, payload)
+	}
+}
+
+// A commanded move must report motion immediately (before the next status poll),
+// then fall back to the real motor state once the window elapses.
+func TestOptimisticMotionAfterCommand(t *testing.T) {
+	c := &Client{lastStatus: &Status{Connected: true, MotorsMoving: 0}}
+
+	c.moveCmdAt = time.Now()
+	if st, _ := c.GetStatus(); st.MotorsMoving == 0 {
+		t.Fatal("just after a move command, GetStatus should report motion")
+	}
+
+	c.moveCmdAt = time.Now().Add(-ubMoveOptimisticWindow - time.Second)
+	if st, _ := c.GetStatus(); st.MotorsMoving != 0 {
+		t.Fatal("past the window with motors idle, GetStatus must report no motion")
+	}
+}

telemetry.go

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

wiki/Import-and-Export-ADIF.md

@@ -6,19 +6,54 @@ export modes.
 
 ## Import
 
-Import an `.adi` / `.adif` file into the active profile's logbook. On import,
-OpsLog parses every field, maps standard fields to columns and keeps unknown but
-valid ADIF fields in a per-QSO **extras** store (editable later). Country /
-zones are enriched from `cty.dat` where missing. A file **without a header**
-(records pasted from another log) imports fine.
+**File → Import** (`Ctrl+O`) → pick an `.adi` / `.adif` file → the **Import ADIF**
+dialog opens with the options below. Import runs into the **active profile's**
+logbook. A file **without a header** (records pasted from another log) imports
+fine. Progress shows live; a summary follows — imported / updated / duplicates /
+skipped / total — with expandable **error** and **duplicate** lists.
 
-- **Field remapping**: the import dialog can move a field as it reads it —
-  e.g. the RSGB IOTA contest exports the island reference in `STATE`; add a
-  `STATE → IOTA` row and it lands where the award looks.
-- **Fill from profile**: optionally stamps your station fields *and* your
-  default confirmation statuses (paper QSL, LoTW, eQSL, Club Log, HRDLog,
-  QRZ.com) on QSOs the file leaves empty — a WSJT-X log carries almost none.
-  Existing values are never overwritten.
+### Duplicate handling
+
+A **duplicate** is a record with the same **callsign + UTC minute + band + mode**
+as a QSO already in the logbook. Pick how they are treated:
+
+| Mode | What it does |
+|------|--------------|
+| **Skip duplicates** *(default)* | Adds only new QSOs; existing ones left untouched. Safe default. |
+| **Update duplicates** | Merges the file's non-empty fields (QSL / LoTW / eQSL / QRZ statuses & dates, etc.) onto the matching QSO — fields the file omits are kept. Use to re-sync from Log4OM or LoTW. |
+| **Import everything** | Inserts every record, duplicates included. For deliberately merging two overlapping logs. |
+
+### Enrichment options
+
+- **Fix country & zones (cty.dat + ClubLog)** *(on by default)* — recompute
+  Country, DXCC and CQ/ITU zones from `cty.dat`, overriding the file. Corrects
+  what contest software exports wrong (e.g. RG2Y tagged Asiatic instead of
+  European Russia). ClubLog's date-ranged DXpedition overrides are applied on top
+  per QSO date (e.g. TO2A in 2012 → French Guiana) whenever the ClubLog data is
+  downloaded. Everything else in the ADIF is kept as-is. *Tip: combine with
+  **Update duplicates** to re-fix QSOs already in your log.*
+- **Fill my station fields from my profile** *(off by default)* — backfill empty
+  `MY_*` fields (grid, rig, antenna, address, city, state, county, SOTA/POTA ref,
+  TX power…) plus Operator and Owner callsign from the active profile. Existing
+  values are kept; only `STATION_CALLSIGN` is left untouched so a mixed-call log
+  isn't re-routed. It **also** stamps your default confirmation statuses (paper
+  QSL, LoTW, eQSL, Club Log, HRDLog, QRZ.com — sent & received) on QSOs the file
+  leaves empty. Enable when importing **your own** log; leave off for someone
+  else's.
+
+### Field remapping (move fields on import)
+
+Contest software stores the exchange where its own module keeps it. The RSGB IOTA
+contest, for example, exports the island reference in `STATE` — imported as-is it
+becomes a US state and the IOTA award stays empty. Click **"The file puts a field
+in the wrong place…"**, then add a `STATE → IOTA` row (add as many rows as you
+need). The destination is filled **only where the file left it blank**.
+
+### Unknown fields
+
+Any valid ADIF field OpsLog doesn't promote to a column is preserved in a per-QSO
+**extras** store — editable later and re-exported intact. Nothing valid is
+dropped.
 
 ## Export
 
@@ -41,4 +76,7 @@ not lose your award-reference assignments.
 
 - To move a batch of QSOs between logs, export selected → import into the other
   profile.
+- Re-syncing statuses from another logger (Log4OM, LoTW, QRZ)? Import the file
+  with **Update duplicates** — it merges the new confirmations onto your existing
+  QSOs without creating copies.
 - Use **Find duplicates** (Tools) after importing to catch overlaps.