chore: release v0.26.12

Dragging a four-pixel slider to change the power by five watts is a fussy
gesture, and the Flex and Yaesu consoles have had the wheel for a while —
an operator moving between them expects it.

React registers onWheel as PASSIVE, so preventDefault() there is ignored
and the panel scrolls under the pointer while the value changes; the
listener is attached natively instead, with the live values read through
refs. Both existing panels solved it the same way, so this is a third
copy turned into one shared component -- used by the new console only.
The other two are left alone deliberately: they work, they are in daily
use, and their styling differs in ways a merge would have to guess at.

Power steps 5 W a notch, matching the K3's own coarse step.

app.go

@@ -312,6 +312,7 @@ const (
 	keyClusterSelfSpot    = "cluster.self_spot"         // "1" → announce ourselves on the cluster as we log
 	keyClusterSelfSpotMin = "cluster.self_spot_minutes" // shortest gap between two self-spots
 	keyClusterSpotTTL     = "cluster.spot_ttl_min"      // drop spots older than this; 0 = keep them
+	keyClusterSpotMax     = "cluster.spot_max"          // how many spots the list holds at once
 
 	keyScpEnabled = "scp.enabled" // Super Check Partial / N+1 suggestions on
 
@@ -344,6 +345,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 +385,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 +423,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
@@ -770,6 +783,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
@@ -6439,6 +6459,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
@@ -6457,9 +6497,53 @@ func (a *App) deleteRemoteCopies(ids []int64) {
 	if !doQRZ && !doClublog {
 		return
 	}
-	for _, id := range ids {
+	// Snapshot first — the rows are about to disappear — then withdraw them in
-		q, err := a.qso.GetByID(a.ctx, id)
+	// the background. Each service is an HTTP round trip PER CONTACT, so doing
-		if err != nil || q.Callsign == "" {
+	// 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
+
+// Club Log's delete endpoint is a REAL-TIME one: it exists for an operator
+// removing a contact they just logged wrongly, at human pace. Club Log watches
+// the rate and blocks the IP of anything that batches through it — they wrote
+// to this station about 167 requests in four minutes, which was one deletion of
+// a couple of hundred rows, not a pile-up.
+//
+// There is no bulk-delete API to move to, so the only honest answer is to go at
+// the pace the endpoint is meant for and to stop rather than push a large
+// deletion through it. Whoever needs to remove hundreds of QSOs from Club Log
+// does it on their site, where the tool for it exists.
+const (
+	clublogDeletePace = 1200 * time.Millisecond
+	maxClublogDeletes = 25
+)
+
+// 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
+	clublogSent := 0
+	for i := range rows {
+		q := rows[i]
+		id := q.ID
+		if q.Callsign == "" {
 			continue
 		}
 		if doQRZ {
@@ -6478,14 +6562,42 @@ 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 clublogSent >= maxClublogDeletes {
+				applog.Printf("extsvc: %d QSOs already withdrawn from Club Log — stopping there. Their delete endpoint is for one contact at a time; remove the rest on clublog.org, which has a tool for it.", clublogSent)
+				doClublog = false
+				continue
+			}
+			if clublogSent > 0 {
+				// Paced deliberately: see clublogDeletePace. This runs in the
+				// background, so the wait costs the operator nothing.
+				time.Sleep(clublogDeletePace)
+			}
+			clublogSent++
 			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
@@ -6494,9 +6606,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.
@@ -10517,6 +10643,7 @@ func (a *App) GetQSLDefaults() (QSLDefaults, error) {
 		keyQSLDefaultEQSLSent, keyQSLDefaultEQSLRcvd,
 		keyQSLDefaultClublogStatus, keyQSLDefaultHRDLogStatus,
 		keyQSLDefaultQRZComStatus, keyQSLDefaultQRZComCfm,
+		keyQSLDefaultHamlogStatus, keyQSLDefaultHamlogCfm,
 	)
 	if err != nil {
 		return out, err
@@ -10531,6 +10658,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
 }
 
@@ -10552,6 +10681,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
@@ -10602,6 +10733,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) ─────────────────────────────────
@@ -10701,7 +10853,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
 	}
@@ -10780,6 +10933,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
 }
 
@@ -10848,6 +11006,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"
@@ -10895,6 +11063,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
@@ -10975,6 +11147,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)
@@ -10990,7 +11169,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()
@@ -12796,6 +12975,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) {
@@ -12809,6 +12997,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
@@ -12845,6 +13042,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)
@@ -14962,6 +15168,9 @@ func (a *App) reloadCAT() {
 			// 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,
@@ -19882,6 +20091,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) })
 }
