chore: release v0.23.9

Settings -> DX Cluster: a toggle and an interval. When it is on, logging a QSO
announces the station on the master cluster — the QSO's own station callsign as
the DX, on the frequency the contact was made on — so callers find the run
without waiting for someone else to spot it. The node fills the DE field from
the login, so the spotter is us too: a self-spot.

It fires on the FIRST QSO of a frequency and then at most once per interval.
Both halves matter: announcing every QSO would flood the node and get the
station filtered out, while a pure timer would stay silent for minutes after a
band change. A drift of up to 500 Hz still counts as the same run, so nudging
the VFO mid-pileup does not re-announce.

Five minutes is the floor, clamped in SaveSelfSpotSettings as well as in the
input: the limit protects the node from us, so it must not depend on the
frontend. The interval input keeps raw text and clamps on blur — clamping per
keystroke rewrote "10" to "5" as soon as the "1" landed.

Wired into both log paths (manual entry and UDP auto-log) on the async side, so
a cluster that is slow or down never holds up logging. A send failure restores
the previous throttle state, so the next QSO retries instead of sitting out an
interval that produced no spot.

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
@@ -286,6 +288,8 @@ const (
 	keyWKCWInvert   = "winkeyer.cw_invert"       // serial engine: invert line polarity (active-LOW)
 
 	keyClusterAutoConnect = "cluster.auto_connect"      // open every enabled server at app start
+	keyClusterSelfSpot    = "cluster.self_spot"         // "1" → announce ourselves on the cluster as we log
+	keyClusterSelfSpotMin = "cluster.self_spot_minutes" // shortest gap between two self-spots
 
 	keyScpEnabled = "scp.enabled" // Super Check Partial / N+1 suggestions on
 
@@ -293,6 +297,8 @@ const (
 	keyBackupFolder    = "backup.folder"
 	keyBackupRotation  = "backup.rotation"
 	keyBackupZip       = "backup.zip"
+	keyBackupEveryExit = "backup.every_exit" // "1" → back up on every quit, not just once/day
+	keyBackupKeepAll   = "backup.keep_all"   // "1" → each backup is a distinct time-stamped file (no same-day overwrite)
 	keyBackupLast      = "backup.last_at"
 
 	keyQSLDefaultQSLSent       = "qsl.qsl_sent"
@@ -569,6 +575,19 @@ type App struct {
 	// Loaded once, appended to on each log, rebuilt after bulk changes.
 	wcbm   map[string]struct{}
 	wcbmMu sync.RWMutex
+	// 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
+	// Self-spot throttle: when and on what frequency we last announced ourselves.
+	// Held in memory only — a restart legitimately re-announces the station.
+	selfSpotMu     sync.Mutex
+	selfSpotAt     time.Time
+	selfSpotHz     int64
 	pota           *pota.Cache
 	uls            *uls.Store // US callsign→county/grid (offline FCC ULS), lazily opened
 	awardRefs      *awardref.Repo
@@ -642,6 +661,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
@@ -1064,6 +1084,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
@@ -1438,7 +1459,8 @@ func (a *App) plannedShutdownSteps() []shutdownStep {
 		if folder == "" {
 			folder = s.DefaultFolder
 		}
-		if !backup.HasBackupToday(folder) {
+		// "Back up on every exit" bypasses the once-a-day gate.
+		if s.EveryExit || !backup.HasBackupToday(folder) {
 			out = append(out, shutdownStep{ID: "backup", Label: "Backing up database", Status: "pending"})
 		}
 	}
@@ -1518,17 +1540,12 @@ func (a *App) runBackupForShutdown() error {
 	if mysql {
 		done = backup.HasADIFBackupToday(folder)
 	}
-	if done {
+	if done && !s.EveryExit { // "every exit" backs up regardless of a prior backup today
 		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, s.KeepAll); 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))
 }
 
@@ -2051,6 +2068,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
@@ -2064,6 +2082,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
@@ -2079,6 +2098,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
 }
 
@@ -2595,6 +2615,7 @@ func (a *App) AddQSO(q qso.QSO) (id int64, err error) {
 				a.extsvc.OnQSOLogged(id)
 			}
 			a.maybeAutoSendEQSL(qc)
+			a.maybeSelfSpot(qc)
 			if a.udp != nil {
 				a.udp.EmitLoggedADIF(adif.SingleRecordADIF(qc))
 			}
@@ -4252,6 +4273,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.
@@ -7773,6 +7799,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,
@@ -11561,6 +11592,13 @@ func (a *App) LogUDPLoggedADIF(adifText string) (int64, error) {
 			a.extsvc.OnQSOLogged(id)
 		}
 		a.maybeAutoSendEQSL(qc)
+		a.maybeSelfSpot(qc)
+		// Forward to the outbound UDP integrations, exactly like the manual log
+		// path — otherwise a QSO logged FROM WSJT-X/JTDX/MSHV was never re-emitted
+		// to the outbound ADIF listeners (Log4OM, N1MM, gridtracker…).
+		if a.udp != nil {
+			a.udp.EmitLoggedADIF(adif.SingleRecordADIF(qc))
+		}
 		if a.ctx != nil {
 			wruntime.EventsEmit(a.ctx, "qso:logged", id) // refresh again so award_refs show
 		}
@@ -11755,6 +11793,8 @@ type BackupSettings struct {
 	Folder        string `json:"folder"`
 	Rotation      int    `json:"rotation"`
 	Zip           bool   `json:"zip"`
+	EveryExit     bool   `json:"every_exit"` // back up on every quit, not just the first of the day
+	KeepAll       bool   `json:"keep_all"`   // time-stamped file per backup instead of one-per-day (kept up to Rotation)
 	LastBackupAt  string `json:"last_backup_at"`
 	DefaultFolder string `json:"default_folder"` // computed, read-only — shown as a hint
 }
@@ -11769,7 +11809,7 @@ func (a *App) GetBackupSettings() (BackupSettings, error) {
 		return out, nil
 	}
 	m, err := a.settings.GetMany(a.ctx,
-		keyBackupEnabled, keyBackupFolder, keyBackupRotation, keyBackupZip, keyBackupLast)
+		keyBackupEnabled, keyBackupFolder, keyBackupRotation, keyBackupZip, keyBackupEveryExit, keyBackupKeepAll, keyBackupLast)
 	if err != nil {
 		return out, err
 	}
@@ -11779,6 +11819,8 @@ func (a *App) GetBackupSettings() (BackupSettings, error) {
 		out.Rotation = n
 	}
 	out.Zip = m[keyBackupZip] == "1"
+	out.EveryExit = m[keyBackupEveryExit] == "1"
+	out.KeepAll = m[keyBackupKeepAll] == "1"
 	out.LastBackupAt = m[keyBackupLast]
 	return out, nil
 }
@@ -11805,6 +11847,8 @@ func (a *App) SaveBackupSettings(s BackupSettings) error {
 		keyBackupFolder:    strings.TrimSpace(s.Folder),
 		keyBackupRotation:  strconv.Itoa(s.Rotation),
 		keyBackupZip:       doZip,
+		keyBackupEveryExit: boolStr(s.EveryExit),
+		keyBackupKeepAll:   boolStr(s.KeepAll),
 	} {
 		if err := a.settings.Set(a.ctx, k, v); err != nil {
 			return err
@@ -11813,6 +11857,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, unique 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", unique); 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, unique)
+	}
+	// 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", unique)
+}
+
 // 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) {
@@ -11824,20 +11895,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 := a.runConfiguredBackup(folder, s.Rotation, s.Zip, s.KeepAll)
-	path, err := backup.Run(a.ctx, a.db, a.dbPath, 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
 }
@@ -11845,11 +11906,11 @@ func (a *App) RunBackupNow() (string, error) {
 // backupLogADIF writes a rotating ADIF export of the (MySQL) logbook into the
 // backup folder. The full set of ADIF + app fields is included so the backup is
 // a complete, re-importable copy of the log.
-func (a *App) backupLogADIF(folder string, rotation int, zip bool) (string, error) {
+func (a *App) backupLogADIF(folder string, rotation int, zip, unique bool) (string, error) {
 	if a.qso == nil {
 		return "", fmt.Errorf("logbook not initialized")
 	}
-	return backup.RunADIF(folder, rotation, zip, func(p string) error {
+	return backup.RunADIF(folder, rotation, zip, unique, func(p string) error {
 		ex := &adif.Exporter{Repo: a.qso, AppName: "OpsLog", AppVersion: "0.1", IncludeAppFields: true}
 		_, e := ex.ExportFile(a.ctx, p)
 		return e
@@ -11880,19 +11941,13 @@ func (a *App) maybeShutdownBackup() {
 	if mysql {
 		done = backup.HasADIFBackupToday(folder)
 	}
-	if done {
+	if done && !s.EveryExit { // "every exit" backs up regardless of a prior backup today
 		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, s.KeepAll); 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))
 }
 
@@ -11987,11 +12042,10 @@ func (a *App) ultrabeamFollowNow(freqHz int64) {
 	if !st.Connected {
 		return
 	}
-	if st.FreqMin > 0 && st.FreqMax > 0 {
+	if !motorBandAllowed(s.Bands, freqHz) {
-		mhz := freqHz / 1_000_000
+		applog.Printf("ultrabeam: followNow %.3f MHz is %q — not in covered bands %v; no move",
-		if mhz < int64(st.FreqMin) || mhz > int64(st.FreqMax) {
+			float64(freqHz)/1e6, bandForHz(freqHz), s.Bands)
-			return // outside the antenna's tunable range
+		return // a band the antenna doesn't cover — leave it where it is
-		}
 	}
 	khz := int(freqHz / 1000)
 	ref := st.Frequency
@@ -13095,6 +13149,21 @@ func (a *App) reloadCAT() {
 			kw.SetDataMode(s.KenwoodDataMode)
 			a.cat.Start(kw)
 		}
+	case "elecraft":
+		// Elecraft K3/K4: the Kenwood-dialect client with the Elecraft specifics on
+		// (digital modes → DATA A via MD6+DT0). Reuses the Kenwood port/baud/host
+		// settings — the K3 emulates the Kenwood command set, so a separate transport
+		// would be a near-total duplicate.
+		if h := strings.TrimSpace(s.KenwoodHost); h != "" {
+			kw := cat.NewKenwoodTCP(h, s.DigitalDefault)
+			kw.SetElecraft(true)
+			a.cat.Start(kw)
+		} else {
+			kw := cat.NewKenwood(s.KenwoodPort, s.KenwoodBaud, s.DigitalDefault)
+			kw.SetLowerLines(s.KenwoodLowLines)
+			kw.SetElecraft(true)
+			a.cat.Start(kw)
+		}
 	case "icom":
 		// Native Icom CI-V over the radio's USB serial port (local control).
 		// Same civ protocol the network backend reuses for remote.
@@ -13477,7 +13546,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"
@@ -13490,6 +13559,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
 	}
@@ -13682,6 +13753,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"`
@@ -13748,6 +13829,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 {
@@ -13774,6 +13865,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)
 	}
@@ -13791,6 +13884,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()
 	}
@@ -13809,6 +13904,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()
 	}
@@ -13847,6 +13944,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)
 	}
@@ -14147,7 +14252,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() }
@@ -14168,7 +14283,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 {
@@ -14210,10 +14336,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 —
+	// Bands the antenna covers — the follow filter. The follow loop only re-tunes
-	// no tune command AND no TX inhibit — so a band the antenna can't cover (e.g.
+	// (and only lets TX-inhibit trigger) on a band in this set; on any other band
-	// 30 m on a 20 m–6 m SteppIR) never traps TX. Ignored for the Ultrabeam, which
+	// the antenna is left where it is. Expressed as a set rather than a min/max
-	// reports its own per-band coverage. 0 = defaults filled in on load for SteppIR.
+	// 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"`
 }
@@ -14227,7 +14358,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
 	}
