chore: release v0.26.10

Five entries were written after v0.26.9 was tagged (b952e07), so they
were never in the release the operators actually got -- their What's New
stops at the Club Log delete fix.

app.go

@@ -344,6 +344,8 @@ const (
 	keyQSLDefaultHRDLogStatus  = "qsl.hrdlog_status"
 	keyQSLDefaultQRZComStatus  = "qsl.qrzcom_status"
 	keyQSLDefaultQRZComCfm     = "qsl.qrzcom_confirmed"
+	keyQSLDefaultHamlogStatus  = "qsl.hamlog_status"
+	keyQSLDefaultHamlogCfm     = "qsl.hamlog_confirmed"
 
 	// External services (logbook upload). QRZ.com first; Clublog / LoTW
 	// will add their own keys under the same extsvc.* prefix.
@@ -382,6 +384,10 @@ const (
 	keyExtCloudlogAutoUpload = "extsvc.cloudlog.auto_upload"
 	keyExtCloudlogUploadMode = "extsvc.cloudlog.upload_mode"
 
+	keyExtHamlogAPIKey     = "extsvc.hamlog.api_key"
+	keyExtHamlogAutoUpload = "extsvc.hamlog.auto_upload"
+	keyExtHamlogUploadMode = "extsvc.hamlog.upload_mode"
+
 	keyExtPotaToken = "extsvc.pota.token" // pota.app session token for hunter-log sync
 
 	keyExtLoTWTQSLPath     = "extsvc.lotw.tqsl_path"
@@ -416,6 +422,12 @@ type QSLDefaults struct {
 	HRDLogStatus  string `json:"hrdlog_status"`
 	QRZComStatus  string `json:"qrzcom_status"`
 	QRZComCfm     string `json:"qrzcom_confirmed"` // QRZ.com download/confirmed status
+	// HAMLOG.online lives in the ADIF extras rather than a column — the standard
+	// names a field for hamlog.EU and none for hamlog.ONLINE — but a default is
+	// a default: an operator who uploads everything wants new contacts to start
+	// at "N" here exactly as they do for Club Log.
+	HamlogStatus string `json:"hamlog_status"`
+	HamlogCfm    string `json:"hamlog_confirmed"`
 }
 
 // CATSettings is the user-tweakable rig-control configuration. Stored as
@@ -716,6 +728,12 @@ type App struct {
 	clublogMW    *clublog.MostWanted // ClubLog "Most Wanted" DXCC ranking (opt-in)
 	motorAnt     motorAntenna        // motorized antenna (Ultrabeam or SteppIR); nil when disabled
 	ubFollowStop chan struct{}       // stops the "follow frequency" loop; nil when off
+	// qsoRecPushed records which SOURCE the recorder was started on: the network
+	// stream, or a sound device. Switching CAT backends changes the answer, and a
+	// recorder left capturing a device that no longer carries the radio records
+	// silence without saying so.
+	qsoRecPushed   bool
+	motorStartMu   sync.Mutex          // serialises startUltrabeam: two restarts at once left two poll loops on one COM port
 	motorInhibStop chan struct{}       // stops the "inhibit TX while moving" loop; nil when off
 	motorMoveCmdNs atomic.Int64        // unixnano of the last commanded antenna move (grace window)
 	motorInhibited atomic.Bool         // TX currently inhibited by the motor-antenna watcher
@@ -764,6 +782,13 @@ type App struct {
 	// a still-running QRZ sync bleed its log into a freshly started LoTW download).
 	confDLMu       sync.Mutex
 	confDLCancel   context.CancelFunc
+
+	// hamlogUnmatched holds the confirmations the last HAMLOG.online import
+	// could not place onto a QSO, kept so they can be exported and worked
+	// through — see ExportHamlogUnmatched. Replaced by each import, never
+	// accumulated: it describes one run, not a history.
+	hamlogUnmatchedMu sync.Mutex
+	hamlogUnmatched   []qso.QSO
 	udpLogMu       sync.Mutex             // serialises UDP auto-log so concurrent packets can't both pass the dedup check
 	adifMonMu      sync.Mutex             // guards the ADIF-monitor config (file list + per-file read offsets)
 	syncMu         sync.Mutex             // serialises folder synchronisation: config, the seq counter, and the append to our own file
@@ -1209,6 +1234,7 @@ func (a *App) startup(ctx context.Context) {
 	applog.Printf("startup: logbook backend = %s", backend)
 	a.logDb = logbookConn
 	a.qso = qso.NewRepo(logbookConn)
+	a.tidyLogbookSchema(logbookConn)
 	a.backfillAwardRefsOnce()                     // one-time: materialise award_refs for pre-existing QSOs
 	go a.rebuildWorkedIndex()                     // in-memory worked-index for per-spot alert checks
 	go a.adifMonitorLoop()                        // watch external ADIF files (fldigi, N1MM…) for new QSOs
@@ -2319,6 +2345,11 @@ func (a *App) connectLogbook(cfg profile.ProfileDB) (*sql.DB, string, error) {
 	}
 	if lp == "" {
 		a.logDbPath = "" // settings db serves as the logbook (split failed) — backup snapshots a.db
+		// It may have had its unused qso table dropped while a separate logbook
+		// was in use (see tidyLogbookSchema); rebuild it before handing it over.
+		if err := db.EnsureQSOTable(a.db); err != nil {
+			return nil, "", err
+		}
 		return a.db, "sqlite", nil
 	}
 	// Resolve against THIS install before opening. Without it, a profile carried
@@ -2330,7 +2361,7 @@ func (a *App) connectLogbook(cfg profile.ProfileDB) (*sql.DB, string, error) {
 		applog.Printf("logbook: profile path %q resolved to %q", lp, r)
 		lp = r
 	}
-	c, err := db.Open(lp)
+	c, err := db.OpenLogbook(lp)
 	if err != nil {
 		return nil, "", fmt.Errorf("open logbook %s: %w", lp, err)
 	}
@@ -6427,6 +6458,26 @@ func (a *App) DeleteQSO(id int64) error {
 // Failures never block the local delete. The operator asked for this QSO to go;
 // a refusing website is not a reason to keep it, and the log says what happened
 // so it can be sorted out on the site afterwards.
+// deleteSnapshot reads the rows behind a set of ids in ONE query.
+//
+// The delete hooks used to fetch them one by one. That is a round trip per
+// contact, and on a remote MySQL logbook 200 deletions became 400 sequential
+// queries before the DELETE was even issued — the reason deleting a selection
+// felt broken rather than slow.
+func (a *App) deleteSnapshot(ids []int64) []qso.QSO {
+	if a.qso == nil || len(ids) == 0 {
+		return nil
+	}
+	out := make([]qso.QSO, 0, len(ids))
+	if err := a.qso.IterateByIDs(a.ctx, ids, func(q qso.QSO) error {
+		out = append(out, q)
+		return nil
+	}); err != nil {
+		applog.Printf("delete: reading %d QSO(s) before deletion failed: %v", len(ids), err)
+	}
+	return out
+}
+
 func (a *App) deleteRemoteCopies(ids []int64) {
 	if a.qso == nil || len(ids) == 0 {
 		return
@@ -6445,9 +6496,37 @@ func (a *App) deleteRemoteCopies(ids []int64) {
 	if !doQRZ && !doClublog {
 		return
 	}
-	for _, id := range ids {
-		q, err := a.qso.GetByID(a.ctx, id)
-		if err != nil || q.Callsign == "" {
+	// Snapshot first — the rows are about to disappear — then withdraw them in
+	// the background. Each service is an HTTP round trip PER CONTACT, so doing
+	// this on the caller's goroutine held the whole UI for as long as the
+	// websites took: minutes for a large selection, with nothing on screen
+	// saying why. The local log is the operator's own copy and must not wait on
+	// two remote sites to answer.
+	rows := a.deleteSnapshot(ids)
+	go a.withdrawRemoteCopies(rows, cfg, doQRZ, doClublog)
+}
+
+// maxClublogRefusals is how many consecutive refusals are tolerated before the
+// withdrawals stop. Three is enough to tell a one-off from a blocked account.
+const maxClublogRefusals = 3
+
+// clublogWasUploaded reports whether this QSO ever reached Club Log. "M"
+// (modified since upload) counts: the copy is there, it is merely out of date.
+func clublogWasUploaded(status string) bool {
+	switch strings.ToUpper(strings.TrimSpace(status)) {
+	case "Y", "M":
+		return true
+	}
+	return false
+}
+
+func (a *App) withdrawRemoteCopies(rows []qso.QSO, cfg extsvc.ExternalServices, doQRZ, doClublog bool) {
+	started := time.Now()
+	clublogRefused := 0
+	for i := range rows {
+		q := rows[i]
+		id := q.ID
+		if q.Callsign == "" {
 			continue
 		}
 		if doQRZ {
@@ -6466,14 +6545,31 @@ func (a *App) deleteRemoteCopies(ids []int64) {
 				applog.Printf("extsvc: QRZ delete of QSO %d (%s): %s", id, q.Callsign, msg)
 			}
 		}
-		if doClublog {
+		// Only ask Club Log about contacts it was actually given. A QSO that was
+		// never uploaded has no copy to withdraw, and asking anyway is not merely
+		// pointless: Club Log answers 403 and starts blocking the account, so a
+		// selection of never-uploaded QSOs turned into hundreds of refused
+		// requests, one after another, each waiting on the network.
+		if doClublog && !clublogWasUploaded(q.ClublogUploadStatus) {
+			applog.Printf("extsvc: QSO %d (%s) was never uploaded to Club Log — nothing to withdraw", id, q.Callsign)
+		} else if doClublog {
 			if msg, err := extsvc.DeleteClublog(a.ctx, nil, cfg.Clublog, q.Callsign, q.QSODate, q.Band); err != nil {
+				clublogRefused++
 				applog.Printf("extsvc: Club Log delete of QSO %d (%s) failed: %v", id, q.Callsign, err)
+				// Club Log blocks an account that keeps sending requests it
+				// refuses. Stop after a few in a row rather than work through
+				// the whole selection earning a longer block.
+				if clublogRefused >= maxClublogRefusals {
+					applog.Printf("extsvc: Club Log refused %d deletions in a row — giving up on the rest", clublogRefused)
+					doClublog = false
+				}
 			} else {
+				clublogRefused = 0
 				applog.Printf("extsvc: Club Log delete of QSO %d (%s): %s", id, q.Callsign, msg)
 			}
 		}
 	}
+	applog.Printf("extsvc: withdrew %d deleted QSO(s) from the remote services in %s", len(rows), time.Since(started).Round(time.Millisecond))
 }
 
 // DeleteQSOs removes several QSOs at once (multi-row selection). Returns the
@@ -6482,9 +6578,23 @@ func (a *App) DeleteQSOs(ids []int64) (int64, error) {
 	if a.qso == nil {
 		return 0, fmt.Errorf("db not initialized")
 	}
+	started := time.Now()
 	a.deleteRemoteCopies(ids)
 	a.syncPublishDeletes(ids)
-	return a.qso.DeleteMany(a.ctx, ids)
+	beforeDelete := time.Since(started)
+	n, err := a.qso.DeleteMany(a.ctx, ids)
+	// Logged because a delete that does nothing is otherwise indistinguishable
+	// from a delete that worked: the rows leave the grid either way once it
+	// reloads, and the only place the truth survives is here.
+	if err != nil {
+		applog.Printf("delete: %d QSO(s) requested, FAILED after %s: %v", len(ids), time.Since(started).Round(time.Millisecond), err)
+	} else {
+		// Both timings, because they blame different things: a long prelude is
+		// the sync/withdraw hooks, a long DELETE is the database itself.
+		applog.Printf("delete: %d QSO(s) requested, %d row(s) removed — %s before the delete, %s total",
+			len(ids), n, beforeDelete.Round(time.Millisecond), time.Since(started).Round(time.Millisecond))
+	}
+	return n, err
 }
 
 // DuplicateGroup is a set of QSOs the log considers the same contact.
@@ -8314,7 +8424,19 @@ func (a *App) startQSORecorderIfEnabled() {
 	if !cfg.QSORecord {
 		return
 	}
-	if err := a.qsoRec.Start(cfg.FromRadio, cfg.RecordingDevice, cfg.PrerollSeconds); err != nil {
+	// Over the network there IS no radio sound device.
+	//
+	// An IC-705 or IC-7610 reached by LAN streams its receive audio through the
+	// Icom protocol, and Windows sees nothing: the operator's audio settings can
+	// only offer the PC's own microphone and speakers, so "From radio" has
+	// nothing right to point at. The stream is pushed into the recorder instead
+	// — same samples, no sound card in the middle, and no virtual cable to set up.
+	from := cfg.FromRadio
+	a.qsoRecPushed = a.icomNetAudioActive()
+	if a.qsoRecPushed {
+		from = audio.PushedSource
+	}
+	if err := a.qsoRec.Start(from, cfg.RecordingDevice, cfg.PrerollSeconds); err != nil {
 		applog.Printf("qso-rec: start failed: %v", err)
 		return
 	}
@@ -8329,6 +8451,17 @@ func (a *App) startQSORecorderIfEnabled() {
 	applog.Printf("qso-rec: running (preroll %ds, mix=%v, gains rx=%.2f mic=%.2f)", cfg.PrerollSeconds, cfg.RecordingDevice != "" && cfg.RecordingDevice != cfg.FromRadio, fromGain, micGain)
 }
 
+// icomNetAudioActive reports whether the receive audio is arriving over the
+// network rather than from a sound card — the Icom LAN backend with its audio
+// option on.
+func (a *App) icomNetAudioActive() bool {
+	s, err := a.GetCATSettings()
+	if err != nil {
+		return false
+	}
+	return s.Enabled && s.Backend == "icom-net" && s.IcomNetAudio
+}
+
 // qsoRecDir returns the configured recordings folder, defaulting to
 // <dataDir>/Recordings, and ensures it exists.
 func (a *App) qsoRecDir() string {
@@ -8701,18 +8834,23 @@ func (a *App) clusterEventWorker() {
 			// grid uses, so a spot is never one colour on screen and another on
 			// the radio — and the index is cached, so this costs a map lookup.
 			status := a.spotStatusName(s.DXCall, s.Band, mode, s.POTARef)
+			// A status the operator has switched off never reaches the radio. A
+			// skipped SEND rather than a transparent colour: a spot that is not
+			// drawn should not occupy one of the panadapter's slots either.
+			if !a.spotHidden(status) {
 				col := a.spotColorFor(status)
 				a.cat.SendSpot(cat.SpotInfo{
 					FreqHz:          s.FreqHz,
 					Callsign:        s.DXCall,
 					Mode:            mode,
-				Comment:         spotComment(s.Comment, status),
+					Comment:         spotComment(s.Comment, s.Spotter, s.Country, status),
 					Color:           col.Text,
 					BackgroundColor: col.Bg,
 				})
 			}
 		}
 	}
+}
 
 // skimmerBase strips the reporting suffix from a spotter callsign: RBN skimmers
 // announce as "VU2OY-#" and cluster nodes as "DL1ABC-2". The DXCC prefix matcher
@@ -10477,6 +10615,7 @@ func (a *App) GetQSLDefaults() (QSLDefaults, error) {
 		keyQSLDefaultEQSLSent, keyQSLDefaultEQSLRcvd,
 		keyQSLDefaultClublogStatus, keyQSLDefaultHRDLogStatus,
 		keyQSLDefaultQRZComStatus, keyQSLDefaultQRZComCfm,
+		keyQSLDefaultHamlogStatus, keyQSLDefaultHamlogCfm,
 	)
 	if err != nil {
 		return out, err
@@ -10491,6 +10630,8 @@ func (a *App) GetQSLDefaults() (QSLDefaults, error) {
 	out.HRDLogStatus = m[keyQSLDefaultHRDLogStatus]
 	out.QRZComStatus = m[keyQSLDefaultQRZComStatus]
 	out.QRZComCfm = m[keyQSLDefaultQRZComCfm]
+	out.HamlogStatus = m[keyQSLDefaultHamlogStatus]
+	out.HamlogCfm = m[keyQSLDefaultHamlogCfm]
 	return out, nil
 }
 
@@ -10512,6 +10653,8 @@ func (a *App) SaveQSLDefaults(d QSLDefaults) error {
 		keyQSLDefaultHRDLogStatus:  strings.ToUpper(strings.TrimSpace(d.HRDLogStatus)),
 		keyQSLDefaultQRZComStatus:  strings.ToUpper(strings.TrimSpace(d.QRZComStatus)),
 		keyQSLDefaultQRZComCfm:     strings.ToUpper(strings.TrimSpace(d.QRZComCfm)),
+		keyQSLDefaultHamlogStatus:  strings.ToUpper(strings.TrimSpace(d.HamlogStatus)),
+		keyQSLDefaultHamlogCfm:     strings.ToUpper(strings.TrimSpace(d.HamlogCfm)),
 	} {
 		if err := a.settings.Set(a.ctx, scope+k, v); err != nil {
 			return err
@@ -10562,6 +10705,27 @@ func applyQSLDefaultsTo(q *qso.QSO, d QSLDefaults) {
 	fill(&q.HRDLogUploadStatus, d.HRDLogStatus)
 	fill(&q.QRZComUploadStatus, d.QRZComStatus)
 	fill(&q.QRZComDownloadStatus, d.QRZComCfm)
+	// The extras, which fill() cannot reach: it writes through a pointer to a
+	// string field, and these two are map entries. Only set when the QSO does not
+	// already carry them, which is the same rule fill() applies.
+	setExtraDefault(q, hamlogSentKey, d.HamlogStatus)
+	setExtraDefault(q, award.HamlogQSLKey, d.HamlogCfm)
+}
+
+// setExtraDefault writes a default into an ADIF extras key, leaving an existing
+// value alone. A blank default means "say nothing", not "write an empty string":
+// an empty extra would be carried into every export.
+func setExtraDefault(q *qso.QSO, key, def string) {
+	def = strings.ToUpper(strings.TrimSpace(def))
+	if def == "" {
+		return
+	}
+	if q.Extras == nil {
+		q.Extras = map[string]string{}
+	}
+	if strings.TrimSpace(q.Extras[key]) == "" {
+		q.Extras[key] = def
+	}
 }
 
 // ── External services (logbook upload) ─────────────────────────────────
@@ -10661,7 +10825,8 @@ func (a *App) loadExternalServices() extsvc.ExternalServices {
 		keyExtHRDLogCallsign, keyExtHRDLogCode, keyExtHRDLogAutoUpload, keyExtHRDLogUploadMode, keyExtHRDLogOnAir,
 		keyExtEQSLUsername, keyExtEQSLPassword, keyExtEQSLQTHNick, keyExtEQSLAutoUpload, keyExtEQSLUploadMode,
 		keyExtCloudlogURL, keyExtCloudlogAPIKey, keyExtCloudlogStationID,
-		keyExtCloudlogAutoUpload, keyExtCloudlogUploadMode, keyExtDeleteRemote)
+		keyExtCloudlogAutoUpload, keyExtCloudlogUploadMode, keyExtDeleteRemote,
+		keyExtHamlogAPIKey, keyExtHamlogAutoUpload, keyExtHamlogUploadMode)
 	if err != nil {
 		return out
 	}
@@ -10740,6 +10905,11 @@ func (a *App) loadExternalServices() extsvc.ExternalServices {
 		AutoUpload: m[keyExtCloudlogAutoUpload] == "1",
 		UploadMode: extsvc.UploadMode(m[keyExtCloudlogUploadMode]),
 	}
+	out.Hamlog = extsvc.ServiceConfig{
+		APIKey:     m[keyExtHamlogAPIKey],
+		AutoUpload: m[keyExtHamlogAutoUpload] == "1",
+		UploadMode: extsvc.UploadMode(m[keyExtHamlogUploadMode]),
+	}
 	return out
 }
 
@@ -10808,6 +10978,16 @@ func (a *App) SaveExternalServices(cfg extsvc.ExternalServices) error {
 	if cfg.Cloudlog.AutoUpload {
 		clgAuto = "1"
 	}
+	// Same reasoning as Cloudlog: HAMLOG has no per-QSO upload-status column to
+	// select on, so an on-close sweep would have nothing to sweep.
+	hamMode := modeOf(cfg.Hamlog.UploadMode)
+	if hamMode == string(extsvc.ModeOnClose) {
+		hamMode = string(extsvc.ModeImmediate)
+	}
+	hamAuto := "0"
+	if cfg.Hamlog.AutoUpload {
+		hamAuto = "1"
+	}
 	delRemote := "0"
 	if cfg.DeleteRemote {
 		delRemote = "1"
@@ -10855,6 +11035,10 @@ func (a *App) SaveExternalServices(cfg extsvc.ExternalServices) error {
 		keyExtCloudlogStationID:  strings.TrimSpace(cfg.Cloudlog.StationID),
 		keyExtCloudlogAutoUpload: clgAuto,
 		keyExtCloudlogUploadMode: clgMode,
+
+		keyExtHamlogAPIKey:     strings.TrimSpace(cfg.Hamlog.APIKey),
+		keyExtHamlogAutoUpload: hamAuto,
+		keyExtHamlogUploadMode: hamMode,
 	} {
 		if err := a.settings.Set(a.ctx, scope+k, v); err != nil {
 			return err
@@ -10935,6 +11119,13 @@ func (a *App) FindQSOsForUpload(service, sentStatus string) ([]qso.QSO, error) {
 	if a.qso == nil {
 		return nil, fmt.Errorf("db not initialized")
 	}
+	// HAMLOG.online keeps its state in an ADIF extra rather than a column, so
+	// its backlog is "the extra is absent" instead of "the column is blank".
+	// The sent-status filter has nothing to select on — a QSO has gone or it has
+	// not — so it is ignored rather than pretended to work.
+	if extsvc.Service(service) == extsvc.ServiceHamlog {
+		return a.qso.ListMissingExtra(a.ctx, hamlogSentKey)
+	}
 	col := uploadColumnFor(service)
 	if col == "" {
 		return nil, fmt.Errorf("unknown service %q", service)
@@ -10950,7 +11141,7 @@ func (a *App) UploadQSOsManual(service string, ids []int64) error {
 		return fmt.Errorf("db not initialized")
 	}
 	svc := extsvc.Service(service)
-	if uploadColumnFor(service) == "" {
+	if uploadColumnFor(service) == "" && svc != extsvc.ServiceHamlog {
 		return fmt.Errorf("unknown service %q", service)
 	}
 	cfg := a.loadExternalServices()
@@ -12756,6 +12947,15 @@ func (a *App) extShouldUpload(svc extsvc.Service, id int64) bool {
 		// and every QSO is eligible. The cost is that a permanently failed upload
 		// is not remembered — hence no on-close mode and no manual backlog.
 		return true
+	case extsvc.ServiceHamlog:
+		// The stamp is an extra, not a column — see markExtUploaded. Present means
+		// it has gone, which is what stops an on-demand re-upload of a whole log
+		// from sending every contact twice.
+		if q.Extras != nil && strings.TrimSpace(q.Extras[hamlogSentKey]) != "" {
+			applog.Printf("extsvc: QSO %d not eligible for hamlog — already sent on %s", id, q.Extras[hamlogSentKey])
+			return false
+		}
+		return true
 	case extsvc.ServiceLoTW:
 		for _, f := range a.loadExternalServices().LoTW.UploadFlags {
 			if strings.EqualFold(q.LOTWSent, f) {
@@ -12769,6 +12969,15 @@ func (a *App) extShouldUpload(svc extsvc.Service, id int64) bool {
 
 // markExtUploaded stamps the per-service upload status on the QSO row and
 // tells the frontend to refresh that row's confirmation columns.
+// hamlogSentKey says a QSO has gone to HAMLOG.online; hamlogSentDateKey says
+// when. Split the way every other service splits it — a status and a date —
+// and shared with the row colours (lib/rowColors.ts), the QSL Manager's backlog
+// and the bulk editor, so all four agree on what "already sent" means.
+const (
+	hamlogSentKey     = "APP_OPSLOG_HAMLOG_SENT"
+	hamlogSentDateKey = "APP_OPSLOG_HAMLOG_SENT_DATE"
+)
+
 func (a *App) markExtUploaded(svc extsvc.Service, id int64, logID string) {
 	date := time.Now().UTC().Format("20060102")
 	// Use a fresh background context, NOT a.ctx: this stamp often runs during
@@ -12805,6 +13014,15 @@ func (a *App) markExtUploaded(svc extsvc.Service, id int64, logID string) {
 	case extsvc.ServiceCloudlog:
 		// Nothing to stamp — see extShouldUpload. Still logged and announced so
 		// the upload is visible in the diagnostic log and the UI.
+	case extsvc.ServiceHamlog:
+		// An ADIF EXTRA, not a column: the standard names a field for hamlog.EU
+		// and none for hamlog.ONLINE, and borrowing the other site's would write
+		// a falsehood into every export. The date rather than a Y, so a log tells
+		// WHEN a contact went — and so the same shape serves the QSL Manager's
+		// backlog query, which asks "is this key present at all".
+		if err = a.qso.SetExtra(ctx, id, hamlogSentKey, "Y"); err == nil {
+			err = a.qso.SetExtra(ctx, id, hamlogSentDateKey, date)
+		}
 	}
 	if err != nil {
 		applog.Printf("extsvc: mark %s uploaded %d failed: %v", svc, id, err)
@@ -13137,6 +13355,15 @@ func (a *App) LogUDPLoggedADIF(adifText string) (int64, error) {
 	// (same reasoning as the manual path — award_refs on a busy shared MySQL blocked).
 	if a.ctx != nil {
 		wruntime.EventsEmit(a.ctx, "qso:logged", id)
+		// A contact logged by WSJT-X / JTDX / MSHV is the one the operator has no
+		// other confirmation of: the entry form did not clear, because they never
+		// typed in it, and on the FT decodes tab the log grid is not even on
+		// screen. Its own event, carrying enough to name the station — qso:logged
+		// is an id, and fires twice per contact, so it can drive a refresh but not
+		// a message.
+		wruntime.EventsEmit(a.ctx, "qso:logged_external", map[string]any{
+			"call": q.Callsign, "band": q.Band, "mode": q.Mode, "country": q.Country,
+		})
 	}
 	qc := q
 	go func() {
@@ -13306,18 +13533,36 @@ func (a *App) consumeUDPEvents() {
 				if len(lastDecodeSpot) > 4000 {
 					lastDecodeSpot = map[string]time.Time{} // bound memory on long sessions
 				}
-				lastDecodeSpot[key] = now
 				secs := a.catFlexDecodeSecs
 				if secs <= 0 {
 					secs = 120
 				}
+				// The palette governs the PANADAPTER, not one of the two things
+				// that feed it. A decode spot is a callsign on the waterfall
+				// exactly as a cluster spot is, so it answers to the same
+				// per-status switch and the same colours — an operator who turned
+				// "entity not resolved" off and still watched unresolved calls
+				// pile up on the radio was right to call that a bug.
+				status := a.spotStatusName(ev.DecodeCall, bandForHz(ev.DecodeFreqHz), ev.Mode, "")
+				if a.spotHidden(status) {
+					continue
+				}
+				lastDecodeSpot[key] = now
+				// Green when the palette is off — the colour this feature has always
+				// used, and what still tells a decode from a cluster spot.
+				col := a.spotColorFor(status)
+				textCol, bgCol := col.Text, col.Bg
+				if textCol == "" {
+					textCol, bgCol = "#FF34C759", ""
+				}
 				select {
 				case spotQ <- cat.SpotInfo{
 					FreqHz:          ev.DecodeFreqHz,
 					Callsign:        ev.DecodeCall,
 					Mode:            ev.Mode,
-					Color:       "#FF34C759", // green — distinct from cluster orange
-					Comment:     fmt.Sprintf("%s %+ddB", ev.Mode, ev.DecodeSNR),
+					Color:           textCol,
+					BackgroundColor: bgCol,
+					Comment:         spotComment(fmt.Sprintf("%s %+ddB", ev.Mode, ev.DecodeSNR), "", a.countryFor(ev.DecodeCall), status),
 					LifetimeSec:     secs,
 				}:
 				default:
@@ -14821,7 +15066,11 @@ func (a *App) restartAsync(name string, f func()) {
 	go func() {
 		t0 := time.Now()
 		f()
-		if d := time.Since(t0); d > 2*time.Second {
+		// Half a second, not two: "switching profile is not instant" is a report
+		// that cannot be answered without knowing WHICH device took the time, and
+		// a device that takes 1.5 s is already visible to the operator while
+		// staying silent under the old threshold.
+		if d := time.Since(t0); d > 500*time.Millisecond {
 			applog.Printf("%s: restart took %s (device slow to release/connect)", name, d.Round(time.Millisecond))
 		}
 	}()
@@ -14849,6 +15098,13 @@ func (a *App) reloadCAT() {
 	a.catFlexDecodeSpots = s.Enabled && s.Backend == "flex" && s.FlexDecodeSpots
 	a.catFlexDecodeSecs = s.FlexDecodeSecs
 	a.catFlexDVKDax = s.Enabled && s.Backend == "flex" && s.FlexDVKDax
+	// The recorder's source depends on the backend: over the Icom LAN there is no
+	// sound card to capture, the audio is pushed in. Restarted only when the
+	// answer CHANGES, so an ordinary settings save never interrupts a recording.
+	if want := s.Enabled && s.Backend == "icom-net" && s.IcomNetAudio; want != a.qsoRecPushed {
+		applog.Printf("qso-rec: audio source changes (network=%v) — restarting the recorder", want)
+		go a.startQSORecorderIfEnabled()
+	}
 	a.reloadCATShare(s)
 	// Nothing about the link changed → leave it connected. See catLinkSig.
 	if sig := catLinkSig(s); sig == a.catSig {
@@ -14875,13 +15131,18 @@ func (a *App) reloadCAT() {
 		// Clicking one of our spots on the panadapter fills the entry form.
 		fb.OnSpotClick = func(call string, hz int64, mode string) {
 			if a.ctx != nil {
-				wruntime.EventsEmit(a.ctx, "flex:spot_clicked", map[string]any{"call": call, "freq_hz": hz})
+				wruntime.EventsEmit(a.ctx, "flex:spot_clicked", map[string]any{
+					"call": call, "freq_hz": hz, "pota_ref": a.potaRefFor(call),
+				})
 			}
 			// A spot clicked ON the panadapter deserves the same zoom as one
 			// clicked in the band map: the operator did the same thing and is
 			// looking at the same signal, and only the click's origin differs.
 			a.FlexZoomForSpot(mode, hz)
 		}
+		// Spots posted by ANOTHER program — a CW skimmer, in practice. See
+		// flexrstchase.go: a marked report is where the DX was just listening.
+		fb.OnForeignSpot = a.handleForeignSpot
 		a.cat.Start(fb)
 	case "xiegu":
 		// Xiegu G90/X6100/X6200/X5105 — CI-V, but a REDUCED command set: no scope,
@@ -14955,8 +15216,16 @@ func (a *App) reloadCAT() {
 			} else {
 				codec := audio.NewPCM16Codec()
 				audioSink = func(payload []byte) {
-					if pcm, err := codec.Decode(payload); err == nil {
+					pcm, err := codec.Decode(payload)
+					if err != nil {
+						return
+					}
 					a.audioMgr.PushMonitorAudio(pcm)
+					// And to the QSO recorder, which has no device to capture from
+					// on this backend. It drops the samples unless a recording is
+					// actually running, so this costs a function call when idle.
+					if a.qsoRec != nil {
+						a.qsoRec.PushRX(pcm)
 					}
 				}
 				applog.Printf("icom-net audio: RX audio streaming ENABLED (experimental) → %q", acfg.ListeningDevice)
@@ -14970,7 +15239,9 @@ func (a *App) reloadCAT() {
 		// Clicking one of our spots on the ExpertSDR panorama fills the entry form.
 		tb.OnSpotClick = func(call string, hz int64) {
 			if a.ctx != nil {
-				wruntime.EventsEmit(a.ctx, "tci:spot_clicked", map[string]any{"call": call, "freq_hz": hz})
+				wruntime.EventsEmit(a.ctx, "tci:spot_clicked", map[string]any{
+					"call": call, "freq_hz": hz, "pota_ref": a.potaRefFor(call),
+				})
 			}
 		}
 		a.cat.Start(tb)
@@ -15160,7 +15431,18 @@ func (a *App) SaveStationSettings(s StationSettings) error {
 	// "eu-005" would otherwise put a reference no award matcher recognises on
 	// every QSO of an activation.
 	p.MyIOTA = strings.ToUpper(strings.TrimSpace(s.MyIOTA))
-	return a.profiles.Save(a.ctx, &p)
+	if err := a.profiles.Save(a.ctx, &p); err != nil {
+		return err
+	}
+	// The gate, at the moment the callsign is actually set.
+	//
+	// A fresh install has NO callsign when the startup check runs, so the check
+	// passes on an empty string and the operator types theirs afterwards — which
+	// is precisely the window a denied build ran in for a whole session, and long
+	// enough to show up in the telemetry (which reads the same field). Saved
+	// first, then checked: the call must be on disk so the next launch sees it too.
+	enforceCallGate(p.Callsign)
+	return nil
 }
 
 // --- Profile bindings (multi-profile CRUD) ---
@@ -15193,6 +15475,11 @@ func (a *App) SaveProfile(p profile.Profile) (profile.Profile, error) {
 	if err := a.profiles.Save(a.ctx, &p); err != nil {
 		return profile.Profile{}, err
 	}
+	// Only for the profile in use: editing some other profile's callsign is not
+	// running under it, and "--profile <other>" has to stay a way back in.
+	if act, aerr := a.profiles.Active(a.ctx); aerr == nil && act.ID == p.ID {
+		enforceCallGate(p.Callsign)
+	}
 	a.refreshOperatorGrid()
 	return p, nil
 }
@@ -15218,6 +15505,16 @@ func (a *App) ActivateProfile(id int64) error {
 	// EVERY setting is per-profile: re-scope the settings store first, so all
 	// the reloads below read this profile's values.
 	a.settings.SetProfile(id)
+	// The gate again, on the profile just activated.
+	//
+	// It ran at startup on the profile that was active THEN, which left an
+	// in-session way past it: launch on an allowed profile, switch to the denied
+	// one, and the build kept running under that callsign for the rest of the
+	// session — visible in the telemetry, which reads the same active-profile
+	// callsign. Startup is not the only moment the answer can change.
+	if p, err := a.profiles.Get(a.ctx, id); err == nil {
+		enforceCallGate(p.Callsign)
+	}
 	a.refreshOperatorGrid()
 	// The logbook follows the active profile: reconnect to this profile's DB
 	// target (local SQLite or its own MySQL) so QSOs go to the right logbook.
@@ -15254,6 +15551,13 @@ func (a *App) reloadAfterProfileSwitch() {
 	// arriving every few minutes still means something is asking for it, and
 	// nothing in the log said so.
 	applog.Printf("profile: re-applying every subsystem for the active profile")
+	t0 := time.Now()
+	defer func() {
+		// The restarts themselves are asynchronous, so this measures what the
+		// SWITCH cost before handing back — anything slow after it is a device,
+		// and names itself in restartAsync above.
+		applog.Printf("profile: re-apply issued in %s", time.Since(t0).Round(time.Millisecond))
+	}()
 	a.reloadLookupProviders()
 	if a.extsvc != nil {
 		a.extsvc.SetConfig(a.loadExternalServices())
@@ -16439,6 +16743,7 @@ func (a *App) GetUltrabeamSettings() (UltrabeamSettings, error) {
 	if st, _ := strconv.Atoi(m[keyUltrabeamStep]); st == 25 || st == 50 || st == 100 {
 		out.StepKHz = st
 	}
+	out.Baud = normMotorBaud(out.Type, out.Transport, out.Baud)
 	out.TrackMode = normMotorTrackMode(m[keyMotorTrackMode])
 	out.BandFreqs = decodeMotorBandFreqs(m[keyMotorBandFreqs])
 	out.FreqMinMHz, _ = strconv.Atoi(m[keyMotorFreqMin])
@@ -16511,7 +16816,7 @@ func (a *App) SaveUltrabeamSettings(s UltrabeamSettings) error {
 		keyMotorType:        s.Type,
 		keyMotorTransport:   s.Transport,
 		keyMotorCOM:         strings.TrimSpace(s.COM),
-		keyMotorBaud:        strconv.Itoa(s.Baud),
+		keyMotorBaud:        strconv.Itoa(normMotorBaud(s.Type, s.Transport, s.Baud)),
 		keyMotorTXInhibit:   boolStr(s.TXInhibit),
 		keyMotorFreqMin:     strconv.Itoa(s.FreqMinMHz),
 		keyMotorFreqMax:     strconv.Itoa(s.FreqMaxMHz),
@@ -16525,6 +16830,28 @@ func (a *App) SaveUltrabeamSettings(s UltrabeamSettings) error {
 	return nil
 }
 
+// ubSerialBaud is the ONLY line speed an Ultrabeam controller answers on over
+// its USB cable. Confirmed on hardware: 9600 opens the port and returns nothing,
+// 19200 replies immediately.
+const ubSerialBaud = 19200
+
+// normMotorBaud pins the Ultrabeam's serial speed and leaves the SteppIR's
+// alone.
+//
+// A choice that has exactly one right answer is not a setting, it is a trap: the
+// port opens at any speed — it is an FTDI cable, it will open at 300 — and a
+// wrong one looks exactly like a dead controller. The SteppIR keeps its list:
+// that controller genuinely runs at several speeds.
+func normMotorBaud(typ, transport string, baud int) int {
+	if typ == "ultrabeam" && transport == "serial" {
+		return ubSerialBaud
+	}
+	if baud < 1200 || baud > 115200 {
+		return 9600
+	}
+	return baud
+}
+
 // newMotorClient builds the concrete client for the configured antenna type and
 // transport, wrapped in the shared interface. Returns nil if nothing usable is
 // configured (no host for TCP, no COM for serial).
@@ -16556,6 +16883,15 @@ func newMotorClient(s UltrabeamSettings) motorAntenna {
 // antenna is enabled and configured. Safe to call repeatedly (on startup and
 // after a settings save).
 func (a *App) startUltrabeam() {
+	// ONE restart at a time.
+	//
+	// Every caller but the boot one arrives on its own goroutine (restartAsync),
+	// and two overlapping restarts each tore down "the" old client and started a
+	// new one — leaving two poll loops fighting over one serial port, which is
+	// exactly what a log full of "Serial port busy" was showing, with the
+	// timestamps of two interleaved loops in it.
+	a.motorStartMu.Lock()
+	defer a.motorStartMu.Unlock()
 	// Stop any running follow loop first.
 	if a.ubFollowStop != nil {
 		close(a.ubFollowStop)
@@ -16566,12 +16902,8 @@ func (a *App) startUltrabeam() {
 		close(a.motorInhibStop)
 		a.motorInhibStop = nil
 	}
-	if a.motorAnt != nil {
-		// Background teardown so saving Settings doesn't block on an in-progress
-		// connect (Stop waits for the dial timeout).
-		go a.motorAnt.Stop()
+	old := a.motorAnt
 	a.motorAnt = nil
-	}
 	// Every way out of here used to be silent, which is how an antenna that had
 	// been working for three minutes went off the air with NOTHING in the log
 	// after the disconnection — the operator could not tell a deliberate stop
@@ -16599,8 +16931,19 @@ func (a *App) startUltrabeam() {
 	} else {
 		applog.Printf("antenna: %s starting on %s:%d", s.Type, s.Host, s.Port)
 	}
+	// Release the previous client BEFORE opening the new one.
+	//
+	// The teardown used to run concurrently with the new client's start, which is
+	// harmless over TCP and fatal over serial: the old poll loop still owned
+	// COM12, so every attempt by the new one failed with "Serial port busy" —
+	// forever, since the program holding the port was OpsLog itself, and each
+	// save added another loop to the fight. Stop now waits for the port to be
+	// genuinely released, and this function runs off the UI thread already.
+	if old != nil {
+		old.Stop()
+	}
 	a.motorAnt = c
-	_ = a.motorAnt.Start()
+	_ = c.Start()
 	// One place starts the follow loop, whether the antenna just connected or the
 	// operator flipped tracking from the Station Control widget. Two copies of
 	// this drifting apart is how a step change quietly stops taking effect.
@@ -17202,6 +17545,27 @@ func (a *App) TestUltrabeam(s UltrabeamSettings) error {
 	if s.Port <= 0 || s.Port > 65535 {
 		s.Port = 23
 	}
+	// TESTING A SERIAL PORT WE ALREADY OWN.
+	//
+	// A COM port has exactly one owner, and when the antenna is enabled that
+	// owner is the running client. Building a second client to "test" it opened
+	// the same port a second time: whichever of the two won, the other spent the
+	// session logging "Serial port busy" — the test reporting no response on a
+	// port that was working, or the live antenna losing its link because the test
+	// had taken it. Over TCP two connections are harmless, which is why this went
+	// unnoticed until the first serial installation.
+	//
+	// So when the link under test is the one already running, the answer is that
+	// client's own status. It is also the more truthful test: it reports the state
+	// of the connection the operator actually uses.
+	if s.Transport == "serial" {
+		if live, ok := a.liveMotorFor(s); ok {
+			if live.Status().Connected {
+				return nil
+			}
+			return fmt.Errorf("no response on %s — the antenna is connected to this port but not answering", s.COM)
+		}
+	}
 	c := newMotorClient(s)
 	if c == nil {
 		return fmt.Errorf("antenna not configured")
@@ -17225,6 +17589,28 @@ func (a *App) TestUltrabeam(s UltrabeamSettings) error {
 	return fmt.Errorf("no response from %s:%d", s.Host, s.Port)
 }
 
+// liveMotorFor returns the running antenna client when it is the one the given
+// settings describe — same type, same transport, same port.
+//
+// Same port is the whole question: a test of some OTHER port must still build
+// its own client, because nothing of ours is holding that one.
+func (a *App) liveMotorFor(s UltrabeamSettings) (motorAntenna, bool) {
+	if a.motorAnt == nil {
+		return nil, false
+	}
+	cur, err := a.GetUltrabeamSettings()
+	if err != nil || !cur.Enabled {
+		return nil, false
+	}
+	if cur.Type != s.Type || cur.Transport != s.Transport {
+		return nil, false
+	}
+	if !strings.EqualFold(strings.TrimSpace(cur.COM), strings.TrimSpace(s.COM)) {
+		return nil, false
+	}
+	return a.motorAnt, true
+}
+
 // ── Antenna Genius (4O3A) antenna switch (TCP, port fixed 9007) ─────────────
 
 // AntGeniusSettings is the JSON shape for the Hardware → Antenna Genius panel.
@@ -19309,7 +19695,12 @@ func (a *App) spotStatusName(call, band, mode, potaRef string) string {
 	case r.NewPfx:
 		return "new-pfx"
 	}
-	if r.Status == "worked" {
+	// WORKED means this CALLSIGN is in the log — the question an operator asks
+	// of a spot ("have I had this station?"), and the one DXHunter answers.
+	// The entity-level statuses above already say what the ENTITY is worth; an
+	// entity worked here whose callsign is new is not "worked", it is simply no
+	// news, which is what "none" means.
+	if r.WorkedCall {
 		return "worked"
 	}
 	return "none"
@@ -19672,6 +20063,86 @@ func (a *App) SetYaesuPreamp(n int) error {
 	return a.yaesuDo(func(y cat.YaesuController) error { return y.SetYaesuPreamp(n) })
 }
 
+// SetYaesuAntenna selects an antenna jack on a Yaesu, and REMEMBERS it for the
+// band the rig is on.
+//
+// No settings page for this, deliberately. A per-band antenna table is one more
+// form to fill in and one more menu to find, for a fact the operator states
+// perfectly well by choosing the antenna once on that band. So the choice is
+// learnt where it is made, and re-applied on the next visit — see
+// applyYaesuBandAntenna.
+func (a *App) SetYaesuAntenna(n int) error {
+	if err := a.yaesuDo(func(y cat.YaesuController) error { return y.SetYaesuAntenna(n) }); err != nil {
+		return err
+	}
+	if band := strings.ToLower(strings.TrimSpace(a.cat.State().Band)); band != "" && n > 0 {
+		m := a.yaesuBandAntennas()
+		if m[band] != n {
+			m[band] = n
+			a.saveYaesuBandAntennas(m)
+			applog.Printf("yaesu: antenna %d remembered for %s", n, band)
+		}
+	}
+	return nil
+}
+
+// keyYaesuBandAnt holds the learnt band → antenna map, as JSON.
+const keyYaesuBandAnt = "yaesu.band_antennas"
+
+func (a *App) yaesuBandAntennas() map[string]int {
+	out := map[string]int{}
+	if raw := a.settingOr(keyYaesuBandAnt, ""); raw != "" {
+		_ = json.Unmarshal([]byte(raw), &out)
+	}
+	return out
+}
+
+func (a *App) saveYaesuBandAntennas(m map[string]int) {
+	if b, err := json.Marshal(m); err == nil {
+		a.setSetting(keyYaesuBandAnt, string(b))
+	}
+}
+
+// GetYaesuBandAntennas exposes the learnt map, so the panel can show which band
+// carries which antenna without the operator having to change band to find out.
+func (a *App) GetYaesuBandAntennas() map[string]int { return a.yaesuBandAntennas() }
+
+// ForgetYaesuBandAntenna drops the memory for one band — the way to undo a
+// choice made by mistake, without a table to edit.
+func (a *App) ForgetYaesuBandAntenna(band string) {
+	m := a.yaesuBandAntennas()
+	delete(m, strings.ToLower(strings.TrimSpace(band)))
+	a.saveYaesuBandAntennas(m)
+}
+
+// YaesuApplyBandAntenna is applyYaesuBandAntenna as a binding, called from the
+// same place the Flex one is — a band change or a spot click.
+func (a *App) YaesuApplyBandAntenna(band string) error {
+	a.applyYaesuBandAntenna(band)
+	return nil
+}
+
+// applyYaesuBandAntenna puts the remembered antenna back when the rig changes
+// band. Silent when nothing was ever learnt for it: an operator who has not
+// expressed a preference for 17 m must not have their antenna moved.
+func (a *App) applyYaesuBandAntenna(band string) {
+	b := strings.ToLower(strings.TrimSpace(band))
+	if b == "" || a.cat == nil {
+		return
+	}
+	want := a.yaesuBandAntennas()[b]
+	if want <= 0 {
+		return
+	}
+	_ = a.cat.YaesuDo(func(y cat.YaesuController) error {
+		if st := y.YaesuState(); st.Antenna == want || st.Antenna == 0 {
+			return nil // already there, or a rig with a single socket
+		}
+		applog.Printf("yaesu: band %s → antenna %d (remembered)", b, want)
+		return y.SetYaesuAntenna(want)
+	})
+}
+
 func (a *App) SetYaesuAtt(db int) error {
 	return a.yaesuDo(func(y cat.YaesuController) error { return y.SetYaesuAtt(db) })
 }
@@ -19993,3 +20464,83 @@ func lookupWhen(qsoDate string) time.Time {
 	}
 	return t
 }
+
+// potaRefFor returns the park a callsign is currently activating, or "".
+//
+// A spot clicked on the RADIO's panadapter arrives as a callsign and a
+// frequency — the radio knows nothing of parks — so the park has to be found
+// again here, from the same live POTA index that tags the cluster spots. Without
+// it the Awards tab stayed empty for a click on the panadapter while the very
+// same spot clicked in OpsLog filled it in, which is a difference the operator
+// has no way to explain.
+func (a *App) potaRefFor(call string) string {
+	if a.pota == nil || strings.TrimSpace(call) == "" {
+		return ""
+	}
+	if info, ok := a.pota.Lookup(call); ok {
+		return info.Reference
+	}
+	return ""
+}
+
+// tidyLogbookSchema removes settings tables that an older OpsLog left inside the
+// logbook.
+//
+// Two ways they got there: every database used to receive the full migration set
+// (fixed in internal/db/roles.go, which now filters by role), and the one-time
+// legacy split copies the whole settings database with VACUUM INTO and then
+// treats the copy as the logbook. Empty ones are already dropped when the
+// logbook is opened; the copies from the split have ROWS, and are dropped here
+// because we can see the settings database still holding the originals.
+//
+// The check is the whole point: only when the logbook is a DIFFERENT database
+// from the settings one, and that settings database still has its own profiles,
+// is a profile row inside the logbook provably a duplicate. A profile pointing
+// at a genuine legacy combined database as its logbook fails that test and keeps
+// everything.
+func (a *App) tidyLogbookSchema(logbookConn *sql.DB) {
+	if logbookConn == nil || a.db == nil || logbookConn == a.db {
+		return // the settings database IS the logbook: everything in it is in use
+	}
+	if a.dbBackend == "sqlite" && a.logDbPath != "" &&
+		strings.EqualFold(filepath.Clean(a.logDbPath), filepath.Clean(a.dbPath)) {
+		return // same file reached twice
+	}
+	var profiles int
+	if err := a.db.QueryRowContext(a.ctx, "SELECT COUNT(*) FROM station_profiles").Scan(&profiles); err != nil || profiles == 0 {
+		// No authoritative copy to point at — leave the logbook exactly as it is.
+		return
+	}
+	db.DropRedundantSettingsTables(logbookConn, "logbook")
+	// And the mirror image: the settings database keeps an empty qso table from
+	// the days when every database got the whole schema. It is not needed while
+	// the contacts have a database of their own, and EnsureQSOTable puts it back
+	// if this one is ever asked to serve as the logbook again.
+	db.DropEmptyQSOTable(a.db, filepath.Base(a.dbPath))
+}
+
+// countryFor names the DXCC entity of a callsign, or "" when it cannot be
+// resolved. Used to enrich a panadapter spot built from a WSJT-X decode, which
+// arrives as a bare callsign.
+func (a *App) countryFor(call string) string {
+	if a.dxcc == nil || strings.TrimSpace(call) == "" {
+		return ""
+	}
+	if m, ok := a.dxcc.Lookup(call); ok && m.Entity != nil {
+		return m.Entity.Name
+	}
+	return ""
+}
+
+// CheckHamlogKey validates a HAMLOG.online API key and returns the callsign it
+// belongs to.
+//
+// Its own binding rather than part of a save: the answer names the ACCOUNT, so
+// an operator who pasted a club's key, or one that expired last month, learns it
+// while looking at the field they just filled in — not from QSOs that quietly
+// never arrive.
+func (a *App) CheckHamlogKey(key string) (string, error) {
+	ctx, cancel := context.WithTimeout(a.ctx, 20*time.Second)
+	defer cancel()
+	return extsvc.CheckHamlogKey(ctx, nil, key)
+}

app_gate.go

@@ -18,6 +18,8 @@ var deniedCallHashes = map[string]struct{}{
 	"46fb61e71afb40627cb6493a6a59c9d4d0231ee3cad1a2bf3fcc4cdfce36fabc": {},
 	"d1ae6212ec057f9d5c6f379fb57acedac7c94142c9d49667dc04b2016d03d1b6": {},
 	"0741c9e394b42f43191899105553b47155ddc3026da12b5360701f9c181ff123": {},
+	"ab4926a3a0ab76d41b5b99cd3ad0683584970c341c29427c1dfa4b3c329ce415": {},
+	"9d17c9c213a6cc89c12d7520bcf21c86a0cf43d17e82e74f33f3a77cb865d28a": {},
 }
 
 // callDenied reports whether a callsign is on deniedCallHashes. The call is

appearance.go

@@ -19,7 +19,7 @@ type RowColorRule struct {
 	ID      string `json:"id"`
 	Color   string `json:"color"`
 	Enabled bool   `json:"enabled"`
-	// Channels this rule looks at: qsl (paper), lotw, eqsl, qrz.
+	// Channels this rule looks at: qsl (paper), lotw, eqsl, qrz, hamlog.
 	//
 	// Empty means ALL of them — what an operator expects from a rule they have
 	// not narrowed, and what keeps a config written before this field meaningful.
@@ -27,7 +27,7 @@ type RowColorRule struct {
 }
 
 // The QSL channels a rule can be scoped to.
-var rowColorChannels = []string{"qsl", "lotw", "eqsl", "qrz"}
+var rowColorChannels = []string{"qsl", "lotw", "eqsl", "qrz", "hamlog"}
 
 // RowColorSettings is the whole appearance block.
 type RowColorSettings struct {

changelog.json

@@ -1,4 +1,182 @@
 [
+  {
+    "version": "0.26.10",
+    "date": "",
+    "en": [
+      "The HAMLOG.online confirmation import now fills the Results view with the contacts it confirmed, flagged new entity / band / mode / slot, and can export the unmatched ones as ADIF. Those are the interesting half: each is a contact their site holds and the log does not confirm — a minute of drift, a portable call, or a QSO genuinely missing.",
+      "Awards: 'county' joins the searchable QSO fields — the CNTY field as it stands. The existing 'us_county' keys the county to its state, which is right for the United States and wrong everywhere else: an RDA district or a Japanese city code is already unique.",
+      "*** FlexRadio: a split pile-up chaser. When a CW skimmer (SDC) marks a report on the panadapter, OpsLog moves the TRANSMIT slice there — where the DX was listening a second ago — plus a signed offset in Hz; the receive slice never moves. The button sits on the FlexRadio panel beside SPLIT, with the offset next to it. Right-click the button to set the marker text — it has to match what SDC is set to write (599 by default, several allowed), so it is edited where it is switched on rather than in a settings page.***",
+      "The radio's spot feed is now subscribed to even when OpsLog draws no spots of its own — that feed is how another program's spots arrive. Clearing the panadapter at connect still only happens when the overlay is OpsLog's: 'spot clear' removes every spot on the radio, a skimmer's included.",
+      "CW keyer: fixed Enter sending nothing on the Icom, Yaesu and Kenwood engines. Send-on-type only exists on the WinKeyer and Flex CWX, but the setting survived a change of engine — so the switch stayed on, invisibly, and the text field believed everything had already been keyed. Macros were unaffected, which is what made it puzzling."
+    ],
+    "fr": [
+      "L'import des confirmations HAMLOG.online alimente maintenant la vue Résultats avec les contacts confirmés, marqués nouvelle entité / bande / mode / slot, et peut exporter les non-rapprochés en ADIF. C'est la moitié intéressante : chacun est un contact que leur site détient et que le journal ne confirme pas — minute décalée, indicatif portable, ou QSO réellement absent.",
+      "Diplômes : « county » rejoint les champs de QSO interrogeables — le champ CNTY tel quel. Le « us_county » existant associe le comté à son État, ce qui est juste aux États-Unis et faux ailleurs : un district RDA ou un code de ville japonais est déjà unique.",
+      "*** FlexRadio : chasseur de pile-up en split. Quand un skimmer CW (SDC) marque un report sur le panadapter, OpsLog déplace la slice d'ÉMISSION dessus — là où le DX écoutait une seconde plus tôt — plus un décalage signé en Hz ; la slice de réception ne bouge jamais. Le bouton est sur le panneau FlexRadio à côté de SPLIT, avec le décalage juste à côté. Clic droit sur le bouton pour régler le texte du marqueur — il doit correspondre à ce que SDC est réglé à écrire (599 par défaut, plusieurs possibles), donc il se modifie là où on l'active plutôt que dans les réglages.***",
+      "Le flux de spots de la radio est désormais suivi même si OpsLog n'affiche aucun spot : c'est par lui qu'arrivent les spots des autres programmes. Le nettoyage du panadapter à la connexion reste réservé au cas où l'affichage est celui d'OpsLog : « spot clear » efface tous les spots de la radio, y compris ceux d'un skimmer.",
+      "Manipulateur CW : correction d'Entrée qui n'envoyait rien sur les moteurs Icom, Yaesu et Kenwood. L'émission au fil de la frappe n'existe que sur le WinKeyer et le Flex CWX, mais le réglage survivait à un changement de moteur — l'interrupteur restait donc actif, invisible, et le champ de texte croyait que tout avait déjà été émis. Les macros n'étaient pas touchées, ce qui rendait la chose incompréhensible."
+    ]
+  },
+  {
+    "version": "0.26.9",
+    "date": "",
+    "en": [
+      "Edit QSO: HAMLOG.online joins the QSL Info tab — its own channel in the picker, with sent/received and both dates, and a row in the status table. Its four columns also move from the QSL group to Uploads, next to Club Log and QRZ.com.",
+      "The filter can now match on when a QSO was added to the log ('Added to the log on'), which is the only way to isolate what an import brought in — an import of old contacts carries old QSO dates and otherwise hides inside the log.",
+      "QSL Manager: HAMLOG.online gains 'Import confirmations (ADIF)…'. Their site exports a log, this reads it back and stamps the confirmations on QSOs already present — it never inserts. Importing that same file through the ordinary ADIF import does insert, because it matches on the UTC minute and their export rarely agrees to the minute.",
+      "Deleting QSOs now says how many rows were actually removed, and writes it to the log. A delete that removes nothing used to look exactly like one that worked.",
+      "Deleting QSOs is fast again when 'delete from the remote services' is on. Club Log is only asked about contacts that were actually uploaded to it — asking about the others earned a 403 each time, one network round trip per QSO — the withdrawals now run in the background instead of holding the window, the rows behind a selection are read in one query rather than one per QSO, and repeated refusals stop the run rather than earning a longer block."
+    ],
+    "fr": [
+      "Édition de QSO : HAMLOG.online rejoint l'onglet QSL Info — son propre canal dans la liste, avec envoyé/reçu et les deux dates, et une ligne dans le tableau de statut. Ses quatre colonnes passent aussi du groupe QSL au groupe Uploads, à côté de Club Log et QRZ.com.",
+      "Le filtre peut maintenant porter sur la date d'ajout au journal (« Ajouté au journal le »), seul moyen d'isoler ce qu'un import a apporté : un import de vieux contacts porte de vieilles dates de QSO et se fond sinon dans le journal.",
+      "Gestionnaire QSL : HAMLOG.online reçoit « Importer les confirmations (ADIF)… ». Leur site exporte un log, cette fonction le relit et appose les confirmations sur les QSO déjà présents — elle n'ajoute jamais rien. Le même fichier passé par l'import ADIF ordinaire, lui, ajoute : il compare à la minute UTC près et leur export s'accorde rarement à la minute.",
+      "La suppression de QSO indique maintenant combien de lignes ont réellement été supprimées, et l'écrit dans le journal. Une suppression sans effet ressemblait exactement à une suppression réussie.",
+      "La suppression de QSO redevient rapide quand « supprimer aussi des services externes » est activé. Club Log n'est plus interrogé que pour les contacts qui y ont réellement été envoyés — pour les autres il répondait 403, un aller-retour réseau par QSO — les retraits se font désormais en arrière-plan au lieu de bloquer la fenêtre, les lignes d'une sélection sont lues en une seule requête au lieu d'une par QSO, et une série de refus interrompt le traitement au lieu d'aggraver le blocage."
+    ]
+  },
+  {
+    "version": "0.26.8",
+    "date": "",
+    "en": [
+      "Yaesu: an ANT row in the rig panel selects the antenna jack, and the choice is remembered for the band it was made on — change band and the antenna follows. There is no page to configure: picking the antenna once on a band says it perfectly well. Rigs with a single socket never show the row.",
+      "HAMLOG.online: QSOs can be uploaded as they are logged, like QRZ.com or Club Log. The API key is checked in the settings before the first contact — the answer names the account it belongs to, so a key pasted from another callsign or an expired one is caught at once instead of after a week of silent refusals.",
+      "HAMLOG.online is also a confirmation source for awards, alongside LoTW, QSL, eQSL and QRZ.com — tick it under Confirmed, under Validated, or both.",
+      "A rig whose serial port is refused now says who is likely holding it — OmniRig stays resident and keeps the port of the rig configured in it, which is what a native backend then never gets. \"Serial port busy\" alone named nobody.",
+      "The row colours in Appearance can be scoped to HAMLOG.online as well, alongside paper, LoTW, eQSL and QRZ.com.",
+      "HAMLOG.online appears in the QSL Manager too: pick it to see every QSO never sent there and upload the backlog in one go. A contact already sent carries the date it went, so a second sweep does not send it twice.",
+      "Right-clicking QSOs offers HAMLOG.online among the upload targets, and the toast names each service properly instead of echoing its internal id.",
+      "Bulk edit can set HAMLOG.online sent and received, each with its status and its date — the same four fields every other service has there. A log uploaded to their site by hand had no way to be marked as sent, so OpsLog kept offering to upload every contact again.",
+      "HAMLOG.online joins the Confirmations defaults and the QSO grid columns — sent and received, each with its status and date, hidden by default like the other extras-backed columns.",
+      "Removed the explanatory paragraph from the Confirmations page.",
+      "HAMLOG.online confirmations are read from the site's own ADIF field, APP_HAMLOG_QSO_CFM, taken from a real export. Import a log downloaded from HAMLOG and its confirmations count for awards straight away, with nothing to rename and no mapping to configure.",
+      "The four HAMLOG.online fields are filterable too, so 'never sent there' is a filter and not a guess.",
+      "RDA: a read-only comparison of the two district sources — the offline RDA database against the CNTY carried by a log imported from HAMLOG.online — reporting how many agree, how many differ, and listing the disagreements with the contact, both districts, and whether the database answer was a dated record or an assumption.",
+      "The QSO right-click menu can now export the selection to ADIF with the OpsLog fields, so the award references (RDA@KR-04 and the like) travel with the contacts. The existing entry still writes standard ADIF for other loggers.",
+      "The filtered-view export gets the same treatment: a second right-click entry writes the whole filtered view to ADIF with the OpsLog fields."
+    ],
+    "fr": [
+      "Yaesu : une ligne ANT dans le panneau du poste sélectionne la prise d'antenne, et le choix est mémorisé pour la bande sur laquelle il a été fait — on change de bande, l'antenne suit. Aucune page à configurer : choisir l'antenne une fois sur une bande le dit très bien. Les postes à une seule prise n'affichent jamais la ligne.",
+      "HAMLOG.online : les QSO peuvent être envoyés au fil de leur enregistrement, comme QRZ.com ou Club Log. La clé API se vérifie dans les réglages avant le premier contact — la réponse nomme le compte auquel elle appartient, donc une clé d'un autre indicatif ou expirée se voit tout de suite au lieu d'après une semaine de refus silencieux.",
+      "HAMLOG.online est aussi une source de confirmation pour les diplômes, aux côtés de LoTW, QSL, eQSL et QRZ.com — à cocher dans Confirmé, dans Validé, ou les deux.",
+      "Un poste dont le port série est refusé indique maintenant qui le détient vraisemblablement — OmniRig reste résident et garde le port de la radio configurée chez lui, que le backend natif n'obtient alors jamais. « Serial port busy » ne désignait personne.",
+      "Les couleurs de lignes dans Apparence peuvent aussi être limitées à HAMLOG.online, aux côtés du papier, de LoTW, d'eQSL et de QRZ.com.",
+      "HAMLOG.online figure aussi dans le gestionnaire QSL : on le choisit pour voir tous les QSO jamais envoyés là-bas et expédier l'arriéré d'un coup. Un contact déjà envoyé porte la date de son départ, donc un second passage ne le renvoie pas.",
+      "Le clic droit sur des QSO propose HAMLOG.online parmi les destinations d'envoi, et la notification nomme correctement chaque service au lieu d'afficher son identifiant interne.",
+      "L'édition en masse peut renseigner HAMLOG.online envoyé et reçu, chacun avec son statut et sa date — les mêmes quatre champs que les autres services. Un journal téléversé à la main sur leur site n'avait aucun moyen d'être marqué comme envoyé, et OpsLog proposait donc de renvoyer tous les contacts.",
+      "HAMLOG.online rejoint les valeurs par défaut des Confirmations et les colonnes de la grille des QSO — envoyé et reçu, chacun avec son statut et sa date, masquées par défaut comme les autres colonnes issues des extras.",
+      "Suppression du paragraphe explicatif de la page Confirmations.",
+      "Les confirmations HAMLOG.online sont lues dans le champ ADIF du site lui-même, APP_HAMLOG_QSO_CFM, relevé sur un export réel. Il suffit d'importer un journal téléchargé depuis HAMLOG pour que ses confirmations comptent aussitôt pour les diplômes, sans rien renommer ni configurer.",
+      "Les quatre champs HAMLOG.online sont aussi filtrables, pour que « jamais envoyé là-bas » soit un filtre et non une supposition.",
+      "RDA : une comparaison en lecture seule des deux sources de district — la base RDA hors ligne face au CNTY d'un journal importé depuis HAMLOG.online — indiquant combien concordent, combien divergent, et listant les désaccords avec le contact, les deux districts, et si la réponse de la base était un enregistrement daté ou une hypothèse.",
+      "Le menu contextuel des QSO peut maintenant exporter la sélection en ADIF avec les champs OpsLog, pour que les références de diplômes (RDA@KR-04 et compagnie) suivent les contacts. L'entrée existante écrit toujours de l'ADIF standard pour les autres carnets.",
+      "L'export de la vue filtrée reçoit le même traitement : une seconde entrée du menu contextuel écrit toute la vue filtrée en ADIF avec les champs OpsLog."
+    ]
+  },
+  {
+    "version": "0.26.7",
+    "date": "",
+    "en": [
+      "The NEW badge on a county now shows in the entry form itself, inside the field, and not only on the Info tab — it answers the question at the moment the operator is deciding whether to call.",
+      "OmniRig: a Yaesu is no longer sent OmniRig's SetSimplexMode when tuning. It is a no-op on some (an FT-891 never moved) and harmful on others — on an FT-2000 it turned split on and moved reception to VFO B, which is why OpsLog then showed B instead of A. The direct frequency write, which is what tunes these rigs, is unchanged.",
+      "The basemap buttons on the main map are shifted clear of the zoom controls — Light sat a few pixels from the minus button and was being clicked by mistake.",
+      "Cluster, French interface: the WKD CALL status now reads DÉJÀ QSO instead of DÉJÀ CTC.",
+      "Icom over LAN: the receive audio streamed by the rig now feeds the QSO recorder as well as the speakers. On a network connection Windows sees no radio sound card at all — the audio settings could only offer the PC microphone — so the stream is pushed straight into the recorder, with no virtual cable to set up."
+    ],
+    "fr": [
+      "Le badge NOUV du comté s'affiche maintenant dans le formulaire de saisie lui-même, à l'intérieur du champ, et plus seulement dans l'onglet Info — il répond au moment où l'opérateur décide d'appeler ou non.",
+      "OmniRig : le SetSimplexMode d'OmniRig n'est plus envoyé aux Yaesu lors d'un changement de fréquence. Il est sans effet sur certains (un FT-891 ne bougeait pas) et nuisible sur d'autres — sur un FT-2000 il activait le split et faisait passer la réception sur le VFO B, d'où l'affichage du B au lieu du A. L'écriture directe de la fréquence, qui est ce qui accorde réellement ces postes, ne change pas.",
+      "Les boutons de fond de carte sont décalés à l'écart des commandes de zoom — Light était à quelques pixels du bouton moins et se faisait cliquer par erreur.",
+      "Cluster, interface française : le statut « DÉJÀ CTC » devient « DÉJÀ QSO ».",
+      "Icom en réseau : l'audio reçu diffusé par le poste alimente maintenant l'enregistreur de QSO en plus des haut-parleurs. Sur une liaison réseau, Windows ne voit aucune carte son de la radio — les réglages audio ne proposaient que le micro du PC — donc le flux est injecté directement dans l'enregistreur, sans câble virtuel à installer."
+    ]
+  },
+  {
+    "version": "0.26.6",
+    "date": "",
+    "en": [
+      "FT decodes: the continent filter is now a multiple choice — click AF, AS, OC and SA to keep those four. It still lists only the continents actually being decoded, plus any you have selected, so a filter can never strand itself with no chip left to switch it off.",
+      "A QSO logged by WSJT-X, JTDX or MSHV now raises a notice in the corner naming the station. Watching the decodes, nothing else on screen said it had happened: the entry form never cleared, because nobody typed in it.",
+      "Icom CI-V: a reply the rig sent to another controller on the same bus is no longer mistaken for ours, and a PTT command whose acknowledgement goes missing is verified by reading the rig instead of being reported as a failure. WSJT-X and JTDX answer a failed set_ptt with a Rig Control Error and drop the link mid-over, which is what an IC-7850 was doing three times a session. The check itself waits 700 ms rather than the poll's 150: the rig has just failed to answer twice, usually because it is retuning — JTDX moves the transmit frequency and keys in the same breath — and a short probe would fail for the same reason. Both outcomes are logged, so a failure that remains can be told from a fix that did not fire.",
+      "FlexRadio: each spot status can now be kept off the panadapter entirely, with a switch beside its colours — and WSJT-X decode spots obey the same switches and the same colours. The palette governs the panadapter, not just one of the two things that feed it: statuses switched off still piled up on the waterfall because the decodes were pushed by another path.",
+      "Panadapter spot comments now read like DXHunter's: the cluster text, then the spotter, the entity and the status — \"CQ up 2 [F4BPO] [Franz Josef Land] [New Slot]\". The words were running together because SmartSDR splits its command line on spaces; non-breaking spaces get them through.",
+      "\"Already worked\" on a panadapter spot now means the CALLSIGN is in the log, not the entity. An entity worked on that band and mode is no news, and saying \"already worked\" of a station never contacted was wrong.",
+      "FT decodes: a compound MSHV message that answers two stations in one line — \"DM8BJF RR73; F4BPO <RI1FJL> +14\" — is now recognised as addressed to you when your callsign is in the second half.",
+      "Edit QSO: your own transmit power can be edited at last — the field was saved and written back but had no box, so a contact logged at the wrong power could never be corrected. The contacted station's extended locator gained a box for the same reason, and the power labels now say WHOSE power they are.",
+      "FlexRadio: a spot is no longer removed and redrawn when nothing about it has changed. A busy skimmer feed re-spots the same station every few seconds — one two-minute session sent 2128 spot adds, 88 of them for a single callsign — and the panadapter did not move a pixel for any of them.",
+      "Panadapter spot comments are kept within what the radio will accept: SmartSDR was cutting the longest ones mid-word, losing the entity and the status. The cluster's own words are trimmed first, the spotter, entity and status always survive. The column padding of an RBN line is collapsed to single spaces too — kept as non-breaking spaces it opened a gap wide enough to push the rest of the comment off the screen.",
+      "Auto-call is withdrawn — it duplicated DXHunter, which already answers decodes. Clicking a decode to answer it is unchanged.",
+      "The elastic bounce at the end of a list is gone, and a two-finger horizontal swipe no longer navigates the window away from the app. Both are browser behaviours that only appear on a touchpad or a touchscreen.",
+      "The interface zoom now says what it is doing: a badge shows the factor while it changes, clicking it returns to 100%, and View → Zoom in / Zoom out / Actual size makes it findable. Ctrl+wheel and Ctrl+0 always worked, but nothing announced them — zoom by accident and there was no way back.",
+      "Icom CI-V: a frequency or mode change whose acknowledgement goes missing is now verified by reading the rig back, like the PTT already was. All three are commands WSJT-X and JTDX answer with a Rig Control Error and a dropped link, and an IC-7850 log shows a set_freq doing exactly that.",
+      "The log file now rotates while OpsLog is running, not only at startup. It was bounded on the belief that a session writes a few kilobytes; with the CI-V wire trace left on, one wrote 416 MB and nothing would have stopped it before the disk did."
+    ],
+    "fr": [
+      "Décodes FT : le filtre par continent est maintenant multiple — clique AF, AS, OC et SA pour garder ces quatre-là. Il ne liste toujours que les continents réellement décodés, plus ceux que tu as sélectionnés, pour qu'un filtre ne puisse pas se bloquer sans pastille pour le désactiver.",
+      "Un QSO enregistré par WSJT-X, JTDX ou MSHV affiche maintenant une notification dans le coin, avec le nom de la station. En regardant les décodes, rien d'autre à l'écran ne le signalait : le formulaire ne se vidait pas, puisque personne n'y avait tapé.",
+      "Icom CI-V : une réponse que la radio adresse à un autre contrôleur du même bus n'est plus prise pour la nôtre, et un ordre de PTT dont l'accusé de réception se perd est vérifié en interrogeant la radio au lieu d'être déclaré en échec. WSJT-X et JTDX répondent à un set_ptt en échec par une erreur de contrôle radio et coupent la liaison en pleine émission — ce que faisait un IC-7850 trois fois par session. La vérification attend 700 ms et non les 150 de la scrutation : la radio vient d'échouer deux fois, en général parce qu'elle se réaccorde — JTDX décale la fréquence d'émission et passe en émission dans la foulée — et une interrogation brève échouerait pour la même raison. Les deux issues sont journalisées, pour distinguer un échec réel d'un correctif qui n'a pas agi.",
+      "FlexRadio : chaque statut de spot peut désormais être totalement exclu du panadapter, par un interrupteur à côté de ses couleurs — et les spots issus des décodes WSJT-X obéissent aux mêmes interrupteurs et aux mêmes couleurs. La palette régit le panadapter, pas seulement l'une des deux sources qui l'alimentent : les statuts décochés continuaient de s'entasser sur la cascade parce que les décodes passaient par un autre chemin.",
+      "Les commentaires des spots du panadapter se lisent maintenant comme ceux de DXHunter : le texte du cluster, puis le spotteur, l'entité et le statut — « CQ up 2 [F4BPO] [Franz Josef Land] [New Slot] ». Les mots se collaient parce que SmartSDR découpe sa ligne de commande sur les espaces ; des espaces insécables les font passer.",
+      "« Déjà contacté » sur un spot du panadapter désigne désormais l'INDICATIF présent dans le journal, et non l'entité. Une entité déjà faite sur cette bande et ce mode n'est pas une nouvelle, et annoncer « déjà contacté » pour une station jamais travaillée était faux.",
+      "Décodes FT : un message composé MSHV qui répond à deux stations sur une seule ligne — « DM8BJF RR73; F4BPO <RI1FJL> +14 » — est maintenant reconnu comme vous étant adressé quand votre indicatif est dans la seconde moitié.",
+      "Édition de QSO : sa propre puissance d'émission est enfin modifiable — le champ était enregistré et réécrit mais n'avait aucune case, donc un contact loggé à la mauvaise puissance ne pouvait pas être corrigé. Le locator étendu du correspondant gagne une case pour la même raison, et les libellés de puissance disent maintenant à QUI elle appartient.",
+      "FlexRadio : un spot n'est plus supprimé puis redessiné quand rien n'a changé. Un flux de skimmers actif re-spotte la même station toutes les quelques secondes — une session de deux minutes envoyait 2128 ajouts, dont 88 pour un seul indicatif — sans que le panadapter bouge d'un pixel.",
+      "Les commentaires des spots du panadapter tiennent maintenant dans ce que la radio accepte : SmartSDR coupait les plus longs en plein mot, perdant l'entité et le statut. Le texte du cluster est rogné en premier, le spotteur, l'entité et le statut survivent toujours. L'alignement en colonnes des lignes RBN est aussi ramené à une seule espace : conservé en espaces insécables, il ouvrait un trou assez large pour repousser le reste du commentaire hors de l'écran.",
+      "L'appel automatique est retiré — il faisait doublon avec DXHunter, qui répond déjà aux décodages. Cliquer un décodage pour répondre ne change pas.",
+      "Le rebond élastique en fin de liste a disparu, et un balayage horizontal à deux doigts ne fait plus quitter l'application. Deux comportements de navigateur qui n'apparaissent qu'au pavé tactile ou sur écran tactile.",
+      "Le zoom de l'interface s'annonce enfin : une pastille affiche le facteur pendant qu'il change, un clic dessus revient à 100 %, et le menu Affichage → Zoom avant / Zoom arrière / Taille réelle le rend trouvable. Ctrl+molette et Ctrl+0 fonctionnaient déjà, mais rien ne le disait — un zoom involontaire et on ne savait plus revenir.",
+      "Icom CI-V : un changement de fréquence ou de mode dont l'accusé de réception se perd est désormais vérifié en interrogeant la radio, comme l'était déjà le PTT. Les trois sont des ordres auxquels WSJT-X et JTDX répondent par une erreur de contrôle radio et une liaison coupée, et un log d'IC-7850 montre un set_freq faire précisément cela.",
+      "Le fichier de log tourne maintenant en cours d'exécution, et plus seulement au démarrage. Sa limite reposait sur l'idée qu'une session écrit quelques kilo-octets ; avec la trace CI-V laissée active, l'une d'elles a écrit 416 Mo sans que rien ne l'arrête avant le disque."
+    ]
+  },
+  {
+    "version": "0.26.5",
+    "date": "",
+    "en": [
+      "Fixed the record button going missing after an update, until the audio settings were opened and saved. Whether a manual recording is possible depends on a per-profile setting, and the question was asked once at startup — before the profile was known on a launch that had more work to do.",
+      "Switching profile is quicker on a shared MySQL logbook: the one-off cleanup of unused settings tables is now recorded as done instead of being re-checked on every connection.",
+      "A profile switch now logs how long it took, and any device slower than half a second names itself — a switch that feels sluggish can be diagnosed from the log file.",
+      "Saving an alert rule or a filter preset now says so, with the name, for a few seconds. Both used to save in silence, leaving the dialog looking exactly as it did before the click.",
+      "Awards: the callsigns listed behind an award cell are now links. Clicking one opens the QSL Manager on Paper QSL with that station searched, ready for the card sent/received dates — chasing a missing confirmation no longer means retyping the callsign into another tab.",
+      "Motorised antennas over serial: the line format is now stated explicitly as 8N1, the baud list covers 1200 to 115200, and the first exchange after each connect is dumped to the log — which separates a silent controller from a wrong baud rate from a frame we misread.",
+      "Fixed a motorised antenna on a serial port failing with \"Serial port busy\" for ever. OpsLog was holding the port itself: stopping a client did not wait for its poll loop to leave, and the new client was started while the old one still owned the COM port — every settings save added another loop to the fight.",
+      "A serial antenna controller whose port is held by another program now says so by name in the log, instead of repeating \"Serial port busy\" — a COM port has one owner, usually the manufacturer control window left open.",
+      "Fixed \"Test connection\" on a serial motorised antenna taking the COM port away from the running antenna. A port has one owner, so the test now reports the live link's own status instead of opening a second connection to it.",
+      "A serial antenna controller that never answers now fails after four seconds with \"nothing came back\", instead of freezing the poll loop for minutes with nothing in the log. A silent serial port returns no bytes AND no error, and the buffered reader retried that a hundred times before giving up.",
+      "Ultrabeam over USB now works. The cable presents TWO COM ports and only the second reaches the controller, at 19200 baud — so the speed is now fixed at 19200 and the port field says which one to pick. Stopping a client no longer waits out the read timeout either, so changing port takes effect at once instead of leaving the old one held."
+    ],
+    "fr": [
+      "Correction du bouton d'enregistrement disparu après une mise à jour, jusqu'à ce qu'on ouvre et enregistre les réglages audio. La possibilité d'enregistrer dépend d'un réglage par profil, et la question n'était posée qu'une fois au démarrage — avant que le profil soit connu, sur un lancement qui avait plus de travail à faire.",
+      "Le changement de profil est plus rapide sur un journal MySQL partagé : le nettoyage ponctuel des tables de réglages inutilisées est désormais marqué comme fait, au lieu d'être revérifié à chaque connexion.",
+      "Un changement de profil enregistre maintenant sa durée dans le journal, et tout appareil dépassant la demi-seconde se nomme — un changement qui traîne peut donc être diagnostiqué depuis le fichier de log.",
+      "L'enregistrement d'une règle d'alerte ou d'un filtre affiche maintenant une confirmation avec son nom, quelques secondes. Les deux enregistraient en silence, la fenêtre restant identique à ce qu'elle était avant le clic.",
+      "Diplômes : les indicatifs listés derrière une case sont désormais cliquables. Un clic ouvre le gestionnaire QSL sur QSL papier avec la station déjà recherchée, prête pour les dates d'envoi et de réception — relancer une confirmation manquante ne demande plus de retaper l'indicatif dans un autre onglet.",
+      "Antennes motorisées en série : le format de ligne est désormais fixé explicitement en 8N1, la liste des vitesses va de 1200 à 115200, et le premier échange après chaque connexion est écrit dans le log — ce qui distingue un contrôleur muet d'une mauvaise vitesse et d'une trame mal relue.",
+      "Correction d'une antenne motorisée en série qui échouait indéfiniment sur « Serial port busy ». OpsLog occupait le port lui-même : l'arrêt d'un client n'attendait pas la sortie de sa boucle de scrutation, et le nouveau client démarrait alors que l'ancien détenait encore le port COM — chaque enregistrement des réglages ajoutait une boucle à la mêlée.",
+      "Un contrôleur d'antenne en série dont le port est occupé par un autre programme le dit maintenant explicitement dans le log, au lieu de répéter « Serial port busy » — un port COM n'a qu'un propriétaire, le plus souvent la fenêtre de contrôle du fabricant restée ouverte.",
+      "Correction du « Test de connexion » d'une antenne motorisée en série qui prenait le port COM à l'antenne en service. Un port n'a qu'un propriétaire : le test rapporte désormais l'état du lien en cours au lieu d'ouvrir une seconde connexion dessus.",
+      "Un contrôleur d'antenne en série qui ne répond jamais échoue maintenant en quatre secondes sur « rien n'est revenu », au lieu de figer la boucle de scrutation pendant des minutes sans rien écrire dans le log. Un port série muet ne renvoie ni octet ni erreur, et le lecteur tamponné réessayait cent fois avant d'abandonner.",
+      "Ultrabeam en USB fonctionne. Le câble présente DEUX ports COM et seul le second atteint le contrôleur, à 19200 bauds — la vitesse est donc fixée à 19200 et le champ du port indique lequel choisir. L'arrêt d'un client n'attend plus la fin du délai de lecture, donc un changement de port prend effet immédiatement au lieu de laisser l'ancien occupé."
+    ]
+  },
+  {
+    "version": "0.26.4",
+    "date": "",
+    "en": [
+      "Clicking a spot on the radio panadapter now carries its POTA park into the Awards tab, like a click in OpsLog does.",
+      "Ultrabeam over serial: the COM port field now has a chevron that opens the list of detected ports. It was a combo box that only opened on a keystroke, so it looked like a plain text box.",
+      "The logbook database now contains only the contacts. Settings, station profiles, award reference lists and the lookup cache were being created in every database, including a shared MySQL logbook, which made the two look interchangeable; the unused tables are dropped on the next start, and any that hold data are left alone.",
+      "And the mirror image: the settings database drops its own unused, empty qso table once the contacts have a database of their own. It is rebuilt automatically if that database is ever pressed into service as the logbook again.",
+      "Settings → Database: a Compact button on each database. SQLite frees deleted pages inside the file and never shrinks it, so this is what gives the disk space back; the result shows the size before and after. A shared MySQL logbook has the button too, running OPTIMIZE TABLE instead."
+    ],
+    "fr": [
+      "Cliquer un spot sur le panadapter de la radio reporte maintenant son parc POTA dans l’onglet Diplômes, comme un clic dans OpsLog.",
+      "Ultrabeam en série : le champ du port COM a maintenant un chevron qui ouvre la liste des ports détectés. C'était une liste déroulante qui ne s'ouvrait qu'en tapant, donc indiscernable d'un simple champ texte.",
+      "La base du journal ne contient plus que les contacts. Les réglages, profils station, listes de références et le cache de recherche étaient créés dans toutes les bases, y compris un MySQL partagé, ce qui laissait croire que les deux étaient interchangeables ; les tables inutilisées sont supprimées au prochain démarrage, et celles qui contiennent des données sont laissées telles quelles.",
+      "Et l'inverse : la base de réglages supprime sa propre table qso, vide et inutilisée, dès lors que les contacts ont leur base à eux. Elle est reconstruite automatiquement si cette base doit à nouveau servir de journal.",
+      "Réglages → Base de données : un bouton Compacter sur chaque base. SQLite libère les pages supprimées à l'intérieur du fichier sans jamais le réduire ; c'est donc ce qui rend l'espace disque, et le résultat affiche la taille avant et après. Un journal MySQL partagé a aussi le bouton, avec un OPTIMIZE TABLE à la place."
+    ]
+  },
   {
     "version": "0.26.3",
     "date": "",

compact.go

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

flexrstchase.go

@@ -0,0 +1,187 @@
+package main
+
+// Chasing a split pile-up by the report the DX just sent.
+//
+// Working a DXpedition in split means guessing where it is listening. The DX
+// answers one station, sends "5NN", and moves on; the useful information is
+// therefore not the callsign it answered but the FREQUENCY that callsign was
+// transmitting on, because the DX's receiver was there a second ago.
+//
+// A CW skimmer already knows this. SDC (Software Defined Connector) decodes the
+// whole pile-up and marks each report on the panadapter as a spot — the marker
+// TEXT is configured in SDC by the operator ("599" for a fresh report, "X" for
+// an older one, by default). Those spots reach OpsLog already: it subscribes to
+// the radio's spot feed, and every spot another program posts arrives on
+// Flex.OnForeignSpot.
+//
+// So the whole feature is: recognise the marker, move the TRANSMIT slice there,
+// leave the receive slice on the DX. Nothing here decodes anything.
+//
+// Three deliberate choices:
+//
+//   - the marker text is a SETTING, not a constant. It is chosen in SDC, and
+//     any guess made here would be wrong for the operator who chose otherwise.
+//   - only the transmit slice moves, never the receive slice. Losing the DX is
+//     a worse outcome than a missed call.
+//   - the offset is signed and in Hz, because working "up a bit" from where the
+//     last station was answered is exactly how a pile-up is chased.
+
+import (
+	"encoding/json"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"hamlog/internal/applog"
+	"hamlog/internal/cat"
+)
+
+const keyFlexRSTChase = "flex.rst_chase"
+
+// FlexRSTChase is the whole configuration.
+type FlexRSTChase struct {
+	Enabled bool `json:"enabled"`
+	// Markers are the skimmer's marker texts, comma-separated ("599,5NN").
+	// Matched against the spot's callsign field, case-insensitively and whole:
+	// a spot IS the marker or it is an ordinary callsign, and a substring rule
+	// would drag in any station whose call happens to contain the digits.
+	Markers string `json:"markers"`
+	// OffsetHz is added to the marker's frequency. Signed: chasing upward from
+	// the last station worked is the usual tactic, downward happens too.
+	OffsetHz int `json:"offset_hz"`
+	// SplitOnly refuses to act when the radio is not in split. On by default:
+	// out of split the transmit slice IS the receive slice, so "move the TX
+	// slice" would take the operator off the DX they are listening to.
+	SplitOnly bool `json:"split_only"`
+}
+
+var defaultFlexRSTChase = FlexRSTChase{Enabled: false, Markers: "599", OffsetHz: 0, SplitOnly: true}
+
+// rstChaseMinGap throttles the moves. A skimmer marks every report it decodes,
+// and a busy pile-up produces several a second; without a floor the transmit
+// slice would twitch continuously and never be anywhere long enough to call.
+const rstChaseMinGap = 700 * time.Millisecond
+
+// rstChaseMinStep ignores a marker that lands where the slice already is.
+// Re-sending the same frequency is not free: it is a command to the radio and a
+// slice status back, several times a second, for no change at all.
+const rstChaseMinStep = 20 // Hz
+
+var (
+	rstChaseMu   sync.Mutex
+	rstChaseLast time.Time
+	rstChaseFreq int64
+)
+
+// GetFlexRSTChase returns the stored configuration (defaults when unset).
+func (a *App) GetFlexRSTChase() FlexRSTChase {
+	s := defaultFlexRSTChase
+	if a.settings == nil {
+		return s
+	}
+	// settingOr, NOT settings.Get with profileScope(): the store already applies
+	// the active profile's prefix, so scoping the key here wrote p3.flex.rst_chase
+	// and read p3.p3.flex.rst_chase — the switch could never be read back on, and
+	// the feature did nothing at all with no sign of why.
+	if v := a.settingOr(keyFlexRSTChase, ""); strings.TrimSpace(v) != "" {
+		_ = json.Unmarshal([]byte(v), &s)
+	}
+	return normRSTChase(s)
+}
+
+// SaveFlexRSTChase stores the configuration.
+func (a *App) SaveFlexRSTChase(s FlexRSTChase) error {
+	b, err := json.Marshal(normRSTChase(s))
+	if err != nil {
+		return err
+	}
+	a.setSetting(keyFlexRSTChase, string(b))
+	return nil
+}
+
+// SetFlexRSTChaseEnabled flips the switch alone.
+//
+// Its own binding because this belongs on a button in the panel, not in a
+// settings page: it is turned on when a DXpedition appears and off when it is
+// worked, which is a thing done mid-QSO with one hand.
+func (a *App) SetFlexRSTChaseEnabled(on bool) error {
+	s := a.GetFlexRSTChase()
+	s.Enabled = on
+	return a.SaveFlexRSTChase(s)
+}
+
+func normRSTChase(s FlexRSTChase) FlexRSTChase {
+	if strings.TrimSpace(s.Markers) == "" {
+		s.Markers = defaultFlexRSTChase.Markers
+	}
+	// A pile-up is a few kHz wide. Anything past that is a typo (Hz entered as
+	// if it were kHz), and honouring it would transmit far outside the segment.
+	if s.OffsetHz > 10000 {
+		s.OffsetHz = 10000
+	}
+	if s.OffsetHz < -10000 {
+		s.OffsetHz = -10000
+	}
+	return s
+}
+
+// rstChaseMarkerSet splits the configured markers into a comparison set.
+func rstChaseMarkerSet(markers string) map[string]bool {
+	out := map[string]bool{}
+	for _, m := range strings.FieldsFunc(markers, func(r rune) bool { return r == ',' || r == ';' || r == ' ' }) {
+		if m = strings.ToUpper(strings.TrimSpace(m)); m != "" {
+			out[m] = true
+		}
+	}
+	return out
+}
+
+// handleForeignSpot is what a skimmer's spot arrives at.
+func (a *App) handleForeignSpot(callsign string, freqHz int64) {
+	cfg := a.GetFlexRSTChase()
+	if !cfg.Enabled || a.cat == nil {
+		return
+	}
+	if !rstChaseMarkerSet(cfg.Markers)[strings.ToUpper(strings.TrimSpace(callsign))] {
+		return // an ordinary spot: another station's callsign, not a report
+	}
+	// From here on every refusal is logged. A marker WAS recognised, so the
+	// operator is entitled to know why the slice stayed where it was — silence
+	// at this point is indistinguishable from a feature that does not work.
+	if cfg.SplitOnly && !a.cat.State().Split {
+		applog.Printf("rst chase: %s marked at %s, but the radio is not in split — ignored",
+			strings.ToUpper(callsign), hzText(freqHz))
+		return
+	}
+	target := freqHz + int64(cfg.OffsetHz)
+	if target <= 0 {
+		return
+	}
+	now := time.Now()
+	rstChaseMu.Lock()
+	if now.Sub(rstChaseLast) < rstChaseMinGap {
+		rstChaseMu.Unlock()
+		return
+	}
+	if rstChaseFreq != 0 && absInt64(target-rstChaseFreq) < rstChaseMinStep {
+		rstChaseMu.Unlock()
+		return
+	}
+	rstChaseLast, rstChaseFreq = now, target
+	rstChaseMu.Unlock()
+
+	if err := a.cat.FlexDo(func(fc cat.FlexController) error {
+		return fc.SetTXSliceFrequency(target)
+	}); err != nil {
+		applog.Printf("rst chase: moving the TX slice to %s failed: %v", hzText(target), err)
+		return
+	}
+	applog.Printf("rst chase: %s marked at %s → TX slice to %s (offset %+d Hz)",
+		strings.ToUpper(callsign), hzText(freqHz), hzText(target), cfg.OffsetHz)
+}
+
+// hzText renders a frequency the way an operator reads one on a dial.
+func hzText(hz int64) string {
+	return strconv.FormatFloat(float64(hz)/1000, 'f', 3, 64) + " kHz"
+}

frontend/src/App.tsx

@@ -18,7 +18,7 @@ import {
   WorkedBefore,
   SetCompactMode, SetCompactHeight,
   RotatorGoToPath,
-  GetCATState, SetCATFrequency, SetCATMode, SwitchCATRig, EntryBandChanged, FlexApplyBandAntenna, FlexApplyBandPower,
+  GetCATState, SetCATFrequency, SetCATMode, SwitchCATRig, EntryBandChanged, FlexApplyBandAntenna, FlexApplyBandPower, YaesuApplyBandAntenna,
   GetSecretStatus, UnlockSecrets,
   RotatorGoTo, RotatorStop, SetActiveRotor,
   GetDBConnectionInfo, GetLogbookRevision,
@@ -891,6 +891,13 @@ export default function App() {
     QSOAudioPlayOnAir().catch((e: any) => setError(String(e?.message ?? e)));
   };
   const refreshManualRecReady = () => { QSOAudioManualReady().then(setManualRecReady).catch(() => {}); };
+  // Asked at mount, and asked AGAIN once the backend is really up (see the
+  // initial grid load) and on every profile change. The audio devices are a
+  // per-profile setting, so this question cannot be answered before the active
+  // profile is known — and a "no" then was final, which is why the record button
+  // went missing for a whole session after an update, when startup does more
+  // work and the first ask loses the race. Opening and closing the audio panel
+  // was the only way back.
   useEffect(() => { refreshManualRecReady(); }, []);
   const startManualRecording = () => {
     QSOAudioManualStart().then((active) => {
@@ -1104,6 +1111,17 @@ export default function App() {
   };
   // QSL Manager is a closable tab opened on demand from Tools → QSL Manager.
   const [qslTabOpen, setQslTabOpen] = useState(false);
+  // A callsign sent to the QSL Manager's Paper QSL view from elsewhere (the
+  // awards grid). The counter makes two clicks on the same callsign two
+  // requests — the panel is force-mounted and would otherwise see no change.
+  const [qslPaperReq, setQslPaperReq] = useState<{ call: string; n: number } | undefined>(undefined);
+  function openPaperQSLFor(call: string) {
+    const c = call.trim().toUpperCase();
+    if (!c) return;
+    setQslTabOpen(true);
+    setActiveTab('qsl');
+    setQslPaperReq((r) => ({ call: c, n: (r?.n ?? 0) + 1 }));
+  }
   const [qslDesignerOpen, setQslDesignerOpen] = useState(false);
   const [eqslQsoId, setEqslQsoId] = useState<number | null>(null); // QSO being sent as eQSL
   function closeQslTab() {
@@ -1266,11 +1284,22 @@ export default function App() {
   // by z, so it reflows to fill that larger box and then scales back to exactly the
   // window (more content visible when zoomed out, like a real browser zoom).
   const appRootRef = useRef<HTMLDivElement>(null);
+  // The current factor, shown briefly whenever it changes.
+  //
+  // Ctrl+wheel and Ctrl+0 have worked from the start, and NOTHING said so:
+  // no menu entry, no readout. An operator who zoomed by accident — easy, the
+  // wheel is over a grid and Ctrl is already down for something else — saw the
+  // interface change size with no explanation and no way back. The number is
+  // the fix; the menu entry makes it findable without reading a manual.
+  const [uiZoom, setUiZoom] = useState(1);
+  const [zoomShown, setZoomShown] = useState(false);
+  const zoomHideRef = useRef(0);
+  const setZoomRef = useRef<(z: number) => void>(() => {});
   useEffect(() => {
     const KEY = 'opslog.uiZoom';
     let z = parseFloat(localStorage.getItem(KEY) || '1');
     if (!Number.isFinite(z) || z <= 0) z = 1;
-    const apply = () => {
+    const apply = (announce = false) => {
       const el = appRootRef.current;
       if (!el) return;
       el.style.transformOrigin = '0 0';
@@ -1278,17 +1307,36 @@ export default function App() {
       el.style.width = `${100 / z}vw`;
       el.style.height = `${100 / z}vh`;
       document.documentElement.setAttribute('data-uizoom', String(z));
+      setUiZoom(z);
+      // Only on a CHANGE: showing it at startup would put a badge over the log
+      // every launch, for a number that is almost always 100 %.
+      if (announce) {
+        setZoomShown(true);
+        window.clearTimeout(zoomHideRef.current);
+        zoomHideRef.current = window.setTimeout(() => setZoomShown(false), 1600);
+      }
     };
     apply();
+    // The menu and the badge set the factor through here, so there is one
+    // implementation of "zoom to z" and not three.
+    setZoomRef.current = (next: number) => {
+      z = Math.min(2.5, Math.max(0.5, Math.round(next * 10) / 10));
+      localStorage.setItem(KEY, String(z));
+      apply(true);
+    };
     const onWheel = (e: WheelEvent) => {
       if (!e.ctrlKey && !e.metaKey) return; // plain wheel is left alone (scroll / freq nudge)
       e.preventDefault();
       z = Math.min(2.5, Math.max(0.5, Math.round((z + (e.deltaY < 0 ? 0.1 : -0.1)) * 10) / 10));
       localStorage.setItem(KEY, String(z));
-      apply();
+      apply(true);
     };
     const onKey = (e: KeyboardEvent) => {
-      if ((e.ctrlKey || e.metaKey) && (e.key === '0')) { e.preventDefault(); z = 1; localStorage.setItem(KEY, '1'); apply(); }
+      if ((e.ctrlKey || e.metaKey) && (e.key === '0')) { e.preventDefault(); z = 1; localStorage.setItem(KEY, '1'); apply(true); }
+      // Ctrl+plus / Ctrl+minus, the shortcuts every other application uses.
+      // '=' as well as '+': on most layouts the plus is the shifted '='.
+      if ((e.ctrlKey || e.metaKey) && (e.key === '+' || e.key === '=')) { e.preventDefault(); setZoomRef.current(z + 0.1); }
+      if ((e.ctrlKey || e.metaKey) && (e.key === '-')) { e.preventDefault(); setZoomRef.current(z - 0.1); }
     };
     window.addEventListener('wheel', onWheel, { passive: false });
     window.addEventListener('keydown', onKey);
@@ -2256,6 +2304,9 @@ export default function App() {
   const [clusterMacros, setClusterMacros] = useState(loadClusterMacros);
   useEffect(() => { if (!showSettings) setClusterMacros(loadClusterMacros()); }, [showSettings]);
   const clusterMacrosShown = useMemo(() => visibleClusterMacros(clusterMacros), [clusterMacros]);
+  // Auto-call is withdrawn — it duplicated DXHunter, which answers decodes from
+  // the same shack. This flag is the single place that says so at runtime.
+  const AUTO_CALL_ENABLED = false;
   const [autoCall, setAutoCall] = useState<AutoCallSettings>(loadAutoCall);
   useEffect(() => { if (!showSettings) setAutoCall(loadAutoCall()); }, [showSettings]);
   // When each callsign was last answered, so a station still calling CQ is not
@@ -2288,6 +2339,15 @@ export default function App() {
   // backstop below.
   const lastTxAtRef = useRef<Map<string, number>>(new Map());
   useEffect(() => {
+    // AUTO-CALL IS WITHDRAWN — DXHunter already answers decodes, and two
+    // programs doing it from one shack key over each other. See lib/autocall.ts.
+    //
+    // Returning here rather than deleting the loop: the decision it implements
+    // is the delicate part, argued over and tested, and worth keeping intact.
+    // The guard is what matters — an operator whose stored preference still
+    // says "enabled" must not have their transmitter keyed by a feature they
+    // can no longer see, let alone switch off.
+    if (!AUTO_CALL_ENABLED) return;
     if (!autoCall.enabled) return;
     const now = Date.now();
     // A QSO is in progress somewhere if ANY receiver is transmitting or still
@@ -2645,8 +2705,17 @@ export default function App() {
   // Backend-emitted toast messages (e.g. recording auto-send result/skip).
   useEffect(() => {
     const off = EventsOn('toast', (msg: any) => { if (msg) showToast(String(msg)); });
-    return () => { off(); };
-  }, [showToast]);
+    // A QSO logged by an external app announces itself: nothing else on screen
+    // says it happened when the operator is watching the decodes rather than the
+    // entry form.
+    const offExt = EventsOn('qso:logged_external', (p: any) => {
+      const call = String(p?.call ?? '').trim();
+      if (!call) return;
+      const bits = [p?.band, p?.mode].filter(Boolean).join(' · ');
+      showToast(`✅ ${t('toast.qsoLogged')} — ${call}${bits ? ` · ${bits}` : ''}`);
+    });
+    return () => { off(); offExt(); };
+  }, [showToast, t]);
 
   // Band openings — sporadic E on 6/4/2 m, detected from the spot stream.
   //
@@ -3087,6 +3156,7 @@ export default function App() {
         // Same race, same fix: the toolbar options were read once at mount,
         // possibly before the profile was active, and a "no" then was final.
         refreshChaseNew();
+        refreshManualRecReady();
       } else if (!ok && alive && tries++ < 360) {
         // Quick retries at first (normal startup connects in ~2 s); then keep
         // trying for several minutes, because the very first migration against a
@@ -3227,11 +3297,16 @@ export default function App() {
   // backends. The backend no-ops if the band has no configured mapping.
   const lastAntBandRef = useRef('');
   useEffect(() => {
-    if (catState.backend !== 'flex' || locks.band) return;
+    if (locks.band) return;
     const b = band.trim();
     if (!b || b === lastAntBandRef.current) return;
     lastAntBandRef.current = b;
-    FlexApplyBandAntenna(b).catch(() => {});
+    // Flex configures its antennas per band in Preferences; a Yaesu LEARNS
+    // them — the antenna picked on a band is remembered for that band. Two
+    // ways to say the same thing, and each backend keeps the one that suits
+    // it: a Flex names its antennas, a Yaesu has two sockets and a knob.
+    if (catState.backend === 'flex') FlexApplyBandAntenna(b).catch(() => {});
+    if (catState.backend === 'yaesu') YaesuApplyBandAntenna(b).catch(() => {});
   }, [band, catState.backend, locks.band]);
 
   // Per-band, per-mode TX power. Applied on band AND mode changes — the point is
@@ -3515,12 +3590,18 @@ export default function App() {
     // An explicit click always wins over whatever call is currently in the field.
     const unsubFlexSpot = EventsOn('flex:spot_clicked', (p: any) => {
       const call = String(p?.call ?? '');
-      if (applyUdpCall(call, true)) restartRecordingForNewTarget(call);
+      if (!applyUdpCall(call, true)) return;
+      restartRecordingForNewTarget(call);
+      // The park, like a click in the band map: the radio reports only a
+      // callsign, so the backend looks it up again before sending the event.
+      applySpotPOTA(String(p?.pota_ref ?? ''));
     });
     // Clicking a spot on the ExpertSDR (TCI) panorama fills the call, like Flex.
     const unsubTciSpot = EventsOn('tci:spot_clicked', (p: any) => {
       const call = String(p?.call ?? '');
-      if (applyUdpCall(call, true)) restartRecordingForNewTarget(call);
+      if (!applyUdpCall(call, true)) return;
+      restartRecordingForNewTarget(call);
+      applySpotPOTA(String(p?.pota_ref ?? ''));
     });
     const unsubBulk = EventsOn('bulkupdate:progress', (p: any) => {
       const total = Number(p?.total ?? 0);
@@ -3635,6 +3716,8 @@ export default function App() {
       setGridPrefsProfile(id ?? null);
       setActiveProfileId(typeof id === 'number' ? id : null);
       loadStation(); loadLists(); loadCATCfg(); reloadWk(); loadMainPanes(); loadProfileList();
+      // The sound devices are per profile: one may record and the next not.
+      refreshManualRecReady();
       // The chat is per shared logbook — clear the previous profile's messages
       // and reload for the new logbook (or hide if it isn't a MySQL log).
       setChatMsgs([]); chatSeen.current.clear(); setChatOnline([]); setChatUnread(0);
@@ -4120,7 +4203,13 @@ export default function App() {
   // background; qslmgr:done refreshes the grid when finished.
   async function bulkSendTo(service: string, ids: number[]) {
     if (ids.length === 0) return;
-    const label = service === 'qrz' ? 'QRZ.com' : service === 'clublog' ? 'Club Log' : service === 'lotw' ? 'LoTW' : service;
+    // Named rather than echoed: an operator who picked a menu entry should see
+    // the same words back, not the internal id.
+    const LABELS: Record<string, string> = {
+      qrz: 'QRZ.com', clublog: 'Club Log', lotw: 'LoTW',
+      hrdlog: 'HRDLog.net', eqsl: 'eQSL.cc', hamlog: 'HAMLOG.online',
+    };
+    const label = LABELS[service] ?? service;
     showToast(`Uploading ${ids.length} QSO${ids.length > 1 ? 's' : ''} to ${label}…`);
     try { await UploadQSOsManual(service, ids as any); }
     catch (e: any) { setError(String(e?.message ?? e)); }
@@ -4130,21 +4219,38 @@ export default function App() {
   // fields (optional): a chosen ADIF-tag list — the "choose which fields" export.
   // Empty = the standard/full behaviour (all fields, includeAppFields=false here).
   async function exportFilteredADIF(fields: string[] = []) {
+    return exportFilteredADIFAs(false, fields);
+  }
+  // The same filtered export, keeping the APP_OPSLOG_* tags — see
+  // exportSelectedADIFFull for why the award references need them.
+  async function exportFilteredADIFFull() {
+    return exportFilteredADIFAs(true, []);
+  }
+  async function exportFilteredADIFAs(includeApp: boolean, fields: string[]) {
     try {
       const path = await SaveADIFFile();
       if (!path) return;
       const f = buildActiveFilter();
-      const r = await ExportADIFFiltered(path, false, { ...f, limit: 0, offset: 0 } as any, fields);
+      const r = await ExportADIFFiltered(path, includeApp, { ...f, limit: 0, offset: 0 } as any, fields);
       showToast(`Exported ${r.count} QSO${r.count > 1 ? 's' : ''} → ${r.path}`);
     } catch (e: any) { setError(String(e?.message ?? e)); }
   }
   // Right-click "Export selected to ADIF": only the highlighted rows.
   async function exportSelectedADIF(ids: number[], fields: string[] = []) {
+    return exportSelectedADIFAs(ids, false, fields);
+  }
+  // The same export, keeping the APP_OPSLOG_* tags. Award references are the
+  // reason it exists: RDA@KR-04 lives in APP_OPSLOG_AWARDREFS, and a standard
+  // export — rightly — leaves every APP_ tag behind.
+  async function exportSelectedADIFFull(ids: number[]) {
+    return exportSelectedADIFAs(ids, true, []);
+  }
+  async function exportSelectedADIFAs(ids: number[], includeApp: boolean, fields: string[]) {
     if (ids.length === 0) return;
     try {
       const path = await SaveADIFFile();
       if (!path) return;
-      const r = await ExportADIFSelected(path, false, ids as any, fields);
+      const r = await ExportADIFSelected(path, includeApp, ids as any, fields);
       showToast(`Exported ${r.count} selected QSO${r.count > 1 ? 's' : ''} → ${r.path}`);
     } catch (e: any) { setError(String(e?.message ?? e)); }
   }
@@ -4191,8 +4297,14 @@ export default function App() {
     if (deletingIds.length === 0) return;
     const ids = deletingIds;
     try {
-      if (ids.length === 1) await DeleteQSO(ids[0]);
-      else await DeleteQSOs(ids as any);
+      // Report what was actually removed rather than assuming it matched what
+      // was asked: a delete that silently removes nothing looks exactly like one
+      // that worked, since the rows leave the grid when it reloads either way.
+      if (ids.length === 1) { await DeleteQSO(ids[0]); showToast(t('toast.deletedOne')); }
+      else {
+        const n = await DeleteQSOs(ids as any);
+        showToast(t('toast.deletedN', { n: Number(n ?? 0), asked: ids.length }));
+      }
       setDeletingIds([]);
       setSelectedId(null);
       setSelectedIds([]);
@@ -4641,6 +4753,10 @@ export default function App() {
       { type: 'item', label: t('edit.prefs'), action: 'edit.prefs' },
     ]},
     { name: 'view', label: t('menu.view'), items: [
+      { type: 'item', label: t('view.zoomIn'), action: 'view.zoomin', shortcut: 'Ctrl++' },
+      { type: 'item', label: t('view.zoomOut'), action: 'view.zoomout', shortcut: 'Ctrl+-' },
+      { type: 'item', label: t('view.zoomReset'), action: 'view.zoomreset', shortcut: 'Ctrl+0' },
+      { type: 'separator' },
       { type: 'item', label: t('view.refresh'), action: 'view.refresh', shortcut: 'F5' },
       { type: 'item', label: t('view.clearFilters'), action: 'view.clearfilters' },
     ]},
@@ -4689,6 +4805,9 @@ export default function App() {
       case 'file.exportCabrillo': exportCabrillo(); break;
       case 'file.deleteall':    setShowDeleteAll(true); break;
       case 'file.exit':         QuitApp(); break;
+      case 'view.zoomin':       setZoomRef.current(uiZoom + 0.1); break;
+      case 'view.zoomout':      setZoomRef.current(uiZoom - 0.1); break;
+      case 'view.zoomreset':    setZoomRef.current(1); break;
       case 'view.refresh':      refresh(); break;
       case 'view.clearfilters': setFilterCallsign(''); setActiveFilter({ conditions: [], match: 'AND' }); break;
       case 'edit.edit':         if (selectedId !== null) openEdit(selectedId); break;
@@ -5129,9 +5248,21 @@ export default function App() {
   };
   const geoDetailRow = (
     <div className="flex gap-4 items-end">
-      <div className="flex flex-col flex-1 min-w-0"><Label className="mb-1 h-3.5">{t('field.cnty')}</Label>
-        <Input value={details.cnty ?? ''}
+      {/* The badge sits INSIDE the field: this row is already tight, and a
+          county name is short enough to leave room at its right. It answers the
+          question at the moment the operator is deciding whether to call — the
+          same answer the Info tab gives, one tab away from where they are. */}
+      <div className="flex flex-col flex-1 min-w-0 relative"><Label className="mb-1 h-3.5">{t('field.cnty')}</Label>
+        <Input value={details.cnty ?? ''} className={cn(entryNewCounty && 'pr-12')}
           onChange={(e) => setDetails((d) => ({ ...d, cnty: e.target.value }))} />
+        {entryNewCounty && (
+          <span
+            title={t('detp.newCountyTip')}
+            className="absolute right-1.5 bottom-1.5 rounded px-1.5 py-0.5 text-[10px] font-bold tracking-wide bg-success text-success-foreground pointer-events-none"
+          >
+            {t('detp.newCounty')}
+          </span>
+        )}
       </div>
       <div className="flex flex-col w-[64px] shrink-0"><Label className="mb-1 h-3.5">{t('field.cqz')}</Label>
         <Input value={details.cqz ?? ''} className="font-mono"
@@ -5785,14 +5916,6 @@ export default function App() {
       txMsgs={txMsgs}
       txState={txState}
       txStates={txStates}
-      autoCallOn={autoCall.enabled}
-      // Written through the same key Preferences uses, so the two can never
-      // disagree about whether the machine is armed.
-      onToggleAutoCall={() => setAutoCall((prev) => {
-        const next = { ...prev, enabled: !prev.enabled };
-        writeUiPref(autoCallKey, JSON.stringify(next));
-        return next;
-      })}
       spotStatus={spotStatus as any}
       myCall={station.callsign}
       // A click ANSWERS the station: it hands the decode back to WSJT-X/MSHV as
@@ -5897,7 +6020,7 @@ export default function App() {
             <WorkedBeforeGrid key={`wbg-${activeProfileId ?? 'x'}`} wb={wbWithAwards as any} myGrid={station.my_grid} awardCols={awardCols} busy={wbBusy} currentCall={callsign} onRowDoubleClicked={(q) => openEdit(q.id as number)}
               onUpdateFromCty={bulkUpdateFromCty} onUpdateFromQRZ={bulkUpdateFromQRZ} onUpdateFromClublog={bulkUpdateFromClublog} onUpdateCountyFromULS={ulsReady ? bulkUpdateCountyFromULS : undefined}
               onSendTo={bulkSendTo} onSendRecording={bulkSendRecording} onSendEQSL={(ids) => setEqslQsoId(ids[0] ?? null)}
-              onBulkEdit={openBulkEdit} onExportSelected={exportSelectedADIF} onExportSelectedFields={exportSelectedFields}
+              onBulkEdit={openBulkEdit} onExportSelected={exportSelectedADIF} onExportSelectedFull={exportSelectedADIFFull} onExportSelectedFields={exportSelectedFields}
               onExportCabrilloSelected={exportSelectedCabrillo} onDelete={(ids) => setDeletingIds(ids)} />
           </div>
         );
@@ -5954,9 +6077,9 @@ export default function App() {
               onSendRecording={bulkSendRecording}
               onSendEQSL={(ids) => setEqslQsoId(ids[0] ?? null)}
               onBulkEdit={openBulkEdit}
-              onExportSelected={exportSelectedADIF}
+              onExportSelected={exportSelectedADIF} onExportSelectedFull={exportSelectedADIFFull}
               onExportSelectedFields={exportSelectedFields}
-              onExportFiltered={exportFilteredADIF}
+              onExportFiltered={exportFilteredADIF} onExportFilteredFull={exportFilteredADIFFull}
               onDelete={(ids) => setDeletingIds(ids)}
               onRowSelected={(ids) => { setSelectedIds(ids); setSelectedId(ids[0] ?? null); }}
               onRowSelectedQso={(r) => setSelQso(r ? { call: String(r.callsign ?? ""), band: String(r.band ?? ""), mode: String(r.mode ?? ""), dxcc: Number(r.dxcc ?? 0) } : null)}
@@ -6641,6 +6764,21 @@ export default function App() {
         </div>
       )}
 
+      {/* The zoom factor, while it is changing.
+          Centred at the top, out of the way of the entry form and the toasts,
+          and clickable: the number is only half an answer if the way back to
+          100 % is another thing to know. */}
+      {zoomShown && uiZoom !== 1 && (
+        <button
+          type="button"
+          onClick={() => setZoomRef.current(1)}
+          title={t('view.zoomResetTip')}
+          className="fixed top-2 left-1/2 -translate-x-1/2 z-[130] rounded-full border border-border bg-card/95 px-3 py-1 text-xs font-mono shadow-lg hover:bg-accent"
+        >
+          {Math.round(uiZoom * 100)}% · {t('view.zoomReset')}
+        </button>
+      )}
+
       {/* Transient toasts (bottom-right). Errors stack on top of the green
           success toast; both auto-dismiss. */}
       {/* Unlock encrypted passwords (set via Settings → Security). Dismissable:
@@ -7338,9 +7476,9 @@ export default function App() {
                 onSendRecording={bulkSendRecording}
                 onSendEQSL={(ids) => setEqslQsoId(ids[0] ?? null)}
                 onBulkEdit={openBulkEdit}
-                onExportSelected={exportSelectedADIF}
+                onExportSelected={exportSelectedADIF} onExportSelectedFull={exportSelectedADIFFull}
                 onExportSelectedFields={exportSelectedFields}
-                onExportFiltered={exportFilteredADIF}
+                onExportFiltered={exportFilteredADIF} onExportFilteredFull={exportFilteredADIFFull}
                 onExportCabrilloSelected={exportSelectedCabrillo}
                 onExportCabrilloFiltered={exportFilteredCabrillo}
                 onDelete={(ids) => setDeletingIds(ids)}
@@ -7671,7 +7809,7 @@ export default function App() {
               <WorkedBeforeGrid key={`wbg-${activeProfileId ?? 'x'}`} wb={wbWithAwards as any} myGrid={station.my_grid} awardCols={awardCols} busy={wbBusy} currentCall={callsign} onRowDoubleClicked={(q) => openEdit(q.id as number)}
                 onUpdateFromCty={bulkUpdateFromCty} onUpdateFromQRZ={bulkUpdateFromQRZ} onUpdateFromClublog={bulkUpdateFromClublog} onUpdateCountyFromULS={ulsReady ? bulkUpdateCountyFromULS : undefined} onSendTo={bulkSendTo} onSendRecording={bulkSendRecording}
                 onSendEQSL={(ids) => setEqslQsoId(ids[0] ?? null)}
-                onBulkEdit={openBulkEdit} onExportSelected={exportSelectedADIF} onExportSelectedFields={exportSelectedFields}
+                onBulkEdit={openBulkEdit} onExportSelected={exportSelectedADIF} onExportSelectedFull={exportSelectedADIFFull} onExportSelectedFields={exportSelectedFields}
                 onExportCabrilloSelected={exportSelectedCabrillo} onDelete={(ids) => setDeletingIds(ids)} />
             </TabsContent>
 
@@ -7682,6 +7820,7 @@ export default function App() {
               <TabsContent value="qsl" forceMount className="mt-0 flex flex-col min-h-0 flex-1 data-[state=inactive]:hidden">
                 <QSLManagerPanel
                   onEditQSO={openEdit}
+                  paperRequest={qslPaperReq}
                   // The same row actions the Recent QSOs grid offers. Only the
                   // selection-based exports: exporting "the filter" would mean
                   // the Recent-QSOs filter, not the rows shown here.
@@ -7787,7 +7926,8 @@ export default function App() {
             </TabsContent>
 
             <TabsContent value="awards" className="flex-1 min-h-0 p-0">
-              <AwardsPanel onEditQSO={openEdit} onAwardsChanged={() => setAwardsVersion((v) => v + 1)} />
+              <AwardsPanel onEditQSO={openEdit} onAwardsChanged={() => setAwardsVersion((v) => v + 1)}
+                onPaperQSL={openPaperQSLFor} />
             </TabsContent>
 
             {statsTabOpen && (

frontend/src/components/AlertsModal.tsx

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { Bell, Plus, Trash2, Volume2, Mail, Eye, X, Search } from 'lucide-react';
 import {
   Dialog, DialogContent, DialogHeader, DialogTitle, DialogDescription,
@@ -102,17 +102,40 @@ export function AlertsModal({ onClose, bands, modes, countries }: {
     return alerts.Rule.createFrom({ ...d, [key]: next });
   });
 
+  // Saving used to be silent: the dialog stays open and the rule looks exactly
+  // as it did a second earlier, so there was nothing to tell an operator whether
+  // the click had registered. A line that says so, and clears itself.
+  const [savedMsg, setSavedMsg] = useState('');
+  const savedTimer = useRef(0);
+  function flashSaved(text: string) {
+    setSavedMsg(text);
+    window.clearTimeout(savedTimer.current);
+    savedTimer.current = window.setTimeout(() => setSavedMsg(''), 3000);
+  }
+  useEffect(() => () => window.clearTimeout(savedTimer.current), []);
+
   async function save() {
     if (!draft) return;
     if (!draft.name.trim()) { setErr(t('altm.giveName')); return; }
-    try { const saved = await SaveAlertRule(draft); await refresh(); loadDraft(saved as Rule); setErr(''); }
-    catch (e: any) { setErr(String(e?.message ?? e)); }
+    try {
+      const saved = await SaveAlertRule(draft);
+      await refresh();
+      loadDraft(saved as Rule);
+      setErr('');
+      flashSaved(t('altm.saved', { name: draft.name.trim() }));
+    } catch (e: any) { setErr(String(e?.message ?? e)); }
   }
   async function del() {
     if (!draft) return;
     if (!draft.id) { loadDraft(null); return; }
     if (!window.confirm(t('altm.deleteConfirm', { name: draft.name }))) return;
-    try { await DeleteAlertRule(draft.id); loadDraft(null); await refresh(); }
+    try {
+      const name = draft.name;
+      await DeleteAlertRule(draft.id);
+      loadDraft(null);
+      await refresh();
+      flashSaved(t('altm.deleted', { name }));
+    }
     catch (e: any) { setErr(String(e?.message ?? e)); }
   }
 
@@ -257,6 +280,7 @@ export function AlertsModal({ onClose, bands, modes, countries }: {
                 {/* Editor actions */}
                 <div className="flex items-center gap-2 px-3 py-2 border-t border-border/60">
                   {err && <span className="text-[11px] text-danger flex-1 truncate">{err}</span>}
+                  {!err && savedMsg && <span className="text-[11px] text-success flex-1 truncate">{savedMsg}</span>}
                   <div className="flex-1" />
                   <Button variant="ghost" size="sm" className="text-danger" onClick={del}><Trash2 className="size-3.5" /> {t('altm.delete')}</Button>
                   <Button size="sm" onClick={save}>{t('altm.saveRule')}</Button>

frontend/src/components/AppearancePanel.tsx

@@ -29,9 +29,9 @@ const LABELS: Record<string, string> = {
 
 // The channels a rule can be scoped to. "worked" is the catch-all — it means
 // nothing on ANY channel — so narrowing it would say nothing.
-const CHANNELS = ['qsl', 'lotw', 'eqsl', 'qrz'] as const;
+const CHANNELS = ['qsl', 'lotw', 'eqsl', 'qrz', 'hamlog'] as const;
 const CHANNEL_LABELS: Record<string, string> = {
-  qsl: 'appr.chQsl', lotw: 'LoTW', eqsl: 'eQSL', qrz: 'QRZ.com',
+  qsl: 'appr.chQsl', lotw: 'LoTW', eqsl: 'eQSL', qrz: 'QRZ.com', hamlog: 'HAMLOG.online',
 };
 
 // MatrixColorsSection recolours the band/mode matrix — the PH/CW/DIG grid in the

frontend/src/components/AwardEditor.tsx

@@ -68,7 +68,8 @@ const AWARD_TYPES = ['REFERENCE', 'QSOFIELDS', 'CALLSIGN'];
 const NO_FIELD = '__none__';
 const CONFIRM_SRC = [
   { id: 'lotw', label: 'LoTW' }, { id: 'qsl', label: 'QSL' }, { id: 'eqsl', label: 'eQSL' },
-  { id: 'qrzcom', label: 'QRZ.com' }, { id: 'custom', label: 'Custom' },
+  { id: 'qrzcom', label: 'QRZ.com' }, { id: 'hamlog', label: 'HAMLOG.online' },
+  { id: 'custom', label: 'Custom' },
 ];
 const BANDS = ['2190m','630m','160m','80m','60m','40m','30m','20m','17m','15m','12m','10m','6m','4m','2m','1.25m','70cm','33cm','23cm','13cm','9cm','6cm','3cm','1.25cm','6mm','4mm','2.5mm','2mm','1mm'];
 const MODES = ['CW','SSB','USB','LSB','AM','FM','RTTY','PSK31','FT8','FT4','JT65','JT9','MFSK','OLIVIA','DIGITALVOICE'];

frontend/src/components/AwardsPanel.tsx

@@ -68,7 +68,11 @@ function ProgressBar({ worked, confirmed, total }: { worked: number; confirmed:
 // detection only means anything for those — see the Missing refs button.
 type AwardListItem = { code: string; name: string; valid?: boolean; bands?: string[]; emission?: string[]; scoped?: boolean };
 
-export function AwardsPanel({ onEditQSO, onAwardsChanged }: { onEditQSO?: (id: number) => void; onAwardsChanged?: () => void } = {}) {
+export function AwardsPanel({ onEditQSO, onAwardsChanged, onPaperQSL }: {
+  onEditQSO?: (id: number) => void;
+  onAwardsChanged?: () => void;
+  onPaperQSL?: (call: string) => void;
+} = {}) {
   const { t } = useI18n();
   const [awardList, setAwardList] = useState<AwardListItem[]>([]);
   // Computed results are cached per award code — each award is scanned only the
@@ -604,7 +608,7 @@ export function AwardsPanel({ onEditQSO, onAwardsChanged }: { onEditQSO?: (id: n
       </div>
 
       {cell && current && (
-        <CellQSOModal code={current.code} cell={cell} modeClass={modeFilter === 'all' ? '' : modeFilter} onClose={() => setCell(null)} />
+        <CellQSOModal code={current.code} cell={cell} modeClass={modeFilter === 'all' ? '' : modeFilter} onClose={() => setCell(null)} onPaperQSL={onPaperQSL} />
       )}
       {showMissing && current && (
         <MissingQSOModal code={current.code} name={current.name} onClose={() => setShowMissing(false)} onEditQSO={onEditQSO} />
@@ -835,7 +839,14 @@ function MissingQSOModal({ code, name, onClose, onEditQSO }: { code: string; nam
 }
 
 // CellQSOModal lists the QSOs behind one award-grid cell (reference × band).
-function CellQSOModal({ code, cell, modeClass, onClose }: { code: string; cell: { ref: string; band: string; name?: string }; modeClass: string; onClose: () => void }) {
+function CellQSOModal({ code, cell, modeClass, onClose, onPaperQSL }: {
+  code: string; cell: { ref: string; band: string; name?: string }; modeClass: string;
+  onClose: () => void;
+  // Send this callsign to the QSL Manager's Paper QSL view. Chasing a
+  // confirmation starts here — an unconfirmed entity, the contact behind it —
+  // and used to continue by retyping the callsign into another tab.
+  onPaperQSL?: (call: string) => void;
+}) {
   const { t } = useI18n();
   const [qsos, setQsos] = useState<any[]>([]);
   const [loading, setLoading] = useState(true);
@@ -872,7 +883,15 @@ function CellQSOModal({ code, cell, modeClass, onClose }: { code: string; cell:
                 {qsos.map((q, i) => (
                   <tr key={q.id ?? i} className="border-b border-border/30">
                     <td className="py-1 px-3 font-mono">{fmt(q.qso_date)}</td>
-                    <td className="py-1 pr-2 font-mono font-semibold">{q.callsign}</td>
+                    <td className="py-1 pr-2 font-mono font-semibold">
+                      {onPaperQSL ? (
+                        <button type="button" className="hover:underline text-primary"
+                          title={t('awp.paperQslTip')}
+                          onClick={() => { onPaperQSL(String(q.callsign ?? '')); onClose(); }}>
+                          {q.callsign}
+                        </button>
+                      ) : q.callsign}
+                    </td>
                     <td className="py-1 pr-2">{q.band}</td>
                     <td className="py-1 pr-2">{q.mode}</td>
                     <td className="py-1 pr-3 text-muted-foreground">{[isQSLConfirmed(q.lotw_rcvd) && 'LoTW', isQSLConfirmed(q.qsl_rcvd) && 'QSL', isQSLConfirmed(q.eqsl_rcvd) && 'eQSL'].filter(Boolean).join(', ')}</td>

frontend/src/components/BulkEditModal.tsx

@@ -48,6 +48,12 @@ const FIELDS: FieldDef[] = [
   { id: 'clublog_sent_date', label: 'bulk.fClublogSentDate', group: 'QSL / upload', kind: 'date' },
   { id: 'hrdlog_sent',       label: 'bulk.fHrdlogSent',      group: 'QSL / upload', kind: 'status' },
   { id: 'hrdlog_sent_date',  label: 'bulk.fHrdlogSentDate',  group: 'QSL / upload', kind: 'date' },
+  // HAMLOG.online: no promoted column, written into extras_json (see
+  // qso.bulkEditableExtras). Status and date, like every other service here.
+  { id: 'hamlog_sent',       label: 'bulk.fHamlogSent',      group: 'QSL / upload', kind: 'status' },
+  { id: 'hamlog_sent_date',  label: 'bulk.fHamlogSentDate',  group: 'QSL / upload', kind: 'date' },
+  { id: 'hamlog_rcvd',       label: 'bulk.fHamlogRcvd',      group: 'QSL / upload', kind: 'status' },
+  { id: 'hamlog_rcvd_date',  label: 'bulk.fHamlogRcvdDate',  group: 'QSL / upload', kind: 'date' },
   // My station / operator
   { id: 'station_callsign', label: 'bulk.fStationCall',  group: 'My station', kind: 'text', upper: true },
   { id: 'operator',         label: 'bulk.fOperator',     group: 'My station', kind: 'text', upper: true },

frontend/src/components/DecodesPanel.tsx

@@ -531,7 +531,14 @@ export function DecodesPanel({ decodes, txMsgs, txState, txStates, spotStatus, o
   });
   const [bandSel, setBandSel] = usePersisted('bandSel', '');
   const [modeSel, setModeSel] = usePersisted('modeSel', '');
-  const [contSel, setContSel] = usePersisted('contSel', '');
+  // Continents are a MULTI-selection, not one at a time: the useful filter is
+  // "everything except NA and EU", which a single-choice dropdown cannot say —
+  // it can only name one continent to keep. Stored as a list (a Set does not
+  // survive JSON), empty meaning no filter at all.
+  const [contList, setContList] = usePersisted<string[]>('contList', []);
+  const contSel = useMemo(() => new Set(contList), [contList]);
+  const toggleCont = (c: string) =>
+    setContList(contSel.has(c) ? contList.filter((x) => x !== c) : [...contList, c].sort());
   const [minSnr, setMinSnr] = usePersisted('minSnr', '');
   const [search, setSearch] = usePersisted('search', '');
 
@@ -554,8 +561,21 @@ export function DecodesPanel({ decodes, txMsgs, txState, txStates, spotStatus, o
   const calling = (txState?.dx_call ?? '').toUpperCase();
   const answersMe = (msg?: string): boolean => {
     if (!me || !msg) return false;
-    const first = msg.trim().split(/\s+/)[0]?.replace(/[<>]/g, '').toUpperCase();
-    return !!first && first === me;
+    // EVERY segment, not just the first.
+    //
+    // MSHV answers two stations in one transmission and sends them as one line:
+    //
+    //   DM8BJF RR73; F4BPO <RI1FJL> +14
+    //
+    // The second half is addressed to F4BPO, and reading only the start of the
+    // line missed it — the operator being answered saw no badge at all, which is
+    // the one moment this badge exists for. Each ';' segment is its own message
+    // and names its own recipient first.
+    for (const part of msg.split(';')) {
+      const first = part.trim().split(/\s+/)[0]?.replace(/[<>]/g, '').toUpperCase();
+      if (first && first === me) return true;
+    }
+    return false;
   };
 
   // The choices are built from what is actually on the feed, and a selector with
@@ -576,6 +596,15 @@ export function DecodesPanel({ decodes, txMsgs, txState, txStates, spotStatus, o
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [decodes, spotStatus]);
 
+  // The chips are the continents on the feed — a selector with nothing to choose
+  // is furniture — PLUS anything currently selected. Without that second half a
+  // filter can strand itself: pick AF, the last African station stops decoding,
+  // and the list empties with no chip left to switch it back off.
+  const contChips = useMemo(
+    () => [...new Set([...conts, ...contList])].sort(),
+    [conts, contList],
+  );
+
   const filtered = useMemo(() => {
     const q = search.trim().toUpperCase();
     const floor = minSnr.trim() === '' ? null : parseInt(minSnr, 10);
@@ -594,7 +623,7 @@ export function DecodesPanel({ decodes, txMsgs, txState, txStates, spotStatus, o
         for (const c of cats) if (have.has(c)) { hit = true; break; }
         if (!hit) return false;
       }
-      if (contSel && e?.continent !== contSel) return false;
+      if (contSel.size > 0 && !(e?.continent && contSel.has(e.continent))) return false;
       if (q && !(d.call.includes(q) || (d.grid ?? '').toUpperCase().includes(q) || (d.msg ?? '').toUpperCase().includes(q))) return false;
       return true;
     });
@@ -627,11 +656,11 @@ export function DecodesPanel({ decodes, txMsgs, txState, txStates, spotStatus, o
 
   const resetFilters = () => {
     setCqOnly(false); setLotwOnly(false); setBandSel('');
-    setModeSel(''); setContSel(''); setMinSnr(''); setSearch('');
+    setModeSel(''); setContList([]); setMinSnr(''); setSearch('');
     setCats(new Set());
     try { localStorage.setItem(CAT_KEY, '[]'); } catch { /* not worth failing over */ }
   };
-  const anyFilter = cqOnly || lotwOnly || cats.size > 0 || !!bandSel || !!modeSel || !!contSel || !!minSnr || !!search.trim();
+  const anyFilter = cqOnly || lotwOnly || cats.size > 0 || !!bandSel || !!modeSel || contSel.size > 0 || !!minSnr || !!search.trim();
 
   const sel = 'h-8 rounded-lg border border-border bg-background px-2 text-sm';
   const chip = (on: boolean, tone = 'primary') => cn(
@@ -700,11 +729,28 @@ export function DecodesPanel({ decodes, txMsgs, txState, txStates, spotStatus, o
             {modes.map((m) => <option key={m} value={m}>{m}</option>)}
           </select>
         )}
-        {conts.length > 1 && (
-          <select className={sel} value={contSel} onChange={(e) => setContSel(e.target.value)}>
-            <option value="">{t('dec.allConts')}</option>
-            {conts.map((c) => <option key={c} value={c}>{c}</option>)}
-          </select>
+        {/* Toggles, like the category badges above — the same gesture for the
+            same kind of question. None lit is every continent, which is what an
+            empty filter has always meant here. */}
+        {contChips.length > 1 && (
+          <span className="flex items-center gap-1 pl-1 border-l border-border/60 ml-1" title={t('dec.contsHint')}>
+            {contChips.map((c) => {
+              const on = contSel.has(c);
+              return (
+                <button
+                  key={c}
+                  type="button"
+                  onClick={() => toggleCont(c)}
+                  className={cn(
+                    'rounded border px-1.5 py-0.5 text-[11px] font-bold uppercase tracking-wide transition-all',
+                    on ? 'border-primary text-primary' : 'border-border text-muted-foreground opacity-50 hover:opacity-100',
+                  )}
+                >
+                  {c}
+                </button>
+              );
+            })}
+          </span>
         )}
 
         <label className="flex items-center gap-1.5 text-sm text-muted-foreground">
@@ -765,21 +811,6 @@ export function DecodesPanel({ decodes, txMsgs, txState, txStates, spotStatus, o
             filter. Halt goes LAST — it is the one that must be findable without
             reading, and the end of the row is the one position that never moves
             as filters come and go. */}
-        {onToggleAutoCall && (
-          <button
-            type="button"
-            onClick={onToggleAutoCall}
-            title={t('dec.autoCallTip')}
-            className={cn('h-8 px-2.5 rounded-lg text-sm inline-flex items-center gap-1.5 border',
-              // Lit when it is armed, because what matters at a glance is not
-              // "where is the switch" but "is this thing about to transmit".
-              autoCallOn
-                ? 'border-warning bg-warning text-warning-foreground'
-                : 'border-border text-muted-foreground hover:bg-muted hover:text-foreground')}
-          >
-            <Bot className="size-3.5" /> {t('dec.autoCall')}
-          </button>
-        )}
         {onHalt && (
           <button
             type="button"

frontend/src/components/FilterBuilder.tsx

@@ -1,4 +1,4 @@
-import { useEffect, useMemo, useState } from 'react';
+import { useEffect, useMemo, useRef, useState } from 'react';
 import { Plus, Trash2, Save, FolderOpen, X } from 'lucide-react';
 import { writeUiPref } from '@/lib/uiPref';
 import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter } from '@/components/ui/dialog';
@@ -33,6 +33,8 @@ type FieldType = 'text' | 'number' | 'date' | 'adifdate';
 const FIELDS: { value: string; label: string; type: FieldType }[] = [
   { value: 'callsign', label: 'fltb.fCallsign', type: 'text' },
   { value: 'qso_date', label: 'fltb.fDate', type: 'date' },
+  // When the record entered the logbook — the way to isolate what an import added.
+  { value: 'created_at', label: 'fltb.fCreated', type: 'date' },
   { value: 'qso_date_off', label: 'fltb.fEndDate', type: 'date' },
   { value: 'band', label: 'fltb.fBand', type: 'text' },
   { value: 'band_rx', label: 'fltb.fRxBand', type: 'text' },
@@ -86,6 +88,12 @@ const FIELDS: { value: string; label: string; type: FieldType }[] = [
   { value: 'clublog_qso_upload_date', label: 'fltb.fClublogSentDate', type: 'adifdate' },
   { value: 'hrdlog_qso_upload_status', label: 'fltb.fHrdlogSent', type: 'text' },
   { value: 'hrdlog_qso_upload_date', label: 'fltb.fHrdlogSentDate', type: 'adifdate' },
+  // HAMLOG.online: no promoted column, filtered through extras_json (see
+  // qso.filterableExtras).
+  { value: 'hamlog_sent', label: 'fltb.fHamlogSent', type: 'text' },
+  { value: 'hamlog_sent_date', label: 'fltb.fHamlogSentDate', type: 'adifdate' },
+  { value: 'hamlog_rcvd', label: 'fltb.fHamlogRcvd', type: 'text' },
+  { value: 'hamlog_rcvd_date', label: 'fltb.fHamlogRcvdDate', type: 'adifdate' },
   { value: 'contest_id', label: 'fltb.fContestId', type: 'text' },
   { value: 'srx', label: 'fltb.fSerialRcvd', type: 'number' },
   { value: 'stx', label: 'fltb.fSerialSent', type: 'number' },
@@ -192,6 +200,17 @@ export function FilterBuilder({ open, initial, onApply, onClose }: Props) {
 
   function apply() { onApply(buildFilter()); }
 
+  // Same silence as the alert rules: the preset landed in the list, but the list
+  // is not where the operator is looking when they press Save.
+  const [savedMsg, setSavedMsg] = useState('');
+  const savedTimer = useRef(0);
+  function flashSaved(text: string) {
+    setSavedMsg(text);
+    window.clearTimeout(savedTimer.current);
+    savedTimer.current = window.setTimeout(() => setSavedMsg(''), 3000);
+  }
+  useEffect(() => () => window.clearTimeout(savedTimer.current), []);
+
   function saveCurrentPreset() {
     const name = presetName.trim();
     if (!name) return;
@@ -199,6 +218,7 @@ export function FilterBuilder({ open, initial, onApply, onClose }: Props) {
     savePresets(next);
     setPresets(next);
     setPresetName('');
+    flashSaved(t('fltb.presetSaved', { name }));
   }
   function loadPreset(name: string) {
     const f = presets[name];
@@ -335,6 +355,7 @@ export function FilterBuilder({ open, initial, onApply, onClose }: Props) {
           <Button variant="outline" size="sm" className="h-8" disabled={!presetName.trim()} onClick={saveCurrentPreset}>
             <Save className="size-3.5 mr-1" /> {t('fltb.savePreset')}
           </Button>
+          {savedMsg && <span className="text-[11px] text-success truncate">{savedMsg}</span>}
         </div>
         </div>
 

frontend/src/components/FlexPanel.tsx

@@ -8,6 +8,7 @@ import {
   GetTunerGeniusStatus, GetTunerGeniusSettings,
   GetAmpStatuses, AmpOperate, AmpPower, AmpPowerLevel,
   FlexSetAGCMode, FlexSetAGCThreshold, FlexSetAudioLevel, FlexSetMute, FlexSetRXAntenna, FlexSetTXAntenna, FlexSetSplit, FlexSetActiveSlice, FlexSetTXSlice,
+  GetFlexRSTChase, SaveFlexRSTChase, SetFlexRSTChaseEnabled,
   FlexSetRIT, FlexSetRITFreq, FlexSetXIT, FlexSetXITFreq,
   FlexSetNB, FlexSetNBLevel, FlexSetNR, FlexSetNRLevel, FlexSetANF, FlexSetANFLevel,
   FlexSetLMSNR, FlexSetLMSNRLevel, FlexSetLMSANF, FlexSetLMSANFLevel,
@@ -304,6 +305,25 @@ function powerLevelLabel(pl?: string): string {
 // host can keep the WinKeyer (which actually sends the macros) in sync.
 export function FlexPanel({ onCWSpeed, onReportRST }: { onCWSpeed?: (wpm: number) => void; onReportRST?: (rst: string) => void } = {}) {
   const { t } = useI18n();
+  // Split-pile-up chaser (see flexrstchase.go). Held here so the button can
+  // paint its state without polling the backend for it.
+  const [rstChase, setRstChase] = useState<{ enabled: boolean; markers: string; offset_hz: number; split_only: boolean }>(
+    { enabled: false, markers: '599', offset_hz: 0, split_only: true });
+  const [rstChaseOffsetText, setRstChaseOffsetText] = useState('0');
+  // The marker text is edited as raw text and only parsed on blur: it is a
+  // comma-separated list, and normalising it on every keystroke would eat the
+  // comma the moment it is typed.
+  const [rstChaseMarkersText, setRstChaseMarkersText] = useState('599');
+  // The marker field is summoned by right-clicking the button, not parked on
+  // the row: it is set once to agree with SDC and then never touched, while the
+  // row it was sitting in is the busiest in the panel.
+  const [rstChaseEditing, setRstChaseEditing] = useState(false);
+  useEffect(() => {
+    GetFlexRSTChase().then((c: any) => {
+      if (!c) return;
+      setRstChase(c); setRstChaseOffsetText(String(c.offset_hz ?? 0)); setRstChaseMarkersText(String(c.markers ?? '599'));
+    }).catch(() => {});
+  }, []);
   const [st, setSt] = useState<FlexState>(ZERO);
   // Extra/"advanced" DSP rows (WNB + the SmartSDR v4 NRL/NRS/NRF/ANFL/AI-FFT
   // block) collapse behind a button so the RECEIVE card doesn't grow tall — only
@@ -652,6 +672,59 @@ export function FlexPanel({ onCWSpeed, onReportRST }: { onCWSpeed?: (wpm: number
                   st.split ? 'bg-info text-info-foreground border-info shadow-[0_0_12px] shadow-info/50' : 'bg-card text-info border-info hover:bg-info-muted')}>
                 SPLIT
               </button>
+              {/* The split chaser. On the panel and not in a settings page:
+                  it is switched on when a DXpedition appears and off when it is
+                  in the log, which is done mid-QSO with one hand. The offset
+                  sits beside it because it is the one number retuned while
+                  chasing — everything else about the feature is configured once. */}
+              <button type="button" disabled={off}
+                title={t('flxp.rstChaseHint', { m: rstChase.markers })}
+                onContextMenu={(e) => { e.preventDefault(); setRstChaseEditing(true); }}
+                onClick={() => { const on = !rstChase.enabled; setRstChase({ ...rstChase, enabled: on }); SetFlexRSTChaseEnabled(on).catch(() => {}); }}
+                className={cn('px-3 py-1.5 rounded-lg text-sm font-extrabold tracking-wide border-2 transition-all disabled:opacity-30',
+                  rstChase.enabled ? 'bg-success text-success-foreground border-success shadow-[0_0_12px] shadow-success/50' : 'bg-card text-success border-success hover:bg-success-muted')}>
+                {rstChase.markers.split(',')[0].trim() || '599'}
+              </button>
+              {/* The marker is whatever SDC was told to write — "599", "5NN", or
+                  several. It has to agree with the skimmer or nothing ever fires,
+                  so it is edited here rather than in a settings page — but only
+                  when asked for, since it is set once and then left alone. */}
+              {rstChaseEditing && (
+                <input type="text" autoFocus value={rstChaseMarkersText}
+                  onChange={(e) => setRstChaseMarkersText(e.target.value)}
+                  onKeyDown={(e) => {
+                    if (e.key === 'Enter') (e.target as HTMLInputElement).blur();
+                    if (e.key === 'Escape') { setRstChaseMarkersText(rstChase.markers); setRstChaseEditing(false); }
+                  }}
+                  onBlur={() => {
+                    const v = rstChaseMarkersText.trim() || '599';
+                    setRstChaseMarkersText(v);
+                    setRstChaseEditing(false);
+                    if (v === rstChase.markers) return;
+                    const next = { ...rstChase, markers: v };
+                    setRstChase(next); SaveFlexRSTChase(next as any).catch(() => {});
+                  }}
+                  title={t('flxp.rstChaseMarkerHint')}
+                  className="w-16 h-6 rounded border border-input bg-background px-1 text-[11px] font-mono uppercase" />
+              )}
+              {rstChase.enabled && (
+                <label className="flex items-center gap-1 text-[11px] text-muted-foreground whitespace-nowrap ml-2">
+                  {t('flxp.rstChaseOffset')}
+                  <input type="number" step={10} value={rstChaseOffsetText}
+                    onChange={(e) => setRstChaseOffsetText(e.target.value)}
+                    onBlur={() => {
+                      // Kept as text while typing: normalising every keystroke
+                      // makes a minus sign impossible to enter.
+                      const n = Math.round(Number(rstChaseOffsetText));
+                      const v = Number.isFinite(n) ? n : 0;
+                      setRstChaseOffsetText(String(v));
+                      const next = { ...rstChase, offset_hz: v };
+                      setRstChase(next); SaveFlexRSTChase(next as any).catch(() => {});
+                    }}
+                    className="w-12 h-6 rounded border border-input bg-background px-1 text-[11px] font-mono" />
+                  Hz
+                </label>
+              )}
               {st.split && !!st.tx_freq_hz && (
                 <span className="text-[11px] font-mono text-muted-foreground whitespace-nowrap">
                   TX {(st.tx_freq_hz / 1e6).toFixed(3)}

frontend/src/components/MainMap.tsx

@@ -366,7 +366,10 @@ export function WorldMap({ fromGrid, toGrid, fromLabel, toLabel, beamAzimuths, b
     <div className="relative isolate h-full w-full rounded-lg overflow-hidden border border-border">
       <div ref={worldRef} className="absolute inset-0" />
       {/* Basemap picker — Light / Street / Satellite (key-free tiles). */}
-      <div className="absolute top-1 left-12 z-[500] flex rounded-md overflow-hidden shadow border border-border backdrop-blur">
+      {/* Clear of the zoom buttons, not merely next to them: at left-12 the
+          first basemap sat a few pixels from the − button and operators kept
+          hitting Light when they meant to zoom out. */}
+      <div className="absolute top-1 left-[4.5rem] z-[500] flex rounded-md overflow-hidden shadow border border-border backdrop-blur">
         {(Object.keys(BASEMAPS) as BasemapKey[]).map((k) => (
           <button
             key={k}

frontend/src/components/QSLManagerModal.tsx

@@ -8,7 +8,7 @@ import {
   Select, SelectTrigger, SelectValue, SelectContent, SelectItem,
 } from '@/components/ui/select';
 import { cn } from '@/lib/utils';
-import { FindQSOsForUpload, UploadQSOsManual, DownloadConfirmations, CancelConfirmations, SyncPOTAHunterLog, ListQSO, BulkUpdateQSL, UploadCallsign, GetSlotStats } from '../../wailsjs/go/main/App';
+import { FindQSOsForUpload, UploadQSOsManual, DownloadConfirmations, CancelConfirmations, ImportHamlogConfirmations, ExportHamlogUnmatched, OpenADIFFile, SaveADIFFile, SyncPOTAHunterLog, ListQSO, BulkUpdateQSL, UploadCallsign, GetSlotStats } from '../../wailsjs/go/main/App';
 import { Input } from '@/components/ui/input';
 import { RecentQSOsGrid } from '@/components/RecentQSOsGrid';
 import { EventsOn } from '../../wailsjs/runtime/runtime';
@@ -41,6 +41,7 @@ const SERVICES = [
   { v: 'hrdlog',  label: 'HRDLog.net' },
   { v: 'eqsl',    label: 'eQSL.cc' },
   { v: 'lotw',    label: 'LoTW' },
+  { v: 'hamlog',  label: 'HAMLOG.online' },
   { v: 'pota',    label: 'POTA hunter log' },
   { v: 'paper',   label: 'Paper QSL' },
 ];
@@ -134,9 +135,14 @@ export type GridActions = {
   onDelete?: (ids: number[]) => void;
 };
 
-export function QSLManagerPanel({ onEditQSO, actions }: {
+export function QSLManagerPanel({ onEditQSO, actions, paperRequest }: {
   onEditQSO?: (id: number) => void;
   actions?: GridActions;
+  // A callsign to open the Paper QSL view on, sent from elsewhere in the app
+  // (the awards grid). Carries a counter rather than being a bare string: the
+  // panel is force-mounted and keeps its state, so asking twice for the SAME
+  // callsign has to be two requests, not one unchanged prop.
+  paperRequest?: { call: string; n: number };
 } = {}) {
   const { t } = useI18n();
   const [service, setService] = useState('lotw');
@@ -198,6 +204,27 @@ export function QSLManagerPanel({ onEditQSO, actions }: {
   }, [paperCall]);
 
 
+  // Honour an incoming request: switch to Paper QSL, fill the callsign, search.
+  // The search runs from the effect below once paperCall has actually changed —
+  // searchPaper closes over paperCall, so calling it here would search the
+  // PREVIOUS callsign.
+  // The pending request's callsign, so the search fires for THAT callsign and
+  // for nothing else: the effect below also wakes on every keystroke in the
+  // field, and searching on each of them would query the log letter by letter.
+  const pendingPaperCall = useRef('');
+  useEffect(() => {
+    const call = paperRequest?.call?.trim().toUpperCase();
+    if (!call) return;
+    setService('paper');
+    setPaperCall(call);
+    pendingPaperCall.current = call;
+  }, [paperRequest?.call, paperRequest?.n]);
+  useEffect(() => {
+    if (!pendingPaperCall.current || paperCall !== pendingPaperCall.current) return;
+    pendingPaperCall.current = '';
+    searchPaper();
+  }, [paperCall, searchPaper]);
+
   async function applyPaper() {
     const ids = paperRows.filter((r) => paperSel.has(r.id)).map((r) => r.id);
     if (ids.length === 0) return;
@@ -323,6 +350,34 @@ export function QSLManagerPanel({ onEditQSO, actions }: {
     catch (e: any) { setLogLines((p) => [...p, 'Error: ' + String(e?.message ?? e)]); setBusy(false); }
   }
 
+  // HAMLOG.online has no download verb — their agent protocol only uploads —
+  // so confirmations come back as an ADIF exported from their site. It is read
+  // here rather than through the ordinary ADIF import because that one matches
+  // on the UTC minute and INSERTS whatever fails to match: a few hundred copies
+  // of contacts already in the log. This path only ever stamps QSOs it finds.
+  async function importHamlogCfm() {
+    const path = await OpenADIFFile();
+    if (!path) return;
+    setLogLines([]); setBusy(true); setLogAction('download'); setShowLog(true);
+    try { await ImportHamlogConfirmations(path); }
+    catch (e: any) { setLogLines((p) => [...p, 'Error: ' + String(e?.message ?? e)]); setBusy(false); }
+  }
+
+  // The unmatched half of an import. Offered as a file because a few hundred
+  // discrepancies are a list to work through, not something to read in a log
+  // window.
+  async function exportHamlogUnmatched() {
+    try {
+      const path = await SaveADIFFile();
+      if (!path) return;
+      const n = await ExportHamlogUnmatched(path);
+      setLogLines((p) => [...p, `Exported ${n} unmatched confirmation(s) → ${path}`]);
+      setShowLog(true);
+    } catch (e: any) {
+      setLogLines((p) => [...p, 'Error: ' + String(e?.message ?? e)]); setShowLog(true);
+    }
+  }
+
   function viewResults() {
     setShowLog(false);
     if (logAction === 'upload') selectRequired();
@@ -639,11 +694,25 @@ export function QSLManagerPanel({ onEditQSO, actions }: {
       {service !== 'pota' && service !== 'paper' && (
       <div className="flex items-center justify-between gap-2 px-3 py-2 border-t border-border bg-muted/20 shrink-0">
         <div className="flex items-center gap-2 flex-wrap">
+          {service === 'hamlog' ? (
+            <>
+            <Button variant="outline" size="sm" onClick={importHamlogCfm} disabled={busy}
+              title={t('qslm.hamlogImportTitle')}>
+              <DownloadCloud className="size-3.5" /> {t('qslm.hamlogImportCfm')}
+            </Button>
+            <Button variant="outline" size="sm" onClick={exportHamlogUnmatched} disabled={busy}
+              title={t('qslm.hamlogUnmatchedTitle')}>
+              <UploadCloud className="size-3.5 rotate-180" /> {t('qslm.hamlogUnmatched')}
+            </Button>
+            </>
+          ) : (
           <Button variant="outline" size="sm" onClick={download} disabled={busy}
             title={t('qslm.downloadTitle')}>
             <DownloadCloud className="size-3.5" /> {t('qslm.downloadConf')}
           </Button>
+          )}
           {/* Date window */}
+          {service !== 'hamlog' && (<>
           <Select value={sinceMode} onValueChange={(v) => setSinceMode(v as any)}>
             <SelectTrigger className="h-8 w-[150px] text-xs" title={t('qslm.downloadRangeTitle')}>
               <SelectValue />
@@ -667,6 +736,7 @@ export function QSLManagerPanel({ onEditQSO, actions }: {
             <Checkbox checked={addNotFound} onCheckedChange={(c) => setAddNotFound(!!c)} />
             {t('qslm.addNotFound')}
           </label>
+          </>)}
         </div>
         <Button size="sm" onClick={upload} disabled={selectedCount === 0 || busy}>
           <UploadCloud className="size-3.5" /> {t('qslm.uploadTo', { n: selectedCount, service: serviceLabel })}

frontend/src/components/QSOContextMenu.tsx

@@ -18,8 +18,11 @@ type Props = {
   onSendEQSL?: (ids: number[]) => void;
   onBulkEdit?: (ids: number[]) => void;
   onExportSelected?: (ids: number[]) => void;
+  // Same rows, but keeping the APP_OPSLOG_* tags — award references above all.
+  onExportSelectedFull?: (ids: number[]) => void;
   onExportSelectedFields?: (ids: number[]) => void;
   onExportFiltered?: () => void;
+  onExportFilteredFull?: () => void;
   onExportCabrilloSelected?: (ids: number[]) => void;
   onExportCabrilloFiltered?: () => void;
   onDelete?: (ids: number[]) => void;
@@ -31,6 +34,7 @@ const UPLOAD_TARGETS: { service: string; name: string }[] = [
   { service: 'hrdlog', name: 'HRDLog.net' },
   { service: 'eqsl', name: 'eQSL.cc' },
   { service: 'lotw', name: 'LoTW' },
+  { service: 'hamlog', name: 'HAMLOG.online' },
 ];
 
 // Lightweight right-click menu for the QSO grids. AG Grid's native context
@@ -39,7 +43,7 @@ const UPLOAD_TARGETS: { service: string; name: string }[] = [
 // or picks a command. (We deliberately do NOT close on scroll/resize: the QSO
 // list auto-refreshes and AG Grid fires internal scroll events on refresh,
 // which used to dismiss the menu the instant it appeared.)
-export function QSOContextMenu({ menu, onClose, onUpdateFromCty, onUpdateFromQRZ, onUpdateFromClublog, onUpdateCountyFromULS, onSendTo, onSendRecording, onSendEQSL, onBulkEdit, onExportSelected, onExportSelectedFields, onExportFiltered, onExportCabrilloSelected, onExportCabrilloFiltered, onDelete }: Props) {
+export function QSOContextMenu({ menu, onClose, onUpdateFromCty, onUpdateFromQRZ, onUpdateFromClublog, onUpdateCountyFromULS, onSendTo, onSendRecording, onSendEQSL, onBulkEdit, onExportSelected, onExportSelectedFull, onExportSelectedFields, onExportFiltered, onExportFilteredFull, onExportCabrilloSelected, onExportCabrilloFiltered, onDelete }: Props) {
   const { t } = useI18n();
   const boxRef = useRef<HTMLDivElement>(null);
   // Starts at the cursor; the layout effect corrects it once the real size is
@@ -189,6 +193,20 @@ export function QSOContextMenu({ menu, onClose, onUpdateFromCty, onUpdateFromQRZ
               <span>{t('qctx.exportSelectedAdif', { n })}</span>
             </button>
           )}
+          {/* The same rows WITH the OpsLog fields.
+              The export above is standard ADIF — what another logger should be
+              given — and it drops every APP_ tag, award references included. A
+              backup, or a move to another OpsLog, needs them: RDA@KR-04 lives in
+              APP_OPSLOG_AWARDREFS and nowhere else. */}
+          {onExportSelectedFull && (
+            <button
+              className="flex w-full items-center gap-2 px-3 py-1.5 text-left hover:bg-accent/50"
+              onClick={() => { onExportSelectedFull(menu.ids); onClose(); }}
+            >
+              <FileDown className="size-4 text-info" />
+              <span>{t('qctx.exportSelectedAdifFull', { n })}</span>
+            </button>
+          )}
           {onExportSelectedFields && (
             <button
               className="flex w-full items-center gap-2 px-3 py-1.5 text-left hover:bg-accent/50"
@@ -207,6 +225,15 @@ export function QSOContextMenu({ menu, onClose, onUpdateFromCty, onUpdateFromQRZ
               <span>{t('qctx.exportFilteredAdif')}</span>
             </button>
           )}
+          {onExportFilteredFull && (
+            <button
+              className="flex w-full items-center gap-2 px-3 py-1.5 text-left hover:bg-accent/50"
+              onClick={() => { onExportFilteredFull(); onClose(); }}
+            >
+              <FileDown className="size-4 text-info" />
+              <span>{t('qctx.exportFilteredAdifFull')}</span>
+            </button>
+          )}
           {onExportCabrilloSelected && (
             <button
               className="flex w-full items-center gap-2 px-3 py-1.5 text-left hover:bg-accent/50"

frontend/src/components/QSOEditModal.tsx

@@ -85,6 +85,19 @@ const CONF_LABEL_KEYS: Record<string, string> = {
 // the channel picker and the status table alongside the rest.
 const OPSLOG_CONF = 'OPSLOG';
 
+// HAMLOG.online. Out of CONFIRMATIONS for the same reason as the OpsLog card —
+// it is stored in the ADIF extras, not in QSO columns — but it is an upload
+// service like QRZ.com or Club Log, so it gets the ordinary sent/received/date
+// editor rather than a special one. The received key is THEIR field name, the
+// one their ADIF export writes; see award.HamlogQSLKey.
+const HAMLOG_CONF = 'HAMLOG';
+const HAMLOG_KEYS = {
+  sent: 'APP_OPSLOG_HAMLOG_SENT',
+  sentDate: 'APP_OPSLOG_HAMLOG_SENT_DATE',
+  rcvd: 'APP_HAMLOG_QSO_CFM',
+  rcvdDate: 'APP_OPSLOG_HAMLOG_QSL_DATE',
+};
+
 // Colour-coded status cell for the confirmation grid.
 function StatusCell({ value }: { value?: string }) {
   const { t } = useI18n();
@@ -626,6 +639,7 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
                   </div>
                   <div className="flex items-end gap-2">
                     <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>{t('qedit.gridExt')}</Label><Input title={t('qedit.gridExtTip')} value={draft.gridsquare_ext ?? ''} onChange={(e) => set('gridsquare_ext', 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)}
@@ -714,6 +728,16 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
                 const def = CONFIRMATIONS.find((c) => c.key === confSel) ?? CONFIRMATIONS[0];
                 const val = (k?: keyof QSOForm) => (k ? ((draft as any)[k] ?? '') : '');
                 const put = (k: keyof QSOForm | undefined, v: any) => { if (k) (set as any)(k, v); };
+                // The extras-backed channel reads and writes the same way, one
+                // level down. Save merges the extras rather than replacing them,
+                // so an emptied field keeps its stored value — which is why the
+                // statuses are written as explicit Y/N and never removed.
+                const exVal = (k: string) => String(draft.extras?.[k] ?? '');
+                const exPut = (k: string, v: any) => {
+                  const next = { ...(draft.extras ?? {}) };
+                  next[k] = String(v ?? '');
+                  set('extras', next as any);
+                };
                 return (
                   <div className="flex gap-6">
                     {/* Left: edit one confirmation channel at a time */}
@@ -730,11 +754,24 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
                                 generic sent/received/date grid, which has no field
                                 to bind to. */}
                             <SelectItem value={OPSLOG_CONF}>{t('qedit.confOpsLog')}</SelectItem>
+                            <SelectItem value={HAMLOG_CONF}>HAMLOG.online</SelectItem>
                           </SelectContent>
                         </Select>
                       </div>
 
-                      {confSel === OPSLOG_CONF ? (
+                      {confSel === HAMLOG_CONF ? (
+                        <>
+                          <div className="grid grid-cols-2 gap-3">
+                            <div><Label>{t('qedit.sent')}</Label><QslSelect value={exVal(HAMLOG_KEYS.sent)} onChange={(v) => exPut(HAMLOG_KEYS.sent, v)} /></div>
+                            <div><Label>{t('qedit.received')}</Label><QslSelect value={exVal(HAMLOG_KEYS.rcvd)} onChange={(v) => exPut(HAMLOG_KEYS.rcvd, v)} /></div>
+                            <div><Label>{t('qedit.dateSent')}</Label><AdifDateInput value={exVal(HAMLOG_KEYS.sentDate)} onChange={(v) => exPut(HAMLOG_KEYS.sentDate, v)} /></div>
+                            <div><Label>{t('qedit.dateReceived')}</Label><AdifDateInput value={exVal(HAMLOG_KEYS.rcvdDate)} onChange={(v) => exPut(HAMLOG_KEYS.rcvdDate, v)} /></div>
+                          </div>
+                          <p className="text-[11px] text-muted-foreground">
+                            {t('qedit.qslPanelHint')} <strong>{t('qedit.saveChanges')}</strong>.
+                          </p>
+                        </>
+                      ) : confSel === OPSLOG_CONF ? (
                         /* OpsLog's own card. "Sent" is stamped when the card
                            actually goes out, so it is shown, not offered: ticking
                            it by hand would record something that never happened.
@@ -826,6 +863,12 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
                             <td className="w-24"><StatusCell value={opslogQslSent ? 'Y' : 'N'} /></td>
                             <td className="w-24"><StatusCell value={qslReceived ? 'Y' : 'N'} /></td>
                           </tr>
+                          {/* HAMLOG.online — extras again, same hand-written row. */}
+                          <tr className="text-xs">
+                            <td className="font-medium pr-3 py-0.5 whitespace-nowrap">HAMLOG.online</td>
+                            <td className="w-24"><StatusCell value={exVal(HAMLOG_KEYS.sent)} /></td>
+                            <td className="w-24"><StatusCell value={exVal(HAMLOG_KEYS.rcvd)} /></td>
+                          </tr>
                         </tbody>
                       </table>
                     </div>
@@ -867,7 +910,7 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
                 <F label={t('qedit.stationCallsign')} span={3}><Input value={draft.station_callsign ?? ''} onChange={(e) => set('station_callsign', e.target.value)} /></F>
                 <F label={t('qedit.operator')} span={3}><Input value={draft.operator ?? ''} onChange={(e) => set('operator', e.target.value)} /></F>
                 <F label={t('qedit.myGrid')}><Input value={draft.my_grid ?? ''} onChange={(e) => set('my_grid', e.target.value)} /></F>
-                <F label={t('qedit.gridExt')}><Input value={draft.my_gridsquare_ext ?? ''} onChange={(e) => set('my_gridsquare_ext', e.target.value)} /></F>
+                <F label={t('qedit.myGridExt')}><Input title={t('qedit.gridExtTip')} value={draft.my_gridsquare_ext ?? ''} onChange={(e) => set('my_gridsquare_ext', e.target.value)} /></F>
                 <F label={t('qedit.country')} span={2}><Combobox value={draft.my_country ?? ''} options={countries} placeholder={t('qedit.country')} onChange={(v) => set('my_country', v)} /></F>
                 <F label={t('qedit.state')}><Input value={draft.my_state ?? ''} onChange={(e) => set('my_state', e.target.value)} /></F>
                 <F label={t('qedit.county')}><Input value={draft.my_cnty ?? ''} onChange={(e) => set('my_cnty', e.target.value)} /></F>
@@ -903,6 +946,10 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
               <div>
                 <p className="text-[11px] font-semibold text-muted-foreground uppercase tracking-wider mb-2">{t('qedit.powerWeather')}</p>
                 <div className="grid grid-cols-6 gap-3">
+                  {/* YOUR power first, then theirs. tx_pwr was saved by this
+                      editor but had no field: a contact logged at the wrong
+                      power could be read back and never corrected. */}
+                  <F label={t('qedit.txPower')}><Input type="number" value={draft.tx_pwr ?? ''} onChange={(e) => set('tx_pwr', numOrUndef(e.target.value) as any)} /></F>
                   <F label={t('qedit.rxPower')}><Input type="number" value={draft.rx_pwr ?? ''} onChange={(e) => set('rx_pwr', numOrUndef(e.target.value) as any)} /></F>
                   <F label={t('qedit.distance')}><Input type="number" value={draft.distance ?? ''} onChange={(e) => set('distance', numOrUndef(e.target.value) as any)} /></F>
                   <F label={t('qedit.aIndex')}><Input type="number" value={draft.a_index ?? ''} onChange={(e) => set('a_index', numOrUndef(e.target.value) as any)} /></F>

frontend/src/components/RecentQSOsGrid.tsx

@@ -70,8 +70,10 @@ type Props = {
   onSendEQSL?: (ids: number[]) => void;
   onBulkEdit?: (ids: number[]) => void;
   onExportSelected?: (ids: number[]) => void;
+  onExportSelectedFull?: (ids: number[]) => void;
   onExportSelectedFields?: (ids: number[]) => void;
   onExportFiltered?: () => void;
+  onExportFilteredFull?: () => void;
   onExportCabrilloSelected?: (ids: number[]) => void;
   onExportCabrilloFiltered?: () => void;
   onDelete?: (ids: number[]) => void;
@@ -207,6 +209,14 @@ export const makeColCatalog = (t: TFn, myGrid?: string): ColEntry[] => [
   { 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 },
+  // HAMLOG.online. No promoted column — the ADIF standard names a field for
+  // hamlog.EU and none for hamlog.ONLINE — so these read the extras, exactly
+  // like the OpsLog card columns above. Hidden by default: a column per
+  // service, shown to everyone, is how a grid becomes unreadable.
+  { group: 'Uploads', label: t('rqg.c.hamlog_sent'), colId: 'hamlog_sent', headerName: t('rqg.h.hamlog_sent'), width: 100, cellClass: qslStatusCellClass, valueGetter: (p) => { const e = (p.data as any)?.extras ?? {}; return e['APP_OPSLOG_HAMLOG_SENT'] || 'N'; }, defaultVisible: false },
+  { group: 'Uploads', label: t('rqg.c.hamlog_sent_date'), colId: 'hamlog_sent_date', headerName: t('rqg.h.hamlog_sent_date'), width: 110, valueGetter: (p) => fmtDateOnly((p.data as any)?.extras?.['APP_OPSLOG_HAMLOG_SENT_DATE']), defaultVisible: false },
+  { group: 'Uploads', label: t('rqg.c.hamlog_rcvd'), colId: 'hamlog_rcvd', headerName: t('rqg.h.hamlog_rcvd'), width: 100, cellClass: qslStatusCellClass, valueGetter: (p) => { const e = (p.data as any)?.extras ?? {}; return e['APP_HAMLOG_QSO_CFM'] || e['APP_OPSLOG_HAMLOG_QSL'] || 'N'; }, defaultVisible: false },
+  { group: 'Uploads', label: t('rqg.c.hamlog_rcvd_date'), colId: 'hamlog_rcvd_date', headerName: t('rqg.h.hamlog_rcvd_date'), width: 110, valueGetter: (p) => fmtDateOnly((p.data as any)?.extras?.['APP_OPSLOG_HAMLOG_QSL_DATE']), 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 },
 
@@ -309,7 +319,7 @@ const sanitizeAwardCols = (st: any[] | null | undefined): any[] =>
     return rest;
   });
 
-export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal, rowDragCall, passOrder, onGridApi, storageKey, onRowDoubleClicked, onRowClicked, onRowSelected, onRowSelectedQso, onUpdateFromCty, onUpdateFromQRZ, onUpdateFromClublog, onUpdateCountyFromULS, onSendTo, onSendRecording, onSendEQSL, onBulkEdit, onExportSelected, onExportSelectedFields, onExportFiltered, onExportCabrilloSelected, onExportCabrilloFiltered, onDelete, onFilteredCountChange, awardCols, rowColors }: Props) {
+export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal, rowDragCall, passOrder, onGridApi, storageKey, onRowDoubleClicked, onRowClicked, onRowSelected, onRowSelectedQso, onUpdateFromCty, onUpdateFromQRZ, onUpdateFromClublog, onUpdateCountyFromULS, onSendTo, onSendRecording, onSendEQSL, onBulkEdit, onExportSelected, onExportSelectedFull, onExportSelectedFields, onExportFiltered, onExportFilteredFull, onExportCabrilloSelected, onExportCabrilloFiltered, onDelete, onFilteredCountChange, awardCols, rowColors }: Props) {
   const { t } = useI18n();
   const gridRef = useRef<any>(null);
   const [pickerOpen, setPickerOpen] = useState(false);
@@ -741,8 +751,10 @@ export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal,
         onSendEQSL={onSendEQSL}
         onBulkEdit={onBulkEdit}
         onExportSelected={onExportSelected}
+        onExportSelectedFull={onExportSelectedFull}
         onExportSelectedFields={onExportSelectedFields}
         onExportFiltered={onExportFiltered}
+        onExportFilteredFull={onExportFilteredFull}
         onExportCabrilloSelected={onExportCabrilloSelected}
         onExportCabrilloFiltered={onExportCabrilloFiltered}
         onDelete={onDelete}

frontend/src/components/SettingsModal.tsx

@@ -4,6 +4,7 @@ import {
   ChevronDown, ChevronRight,
   User, Database, Radio, Cog, Server, Antenna as AntennaIcon,
   Compass, Wifi, Construction, UploadCloud, Loader2, FolderOpen, Play, Power, Check, Pencil,
+  Minimize2,
 } from 'lucide-react';
 import {
   GetLookupSettings, SaveLookupSettings, ClearLookupCache, TestLookupProvider,
@@ -12,7 +13,7 @@ import {
   ListProfiles, GetActiveProfile, SaveProfile, DeleteProfile, ActivateProfile, DuplicateProfile,
   GetRotators, SaveRotators, TestRotatorDevice, RotatorPark, RotatorStop,
   GetRotorPresets, SaveRotorPresets, ResetRotorPresets,
-  GetUltrabeamSettings, SaveUltrabeamSettings, TestUltrabeam,
+  GetUltrabeamSettings, SaveUltrabeamSettings, TestUltrabeam, CompactDatabase, CheckHamlogKey, CompareRDASources,
   GetAntGeniusSettings, SaveAntGeniusSettings,
   GetTunerGeniusSettings, SaveTunerGeniusSettings,
   GetPSUSettings, SavePSUSettings,
@@ -62,7 +63,7 @@ import {
 import type { profile as profileModels } from '../../wailsjs/go/models';
 import type { LookupSettingsForm, StationSettingsForm, ListsSettingsForm, ModePresetForm } from '@/types';
 import type { main as mainModels, cluster as clusterModels } from '../../wailsjs/go/models';
-import { EventsOn } from '../../wailsjs/runtime/runtime';
+import { EventsOn, BrowserOpenURL } from '../../wailsjs/runtime/runtime';
 
 import {
   Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter, DialogDescription,
@@ -208,7 +209,6 @@ type SectionId =
   | 'databases'
   | 'awards'
   | 'cat'
-  | 'ftx'
   | 'rotator'
   | 'winkeyer'
   | 'antenna'
@@ -313,7 +313,6 @@ function buildTree(flexAvailable: boolean, t: (k: string) => string): TreeNode[]
         { kind: 'item', label: t('sec.modes'), id: 'lists-modes' },
       ]},
       { kind: 'item', label: t('sec.cluster'),     id: 'cluster' },
-      { kind: 'item', label: t('sec.ftx'),         id: 'ftx' },
       { kind: 'item', label: t('sec.udp'), id: 'udp' },
       { kind: 'item', label: t('sec.adifmon'), id: 'adifmon' },
       { kind: 'item', label: t('sec.foldersync'), id: 'foldersync' },
@@ -342,7 +341,7 @@ function buildTree(flexAvailable: boolean, t: (k: string) => string): TreeNode[]
 const SECTION_KEY: Partial<Record<SectionId, string>> = {
   station: 'sec.station', profiles: 'sec.profiles', operating: 'sec.operating', confirmations: 'sec.confirmations',
   'external-services': 'sec.external', appearance: 'sec.appearance', lookup: 'sec.lookup', 'lists-bands': 'sec.bands', 'lists-modes': 'sec.modes',
-  cluster: 'sec.cluster', ftx: 'sec.ftx', backup: 'sec.backup', database: 'sec.database', autostart: 'sec.autostart', udp: 'sec.udp',
+  cluster: 'sec.cluster', backup: 'sec.backup', database: 'sec.database', autostart: 'sec.autostart', udp: 'sec.udp',
   adifmon: 'sec.adifmon',
   foldersync: 'sec.foldersync',
   webpublish: 'sec.webpublish',
@@ -1709,6 +1708,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     eqsl_sent: string; eqsl_rcvd: string;
     clublog_status: string; hrdlog_status: string; qrzcom_status: string;
     qrzcom_confirmed: string;
+    hamlog_status: string; hamlog_confirmed: string;
   };
   const [qslDefaults, setQslDefaults] = useState<QSLDefaults>({
     qsl_sent: '', qsl_rcvd: '',
@@ -1716,6 +1716,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     eqsl_sent: '', eqsl_rcvd: '',
     clublog_status: '', hrdlog_status: '', qrzcom_status: '',
     qrzcom_confirmed: '',
+    hamlog_status: '', hamlog_confirmed: '',
   });
 
   // External services (logbook upload). One block per service; only QRZ is
@@ -1731,7 +1732,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     // HRDLog only: publish the live frequency/mode/rig on hrdlog.net.
     on_air?: boolean;
   };
-  type ExternalServices = { qrz: ExtServiceCfg; clublog: ExtServiceCfg; lotw: ExtServiceCfg; hrdlog: ExtServiceCfg; eqsl: ExtServiceCfg; cloudlog: ExtServiceCfg; delete_remote?: boolean };
+  type ExternalServices = { qrz: ExtServiceCfg; clublog: ExtServiceCfg; lotw: ExtServiceCfg; hrdlog: ExtServiceCfg; eqsl: ExtServiceCfg; cloudlog: ExtServiceCfg; hamlog: ExtServiceCfg; delete_remote?: boolean };
   const emptyExtCfg = (): ExtServiceCfg => ({
     api_key: '', url: '', station_id: '', email: '', username: '', password: '', callsign: '', code: '', qth_nickname: '',
     force_station_callsign: '', tqsl_path: '', station_location: '', key_password: '',
@@ -1739,7 +1740,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     auto_upload: false, upload_mode: 'immediate', on_air: false,
   });
   const [extSvc, setExtSvc] = useState<ExternalServices>({
-    qrz: emptyExtCfg(), clublog: emptyExtCfg(), lotw: emptyExtCfg(), hrdlog: emptyExtCfg(), eqsl: emptyExtCfg(), cloudlog: emptyExtCfg(), delete_remote: false,
+    qrz: emptyExtCfg(), clublog: emptyExtCfg(), lotw: emptyExtCfg(), hrdlog: emptyExtCfg(), eqsl: emptyExtCfg(), cloudlog: emptyExtCfg(), hamlog: emptyExtCfg(), delete_remote: false,
   });
   const [qrzTest, setQrzTest] = useState<{ ok: boolean; msg: string } | null>(null);
   const [qrzTesting, setQrzTesting] = useState(false);
@@ -1800,7 +1801,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   // form: waiting for the modal's Save to see a colour on the waterfall would
   // make picking one a guessing game.
   type SpotColor = { text: string; bg?: string };
-  const [spotColors, setSpotColors] = useState<{ enabled: boolean; colors: Record<string, SpotColor> }>({ enabled: true, colors: {} });
+  const [spotColors, setSpotColors] = useState<{ enabled: boolean; colors: Record<string, SpotColor & { hide?: boolean }> }>({ enabled: true, colors: {} });
   useEffect(() => { GetSpotColors().then((c: any) => setSpotColors(c ?? { enabled: true, colors: {} })).catch(() => {}); }, []);
   const saveSpotColors = (next: { enabled: boolean; colors: Record<string, SpotColor> }) => {
     setSpotColors(next);
@@ -1838,11 +1839,35 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   };
   // A date for a person: the day, not the timestamp the backend stores.
   const fmtDay = (v?: string) => (v ? String(v).slice(0, 10) : '—');
+  // Binary units, one decimal, because the point of showing a size here is to
+  // compare two of them: "412.7 MB → 38.4 MB" says what a bare byte count does not.
+  const fmtBytes = (n: number) => {
+    if (!n || n < 0) return '—';
+    const u = ['B', 'KB', 'MB', 'GB'];
+    let i = 0;
+    let v = n;
+    while (v >= 1024 && i < u.length - 1) { v /= 1024; i++; }
+    return `${i === 0 ? v : v.toFixed(1)} ${u[i]}`;
+  };
   const [rdaCount, setRdaCount] = useState(0);
   const [rdaBusy, setRdaBusy] = useState(false);
   const [rdaUseCurrent, setRdaUseCurrent] = useState(true);
   const [rdaMsg, setRdaMsg] = useState<string | null>(null);
   useEffect(() => { RDADatabaseCount().then((n) => setRdaCount(Number(n) || 0)).catch(() => {}); }, []);
+  // Measuring the two sources against each other, before deciding which wins.
+  //
+  // Read-only on purpose: the question "is HAMLOG's district independent
+  // evidence or a copy of the same database?" has to be answered with the
+  // operator's own log, and answering it must not modify that log.
+  const [rdaCmp, setRdaCmp] = useState<any>(null);
+  const [rdaCmpBusy, setRdaCmpBusy] = useState(false);
+  const runRDACompare = async () => {
+    setRdaCmpBusy(true); setRdaCmp(null);
+    try { setRdaCmp(await CompareRDASources()); }
+    catch (e: any) { setRdaMsg(String(e?.message ?? e)); }
+    finally { setRdaCmpBusy(false); }
+  };
+
   const runRDABackfill = async () => {
     setRdaBusy(true); setRdaMsg(null);
     try {
@@ -1863,6 +1888,8 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   const [hrdlogTesting, setHrdlogTesting] = useState(false);
   const [cloudlogTest, setCloudlogTest] = useState<{ ok: boolean; msg: string } | null>(null);
   const [cloudlogTesting, setCloudlogTesting] = useState(false);
+  const [hamlogTest, setHamlogTest] = useState<{ ok: boolean; msg: string } | null>(null);
+  const [hamlogTesting, setHamlogTesting] = useState(false);
   const [eqslTest, setEqslTest] = useState<{ ok: boolean; msg: string } | null>(null);
   const [eqslTesting, setEqslTesting] = useState(false);
   const [stationLocations, setStationLocations] = useState<string[]>([]);
@@ -1870,7 +1897,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   // could not hold hooks at all; PanelHost lifted that restriction, and this
   // stays put because moving it down would reset the tab on every reopen —
   // a choice now, not a workaround.
-  const [extSvcTab, setExtSvcTab] = useState<'qrz' | 'clublog' | 'hrdlog' | 'eqsl' | 'lotw' | 'cloudlog' | 'pota'>('qrz');
+  const [extSvcTab, setExtSvcTab] = useState<'qrz' | 'clublog' | 'hrdlog' | 'eqsl' | 'lotw' | 'cloudlog' | 'hamlog' | 'pota'>('qrz');
   // POTA hunter-log sync (stamps pota_ref on local QSOs from your pota.app log).
   const [potaToken, setPotaToken] = useState('');
   const [potaBusy, setPotaBusy] = useState(false);
@@ -3578,7 +3605,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
           {isSerial ? (
             <div className="grid grid-cols-3 gap-3">
               <div className="space-y-1 col-span-2">
-                <Label>{t('hw.motorCom')}</Label>
+                <Label>{t('hw.motorCom')}{!isSteppir && <span className="ml-1.5 font-normal text-muted-foreground">{t('hw.motorComUb')}</span>}</Label>
                 {/* A list AND a text field, which is why this is a Combobox and
                     not the Select the other serial devices use: the port for a
                     USB adapter that is currently unplugged does not appear in
@@ -3591,6 +3618,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                     options={wkPorts}
                     allowFreeText
                     commitOnType
+                    showToggle
                     placeholder="COM3"
                     className="font-mono flex-1"
                     onChange={(v) => setUltrabeam((s) => ({ ...s, com: v.trim().toUpperCase() }))}
@@ -3601,12 +3629,19 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
               </div>
               <div className="space-y-1">
                 <Label>{t('hw.motorBaud')}</Label>
-                <Select value={String(ultrabeam.baud || 9600)} onValueChange={(v) => setUltrabeam((s) => ({ ...s, baud: parseInt(v, 10) || 9600 }))}>
+                {/* The Ultrabeam answers on 19200 and on nothing else, so there is
+                    no choice to offer — an FTDI cable opens at any speed, and a
+                    wrong one is indistinguishable from a dead controller. */}
+                {!isSteppir ? (
+                  <Input className="h-9 font-mono" value="19200" readOnly disabled />
+                ) : (
+                  <Select value={String(ultrabeam.baud || 9600)} onValueChange={(s2) => setUltrabeam((s) => ({ ...s, baud: parseInt(s2, 10) || 9600 }))}>
                     <SelectTrigger className="h-9"><SelectValue /></SelectTrigger>
                     <SelectContent>
-                    {[1200, 4800, 9600, 19200].map((b) => <SelectItem key={b} value={String(b)}>{b}</SelectItem>)}
+                      {[1200, 2400, 4800, 9600, 19200, 38400, 57600, 115200].map((b) => <SelectItem key={b} value={String(b)}>{b}</SelectItem>)}
                     </SelectContent>
                   </Select>
+                )}
               </div>
             </div>
           ) : (
@@ -4764,91 +4799,6 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     setEditingServer(next);
   }
 
-  // FTx decodes: what OpsLog does on its own with the digital stream.
-  //
-  // Auto-call KEYS THE TRANSMITTER without anyone clicking, so the panel is
-  // deliberately explicit about it: off by default, every criterion opt-in, and
-  // a plain statement of what the machine will do once it is on.
-  function FtxPanel() {
-    const set = (patch: Partial<AutoCallSettings>) => {
-      const next = { ...autoCall, ...patch };
-      setAutoCall(next);
-      writeUiPref(autoCallKey, JSON.stringify(next));
-    };
-    const crit = (which: 'criteria' | 'watchCriteria', k: keyof AutoCallCriteria) => (
-      <label key={k} className="flex items-center gap-1.5 text-xs cursor-pointer">
-        <Checkbox
-          checked={!!autoCall[which][k]}
-          onCheckedChange={(v) => set({ [which]: { ...autoCall[which], [k]: !!v } } as any)}
-        />
-        {t(`ftx.c_${k}`)}
-      </label>
-    );
-    const KEYS: (keyof AutoCallCriteria)[] = ['dxcc', 'bandmode', 'band', 'mode', 'slot', 'grid', 'county', 'pota', 'pfx'];
-    return (
-      <>
-        <SectionHeader title={t('sec.ftx')} hint={t('ftx.hint')} />
-        <div className="space-y-4">
-          <div className="rounded-md border border-border p-3 space-y-3">
-            <label className="flex items-start gap-2 text-sm cursor-pointer">
-              <Checkbox checked={autoCall.enabled} className="mt-0.5"
-                onCheckedChange={(v) => set({ enabled: !!v })} />
-              <span>
-                {t('ftx.enable')}{' '}
-                <span className="text-xs text-muted-foreground">{t('ftx.enableHint')}</span>
-              </span>
-            </label>
-
-            {autoCall.enabled && (
-              <div className="pl-6 space-y-3">
-                <div>
-                  <p className="text-xs font-semibold text-muted-foreground mb-1.5">{t('ftx.callWhen')}</p>
-                  <div className="grid grid-cols-2 gap-x-4 gap-y-1">{KEYS.map((k) => crit('criteria', k))}</div>
-                </div>
-
-                <div className="border-t border-border/60 pt-3">
-                  <p className="text-xs font-semibold text-muted-foreground mb-1">{t('ftx.watch')}</p>
-                  <p className="text-[11px] text-muted-foreground mb-1.5 leading-relaxed">{t('ftx.watchHint')}</p>
-                  <Textarea
-                    className="h-20 font-mono text-xs"
-                    placeholder={"4S7*\nTM0HQ\n*/P"}
-                    defaultValue={(autoCall.watch ?? []).join('\n')}
-                    key={`w-${(autoCall.watch ?? []).length}`}
-                    onBlur={(e) => set({
-                      watch: e.target.value.split('\n').map((x) => x.trim().toUpperCase()).filter(Boolean),
-                    })}
-                  />
-                  {(autoCall.watch ?? []).length > 0 && (
-                    <div className="mt-2">
-                      <p className="text-[11px] text-muted-foreground mb-1">{t('ftx.watchOnlyIf')}</p>
-                      <div className="grid grid-cols-2 gap-x-4 gap-y-1">{KEYS.map((k) => crit('watchCriteria', k))}</div>
-                    </div>
-                  )}
-                </div>
-
-                <div className="border-t border-border/60 pt-3 flex items-center gap-2 flex-wrap">
-                  <span className="text-xs text-muted-foreground">{t('ftx.cooldown')}</span>
-                  <Input type="number" min={10} max={3600} className="w-24 h-7 text-xs"
-                    defaultValue={autoCall.cooldownSec}
-                    key={`cd-${autoCall.cooldownSec}`}
-                    onBlur={(e) => {
-                      const v = parseInt(e.target.value, 10);
-                      if (!isNaN(v) && v >= 10 && v <= 3600) set({ cooldownSec: v });
-                    }} />
-                  <span className="text-xs text-muted-foreground">s</span>
-                </div>
-
-                <p className="text-[11px] rounded border border-warning-border bg-warning-muted text-warning-muted-foreground px-2 py-1.5 leading-relaxed">
-                  {t('ftx.warn')}
-                </p>
-              </div>
-            )}
-          </div>
-        </div>
-      </>
-    );
-  }
-
   function ClusterPanel() {
     const sorted = [...clusterServers].sort((a, b) => (a.sort_order ?? 0) - (b.sort_order ?? 0));
     // Written on every keystroke. This panel has no Save button, and a pair of
@@ -5272,9 +5222,6 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
           </div>
 
           <div className="border-t border-border/60 pt-3 space-y-3">
-            <div className="text-[11px] text-muted-foreground">
-              {t('conf.note')}
-            </div>
             {/* Clublog */}
             <div className="grid grid-cols-[150px_1fr_1fr] gap-3 items-end">
               <Label className="text-sm font-medium pb-1.5">Clublog</Label>
@@ -5305,6 +5252,18 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                 {renderSelect('qrzcom_confirmed', FULL_OPTIONS)}
               </div>
             </div>
+            {/* HAMLOG.online */}
+            <div className="grid grid-cols-[150px_1fr_1fr] gap-3 items-end">
+              <Label className="text-sm font-medium pb-1.5">HAMLOG.online</Label>
+              <div>
+                <Label className="text-[10px] text-muted-foreground uppercase tracking-wider mb-1 block">{t('conf.sent')}</Label>
+                {renderSelect('hamlog_status', FULL_OPTIONS)}
+              </div>
+              <div>
+                <Label className="text-[10px] text-muted-foreground uppercase tracking-wider mb-1 block">{t('conf.rcvd')}</Label>
+                {renderSelect('hamlog_confirmed', FULL_OPTIONS)}
+              </div>
+            </div>
           </div>
         </div>
       </>
@@ -5488,6 +5447,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
       { k: 'eqsl',    label: 'EQSL', ready: true },
       { k: 'lotw',    label: 'LOTW', ready: true },
       { k: 'cloudlog', label: 'CLOUDLOG', ready: true },
+      { k: 'hamlog',  label: 'HAMLOG.ONLINE', ready: true },
       { k: 'pota',    label: 'POTA', ready: true },
     ];
 
@@ -5557,6 +5517,30 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
       }
     }
 
+    const hamlog = extSvc.hamlog ?? emptyExtCfg();
+    const setHamlog = (patch: Partial<ExtServiceCfg>) =>
+      setExtSvc((s) => ({ ...s, hamlog: { ...(s.hamlog ?? emptyExtCfg()), ...patch } }));
+
+    // Checking the KEY, not the connection.
+    //
+    // HAMLOG answers KEYSTATUS with the callsign the key belongs to, which no
+    // other service here does — so the answer is shown as the callsign rather
+    // than a bare "OK". A key pasted from a club account or a second station is
+    // then visible immediately, which is exactly the mistake a green tick would
+    // have hidden.
+    async function testHamlog() {
+      setHamlogTesting(true);
+      setHamlogTest(null);
+      try {
+        const call = await CheckHamlogKey(hamlog.api_key ?? '');
+        setHamlogTest({ ok: true, msg: call ? t('es.hamlogKeyOkCall', { call }) : t('es.hamlogKeyOk') });
+      } catch (e: any) {
+        setHamlogTest({ ok: false, msg: String(e?.message ?? e) });
+      } finally {
+        setHamlogTesting(false);
+      }
+    }
+
     const cloudlog = extSvc.cloudlog;
     const setCloudlog = (patch: Partial<ExtServiceCfg>) =>
       setExtSvc((s) => ({ ...s, cloudlog: { ...s.cloudlog, ...patch } }));
@@ -5858,6 +5842,60 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
               </div>
             </div>
           </div>
+        ) : extSvcTab === 'hamlog' ? (
+          <div className="space-y-4 max-w-2xl">
+            <div className="grid grid-cols-[170px_1fr] gap-3 items-center">
+              <Label className="text-sm">{t('es.apiKey')}</Label>
+              <Input
+                type="password"
+                value={hamlog.api_key}
+                onChange={(e) => setHamlog({ api_key: e.target.value })}
+                className="text-xs"
+              />
+            </div>
+            <div className="text-[10px] text-muted-foreground -mt-1">
+              {t('es.hamlogHint')}{' '}
+              <button type="button" className="underline hover:text-foreground"
+                onClick={() => BrowserOpenURL('https://hamlog.online/account/agent.php')}>
+                hamlog.online/account/agent.php
+              </button>
+            </div>
+
+            <div className="border-t border-border/60 pt-3 space-y-3">
+              <label className="flex items-center gap-2 text-sm cursor-pointer">
+                <Checkbox
+                  checked={hamlog.auto_upload}
+                  onCheckedChange={(c) => setHamlog({ auto_upload: !!c })}
+                />
+                {t('es.autoUpload')}
+              </label>
+
+              <div className="grid grid-cols-[170px_1fr] gap-3 items-center">
+                <Label className="text-sm">{t('es.uploadTiming')}</Label>
+                <Select
+                  value={hamlog.upload_mode === 'delayed' ? 'delayed' : 'immediate'}
+                  onValueChange={(v) => setHamlog({ upload_mode: v })}
+                >
+                  <SelectTrigger className="h-8 w-64"><SelectValue /></SelectTrigger>
+                  <SelectContent>
+                    <SelectItem value="immediate">{t('es.immediate')}</SelectItem>
+                    <SelectItem value="delayed">{t('es.delayed')}</SelectItem>
+                  </SelectContent>
+                </Select>
+              </div>
+
+              <div className="flex items-center gap-3">
+                <Button variant="outline" size="sm" onClick={testHamlog} disabled={hamlogTesting}>
+                  <UploadCloud className="size-3.5" /> {hamlogTesting ? t('es.testing') : t('es.hamlogCheckKey')}
+                </Button>
+                {hamlogTest && (
+                  <span className={cn('text-xs', hamlogTest.ok ? 'text-success' : 'text-danger')}>
+                    {hamlogTest.msg}
+                  </span>
+                )}
+              </div>
+            </div>
+          </div>
         ) : extSvcTab === 'cloudlog' ? (
           <div className="space-y-4 max-w-2xl">
             <div className="grid grid-cols-[170px_1fr] gap-3 items-center">
@@ -6166,6 +6204,24 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   }
 
   function DatabasePanel() {
+    // Compacting: which database is running, and what the last one saved.
+    // SQLite frees pages inside the file and never shrinks it, so this is the
+    // only thing that gives the disk space back after a large delete.
+    const [compacting, setCompacting] = useState('');
+    const [compactMsg, setCompactMsg] = useState<Record<string, string>>({});
+    function compact(target: 'settings' | 'logbook') {
+      setCompacting(target);
+      setCompactMsg((m) => ({ ...m, [target]: '' }));
+      CompactDatabase(target)
+        .then((r: any) => {
+          const msg = r?.backend === 'mysql'
+            ? t('db.compactMysqlDone')
+            : t('db.compactDone', { before: fmtBytes(r?.before ?? 0), after: fmtBytes(r?.after ?? 0) });
+          setCompactMsg((m) => ({ ...m, [target]: msg }));
+        })
+        .catch((e: any) => setErr(String(e?.message ?? e)))
+        .finally(() => setCompacting(''));
+    }
     async function refreshDb() { try { setDbSettings(await GetDatabaseSettings() as any); } catch {} }
     async function refreshBackend() { try { setBackendStatus(await GetDBBackendStatus() as any); } catch {} }
     // The chosen file is persisted (config.json) the moment it's picked; dbMsg
@@ -6285,9 +6341,13 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             <Button variant="outline" size="sm" onClick={renameDb} title={t('db.renameTip')}><Pencil className="size-3.5" /> {t('db.rename')}</Button>
             {/* Pushed right: these two act on the file that is already there,
                 while the four on the left change WHICH file is in use. */}
-            <Button variant="outline" size="sm" className="ml-auto" onClick={revealFolder}><FolderOpen className="size-3.5" /> {t('db.openFolder')}</Button>
+            <Button variant="outline" size="sm" className="ml-auto" onClick={() => compact('settings')} disabled={compacting !== ''}>
+              {compacting === 'settings' ? <Loader2 className="size-3.5 animate-spin" /> : <Minimize2 className="size-3.5" />} {t('db.compact')}
+            </Button>
+            <Button variant="outline" size="sm" onClick={revealFolder}><FolderOpen className="size-3.5" /> {t('db.openFolder')}</Button>
             {dbSettings.is_custom && <Button variant="ghost" size="sm" onClick={resetDefault}>{t('db.resetDefault')}</Button>}
           </div>
+          {compactMsg.settings && <p className="text-[11px] text-success">{compactMsg.settings}</p>}
           {/* The DB pointer is only read at startup, so offer the restart inline. */}
           {dbMsg && (
             <div className="text-[11px] text-success space-y-1 pt-1">
@@ -6350,8 +6410,12 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             <Button variant="outline" size="sm" onClick={newLogbook}><Plus className="size-3.5" /> {t('db.newDb')}</Button>
             <Button variant="outline" size="sm" onClick={openLogbook}><FolderOpen className="size-3.5" /> {t('db.openExisting')}</Button>
             <Button variant="outline" size="sm" onClick={renameLogbook} title={t('db.renameLogbookTip')}><Pencil className="size-3.5" /> {t('db.renameLogbook')}</Button>
+            <Button variant="outline" size="sm" className="ml-auto" onClick={() => compact('logbook')} disabled={compacting !== ''}>
+              {compacting === 'logbook' ? <Loader2 className="size-3.5 animate-spin" /> : <Minimize2 className="size-3.5" />} {t('db.compact')}
+            </Button>
             {mysqlCfg.sqlite_path && <Button variant="ghost" size="sm" onClick={useLocalLogbook}>{t('db.useDefaultLogbook')}</Button>}
           </div>
+          {compactMsg.logbook && <p className="text-[11px] text-success">{compactMsg.logbook}</p>}
         </div>
         )}
 
@@ -6376,8 +6440,17 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
               {t('db.testCreate')}
             </Button>
             <Button size="sm" className="h-8" onClick={connectMysql}>{t('db.connectUse')}</Button>
+            {/* Compacting a shared logbook is OPTIMIZE TABLE, and it rebuilds the
+                table with everyone else waiting on it — hence the warning, and
+                hence its place here rather than beside the connection buttons of
+                a file only this operator uses. */}
+            <Button variant="outline" size="sm" className="h-8 ml-auto" title={t('db.compactMysqlWarn')}
+              onClick={() => compact('logbook')} disabled={compacting !== ''}>
+              {compacting === 'logbook' ? <Loader2 className="size-3.5 animate-spin" /> : <Minimize2 className="size-3.5" />} {t('db.compact')}
+            </Button>
             <span className="text-[11px] text-muted-foreground">{mysqlMsg}</span>
           </div>
+          {compactMsg.logbook && <p className="text-[11px] text-success">{compactMsg.logbook}</p>}
         </div>
         )}
 
@@ -7161,6 +7234,56 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
           </div>
           <p className="text-[11px] text-muted-foreground">{t('rda.neverOverwrites')}</p>
         </div>
+
+        {/* Comparing the two sources. Read-only: it answers a question about the
+            log without touching it. */}
+        <div className="rounded-md border border-border p-3 space-y-2">
+          <div className="text-xs font-medium">{t('rda.cmpTitle')}</div>
+          <div className="flex items-center gap-3">
+            <Button size="sm" variant="secondary" onClick={runRDACompare} disabled={rdaCmpBusy}>
+              {rdaCmpBusy ? <Loader2 className="size-3.5 animate-spin mr-1.5" /> : null}
+              {t('rda.cmpRun')}
+            </Button>
+            {rdaCmp && (
+              <span className="text-xs text-muted-foreground">
+                {t('rda.cmpDone', {
+                  s: rdaCmp.scanned ?? 0, a: rdaCmp.agree ?? 0, d: rdaCmp.disagree ?? 0,
+                  l: rdaCmp.only_log ?? 0, b: rdaCmp.only_db ?? 0,
+                })}
+              </span>
+            )}
+          </div>
+          {/* The disagreements themselves. A count alone would say "there is a
+              problem" and leave the operator with no way to look at it. */}
+          {rdaCmp?.conflicts?.length > 0 && (
+            <div className="max-h-56 overflow-auto rounded border border-border">
+              <table className="w-full text-[11px]">
+                <thead className="sticky top-0 bg-card text-left text-muted-foreground border-b border-border">
+                  <tr>
+                    <th className="py-1 px-2 font-medium">{t('rda.cmpCall')}</th>
+                    <th className="py-1 pr-2 font-medium">{t('rda.cmpDate')}</th>
+                    <th className="py-1 pr-2 font-medium">{t('rda.cmpFromLog')}</th>
+                    <th className="py-1 pr-2 font-medium">{t('rda.cmpFromDb')}</th>
+                    <th className="py-1 pr-2 font-medium">{t('rda.cmpKind')}</th>
+                  </tr>
+                </thead>
+                <tbody>
+                  {rdaCmp.conflicts.map((c: any) => (
+                    <tr key={c.qso_id} className="border-b border-border/30">
+                      <td className="py-1 px-2 font-mono font-semibold">{c.callsign}</td>
+                      <td className="py-1 pr-2 font-mono">{c.date}</td>
+                      <td className="py-1 pr-2 font-mono">{c.from_log}{c.confirmed ? ' ✓' : ''}</td>
+                      <td className="py-1 pr-2 font-mono">{c.from_db}</td>
+                      <td className="py-1 pr-2 text-muted-foreground">
+                        {c.dated ? t('rda.cmpDated') : t('rda.cmpCurrent')}
+                      </td>
+                    </tr>
+                  ))}
+                </tbody>
+              </table>
+            </div>
+          )}
+        </div>
       </div>
     );
   }
@@ -7179,7 +7302,6 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     'lists-bands':  BandsPanel,
     'lists-modes':  ModesPanel,
     cluster:        ClusterPanel,
-    ftx:            FtxPanel,
     udp:            UDPIntegrationsPanelWrapper,
     // Module-scope components, wrapped so their props can be passed. The nested
     // panels below go through PanelHost instead — which is what now lets either
@@ -7289,7 +7411,11 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                 const c = spotColors.colors[k] ?? { text: '', bg: '' };
                 return (
                   <div key={k} className="flex items-center gap-3 px-3 py-1.5">
-                    <span className="text-xs flex-1 min-w-0">{t('spotcol.s_' + k)}</span>
+                    {/* Sent to the radio at all. First in the row because it
+                        decides whether the colours next to it mean anything. */}
+                    <Checkbox checked={!c.hide} title={t('spotcol.send')}
+                      onCheckedChange={(v) => setSpotColor(k, { hide: !v } as any)} />
+                    <span className={cn('text-xs flex-1 min-w-0', c.hide && 'opacity-40 line-through')}>{t('spotcol.s_' + k)}</span>
                     {/* The preview is the point of the row: two colour boxes say
                         nothing about what the pair looks like together. */}
                     <span className="text-xs font-mono px-2 py-0.5 rounded"

frontend/src/components/WinkeyerPanel.tsx

@@ -73,9 +73,17 @@ export function WinkeyerPanel({
 
   const connected = status.connected;
 
+  // Send-on-type only exists where the engine can key one character at a time:
+  // the WinKeyer and Flex CWX. The stored preference survives an engine change,
+  // though, and an Icom or Yaesu operator inherited a hidden switch that was on
+  // — the checkbox is not shown for them, so nothing keyed as they typed AND
+  // Enter sent nothing either, since it believes the text has already gone.
+  // Macros kept working, which is exactly how it looked from the outside.
+  const liveType = sendOnType && (source === 'winkeyer' || source === 'flex');
+
   function sendText() {
     const t = cwText.trim();
-    if (t && !sendOnType) onSend(t); // in send-on-type the text already went out
+    if (t && !liveType) onSend(t); // in send-on-type the text already went out
     setCwText('');
   }
 
@@ -83,7 +91,7 @@ export function WinkeyerPanel({
   // WinKeyer backspace for each deleted char (removes it from the buffer if it
   // hasn't been keyed yet). Only end-of-string edits are mirrored live.
   function onCwChange(v: string) {
-    if (sendOnType && connected) {
+    if (liveType && connected) {
       const old = cwText;
       if (v.length > old.length && v.startsWith(old)) {
         onSendRaw(v.slice(old.length));
@@ -200,13 +208,13 @@ export function WinkeyerPanel({
               value={cwText}
               onChange={(e) => onCwChange(e.target.value)}
               onKeyDown={(e) => { if (e.key === 'Enter') { e.preventDefault(); sendText(); } }}
-              placeholder={sendOnType ? t('wkp.phLive') : t('wkp.phEnter')}
+              placeholder={liveType ? t('wkp.phLive') : t('wkp.phEnter')}
               disabled={!connected}
               className="font-mono uppercase"
             />
           </div>
           <Button size="sm" className="h-8" onClick={sendText} disabled={!connected}>
-            <Send className="size-3.5" /> {sendOnType ? t('wkp.clear') : t('wkp.send')}
+            <Send className="size-3.5" /> {liveType ? t('wkp.clear') : t('wkp.send')}
           </Button>
           <Button variant="destructive" size="sm" className="h-8" onClick={onStop} disabled={!connected} title={t('wkp.abort')}>
             <Square className="size-3.5" /> {t('wkp.stop')}

frontend/src/components/WorkedBeforeGrid.tsx

@@ -41,6 +41,7 @@ type Props = {
   onSendEQSL?: (ids: number[]) => void;
   onBulkEdit?: (ids: number[]) => void;
   onExportSelected?: (ids: number[]) => void;
+  onExportSelectedFull?: (ids: number[]) => void;
   onExportSelectedFields?: (ids: number[]) => void;
   onExportCabrilloSelected?: (ids: number[]) => void;
   onDelete?: (ids: number[]) => void;
@@ -58,7 +59,7 @@ function fmtDate(s: any): string {
   return `${d.getUTCFullYear()}-${p(d.getUTCMonth() + 1)}-${p(d.getUTCDate())}`;
 }
 
-export function WorkedBeforeGrid({ wb, myGrid, busy, currentCall, onRowDoubleClicked, onUpdateFromCty, onUpdateFromQRZ, onUpdateFromClublog, onUpdateCountyFromULS, onSendTo, onSendRecording, onSendEQSL, onBulkEdit, onExportSelected, onExportSelectedFields, onExportCabrilloSelected, onDelete, awardCols }: Props) {
+export function WorkedBeforeGrid({ wb, myGrid, busy, currentCall, onRowDoubleClicked, onUpdateFromCty, onUpdateFromQRZ, onUpdateFromClublog, onUpdateCountyFromULS, onSendTo, onSendRecording, onSendEQSL, onBulkEdit, onExportSelected, onExportSelectedFull, onExportSelectedFields, onExportCabrilloSelected, onDelete, awardCols }: Props) {
   const { t } = useI18n();
   const gridRef = useRef<any>(null);
   const [pickerOpen, setPickerOpen] = useState(false);
@@ -279,6 +280,7 @@ export function WorkedBeforeGrid({ wb, myGrid, busy, currentCall, onRowDoubleCli
         onSendEQSL={onSendEQSL}
         onBulkEdit={onBulkEdit}
         onExportSelected={onExportSelected}
+        onExportSelectedFull={onExportSelectedFull}
         onExportSelectedFields={onExportSelectedFields}
         onExportCabrilloSelected={onExportCabrilloSelected}
         onDelete={onDelete}

frontend/src/components/YaesuPanel.tsx

@@ -3,7 +3,7 @@ import { Radio, AudioLines, Mic, Activity, SlidersHorizontal, Antenna } from 'lu
 import {
   GetYaesuState, RefreshYaesuPanel,
   SetYaesuPower, SetYaesuMicGain, SetYaesuAFGain, SetYaesuRFGain, SetYaesuSquelch,
-  SetYaesuAGC, SetYaesuPreamp, SetYaesuAtt, SetYaesuNB, SetYaesuNR, SetYaesuNRLevel,
+  SetYaesuAGC, SetYaesuPreamp, SetYaesuAtt, SetYaesuAntenna, SetYaesuNB, SetYaesuNR, SetYaesuNRLevel,
   SetYaesuNarrow, SetYaesuVOX, SetYaesuSplit, SetYaesuBand, TuneYaesuATU,
   SetYaesuModeRaw, SetYaesuSplitOffset, SetYaesuKeySpeed, SetYaesuBreakIn, YaesuZeroIn, GetCATState,
 } from '../../wailsjs/go/main/App';
@@ -17,7 +17,7 @@ type YaesuState = {
   transmitting: boolean; split: boolean;
   s_meter: number; power_meter: number; swr_meter: number;
   rf_power: number; mic_gain: number; af_gain: number; rf_gain: number; squelch: number;
-  agc?: string; preamp: number; att: number;
+  agc?: string; preamp: number; att: number; antenna: number;
   nb: boolean; nr: boolean; nr_level: number; narrow: boolean; vox: boolean;
   split_tx_hz?: number; key_speed?: number; break_in?: boolean; swr?: number; power_w?: number;
 };
@@ -26,7 +26,7 @@ const ZERO: YaesuState = {
   available: false, transmitting: false, split: false,
   s_meter: 0, power_meter: 0, swr_meter: 0,
   rf_power: 0, mic_gain: 0, af_gain: 0, rf_gain: 0, squelch: 0,
-  preamp: 0, att: 0, nb: false, nr: false, nr_level: 0, narrow: false, vox: false,
+  preamp: 0, att: 0, antenna: 0, nb: false, nr: false, nr_level: 0, narrow: false, vox: false,
 };
 
 // Band buttons use the rig's OWN band memory (CAT "BS"), not a frequency we
@@ -74,6 +74,10 @@ function activeMode(raw?: string): { id: string; side: 'U' | 'L' } | null {
 // IPO bypasses the preamp entirely (best on a quiet, high-signal band), AMP1 and
 // AMP2 add gain. Presenting it as a toggle would hide the middle position.
 const PREAMPS = [{ v: '0', l: 'IPO' }, { v: '1', l: 'AMP1' }, { v: '2', l: 'AMP2' }];
+// Three jacks is the most any of these rigs has (FTDX101); an FTDX10 answers
+// with 1 or 2 and the third button simply never gets used. A rig with a single
+// socket answers nothing at all and reports 0, and the row is not drawn.
+const ANTENNAS = [{ v: '1', l: 'ANT1' }, { v: '2', l: 'ANT2' }, { v: '3', l: 'ANT3' }];
 const AGCS = [{ v: 'FAST', l: 'FAST' }, { v: 'MID', l: 'MID' }, { v: 'SLOW', l: 'SLOW' }, { v: 'AUTO', l: 'AUTO' }];
 // The attenuator is a three-step pad on these rigs (6/12/18 dB), not a toggle.
 const ATTS = [{ v: '0', l: 'OFF' }, { v: '6', l: '6dB' }, { v: '12', l: '12dB' }, { v: '18', l: '18dB' }];
@@ -424,6 +428,16 @@ export function YaesuPanel({ onReportRST, onKeySpeed }: {
         <Row label="ATT">
           <Segmented value={String(view.att)} options={ATTS} onChange={(v) => push('att', parseInt(v, 10), () => SetYaesuAtt(parseInt(v, 10)))} />
         </Row>
+        {/* Only on a rig that HAS a choice: 0 means the AN command went
+            unanswered, which is what a single-socket FT-891 does. And the
+            choice is remembered for the band it was made on — no table to
+            fill in anywhere, the backend learns it here. */}
+        {view.antenna > 0 && (
+          <Row label="ANT">
+            <Segmented value={String(view.antenna)} options={ANTENNAS}
+              onChange={(v) => push('antenna', parseInt(v, 10), () => SetYaesuAntenna(parseInt(v, 10)))} />
+          </Row>
+        )}
       </Card>
 
       {/* Noise + filter */}

frontend/src/components/ui/combobox.tsx

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

frontend/src/lib/autocall.ts

@@ -1,5 +1,18 @@
 // Auto-call: let OpsLog answer a decode without the operator clicking it.
 //
+// WITHDRAWN FROM THE INTERFACE, because DXHunter already does it.
+//
+// Two programs from the same shack deciding on their own to answer the same
+// decode is worse than either doing it alone: they cannot see each other, so
+// they key over one another, and afterwards there is no telling which of them
+// called. The duplicate is the one to remove, and DXHunter is where this lives.
+//
+// There is no switch in Preferences and no button on the decodes toolbar, and
+// App.tsx returns before the loop can run. The file is kept whole: the rules
+// below are the delicate part, argued over and tested, and rewriting them from
+// memory later would be worse than leaving them here. Reinstating the feature
+// means restoring all three — the settings page, the button, and the guard.
+//
 // This KEYS THE TRANSMITTER on its own, which is why the rules here are written
 // as a series of refusals rather than a search for a reason to call. Everything
 // below has to be true; anything unknown means no.
@@ -154,9 +167,20 @@ export function shouldAutoCall(
   if (!call) return no('no callsign');
   // Never answer ourselves, however the decode reached us.
   if (opts.myCall && call === opts.myCall.trim().toUpperCase()) return no('own callsign');
-  // Only a CQ. Answering a station mid-QSO is both rude and futile — WSJT-X
-  // actions a Reply only for CQ and QRZ anyway.
-  if (!d.cq) return no('not a CQ');
+  // NOT limited to a CQ, deliberately.
+  //
+  // It used to be, on the reasoning that answering a station mid-QSO is calling
+  // over somebody. That reasoning ignored the case the feature exists for: a
+  // DXpedition running a pileup never sends CQ at all — it works caller after
+  // caller — so the rule sat out the one contact auto-call was turned on for. A
+  // new entity on 15 m FT8, decode after decode, and not a single transmission.
+  //
+  // WHEN to transmit is not ours to decide either: the Reply goes to the
+  // decoder, and MSHV starts at once while JTDX waits for a CQ. Two correct
+  // behaviours, both belonging to the program that owns the timing. Here the
+  // question is only whether the station is one the operator wants — the
+  // criteria below answer that, and the cooldown and the busy check keep it from
+  // calling twice.
   // Not while ANY receiver is mid-QSO — transmitting, or holding a DX call it
   // has not finished with. Starting a second exchange before the first is done
   // is what turned this into a machine that called without stopping.

frontend/src/lib/rowColors.ts

@@ -26,7 +26,7 @@ export type RowColorSettings = {
 // otherwise keep striping underneath whatever we do per row.
 const ZEBRA_DEFAULT = 'color-mix(in srgb, var(--muted) 40%, var(--card))';
 
-export const CHANNELS = ['qsl', 'lotw', 'eqsl', 'qrz'] as const;
+export const CHANNELS = ['qsl', 'lotw', 'eqsl', 'qrz', 'hamlog'] as const;
 
 // The two QSO fields behind each channel. QRZ.com and Club Log call theirs an
 // "upload status" rather than a QSL flag, but they carry the same Y / R letters.
@@ -37,6 +37,24 @@ const FIELDS: Record<string, { sent: string; rcvd: string }> = {
   qrz: { sent: 'qrzcom_qso_upload_status', rcvd: 'qrzcom_qso_download_status' },
 };
 
+// HAMLOG.online has no column of its own: the ADIF standard names a field for
+// hamlog.EU and none for hamlog.ONLINE, so its state lives in the extras — see
+// internal/award/award.go, which reads the same keys for award confirmations.
+// One vocabulary, two readers.
+const HAMLOG_SENT = 'APP_OPSLOG_HAMLOG_SENT';
+const HAMLOG_RCVD = ['APP_HAMLOG_QSO_CFM', 'APP_OPSLOG_HAMLOG_QSL', 'APP_HAMLOG_QSL', 'APP_HAMLOGONLINE_QSL', 'HAMLOG_QSL_RCVD'];
+
+// hamlogState reads a row's extras. Any value that is not an explicit "no"
+// counts, because their export could carry a date or a match id rather than Y.
+function hamlogState(q: any, which: 'sent' | 'rcvd'): boolean {
+  const e = (q?.extras ?? {}) as Record<string, string>;
+  const keys = which === 'sent' ? [HAMLOG_SENT] : HAMLOG_RCVD;
+  return keys.some((k) => {
+    const v = String(e[k] ?? '').trim();
+    return v !== '' && v.toUpperCase() !== 'N' && v.toUpperCase() !== 'NO';
+  });
+}
+
 // ADIF QSL fields are single letters. Y is the only one that means "yes";
 // R (requested) and Q (queued) mean it has not gone out yet — a different state,
 // and the one an operator looks for when deciding what to send.
@@ -55,14 +73,18 @@ function ruleMatches(q: any, r: RowColorRule): boolean {
   const cs = chansOf(r);
   switch (r.id) {
     case 'confirmed':
-      return cs.some((c) => yes(q[FIELDS[c]?.rcvd]));
+      return cs.some((c) => (c === 'hamlog' ? hamlogState(q, 'rcvd') : yes(q[FIELDS[c]?.rcvd])));
     case 'sent':
-      return cs.some((c) => yes(q[FIELDS[c]?.sent]));
+      return cs.some((c) => (c === 'hamlog' ? hamlogState(q, 'sent') : yes(q[FIELDS[c]?.sent])));
     case 'to_send':
-      return cs.some((c) => owed(q[FIELDS[c]?.sent]));
+      // Nothing to request from HAMLOG: a QSO is either uploaded or it is not,
+      // there is no "card asked for" state to be owed.
+      return cs.some((c) => c !== 'hamlog' && owed(q[FIELDS[c]?.sent]));
     case 'worked':
       // The catch-all: nothing sent, nothing asked for, nothing back.
-      return !CHANNELS.some((c) => yes(q[FIELDS[c].rcvd]) || yes(q[FIELDS[c].sent]) || owed(q[FIELDS[c].sent]));
+      return !CHANNELS.some((c) => (c === 'hamlog'
+        ? hamlogState(q, 'rcvd') || hamlogState(q, 'sent')
+        : yes(q[FIELDS[c].rcvd]) || yes(q[FIELDS[c].sent]) || owed(q[FIELDS[c].sent])));
     default:
       return false;
   }

frontend/src/style.css

@@ -991,6 +991,18 @@
 @layer base {
   * { @apply border-border; }
   html, body, #root { height: 100%; }
+  /* No rubber-band, and no swipe-to-navigate.
+
+     Chromium lets a scroll that has reached the end pull the content a few
+     pixels and spring back, and a two-finger horizontal swipe means "go back a
+     page". Both are browser behaviours that have no meaning in a logbook: the
+     first makes a table wobble at the bottom of a list, and the second can
+     navigate the WebView away from the app entirely — a blank window and a
+     restart. Neither shows up with a mouse, which is why they went unnoticed;
+     they arrive with a precision touchpad or a touchscreen.
+
+     A no-op wherever the effects don't occur. */
+  html, body { overscroll-behavior: none; }
   /* Root rem base. Tailwind sizing (text/heights/padding/gaps) is in rem, so
      this is the single global density knob — shrinks the whole UI uniformly
      while Leaflet maps (px-based) stay correct. Default browser base is 16px. */
@@ -1055,3 +1067,15 @@
   filter: invert(1) brightness(1.8);
   opacity: 0.9;
 }
+
+/* Every scrollable pane keeps its overscroll to itself.
+
+   "contain" (not "none") on the inside: the pane still scrolls normally, it
+   simply stops passing the leftover motion up to its parent — which is how
+   scrolling a grid to its end used to tug the panel behind it. */
+.overflow-auto,
+.overflow-y-auto,
+.overflow-x-auto,
+.overflow-scroll {
+  overscroll-behavior: contain;
+}

frontend/src/version.ts

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

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

@@ -117,12 +117,18 @@ export function ChatAvailable():Promise<boolean>;
 
 export function CheckForUpdate():Promise<main.UpdateInfo>;
 
+export function CheckHamlogKey(arg1:string):Promise<string>;
+
 export function ClearLookupCache():Promise<void>;
 
 export function CloseAutostartPrograms():Promise<void>;
 
 export function ClusterSpotStatuses(arg1:Array<main.SpotQuery>):Promise<Array<main.SpotStatus>>;
 
+export function CompactDatabase(arg1:string):Promise<main.CompactResult>;
+
+export function CompareRDASources():Promise<main.RDACompareResult>;
+
 export function ComputeQSOAwardRefs(arg1:qso.QSO):Promise<Array<main.QSOAwardRef>>;
 
 export function ComputeStationInfo(arg1:string,arg2:string):Promise<main.StationInfoComputed>;
@@ -227,6 +233,8 @@ export function ExportCabrilloFiltered(arg1:string,arg2:qso.QueryFilter):Promise
 
 export function ExportCabrilloSelected(arg1:string,arg2:Array<number>):Promise<main.CabrilloResult>;
 
+export function ExportHamlogUnmatched(arg1:string):Promise<number>;
+
 export function FilterFields():Promise<Array<string>>;
 
 export function FindDuplicates(arg1:number):Promise<Array<main.DuplicateGroup>>;
@@ -369,6 +377,8 @@ export function FlexTune(arg1:boolean):Promise<void>;
 
 export function FlexZoomForSpot(arg1:string,arg2:number):Promise<void>;
 
+export function ForgetYaesuBandAntenna(arg1:string):Promise<void>;
+
 export function GetACOMStatus():Promise<acom.Status>;
 
 export function GetADIFMonitor():Promise<main.ADIFMonitorConfig>;
@@ -461,6 +471,8 @@ export function GetFlexBandAntennas():Promise<Record<string, main.FlexBandAnt>>;
 
 export function GetFlexBandPower():Promise<Record<string, main.FlexBandPower>>;
 
+export function GetFlexRSTChase():Promise<main.FlexRSTChase>;
+
 export function GetFlexState():Promise<cat.FlexTXState>;
 
 export function GetFlexZoom():Promise<main.FlexZoomSettings>;
@@ -583,6 +595,8 @@ export function GetWinkeyerStatus():Promise<winkeyer.Status>;
 
 export function GetWorkedCallVariants():Promise<boolean>;
 
+export function GetYaesuBandAntennas():Promise<Record<string, number>>;
+
 export function GetYaesuState():Promise<cat.YaesuTXState>;
 
 export function GridSquares(arg1:string):Promise<Array<qso.GridSquare>>;
@@ -683,6 +697,8 @@ export function ImportAwardReferencesText(arg1:string,arg2:string):Promise<numbe
 
 export function ImportAwards():Promise<main.AwardImportResult>;
 
+export function ImportHamlogConfirmations(arg1:string):Promise<main.HamlogCfmResult>;
+
 export function InspectAwardImport():Promise<main.AwardImportPreview>;
 
 export function IsNewUSCounty(arg1:string,arg2:string):Promise<boolean>;
@@ -977,6 +993,8 @@ export function SaveFlexBandAntennas(arg1:Record<string, main.FlexBandAnt>):Prom
 
 export function SaveFlexBandPower(arg1:Record<string, main.FlexBandPower>):Promise<void>;
 
+export function SaveFlexRSTChase(arg1:main.FlexRSTChase):Promise<void>;
+
 export function SaveFlexZoom(arg1:main.FlexZoomSettings):Promise<void>;
 
 export function SaveFolderSync(arg1:main.FolderSyncConfig):Promise<void>;
@@ -1079,6 +1097,8 @@ export function SetCompactMode(arg1:boolean):Promise<void>;
 
 export function SetDVKLabel(arg1:number,arg2:string):Promise<void>;
 
+export function SetFlexRSTChaseEnabled(arg1:boolean):Promise<void>;
+
 export function SetKenwoodKeySpeed(arg1:number):Promise<void>;
 
 export function SetLinkedAmps(arg1:Array<string>):Promise<void>;
@@ -1109,6 +1129,8 @@ export function SetYaesuAFGain(arg1:number):Promise<void>;
 
 export function SetYaesuAGC(arg1:string):Promise<void>;
 
+export function SetYaesuAntenna(arg1:number):Promise<void>;
+
 export function SetYaesuAtt(arg1:number):Promise<void>;
 
 export function SetYaesuBand(arg1:string):Promise<void>;
@@ -1237,6 +1259,8 @@ export function WinkeyerTraceEnabled():Promise<boolean>;
 
 export function WorkedBefore(arg1:string,arg2:number):Promise<qso.WorkedBefore>;
 
+export function YaesuApplyBandAntenna(arg1:string):Promise<void>;
+
 export function YaesuSendCW(arg1:string):Promise<void>;
 
 export function YaesuStopCW():Promise<void>;

frontend/wailsjs/go/main/App.js

@@ -174,6 +174,10 @@ export function CheckForUpdate() {
   return window['go']['main']['App']['CheckForUpdate']();
 }
 
+export function CheckHamlogKey(arg1) {
+  return window['go']['main']['App']['CheckHamlogKey'](arg1);
+}
+
 export function ClearLookupCache() {
   return window['go']['main']['App']['ClearLookupCache']();
 }
@@ -186,6 +190,14 @@ export function ClusterSpotStatuses(arg1) {
   return window['go']['main']['App']['ClusterSpotStatuses'](arg1);
 }
 
+export function CompactDatabase(arg1) {
+  return window['go']['main']['App']['CompactDatabase'](arg1);
+}
+
+export function CompareRDASources() {
+  return window['go']['main']['App']['CompareRDASources']();
+}
+
 export function ComputeQSOAwardRefs(arg1) {
   return window['go']['main']['App']['ComputeQSOAwardRefs'](arg1);
 }
@@ -394,6 +406,10 @@ export function ExportCabrilloSelected(arg1, arg2) {
   return window['go']['main']['App']['ExportCabrilloSelected'](arg1, arg2);
 }
 
+export function ExportHamlogUnmatched(arg1) {
+  return window['go']['main']['App']['ExportHamlogUnmatched'](arg1);
+}
+
 export function FilterFields() {
   return window['go']['main']['App']['FilterFields']();
 }
@@ -678,6 +694,10 @@ export function FlexZoomForSpot(arg1, arg2) {
   return window['go']['main']['App']['FlexZoomForSpot'](arg1, arg2);
 }
 
+export function ForgetYaesuBandAntenna(arg1) {
+  return window['go']['main']['App']['ForgetYaesuBandAntenna'](arg1);
+}
+
 export function GetACOMStatus() {
   return window['go']['main']['App']['GetACOMStatus']();
 }
@@ -862,6 +882,10 @@ export function GetFlexBandPower() {
   return window['go']['main']['App']['GetFlexBandPower']();
 }
 
+export function GetFlexRSTChase() {
+  return window['go']['main']['App']['GetFlexRSTChase']();
+}
+
 export function GetFlexState() {
   return window['go']['main']['App']['GetFlexState']();
 }
@@ -1106,6 +1130,10 @@ export function GetWorkedCallVariants() {
   return window['go']['main']['App']['GetWorkedCallVariants']();
 }
 
+export function GetYaesuBandAntennas() {
+  return window['go']['main']['App']['GetYaesuBandAntennas']();
+}
+
 export function GetYaesuState() {
   return window['go']['main']['App']['GetYaesuState']();
 }
@@ -1306,6 +1334,10 @@ export function ImportAwards() {
   return window['go']['main']['App']['ImportAwards']();
 }
 
+export function ImportHamlogConfirmations(arg1) {
+  return window['go']['main']['App']['ImportHamlogConfirmations'](arg1);
+}
+
 export function InspectAwardImport() {
   return window['go']['main']['App']['InspectAwardImport']();
 }
@@ -1894,6 +1926,10 @@ export function SaveFlexBandPower(arg1) {
   return window['go']['main']['App']['SaveFlexBandPower'](arg1);
 }
 
+export function SaveFlexRSTChase(arg1) {
+  return window['go']['main']['App']['SaveFlexRSTChase'](arg1);
+}
+
 export function SaveFlexZoom(arg1) {
   return window['go']['main']['App']['SaveFlexZoom'](arg1);
 }
@@ -2098,6 +2134,10 @@ export function SetDVKLabel(arg1, arg2) {
   return window['go']['main']['App']['SetDVKLabel'](arg1, arg2);
 }
 
+export function SetFlexRSTChaseEnabled(arg1) {
+  return window['go']['main']['App']['SetFlexRSTChaseEnabled'](arg1);
+}
+
 export function SetKenwoodKeySpeed(arg1) {
   return window['go']['main']['App']['SetKenwoodKeySpeed'](arg1);
 }
@@ -2158,6 +2198,10 @@ export function SetYaesuAGC(arg1) {
   return window['go']['main']['App']['SetYaesuAGC'](arg1);
 }
 
+export function SetYaesuAntenna(arg1) {
+  return window['go']['main']['App']['SetYaesuAntenna'](arg1);
+}
+
 export function SetYaesuAtt(arg1) {
   return window['go']['main']['App']['SetYaesuAtt'](arg1);
 }
@@ -2414,6 +2458,10 @@ export function WorkedBefore(arg1, arg2) {
   return window['go']['main']['App']['WorkedBefore'](arg1, arg2);
 }
 
+export function YaesuApplyBandAntenna(arg1) {
+  return window['go']['main']['App']['YaesuApplyBandAntenna'](arg1);
+}
+
 export function YaesuSendCW(arg1) {
   return window['go']['main']['App']['YaesuSendCW'](arg1);
 }

frontend/wailsjs/go/models.ts

@@ -1160,6 +1160,7 @@ export namespace cat {
 	    squelch: number;
 	    agc?: string;
 	    preamp: number;
+	    antenna: number;
 	    att: number;
 	    nb: boolean;
 	    nr: boolean;
@@ -1194,6 +1195,7 @@ export namespace cat {
 	        this.squelch = source["squelch"];
 	        this.agc = source["agc"];
 	        this.preamp = source["preamp"];
+	        this.antenna = source["antenna"];
 	        this.att = source["att"];
 	        this.nb = source["nb"];
 	        this.nr = source["nr"];
@@ -1367,6 +1369,7 @@ export namespace extsvc {
 	    hrdlog: ServiceConfig;
 	    eqsl: ServiceConfig;
 	    cloudlog: ServiceConfig;
+	    hamlog: ServiceConfig;
 	    delete_remote: boolean;
 	
 	    static createFrom(source: any = {}) {
@@ -1381,6 +1384,7 @@ export namespace extsvc {
 	        this.hrdlog = this.convertValues(source["hrdlog"], ServiceConfig);
 	        this.eqsl = this.convertValues(source["eqsl"], ServiceConfig);
 	        this.cloudlog = this.convertValues(source["cloudlog"], ServiceConfig);
+	        this.hamlog = this.convertValues(source["hamlog"], ServiceConfig);
 	        this.delete_remote = source["delete_remote"];
 	    }
 	
@@ -2295,6 +2299,24 @@ export namespace main {
 	        this.count = source["count"];
 	    }
 	}
+	export class CompactResult {
+	    path: string;
+	    backend: string;
+	    before: number;
+	    after: number;
+	
+	    static createFrom(source: any = {}) {
+	        return new CompactResult(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.path = source["path"];
+	        this.backend = source["backend"];
+	        this.before = source["before"];
+	        this.after = source["after"];
+	    }
+	}
 	export class ContestBandRow {
 	    band: string;
 	    count: number;
@@ -2515,6 +2537,24 @@ export namespace main {
 	        this.body = source["body"];
 	    }
 	}
+	export class FlexRSTChase {
+	    enabled: boolean;
+	    markers: string;
+	    offset_hz: number;
+	    split_only: boolean;
+	
+	    static createFrom(source: any = {}) {
+	        return new FlexRSTChase(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.enabled = source["enabled"];
+	        this.markers = source["markers"];
+	        this.offset_hz = source["offset_hz"];
+	        this.split_only = source["split_only"];
+	    }
+	}
 	export class FlexZoomSettings {
 	    enabled: boolean;
 	    cw_khz: number;
@@ -2677,6 +2717,28 @@ export namespace main {
 		    return a;
 		}
 	}
+	export class HamlogCfmResult {
+	    total: number;
+	    confirmed: number;
+	    matched: number;
+	    by_class: number;
+	    unmatched: number;
+	    samples: string[];
+	
+	    static createFrom(source: any = {}) {
+	        return new HamlogCfmResult(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.total = source["total"];
+	        this.confirmed = source["confirmed"];
+	        this.matched = source["matched"];
+	        this.by_class = source["by_class"];
+	        this.unmatched = source["unmatched"];
+	        this.samples = source["samples"];
+	    }
+	}
 	export class ModePreset {
 	    name: string;
 	    default_rst_sent?: string;
@@ -3010,6 +3072,8 @@ export namespace main {
 	    hrdlog_status: string;
 	    qrzcom_status: string;
 	    qrzcom_confirmed: string;
+	    hamlog_status: string;
+	    hamlog_confirmed: string;
 	
 	    static createFrom(source: any = {}) {
 	        return new QSLDefaults(source);
@@ -3027,6 +3091,8 @@ export namespace main {
 	        this.hrdlog_status = source["hrdlog_status"];
 	        this.qrzcom_status = source["qrzcom_status"];
 	        this.qrzcom_confirmed = source["qrzcom_confirmed"];
+	        this.hamlog_status = source["hamlog_status"];
+	        this.hamlog_confirmed = source["hamlog_confirmed"];
 	    }
 	}
 	export class QSLEmailTemplates {
@@ -3203,6 +3269,79 @@ export namespace main {
 	        this.team_last60 = source["team_last60"];
 	    }
 	}
+	export class RDAConflict {
+	    qso_id: number;
+	    callsign: string;
+	    date: string;
+	    band: string;
+	    mode: string;
+	    from_log: string;
+	    from_db: string;
+	    dated: boolean;
+	    confirmed: boolean;
+	
+	    static createFrom(source: any = {}) {
+	        return new RDAConflict(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.qso_id = source["qso_id"];
+	        this.callsign = source["callsign"];
+	        this.date = source["date"];
+	        this.band = source["band"];
+	        this.mode = source["mode"];
+	        this.from_log = source["from_log"];
+	        this.from_db = source["from_db"];
+	        this.dated = source["dated"];
+	        this.confirmed = source["confirmed"];
+	    }
+	}
+	export class RDACompareResult {
+	    scanned: number;
+	    both_known: number;
+	    agree: number;
+	    disagree: number;
+	    only_log: number;
+	    only_db: number;
+	    neither: number;
+	    conflicts: RDAConflict[];
+	
+	    static createFrom(source: any = {}) {
+	        return new RDACompareResult(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.scanned = source["scanned"];
+	        this.both_known = source["both_known"];
+	        this.agree = source["agree"];
+	        this.disagree = source["disagree"];
+	        this.only_log = source["only_log"];
+	        this.only_db = source["only_db"];
+	        this.neither = source["neither"];
+	        this.conflicts = this.convertValues(source["conflicts"], RDAConflict);
+	    }
+	
+		convertValues(a: any, classs: any, asMap: boolean = false): any {
+		    if (!a) {
+		        return a;
+		    }
+		    if (a.slice && a.map) {
+		        return (a as any[]).map(elem => this.convertValues(elem, classs));
+		    } else if ("object" === typeof a) {
+		        if (asMap) {
+		            for (const key of Object.keys(a)) {
+		                a[key] = new classs(a[key]);
+		            }
+		            return a;
+		        }
+		        return new classs(a);
+		    }
+		    return a;
+		}
+	}
+	
 	export class RelayAutoRule {
 	    device_id: string;
 	    relay: number;
@@ -3445,6 +3584,7 @@ export namespace main {
 	export class SpotColor {
 	    text: string;
 	    bg?: string;
+	    hide?: boolean;
 	
 	    static createFrom(source: any = {}) {
 	        return new SpotColor(source);
@@ -3454,6 +3594,7 @@ export namespace main {
 	        if ('string' === typeof source) source = JSON.parse(source);
 	        this.text = source["text"];
 	        this.bg = source["bg"];
+	        this.hide = source["hide"];
 	    }
 	}
 	export class SpotColors {

gate_coverage_test.go

@@ -0,0 +1,64 @@
+package main
+
+import (
+	"os"
+	"strings"
+	"testing"
+)
+
+// The build gate is only as good as the moments it runs at.
+//
+// It used to run at startup alone, on the profile active then — and a fresh
+// install has NO callsign at that point. The operator typed theirs afterwards,
+// so a denied call ran for the whole session and reached the telemetry, which
+// reads the very same field. Every place that can make a denied callsign the
+// ACTIVE one has to re-ask.
+func TestCallGateRunsWhereverTheActiveCallsignChanges(t *testing.T) {
+	src, err := os.ReadFile("app.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, fn := range []string{
+		"func (a *App) startup(ctx context.Context) {",                 // launch
+		"func (a *App) SaveStationSettings(s StationSettings) error {", // the call is entered here
+		"func (a *App) SaveProfile(p profile.Profile) (profile.Profile, error) {",
+		"func (a *App) ActivateProfile(id int64) error {",
+	} {
+		body := funcBody(t, string(src), fn)
+		if !strings.Contains(body, "enforceCallGate(") {
+			t.Errorf("%s can change the active callsign but never re-checks the gate", fn)
+		}
+	}
+}
+
+// The hashes are the whole mechanism: a truncated or re-cased entry silently
+// matches nothing, and nothing in the running program would ever say so.
+func TestDeniedCallHashesAreWellFormed(t *testing.T) {
+	if len(deniedCallHashes) == 0 {
+		t.Fatal("the deny list is empty — the gate has stopped gating")
+	}
+	for h := range deniedCallHashes {
+		if len(h) != 64 {
+			t.Errorf("hash %q is %d chars, want 64", h, len(h))
+		}
+		if h != strings.ToLower(h) {
+			t.Errorf("hash %q is not lower-case, so it can never match", h)
+		}
+	}
+}
+
+// A slashed call must reduce to the real one, or /P is a way round the gate.
+func TestDenyBaseCall(t *testing.T) {
+	for in, want := range map[string]string{
+		"f4xyz":    "F4XYZ",
+		" F4XYZ ":  "F4XYZ",
+		"F4XYZ/P":  "F4XYZ",
+		"TM/F4XYZ": "F4XYZ",
+		"F4XYZ/MM": "F4XYZ",
+		"":         "",
+	} {
+		if got := denyBaseCall(in); got != want {
+			t.Errorf("denyBaseCall(%q) = %q, want %q", in, got, want)
+		}
+	}
+}

hamlogcfm.go

@@ -0,0 +1,264 @@
+package main
+
+// Reading confirmations back from a HAMLOG.online ADIF export.
+//
+// Their agent protocol only uploads — it has no verb for asking what has been
+// confirmed — so the return path is a file: their site exports an ADIF, and the
+// operator feeds it back here.
+//
+// That file must NOT be imported the ordinary way. A plain import matches a
+// record to a local QSO on callsign + UTC MINUTE + band + mode, and their
+// export is rebuilt from their own database: a minute of rounding, SSB where
+// the log says USB, and the key no longer matches. "Update duplicates" then
+// does what it is told — no duplicate found, so it inserts — and a few hundred
+// copies of contacts the operator already had land in the log. That is exactly
+// what happened once, and it is why this path exists instead.
+//
+// So: match only, never insert. Confirmations are stamped onto the QSOs already
+// in the log, and anything that cannot be matched is REPORTED rather than
+// added, because an unmatched confirmation is a question about the log (a
+// minute off, a portable call) and not a contact to create.
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"strings"
+	"time"
+
+	wruntime "github.com/wailsapp/wails/v2/pkg/runtime"
+
+	"hamlog/internal/adif"
+	"hamlog/internal/applog"
+	"hamlog/internal/award"
+	"hamlog/internal/qso"
+)
+
+// hamlogUnmatchedMax bounds what is kept for export. A whole log's worth of
+// unmatched records means the file belongs to another station, not that the
+// operator wants 50 000 of them written back out.
+const hamlogUnmatchedMax = 20000
+
+// HamlogCfmResult is what the import did.
+type HamlogCfmResult struct {
+	Total     int `json:"total"`     // records read from the file
+	Confirmed int `json:"confirmed"` // records carrying HAMLOG's confirmation flag
+	Matched   int `json:"matched"`   // local QSOs stamped
+	ByClass   int `json:"by_class"`  // matched on mode CLASS rather than exact mode
+	Unmatched int `json:"unmatched"` // confirmations with no local QSO
+	// Samples names a few unmatched contacts, so "12 unmatched" can be looked
+	// into rather than merely worried about. The full list is kept for export —
+	// see ExportHamlogUnmatched — because 395 of them is not a sample-sized
+	// problem: it is a list to work through.
+	Samples []string `json:"samples"`
+}
+
+// hamlogCfmSamples caps the reported list — enough to see the pattern, not so
+// many that the dialog becomes a log file.
+const hamlogCfmSamples = 30
+
+// ImportHamlogConfirmations stamps the confirmations from a HAMLOG.online ADIF
+// export onto the matching local QSOs. It inserts nothing.
+func (a *App) ImportHamlogConfirmations(path string) (HamlogCfmResult, error) {
+	var res HamlogCfmResult
+	if a.qso == nil {
+		return res, fmt.Errorf("db not initialized")
+	}
+	if strings.TrimSpace(path) == "" {
+		return res, fmt.Errorf("empty path")
+	}
+	f, err := os.Open(path)
+	if err != nil {
+		return res, err
+	}
+	defer f.Close()
+
+	ctx := a.ctx
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	// The same two indexes the LoTW download uses: the exact key, then the
+	// mode-CLASS key for the contacts whose mode was written differently at the
+	// other end (FT8 exported as DATA, SSB where the log says USB).
+	keyIDs, err := a.qso.DedupeKeyIDs(ctx)
+	if err != nil {
+		return res, fmt.Errorf("read local log: %w", err)
+	}
+	classIDs, _ := a.qso.DedupeClassKeyIDs(ctx)
+
+	emit := func(line string) {
+		if a.ctx != nil {
+			wruntime.EventsEmit(a.ctx, "qslmgr:log", line)
+		}
+	}
+	emit("Reading " + path + "…")
+
+	// What already counts towards an award, so each confirmation can be flagged
+	// NEW. LoTW and paper QSL are the two award-valid sources; a HAMLOG
+	// confirmation is "new" when it lands on a slot neither of them holds — which
+	// is the only sense in which it changes anything.
+	sets, _ := a.qso.ConfirmedSlots(ctx, []string{"lotw_rcvd", "qsl_rcvd"})
+	var items []ConfirmationItem
+	var unmatched []qso.QSO
+
+	perr := adif.Parse(f, func(rec adif.Record) error {
+		q, ok := adif.RecordToQSO(rec)
+		if !ok {
+			return nil
+		}
+		res.Total++
+		// Only the records they actually confirmed. The export carries the whole
+		// log, and stamping "confirmed" on all of it would turn every uploaded
+		// contact into a confirmed one.
+		if !hamlogRecordConfirmed(rec) {
+			return nil
+		}
+		res.Confirmed++
+
+		minute := q.QSODate.UTC().Format("2006-01-02T15:04")
+		id, found := keyIDs[qso.DedupeKey(q.Callsign, minute, q.Band, q.Mode)]
+		if !found {
+			// id 0 means the class key is ambiguous — several local QSOs share
+			// it — and guessing between them would stamp the wrong one.
+			if cid, ok := classIDs[qso.DedupeClassKey(q.Callsign, minute, q.Band, q.Mode)]; ok && cid != 0 {
+				id, found = cid, true
+				res.ByClass++
+			}
+		}
+		if !found {
+			res.Unmatched++
+			if len(res.Samples) < hamlogCfmSamples {
+				res.Samples = append(res.Samples, fmt.Sprintf("%s · %s · %s · %s",
+					q.Callsign, q.QSODate.UTC().Format("2006-01-02 15:04Z"), q.Band, q.Mode))
+			}
+			if len(unmatched) < hamlogUnmatchedMax {
+				unmatched = append(unmatched, q)
+			}
+			return nil
+		}
+		date := hamlogCfmDate(rec)
+		if e := a.qso.SetExtra(ctx, id, award.HamlogQSLKey, "Y"); e != nil {
+			return nil
+		}
+		_ = a.qso.SetExtra(ctx, id, hamlogQSLDateKey, date)
+		// A confirmed contact is by definition one they hold, so the sent side
+		// is true whether or not OpsLog is what uploaded it — a log uploaded
+		// from their website would otherwise read "never sent, yet confirmed".
+		_ = a.qso.SetExtra(ctx, id, hamlogSentKey, "Y")
+		res.Matched++
+
+		// Feed the Results view, the same rows the LoTW download produces: an
+		// import that only prints counts leaves the operator with no way to see
+		// WHICH contacts were confirmed, which is the reason they ran it.
+		a.enrichContactedFromCty(&q) // country/dxcc, for the entity flags
+		it := ConfirmationItem{
+			Callsign: q.Callsign,
+			QSODate:  q.QSODate.UTC().Format(time.RFC3339),
+			Band:     q.Band,
+			Mode:     q.Mode,
+			Country:  q.Country,
+		}
+		if q.DXCC != nil && *q.DXCC != 0 {
+			n := *q.DXCC
+			it.NewDXCC = !sets.DXCC[n]
+			it.NewBand = !sets.Band[qso.BandKey(n, q.Band)]
+			it.NewMode = !sets.Mode[qso.ModeClassKey(n, q.Mode)]
+			it.NewSlot = !sets.Slot[qso.SlotClassKey(n, q.Band, q.Mode)]
+			// Fold it in, so a repeat inside the same file isn't flagged twice.
+			sets.DXCC[n] = true
+			sets.Band[qso.BandKey(n, q.Band)] = true
+			sets.Mode[qso.ModeClassKey(n, q.Mode)] = true
+			sets.Slot[qso.SlotClassKey(n, q.Band, q.Mode)] = true
+		}
+		items = append(items, it)
+		return nil
+	})
+	if perr != nil {
+		return res, perr
+	}
+	a.invalidateAwardStats() // confirmations move award counts
+	// Kept for ExportHamlogUnmatched. Held rather than written now: the operator
+	// decides whether a list of 395 is worth a file.
+	a.hamlogUnmatchedMu.Lock()
+	a.hamlogUnmatched = unmatched
+	a.hamlogUnmatchedMu.Unlock()
+	if a.ctx != nil {
+		wruntime.EventsEmit(a.ctx, "qslmgr:confirmations", items)
+	}
+	applog.Printf("hamlog cfm import: %d records, %d confirmed, %d matched (%d by mode class), %d unmatched",
+		res.Total, res.Confirmed, res.Matched, res.ByClass, res.Unmatched)
+	emit(fmt.Sprintf("%d records read, %d confirmed by HAMLOG.online, %d matched in the log (%d by mode class), %d unmatched",
+		res.Total, res.Confirmed, res.Matched, res.ByClass, res.Unmatched))
+	for _, s := range res.Samples {
+		emit("  unmatched: " + s)
+	}
+	if res.Unmatched > len(res.Samples) {
+		emit(fmt.Sprintf("  …and %d more — use \"Export unmatched (ADIF)…\" to get the whole list.",
+			res.Unmatched-len(res.Samples)))
+	}
+	if a.ctx != nil {
+		wruntime.EventsEmit(a.ctx, "qslmgr:done", map[string]any{"uploaded": res.Matched, "total": res.Confirmed})
+	}
+	return res, nil
+}
+
+// ExportHamlogUnmatched writes the confirmations the last import could not
+// place onto a QSO.
+//
+// They are the interesting half of the result: each one is a contact HAMLOG
+// believes it holds and this log does not agree about — a minute of drift, a
+// portable call, a band written differently, or a QSO genuinely missing. A
+// count cannot be worked through; a file can be opened, sorted and compared.
+//
+// Written as ADIF because that is what every other tool reads, and because it
+// can be handed straight back to an import once the discrepancies are settled.
+func (a *App) ExportHamlogUnmatched(path string) (int, error) {
+	a.hamlogUnmatchedMu.Lock()
+	rows := a.hamlogUnmatched
+	a.hamlogUnmatchedMu.Unlock()
+	if len(rows) == 0 {
+		return 0, fmt.Errorf("nothing to export: the last import left no unmatched confirmations")
+	}
+	if strings.TrimSpace(path) == "" {
+		return 0, fmt.Errorf("empty path")
+	}
+	recs := make([]string, 0, len(rows))
+	for i := range rows {
+		recs = append(recs, adif.FullRecordADIF(rows[i]))
+	}
+	if err := os.WriteFile(path, []byte(adif.BatchRecordsADIF(recs)), 0o644); err != nil {
+		return 0, err
+	}
+	applog.Printf("hamlog cfm import: exported %d unmatched confirmation(s) to %s", len(rows), path)
+	return len(rows), nil
+}
+
+// hamlogQSLDateKey stamps WHEN the confirmation was read back. Their export
+// carries no confirmation date of its own, so this is the import date — which
+// is honest about what it knows, unlike borrowing the QSO date.
+const hamlogQSLDateKey = "APP_OPSLOG_HAMLOG_QSL_DATE"
+
+// hamlogRecordConfirmed reads their flag off a raw ADIF record. The primary key
+// is the one their own export writes; the alternates are the names OpsLog and
+// other tools have used, so a file that went through another logger still reads.
+func hamlogRecordConfirmed(rec adif.Record) bool {
+	keys := append([]string{award.HamlogQSLKey}, award.HamlogAltKeys()...)
+	for _, k := range keys {
+		v := strings.ToUpper(strings.TrimSpace(rec[strings.ToLower(k)]))
+		if v != "" && v != "N" && v != "NO" {
+			return true
+		}
+	}
+	return false
+}
+
+// hamlogCfmDate is the date to stamp: the import date, in ADIF form.
+func hamlogCfmDate(rec adif.Record) string {
+	// If a future export ever carries one, take it rather than today's date.
+	for _, k := range []string{"app_hamlog_qso_cfm_date", "qslrdate"} {
+		if v := strings.TrimSpace(rec[k]); len(v) == 8 {
+			return v
+		}
+	}
+	return time.Now().UTC().Format("20060102")
+}

internal/applog/applog.go

@@ -20,9 +20,15 @@ var (
 	mu        sync.Mutex
 	file      *os.File
 	path      string
+	written   int64    // bytes in the CURRENT file, for the size check in Printf
 	crashFile *os.File // kept open so the runtime can write a crash traceback to it
 )
 
+// maxLogBytes is where the file rolls over, at startup AND while running.
+// A variable, not a constant, so the rotation can be exercised in a test without
+// writing ten megabytes to do it.
+var maxLogBytes int64 = 10 * 1024 * 1024
+
 // Init opens (creates) the log file in dataDir. On rotation we truncate
 // at startup if the file is too big; for now it's a single file, no
 // rolling — the volume is low (a few KB per session).
@@ -47,11 +53,11 @@ func Init(dataDir string) (string, error) {
 			_ = os.Rename(oldLog, logPath)
 		}
 	}
-	// Rotate (don't delete) once the file grows past ~10MB: rename it to
+	// Rotate (don't delete) once the file grows past maxLogBytes: rename it to
 	// opslog.log.1 so the PREVIOUS session's log survives. Deleting it outright used
 	// to erase exactly the diagnostics we needed when a user reported an issue from
 	// the session that just ended. One generation kept — enough, without unbounded growth.
-	if fi, err := os.Stat(logPath); err == nil && fi.Size() > 10*1024*1024 {
+	if fi, err := os.Stat(logPath); err == nil && fi.Size() > maxLogBytes {
 		_ = os.Remove(logPath + ".1") // drop the older generation
 		if err := os.Rename(logPath, logPath+".1"); err != nil {
 			_ = os.Remove(logPath) // rename failed (locked?) → fall back to the old behaviour
@@ -96,13 +102,57 @@ func Printf(format string, args ...any) {
 		msg = msg[:len(msg)-1]
 	}
 	if file != nil {
-		fmt.Fprintf(file, "%s %s\n", stamp, msg)
+		n, _ := fmt.Fprintf(file, "%s %s\n", stamp, msg)
+		written += int64(n)
+		rotateIfBigLocked()
 	}
 	// Also dump to stderr in case the binary was launched with a console
 	// attached (wails dev, custom build).
 	fmt.Fprintf(os.Stderr, "%s %s\n", stamp, msg)
 }
 
+// rotateIfBigLocked rolls the file over mid-session once it passes maxLogBytes.
+//
+// The check used to happen at STARTUP only, on the reasonable belief that a
+// session writes a few kilobytes. The CI-V wire trace disproved it: left on for
+// a day it wrote 416 MB, and nothing would have stopped it before the disk did.
+// A log that has to be rotated by quitting the program is not a bound.
+//
+// Same one-generation scheme as the startup rotation, so the previous stretch
+// survives — which is the half an operator usually needs, the part just before
+// the thing they are reporting.
+//
+// Caller holds mu.
+func rotateIfBigLocked() {
+	if written < maxLogBytes || file == nil || path == "" {
+		return
+	}
+	fmt.Fprintf(file, "%s ── log reached %d MB, rotating to %s.1 ──\n",
+		time.Now().Format("15:04:05.000"), maxLogBytes/(1024*1024), filepath.Base(path))
+	_ = file.Close()
+	file = nil
+	_ = os.Remove(path + ".1")
+	if err := os.Rename(path, path+".1"); err != nil {
+		// Rename refused (the file is held open elsewhere, a virus scanner): keep
+		// writing to the old handle rather than losing the log entirely, and try
+		// again in another maxLogBytes rather than on every single line.
+		f, oerr := os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0o644)
+		if oerr == nil {
+			file = f
+		}
+		written = 0
+		return
+	}
+	f, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0o644)
+	if err != nil {
+		return // nothing more to be done; the next Printf simply writes nowhere
+	}
+	file = f
+	written = 0
+	fmt.Fprintf(file, "%s ── continued from %s.1 ──\n",
+		time.Now().Format("15:04:05.000"), filepath.Base(path))
+}
+
 // Path returns where the file is so the UI can surface it.
 func Path() string {
 	mu.Lock()
@@ -118,4 +168,19 @@ func Close() {
 		_ = file.Close()
 		file = nil
 	}
+	// The crash file is held open for the whole run so the runtime can dump a
+	// traceback into it without allocating; on the way out it has to be released
+	// like any other handle, or the data directory cannot be moved or removed.
+	if crashFile != nil {
+		// The RUNTIME holds its own duplicate of this handle (SetCrashOutput), so
+		// closing ours releases nothing on Windows — the data directory stays
+		// locked. Hand the runtime a nil first. Anything fatal in the last moments
+		// of shutdown is no longer captured, which is the right trade at a point
+		// where the databases are already closed.
+		_ = debug.SetCrashOutput(nil, debug.CrashOptions{})
+		_ = crashFile.Close()
+		crashFile = nil
+	}
+	path = ""
+	written = 0
 }

internal/applog/rotate_test.go

@@ -0,0 +1,49 @@
+package applog
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// The log has to be bounded WHILE RUNNING, not only at startup. The CI-V wire
+// trace left on for a day wrote 416 MB, and nothing would have stopped it
+// before the disk did.
+func TestRotatesMidSession(t *testing.T) {
+	orig := maxLogBytes
+	maxLogBytes = 8 * 1024 // small, so the test costs milliseconds
+	defer func() { maxLogBytes = orig }()
+
+	dir := t.TempDir()
+	p, err := Init(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer Close()
+
+	line := strings.Repeat("x", 256)
+	for i := 0; i < 100; i++ { // ~25 KB: several times the limit
+		Printf("%s", line)
+	}
+
+	if _, err := os.Stat(p + ".1"); err != nil {
+		t.Fatalf("no previous generation kept: %v", err)
+	}
+	fi, err := os.Stat(p)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if fi.Size() > maxLogBytes {
+		t.Fatalf("current log is %d bytes, over the %d limit — it did not roll over", fi.Size(), maxLogBytes)
+	}
+	// The new file says where the rest went: a log that starts mid-sentence with
+	// no explanation is how an operator concludes the app lost its history.
+	b, err := os.ReadFile(p)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(b), "continued from "+filepath.Base(p)+".1") {
+		t.Error("the new file does not point at the one it continues")
+	}
+}

internal/audio/recorder.go

@@ -168,7 +168,48 @@ func (r *Recorder) Start(fromDev, micDev string, prerollSec int) error {
 	twoSrc := r.twoSrc
 	r.mu.Unlock()
 
-	// Capture goroutine(s) feed the per-source queues.
+	// The radio side is either CAPTURED from a sound device or PUSHED in from
+	// somewhere else. Over the network there is no sound device at all: an
+	// IC-705 reached by LAN streams its receive audio over the Icom protocol,
+	// and the operator's audio settings can only offer the PC's own microphone
+	// and speakers. fromDev == PushedSource says "someone else will feed me",
+	// and PushRX is how they do it.
+	if fromDev == PushedSource {
+		LogSink("recorder: radio audio is pushed in (network), not captured from a device")
+	} else {
+		r.startRadioCapture(fromDev, stop)
+	}
+	if twoSrc {
+		r.startMicCapture(micDev, stop)
+	}
+	r.finishStart(fromDev, micDev, twoSrc, stop)
+	return nil
+}
+
+// PushedSource is the "device" name that means the radio audio arrives through
+// PushRX instead of a capture stream.
+const PushedSource = "\x00pushed"
+
+// PushRX feeds one chunk of 16-bit mono PCM from a non-device source.
+//
+// Safe to call when nothing is recording — the samples are dropped, which is
+// what should happen: the network stream runs whenever the rig is connected,
+// and the recorder only wants it between BeginQSO and the save.
+func (r *Recorder) PushRX(pcm []byte) {
+	r.mu.Lock()
+	running := r.running
+	r.mu.Unlock()
+	if !running || len(pcm) == 0 {
+		return
+	}
+	sm := bytesToInt16(pcm)
+	r.srcMu.Lock()
+	r.bufA = append(r.bufA, sm...)
+	r.lastA = time.Now()
+	r.srcMu.Unlock()
+}
+
+func (r *Recorder) startRadioCapture(fromDev string, stop chan struct{}) {
 	r.wg.Add(1)
 	go func() {
 		defer r.wg.Done()
@@ -187,7 +228,9 @@ func (r *Recorder) Start(fromDev, micDev string, prerollSec int) error {
 			LogSink("recorder: capture from %q failed: %v", DeviceName(fromDev), err)
 		}
 	}()
-	if twoSrc {
+}
+
+func (r *Recorder) startMicCapture(micDev string, stop chan struct{}) {
 	r.wg.Add(1)
 	go func() {
 		defer r.wg.Done()
@@ -204,6 +247,8 @@ func (r *Recorder) Start(fromDev, micDev string, prerollSec int) error {
 	}()
 }
 
+// finishStart logs what is being recorded and arms the silence watchdog.
+func (r *Recorder) finishStart(fromDev, micDev string, twoSrc bool, stop chan struct{}) {
 	// Name the devices being recorded FROM, once, at the start.
 	//
 	// A station with two radios has two sets of endpoints, and the recorder will
@@ -262,7 +307,6 @@ func (r *Recorder) Start(fromDev, micDev string, prerollSec int) error {
 			}
 		}
 	}()
-	return nil
 }
 
 // mixTick drains the source queues, mixes what's available, and appends to the

internal/award/award.go

@@ -109,7 +109,7 @@ type Def struct {
 	Emission   []string `json:"emission,omitempty"`    // CW | DIGITAL | PHONE (empty = all)
 
 	// --- Confirmation ---
-	Confirm  []string `json:"confirm"`            // worked-confirmed: lotw|qsl|eqsl|qrzcom|custom
+	Confirm  []string `json:"confirm"`            // worked-confirmed: lotw|qsl|eqsl|qrzcom|hamlog|custom
 	Validate []string `json:"validate,omitempty"` // validated/granted sources
 	// The "custom" source, for confirmations OpsLog has no dedicated column for:
 	// ConfirmField names a QSO field or an ADIF extras key, ConfirmValue the
@@ -344,7 +344,7 @@ func Migrate(defs []Def) ([]Def, bool) {
 func Fields() []string {
 	return []string{
 		"dxcc", "cqz", "ituz", "prefix", "callsign",
-		"state", "us_county", "cont", "country", "grid", "grid4",
+		"state", "county", "us_county", "cont", "country", "grid", "grid4",
 		"iota", "sota_ref", "pota_ref", "wwff",
 		"name", "qth", "address", "comment", "note",
 	}
@@ -1373,6 +1373,13 @@ func fieldRaw(field string, q *qso.QSO) string {
 		return q.Callsign
 	case "state":
 		return q.State
+	case "county":
+		// CNTY as it stands, with nothing prepended. us_county below answers a
+		// different question — it keys the county to its state, because two US
+		// states each have a Jefferson County. Outside the United States that
+		// prefixing is wrong: an RDA district (RO-19) and a Japanese city code
+		// are already unique, and a state is not what qualifies them.
+		return q.County
 	case "us_county":
 		return USCountyKey(q.State, q.County)
 	case "cont":
@@ -1481,6 +1488,18 @@ func confirmed(q *qso.QSO, sources []string, d *Def) bool {
 			if isYes(q.QRZComDownloadStatus) {
 				return true
 			}
+		case "hamlog":
+			// HAMLOG.online, a first-class source rather than something to express
+			// through "custom" — its confirmations feed its own award programme
+			// and operators reach for it the same way they reach for LoTW.
+			//
+			// Read from the ADIF EXTRAS, not a column: the ADIF standard names a
+			// field for hamlog.EU (HAMLOGEU_QSO_UPLOAD_STATUS) and none for
+			// hamlog.ONLINE, and borrowing the other site's field would write a
+			// falsehood into every exported log.
+			if hamlogConfirmed(q) {
+				return true
+			}
 		case "custom":
 			if customConfirmed(q, d) {
 				return true
@@ -1490,6 +1509,46 @@ func confirmed(q *qso.QSO, sources []string, d *Def) bool {
 	return false
 }
 
+// HamlogQSLKey is where a HAMLOG.online confirmation is recorded.
+//
+// THEIR field name, taken from a real export:
+//
+//	<APP_HAMLOG_QSO_CFM:1>Y
+//
+// Using the site's own key rather than one of ours is what makes an import
+// simply work: a log downloaded from HAMLOG carries its confirmations into
+// OpsLog with nothing to rename and no mapping to configure. The guesses this
+// replaced (APP_HAMLOG_QSL and friends) were all wrong, which is the argument
+// for reading a real file before naming a field.
+const HamlogQSLKey = "APP_HAMLOG_QSO_CFM"
+
+// hamlogAltKeys are older or hand-written spellings still honoured on read.
+// APP_OPSLOG_HAMLOG_QSL is the one OpsLog itself wrote before a real export was
+// available; a log stamped with it keeps counting.
+var hamlogAltKeys = []string{"APP_OPSLOG_HAMLOG_QSL", "APP_HAMLOG_QSL", "APP_HAMLOGONLINE_QSL", "HAMLOG_QSL_RCVD"}
+
+// hamlogConfirmed reports whether a QSO carries a HAMLOG.online confirmation.
+//
+// Any non-empty value counts, except an explicit "N": their export could carry
+// a date, a Y, or a match id, and demanding one of them would silently confirm
+// nothing on the two shapes we guessed wrong.
+func hamlogConfirmed(q *qso.QSO) bool {
+	if q == nil || q.Extras == nil {
+		return false
+	}
+	for _, k := range append([]string{HamlogQSLKey}, hamlogAltKeys...) {
+		v := strings.TrimSpace(q.Extras[k])
+		if v == "" {
+			continue
+		}
+		if strings.EqualFold(v, "N") || strings.EqualFold(v, "NO") {
+			continue
+		}
+		return true
+	}
+	return false
+}
+
 // customConfirmed answers the operator-defined confirmation source: the field
 // named by ConfirmField, optionally required to hold one of ConfirmValue's
 // comma-separated values.
@@ -1580,3 +1639,7 @@ func sortedBands(m map[string]int) []string {
 	})
 	return out
 }
+
+// HamlogAltKeys exposes the alternate spellings so a reader outside this package
+// (the confirmations import) accepts exactly what the award engine accepts.
+func HamlogAltKeys() []string { return append([]string(nil), hamlogAltKeys...) }

internal/award/confirm_test.go

@@ -64,3 +64,61 @@ func TestConfirmedSources(t *testing.T) {
 		}
 	}
 }
+
+// HAMLOG.online is a named confirmation source, not something to express through
+// "custom": an award ticks it the way it ticks LoTW.
+func TestHamlogConfirmationSource(t *testing.T) {
+	def := Def{Confirm: []string{"hamlog"}, Validate: []string{"hamlog"}}
+	yes := func(extras map[string]string) bool {
+		return Confirmed(&qso.QSO{Extras: extras}, def, def.Confirm)
+	}
+	if !yes(map[string]string{HamlogQSLKey: "Y"}) {
+		t.Error("our own key did not confirm")
+	}
+	// Their export's field name is unpublished, so the plausible shapes count too.
+	if !yes(map[string]string{"APP_HAMLOG_QSL": "20260823"}) {
+		t.Error("a date in an alternative key did not confirm")
+	}
+	// A value is not a confirmation when it says no.
+	if yes(map[string]string{HamlogQSLKey: "N"}) {
+		t.Error(`"N" was taken as a confirmation`)
+	}
+	if yes(map[string]string{HamlogQSLKey: "  "}) {
+		t.Error("blank was taken as a confirmation")
+	}
+	if yes(nil) || yes(map[string]string{"SOMETHING_ELSE": "Y"}) {
+		t.Error("confirmed with nothing to confirm it")
+	}
+	// And it does not leak into an award that never asked for it.
+	other := Def{Confirm: []string{"lotw"}}
+	if Confirmed(&qso.QSO{Extras: map[string]string{HamlogQSLKey: "Y"}}, other, other.Confirm) {
+		t.Error("a hamlog confirmation counted for an award that only accepts LoTW")
+	}
+}
+
+// The field name is theirs, taken from a real export:
+//
+//	<APP_HAMLOG_QSO_CFM:1>Y
+//
+// Pinned as a test because it was GUESSED wrong first — an import that carries
+// its confirmations into OpsLog with nothing to rename is the whole point, and
+// a renamed constant would break it in silence.
+func TestHamlogUsesTheSitesOwnFieldName(t *testing.T) {
+	if HamlogQSLKey != "APP_HAMLOG_QSO_CFM" {
+		t.Fatalf("HamlogQSLKey = %q — their export writes APP_HAMLOG_QSO_CFM", HamlogQSLKey)
+	}
+	def := Def{Confirm: []string{"hamlog"}}
+	// The record as HAMLOG exports it.
+	q := &qso.QSO{Extras: map[string]string{
+		"APP_HAMLOG_R150COUNTRY": "Russia",
+		"APP_HAMLOG_QSO_CFM":     "Y",
+	}}
+	if !Confirmed(q, def, def.Confirm) {
+		t.Error("a real HAMLOG export did not confirm")
+	}
+	// Anything OpsLog stamped before that export existed keeps counting.
+	old := &qso.QSO{Extras: map[string]string{"APP_OPSLOG_HAMLOG_QSL": "Y"}}
+	if !Confirmed(old, def, def.Confirm) {
+		t.Error("a QSO stamped with the older key stopped counting")
+	}
+}

internal/award/fieldvalue_county_test.go

@@ -0,0 +1,29 @@
+package award
+
+import (
+	"testing"
+
+	"hamlog/internal/qso"
+)
+
+// A district lives in CNTY as-is; the US award field keys it to the state
+// because county names repeat across states. Confusing the two silently breaks
+// whichever award is not American.
+func TestCountyFieldIsRawWhileUSCountyIsKeyed(t *testing.T) {
+	q := &qso.QSO{State: "TX", County: "RO-19"}
+	if got := fieldRaw("county", q); got != "RO-19" {
+		t.Fatalf("county = %q, want RO-19", got)
+	}
+	if got := fieldRaw("us_county", q); got == "RO-19" {
+		t.Fatalf("us_county should key the county to its state, got %q", got)
+	}
+	var found bool
+	for _, f := range Fields() {
+		if f == "county" {
+			found = true
+		}
+	}
+	if !found {
+		t.Fatal("county missing from the award field list")
+	}
+}

internal/cat/cat.go

@@ -487,6 +487,8 @@ type FlexController interface {
 	// keeps freqMHz inside it, re-centring when it must. See Flex.ZoomPan.
 	ZoomPan(bandwidthMHz, freqMHz float64, centre bool) error
 	SetTXSlice(int) error // make slice idx the transmitter (tx=1)
+	// SetTXSliceFrequency moves the TRANSMIT slice only — split pile-up chasing.
+	SetTXSliceFrequency(int64) error
 	SetSplit(bool) error
 	SetNB(bool) error
 	SetNBLevel(int) error

internal/cat/flex.go

@@ -60,6 +60,9 @@ type Flex struct {
 	txRawLogged    bool         // log the first raw transmit status once (field-name audit)
 
 	spotsEnabled    bool           // push cluster spots + manage the panadapter overlay
+	// foreignSpotSeen counts what probeForeignSpot has already reported, so a
+	// skimmer posting all evening cannot turn the log into its own transcript.
+	foreignSpotSeen int
 	spotIdx         map[int]bool   // panadapter spot indices currently known to the radio
 	pendingSpot     map[int]string // seq → callsign, awaiting the spot index in the R response
 	pendingSpotMode map[int]string // seq → ADIF mode, paired with pendingSpot
@@ -74,6 +77,15 @@ type Flex struct {
 	// end up outside the new window — see ZoomPan.
 	panWindow map[string]panView
 
+	// spotSig is what each live spot LOOKS like, and when it was drawn. A
+	// callsign spotted again with the same frequency, colour and comment does not
+	// need to be removed and re-added: the panadapter would not change by one
+	// pixel, and a busy RBN feed re-spots the same station every few seconds. One
+	// two-minute session sent 2 128 adds and 1 634 removes, 88 of them for a
+	// single callsign — see SendSpot.
+	spotSig  map[string]string
+	spotSent map[string]time.Time
+
 	spotByCall map[string]int // callsign → live spot index, so re-spotting a call replaces its old spot (WSJT decodes re-fire every cycle)
 	sentCmds   map[int]string // seq → command text, so an R<seq> error names the command
 
@@ -83,6 +95,16 @@ type Flex struct {
 	// the spot, since the radio's own notification carries only an index. The host
 	// wires this to fill the entry form and to size the panadapter. Set before Connect.
 	OnSpotClick func(callsign string, freqHz int64, mode string)
+
+	// OnForeignSpot is called for every spot posted to the radio by a program
+	// OTHER than OpsLog, with the spot's callsign field and its frequency.
+	//
+	// A CW skimmer posts what it decodes, so the marker a DX operator's report
+	// leaves on the panadapter arrives here — that is what the split chaser acts
+	// on. Deliberately raw: this package reports what the radio said and does not
+	// decide what a marker looks like, because the marker text is configured in
+	// the skimmer, by the operator, and only they know what they chose.
+	OnForeignSpot func(callsign string, freqHz int64)
 }
 
 // panView is one panadapter's visible window, in MHz.
@@ -205,7 +227,7 @@ func NewFlex(host string, port int, spotsEnabled bool) *Flex {
 	return &Flex{
 		host: strings.TrimSpace(host), port: port,
 		slices: map[int]*flexSlice{}, spotsEnabled: spotsEnabled,
-		spotIdx: map[int]bool{}, pendingSpot: map[int]string{}, pendingSpotMode: map[int]string{}, spotCall: map[int]string{}, spotMode: map[int]string{}, spotFreq: map[int]int64{}, pendingSpotFreq: map[int]int64{}, panWindow: map[string]panView{}, spotByCall: map[string]int{}, pendingSplit: map[int]bool{},
+		spotIdx: map[int]bool{}, pendingSpot: map[int]string{}, pendingSpotMode: map[int]string{}, spotCall: map[int]string{}, spotMode: map[int]string{}, spotFreq: map[int]int64{}, pendingSpotFreq: map[int]int64{}, panWindow: map[string]panView{}, spotSig: map[string]string{}, spotSent: map[string]time.Time{}, spotByCall: map[string]int{}, pendingSplit: map[int]bool{},
 		meterMeta: map[int]meterInfo{}, meterVal: map[int]float64{}, meterSub: map[int]bool{},
 		sentCmds: map[int]string{}, txSetAt: map[string]time.Time{},
 		pinnedSlice: -1,
@@ -269,11 +291,18 @@ func (f *Flex) Connect() error {
 	f.send("sub pan all")       // panadapter centre/bandwidth, so a zoom knows where the display already is
 	f.send("sub client all")    // learn the GUI client (SmartSDR) so we can bind to it (below)
 	f.startMeters(conn)         // open the UDP VITA-49 stream for live meters
-	if f.spotsEnabled {
-		// Subscribe so the radio pushes existing spots (we learn their indices),
-		// then wipe the panadapter so stale spots from a previous session or
-		// another logger are cleared before we start adding our own.
+	// Always subscribed, even when OpsLog draws no spots of its own: the feed is
+	// read-only and it is how the spots posted by OTHER programs arrive — a CW
+	// skimmer's decoded reports, which the split chaser acts on. Tying the
+	// subscription to our own overlay meant a station using SDC and no OpsLog
+	// spots heard nothing at all.
 	f.send("sub spot all")
+	if f.spotsEnabled {
+		// Wipe the panadapter so stale spots from a previous session or another
+		// logger are cleared before we start adding our own. Only when the
+		// overlay is ours to manage: "spot clear" removes EVERY spot on the
+		// radio, a skimmer's included, and taking those away from an operator
+		// who never asked us to draw anything would be pure vandalism.
 		go f.clearSpotsOnConnect(conn)
 	}
 	return nil
@@ -859,6 +888,13 @@ func (f *Flex) handleStatus(payload string) {
 				}
 				f.mu.Lock()
 				if removed {
+					// The radio expired or dropped this spot: forget what it looked
+					// like, or the next identical spot would be skipped as "already
+					// drawn" and the station would never come back.
+					if c, ok := f.spotCall[idx]; ok {
+						delete(f.spotSig, strings.ToUpper(c))
+						delete(f.spotSent, strings.ToUpper(c))
+					}
 					delete(f.spotIdx, idx)
 					delete(f.spotCall, idx)
 					delete(f.spotMode, idx)
@@ -867,6 +903,10 @@ func (f *Flex) handleStatus(payload string) {
 					f.spotIdx[idx] = true
 				}
 				f.mu.Unlock()
+				if !removed {
+					f.probeForeignSpot(payload)
+					f.reportForeignSpot(payload)
+				}
 			}
 			debugLog.Printf("Flex: status %s", payload)
 		}
@@ -1361,6 +1401,105 @@ func (f *Flex) ZoomPan(bandwidthMHz, freqMHz float64, centre bool) error {
 	return nil
 }
 
+// foreignSpotProbeMax bounds the probe below. Enough lines to see what another
+// program writes into a spot, few enough that a running skimmer — which posts
+// hundreds an hour — cannot fill the log file with them.
+const foreignSpotProbeMax = 60
+
+// probeForeignSpot records, verbatim, the spots this radio receives from
+// programs OTHER than OpsLog.
+//
+// A CW skimmer (SDC, for one) posts what it decodes as panadapter spots, the
+// exchange included: chasing a split pileup means finding the "5NN" the DX just
+// sent and moving the transmit slice there. Acting on that requires knowing
+// exactly what the spot looks like — which field carries the text, whether the
+// report is the callsign or the comment, what source names the skimmer — and no
+// amount of reasoning substitutes for reading real lines off a real radio.
+//
+// So this logs and does nothing else. It is deliberately not a feature.
+func (f *Flex) probeForeignSpot(payload string) {
+	if strings.Contains(payload, "source=OpsLog") {
+		return
+	}
+	f.mu.Lock()
+	if f.foreignSpotSeen >= foreignSpotProbeMax {
+		f.mu.Unlock()
+		return
+	}
+	f.foreignSpotSeen++
+	n := f.foreignSpotSeen
+	f.mu.Unlock()
+	debugLog.Printf("flex: foreign spot %d/%d: %s", n, foreignSpotProbeMax, payload)
+	if n == foreignSpotProbeMax {
+		debugLog.Printf("flex: that is enough foreign spots to go on — no more will be logged this session")
+	}
+}
+
+// reportForeignSpot hands another program's spot to OnForeignSpot.
+//
+// Off the reader goroutine, like OnSpotClick: the handler tunes the radio, and
+// a command sent from inside the reader would deadlock against the socket it is
+// reading.
+func (f *Flex) reportForeignSpot(payload string) {
+	if strings.Contains(payload, "source=OpsLog") {
+		return
+	}
+	handler := f.OnForeignSpot
+	if handler == nil {
+		return
+	}
+	var call string
+	var hz int64
+	for _, kv := range strings.Fields(payload) {
+		eq := strings.IndexByte(kv, '=')
+		if eq <= 0 {
+			continue
+		}
+		switch kv[:eq] {
+		case "callsign":
+			call = kv[eq+1:]
+		case "rx_freq":
+			if mhz, err := strconv.ParseFloat(kv[eq+1:], 64); err == nil {
+				hz = int64(math.Round(mhz * 1e6))
+			}
+		}
+	}
+	if call == "" || hz <= 0 {
+		return
+	}
+	go handler(call, hz)
+}
+
+// SetTXSliceFrequency tunes the TRANSMIT slice, leaving the receive slice where
+// it is. That distinction is the whole point in split: the operator listens to
+// the DX on one slice and moves the other around the pile-up.
+func (f *Flex) SetTXSliceFrequency(hz int64) error {
+	if hz <= 0 {
+		return fmt.Errorf("flex: invalid frequency")
+	}
+	f.mu.Lock()
+	idx := -1
+	for i, s := range f.slices {
+		if s != nil && s.inUse && s.tx {
+			idx = i
+			break
+		}
+	}
+	if idx >= 0 && f.slices[idx] != nil {
+		f.slices[idx].freqHz = hz // optimistic, like SetFrequency
+	}
+	connected := f.conn != nil
+	f.mu.Unlock()
+	if idx < 0 {
+		return fmt.Errorf("flex: no transmit slice")
+	}
+	if !connected {
+		return fmt.Errorf("flex: not connected")
+	}
+	f.send(fmt.Sprintf("slice t %d %.6f", idx, float64(hz)/1e6))
+	return nil
+}
+
 // SendSpot renders a cluster spot on the panadapter via "spot add". Spots carry
 // a lifetime so the radio expires them on its own (the API has no "spot clear").
 // Per the SmartSDR API, spaces inside a field value are encoded as 0x7F.
@@ -1390,7 +1529,22 @@ func (f *Flex) SendSpot(s SpotInfo) error {
 	// and Go mutexes aren't reentrant (calling send while locked deadlocks the
 	// whole Flex goroutine → the radio drops OFFLINE).
 	upperCall := strings.ToUpper(s.Callsign)
+	// Unchanged and still fresh → leave it alone.
+	//
+	// Refreshed once past half its lifetime, so a long-lived spot still gets its
+	// timer wound on and never quietly expires off the panadapter; anything that
+	// actually differs (a new frequency, a status that has changed colour, a
+	// different comment) is redrawn at once.
+	sig := fmt.Sprintf("%d|%s|%s|%s|%s", s.FreqHz, s.Mode, s.Color, s.BackgroundColor, s.Comment)
 	f.mu.Lock()
+	if prev, ok := f.spotSig[upperCall]; ok && prev == sig {
+		if at, ok := f.spotSent[upperCall]; ok && time.Since(at) < time.Duration(life)*time.Second/2 {
+			f.mu.Unlock()
+			return nil
+		}
+	}
+	f.spotSig[upperCall] = sig
+	f.spotSent[upperCall] = time.Now()
 	old, hadOld := f.spotByCall[upperCall]
 	if hadOld {
 		delete(f.spotByCall, upperCall)
@@ -1464,6 +1618,8 @@ func (f *Flex) ClearSpots() error {
 	f.spotCall = map[int]string{}
 	f.spotMode = map[int]string{}
 	f.spotFreq = map[int]int64{}
+	f.spotSig = map[string]string{}
+	f.spotSent = map[string]time.Time{}
 	f.spotByCall = map[string]int{}
 	connected := f.conn != nil
 	f.mu.Unlock()

internal/cat/icom_foreign_test.go

@@ -0,0 +1,43 @@
+package cat
+
+import (
+	"testing"
+
+	"hamlog/internal/cat/civ"
+)
+
+// A CI-V bus can carry a second controller, and the rig answers each of them on
+// the same wire. A reply addressed to somebody else must not be taken for ours —
+// on an IC-7850 one arrived between a PTT command and its acknowledgement, the
+// acknowledgement was never matched, and the failure was handed to JTDX as a rig
+// control error.
+func TestForeignCIVRepliesAreIgnored(t *testing.T) {
+	const rig = 0x8E
+	frames, _ := civ.Scan([]byte{
+		0xFE, 0xFE, 0x01, rig, 0x1C, 0x00, 0x01, 0xFD, // to controller 01 — not ours
+		0xFE, 0xFE, civ.AddrController, rig, 0xFB, 0xFD, // to us: the acknowledgement
+		0xFE, 0xFE, 0x00, rig, 0x00, 0x00, 0x25, 0x09, 0x14, 0x00, 0xFD, // transceive broadcast
+	})
+	if len(frames) != 3 {
+		t.Fatalf("scanned %d frames, want 3", len(frames))
+	}
+	var kept []civ.Decoded
+	for _, f := range frames {
+		if f.From != rig {
+			continue
+		}
+		if f.To != civ.AddrController && f.To != 0x00 {
+			continue
+		}
+		kept = append(kept, f)
+	}
+	if len(kept) != 2 {
+		t.Fatalf("kept %d frames, want 2 (ours + the broadcast)", len(kept))
+	}
+	if kept[0].Cmd != 0xFB {
+		t.Errorf("the acknowledgement was not the first kept frame: % X", kept[0].Cmd)
+	}
+	if kept[1].To != 0x00 {
+		t.Errorf("the transceive broadcast was dropped")
+	}
+}

internal/cat/icomserial.go

@@ -189,7 +189,7 @@ func NewIcomSerial(portName string, baud, civAddr int, digitalDefault string) *I
 		}
 		p, err := serial.Open(b.portName, &serial.Mode{BaudRate: b.baud})
 		if err != nil {
-			return nil, fmt.Errorf("open %s @ %d baud: %w", b.portName, b.baud, err)
+			return nil, fmt.Errorf("open %s @ %d baud: %w%s", b.portName, b.baud, err, busyHint(b.portName, err))
 		}
 		return p, nil
 	}
@@ -514,8 +514,21 @@ func (b *IcomSerial) SetFrequency(hz int64) error {
 		return fmt.Errorf("invalid frequency")
 	}
 	b.lastSetFreq, b.lastSetFreqAt = hz, time.Now()
-	return b.execIdempotent(fmt.Sprintf("set frequency %d Hz", hz),
+	err := b.execIdempotent(fmt.Sprintf("set frequency %d Hz", hz),
 		append([]byte{civ.CmdSetFreq}, civ.FreqToBCD(hz)...)...)
+	// Same reasoning as SetPTT: a lost acknowledgement is not a failed command,
+	// and WSJT-X or JTDX answer a failed set_freq by dropping the link — an
+	// IC-7850 log shows exactly that at 15:16:15, the disconnect four seconds
+	// later. The rig is asked what frequency it is on rather than being called a
+	// failure on the strength of a missing "FB".
+	if err == nil || !errors.Is(err, errIcomAckLost) {
+		return err
+	}
+	if got, rerr := b.readFreq(); rerr == nil && got == hz {
+		applog.Printf("icom: frequency %d Hz not acknowledged, but the rig is on it — treating as done", hz)
+		return nil
+	}
+	return err
 }
 
 func (b *IcomSerial) SetMode(mode string) error {
@@ -526,8 +539,17 @@ func (b *IcomSerial) SetMode(mode string) error {
 	// Set the base mode (keeping the rig's current filter by sending only the
 	// mode byte), then set the data-mode flag for digital modes.
 	if err := b.execIdempotent("set mode "+mode, civ.CmdSetMode, code); err != nil {
+		// A lost acknowledgement is not a refused mode — see SetPTT. The mode is
+		// readable, so ask rather than report a failure that would cost the
+		// digital application its connection.
+		if !errors.Is(err, errIcomAckLost) {
 			return err
 		}
+		if got, ok := b.readMode(); !ok || got != code {
+			return err
+		}
+		applog.Printf("icom: mode %s not acknowledged, but the rig reports it — treating as done", mode)
+	}
 	dataByte := byte(0)
 	if data {
 		dataByte = 1
@@ -569,12 +591,43 @@ func (b *IcomSerial) execIdempotent(what string, payload ...byte) error {
 }
 
 // SetPTT keys or unkeys the transmitter (CI-V 0x1C 0x00).
+// A lost acknowledgement is NOT proof the rig ignored us, and treating it as one
+// is expensive: OpsLog fronts a Hamlib rigctl port, so the failure is handed
+// straight to WSJT-X or JTDX, which answer a failed set_ptt with a Rig Control
+// Error and drop the link mid-over. An IC-7850 log showed exactly that, three
+// times in a session, on a CI-V bus with a second controller corrupting frames.
+//
+// So when the acknowledgement does not arrive, ASK the rig what it is doing. PTT
+// is readable (0x1C 0x00), the answer is unambiguous, and a rig that is keyed
+// received the command whatever became of its reply.
 func (b *IcomSerial) SetPTT(on bool) error {
 	state := byte(0)
 	if on {
 		state = 1
 	}
-	return b.execIdempotent(fmt.Sprintf("PTT %v", on), civ.CmdPTT, civ.SubPTT, state)
+	err := b.execIdempotent(fmt.Sprintf("PTT %v", on), civ.CmdPTT, civ.SubPTT, state)
+	if err == nil || !errors.Is(err, errIcomAckLost) {
+		return err
+	}
+	// A GENEROUS window for the verification, not the poll's 150 ms.
+	//
+	// The rig has just failed to answer twice in 800 ms, and the reason seen on a
+	// real IC-7850 is that it was retuning: JTDX moves the transmit frequency and
+	// keys in the same breath. Asking it again with the short probe timeout would
+	// fail for exactly the same reason and prove nothing.
+	keyed, ok := b.readTXWithin(icomPTTVerifyTimeout)
+	if ok && keyed == on {
+		applog.Printf("icom: PTT %v not acknowledged, but the rig reports it — treating as done", on)
+		return nil
+	}
+	// Logged either way, because "the fix did not work" and "the rig really did
+	// not key" look identical from outside and need telling apart.
+	if ok {
+		applog.Printf("icom: PTT %v not acknowledged, and the rig reports %v — reporting the failure", on, keyed)
+	} else {
+		applog.Printf("icom: PTT %v not acknowledged, and the rig did not answer the check either", on)
+	}
+	return err
 }
 
 // SetPower turns the transceiver on or off (CI-V 0x18). Power-ON is prefixed with
@@ -686,6 +739,19 @@ func (b *IcomSerial) reader(port civTransport, done chan struct{}) {
 			if f.From != b.rigAddr {
 				continue // echo of our own command
 			}
+			// Addressed to US, or broadcast.
+			//
+			// A CI-V bus can carry a second controller — RS-BA1, wfview, another
+			// logger — and the rig answers each of them in turn on the same wire.
+			// Those replies come FROM the rig, so the check above lets them through,
+			// and one can be taken for the answer to our own command: an IC-7850 log
+			// showed "FE FE 01 8E …" (to controller 01) arriving between our PTT
+			// command and its acknowledgement, with bus collisions around it.
+			// Transceive broadcasts (to 0x00) stay welcome — that is how the rig
+			// announces a knob turn.
+			if f.To != civ.AddrController && f.To != 0x00 {
+				continue
+			}
 			if f.Cmd == civ.CmdScope {
 				b.route(b.specCh, f)
 				continue
@@ -1273,16 +1339,30 @@ func (b *IcomSerial) readTXFreq() (int64, bool) {
 
 // readTX reads the transmit state (CI-V 0x1C 0x00): non-zero data = keyed.
 func (b *IcomSerial) readTX() bool {
-	if err := b.write(civ.CmdPTT, civ.SubPTT); err != nil {
-		return false
+	on, _ := b.readTXWithin(icomDSPTimeout)
+	return on
 }
-	f, err := b.recv(icomDSPTimeout, func(d civ.Decoded) bool {
+
+// icomPTTVerifyTimeout is how long the PTT check waits. Long, deliberately: it
+// runs only after a command was already given up on, so it costs nothing in the
+// normal case and everything depends on it in the abnormal one.
+const icomPTTVerifyTimeout = 700 * time.Millisecond
+
+// readTXWithin reads the transmit state, reporting whether the rig ANSWERED.
+//
+// The two are different questions and the caller usually needs both: "not
+// transmitting" and "did not say" are the same bool but not the same fact.
+func (b *IcomSerial) readTXWithin(timeout time.Duration) (on bool, answered bool) {
+	if err := b.write(civ.CmdPTT, civ.SubPTT); err != nil {
+		return false, false
+	}
+	f, err := b.recv(timeout, func(d civ.Decoded) bool {
 		return d.Cmd == civ.CmdPTT && len(d.Data) >= 2 && d.Data[0] == civ.SubPTT
 	})
 	if err != nil {
-		return false
+		return false, false
 	}
-	return f.Data[1] != 0
+	return f.Data[1] != 0, true
 }
 
 // readMeter reads a meter (CI-V 0x15) and returns it scaled to 0-100.

internal/cat/kenwood.go

@@ -210,7 +210,7 @@ func (k *Kenwood) Connect() error {
 		if k.host != "" {
 			return fmt.Errorf("kenwood: connect %s: %w", k.host, err)
 		}
-		return fmt.Errorf("kenwood: open %s @ %d baud: %w", k.portName, k.baud, err)
+		return fmt.Errorf("kenwood: open %s @ %d baud: %w%s", k.portName, k.baud, err, busyHint(k.portName, err))
 	}
 	p.SetReadTimeout(300 * time.Millisecond)
 	k.port = p

internal/cat/omnirig.go

@@ -500,10 +500,30 @@ func (o *OmniRig) SetFrequency(hz int64) error {
 	// deliberately; a spot click is a request to change frequency, not to change
 	// VFO. On SUB the direct FreqB write below does the whole job.
 	onSubVFO := vfo == "B" || vfo == "BB" || vfo == "BA"
+	// …and NEVER on a Yaesu.
+	//
+	// On Yaesu the call is useless at best: an FT-891 logged "SetSimplexMode OK"
+	// on every spot click while FreqA never moved (see below — the direct property
+	// write is what actually tunes these rigs). On an FT-2000 it is worse than
+	// useless. From a log of one QSY, before and after the call:
+	//
+	//	Vfo="AB"(0x80)  Split=0x10000 (off)   → the operator's state
+	//	Vfo="BA"(0x100) Split=0x8000  (ON)    → after SetSimplexMode
+	//
+	// The rig-agnostic "receive and transmit HERE, simplex" method turned split ON
+	// and moved reception to VFO B, which is exactly what the operator reported:
+	// OpsLog showing B instead of A. OpsLog was not misreading the radio — it was
+	// reading it correctly after having moved it itself.
+	//
+	// Restricted to Yaesu because that is where the evidence is: on Icom the call
+	// is authoritative and the direct write is the unreliable one.
+	isYaesu := isYaesuRig(rigType)
 	simplexOK := false
 	switch {
 	case onSubVFO:
 		debugLog.Printf("OmniRig.SetFrequency: on VFO %q — skipping SetSimplexMode so the rig stays on SUB", vfo)
+	case isYaesu:
+		debugLog.Printf("OmniRig.SetFrequency: %q is a Yaesu — skipping SetSimplexMode (a no-op on some, and on an FT-2000 it turns split on and jumps to VFO B); the direct write below does the work", rigType)
 	default:
 		if _, err := oleutil.CallMethod(o.rig, "SetSimplexMode", int32(hz32)); err == nil {
 			simplexOK = true

internal/cat/omnirig_vfo_test.go

@@ -125,3 +125,24 @@ func TestOmniRigWriteTarget(t *testing.T) {
 		}
 	}
 }
+
+// SetSimplexMode is skipped on Yaesu, and that is not a preference.
+//
+// On an FT-891 it returned OK on every spot click while the rig never moved. On
+// an FT-2000 it did something worse — a log of one QSY shows the state going
+// from Vfo="AB" split off to Vfo="BA" split ON, so the operator's reception
+// jumped to VFO B and OpsLog, reading the radio correctly, displayed B. The
+// direct FreqA/Freq write does the tuning on these rigs.
+func TestYaesuRigsAreRecognisedForTheSimplexSkip(t *testing.T) {
+	for _, yes := range []string{"FT-2000", "FT-891", "FTDX10", "ftdx101", " FT-991A "} {
+		if !isYaesuRig(yes) {
+			t.Errorf("%q not recognised as a Yaesu — SetSimplexMode would still be called on it", yes)
+		}
+	}
+	// Everything else keeps the call: on Icom it is the authoritative one.
+	for _, no := range []string{"IC-7610", "TS-590", "K3", "", "Flex-6600"} {
+		if isYaesuRig(no) {
+			t.Errorf("%q wrongly treated as a Yaesu", no)
+		}
+	}
+}

internal/cat/portbusy.go

@@ -0,0 +1,39 @@
+package cat
+
+// "Serial port busy" is a true statement that helps nobody.
+//
+// A COM port has exactly one owner, and when a rig's port is refused the owner
+// is almost always another program on the same desktop — most often OmniRig,
+// which stays resident once any application has activated it and keeps the port
+// of the rig configured in it. An operator switching from OmniRig to a native
+// backend therefore hits this the moment they save: OpsLog is now asking for a
+// port OmniRig never let go of. The message named none of that.
+//
+// It also happens the other way round, and the wording says so rather than
+// accusing: a digital application (WSJT-X, JTDX, MSHV) configured on the rig's
+// port directly, rather than through OpsLog's CAT sharing, holds it just as
+// firmly.
+
+import "strings"
+
+// busyHint returns a sentence to append to an open error, or "" when the error
+// is not about the port being taken.
+//
+// Deliberately not a wrapped error: this is advice for a human reading a log,
+// and it must not change how any caller compares the error.
+func busyHint(port string, err error) string {
+	if err == nil {
+		return ""
+	}
+	msg := strings.ToLower(err.Error())
+	busy := strings.Contains(msg, "busy") ||
+		strings.Contains(msg, "access is denied") ||
+		strings.Contains(msg, "denied") ||
+		strings.Contains(msg, "in use")
+	if !busy {
+		return ""
+	}
+	return " — another program holds " + port +
+		". OmniRig is the usual one (it stays running and keeps the port of the rig configured in it, so a native backend can never have it);" +
+		" a digital application pointed straight at the rig instead of at OpsLog's CAT sharing does the same. Close it, then reconnect."
+}

internal/cat/xiegu.go

@@ -95,7 +95,7 @@ func (x *Xiegu) Connect() error {
 	}
 	p, err := serial.Open(x.portName, &serial.Mode{BaudRate: x.baud})
 	if err != nil {
-		return fmt.Errorf("xiegu: open %s @ %d baud: %w", x.portName, x.baud, err)
+		return fmt.Errorf("xiegu: open %s @ %d baud: %w%s", x.portName, x.baud, err, busyHint(x.portName, err))
 	}
 	p.SetReadTimeout(200 * time.Millisecond)
 	// Deassert DTR and RTS.

internal/cat/yaesu.go

@@ -159,7 +159,7 @@ func (y *Yaesu) Connect() error {
 	}
 	p, err := serial.Open(y.portName, &serial.Mode{BaudRate: y.baud})
 	if err != nil {
-		return fmt.Errorf("yaesu: open %s @ %d baud: %w", y.portName, y.baud, err)
+		return fmt.Errorf("yaesu: open %s @ %d baud: %w%s", y.portName, y.baud, err, busyHint(y.portName, err))
 	}
 	// The modem lines are only touched when the operator asks for it — see the
 	// note on Kenwood.lowerLines. Both defaults break somebody's station.

internal/cat/yaesu_panel.go

@@ -50,6 +50,10 @@ type YaesuTXState struct {
 	Squelch int    `json:"squelch"`  // 0-100
 	AGC     string `json:"agc,omitempty"`
 	Preamp  int    `json:"preamp"` // 0=IPO, 1=AMP1, 2=AMP2
+	// Antenna is the selected jack, 1-3, or 0 when the rig has no AN command —
+	// an FT-891 or FT-991A has a single socket and answers nothing. 0 is what
+	// tells the panel to draw no selector at all rather than a dead one.
+	Antenna int  `json:"antenna"`
 	Att     int  `json:"att"` // 0=off, else dB
 	NB      bool `json:"nb"`
 	NR      bool `json:"nr"`
@@ -80,6 +84,7 @@ type YaesuController interface {
 	SetYaesuSquelch(int) error
 	SetYaesuAGC(string) error
 	SetYaesuPreamp(int) error
+	SetYaesuAntenna(int) error
 	SetYaesuAtt(int) error
 	SetYaesuNB(bool) error
 	SetYaesuNR(bool) error
@@ -239,6 +244,24 @@ func (y *Yaesu) readPanelSettings() {
 	if v, ok := y.askNum("PA0;", "PA0", 1); ok {
 		y.panel.Preamp = v
 	}
+	// ANTENNA. "AN0;" → "AN01;" — the first digit is the receiver (0 = main,
+	// 1 = sub on an FTDX101), the second the jack. A rig with one socket does
+	// not implement it and simply says nothing, which askNum reports as
+	// not-ok — and 0 then means "no antenna switching here".
+	if v, ok := y.askNum("AN0;", "AN0", 1); ok {
+		if y.panel.Antenna == 0 {
+			debugLog.Printf("yaesu: antenna select available (AN0; → %d)", v)
+		}
+		y.panel.Antenna = v
+	} else {
+		// Said once, at the first read: an operator who expects the ANT row and
+		// does not get it should find the reason in the log rather than wonder
+		// whether OpsLog forgot the feature.
+		if y.panel.Antenna != -1 {
+			debugLog.Printf("yaesu: no answer to AN0; — this rig has no antenna selection, the ANT row stays hidden")
+		}
+		y.panel.Antenna = -1
+	}
 	if v, ok := y.askNum("RA0;", "RA0", 1); ok {
 		y.panel.Att = yaesuAttDB(v)
 	}
@@ -356,6 +379,17 @@ func (y *Yaesu) SetYaesuPreamp(n int) error {
 	return y.setAndRefresh(fmt.Sprintf("PA0%d;", clampInt(n, 0, 2)))
 }
 
+// SetYaesuAntenna selects an antenna jack (1-3) on the main receiver.
+//
+// Verified against the FTDX10 command set; the FTDX101 adds a third jack and a
+// sub receiver, which is the "0" in AN0 — the day someone drives a sub receiver
+// from here it becomes a parameter rather than a constant. A rig without the
+// command ignores it, and readPanelSettings then keeps Antenna at 0, so the
+// control never appears in the first place.
+func (y *Yaesu) SetYaesuAntenna(n int) error {
+	return y.setAndRefresh(fmt.Sprintf("AN0%d;", clampInt(n, 1, 3)))
+}
+
 func (y *Yaesu) SetYaesuAtt(db int) error {
 	return y.setAndRefresh(fmt.Sprintf("RA0%d;", yaesuAttCode(db)))
 }

internal/cat/yaesu_test.go

@@ -1,6 +1,9 @@
 package cat
 
-import "testing"
+import (
+	"fmt"
+	"testing"
+)
 
 func TestParseYaesuFreq(t *testing.T) {
 	cases := []struct {
@@ -380,3 +383,26 @@ func TestYaesuModeVFOSuffix(t *testing.T) {
 		t.Errorf("setting CW on main sends %q, want MD03;", cmd)
 	}
 }
+
+// The antenna command, as the FTDX10 reference gives it: AN + receiver + jack.
+// The jack is clamped rather than trusted — a panel bug that sent AN09 would be
+// answered by the rig with silence, and the operator would be left wondering
+// which antenna they were on.
+func TestYaesuAntennaCommand(t *testing.T) {
+	for _, tc := range []struct {
+		in   int
+		want string
+	}{
+		{1, "AN01;"},
+		{2, "AN02;"},
+		{3, "AN03;"},
+		{0, "AN01;"}, // below range → the first jack
+		{9, "AN03;"}, // above range → the last
+		{-1, "AN01;"},
+	} {
+		got := fmt.Sprintf("AN0%d;", clampInt(tc.in, 1, 3))
+		if got != tc.want {
+			t.Errorf("antenna %d → %q, want %q", tc.in, got, tc.want)
+		}
+	}
+}

internal/db/db.go

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

internal/db/mysql.go

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

internal/db/roles.go

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

internal/db/roles_test.go

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

internal/extsvc/extsvc.go

@@ -36,6 +36,8 @@ const (
 	// ServiceCloudlog covers Cloudlog AND its fork Wavelog: same API contract,
 	// only the instance URL differs, so one service handles both.
 	ServiceCloudlog Service = "cloudlog"
+	// ServiceHamlog is HAMLOG.online — one API key, an ADIF record per QSO.
+	ServiceHamlog Service = "hamlog"
 )
 
 // UploadMode selects when an auto-upload fires after a QSO is saved.
@@ -130,6 +132,7 @@ type ExternalServices struct {
 	HRDLog   ServiceConfig `json:"hrdlog"`
 	EQSL     ServiceConfig `json:"eqsl"`
 	Cloudlog ServiceConfig `json:"cloudlog"`
+	Hamlog   ServiceConfig `json:"hamlog"`
 
 	// DeleteRemote asks OpsLog to withdraw a QSO from QRZ.com and Club Log when
 	// it is deleted locally. Off unless the operator turns it on: neither

internal/extsvc/hamlog.go

@@ -0,0 +1,149 @@
+package extsvc
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+)
+
+// HAMLOG.online — a cloud logbook whose confirmations feed its own award
+// programme, so operators want their contacts there as they make them.
+//
+// # Where this protocol comes from
+//
+// HAMLOG publishes no API documentation. What follows is read from THEIR OWN
+// client, the HAMLOG Agent (github.com/hamlogonline/Agent, Hamlog/hamlog_api.py)
+// — the authoritative source short of asking them, and the same code their own
+// users run:
+//
+//	POST https://hamlog.online/api/agent/     (JSON in, JSON out)
+//
+//	{"KEYSTATUS": {"APIKEY": k}}                  → {"STATUS":"OK","CALLSIGN":…,"EXPIRES":…}
+//	{"ADIFADD":   {"APIKEY": k, "ADIFDATA": rec}} → {"STATUS":"OK"}
+//	{"QSOADD":    {"APIKEY": k, "DATA": {…}}}     → field map, keys upper-cased
+//	{"LOGOUT":    {"APIKEY": k}}
+//
+// A failure answers {"ERROR": "…"} with no STATUS, so success is "STATUS is
+// exactly OK" rather than "no error field" — an unknown reply shape must not
+// read as an accepted QSO.
+//
+// ADIFADD is the verb used here: OpsLog already builds a full ADIF record for
+// every other service, and sending the same bytes keeps one representation of
+// a contact instead of two.
+//
+// The operator gets their key from https://hamlog.online/account/agent.php.
+const (
+	hamlogAPIEndpoint = "https://hamlog.online/api/agent/"
+	hamlogKeyPage     = "https://hamlog.online/account/agent.php"
+)
+
+// hamlogReply is the shape both success and failure share.
+type hamlogReply struct {
+	Status   string `json:"STATUS"`
+	Error    string `json:"ERROR"`
+	Callsign string `json:"CALLSIGN"`
+	Expires  any    `json:"EXPIRES"` // seconds since the epoch; string or number depending on the verb
+}
+
+// hamlogPost sends one verb and decodes the reply.
+func hamlogPost(ctx context.Context, client *http.Client, endpoint string, body map[string]any) (hamlogReply, error) {
+	buf, err := json.Marshal(body)
+	if err != nil {
+		return hamlogReply{}, fmt.Errorf("hamlog: encode request: %w", err)
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, endpoint, bytes.NewReader(buf))
+	if err != nil {
+		return hamlogReply{}, fmt.Errorf("hamlog: build request: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Accept", "application/json")
+	if client == nil {
+		client = &http.Client{Timeout: 20 * time.Second}
+	}
+	resp, err := client.Do(req)
+	if err != nil {
+		return hamlogReply{}, fmt.Errorf("hamlog: request failed: %w", err)
+	}
+	defer resp.Body.Close()
+	raw, _ := io.ReadAll(io.LimitReader(resp.Body, 64*1024))
+	var r hamlogReply
+	if jerr := json.Unmarshal(raw, &r); jerr != nil {
+		// Not JSON at all — a proxy error page, a maintenance notice. Report what
+		// arrived rather than "invalid character '<'", which tells an operator
+		// nothing about their own setup.
+		msg := strings.TrimSpace(string(raw))
+		if len(msg) > 200 {
+			msg = msg[:200]
+		}
+		if msg == "" {
+			msg = fmt.Sprintf("HTTP %d", resp.StatusCode)
+		}
+		return hamlogReply{}, fmt.Errorf("hamlog: unexpected reply: %s", msg)
+	}
+	return r, nil
+}
+
+// hamlogFailure turns a reply into a human-readable reason, or "" on success.
+func hamlogFailure(r hamlogReply) string {
+	if strings.EqualFold(strings.TrimSpace(r.Status), "OK") {
+		return ""
+	}
+	if e := strings.TrimSpace(r.Error); e != "" {
+		return e
+	}
+	return "rejected"
+}
+
+// UploadHamlog pushes one ADIF record to HAMLOG.online.
+func UploadHamlog(ctx context.Context, client *http.Client, cfg ServiceConfig, adifRecord string) (UploadResult, error) {
+	return uploadHamlogTo(ctx, client, hamlogAPIEndpoint, cfg, adifRecord)
+}
+
+func uploadHamlogTo(ctx context.Context, client *http.Client, endpoint string, cfg ServiceConfig, adifRecord string) (UploadResult, error) {
+	key := strings.TrimSpace(cfg.APIKey)
+	if key == "" {
+		return UploadResult{}, fmt.Errorf("hamlog: API key not set — get one at %s", hamlogKeyPage)
+	}
+	rec := strings.TrimSpace(adifRecord)
+	if rec == "" {
+		return UploadResult{}, fmt.Errorf("hamlog: empty ADIF record")
+	}
+	r, err := hamlogPost(ctx, client, endpoint, map[string]any{
+		"ADIFADD": map[string]any{"APIKEY": key, "ADIFDATA": rec},
+	})
+	if err != nil {
+		return UploadResult{}, err
+	}
+	if reason := hamlogFailure(r); reason != "" {
+		return UploadResult{OK: false, Message: reason}, nil
+	}
+	return UploadResult{OK: true}, nil
+}
+
+// CheckHamlogKey validates an API key and reports the callsign it belongs to.
+//
+// Worth its own call because HAMLOG offers what no other service here does: the
+// key can be checked BEFORE the first QSO, and the answer names the account. An
+// operator who pasted the key of another callsign — or one that has expired —
+// finds out in the settings panel rather than through a week of silent refusals.
+func CheckHamlogKey(ctx context.Context, client *http.Client, key string) (callsign string, err error) {
+	key = strings.TrimSpace(key)
+	if key == "" {
+		return "", fmt.Errorf("hamlog: API key not set — get one at %s", hamlogKeyPage)
+	}
+	r, perr := hamlogPost(ctx, client, hamlogAPIEndpoint, map[string]any{
+		"KEYSTATUS": map[string]any{"APIKEY": key},
+	})
+	if perr != nil {
+		return "", perr
+	}
+	if reason := hamlogFailure(r); reason != "" {
+		return "", fmt.Errorf("hamlog: %s", reason)
+	}
+	return strings.ToUpper(strings.TrimSpace(r.Callsign)), nil
+}

internal/extsvc/hamlog_test.go

@@ -0,0 +1,87 @@
+package extsvc
+
+import (
+	"context"
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+)
+
+// The verb, the key and the record must arrive in the shape HAMLOG's own agent
+// sends — this is read from their client, not from documentation, so the test
+// pins it rather than trusting a memory of it.
+func TestUploadHamlogRequestShape(t *testing.T) {
+	var got map[string]map[string]any
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodPost {
+			t.Errorf("method %s, want POST", r.Method)
+		}
+		if ct := r.Header.Get("Content-Type"); !strings.Contains(ct, "application/json") {
+			t.Errorf("Content-Type %q", ct)
+		}
+		b, _ := io.ReadAll(r.Body)
+		_ = json.Unmarshal(b, &got)
+		_, _ = w.Write([]byte(`{"STATUS":"OK"}`))
+	}))
+	defer srv.Close()
+
+	res, err := uploadHamlogTo(context.Background(), nil, srv.URL, ServiceConfig{APIKey: "KEY123"}, "<call:5>F4BPO <eor>")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !res.OK {
+		t.Fatalf("upload not OK: %+v", res)
+	}
+	add, ok := got["ADIFADD"]
+	if !ok {
+		t.Fatalf("no ADIFADD verb in %v", got)
+	}
+	if add["APIKEY"] != "KEY123" {
+		t.Errorf("APIKEY = %v", add["APIKEY"])
+	}
+	if add["ADIFDATA"] != "<call:5>F4BPO <eor>" {
+		t.Errorf("ADIFDATA = %v", add["ADIFDATA"])
+	}
+}
+
+// A refusal must be reported as a refusal. Their failure shape carries ERROR
+// and no STATUS, so "no error field" would have read an unknown reply as an
+// accepted QSO — which is how a contact goes missing without anyone noticing.
+func TestHamlogFailureIsNotSuccess(t *testing.T) {
+	for _, tc := range []struct {
+		body     string
+		wantOK   bool
+		wantSaid string
+	}{
+		{`{"STATUS":"OK"}`, true, ""},
+		{`{"ERROR":"Invalid API key"}`, false, "Invalid API key"},
+		{`{"STATUS":"FAILED"}`, false, "rejected"},
+		{`{}`, false, "rejected"}, // an empty object is not an acceptance
+	} {
+		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			_, _ = w.Write([]byte(tc.body))
+		}))
+		res, err := uploadHamlogTo(context.Background(), nil, srv.URL, ServiceConfig{APIKey: "K"}, "<eor>")
+		srv.Close()
+		if err != nil {
+			t.Fatalf("%s: %v", tc.body, err)
+		}
+		if res.OK != tc.wantOK {
+			t.Errorf("%s → OK=%v, want %v", tc.body, res.OK, tc.wantOK)
+		}
+		if !tc.wantOK && res.Message != tc.wantSaid {
+			t.Errorf("%s → message %q, want %q", tc.body, res.Message, tc.wantSaid)
+		}
+	}
+}
+
+// Nothing leaves without a key, and the message says where to get one.
+func TestUploadHamlogNeedsAKey(t *testing.T) {
+	_, err := UploadHamlog(context.Background(), nil, ServiceConfig{}, "<eor>")
+	if err == nil || !strings.Contains(err.Error(), hamlogKeyPage) {
+		t.Fatalf("err = %v, want it to point at %s", err, hamlogKeyPage)
+	}
+}

internal/extsvc/manager.go

@@ -139,6 +139,7 @@ func (m *Manager) SetConfig(cfg ExternalServices) {
 	cfg.HRDLog = cfg.HRDLog.normalised()
 	cfg.EQSL = cfg.EQSL.normalised()
 	cfg.Cloudlog = cfg.Cloudlog.normalised()
+	cfg.Hamlog = cfg.Hamlog.normalised()
 	m.cfg = cfg
 
 	// Summary of what is armed, written at startup and on every settings save.
@@ -152,6 +153,7 @@ func (m *Manager) SetConfig(cfg ExternalServices) {
 	}{
 		{"qrz", cfg.QRZ}, {"clublog", cfg.Clublog}, {"lotw", cfg.LoTW},
 		{"hrdlog", cfg.HRDLog}, {"eqsl", cfg.EQSL}, {"cloudlog", cfg.Cloudlog},
+		{"hamlog", cfg.Hamlog},
 	} {
 		if s.cfg.AutoUpload {
 			on = append(on, fmt.Sprintf("%s(%s)", s.name, s.cfg.UploadMode))
@@ -227,6 +229,14 @@ func (m *Manager) OnQSOLogged(id int64) {
 			m.route(ServiceCloudlog, id, c)
 		}
 	}
+	// HAMLOG.online — one API key and nothing else to get wrong.
+	if h := cfg.Hamlog; h.AutoUpload {
+		if h.APIKey == "" {
+			m.logf("extsvc: hamlog auto-upload is ON but no API key is set (QSO %d not sent)", id)
+		} else {
+			m.route(ServiceHamlog, id, h)
+		}
+	}
 }
 
 // route sends a logged QSO down the configured timing path: queue it for the
@@ -277,6 +287,9 @@ func (m *Manager) onCloseServices() []Service {
 	if c := cfg.Cloudlog; c.AutoUpload && c.UploadMode == ModeOnClose && c.URL != "" && c.APIKey != "" && c.StationID != "" {
 		out = append(out, ServiceCloudlog)
 	}
+	if h := cfg.Hamlog; h.AutoUpload && h.UploadMode == ModeOnClose && h.APIKey != "" {
+		out = append(out, ServiceHamlog)
+	}
 	return out
 }
 
@@ -323,6 +336,8 @@ func (m *Manager) FlushOnClose() int {
 			uploaded += m.flushOneByOne(svc, ids, cfg.HRDLog)
 		case ServiceCloudlog:
 			uploaded += m.flushOneByOne(svc, ids, cfg.Cloudlog)
+		case ServiceHamlog:
+			uploaded += m.flushOneByOne(svc, ids, cfg.Hamlog)
 		}
 	}
 	return uploaded
@@ -644,6 +659,16 @@ func (m *Manager) upload(svc Service, id int64, cfg ServiceConfig) (ok bool, ret
 			return false, false
 		}
 		res, err = UploadCloudlog(ctx, m.deps.Client, cfg, record)
+	case ServiceHamlog:
+		// The station callsign is whatever the QSO carries: HAMLOG files the
+		// contact under the account the API key belongs to, and KEYSTATUS is how
+		// the operator checks that account is the right one.
+		record, ok := m.deps.BuildADIF(id, "")
+		if !ok {
+			m.logf("extsvc: %s upload of QSO %d skipped (no record)", svc, id)
+			return false, false
+		}
+		res, err = UploadHamlog(ctx, m.deps.Client, cfg, record)
 	default:
 		return false, false
 	}

internal/qso/bulkmode_test.go

@@ -24,3 +24,29 @@ func TestBandIsNotBulkEditableAlone(t *testing.T) {
 		}
 	}
 }
+
+// A log uploaded to HAMLOG.online BY HAND has to be markable afterwards, or
+// OpsLog offers to send every one of those contacts again. Both directions live
+// in extras — the ADIF names a field for hamlog.EU and none for hamlog.ONLINE —
+// so they must be reachable through the extras path, not the column one.
+func TestHamlogFieldsAreBulkEditable(t *testing.T) {
+	for field, want := range map[string]string{
+		"hamlog_sent":      "APP_OPSLOG_HAMLOG_SENT",
+		"hamlog_sent_date": "APP_OPSLOG_HAMLOG_SENT_DATE",
+		// Their field name — see award.HamlogQSLKey. Editing it by hand and
+		// importing their ADIF must land in the SAME place.
+		"hamlog_rcvd":      "APP_HAMLOG_QSO_CFM",
+		"hamlog_rcvd_date": "APP_OPSLOG_HAMLOG_QSL_DATE",
+	} {
+		if got := BulkExtraKey(field); got != want {
+			t.Errorf("BulkExtraKey(%q) = %q, want %q", field, got, want)
+		}
+	}
+	// And they are NOT columns: a mapping that also claimed a column would write
+	// to a table that has none.
+	for _, col := range []string{"hamlog_sent", "hamlog_rcvd", "APP_OPSLOG_HAMLOG_SENT"} {
+		if BulkEditable(col) {
+			t.Errorf("%q is offered as a bulk-editable COLUMN", col)
+		}
+	}
+}

internal/qso/filter_in_test.go

@@ -55,3 +55,24 @@ func TestNotInKeepsNulls(t *testing.T) {
 		t.Errorf("sql = %q, want the column wrapped in IFNULL", sql)
 	}
 }
+
+// Every HAMLOG field an operator can bulk-edit must also be filterable: the
+// question "which contacts have never gone to HAMLOG" is what you ask BEFORE
+// uploading a backlog, and a field that can be written but not read back is
+// half a feature.
+func TestHamlogFieldsAreFilterable(t *testing.T) {
+	filterable := map[string]bool{}
+	for _, f := range FilterableFields() {
+		filterable[f] = true
+	}
+	for _, f := range []string{"hamlog_sent", "hamlog_sent_date", "hamlog_rcvd", "hamlog_rcvd_date"} {
+		if !filterable[f] {
+			t.Errorf("%s is bulk-editable but not filterable", f)
+		}
+	}
+	// The received key must be THEIR name, or an imported log filters differently
+	// from a stamped one — the exact split the confirmation source exists to avoid.
+	if got := filterableExtras["hamlog_rcvd"]; got != "APP_HAMLOG_QSO_CFM" {
+		t.Errorf("hamlog_rcvd filters on %q, want APP_HAMLOG_QSO_CFM", got)
+	}
+}

internal/qso/qso.go

@@ -909,6 +909,19 @@ func (r *Repo) BulkSetField(ctx context.Context, ids []int64, column, value stri
 // column and there is no owner_callsign column.
 var bulkEditableExtras = map[string]string{
 	"owner_callsign": "OWNER_CALLSIGN",
+	// HAMLOG.online has no promoted column — the ADIF standard defines a field
+	// for hamlog.EU and none for hamlog.ONLINE. Bulk-editable because a log
+	// uploaded to their site BY HAND has to be markable afterwards: without it
+	// OpsLog would offer to send every one of those contacts again.
+	//
+	// A STATUS and a DATE in each direction, like every other service: one field
+	// holding a date and standing in for the flag looked clever and read as a
+	// riddle — "which of these two is the status?" was the first thing an
+	// operator asked of it.
+	"hamlog_sent":      "APP_OPSLOG_HAMLOG_SENT",
+	"hamlog_sent_date": "APP_OPSLOG_HAMLOG_SENT_DATE",
+	"hamlog_rcvd":      "APP_HAMLOG_QSO_CFM",
+	"hamlog_rcvd_date": "APP_OPSLOG_HAMLOG_QSL_DATE",
 }
 
 // BulkExtraKey maps a frontend field id to its ADIF key in extras_json, or "".
@@ -1278,11 +1291,16 @@ var filterableColumns = map[string]bool{
 	"my_wwff_ref": true, "my_street": true, "my_city": true, "my_postal_code": true,
 	"my_rig": true, "my_antenna": true, "my_sig": true, "my_sig_info": true,
 	"tx_pwr": true, "comment": true, "notes": true,
+	// When the record entered THIS logbook, as opposed to when the contact was
+	// made. The question it answers is "what did that import actually add?" —
+	// unanswerable otherwise, since an import of old contacts carries old QSO
+	// dates and hides inside the log.
+	"created_at": true,
 }
 
 // dateColumns are stored as full ISO timestamps; a filter on a bare YYYY-MM-DD
 // value compares on the date part (see conditionSQL) so day filters are exact.
-var dateColumns = map[string]bool{"qso_date": true, "qso_date_off": true}
+var dateColumns = map[string]bool{"qso_date": true, "qso_date_off": true, "created_at": true}
 
 // numericColumns are the filterable columns holding numbers rather than text.
 //
@@ -1303,6 +1321,15 @@ var bareDateRe = regexp.MustCompile(`^\d{4}-\d{2}-\d{2}$`)
 // ADIF/Extras key; the SQL expression uses json_extract.
 var filterableExtras = map[string]string{
 	"owner_callsign": "OWNER_CALLSIGN",
+	// HAMLOG.online, in both directions and with its dates. Filterable for the
+	// same reason it is bulk-editable: without it there is no way to ask "which
+	// contacts have never gone there", which is the question an operator asks
+	// before uploading a backlog. The received key is THEIR field name — see
+	// award.HamlogQSLKey — so an imported log filters the same as a stamped one.
+	"hamlog_sent":      "APP_OPSLOG_HAMLOG_SENT",
+	"hamlog_sent_date": "APP_OPSLOG_HAMLOG_SENT_DATE",
+	"hamlog_rcvd":      "APP_HAMLOG_QSO_CFM",
+	"hamlog_rcvd_date": "APP_OPSLOG_HAMLOG_QSL_DATE",
 }
 
 // FilterableFields returns the whitelist (for the frontend to build its field
@@ -3750,3 +3777,39 @@ func (r *Repo) IDByDedupeKey(ctx context.Context, callsign, qsoDateMinute, band,
 	}
 	return id, u.String, true, nil
 }
+
+// ListMissingExtra returns the QSOs that do NOT carry an ADIF extras key.
+//
+// For a service with no status column of its own — HAMLOG.online, whose field
+// the ADIF standard does not define — this is the backlog: everything never
+// sent. Matched with LIKE on the extras JSON, which is a full scan; that is
+// acceptable here because it answers a button the operator presses, not a hot
+// path, and the alternative is a promoted column for a field no other program
+// would ever read.
+func (r *Repo) ListMissingExtra(ctx context.Context, key string) ([]QSO, error) {
+	key = strings.ToUpper(strings.TrimSpace(key))
+	if key == "" {
+		return nil, fmt.Errorf("missing extras key")
+	}
+	// The JSON is written by encoding/json, so a present key always appears as
+	// "KEY": — quoted, followed by a colon. A value containing that text cannot
+	// produce a false positive: it would be escaped inside its own quotes.
+	like := "%\"" + key + "\":%"
+	rows, err := r.db.QueryContext(ctx,
+		`SELECT `+selectCols+` FROM qso
+		 WHERE COALESCE(extras_json,'') NOT LIKE ?
+		 ORDER BY qso_date DESC, id DESC`, like)
+	if err != nil {
+		return nil, fmt.Errorf("list missing extra: %w", err)
+	}
+	defer rows.Close()
+	out := make([]QSO, 0, 64)
+	for rows.Next() {
+		q, err := scanQSO(rows)
+		if err != nil {
+			return nil, err
+		}
+		out = append(out, q)
+	}
+	return out, rows.Err()
+}

internal/qso/syncuid_test.go

@@ -143,3 +143,37 @@ func TestIDByDedupeKeyRecognisesTheSameContact(t *testing.T) {
 		t.Error("an empty key matched a row")
 	}
 }
+
+// A service with no status column of its own — HAMLOG.online, whose field the
+// ADIF standard does not define — finds its backlog by the ABSENCE of an extras
+// key. The LIKE has to match the key, and only the key: a QSO whose comment
+// happens to contain the same text must not be mistaken for one already sent.
+func TestListMissingExtraMatchesTheKeyNotItsText(t *testing.T) {
+	r := openRepo(t)
+	ctx := context.Background()
+
+	sent := addQSO(t, r, "F4BPO", time.Date(2026, 1, 1, 12, 0, 0, 0, time.UTC))
+	notSent, err := r.Add(ctx, QSO{
+		Callsign: "F1TRF", QSODate: time.Date(2026, 1, 2, 12, 0, 0, 0, time.UTC),
+		Band: "40m", Mode: "CW",
+		Comment: "mentions APP_OPSLOG_HAMLOG_SENT in the text",
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := r.SetExtra(ctx, sent, "APP_OPSLOG_HAMLOG_SENT", "20260823"); err != nil {
+		t.Fatal(err)
+	}
+
+	got, err := r.ListMissingExtra(ctx, "APP_OPSLOG_HAMLOG_SENT")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(got) != 1 || got[0].ID != notSent {
+		ids := make([]int64, len(got))
+		for i, q := range got {
+			ids[i] = q.ID
+		}
+		t.Fatalf("backlog = %v, want just %d (the one never sent)", ids, notSent)
+	}
+}

internal/steppir/steppir.go

@@ -30,6 +30,7 @@ import (
 	"io"
 	"log"
 	"net"
+	"strings"
 	"sync"
 	"time"
 
@@ -126,6 +127,9 @@ type Client struct {
 	pendingDirSet bool
 
 	stopChan chan struct{}
+	// done is closed by the poll loop on its way out, so Stop can wait for the
+	// serial port to be genuinely released — see Stop.
+	done    chan struct{}
 	running bool
 }
 
@@ -138,10 +142,20 @@ func New(tr Transport) *Client {
 
 func (c *Client) Start() error {
 	c.running = true
+	c.done = make(chan struct{})
 	go c.pollLoop()
 	return nil
 }
 
+// Stop closes the link and WAITS for the poll loop to leave.
+//
+// Closing the port from another goroutine does not undo an open() the loop is
+// already inside: that open returns a fresh handle which the loop then stores,
+// and the stopped client goes on owning the serial port. The next client — a
+// settings save, a profile switch — cannot open it, and the operator sees
+// "Serial port busy" with no other program running.
+//
+// Bounded, so a device stuck in the driver cannot freeze a settings save.
 func (c *Client) Stop() {
 	if !c.running {
 		return
@@ -154,6 +168,14 @@ func (c *Client) Stop() {
 		c.conn = nil
 	}
 	c.connMu.Unlock()
+	if c.done == nil {
+		return
+	}
+	select {
+	case <-c.done:
+	case <-time.After(6 * time.Second):
+		log.Printf("steppir: poll loop did not exit within 6s — %s may stay busy a moment longer", c.target())
+	}
 }
 
 // LastSetKHz returns the frequency last commanded, or 0.
@@ -179,7 +201,14 @@ func (c *Client) open() (io.ReadWriteCloser, error) {
 		if c.tr.COM == "" {
 			return nil, fmt.Errorf("steppir: no serial port configured")
 		}
-		p, err := serial.Open(c.tr.COM, &serial.Mode{BaudRate: c.tr.Baud})
+		// 8N1 spelled out rather than left to the library defaults: a controller
+		// that answers nothing must not have a line format that depends on them.
+		p, err := serial.Open(c.tr.COM, &serial.Mode{
+			BaudRate: c.tr.Baud,
+			DataBits: 8,
+			Parity:   serial.NoParity,
+			StopBits: serial.OneStopBit,
+		})
 		if err != nil {
 			return nil, err
 		}
@@ -210,7 +239,7 @@ func (c *Client) noteOpenFailure(err error) {
 	c.connMu.Unlock()
 	switch {
 	case n <= openFailQuiet:
-		log.Printf("steppir: cannot open %s: %v (attempt %d)", c.target(), err, n)
+		log.Printf("steppir: cannot open %s: %v%s (attempt %d)", c.target(), err, portBusyHint(c.tr.Mode, c.tr.COM, err), n)
 	case n == openFailQuiet+1:
 		log.Printf("steppir: still cannot open %s — retrying every 2 s, further attempts will not be logged until it comes back", c.target())
 	}
@@ -225,6 +254,18 @@ func (c *Client) target() string {
 }
 
 func (c *Client) pollLoop() {
+	// Signals Stop that the port is genuinely released.
+	defer func() {
+		c.connMu.Lock()
+		if c.conn != nil {
+			c.conn.Close()
+			c.conn = nil
+		}
+		c.connMu.Unlock()
+		if c.done != nil {
+			close(c.done)
+		}
+	}()
 	ticker := time.NewTicker(2 * time.Second)
 	defer ticker.Stop()
 	for {
@@ -632,3 +673,16 @@ func (c *Client) Retract() error {
 	}
 	return c.writeCmd(buildSet(khz*1000, DirNormal, 'S'))
 }
+
+// portBusyHint turns "Serial port busy" into something actionable — see the
+// identical note in internal/ultrabeam.
+func portBusyHint(mode, com string, err error) string {
+	if mode != "serial" || err == nil {
+		return ""
+	}
+	msg := strings.ToLower(err.Error())
+	if !strings.Contains(msg, "busy") && !strings.Contains(msg, "access is denied") && !strings.Contains(msg, "denied") {
+		return ""
+	}
+	return " — another program already has " + com + " open (the SteppIR control window, PstRotator, a terminal). A COM port has one owner: close the other program, then OpsLog can connect."
+}

internal/ultrabeam/stop_test.go

@@ -0,0 +1,80 @@
+package ultrabeam
+
+import (
+	"bufio"
+	"errors"
+	"strings"
+	"testing"
+	"time"
+)
+
+// Stop must not return while the poll loop is still alive: on a serial link the
+// loop owns the port, and a client that outlives its Stop is what turned every
+// later connection into "Serial port busy".
+func TestStopWaitsForPollLoop(t *testing.T) {
+	// A transport that cannot connect, so the loop spends its life in open() and
+	// the reconnect path — the state the real fault happened in.
+	c := New(Transport{Mode: "tcp", Host: "127.0.0.1", Port: 1})
+	if err := c.Start(); err != nil {
+		t.Fatal(err)
+	}
+	done := c.done
+	time.Sleep(50 * time.Millisecond)
+	c.Stop()
+	select {
+	case <-done:
+	default:
+		t.Fatal("Stop returned while the poll loop was still running")
+	}
+	// Stopping twice must not panic on the closed channel.
+	c.Stop()
+}
+
+func TestPortBusyHint(t *testing.T) {
+	// The Windows driver's own words, and the ones an operator has to act on.
+	if h := portBusyHint("serial", "COM13", errors.New("Serial port busy")); !strings.Contains(h, "COM13") {
+		t.Fatalf("no hint for a busy port: %q", h)
+	}
+	if h := portBusyHint("serial", "COM13", errors.New("Access is denied.")); h == "" {
+		t.Fatal("no hint for access denied")
+	}
+	// A port that simply is not there is a different problem, and saying "another
+	// program has it" would send the operator hunting for a program that is not
+	// running.
+	if h := portBusyHint("serial", "COM13", errors.New("The system cannot find the file specified.")); h != "" {
+		t.Fatalf("hinted at a busy port for a missing one: %q", h)
+	}
+	if h := portBusyHint("tcp", "", errors.New("connection refused")); h != "" {
+		t.Fatalf("serial hint on a TCP link: %q", h)
+	}
+}
+
+// silentPort answers every read the way a serial port with nothing on the other
+// end does: no bytes, no error. bufio turns a run of those into ErrNoProgress.
+type silentPort struct{ writes int }
+
+func (s *silentPort) Read(p []byte) (int, error)  { return 0, nil }
+func (s *silentPort) Write(p []byte) (int, error) { s.writes++; return len(p), nil }
+func (s *silentPort) Close() error                { return nil }
+
+// A controller that never answers must fail ONCE, promptly, with a message that
+// says so — not wedge the poll loop for minutes inside bufio's retry budget.
+func TestSilentControllerFailsWithinTheReadTimeout(t *testing.T) {
+	c := New(Transport{Mode: "serial", COM: "COM_TEST", Baud: 9600})
+	c.conn = &silentPort{}
+	c.reader = bufio.NewReader(c.conn)
+
+	start := time.Now()
+	_, err := c.sendCommand(CMD_STATUS, nil)
+	elapsed := time.Since(start)
+
+	if err == nil {
+		t.Fatal("a silent controller reported success")
+	}
+	if elapsed > 3*ubReadTimeout {
+		t.Fatalf("took %s to give up — the read deadline is not bounding the exchange", elapsed.Round(time.Millisecond))
+	}
+	if !strings.Contains(err.Error(), "no reply") {
+		t.Fatalf("unhelpful error for a silent port: %v", err)
+	}
+}

internal/ultrabeam/ultrabeam.go

@@ -17,6 +17,7 @@ import (
 	"log"
 	"net"
 	"runtime"
+	"strings"
 	"sync"
 	"time"
 
@@ -91,10 +92,20 @@ type Client struct {
 	lastStatus *Status
 	statusMu   sync.RWMutex
 	stopChan   chan struct{}
+	// done is closed by pollLoop as it exits, so Stop can WAIT for it. Without
+	// that wait the loop outlives the client that owns it, and on a serial link
+	// the zombie keeps the port open: every later client then fails with "Serial
+	// port busy" — forever, because the thing holding the port is us.
+	done    chan struct{}
 	running bool
 	seqNum  byte
 	seqMu   sync.Mutex
 
+	// First-exchange diagnostics — see armDiag.
+	diagMu   sync.Mutex
+	diag     bool
+	diagJunk []byte
+
 	// Optimistic pattern direction kept until the antenna's status poll reports
 	// it (or it ages out) — the motors take a second or two, and a stale poll in
 	// between would otherwise snap the UI back to the old direction.
@@ -165,7 +176,15 @@ func (c *Client) open() (io.ReadWriteCloser, error) {
 		if c.tr.COM == "" {
 			return nil, fmt.Errorf("ultrabeam: no serial port configured")
 		}
-		p, err := serial.Open(c.tr.COM, &serial.Mode{BaudRate: c.tr.Baud})
+		// 8N1 spelled out. The library's zero values happen to mean the same
+		// thing today, but a controller that answers nothing is impossible to
+		// diagnose with a line count that depends on a default.
+		p, err := serial.Open(c.tr.COM, &serial.Mode{
+			BaudRate: c.tr.Baud,
+			DataBits: 8,
+			Parity:   serial.NoParity,
+			StopBits: serial.OneStopBit,
+		})
 		if err != nil {
 			return nil, err
 		}
@@ -181,6 +200,27 @@ func (c *Client) open() (io.ReadWriteCloser, error) {
 	return dialer.Dial("tcp", net.JoinHostPort(c.tr.Host, fmt.Sprintf("%d", c.tr.Port)))
 }
 
+// diagNextExchange asks for the next command/reply to be dumped to the log.
+//
+// "It does not work" is unanswerable for a serial link, because the three
+// possible causes look identical from the outside: nothing arrives (wrong port,
+// dead cable, controller off), something arrives but is not our protocol (wrong
+// baud), or a valid frame arrives and we misread it. One hex dump of the first
+// exchange after each connect separates them, and costs two log lines per
+// connection.
+func (c *Client) armDiag() {
+	c.diagMu.Lock()
+	c.diag = true
+	c.diagJunk = c.diagJunk[:0]
+	c.diagMu.Unlock()
+}
+
+func (c *Client) diagOn() bool {
+	c.diagMu.Lock()
+	defer c.diagMu.Unlock()
+	return c.diag
+}
+
 // target names what the client is talking to, for the log.
 func (c *Client) target() string {
 	if c.tr.Mode == "serial" {
@@ -219,10 +259,22 @@ func transientRead(err error) bool {
 
 func (c *Client) Start() error {
 	c.running = true
+	c.done = make(chan struct{})
 	go c.pollLoop()
 	return nil
 }
 
+// Stop closes the link and WAITS for the poll loop to leave.
+//
+// The wait is the point. Closing the port from another goroutine does not undo
+// an open() the loop is already inside: that open returns a fresh handle, the
+// loop stores it, and the client that was told to stop goes on owning the serial
+// port. The next client — a settings save, a profile switch — then cannot open
+// it, and the operator sees "Serial port busy" with no other program running.
+//
+// Bounded, because a serial open can sit in the driver for a while and a stuck
+// device must not freeze a settings save. If the deadline passes, the loop is
+// still on its way out and the log says so.
 func (c *Client) Stop() {
 	if !c.running {
 		return
@@ -236,9 +288,30 @@ func (c *Client) Stop() {
 		c.conn = nil
 	}
 	c.connMu.Unlock()
+
+	if c.done == nil {
+		return
+	}
+	select {
+	case <-c.done:
+	case <-time.After(6 * time.Second):
+		log.Printf("Ultrabeam: poll loop did not exit within 6s — %s may stay busy a moment longer", c.target())
+	}
 }
 
 func (c *Client) pollLoop() {
+	// Signals Stop that the port is genuinely released.
+	defer func() {
+		c.connMu.Lock()
+		if c.conn != nil {
+			c.conn.Close()
+			c.conn = nil
+		}
+		c.connMu.Unlock()
+		if c.done != nil {
+			close(c.done)
+		}
+	}()
 	ticker := time.NewTicker(2 * time.Second) // Increased from 500ms to 2s
 	defer ticker.Stop()
 
@@ -256,7 +329,7 @@ func (c *Client) pollLoop() {
 				log.Printf("Ultrabeam: Not connected, attempting connection to %s...", c.target())
 				conn, err := c.open()
 				if err != nil {
-					log.Printf("Ultrabeam: Connection failed: %v", err)
+					log.Printf("Ultrabeam: Connection failed: %v%s", err, portBusyHint(c.tr.Mode, c.tr.COM, err))
 					c.connMu.Unlock()
 
 					// Mark as disconnected
@@ -266,9 +339,25 @@ func (c *Client) pollLoop() {
 					continue
 				}
 				c.conn = conn
+				// Stopped while open() was running? Let go of the port at once.
+				// Stop cannot interrupt an open already in flight, so without this
+				// the fresh handle is stored by a client that has been told to die,
+				// and it keeps the port — which is precisely the "Serial port busy"
+				// the next client then reports, forever.
+				select {
+				case <-c.stopChan:
+					conn.Close()
+					c.conn = nil // already closed; keep the deferred cleanup from closing it twice
+					c.connMu.Unlock()
+					return
+				default:
+				}
 				c.reader = bufio.NewReader(c.conn)
 				pollFails = 0
 				log.Printf("Ultrabeam: Connected to %s", c.target())
+				// Dump the first exchange on this link. A connection that opens and
+				// then says nothing is the whole of what a serial user can see.
+				c.armDiag()
 			}
 			c.connMu.Unlock()
 
@@ -502,6 +591,10 @@ func (c *Client) sendCommand(cmd byte, data []byte) ([]byte, error) {
 
 	seq := c.getNextSeq()
 	packet := c.buildPacket(seq, cmd, data)
+	diag := c.diagOn()
+	if diag {
+		log.Printf("Ultrabeam: first exchange on %s — sending %d bytes: % X", c.target(), len(packet), packet)
+	}
 	if _, err := c.conn.Write(packet); err != nil {
 		return nil, fmt.Errorf("failed to write: %w", err)
 	}
@@ -509,6 +602,20 @@ func (c *Client) sendCommand(cmd byte, data []byte) ([]byte, error) {
 	// Read the reply with a timeout generous enough for a remote link.
 	c.setReadTimeout(ubReadTimeout)
 	buffer, err := c.readPacket()
+	if diag {
+		c.diagMu.Lock()
+		junk := append([]byte(nil), c.diagJunk...)
+		c.diag = false
+		c.diagMu.Unlock()
+		switch {
+		case err != nil && len(junk) == 0:
+			log.Printf("Ultrabeam: first exchange — NOTHING came back (%v). The controller is not answering on this port. Note that the USB cable presents TWO COM ports and only the SECOND one reaches the controller (at 19200 baud on the units seen so far); also check the cable and that the controller is on.", err)
+		case err != nil:
+			log.Printf("Ultrabeam: first exchange — %d bytes came back but no frame started (% X): %v. Bytes with no frame usually mean the wrong baud rate.", len(junk), junk, err)
+		default:
+			log.Printf("Ultrabeam: first exchange — reply %d bytes: % X (%d discarded before the frame: % X)", len(buffer), buffer, len(junk), junk)
+		}
+	}
 	if err != nil {
 		return nil, err
 	}
@@ -561,13 +668,53 @@ func (c *Client) drainStale() {
 // so a raw ETX only ever appears as the real terminator. Caller holds connMu and
 // has set a read deadline.
 func (c *Client) readPacket() ([]byte, error) {
+	// A DEADLINE for the whole frame, not a timeout per read.
+	//
+	// A silent serial port does not error: it returns (0, nil) on every read once
+	// its timeout expires, and bufio retries that a hundred times before giving up
+	// with ErrNoProgress. With a 4-second port timeout that is over six minutes of
+	// a poll loop frozen mid-exchange, logging nothing — which is exactly how a
+	// controller that never answered looked like a program that had hung. Short
+	// port timeouts, checked against a deadline here, turn it into one clear
+	// "nothing came back" after four seconds.
+	deadline := time.Now().Add(ubReadTimeout)
+	c.setReadTimeout(250 * time.Millisecond)
+	defer c.setReadTimeout(ubReadTimeout)
 	var buffer []byte
 	for {
+		// A stop must not have to wait out the deadline. Without this, tearing the
+		// client down mid-exchange took up to four seconds — long enough for the
+		// replacement client to find the port still held, and for Stop to give up
+		// waiting and say so.
+		select {
+		case <-c.stopChan:
+			return nil, fmt.Errorf("stopped")
+		default:
+		}
+		if time.Now().After(deadline) {
+			if len(buffer) == 0 {
+				return nil, fmt.Errorf("no reply within %s", ubReadTimeout)
+			}
+			return nil, fmt.Errorf("incomplete frame within %s (% X)", ubReadTimeout, buffer)
+		}
 		b, err := c.reader.ReadByte()
 		if err != nil {
+			// A quiet port between bytes is normal — go.bug.st returns (0, nil) on
+			// its timeout, which bufio eventually reports as ErrNoProgress. Only the
+			// deadline above decides that the exchange has failed.
+			if transientRead(err) {
+				continue
+			}
 			return nil, fmt.Errorf("failed to read: %w", err)
 		}
 		if len(buffer) == 0 && b != STX {
+			// Kept, briefly, for the first exchange after a connect: what gets
+			// discarded here IS the diagnosis when the link is misconfigured.
+			c.diagMu.Lock()
+			if c.diag && len(c.diagJunk) < 32 {
+				c.diagJunk = append(c.diagJunk, b)
+			}
+			c.diagMu.Unlock()
 			continue // resync to the start of a frame
 		}
 		buffer = append(buffer, b)
@@ -725,3 +872,21 @@ func (c *Client) ModifyElement(elementNum int, lengthMm int) error {
 	_, err := c.sendCommand(CMD_MODIFY_ELEM, data)
 	return err
 }
+
+// portBusyHint turns "Serial port busy" into something actionable.
+//
+// A COM port has exactly one owner. The message the driver gives back says the
+// port is busy and stops there, which reads like a fault in OpsLog — and the
+// program actually holding it is usually the antenna manufacturer's own control
+// window, sitting open on the same desktop. Naming that is the difference
+// between a bug report and a five-second fix.
+func portBusyHint(mode, com string, err error) string {
+	if mode != "serial" || err == nil {
+		return ""
+	}
+	msg := strings.ToLower(err.Error())
+	if !strings.Contains(msg, "busy") && !strings.Contains(msg, "access is denied") && !strings.Contains(msg, "denied") {
+		return ""
+	}
+	return " — another program already has " + com + " open (the UltraBeam Controller window, PstRotator, a terminal). A COM port has one owner: close the other program, then OpsLog can connect."
+}

motor_bandfreq_test.go

@@ -76,3 +76,30 @@ func TestMotorTuneKHzForBandFallsBack(t *testing.T) {
 		}
 	}
 }
+
+// The Ultrabeam's USB link answers on 19200 and on nothing else — confirmed on
+// hardware, where 9600 opened the port and returned not one byte. A speed with a
+// single right answer must not be storable as anything else, whatever an older
+// config or a hand-edited setting says.
+func TestNormMotorBaud(t *testing.T) {
+	for _, tc := range []struct {
+		typ, transport string
+		in, want       int
+	}{
+		{"ultrabeam", "serial", 9600, 19200},
+		{"ultrabeam", "serial", 0, 19200},
+		{"ultrabeam", "serial", 115200, 19200},
+		// Over TCP the speed is the adapter's business, not ours.
+		{"ultrabeam", "tcp", 9600, 9600},
+		// The SteppIR controller really does run at several speeds.
+		{"steppir", "serial", 4800, 4800},
+		{"steppir", "serial", 19200, 19200},
+		// Nonsense falls back rather than reaching the driver.
+		{"steppir", "serial", 0, 9600},
+		{"steppir", "serial", 999999, 9600},
+	} {
+		if got := normMotorBaud(tc.typ, tc.transport, tc.in); got != tc.want {
+			t.Errorf("normMotorBaud(%q, %q, %d) = %d, want %d", tc.typ, tc.transport, tc.in, got, tc.want)
+		}
+	}
+}

motor_trackmode_test.go

@@ -1,6 +1,10 @@
 package main
 
-import "testing"
+import (
+	"os"
+	"strings"
+	"testing"
+)
 
 // The tracking mode decides how often a motorized antenna's elements run, so a
 // value that fails to parse must not silently become the most aggressive
@@ -46,3 +50,36 @@ func TestBandForHzDrivesBandTracking(t *testing.T) {
 		t.Errorf("30 m and 20 m both read %q — band mode would never re-tune between them", a)
 	}
 }
+
+// A "Test connection" on a serial port must not open a port OpsLog already
+// holds: a COM port has one owner, and the owner is the running antenna client.
+// Building a second client made the two fight — one of them logging "Serial port
+// busy" for the rest of the session.
+func TestTestUltrabeamReusesTheLiveSerialClient(t *testing.T) {
+	src, err := os.ReadFile("app.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	body := funcBody(t, string(src), "func (a *App) TestUltrabeam(s UltrabeamSettings) error {")
+	if !strings.Contains(body, "a.liveMotorFor(s)") {
+		t.Error("TestUltrabeam builds a client without first checking whether the live one already owns that port")
+	}
+	// The check has to come BEFORE the second client is created, or it is no check.
+	if i, j := strings.Index(body, "a.liveMotorFor(s)"), strings.Index(body, "newMotorClient(s)"); i < 0 || j < 0 || i > j {
+		t.Error("the live-client check must precede newMotorClient")
+	}
+}
+
+// funcBody returns the source of a function, up to the closing brace in column 0.
+func funcBody(t *testing.T, src, signature string) string {
+	t.Helper()
+	i := strings.Index(src, signature)
+	if i < 0 {
+		t.Fatalf("function not found: %s", signature)
+	}
+	rest := src[i:]
+	if j := strings.Index(rest, "\n}\n"); j >= 0 {
+		return rest[:j]
+	}
+	return rest
+}

rdacompare.go

@@ -0,0 +1,145 @@
+package main
+
+// Comparing the two sources of a Russian district, BEFORE deciding which wins.
+//
+// A QSO can carry an RDA district from two places now:
+//
+//   - the offline RDA database (internal/rda), compiled by the award's own
+//     administrators, which knows where a callsign was on a GIVEN DAY;
+//   - the CNTY field of a log downloaded from HAMLOG.online, whose export
+//     writes the district there (<CNTY:5>RO-19 on a real record).
+//
+// Whether that second source is EVIDENCE or merely a COPY is not a matter of
+// opinion, and it decides everything downstream: if HAMLOG's value always
+// equals the database's, there is nothing to arbitrate and a precedence rule
+// would be ceremony around a redundancy. If they genuinely differ on some
+// contacts, then two independent records disagree about a QSO that counts for
+// an award, and that has to be surfaced rather than silently resolved.
+//
+// So: measure first. This reports agreements, disagreements, and the contacts
+// where only one side has an answer — and it changes nothing in the log.
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+
+	"hamlog/internal/applog"
+	"hamlog/internal/award"
+	"hamlog/internal/qso"
+	"hamlog/internal/rda"
+)
+
+// rdaDistrictRe is the shape of an RDA reference: two letters, a dash, two
+// digits (RO-19, KO-05). Used to tell a real district in CNTY from a US county
+// name or whatever else a callbook dropped in that field.
+var rdaDistrictRe = regexp.MustCompile(`^[A-Z]{2}-[0-9]{2}$`)
+
+// RDAConflict is one contact where the two sources disagree.
+type RDAConflict struct {
+	QSOID    int64  `json:"qso_id"`
+	Callsign string `json:"callsign"`
+	Date     string `json:"date"`
+	Band     string `json:"band"`
+	Mode     string `json:"mode"`
+	// FromLog is the district the imported log carries (CNTY).
+	FromLog string `json:"from_log"`
+	// FromDB is what the offline RDA database answers for that callsign on that
+	// day, and Dated says whether it was a dated activity record (a fact) or the
+	// callsign's current district (an assumption).
+	FromDB string `json:"from_db"`
+	Dated  bool   `json:"dated"`
+	// Confirmed is whether the QSO is confirmed on HAMLOG — a confirmed contact's
+	// CNTY has been through their matching of two logs, which is what makes it
+	// worth weighing against the database at all.
+	Confirmed bool `json:"confirmed"`
+}
+
+// RDACompareResult is the measurement.
+type RDACompareResult struct {
+	Scanned   int `json:"scanned"`    // Russian QSOs examined
+	BothKnown int `json:"both_known"` // a district from each source
+	Agree     int `json:"agree"`
+	Disagree  int `json:"disagree"`
+	OnlyLog   int `json:"only_log"` // CNTY has it, the database does not
+	OnlyDB    int `json:"only_db"`  // the database has it, the log does not
+	Neither   int `json:"neither"`
+	// Conflicts lists the disagreements, newest first, capped so a large log
+	// cannot produce a dialog nobody can read. Count is in Disagree regardless.
+	Conflicts []RDAConflict `json:"conflicts"`
+}
+
+// rdaCompareMax bounds the returned list. The COUNT is always exact; it is the
+// enumeration that is capped, because a hundred rows is already more than
+// anyone reviews in one sitting.
+const rdaCompareMax = 200
+
+// CompareRDASources measures the two sources against each other. Read-only.
+func (a *App) CompareRDASources() (RDACompareResult, error) {
+	var res RDACompareResult
+	if a.qso == nil {
+		return res, fmt.Errorf("db not initialized")
+	}
+	rows, err := a.qso.List(a.ctx, qso.ListFilter{Limit: 1_000_000})
+	if err != nil {
+		return res, err
+	}
+	for i := range rows {
+		q := &rows[i]
+		// The same three entities the award covers — see BackfillRDA.
+		if q.DXCC == nil {
+			continue
+		}
+		switch *q.DXCC {
+		case 15, 54, 126:
+		default:
+			continue
+		}
+		res.Scanned++
+
+		fromLog := strings.ToUpper(strings.TrimSpace(q.County))
+		if !rdaDistrictRe.MatchString(fromLog) {
+			fromLog = "" // a county name, a stray value: not a district
+		}
+		var fromDB string
+		var dated bool
+		if m, ok := rda.Lookup(q.Callsign, q.QSODate); ok {
+			fromDB, dated = m.District, m.Dated
+		}
+
+		switch {
+		case fromLog == "" && fromDB == "":
+			res.Neither++
+		case fromLog == "":
+			res.OnlyDB++
+		case fromDB == "":
+			res.OnlyLog++
+		default:
+			res.BothKnown++
+			if fromLog == fromDB {
+				res.Agree++
+				continue
+			}
+			res.Disagree++
+			if len(res.Conflicts) < rdaCompareMax {
+				res.Conflicts = append(res.Conflicts, RDAConflict{
+					QSOID: q.ID, Callsign: q.Callsign,
+					Date: q.QSODate.UTC().Format("2006-01-02"),
+					Band: q.Band, Mode: q.Mode,
+					FromLog: fromLog, FromDB: fromDB, Dated: dated,
+					Confirmed: q.Extras != nil && isHamlogConfirmed(q.Extras[award.HamlogQSLKey]),
+				})
+			}
+		}
+	}
+	applog.Printf("rda compare: %d Russian QSOs — both %d (agree %d, disagree %d), only-log %d, only-db %d, neither %d",
+		res.Scanned, res.BothKnown, res.Agree, res.Disagree, res.OnlyLog, res.OnlyDB, res.Neither)
+	return res, nil
+}
+
+// isHamlogConfirmed reads their Y — anything that is not an explicit no counts,
+// the same rule the award engine applies.
+func isHamlogConfirmed(v string) bool {
+	v = strings.ToUpper(strings.TrimSpace(v))
+	return v != "" && v != "N" && v != "NO"
+}

spotcolors.go

@@ -24,6 +24,16 @@ const keySpotColors = "flex.spot_colors"
 type SpotColor struct {
 	Text string `json:"text"`
 	Bg   string `json:"bg,omitempty"`
+	// Hide keeps this status OFF the panadapter entirely.
+	//
+	// Expressed as "hide" and not "send" so the zero value means SEND: every
+	// palette stored before this existed has to keep behaving as it did, and a
+	// missing field must never be read as "the operator turned this off".
+	//
+	// A colour and a switch rather than one control: the operator who stops
+	// drawing already-worked stations today may want them back tomorrow, and
+	// their colour should still be there when they do.
+	Hide bool `json:"hide,omitempty"`
 }
 
 // SpotColors is the whole palette, keyed by the status names the cluster uses.
@@ -97,14 +107,17 @@ func normSpotColors(s SpotColors) SpotColors {
 		if !known[k] {
 			continue
 		}
-		c := SpotColor{}
+		c := SpotColor{Hide: v.Hide}
 		if hexARGB(v.Text) {
 			c.Text = strings.ToUpper(strings.TrimSpace(v.Text))
 		}
 		if hexARGB(v.Bg) {
 			c.Bg = strings.ToUpper(strings.TrimSpace(v.Bg))
 		}
-		if c.Text != "" || c.Bg != "" {
+		// Kept when it carries ANY decision — a status with no colours but "hide"
+		// set is a real instruction, and dropping it would silently switch that
+		// status back on.
+		if c.Text != "" || c.Bg != "" || c.Hide {
 			out.Colors[k] = c
 		}
 	}
@@ -190,36 +203,127 @@ func (a *App) spotColorFor(status string) SpotColor {
 func spotStatusTag(status string) string {
 	switch status {
 	case "new":
-		return "NEW DXCC"
+		return "New DXCC"
 	case "new-band-mode":
-		return "NEW BAND+MODE"
+		return "New B&M"
 	case "new-band":
-		return "NEW BAND"
+		return "New Band"
 	case "new-mode":
-		return "NEW MODE"
+		return "New Mode"
 	case "new-slot":
-		return "NEW SLOT"
+		return "New Slot"
 	case "new-pota":
-		return "NEW POTA"
+		return "New POTA"
 	case "new-county":
-		return "NEW COUNTY"
+		return "New Cnty"
 	case "new-pfx":
-		return "NEW PFX"
+		return "New Pfx"
 	case "my-call":
-		return "ME"
+		return "Me"
+	case "worked":
+		return "Worked"
 	}
 	return ""
 }
 
-// spotComment appends the status tag to the cluster's own comment.
-func spotComment(comment, status string) string {
-	c := strings.TrimSpace(comment)
-	tag := spotStatusTag(status)
-	if tag == "" {
-		return c
+// spotComment builds what the panadapter shows under a spot:
+//
+//	CQ up 2 [F4BPO] [Franz Josef Land] [New Slot]
+//
+// the cluster's own text, then WHO spotted it, then the entity, then what it is
+// worth. Same order and same shape as DXHunter, whose users read these at a
+// glance and should not have to learn a second convention.
+//
+// # The spaces are not spaces
+//
+// SmartSDR's command line separates parameters ON SPACES, so a comment written
+// with ordinary ones arrives at the radio as "CQup2[F4BPO]" — every word run
+// together, which is exactly how ours looked. Non-breaking spaces (U+00A0) pass
+// through the parser untouched and render as spaces on the panadapter. This is
+// the trick DXHunter uses, and there is no other way to get a readable comment
+// through that protocol.
+func spotComment(comment, spotter, country, status string) string {
+	var b strings.Builder
+	add := func(s string) {
+		s = strings.TrimSpace(s)
+		if s == "" {
+			return
 		}
-	if c == "" {
-		return "[" + tag + "]"
+		if b.Len() > 0 {
+			b.WriteString(" ")
 		}
-	return c + " [" + tag + "]"
+		b.WriteString(s)
+	}
+	// The radio has the last word on length: a comment past roughly sixty
+	// characters comes back from SmartSDR cut mid-word — one was echoed as
+	// "…[European Russia" with the closing bracket and the status gone. So the
+	// parts are added in order of what an operator would keep, and the cluster's
+	// own words — the longest and the least specific — are the ones trimmed.
+	// The cluster's own text arrives padded: RBN lines are column-aligned, so a
+	// comment reads "FT8    5 dB  LN14    CQ" with runs of spaces holding the
+	// columns apart. Those runs became runs of NON-BREAKING spaces, which the
+	// panadapter faithfully rendered as a gap wide enough to push the rest of the
+	// comment off the screen. Columns mean nothing once the text is out of its
+	// table: one space between words.
+	comment = strings.Join(strings.Fields(comment), " ")
+	tag := bracket(spotStatusTag(status))
+	spot := bracket(spotter)
+	cty := bracket(country)
+	room := panCommentMax - len(tag) - len(spot) - len(cty) - 3 // 3 separators
+	add(trimTo(comment, room))
+	add(spot)
+	add(cty)
+	add(tag)
+	// Every space, including the ones already inside the cluster's comment.
+	return strings.ReplaceAll(b.String(), " ", "\u00A0")
+}
+
+// panCommentMax is what SmartSDR keeps of a spot comment. Measured against a
+// real radio's own status echo, with a margin: the cost of being wrong is a
+// comment cut mid-word, and nothing in the protocol reports the limit.
+const panCommentMax = 58
+
+// trimTo shortens s to at most n characters, on a word boundary when it can.
+// A negative or tiny budget yields nothing at all — the brackets that follow
+// matter more than a two-letter fragment of the cluster's text.
+func trimTo(s string, n int) string {
+	s = strings.TrimSpace(s)
+	if n < 4 {
+		return ""
+	}
+	if len(s) <= n {
+		return s
+	}
+	cut := s[:n]
+	if i := strings.LastIndex(cut, " "); i > n/2 {
+		cut = cut[:i]
+	}
+	return strings.TrimSpace(cut)
+}
+
+// bracket wraps a non-empty value in square brackets.
+func bracket(s string) string {
+	s = strings.TrimSpace(s)
+	if s == "" {
+		return ""
+	}
+	return "[" + s + "]"
+}
+
+// spotHidden reports whether this status should stay off the panadapter.
+//
+// Read from the same cached palette as the colours — see spotColorFor — because
+// it is consulted on every spot from every cluster.
+func (a *App) spotHidden(status string) bool {
+	a.spotColorsMu.Lock()
+	if a.spotColorsCache == nil {
+		c := a.GetSpotColors()
+		a.spotColorsCache = &c
+	}
+	p := a.spotColorsCache
+	a.spotColorsMu.Unlock()
+	if c, ok := p.Colors[status]; ok {
+		return c.Hide
+	}
+	return false
 }

spotcolors_test.go

@@ -1,6 +1,9 @@
 package main
 
-import "testing"
+import (
+	"strings"
+	"testing"
+)
 
 // A colour the Flex refuses is a spot that never appears, and the command error
 // goes to a log nobody is reading. Anything that is not #AARRGGBB must be
@@ -47,30 +50,118 @@ func TestNormSpotColors(t *testing.T) {
 }
 
 func TestSpotComment(t *testing.T) {
-	// The cluster's own text is kept: it carries the signal report and the
-	// operator's note, which is why the spot is readable in the first place.
-	if got := spotComment("CQ up 2", "new"); got != "CQ up 2 [NEW DXCC]" {
-		t.Fatalf("got %q", got)
+	// What the panadapter shows: the cluster's words, who spotted it, the entity,
+	// then what it is worth — DXHunter's order, so an operator reads one
+	// convention and not two.
+	got := spotComment("CQ up 2", "F4BPO", "Franz Josef Land", "new-slot")
+	want := "CQ up 2 [F4BPO] [Franz Josef Land] [New Slot]"
+	if plain(got) != want {
+		t.Fatalf("got %q, want %q", plain(got), want)
 	}
-	// An empty comment must not produce a leading space on the panadapter.
-	if got := spotComment("", "new-band"); got != "[NEW BAND]" {
-		t.Fatalf("got %q", got)
+	// EVERY space is non-breaking, the ones inside the cluster comment included:
+	// SmartSDR splits its command line on spaces, so a real one truncates the
+	// comment at the first word.
+	if strings.Contains(got, " ") {
+		t.Fatalf("an ordinary space survived: %q", got)
 	}
-	// Nothing to say about a station already in the log.
-	if got := spotComment("loud", "worked"); got != "loud" {
-		t.Fatalf("got %q", got)
+	if !strings.Contains(got, " ") {
+		t.Fatal("no non-breaking space in the comment")
 	}
-	if got := spotComment("loud", "none"); got != "loud" {
-		t.Fatalf("got %q", got)
+	// Missing parts leave no empty brackets and no double separators.
+	if p := plain(spotComment("", "", "", "new")); p != "[New DXCC]" {
+		t.Fatalf("got %q", p)
 	}
-	// Every colourable status except the two quiet ones is labelled, or the
+	if p := plain(spotComment("CQ", "", "Spain", "")); p != "CQ [Spain]" {
+		t.Fatalf("got %q", p)
+	}
+	// A status with nothing to announce contributes no tag.
+	if p := plain(spotComment("loud", "DL1ABC", "Germany", "none")); p != "loud [DL1ABC] [Germany]" {
+		t.Fatalf("got %q", p)
+	}
+	// Every colourable status except the unresolved one is labelled, or the
 	// palette would say something the text does not.
-	for _, s := range spotColorOrder {
-		if s == "worked" || s == "none" {
+	for _, st := range spotColorOrder {
+		if st == "none" {
 			continue
 		}
-		if spotStatusTag(s) == "" {
-			t.Fatalf("status %q has a colour but no tag", s)
+		if spotStatusTag(st) == "" {
+			t.Fatalf("status %q has a colour but no tag", st)
 		}
 	}
 }
+
+// plain puts the ordinary spaces back, for readable assertions.
+func plain(s string) string { return strings.ReplaceAll(s, " ", " ") }
+
+// The per-status switch must survive a save with no colours on that row: it is
+// an instruction in its own right, and dropping it would quietly turn the status
+// back on. And a palette written before the switch existed must keep sending
+// everything — "no field" is not "the operator turned this off".
+func TestSpotColorHideSurvivesNormalisation(t *testing.T) {
+	in := SpotColors{Enabled: true, Colors: map[string]SpotColor{
+		"worked":   {Hide: true},                    // no colours, just the switch
+		"new":      {Text: "#FFFF3B30", Hide: true}, // both
+		"none":     {Text: "not a colour"},          // neither survives
+		"new-band": {Text: "#FFFFCC00"},             // colour only
+	}}
+	out := normSpotColors(in)
+	if c, ok := out.Colors["worked"]; !ok || !c.Hide {
+		t.Error("a status hidden with no colour was dropped")
+	}
+	if c := out.Colors["new"]; !c.Hide || c.Text != "#FFFF3B30" {
+		t.Errorf("hide and colour did not both survive: %+v", c)
+	}
+	if _, ok := out.Colors["none"]; ok {
+		t.Error("an entry with nothing valid in it was kept")
+	}
+	if c := out.Colors["new-band"]; c.Hide {
+		t.Error("a colour-only entry came back hidden")
+	}
+	// An older palette says nothing about hiding, and must send everything.
+	old := normSpotColors(SpotColors{Enabled: true, Colors: map[string]SpotColor{"new": {Text: "#FFFF3B30"}}})
+	if old.Colors["new"].Hide {
+		t.Error("a palette from before the switch existed came back hidden")
+	}
+}
+
+// SmartSDR cuts a long comment mid-word — one came back from the radio as
+// "…[European Russia", losing its closing bracket and its status. What the
+// operator would keep must therefore survive: the spotter, the entity and the
+// status, with the cluster's own words trimmed to fit.
+func TestSpotCommentFitsTheRadio(t *testing.T) {
+	long := "FT8    5 dB  LN14    CQ DX FROM A VERY TALKATIVE SKIMMER NODE INDEED"
+	got := plain(spotComment(long, "OH6BG-#", "European Russia", "new-band"))
+	if len(got) > panCommentMax {
+		t.Fatalf("comment is %d chars, over the %d the radio keeps: %q", len(got), panCommentMax, got)
+	}
+	for _, must := range []string{"[OH6BG-#]", "[European Russia]", "[New Band]"} {
+		if !strings.Contains(got, must) {
+			t.Errorf("%s was trimmed away — the cluster text should go first: %q", must, got)
+		}
+	}
+	// A short comment is left exactly as it is.
+	short := plain(spotComment("CQ", "K1ABC", "Spain", "new"))
+	if short != "CQ [K1ABC] [Spain] [New DXCC]" {
+		t.Fatalf("got %q", short)
+	}
+	// No room at all for the cluster's words: they go, the brackets stay.
+	tight := plain(spotComment("CQ DX UP 2 LISTENING", "VERYLONGSPOTTER-#", "Democratic Republic of the Congo", "new"))
+	if strings.Contains(tight, "LISTENING") {
+		t.Errorf("kept the cluster text at the expense of the tags: %q", tight)
+	}
+}
+
+// RBN lines are column-aligned, so a comment arrives as "FT8    5 dB  LN14
+// CQ". Preserved as non-breaking spaces, those runs rendered on the panadapter
+// as a gap wide enough to push the rest of the comment off the screen.
+func TestSpotCommentCollapsesClusterPadding(t *testing.T) {
+	got := plain(spotComment("FT8   -13 dB          CQ", "WC2L-#", "United States", "new"))
+	want := "FT8 -13 dB CQ [WC2L-#] [United States] [New DXCC]"
+	if got != want {
+		t.Fatalf("got  %q\nwant %q", got, want)
+	}
+	// Tabs and newlines are padding too.
+	if p := plain(spotComment("CQ\t\tDX\n", "K1ABC", "", "")); p != "CQ DX [K1ABC]" {
+		t.Fatalf("got %q", p)
+	}
+}

syncfolder.go

@@ -315,11 +315,11 @@ func (a *App) syncPublishDeletes(ids []int64) {
 	if store == nil {
 		return
 	}
-	for _, id := range ids {
-		q, err := a.qso.GetByID(a.ctx, id)
-		if err != nil {
-			continue
-		}
+	// One read for the whole set: see deleteSnapshot. Tombstones are written
+	// before the rows go, because a QSO that never had a sync identity has to be
+	// given one here — after the DELETE there would be nothing left to stamp.
+	for _, q := range a.deleteSnapshot(ids) {
+		id := q.ID
 		// A contact never touched since the sync was switched on has no identity,
 		// and giving it one now is what makes the deletion addressable at all.
 		a.syncMu.Lock()

telemetry.go

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