@@ -20006,6 +20295,50 @@ func (a *App) SetKenwoodKeySpeed(wpm int) error {
 // and exists only so a mistyped value cannot mean "never".
 const spotTTLMax = 720
 
+// The spot list is a ring buffer, and its size decided the lifetime far more
+// often than the lifetime setting did: on a busy evening a thousand spots
+// arrive in a couple of minutes, so a fifteen-minute lifetime never got the
+// chance to expire anything. Hence a setting.
+//
+// The ceiling is a real limit, not a round number. Every spot is matched against
+// the worked index and the alert rules, and each one is a row the cluster grid
+// and every open band map re-render; past ten thousand that work starts to show
+// on the very evenings the list is worth having.
+const (
+	spotMaxDefault = 1000
+	spotMaxCeiling = 10000
+	spotMaxFloor   = 100
+)
+
+// GetSpotMax returns how many spots the list holds.
+func (a *App) GetSpotMax() int {
+	n, _ := strconv.Atoi(a.settingOr(keyClusterSpotMax, ""))
+	if n <= 0 {
+		return spotMaxDefault
+	}
+	return clampSpotMax(n)
+}
+
+// SetSpotMax sets it. Clamped here as well as in the UI, for the same reason as
+// the lifetime: the value decides how much work arrives on every spot, and a
+// stale frontend must not be able to widen it past the ceiling.
+func (a *App) SetSpotMax(n int) error {
+	a.setSetting(keyClusterSpotMax, strconv.Itoa(clampSpotMax(n)))
+	return nil
+}
+
+func clampSpotMax(n int) int {
+	if n < spotMaxFloor {
+		return spotMaxFloor
+	}
+	if n > spotMaxCeiling {
+		return spotMaxCeiling
+	}
+	return n
+}
+
+
+
 // GetSpotTTLMinutes returns how long a spot stays in the list, in minutes.
 // 0 means spots are kept until the count cap pushes them out, which is what
 // OpsLog always did.
@@ -20270,3 +20603,16 @@ func (a *App) countryFor(call string) string {
 	}
 	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_k3.go

@@ -0,0 +1,115 @@
+package main
+
+// Elecraft K3/K4 panel bindings.
+//
+// The controls the operator asked for and nothing else: power, volume, the
+// S-meter and SWR, MOX, and an ATU tune. A K3 exposes dozens of commands, but a
+// panel earns its place by covering what is reached for during a QSO — and each
+// one added without a radio to test it against is a control that may or may not
+// do what its label says. See internal/cat/kenwood_panel.go.
+
+import (
+	"fmt"
+
+	"hamlog/internal/cat"
+)
+
+// GetKenwoodState returns the K3/K4 panel snapshot. Zero value when the active
+// CAT backend is something else, which is how the UI knows to hide the panel.
+func (a *App) GetKenwoodState() cat.KenwoodTXState {
+	if a.cat == nil {
+		return cat.KenwoodTXState{}
+	}
+	st, _ := a.cat.KenwoodState()
+	return st
+}
+
+func (a *App) SetKenwoodPower(w int) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodPower(w) })
+}
+
+func (a *App) SetKenwoodAFGain(p int) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodAFGain(p) })
+}
+
+func (a *App) SetKenwoodRFGain(p int) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodRFGain(p) })
+}
+
+func (a *App) SetKenwoodMicGain(p int) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodMicGain(p) })
+}
+
+func (a *App) SetKenwoodSquelch(p int) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodSquelch(p) })
+}
+
+func (a *App) SetKenwoodPreamp(on bool) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodPreamp(on) })
+}
+
+func (a *App) SetKenwoodAtt(on bool) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodAtt(on) })
+}
+
+func (a *App) SetKenwoodNB(on bool) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodNB(on) })
+}
+
+func (a *App) SetKenwoodNR(on bool) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodNR(on) })
+}
+
+func (a *App) SetKenwoodAGC(name string) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodAGC(name) })
+}
+
+func (a *App) SetKenwoodFilter(hz int) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodFilter(hz) })
+}
+
+func (a *App) SetKenwoodAntenna(n int) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodAntenna(n) })
+}
+
+func (a *App) SetKenwoodRIT(on bool) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodRIT(on) })
+}
+
+func (a *App) SetKenwoodXIT(on bool) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodXIT(on) })
+}
+
+// ClearKenwoodRIT zeroes the RIT and XIT offsets together, which is what the
+// radio's own RC does and what an operator means by "clear it".
+func (a *App) ClearKenwoodRIT() error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.ClearKenwoodRIT() })
+}
+
+// SetKenwoodTX is the panel's MOX.
+func (a *App) SetKenwoodTX(on bool) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodTX(on) })
+}
+
+// ToggleKenwoodATU puts the tuner in line or bypasses it (the HOLD of the same
+// front-panel switch the tune uses).
+func (a *App) ToggleKenwoodATU() error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.ToggleKenwoodATU() })
+}
+
+func (a *App) TuneKenwoodATU() error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.TuneKenwoodATU() })
+}
+
+// RefreshKenwood re-reads the settings on the next poll — for when a knob was
+// turned on the radio itself.
+func (a *App) RefreshKenwood() error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.RefreshKenwood() })
+}
+
+func (a *App) kenwoodPanelDo(fn func(cat.KenwoodPanelController) error) error {
+	if a.cat == nil {
+		return fmt.Errorf("CAT not initialized")
+	}
+	return a.cat.KenwoodPanelDo(fn)
+}

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,122 @@
 [
+  {
+    "version": "0.26.12",
+    "date": "",
+    "en": [
+      "When TQSL refuses an upload, the log now carries the exact ADIF record it was given and the station location it was told to sign with. 'No QSOs processed' covers several unrelated causes and the temp file is deleted the moment TQSL returns, so the one piece of evidence that mattered was the one nobody could see.",
+      "An Elecraft console for the K3/K4, in a tab of its own when the CAT backend is Elecraft or Kenwood: power, volume, RF and mic gain, squelch, preamp, attenuator, NB, NR, AGC, filter width, antenna, RIT/XIT with a clear, keyer speed, S-meter, SWR, MOX and an ATU tune. The meter scaling is marked provisional and the raw readings go to the log — it was written from the K3 Programmer's Reference without a radio to hand, and a wrongly scaled SWR bar reports a good match on a bad antenna.",
+      "Type a number in the callsign field and press Enter to move the radio: kHz for a frequency (28500 → 28.500 MHz), or a band on its own (20, 160, 6…). It is where the hands already are — reading a spot and reaching for the frequency box is what loses the station. Ambiguous numbers are read as bands, since 40 kHz and 160 kHz are nowhere anyone tunes.",
+      "Yaesu console: the mic gain is read and written on the rig's own 0-100 scale. It was treated as 0-255, so an FTDX101 set to 80 showed 38 and every attempt to move the slider was refused by the radio and sprang back.",
+      "Yaesu console: the power slider goes to 200 W on the models that make it (FTDX101MP and the like), and follows the radio if it ever reports more than expected. The slider, not the rig, was the 100 W limit.",
+      "Yaesu console: the NAR button (narrow IF filter) is shown only when the radio answers the command, and says what it is. A button that did nothing when pressed read as a fault in the rig.",
+      "The frequency readout now steps the Hz digits under the mouse wheel too, not just the kHz ones — 100, 10 and 1 Hz. Zero-beating a CW signal is a few tens of Hz, and it was the one move the display would not make.",
+      "The split-pile-up chaser only appears in CW: the marker comes from a skimmer decoding a report, so on SSB or FT8 there is nothing for it to chase.",
+      "Cluster: a single click now only fills the callsign, and a DOUBLE click works the spot — QSY, mode and the rest. Running down the list used to drag the radio along with every line looked at.",
+      "Cluster: how many spots the list keeps is now a setting (Preferences → Cluster, beside the spot lifetime). It was fixed at a thousand, and on a busy evening that fills in a couple of minutes — so the cap, not the lifetime, decided when a spot disappeared and a 15-minute lifetime never expired anything.",
+      "Elecraft console: the ATU tune sends the right switch. SWT19 is the ATU row in the K3 reference — TAP starts a tuning cycle, and a HOLD (the new ATU button) puts the tuner in line or bypasses it. It was written as SWT20, which is not an ATU switch at all. Power now takes the K3 range of 0-110 W.",
+      "Elecraft console: the mouse wheel moves the sliders, as it already did on the Flex and Yaesu consoles. Power steps 5 W a notch, the rest one unit."
+    ],
+    "fr": [
+      "Quand TQSL refuse un envoi, le journal contient désormais l'enregistrement ADIF exact qui lui a été remis et l'emplacement de station demandé pour la signature. « No QSOs processed » recouvre plusieurs causes sans rapport et le fichier temporaire est supprimé dès que TQSL rend la main : la seule pièce à conviction utile était justement invisible.",
+      "Une console Elecraft pour les K3/K4, dans un onglet dédié quand le CAT est réglé sur Elecraft ou Kenwood : puissance, volume, gain HF et micro, squelch, préampli, atténuateur, NB, NR, AGC, largeur de filtre, antenne, RIT/XIT avec effacement, vitesse du manipulateur, S-mètre, ROS, MOX et accord de l'ATU. L'échelle des mesures est signalée comme provisoire et les valeurs brutes partent dans le journal — la console a été écrite d'après le manuel de programmation du K3, sans radio sous la main, et une barre de ROS mal calibrée annonce un bon accord sur une mauvaise antenne.",
+      "Taper un nombre dans le champ indicatif puis Entrée déplace la radio : en kHz pour une fréquence (28500 → 28.500 MHz), ou une bande seule (20, 160, 6…). C'est là que sont déjà les mains — lire un spot puis aller chercher la case fréquence, c'est ce qui fait perdre la station. Les nombres ambigus sont lus comme des bandes : 40 kHz ou 160 kHz ne sont nulle part où l'on s'accorde.",
+      "Console Yaesu : le gain micro est lu et écrit sur l'échelle 0-100 de la radio. Il était traité en 0-255 : un FTDX101 réglé sur 80 affichait 38, et toute tentative de bouger le curseur était refusée par la radio et revenait en place.",
+      "Console Yaesu : le curseur de puissance monte à 200 W sur les modèles qui la sortent (FTDX101MP et consorts), et suit la radio si elle annonce davantage. C'était le curseur, pas la radio, qui plafonnait à 100 W.",
+      "Console Yaesu : le bouton NAR (filtre FI étroit) n'apparaît que si la radio répond à la commande, et indique ce qu'il fait. Un bouton sans effet passait pour une panne de la radio.",
+      "L'affichage de fréquence fait maintenant défiler aussi les chiffres des Hz à la molette, pas seulement ceux des kHz — 100, 10 et 1 Hz. Se caler au zéro-beat sur un signal CW se joue à quelques dizaines de Hz, et c'était le seul geste que l'affichage refusait.",
+      "Le chasseur de pile-up en split n'apparaît qu'en CW : le marqueur vient d'un skimmer qui décode un report, donc en SSB ou en FT8 il n'a rien à chasser.",
+      "Cluster : un clic simple ne remplit plus que l'indicatif, et le DOUBLE clic travaille le spot — QSY, mode et le reste. Parcourir la liste entraînait la radio à chaque ligne regardée.",
+      "Cluster : le nombre de spots conservés devient un réglage (Préférences → Cluster, à côté de la durée de vie). Il était fixé à mille, et un soir chargé remplit ça en quelques minutes — c'était donc le plafond, et non la durée de vie, qui décidait de la disparition d'un spot, et une durée de 15 minutes n'expirait jamais rien.",
+      "Console Elecraft : l'accord ATU envoie la bonne touche. SWT19 est la ligne ATU du manuel K3 — l'appui bref lance un cycle d'accord, et le maintien (nouveau bouton ATU) met la boîte en ligne ou la contourne. C'était écrit SWT20, qui n'est pas une touche d'ATU. La puissance suit la plage 0-110 W du K3.",
+      "Console Elecraft : la molette agit sur les curseurs, comme elle le faisait déjà sur les consoles Flex et Yaesu. La puissance avance de 5 W par cran, le reste d'une unité."
+    ]
+  },
+  {
+    "version": "0.26.11",
+    "date": "",
+    "en": [
+      "Withdrawing deleted QSOs from Club Log is now paced and capped at 25 per deletion. Their delete endpoint is a real-time one, meant for an operator removing a contact they just mis-logged; Club Log watches the rate and blocks the IP of anything that batches through it. Past the cap OpsLog stops and says so — there is no bulk-delete API, and hundreds of removals belong on clublog.org, which has a tool for it.",
+      "Auto-call, withdrawn earlier, is now disarmed where it was remembered: a stored 'enabled' is switched off and written back the first time OpsLog reads it. The running guard already stopped this build from calling anyone, but the stored flag survived — and any build without that guard would key the transmitter for a feature with no switch left to turn it off."
+    ],
+    "fr": [
+      "Le retrait des QSO supprimés chez Club Log est désormais cadencé et limité à 25 par suppression. Leur point d'entrée de suppression est temps réel, prévu pour un opérateur qui retire un contact qu'il vient de mal enregistrer ; Club Log surveille le rythme et bloque l'IP de ce qui passe des lots par là. Au-delà de la limite, OpsLog s'arrête et le dit — il n'existe pas d'API de suppression en masse, et des centaines de retraits se font sur clublog.org, qui a l'outil pour ça.",
+      "L'appel automatique, retiré précédemment, est maintenant désarmé là où il était mémorisé : un « activé » enregistré est éteint et réécrit dès la première lecture par OpsLog. Le garde-fou à l'exécution empêchait déjà cette version d'appeler qui que ce soit, mais l'indicateur enregistré survivait — et toute version sans ce garde-fou passait à l'émission pour une fonction dont il ne reste aucun interrupteur."
+    ]
+  },
+  {
+    "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": "",

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,
@@ -78,6 +78,7 @@ import { WorldMap, LocatorMap } from '@/components/MainMap';
 import { FlexPanel } from '@/components/FlexPanel';
 import { IcomPanel } from '@/components/IcomPanel';
 import { YaesuPanel } from '@/components/YaesuPanel';
+import { ElecraftPanel } from '@/components/ElecraftPanel';
 import { AntGeniusPanel, type AGStatus } from '@/components/AntGeniusPanel';
 import { MotorAntennaWidget, type AntStatus } from '@/components/MotorAntennaWidget';
 import { TunerGeniusPanel, type TGStatus } from '@/components/TunerGeniusPanel';
@@ -94,7 +95,7 @@ import { ShutdownProgress } from '@/components/ShutdownProgress';
 import { ClusterGrid } from '@/components/ClusterGrid';
 import { cleanSpotter, inferSpotMode, spotModeCategory, spotStatusKey } from '@/lib/spot';
 import { applySpotDisplay, readSpotDisplayOptions, spotIsWorked, SPOT_DISPLAY_OPTIONS_EXPOSED } from '@/lib/spotDisplay';
-import { AnswerDecode, HaltDecodeTx, LogUIError, FlexTXOnBand, GetMatrixColors, GetRotorPresets, GetRowColors, GetSpotTTLMinutes, IsNewUSCounty } from '../wailsjs/go/main/App';
+import { AnswerDecode, HaltDecodeTx, LogUIError, FlexTXOnBand, GetMatrixColors, GetRotorPresets, GetRowColors, GetSpotTTLMinutes, GetSpotMax, IsNewUSCounty } from '../wailsjs/go/main/App';
 import { applyMatrixColors } from '@/lib/matrixColors';
 import { WorkedBeforeGrid } from '@/components/WorkedBeforeGrid';
 import { NetControlPanel } from '@/components/NetControlPanel';
@@ -243,10 +244,15 @@ function fmtFreqDots(mhzStr: string): string {
 }
 
 // FreqWheelDisplay renders a frequency (MHz string) like fmtFreqDots — MHz.kHz.Hz
-// — but makes the three kHz digits scroll-sensitive: rolling the mouse wheel over
+// — and makes the kHz AND Hz digits scroll-sensitive: rolling the wheel over a
-// the hundreds / tens / units-of-kHz digit steps the frequency by 100 / 10 / 1 kHz
+// digit steps the frequency by that digit (100/10/1 kHz, then 100/10/1 Hz; up =
-// (up = wheel up). onNudge receives the delta in Hz. The MHz and Hz digits are
+// wheel up). onNudge receives the delta in Hz.
-// static (only kHz stepping was requested). Used in the header + compact top bar.
+//
+// The Hz digits were static at first, on the grounds that only kHz stepping had
+// been asked for. An FTDX101 operator put it plainly: the fine tuning is exactly
+// what a mouse is wanted for — zero-beating a CW signal or nudging onto an SSB
+// voice is a few tens of Hz, and it was the one move the display would not make.
+// The MHz digits stay static: a wheel notch that changes band is not fine tuning.
 function FreqWheelDisplay({ mhz, onNudge, className, placeholder = '—.———.———' }: {
   mhz: string; onNudge: (deltaHz: number) => void; className?: string; placeholder?: string;
 }) {
@@ -256,6 +262,7 @@ function FreqWheelDisplay({ mhz, onNudge, className, placeholder = '—.——
   const khz = frac.slice(0, 3); // [hundreds, tens, units] of kHz
   const hz = frac.slice(3, 6);
   const stepHz = [100_000, 10_000, 1_000]; // per kHz digit: 100 / 10 / 1 kHz
+  const stepHzFine = [100, 10, 1];         // per Hz digit
   return (
     <span className={className}>
       {intPart}.
@@ -267,7 +274,15 @@ function FreqWheelDisplay({ mhz, onNudge, className, placeholder = '—.——
           {d}
         </span>
       ))}
-      .{hz}
+      .
+      {hz.split('').map((d, i) => (
+        <span key={'h' + i}
+          onWheel={(e) => { if (e.ctrlKey || e.metaKey) return; e.preventDefault(); e.stopPropagation(); onNudge(e.deltaY < 0 ? stepHzFine[i] : -stepHzFine[i]); }}
+          className="cursor-ns-resize rounded-[2px] hover:bg-primary/25 transition-colors"
+          title="Scroll to change frequency">
+          {d}
+        </span>
+      ))}
     </span>
   );
 }
@@ -291,6 +306,37 @@ function shortCatError(err?: string): string {
 }
 // bandForMHz maps a dial frequency (MHz) to its ADIF band, or '' if outside
 // every known allocation (used to auto-fill the band when the freq changes).
+// A number typed into the CALLSIGN field is a QSY, not a callsign.
+//
+// It is where the hands already are: an operator watching a cluster or a
+// spotting page reads "28500" and wants to be there, and reaching for the
+// frequency box — or worse, the mouse — is the part that loses the station. So
+// the call field takes it, on Enter, and nothing else in the entry form changes.
+//
+// Two forms, and the AMBIGUOUS ones resolve to the band deliberately. "160" is
+// the 160 m band, not 160 kHz; "40" is 40 m, not 40 kHz. Neither number is a
+// frequency anyone tunes to, so reading them as bands costs nothing and reads
+// the way an operator says it out loud.
+const ENTRY_BAND_WORDS: Record<string, string> = {
+  '2200': '2200m', '630': '630m', '160': '160m', '80': '80m', '60': '60m',
+  '40': '40m', '30': '30m', '20': '20m', '17': '17m', '15': '15m', '12': '12m',
+  '10': '10m', '6': '6m', '4': '4m', '2': '2m', '70': '70cm',
+};
+
+// entryQSYCommand reads what was typed. Returns null for anything that is not
+// unambiguously one of the two — a callsign must never be mistaken for a QSY.
+function entryQSYCommand(text: string): { band?: string; hz?: number } | null {
+  const v = text.trim();
+  if (!/^\d{1,7}$/.test(v)) return null; // digits only: a callsign has letters
+  const band = ENTRY_BAND_WORDS[v];
+  if (band) return { band };
+  const khz = Number(v);
+  // 1500 kHz to 1.3 GHz: below that is not a band anyone works, above it is a
+  // typo. A bare "500" is neither a band nor a frequency, so nothing happens.
+  if (khz >= 1500 && khz <= 1_300_000) return { hz: Math.round(khz * 1000) };
+  return null;
+}
+
 function bandForMHz(mhz: number): string {
   if (!mhz || isNaN(mhz)) return '';
   const plan: [number, number, string][] = [
@@ -701,6 +747,7 @@ export default function App() {
     '15m':  { SSB: 21300000, CW: 21030000, FT8: 21074000, FT4: 21140000, RTTY: 21080000, default: 21300000 },
     '12m':  { SSB: 24950000, CW: 24910000, FT8: 24915000, FT4: 24919000, RTTY: 24920000, default: 24950000 },
     '10m':  { SSB: 28500000, CW: 28030000, FT8: 28074000, FT4: 28180000, RTTY: 28080000, default: 28500000 },
+    '4m':   { SSB: 70200000, CW: 70100000, FT8: 70154000,                               default: 70200000 },
     '6m':   { SSB: 50150000, CW: 50080000, FT8: 50313000, FT4: 50318000,                default: 50150000 },
     '2m':   { SSB: 144300000, CW: 144050000, FT8: 144174000,                            default: 144300000 },
     '70cm': { SSB: 432300000, CW: 432050000, FT8: 432174000,                            default: 432300000 },
@@ -1616,7 +1663,14 @@ export default function App() {
   const [clusterServers, setClusterServers] = useState<{ id: number; name: string; enabled: boolean; sort_order: number }[]>([]);
   // Ring buffer — only keep the last N spots; cluster firehose can be heavy.
   const [spots, setSpots] = useState<ClusterSpot[]>([]);
-  const SPOTS_CAP = 1000;
+  // How many spots the list holds. A setting rather than a constant: at a
+  // thousand, a busy evening filled the buffer in a couple of minutes, so the
+  // spot LIFETIME never had anything left to expire — the cap was deciding the
+  // lifetime. Kept in a ref as well: the append path runs inside a state updater
+  // that must not close over a stale value.
+  const [spotsCap, setSpotsCap] = useState(1000);
+  const spotsCapRef = useRef(1000);
+  useEffect(() => { spotsCapRef.current = spotsCap; }, [spotsCap]);
   // Cluster filter selections persist across restarts (writeUiPref → localStorage
   // + DB, so they also travel with a copied data/ folder). Loaders read the cache
   // synchronously at first render; a single effect below writes them back.
@@ -1861,7 +1915,7 @@ export default function App() {
   // so it's loaded async on mount and re-read on profile:changed below.
   // 'none' is only ever stored for the third and fourth panes: the first two are
   // the Main view, and a layout with no panes at all is not a layout.
-  type MainPaneKind = 'map1' | 'map2' | 'cluster' | 'worked' | 'flex' | 'recent' | 'icom' | 'yaesu' | 'netcontrol' | 'decodes' | 'none';
+  type MainPaneKind = 'map1' | 'map2' | 'cluster' | 'worked' | 'flex' | 'recent' | 'icom' | 'yaesu' | 'elecraft' | 'netcontrol' | 'decodes' | 'none';
   const [mapZoomSignal, setMapZoomSignal] = useState(0); // bump → world map auto-zooms now
   const [mainPaneLeft, setMainPaneLeft] = useState<MainPaneKind>('map1');
   const [mainPaneRight, setMainPaneRight] = useState<MainPaneKind>('map2');
@@ -1872,7 +1926,7 @@ export default function App() {
   // quarter-width map is unreadable.
   const [mainLayout4, setMainLayout4] = useState<'cols' | 'quad'>('quad');
   const loadMainPanes = useCallback(async () => {
-    const valid = (v: string): v is MainPaneKind => v === 'map1' || v === 'map2' || v === 'cluster' || v === 'worked' || v === 'flex' || v === 'recent' || v === 'icom' || v === 'yaesu' || v === 'netcontrol' || v === 'decodes';
+    const valid = (v: string): v is MainPaneKind => v === 'map1' || v === 'map2' || v === 'cluster' || v === 'worked' || v === 'flex' || v === 'recent' || v === 'icom' || v === 'yaesu' || v === 'elecraft' || v === 'netcontrol' || v === 'decodes';
     const [l, r, p3, p4, lay] = await Promise.all([
       GetUIPref('mainPaneLeft').catch(() => ''),
       GetUIPref('mainPaneRight').catch(() => ''),
@@ -1930,7 +1984,7 @@ export default function App() {
   useEffect(() => {
     setSpotStatus((prev) => {
       const keys = Object.keys(prev);
-      if (keys.length <= SPOTS_CAP * 2) return prev;
+      if (keys.length <= spotsCapRef.current * 2) return prev;
       const live = new Set(spots.map((x) => spotStatusKey(x.dx_call, x.band ?? '', x.comment ?? '', x.freq_hz)));
       // Decoded stations count as live too. They share this cache, and pruning
       // to the cluster spots alone would evict every one of them — on a busy
@@ -2441,6 +2495,9 @@ export default function App() {
   // same thing everywhere — and it gives the memory back.
   const [spotTTLMin, setSpotTTLMin] = useState(0);
   useEffect(() => { GetSpotTTLMinutes().then(setSpotTTLMin).catch(() => {}); }, [showSettings]);
+  // Same beat as the lifetime: re-read when Preferences closes, since the two
+  // settings decide between them how long a spot survives.
+  useEffect(() => { GetSpotMax().then((n: number) => { if (n > 0) setSpotsCap(n); }).catch(() => {}); }, [showSettings]);
   useEffect(() => {
     if (spotTTLMin <= 0) return; // 0 = keep until the count cap pushes them out
     const sweep = () => {
@@ -3112,6 +3169,19 @@ export default function App() {
   // Clicking a spot (cluster grid or any band map): tune the rig, set the mode,
   // fill the call, pre-fill POTA, (re)start the recording. Shared so every spot
   // source behaves identically.
+  // Single click on a cluster line: fill the callsign, nothing else.
+  //
+  // Reading the cluster means running down dozens of lines, and while a single
+  // click WORKED the spot every pass dragged the radio with it — one stray click
+  // while looking took the operator off the station they were working. Looking
+  // and going are two different intentions, so they are now two gestures: click
+  // to look the call up, double-click to go there.
+  function handleSpotSelect(s: any) {
+    if (!s?.dx_call?.trim()) return;
+    onCallsignInput(s.dx_call, { force: true });
+    applySpotPOTA((s as any).pota_ref);
+  }
+
   function handleSpotClick(s: any) {
     const m = inferSpotMode(s.comment ?? '', s.freq_hz);
     // Reflect the spot's freq/band in the entry strip IMMEDIATELY (optimistic),
@@ -3297,11 +3367,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
@@ -3413,7 +3488,8 @@ export default function App() {
           const filtered = hist(sp) ? next : next.filter((x) => hist(x) || key(x) !== k);
           next = [sp, ...filtered];
         }
-        return next.length > SPOTS_CAP ? next.slice(0, SPOTS_CAP) : next;
+        const cap = spotsCapRef.current;
+        return next.length > cap ? next.slice(0, cap) : next;
       });
     };
     const unsubSpot = EventsOn('cluster:spot', (sp: ClusterSpot) => {
@@ -4198,7 +4274,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)); }
@@ -4208,21 +4290,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)); }
   }
@@ -4269,8 +4368,14 @@ export default function App() {
     if (deletingIds.length === 0) return;
     const ids = deletingIds;
     try {
-      if (ids.length === 1) await DeleteQSO(ids[0]);
+      // Report what was actually removed rather than assuming it matched what
-      else await DeleteQSOs(ids as any);
+      // 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([]);
@@ -5434,6 +5539,25 @@ export default function App() {
     noteManualEdit();
     SetCATFrequency(Math.round(mhz * 1_000_000)).catch(() => {});
   };
+  // Carry out what was typed in the call field. Bands go through the ordinary
+  // band change, so the antennas, the power table and the outbound integrations
+  // all hear about it exactly as they would from the dropdown.
+  const applyEntryQSY = (q: { band?: string; hz?: number }) => {
+    if (q.band) {
+      onBandUserChange(q.band);
+      showToast(q.band);
+      return;
+    }
+    const hz = q.hz ?? 0;
+    if (hz <= 0) return;
+    noteManualEdit();
+    setFreqMhz((hz / 1_000_000).toFixed(6));
+    const b = bandForMHz(hz / 1_000_000);
+    if (b) setBand(b);
+    if (catState.enabled && catState.connected) SetCATFrequency(hz).catch(() => {});
+    showToast((hz / 1_000_000).toFixed(3) + ' MHz');
+  };
+
   // Mouse-wheel over a kHz digit of the top frequency readout: step the frequency
   // and (if CAT is connected) QSY the rig. The display updates optimistically on
   // every notch; the actual radio tune is debounced so a fast scroll doesn't flood
@@ -5974,7 +6098,7 @@ export default function App() {
             </div>
             <div className="flex-1 min-h-0 flex">
               <div className="flex-1 min-w-0 flex flex-col min-h-0">
-                <ClusterGrid key={`clg-${activeProfileId ?? 'x'}`} rows={clusterRenderedRows as any} spotStatus={spotStatus} onSpotClick={handleSpotClick} />
+                <ClusterGrid key={`clg-${activeProfileId ?? 'x'}`} rows={clusterRenderedRows as any} spotStatus={spotStatus} onSpotClick={handleSpotClick} onSpotSelect={handleSpotSelect} />
               </div>
               {clusterShowFilters && renderClusterFilters()}
             </div>
@@ -5986,7 +6110,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>
         );
@@ -6003,6 +6127,12 @@ export default function App() {
             <YaesuPanel onReportRST={(r) => { setRstSent(r); rstUserEditedRef.current = true; }} onKeySpeed={setCWSpeedEverywhere} />
           </div>
         );
+      case 'elecraft':
+        return (
+          <div className="h-full w-full min-h-0 rounded-lg overflow-hidden border border-border">
+            <ElecraftPanel onReportRST={(r) => { setRstSent(r); rstUserEditedRef.current = true; }} />
+          </div>
+        );
       case 'icom':
         return (
           <div className="h-full w-full min-h-0 rounded-lg overflow-hidden border border-border">
@@ -6043,9 +6173,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)}
@@ -6794,6 +6924,16 @@ export default function App() {
         onKeyDown={(e) => {
           if (e.key === 'Enter' && (e.target as HTMLElement).tagName === 'INPUT') {
             e.preventDefault();
+            // A number in the call field is a QSY. Checked BEFORE ESM and before
+            // logging: both would otherwise act on a "callsign" of 28500.
+            if (e.target === callsignRef.current) {
+              const q = entryQSYCommand(callsignRef.current?.value ?? '');
+              if (q) {
+                applyEntryQSY(q);
+                setCallsign(''); // the field goes back to what it is for
+                return;
+              }
+            }
             // ESM (Enter Sends Message): fire the stage-appropriate CW macro instead
             // of logging. Falls through to the normal log when ESM isn't active.
             if (esmHandleEnter(e.target as HTMLElement)) return;
@@ -7269,6 +7409,7 @@ export default function App() {
               {catState.backend === 'flex' && <TabsTrigger value="flex">Flex Console</TabsTrigger>}
               {catState.backend === 'icom' && <TabsTrigger value="icom">Icom Console</TabsTrigger>}
               {catState.backend === 'yaesu' && <TabsTrigger value="yaesu">Yaesu Console</TabsTrigger>}
+            {(catState.backend === 'elecraft' || catState.backend === 'kenwood') && <TabsTrigger value="elecraft">{t('k3.console')}</TabsTrigger>}
               {statsTabOpen && (
                 <TabsTrigger value="stats" className="gap-1.5">
                   {t('stats.tab')}
@@ -7442,9 +7583,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)}
@@ -7635,6 +7776,7 @@ export default function App() {
                     rows={rendered as any}
                     spotStatus={spotStatus}
                     onSpotClick={handleSpotClick}
+                    onSpotSelect={handleSpotSelect}
                   />
                 );
               })()}
@@ -7775,7 +7917,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>
 
@@ -7948,6 +8090,14 @@ export default function App() {
               </TabsContent>
             )}
 
+            {/* Elecraft K3/K4 console. Shown for the Kenwood backend too: the
+                K3 speaks that dialect and the panel reads whatever answers. */}
+            {(catState.backend === 'elecraft' || catState.backend === 'kenwood') && (
+              <TabsContent value="elecraft" className="flex-1 min-h-0 p-0">
+                <ElecraftPanel onReportRST={(r) => { setRstSent(r); rstUserEditedRef.current = true; }} />
+              </TabsContent>
+            )}
+
             {catState.backend === 'icom' && (
               <TabsContent value="icom" className="flex-1 min-h-0 p-0">
                 <IcomPanel isNetwork={catBackend === 'icom-net'} onReportRST={(r) => { setRstSent(r); rstUserEditedRef.current = true; }} />

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

@@ -1,7 +1,7 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import {
   AllCommunityModule, ModuleRegistry,
-  type ColDef, type ColumnState, type GridReadyEvent, type RowClickedEvent,
+  type ColDef, type ColumnState, type GridReadyEvent, type RowClickedEvent, type RowDoubleClickedEvent,
 } from 'ag-grid-community';
 import { hamlogGridTheme } from '@/lib/gridTheme';
 import { AgGridReact } from 'ag-grid-react';
@@ -75,7 +75,13 @@ export type SpotStatusEntry = {
 type Props = {
   rows: ClusterSpot[];
   spotStatus: Record<string, SpotStatusEntry>;
+  // A DOUBLE click works the spot: QSY, mode, callsign, the lot.
   onSpotClick?: (s: ClusterSpot) => void;
+  // A SINGLE click only fills the callsign. Reading the cluster means passing
+  // over dozens of lines, and every pass used to drag the radio with it — one
+  // stray click while looking took the operator off the station they were
+  // working. Looking and going are now two different gestures.
+  onSpotSelect?: (s: ClusterSpot) => void;
 };
 
 const COL_STATE_KEY = 'hamlog.clusterColState.v1';
@@ -500,7 +506,7 @@ const GROUP_ORDER = ['Spot', 'Geo'];
 const CLG_GRP_KEYS: Record<string, string> = { Spot: 'clg2.grpSpot', Geo: 'clg2.grpGeo' };
 const groupLabel = (t: TFn, g: string): string => t(CLG_GRP_KEYS[g] ?? g);
 
-export function ClusterGrid({ rows, spotStatus, onSpotClick }: Props) {
+export function ClusterGrid({ rows, spotStatus, onSpotClick, onSpotSelect }: Props) {
   const { t } = useI18n();
   const gridRef = useRef<any>(null);
   const [pickerOpen, setPickerOpen] = useState(false);
@@ -583,6 +589,10 @@ export function ClusterGrid({ rows, spotStatus, onSpotClick }: Props) {
   }, []);
 
   function handleRowClicked(e: RowClickedEvent<ClusterSpot>) {
+    if (e.data && onSpotSelect) onSpotSelect(e.data);
+  }
+
+  function handleRowDoubleClicked(e: RowDoubleClickedEvent<ClusterSpot>) {
     if (e.data && onSpotClick) onSpotClick(e.data);
   }
 
@@ -647,6 +657,7 @@ export function ClusterGrid({ rows, spotStatus, onSpotClick }: Props) {
             onColumnVisible={saveColumnState}
             onSortChanged={saveColumnState}
             onRowClicked={handleRowClicked}
+            onRowDoubleClicked={handleRowDoubleClicked}
             animateRows={false}
             suppressCellFocus
             getRowId={(p) => `${(p.data as any).received_at}-${(p.data as any).dx_call}-${(p.data as any).source_id}`}

frontend/src/components/ElecraftPanel.tsx

@@ -0,0 +1,314 @@
+import { useEffect, useRef, useState } from 'react';
+import { Radio, Power, Activity, AudioLines, SlidersHorizontal } from 'lucide-react';
+import {
+  GetKenwoodState, RefreshKenwood, SetKenwoodPower, SetKenwoodAFGain, SetKenwoodTX, TuneKenwoodATU,
+  SetKenwoodRFGain, SetKenwoodMicGain, SetKenwoodSquelch, SetKenwoodPreamp, SetKenwoodAtt,
+  SetKenwoodNB, SetKenwoodNR, SetKenwoodAGC, SetKenwoodFilter, SetKenwoodAntenna,
+  SetKenwoodRIT, SetKenwoodXIT, ClearKenwoodRIT, SetKenwoodKeySpeed, ToggleKenwoodATU,
+  GetCATState,
+} from '../../wailsjs/go/main/App';
+import { cn } from '@/lib/utils';
+import { useI18n } from '@/lib/i18n';
+import { sMeterRST } from '@/lib/rst';
+import { MeterBar } from '@/components/MeterBar';
+import { WheelRange } from '@/components/WheelRange';
+
+type KenwoodState = {
+  available: boolean; model?: string; elecraft: boolean; mode?: string;
+  transmitting: boolean; split: boolean; split_tx_hz?: number;
+  s_meter: number; s_meter_raw: number;
+  power_meter: number; swr: number; swr_raw: number;
+  rf_power: number; af_gain: number; rf_gain: number; mic_gain: number; squelch: number;
+  preamp: boolean; att: boolean; nb: boolean; nr: boolean; agc?: string;
+  filter_hz: number; antenna: number; rit: boolean; xit: boolean; key_speed: number;
+  meters_provisional: boolean;
+};
+
+const ZERO: KenwoodState = {
+  available: false, elecraft: false, transmitting: false, split: false,
+  s_meter: 0, s_meter_raw: 0, power_meter: 0, swr: 0, swr_raw: 0,
+  rf_power: 0, af_gain: 0, rf_gain: 0, mic_gain: 0, squelch: 0,
+  preamp: false, att: false, nb: false, nr: false,
+  filter_hz: 0, antenna: 0, rit: false, xit: false, key_speed: 0,
+  meters_provisional: true,
+};
+
+// Filter widths worth a button. CW work happens at 200-500 Hz, SSB at 2.4-2.8
+// kHz; the rest of the range is reachable from the radio's own knob, and a
+// panel offering thirty widths is slower to use than the knob it replaces.
+const FILTERS = [200, 400, 700, 1000, 1800, 2400, 2800];
+
+// Raw S-meter → S units. The K3 answers 0-21 across S0…S9+60; S9 is taken at
+// raw 9 and each step above it as 6 dB. PROVISIONAL, like the rest of the
+// scaling: the raw value is on screen and in the log, so a real radio settles
+// it rather than this comment.
+const S9_RAW = 9;
+const DB_PER_RAW = 6;
+function sParts(rawV: number): { s: number; over: number; label: string } {
+  if (rawV >= S9_RAW) {
+    const over = Math.max(0, Math.round((rawV - S9_RAW) * DB_PER_RAW));
+    return { s: 9, over, label: over > 0 ? `S9+${over}` : 'S9' };
+  }
+  const s = Math.max(0, Math.min(9, rawV));
+  return { s, over: 0, label: `S${s}` };
+}
+
+// Segment colour, printed the way a radio's own meter is: green up to S9, amber
+// through the S9+ range, red once the signal would be reported as 59+20 or more.
+function sSegColor(frac: number) {
+  if (frac > 0.78) return '#dc2626';
+  if (frac > 0.55) return '#f59e0b';
+  return '#16a34a';
+}
+
+// The card shell the Yaesu and Icom consoles use, so the three read alike.
+function Card({ icon: Icon, title, children }: { icon: any; title: string; children: React.ReactNode }) {
+  return (
+    <div className="rounded-xl border border-border bg-card shadow-sm overflow-hidden">
+      <div className="flex items-center gap-2 px-3 py-2 border-b border-border/60 bg-muted/30">
+        <Icon className="size-4 text-primary" />
+        <span className="text-xs font-bold uppercase tracking-wider text-foreground/80">{title}</span>
+      </div>
+      <div className="p-3 space-y-3">{children}</div>
+    </div>
+  );
+}
+
+// One button shape for every on/off control, so the panel reads as one
+// instrument instead of a collection of differently-styled switches.
+function Toggle({ label, on, off, onClick }: { label: string; on: boolean; off: boolean; onClick: () => void }) {
+  return (
+    <button type="button" disabled={off} onClick={onClick}
+      className={cn('px-2 py-1 rounded-md text-[11px] font-bold tracking-wide border transition-all disabled:opacity-30',
+        on ? 'bg-primary text-primary-foreground border-primary' : 'bg-card text-muted-foreground border-border hover:border-primary/60')}>
+      {label}
+    </button>
+  );
+}
+
+export function ElecraftPanel({ onReportRST }: { onReportRST?: (rst: string) => void }) {
+  const { t } = useI18n();
+  const [st, setSt] = useState<KenwoodState>(ZERO);
+  const [freqHz, setFreqHz] = useState(0);
+  const [err, setErr] = useState('');
+  // Optimistic overlay: a slider must follow the finger, not the poll. Dropped
+  // once the radio has had time to answer with the value it actually took.
+  const [local, setLocal] = useState<{ rf_power?: number; af_gain?: number; rf_gain?: number; mic_gain?: number; squelch?: number; key_speed?: number }>({});
+  const localAtRef = useRef(0);
+
+  useEffect(() => {
+    let alive = true;
+    const tick = async () => {
+      try {
+        const s = (await GetKenwoodState()) as KenwoodState;
+        const c = (await GetCATState()) as any;
+        if (!alive) return;
+        setSt(s);
+        setFreqHz(c?.split && c?.freq_rx_hz > 0 ? c.freq_rx_hz : (c?.freq_hz ?? 0));
+        if (Date.now() - localAtRef.current > 1200) setLocal({});
+        setErr('');
+      } catch (e: any) {
+        if (alive) setErr(String(e?.message ?? e));
+      }
+    };
+    tick();
+    const id = window.setInterval(tick, 500);
+    return () => { alive = false; window.clearInterval(id); };
+  }, []);
+
+  const view = { ...st, ...local };
+  const off = !st.available;
+
+  const setErrMsg = (e: any) => setErr(String(e?.message ?? e));
+
+  const put = (patch: typeof local, run: () => Promise<any>) => {
+    setLocal((p) => ({ ...p, ...patch }));
+    localAtRef.current = Date.now();
+    run().catch((e) => setErr(String(e?.message ?? e)));
+  };
+
+  return (
+    <div className="h-full min-h-0 overflow-auto bg-background">
+      {/* Same wrapper as the Yaesu, Icom and Flex consoles: capped width and
+          CENTRED. A console stretched across a 2000 px window puts a slider a
+          hand's width from its own label, and the panel stops reading as one
+          instrument. */}
+      <div className="max-w-5xl mx-auto p-3 space-y-3">
+      {/* VFO + status */}
+      <div className="rounded-xl border border-border bg-card shadow-sm px-4 py-3 flex items-center justify-between gap-3 flex-wrap">
+        <div>
+          <div className="text-[10px] font-bold uppercase tracking-wider text-muted-foreground flex items-center gap-1.5">
+            <Radio className="size-3.5" />
+            {st.elecraft ? 'Elecraft' : 'Kenwood'} {st.model}
+            <span className={cn('size-2 rounded-full', off ? 'bg-muted-foreground/40' : 'bg-success')} />
+          </div>
+          <div className="text-2xl font-mono tabular-nums font-bold">
+            {freqHz > 0 ? (freqHz / 1e6).toFixed(6) : '—'}
+          </div>
+        </div>
+        <button type="button" className="text-[11px] text-muted-foreground hover:text-foreground flex items-center gap-1"
+          onClick={() => RefreshKenwood().catch(() => {})} title={t('k3.refreshHint')}>
+          <SlidersHorizontal className="size-3.5" />
+        </button>
+      </div>
+
+      {off && <div className="text-xs text-muted-foreground px-1">{t('k3.waiting')}</div>}
+      {!!err && <div className="text-[11px] text-danger px-1">{err}</div>}
+
+      {/* Meters */}
+      <Card icon={Activity} title={t('k3.meters')}>
+      <div className="grid grid-cols-1 sm:grid-cols-3 gap-2">
+        <MeterBar label="S-METER" value={view.transmitting ? 0 : view.s_meter} lo={0} hi={100}
+          accent="#16a34a" segColor={sSegColor}
+          display={view.transmitting ? '—' : sParts(view.s_meter_raw).label}
+          onClick={() => {
+            if (view.transmitting || !onReportRST) return;
+            const sp = sParts(view.s_meter_raw);
+            onReportRST(sMeterRST(sp.s, sp.over, view.mode));
+          }}
+          title={t('k3.sMeterHint', { raw: String(view.s_meter_raw) })} />
+        <MeterBar label="PWR" value={view.transmitting ? view.power_meter : 0} lo={0} hi={100} accent="#0ea5e9" />
+        {/* 0 means "not measured", and it must not render as a perfect 1.0:
+            a match that looks ideal on an antenna nobody has measured is the one
+            reading that can cost a radio. */}
+        <MeterBar label="SWR" value={view.transmitting && view.swr > 0 ? view.swr : 1} lo={1} hi={4}
+          accent="#f59e0b"
+          display={view.transmitting && view.swr > 0 ? view.swr.toFixed(1) : '—'} />
+      </div>
+      {view.meters_provisional && (
+        <p className="text-[10px] text-muted-foreground">{t('k3.provisional')}</p>
+      )}
+      </Card>
+
+      {/* MOX + TUNE */}
+      <div className="flex items-center gap-2">
+        <button type="button" disabled={off}
+          onClick={() => SetKenwoodTX(!view.transmitting).catch((e) => setErr(String(e?.message ?? e)))}
+          className={cn('flex-1 px-3 py-2.5 rounded-lg text-sm font-extrabold tracking-wide border-2 transition-all disabled:opacity-30',
+            view.transmitting
+              ? 'bg-danger text-danger-foreground border-danger shadow-[0_0_14px] shadow-danger/50'
+              : 'bg-card text-danger border-danger hover:bg-danger-muted')}>
+          <Power className="size-4 inline mr-1 -mt-0.5" /> MOX
+        </button>
+        <button type="button" disabled={off}
+          onClick={() => TuneKenwoodATU().catch((e) => setErr(String(e?.message ?? e)))}
+          title={t('k3.tuneHint')}
+          className="flex-1 px-3 py-2.5 rounded-lg text-sm font-extrabold tracking-wide border-2 border-warning text-warning bg-card hover:bg-warning-muted transition-all disabled:opacity-30">
+          <Activity className="size-4 inline mr-1 -mt-0.5" /> TUNE
+        </button>
+        {/* The HOLD of the same switch: tuner in line or bypassed. Two buttons
+            because they are two things on the radio — tuning is a cycle you
+            start, bypassing is a state you leave it in. */}
+        <button type="button" disabled={off}
+          onClick={() => ToggleKenwoodATU().catch(setErrMsg)}
+          title={t('k3.atuHint')}
+          className="px-3 py-2.5 rounded-lg text-sm font-extrabold tracking-wide border-2 border-border text-muted-foreground bg-card hover:bg-muted transition-all disabled:opacity-30">
+          ATU
+        </button>
+      </div>
+
+      {/* Levels — two columns, so a slider stays beside the label it belongs to
+          instead of running the width of the window. */}
+      <Card icon={SlidersHorizontal} title={t('k3.levels')}>
+      <div className="grid grid-cols-1 lg:grid-cols-2 gap-x-6 gap-y-2">
+        <label className="flex items-center gap-2 text-xs">
+          <span className="w-16 shrink-0 text-muted-foreground">{t('k3.power')}</span>
+          <WheelRange min={0} max={110} step={5} disabled={off}
+            value={view.rf_power ?? 0}
+            onChange={(n) => put({ rf_power: n }, () => SetKenwoodPower(n))} />
+          <span className="w-12 text-right font-mono tabular-nums">{view.rf_power ?? 0} W</span>
+        </label>
+        <label className="flex items-center gap-2 text-xs">
+          <span className="w-16 shrink-0 text-muted-foreground flex items-center gap-1">
+            <AudioLines className="size-3.5" /> {t('k3.volume')}
+          </span>
+          <WheelRange min={0} max={100} disabled={off}
+            value={view.af_gain ?? 0}
+            onChange={(n) => put({ af_gain: n }, () => SetKenwoodAFGain(n))} />
+          <span className="w-12 text-right font-mono tabular-nums">{view.af_gain ?? 0}</span>
+        </label>
+        <label className="flex items-center gap-2 text-xs">
+          <span className="w-16 shrink-0 text-muted-foreground">{t('k3.rfGain')}</span>
+          <WheelRange min={0} max={100} disabled={off}
+            value={view.rf_gain ?? 0}
+            onChange={(n) => put({ rf_gain: n }, () => SetKenwoodRFGain(n))} />
+          <span className="w-12 text-right font-mono tabular-nums">{view.rf_gain ?? 0}</span>
+        </label>
+        <label className="flex items-center gap-2 text-xs">
+          <span className="w-16 shrink-0 text-muted-foreground">{t('k3.micGain')}</span>
+          <WheelRange min={0} max={100} disabled={off}
+            value={view.mic_gain ?? 0}
+            onChange={(n) => put({ mic_gain: n }, () => SetKenwoodMicGain(n))} />
+          <span className="w-12 text-right font-mono tabular-nums">{view.mic_gain ?? 0}</span>
+        </label>
+        <label className="flex items-center gap-2 text-xs">
+          <span className="w-16 shrink-0 text-muted-foreground">{t('k3.squelch')}</span>
+          <WheelRange min={0} max={100} disabled={off}
+            value={view.squelch ?? 0}
+            onChange={(n) => put({ squelch: n }, () => SetKenwoodSquelch(n))} />
+          <span className="w-12 text-right font-mono tabular-nums">{view.squelch ?? 0}</span>
+        </label>
+        {/* CW keyer speed — the radio's own keyer, the one the K3 sends with. */}
+        <label className="flex items-center gap-2 text-xs">
+          <span className="w-16 shrink-0 text-muted-foreground">{t('k3.keySpeed')}</span>
+          <WheelRange min={8} max={50} disabled={off}
+            value={view.key_speed || 20}
+            onChange={(n) => put({ key_speed: n }, () => SetKenwoodKeySpeed(n))} />
+          <span className="w-12 text-right font-mono tabular-nums">{view.key_speed || 0} wpm</span>
+        </label>
+      </div>
+      </Card>
+
+      {/* Receive chain. Toggles, because that is what they are on the radio:
+          one press each, and the state comes back from the rig rather than from
+          what the button was asked to do. */}
+      <Card icon={AudioLines} title={t('k3.receive')}>
+      <div className="space-y-2">
+        <div className="flex flex-wrap items-center gap-1.5">
+          <Toggle label="PRE" on={view.preamp} off={off} onClick={() => SetKenwoodPreamp(!view.preamp).catch(setErrMsg)} />
+          <Toggle label="ATT" on={view.att} off={off} onClick={() => SetKenwoodAtt(!view.att).catch(setErrMsg)} />
+          <Toggle label="NB" on={view.nb} off={off} onClick={() => SetKenwoodNB(!view.nb).catch(setErrMsg)} />
+          <Toggle label="NR" on={view.nr} off={off} onClick={() => SetKenwoodNR(!view.nr).catch(setErrMsg)} />
+          <span className="w-2" />
+          {['OFF', 'SLOW', 'FAST'].map((a) => (
+            <Toggle key={a} label={a} on={(view.agc || '').toUpperCase() === a} off={off}
+              onClick={() => SetKenwoodAGC(a).catch(setErrMsg)} />
+          ))}
+        </div>
+
+        {/* RIT / XIT. Clear zeroes both offsets at once — the radio's own RC,
+            and what an operator means by "clear it". */}
+        <div className="flex flex-wrap items-center gap-1.5">
+          <Toggle label="RIT" on={view.rit} off={off} onClick={() => SetKenwoodRIT(!view.rit).catch(setErrMsg)} />
+          <Toggle label="XIT" on={view.xit} off={off} onClick={() => SetKenwoodXIT(!view.xit).catch(setErrMsg)} />
+          <Toggle label={t('k3.clear')} on={false} off={off} onClick={() => ClearKenwoodRIT().catch(setErrMsg)} />
+          {/* Antenna only when the radio answered AN — a K3 without the internal
+              ATU has one socket and no switch to offer. */}
+          {view.antenna > 0 && (<>
+            <span className="w-2" />
+            <span className="text-[10px] uppercase tracking-wider text-muted-foreground">{t('k3.antenna')}</span>
+            {[1, 2].map((n) => (
+              <Toggle key={n} label={'ANT' + n} on={view.antenna === n} off={off}
+                onClick={() => SetKenwoodAntenna(n).catch(setErrMsg)} />
+            ))}
+          </>)}
+        </div>
+
+        {/* Filter width */}
+        <div className="flex flex-wrap items-center gap-1.5">
+          <span className="text-[10px] uppercase tracking-wider text-muted-foreground">{t('k3.filter')}</span>
+          {FILTERS.map((hz) => (
+            <Toggle key={hz} label={hz >= 1000 ? (hz / 1000).toFixed(1) + 'k' : String(hz)}
+              on={view.filter_hz === hz} off={off}
+              onClick={() => SetKenwoodFilter(hz).catch(setErrMsg)} />
+          ))}
+          {view.filter_hz > 0 && (
+            <span className="text-[10px] font-mono text-muted-foreground">{view.filter_hz} Hz</span>
+          )}
+        </div>
+      </div>
+      </Card>
+      </div>
+    </div>
+  );
+}

frontend/src/components/FilterBuilder.tsx

@@ -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' },

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,64 @@ 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. */}
+              {/* CW ONLY. The marker comes from a skimmer decoding a CW report,
+                  so on SSB or FT8 there is nothing to chase — and a switch that
+                  cannot fire is an invitation to wonder why it does nothing. */}
+              {isCW && (<>
+              <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/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' },
 ];
@@ -349,6 +350,34 @@ export function QSLManagerPanel({ onEditQSO, actions, paperRequest }: {
     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();
@@ -665,11 +694,25 @@ export function QSLManagerPanel({ onEditQSO, actions, paperRequest }: {
       {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 />
@@ -693,6 +736,7 @@ export function QSLManagerPanel({ onEditQSO, actions, paperRequest }: {
             <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();
@@ -715,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 */}
@@ -731,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.
@@ -827,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>

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

@@ -13,7 +13,7 @@ import {
   ListProfiles, GetActiveProfile, SaveProfile, DeleteProfile, ActivateProfile, DuplicateProfile,
   GetRotators, SaveRotators, TestRotatorDevice, RotatorPark, RotatorStop,
   GetRotorPresets, SaveRotorPresets, ResetRotorPresets,
-  GetUltrabeamSettings, SaveUltrabeamSettings, TestUltrabeam, CompactDatabase,
+  GetUltrabeamSettings, SaveUltrabeamSettings, TestUltrabeam, CompactDatabase, CheckHamlogKey, CompareRDASources,
   GetAntGeniusSettings, SaveAntGeniusSettings,
   GetTunerGeniusSettings, SaveTunerGeniusSettings,
   GetPSUSettings, SavePSUSettings,
@@ -58,12 +58,12 @@ import {
   GetFolderSync, SaveFolderSync, PickFolderSyncFolder, GetFolderSyncStatus, SyncFolderNow,
   GetRelayAuto, SaveRelayAuto, GetStationDevices,
   GetAwardDefs, GetTrackedAwards, SaveTrackedAwards,
-  GetBandOpenSettings, SaveBandOpenSettings, GetGridScopeSettings, SaveGridScopeSettings, GetPSKReporterStatus, GetChaseNewGrids, SetChaseNewGrids, GetChaseNew, SetChaseNew, GetGridCacheStatus, GetLinkedAmps, SetLinkedAmps, GetSpotTTLMinutes, SetSpotTTLMinutes,
+  GetBandOpenSettings, SaveBandOpenSettings, GetGridScopeSettings, SaveGridScopeSettings, GetPSKReporterStatus, GetChaseNewGrids, SetChaseNewGrids, GetChaseNew, SetChaseNew, GetGridCacheStatus, GetLinkedAmps, SetLinkedAmps, GetSpotTTLMinutes, SetSpotTTLMinutes, GetSpotMax, SetSpotMax,
 } from '../../wailsjs/go/main/App';
 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,
@@ -80,7 +80,6 @@ import {
 } from '@/components/ui/select';
 import { cn } from '@/lib/utils';
 import { writeUiPref } from '@/lib/uiPref';
-import { loadAutoCall, autoCallKey, type AutoCallSettings, type AutoCallCriteria } from '@/lib/autocall';
 import { getDateFormat, setDateFormat, type DateFormat } from '@/lib/dateFormat';
 import { useI18n, FlagGB, FlagFR, type Lang } from '@/lib/i18n';
 import { useTheme, CONCRETE_THEMES, type ThemeChoice } from '@/lib/theme';
@@ -1708,6 +1707,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: '',
@@ -1715,6 +1715,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
@@ -1730,7 +1731,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: '',
@@ -1738,7 +1739,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);
@@ -1852,6 +1853,20 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   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 {
@@ -1872,6 +1887,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[]>([]);
@@ -1879,7 +1896,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);
@@ -1915,7 +1932,6 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   // feed up or down — so the write has to go where those live.
   const [bandOpen, setBandOpen] = useState<any>({ enabled: false, bands: [], available: [] });
   // How a worked square is matched, and what counts as still wanted.
-  const [autoCall, setAutoCall] = useState<AutoCallSettings>(loadAutoCall);
   const [gridScope, setGridScope] = useState<any>({ scope: 'mix_digi', hunt: 'new', scopes: [] });
   useEffect(() => { GetGridScopeSettings().then((g) => setGridScope(g as any)).catch(() => {}); }, []);
   const saveGridScope = async (next: any) => {
@@ -1926,6 +1942,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   const [chaseNew, setChaseNew] = useState(false);
   const [spotTTL, setSpotTTL] = useState(0);
   const [spotTTLText, setSpotTTLText] = useState('0');
+  const [spotMaxText, setSpotMaxText] = useState('1000');
   const [gridStat, setGridStat] = useState<any>(null);
   const [pskrStatus, setPskrStatus] = useState<any>(null);
   const saveBandOpen = async (next: any) => {
@@ -1939,6 +1956,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
       try { setChaseNew(await GetChaseNew()); } catch { /* defaults stand */ }
       try { setLinkedAmps((await GetLinkedAmps()) ?? []); } catch { /* defaults stand */ }
       try { const n = await GetSpotTTLMinutes(); setSpotTTL(n); setSpotTTLText(String(n)); } catch { /* defaults stand */ }
+      try { const n = await GetSpotMax(); setSpotMaxText(String(n)); } catch { /* defaults stand */ }
     })();
     // Poll the feed while the panel is open: a live count is the only thing that
     // distinguishes "connected" from "connected and receiving nothing".
@@ -4957,6 +4975,28 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                 }} />
               <span className="text-xs text-muted-foreground">{t('clu.spotTtlHint')}</span>
             </div>
+            {/* The list size, beside the lifetime because between them they decide
+                the same thing: whichever runs out first removes the spot. */}
+            <div className="flex items-center gap-3 flex-wrap">
+              <span className="text-sm">{t('clu.spotMax')}</span>
+              <div className="inline-flex rounded-md border border-border overflow-hidden text-xs">
+                {[500, 1000, 2500, 5000].map((v) => (
+                  <button key={v} type="button"
+                    onClick={() => { setSpotMaxText(String(v)); SetSpotMax(v).catch(() => {}); }}
+                    className={cn('px-2.5 py-1.5 font-medium', Number(spotMaxText) === v ? 'bg-primary text-primary-foreground' : 'text-muted-foreground hover:bg-muted')}>
+                    {v}
+                  </button>
+                ))}
+              </div>
+              <Input className="h-8 w-24" value={spotMaxText}
+                onChange={(e) => {
+                  const raw = e.target.value.replace(/[^0-9]/g, '');
+                  setSpotMaxText(raw);
+                  const n = parseInt(raw, 10);
+                  if (Number.isFinite(n) && n > 0) SetSpotMax(Math.min(10000, n)).catch(() => {});
+                }} />
+              <span className="text-xs text-muted-foreground">{t('clu.spotMaxHint')}</span>
+            </div>
           </div>
 
           <div className="border-t border-border/60 pt-3 space-y-2">
@@ -5204,9 +5244,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>
@@ -5237,6 +5274,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>
       </>
@@ -5420,6 +5469,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 },
     ];
 
@@ -5489,6 +5539,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 } }));
@@ -5790,6 +5864,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">
@@ -7128,6 +7256,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>
     );
   }

frontend/src/components/WheelRange.tsx

@@ -0,0 +1,62 @@
+import { useEffect, useRef } from 'react';
+import { cn } from '@/lib/utils';
+
+// A range slider the mouse wheel can move.
+//
+// Dragging a 4-pixel-tall slider to change the power by five watts is a fussy
+// gesture; rolling the wheel over it is not, and it is what an operator reaches
+// for after using the Flex and Yaesu consoles, which have had it for a while.
+//
+// React's own onWheel is registered PASSIVE, so preventDefault() inside it is
+// ignored and the panel scrolls under the pointer while the value changes. The
+// listener therefore has to be attached natively with { passive: false }, and
+// the live values read through refs — the listener is installed once and would
+// otherwise capture the first render's value for ever.
+//
+// The Flex and Yaesu panels each grew their own copy of this before it was worth
+// sharing. They are left alone deliberately: they work, they are in daily use,
+// and their styling differs in small ways that a merge would have to guess at.
+export function WheelRange({ value, onChange, min = 0, max = 100, step = 1, disabled, accent = 'var(--primary)', className }: {
+  value: number; onChange: (v: number) => void;
+  min?: number; max?: number; step?: number; disabled?: boolean; accent?: string; className?: string;
+}) {
+  const v = Math.max(min, Math.min(max, value));
+  const pct = max > min ? ((v - min) / (max - min)) * 100 : 0;
+  const ref = useRef<HTMLInputElement>(null);
+  const valRef = useRef(v); valRef.current = v;
+  const cbRef = useRef(onChange); cbRef.current = onChange;
+  const disRef = useRef(disabled); disRef.current = disabled;
+  const stepRef = useRef(step); stepRef.current = step;
+  const minRef = useRef(min); minRef.current = min;
+  const maxRef = useRef(max); maxRef.current = max;
+
+  useEffect(() => {
+    const el = ref.current;
+    if (!el) return;
+    const onWheel = (e: WheelEvent) => {
+      if (disRef.current) return;
+      e.preventDefault();
+      const d = e.deltaY < 0 ? stepRef.current : -stepRef.current;
+      const nv = Math.max(minRef.current, Math.min(maxRef.current, valRef.current + d));
+      if (nv !== valRef.current) cbRef.current(nv);
+    };
+    el.addEventListener('wheel', onWheel, { passive: false });
+    return () => el.removeEventListener('wheel', onWheel);
+  }, []);
+
+  return (
+    <input
+      ref={ref}
+      type="range" min={min} max={max} step={step} value={v} disabled={disabled}
+      onChange={(e) => onChange(parseInt(e.target.value, 10))}
+      className={cn('flex-1 h-1.5 rounded-full appearance-none cursor-pointer disabled:opacity-30 disabled:cursor-default',
+        '[&::-webkit-slider-thumb]:appearance-none [&::-webkit-slider-thumb]:size-3.5 [&::-webkit-slider-thumb]:rounded-full',
+        '[&::-webkit-slider-thumb]:bg-card [&::-webkit-slider-thumb]:border-2 [&::-webkit-slider-thumb]:shadow-sm [&::-webkit-slider-thumb]:cursor-pointer',
+        className)}
+      style={{
+        background: `linear-gradient(to right, ${accent} ${pct}%, color-mix(in srgb, var(--foreground) 18%, transparent) ${pct}%)`,
+        borderColor: accent,
+      }}
+    />
+  );
+}

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,8 +17,9 @@ 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;
+  nb: boolean; nr: boolean; nr_level: number; narrow: boolean; narrow_supported?: boolean; vox: boolean;
+  max_power?: number;
   split_tx_hz?: number; key_speed?: number; break_in?: boolean; swr?: number; power_w?: number;
 };
 
@@ -26,7 +27,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 +75,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 +429,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 */}
@@ -431,7 +446,13 @@ export function YaesuPanel({ onReportRST, onKeySpeed }: {
         <div className="flex items-center gap-2 flex-wrap">
           <Chip on={view.nb} onClick={() => push('nb', !view.nb, () => SetYaesuNB(!view.nb))} label="NB" />
           <Chip on={view.nr} onClick={() => push('nr', !view.nr, () => SetYaesuNR(!view.nr))} label="DNR" />
-          <Chip on={view.narrow} onClick={() => push('narrow', !view.narrow, () => SetYaesuNarrow(!view.narrow))} label="NAR" />
+          {/* NAR is the narrow IF filter. Shown only when the rig ANSWERED NA:
+              a button that does nothing when pressed reads as a fault in the
+              radio, which is how it was reported from an FTDX101. */}
+          {view.narrow_supported && (
+            <Chip on={view.narrow} onClick={() => push('narrow', !view.narrow, () => SetYaesuNarrow(!view.narrow))}
+              label="NAR" title={t('yaesu.narrowHint')} />
+          )}
         </div>
         <Row label="DNR">
           {/* 1-15 on the rig, shown as-is rather than rescaled to a percentage:
@@ -448,7 +469,7 @@ export function YaesuPanel({ onReportRST, onKeySpeed }: {
         <Row label="PWR">
           {/* Watts, not a percentage: the rig reports and takes watts, and a
               percentage would be a second unit to reconcile every time. */}
-          <Slider value={view.rf_power || 5} min={5} max={100} accent="var(--destructive)"
+          <Slider value={view.rf_power || 5} min={5} max={Math.max(100, view.max_power || 100)} accent="var(--destructive)"
             onChange={(v) => push('rf_power', v, () => SetYaesuPower(v))} />
           <span className="w-10 text-right text-xs font-mono tabular-nums text-muted-foreground">{view.rf_power}W</span>
         </Row>

frontend/src/lib/autocall.ts

@@ -72,13 +72,26 @@ export function loadAutoCall(): AutoCallSettings {
     const raw = localStorage.getItem(AC_KEY);
     if (!raw) return { ...defaultAutoCall };
     const v = JSON.parse(raw);
-    return {
+    const out: AutoCallSettings = {
       ...defaultAutoCall,
       ...v,
       criteria: { ...emptyCriteria, ...(v?.criteria ?? {}) },
       watchCriteria: { ...emptyCriteria, ...(v?.watchCriteria ?? {}) },
       watch: Array.isArray(v?.watch) ? v.watch : [],
     };
+    // DISARMED ON SIGHT, and written back disabled.
+    //
+    // The runtime guard in App.tsx stops this build from calling anyone, but it
+    // leaves "enabled": true sitting in storage, where any build without the
+    // guard — an older one an operator reinstalls, a machine that upgrades
+    // later — reads it and keys the transmitter for a feature with no switch
+    // left to turn off. A withdrawn feature that keys a radio has to be
+    // disarmed where it is REMEMBERED, not only where it runs.
+    if (out.enabled) {
+      out.enabled = false;
+      try { localStorage.setItem(AC_KEY, JSON.stringify(out)); } catch { /* private mode: the guard still holds */ }
+    }
+    return out;
   } catch { return { ...defaultAutoCall }; }
 }
 

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

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

@@ -117,6 +117,10 @@ export function ChatAvailable():Promise<boolean>;
 
 export function CheckForUpdate():Promise<main.UpdateInfo>;
 
+export function CheckHamlogKey(arg1:string):Promise<string>;
+
+export function ClearKenwoodRIT():Promise<void>;
+
 export function ClearLookupCache():Promise<void>;
 
 export function CloseAutostartPrograms():Promise<void>;
@@ -125,6 +129,8 @@ export function ClusterSpotStatuses(arg1:Array<main.SpotQuery>):Promise<Array<ma
 
 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>;
@@ -229,6 +235,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>>;
@@ -371,6 +379,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>;
@@ -463,6 +473,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>;
@@ -477,6 +489,8 @@ export function GetGridScopeSettings():Promise<main.GridScopeSettings>;
 
 export function GetIcomState():Promise<cat.IcomTXState>;
 
+export function GetKenwoodState():Promise<cat.KenwoodTXState>;
+
 export function GetLinkedAmps():Promise<Array<string>>;
 
 export function GetListsSettings():Promise<main.ListsSettings>;
@@ -549,6 +563,8 @@ export function GetSolarData():Promise<solar.Data>;
 
 export function GetSpotColors():Promise<main.SpotColors>;
 
+export function GetSpotMax():Promise<number>;
+
 export function GetSpotTTLMinutes():Promise<number>;
 
 export function GetStartupStatus():Promise<main.StartupStatus>;
@@ -585,6 +601,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>>;
@@ -685,6 +703,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>;
@@ -885,6 +905,8 @@ export function RecomputeAwardRefsForCode(arg1:string):Promise<number>;
 
 export function RefreshCtyDat():Promise<main.CtyDatInfo>;
 
+export function RefreshKenwood():Promise<void>;
+
 export function RefreshSolar():Promise<void>;
 
 export function RefreshYaesuPanel():Promise<void>;
@@ -979,6 +1001,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>;
@@ -1081,8 +1105,40 @@ 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 SetKenwoodAFGain(arg1:number):Promise<void>;
+
+export function SetKenwoodAGC(arg1:string):Promise<void>;
+
+export function SetKenwoodAntenna(arg1:number):Promise<void>;
+
+export function SetKenwoodAtt(arg1:boolean):Promise<void>;
+
+export function SetKenwoodFilter(arg1:number):Promise<void>;
+
 export function SetKenwoodKeySpeed(arg1:number):Promise<void>;
 
+export function SetKenwoodMicGain(arg1:number):Promise<void>;
+
+export function SetKenwoodNB(arg1:boolean):Promise<void>;
+
+export function SetKenwoodNR(arg1:boolean):Promise<void>;
+
+export function SetKenwoodPower(arg1:number):Promise<void>;
+
+export function SetKenwoodPreamp(arg1:boolean):Promise<void>;
+
+export function SetKenwoodRFGain(arg1:number):Promise<void>;
+
+export function SetKenwoodRIT(arg1:boolean):Promise<void>;
+
+export function SetKenwoodSquelch(arg1:number):Promise<void>;
+
+export function SetKenwoodTX(arg1:boolean):Promise<void>;
+
+export function SetKenwoodXIT(arg1:boolean):Promise<void>;
+
 export function SetLinkedAmps(arg1:Array<string>):Promise<void>;
 
 export function SetMotorFollow(arg1:boolean,arg2:number,arg3:string):Promise<void>;
@@ -1095,6 +1151,8 @@ export function SetPassphrase(arg1:string):Promise<void>;
 
 export function SetScpEnabled(arg1:boolean):Promise<void>;
 
+export function SetSpotMax(arg1:number):Promise<void>;
+
 export function SetSpotTTLMinutes(arg1:number):Promise<void>;
 
 export function SetTelemetryEnabled(arg1:boolean):Promise<void>;
@@ -1111,6 +1169,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>;
@@ -1187,6 +1247,10 @@ export function TestUltrabeam(arg1:main.UltrabeamSettings):Promise<void>;
 
 export function TestWebPublishFTP(arg1:webpub.Config):Promise<string>;
 
+export function ToggleKenwoodATU():Promise<void>;
+
+export function TuneKenwoodATU():Promise<void>;
+
 export function TuneYaesuATU():Promise<void>;
 
 export function TunerGeniusActivate(arg1:number):Promise<void>;
@@ -1239,6 +1303,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,14 @@ export function CheckForUpdate() {
   return window['go']['main']['App']['CheckForUpdate']();
 }
 
+export function CheckHamlogKey(arg1) {
+  return window['go']['main']['App']['CheckHamlogKey'](arg1);
+}
+
+export function ClearKenwoodRIT() {
+  return window['go']['main']['App']['ClearKenwoodRIT']();
+}
+
 export function ClearLookupCache() {
   return window['go']['main']['App']['ClearLookupCache']();
 }
@@ -190,6 +198,10 @@ 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);
 }
@@ -398,6 +410,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']();
 }
@@ -682,6 +698,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']();
 }
@@ -866,6 +886,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']();
 }
@@ -894,6 +918,10 @@ export function GetIcomState() {
   return window['go']['main']['App']['GetIcomState']();
 }
 
+export function GetKenwoodState() {
+  return window['go']['main']['App']['GetKenwoodState']();
+}
+
 export function GetLinkedAmps() {
   return window['go']['main']['App']['GetLinkedAmps']();
 }
@@ -1038,6 +1066,10 @@ export function GetSpotColors() {
   return window['go']['main']['App']['GetSpotColors']();
 }
 
+export function GetSpotMax() {
+  return window['go']['main']['App']['GetSpotMax']();
+}
+
 export function GetSpotTTLMinutes() {
   return window['go']['main']['App']['GetSpotTTLMinutes']();
 }
@@ -1110,6 +1142,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']();
 }
@@ -1310,6 +1346,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']();
 }
@@ -1710,6 +1750,10 @@ export function RefreshCtyDat() {
   return window['go']['main']['App']['RefreshCtyDat']();
 }
 
+export function RefreshKenwood() {
+  return window['go']['main']['App']['RefreshKenwood']();
+}
+
 export function RefreshSolar() {
   return window['go']['main']['App']['RefreshSolar']();
 }
@@ -1898,6 +1942,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);
 }
@@ -2102,10 +2150,74 @@ 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 SetKenwoodAFGain(arg1) {
+  return window['go']['main']['App']['SetKenwoodAFGain'](arg1);
+}
+
+export function SetKenwoodAGC(arg1) {
+  return window['go']['main']['App']['SetKenwoodAGC'](arg1);
+}
+
+export function SetKenwoodAntenna(arg1) {
+  return window['go']['main']['App']['SetKenwoodAntenna'](arg1);
+}
+
+export function SetKenwoodAtt(arg1) {
+  return window['go']['main']['App']['SetKenwoodAtt'](arg1);
+}
+
+export function SetKenwoodFilter(arg1) {
+  return window['go']['main']['App']['SetKenwoodFilter'](arg1);
+}
+
 export function SetKenwoodKeySpeed(arg1) {
   return window['go']['main']['App']['SetKenwoodKeySpeed'](arg1);
 }
 
+export function SetKenwoodMicGain(arg1) {
+  return window['go']['main']['App']['SetKenwoodMicGain'](arg1);
+}
+
+export function SetKenwoodNB(arg1) {
+  return window['go']['main']['App']['SetKenwoodNB'](arg1);
+}
+
+export function SetKenwoodNR(arg1) {
+  return window['go']['main']['App']['SetKenwoodNR'](arg1);
+}
+
+export function SetKenwoodPower(arg1) {
+  return window['go']['main']['App']['SetKenwoodPower'](arg1);
+}
+
+export function SetKenwoodPreamp(arg1) {
+  return window['go']['main']['App']['SetKenwoodPreamp'](arg1);
+}
+
+export function SetKenwoodRFGain(arg1) {
+  return window['go']['main']['App']['SetKenwoodRFGain'](arg1);
+}
+
+export function SetKenwoodRIT(arg1) {
+  return window['go']['main']['App']['SetKenwoodRIT'](arg1);
+}
+
+export function SetKenwoodSquelch(arg1) {
+  return window['go']['main']['App']['SetKenwoodSquelch'](arg1);
+}
+
+export function SetKenwoodTX(arg1) {
+  return window['go']['main']['App']['SetKenwoodTX'](arg1);
+}
+
+export function SetKenwoodXIT(arg1) {
+  return window['go']['main']['App']['SetKenwoodXIT'](arg1);
+}
+
 export function SetLinkedAmps(arg1) {
   return window['go']['main']['App']['SetLinkedAmps'](arg1);
 }
@@ -2130,6 +2242,10 @@ export function SetScpEnabled(arg1) {
   return window['go']['main']['App']['SetScpEnabled'](arg1);
 }
 
+export function SetSpotMax(arg1) {
+  return window['go']['main']['App']['SetSpotMax'](arg1);
+}
+
 export function SetSpotTTLMinutes(arg1) {
   return window['go']['main']['App']['SetSpotTTLMinutes'](arg1);
 }
@@ -2162,6 +2278,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);
 }
@@ -2314,6 +2434,14 @@ export function TestWebPublishFTP(arg1) {
   return window['go']['main']['App']['TestWebPublishFTP'](arg1);
 }
 
+export function ToggleKenwoodATU() {
+  return window['go']['main']['App']['ToggleKenwoodATU']();
+}
+
+export function TuneKenwoodATU() {
+  return window['go']['main']['App']['TuneKenwoodATU']();
+}
+
 export function TuneYaesuATU() {
   return window['go']['main']['App']['TuneYaesuATU']();
 }
@@ -2418,6 +2546,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

@@ -1067,6 +1067,72 @@ export namespace cat {
 	        this.anti_vox = source["anti_vox"];
 	    }
 	}
+	export class KenwoodTXState {
+	    available: boolean;
+	    model?: string;
+	    elecraft: boolean;
+	    mode?: string;
+	    transmitting: boolean;
+	    split: boolean;
+	    split_tx_hz: number;
+	    s_meter: number;
+	    s_meter_raw: number;
+	    power_meter: number;
+	    swr: number;
+	    swr_raw: number;
+	    rf_power: number;
+	    af_gain: number;
+	    rf_gain: number;
+	    mic_gain: number;
+	    squelch: number;
+	    preamp: boolean;
+	    att: boolean;
+	    nb: boolean;
+	    nr: boolean;
+	    agc?: string;
+	    filter_hz: number;
+	    antenna: number;
+	    rit: boolean;
+	    xit: boolean;
+	    key_speed: number;
+	    meters_provisional: boolean;
+	
+	    static createFrom(source: any = {}) {
+	        return new KenwoodTXState(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.available = source["available"];
+	        this.model = source["model"];
+	        this.elecraft = source["elecraft"];
+	        this.mode = source["mode"];
+	        this.transmitting = source["transmitting"];
+	        this.split = source["split"];
+	        this.split_tx_hz = source["split_tx_hz"];
+	        this.s_meter = source["s_meter"];
+	        this.s_meter_raw = source["s_meter_raw"];
+	        this.power_meter = source["power_meter"];
+	        this.swr = source["swr"];
+	        this.swr_raw = source["swr_raw"];
+	        this.rf_power = source["rf_power"];
+	        this.af_gain = source["af_gain"];
+	        this.rf_gain = source["rf_gain"];
+	        this.mic_gain = source["mic_gain"];
+	        this.squelch = source["squelch"];
+	        this.preamp = source["preamp"];
+	        this.att = source["att"];
+	        this.nb = source["nb"];
+	        this.nr = source["nr"];
+	        this.agc = source["agc"];
+	        this.filter_hz = source["filter_hz"];
+	        this.antenna = source["antenna"];
+	        this.rit = source["rit"];
+	        this.xit = source["xit"];
+	        this.key_speed = source["key_speed"];
+	        this.meters_provisional = source["meters_provisional"];
+	    }
+	}
 	export class RigState {
 	    enabled: boolean;
 	    connected: boolean;
@@ -1154,12 +1220,15 @@ export namespace cat {
 	    power_meter: number;
 	    swr_meter: number;
 	    rf_power: number;
+	    max_power: number;
+	    narrow_supported: boolean;
 	    mic_gain: number;
 	    af_gain: number;
 	    rf_gain: number;
 	    squelch: number;
 	    agc?: string;
 	    preamp: number;
+	    antenna: number;
 	    att: number;
 	    nb: boolean;
 	    nr: boolean;
@@ -1188,12 +1257,15 @@ export namespace cat {
 	        this.power_meter = source["power_meter"];
 	        this.swr_meter = source["swr_meter"];
 	        this.rf_power = source["rf_power"];
+	        this.max_power = source["max_power"];
+	        this.narrow_supported = source["narrow_supported"];
 	        this.mic_gain = source["mic_gain"];
 	        this.af_gain = source["af_gain"];
 	        this.rf_gain = source["rf_gain"];
 	        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 +1439,7 @@ export namespace extsvc {
 	    hrdlog: ServiceConfig;
 	    eqsl: ServiceConfig;
 	    cloudlog: ServiceConfig;
+	    hamlog: ServiceConfig;
 	    delete_remote: boolean;
 	
 	    static createFrom(source: any = {}) {
@@ -1381,6 +1454,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"];
 	    }
 	
@@ -2533,6 +2607,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;
@@ -2695,6 +2787,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;
@@ -3028,6 +3142,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);
@@ -3045,6 +3161,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 {
@@ -3221,6 +3339,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;

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/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
@@ -988,6 +990,30 @@ type KenwoodController interface {
 	SetKeySpeed(int) error
 }
 
+// KenwoodState returns the K3/K4 panel snapshot, or (zero, false) when the
+// active backend is not a Kenwood-dialect rig.
+func (m *Manager) KenwoodState() (KenwoodTXState, bool) {
+	m.mu.RLock()
+	b := m.backend
+	m.mu.RUnlock()
+	if kc, ok := b.(KenwoodPanelController); ok {
+		return kc.KenwoodState(), true
+	}
+	return KenwoodTXState{}, false
+}
+
+// KenwoodPanelDo dispatches a K3/K4 panel control onto the CAT goroutine, so a
+// panel click and the poll loop never share the serial port at the same instant.
+func (m *Manager) KenwoodPanelDo(fn func(KenwoodPanelController) error) error {
+	return m.exec(func(b Backend) error {
+		kc, ok := b.(KenwoodPanelController)
+		if !ok {
+			return fmt.Errorf("active CAT backend is not a Kenwood/Elecraft")
+		}
+		return fn(kc)
+	})
+}
+
 // KenwoodDo dispatches a Kenwood control onto the CAT goroutine.
 func (m *Manager) KenwoodDo(fn func(KenwoodController) error) error {
 	return m.exec(func(b Backend) 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
@@ -92,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.
@@ -278,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 {
+	// Always subscribed, even when OpsLog draws no spots of its own: the feed is
-		// Subscribe so the radio pushes existing spots (we learn their indices),
+	// read-only and it is how the spots posted by OTHER programs arrive — a CW
-		// then wipe the panadapter so stale spots from a previous session or
+	// skimmer's decoded reports, which the split chaser acts on. Tying the
-		// another logger are cleared before we start adding our own.
+	// 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
@@ -883,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)
 		}
@@ -1377,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.

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
 	}

internal/cat/kenwood.go

@@ -92,6 +92,16 @@ type Kenwood struct {
 	// Commands this rig answered "?;" to — asked once, then never again.
 	unsupported map[string]bool
 
+	// Panel state — the K3/K4 control panel, see kenwood_panel.go. Read on the
+	// same serialised link as everything else, on a slow beat for the settings
+	// and every poll for the meters.
+	panel        KenwoodTXState
+	panelCycle   int
+	panelLoaded  bool
+	metersLogged int
+	powerPeak    meterPeak
+	swrPeak      meterPeak
+
 	// rx holds bytes read but not yet consumed, ACROSS calls to ask.
 	//
 	// It has to survive: a rig answers faster than we ask, so one Read often
@@ -210,7 +220,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
@@ -422,6 +432,10 @@ func (k *Kenwood) ReadState() (RigState, error) {
 		k.curRXFreq = s.RxFreqHz
 	}
 	k.lastState = s // cache for the transmit window, where we can't poll
+	// The panel rides on the same poll and the same held mutex: its own reader
+	// would have to take turns on the serial port, and the K3 is slow enough
+	// that two readers taking turns is what makes a dial lag.
+	k.readPanel(s.Mode, s.Split, s.FreqHz)
 	return s, nil
 }
 

internal/cat/kenwood_panel.go

@@ -0,0 +1,554 @@
+package cat
+
+// Elecraft K3/K4 control panel — power, volume, S-meter, SWR, MOX and ATU tune.
+//
+// Built on the Kenwood-dialect backend, because a K3 speaks it: plain ASCII,
+// every command terminated by ';'. What is Elecraft-specific is the vocabulary
+// below, taken from the K3 Programmer's Reference; the K4 accepts the same set.
+//
+// NO K3 WAS AVAILABLE WHILE WRITING THIS, and that shapes it:
+//
+//   - The commands that SET something are the ones the reference documents
+//     unambiguously and whose effect is visible and reversible (PC, AG, TX/RX).
+//   - The meters are the opposite: their scaling differs between models and
+//     firmware, and a wrongly scaled SWR bar is worse than none — it reports a
+//     good match on a bad antenna. So the raw answers are LOGGED, for a real
+//     radio to settle, and until then the panel says the scaling is provisional.
+//
+// The same discipline as the Yaesu meters, which were guessed wrong twice and
+// only settled when an FTDX10 keyed a carrier at two known power levels.
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// KenwoodTXState is what the panel shows.
+type KenwoodTXState struct {
+	Available bool   `json:"available"`
+	Model     string `json:"model,omitempty"`
+	Elecraft  bool   `json:"elecraft"` // a K3/K4 rather than a Kenwood
+	Mode      string `json:"mode,omitempty"`
+
+	Transmitting bool  `json:"transmitting"`
+	Split        bool  `json:"split"`
+	SplitTXHz    int64 `json:"split_tx_hz"`
+
+	// SMeter is 0-100 for the bar. SMeterRaw is what the rig actually answered,
+	// kept because the scaling is not yet confirmed on a real K3 and a number
+	// nobody can check is worth less than the reading it came from.
+	SMeter    int `json:"s_meter"`
+	SMeterRaw int `json:"s_meter_raw"`
+	// PowerMeter is 0-100 while transmitting. SWR is the ratio; 0 means "not
+	// measured", NOT a perfect match.
+	PowerMeter int     `json:"power_meter"`
+	SWR        float64 `json:"swr"`
+	SWRRaw     int     `json:"swr_raw"`
+
+	RFPower int `json:"rf_power"` // watts, the PC setting
+	AFGain  int `json:"af_gain"`  // 0-100
+	RFGain  int `json:"rf_gain"`  // 0-100
+	MicGain int `json:"mic_gain"` // 0-100
+	Squelch int `json:"squelch"`  // 0-100
+
+	// Receive controls. Preamp and attenuator are the K3's single-step ones
+	// (PA/RA); a rig that answers neither leaves them false and the row shows
+	// the state it read, not a state it assumed.
+	Preamp bool   `json:"preamp"`
+	Att    bool   `json:"att"`
+	NB     bool   `json:"nb"`
+	NR     bool   `json:"nr"`
+	AGC    string `json:"agc,omitempty"` // "OFF", "SLOW", "FAST"
+	// FilterHz is the DSP bandwidth in Hz (the K3 reports it in 10 Hz units).
+	FilterHz int `json:"filter_hz"`
+	// Antenna is 1 or 2 on a K3 with the internal ATU, 0 when the rig does not
+	// answer AN — which is also how the panel knows to hide the row rather than
+	// offer a switch that goes nowhere.
+	Antenna int `json:"antenna"`
+
+	RIT      bool `json:"rit"`
+	XIT      bool `json:"xit"`
+	KeySpeed int  `json:"key_speed"` // WPM
+
+	// MetersProvisional says the meter scaling has not been confirmed against a
+	// real radio. The panel says so rather than presenting a guess as a
+	// measurement.
+	MetersProvisional bool `json:"meters_provisional"`
+}
+
+// KenwoodPanelController is the K3/K4 panel capability. Separate from
+// KenwoodController (the CW keyer) so a backend can offer one without the other.
+type KenwoodPanelController interface {
+	KenwoodState() KenwoodTXState
+	RefreshKenwood() error
+	SetKenwoodPower(int) error
+	SetKenwoodAFGain(int) error
+	SetKenwoodRFGain(int) error
+	SetKenwoodMicGain(int) error
+	SetKenwoodSquelch(int) error
+	SetKenwoodPreamp(bool) error
+	SetKenwoodAtt(bool) error
+	SetKenwoodNB(bool) error
+	SetKenwoodNR(bool) error
+	SetKenwoodAGC(string) error
+	SetKenwoodFilter(int) error
+	SetKenwoodAntenna(int) error
+	SetKenwoodRIT(bool) error
+	SetKenwoodXIT(bool) error
+	ClearKenwoodRIT() error
+	SetKenwoodTX(bool) error
+	TuneKenwoodATU() error
+	ToggleKenwoodATU() error
+}
+
+// kenwoodPanelSlowBeat is how many polls pass between full re-reads of the
+// settings. The meters are read every poll; a power setting is not.
+const kenwoodPanelSlowBeat = 8
+
+// KenwoodState returns the panel snapshot.
+func (k *Kenwood) KenwoodState() KenwoodTXState {
+	k.mu.Lock()
+	defer k.mu.Unlock()
+	st := k.panel
+	st.Available = k.port != nil
+	st.Model = k.model
+	st.Elecraft = k.elecraft
+	return st
+}
+
+// RefreshKenwood forces the settings to be re-read on the next poll, so a value
+// changed on the radio's own front panel shows up at once.
+func (k *Kenwood) RefreshKenwood() error {
+	k.mu.Lock()
+	k.panelCycle = kenwoodPanelSlowBeat
+	k.mu.Unlock()
+	return nil
+}
+
+// readPanel refreshes the panel. Called from ReadState with the mutex HELD, so
+// it shares the same serialised link as everything else.
+func (k *Kenwood) readPanel(mode string, split bool, txHz int64) {
+	k.panel.Mode = mode
+	k.panel.Split = split
+	k.panel.SplitTXHz = 0
+	if split {
+		k.panel.SplitTXHz = txHz
+	}
+	k.panel.Transmitting = k.tx
+	k.panel.MetersProvisional = true
+
+	if k.panel.Transmitting {
+		k.readTXMeters()
+	} else {
+		// Cleared, not frozen: a power bar left standing after the carrier drops
+		// reads as a live transmission.
+		k.panel.PowerMeter = 0
+		k.panel.SWR, k.panel.SWRRaw = 0, 0
+		k.powerPeak, k.swrPeak = meterPeak{}, meterPeak{}
+		// The S-meter only means anything while receiving.
+		if v, ok := k.askNum("SM;", "SM", 4); ok {
+			k.panel.SMeterRaw = v
+			k.panel.SMeter = kenwoodSMeterPercent(v)
+		}
+	}
+
+	k.panelCycle++
+	if k.panelLoaded && k.panelCycle < kenwoodPanelSlowBeat {
+		return
+	}
+	k.panelCycle = 0
+	k.panelLoaded = true
+	k.readPanelSettings()
+}
+
+// readPanelSettings re-reads what a knob can change.
+func (k *Kenwood) readPanelSettings() {
+	// PC is watts on both the K3 and the Kenwoods — a setting, not a scale.
+	if v, ok := k.askNum("PC;", "PC", 3); ok {
+		k.panel.RFPower = v
+	}
+	// AF gain. The K3 answers three digits 000-255; a Kenwood answers AG0nnn,
+	// which is why the plain form is tried first and the addressed one after.
+	if v, ok := k.askNum("AG;", "AG", 3); ok {
+		k.panel.AFGain = scale255(v)
+	} else if v, ok := k.askNum("AG0;", "AG0", 3); ok {
+		k.panel.AFGain = scale255(v)
+	}
+	// RF gain. The K3 counts 000-250 in dB of reduction; a Kenwood uses the
+	// familiar 0-255. Both are shown as a percentage, so the slider means the
+	// same thing on either radio.
+	if v, ok := k.askNum("RG;", "RG", 3); ok {
+		k.panel.RFGain = scalePercent(v, k.rfGainFull())
+	}
+	if v, ok := k.askNum("MG;", "MG", 3); ok {
+		k.panel.MicGain = scalePercent(v, k.micGainFull())
+	}
+	if v, ok := k.askNum("SQ;", "SQ", 3); ok {
+		k.panel.Squelch = scalePercent(v, k.squelchFull())
+	} else if v, ok := k.askNum("SQ0;", "SQ0", 3); ok {
+		k.panel.Squelch = scale255(v)
+	}
+	if v, ok := k.askNum("PA;", "PA", 1); ok {
+		k.panel.Preamp = v != 0
+	}
+	if v, ok := k.askNum("RA;", "RA", 2); ok {
+		k.panel.Att = v != 0
+	}
+	if v, ok := k.askNum("NB;", "NB", 1); ok {
+		k.panel.NB = v != 0
+	}
+	if v, ok := k.askNum("NR;", "NR", 1); ok {
+		k.panel.NR = v != 0
+	}
+	if v, ok := k.askNum("GT;", "GT", 3); ok {
+		k.panel.AGC = kenwoodAGCName(v)
+	}
+	// Filter width. The K3 answers BW in 10 Hz units (BW0270 = 2.7 kHz); a
+	// Kenwood that does not implement it says nothing and the row stays as it
+	// was rather than showing a zero-width filter.
+	if v, ok := k.askNum("BW;", "BW", 4); ok && v > 0 {
+		k.panel.FilterHz = v * 10
+	}
+	// Antenna. Only a K3 with the internal ATU answers; 0 means "this radio has
+	// no antenna switching", which is what hides the row.
+	if v, ok := k.askNum("AN;", "AN", 1); ok {
+		k.panel.Antenna = v
+	}
+	if v, ok := k.askNum("RT;", "RT", 1); ok {
+		k.panel.RIT = v != 0
+	}
+	if v, ok := k.askNum("XT;", "XT", 1); ok {
+		k.panel.XIT = v != 0
+	}
+	if v, ok := k.askNum("KS;", "KS", 3); ok {
+		k.panel.KeySpeed = v
+	}
+}
+
+// The full-scale value of the analogue controls differs between an Elecraft and
+// a Kenwood, and using one rig's scale on the other silently halves or doubles
+// every setting. Kept as three small functions rather than a table so each one
+// carries the range it comes from.
+func (k *Kenwood) rfGainFull() int {
+	if k.elecraft {
+		return 250 // K3: 000-250, dB of reduction
+	}
+	return 255
+}
+
+func (k *Kenwood) micGainFull() int {
+	if k.elecraft {
+		return 60 // K3: 000-060
+	}
+	return 255
+}
+
+func (k *Kenwood) squelchFull() int {
+	if k.elecraft {
+		return 29 // K3: 000-029
+	}
+	return 255
+}
+
+// scalePercent turns a raw value into 0-100 against its own full scale.
+func scalePercent(v, full int) int {
+	if full <= 0 || v <= 0 {
+		return 0
+	}
+	if v >= full {
+		return 100
+	}
+	return v * 100 / full
+}
+
+// kenwoodAGCName decodes GT. The K3 answers 000 (off), 002 (slow) or 004
+// (fast); a Kenwood uses the same three values for the same three states.
+func kenwoodAGCName(v int) string {
+	switch {
+	case v == 0:
+		return "OFF"
+	case v <= 2:
+		return "SLOW"
+	default:
+		return "FAST"
+	}
+}
+
+// kenwoodAGCValue is the inverse, for the buttons.
+func kenwoodAGCValue(name string) int {
+	switch strings.ToUpper(strings.TrimSpace(name)) {
+	case "OFF":
+		return 0
+	case "SLOW":
+		return 2
+	default:
+		return 4
+	}
+}
+
+// kenwoodMeterProbes are the candidate meter commands, asked once per
+// transmission burst so a real radio can settle what they mean.
+//
+// They are NOT interchangeable — BG is a bargraph position, SM during transmit
+// is something else again — which is exactly why the log records which one
+// answered and what it said, next to the power SETTING: the meter that tracks a
+// known carrier at two different power levels is the power meter, and no amount
+// of reading the reference settles that as well as one transmission does.
+var kenwoodMeterProbes = []struct {
+	cmd    string
+	prefix string
+	digits int
+}{
+	{"SM;", "SM", 4},
+	{"BG;", "BG", 2},
+	{"SW;", "SW", 4},
+	{"PO;", "PO", 3},
+}
+
+// readTXMeters reads the transmit meters.
+func (k *Kenwood) readTXMeters() {
+	now := time.Now()
+	if v, ok := k.askNum("BG;", "BG", 2); ok {
+		k.panel.PowerMeter = k.powerPeak.update(kenwoodBargraphPercent(v), now)
+	}
+	if v, ok := k.askNum("SW;", "SW", 4); ok {
+		k.panel.SWRRaw = v
+		// Tenths of a ratio, provisionally: 15 → 1.5. Reported as raw as well,
+		// so the log can correct this without anyone having to trust the bar.
+		if v > 0 {
+			k.panel.SWR = float64(k.swrPeak.update(v, now)) / 10
+		}
+	}
+	if k.metersLogged >= 20 {
+		return
+	}
+	k.metersLogged++
+	raw := make([]string, 0, len(kenwoodMeterProbes))
+	for _, p := range kenwoodMeterProbes {
+		if v, ok := k.askNum(p.cmd, p.prefix, p.digits); ok {
+			raw = append(raw, fmt.Sprintf("%s=%d", strings.TrimSuffix(p.cmd, ";"), v))
+		} else {
+			raw = append(raw, strings.TrimSuffix(p.cmd, ";")+"=-")
+		}
+	}
+	debugLog.Printf("kenwood: TX meters at PC=%dW: %s (compare two power settings, and a known SWR)",
+		k.panel.RFPower, strings.Join(raw, " "))
+}
+
+// kenwoodSMeterPercent turns the S-meter answer into a bar percentage.
+//
+// The K3 reports 0-21 across S0…S9+60, which is not a linear dB scale but is
+// what its own display shows — and matching the radio's own bar is something an
+// operator can check at a glance. A Kenwood answers 0-30 on the same command;
+// both are covered by clamping rather than by guessing which rig is on the
+// other end.
+func kenwoodSMeterPercent(v int) int {
+	switch {
+	case v <= 0:
+		return 0
+	case v >= 30:
+		return 100
+	}
+	return v * 100 / 21
+}
+
+// kenwoodBargraphPercent scales the K3 bargraph (0-12 segments) to the bar.
+func kenwoodBargraphPercent(v int) int {
+	switch {
+	case v <= 0:
+		return 0
+	case v >= 12:
+		return 100
+	}
+	return v * 100 / 12
+}
+
+// SetKenwoodPower sets the transmit power, in watts.
+//
+// A K3 takes PC000-110: 110 rather than 100 because the radio will make a
+// little over its rated output and the reference says so. A Kenwood of the
+// TS-890 sort goes to 200, so the ceiling follows the radio rather than being
+// one number that is wrong for one of them.
+func (k *Kenwood) SetKenwoodPower(w int) error {
+	max := 200
+	if k.elecraft {
+		max = 110
+	}
+	if w < 0 {
+		w = 0
+	}
+	if w > max {
+		w = max
+	}
+	return k.setPanel(fmt.Sprintf("PC%03d;", w))
+}
+
+// SetKenwoodAFGain sets the volume, 0-100, scaled to the rig's 0-255.
+func (k *Kenwood) SetKenwoodAFGain(p int) error {
+	if p < 0 {
+		p = 0
+	}
+	if p > 100 {
+		p = 100
+	}
+	return k.setPanel(fmt.Sprintf("AG%03d;", p*255/100))
+}
+
+// SetKenwoodRFGain sets the RF gain, 0-100 of the rig's own scale.
+func (k *Kenwood) SetKenwoodRFGain(p int) error {
+	return k.setPanel(fmt.Sprintf("RG%03d;", clampPercentTo(p, k.rfGainFull())))
+}
+
+func (k *Kenwood) SetKenwoodMicGain(p int) error {
+	return k.setPanel(fmt.Sprintf("MG%03d;", clampPercentTo(p, k.micGainFull())))
+}
+
+func (k *Kenwood) SetKenwoodSquelch(p int) error {
+	return k.setPanel(fmt.Sprintf("SQ%03d;", clampPercentTo(p, k.squelchFull())))
+}
+
+func (k *Kenwood) SetKenwoodPreamp(on bool) error {
+	return k.setPanel(fmt.Sprintf("PA%d;", boolDigit(on)))
+}
+
+// SetKenwoodAtt switches the attenuator. Two digits: the K3 reads RA01 as its
+// single 10 dB pad, and a Kenwood with several steps takes the first one.
+func (k *Kenwood) SetKenwoodAtt(on bool) error {
+	if on {
+		return k.setPanel("RA01;")
+	}
+	return k.setPanel("RA00;")
+}
+
+func (k *Kenwood) SetKenwoodNB(on bool) error {
+	return k.setPanel(fmt.Sprintf("NB%d;", boolDigit(on)))
+}
+
+func (k *Kenwood) SetKenwoodNR(on bool) error {
+	return k.setPanel(fmt.Sprintf("NR%d;", boolDigit(on)))
+}
+
+func (k *Kenwood) SetKenwoodAGC(name string) error {
+	return k.setPanel(fmt.Sprintf("GT%03d;", kenwoodAGCValue(name)))
+}
+
+// SetKenwoodFilter sets the DSP bandwidth in Hz — sent in the K3's 10 Hz units.
+func (k *Kenwood) SetKenwoodFilter(hz int) error {
+	if hz < 50 {
+		hz = 50
+	}
+	if hz > 4000 {
+		hz = 4000
+	}
+	return k.setPanel(fmt.Sprintf("BW%04d;", hz/10))
+}
+
+// SetKenwoodAntenna selects antenna 1 or 2 (a K3 with the internal ATU).
+func (k *Kenwood) SetKenwoodAntenna(n int) error {
+	if n < 1 {
+		n = 1
+	}
+	if n > 2 {
+		n = 2
+	}
+	return k.setPanel(fmt.Sprintf("AN%d;", n))
+}
+
+func (k *Kenwood) SetKenwoodRIT(on bool) error {
+	return k.setPanel(fmt.Sprintf("RT%d;", boolDigit(on)))
+}
+
+func (k *Kenwood) SetKenwoodXIT(on bool) error {
+	return k.setPanel(fmt.Sprintf("XT%d;", boolDigit(on)))
+}
+
+// ClearKenwoodRIT zeroes the RIT/XIT offset, both at once — which is what RC
+// does and what the operator means by "clear it".
+func (k *Kenwood) ClearKenwoodRIT() error {
+	return k.setPanel("RC;")
+}
+
+// clampPercentTo maps 0-100 onto a rig's own full scale.
+func clampPercentTo(p, full int) int {
+	if p < 0 {
+		p = 0
+	}
+	if p > 100 {
+		p = 100
+	}
+	return p * full / 100
+}
+
+// SetKenwoodTX keys or unkeys the transmitter — the panel's MOX.
+//
+// Goes through SetPTT rather than writing TX;/RX; here, so the backend's own
+// idea of transmitting stays true: it suppresses polling while the carrier is
+// up, and a panel that keyed behind its back would leave it polling a rig that
+// answers "?;" to everything.
+func (k *Kenwood) SetKenwoodTX(on bool) error {
+	return k.SetPTT(on)
+}
+
+// The K3 has no dedicated "tune" command: the reference exposes the front panel
+// instead, through SWT (tap) and SWH (hold) with a switch number from Table 7.
+// Switch 19 is the ATU row — TAP starts a tuning cycle, HOLD puts the tuner in
+// or out of line.
+//
+// It was written as SWT20 first, from memory of the reference rather than from
+// the table, and 20 is not an ATU switch at all. Corrected against Table 7 of
+// the K3 Programmer's Reference, which an operator read out for us. Every send
+// is still logged: a switch-emulation command presses a real button on a real
+// front panel, so what OpsLog sent must be recoverable afterwards.
+const (
+	kenwoodATUTune   = "SWT19;" // tap ATU TUNE — start a tuning cycle
+	kenwoodATUToggle = "SWH19;" // hold ATU — tuner in line / bypassed
+)
+
+// TuneKenwoodATU starts an ATU tuning cycle.
+func (k *Kenwood) TuneKenwoodATU() error {
+	debugLog.Printf("kenwood: ATU tune — sending %q (K3 Table 7: tap of the ATU TUNE switch)", kenwoodATUTune)
+	return k.setPanel(kenwoodATUTune)
+}
+
+// ToggleKenwoodATU puts the tuner in line or bypasses it — the HOLD of the same
+// switch, which is how it is done on the radio itself.
+func (k *Kenwood) ToggleKenwoodATU() error {
+	debugLog.Printf("kenwood: ATU in/out — sending %q (K3 Table 7: hold of the ATU switch)", kenwoodATUToggle)
+	return k.setPanel(kenwoodATUToggle)
+}
+
+// setPanel writes one command and schedules a settings re-read, so the panel
+// shows what the radio did rather than what it was asked to do.
+func (k *Kenwood) setPanel(cmd string) error {
+	k.mu.Lock()
+	defer k.mu.Unlock()
+	if k.port == nil {
+		return fmt.Errorf("kenwood: not connected")
+	}
+	if err := k.write(cmd); err != nil {
+		return err
+	}
+	k.panelCycle = kenwoodPanelSlowBeat // re-read on the next poll
+	return nil
+}
+
+// askNum asks a command and parses its numeric body. ask() already remembers
+// what this rig answered "?;" to and refuses to ask it again, so an unsupported
+// meter costs one timeout for the life of the session, not one per poll.
+func (k *Kenwood) askNum(cmd, prefix string, digits int) (int, bool) {
+	r, err := k.ask(cmd)
+	if err != nil {
+		return 0, false
+	}
+	body := strings.TrimSuffix(strings.TrimPrefix(r, prefix), ";")
+	if len(body) < digits {
+		return 0, false
+	}
+	n, err := strconv.Atoi(strings.TrimSpace(body[:digits]))
+	if err != nil {
+		return 0, false
+	}
+	return n, true
+}

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

@@ -44,12 +44,24 @@ type YaesuTXState struct {
 	SWRMeter   int   `json:"swr_meter"`   // 0-100, TX only
 
 	RFPower int `json:"rf_power"` // watts
+	// MaxPower is what this model can actually be set to, so the slider stops
+	// where the radio does. An FTDX101MP is a 200 W transmitter and its operator
+	// could not ask for more than 100 W — the slider, not the rig, was the limit.
+	MaxPower int `json:"max_power"`
+	// NarrowSupported says the rig answered NA at all. A button that reports a
+	// state the radio never gave, and does nothing when pressed, is worse than
+	// an absent one: it looks like a fault in the radio.
+	NarrowSupported bool `json:"narrow_supported"`
 	MicGain int    `json:"mic_gain"` // 0-100
 	AFGain  int    `json:"af_gain"`  // 0-100
 	RFGain  int    `json:"rf_gain"`  // 0-100
 	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 +92,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
@@ -105,9 +118,29 @@ func (y *Yaesu) YaesuState() YaesuTXState {
 	st := y.panel
 	st.Available = y.port != nil
 	st.Model = y.model
+	st.MaxPower = yaesuMaxPower(y.model, st.RFPower)
 	return st
 }
 
+// yaesuMaxPower is how far the power slider may go on this model.
+//
+// The rig itself is never asked — there is no CAT command for "how much power
+// can you make" — so it comes from the model name, with one safeguard: a rig
+// REPORTING more than the table expects is believed, because it has just proved
+// what it can do. Anything unknown gets 100 W, which is the family default and
+// errs towards asking for too little.
+func yaesuMaxPower(model string, reported int) int {
+	max := 100
+	switch {
+	case strings.Contains(model, "101MP"), strings.Contains(model, "5000"), strings.Contains(model, "9000"):
+		max = 200
+	}
+	if reported > max {
+		max = reported
+	}
+	return max
+}
+
 // readPanel refreshes the meters, and the settings on the slower beat. Called
 // from ReadState with the mutex HELD, so it shares the same serialised link.
 func (y *Yaesu) readPanel(mode string, split bool, txHz int64) {
@@ -221,8 +254,15 @@ func (y *Yaesu) readPanelSettings() {
 	if v, ok := y.askNum("PC;", "PC", 3); ok {
 		y.panel.RFPower = v // watts, not a 0-255 scale
 	}
+	// MIC GAIN IS 0-100, not 0-255.
+	//
+	// It was read through the 0-255 scale like the audio gains, so an FTDX101
+	// set to 80 showed 38 — and worse, writing sent 80 → 204, outside the range
+	// the rig accepts, so the setting was refused and the slider sprang back to
+	// where it had been. Reported from a real FTDX101; the CAT reference gives
+	// MG000-100 for the whole current family.
 	if v, ok := y.askNum("MG;", "MG", 3); ok {
-		y.panel.MicGain = scale255(v)
+		y.panel.MicGain = clampInt(v, 0, 100)
 	}
 	if v, ok := y.askNum("AG0;", "AG0", 3); ok {
 		y.panel.AFGain = scale255(v)
@@ -239,6 +279,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)
 	}
@@ -253,6 +311,7 @@ func (y *Yaesu) readPanelSettings() {
 	}
 	if v, ok := y.askNum("NA0;", "NA0", 1); ok {
 		y.panel.Narrow = v != 0
+		y.panel.NarrowSupported = true
 	}
 	if v, ok := y.askNum("VX;", "VX", 1); ok {
 		y.panel.VOX = v != 0
@@ -333,7 +392,7 @@ func (y *Yaesu) SetYaesuPower(w int) error {
 }
 
 func (y *Yaesu) SetYaesuMicGain(p int) error {
-	return y.setAndRefresh(fmt.Sprintf("MG%03d;", from100(p)))
+	return y.setAndRefresh(fmt.Sprintf("MG%03d;", clampInt(p, 0, 100)))
 }
 
 func (y *Yaesu) SetYaesuAFGain(p int) error {
@@ -356,6 +415,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/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/lotw.go

@@ -265,6 +265,22 @@ func UploadLoTW(ctx context.Context, cfg ServiceConfig, tempDir, adifRecord stri
 	// callsign certificate's validity is silently left out, and reporting that as
 	// success stamped it sent for ever. TQSL says which case it is in its output,
 	// so the message is carried up rather than replaced with a guess.
+	if code != 0 && LogSink != nil {
+		// The ADIF that was handed to TQSL, verbatim, and how TQSL was called.
+		//
+		// TQSL says "no QSOs processed" for several unrelated reasons — already
+		// uploaded, outside the certificate's dates, or a STATION_CALLSIGN that
+		// does not match the station location it was told to sign with — and its
+		// message does not distinguish them. An operator whose contact was
+		// refused, then accepted after a round trip through another logger, is
+		// reporting a difference in THIS RECORD, and there is no way to see it
+		// afterwards: the temp file is deleted as soon as TQSL returns.
+		//
+		// Nothing secret here: it is a QSO, and the key password is not logged.
+		LogSink("lotw: tqsl exit %d for station location %q", code, loc)
+		LogSink("lotw: record was: %s", strings.TrimSpace(adifRecord))
+	}
+
 	switch code {
 	case 0:
 		return UploadResult{OK: true, Message: "uploaded to LoTW"}, nil

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

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

syncfolder.go

@@ -315,11 +315,11 @@ func (a *App) syncPublishDeletes(ids []int64) {
 	if store == nil {
 		return
 	}
-	for _, id := range ids {
+	// One read for the whole set: see deleteSnapshot. Tombstones are written
-		q, err := a.qso.GetByID(a.ctx, id)
+	// before the rows go, because a QSO that never had a sync identity has to be
-		if err != nil {
+	// given one here — after the DELETE there would be nothing left to stamp.
-			continue
+	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.7"
+	appVersion = "0.26.12"
 
 	// posthogHost is the PostHog ingestion endpoint. EU cloud by default; change
 	// to https://us.i.posthog.com for a US project.