@@ -14253,17 +14384,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
+	// Bands is the follow filter. If it was saved, use it verbatim. Otherwise this
-	// range (13–54 MHz) when unset — the common model. Widen it (e.g. min 6 for a
+	// is a config from before the band selector: migrate the legacy FreqMin/FreqMax
-	// 40 m-equipped SteppIR) in Settings. This is what lets the follow loop leave
+	// range into a band set so the effective coverage is unchanged (an unset range
-	// TX alone on a band the antenna can't reach.
+	// on a SteppIR is treated as the standard 20 m–6 m; an unset range on the
-	if out.Type == "steppir" {
+	// Ultrabeam becomes the whole 40 m–6 m universe, which still excludes 80 m).
-		if out.FreqMinMHz <= 0 {
+	if raw := strings.TrimSpace(m[keyMotorBands]); raw != "" {
-			out.FreqMinMHz = 13
+		out.Bands = normMotorBands(strings.Split(raw, ","))
 	}
-		if out.FreqMaxMHz <= 0 {
+	if len(out.Bands) == 0 {
-			out.FreqMaxMHz = 54
+		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
 }
@@ -14299,6 +14433,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),
@@ -14312,6 +14454,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
@@ -14339,7 +14482,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
@@ -14375,15 +14518,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
@@ -14421,7 +14659,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()
@@ -14434,12 +14672,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
 	}
@@ -14468,17 +14717,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).
+			// Skip bands the antenna doesn't cover (per the operator's band list) —
-			if st.FreqMin > 0 && st.FreqMax > 0 {
+			// no tune command, so the elements stay where they are on 80 m, an
-				rigMHz := rs.FreqHz / 1_000_000
+			// un-fitted 30 m, etc. Log the decision once per QSY so "why did/didn't
-				if rigMHz < int64(st.FreqMin) || rigMHz > int64(st.FreqMax) {
+			// the antenna move" is answerable from the log.
-					continue
+			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
@@ -15745,6 +15999,128 @@ func (a *App) GetClusterAutoConnect() (bool, error) {
 	return a.clusterAutoConnect()
 }
 
+// ── Self-spot ─────────────────────────────────────────────────────────────
+
+// selfSpotMinMinutes is the shortest gap OpsLog will announce itself at.
+//
+// A self-spot is traffic every user of the node sees, so the floor is a
+// courtesy rule, not a preference: at one spot per QSO a run would flood the
+// cluster within minutes and get the station filtered out — which is worse for
+// the operator than not spotting at all. Five minutes is the interval the
+// DX-cluster etiquette guides give.
+const selfSpotMinMinutes = 5
+
+// selfSpotSameRunHz is how far the frequency may drift and still count as the
+// same run. A run creeps a few hundred Hz as the operator nudges the VFO, and
+// re-announcing on every nudge is exactly the flood the gap exists to prevent.
+// Move further than this and it IS a new frequency, which is announced at once.
+const selfSpotSameRunHz = 500
+
+// SelfSpotSettings configures announcing the station on the DX cluster as it
+// logs, so callers can find it without anyone else having to spot it.
+type SelfSpotSettings struct {
+	Enabled bool `json:"enabled"`
+	Minutes int  `json:"minutes"` // shortest gap between two self-spots
+}
+
+// GetSelfSpotSettings reads the self-spot configuration.
+func (a *App) GetSelfSpotSettings() (SelfSpotSettings, error) {
+	out := SelfSpotSettings{Minutes: selfSpotMinMinutes}
+	if a.settings == nil {
+		return out, fmt.Errorf("db not initialized")
+	}
+	m, err := a.settings.GetMany(a.ctx, keyClusterSelfSpot, keyClusterSelfSpotMin)
+	if err != nil {
+		return out, err
+	}
+	out.Enabled = m[keyClusterSelfSpot] == "1"
+	if n, _ := strconv.Atoi(m[keyClusterSelfSpotMin]); n >= selfSpotMinMinutes {
+		out.Minutes = n
+	}
+	return out, nil
+}
+
+// SaveSelfSpotSettings persists it. The minimum gap is clamped here as well as
+// in the UI: the floor protects the node from us, so it must not depend on a
+// frontend that could be bypassed or carry a stale value.
+func (a *App) SaveSelfSpotSettings(s SelfSpotSettings) error {
+	if a.settings == nil {
+		return fmt.Errorf("db not initialized")
+	}
+	if s.Minutes < selfSpotMinMinutes {
+		s.Minutes = selfSpotMinMinutes
+	}
+	if err := a.settings.Set(a.ctx, keyClusterSelfSpot, boolStr(s.Enabled)); err != nil {
+		return err
+	}
+	return a.settings.Set(a.ctx, keyClusterSelfSpotMin, strconv.Itoa(s.Minutes))
+}
+
+// maybeSelfSpot announces the station on the master cluster after a QSO, so a
+// run is findable without waiting for someone else to spot it.
+//
+// The DX call and the spotter are both us: the node fills the "DE" from the
+// login, and the QSO's own station callsign is the DX — which is the right
+// source, not the profile, because that is the call the contact was made under.
+//
+// Fires on the FIRST QSO of a frequency, then at most once per configured gap.
+// Called from both log paths (manual entry and UDP auto-log), off the critical
+// path — a cluster that is slow or down must never hold up logging.
+func (a *App) maybeSelfSpot(q qso.QSO) {
+	cfg, err := a.GetSelfSpotSettings()
+	if err != nil || !cfg.Enabled {
+		return
+	}
+	call := strings.ToUpper(strings.TrimSpace(q.StationCallsign))
+	if call == "" {
+		return
+	}
+	// The QSO's frequency, not the rig's: by the time this runs the operator may
+	// already have tuned away, and a spot has to say where the contact happened.
+	var hz int64
+	if q.FreqHz != nil {
+		hz = *q.FreqHz
+	}
+	if hz <= 0 && a.cat != nil {
+		hz = a.cat.State().FreqHz // no frequency on the QSO (paper-style entry) — fall back to CAT
+	}
+	if hz <= 0 {
+		return
+	}
+
+	a.selfSpotMu.Lock()
+	sameRun := a.selfSpotHz != 0 && absInt64(hz-a.selfSpotHz) <= selfSpotSameRunHz
+	if sameRun && time.Since(a.selfSpotAt) < time.Duration(cfg.Minutes)*time.Minute {
+		a.selfSpotMu.Unlock()
+		return
+	}
+	prevAt, prevHz := a.selfSpotAt, a.selfSpotHz
+	// Claim the slot BEFORE sending: the two log paths can run concurrently and
+	// would otherwise both pass the check and spot twice.
+	a.selfSpotAt, a.selfSpotHz = time.Now(), hz
+	a.selfSpotMu.Unlock()
+
+	khz := math.Round(float64(hz)/100) / 10 // 0.1 kHz — the resolution a cluster keeps
+	if err := a.SendClusterSpot(call, khz, strings.ToUpper(strings.TrimSpace(q.Mode))); err != nil {
+		// Not sent (no enabled server, node not connected). Restore the previous
+		// state so the NEXT QSO tries again, instead of sitting out a gap that
+		// never produced a spot.
+		a.selfSpotMu.Lock()
+		a.selfSpotAt, a.selfSpotHz = prevAt, prevHz
+		a.selfSpotMu.Unlock()
+		applog.Printf("cluster: self-spot %s on %.1f kHz failed: %v", call, khz, err)
+		return
+	}
+	applog.Printf("cluster: self-spot %s on %.1f kHz sent", call, khz)
+}
+
+func absInt64(n int64) int64 {
+	if n < 0 {
+		return -n
+	}
+	return n
+}
+
 // ConnectClusterServer opens a session for one specific saved server.
 func (a *App) ConnectClusterServer(id int64) error {
 	if a.cluster == nil {
@@ -15889,18 +16265,46 @@ type SpotStatus struct {
 	Pfx    string `json:"pfx,omitempty"`
 }
 
-// ClusterSpotStatuses takes a batch of spots and returns slot status for
+// clusterStatusCache holds the whole-logbook maps ClusterSpotStatuses colours
-// each. Used by the Cluster tab to color rows (NEW / NEW BAND / NEW SLOT
+// spots against. Rebuilding them per spot batch re-scanned the entire logbook
-// / WORKED). One cty.dat lookup + one DB scan, regardless of batch size.
+// ~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
-// Mode handling: when the caller passes an empty Mode (cluster comment
+// that already holds the pointer keeps reading valid (stale-by-one-log) data
-// was ambiguous and the frontend couldn't infer) we degrade gracefully
+// while a newer snapshot is being built. See clusterStatusMaps.
-// to band-only — saying "worked" rather than wrongly flagging "new-slot"
+type clusterStatusCache struct {
-// just because we don't know the mode.
+	entities        map[int]*qso.EntitySlot
-func (a *App) ClusterSpotStatuses(spots []SpotQuery) []SpotStatus {
+	workedCalls     map[string]struct{}
-	out := make([]SpotStatus, len(spots))
+	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.
@@ -15923,43 +16327,58 @@ func (a *App) ClusterSpotStatuses(spots []SpotQuery) []SpotStatus {
 		}
 		return 0
 	}
-	// Optional digital-mode grouping (Settings → General): with it on, FT8/FT4/
+	c.entities, _ = a.qso.EntitySlotMap(a.ctx, keyFor, c.normMode)
-	// 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
-	}
 	// 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.
-	sameSlot := a.clusterWorkedSameSlot()
-	var workedCallSlots map[string]struct{}
 	if sameSlot {
-		workedCallSlots, _ = a.qso.WorkedCallSlotKeys(a.ctx, normMode)
+		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.
+	// lookup) and worked POTA parks.
-	workedCounties, _ := a.qso.WorkedCountyKeys(a.ctx, award.USCountyKey)
+	c.workedCounties, _ = a.qso.WorkedCountyKeys(a.ctx, award.USCountyKey)
-	workedPOTA, _ := a.qso.WorkedPOTARefs(a.ctx)
+	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))
+	c.workedPfx = make(map[string]struct{}, len(c.workedCalls))
-	for c := range workedCalls {
+	for call := range c.workedCalls {
-		if p := award.WPXPrefix(c); p != "" {
+		if p := award.WPXPrefix(call); p != "" {
-			workedPfx[p] = struct{}{}
+			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,

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

@@ -32,12 +32,19 @@ const (
 	keyQSLEmailSubject = "qsl.email_subject"
 	keyQSLEmailBody    = "qsl.email_body"
 	keyQSLAutoSend     = "qsl.auto_send"      // "1" → render+send an eQSL on log when an e-mail and default template exist
+	keyQSLDefaultMsg   = "qsl.default_message" // fallback QSL message printed on the card when the QSO's own QSLMSG is empty
 )
 
 // appQSLCardSentField is the ADIF APP_ field stamping when OpsLog e-mailed its
 // own QSL card. Deliberately NOT eqsl_sent (that's eQSL.cc's, kept independent).
 const appQSLCardSentField = "APP_OPSLOG_QSL_SENT"
 
+// appQSLCardRcvdField marks that a QSL was RECEIVED for this QSO (set by the
+// operator, e.g. when a card arrives by e-mail). It drives the PSE/TNX stamp on
+// the card: received → "TNX" (thanks for your card), not received → "PSE QSL"
+// (please send one). Independent of ADIF qsl_rcvd, like the sent field.
+const appQSLCardRcvdField = "APP_OPSLOG_QSL_RCVD"
+
 const (
 	defaultQSLEmailSubject = "eQSL — {CALL} de {MYCALL}"
 	defaultQSLEmailBody    = "Hi,\n\nThank you for our QSO! Please find attached your eQSL card.\n\n{DATE}  ·  {BAND}  ·  {MODE}\n\n73,\n{MYCALL}"
@@ -453,11 +460,37 @@ func (a *App) SendEQSL(qsoID int64, templateID int64, jpegB64 string) error {
 	return nil
 }
 
-// QSLEmailTemplates is the eQSL e-mail subject/body plus the auto-send toggle.
+// qslDefaultMessage returns the operator's default QSL message (Settings), used
+// on the card when a QSO has no QSLMSG of its own.
+func (a *App) qslDefaultMessage() string {
+	if a.settings == nil {
+		return ""
+	}
+	s, _ := a.settings.Get(a.ctx, keyQSLDefaultMsg)
+	return s
+}
+
+// SetOpsLogQSLReceived marks (or clears) that a QSL was received for a QSO. This
+// flips the card's PSE/TNX stamp. Stored as a timestamp in the QSO extras (a
+// single-key UPDATE, like the sent marker) so it survives concurrent uploads.
+func (a *App) SetOpsLogQSLReceived(qsoID int64, on bool) error {
+	if a.qso == nil {
+		return fmt.Errorf("db not initialized")
+	}
+	v := ""
+	if on {
+		v = time.Now().UTC().Format(time.RFC3339)
+	}
+	return a.qso.SetExtra(a.ctx, qsoID, appQSLCardRcvdField, v)
+}
+
+// QSLEmailTemplates is the eQSL e-mail subject/body, the auto-send toggle, and
+// the default QSL message printed on the card when a QSO has none of its own.
 type QSLEmailTemplates struct {
 	Subject        string `json:"subject"`
 	Body           string `json:"body"`
 	AutoSend       bool   `json:"auto_send"`
+	DefaultMessage string `json:"default_message"`
 }
 
 // QSLGetEmailTemplates returns the eQSL e-mail templates (with defaults).
@@ -466,7 +499,7 @@ func (a *App) QSLGetEmailTemplates() (QSLEmailTemplates, error) {
 	if a.settings == nil {
 		return out, nil
 	}
-	m, err := a.settings.GetMany(a.ctx, keyQSLEmailSubject, keyQSLEmailBody, keyQSLAutoSend)
+	m, err := a.settings.GetMany(a.ctx, keyQSLEmailSubject, keyQSLEmailBody, keyQSLAutoSend, keyQSLDefaultMsg)
 	if err != nil {
 		return out, err
 	}
@@ -477,6 +510,7 @@ func (a *App) QSLGetEmailTemplates() (QSLEmailTemplates, error) {
 		out.Body = b
 	}
 	out.AutoSend = m[keyQSLAutoSend] == "1"
+	out.DefaultMessage = m[keyQSLDefaultMsg]
 	return out, nil
 }
 
@@ -495,7 +529,10 @@ func (a *App) QSLSaveEmailTemplates(t QSLEmailTemplates) error {
 	if t.AutoSend {
 		v = "1"
 	}
-	return a.settings.Set(a.ctx, keyQSLAutoSend, v)
+	if err := a.settings.Set(a.ctx, keyQSLAutoSend, v); err != nil {
+		return err
+	}
+	return a.settings.Set(a.ctx, keyQSLDefaultMsg, t.DefaultMessage)
 }
 
 // maybeAutoSendEQSL fires an eQSL render+send for a freshly-logged QSO when the
@@ -634,6 +671,18 @@ func (a *App) qslVars(q qso.QSO) (map[string]string, qslcard.CountryInfo, error)
 		}
 		return strconv.Itoa(z)
 	}
+	// The QSL message on the card: the QSO's own QSLMSG wins; when it's empty the
+	// operator's default message (Settings) is used instead.
+	msg := q.QSLMsg
+	if strings.TrimSpace(msg) == "" {
+		msg = a.qslDefaultMessage()
+	}
+	// PSE/TNX stamp, chosen automatically by whether a QSL was received for this
+	// QSO (appQSLCardRcvdField): received → thank them, otherwise ask for a card.
+	pseTnx := "PSE QSL"
+	if q.Extras != nil && strings.TrimSpace(q.Extras[appQSLCardRcvdField]) != "" {
+		pseTnx = "TNX"
+	}
 	vars := map[string]string{
 		"profile.callsign":      info.Callsign,
 		"profile.operator_name": info.Operator,
@@ -650,7 +699,8 @@ func (a *App) qslVars(q qso.QSO) (map[string]string, qslcard.CountryInfo, error)
 		"qso.mode":     q.Mode,
 		"qso.submode":  q.Submode,
 		"qso.rst_sent": q.RSTSent,
-		"qso.qsl_msg":  q.QSLMsg,
+		"qso.qsl_msg":  msg,
+		"qso.pse_tnx":  pseTnx,
 		"qso.name":     q.Name,
 	}
 	vars["qso.my_rig"], vars["qso.my_antenna"] = a.qslRigAntenna(q)

changelog.json

@@ -1,4 +1,88 @@
 [
+  {
+    "version": "0.23.9",
+    "date": "",
+    "en": [
+      "Backup: new \"Back up on every exit\" option (Settings → Backup). With it on, OpsLog backs up the database each time you quit instead of only the first time of the day — so a second session's QSOs are always captured.",
+      "Cluster details (My station): removed the example placeholders in My rig / My antenna (and the satellite name/mode) — they looked like real values, so an empty field read as already filled.",
+      "QSL: new \"OpsLog QSL received\" marker on the QSO edit window (next to QSL Message), with a live PSE QSL / TNX indicator. When a QSL was received the card prints TNX (thanks), otherwise PSE QSL (please send one) — automatic. The stamp uses the {qso.pse_tnx} token (in the default card footer; placeable anywhere in the designer). A \"QSL received\" column was added to Recent QSOs.",
+      "QSL: a default QSL message (Settings → E-mail, under the QSL card e-mail) now prints on the card when a QSO has no QSL Message of its own — a QSO's own QSL Message always takes precedence.",
+      "UDP outbound: a QSO logged from WSJT-X / JTDX / MSHV (via the inbound UDP listener) is now forwarded to the outbound ADIF integrations too — previously only QSOs typed directly into OpsLog were re-emitted.",
+      "Backup: with \"back up on every exit\", a new \"Keep every backup\" sub-option writes a distinct time-stamped file per exit (opslog-YYYY-MM-DD-HHMMSS.db) instead of overwriting the day's file. Rotation still keeps the newest N — raise it for more history.",
+      "Awards editor: the PRIMARY QSOFIELDS search now has a Prefix field too (prepended to each found reference, e.g. captured 01 → D01) — previously only the OR fallback searches could add a prefix, so a DOK-style award couldn't match on its main rule.",
+      "CAT: new Elecraft K3/K4 backend in the rig list. Select it (it reuses the Kenwood USB/network settings) and digital modes automatically use DATA A (MD6+DT0) — the sub-mode FT8 audio needs, so the K3 no longer keys the transmitter without modulating.",
+      "Settings database: the New / Open existing / Save a copy / Rename / Reset buttons are back (Settings → Database). Only \"Open folder\" was left, which opens Windows Explorer — where a .db can't be selected, it just asks which program should open it. Picking a database now uses a proper file dialog and offers a one-click restart.",
+      "Recent QSOs: a column dragged to sit AFTER an award column now stays there. Award columns were left out of the saved layout, so on reload they were pushed to the far right and jumped back in front of the column you had placed after them.",
+      "Entry form and QSO editor: Name and QTH are capitalised word by word (\"JEAN-PIERRE\" → \"Jean-Pierre\"), Comment and Note get a capital first letter. Applied when you leave the field, so typing is never interrupted; the rest of a comment is left alone, since it usually holds callsigns and modes.",
+      "Recent QSOs: the search box only ever takes callsigns, so it now upper-cases as you type and carries a small clear button.",
+      "CAT Elecraft K3/K4: the rig's mode is read back correctly. MD6 is DATA on a K3 but FSK on a Kenwood, and OpsLog decoded it as RTTY — so a K3 running FT8 showed RTTY, logged its QSOs as RTTY, and told WSJT-X/JTDX over the shared CAT link that the rig was in RTTY while they had asked for a data mode. Applies to the Elecraft K3/K4 backend and to the \"DATA A — MD6\" option; a plain Kenwood still reads MD6 as RTTY.",
+      "CAT sharing: the transmitter is dropped when the program keying it goes away. If WSJT-X/JTDX crashed, was closed, or simply had its connection cut — which is what saving the settings does, since the sharing server is rebuilt — the rig stayed on air with nobody watching: the Kenwood/Elecraft link stops polling while PTT is held, so nothing noticed. A K3 was seen transmitting for 29 seconds.",
+      "DX cluster: new \"Self-spot while I log\" option (Settings → DX Cluster). When you log a QSO, OpsLog announces YOU on the master cluster — your station callsign as the DX, on the frequency you just worked — so callers find you without waiting for someone else to spot you. It fires on the first QSO of a frequency, then no more often than the interval you set; five minutes is the minimum, since a self-spot is traffic every user of the node sees."
+    ],
+    "fr": [
+      "Sauvegarde : nouvelle option \"Sauvegarder à chaque fermeture\" (Réglages → Sauvegarde). Activée, OpsLog sauvegarde la base à chaque fois que tu quittes au lieu d'une seule fois par jour — les QSO d'une seconde session sont ainsi toujours pris.",
+      "Détails cluster (Ma station) : suppression des exemples en filigrane dans Mon rig / Mon antenne (et nom/mode satellite) — ils ressemblaient à de vraies valeurs, faisant croire qu'un champ vide était déjà rempli.",
+      "QSL : nouveau marqueur \"QSL OpsLog reçue\" dans la fenêtre d'édition du QSO (à côté du Message QSL), avec un indicateur PSE QSL / TNX en direct. Si une QSL a été reçue, la carte imprime TNX (merci), sinon PSE QSL (envoie-moi une carte) — automatique. Le tampon utilise le token {qso.pse_tnx} (dans le pied de carte par défaut ; plaçable où tu veux dans le designer). Une colonne \"QSL reçue\" a été ajoutée aux QSO récents.",
+      "QSL : un message QSL par défaut (Réglages → E-mail, sous l'e-mail de carte QSL) s'imprime désormais sur la carte quand un QSO n'a pas son propre Message QSL — le Message QSL du QSO l'emporte toujours.",
+      "UDP sortant : un QSO enregistré depuis WSJT-X / JTDX / MSHV (via l'écouteur UDP entrant) est désormais aussi transmis aux intégrations ADIF sortantes — avant, seuls les QSO saisis directement dans OpsLog étaient réémis.",
+      "Sauvegarde : avec \"sauvegarder à chaque fermeture\", une nouvelle sous-option \"Garder chaque sauvegarde\" écrit un fichier horodaté distinct par fermeture (opslog-AAAA-MM-JJ-HHMMSS.db) au lieu d'écraser le fichier du jour. La rotation garde les N plus récents — augmente-la pour plus d'historique.",
+      "Éditeur de diplômes : la recherche PRINCIPALE QSOFIELDS a aussi un champ Préfixe (ajouté devant chaque référence trouvée, ex. 01 capturé → D01) — avant, seules les recherches OR de repli pouvaient ajouter un préfixe, empêchant un diplôme type DOK de matcher sur sa règle principale.",
+      "CAT : nouveau backend Elecraft K3/K4 dans la liste des rigs. Sélectionne-le (il réutilise les réglages USB/réseau Kenwood) et les modes numériques passent automatiquement en DATA A (MD6+DT0) — le sous-mode dont l'audio FT8 a besoin, donc le K3 ne passe plus en émission sans moduler.",
+      "Base de réglages : les boutons Nouvelle base / Ouvrir existante / Enregistrer une copie / Renommer / Réinitialiser sont de retour (Réglages → Base de données). Il ne restait que \"Ouvrir le dossier\", qui lance l'Explorateur Windows — où un .db n'est pas sélectionnable, il demande juste avec quel logiciel l'ouvrir. Choisir une base passe désormais par un vrai sélecteur de fichier, avec redémarrage en un clic.",
+      "QSO récents : une colonne déplacée APRÈS une colonne de diplôme y reste. Les colonnes de diplômes étaient exclues de la disposition enregistrée, donc au rechargement elles étaient repoussées tout à droite et repassaient devant la colonne que tu avais placée après elles.",
+      "Saisie et éditeur de QSO : Name et QTH sont capitalisés mot par mot (« JEAN-PIERRE » → « Jean-Pierre »), Comment et Note prennent une majuscule en première lettre. Appliqué quand tu quittes le champ, donc la frappe n'est jamais perturbée ; la suite d'un commentaire est laissée telle quelle, puisqu'elle contient souvent des indicatifs et des modes.",
+      "QSO récents : le champ de recherche ne prend que des indicatifs — il passe donc en majuscules à la frappe et reçoit un petit bouton d'effacement.",
+      "CAT Elecraft K3/K4 : le mode de la radio est relu correctement. MD6 vaut DATA sur un K3 mais FSK sur un Kenwood, et OpsLog le décodait en RTTY — un K3 en FT8 affichait donc RTTY, enregistrait ses QSO en RTTY, et annonçait RTTY à WSJT-X/JTDX via le partage CAT alors qu'ils avaient demandé un mode data. Vaut pour le backend Elecraft K3/K4 et pour l'option « DATA A — MD6 » ; un Kenwood classique lit toujours MD6 comme RTTY.",
+      "Partage CAT : l'émission est coupée quand le logiciel qui la commandait disparaît. Si WSJT-X/JTDX plantait, était fermé, ou voyait simplement sa connexion coupée — ce que fait un enregistrement des réglages, puisque le serveur de partage est reconstruit — la radio restait en émission sans surveillance : la liaison Kenwood/Elecraft cesse d'interroger le poste tant que le PTT est tenu, donc rien ne s'en apercevait. Un K3 a été vu en émission pendant 29 secondes.",
+      "Cluster DX : nouvelle option « M'auto-spotter quand j'enregistre » (Réglages → DX Cluster). À chaque QSO enregistré, OpsLog t'annonce sur le cluster maître — ton indicatif de station en DX, sur la fréquence que tu viens de travailler — pour qu'on te trouve sans attendre que quelqu'un te spotte. Déclenché au premier QSO d'une fréquence, puis pas plus souvent que l'intervalle choisi ; cinq minutes est le minimum, un auto-spot étant du trafic que voient tous les utilisateurs du nœud."
+    ]
+  },
+  {
+    "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": "",

frontend/src/App.tsx

@@ -103,6 +103,7 @@ import { WinkeyerPanel, type WKStatus, type WKMacro } from '@/components/Winkeye
 import { RotorCompass } from '@/components/RotorCompass';
 import { writeUiPref } from '@/lib/uiPref';
 import { formatDateTimeUTC } from '@/lib/dateFormat';
+import { titleCase, sentenceCase } from '@/lib/textCase';
 import { setGridPrefsProfile, flushGridPrefs } from '@/lib/gridPrefs';
 import { DvkPanel, type DVKMsg, type DVKStat } from '@/components/DvkPanel';
 
@@ -1500,6 +1501,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.
@@ -4145,7 +4223,8 @@ export default function App() {
   );
   const nameBlock = (
     <div className="flex flex-col flex-1 min-w-[110px]"><Label className="mb-1 h-3.5">{t('field.name')}</Label>
-      <Input value={name} onChange={(e) => { setName(e.target.value); markEdited('name'); }} />
+      <Input value={name} onChange={(e) => { setName(e.target.value); markEdited('name'); }}
+        onBlur={() => setName(titleCase)} />
     </div>
   );
   // In contest mode QTH is replaced by the sent (read-only, auto) and received
@@ -4165,7 +4244,8 @@ export default function App() {
     </>
   ) : (
     <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'); }} />
+      <Input value={qth} onChange={(e) => { setQth(e.target.value); markEdited('qth'); }}
+        onBlur={() => setQth(titleCase)} />
     </div>
   );
   const gridBlock = (
@@ -4310,7 +4390,7 @@ export default function App() {
   );
   const commentSm = (
     <div className="flex flex-col w-40"><Label className="mb-1 h-3.5">{t('field.comment')}</Label>
-      <Input value={comment} onChange={(e) => setComment(e.target.value)} />
+      <Input value={comment} onChange={(e) => setComment(e.target.value)} onBlur={() => setComment(sentenceCase)} />
     </div>
   );
   // Inline-label variants (label to the LEFT of the control, Log4OM-style) —
@@ -4426,12 +4506,12 @@ export default function App() {
   // column). No flex-1 so they stay one row tall.
   const commentLine = (
     <div className="flex flex-col"><Label className="mb-1 h-3.5">{t('field.comment')}</Label>
-      <Input value={comment} onChange={(e) => setComment(e.target.value)} />
+      <Input value={comment} onChange={(e) => setComment(e.target.value)} onBlur={() => setComment(sentenceCase)} />
     </div>
   );
   const noteLine = (
     <div className="flex flex-col"><Label className="mb-1 h-3.5">{t('field.note')}</Label>
-      <Input value={note} onChange={(e) => setNote(e.target.value)} />
+      <Input value={note} onChange={(e) => setNote(e.target.value)} onBlur={() => setNote(sentenceCase)} />
     </div>
   );
   const logButtons = (
@@ -5528,7 +5608,8 @@ export default function App() {
                 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'); }} />
+                <Input value={name} onChange={(e) => { setName(e.target.value); markEdited('name'); }}
+                  onBlur={() => setName(titleCase)} />
               </div>
               {qthBlock}
               {gridBlock}
@@ -5592,6 +5673,7 @@ 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,
@@ -5967,12 +6049,29 @@ export default function App() {
 
             <TabsContent value="recent" className="mt-0 flex flex-col min-h-0 flex-1">
               <div className="flex gap-2 p-2.5 border-b border-border/60">
+                {/* Callsign-only search: forced upper-case (a call is never
+                    lower-case, and the operator shouldn't have to hold shift)
+                    with an inline clear so wiping the filter is one click
+                    instead of a select-all + delete. */}
+                <div className="relative flex-1">
                   <Input
-                  className="flex-1"
+                    className="w-full pr-8 font-mono"
                     placeholder="Search callsign…"
                     value={filterCallsign}
-                  onChange={(e) => setFilterCallsign(e.target.value)}
+                    onChange={(e) => setFilterCallsign(e.target.value.toUpperCase())}
                   />
+                  {filterCallsign && (
+                    <button
+                      type="button"
+                      aria-label={t('btn.clear')}
+                      title={t('btn.clear')}
+                      className="absolute right-1.5 top-1/2 -translate-y-1/2 inline-flex items-center justify-center size-5 rounded text-muted-foreground hover:text-foreground hover:bg-foreground/10"
+                      onClick={() => setFilterCallsign('')}
+                    >
+                      <X className="size-3.5" />
+                    </button>
+                  )}
+                </div>
                 <Button variant="outline" size="sm" onClick={() => refresh()}>
                   <RefreshCw className="size-3.5" /> Refresh
                 </Button>

frontend/src/components/AwardEditor.tsx

@@ -34,7 +34,7 @@ export type AwardDef = {
   url?: string; download_url?: string; ref_url?: string; valid_from?: string; valid_to?: string; alias?: string;
   ref_display?: string; // grid column shows: ref | name | both
   type?: string; field: string; match_by?: string; exact_match?: boolean; one_ref_per_qso?: boolean; pattern: string;
-  leading_str?: string; trailing_str?: string; dynamic?: boolean;
+  leading_str?: string; trailing_str?: string; prefix?: string; dynamic?: boolean;
   or_rules?: AwardOrRule[];
   dxcc_filter: number[] | null; valid_bands?: string[]; valid_modes?: string[]; emission?: string[];
   confirm: string[] | null; validate?: string[] | null; grant_codes?: string; export_credit_granted?: boolean;
@@ -556,9 +556,10 @@ export function AwardEditor({ open, onClose, onSaved }: Props) {
                       <label className="flex items-center gap-2 text-xs cursor-pointer pl-[128px]"><Checkbox checked={!!cur.exact_match} onCheckedChange={(c) => patch({ exact_match: !!c })} /> {t('awed.exactMatch')}</label>
                       <label className="flex items-center gap-2 text-xs cursor-pointer pl-[128px]" title={t('awed.oneRefHint')}><Checkbox checked={!!cur.one_ref_per_qso} onCheckedChange={(c) => patch({ one_ref_per_qso: !!c })} /> {t('awed.oneRef')}</label>
                       <Field2 label={t('awed.patternRegex')}><Input className="h-8 font-mono text-xs" value={cur.pattern} onChange={(e) => patch({ pattern: e.target.value })} placeholder={t('awed.patternPlaceholder')} /></Field2>
-                      <div className="grid grid-cols-2 gap-3">
+                      <div className="grid grid-cols-3 gap-3">
                         <Field2 label={t('awed.leadingString')}><Input className="h-8 font-mono text-xs" value={cur.leading_str ?? ''} onChange={(e) => patch({ leading_str: e.target.value })} /></Field2>
                         <Field2 label={t('awed.trailingString')}><Input className="h-8 font-mono text-xs" value={cur.trailing_str ?? ''} onChange={(e) => patch({ trailing_str: e.target.value })} /></Field2>
+                        <Field2 label={t('awed.prefix')}><Input className="h-8 font-mono text-xs" value={cur.prefix ?? ''} onChange={(e) => patch({ prefix: e.target.value })} placeholder={t('awed.prefixPlaceholder')} title={t('awed.prefixTitle')} /></Field2>
                       </div>
 
                       {/* Fallback searches: tried in order, only while nothing

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 [defs, tracked] = await Promise.all([
-      const list: AwardListItem[] = defs
+        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

frontend/src/components/BandSlotGrid.tsx

@@ -22,6 +22,9 @@ interface Props {
   // 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,
@@ -93,7 +96,7 @@ 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, forCall }: 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
@@ -340,6 +343,7 @@ export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, hasCal
           band={slot.band}
           cls={slot.cls}
           onClose={() => setSlot(null)}
+          onEdit={onEditQso}
         />
       )}
     </section>
@@ -351,8 +355,8 @@ export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, hasCal
 // 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 }: {
+function SlotQSOModal({ call, dxcc, entity, band, cls, onClose, onEdit }: {
-  call: string; dxcc: number; entity: string; band: string; cls: string; onClose: () => void;
+  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('');
@@ -376,18 +380,19 @@ function SlotQSOModal({ call, dxcc, entity, band, cls, onClose }: {
   }, [onClose]);
 
   return (
-    <div className="fixed inset-0 z-50 flex items-center justify-center bg-black/50" onClick={onClose}>
+    <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-lg shadow-xl w-[720px] max-w-[92vw] max-h-[70vh] flex flex-col"
+      <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 px-3 py-2 border-b border-border">
+        <div className="flex items-center gap-2.5 px-4 py-2.5 border-b border-border bg-muted/30">
-          <span className="font-semibold text-sm">
+          <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>
-            {band} · {cls}
+          <div className="min-w-0">
-            {entity && <span className="text-muted-foreground font-normal"> — {entity}</span>}
+            <div className="font-semibold text-sm leading-tight truncate">
-          </span>
+              {cls}{entity && <span className="text-muted-foreground font-normal"> · {entity}</span>}
-          <span className="ml-auto text-xs text-muted-foreground tabular-nums">
+            </div>
-            {rows ? `${rows.length} QSO` : ''}
+            {onEdit && <div className="text-[10px] text-muted-foreground leading-tight">Click a callsign to edit the QSO</div>}
-          </span>
+          </div>
-          <button type="button" onClick={onClose} className="text-muted-foreground hover:text-foreground">
+          <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>
@@ -400,30 +405,40 @@ function SlotQSOModal({ call, dxcc, entity, band, cls, onClose }: {
           ) : rows.length === 0 ? (
             <p className="p-4 text-xs text-muted-foreground italic">No QSOs.</p>
           ) : (
-            <table className="w-full text-xs">
+            <table className="w-full text-xs border-collapse">
-              <thead className="sticky top-0 bg-muted/60 backdrop-blur text-muted-foreground">
+              <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-2 py-1">Date UTC</th>
+                  <th className="text-left font-medium px-3 py-1.5">Date UTC</th>
-                  <th className="text-left font-medium px-2 py-1">Callsign</th>
+                  <th className="text-left font-medium px-3 py-1.5">Callsign</th>
-                  <th className="text-left font-medium px-2 py-1">Mode</th>
+                  <th className="text-left font-medium px-3 py-1.5">Mode</th>
-                  <th className="text-left font-medium px-2 py-1">Freq</th>
+                  <th className="text-left font-medium px-3 py-1.5">Freq</th>
-                  <th className="text-left font-medium px-2 py-1">Name</th>
+                  <th className="text-left font-medium px-3 py-1.5">Name</th>
-                  <th className="text-left font-medium px-2 py-1">Cfm</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">
+                    <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-2 py-1 tabular-nums text-muted-foreground whitespace-nowrap">
+                      <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={cn('px-2 py-1 font-mono', q.callsign === call && 'font-bold text-primary')}>{q.callsign}</td>
+                      <td className="px-3 py-1.5">
-                      <td className="px-2 py-1">{q.mode}</td>
+                        {onEdit ? (
-                      <td className="px-2 py-1 tabular-nums text-muted-foreground">{q.freq_hz ? (q.freq_hz / 1e6).toFixed(3) : ''}</td>
+                          <button type="button" onClick={() => { onEdit(q.id as number); onClose(); }} title="Edit this QSO"
-                      <td className="px-2 py-1 text-muted-foreground truncate max-w-[160px]">{q.name}</td>
+                            className={cn('font-mono cursor-pointer text-left hover:underline underline-offset-2', mine ? 'font-bold text-primary' : 'text-foreground hover:text-primary')}>
-                      <td className="px-2 py-1">{cfm ? <span className="text-success">✓</span> : ''}</td>
+                            {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>
                   );
                 })}

frontend/src/components/ClusterGrid.tsx

@@ -410,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
@@ -419,14 +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
+  // Mode cellStyles and the dimmed "represents nothing" class depend on them but
-  // won't re-render those cells on its own — force a refresh so e.g. a worked call
+  // the cell VALUE doesn't change, so ag-grid won't re-render on its own — force a
-  // turns blue once its status loads.
+  // 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(() => {
-    // redrawRows (not refreshCells) so getRowStyle re-runs too — the whole-row
+    if (refreshPending.current !== undefined) return; // a refresh is already queued
-    // dimming of "represents nothing" spots depends on the status that lands here.
+    refreshPending.current = window.setTimeout(() => {
-    gridRef.current?.api?.redrawRows();
+      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.
@@ -511,7 +524,6 @@ export function ClusterGrid({ rows, spotStatus, onSpotClick }: Props) {
             onColumnVisible={saveColumnState}
             onSortChanged={saveColumnState}
             onRowClicked={handleRowClicked}
-            getRowStyle={(p: any) => (isDull(statusFor(p)) ? { opacity: 0.4 } : undefined)}
             animateRows={false}
             suppressCellFocus
             getRowId={(p) => `${(p.data as any).received_at}-${(p.data as any).dx_call}-${(p.data as any).source_id}`}

frontend/src/components/DetailsPanel.tsx

@@ -85,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';
@@ -147,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, slotCall, slotBand, slotMode, slotWb, slotWbBusy, 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
@@ -288,6 +290,7 @@ export function DetailsPanel({ callsign, prefix, operatorGrid, remoteGrid, qth,
             bands={bands}
             hasCall={slotCall ? true : callsign.trim() !== ''}
             forCall={slotCall}
+            onEditQso={onEditQso}
             lat={dxLL?.lat} lon={dxLL?.lon} />
         </div>
       )}
@@ -462,18 +465,18 @@ export function DetailsPanel({ callsign, prefix, operatorGrid, remoteGrid, qth,
             </Select>
           </Field>
           <Field label={t('detp.rig')} span={3}>
-            <Input value={details.my_rig} placeholder="Flex 8600" onChange={(e) => onChange({ my_rig: e.target.value })} />
+            <Input value={details.my_rig} onChange={(e) => onChange({ my_rig: e.target.value })} />
           </Field>
           <Field label={t('detp.antenna')} span={3}>
-            <Input value={details.my_antenna} placeholder="UB640" onChange={(e) => onChange({ my_antenna: e.target.value })} />
+            <Input value={details.my_antenna} onChange={(e) => onChange({ my_antenna: e.target.value })} />
           </Field>
           {satelliteMode && (
             <>
               <Field label={t('detp.satName')} span={3}>
-                <Input value={details.sat_name} placeholder="AO-91" onChange={(e) => onChange({ sat_name: e.target.value })} />
+                <Input value={details.sat_name} onChange={(e) => onChange({ sat_name: e.target.value })} />
               </Field>
               <Field label={t('detp.satelliteMode')} span={3}>
-                <Input value={details.sat_mode} placeholder="U/V" onChange={(e) => onChange({ sat_mode: e.target.value })} />
+                <Input value={details.sat_mode} onChange={(e) => onChange({ sat_mode: e.target.value })} />
               </Field>
             </>
           )}

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, SetOpsLogQSLReceived } from '../../wailsjs/go/main/App';
 import { rstOptions, type RSTLists } from '@/lib/rst';
 import { AwardRefSelector } from '@/components/AwardRefSelector';
 import { AdifExtrasEditor } from '@/components/AdifExtrasEditor';
@@ -22,6 +22,7 @@ import { Combobox } from '@/components/ui/combobox';
 import { cn } from '@/lib/utils';
 import { flagURL } from '@/lib/flags';
 import { useI18n } from '@/lib/i18n';
+import { titleCase, sentenceCase } from '@/lib/textCase';
 import type { QSOForm } from '@/types';
 
 type QSO = QSOForm;
@@ -428,6 +429,22 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
     [draft.extras],
   );
 
+  // OpsLog QSL "received" marker (ADIF extra). Drives the card's PSE/TNX stamp:
+  // received → TNX (thanks for your card), otherwise PSE QSL (please send one).
+  // Saved with the normal Save via draft.extras.
+  const OPSLOG_QSL_RCVD = 'APP_OPSLOG_QSL_RCVD';
+  const qslReceived = !!String(draft.extras?.[OPSLOG_QSL_RCVD] ?? '').trim();
+  const toggleQslReceived = (on: boolean) => {
+    // Reflect immediately in the draft (for the PSE/TNX indicator)…
+    const next = { ...(draft.extras ?? {}) };
+    if (on) next[OPSLOG_QSL_RCVD] = new Date().toISOString();
+    else delete next[OPSLOG_QSL_RCVD];
+    set('extras', next as any);
+    // …and persist right away with a targeted write that reliably sets OR clears
+    // the key (the modal's extras-merge on Save wouldn't clear a removed key).
+    if ((draft as any).id) SetOpsLogQSLReceived((draft as any).id, on).catch(() => {});
+  };
+
   return (
     <Dialog open onOpenChange={(o) => { if (!o) onClose(); }}>
       <DialogContent className="max-w-5xl max-h-[92vh] grid grid-rows-[auto_1fr_auto] gap-0 p-0">
@@ -466,7 +483,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">
+                  <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>
@@ -483,7 +515,8 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
               <div className="grid grid-cols-2 gap-x-6 gap-y-2.5">
                 {/* ── Left column ── */}
                 <div className="flex flex-col gap-2.5">
-                  <div><Label>{t('qedit.name')}</Label><Input value={draft.name ?? ''} onChange={(e) => set('name', e.target.value)} /></div>
+                  <div><Label>{t('qedit.name')}</Label><Input value={draft.name ?? ''} onChange={(e) => set('name', e.target.value)}
+                    onBlur={() => set('name', titleCase(draft.name ?? '') as any)} /></div>
                   <div className="flex items-center gap-2">
                     <Label className="w-20 shrink-0">{t('qedit.band')}</Label>
                     <Select value={draft.band || ''} onValueChange={(v) => set('band', v)}>
@@ -549,8 +582,10 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
                     <div className="flex flex-col flex-1"><Label>{t('qedit.grid')}</Label><Input value={draft.grid ?? ''} onChange={(e) => set('grid', e.target.value)} className="font-mono uppercase" /></div>
                     <div className="flex flex-col w-24"><Label>PFX</Label><Input readOnly value={pfxOf(draft.callsign ?? '')} className="font-mono bg-muted/40" /></div>
                   </div>
-                  <div><Label>{t('qedit.comment')}</Label><Input value={draft.comment ?? ''} onChange={(e) => set('comment', e.target.value)} /></div>
+                  <div><Label>{t('qedit.comment')}</Label><Input value={draft.comment ?? ''} onChange={(e) => set('comment', e.target.value)}
-                  <div><Label>{t('qedit.note')}</Label><Textarea rows={3} value={draft.notes ?? ''} onChange={(e) => set('notes', e.target.value)} /></div>
+                    onBlur={() => set('comment', sentenceCase(draft.comment ?? '') as any)} /></div>
+                  <div><Label>{t('qedit.note')}</Label><Textarea rows={3} value={draft.notes ?? ''} onChange={(e) => set('notes', e.target.value)}
+                    onBlur={() => set('notes', sentenceCase(draft.notes ?? '') as any)} /></div>
                 </div>
               </div>
             </TabsContent>
@@ -571,7 +606,8 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
                       </SelectContent>
                     </Select>
                   </div>
-                  <div><Label>QTH</Label><Input value={draft.qth ?? ''} onChange={(e) => set('qth', e.target.value)} /></div>
+                  <div><Label>QTH</Label><Input value={draft.qth ?? ''} onChange={(e) => set('qth', e.target.value)}
+                    onBlur={() => set('qth', titleCase(draft.qth ?? '') as any)} /></div>
                   <div><Label>{t('qedit.address')}</Label><Textarea rows={4} value={draft.address ?? ''} onChange={(e) => set('address', e.target.value)} /></div>
                 </div>
                 {/* Right column */}
@@ -581,7 +617,19 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
                     <div className="flex flex-col flex-1"><Label>Lat</Label><Input type="number" step="0.000001" value={draft.lat ?? ''} onChange={(e) => set('lat', numOrUndef(e.target.value) as any)} className="font-mono" /></div>
                     <div className="flex flex-col flex-1"><Label>Lon</Label><Input type="number" step="0.000001" value={draft.lon ?? ''} onChange={(e) => set('lon', numOrUndef(e.target.value) as any)} className="font-mono" /></div>
                   </div>
-                  <div><Label>{t('qedit.qslMsg')}</Label><Input value={draft.qsl_msg ?? ''} onChange={(e) => set('qsl_msg', e.target.value)} /></div>
+                  <div>
+                    <Label>{t('qedit.qslMsg')}</Label>
+                    <Input value={draft.qsl_msg ?? ''} onChange={(e) => set('qsl_msg', e.target.value)} />
+                    <div className="mt-1 flex items-center gap-2">
+                      <label className="flex items-center gap-2 text-sm cursor-pointer">
+                        <Checkbox checked={qslReceived} onCheckedChange={(c) => toggleQslReceived(!!c)} />
+                        {t('qedit.qslReceived')}
+                      </label>
+                      <span className="text-[11px] font-mono px-1.5 py-0.5 rounded bg-muted text-muted-foreground" title={t('qedit.pseTnxHint')}>
+                        {qslReceived ? 'TNX' : 'PSE QSL'}
+                      </span>
+                    </div>
+                  </div>
                   <div><Label>{t('qedit.qslVia')}</Label><Input value={draft.qsl_via ?? ''} onChange={(e) => set('qsl_via', e.target.value)} /></div>
                 </div>
               </div>

frontend/src/components/RecentQSOsGrid.tsx

@@ -195,6 +195,8 @@ export const makeColCatalog = (t: TFn, myGrid?: string): ColEntry[] => [
   { group: 'eQSL', label: t('rqg.c.eqsl_rcvd_date'), colId: 'eqsl_rcvd_date', headerName: t('rqg.h.eqsl_rcvd_date'), field: 'eqsl_rcvd_date' as any, width: 120, valueFormatter: (p) => fmtDateOnly(p.value) },
   // App-specific: when OpsLog e-mailed its own QSL card. Distinct from eQSL.cc.
   { group: 'QSL', label: t('rqg.c.opslog_qsl_card_sent'), colId: 'opslog_qsl_card_sent', headerName: t('rqg.c.opslog_qsl_card_sent'), width: 100, cellClass: qslStatusCellClass, valueGetter: (p) => { const e = (p.data as any)?.extras ?? {}; return (e['APP_OPSLOG_QSL_SENT'] || e['APP_OPSLOG_QSL_CARD_SENT']) ? 'Y' : 'N'; }, defaultVisible: true },
+  // App-specific: operator marked a QSL as RECEIVED for this QSO (drives PSE/TNX).
+  { group: 'QSL', label: t('rqg.c.opslog_qsl_card_rcvd'), colId: 'opslog_qsl_card_rcvd', headerName: t('rqg.c.opslog_qsl_card_rcvd'), width: 100, cellClass: qslStatusCellClass, valueGetter: (p) => { const e = (p.data as any)?.extras ?? {}; return e['APP_OPSLOG_QSL_RCVD'] ? 'Y' : 'N'; }, defaultVisible: false },
   // App-specific: when the QSO's audio recording was e-mailed to the station.
   { group: 'QSL', label: t('rqg.c.opslog_recording_sent'), colId: 'opslog_recording_sent', headerName: t('rqg.h.opslog_recording_sent'), width: 100, cellClass: qslStatusCellClass, valueGetter: (p) => { const e = (p.data as any)?.extras ?? {}; return e['APP_OPSLOG_RECORDING_SENT'] ? 'Y' : 'N'; }, defaultVisible: false },
 
@@ -280,12 +282,22 @@ const GRP_KEYS: Record<string, string> = {
 };
 export const groupLabel = (t: TFn, g: string): string => t(GRP_KEYS[g] ?? g);
 
-// Award columns are governed SOLELY by the awardShown code-set, never by AG
+// Award-column VISIBILITY is governed SOLELY by the awardShown code-set, never
-// Grid's saved column state. Stripping them here (on both save and restore)
+// by AG Grid's saved column state: dropping `hide` here (on both save and
-// stops a stale saved state from re-hiding a shown award column on every
+// restore) stops a stale saved state from re-hiding a shown award column on
-// awardCols rebuild — the desync that made award columns vanish mid-session.
+// every awardCols rebuild — the desync that made award columns vanish
-const stripAwardCols = (st: any[] | null | undefined): any[] =>
+// mid-session.
-  (st ?? []).filter((s) => !String(s?.colId ?? '').startsWith('award_'));
+//
+// Their POSITION, however, has to stay in the state. Filtering the entries out
+// entirely left applyColumnState({applyOrder:true}) with no place for them, and
+// AG Grid appends what the state doesn't mention — so a column the operator
+// dragged to sit AFTER an award column jumped back in front of it on reload.
+const sanitizeAwardCols = (st: any[] | null | undefined): any[] =>
+  (st ?? []).map((s) => {
+    if (!String(s?.colId ?? '').startsWith('award_')) return s;
+    const { hide: _hide, ...rest } = s as any;
+    return rest;
+  });
 
 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();
@@ -468,12 +480,12 @@ export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal,
   function onGridReady(e: GridReadyEvent) {
     onGridApi?.(e.api);
     const local = loadLocal(colStateKey);
-    if (local) e.api.applyColumnState({ state: sanitizeState(stripAwardCols(local)) as ColumnState[], applyOrder: true });
+    if (local) e.api.applyColumnState({ state: sanitizeState(sanitizeAwardCols(local)) as ColumnState[], applyOrder: true });
     // Fall back to the portable DB copy when the local cache is empty
     // (fresh machine / after a reinstall), then re-seed the cache.
     loadRemote(colStateKey).then((remote) => {
       if (remote && !local) {
-        e.api.applyColumnState({ state: sanitizeState(stripAwardCols(remote)) as ColumnState[], applyOrder: true });
+        e.api.applyColumnState({ state: sanitizeState(sanitizeAwardCols(remote)) as ColumnState[], applyOrder: true });
         seedLocal(colStateKey, remote);
       }
     });
@@ -497,7 +509,7 @@ export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal,
     if (restoringRef.current) return; // ignore the events fired by a column rebuild
     const state = gridRef.current?.api?.getColumnState();
     if (!state) return;
-    saveState(colStateKey, stripAwardCols(state));
+    saveState(colStateKey, sanitizeAwardCols(state));
     // Award columns are stripped above, so persist their widths on the side.
     let changed = false;
     for (const s of state) {
@@ -525,7 +537,7 @@ export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal,
   useEffect(() => {
     const api = gridRef.current?.api;
     const local = loadLocal(colStateKey);
-    if (api && local) api.applyColumnState({ state: sanitizeState(stripAwardCols(local)) as ColumnState[], applyOrder: true });
+    if (api && local) api.applyColumnState({ state: sanitizeState(sanitizeAwardCols(local)) as ColumnState[], applyOrder: true });
     // Re-enable saving once AG Grid has settled the column events from the rebuild.
     const t = window.setTimeout(() => { restoringRef.current = false; }, 0);
     return () => window.clearTimeout(t);

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 {
@@ -26,7 +26,7 @@ import {
   AudioStartMonitor, AudioStopMonitor, AudioMonitorActive,
   AudioStartTX, AudioStopTX, AudioTXActive,
   ListClusterServers, SaveClusterServer, DeleteClusterServer,
-  GetClusterAutoConnect, SetClusterAutoConnect,
+  GetClusterAutoConnect, SetClusterAutoConnect, GetSelfSpotSettings, SaveSelfSpotSettings,
   ConnectClusterServer, DisconnectClusterServer,
   ConnectAllClusters, DisconnectAllClusters, GetClusterStatus,
   GetBackupSettings, SaveBackupSettings, RunBackupNow, PickBackupFolder,
@@ -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 }>({
+  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, freq_min_mhz: 13, freq_max_mhz: 54,
+    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);
@@ -1283,8 +1373,8 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   const [emailMsg, setEmailMsg] = useState('');
   const setEmailField = (patch: Partial<EmailCfg>) => setEmailCfg((s) => ({ ...s, ...patch }));
   // eQSL card e-mail (subject/body templates + auto-send on log).
-  type EQSLCfg = { subject: string; body: string; auto_send: boolean };
+  type EQSLCfg = { subject: string; body: string; auto_send: boolean; default_message: string };
-  const [eqslCfg, setEqslCfg] = useState<EQSLCfg>({ subject: '', body: '', auto_send: false });
+  const [eqslCfg, setEqslCfg] = useState<EQSLCfg>({ subject: '', body: '', auto_send: false, default_message: '' });
   const setEqslField = (patch: Partial<EQSLCfg>) => setEqslCfg((s) => ({ ...s, ...patch }));
   // ClubLog Country File (cty.xml) exception status.
   type ClubInfo = { enabled: boolean; loaded: boolean; date: string; count: number };
@@ -1434,19 +1524,28 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
 
   const [clusterServers, setClusterServers] = useState<ClusterServer[]>([]);
   const [clusterAutoConnect, setClusterAutoConnectState] = useState(false);
+  // Self-spot. SELF_SPOT_MIN_MIN mirrors the backend floor — the input clamps on
+  // blur, not per keystroke, or typing "10" would be rewritten to "5" the moment
+  // the "1" landed and the field would fight the operator.
+  const SELF_SPOT_MIN_MIN = 5;
+  const [selfSpot, setSelfSpot] = useState({ enabled: false, minutes: SELF_SPOT_MIN_MIN });
+  const [selfSpotText, setSelfSpotText] = useState(String(SELF_SPOT_MIN_MIN));
   const [clusterStatuses, setClusterStatuses] = useState<ClusterServerStatus[]>([]);
   const [editingServer, setEditingServer] = useState<ClusterServer | null>(null);
 
   async function reloadClusterServers() {
     try {
-      const [list, ac, st] = await Promise.all([
+      const [list, ac, st, ss] = await Promise.all([
         ListClusterServers(),
         GetClusterAutoConnect(),
         GetClusterStatus(),
+        GetSelfSpotSettings(),
       ]);
       setClusterServers((list ?? []) as ClusterServer[]);
       setClusterAutoConnectState(ac);
       setClusterStatuses((st ?? []) as ClusterServerStatus[]);
+      setSelfSpot(ss as any);
+      setSelfSpotText(String((ss as any).minutes ?? SELF_SPOT_MIN_MIN));
     } catch (e: any) { setErr(String(e?.message ?? e)); }
   }
 
@@ -1759,6 +1858,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
       await SaveQSLDefaults(qslDefaults as any);
       await SaveExternalServices(extSvc as any);
       await SetClusterAutoConnect(clusterAutoConnect);
+      await SaveSelfSpotSettings(selfSpot as any);
 
       setMsg('Settings saved.');
       onSaved();
@@ -2437,6 +2537,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                   <SelectItem value="flex">{t('cat.optFlex')}</SelectItem>
                   <SelectItem value="yaesu">{t('cat.optYaesu')}</SelectItem>
                   <SelectItem value="kenwood">{t('cat.optKenwood')}</SelectItem>
+                  <SelectItem value="elecraft">{t('cat.optElecraft')}</SelectItem>
                   <SelectItem value="xiegu">{t('cat.optXiegu')}</SelectItem>
                   <SelectItem value="icom">{t('cat.optIcom')}</SelectItem>
                   <SelectItem value="icom-net">{t('cat.optIcomNet')}</SelectItem>
@@ -2598,7 +2699,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                   {t('cat.civTrace')}
                 </label>              </div>
             )}
-            {catCfg.backend === 'kenwood' && (
+            {(catCfg.backend === 'kenwood' || catCfg.backend === 'elecraft') && (
             <>
               <div className="space-y-1">
                 <Label>{t('cat.kenwoodPort')}</Label>
@@ -2635,6 +2736,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                 </label>
                 <span className="text-xs text-muted-foreground">{t('cat.lowerLinesHint')}</span>
               </div>
+              {catCfg.backend === 'kenwood' ? (
                 <div className="space-y-1">
                   <Label>{t('cat.kwDataMode')}</Label>
                   <Select value={(catCfg as any).kenwood_data_mode || 'usb'} onValueChange={(v) => setCatCfg((s) => ({ ...s, kenwood_data_mode: v } as any))}>
@@ -2644,7 +2746,11 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                       <SelectItem value="data">{t('cat.kwDataMd6')}</SelectItem>
                       <SelectItem value="keep">{t('cat.kwDataKeep')}</SelectItem>
                     </SelectContent>
-                </Select>              </div>
+                  </Select>
+                </div>
+              ) : (
+                <span className="text-xs text-muted-foreground">{t('cat.elecraftHint')}</span>
+              )}
             </>
             )}
             {catCfg.backend === 'icom' && (
@@ -3012,20 +3118,28 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
               </div>
             )}
           </div>
-          {isSteppir && (
+          {(isSteppir || ultrabeam.type === 'ultrabeam') && (
-            <div className="border-t border-border/60 pt-3 space-y-1">
+            <div className="border-t border-border/60 pt-3 space-y-2">
-              <div className="flex items-center gap-2 flex-wrap">
+              <Label className="text-sm">{t('hw.motorBands')}</Label>
-                <Label className="text-sm">{t('hw.steppirRange')}</Label>
+              <div className="flex items-center gap-1.5 flex-wrap">
-                <input type="number" min={1} max={60} value={ultrabeam.freq_min_mhz}
+                {MOTOR_BANDS.map((b) => {
-                  onChange={(e) => setUltrabeam((s) => ({ ...s, freq_min_mhz: parseInt(e.target.value, 10) || 0 }))}
+                  const on = ultrabeam.bands.includes(b);
-                  className="h-8 w-16 rounded-md border border-input bg-background px-2 text-sm" />
+                  return (
-                <span className="text-xs text-muted-foreground">–</span>
+                    <button key={b} type="button"
-                <input type="number" min={1} max={60} value={ultrabeam.freq_max_mhz}
+                      onClick={() => setUltrabeam((s) => ({
-                  onChange={(e) => setUltrabeam((s) => ({ ...s, freq_max_mhz: parseInt(e.target.value, 10) || 0 }))}
+                        ...s,
-                  className="h-8 w-16 rounded-md border border-input bg-background px-2 text-sm" />
+                        bands: on ? s.bands.filter((x) => x !== b) : [...s.bands, b],
-                <span className="text-xs text-muted-foreground">MHz</span>
+                      }))}
+                      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">
@@ -3388,6 +3502,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">
@@ -3406,12 +3522,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>
@@ -3428,8 +3545,8 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                       </Select>
                     </div>
                   )}
-                  {/* The ARCO is reachable over the LAN (TCP) or its USB virtual COM. */}
+                  {/* ARCO and DCU-1 controllers reach over the LAN (TCP) or a serial COM. */}
-                  {isARCO && (
+                  {isSerialCap && (
                     <div className="space-y-1">
                       <Label>Connection</Label>
                       <Select value={transport} onValueChange={(v) => patch(i, { transport: v as any })}>
@@ -3449,7 +3566,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">
@@ -3478,16 +3595,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)
@@ -3495,6 +3612,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">
@@ -4006,6 +4124,39 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
               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>
+
+          {/* Self-spot. The interval only shows once it's on — an interval for
+              something switched off is just a question the operator can't act on. */}
+          <div className="border-t border-border/60 pt-3 space-y-2">
+            <div className="flex items-center gap-3 flex-wrap">
+              <label className="flex items-center gap-2 text-sm cursor-pointer">
+                <Checkbox checked={selfSpot.enabled}
+                  onCheckedChange={(c) => setSelfSpot((s) => ({ ...s, enabled: !!c }))} />
+                {t('clu.selfSpot')}
+              </label>
+              {selfSpot.enabled && (
+                <div className="flex items-center gap-2 text-sm">
+                  <span className="text-muted-foreground">{t('clu.selfSpotEvery')}</span>
+                  <Input
+                    type="number"
+                    min={SELF_SPOT_MIN_MIN}
+                    max={240}
+                    className="w-20 h-8 font-mono text-xs"
+                    value={selfSpotText}
+                    onChange={(e) => setSelfSpotText(e.target.value)}
+                    onBlur={() => {
+                      const n = Math.floor(Number(selfSpotText));
+                      const v = Number.isFinite(n) && n > SELF_SPOT_MIN_MIN ? Math.min(n, 240) : SELF_SPOT_MIN_MIN;
+                      setSelfSpotText(String(v));
+                      setSelfSpot((s) => ({ ...s, minutes: v }));
+                    }}
+                  />
+                  <span className="text-muted-foreground">{t('clu.selfSpotMinutes')}</span>
+                </div>
+              )}
+            </div>
+            <p className="text-xs text-muted-foreground leading-relaxed">{t('clu.selfSpotHint')}</p>
+          </div>
         </div>
 
         {editingServer && (
@@ -4203,7 +4354,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
           title={t('sec.backup')}
           hint={mysqlCfg.enabled ? t('bk.hintMysql') : t('bk.hint')}
         />
-        <div className="space-y-4 max-w-xl">
+        <div className="space-y-5 max-w-2xl">
           <label className="flex items-center gap-2 text-sm cursor-pointer">
             <Checkbox
               checked={!!backupCfg.enabled}
@@ -4244,7 +4395,6 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             </div>
           </div>
 
-          <div className="flex items-end gap-3">
           <div className="space-y-1.5">
             <Label className="text-xs text-muted-foreground">{t('bk.rotation')}</Label>
             <Input
@@ -4259,13 +4409,39 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
               }}
             />
           </div>
-            <label className="flex items-center gap-2 text-sm cursor-pointer pb-2">
+
+          {/* Stacked, not one flex row: these labels are full sentences and the
+              "keep every backup" hint is two lines — side by side they wrapped
+              into unreadable slivers. It also puts keep-all under the option it
+              depends on rather than beside it. */}
+          <div className="space-y-2.5">
+            <label className="flex items-center gap-2 text-sm cursor-pointer">
               <Checkbox
                 checked={!!backupCfg.zip}
                 onCheckedChange={(c) => setBackupCfg((b) => ({ ...b, zip: !!c }))}
               />
               <span>{t('bk.zip')}</span>
             </label>
+            <label className="flex items-center gap-2 text-sm cursor-pointer">
+              <Checkbox
+                checked={!!(backupCfg as any).every_exit}
+                onCheckedChange={(c) => setBackupCfg((b) => ({ ...b, every_exit: !!c } as any))}
+              />
+              <span>{t('bk.everyExit')}</span>
+            </label>
+            {!!(backupCfg as any).every_exit && (
+              <label className="flex items-start gap-2 text-sm cursor-pointer pl-6">
+                <Checkbox
+                  className="mt-0.5"
+                  checked={!!(backupCfg as any).keep_all}
+                  onCheckedChange={(c) => setBackupCfg((b) => ({ ...b, keep_all: !!c } as any))}
+                />
+                <span>
+                  {t('bk.keepAll')}
+                  <span className="block text-xs text-muted-foreground mt-0.5 leading-relaxed">{t('bk.keepAllHint')}</span>
+                </span>
+              </label>
+            )}
           </div>
 
           <div className="border-t border-border/60 pt-3 flex items-center gap-3">
@@ -5077,8 +5253,23 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
           </div>
           <p className="text-[11px] text-muted-foreground">{t('db.appDbHint')}</p>
           <div className="flex flex-wrap gap-2">
+            <Button variant="outline" size="sm" onClick={createNew}><Plus className="size-3.5" /> {t('db.newDb')}</Button>
+            <Button variant="outline" size="sm" onClick={openExisting}><Database className="size-3.5" /> {t('db.openExisting')}</Button>
+            <Button variant="outline" size="sm" onClick={saveCopy}><Copy className="size-3.5" /> {t('db.saveCopy')}</Button>
+            <Button variant="outline" size="sm" onClick={renameDb} title={t('db.renameTip')}><Pencil className="size-3.5" /> {t('db.rename')}</Button>
             <Button variant="outline" size="sm" onClick={revealFolder}><FolderOpen className="size-3.5" /> {t('db.openFolder')}</Button>
+            {dbSettings.is_custom && <Button variant="ghost" size="sm" onClick={resetDefault}>{t('db.resetDefault')}</Button>}
           </div>
+          {/* The DB pointer is only read at startup, so offer the restart inline. */}
+          {dbMsg && (
+            <div className="text-[11px] text-success space-y-1 pt-1">
+              <div>{t('db.savedRestart')} <span className="font-mono break-all">{dbMsg}</span></div>
+              <Button size="sm" className="h-7" onClick={() => RestartApp().catch((e: any) => setErr(String(e?.message ?? e)))}>
+                <Power className="size-3.5" /> {t('db.restartNow')}
+              </Button>
+              <span className="ml-2 text-muted-foreground">{t('db.restartHint')}</span>
+            </div>
+          )}
         </div>
 
         {/* Logbook (QSOs) — this profile: default SQLite file, a dedicated file, or MySQL. */}
@@ -5700,6 +5891,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">
@@ -5716,6 +5918,12 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             <div className="text-[11px] text-muted-foreground">
               {t('em.autoSendHint')}
             </div>
+            <div className="pt-2 space-y-1">
+              <Label className="text-sm">{t('em.qslDefaultMsg')}</Label>
+              <Input className="h-8" placeholder={t('em.qslDefaultMsgPh')} value={eqslCfg.default_message ?? ''}
+                onChange={(e) => setEqslField({ default_message: e.target.value })} />
+              <div className="text-[11px] text-muted-foreground">{t('em.qslDefaultMsgHint')}</div>
+            </div>
           </div>
         </div>
       </>
@@ -5807,7 +6015,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/lib/textCase.ts

@@ -0,0 +1,28 @@
+// Capitalisation helpers for the free-text QSO fields (Name / QTH / Comment /
+// Note).
+//
+// The same station reaches the log SHOUTED by QRZ, lower-cased by a hurried
+// operator, and in whatever case the other logger stored it in an imported
+// ADIF — so one callsign ends up as "JEAN", "jean" and "Jean" across a log,
+// and sorting or reading a QTH column becomes a mess.
+//
+// Both helpers are meant to run on BLUR, never per keystroke: rewriting the
+// value while the operator is still typing a word fights them mid-word (see
+// the controlled-input note in CLAUDE.md).
+
+// titleCase upper-cases the first letter of every word and lower-cases the
+// rest. Separators are kept, so "SAINT-JULIEN" → "Saint-Julien" and
+// "o'brien" → "O'Brien".
+export function titleCase(s: string): string {
+  return s
+    .toLowerCase()
+    .replace(/(^|[\s\-'’/.])(\p{L})/gu, (_m, sep: string, ch: string) => sep + ch.toUpperCase());
+}
+
+// sentenceCase upper-cases the first letter and leaves everything after it as
+// typed. A comment routinely carries callsigns, modes and abbreviations
+// ("TNX QSO F5ABC, FT8 59") that lower-casing would quietly destroy — which is
+// why this is NOT titleCase.
+export function sentenceCase(s: string): string {
+  return s.replace(/^(\s*)(\p{L})/u, (_m, sp: string, ch: string) => sp + ch.toUpperCase());
+}

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

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

@@ -481,6 +481,8 @@ export function GetScpStatus():Promise<main.ScpStatus>;
 
 export function GetSecretStatus():Promise<main.SecretStatus>;
 
+export function GetSelfSpotSettings():Promise<main.SelfSpotSettings>;
+
 export function GetSlotStats():Promise<qso.SlotStats>;
 
 export function GetSolarData():Promise<solar.Data>;
@@ -495,6 +497,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>;
@@ -893,10 +897,14 @@ export function SaveRelayAuto(arg1:main.RelayAutoConfig):Promise<void>;
 
 export function SaveRotators(arg1:Array<main.RotatorDevice>):Promise<void>;
 
+export function SaveSelfSpotSettings(arg1:main.SelfSpotSettings):Promise<void>;
+
 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>;
@@ -945,6 +953,8 @@ export function SetDVKLabel(arg1:number,arg2:string):Promise<void>;
 
 export function SetKenwoodKeySpeed(arg1:number):Promise<void>;
 
+export function SetOpsLogQSLReceived(arg1:number,arg2:boolean):Promise<void>;
+
 export function SetPassphrase(arg1:string):Promise<void>;
 
 export function SetScpEnabled(arg1:boolean):Promise<void>;

frontend/wailsjs/go/main/App.js

@@ -910,6 +910,10 @@ export function GetSecretStatus() {
   return window['go']['main']['App']['GetSecretStatus']();
 }
 
+export function GetSelfSpotSettings() {
+  return window['go']['main']['App']['GetSelfSpotSettings']();
+}
+
 export function GetSlotStats() {
   return window['go']['main']['App']['GetSlotStats']();
 }
@@ -938,6 +942,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']();
 }
@@ -1734,6 +1742,10 @@ export function SaveRotators(arg1) {
   return window['go']['main']['App']['SaveRotators'](arg1);
 }
 
+export function SaveSelfSpotSettings(arg1) {
+  return window['go']['main']['App']['SaveSelfSpotSettings'](arg1);
+}
+
 export function SaveStationDevices(arg1) {
   return window['go']['main']['App']['SaveStationDevices'](arg1);
 }
@@ -1742,6 +1754,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);
 }
@@ -1838,6 +1854,10 @@ export function SetKenwoodKeySpeed(arg1) {
   return window['go']['main']['App']['SetKenwoodKeySpeed'](arg1);
 }
 
+export function SetOpsLogQSLReceived(arg1, arg2) {
+  return window['go']['main']['App']['SetOpsLogQSLReceived'](arg1, arg2);
+}
+
 export function SetPassphrase(arg1) {
   return window['go']['main']['App']['SetPassphrase'](arg1);
 }

frontend/wailsjs/go/models.ts

@@ -315,6 +315,7 @@ export namespace award {
 	    pattern: string;
 	    leading_str?: string;
 	    trailing_str?: string;
+	    prefix?: string;
 	    dynamic?: boolean;
 	    one_ref_per_qso?: boolean;
 	    or_rules?: OrRule[];
@@ -356,6 +357,7 @@ export namespace award {
 	        this.pattern = source["pattern"];
 	        this.leading_str = source["leading_str"];
 	        this.trailing_str = source["trailing_str"];
+	        this.prefix = source["prefix"];
 	        this.dynamic = source["dynamic"];
 	        this.one_ref_per_qso = source["one_ref_per_qso"];
 	        this.or_rules = this.convertValues(source["or_rules"], OrRule);
@@ -1894,6 +1896,8 @@ export namespace main {
 	    folder: string;
 	    rotation: number;
 	    zip: boolean;
+	    every_exit: boolean;
+	    keep_all: boolean;
 	    last_backup_at: string;
 	    default_folder: string;
 	
@@ -1907,6 +1911,8 @@ export namespace main {
 	        this.folder = source["folder"];
 	        this.rotation = source["rotation"];
 	        this.zip = source["zip"];
+	        this.every_exit = source["every_exit"];
+	        this.keep_all = source["keep_all"];
 	        this.last_backup_at = source["last_backup_at"];
 	        this.default_folder = source["default_folder"];
 	    }
@@ -2635,6 +2641,7 @@ export namespace main {
 	    subject: string;
 	    body: string;
 	    auto_send: boolean;
+	    default_message: string;
 	
 	    static createFrom(source: any = {}) {
 	        return new QSLEmailTemplates(source);
@@ -2645,6 +2652,7 @@ export namespace main {
 	        this.subject = source["subject"];
 	        this.body = source["body"];
 	        this.auto_send = source["auto_send"];
+	        this.default_message = source["default_message"];
 	    }
 	}
 	export class QSLFontInfo {
@@ -2906,6 +2914,20 @@ export namespace main {
 	        this.unlocked = source["unlocked"];
 	    }
 	}
+	export class SelfSpotSettings {
+	    enabled: boolean;
+	    minutes: number;
+	
+	    static createFrom(source: any = {}) {
+	        return new SelfSpotSettings(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.enabled = source["enabled"];
+	        this.minutes = source["minutes"];
+	    }
+	}
 	export class SpotQuery {
 	    call: string;
 	    band: string;
@@ -3156,6 +3178,7 @@ export namespace main {
 	    follow: boolean;
 	    step_khz: number;
 	    tx_inhibit: boolean;
+	    bands: string[];
 	    freq_min_mhz: number;
 	    freq_max_mhz: number;
 	
@@ -3175,6 +3198,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/award/award.go

@@ -74,6 +74,7 @@ type Def struct {
 	Pattern     string    `json:"pattern"`                // award-level Go regexp; group 1 = reference
 	LeadingStr  string    `json:"leading_str,omitempty"`  // strip this prefix before matching
 	TrailingStr string    `json:"trailing_str,omitempty"` // strip this suffix before matching
+	Prefix      string    `json:"prefix,omitempty"`       // prepended to each found reference (e.g. captured "01" + "D" → "D01"), same as OrRule.Prefix
 	Dynamic     bool      `json:"dynamic,omitempty"`      // references not predefined (any value counts)
 	// OneRefPerQSO refuses an AMBIGUOUS match rather than guessing.
 	//
@@ -960,7 +961,7 @@ func candidatesTrace(d *Def, re *regexp.Regexp, q *qso.QSO, rl refList, hasList
 	// Testing the raw candidate would call that a hit, skip every fallback, and
 	// only then drop it as unlisted — leaving the QSO unmatched even though the
 	// next rule ("find the code inside the QTH") would have found BG.
-	found := run("primary", d.Field, d.MatchBy, d.Pattern, re, d.ExactMatch, d.LeadingStr, d.TrailingStr, "")
+	found := run("primary", d.Field, d.MatchBy, d.Pattern, re, d.ExactMatch, d.LeadingStr, d.TrailingStr, d.Prefix)
 	for i := range d.OrRules {
 		r := &d.OrRules[i]
 		label := fmt.Sprintf("OR %d", i+1)

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, unique bool) (string, error) {
 	if dbConn == nil {
 		return "", fmt.Errorf("nil db connection")
 	}
@@ -54,12 +54,20 @@ 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)
 	}
 
+	// One file per DAY by default (same-day runs overwrite). With `unique`, add the
+	// time so every run is a distinct file — rotation still keeps the newest N.
 	stamp := time.Now().Format("2006-01-02")
-	base := fmt.Sprintf("opslog-%s", stamp)
+	if unique {
+		stamp = time.Now().Format("2006-01-02-150405")
+	}
+	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 +100,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)
 	}
@@ -103,7 +111,7 @@ func Run(ctx context.Context, dbConn *sql.DB, dbPath, folder string, rotation in
 // log lives on a shared MySQL server, where VACUUM INTO can't snapshot it — an
 // ADIF export is a portable, re-importable backup of the actual contacts.
 // writeADIF must write the full ADIF to the path it's handed.
-func RunADIF(folder string, rotation int, doZip bool, writeADIF func(path string) error) (string, error) {
+func RunADIF(folder string, rotation int, doZip bool, unique bool, writeADIF func(path string) error) (string, error) {
 	if rotation <= 0 {
 		rotation = 5
 	}
@@ -113,7 +121,11 @@ func RunADIF(folder string, rotation int, doZip bool, writeADIF func(path string
 	if err := os.MkdirAll(folder, 0o755); err != nil {
 		return "", fmt.Errorf("create backup folder: %w", err)
 	}
-	base := "opslog-log-" + time.Now().Format("2006-01-02")
+	stamp := time.Now().Format("2006-01-02")
+	if unique {
+		stamp = time.Now().Format("2006-01-02-150405")
+	}
+	base := "opslog-log-" + stamp
 	tmp := filepath.Join(folder, base+".adi.tmp")
 	_ = os.Remove(tmp)
 	if err := writeADIF(tmp); err != nil {
@@ -203,12 +215,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

@@ -62,6 +62,10 @@ type Kenwood struct {
 	// leave the rig's current mode untouched (safest for a TS-590SG/TS-990S whose
 	// data mode is a USB modifier the operator sets on the rig). See SetMode.
 	dataMode string
+	// elecraft marks a K3/K4 (the "Elecraft" backend). It reuses this Kenwood-dialect
+	// client but, being an Elecraft, always drives digital modes to DATA A (MD6+DT0)
+	// — the sub-mode FT8 audio needs — instead of going through the dataMode option.
+	elecraft bool
 
 	mu   sync.Mutex
 	port serial.Port
@@ -115,6 +119,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 +270,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
@@ -267,7 +291,10 @@ func (k *Kenwood) ReadState() (RigState, error) {
 	s := RigState{Connected: true, Backend: "kenwood"}
 	k.curVFO = f.VFO
 	s.Vfo = f.VFO
-	s.Mode = kenwoodModeToADIF(f.Mode, k.digital)
+	// Both branches of SetMode that emit MD6 identify a K3/K4: the Elecraft
+	// backend, and the "MD6" data-mode option that exists for it. Decode the
+	// read-back the same way, or OpsLog contradicts the mode it just set.
+	s.Mode = kenwoodModeToADIF(f.Mode, k.digital, k.elecraft || k.dataMode == "data")
 	s.Rig = k.model
 
 	// IF reports the frequency of the VFO in USE (what the operator hears).
@@ -339,6 +366,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
 }
 
@@ -370,11 +398,30 @@ func (k *Kenwood) SetMode(mode string) error {
 	// mode digit fits every rig, so the operator picks: keep the rig's mode, use
 	// MD6 (K3/K4 DATA), or fall through to the default USB from kenwoodModeDigit.
 	if isKenwoodDataMode(mode) {
+		// An Elecraft always uses DATA A for a soundcard digital mode — that's what
+		// the "Elecraft" backend means, so the dataMode option doesn't apply.
+		if k.elecraft {
+			if err := k.write("MD6;"); err != nil {
+				return err
+			}
+			return k.write("DT0;")
+		}
 		switch k.dataMode {
 		case "keep":
 			return nil // leave whatever data mode the operator set on the rig
 		case "data":
-			return k.write("MD6;") // Elecraft K3/K4 DATA mode
+			// Elecraft K3/K4 DATA mode (MD6) PLUS the DATA-A submode (DT0). MD6 alone
+			// can leave the rig in an FSK/PSK data submode (from a prior RTTY/PSK
+			// session), where FT8 keys the transmitter but the rear sound-card audio
+			// never modulates — "transmits but nothing comes out". DT0 forces DATA A,
+			// the audio submode FT8 needs. This is the Elecraft path (the option is
+			// labelled K3/K4); a real K3/K4 answers DT with nothing. A plain Kenwood
+			// has no DT command and would "?;" it — but that's a misconfiguration
+			// (pick USB there), and IF is never latched so the link self-recovers.
+			if err := k.write("MD6;"); err != nil {
+				return err
+			}
+			return k.write("DT0;")
 		}
 	}
 	d := kenwoodModeDigit(mode, k.curFreq)
@@ -392,6 +439,14 @@ func (k *Kenwood) SetDataMode(m string) {
 	k.mu.Unlock()
 }
 
+// SetElecraft marks this client as driving a K3/K4 (the "Elecraft" backend), so
+// digital modes always land in DATA A (MD6+DT0). Set before Start.
+func (k *Kenwood) SetElecraft(v bool) {
+	k.mu.Lock()
+	k.elecraft = v
+	k.mu.Unlock()
+}
+
 // isKenwoodDataMode reports whether a mode name is a soundcard/data mode (FT8,
 // PSK, JT…) rather than a voice/CW/RTTY mode the rig sets natively.
 func isKenwoodDataMode(mode string) bool {
@@ -409,7 +464,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 +524,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
+				// IF; and ID; are universal on Kenwood/Elecraft — a "?;" to them is a
-				// paying a 600 ms timeout for it on every cycle.
+				// 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) {
@@ -600,7 +662,11 @@ func kenwoodModeDigit(mode string, hz int64) byte {
 // Digital modes are indistinguishable from SSB over CAT — the rig only knows
 // it is on USB — so the operator's configured digital mode is used, exactly as
 // the other backends do.
-func kenwoodModeToADIF(d byte, digital string) string {
+//
+// md6IsData says whether MD6 means DATA on THIS rig — true for an Elecraft
+// (the K3/K4 backend, and the "MD6" data-mode option that targets it), false
+// for a plain Kenwood. See below.
+func kenwoodModeToADIF(d byte, digital string, md6IsData bool) string {
 	switch d {
 	case '1':
 		return "LSB"
@@ -613,6 +679,15 @@ func kenwoodModeToADIF(d byte, digital string) string {
 	case '5':
 		return "AM"
 	case '6', '9':
+		// One digit, two meanings. On a Kenwood MD6/MD9 is FSK/FSK-R; on an
+		// Elecraft it is DATA / DATA-REV — and DATA is precisely what SetMode
+		// puts a K3/K4 into for FT8. Reading it straight back as RTTY meant a K3
+		// running FT8 reported RTTY: the QSO was logged on the wrong mode, and
+		// the shared CAT link told WSJT-X/JTDX the rig sat in RTTY while they had
+		// asked for a data mode.
+		if md6IsData {
+			return digital
+		}
 		return "RTTY"
 	}
 	return ""

internal/cat/kenwood_test.go

@@ -141,8 +141,23 @@ func TestKenwoodModeToADIF(t *testing.T) {
 		{'0', ""}, // unknown → say nothing rather than guess
 	}
 	for _, c := range cases {
-		if got := kenwoodModeToADIF(c.d, "FT8"); got != c.want {
+		if got := kenwoodModeToADIF(c.d, "FT8", false); got != c.want {
 			t.Errorf("kenwoodModeToADIF(%q) = %q, want %q", c.d, got, c.want)
 		}
 	}
 }
+
+// On a K3/K4 the same digits mean DATA / DATA-REV, not FSK — and DATA is what
+// OpsLog itself sets for FT8. Decoding them as RTTY logged a K3 running FT8 on
+// the wrong mode and told the shared-CAT clients the rig was in RTTY.
+func TestKenwoodModeToADIFElecraftData(t *testing.T) {
+	for _, d := range []byte{'6', '9'} {
+		if got := kenwoodModeToADIF(d, "FT8", true); got != "FT8" {
+			t.Errorf("kenwoodModeToADIF(%q, elecraft) = %q, want %q", d, got, "FT8")
+		}
+	}
+	// Everything else is unaffected by the Elecraft dialect.
+	if got := kenwoodModeToADIF('2', "FT8", true); got != "USB" {
+		t.Errorf("kenwoodModeToADIF('2', elecraft) = %q, want USB", got)
+	}
+}

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
+	// The verb the amp wants is "setup fanmode=VALUE" — confirmed LIVE: with the
-	// (same convention as "operate=1"). The earlier "setup fanmode=…" carried a
+	// "setup " prefix the amp replies code 0 (accepted), while the bare
-	// bogus prefix the amp silently ignored, so the fan never changed and the next
+	// "fanmode=VALUE" we switched to earlier is rejected (reply code 0x50000015).
-	// status kept reporting the old mode — the revert-to-Contest the operator saw.
+	// That regression is what stopped the fan from changing; restoring "setup "
-	reply, err := c.command("fanmode=" + m)
+	// 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/qslcard/placement.go

@@ -734,7 +734,10 @@ func placeQSOBox(profile ProfileInfo, zone pxRect, occupied []pxRect) QSOBox {
 		BG: "#ffffff", BGOpacity: 0.88, Radius: 12,
 		Title:  "Confirming QSO with {qso.callsign}",
 		Fields: []string{"qso_date", "time_on", "band", "mode", "rst_sent"},
-		Footer: "{qso.qsl_msg}",
+		// PSE/TNX stamp (auto: TNX if a QSL was received, else PSE QSL) leads the
+		// message. {qso.pse_tnx} is a normal token — it can be moved to its own
+		// element anywhere on the card in the designer.
+		Footer: "{qso.pse_tnx}   {qso.qsl_msg}",
 	}
 	box.Y = cardH - box.H - 110
 	if zone.y+zone.h/2 > cardH/2 {

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&",
+	body, err := d.getCGI(ctx, fmt.Sprintf("%s/relay_cgi.cgi?type=0&relay=%d&on=%d&time=0&pwd=%s&",
-		d.host, relay-1, state, d.pwd))
+		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

@@ -118,7 +118,32 @@ func (s *Server) Start() error {
 	return nil
 }
 
+// releasePTT drops the transmitter when whoever was holding it goes away.
+//
+// Nothing else will. The Kenwood/Elecraft backend deliberately suspends its
+// wire poll while PTT is held (a K3 answers "?;" to IF; during transmit), so a
+// client that crashes, is killed, or simply has its socket closed under it
+// leaves the rig keyed with nobody watching — and closing the socket is exactly
+// what Stop() does on every settings save. Seen in the field: a K3 sat in
+// transmit for 29 s, until the CAT link happened to be rebuilt.
+//
+// Swap makes this once-only, so the Stop() path and the per-connection defer it
+// triggers can both call it without double-unkeying.
+func (s *Server) releasePTT(why string) {
+	if !s.ptt.Swap(false) {
+		return
+	}
+	s.log("rigctld: %s while the rig was keyed — dropping PTT", why)
+	if err := s.rig.SetPTT(false); err != nil {
+		s.log("rigctld: emergency unkey failed: %v", err)
+	}
+}
+
 func (s *Server) Stop() {
+	// Before anything is torn down: reloadCAT calls us BEFORE it restarts the CAT
+	// backend, so the rig is still reachable here and an unkey still lands.
+	s.releasePTT("CAT sharing stopped")
+
 	s.mu.Lock()
 	s.closed = true
 	ln := s.ln
@@ -146,6 +171,8 @@ func (s *Server) serve(c net.Conn) {
 		delete(s.conns, c)
 		s.mu.Unlock()
 		_ = c.Close()
+		// A client that walks away mid-over must not leave the rig transmitting.
+		s.releasePTT(fmt.Sprintf("client %s left", c.RemoteAddr()))
 	}()
 	s.log("rigctld: client connected from %s", c.RemoteAddr())
 	r := bufio.NewReader(c)

internal/rigctld/rigctld_test.go

@@ -7,6 +7,7 @@ import (
 	"strings"
 	"sync"
 	"testing"
+	"time"
 )
 
 // fakeRig stands in for the CAT manager.
@@ -234,6 +235,66 @@ func TestServerOverTCP(t *testing.T) {
 	}
 }
 
+// A client that vanishes mid-over must not leave the transmitter keyed. Nothing
+// else would notice: the Kenwood/Elecraft backend stops polling while PTT is
+// held, so a K3 was seen sitting in transmit for 29 s after WSJT-X's socket was
+// closed under it by a settings save.
+func TestPTTIsDroppedWhenTheClientDisappears(t *testing.T) {
+	rig := &fakeRig{freq: 14074000, mode: "FT8"}
+	s := New(0, rig, nil)
+	ln, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatalf("listen: %v", err)
+	}
+	s.mu.Lock()
+	s.ln = ln
+	s.mu.Unlock()
+	go func() {
+		for {
+			c, err := ln.Accept()
+			if err != nil {
+				return
+			}
+			go s.serve(c)
+		}
+	}()
+	defer s.Stop()
+
+	c, err := net.DialTimeout("tcp", ln.Addr().String(), dialTimeout)
+	if err != nil {
+		t.Fatalf("dial: %v", err)
+	}
+	r := bufio.NewReader(c)
+	// "T 3" is what WSJT-X sends for PTT_ON_DATA — the form seen in the field.
+	if _, err := c.Write([]byte("T 3\n")); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+	line, _ := r.ReadString('\n')
+	if strings.TrimSpace(line) != "RPRT 0" {
+		t.Fatalf("set_ptt = %q, want RPRT 0", strings.TrimSpace(line))
+	}
+	rig.mu.Lock()
+	keyed := rig.ptt
+	rig.mu.Unlock()
+	if !keyed {
+		t.Fatalf("rig is not keyed after T 3 — the test proves nothing")
+	}
+
+	_ = c.Close()
+	// The unkey happens on the serve goroutine's defer, so poll briefly.
+	deadline := time.Now().Add(2 * time.Second)
+	for time.Now().Before(deadline) {
+		rig.mu.Lock()
+		keyed = rig.ptt
+		rig.mu.Unlock()
+		if !keyed {
+			return
+		}
+		time.Sleep(10 * time.Millisecond)
+	}
+	t.Error("rig still keyed after the client disconnected — the transmitter was left on air")
+}
+
 func TestModeMapping(t *testing.T) {
 	for _, c := range []struct{ adif, hamlib string }{
 		{"SSB", "USB"}, {"LSB", "LSB"}, {"CW", "CW"}, {"RTTY", "RTTY"},

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

@@ -509,7 +509,7 @@ func (c *Client) queryStatus() (*Status, error) {
 		return nil, err
 	}
 
-	// An older controller — seen behind an RS232-to-Ethernet bridge — answers with
+	// 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

telemetry.go

@@ -21,7 +21,7 @@ import (
 
 const (
 	// appVersion is stamped on every heartbeat (and could feed the About box).
-	appVersion = "0.23.6"
+	appVersion = "0.23.9"
 
 	// 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,
+**File → Import** (`Ctrl+O`) → pick an `.adi` / `.adif` file → the **Import ADIF**
-OpsLog parses every field, maps standard fields to columns and keeps unknown but
+dialog opens with the options below. Import runs into the **active profile's**
-valid ADIF fields in a per-QSO **extras** store (editable later). Country /
+logbook. A file **without a header** (records pasted from another log) imports
-zones are enriched from `cty.dat` where missing. A file **without a header**
+fine. Progress shows live; a summary follows — imported / updated / duplicates /
-(records pasted from another log) imports fine.
+skipped / total — with expandable **error** and **duplicate** lists.
 
-- **Field remapping**: the import dialog can move a field as it reads it —
+### Duplicate handling
-  e.g. the RSGB IOTA contest exports the island reference in `STATE`; add a
+
-  `STATE → IOTA` row and it lands where the award looks.
+A **duplicate** is a record with the same **callsign + UTC minute + band + mode**
-- **Fill from profile**: optionally stamps your station fields *and* your
+as a QSO already in the logbook. Pick how they are treated:
-  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.
+| Mode | What it does |
-  Existing values are never overwritten.
+|------|--------------|
+| **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.