chore: release v0.25.1

The K3NG entry added an hour ago is gone. It named one clone among many —
WKmini, home-built Arduinos, unbranded boxes — for hardware that speaks
exactly the same protocol, and it was the only line in the engine list that
picked a boot delay rather than a protocol. An operator with an unlabelled
clone would have had to guess.

The delay is now learnt per port. The first connect finds out by failing the
quick attempt and succeeding on the slow one; that fact is written to a
global setting keyed by the port, and every connect afterwards goes straight
to the slow attempt. Global rather than per profile on purpose: which keyer
is plugged into COM3 belongs to the computer, and switching profiles for a
different rig does not change the keyer on the desk.

Two tests hold the contract from both sides — a slow keyer must be reported
as slow, and a keyer that answers at once must not be, or every K1EL connect
would inherit seconds it never needed.

amps_linked_test.go

@@ -0,0 +1,63 @@
+package main
+
+import "testing"
+
+// The coupling is a SET, not a global switch.
+//
+// A station can run a combiner pair AND a third amplifier that has nothing to
+// do with it — two SPE on the combiner, a PowerGenius on another antenna. A
+// global flag would send that third one into OPERATE alongside them.
+func TestAmpTargetsFollowTheGroup(t *testing.T) {
+	a := &App{}
+	a.ampInsts = map[string]*ampInst{"spe1": {}, "spe2": {}, "pgxl": {}}
+	group := []string{"spe1", "spe2"}
+
+	// A member commands the whole group, itself first.
+	got := a.ampTargets("spe2", group)
+	if len(got) != 2 || got[0] != "spe2" || got[1] != "spe1" {
+		t.Errorf("member = %v, want [spe2 spe1] — the clicked one first", got)
+	}
+
+	// The amplifier OUTSIDE the group keeps its buttons to itself.
+	if got := a.ampTargets("pgxl", group); len(got) != 1 || got[0] != "pgxl" {
+		t.Errorf("outsider = %v, want just [pgxl]", got)
+	}
+
+	// No group at all: everyone is on their own.
+	if got := a.ampTargets("spe1", nil); len(got) != 1 || got[0] != "spe1" {
+		t.Errorf("no group = %v, want just [spe1]", got)
+	}
+
+	// A group remembering an amplifier that is gone must not carry it: it would
+	// fail the command for a member that no longer exists.
+	if got := a.ampTargets("spe1", []string{"spe1", "deleted"}); len(got) != 1 || got[0] != "spe1" {
+		t.Errorf("stale member = %v, want it dropped", got)
+	}
+}
+
+// One amplifier coupled to itself is not a group — storing it would make every
+// command fan out to a single member for ever, which is just noise.
+func TestLinkedAmpsNeedsTwo(t *testing.T) {
+	for _, tc := range []struct {
+		in   []string
+		want int
+	}{
+		{[]string{"a", "b"}, 2},
+		{[]string{"a"}, 0},
+		{[]string{"  ", "a"}, 0}, // blanks are not members
+		{nil, 0},
+	} {
+		clean := make([]string, 0, len(tc.in))
+		for _, id := range tc.in {
+			if id != "" && id != "  " {
+				clean = append(clean, id)
+			}
+		}
+		if len(clean) < 2 {
+			clean = nil
+		}
+		if len(clean) != tc.want {
+			t.Errorf("SetLinkedAmps(%v) would keep %d, want %d", tc.in, len(clean), tc.want)
+		}
+	}
+}

app.go

@@ -78,6 +78,7 @@ import (
 const (
 	keyQRZUser     = "lookup.qrz.user"
 	keyQRZPassword = "lookup.qrz.password"
+	keyQRZNickname = "lookup.qrz.prefer_nickname" // "1" → QRZ <nickname> over first+last name
 	keyHQUser      = "lookup.hamqth.user"
 	keyHQPassword  = "lookup.hamqth.password"
 	keyCacheTTL    = "lookup.cache.ttl_days"
@@ -232,11 +233,11 @@ const (
 	keyUltrabeamEnabled = "ultrabeam.enabled"
 	keyUltrabeamHost    = "ultrabeam.host"
 	keyUltrabeamPort    = "ultrabeam.port"
-	keyUltrabeamFollow  = "ultrabeam.follow"     // "1" → re-tune to the rig frequency
-	keyUltrabeamStep    = "ultrabeam.step_khz"   // re-tune hysteresis: 25 | 50 | 100 kHz
-	keyMotorTrackMode   = "motor.track_mode"     // "always" | "step" | "band"
-	keyMotorBandFreqs   = "motor.band_freqs"     // per-band tune frequency: "40m=7100,20m=14150"
-	keyChaseNewGrids    = "cluster.chase_grids"  // "1" → persist learnt locators across restarts
+	keyUltrabeamFollow  = "ultrabeam.follow"    // "1" → re-tune to the rig frequency
+	keyUltrabeamStep    = "ultrabeam.step_khz"  // re-tune hysteresis: 25 | 50 | 100 kHz
+	keyMotorTrackMode   = "motor.track_mode"    // "always" | "step" | "band"
+	keyMotorBandFreqs   = "motor.band_freqs"    // per-band tune frequency: "40m=7100,20m=14150"
+	keyChaseNewGrids    = "cluster.chase_grids" // "1" → persist learnt locators across restarts
 	keyRowColors        = "appearance.row_colors"
 	keyMotorType        = "ultrabeam.type"       // "ultrabeam" | "steppir" (default ultrabeam)
 	keyMotorTransport   = "ultrabeam.transport"  // "tcp" | "serial" (default tcp)
@@ -288,7 +289,7 @@ const (
 	keyWKUsePTT     = "winkeyer.use_ptt"
 	keyWKSerialEcho = "winkeyer.serial_echo"
 	keyWKMacros     = "winkeyer.macros"          // JSON array of {label,text}
-	keyWKEngine     = "winkeyer.engine"          // "winkeyer" | "serial" | "icom" | "flex" | "tci"
+	keyWKEngine     = "winkeyer.engine"          // "winkeyer" | "k3ng" | "serial" | "icom" | "flex" | "tci"
 	keyWKEscClears  = "winkeyer.esc_clears_call" // ESC also clears the callsign
 	keyWKSendOnType = "winkeyer.send_on_type"    // key characters live as typed
 	keyWKEsm        = "winkeyer.esm"             // Enter-Sends-Message (N1MM-style CW flow)
@@ -298,6 +299,7 @@ const (
 	keyClusterAutoConnect = "cluster.auto_connect"      // open every enabled server at app start
 	keyClusterSelfSpot    = "cluster.self_spot"         // "1" → announce ourselves on the cluster as we log
 	keyClusterSelfSpotMin = "cluster.self_spot_minutes" // shortest gap between two self-spots
+	keyClusterSpotTTL     = "cluster.spot_ttl_min"      // drop spots older than this; 0 = keep them
 
 	keyScpEnabled = "scp.enabled" // Super Check Partial / N+1 suggestions on
 
@@ -352,6 +354,7 @@ const (
 	keyExtHRDLogCode       = "extsvc.hrdlog.code" // HRDLog account upload code
 	keyExtHRDLogAutoUpload = "extsvc.hrdlog.auto_upload"
 	keyExtHRDLogUploadMode = "extsvc.hrdlog.upload_mode"
+	keyExtHRDLogOnAir      = "extsvc.hrdlog.on_air" // publish frequency/mode/rig live on hrdlog.net
 
 	keyExtEQSLUsername   = "extsvc.eqsl.username"
 	keyExtEQSLPassword   = "extsvc.eqsl.password"
@@ -563,7 +566,11 @@ type LookupSettings struct {
 	Primary        string `json:"primary"`
 	Failsafe       string `json:"failsafe"`
 	DownloadImages bool   `json:"download_images"` // show QRZ profile pictures in the UI
-	CacheTTLDays   int    `json:"cache_ttl_days"`
+	// QRZPreferNickname logs the name an operator goes BY rather than their
+	// registered first+last. QRZ only: HamQTH's <nick> already serves that role
+	// there, so the option would be a second switch for a behaviour it has.
+	QRZPreferNickname bool `json:"qrz_prefer_nickname"`
+	CacheTTLDays      int  `json:"cache_ttl_days"`
 }
 
 // App is the application context bound to the Wails runtime.
@@ -1319,6 +1326,7 @@ func (a *App) startup(ctx context.Context) {
 			}
 		},
 	)
+	a.winkeyer.OnSlowBoot(a.noteKeyerSlowBoot)
 
 	// Live space-weather (solar flux, sunspots, A/K indices) for the header strip
 	// and per-QSO stamping. Refreshes in the background; pushes a UI event on each
@@ -1399,8 +1407,9 @@ func (a *App) startup(ctx context.Context) {
 	// Anonymous usage heartbeat (once/day) so we can gauge active users. No-op
 	// when disabled in Preferences or until the PostHog key is configured.
 	go a.sendTelemetryHeartbeat()
-	go a.liveStatusLoop() // multi-op: heartbeat current activity to shared MySQL
-	go a.chatLoop()       // multi-op: poll the shared chat + heartbeat presence
+	go a.liveStatusLoop()  // multi-op: heartbeat current activity to shared MySQL
+	go a.chatLoop()        // multi-op: poll the shared chat + heartbeat presence
+	go a.hrdlogOnAirLoop() // publish frequency/mode/rig on hrdlog.net when enabled
 	// Locator store BEFORE the feed: the feed asks whether it exists to decide
 	// which bands to subscribe to.
 	a.startGridCache()
@@ -1696,6 +1705,13 @@ func copyDirContents(src, dst string) error {
 	if err != nil {
 		return err
 	}
+	// Create the destination BEFORE writing into it. Without this the first
+	// os.Create failed with ENOENT, which reads as "not exist" — indistinguishable
+	// from a source folder that simply has nothing to copy, and callers testing
+	// for that swallowed it.
+	if err := os.MkdirAll(dst, 0o755); err != nil {
+		return err
+	}
 	for _, e := range entries {
 		srcPath := filepath.Join(src, e.Name())
 		dstPath := filepath.Join(dst, e.Name())
@@ -2595,7 +2611,7 @@ func (a *App) reloadLookupProviders() {
 		return
 	}
 	m, err := a.settings.GetMany(a.ctx,
-		keyQRZUser, keyQRZPassword, keyHQUser, keyHQPassword,
+		keyQRZUser, keyQRZPassword, keyQRZNickname, keyHQUser, keyHQPassword,
 		keyCacheTTL, keyLookupPrimary, keyLookupFailsafe)
 	if err != nil {
 		fmt.Println("OpsLog: settings load error:", err)
@@ -2609,7 +2625,9 @@ func (a *App) reloadLookupProviders() {
 		switch name {
 		case "qrz":
 			if m[keyQRZUser] != "" && m[keyQRZPassword] != "" {
-				return lookup.NewQRZ(m[keyQRZUser], m[keyQRZPassword])
+				p := lookup.NewQRZ(m[keyQRZUser], m[keyQRZPassword])
+				p.PreferNickname = m[keyQRZNickname] == "1"
+				return p
 			}
 		case "hamqth":
 			if m[keyHQUser] != "" && m[keyHQPassword] != "" {
@@ -6213,8 +6231,12 @@ func (a *App) BulkUpdateQSL(ids []int64, u QSLBulkUpdate) (int, error) {
 		if v := strings.TrimSpace(u.RcvdDate); v != "" {
 			q.QSLRcvdDate, changed = v, true
 		}
-		if v := strings.TrimSpace(u.Via); v != "" {
-			q.QSLVia, changed = v, true
+		// The QSL Manager panel's "Via" is a routing method (bureau / direct /
+		// electronic), so it belongs in QSL_SENT_VIA, not in QSL_VIA — which
+		// holds the manager. It used to write the manager field, in full words,
+		// which is half of why the two got mixed up in operators' logs.
+		if v := adif.NormaliseQSLVia(u.Via); v != "" {
+			q.QSLSentVia, changed = v, true
 		}
 		if v := strings.TrimSpace(u.Notes); v != "" {
 			q.Notes, changed = v, true
@@ -6245,6 +6267,8 @@ var bulkFieldColumns = map[string]string{
 	"qsl_sent":     "qsl_sent",
 	"qsl_rcvd":     "qsl_rcvd",
 	"qsl_via":      "qsl_via",
+	"qsl_sent_via": "qsl_sent_via",
+	"qsl_rcvd_via": "qsl_rcvd_via",
 	"qrz_sent":     "qrzcom_qso_upload_status",
 	"qrz_rcvd":     "qrzcom_qso_download_status",
 	"clublog_sent": "clublog_qso_upload_status",
@@ -7197,7 +7221,7 @@ func (a *App) GetLookupSettings() (LookupSettings, error) {
 	}
 	m, err := a.settings.GetMany(a.ctx,
 		keyQRZUser, keyQRZPassword, keyHQUser, keyHQPassword,
-		keyCacheTTL, keyLookupPrimary, keyLookupFailsafe, keyLookupImages)
+		keyCacheTTL, keyLookupPrimary, keyLookupFailsafe, keyLookupImages, keyQRZNickname)
 	if err != nil {
 		return LookupSettings{}, err
 	}
@@ -7206,14 +7230,15 @@ func (a *App) GetLookupSettings() (LookupSettings, error) {
 		ttl = 30
 	}
 	return LookupSettings{
-		QRZUser:        m[keyQRZUser],
-		QRZPassword:    m[keyQRZPassword],
-		HamQTHUser:     m[keyHQUser],
-		HamQTHPassword: m[keyHQPassword],
-		Primary:        m[keyLookupPrimary],
-		Failsafe:       m[keyLookupFailsafe],
-		DownloadImages: m[keyLookupImages] == "1",
-		CacheTTLDays:   ttl,
+		QRZUser:           m[keyQRZUser],
+		QRZPassword:       m[keyQRZPassword],
+		HamQTHUser:        m[keyHQUser],
+		HamQTHPassword:    m[keyHQPassword],
+		Primary:           m[keyLookupPrimary],
+		Failsafe:          m[keyLookupFailsafe],
+		DownloadImages:    m[keyLookupImages] == "1",
+		QRZPreferNickname: m[keyQRZNickname] == "1",
+		CacheTTLDays:      ttl,
 	}, nil
 }
 
@@ -7239,6 +7264,7 @@ func (a *App) SaveLookupSettings(s LookupSettings) error {
 		keyLookupPrimary:  s.Primary,
 		keyLookupFailsafe: s.Failsafe,
 		keyLookupImages:   boolStr(s.DownloadImages),
+		keyQRZNickname:    boolStr(s.QRZPreferNickname),
 	} {
 		if err := a.settings.Set(a.ctx, k, v); err != nil {
 			return err
@@ -9902,7 +9928,7 @@ func (a *App) loadExternalServices() extsvc.ExternalServices {
 		keyExtLoTWUploadFlag, keyExtLoTWUploadFlags, keyExtLoTWWriteLog,
 		keyExtLoTWAutoUpload, keyExtLoTWUploadMode,
 		keyExtLoTWUsername, keyExtLoTWWebPassword,
-		keyExtHRDLogCallsign, keyExtHRDLogCode, keyExtHRDLogAutoUpload, keyExtHRDLogUploadMode,
+		keyExtHRDLogCallsign, keyExtHRDLogCode, keyExtHRDLogAutoUpload, keyExtHRDLogUploadMode, keyExtHRDLogOnAir,
 		keyExtEQSLUsername, keyExtEQSLPassword, keyExtEQSLQTHNick, keyExtEQSLAutoUpload, keyExtEQSLUploadMode,
 		keyExtCloudlogURL, keyExtCloudlogAPIKey, keyExtCloudlogStationID,
 		keyExtCloudlogAutoUpload, keyExtCloudlogUploadMode, keyExtDeleteRemote)
@@ -9956,6 +9982,7 @@ func (a *App) loadExternalServices() extsvc.ExternalServices {
 		Code:       m[keyExtHRDLogCode],
 		AutoUpload: m[keyExtHRDLogAutoUpload] == "1",
 		UploadMode: extsvc.UploadMode(m[keyExtHRDLogUploadMode]),
+		OnAir:      m[keyExtHRDLogOnAir] == "1",
 	}
 	// Default the HRDLog callsign to the active profile's call when unset.
 	if out.HRDLog.Callsign == "" && a.profiles != nil {
@@ -10085,6 +10112,7 @@ func (a *App) SaveExternalServices(cfg extsvc.ExternalServices) error {
 		keyExtHRDLogCode:       strings.TrimSpace(cfg.HRDLog.Code),
 		keyExtHRDLogAutoUpload: hlAuto,
 		keyExtHRDLogUploadMode: hlMode,
+		keyExtHRDLogOnAir:      boolStr(cfg.HRDLog.OnAir),
 
 		keyExtEQSLUsername:   strings.ToUpper(strings.TrimSpace(cfg.EQSL.Username)),
 		keyExtEQSLPassword:   cfg.EQSL.Password,
@@ -10227,6 +10255,16 @@ func (a *App) runManualUpload(svc extsvc.Service, ids []int64, cfg extsvc.Extern
 				uploaded++
 			}
 			emit(fmt.Sprintf("LoTW: %d QSO(s) uploaded", uploaded))
+			// TQSL accepted the batch but left contacts out of it — already
+			// uploaded, or outside the certificate's date range. Said out loud:
+			// the operator has no other way to learn that some of what they just
+			// selected is still not on LoTW.
+			if res.Ignored {
+				emit(res.Message)
+				if a.ctx != nil {
+					wruntime.EventsEmit(a.ctx, "toast", "LoTW: "+res.Message)
+				}
+			}
 		}
 	} else if svc == extsvc.ServiceClublog || svc == extsvc.ServiceHRDLog {
 		statusCol, dateCol := "clublog_qso_upload_status", "clublog_qso_upload_date"
@@ -10471,6 +10509,11 @@ func (a *App) applyULSCounty(q *qso.QSO) {
 type ULSStatusResult struct {
 	Count     int    `json:"count"`
 	UpdatedAt string `json:"updated_at"` // RFC3339, empty if never downloaded
+	// NeedsRefresh is set when the stored data predates a correction to how a
+	// callsign's county is derived. The download date alone cannot show this —
+	// a database fetched yesterday by an older OpsLog still holds the wrong
+	// Connecticut counties — so it is reported as its own flag.
+	NeedsRefresh bool `json:"needs_refresh"`
 }
 
 // ULSStatus returns the state of the offline US county database.
@@ -10482,7 +10525,7 @@ func (a *App) ULSStatus() ULSStatusResult {
 	if t := a.uls.UpdatedAt(); !t.IsZero() {
 		updated = t.Format(time.RFC3339)
 	}
-	return ULSStatusResult{Count: a.uls.Count(), UpdatedAt: updated}
+	return ULSStatusResult{Count: a.uls.Count(), UpdatedAt: updated, NeedsRefresh: a.uls.NeedsRefresh()}
 }
 
 // DownloadULSCounties downloads and (re)builds the offline US county database in
@@ -10515,6 +10558,84 @@ func (a *App) DownloadULSCounties() error {
 }
 
 // BackfillUSCountiesResult summarises a bulk county/grid backfill over the log.
+// ── QSL routing repair (QSL_VIA vs QSL_SENT_VIA) ───────────────────────
+
+// keyQSLViaRepairDone records that the operator has answered the offer to move
+// routing words out of the manager field — whether they accepted or declined.
+// Asked once per log, never again: a repair that keeps proposing itself after a
+// "no" is a nag, and the answer does not change.
+const keyQSLViaRepairDone = "migr.qsl_via_routing.v1"
+
+// QSLViaRepairStatus counts the QSOs whose QSL_VIA holds a routing method
+// rather than a manager, so the operator can be shown a number before anything
+// is touched.
+type QSLViaRepairStatus struct {
+	Affected int  `json:"affected"` // QSOs holding a routing word in qsl_via
+	Asked    bool `json:"asked"`    // the offer has already been answered
+}
+
+// QSLViaRepairStatus reports whether this log needs the QSL_VIA repair.
+//
+// OpsLog wrote "Bureau" / "Direct" / "Electronic" into QSL_VIA from its own QSL
+// Manager panel, and ADIF imports folded QSL_SENT_VIA there as well, so the
+// manager column in an existing log is a mixture of the two. Moving them is
+// safe — a manager is a callsign and can never be one of those words — but it
+// rewrites what an operator sees in their own log, so it is counted and offered
+// rather than done.
+func (a *App) QSLViaRepairStatus() (QSLViaRepairStatus, error) {
+	var res QSLViaRepairStatus
+	if a.qso == nil {
+		return res, fmt.Errorf("db not initialized")
+	}
+	if a.settings != nil {
+		if v, _ := a.settings.GetGlobal(a.ctx, keyQSLViaRepairDone); v == "1" {
+			res.Asked = true
+		}
+	}
+	n, err := a.qso.CountQSLViaRouting(a.ctx, adif.IsQSLViaRouting)
+	if err != nil {
+		return res, err
+	}
+	res.Affected = n
+	return res, nil
+}
+
+// QSLViaRepairResult reports what the repair moved.
+type QSLViaRepairResult struct {
+	Moved int `json:"moved"`
+}
+
+// RepairQSLVia moves routing words out of QSL_VIA into QSL_SENT_VIA.
+//
+// Only where QSL_SENT_VIA is still empty: a QSO that already carries a real
+// sent-via — from an import made after this was fixed — knows better than a
+// word left in the manager column, and must not be overwritten by it.
+func (a *App) RepairQSLVia() (QSLViaRepairResult, error) {
+	var res QSLViaRepairResult
+	if a.qso == nil {
+		return res, fmt.Errorf("db not initialized")
+	}
+	n, err := a.qso.RepairQSLViaRouting(a.ctx, adif.NormaliseQSLVia)
+	res.Moved = n
+	if err != nil {
+		return res, err
+	}
+	a.markQSLViaRepairAsked()
+	applog.Printf("qsl via repair: moved %d routing values out of the manager field", n)
+	return res, nil
+}
+
+// DismissQSLViaRepair records a "no" so the offer is not made again.
+func (a *App) DismissQSLViaRepair() {
+	a.markQSLViaRepairAsked()
+}
+
+func (a *App) markQSLViaRepairAsked() {
+	if a.settings != nil {
+		_ = a.settings.SetGlobal(a.ctx, keyQSLViaRepairDone, "1")
+	}
+}
+
 // keyDistanceBackfilled marks the one-time distance fill as done.
 //
 // A migration, not a setting. It was briefly a button in Preferences, which was
@@ -11870,6 +11991,21 @@ func (a *App) LogUDPLoggedADIF(adifText string) (int64, error) {
 		return 0, fmt.Errorf("record missing required fields (call/band/mode/date)")
 	}
 
+	// The grid the station SENT beats any directory.
+	//
+	// A CQ in FT8 carries the operator's square, and it is where they are right
+	// now. QRZ and HamQTH describe where they LIVE, which for an expedition is
+	// the wrong side of the planet: RI0FA transmitted QN35 all evening and was
+	// logged with its licence-holder's home square, because WSJT-X's ADIF carries
+	// no GRIDSQUARE and the lookup was the only source left.
+	//
+	// Applied BEFORE the lookup, so refineGrid below sees a grid it must not
+	// replace. It still upgrades a 4-character square to a 6-character one from
+	// the same field.
+	if g := a.lookupDecodeGrid(q.Callsign); g != "" {
+		q.Grid = refineGrid(q.Grid, g)
+	}
+
 	// ── Lookup-based enrichment ──
 	// WSJT sends only call/freq/mode/RST/date. Fill Name/QTH/Country/
 	// Grid/CQZ/ITUZ/DXCC/Continent via the lookup chain (QRZ/HamQTH/
@@ -12108,7 +12244,13 @@ func (a *App) consumeUDPEvents() {
 				})
 			}
 		case ev.LoggedADIF != "":
-			applog.Printf("udp: emit udp:logged_qso (%d bytes ADIF)\n", len(ev.LoggedADIF))
+			// The RECORD, not just its size. "Was the grid in what WSJT-X sent, or
+			// did OpsLog put it there?" is the first question asked when a contact
+			// is logged in the wrong square, and a byte count cannot answer it —
+			// an expedition logged at its licence holder's home QTH stayed
+			// undiagnosable for exactly that reason. One line per QSO, ~280 bytes.
+			applog.Printf("udp: emit udp:logged_qso (%d bytes) %s\n",
+				len(ev.LoggedADIF), strings.Join(strings.Fields(ev.LoggedADIF), " "))
 			wruntime.EventsEmit(a.ctx, "udp:logged_qso", map[string]any{
 				"config_id": ev.ConfigID,
 				"service":   string(ev.Service),
@@ -13965,10 +14107,7 @@ func (a *App) DuplicateProfile(id int64, newName string) (profile.Profile, error
 			applog.Printf("duplicate profile: copy operating: %v", err)
 		}
 	}
-	if _, err := a.db.ExecContext(a.ctx,
-		`INSERT INTO qsl_templates (name, profile_id, json, is_default, created_at, updated_at)
-		 SELECT name, ?, json, is_default, created_at, updated_at
-		 FROM qsl_templates WHERE profile_id = ?`, p.ID, id); err != nil {
+	if err := a.copyQSLTemplatesToProfile(id, p.ID); err != nil {
 		applog.Printf("duplicate profile: copy qsl templates: %v", err)
 	}
 	return p, nil
@@ -14790,14 +14929,14 @@ func (a steppirAdapter) Status() motorStatus {
 // is kept (bindings + frontend) though it now covers SteppIR too.
 type UltrabeamSettings struct {
 	Enabled   bool   `json:"enabled"`
-	Type      string `json:"type"`       // "ultrabeam" | "steppir"
-	Transport string `json:"transport"`  // "tcp" | "serial"
-	Host      string `json:"host"`       // tcp
-	Port      int    `json:"port"`       // tcp
-	COM       string `json:"com"`        // serial device
-	Baud      int    `json:"baud"`       // serial baud
-	Follow    bool   `json:"follow"`     // re-tune the antenna to the rig's frequency
-	StepKHz   int    `json:"step_khz"`   // re-tune only when the freq moved this far (25/50/100)
+	Type      string `json:"type"`      // "ultrabeam" | "steppir"
+	Transport string `json:"transport"` // "tcp" | "serial"
+	Host      string `json:"host"`      // tcp
+	Port      int    `json:"port"`      // tcp
+	COM       string `json:"com"`       // serial device
+	Baud      int    `json:"baud"`      // serial baud
+	Follow    bool   `json:"follow"`    // re-tune the antenna to the rig's frequency
+	StepKHz   int    `json:"step_khz"`  // re-tune only when the freq moved this far (25/50/100)
 	// When the follow loop is allowed to move the motors. The three choices the
 	// SteppIR's own controller software offers, because operators arrive with
 	// that mental model:
@@ -16181,6 +16320,19 @@ func (a *App) ampInstByID(id string) *ampInst {
 
 // AmpOperate puts the given amp in OPERATE (true) or STANDBY (false).
 func (a *App) AmpOperate(id string, on bool) error {
+	// Fan out here rather than in the UI: the card and the docked widget both
+	// call this, and a coupling implemented in one of them would be missing from
+	// the other — which on a combiner means one amplifier keyed and one not.
+	var firstErr error
+	for _, tid := range a.ampTargets(id, a.GetLinkedAmps()) {
+		if err := a.ampOperateOne(tid, on); err != nil && firstErr == nil {
+			firstErr = err
+		}
+	}
+	return firstErr
+}
+
+func (a *App) ampOperateOne(id string, on bool) error {
 	inst := a.ampInstByID(id)
 	if inst == nil {
 		return fmt.Errorf("amplifier not running — check Settings → Amplifier")
@@ -16205,6 +16357,18 @@ func (a *App) AmpPower(id string, on bool) (err error) {
 			applog.Printf("amp %s: power %v failed: %v", id, on, err)
 		}
 	}()
+	linked := a.GetLinkedAmps()
+	targets := a.ampTargets(id, linked)
+	var firstErr error
+	for _, tid := range targets {
+		if e := a.ampPowerOne(tid, on, len(targets) > 1); e != nil && firstErr == nil {
+			firstErr = e
+		}
+	}
+	return firstErr
+}
+
+func (a *App) ampPowerOne(id string, on, linked bool) error {
 	inst := a.ampInstByID(id)
 	if inst == nil {
 		return fmt.Errorf("amplifier not running — check Settings → Amplifier")
@@ -16221,6 +16385,12 @@ func (a *App) AmpPower(id string, on bool) (err error) {
 		}
 		return inst.acom.PowerOff()
 	}
+	// Not an error worth surfacing when linked: a PGXL alongside two SPEs simply
+	// has no power command on its direct link, and reporting that as a failure
+	// would make a successful pair look broken.
+	if linked {
+		return nil
+	}
 	return fmt.Errorf("power on/off is not available for this amplifier")
 }
 
@@ -16508,6 +16678,43 @@ func (a *App) CIVTraceEnabled() bool { return cat.CIVTraceEnabled() }
 // WinkeyerTraceEnabled — same, for the keyer trace.
 func (a *App) WinkeyerTraceEnabled() bool { return winkeyer.TraceEnabled() }
 
+// keyerSlowBootKey names the "this port holds a keyer that reboots when opened"
+// flag. GLOBAL, not per profile: which keyer is plugged into COM3 is a property
+// of the computer, and an operator who switches profiles for a different rig has
+// not changed the keyer on the desk.
+func keyerSlowBootKey(port string) string {
+	return "winkeyer.slow_boot." + strings.ToUpper(strings.TrimSpace(port))
+}
+
+// keyerNeedsSlowBoot reports whether this port has already been seen to need the
+// long opening wait.
+//
+// A K3NG keyer — an Arduino running the WinKeyer protocol — reboots when the
+// port opens, because DTR is wired to its reset pin. The first connect finds
+// that out by failing the quick attempt and succeeding on the slow one; every
+// connect afterwards reads this and goes straight to the slow one.
+//
+// Learnt rather than configured. The alternative was a "K3NG" entry beside
+// "WinKeyer" in the engine list, which would name one clone among many — WKmini,
+// home-built Arduinos, unbranded boxes — and leave every other operator guessing
+// which of the two to pick for hardware that speaks exactly the same protocol.
+func (a *App) keyerNeedsSlowBoot(port string) bool {
+	if a.settings == nil || strings.TrimSpace(port) == "" {
+		return false
+	}
+	v, _ := a.settings.GetGlobal(a.ctx, keyerSlowBootKey(port))
+	return v == "1"
+}
+
+// noteKeyerSlowBoot records that this port's keyer needed the long wait.
+func (a *App) noteKeyerSlowBoot(port string) {
+	if a.settings == nil || strings.TrimSpace(port) == "" {
+		return
+	}
+	_ = a.settings.SetGlobal(a.ctx, keyerSlowBootKey(port), "1")
+	applog.Printf("winkeyer: %s remembered as a slow-booting keyer — it will open directly next time", port)
+}
+
 // WinkeyerConnect opens the serial link using the saved config.
 func (a *App) WinkeyerConnect() error {
 	if a.winkeyer == nil {
@@ -16523,6 +16730,7 @@ func (a *App) WinkeyerConnect() error {
 	if s.Engine == "serial" {
 		cfg.Type = "serial"
 	}
+	cfg.SlowBoot = a.keyerNeedsSlowBoot(cfg.Port)
 	return a.winkeyer.Connect(cfg)
 }
 
@@ -17048,7 +17256,11 @@ type clusterStatusCache struct {
 	workedCalls     map[string]struct{}
 	workedCallSlots map[string]struct{} // nil unless the "same slot" option is on
 	workedCounties  map[string]struct{}
-	workedPOTA      map[string]struct{}
+	// callCounties holds callsign → "STATE,County" for stations already logged
+	// with a county, so a spot shows the county the entry panel showed rather
+	// than the one derived from the licence ZIP. See qso.CallCounties.
+	callCounties map[string]string
+	workedPOTA   map[string]struct{}
 	workedPfx       map[string]struct{}
 	workedGrids     map[string]struct{} // "GRID|MODE", mode normalised like the rest
 	normMode        func(string) string // nil unless digital-mode grouping is on
@@ -17116,6 +17328,7 @@ func (a *App) clusterStatusMaps() *clusterStatusCache {
 	// Orthogonal dimensions: worked US counties (for the ULS callsign→county
 	// lookup) and worked POTA parks.
 	c.workedCounties, _ = a.qso.WorkedCountyKeys(a.ctx, award.USCountyKey)
+	c.callCounties, _ = a.qso.CallCounties(a.ctx)
 	c.workedPOTA, _ = a.qso.WorkedPOTARefs(a.ctx)
 	// One more DISTINCT scan when the snapshot is rebuilt, then pure map lookups
 	// per spot — the same shape as the county and POTA sets beside it, which is
@@ -17392,9 +17605,27 @@ func (a *App) ClusterSpotStatuses(spots []SpotQuery) []SpotStatus {
 				}
 			}
 		}
-		// NEW COUNTY: resolve the callsign's home county from the offline ULS
-		// store (US only; inert until downloaded) and flag if never worked.
-		if a.uls != nil {
+		// NEW COUNTY. Two sources, better one first:
+		//
+		//  1. the county this station was logged with — a callbook's answer,
+		//     the same one the entry panel shows;
+		//  2. the offline ULS store, which derives a county from the licence
+		//     ZIP (US only; inert until downloaded, ~98% for fixed stations).
+		//
+		// Preferring the log is what keeps the cluster column and the entry
+		// panel from disagreeing about the same callsign, which was impossible
+		// to explain and made both look wrong.
+		if cnty, ok := idx.callCounties[q.Call]; ok {
+			st, name, _ := strings.Cut(cnty, ",")
+			out[i].State, out[i].County = st, name
+			// Logged means worked, so this can never be a new county — but say
+			// so through the same key the flag below uses, not by assumption.
+			if key := award.USCountyKey(st, name); key != "" {
+				if _, done := workedCounties[key]; !done {
+					out[i].NewCounty = true
+				}
+			}
+		} else if a.uls != nil {
 			if loc, ok := a.uls.Resolve(q.Call); ok {
 				out[i].County, out[i].State = loc.County, loc.State
 				if key := award.USCountyKey(loc.State, loc.County); key != "" {
@@ -17407,6 +17638,16 @@ func (a *App) ClusterSpotStatuses(spots []SpotQuery) []SpotStatus {
 		if a.dxcc == nil {
 			continue
 		}
+		// Say WHY a maritime/aeronautical mobile has no entity, rather than
+		// leaving the column blank — blank is what an unresolved spot looks like,
+		// and the two mean opposite things: one is "we don't know yet", this is
+		// "there is nothing to know, the station is at sea". Display only: the
+		// QSO's own Country stays empty, because it is a DXCC entity name and
+		// there is none.
+		if dxcc.IsMobileNoEntity(q.Call) {
+			out[i].Country = "Maritime mobile — no DXCC"
+			continue
+		}
 		m, ok := a.dxcc.Lookup(q.Call)
 		if !ok || m.Entity == nil {
 			continue
@@ -17697,3 +17938,141 @@ func (a *App) SetKenwoodKeySpeed(wpm int) error {
 	}
 	return a.cat.KenwoodDo(func(k cat.KenwoodController) error { return k.SetKeySpeed(wpm) })
 }
+
+// spotTTLMax bounds the setting. Twelve hours is far past any operational use
+// and exists only so a mistyped value cannot mean "never".
+const spotTTLMax = 720
+
+// 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.
+func (a *App) GetSpotTTLMinutes() int {
+	n, _ := strconv.Atoi(a.settingOr(keyClusterSpotTTL, ""))
+	if n < 0 {
+		return 0
+	}
+	if n > spotTTLMax {
+		return spotTTLMax
+	}
+	return n
+}
+
+// SetSpotTTLMinutes sets it. Clamped here as well as in the UI: the value
+// shapes what an operator sees on the band map, and a stale or bypassed
+// frontend must not be able to widen it past the ceiling.
+func (a *App) SetSpotTTLMinutes(min int) error {
+	if min < 0 {
+		min = 0
+	}
+	if min > spotTTLMax {
+		min = spotTTLMax
+	}
+	a.setSetting(keyClusterSpotTTL, strconv.Itoa(min))
+	return nil
+}
+
+// SetCompactHeight resizes the compact window to fit its content.
+//
+// The height used to be a constant "tuned so the compact entry strip fits in a
+// single row". Constants tuned against a layout stop being true the moment the
+// layout changes, and this one outlived a strip that had since lost a row —
+// leaving a band of empty window under the fields. The frontend measures what
+// it actually rendered and says so.
+//
+// Ignored unless compact is on, so nothing can shrink the normal window.
+func (a *App) SetCompactHeight(h int) {
+	if a.ctx == nil || !a.compact {
+		return
+	}
+	// Bounded: a measurement of zero (a layout not yet painted) must not collapse
+	// the window to nothing, and no strip is ever 600px tall.
+	if h < 80 || h > 600 {
+		return
+	}
+	w, _ := wruntime.WindowGetSize(a.ctx)
+	if w <= 0 {
+		w = compactW
+	}
+	wruntime.WindowSetMinSize(a.ctx, 900, h)
+	wruntime.WindowSetSize(a.ctx, w, h)
+}
+
+// keyAmpsLinked couples the configured amplifiers so ON, OFF and OPERATE act on
+// all of them at once — the SPE CO1-2 combiner case.
+//
+// The combiner is an RF device: it sums two amplifiers and commands nothing. So
+// "combined" operation is really two amplifiers that must be kept in the same
+// state, and leaving one in OPERATE while the other sits in STANDBY is exactly
+// what must not happen — the combiner would see power on one input only.
+const keyAmpsLinked = "amps.linked"
+
+// GetLinkedAmps returns the ids of the amplifiers commanded together.
+//
+// A SET, not a global flag. A station can have a combiner pair AND a third
+// amplifier that has nothing to do with it — two SPE on the combiner and a
+// PowerGenius on another antenna — and a global switch would send that third
+// one into OPERATE alongside them.
+func (a *App) GetLinkedAmps() []string {
+	out := []string{}
+	for _, id := range strings.Split(a.settingOr(keyAmpsLinked, ""), ",") {
+		if id = strings.TrimSpace(id); id != "" {
+			out = append(out, id)
+		}
+	}
+	return out
+}
+
+// SetLinkedAmps records which amplifiers are coupled.
+func (a *App) SetLinkedAmps(ids []string) error {
+	clean := make([]string, 0, len(ids))
+	for _, id := range ids {
+		if id = strings.TrimSpace(id); id != "" {
+			clean = append(clean, id)
+		}
+	}
+	// One amplifier coupled to itself is not a group; store nothing rather than
+	// a set that would make ampTargets fan out to a single member for ever.
+	if len(clean) < 2 {
+		clean = nil
+	}
+	a.setSetting(keyAmpsLinked, strings.Join(clean, ","))
+	return nil
+}
+
+// ampTargets returns the amplifier ids a command should reach: the one asked
+// for, or every running amplifier when they are linked.
+//
+// The METERS are deliberately untouched by this — each amplifier keeps its own
+// bars. Two amps combined are still two amps, and an operator watching for one
+// of them to run away needs to see them apart.
+func (a *App) ampTargets(id string, linked []string) []string {
+	inGroup := false
+	for _, l := range linked {
+		if l == id {
+			inGroup = true
+			break
+		}
+	}
+	// An amplifier outside the group keeps its own buttons to itself — that is
+	// the whole point of the group being a set.
+	if !inGroup {
+		return []string{id}
+	}
+	a.ampsMu.Lock()
+	defer a.ampsMu.Unlock()
+	out := make([]string, 0, len(linked))
+	// The one that was asked for goes FIRST, so a partial failure still did what
+	// the operator clicked before it stopped.
+	out = append(out, id)
+	for _, l := range linked {
+		if l == id {
+			continue
+		}
+		// Only amplifiers actually running: a group remembering one that has been
+		// deleted or switched off must not fail the whole command for it.
+		if _, ok := a.ampInsts[l]; ok {
+			out = append(out, l)
+		}
+	}
+	return out
+}

app_qsl_designer.go

@@ -31,7 +31,7 @@ import (
 const (
 	keyQSLEmailSubject = "qsl.email_subject"
 	keyQSLEmailBody    = "qsl.email_body"
-	keyQSLAutoSend     = "qsl.auto_send"      // "1" → render+send an eQSL on log when an e-mail and default template exist
+	keyQSLAutoSend     = "qsl.auto_send"       // "1" → render+send an eQSL on log when an e-mail and default template exist
 	keyQSLDefaultMsg   = "qsl.default_message" // fallback QSL message printed on the card when the QSO's own QSLMSG is empty
 )
 
@@ -748,3 +748,165 @@ func sampleQSO() qso.QSO {
 		QSLMsg:   "TNX FB QSO — 73!",
 	}
 }
+
+// QSLForeignTemplate is one card design belonging to ANOTHER profile, offered
+// for copying into the active one.
+type QSLForeignTemplate struct {
+	ID          int64  `json:"id"`
+	Name        string `json:"name"`
+	ProfileID   int64  `json:"profile_id"`
+	ProfileName string `json:"profile_name"`
+}
+
+// QSLListOtherProfileTemplates lists the designs the ACTIVE profile cannot see.
+//
+// A second profile is usually the same operator with a different rig or a
+// different locator — same callsign, same cards. Redrawing a design because the
+// antenna changed is work nobody should have to do, and the designs a profile
+// already sees (its own, and the shared ones) are deliberately left out: they
+// are not something to copy.
+func (a *App) QSLListOtherProfileTemplates() ([]QSLForeignTemplate, error) {
+	if a.qslTemplates == nil || a.profiles == nil {
+		return nil, fmt.Errorf("db not initialized")
+	}
+	active := int64(-1)
+	if p, err := a.profiles.Active(a.ctx); err == nil {
+		active = p.ID
+	}
+	names := map[int64]string{}
+	if list, err := a.ListProfiles(); err == nil {
+		for _, p := range list {
+			names[p.ID] = p.Name
+		}
+	}
+	all, err := a.qslTemplates.List(a.ctx)
+	if err != nil {
+		return nil, err
+	}
+	out := []QSLForeignTemplate{}
+	for _, r := range all {
+		// Shared designs (no profile) already appear in every profile's list.
+		if r.ProfileID == nil || *r.ProfileID == active {
+			continue
+		}
+		out = append(out, QSLForeignTemplate{
+			ID: r.ID, Name: r.Name, ProfileID: *r.ProfileID,
+			ProfileName: firstNonEmptyStr(names[*r.ProfileID], fmt.Sprintf("profile %d", *r.ProfileID)),
+		})
+	}
+	return out, nil
+}
+
+// QSLCopyTemplateToActiveProfile duplicates another profile's design into the
+// active one and returns the new id.
+//
+// A COPY, not a move or a share. The original profile keeps its design
+// untouched, and the copy is free to diverge — a second profile usually exists
+// because something differs, and that something often ends up on the card.
+func (a *App) QSLCopyTemplateToActiveProfile(id int64) (int64, error) {
+	if a.qslTemplates == nil {
+		return 0, fmt.Errorf("db not initialized")
+	}
+	src, err := a.qslTemplates.Get(a.ctx, id)
+	if err != nil {
+		return 0, err
+	}
+	// The stored document references photos by NAME, relative to the template's
+	// own asset folder — so copying the JSON alone would point the new design at
+	// files that are not in its folder, and the save would fail validation.
+	//
+	// The files are copied too, giving the duplicate its own folder. Sharing the
+	// source's would mean deleting one design silently emptied the other.
+	rec := qslcard.Record{Name: src.Name + " (copy)", JSON: src.JSON}
+	if p, e := a.profiles.Active(a.ctx); e == nil {
+		rec.ProfileID = &p.ID
+	}
+	// Saved first: a new template needs its id before it can own a folder.
+	if err := a.qslTemplates.Save(a.ctx, &rec); err != nil {
+		return 0, err
+	}
+	srcDir := qslcard.TemplateDir(a.qslDir(), id)
+	dstDir := qslcard.TemplateDir(a.qslDir(), rec.ID)
+	// A design with no pictures at all has no folder, and that is not a failure.
+	// Anything else IS: this used to be written as "ignore os.IsNotExist", which
+	// also swallowed every ENOENT raised while copying — so a failed copy looked
+	// like a design that had nothing to copy, and the operator got "hero photo
+	// not found" with no clue why.
+	if _, statErr := os.Stat(srcDir); statErr == nil {
+		if err := copyDirContents(srcDir, dstDir); err != nil {
+			// Roll back rather than leave a design whose pictures are missing.
+			_ = a.qslTemplates.Delete(a.ctx, rec.ID)
+			_ = qslcard.RemoveTemplateDir(a.qslDir(), rec.ID)
+			return 0, fmt.Errorf("copy template assets: %w", err)
+		}
+	}
+	// Every failure from here rolls back BOTH halves: deleting only the row would
+	// leave the copied pictures on disk under an id nothing refers to.
+	rollback := func() {
+		_ = a.qslTemplates.Delete(a.ctx, rec.ID)
+		_ = qslcard.RemoveTemplateDir(a.qslDir(), rec.ID)
+	}
+	t, err := qslcard.Parse([]byte(rec.JSON))
+	if err != nil {
+		rollback()
+		return 0, err
+	}
+	if err := qslcard.Validate(t, qslcard.PhotoExistsIn(dstDir)); err != nil {
+		rollback()
+		return 0, fmt.Errorf("copied design is incomplete: %w", err)
+	}
+	applog.Printf("qsl: copied template %q (id %d) into the active profile as %q (id %d)",
+		src.Name, id, rec.Name, rec.ID)
+	return rec.ID, nil
+}
+
+// copyQSLTemplatesToProfile duplicates one profile's QSL designs into another,
+// PICTURES INCLUDED.
+//
+// This was an INSERT … SELECT, which cloned the rows and nothing else. A design
+// references its photos by name, relative to its own asset folder, so every
+// duplicated design pointed at a folder that did not exist: no thumbnail in the
+// designer, and nothing to print. The rows looked right, which is why it went
+// unnoticed — the damage is entirely on disk.
+//
+// Row by row rather than in one statement, because each new design needs its id
+// before it can own a folder. A design whose files cannot be copied is dropped
+// rather than kept empty: an operator who sees the design listed will believe
+// it works.
+func (a *App) copyQSLTemplatesToProfile(fromProfile, toProfile int64) error {
+	if a.qslTemplates == nil {
+		return fmt.Errorf("db not initialized")
+	}
+	all, err := a.qslTemplates.List(a.ctx)
+	if err != nil {
+		return err
+	}
+	for _, src := range all {
+		if src.ProfileID == nil || *src.ProfileID != fromProfile {
+			continue
+		}
+		rec := qslcard.Record{Name: src.Name, JSON: src.JSON, IsDefault: src.IsDefault}
+		to := toProfile
+		rec.ProfileID = &to
+		if err := a.qslTemplates.Save(a.ctx, &rec); err != nil {
+			return err
+		}
+		srcDir := qslcard.TemplateDir(a.qslDir(), src.ID)
+		if _, statErr := os.Stat(srcDir); statErr != nil {
+			continue // a design with no pictures at all — nothing to carry over
+		}
+		if err := copyDirContents(srcDir, qslcard.TemplateDir(a.qslDir(), rec.ID)); err != nil {
+			_ = a.qslTemplates.Delete(a.ctx, rec.ID)
+			_ = qslcard.RemoveTemplateDir(a.qslDir(), rec.ID)
+			return fmt.Errorf("copy assets of %q: %w", src.Name, err)
+		}
+	}
+	return nil
+}
+
+func firstNonEmptyStr(a, b string) string {
+	if strings.TrimSpace(a) != "" {
+		return a
+	}
+	return b
+}

appearance.go

@@ -19,31 +19,66 @@ 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.
+	//
+	// 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.
+	Channels []string `json:"channels"`
 }
 
+// The QSL channels a rule can be scoped to.
+var rowColorChannels = []string{"qsl", "lotw", "eqsl", "qrz"}
+
 // RowColorSettings is the whole appearance block.
 type RowColorSettings struct {
-	Enabled bool           `json:"enabled"`
-	Rules   []RowColorRule `json:"rules"`
+	Enabled bool `json:"enabled"`
+	// Style is how the colour is shown: "bar" paints a stripe down the left edge,
+	// "tint" washes the row, "both" does each.
+	//
+	// A bar is the default because a filled row is a poor signal in a log where
+	// nearly every contact has SOME QSL state: colour that is always present
+	// stops being information and becomes a striped background, with the data
+	// behind it. The stripe says the same thing and costs nothing to read.
+	Style string `json:"style"`
+	// Intensity is the tint strength in percent. Only used by "tint"/"both".
+	Intensity int `json:"intensity"`
+	// BandMapLotw marks stations that upload to LoTW on the band map, with the
+	// same "L" badge the cluster list uses — one visual vocabulary across the two
+	// views rather than a second invention.
+	BandMapLotw bool `json:"bandmap_lotw"`
+	// Configured distinguishes "saved with this off" from "saved before the
+	// option existed", so a new marker can default ON without silently turning
+	// itself back on for an operator who switched it off.
+	Configured bool           `json:"configured"`
+	Rules      []RowColorRule `json:"rules"`
 }
 
 // The rule ids, in priority order. The frontend matches on these and holds the
 // labels, so a translated name never has to travel through the settings.
+// The four categories, in the order they are tested — first match wins.
+//
+// "To send" comes FIRST on purpose. A contact can be confirmed on LoTW and
+// still owe a paper card, and the colour an operator scans for is the one that
+// means "there is something left to do here". Put after "confirmed", that row
+// would go green and the card would never be printed.
+//
+// "Worked" is the catch-all: a contact with nothing sent, nothing asked for and
+// nothing back. Off by default — with it on, every remaining row is painted.
 var rowColorOrder = []string{
-	"confirmed_lotw",  // LoTW confirmation received
-	"confirmed_paper", // card or eQSL received
-	"sent_waiting",    // sent by some route, nothing back yet
-	"to_send",         // a card is requested / queued and has not gone out
+	"to_send",   // requested or queued on a watched channel, not gone out
+	"confirmed", // a watched channel has a confirmation back
+	"sent",      // gone out on a watched channel, nothing back yet
+	"worked",    // none of the above
 }
 
 // Defaults: green for done, amber for waiting, blue for owed. Deliberately
 // muted — they are composited at low opacity over a dark grid, and a saturated
 // value there reads as an error state rather than a status.
 var rowColorDefaults = map[string]string{
-	"confirmed_lotw":  "#16a34a",
-	"confirmed_paper": "#0ea5e9",
-	"sent_waiting":    "#f59e0b",
-	"to_send":         "#a855f7",
+	"to_send":   "#a855f7",
+	"confirmed": "#16a34a",
+	"sent":      "#f59e0b",
+	"worked":    "#64748b",
 }
 
 // hexColor guards what reaches the stylesheet. The value is interpolated into a
@@ -56,13 +91,48 @@ func normRowColors(s RowColorSettings) RowColorSettings {
 	for _, r := range s.Rules {
 		byID[r.ID] = r
 	}
-	out := RowColorSettings{Enabled: s.Enabled}
+	out := RowColorSettings{
+		Enabled: s.Enabled, Style: s.Style, Intensity: s.Intensity,
+		BandMapLotw: s.BandMapLotw, Configured: true,
+	}
+	if !s.Configured {
+		out.BandMapLotw = true // new option, on unless the operator says otherwise
+	}
+	switch out.Style {
+	case "bar", "tint", "both":
+	default:
+		out.Style = "bar"
+	}
+	// Clamped rather than rejected: the value only shapes a colour-mix, and a
+	// number outside the range is a slider that got away, not a fault worth
+	// resetting the operator's whole choice for.
+	if out.Intensity < 5 {
+		out.Intensity = 12
+	} else if out.Intensity > 45 {
+		out.Intensity = 45
+	}
+	ok := map[string]bool{}
+	for _, c := range rowColorChannels {
+		ok[c] = true
+	}
 	for _, id := range rowColorOrder {
 		r := byID[id]
 		r.ID = id
 		if !hexColor.MatchString(strings.TrimSpace(r.Color)) {
 			r.Color = rowColorDefaults[id]
 		}
+		// Keep only channels we know, in the canonical order, de-duplicated.
+		want := map[string]bool{}
+		for _, c := range r.Channels {
+			want[strings.ToLower(strings.TrimSpace(c))] = true
+		}
+		chans := []string{}
+		for _, c := range rowColorChannels {
+			if want[c] {
+				chans = append(chans, c)
+			}
+		}
+		r.Channels = chans
 		out.Rules = append(out.Rules, r)
 	}
 	return out

appearance_test.go

@@ -6,8 +6,8 @@ import "testing"
 // that is not plainly a hex colour has to be refused rather than passed on.
 func TestRowColorsRefuseAnythingButHex(t *testing.T) {
 	in := RowColorSettings{Enabled: true, Rules: []RowColorRule{
-		{ID: "confirmed_lotw", Color: "#123abc", Enabled: true},
-		{ID: "sent_waiting", Color: "red; background:url(x)", Enabled: true},
+		{ID: "confirmed", Color: "#123abc", Enabled: true},
+		{ID: "sent", Color: "red; background:url(x)", Enabled: true},
 		{ID: "to_send", Color: "", Enabled: true},
 	}}
 	got := normRowColors(in)
@@ -16,11 +16,11 @@ func TestRowColorsRefuseAnythingButHex(t *testing.T) {
 	for _, r := range got.Rules {
 		byID[r.ID] = r
 	}
-	if byID["confirmed_lotw"].Color != "#123abc" {
-		t.Errorf("a valid colour was rewritten: %q", byID["confirmed_lotw"].Color)
+	if byID["confirmed"].Color != "#123abc" {
+		t.Errorf("a valid colour was rewritten: %q", byID["confirmed"].Color)
 	}
-	if byID["sent_waiting"].Color != rowColorDefaults["sent_waiting"] {
-		t.Errorf("an injection attempt survived: %q", byID["sent_waiting"].Color)
+	if byID["sent"].Color != rowColorDefaults["sent"] {
+		t.Errorf("an injection attempt survived: %q", byID["sent"].Color)
 	}
 	if byID["to_send"].Color != rowColorDefaults["to_send"] {
 		t.Errorf("an empty colour was kept: %q", byID["to_send"].Color)
@@ -34,7 +34,7 @@ func TestRowColorsKeepPriorityOrder(t *testing.T) {
 	// Saved in a jumbled order, as a hand-edited settings row could be.
 	got := normRowColors(RowColorSettings{Rules: []RowColorRule{
 		{ID: "to_send", Color: "#111111"},
-		{ID: "confirmed_lotw", Color: "#222222"},
+		{ID: "confirmed", Color: "#222222"},
 	}})
 	if len(got.Rules) != len(rowColorOrder) {
 		t.Fatalf("got %d rules, want every one present", len(got.Rules))
@@ -44,8 +44,71 @@ func TestRowColorsKeepPriorityOrder(t *testing.T) {
 			t.Errorf("rule %d is %q, want %q", i, got.Rules[i].ID, id)
 		}
 	}
-	// The saved colours survived the reordering.
-	if got.Rules[0].Color != "#222222" {
-		t.Errorf("confirmed_lotw lost its colour: %q", got.Rules[0].Color)
+	// The saved colours survived the reordering: each stayed with its own rule.
+	byID := map[string]string{}
+	for _, r := range got.Rules {
+		byID[r.ID] = r.Color
+	}
+	if byID["to_send"] != "#111111" || byID["confirmed"] != "#222222" {
+		t.Errorf("colours moved between rules: %v", byID)
+	}
+}
+
+// Style and strength are normalised, not rejected: they only shape a colour, and
+// a value that got away is a slider, not a fault worth resetting the operator's
+// whole choice for.
+func TestRowColorsNormaliseStyleAndIntensity(t *testing.T) {
+	for _, tc := range []struct {
+		inStyle   string
+		inPct     int
+		wantStyle string
+		wantPct   int
+	}{
+		{"bar", 12, "bar", 12},
+		{"tint", 30, "tint", 30},
+		{"both", 45, "both", 45},
+		{"", 0, "bar", 12},           // never configured
+		{"wallpaper", 12, "bar", 12}, // not a style we draw
+		{"tint", 900, "tint", 45},    // clamped, not reset
+		{"tint", -5, "tint", 12},
+	} {
+		got := normRowColors(RowColorSettings{Style: tc.inStyle, Intensity: tc.inPct})
+		if got.Style != tc.wantStyle || got.Intensity != tc.wantPct {
+			t.Errorf("(%q,%d) -> (%q,%d), want (%q,%d)",
+				tc.inStyle, tc.inPct, got.Style, got.Intensity, tc.wantStyle, tc.wantPct)
+		}
+	}
+}
+
+// Channels are normalised to the canonical order, and anything unknown is
+// dropped. Empty stays empty, because empty means "every channel" — a rule the
+// operator has not narrowed must not silently become a rule about nothing.
+func TestRowColorChannelsNormalise(t *testing.T) {
+	got := normRowColors(RowColorSettings{Rules: []RowColorRule{
+		{ID: "confirmed", Color: "#111111", Channels: []string{"LOTW", "pigeon", "qsl", "lotw"}},
+		{ID: "sent", Color: "#222222"},
+	}})
+	byID := map[string][]string{}
+	for _, r := range got.Rules {
+		byID[r.ID] = r.Channels
+	}
+	if len(byID["confirmed"]) != 2 || byID["confirmed"][0] != "qsl" || byID["confirmed"][1] != "lotw" {
+		t.Errorf("confirmed channels = %v, want [qsl lotw] — canonical order, deduped, unknown dropped", byID["confirmed"])
+	}
+	if len(byID["sent"]) != 0 {
+		t.Errorf("sent channels = %v, want empty (meaning every channel)", byID["sent"])
+	}
+}
+
+// The order IS the priority, and "to send" leads. A contact confirmed on LoTW
+// that still owes a paper card must read as owing the card — put after
+// "confirmed" it would go green and never be printed.
+func TestToSendOutranksConfirmed(t *testing.T) {
+	got := normRowColors(RowColorSettings{})
+	if got.Rules[0].ID != "to_send" {
+		t.Errorf("first rule is %q, want to_send", got.Rules[0].ID)
+	}
+	if got.Rules[len(got.Rules)-1].ID != "worked" {
+		t.Errorf("last rule is %q, want worked as the catch-all", got.Rules[len(got.Rules)-1].ID)
 	}
 }

changelog.json

@@ -1,4 +1,74 @@
 [
+  {
+    "version": "0.25.1",
+    "date": "",
+    "en": [
+      "Amplifiers: tick the ones sharing a combiner and ON, OFF and OPERATE act on all of them at once. Each keeps its own meters.",
+      "Shared CAT: JTDX and WSJT-X no longer get an error for turning split off or setting the transmit mode — which made JTDX abandon a transmission — and the wire trace now logs every exchange.",
+      "QSL designer: a card design can be copied from another profile, pictures included, and duplicating a profile now carries its designs’ pictures too instead of leaving cards that cannot be printed.",
+      "Appearance: new Sahara theme, warm sand tones for long sessions in daylight.",
+      "US counties: Connecticut returned the census planning regions, and San Francisco, Doña Ana, Baltimore city and several Alaska boroughs matched nothing at all. The cluster now shows the same county as the Info panel. Re-download the county database.",
+      "QSL: the manager (QSL_VIA) and the sending method (QSL_SENT_VIA / QSL_RCVD_VIA) are separate fields at last, as ADIF defines them. Imports keep both, exports write both, and a log where they were mixed is offered a correction at startup.",
+      "WinKeyer: the opening handshake follows K1EL’s own sequence (RTS off, parser resync, echo test), which wakes keyers that stayed silent, and a port where nothing answers now says so instead of showing “connected”. A keyer that reboots when the port opens — K3NG and other Arduino builds — is waited out and remembered, so it opens directly next time."
+    ],
+    "fr": [
+      "Amplificateurs : cochez ceux qui partagent un combineur et ON, OFF et OPERATE agissent sur tous à la fois. Chacun garde ses propres mesures.",
+      "CAT partagé : JTDX et WSJT-X ne reçoivent plus d’erreur en coupant le split ou en réglant le mode d’émission — ce qui faisait abandonner une transmission à JTDX — et la trace consigne désormais chaque échange.",
+      "Concepteur QSL : un design peut être copié depuis un autre profil, images comprises, et dupliquer un profil emporte aussi les images de ses designs au lieu de laisser des cartes impossibles à imprimer.",
+      "Apparence : nouveau thème Sahara, tons sable chauds pour les longues sessions en plein jour.",
+      "Comtés US : le Connecticut renvoyait les planning regions du recensement, et San Francisco, Doña Ana, Baltimore city et plusieurs districts d’Alaska ne correspondaient à rien. Le cluster affiche maintenant le même comté que le panneau Info. Rechargez la base des comtés.",
+      "QSL : le manager (QSL_VIA) et le mode d’envoi (QSL_SENT_VIA / QSL_RCVD_VIA) sont enfin deux champs distincts, comme le veut l’ADIF. Les imports gardent les deux, les exports les écrivent, et un log où ils étaient mélangés se voit proposer une correction au démarrage.",
+      "WinKeyer : la séquence d’ouverture suit celle de K1EL (RTS bas, resynchronisation, test d’écho), ce qui réveille les manipulateurs muets, et un port où rien ne répond le dit au lieu d’afficher « connecté ». Un manipulateur qui redémarre à l’ouverture du port — K3NG et autres montages Arduino — est attendu puis mémorisé, pour s’ouvrir directement ensuite."
+    ]
+  },
+  {
+    "version": "0.25.0",
+    "date": "",
+    "en": [
+      "Cluster: \"Hide worked\" no longer hides a spot that is a new prefix, county, grid or park in an entity already worked.",
+      "DX Cluster: a spot lifetime can be set — 5, 10, 15 minutes or your own value — after which spots leave the list and the band maps.",
+      "Call lookup: QRZ.com now fills Name with the first name only, and optionally with the operator nickname instead.",
+      "Entry form: a narrower left column, State beside the locator, and a new line with County, CQ, ITU and DXCC.",
+      "Station Control: the short and long path headings are repeated under the compass, at a readable size and clickable.",
+      "Compact mode: the window now fits the entry strip instead of leaving a band of empty space below it.",
+      "HRDLog: an ON AIR option publishes your live frequency, mode and rig on hrdlog.net.",
+      "ADIF: the county is exported as STATE,COUNTY as the standard requires, and a county imported that way now fills the state too.",
+      "A /MM or /AM callsign no longer resolves to a country — RI1FJL/MM read as Franz Josef Land while the expedition was still sailing there."
+    ],
+    "fr": [
+      "Cluster : « Masquer les contactés » ne masque plus un spot qui est un nouveau préfixe, comté, carré ou parc dans une contrée déjà faite.",
+      "Cluster DX : on peut fixer une durée de vie des spots — 5, 10, 15 minutes ou une valeur libre — au-delà de laquelle ils quittent la liste et les band maps.",
+      "Recherche d indicatif : QRZ.com remplit désormais Nom avec le seul prénom, et au choix avec le surnom de l opérateur.",
+      "Saisie : colonne de gauche plus étroite, État à côté du locator, et une nouvelle ligne Comté, CQ, ITU et DXCC.",
+      "Contrôle station : les azimuts court et long chemin sont repris sous la boussole, lisibles et cliquables.",
+      "Mode compact : la fenêtre épouse la bande de saisie au lieu de laisser une bande vide en dessous.",
+      "HRDLog : une option ON AIR publie ta fréquence, ton mode et ta radio en direct sur hrdlog.net.",
+      "ADIF : le comté est exporté sous la forme ÉTAT,COMTÉ comme l exige le standard, et un comté importé ainsi remplit aussi l état.",
+      "Un indicatif en /MM ou /AM ne se résout plus en pays — RI1FJL/MM affichait Franz Josef Land alors que l expédition faisait encore route."
+    ]
+  },
+  {
+    "version": "0.24.9",
+    "date": "",
+    "en": [
+      "Appearance: row colouring now defaults to a left stripe, with a filled row and its strength offered as choices.",
+      "The band map now follows the cluster filters — LoTW only, spotter continent, hide worked, status and mode chips.",
+      "Band map: stations that upload to LoTW now carry the same L badge as the cluster list, switchable in Appearance.",
+      "LoTW: contacts TQSL leaves out — already uploaded, or outside the certificate date range — are no longer reported as uploaded.",
+      "FT8: a contact is logged with the grid the station actually sent, not the home square from QRZ — expeditions were logged in the wrong place.",
+      "SPE amplifier: switching it off is shown at once, instead of needing a second press of OFF.",
+      "Appearance: row colouring is now Worked / Confirmed / QSL sent / To be sent, each scoped to the channels you pick — paper, LoTW, eQSL, QRZ.com."
+    ],
+    "fr": [
+      "Apparence : la coloration des lignes se fait par défaut sur une barre à gauche, la ligne remplie et son intensité restant proposées.",
+      "La band map suit désormais les filtres du cluster — LoTW seulement, continent du spotter, masquer les contactés, statuts et modes.",
+      "Band map : les stations qui utilisent LoTW portent le même badge L que la liste du cluster, activable dans Apparence.",
+      "LoTW : les contacts que TQSL écarte — déjà envoyés, ou hors de la plage de dates du certificat — ne sont plus annoncés comme envoyés.",
+      "FT8 : un contact est enregistré avec le locator réellement émis par la station, et non le carré du domicile depuis QRZ — les expéditions étaient logguées au mauvais endroit.",
+      "Amplificateur SPE : l extinction s affiche immédiatement, au lieu de demander un second appui sur OFF.",
+      "Apparence : la coloration des lignes devient Contacté / Confirmé / QSL envoyée / À envoyer, chacune limitée aux canaux choisis — papier, LoTW, eQSL, QRZ.com."
+    ]
+  },
   {
     "version": "0.24.8",
     "date": "",
@@ -1147,4 +1217,4 @@
       "Ce résumé « Nouveautés » s'affiche désormais au premier lancement après chaque mise à jour."
     ]
   }
-]
+]

cmd/cntygen/main.go

@@ -9,6 +9,7 @@ import (
 	"os"
 	"sort"
 	"strings"
+	"unicode/utf8"
 
 	"hamlog/internal/award"
 )
@@ -58,6 +59,15 @@ func main() {
 	sc.Scan() // header
 	for sc.Scan() {
 		line := sc.Text()
+		// The FIPS CSV is not reliably UTF-8, and the one county whose name is
+		// not ASCII (Doña Ana, NM) came through mangled once already — it landed
+		// in the reference as "NM/DO̱AANA", a code no log could ever match,
+		// silently costing that county for every operator. Refuse the row rather
+		// than emit a broken one.
+		if !utf8.ValidString(line) {
+			fmt.Fprintf(os.Stderr, "cntygen: skipping non-UTF-8 line: %q\n", line)
+			continue
+		}
 		parts := strings.SplitN(line, ",", 3)
 		if len(parts) < 3 {
 			continue

cmd/ctzipgen/main.go

@@ -0,0 +1,203 @@
+package main
+
+// One-shot generator: emits internal/uls/ctcounty_gen.go, the Connecticut
+// ZIP → legal county table. Not part of the build.
+//
+// Why it has to exist
+// -------------------
+// internal/uls resolves a US callsign to a county through GeoNames' ZIP table.
+// The Census replaced Connecticut's eight counties with nine PLANNING REGIONS
+// as county-equivalents in 2022, and GeoNames followed: 418 of Connecticut's
+// 429 ZIPs now report "Capitol Region", "Lower Connecticut River Valley" and
+// so on. CQ's USA-CA award did not follow, callbooks did not follow, and no
+// operator's log did either — so every Connecticut station resolved to a name
+// nothing could match, showed as a new county for ever, and counted for no
+// award. Roughly 15 000 US callsigns.
+//
+// A planning region is NOT a renamed county — it is built from towns drawn
+// from several different counties — so there is no name-to-name mapping to be
+// had. The ZIP is the only handle, hence this table.
+//
+// Sources (both public, both free)
+// --------------------------------
+//	geonames  US.txt from https://download.geonames.org/export/zip/US.zip
+//	          — the ZIP list itself, and each ZIP's centroid.
+//	crosswalk https://www2.census.gov/geo/docs/maps-data/data/rel2020/
+//	          zcta520/tab20_zcta520_county20_natl.txt
+//	          — the 2020 ZCTA↔county relationship file, which predates the
+//	            change and therefore still carries the eight real counties.
+//
+// The crosswalk covers 278 of the 418 affected ZIPs. The rest are PO-box-only
+// ZIPs, which have no ZCTA at all; each is given the county of the nearest
+// resolved ZIP centroid. That is sound here because a PO-box ZIP sits inside
+// the town it serves, and Connecticut's counties are tens of kilometres across
+// — the fallback can only err on a ZIP that straddles a county line, which the
+// ZIP-to-county approach is already documented as accepting (~98%).
+//
+// Usage:
+//
+//	go run ./cmd/ctzipgen US.txt tab20_zcta520_county20_natl.txt > internal/uls/ctcounty_gen.go
+
+import (
+	"bufio"
+	"fmt"
+	"math"
+	"os"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+type zipPt struct {
+	zip      string
+	lat, lon float64
+	county   string // from the crosswalk, "" if the ZIP has no ZCTA
+	geoName  string // what GeoNames says today
+}
+
+func main() {
+	if len(os.Args) < 3 {
+		fmt.Fprintln(os.Stderr, "usage: ctzipgen US.txt tab20_zcta520_county20_natl.txt")
+		os.Exit(2)
+	}
+
+	// 1. Every Connecticut ZIP, with its centroid, from GeoNames.
+	var pts []*zipPt
+	byZip := map[string]*zipPt{}
+	f, err := os.Open(os.Args[1])
+	must(err)
+	sc := bufio.NewScanner(f)
+	sc.Buffer(make([]byte, 0, 64*1024), 256*1024)
+	for sc.Scan() {
+		c := strings.Split(sc.Text(), "\t")
+		if len(c) < 11 || strings.ToUpper(strings.TrimSpace(c[4])) != "CT" {
+			continue
+		}
+		z := strings.TrimSpace(c[1])
+		if z == "" || byZip[z] != nil {
+			continue
+		}
+		p := &zipPt{zip: z, lat: atof(c[9]), lon: atof(c[10]), geoName: strings.TrimSpace(c[5])}
+		byZip[z] = p
+		pts = append(pts, p)
+	}
+	must(sc.Err())
+	f.Close()
+
+	// 2. The 2020 county for each ZCTA. A ZCTA can straddle a county line, so
+	//    keep the county holding the largest share of its land area.
+	best := map[string]float64{}
+	f2, err := os.Open(os.Args[2])
+	must(err)
+	sc2 := bufio.NewScanner(f2)
+	sc2.Buffer(make([]byte, 0, 64*1024), 1<<20)
+	sc2.Scan() // header
+	for sc2.Scan() {
+		c := strings.Split(sc2.Text(), "|")
+		if len(c) < 18 || !strings.HasPrefix(c[9], "09") {
+			continue
+		}
+		p := byZip[strings.TrimSpace(c[1])]
+		if p == nil {
+			continue
+		}
+		area := atof(c[16])
+		if p.county != "" && area <= best[p.zip] {
+			continue
+		}
+		best[p.zip] = area
+		p.county = strings.TrimSuffix(strings.TrimSpace(c[10]), " County")
+	}
+	must(sc2.Err())
+	f2.Close()
+
+	// 3. Fill the PO-box-only ZIPs from the nearest ZIP the crosswalk resolved.
+	var anchors []*zipPt
+	for _, p := range pts {
+		if p.county != "" {
+			anchors = append(anchors, p)
+		}
+	}
+	if len(anchors) == 0 {
+		fmt.Fprintln(os.Stderr, "ctzipgen: crosswalk resolved nothing — wrong file?")
+		os.Exit(1)
+	}
+	filled := 0
+	for _, p := range pts {
+		if p.county != "" {
+			continue
+		}
+		nearest, bestD := "", math.MaxFloat64
+		for _, a := range anchors {
+			if d := haversine(p.lat, p.lon, a.lat, a.lon); d < bestD {
+				bestD, nearest = d, a.county
+			}
+		}
+		p.county = nearest
+		filled++
+	}
+
+	// 4. Self-check: the ZIPs GeoNames still labels with a real county must
+	//    agree with what we derived, or the derivation is wrong.
+	real := map[string]bool{
+		"Fairfield": true, "Hartford": true, "Litchfield": true, "Middlesex": true,
+		"New Haven": true, "New London": true, "Tolland": true, "Windham": true,
+	}
+	checked, bad := 0, 0
+	for _, p := range pts {
+		if !real[p.geoName] {
+			continue
+		}
+		checked++
+		if p.geoName != p.county {
+			bad++
+			fmt.Fprintf(os.Stderr, "MISMATCH %s: geonames %q, derived %q\n", p.zip, p.geoName, p.county)
+		}
+	}
+	fmt.Fprintf(os.Stderr, "ctzipgen: %d zips, %d from crosswalk, %d by nearest; cross-check %d/%d agree\n",
+		len(pts), len(pts)-filled, filled, checked-bad, checked)
+	if bad > 0 {
+		os.Exit(1)
+	}
+
+	sort.Slice(pts, func(i, j int) bool { return pts[i].zip < pts[j].zip })
+
+	var b strings.Builder
+	b.WriteString("// Code generated by cmd/ctzipgen. DO NOT EDIT.\n\n")
+	b.WriteString("package uls\n\n")
+	b.WriteString("// ctCounty maps a Connecticut ZIP to its legal county.\n")
+	b.WriteString("//\n")
+	b.WriteString("// GeoNames reports Connecticut's 2022 planning regions instead, which no\n")
+	b.WriteString("// award, callbook or log uses. See cmd/ctzipgen for how this was built and\n")
+	b.WriteString("// why a name-to-name mapping cannot work.\n")
+	fmt.Fprintf(&b, "var ctCounty = map[string]string{\n")
+	for _, p := range pts {
+		fmt.Fprintf(&b, "\t%q: %q,\n", p.zip, p.county)
+	}
+	b.WriteString("}\n")
+	fmt.Print(b.String())
+}
+
+func atof(s string) float64 {
+	v, _ := strconv.ParseFloat(strings.TrimSpace(s), 64)
+	return v
+}
+
+// haversine returns the great-circle distance in km. Connecticut is small
+// enough that a flat approximation would do, but this costs nothing and cannot
+// be wrong near the state's edges.
+func haversine(lat1, lon1, lat2, lon2 float64) float64 {
+	const r = 6371.0
+	dLat := (lat2 - lat1) * math.Pi / 180
+	dLon := (lon2 - lon1) * math.Pi / 180
+	a := math.Sin(dLat/2)*math.Sin(dLat/2) +
+		math.Cos(lat1*math.Pi/180)*math.Cos(lat2*math.Pi/180)*math.Sin(dLon/2)*math.Sin(dLon/2)
+	return 2 * r * math.Asin(math.Sqrt(a))
+}
+
+func must(err error) {
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "ctzipgen:", err)
+		os.Exit(1)
+	}
+}

copydir_test.go

@@ -0,0 +1,61 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// TestCopyDirContentsCreatesDestination pins the bug that broke copying a QSL
+// design between profiles.
+//
+// copyDirContents wrote straight into dst without creating it, so the first
+// os.Create failed with ENOENT. The caller was written as "ignore
+// os.IsNotExist", meaning "the source has no assets, that is fine" — and ENOENT
+// from the failed write matched it exactly. Nothing was copied, no error was
+// reported, and the operator saw "copied design is incomplete: hero photo file
+// … not found" from the validation two lines later.
+func TestCopyDirContentsCreatesDestination(t *testing.T) {
+	base := t.TempDir()
+	src := filepath.Join(base, "src")
+	if err := os.MkdirAll(filepath.Join(src, "sub"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(src, "img_25c06bda.jpg"), []byte("hero"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(src, "sub", "back.png"), []byte("back"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	// dst does not exist — the case of every first copy.
+	dst := filepath.Join(base, "dst")
+	if err := copyDirContents(src, dst); err != nil {
+		t.Fatalf("copyDirContents: %v", err)
+	}
+	for name, want := range map[string]string{
+		"img_25c06bda.jpg": "hero",
+		"sub/back.png":     "back",
+	} {
+		got, err := os.ReadFile(filepath.Join(dst, filepath.FromSlash(name)))
+		if err != nil {
+			t.Errorf("%s: %v", name, err)
+			continue
+		}
+		if string(got) != want {
+			t.Errorf("%s = %q, want %q", name, got, want)
+		}
+	}
+}
+
+// A missing SOURCE is still an error from copyDirContents itself — it is the
+// caller that decides whether a design with no pictures is acceptable, and it
+// can only decide that if this does not quietly succeed.
+func TestCopyDirContentsMissingSource(t *testing.T) {
+	base := t.TempDir()
+	if err := copyDirContents(filepath.Join(base, "nope"), filepath.Join(base, "dst")); err == nil {
+		t.Fatal("copying a missing source returned no error")
+	} else if !os.IsNotExist(err) {
+		t.Fatalf("want a not-exist error, got %v", err)
+	}
+}

frontend/src/App.tsx

@@ -16,7 +16,7 @@ import {
   GetStartupStatus, CheckForUpdate, DownloadAndApplyUpdate, GetLiveStations, GetWhatsNew, GetChangelog,
   SMTPConfigured, SendLogToDeveloper,
   WorkedBefore,
-  SetCompactMode,
+  SetCompactMode, SetCompactHeight,
   GetCATState, SetCATFrequency, SetCATMode, SwitchCATRig, FlexApplyBandAntenna, FlexApplyBandPower,
   GetSecretStatus, UnlockSecrets,
   RefreshCtyDat, DownloadAllReferenceLists,
@@ -52,6 +52,7 @@ import {
   GetAmpStatuses, AmpOperate,
   GetFlexState, FlexAmpOperate,
   GetPSKReporterStatus, GetLiveOpenings,
+  QSLViaRepairStatus, RepairQSLVia, DismissQSLViaRepair,
 } from '../wailsjs/go/main/App';
 import { Combobox } from '@/components/ui/combobox';
 import { applyAwardRefs } from '@/lib/awardRefs';
@@ -90,8 +91,8 @@ import { ExportFieldsDialog } from '@/components/ExportFieldsDialog';
 import { ShutdownProgress } from '@/components/ShutdownProgress';
 import { ClusterGrid } from '@/components/ClusterGrid';
 import { cleanSpotter, inferSpotMode, spotModeCategory, spotStatusKey } from '@/lib/spot';
-import { applySpotDisplay, readSpotDisplayOptions, SPOT_DISPLAY_OPTIONS_EXPOSED } from '@/lib/spotDisplay';
-import { GetRowColors } from '../wailsjs/go/main/App';
+import { applySpotDisplay, readSpotDisplayOptions, spotIsWorked, SPOT_DISPLAY_OPTIONS_EXPOSED } from '@/lib/spotDisplay';
+import { GetRowColors, GetSpotTTLMinutes, IsNewUSCounty } from '../wailsjs/go/main/App';
 import { WorkedBeforeGrid } from '@/components/WorkedBeforeGrid';
 import { NetControlPanel } from '@/components/NetControlPanel';
 import { ContestPanel, CONTEST_DEFAULT, type ContestSession } from '@/components/ContestPanel';
@@ -529,6 +530,28 @@ export default function App() {
     setCompact(next);
     SetCompactMode(next);
   }
+  // Fit the compact window to what was actually rendered.
+  //
+  // The height was a constant "tuned so the compact entry strip fits in a single
+  // row". A constant tuned against a layout stops being true the moment the
+  // layout changes, and this one outlived a strip that had since lost a row —
+  // leaving a band of empty window under the fields. Measure instead.
+  const compactRootRef = useRef<HTMLDivElement | null>(null);
+  useEffect(() => {
+    if (!compact) return;
+    const fit = () => {
+      const el = compactRootRef.current;
+      if (!el) return;
+      // Rounded, so a sub-pixel reflow cannot start a resize loop.
+      // + the compact topbar, which is a fixed h-8 (32px), + a couple of pixels
+      // for the border so the strip is never clipped by one row of anti-aliasing.
+      SetCompactHeight(Math.round(el.getBoundingClientRect().height) + 32 + 2);
+    };
+    const id = window.setTimeout(fit, 60); // let the strip paint first
+    const ro = new ResizeObserver(fit);
+    if (compactRootRef.current) ro.observe(compactRootRef.current);
+    return () => { window.clearTimeout(id); ro.disconnect(); };
+  }, [compact]);
 
   // CAT — receives live rig state via Wails events.
   const [catState, setCatState] = useState<CATState>({ enabled: false, connected: false } as any);
@@ -1771,6 +1794,20 @@ export default function App() {
   // close so the next plain "Preferences" launch reverts to default.
   const [settingsSection, setSettingsSection] = useState<string | undefined>(undefined);
   const [showDeleteAll, setShowDeleteAll] = useState(false);
+  // How many QSOs hold a QSL routing word where the manager belongs — null when
+  // there is nothing to offer, or the operator has already answered. Asked once
+  // per log, a moment after startup so it does not race the first paint.
+  const [qslViaRepair, setQslViaRepair] = useState<number | null>(null);
+  useEffect(() => {
+    let alive = true;
+    const id = window.setTimeout(async () => {
+      try {
+        const s: any = await QSLViaRepairStatus();
+        if (alive && !s?.asked && (s?.affected ?? 0) > 0) setQslViaRepair(s.affected);
+      } catch { /* a log we cannot query yet will be offered next start */ }
+    }, 4000);
+    return () => { alive = false; window.clearTimeout(id); };
+  }, []);
   const [showAbout, setShowAbout] = useState(false);
   // "What's new": the changelog for the version(s) since the operator last ran,
   // shown once on the first launch after an update (EN/FR per the UI language).
@@ -1928,6 +1965,31 @@ export default function App() {
   // settings dialog closes, which is the only place it changes.
   const [rowColors, setRowColors] = useState<any>(null);
   useEffect(() => { GetRowColors().then(setRowColors).catch(() => {}); }, [showSettings]);
+  // Spot lifetime (Settings → DX Cluster). Spots are actually REMOVED rather
+  // than filtered at render: the cluster list, every band map and the counts all
+  // read the same array, so pruning it once is what makes the setting mean the
+  // same thing everywhere — and it gives the memory back.
+  const [spotTTLMin, setSpotTTLMin] = useState(0);
+  useEffect(() => { GetSpotTTLMinutes().then(setSpotTTLMin).catch(() => {}); }, [showSettings]);
+  useEffect(() => {
+    if (spotTTLMin <= 0) return; // 0 = keep until the count cap pushes them out
+    const sweep = () => {
+      const cutoff = Date.now() - spotTTLMin * 60_000;
+      setSpots((arr) => {
+        const kept = arr.filter((sp) => {
+          const t = Date.parse((sp as any).received_at ?? '');
+          return isNaN(t) || t >= cutoff; // an unparseable stamp is never a reason to drop a spot
+        });
+        return kept.length === arr.length ? arr : kept;
+      });
+    };
+    sweep();
+    // Half a minute: fine enough that a 5-minute setting is honoured closely,
+    // coarse enough to be invisible next to the spot stream itself.
+    const id = window.setInterval(sweep, 30_000);
+    return () => window.clearInterval(id);
+  }, [spotTTLMin]);
+
   const qsosWithAwards = useMemo(
     () => (qsos as any[]).map((q) => ({ ...q, award_refs: parseAwardRefs(q.award_refs) })),
     [qsos],
@@ -4414,6 +4476,67 @@ export default function App() {
         onBlur={() => setQth(titleCase)} />
     </div>
   );
+  // State sits between QTH and the locator: it is part of the same "where is
+  // this station" reading, and it is what several awards key off (WAS, the US
+  // county work). Narrow — it holds two or three characters.
+  const stateBlock = (
+    <div className="flex flex-col w-[70px] shrink-0"><Label className="mb-1 h-3.5">{t('field.state')}</Label>
+      <Input value={details.state ?? ''} className="font-mono"
+        onChange={(e) => setDetails((d) => ({ ...d, state: e.target.value.toUpperCase() }))} />
+    </div>
+  );
+  // County beside State: the lookup fills QTH, State, County and the locator
+  // together, and they are read together. Wider than State because a county name
+  // is a name — "St. Tammany Parish", not a code.
+  // The row Comment/Note freed by moving onto one line: county, zones and the
+  // ADIF entity number. All four are filled by the lookup and were previously
+  // only visible after opening a tab — which is the wrong place for values an
+  // operator wants to SEE are right before pressing Log.
+  //
+  // A numeric field stores undefined when cleared, not 0: zero is a real DXCC
+  // number for "no entity" and a real answer for a zone, so an empty box must
+  // stay empty rather than assert something.
+  // NEW badge on the county — the same answer the Details tab gives, moved to
+  // where the county is now typed. Debounced: this field is typed into as well
+  // as filled by the lookup, and the check hits the database.
+  const [entryNewCounty, setEntryNewCounty] = useState(false);
+  useEffect(() => {
+    const cnty = (details.cnty ?? '').trim();
+    if (!cnty) { setEntryNewCounty(false); return; }
+    let alive = true;
+    const id = window.setTimeout(async () => {
+      try {
+        const isNew = await IsNewUSCounty(details.state ?? '', cnty);
+        if (alive) setEntryNewCounty(!!isNew);
+      } catch { if (alive) setEntryNewCounty(false); }
+    }, 300);
+    return () => { alive = false; window.clearTimeout(id); };
+  }, [details.state, details.cnty]);
+
+  const num = (v: string): number | undefined => {
+    const s = v.replace(/[^0-9]/g, '');
+    return s === '' ? undefined : parseInt(s, 10);
+  };
+  const geoDetailRow = (
+    <div className="flex gap-4 items-end">
+      <div className="flex flex-col flex-1 min-w-0"><Label className="mb-1 h-3.5">{t('field.cnty')}</Label>
+        <Input value={details.cnty ?? ''}
+          onChange={(e) => setDetails((d) => ({ ...d, cnty: e.target.value }))} />
+      </div>
+      <div className="flex flex-col w-[64px] shrink-0"><Label className="mb-1 h-3.5">{t('field.cqz')}</Label>
+        <Input value={details.cqz ?? ''} className="font-mono"
+          onChange={(e) => setDetails((d) => ({ ...d, cqz: num(e.target.value) }))} />
+      </div>
+      <div className="flex flex-col w-[64px] shrink-0"><Label className="mb-1 h-3.5">{t('field.ituz')}</Label>
+        <Input value={details.ituz ?? ''} className="font-mono"
+          onChange={(e) => setDetails((d) => ({ ...d, ituz: num(e.target.value) }))} />
+      </div>
+      <div className="flex flex-col w-[72px] shrink-0"><Label className="mb-1 h-3.5">{t('field.dxcc')}</Label>
+        <Input value={details.dxcc ?? ''} className="font-mono"
+          onChange={(e) => setDetails((d) => ({ ...d, dxcc: num(e.target.value) }))} />
+      </div>
+    </div>
+  );
   const gridBlock = (
     <div className="flex flex-col w-[76px] shrink-0"><Label className="mb-1 h-3.5">{t('field.grid')}</Label>
       <Input value={grid} placeholder="JN05" className="font-mono" onChange={(e) => { setGrid(e.target.value); markEdited('grid'); }} />
@@ -4717,12 +4840,21 @@ export default function App() {
   // Cluster spots after every active filter (band / mode / status / search /
   // hide-worked / group). Shared by the Cluster tab and the Main-view cluster
   // pane so both show exactly the same list.
-  const clusterRenderedRows = useMemo(() => {
-    const bandsActive = clusterLockBand ? new Set([band]) : clusterBands;
+  // Everything the operator has said about WHICH STATIONS they care about —
+  // LoTW only, the spotter's continent, hide worked, the status and mode chips,
+  // the search box, the source node.
+  //
+  // Shared with the band map, which used to receive the raw stream filtered by
+  // band alone: switching on "LoTW users only" changed the cluster list and left
+  // the panadapter showing everyone. Two views of one spot stream disagreeing
+  // about the same spot is the fault lib/spotDisplay already exists to prevent.
+  //
+  // The BAND filter is deliberately not in here: a band map's band IS its
+  // filter, and applying the cluster's would empty every map but one.
+  const spotPassesStationFilters = useCallback((s: ClusterSpot): boolean => {
     const search = clusterSearch.trim().toUpperCase();
-    const list = spots.filter((s) => {
+    {
       if (clusterFilterSource && s.source_id !== clusterFilterSource) return false;
-      if (bandsActive.size > 0 && !bandsActive.has(s.band ?? '')) return false;
       if (search && !s.dx_call.includes(search)) return false;
       if (clusterLockMode) {
         const spotMode = inferSpotMode(s.comment ?? '', s.freq_hz);
@@ -4771,9 +4903,27 @@ export default function App() {
         const k = spotStatusKey(s.dx_call, s.band ?? '', s.comment ?? '', s.freq_hz);
         const e = spotStatus[k];
         if (!e) return false;
-        if (e.worked_call || e.status === 'worked') return false;
+        // A spot that is NEW for something is not "worked", whatever the entity
+        // says. The extra markers are orthogonal to the entity status — the same
+        // rule the band map already states — so a new prefix, county, grid or
+        // park in an entity worked years ago is exactly what an operator is
+        // hunting, and hiding it is the opposite of what was asked.
+        //
+        // Reported on BH2SWB and 4X9AA: both flagged NEW PFX, neither ever
+        // worked, both vanished the moment "hide worked" went on.
+        const isNew = !!(e.new_pota || e.new_county || e.new_pfx || e.new_grid);
+        if (!isNew && (e.worked_call || e.status === 'worked')) return false;
       }
       return true;
+    }
+  }, [clusterFilterSource, clusterSearch, clusterLockMode, mode, clusterModeFilter,
+    clusterStatusFilter, spotStatus, clusterLotwOnly, clusterSpotterConts, clusterHideWorked]);
+
+  const clusterRenderedRows = useMemo(() => {
+    const bandsActive = clusterLockBand ? new Set([band]) : clusterBands;
+    const list = spots.filter((s) => {
+      if (bandsActive.size > 0 && !bandsActive.has(s.band ?? '')) return false;
+      return spotPassesStationFilters(s);
     });
     let rendered = list as (ClusterSpot & { repeats?: number })[];
     if (clusterGroup) {
@@ -5779,7 +5929,7 @@ export default function App() {
           Enter from any <input> inside the strip logs the QSO. Radix Selects
           render as <button> elements and are ignored by this handler — they
           keep their own keyboard behaviour. */}
-      <div className={cn(!compact && 'flex gap-2.5 items-stretch px-2.5 pt-2.5 shrink-0')}>
+      <div ref={compactRootRef} className={cn(!compact && 'flex gap-2.5 items-stretch px-2.5 pt-2.5 shrink-0')}>
       <section
         className={cn('bg-card shadow-sm border-border',
           compact
@@ -5834,25 +5984,30 @@ export default function App() {
                 to be pushed outside the entry panel and clipped. Wrapping drops
                 it to its own line instead, which stays readable. */}
             <div className="flex gap-4 items-end flex-wrap">
-              <div className="flex flex-col w-[300px] shrink-0"><Label className="mb-1 h-3.5">Name</Label>
+              <div className="flex flex-col w-[230px] shrink-0"><Label className="mb-1 h-3.5">{t('field.name')}</Label>
                 <Input value={name} onChange={(e) => { setName(e.target.value); markEdited('name'); }}
                   onBlur={() => setName(titleCase)} />
               </div>
               {qthBlock}
+              {stateBlock}
               {gridBlock}
             </div>
 
             {/* Row 3: tight left detail column (Band/Mode/Country) and
-                single-line Comment/Note on the right. */}
+                Comment/Note SIDE BY SIDE on the right — one line each was a lot
+                of vertical space for two fields that are usually short. */}
             <div className="flex gap-4 items-start">
-              <div className="flex flex-col gap-1.5 w-[300px] shrink-0">
+              <div className="flex flex-col gap-1.5 w-[230px] shrink-0">
                 {bandRow}
                 {modeRow}
                 {countryRow}
               </div>
               <div className="flex flex-col gap-1.5 flex-1 min-w-0">
-                {commentLine}
-                {noteLine}
+                {geoDetailRow}
+                <div className="flex gap-4">
+                  <div className="flex-1 min-w-0">{commentLine}</div>
+                  <div className="flex-1 min-w-0">{noteLine}</div>
+                </div>
               </div>
             </div>
 
@@ -6775,13 +6930,14 @@ export default function App() {
                     </div>
                     <BandMap
                       band={b}
-                      spots={spots.filter((s) => s.band === b)}
+                      spots={spots.filter((s) => s.band === b && spotPassesStationFilters(s))}
                       spotStatus={spotStatus}
                       currentFreqHz={band === b && freqMhz ? Math.round(parseFloat(freqMhz) * 1_000_000) : 0}
                       onSpotClick={handleSpotClick}
                       onClose={() => toggleBandMapBand(b)}
                       hideDigital={bandMapHideFt}
                       fitToBand={bandMapFit}
+                      showLotw={!!rowColors?.bandmap_lotw}
                     />
                   </div>
                 ))}
@@ -6811,11 +6967,12 @@ export default function App() {
               side={bandMapSide}
               onToggleSide={toggleBandMapSide}
               band={band}
-              spots={spots.filter((s) => s.band === band)}
+              spots={spots.filter((s) => s.band === band && spotPassesStationFilters(s))}
               spotStatus={spotStatus}
               currentFreqHz={band && freqMhz ? Math.round(parseFloat(freqMhz) * 1_000_000) : 0}
               onSpotClick={handleSpotClick}
               onClose={() => setBandMapShown(false)}
+              showLotw={!!rowColors?.bandmap_lotw}
               keyNav
             />
           </div>
@@ -7133,6 +7290,27 @@ export default function App() {
           />
         );
       })()}
+      {/* One-time offer to move QSL routing words out of the manager field.
+          Shown with a count and never acted on without an answer: it rewrites
+          what the operator sees in their own log. Either answer is final —
+          asking again after a "no" would be a nag. */}
+      {qslViaRepair !== null && (
+        <ConfirmDialog
+          title={t('qslvia.title')}
+          message={t('qslvia.body', { n: qslViaRepair.toLocaleString() })}
+          confirmLabel={t('qslvia.confirm')}
+          cancelLabel={t('qslvia.cancel')}
+          onConfirm={async () => {
+            const n = qslViaRepair;
+            setQslViaRepair(null);
+            try {
+              const r: any = await RepairQSLVia();
+              showToast(t('qslvia.done', { n: (r?.moved ?? n).toLocaleString() }));
+            } catch { /* the log keeps the reason; nothing to undo */ }
+          }}
+          onCancel={() => { setQslViaRepair(null); DismissQSLViaRepair().catch(() => {}); }}
+        />
+      )}
       {showDeleteAll && (
         <ConfirmDialog
           title="Delete ALL QSOs?"

frontend/src/components/AppearancePanel.tsx

@@ -17,10 +17,17 @@ const PALETTE = [
 // The rule ids the backend orders; the labels live here so a translation never
 // travels through the settings row.
 const LABELS: Record<string, string> = {
-  confirmed_lotw: 'appr.confirmedLotw',
-  confirmed_paper: 'appr.confirmedPaper',
-  sent_waiting: 'appr.sentWaiting',
-  to_send: 'appr.toSend',
+  to_send: 'appr.ruleToSend',
+  confirmed: 'appr.ruleConfirmed',
+  sent: 'appr.ruleSent',
+  worked: 'appr.ruleWorked',
+};
+
+// 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 CHANNEL_LABELS: Record<string, string> = {
+  qsl: 'appr.chQsl', lotw: 'LoTW', eqsl: 'eQSL', qrz: 'QRZ.com',
 };
 
 export function AppearancePanel() {
@@ -37,15 +44,32 @@ export function AppearancePanel() {
     setCfg(next);
     SaveRowColors(next as any).catch(() => {});
   };
-  const patchRule = (id: string, patch: Partial<{ color: string; enabled: boolean }>) => {
+  const patchRule = (id: string, patch: Partial<{ color: string; enabled: boolean; channels: string[] }>) => {
     if (!cfg) return;
     save({ ...cfg, rules: cfg.rules.map((r) => (r.id === id ? { ...r, ...patch } : r)) });
   };
 
+  // The rule card shows the row exactly as the grid will draw it, so the choice
+  // is made by looking rather than by imagining.
+  const preview = (color: string): Record<string, string> => {
+    const st = cfg?.style ?? 'bar';
+    const pct = cfg?.intensity ?? 12;
+    const out: Record<string, string> = {};
+    if (st === 'tint' || st === 'both') out.backgroundColor = `color-mix(in srgb, ${color} ${pct}%, transparent)`;
+    if (st === 'bar' || st === 'both') out.boxShadow = `inset 3px 0 0 ${color}`;
+    return out;
+  };
+
   if (!cfg) return <div className="p-1 text-sm text-muted-foreground">…</div>;
 
   return (
     <div className="space-y-4">
+      <label className="flex items-start gap-2 text-sm cursor-pointer">
+        <Checkbox checked={!!cfg.bandmap_lotw} className="mt-0.5"
+          onCheckedChange={(c) => save({ ...cfg, bandmap_lotw: !!c } as any)} />
+        <span>{t('appr.bandmapLotw')} <span className="text-xs text-muted-foreground">{t('appr.bandmapLotwHint')}</span></span>
+      </label>
+
       <label className="flex items-start gap-2 text-sm cursor-pointer">
         <Checkbox checked={cfg.enabled} className="mt-0.5"
           onCheckedChange={(c) => save({ ...cfg, enabled: !!c })} />
@@ -53,18 +77,59 @@ export function AppearancePanel() {
       </label>
 
       {cfg.enabled && (
-        <div className="space-y-2">
+        <div className="space-y-3">
+          {/* Style first: it decides whether the colours below are a signal or a
+              wallpaper, which matters more than which hue they are. */}
+          <div className="flex items-center gap-3 flex-wrap">
+            <span className="text-sm">{t('appr.style')}</span>
+            <div className="inline-flex rounded-md border border-border overflow-hidden text-xs">
+              {(['bar', 'tint', 'both'] as const).map((v) => (
+                <button key={v} type="button" onClick={() => save({ ...cfg, style: v })}
+                  className={cn('px-3 py-1.5 font-medium', (cfg.style ?? 'bar') === v ? 'bg-primary text-primary-foreground' : 'text-muted-foreground hover:bg-muted')}>
+                  {t('appr.style' + v[0].toUpperCase() + v.slice(1))}
+                </button>
+              ))}
+            </div>
+            {(cfg.style ?? 'bar') !== 'bar' && (
+              <label className="flex items-center gap-2 text-sm">
+                {t('appr.intensity')}
+                <input type="range" min={5} max={45} step={1} value={cfg.intensity ?? 12}
+                  onChange={(e) => save({ ...cfg, intensity: parseInt(e.target.value, 10) })}
+                  className="w-32 accent-[var(--primary)]" />
+                <span className="font-mono text-xs text-muted-foreground w-8">{cfg.intensity ?? 12}%</span>
+              </label>
+            )}
+          </div>
           {/* Order matters and is shown: a contact is usually several of these at
               once, and the first match wins. */}
           <p className="text-xs text-muted-foreground">{t('appr.orderHint')}</p>
           {cfg.rules.map((r, i) => (
             <div key={r.id} className="rounded-lg border border-border/60 p-2.5 space-y-2"
-              style={{ backgroundColor: r.enabled ? `color-mix(in srgb, ${r.color} 24%, transparent)` : undefined }}>
+              style={r.enabled ? preview(r.color) : undefined}>
               <label className="flex items-center gap-2 text-sm cursor-pointer">
                 <Checkbox checked={r.enabled} onCheckedChange={(c) => patchRule(r.id, { enabled: !!c })} />
                 <span className="font-mono text-xs text-muted-foreground">{i + 1}.</span>
                 <span className="font-medium">{t(LABELS[r.id] ?? r.id)}</span>
               </label>
+              {/* Which channels this category looks at. None ticked = all of
+                  them, which is what an unnarrowed rule should mean. */}
+              {r.enabled && r.id !== 'worked' && (
+                <div className="flex items-center gap-3 flex-wrap pl-6 text-xs">
+                  {CHANNELS.map((c) => {
+                    const on = !r.channels?.length || r.channels.includes(c);
+                    return (
+                      <label key={c} className="flex items-center gap-1.5 cursor-pointer">
+                        <Checkbox checked={on} onCheckedChange={(v) => {
+                          const cur = r.channels?.length ? r.channels : [...CHANNELS];
+                          const next = v ? [...new Set([...cur, c])] : cur.filter((x) => x !== c);
+                          patchRule(r.id, { channels: next });
+                        }} />
+                        {CHANNEL_LABELS[c]?.startsWith('appr.') ? t(CHANNEL_LABELS[c]) : CHANNEL_LABELS[c]}
+                      </label>
+                    );
+                  })}
+                </div>
+              )}
               {r.enabled && (
                 <div className="flex items-center gap-1.5 flex-wrap pl-6">
                   {PALETTE.map((c) => (

frontend/src/components/BandMap.tsx

@@ -38,6 +38,9 @@ type SpotStatusEntry = {
   new_county?: boolean;
   new_pota?: boolean;
   new_pfx?: boolean;
+  // Whether the station uploads to LoTW. Not a status — it says nothing about
+  // whether the spot is worth chasing — so it is drawn as a badge, never a colour.
+  lotw?: boolean;
 };
 
 // The extra markers are ORTHOGONAL to the entity status: a spot can be a worked
@@ -79,6 +82,8 @@ interface Props {
   // globally from the band-map tab toolbar.
   hideDigital?: boolean;
   fitToBand?: boolean;
+  // Mark stations that upload to LoTW (Settings → Appearance).
+  showLotw?: boolean;
   // keyNav enables Ctrl+↑ / Ctrl+↓ to hop to the next spot above / below the rig
   // frequency (and tune to it). Only the docked Main-view band map sets this, so
   // the multi-band Band Map tab (several maps) doesn't fight over the shortcut.
@@ -227,7 +232,7 @@ const BOT_PAD = 14;    // the top-most freq label isn't clipped at y=0
 // last; ties broken by closeness to the rig freq).
 const MAX_VISIBLE_SPOTS = 30;
 
-export function BandMap({ band, spots, spotStatus: spotStatusRaw, currentFreqHz, onSpotClick, onClose, side = 'right', onToggleSide, hideDigital = false, fitToBand = false, keyNav = false }: Props) {
+export function BandMap({ band, spots, spotStatus: spotStatusRaw, currentFreqHz, onSpotClick, onClose, side = 'right', onToggleSide, hideDigital = false, fitToBand = false, keyNav = false, showLotw = false }: Props) {
   const { t } = useI18n();
 
   // The two display options are applied ONCE here, on the whole map, so the
@@ -649,6 +654,15 @@ export function BandMap({ band, spots, spotStatus: spotStatusRaw, currentFreqHz,
                 })()}
                 <span className="flex items-center gap-1.5 px-2 font-mono text-[11px] font-bold leading-none">
                   <span>{p.spot.dx_call}</span>
+                  {/* Same badge the cluster list draws, for the same reason: the
+                      muted-blue of a confirmation, never a status colour —
+                      whether a station uploads to LoTW says nothing about
+                      whether the spot is worth chasing. A glyph rather than a
+                      colour also keeps it off the channel the statuses use. */}
+                  {showLotw && entry?.lotw && (
+                    <span title={t('clu.lotwBadge')} className="text-[9px] font-normal rounded px-1 py-px"
+                      style={{ background: 'color-mix(in srgb, var(--info) 22%, transparent)', color: 'var(--info)' }}>L</span>
+                  )}
                   {mode && (
                     <span className="text-[9px] font-normal text-current/70 bg-current/10 rounded px-1 py-px">
                       {mode}

frontend/src/components/BulkEditModal.tsx

@@ -30,6 +30,8 @@ const FIELDS: FieldDef[] = [
   { id: 'qsl_rcvd',          label: 'bulk.fQslRcvd',         group: 'QSL / upload', kind: 'status' },
   { id: 'qsl_rcvd_date',     label: 'bulk.fQslRcvdDate',     group: 'QSL / upload', kind: 'date' },
   { id: 'qsl_via',           label: 'bulk.fQslVia',          group: 'QSL / upload', kind: 'text' },
+  { id: 'qsl_sent_via',      label: 'bulk.fQslSentVia',      group: 'QSL / upload', kind: 'text' },
+  { id: 'qsl_rcvd_via',      label: 'bulk.fQslRcvdVia',      group: 'QSL / upload', kind: 'text' },
   { id: 'lotw_sent',         label: 'bulk.fLotwSent',        group: 'QSL / upload', kind: 'status' },
   { id: 'lotw_sent_date',    label: 'bulk.fLotwSentDate',    group: 'QSL / upload', kind: 'date' },
   { id: 'lotw_rcvd',         label: 'bulk.fLotwRcvd',        group: 'QSL / upload', kind: 'status' },

frontend/src/components/FilterBuilder.tsx

@@ -68,6 +68,8 @@ const FIELDS: { value: string; label: string; type: FieldType }[] = [
   { value: 'qsl_rcvd', label: 'fltb.fQslRcvd', type: 'text' },
   { value: 'qsl_rcvd_date', label: 'fltb.fQslRcvdDate', type: 'adifdate' },
   { value: 'qsl_via', label: 'fltb.fQslVia', type: 'text' },
+  { value: 'qsl_sent_via', label: 'fltb.fQslSentVia', type: 'text' },
+  { value: 'qsl_rcvd_via', label: 'fltb.fQslRcvdVia', type: 'text' },
   { value: 'lotw_sent', label: 'fltb.fLotwSent', type: 'text' },
   { value: 'lotw_sent_date', label: 'fltb.fLotwSentDate', type: 'adifdate' },
   { value: 'lotw_rcvd', label: 'fltb.fLotwRcvd', type: 'text' },

frontend/src/components/QSLManagerModal.tsx

@@ -57,9 +57,9 @@ const QSL_STATUSES = [
 // QSL routing methods for the paper-QSL "Via" dropdown (was free text).
 const QSL_VIA_OPTIONS = [
   { v: '_', label: 'qslm.leave' },
-  { v: 'Bureau', label: 'qslm.viaBureau' },
-  { v: 'Direct', label: 'qslm.viaDirect' },
-  { v: 'Electronic', label: 'qslm.viaElectronic' },
+  { v: 'B', label: 'qslm.viaBureau' },
+  { v: 'D', label: 'qslm.viaDirect' },
+  { v: 'E', label: 'qslm.viaElectronic' },
 ];
 
 // Maps a service value → its i18n label key (only for services with

frontend/src/components/QSOEditModal.tsx

@@ -57,10 +57,12 @@ type ConfDef = {
   key: string; label: string;
   sent?: keyof QSOForm; rcvd?: keyof QSOForm;
   sentDate?: keyof QSOForm; rcvdDate?: keyof QSOForm;
-  via?: keyof QSOForm;
+  // How the card travelled, each way (ADIF QSL_SENT_VIA / QSL_RCVD_VIA). Paper
+  // only — the electronic channels below ARE the route.
+  sentVia?: keyof QSOForm; rcvdVia?: keyof QSOForm;
 };
 const CONFIRMATIONS: ConfDef[] = [
-  { key: 'QSL',     label: 'QSL (paper)', sent: 'qsl_sent',  rcvd: 'qsl_rcvd',  sentDate: 'qsl_sent_date',  rcvdDate: 'qsl_rcvd_date',  via: 'qsl_via' },
+  { key: 'QSL',     label: 'QSL (paper)', sent: 'qsl_sent',  rcvd: 'qsl_rcvd',  sentDate: 'qsl_sent_date',  rcvdDate: 'qsl_rcvd_date',  sentVia: 'qsl_sent_via', rcvdVia: 'qsl_rcvd_via' },
   { key: 'LOTW',    label: 'LoTW',        sent: 'lotw_sent', rcvd: 'lotw_rcvd', sentDate: 'lotw_sent_date', rcvdDate: 'lotw_rcvd_date' },
   { key: 'EQSL',    label: 'eQSL',        sent: 'eqsl_sent', rcvd: 'eqsl_rcvd', sentDate: 'eqsl_sent_date', rcvdDate: 'eqsl_rcvd_date' },
   { key: 'QRZCOM',  label: 'QRZ.com',     sent: 'qrzcom_qso_upload_status' as any, sentDate: 'qrzcom_qso_upload_date' as any, rcvd: 'qrzcom_qso_download_status' as any, rcvdDate: 'qrzcom_qso_download_date' as any },
@@ -216,6 +218,28 @@ function QslSelect({ value, onChange }: { value?: string; onChange: (v: string)
   );
 }
 
+// The ADIF QSL Via enumeration. M (manager) is import-only in the standard, so
+// it is not offered here — a file that arrives carrying it keeps it, and this
+// list is what an operator may choose.
+const QSL_VIA_CHOICES = [
+  { value: '_', label: 'qedit.qslDash' },
+  { value: 'B', label: 'qedit.viaBureau' },
+  { value: 'D', label: 'qedit.viaDirect' },
+  { value: 'E', label: 'qedit.viaElectronic' },
+];
+
+function QslViaSelect({ value, onChange }: { value?: string; onChange: (v: string) => void }) {
+  const { t } = useI18n();
+  return (
+    <Select value={value || '_'} onValueChange={(v) => onChange(v === '_' ? '' : v)}>
+      <SelectTrigger><SelectValue /></SelectTrigger>
+      <SelectContent>
+        {QSL_VIA_CHOICES.map((s) => <SelectItem key={s.value} value={s.value}>{t(s.label)}</SelectItem>)}
+      </SelectContent>
+    </Select>
+  );
+}
+
 export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], bands, modes }: Props) {
   const { t } = useI18n();
   // Use the operator's configured band/mode lists (incl. custom ones like 13cm);
@@ -633,7 +657,12 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
                     <Label>{t('qedit.qslMsg')}</Label>
                     <Input value={draft.qsl_msg ?? ''} onChange={(e) => set('qsl_msg', e.target.value)} />
                   </div>
-                  <div><Label>{t('qedit.qslVia')}</Label><Input value={draft.qsl_via ?? ''} onChange={(e) => set('qsl_via', e.target.value)} /></div>
+                  {/* The manager, and only the manager — ADIF QSL_VIA. How the
+                      card travelled is a separate field, on the QSL Info tab. */}
+                  <div>
+                    <Label>{t('qedit.qslVia')}</Label>
+                    <Input value={draft.qsl_via ?? ''} onChange={(e) => set('qsl_via', e.target.value)} placeholder={t('qedit.qslViaPlaceholder')} />
+                  </div>
                 </div>
               </div>
             </TabsContent>
@@ -734,8 +763,14 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
                             </div>
                             <div><Label>{t('qedit.dateSent')}</Label><AdifDateInput value={val(def.sentDate)} onChange={(v) => put(def.sentDate, v)} /></div>
                             <div><Label>{t('qedit.dateReceived')}</Label><AdifDateInput value={val(def.rcvdDate)} onChange={(v) => put(def.rcvdDate, v)} disabled={!def.rcvdDate} /></div>
-                            {def.via && (
-                              <div className="col-span-2"><Label>{t('qedit.via')}</Label><Input value={val(def.via)} onChange={(e) => put(def.via, e.target.value)} placeholder={t('qedit.viaPlaceholder')} /></div>
+                            {/* How the card travelled, each way — ADIF's QSL Via
+                                enumeration. Not the manager: that is a callsign
+                                and lives on the Contact's details tab. */}
+                            {def.sentVia && (
+                              <div><Label>{t('qedit.sentVia')}</Label><QslViaSelect value={val(def.sentVia)} onChange={(v) => put(def.sentVia, v)} /></div>
+                            )}
+                            {def.rcvdVia && (
+                              <div><Label>{t('qedit.rcvdVia')}</Label><QslViaSelect value={val(def.rcvdVia)} onChange={(v) => put(def.rcvdVia, v)} /></div>
                             )}
                           </div>
                           <p className="text-[11px] text-muted-foreground">

frontend/src/components/RecentQSOsGrid.tsx

@@ -186,6 +186,8 @@ export const makeColCatalog = (t: TFn, myGrid?: string): ColEntry[] => [
   { group: 'QSL',  label: t('rqg.c.qsl_sent_date'),colId: 'qsl_sent_date', headerName: t('rqg.h.qsl_sent_date'), field: 'qsl_sent_date' as any, width: 120, valueFormatter: (p) => fmtDateOnly(p.value) },
   { group: 'QSL',  label: t('rqg.c.qsl_rcvd_date'),colId: 'qsl_rcvd_date', headerName: t('rqg.h.qsl_rcvd_date'), field: 'qsl_rcvd_date' as any, width: 120, valueFormatter: (p) => fmtDateOnly(p.value) },
   { group: 'QSL',  label: t('rqg.c.qsl_via'),      colId: 'qsl_via',       headerName: t('rqg.c.qsl_via'),    field: 'qsl_via' as any,       width: 130 },
+  { group: 'QSL',  label: t('rqg.c.qsl_sent_via'), colId: 'qsl_sent_via',  headerName: t('rqg.h.qsl_sent_via'), field: 'qsl_sent_via' as any, width: 110 },
+  { group: 'QSL',  label: t('rqg.c.qsl_rcvd_via'), colId: 'qsl_rcvd_via',  headerName: t('rqg.h.qsl_rcvd_via'), field: 'qsl_rcvd_via' as any, width: 110 },
   { group: 'QSL',  label: t('rqg.c.qsl_msg'),      colId: 'qsl_msg',       headerName: t('rqg.c.qsl_msg'),    field: 'qsl_msg' as any,       width: 200 },
   { group: 'QSL',  label: t('rqg.c.qslmsg_rcvd'), colId: 'qslmsg_rcvd',   headerName: t('rqg.c.qslmsg_rcvd'), field: 'qslmsg_rcvd' as any, width: 200 },
 

frontend/src/components/RotorCompass.tsx

@@ -128,7 +128,9 @@ export function RotorCompass({ bearing, headings, boomHeading, pattern, centerLa
         </div>
       )}
 
-      <div className="flex items-center justify-center p-2 min-h-0">
+      {/* flex-col: the readout goes BELOW the dial. This wrapper was a row, so a
+          sibling of the <svg> landed beside it. */}
+      <div className="flex flex-col items-center justify-center p-2 min-h-0">
         <svg
           viewBox={`0 0 ${SIZE} ${SIZE}`}
           className={onGoto ? 'cursor-pointer select-none' : 'select-none'}
@@ -188,6 +190,31 @@ export function RotorCompass({ bearing, headings, boomHeading, pattern, centerLa
           ); })}
           <circle cx={C} cy={C} r={3.5} fill="#15803d" stroke="#fff" strokeWidth={1} />
         </svg>
+
+        {/* Short and long path to the DX, in figures.
+            The bezel already carries the short path as a red marker, but a
+            marker is a direction, not a number — the same pair sits in the
+            status bar at 10px and operators reported not being able to read it.
+            Here because it belongs to the compass: every place that draws one
+            gets the readout, instead of each caller inventing its own.
+            Clickable when the caller can turn, like the status bar's. */}
+        <div className="flex gap-1.5 mt-2 font-mono w-full">
+          {([['SP', bearing ?? null], ['LP', bearing == null ? null : (bearing + 180) % 360]] as const).map(([lbl, az]) => (
+            <button key={lbl} type="button" disabled={az == null || !onGoto}
+              onClick={() => { if (az != null && onGoto) onGoto(Math.round(az)); }}
+              title={az == null ? '' : `${lbl} ${Math.round(az)}°`}
+              className={
+                'flex-1 rounded-md border py-1 text-xs font-semibold tabular-nums transition-colors ' +
+                (az == null
+                  ? 'border-border text-muted-foreground/50 cursor-not-allowed'
+                  : onGoto
+                    ? 'border-info-border text-info-muted-foreground hover:bg-info-muted cursor-pointer'
+                    : 'border-border text-muted-foreground cursor-default')
+              }>
+              {lbl} {az == null ? '—' : `${Math.round(az)}°`}
+            </button>
+          ))}
+        </div>
       </div>
     </section>
   );

frontend/src/components/SettingsModal.tsx

@@ -52,7 +52,7 @@ import {
   GetADIFMonitor, SaveADIFMonitor, PickADIFMonitorFile,
   GetRelayAuto, SaveRelayAuto, GetStationDevices,
   GetAwardDefs, GetTrackedAwards, SaveTrackedAwards,
-  GetBandOpenSettings, SaveBandOpenSettings, GetPSKReporterStatus, GetChaseNewGrids, SetChaseNewGrids, GetGridCacheStatus,
+  GetBandOpenSettings, SaveBandOpenSettings, GetPSKReporterStatus, GetChaseNewGrids, SetChaseNewGrids, GetGridCacheStatus, GetLinkedAmps, SetLinkedAmps, GetSpotTTLMinutes, SetSpotTTLMinutes,
 } from '../../wailsjs/go/main/App';
 import type { profile as profileModels } from '../../wailsjs/go/models';
 import type { LookupSettingsForm, StationSettingsForm, ListsSettingsForm, ModePresetForm } from '@/types';
@@ -412,6 +412,7 @@ const THEME_SWATCH: Record<Exclude<ThemeChoice, 'auto'>, { bg: string; card: str
   'light-warm':    { bg: '#e8dfc9', card: '#faf6ea', accent: '#b8410c' },
   'light-cool':    { bg: '#f4f6f8', card: '#ffffff', accent: '#2563eb' },
   'light-sage':    { bg: '#eef1ec', card: '#f8faf6', accent: '#2f855a' },
+  'sahara':        { bg: '#dcceab', card: '#faf6eb', accent: '#a55f14' },
   'light-nordic':  { bg: '#eef1f7', card: '#ffffff', accent: '#4f46e5' },
   'dim-slate':     { bg: '#343b47', card: '#3d4552', accent: '#fb923c' },
   'dark-warm':     { bg: '#221d18', card: '#2e2820', accent: '#e07a2e' },
@@ -1224,6 +1225,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     hamqth_user: '', hamqth_password: '',
     primary: '', failsafe: '',
     download_images: false,
+    qrz_prefer_nickname: false,
     cache_ttl_days: 30,
   });
   // Per-provider Test state — keeps the success/error feedback adjacent
@@ -1273,6 +1275,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   // Amplifier list — operators can run SEVERAL amps (even two SPEs combined),
   // each with its own connection. Saved as a whole via SaveAmplifiers.
   const [amps, setAmps] = useState<AmpUI[]>([]);
+  const [linkedAmps, setLinkedAmps] = useState<string[]>([]);
 
   // WinKeyer CW keyer settings + macro editor.
   type WKMac = { label: string; text: string };
@@ -1441,13 +1444,15 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     tqsl_path: string; station_location: string; key_password: string;
     upload_flags: string[]; write_log: boolean;
     auto_upload: boolean; upload_mode: string;
+    // 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 };
   const emptyExtCfg = (): ExtServiceCfg => ({
     api_key: '', url: '', station_id: '', email: '', username: '', password: '', callsign: '', code: '', qth_nickname: '',
     force_station_callsign: '', tqsl_path: '', station_location: '', key_password: '',
     upload_flags: ['N', 'R'], write_log: false,
-    auto_upload: false, upload_mode: 'immediate',
+    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,
@@ -1484,7 +1489,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     finally { setScpBusy(false); }
   };
   // US Counties (offline FCC ULS) — download progress arrives via events.
-  const [ulsStatus, setUlsStatus] = useState<{ count: number; updated_at?: string }>({ count: 0 });
+  const [ulsStatus, setUlsStatus] = useState<{ count: number; updated_at?: string; needs_refresh?: boolean }>({ count: 0 });
   const [ulsBusy, setUlsBusy] = useState(false);
   const [ulsProgress, setUlsProgress] = useState<{ stage: string; pct: number } | null>(null);
   const [ulsMsg, setUlsMsg] = useState<{ ok: boolean; text: string } | null>(null);
@@ -1556,6 +1561,8 @@ 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: [] });
   const [chaseGrids, setChaseGrids] = useState(false);
+  const [spotTTL, setSpotTTL] = useState(0);
+  const [spotTTLText, setSpotTTLText] = useState('0');
   const [gridStat, setGridStat] = useState<any>(null);
   const [pskrStatus, setPskrStatus] = useState<any>(null);
   const saveBandOpen = async (next: any) => {
@@ -1566,6 +1573,8 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     (async () => {
       try { setBandOpen(await GetBandOpenSettings()); } catch { /* defaults stand */ }
       try { setChaseGrids(await GetChaseNewGrids()); } catch { /* defaults stand */ }
+      try { setLinkedAmps((await GetLinkedAmps()) ?? []); } catch { /* defaults stand */ }
+      try { const n = await GetSpotTTLMinutes(); setSpotTTL(n); setSpotTTLText(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".
@@ -2309,6 +2318,23 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
               </span>
             </span>
           </label>
+
+          {/* QRZ only. HamQTH's <nick> already fills the Name field with the
+              on-air name, so the same switch there would toggle a behaviour it
+              has no way to turn off. */}
+          <label className="flex items-start gap-2 text-sm cursor-pointer mt-3">
+            <Checkbox
+              checked={!!(lookup as any).qrz_prefer_nickname}
+              onCheckedChange={(c) => setLookup((s) => ({ ...s, qrz_prefer_nickname: !!c } as any))}
+              className="mt-0.5"
+            />
+            <span>
+              {t('lk.qrzNickname')}
+              <span className="block text-xs text-muted-foreground mt-0.5">
+                {t('lk.qrzNicknameHint')}
+              </span>
+            </span>
+          </label>
         </div>
 
         <div className="mt-6 pt-4 border-t border-border">
@@ -3579,6 +3605,38 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             <Plus className="size-3.5 mr-1" /> {t('amp.add')}
           </Button>
 
+          {/* WHICH amplifiers are coupled, not whether coupling is on.
+              A station can run a combiner pair AND a third amplifier that has
+              nothing to do with it — two SPE on the combiner, a PowerGenius on
+              another antenna — so a single switch would send that third one into
+              OPERATE alongside them. Shown from two amplifiers up. */}
+          {amps.length > 1 && (
+            <div className="border-t border-border/60 pt-3 space-y-2">
+              <div className="text-sm">{t('amp.linked')}</div>
+              <p className="text-xs text-muted-foreground">{t('amp.linkedHint')}</p>
+              <div className="flex flex-wrap gap-x-4 gap-y-1.5">
+                {amps.filter((x) => (x.id ?? '') !== '').map((x) => {
+                  const on = linkedAmps.includes(x.id!);
+                  return (
+                    <label key={x.id} className="flex items-center gap-1.5 text-sm cursor-pointer">
+                      <Checkbox checked={on} onCheckedChange={(c) => {
+                        const next = c ? [...linkedAmps, x.id!] : linkedAmps.filter((v) => v !== x.id);
+                        setLinkedAmps(next);
+                        SetLinkedAmps(next).catch(() => {});
+                      }} />
+                      {x.name?.trim() || x.type}
+                    </label>
+                  );
+                })}
+              </div>
+              {/* An amplifier saved without an id cannot be a member — say so
+                  rather than silently leaving it out of the list. */}
+              {amps.some((x) => (x.id ?? '') === '') && (
+                <p className="text-xs text-muted-foreground">{t('amp.linkedSaveFirst')}</p>
+              )}
+            </div>
+          )}
+
         </div>
       </>
     );
@@ -4237,6 +4295,35 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
           {/* Grid chasing. Here rather than in the filter panel because it is set
               up once: it decides whether locators learnt from decodes are KEPT
               across restarts, not what the list shows right now. */}
+          {/* Spot lifetime. Applies to the cluster list AND every band map: the
+              spots are removed from the shared list rather than hidden, so the
+              setting cannot mean one thing in one view and another elsewhere. */}
+          <div className="border-t border-border/60 pt-3 space-y-2">
+            <div className="flex items-center gap-3 flex-wrap">
+              <span className="text-sm">{t('clu.spotTtl')}</span>
+              <div className="inline-flex rounded-md border border-border overflow-hidden text-xs">
+                {[0, 5, 10, 15, 30, 60].map((v) => (
+                  <button key={v} type="button"
+                    onClick={() => { setSpotTTL(v); setSpotTTLText(String(v)); SetSpotTTLMinutes(v).catch(() => {}); }}
+                    className={cn('px-2.5 py-1.5 font-medium', spotTTL === v ? 'bg-primary text-primary-foreground' : 'text-muted-foreground hover:bg-muted')}>
+                    {v === 0 ? t('clu.spotTtlNever') : `${v}′`}
+                  </button>
+                ))}
+              </div>
+              {/* Raw text in local state: binding the input straight to the
+                  clamped number makes an empty field impossible to type into. */}
+              <Input className="h-8 w-20" value={spotTTLText}
+                onChange={(e) => {
+                  const raw = e.target.value.replace(/[^0-9]/g, '');
+                  setSpotTTLText(raw);
+                  const n = Math.min(720, parseInt(raw, 10) || 0);
+                  setSpotTTL(n);
+                  SetSpotTTLMinutes(n).catch(() => {});
+                }} />
+              <span className="text-xs text-muted-foreground">{t('clu.spotTtlHint')}</span>
+            </div>
+          </div>
+
           <div className="border-t border-border/60 pt-3 space-y-2">
             <label className="flex items-start gap-2 text-sm cursor-pointer">
               <Checkbox checked={chaseGrids} className="mt-0.5"
@@ -4969,6 +5056,20 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                 {t('es.autoUpload')}
               </label>
 
+              {/* ON AIR is a live status, not an upload: it needs the rig
+                  readable, not a QSO. Its own switch beside the upload one
+                  rather than folded into it. */}
+              <label className="flex items-start gap-2 text-sm cursor-pointer">
+                <Checkbox className="mt-0.5"
+                  checked={!!(hrdlog as any).on_air}
+                  onCheckedChange={(c) => setHrdlog({ on_air: !!c } as any)}
+                />
+                <span>
+                  {t('es.hrdOnAir')}
+                  <span className="block text-xs text-muted-foreground mt-0.5">{t('es.hrdOnAirHint')}</span>
+                </span>
+              </label>
+
               <div className="grid grid-cols-[170px_1fr] gap-3 items-center">
                 <Label className="text-sm">{t('es.uploadTiming')}</Label>
                 <Select
@@ -6132,6 +6233,15 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             </Button>
           </div>
 
+          {/* A database downloaded by an older OpsLog still holds Connecticut's
+              planning regions instead of its counties. The download date cannot
+              show that, so say it outright. */}
+          {loaded && ulsStatus.needs_refresh && !ulsBusy && (
+            <div className="text-[11px] rounded border border-warning-border bg-warning-muted text-warning-muted-foreground px-2 py-1.5 leading-relaxed">
+              {t('uscty.stale')}
+            </div>
+          )}
+
           {ulsProgress && (
             <div className="space-y-1">
               <div className="text-[11px] text-muted-foreground flex justify-between">

frontend/src/components/StationControlPanel.tsx

@@ -77,6 +77,8 @@ function RotatorWidget({ hd, refetch, centerLat, centerLon, bearing, t }: Rotato
           title={hd.ok ? t('station.online') : t('station.rotatorNoRead')} />
       </div>
       <div className="p-3 flex gap-4 items-start">
+        {/* The SP/LP readout lives INSIDE RotorCompass, so every compass in the
+            app carries it rather than each caller drawing its own. */}
         <RotorCompass
           bearing={bearing ?? null}
           headings={hd.ok ? [hd.azimuth] : []}

frontend/src/components/qsl/QslDesignerModal.tsx

@@ -13,6 +13,7 @@ import { Checkbox } from '@/components/ui/checkbox';
 import { Label } from '@/components/ui/label';
 import {
   QSLPickPhotos, QSLGenerateProposals, QSLListTemplates, QSLGetTemplate,
+  QSLListOtherProfileTemplates, QSLCopyTemplateToActiveProfile,
   QSLSaveTemplate, QSLSetDefaultTemplate, QSLDeleteTemplate, QSLSavePreview,
   QSLPreviewDataURL, QSLResolvePreview, QSLStylePresets,
 } from '../../../wailsjs/go/main/App';
@@ -59,6 +60,7 @@ export function QslDesignerModal({ open, onClose }: Props) {
   const [busy, setBusy] = useState(false);
   const [error, setError] = useState('');
   const [saved, setSaved] = useState<QSLTemplateInfo[]>([]);
+  const [foreign, setForeign] = useState<any[]>([]);
   const [previews, setPreviews] = useState<Record<number, string>>({});
   const [presets, setPresets] = useState<QSLPresetInfo[]>([]);
   const [fontFamilies, setFontFamilies] = useState<string[]>([]);
@@ -88,6 +90,8 @@ export function QslDesignerModal({ open, onClose }: Props) {
         if (url) p[t.id] = url;
       }));
       setPreviews(p);
+      // The designs this profile cannot see, offered for copying.
+      try { setForeign(((await QSLListOtherProfileTemplates()) ?? []) as any[]); } catch { /* nothing to offer */ }
     } catch (e) {
       setError(String(e));
     }
@@ -274,7 +278,29 @@ export function QslDesignerModal({ open, onClose }: Props) {
             </section>
 
             <section className="space-y-2">
-              <h3 className="text-sm font-semibold">Saved templates</h3>
+              <div className="flex items-center gap-3">
+                <h3 className="text-sm font-semibold">Saved templates</h3>
+                {/* Designs owned by another profile. A second profile is usually
+                    the same operator with a different rig or locator — same
+                    callsign, same cards — and redrawing one because the antenna
+                    changed is work nobody should have to do. */}
+                {!!foreign.length && (
+                  <select
+                    value=""
+                    onChange={async (e) => {
+                      const id = parseInt(e.target.value, 10);
+                      if (!id) return;
+                      try { await QSLCopyTemplateToActiveProfile(id); await refreshSaved(); }
+                      catch (err) { setError(String(err)); }
+                    }}
+                    className="h-7 rounded-md border border-border bg-background px-2 text-xs">
+                    <option value="">Copy from another profile…</option>
+                    {foreign.map((f) => (
+                      <option key={f.id} value={f.id}>{f.profile_name} — {f.name}</option>
+                    ))}
+                  </select>
+                )}
+              </div>
               {!saved.length && <p className="text-xs text-muted-foreground">None yet.</p>}
               <div className="grid grid-cols-3 gap-3">
                 {saved.map((t) => (

frontend/src/lib/rowColors.ts

@@ -1,41 +1,93 @@
-// Row colouring for the log grid, by QSL / LoTW status.
+// Row colouring for the log grid, by QSL status.
 //
-// The rules are ORDERED and the first match wins: a contact is usually several
-// things at once, and one confirmed on LoTW and by card is confirmed, not
-// "sent, awaiting reply".
+// Four categories, each scoped to the channels the operator cares about —
+// paper QSL, LoTW, eQSL, QRZ.com. The rules are ORDERED and the first match
+// wins, because a contact is usually several of them at once.
 
-export type RowColorRule = { id: string; color: string; enabled: boolean };
-export type RowColorSettings = { enabled: boolean; rules: RowColorRule[] };
+export type RowColorRule = {
+  id: string;
+  color: string;
+  enabled: boolean;
+  channels?: string[]; // empty = every channel
+};
+export type RowColorSettings = {
+  enabled: boolean;
+  style?: 'bar' | 'tint' | 'both';
+  intensity?: number;
+  bandmap_lotw?: boolean;
+  rules: RowColorRule[];
+};
+
+export const CHANNELS = ['qsl', 'lotw', 'eqsl', 'qrz'] 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.
+const FIELDS: Record<string, { sent: string; rcvd: string }> = {
+  qsl: { sent: 'qsl_sent', rcvd: 'qsl_rcvd' },
+  lotw: { sent: 'lotw_sent', rcvd: 'lotw_rcvd' },
+  eqsl: { sent: 'eqsl_sent', rcvd: 'eqsl_rcvd' },
+  qrz: { sent: 'qrzcom_qso_upload_status', rcvd: 'qrzcom_qso_download_status' },
+};
 
 // ADIF QSL fields are single letters. Y is the only one that means "yes";
-// R (requested) and Q (queued) mean a card is owed, which is a different state
-// and the one an operator is looking for when deciding what to post.
+// 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.
 const yes = (v: any) => String(v ?? '').trim().toUpperCase() === 'Y';
 const owed = (v: any) => {
   const s = String(v ?? '').trim().toUpperCase();
   return s === 'R' || s === 'Q';
 };
 
-export function matchRowRule(q: any): string | null {
-  if (!q) return null;
-  if (yes(q.lotw_rcvd)) return 'confirmed_lotw';
-  if (yes(q.qsl_rcvd) || yes(q.eqsl_rcvd)) return 'confirmed_paper';
-  if (yes(q.qsl_sent) || yes(q.lotw_sent) || yes(q.eqsl_sent)) return 'sent_waiting';
-  // Any route still queued, not just the paper card. LoTW marks a pending upload
-  // as R, which is the commonest "not gone out yet" state in a digital log and
-  // was matching nothing at all while this only looked at qsl_sent.
-  if (owed(q.qsl_sent) || owed(q.lotw_sent) || owed(q.eqsl_sent)) return 'to_send';
+const chansOf = (r: RowColorRule): readonly string[] =>
+  r.channels && r.channels.length ? r.channels : CHANNELS;
+
+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]));
+    case 'sent':
+      return cs.some((c) => yes(q[FIELDS[c]?.sent]));
+    case 'to_send':
+      return cs.some((c) => 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]));
+    default:
+      return false;
+  }
+}
+
+// Walks the rules IN ORDER — the order is the priority, and the settings panel
+// shows it numbered so it can be read rather than guessed.
+export function matchRowRule(q: any, cfg: RowColorSettings | null): RowColorRule | null {
+  if (!q || !cfg?.rules) return null;
+  for (const r of cfg.rules) {
+    if (r.enabled && ruleMatches(q, r)) return r;
+  }
   return null;
 }
 
-// The colour is applied as a TINT, not a fill. The grid is dark and a solid
-// user-picked colour behind white text is unreadable at exactly the moment it
-// matters — Logger32 gets away with it because its grid is white.
-export function rowStyleFor(q: any, cfg: RowColorSettings | null): { backgroundColor: string } | undefined {
+// The colour is never a fill by default.
+//
+// A log where nearly every contact has SOME QSL state ends up with every row
+// painted, and colour that is always present stops being information. The
+// default is a stripe down the left edge; a tint is offered at a chosen strength.
+export function rowStyleFor(q: any, cfg: RowColorSettings | null): Record<string, string> | undefined {
   if (!cfg?.enabled) return undefined;
-  const id = matchRowRule(q);
-  if (!id) return undefined;
-  const rule = cfg.rules?.find((r) => r.id === id);
-  if (!rule?.enabled || !rule.color) return undefined;
-  return { backgroundColor: `color-mix(in srgb, ${rule.color} 24%, transparent)` };
+  const rule = matchRowRule(q, cfg);
+  if (!rule?.color) return undefined;
+
+  const style = cfg.style ?? 'bar';
+  const pct = Math.max(5, Math.min(45, cfg.intensity ?? 12));
+  const out: Record<string, string> = {};
+  if (style === 'tint' || style === 'both') {
+    out.backgroundColor = `color-mix(in srgb, ${rule.color} ${pct}%, transparent)`;
+  }
+  if (style === 'bar' || style === 'both') {
+    // inset shadow rather than a border: a border would shift the cells three
+    // pixels on coloured rows only, and the columns would stop lining up.
+    out.boxShadow = `inset 3px 0 0 ${rule.color}`;
+  }
+  return out;
 }

frontend/src/lib/spotDisplay.ts

@@ -74,3 +74,16 @@ export function applySpotDisplay<T extends Entry>(s: T, o: SpotDisplayOptions):
   }
   return e;
 }
+
+// spotIsWorked answers "does this spot bring me nothing?", which is what the
+// "hide worked" filter is really asking.
+//
+// The extra markers are ORTHOGONAL to the entity status — a spot can be a worked
+// entity AND a new park, prefix, county or grid — so they win. Without that, a
+// new prefix in an entity worked years ago vanished the moment the filter went
+// on, which is the opposite of what an operator hunting prefixes wants.
+export function spotIsWorked(e: Entry): boolean {
+  if (!e) return false;
+  if (e.new_pota || e.new_county || e.new_pfx || e.new_grid) return false;
+  return !!e.worked_call || e.status === 'worked';
+}

frontend/src/lib/theme.tsx

@@ -6,14 +6,14 @@ import { GetUIPref } from '../../wailsjs/go/main/App';
 // CSS variables in style.css key off of. 'auto' follows the OS light/dark
 // preference. The choice is persisted (localStorage + portable UI pref, so it
 // travels with the data/ folder like the language).
-export type ThemeChoice = 'auto' | 'light-warm' | 'light-cool' | 'light-sage' | 'light-nordic'
+export type ThemeChoice = 'auto' | 'light-warm' | 'light-cool' | 'light-sage' | 'light-nordic' | 'sahara'
   | 'dim-slate' | 'dark-warm' | 'dark-graphite' | 'dark-indigo' | 'dark-teal' | 'dark-plum' | 'high-contrast';
 
 // Selectable, concrete themes (excludes 'auto') in display order: lights first,
 // then darks, with high-contrast last — it is an accessibility choice, not a
 // taste one, and listing it among the moods buries it.
 export const CONCRETE_THEMES: Exclude<ThemeChoice, 'auto'>[] = [
-  'light-warm', 'light-cool', 'light-sage', 'light-nordic',
+  'light-warm', 'light-cool', 'light-sage', 'light-nordic', 'sahara',
   'dim-slate', 'dark-warm', 'dark-graphite', 'dark-indigo', 'dark-teal', 'dark-plum',
   'high-contrast',
 ];

frontend/src/style.css

@@ -775,6 +775,82 @@
   color-scheme: light;
 }
 
+/* ---- Theme 1e: Sahara — Warm light, taken a step deeper --------------------
+   Warm light's cream is kept for panels and the entry strip (#faf6eb, the one
+   surface an operator stares at while typing a call), but the page behind them
+   and every toolbar, tab bar and table header go one shade further into the
+   sand. That was the whole request: same family, just a little darker, so the
+   cream panels lift clearly instead of blending into the page.
+   Ink is a deep warm brown rather than black: pure black on sand glares.
+   The accent moves from Warm light's burnt orange to ochre to keep the two
+   themes apart at a glance in the theme picker. ---------------------------- */
+[data-theme="sahara"] {
+  --background: #dcceab;            /* deep sand — the page */
+  --foreground: #2b2318;            /* deep warm brown-ink */
+  --card: #faf6eb;                  /* lifted panel / entry strip — kept cream */
+  --card-foreground: #2b2318;
+  --popover: #faf6eb;
+  --popover-foreground: #2b2318;
+  --primary: #a55f14;               /* ochre */
+  --primary-foreground: #fffbf2;
+  --secondary: #cdbb92;
+  --secondary-foreground: #2b2318;
+  --muted: #cdbb92;                 /* toolbars / tab bar / table headers */
+  --muted-foreground: #544731;      /* readable on both sands */
+  --accent: #e9d3a6;                /* warm highlight */
+  --accent-foreground: #6b3a06;
+  --destructive: #b91c1c;
+  --destructive-foreground: #ffffff;
+  --destructive-muted: #fdecec;
+  --destructive-muted-foreground: #b91c1c;
+  --border: #b6a179;                /* sand a step down again, so edges read */
+  --input: #b6a179;
+  --ring: #c2760c;                  /* amber focus ring */
+
+  --success: #15803d;
+  --success-foreground: #ffffff;
+  --success-muted: #dcf3e1;
+  --success-muted-foreground: #14532d;
+  --success-border: #86d99f;
+
+  --warning: #b45309;
+  --warning-foreground: #ffffff;
+  --warning-muted: #fbeacd;
+  --warning-muted-foreground: #7c3d05;
+  --warning-border: #e8b96a;
+
+  --caution: #a16207;
+  --caution-foreground: #1c1917;
+  --caution-muted: #f7edcb;
+  --caution-muted-foreground: #713f12;
+  --caution-border: #e0c069;
+
+  --danger: #be123c;
+  --danger-foreground: #ffffff;
+  --danger-muted: #fbe3e8;
+  --danger-muted-foreground: #9f1239;
+  --danger-border: #ee9aac;
+
+  --info: #0369a1;
+  --info-foreground: #ffffff;
+  --info-muted: #e0eef6;
+  --info-muted-foreground: #075985;
+  --info-border: #86c5e4;
+
+  /* Band/mode matrix — the app's blues kept, on a sand neutral so an empty slot
+     recedes into the grid instead of punching a hole in it. */
+  --mx-call-conf: #15803d;
+  --mx-call-work: #7fd6a4;
+  --mx-dx-conf:   #3730a3;
+  --mx-dx-work:   #a5b4fc;
+  --mx-none:      #cdbb92;
+
+  --scrollbar-thumb: #ac9868;
+  --scrollbar-thumb-hover: #927d4e;
+  --card-shadow: 0 1px 2px rgba(43, 35, 24, 0.07), 0 0 0 1px rgba(43, 35, 24, 0.03);
+  color-scheme: light;
+}
+
 /* ── Data-viz palette (Statistics dashboard) ────────────────────────────────
    A VALIDATED categorical palette, not hand-picked: the slot ORDER is what makes
    it colour-blind-safe (worst adjacent ΔE 24.2 light / 10.3 dark), so never
@@ -793,7 +869,8 @@
 [data-theme="light-warm"],
 [data-theme="light-cool"],
 [data-theme="light-sage"],
-[data-theme="light-nordic"] {
+[data-theme="light-nordic"],
+[data-theme="sahara"] {
   --chart-1: #2a78d6; /* blue    — default single-series hue */
   --chart-2: #1baf7a; /* aqua    */
   --chart-3: #eda100; /* yellow  */

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

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

@@ -176,6 +176,8 @@ export function DiscoverFlexRadios():Promise<Array<cat.FlexRadio>>;
 
 export function DismissAwardUpdate(arg1:string):Promise<void>;
 
+export function DismissQSLViaRepair():Promise<void>;
+
 export function DownloadAllReferenceLists():Promise<string>;
 
 export function DownloadAndApplyUpdate(arg1:string):Promise<void>;
@@ -446,6 +448,8 @@ export function GetGridCacheStatus():Promise<main.GridCacheStatus>;
 
 export function GetIcomState():Promise<cat.IcomTXState>;
 
+export function GetLinkedAmps():Promise<Array<string>>;
+
 export function GetListsSettings():Promise<main.ListsSettings>;
 
 export function GetLiveOpenings():Promise<Array<bandopen.Opening>>;
@@ -506,6 +510,8 @@ export function GetSlotStats():Promise<qso.SlotStats>;
 
 export function GetSolarData():Promise<solar.Data>;
 
+export function GetSpotTTLMinutes():Promise<number>;
+
 export function GetStartupStatus():Promise<main.StartupStatus>;
 
 export function GetStationDevices():Promise<Array<main.StationDevice>>;
@@ -766,6 +772,8 @@ export function PopulateBuiltinReferences(arg1:string):Promise<number>;
 
 export function PublishLogNow():Promise<string>;
 
+export function QSLCopyTemplateToActiveProfile(arg1:number):Promise<number>;
+
 export function QSLDefaultTemplateID():Promise<number>;
 
 export function QSLDeleteTemplate(arg1:number):Promise<void>;
@@ -780,6 +788,8 @@ export function QSLGetEmailTemplates():Promise<main.QSLEmailTemplates>;
 
 export function QSLGetTemplate(arg1:number):Promise<string>;
 
+export function QSLListOtherProfileTemplates():Promise<Array<main.QSLForeignTemplate>>;
+
 export function QSLListTemplates():Promise<Array<main.QSLTemplateInfo>>;
 
 export function QSLPhotoDataURL(arg1:number,arg2:string):Promise<string>;
@@ -800,6 +810,8 @@ export function QSLSetDefaultTemplate(arg1:number):Promise<void>;
 
 export function QSLStylePresets():Promise<Array<main.QSLPresetInfo>>;
 
+export function QSLViaRepairStatus():Promise<main.QSLViaRepairStatus>;
+
 export function QSOAudioBegin():Promise<boolean>;
 
 export function QSOAudioCancel():Promise<void>;
@@ -838,6 +850,8 @@ export function RenameLogbook(arg1:string):Promise<void>;
 
 export function RenderEQSL(arg1:number,arg2:number):Promise<string>;
 
+export function RepairQSLVia():Promise<main.QSLViaRepairResult>;
+
 export function ReplaceAwardReferences(arg1:string,arg2:Array<awardref.Ref>):Promise<number>;
 
 export function ReportLiveActivity(arg1:number,arg2:string,arg3:string):Promise<void>;
@@ -986,12 +1000,16 @@ export function SetClublogMostWantedEnabled(arg1:boolean):Promise<void>;
 
 export function SetClusterAutoConnect(arg1:boolean):Promise<void>;
 
+export function SetCompactHeight(arg1:number):Promise<void>;
+
 export function SetCompactMode(arg1:boolean):Promise<void>;
 
 export function SetDVKLabel(arg1:number,arg2:string):Promise<void>;
 
 export function SetKenwoodKeySpeed(arg1:number):Promise<void>;
 
+export function SetLinkedAmps(arg1:Array<string>):Promise<void>;
+
 export function SetMotorFollow(arg1:boolean,arg2:number,arg3:string):Promise<void>;
 
 export function SetOpsLogQSLReceived(arg1:number,arg2:boolean):Promise<void>;
@@ -1000,6 +1018,8 @@ export function SetPassphrase(arg1:string):Promise<void>;
 
 export function SetScpEnabled(arg1:boolean):Promise<void>;
 
+export function SetSpotTTLMinutes(arg1:number):Promise<void>;
+
 export function SetTelemetryEnabled(arg1:boolean):Promise<void>;
 
 export function SetUIPref(arg1:string,arg2:string):Promise<void>;

frontend/wailsjs/go/main/App.js

@@ -294,6 +294,10 @@ export function DismissAwardUpdate(arg1) {
   return window['go']['main']['App']['DismissAwardUpdate'](arg1);
 }
 
+export function DismissQSLViaRepair() {
+  return window['go']['main']['App']['DismissQSLViaRepair']();
+}
+
 export function DownloadAllReferenceLists() {
   return window['go']['main']['App']['DownloadAllReferenceLists']();
 }
@@ -834,6 +838,10 @@ export function GetIcomState() {
   return window['go']['main']['App']['GetIcomState']();
 }
 
+export function GetLinkedAmps() {
+  return window['go']['main']['App']['GetLinkedAmps']();
+}
+
 export function GetListsSettings() {
   return window['go']['main']['App']['GetListsSettings']();
 }
@@ -954,6 +962,10 @@ export function GetSolarData() {
   return window['go']['main']['App']['GetSolarData']();
 }
 
+export function GetSpotTTLMinutes() {
+  return window['go']['main']['App']['GetSpotTTLMinutes']();
+}
+
 export function GetStartupStatus() {
   return window['go']['main']['App']['GetStartupStatus']();
 }
@@ -1474,6 +1486,10 @@ export function PublishLogNow() {
   return window['go']['main']['App']['PublishLogNow']();
 }
 
+export function QSLCopyTemplateToActiveProfile(arg1) {
+  return window['go']['main']['App']['QSLCopyTemplateToActiveProfile'](arg1);
+}
+
 export function QSLDefaultTemplateID() {
   return window['go']['main']['App']['QSLDefaultTemplateID']();
 }
@@ -1502,6 +1518,10 @@ export function QSLGetTemplate(arg1) {
   return window['go']['main']['App']['QSLGetTemplate'](arg1);
 }
 
+export function QSLListOtherProfileTemplates() {
+  return window['go']['main']['App']['QSLListOtherProfileTemplates']();
+}
+
 export function QSLListTemplates() {
   return window['go']['main']['App']['QSLListTemplates']();
 }
@@ -1542,6 +1562,10 @@ export function QSLStylePresets() {
   return window['go']['main']['App']['QSLStylePresets']();
 }
 
+export function QSLViaRepairStatus() {
+  return window['go']['main']['App']['QSLViaRepairStatus']();
+}
+
 export function QSOAudioBegin() {
   return window['go']['main']['App']['QSOAudioBegin']();
 }
@@ -1618,6 +1642,10 @@ export function RenderEQSL(arg1, arg2) {
   return window['go']['main']['App']['RenderEQSL'](arg1, arg2);
 }
 
+export function RepairQSLVia() {
+  return window['go']['main']['App']['RepairQSLVia']();
+}
+
 export function ReplaceAwardReferences(arg1, arg2) {
   return window['go']['main']['App']['ReplaceAwardReferences'](arg1, arg2);
 }
@@ -1914,6 +1942,10 @@ export function SetClusterAutoConnect(arg1) {
   return window['go']['main']['App']['SetClusterAutoConnect'](arg1);
 }
 
+export function SetCompactHeight(arg1) {
+  return window['go']['main']['App']['SetCompactHeight'](arg1);
+}
+
 export function SetCompactMode(arg1) {
   return window['go']['main']['App']['SetCompactMode'](arg1);
 }
@@ -1926,6 +1958,10 @@ export function SetKenwoodKeySpeed(arg1) {
   return window['go']['main']['App']['SetKenwoodKeySpeed'](arg1);
 }
 
+export function SetLinkedAmps(arg1) {
+  return window['go']['main']['App']['SetLinkedAmps'](arg1);
+}
+
 export function SetMotorFollow(arg1, arg2, arg3) {
   return window['go']['main']['App']['SetMotorFollow'](arg1, arg2, arg3);
 }
@@ -1942,6 +1978,10 @@ export function SetScpEnabled(arg1) {
   return window['go']['main']['App']['SetScpEnabled'](arg1);
 }
 
+export function SetSpotTTLMinutes(arg1) {
+  return window['go']['main']['App']['SetSpotTTLMinutes'](arg1);
+}
+
 export function SetTelemetryEnabled(arg1) {
   return window['go']['main']['App']['SetTelemetryEnabled'](arg1);
 }

frontend/wailsjs/go/models.ts

@@ -1331,6 +1331,7 @@ export namespace extsvc {
 	    upload_flags: string[];
 	    write_log: boolean;
 	    auto_upload: boolean;
+	    on_air: boolean;
 	    upload_mode: string;
 	
 	    static createFrom(source: any = {}) {
@@ -1355,6 +1356,7 @@ export namespace extsvc {
 	        this.upload_flags = source["upload_flags"];
 	        this.write_log = source["write_log"];
 	        this.auto_upload = source["auto_upload"];
+	        this.on_air = source["on_air"];
 	        this.upload_mode = source["upload_mode"];
 	    }
 	}
@@ -2541,6 +2543,7 @@ export namespace main {
 	    primary: string;
 	    failsafe: string;
 	    download_images: boolean;
+	    qrz_prefer_nickname: boolean;
 	    cache_ttl_days: number;
 	
 	    static createFrom(source: any = {}) {
@@ -2556,6 +2559,7 @@ export namespace main {
 	        this.primary = source["primary"];
 	        this.failsafe = source["failsafe"];
 	        this.download_images = source["download_images"];
+	        this.qrz_prefer_nickname = source["qrz_prefer_nickname"];
 	        this.cache_ttl_days = source["cache_ttl_days"];
 	    }
 	}
@@ -2781,6 +2785,24 @@ export namespace main {
 	        this.data_b64 = source["data_b64"];
 	    }
 	}
+	export class QSLForeignTemplate {
+	    id: number;
+	    name: string;
+	    profile_id: number;
+	    profile_name: string;
+	
+	    static createFrom(source: any = {}) {
+	        return new QSLForeignTemplate(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.id = source["id"];
+	        this.name = source["name"];
+	        this.profile_id = source["profile_id"];
+	        this.profile_name = source["profile_name"];
+	    }
+	}
 	export class QSLPresetInfo {
 	    name: string;
 	    label: string;
@@ -2837,6 +2859,32 @@ export namespace main {
 	        this.updated_at = source["updated_at"];
 	    }
 	}
+	export class QSLViaRepairResult {
+	    moved: number;
+	
+	    static createFrom(source: any = {}) {
+	        return new QSLViaRepairResult(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.moved = source["moved"];
+	    }
+	}
+	export class QSLViaRepairStatus {
+	    affected: number;
+	    asked: boolean;
+	
+	    static createFrom(source: any = {}) {
+	        return new QSLViaRepairStatus(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.affected = source["affected"];
+	        this.asked = source["asked"];
+	    }
+	}
 	export class QSOAwardRef {
 	    code: string;
 	    ref: string;
@@ -2996,6 +3044,7 @@ export namespace main {
 	    id: string;
 	    color: string;
 	    enabled: boolean;
+	    channels: string[];
 	
 	    static createFrom(source: any = {}) {
 	        return new RowColorRule(source);
@@ -3006,10 +3055,15 @@ export namespace main {
 	        this.id = source["id"];
 	        this.color = source["color"];
 	        this.enabled = source["enabled"];
+	        this.channels = source["channels"];
 	    }
 	}
 	export class RowColorSettings {
 	    enabled: boolean;
+	    style: string;
+	    intensity: number;
+	    bandmap_lotw: boolean;
+	    configured: boolean;
 	    rules: RowColorRule[];
 	
 	    static createFrom(source: any = {}) {
@@ -3019,6 +3073,10 @@ export namespace main {
 	    constructor(source: any = {}) {
 	        if ('string' === typeof source) source = JSON.parse(source);
 	        this.enabled = source["enabled"];
+	        this.style = source["style"];
+	        this.intensity = source["intensity"];
+	        this.bandmap_lotw = source["bandmap_lotw"];
+	        this.configured = source["configured"];
 	        this.rules = this.convertValues(source["rules"], RowColorRule);
 	    }
 	
@@ -3330,6 +3388,7 @@ export namespace main {
 	export class ULSStatusResult {
 	    count: number;
 	    updated_at: string;
+	    needs_refresh: boolean;
 	
 	    static createFrom(source: any = {}) {
 	        return new ULSStatusResult(source);
@@ -3339,6 +3398,7 @@ export namespace main {
 	        if ('string' === typeof source) source = JSON.parse(source);
 	        this.count = source["count"];
 	        this.updated_at = source["updated_at"];
+	        this.needs_refresh = source["needs_refresh"];
 	    }
 	}
 	export class UltrabeamSettings {
@@ -4296,6 +4356,8 @@ export namespace qso {
 	    qsl_sent_date?: string;
 	    qsl_rcvd_date?: string;
 	    qsl_via?: string;
+	    qsl_sent_via?: string;
+	    qsl_rcvd_via?: string;
 	    qsl_msg?: string;
 	    qslmsg_rcvd?: string;
 	    lotw_sent?: string;
@@ -4435,6 +4497,8 @@ export namespace qso {
 	        this.qsl_sent_date = source["qsl_sent_date"];
 	        this.qsl_rcvd_date = source["qsl_rcvd_date"];
 	        this.qsl_via = source["qsl_via"];
+	        this.qsl_sent_via = source["qsl_sent_via"];
+	        this.qsl_rcvd_via = source["qsl_rcvd_via"];
 	        this.qsl_msg = source["qsl_msg"];
 	        this.qslmsg_rcvd = source["qslmsg_rcvd"];
 	        this.lotw_sent = source["lotw_sent"];

hrdlogonair.go

@@ -0,0 +1,74 @@
+package main
+
+// HRDLog "ON AIR" — publishing the live frequency, mode and rig on hrdlog.net,
+// so the site shows "F4BPO is on air 14,074,000 FT8 IC-7300" while the station
+// is operating.
+//
+// The endpoint and its field names come from HRDLog's own library
+// (github.com/iw1qlh/HRDLOG-net-library), not from reading someone's traffic.
+
+import (
+	"context"
+	"strings"
+	"time"
+
+	"hamlog/internal/applog"
+	"hamlog/internal/extsvc"
+)
+
+// onAirEvery is how often the status is refreshed. HRDLog drops a station from
+// the on-air list when it stops hearing from it, so this is a heartbeat, not a
+// change notification.
+const onAirEvery = 2 * time.Minute
+
+// hrdlogOnAirLoop publishes while the option is on and the rig is readable.
+func (a *App) hrdlogOnAirLoop() {
+	defer func() { _ = recover() }() // never crash the app from a status broadcast
+	t := time.NewTicker(onAirEvery)
+	defer t.Stop()
+	for range t.C {
+		a.publishHRDLogOnAir()
+	}
+}
+
+// publishHRDLogOnAir sends one update. Silent when switched off, unconfigured,
+// or when the rig has nothing to report — an announcement with no frequency
+// would say the operator is on air on 0 Hz.
+func (a *App) publishHRDLogOnAir() {
+	cfg := a.loadExternalServices().HRDLog
+	if !cfg.OnAir || strings.TrimSpace(cfg.Callsign) == "" || strings.TrimSpace(cfg.Code) == "" {
+		return
+	}
+	if a.cat == nil {
+		return
+	}
+	st := a.cat.State()
+	if !st.Connected || st.FreqHz <= 0 {
+		return
+	}
+	// The rig NAME as the operator knows it — that string is what the site
+	// displays. The active profile's MyRig first, since it is what every QSO is
+	// stamped with; the CAT backend's own model only when the profile has none.
+	radio := ""
+	if a.profiles != nil {
+		if pr, err := a.profiles.Active(a.ctx); err == nil {
+			radio = strings.TrimSpace(pr.MyRig)
+		}
+	}
+	if radio == "" {
+		radio = strings.TrimSpace(st.Rig)
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
+	defer cancel()
+	msg, err := extsvc.SendHRDLogOnAir(ctx, nil, cfg.Callsign, cfg.Code, st.FreqHz, st.Mode, radio)
+	if err != nil {
+		// Logged, never surfaced: this is a broadcast the operator did not ask
+		// for at this instant, and a toast every two minutes on a flaky link
+		// would be worse than the missing status.
+		applog.Printf("hrdlog on-air: %v (%s)", err, msg)
+		return
+	}
+	applog.Printf("hrdlog on-air: %s %.3f MHz %s (%s) — %s",
+		cfg.Callsign, float64(st.FreqHz)/1e6, st.Mode, radio, msg)
+}

internal/adif/charcount_test.go

@@ -19,8 +19,8 @@ func TestCharCountLengthRepair(t *testing.T) {
 		},
 		{
 			name:     "cyrillic",
-			wantQTH:  "Дзержинск",        // 9 chars / 18 bytes, declared 9
-			wantName: "Александр Чайка",  // 15 chars / 29 bytes, declared 15
+			wantQTH:  "Дзержинск",       // 9 chars / 18 bytes, declared 9
+			wantName: "Александр Чайка", // 15 chars / 29 bytes, declared 15
 			adi:      "<EOH>\n<CALL:6>UA3TFS<NAME:15>Александр Чайка<QTH:9>Дзержинск<EOR>\n",
 		},
 	}

internal/adif/county_test.go

@@ -0,0 +1,46 @@
+package adif
+
+import "testing"
+
+// ADIF defines CNTY as "STATE,COUNTY" — "GA,BARROW". OpsLog exported the bare
+// county, which a receiving logger cannot resolve: county names repeat across
+// states, and there is a Washington County in thirty of them.
+func TestADIFCountyFormat(t *testing.T) {
+	for _, tc := range []struct{ state, county, want string }{
+		{"GA", "BARROW", "GA,BARROW"},
+		{"ga", "Barrow", "GA,Barrow"},    // the state is a code, upper-cased; the name is not touched
+		{"", "BARROW", "BARROW"},         // no state known: a bare name beats nothing
+		{"GA", "", ""},                   // no county: nothing to write
+		{"GA", "GA,BARROW", "GA,BARROW"}, // already formatted — never double the prefix
+		{"  GA  ", " BARROW ", "GA,BARROW"},
+	} {
+		if got := adifCounty(tc.state, tc.county); got != tc.want {
+			t.Errorf("adifCounty(%q, %q) = %q, want %q", tc.state, tc.county, got, tc.want)
+		}
+	}
+}
+
+// And the mirror: a file from a logger that follows the standard must fill both
+// columns, while a file carrying the bare county still imports unchanged.
+func TestSplitADIFCounty(t *testing.T) {
+	for _, tc := range []struct{ in, county, state string }{
+		{"GA,BARROW", "BARROW", "GA"},
+		{"ga, Barrow", "Barrow", "GA"},
+		{"BARROW", "BARROW", ""}, // the old OpsLog form, and many other loggers
+		{"", "", ""},
+		{"  ", "", ""},
+	} {
+		c, s := splitADIFCounty(tc.in)
+		if c != tc.county || s != tc.state {
+			t.Errorf("splitADIFCounty(%q) = (%q, %q), want (%q, %q)", tc.in, c, s, tc.county, tc.state)
+		}
+	}
+}
+
+// Round trip: what OpsLog writes, OpsLog reads back to the same two values.
+func TestCountyRoundTrip(t *testing.T) {
+	c, s := splitADIFCounty(adifCounty("GA", "BARROW"))
+	if c != "BARROW" || s != "GA" {
+		t.Errorf("round trip gave (%q, %q), want (BARROW, GA)", c, s)
+	}
+}

internal/adif/export.go

@@ -15,9 +15,9 @@ import (
 
 // ExportResult summarises an ADIF export for the UI.
 type ExportResult struct {
-	Path    string `json:"path"`
-	Count   int    `json:"count"`
-	SizeKB  int64  `json:"size_kb"`
+	Path   string `json:"path"`
+	Count  int    `json:"count"`
+	SizeKB int64  `json:"size_kb"`
 }
 
 // Exporter streams every QSO in a repo to an ADIF (.adi) file.
@@ -221,7 +221,7 @@ func writeRecord(bw *bufio.Writer, q qso.QSO, includeApp bool, allow map[string]
 	w("VUCC_GRIDS", q.VUCCGrids)
 	w("COUNTRY", q.Country)
 	w("STATE", q.State)
-	w("CNTY", q.County)
+	w("CNTY", adifCounty(q.State, q.County))
 	wi("DXCC", q.DXCC)
 	w("CONT", q.Continent)
 	wi("CQZ", q.CQZ)
@@ -241,6 +241,14 @@ func writeRecord(bw *bufio.Writer, q qso.QSO, includeApp bool, allow map[string]
 	w("QSLSDATE", q.QSLSentDate)
 	w("QSLRDATE", q.QSLRcvdDate)
 	w("QSL_VIA", q.QSLVia)
+	// M (manager) is import-only in the QSL Via enumeration: we keep it when a
+	// file gives it to us, but a file we write must not carry it.
+	if q.QSLSentVia != QSLViaManager {
+		w("QSL_SENT_VIA", q.QSLSentVia)
+	}
+	if q.QSLRcvdVia != QSLViaManager {
+		w("QSL_RCVD_VIA", q.QSLRcvdVia)
+	}
 	w("QSLMSG", q.QSLMsg)
 	w("QSLMSG_RCVD", q.QSLMsgRcvd)
 	w("LOTW_QSL_SENT", q.LOTWSent)
@@ -285,7 +293,7 @@ func writeRecord(bw *bufio.Writer, q qso.QSO, includeApp bool, allow map[string]
 	w("MY_GRIDSQUARE_EXT", q.MyGridExt)
 	w("MY_COUNTRY", q.MyCountry)
 	w("MY_STATE", q.MyState)
-	w("MY_CNTY", q.MyCounty)
+	w("MY_CNTY", adifCounty(q.MyState, q.MyCounty))
 	w("MY_IOTA", q.MyIOTA)
 	w("MY_SOTA_REF", q.MySOTARef)
 	w("MY_POTA_REF", q.MyPOTARef)
@@ -391,10 +399,10 @@ var parentMode = map[string]string{
 	"ISCAT": "MFSK", "Q65": "MFSK", "FST4": "MFSK", "FST4W": "MFSK",
 	"MFSK16": "MFSK", "MFSK32": "MFSK", "MFSK64": "MFSK", "MFSK128": "MFSK",
 	"OLIVIA": "MFSK",
-	"PSK31": "PSK", "PSK63": "PSK", "PSK125": "PSK", "PSK250": "PSK", "PSK500": "PSK",
+	"PSK31":  "PSK", "PSK63": "PSK", "PSK125": "PSK", "PSK250": "PSK", "PSK500": "PSK",
 	"QPSK31": "PSK", "QPSK63": "PSK", "QPSK125": "PSK", "QPSK250": "PSK", "QPSK500": "PSK",
 	"FREEDV": "DIGITALVOICE",
-	"VARA": "DYNAMIC", "VARA HF": "DYNAMIC", "VARA FM": "DYNAMIC", "VARAC": "DYNAMIC",
+	"VARA":   "DYNAMIC", "VARA HF": "DYNAMIC", "VARA FM": "DYNAMIC", "VARAC": "DYNAMIC",
 	"THOR4": "THOR", "THOR8": "THOR", "THOR16": "THOR", "THOR32": "THOR",
 	"DOMINOF": "DOMINO", "DOMINOEX": "DOMINO",
 	"HELL80": "HELL", "FMHELL": "HELL",
@@ -413,3 +421,25 @@ func modeForExport(mode, submode string) (string, string) {
 	}
 	return mode, ""
 }
+
+// adifCounty renders CNTY the way ADIF specifies: "STATE,COUNTY", e.g.
+// "GA,BARROW".
+//
+// OpsLog stores the two apart, and exported only the county — which a receiving
+// logger cannot resolve, since county names repeat across states (there is a
+// Washington County in thirty of them). The award engine here was never
+// affected because it reads the columns, not the ADIF; the damage was to
+// everyone we send a file to.
+//
+// The county alone is still written when no state is known: a bare name is
+// worth more than nothing, and inventing a prefix would be worse than either.
+// A county that ALREADY carries a comma is passed through — it has been
+// formatted once, and doubling the prefix would corrupt it.
+func adifCounty(state, county string) string {
+	c := strings.TrimSpace(county)
+	s := strings.TrimSpace(state)
+	if c == "" || s == "" || strings.Contains(c, ",") {
+		return c
+	}
+	return strings.ToUpper(s) + "," + c
+}

internal/adif/fields.go

@@ -16,23 +16,23 @@ import "strings"
 type FieldKind string
 
 const (
-	KindText    FieldKind = "text"    // String / IntlString / MultilineString
-	KindNumber  FieldKind = "number"  // Number / PositiveInteger
-	KindDate    FieldKind = "date"    // ADIF Date (YYYYMMDD)
-	KindTime    FieldKind = "time"    // ADIF Time (HHMMSS / HHMM)
-	KindBool    FieldKind = "boolean" // Boolean (Y/N)
-	KindEnum    FieldKind = "enum"    // Enumeration
-	KindLoc     FieldKind = "location" // Location (e.g. "N048 09.000")
+	KindText   FieldKind = "text"     // String / IntlString / MultilineString
+	KindNumber FieldKind = "number"   // Number / PositiveInteger
+	KindDate   FieldKind = "date"     // ADIF Date (YYYYMMDD)
+	KindTime   FieldKind = "time"     // ADIF Time (HHMMSS / HHMM)
+	KindBool   FieldKind = "boolean"  // Boolean (Y/N)
+	KindEnum   FieldKind = "enum"     // Enumeration
+	KindLoc    FieldKind = "location" // Location (e.g. "N048 09.000")
 )
 
 // FieldDef describes one ADIF QSO field.
 type FieldDef struct {
-	Name       string    `json:"name"`        // canonical uppercase ADIF tag
-	Kind       FieldKind `json:"kind"`        // editor widget hint
-	Category   string    `json:"category"`    // grouping for the UI
-	Promoted   bool      `json:"promoted"`    // has a dedicated QSO column
-	Deprecated bool      `json:"deprecated"`  // import-only per the spec
-	Intl       bool      `json:"intl"`        // *_INTL UTF-8 variant
+	Name       string    `json:"name"`       // canonical uppercase ADIF tag
+	Kind       FieldKind `json:"kind"`       // editor widget hint
+	Category   string    `json:"category"`   // grouping for the UI
+	Promoted   bool      `json:"promoted"`   // has a dedicated QSO column
+	Deprecated bool      `json:"deprecated"` // import-only per the spec
+	Intl       bool      `json:"intl"`       // *_INTL UTF-8 variant
 }
 
 // adifVersion is the ADIF spec version OpsLog targets for import/export.
@@ -135,8 +135,8 @@ var Fields = []FieldDef{
 	{Name: "QSLSDATE", Kind: KindDate, Category: "QSL", Promoted: true},
 	{Name: "QSLRDATE", Kind: KindDate, Category: "QSL", Promoted: true},
 	{Name: "QSL_VIA", Kind: KindText, Category: "QSL", Promoted: true},
-	{Name: "QSL_SENT_VIA", Kind: KindEnum, Category: "QSL"},
-	{Name: "QSL_RCVD_VIA", Kind: KindEnum, Category: "QSL"},
+	{Name: "QSL_SENT_VIA", Kind: KindEnum, Category: "QSL", Promoted: true},
+	{Name: "QSL_RCVD_VIA", Kind: KindEnum, Category: "QSL", Promoted: true},
 	{Name: "QSLMSG", Kind: KindText, Category: "QSL", Promoted: true},
 	{Name: "QSLMSG_INTL", Kind: KindText, Category: "QSL", Intl: true},
 	{Name: "QSLMSG_RCVD", Kind: KindText, Category: "QSL", Promoted: true},

internal/adif/import.go

@@ -428,7 +428,12 @@ func recordToQSO(rec Record) (qso.QSO, bool) {
 	q.VUCCGrids = strings.ToUpper(rec["vucc_grids"])
 	q.Country = rec["country"]
 	q.State = strings.ToUpper(rec["state"])
-	q.County = rec["cnty"]
+	q.County, _ = splitADIFCounty(rec["cnty"])
+	if st := rec["state"]; strings.TrimSpace(st) == "" {
+		if _, fromCnty := splitADIFCounty(rec["cnty"]); fromCnty != "" {
+			q.State = fromCnty
+		}
+	}
 	if v, ok := parseInt(rec["dxcc"]); ok {
 		q.DXCC = &v
 	}
@@ -459,10 +464,17 @@ func recordToQSO(rec Record) (qso.QSO, bool) {
 	q.QSLRcvd = rec["qsl_rcvd"]
 	q.QSLSentDate = rec["qslsdate"]
 	q.QSLRcvdDate = rec["qslrdate"]
+	// QSL_VIA is the manager. QSL_SENT_VIA / QSL_RCVD_VIA are the routing
+	// method, an enumeration of their own.
+	//
+	// These used to be one field here: an empty QSL_VIA was filled from
+	// QSL_SENT_VIA, on the theory that loggers writing one meant the other.
+	// They do not — Log4OM defaults QSL_SENT_VIA to E, and the import put "E"
+	// where every panel in OpsLog shows the manager's callsign. Keeping them
+	// apart is also what lets an export give them back.
 	q.QSLVia = rec["qsl_via"]
-	if q.QSLVia == "" { // many loggers (Log4OM) write QSL_SENT_VIA instead
-		q.QSLVia = rec["qsl_sent_via"]
-	}
+	q.QSLSentVia = NormaliseQSLVia(rec["qsl_sent_via"])
+	q.QSLRcvdVia = NormaliseQSLVia(rec["qsl_rcvd_via"])
 	q.QSLMsg = rec["qslmsg"]
 	q.QSLMsgRcvd = rec["qslmsg_rcvd"]
 	q.LOTWSent = rec["lotw_qsl_sent"]
@@ -515,7 +527,12 @@ func recordToQSO(rec Record) (qso.QSO, bool) {
 	q.MyGridExt = strings.ToUpper(rec["my_gridsquare_ext"])
 	q.MyCountry = rec["my_country"]
 	q.MyState = strings.ToUpper(rec["my_state"])
-	q.MyCounty = rec["my_cnty"]
+	q.MyCounty, _ = splitADIFCounty(rec["my_cnty"])
+	if st := rec["my_state"]; strings.TrimSpace(st) == "" {
+		if _, fromCnty := splitADIFCounty(rec["my_cnty"]); fromCnty != "" {
+			q.MyState = fromCnty
+		}
+	}
 	q.MyIOTA = strings.ToUpper(rec["my_iota"])
 	q.MySOTARef = strings.ToUpper(rec["my_sota_ref"])
 	q.MyPOTARef = strings.ToUpper(rec["my_pota_ref"])
@@ -698,3 +715,20 @@ var promotableSubmodes = map[string]bool{
 func submodeSubsumesParent(submode string) bool {
 	return promotableSubmodes[submode]
 }
+
+// splitADIFCounty reads CNTY, which ADIF defines as "STATE,COUNTY".
+//
+// Returns the county on its own plus the state the field carried, so an import
+// from a logger that follows the standard fills BOTH columns here. Files that
+// write the bare county — as OpsLog itself used to — still import unchanged.
+//
+// The state from the field never overrides an explicit STATE tag: STATE is the
+// dedicated field and the more specific statement. It only fills a blank.
+func splitADIFCounty(cnty string) (county, state string) {
+	cnty = strings.TrimSpace(cnty)
+	i := strings.Index(cnty, ",")
+	if i < 0 {
+		return cnty, ""
+	}
+	return strings.TrimSpace(cnty[i+1:]), strings.ToUpper(strings.TrimSpace(cnty[:i]))
+}

internal/adif/qslvia.go

@@ -0,0 +1,53 @@
+package adif
+
+import "strings"
+
+// The ADIF "QSL Via" enumeration, used by QSL_SENT_VIA and QSL_RCVD_VIA. It
+// says how a card travelled, and is a different thing entirely from QSL_VIA,
+// which is the manager's callsign.
+const (
+	QSLViaBureau     = "B"
+	QSLViaDirect     = "D"
+	QSLViaElectronic = "E"
+	// QSLViaManager is import-only in the standard: it may be read from another
+	// logger's file, never written to one. OpsLog keeps it when it arrives so
+	// the operator's own data is not silently altered, and NormaliseQSLVia is
+	// the only place that decides so.
+	QSLViaManager = "M"
+)
+
+// NormaliseQSLVia folds what other loggers and OpsLog's own older versions put
+// in a routing field down to the ADIF enumeration.
+//
+// It accepts the letter, the English word, and the French one — OpsLog wrote
+// "Bureau", "Direct" and "Electronic" in full for a long time, and the QSL
+// Manager panel still shows those words to a French operator. Anything it does
+// not recognise comes back empty rather than being passed through: this feeds
+// an enumerated ADIF field, and inventing a value there breaks the file for
+// every other logger that reads it.
+func NormaliseQSLVia(s string) string {
+	switch strings.ToUpper(strings.TrimSpace(s)) {
+	case "B", "BUREAU", "BURO", "VIA BUREAU":
+		return QSLViaBureau
+	case "D", "DIRECT":
+		return QSLViaDirect
+	case "E", "ELECTRONIC", "ELECTRONIQUE", "ÉLECTRONIQUE", "OQRS":
+		return QSLViaElectronic
+	case "M", "MANAGER":
+		return QSLViaManager
+	}
+	return ""
+}
+
+// IsQSLViaRouting reports whether a QSL_VIA value is in fact a routing method
+// that ended up in the manager field.
+//
+// It exists for one repair: OpsLog's QSL Manager panel wrote "Bureau",
+// "Direct" and "Electronic" into QSL_VIA, and imports folded QSL_SENT_VIA
+// there too, so logs hold a mixture of managers and routing words in one
+// column. A manager is a callsign, never one of these six words, so the test
+// is exact — but it is deliberately narrow: anything else, including a manager
+// whose callsign happens to be unusual, is left alone.
+func IsQSLViaRouting(s string) bool {
+	return NormaliseQSLVia(s) != ""
+}

internal/adif/qslvia_test.go

@@ -0,0 +1,37 @@
+package adif
+
+import "testing"
+
+func TestNormaliseQSLVia(t *testing.T) {
+	for in, want := range map[string]string{
+		"B": "B", "b": "B", "Bureau": "B", "BUREAU": "B", " buro ": "B",
+		"D": "D", "Direct": "D", "direct": "D",
+		"E": "E", "Electronic": "E", "électronique": "E", "OQRS": "E",
+		"M": "M", "Manager": "M",
+		// A manager's callsign is not a routing method, and neither is noise.
+		"M0OXO": "", "EA5GL": "", "": "", "Bureau via M0OXO": "", "X": "",
+	} {
+		if got := NormaliseQSLVia(in); got != want {
+			t.Errorf("NormaliseQSLVia(%q) = %q, want %q", in, got, want)
+		}
+	}
+}
+
+// The repair moves values out of the manager column. A false positive would
+// erase a real manager, so the guard is worth its own test: every callsign-like
+// value must be refused.
+func TestIsQSLViaRoutingRefusesManagers(t *testing.T) {
+	for _, call := range []string{
+		"M0OXO", "EA5GL", "F5CWU", "DJ9ZB", "W3HNK", "IK2DUW", "N7RO",
+		"BUREAU M0OXO", "via bureau DL1XYZ", "QSL DIRECT ONLY",
+	} {
+		if IsQSLViaRouting(call) {
+			t.Errorf("%q was taken for a routing method — the repair would erase it", call)
+		}
+	}
+	for _, v := range []string{"B", "D", "E", "M", "Bureau", "Direct", "Electronic"} {
+		if !IsQSLViaRouting(v) {
+			t.Errorf("%q should be recognised as a routing method", v)
+		}
+	}
+}

internal/adif/roundtrip_test.go

@@ -20,7 +20,7 @@ func TestPromotedFieldsRoundTrip(t *testing.T) {
 	in := qso.QSO{
 		Callsign: "EA8ABC", Band: "20m", Mode: "SSB",
 		QSODate: time.Date(2026, 6, 6, 12, 0, 0, 0, time.UTC),
-		SIG: "POTA", SIGInfo: "US-0001", MySIG: "WWFF", MySIGInfo: "ONFF-0001",
+		SIG:     "POTA", SIGInfo: "US-0001", MySIG: "WWFF", MySIGInfo: "ONFF-0001",
 		WWFFRef: "ONFF-0001", MyWWFFRef: "F-FFF-0001",
 		Distance: &dist, RXPower: &rxp, AIndex: &a,
 		SKCC: "12345S", FISTS: "999", TenTen: "55555",
@@ -119,3 +119,85 @@ func renderRecord(q qso.QSO, includeApp bool) string {
 	bw.Flush()
 	return buf.String()
 }
+
+// TestQSLViaFieldsRoundTrip covers the case reported as issue #16: a log
+// exported by another logger carries a manager in QSL_VIA and a routing method
+// in QSL_SENT_VIA, and the two must stay apart.
+//
+// Before this, QSL_SENT_VIA was folded into QSL_VIA whenever QSL_VIA was empty
+// — so a Log4OM log, which defaults QSL_SENT_VIA to E, showed "E" wherever
+// OpsLog displays the manager — and QSL_RCVD_VIA was thrown away outright: it
+// was listed as a promoted field with no column behind it, so it was not even
+// kept among the extras. Neither was ever exported, which made an import
+// followed by an export destroy both.
+func TestQSLViaFieldsRoundTrip(t *testing.T) {
+	in := qso.QSO{
+		Callsign: "3B9FR", Band: "20m", Mode: "CW",
+		QSODate:    time.Date(2026, 6, 6, 12, 0, 0, 0, time.UTC),
+		QSLVia:     "M0OXO", // the manager
+		QSLSentVia: "D",     // sent direct
+		QSLRcvdVia: "B",     // came back via the bureau
+	}
+	var buf bytes.Buffer
+	bw := bufio.NewWriter(&buf)
+	bw.WriteString("<EOH>\n")
+	writeRecord(bw, in, true, nil)
+	bw.Flush()
+
+	var rec Record
+	if err := Parse(strings.NewReader(buf.String()), func(r Record) error { rec = r; return nil }); err != nil {
+		t.Fatalf("parse: %v", err)
+	}
+	out, ok := recordToQSO(rec)
+	if !ok {
+		t.Fatal("recordToQSO returned !ok")
+	}
+	for name, c := range map[string]struct{ got, want string }{
+		"QSL_VIA":      {out.QSLVia, in.QSLVia},
+		"QSL_SENT_VIA": {out.QSLSentVia, in.QSLSentVia},
+		"QSL_RCVD_VIA": {out.QSLRcvdVia, in.QSLRcvdVia},
+	} {
+		if c.got != c.want {
+			t.Errorf("%s: got %q, want %q", name, c.got, c.want)
+		}
+	}
+}
+
+// TestQSLSentViaDoesNotBecomeManager pins the exact shape a Log4OM export has:
+// no QSL_VIA at all, QSL_SENT_VIA defaulted to E. The manager field must come
+// back empty rather than holding "E".
+func TestQSLSentViaDoesNotBecomeManager(t *testing.T) {
+	const rec = "<CALL:5>OE6CLD<QSO_DATE:8>20260606<TIME_ON:4>1200<BAND:3>20m<MODE:2>CW" +
+		"<QSL_SENT_VIA:1>E<EOR>\n"
+	var got Record
+	if err := Parse(strings.NewReader("<EOH>\n"+rec), func(r Record) error { got = r; return nil }); err != nil {
+		t.Fatalf("parse: %v", err)
+	}
+	q, ok := recordToQSO(got)
+	if !ok {
+		t.Fatal("recordToQSO returned !ok")
+	}
+	if q.QSLVia != "" {
+		t.Errorf("QSL_VIA = %q — the routing method leaked into the manager field again", q.QSLVia)
+	}
+	if q.QSLSentVia != "E" {
+		t.Errorf("QSL_SENT_VIA = %q, want %q", q.QSLSentVia, "E")
+	}
+}
+
+// M is import-only in the ADIF QSL Via enumeration: keep it when given, never
+// write it back out.
+func TestQSLViaManagerIsImportOnly(t *testing.T) {
+	in := qso.QSO{
+		Callsign: "3B9FR", Band: "20m", Mode: "CW",
+		QSODate:    time.Date(2026, 6, 6, 12, 0, 0, 0, time.UTC),
+		QSLSentVia: "M", QSLRcvdVia: "M",
+	}
+	var buf bytes.Buffer
+	bw := bufio.NewWriter(&buf)
+	writeRecord(bw, in, true, nil)
+	bw.Flush()
+	if s := buf.String(); strings.Contains(s, "QSL_SENT_VIA") || strings.Contains(s, "QSL_RCVD_VIA") {
+		t.Errorf("exported an import-only value:\n%s", s)
+	}
+}

internal/award/award.go

@@ -749,9 +749,14 @@ func EmissionOf(mode string) string { return emissionOf(mode) }
 // abbreviating "Saint"→"St." and hyphenating "Matanuska-Susitna". The rules:
 //   - if cnty already carries "ST,County", split on the first comma; else take
 //     the state from the STATE column;
-//   - upper-case; drop periods and apostrophes; hyphens→space; strip a trailing
-//     County/Parish/Borough/Census Area/Municipality; fold Saint(e)→St(e);
-//     collapse whitespace;
+//   - upper-case; fold accents (the FIPS list writes "Doña Ana", callbooks and
+//     logs write "Dona Ana"); drop periods and apostrophes; hyphens→space;
+//     expand the parenthetical shapes GeoNames uses for county-equivalents
+//     ("Baltimore (city)", "Nome (CA)") and drop its "City and County of"
+//     style prefixes; strip a trailing County/Parish/Borough/Census Area/
+//     Municipality; fold Saint(e)→St(e); collapse whitespace;
+//   - fold the counties renamed since the USA-CA list was drawn onto the name
+//     the award still uses, so a QSO there counts for something (see renamed);
 //   - require a 2-letter state and a non-empty county, else no match ("").
 func USCountyKey(state, cnty string) string {
 	s := strings.TrimSpace(cnty)
@@ -764,10 +769,11 @@ func USCountyKey(state, cnty string) string {
 	} else {
 		st, co = strings.TrimSpace(state), s
 	}
-	co = strings.ToUpper(co)
+	co = strings.ToUpper(foldAccents(co))
 	co = strings.ReplaceAll(co, ".", "")
 	co = strings.ReplaceAll(co, "'", "")
 	co = strings.ReplaceAll(co, "-", " ")
+	co = expandCountyEquivalent(co)
 	for _, suf := range []string{" COUNTY", " PARISH", " BOROUGH", " CENSUS AREA", " MUNICIPALITY"} {
 		if strings.HasSuffix(co, suf) {
 			co = strings.TrimSuffix(co, suf)
@@ -788,6 +794,9 @@ func USCountyKey(state, cnty string) string {
 	if len(st) != 2 || co == "" {
 		return ""
 	}
+	if alias, ok := renamed[st+"/"+co]; ok {
+		co = alias
+	}
 	// Separator is "/", NOT ",": the QSOFIELDS matcher splits a field value on
 	// commas/semicolons (n-fer POTA "US-1,US-2"), which would shatter "AL,AUTAUGA"
 	// into two non-matching tokens. The stored ADIF cnty keeps its comma; only

internal/award/uscounty_names.go

@@ -0,0 +1,120 @@
+package award
+
+import "strings"
+
+// Name normalisation for USCountyKey. It exists because the county a QSO
+// carries and the county the USA-CA reference list carries come from different
+// hands and rarely agree letter for letter:
+//
+//   - the reference is the FIPS list ("Doña Ana County", "Baltimore city");
+//   - a callbook writes what the licensee typed;
+//   - and OpsLog's own offline resolver reads GeoNames, which spells the
+//     county-equivalents its own way ("Baltimore (city)", "Nome (CA)",
+//     "City and County of San Francisco").
+//
+// Measured against a full FCC ULS import (1.56 M US callsigns), the shapes
+// handled here account for ~7 300 stations whose county matched nothing at all
+// — they showed as a new county for ever and counted for no award.
+//
+// Everything here is SPELLING. A county that genuinely no longer exists under
+// that name is a different problem, handled by renamed below.
+
+// foldAccents strips the diacritics that separate a FIPS name from the ASCII
+// every log and callbook actually holds. Only the letters that occur in US
+// place names are listed — this is not a general Unicode folder, and it must
+// not become one: silently folding arbitrary marks would let two distinct
+// references collapse onto one key.
+var accents = strings.NewReplacer(
+	"ñ", "n", "Ñ", "N",
+	"á", "a", "Á", "A",
+	"é", "e", "É", "E",
+	"í", "i", "Í", "I",
+	"ó", "o", "Ó", "O",
+	"ú", "u", "Ú", "U",
+	"ü", "u", "Ü", "U",
+	"ç", "c", "Ç", "C",
+)
+
+func foldAccents(s string) string {
+	// Fast path: US county names are ASCII with a single exception (Doña Ana),
+	// so the common case must not pay for the replacer.
+	for i := 0; i < len(s); i++ {
+		if s[i] >= 0x80 {
+			return accents.Replace(s)
+		}
+	}
+	return s
+}
+
+// expandCountyEquivalent rewrites GeoNames' parenthetical and prefixed spellings
+// of county-equivalents into the plain FIPS form, which the rest of USCountyKey
+// then normalises as usual.
+//
+// Input is already upper-cased with periods and hyphens removed.
+//
+//	BALTIMORE (CITY)                 → BALTIMORE CITY   (FIPS "Baltimore city")
+//	NOME (CA)                        → NOME CENSUS AREA (suffix stripped after)
+//	CITY AND COUNTY OF SAN FRANCISCO → SAN FRANCISCO
+//
+// The truncated "(CITY" is not a typo here: GeoNames really does ship
+// "Colonial Heights (city" with the closing parenthesis missing.
+func expandCountyEquivalent(co string) string {
+	switch {
+	case strings.HasSuffix(co, " (CITY)"):
+		co = strings.TrimSuffix(co, " (CITY)") + " CITY"
+	case strings.HasSuffix(co, " (CITY"):
+		co = strings.TrimSuffix(co, " (CITY") + " CITY"
+	case strings.HasSuffix(co, " (CA)"):
+		co = strings.TrimSuffix(co, " (CA)") + " CENSUS AREA"
+	}
+	// "City and County of X" and "City and Borough of X" are the same place as
+	// FIPS's bare "X" (San Francisco, Denver, Honolulu, Juneau, Sitka). Note the
+	// order: the longer prefixes must be tried before "CITY OF ".
+	for _, p := range []string{
+		"CITY AND COUNTY OF ",
+		"CITY AND BOROUGH OF ",
+		"MUNICIPALITY OF ",
+		"BOROUGH OF ",
+		"CITY OF ",
+	} {
+		if strings.HasPrefix(co, p) {
+			return strings.TrimPrefix(co, p)
+		}
+	}
+	return co
+}
+
+// renamed folds a county renamed or re-drawn since the CQ USA-CA list was
+// published onto the name the award still counts. Keys and values are finished
+// USCountyKey county parts (upper-case, no spaces), looked up as "ST/COUNTY".
+//
+// This deliberately does NOT track the FIPS list. USA-CA is a fixed target of
+// ~3 100 counties; when a state renames one, the award does not reissue its
+// list, so a QSO with the new name would otherwise match nothing and count for
+// nothing. Folding it onto the old name is the only outcome that scores.
+//
+// Connecticut is absent on purpose. Its 2022 planning regions are not renamed
+// counties: a region is drawn from towns belonging to several different
+// counties, so there is no name that maps to another name. That one is resolved
+// from the station's ZIP, in internal/uls.
+var renamed = map[string]string{
+	// Wade Hampton Census Area, AK → Kusilvak Census Area (2015).
+	"AK/KUSILVAK": "WADEHAMPTON",
+	// Shannon County, SD → Oglala Lakota County (2015).
+	"SD/OGLALALAKOTA": "SHANNON",
+	// Valdez-Cordova Census Area, AK was split in two (2019). Both halves fold
+	// back to the parent the award still lists.
+	"AK/CHUGACH":     "VALDEZCORDOVA",
+	"AK/COPPERRIVER": "VALDEZCORDOVA",
+
+	// Alaska's four "X City and Borough". The reference codes for these look
+	// wrong and are not: the trailing " BOROUGH" is stripped as a county type,
+	// leaving "JUNEAU CITY AND". Nothing else in the chain produces that shape
+	// — a log that simply says "Juneau", and GeoNames' "City and Borough of
+	// Juneau", both arrive here as "JUNEAU" and would match nothing. Rather
+	// than re-key four published references, bend the bare name onto them.
+	"AK/JUNEAU":   "JUNEAUCITYAND",
+	"AK/SITKA":    "SITKACITYAND",
+	"AK/WRANGELL": "WRANGELLCITYAND",
+	"AK/YAKUTAT":  "YAKUTATCITYAND",
+}

internal/awardref/uscounties_gen.go

@@ -1943,7 +1943,7 @@ func usCounties() []Ref {
 		ref("NM/COLFAX", "Colfax County, NM", 291),
 		ref("NM/CURRY", "Curry County, NM", 291),
 		ref("NM/DEBACA", "De Baca County, NM", 291),
-		ref("NM/DO̱AANA", "Do̱a Ana County, NM", 291),
+		ref("NM/DONAANA", "Doña Ana County, NM", 291),
 		ref("NM/EDDY", "Eddy County, NM", 291),
 		ref("NM/GRANT", "Grant County, NM", 291),
 		ref("NM/GUADALUPE", "Guadalupe County, NM", 291),

internal/awardref/uscounties_test.go

@@ -0,0 +1,118 @@
+package awardref
+
+import (
+	"strings"
+	"testing"
+	"unicode/utf8"
+
+	"hamlog/internal/award"
+)
+
+// TestUSCountyRefsSelfConsistent is the guard that was missing when the Doña Ana
+// row shipped mangled: its code was "NM/DO̱AANA", which no log, no callbook and
+// no county database could ever produce, so that county was unwinnable and
+// nothing said so.
+//
+// Every reference must reproduce its own code from its own display name through
+// award.USCountyKey — the same function cmd/cntygen used to build it. That ties
+// the generated file to the matcher: change the normalisation rules and this
+// fails the moment one of the 3 102 references stops matching itself.
+func TestUSCountyRefsSelfConsistent(t *testing.T) {
+	refs := usCounties()
+	if len(refs) < 3000 {
+		t.Fatalf("only %d counties — the generated list looks truncated", len(refs))
+	}
+	for _, r := range refs {
+		if !utf8.ValidString(r.Name) || !utf8.ValidString(r.Code) {
+			t.Errorf("%s (%q): not valid UTF-8", r.Code, r.Name)
+			continue
+		}
+		// Name is "County Name, ST".
+		i := strings.LastIndex(r.Name, ", ")
+		if i < 0 {
+			t.Errorf("%s: name %q is not \"County, ST\"", r.Code, r.Name)
+			continue
+		}
+		name, st := r.Name[:i], r.Name[i+2:]
+		if got := award.USCountyKey(st, name); got != r.Code {
+			t.Errorf("USCountyKey(%q, %q) = %q, want %q", st, name, got, r.Code)
+		}
+	}
+}
+
+// TestUSCountyRefsUnique catches a normalisation rule loose enough to collapse
+// two real counties onto one key — the failure mode that would silently merge
+// them in every award total.
+func TestUSCountyRefsUnique(t *testing.T) {
+	seen := map[string]string{}
+	for _, r := range usCounties() {
+		if prev, dup := seen[r.Code]; dup {
+			t.Errorf("code %s is shared by %q and %q", r.Code, prev, r.Name)
+			continue
+		}
+		seen[r.Code] = r.Name
+	}
+}
+
+// TestUSCountyResolverShapes pins the spellings OpsLog's own offline resolver
+// produces (GeoNames, via internal/uls) against the reference. These are the
+// real strings that were failing to match, with the number of US callsigns each
+// covers in a full FCC ULS import.
+func TestUSCountyResolverShapes(t *testing.T) {
+	valid := map[string]bool{}
+	for _, r := range usCounties() {
+		valid[r.Code] = true
+	}
+	cases := []struct {
+		st, county, want string
+	}{
+		{"CA", "City and County of San Francisco", "CA/SANFRANCISCO"}, // 4 217 calls
+		{"NM", "Doña Ana", "NM/DONAANA"},                              // 1 214
+		{"NM", "Dona Ana", "NM/DONAANA"},                              // what logs hold
+		{"MD", "Baltimore (city)", "MD/BALTIMORECITY"},                // 885
+		{"MO", "St. Louis (city)", "MO/STLOUISCITY"},                  // 574
+		{"MO", "St. Louis", "MO/STLOUIS"},                             // the county, distinct
+		{"AK", "Nome (CA)", "AK/NOME"},                                // 252
+		{"AK", "Yukon-Koyukuk (CA)", "AK/YUKONKOYUKUK"},               // 84
+		{"AK", "City and Borough of Wrangell", "AK/WRANGELLCITYAND"},  // 27
+		{"AK", "Juneau", "AK/JUNEAUCITYAND"},                          // a log that just says Juneau
+		{"AK", "Kusilvak", "AK/WADEHAMPTON"},                          // renamed 2015
+		{"SD", "Oglala Lakota County", "SD/SHANNON"},                  // renamed 2015
+		{"AK", "Chugach Census Area", "AK/VALDEZCORDOVA"},             // split 2019
+		{"AK", "Copper River Census Area", "AK/VALDEZCORDOVA"},
+		{"CO", "City and County of Denver", "CO/DENVER"},
+		{"HI", "City and County of Honolulu", "HI/HONOLULU"},
+	}
+	for _, c := range cases {
+		got := award.USCountyKey(c.st, c.county)
+		if got != c.want {
+			t.Errorf("USCountyKey(%q, %q) = %q, want %q", c.st, c.county, got, c.want)
+			continue
+		}
+		if !valid[got] {
+			t.Errorf("USCountyKey(%q, %q) = %q, which is not in the reference list", c.st, c.county, got)
+		}
+	}
+}
+
+// TestUSCountyKeepsVirginiaCitiesOut guards the other direction: cmd/cntygen
+// drops Virginia's independent cities and Carson City on purpose, because CQ's
+// USA-CA does not count them. Normalising their names must not smuggle them
+// back in as some neighbouring county.
+func TestUSCountyKeepsVirginiaCitiesOut(t *testing.T) {
+	valid := map[string]bool{}
+	for _, r := range usCounties() {
+		valid[r.Code] = true
+	}
+	for _, c := range []string{"Virginia Beach (city)", "City of Alexandria", "Lynchburg (city)"} {
+		if k := award.USCountyKey("VA", c); valid[k] {
+			t.Errorf("%q resolved to %s, which USA-CA does not count", c, k)
+		}
+	}
+	// Charles City and James City ARE counties, despite the name.
+	for _, c := range []string{"Charles City", "James City"} {
+		if k := award.USCountyKey("VA", c); !valid[k] {
+			t.Errorf("%q resolved to %s, which is missing from the reference", c, k)
+		}
+	}
+}

internal/db/migrations/0027_qsl_sent_rcvd_via.sql

@@ -0,0 +1,18 @@
+-- QSL_SENT_VIA / QSL_RCVD_VIA — the ADIF fields that say HOW a card travelled.
+--
+-- Until now OpsLog had one column, qsl_via, and used it for two unrelated
+-- things: the QSL manager (what ADIF's QSL_VIA holds) and the routing method.
+-- Imports made it worse — QSL_SENT_VIA was folded into qsl_via when qsl_via was
+-- empty, so a Log4OM log arrived with "E" sitting where the manager belongs —
+-- and QSL_RCVD_VIA was dropped outright, listed as a promoted field with no
+-- column behind it, so it was not even kept among the extras.
+--
+-- These two columns hold the ADIF enumeration: B (bureau), D (direct),
+-- E (electronic). M (manager) is accepted on import only, per the standard.
+--
+-- Adding the columns is all that happens here. Existing qsl_via values are NOT
+-- touched: separating a manager from a routing word rewrites what an operator
+-- can see in their own log, so it is offered once, with a count, and only runs
+-- when they say yes.
+ALTER TABLE qso ADD COLUMN qsl_sent_via TEXT;
+ALTER TABLE qso ADD COLUMN qsl_rcvd_via TEXT;

internal/dxcc/dxcc.go

@@ -132,6 +132,18 @@ func (db *DB) Entities() []*Entity {
 func (db *DB) Lookup(callsign string) (Match, bool) {
 	db.mu.RLock()
 	defer db.mu.RUnlock()
+	// Maritime and aeronautical mobile belong to NO entity, and that is not a
+	// technicality — the station is at sea or in the air. RI1FJL/MM resolved to
+	// Franz Josef Land while the expedition was still on its way there, telling
+	// the operator they had worked an entity they had not.
+	//
+	// The previous choice was deliberate ("the log should still show the
+	// operator's country") and it is wrong for exactly that reason: a home
+	// country here is not extra information, it is a false claim about where the
+	// contact happened.
+	if IsMobileNoEntity(callsign) {
+		return Match{}, false
+	}
 	call := normalizeCallsign(callsign)
 	if call == "" {
 		return Match{}, false
@@ -364,3 +376,22 @@ func replaceAreaDigit(call string, d byte) string {
 	}
 	return call
 }
+
+// IsMobileNoEntity reports a callsign DXCC assigns to no entity: a TRAILING
+// /MM (maritime mobile) or /AM (aeronautical mobile).
+//
+// Trailing only. A LEADING "MM" is the Scotland prefix and "AM" is Spain, so
+// MM0ABC and AM5X are ordinary calls — treating those as entity-less would be a
+// far larger error than the one this fixes.
+func IsMobileNoEntity(callsign string) bool {
+	s := strings.ToUpper(strings.TrimSpace(callsign))
+	i := strings.LastIndex(s, "/")
+	if i < 0 {
+		return false
+	}
+	switch s[i+1:] {
+	case "MM", "AM":
+		return true
+	}
+	return false
+}

internal/dxcc/dxcc_names_gen.go

@@ -4,348 +4,348 @@ package dxcc
 // numbers. Generated by joining cty.dat to the authoritative ARRL/ADIF entity
 // list (k0swe/dxcc-json) by primary prefix + canonical name. 344 entities.
 var dxccByName = map[string]int{
-	"afghanistan": 3,
-	"agalega & st. brandon": 4,
-	"aland islands": 5,
-	"alaska": 6,
-	"albania": 7,
-	"algeria": 400,
-	"american samoa": 9,
+	"afghanistan":              3,
+	"agalega & st. brandon":    4,
+	"aland islands":            5,
+	"alaska":                   6,
+	"albania":                  7,
+	"algeria":                  400,
+	"american samoa":           9,
 	"amsterdam & st. paul is.": 10,
-	"andaman & nicobar is.": 11,
-	"andorra": 203,
-	"angola": 401,
-	"anguilla": 12,
-	"annobon island": 195,
-	"antarctica": 13,
-	"antigua & barbuda": 94,
-	"argentina": 100,
-	"armenia": 14,
-	"aruba": 91,
-	"ascension island": 205,
-	"asiatic russia": 15,
-	"asiatic turkey": 390,
-	"austral islands": 508,
-	"australia": 150,
-	"austria": 206,
-	"aves island": 17,
-	"azerbaijan": 18,
-	"azores": 149,
-	"bahamas": 60,
-	"bahrain": 304,
-	"baker & howland islands": 20,
-	"balearic islands": 21,
-	"banaba island": 490,
-	"bangladesh": 305,
-	"barbados": 62,
-	"bear island": 259,
-	"belarus": 27,
-	"belgium": 209,
-	"belize": 66,
-	"benin": 416,
-	"bermuda": 64,
-	"bhutan": 306,
-	"bolivia": 104,
-	"bonaire": 520,
-	"bosnia-herzegovina": 501,
-	"botswana": 402,
-	"bouvet": 24,
-	"brazil": 108,
-	"british virgin islands": 65,
-	"brunei darussalam": 345,
-	"bulgaria": 212,
-	"burkina faso": 480,
-	"burundi": 404,
-	"cambodia": 312,
-	"cameroon": 406,
-	"canada": 1,
-	"canary islands": 29,
-	"cape verde": 409,
-	"cayman islands": 69,
+	"andaman & nicobar is.":    11,
+	"andorra":                  203,
+	"angola":                   401,
+	"anguilla":                 12,
+	"annobon island":           195,
+	"antarctica":               13,
+	"antigua & barbuda":        94,
+	"argentina":                100,
+	"armenia":                  14,
+	"aruba":                    91,
+	"ascension island":         205,
+	"asiatic russia":           15,
+	"asiatic turkey":           390,
+	"austral islands":          508,
+	"australia":                150,
+	"austria":                  206,
+	"aves island":              17,
+	"azerbaijan":               18,
+	"azores":                   149,
+	"bahamas":                  60,
+	"bahrain":                  304,
+	"baker & howland islands":  20,
+	"balearic islands":         21,
+	"banaba island":            490,
+	"bangladesh":               305,
+	"barbados":                 62,
+	"bear island":              259,
+	"belarus":                  27,
+	"belgium":                  209,
+	"belize":                   66,
+	"benin":                    416,
+	"bermuda":                  64,
+	"bhutan":                   306,
+	"bolivia":                  104,
+	"bonaire":                  520,
+	"bosnia-herzegovina":       501,
+	"botswana":                 402,
+	"bouvet":                   24,
+	"brazil":                   108,
+	"british virgin islands":   65,
+	"brunei darussalam":        345,
+	"bulgaria":                 212,
+	"burkina faso":             480,
+	"burundi":                  404,
+	"cambodia":                 312,
+	"cameroon":                 406,
+	"canada":                   1,
+	"canary islands":           29,
+	"cape verde":               409,
+	"cayman islands":           69,
 	"central african republic": 408,
-	"central kiribati": 31,
-	"ceuta & melilla": 32,
-	"chad": 410,
-	"chagos islands": 33,
-	"chatham islands": 34,
-	"chesterfield islands": 512,
-	"chile": 112,
-	"china": 318,
-	"christmas island": 35,
-	"clipperton island": 36,
-	"cocos (keeling) islands": 38,
-	"cocos island": 37,
-	"colombia": 116,
-	"comoros": 411,
-	"conway reef": 489,
-	"corsica": 214,
-	"costa rica": 308,
-	"cote d'ivoire": 428,
-	"crete": 40,
-	"croatia": 497,
-	"crozet island": 41,
-	"cuba": 70,
-	"curacao": 517,
-	"cyprus": 215,
-	"czech republic": 503,
-	"dem. rep. of the congo": 414,
-	"denmark": 221,
-	"desecheo island": 43,
-	"djibouti": 382,
-	"dodecanese": 45,
-	"dominica": 95,
-	"dominican republic": 72,
-	"dpr of korea": 344,
-	"ducie island": 513,
-	"east malaysia": 46,
-	"easter island": 47,
-	"eastern kiribati": 48,
-	"ecuador": 120,
-	"egypt": 478,
-	"el salvador": 74,
-	"england": 223,
-	"equatorial guinea": 49,
-	"eritrea": 51,
-	"estonia": 52,
-	"ethiopia": 53,
-	"european russia": 54,
-	"european turkey": 390,
-	"falkland islands": 141,
-	"faroe islands": 222,
-	"fed. rep. of germany": 230,
-	"fernando de noronha": 56,
-	"fiji": 176,
-	"finland": 224,
-	"france": 227,
-	"franz josef land": 61,
-	"french guiana": 63,
-	"french polynesia": 175,
-	"gabon": 420,
-	"galapagos islands": 71,
-	"georgia": 75,
-	"ghana": 424,
-	"gibraltar": 233,
-	"glorioso islands": 99,
-	"greece": 236,
-	"greenland": 237,
-	"grenada": 77,
-	"guadeloupe": 79,
-	"guam": 103,
-	"guantanamo bay": 105,
-	"guatemala": 76,
-	"guernsey": 106,
-	"guinea": 107,
-	"guinea-bissau": 109,
-	"guyana": 129,
-	"haiti": 78,
-	"hawaii": 110,
-	"heard island": 111,
-	"honduras": 80,
-	"hong kong": 321,
-	"hungary": 239,
-	"iceland": 242,
-	"india": 324,
-	"indonesia": 327,
-	"iran": 330,
-	"iraq": 333,
-	"ireland": 245,
-	"isle of man": 114,
-	"israel": 336,
-	"italy": 248,
-	"itu hq": 117,
-	"jamaica": 82,
-	"jan mayen": 118,
-	"japan": 339,
-	"jersey": 122,
-	"johnston island": 123,
-	"jordan": 342,
-	"juan de nova, europa": 124,
-	"juan fernandez islands": 125,
-	"kaliningrad": 126,
-	"kazakhstan": 130,
-	"kenya": 430,
-	"kerguelen islands": 131,
-	"kermadec islands": 133,
-	"kingdom of eswatini": 468,
-	"kure island": 138,
-	"kuwait": 348,
-	"kyrgyzstan": 135,
-	"lakshadweep islands": 142,
-	"laos": 143,
-	"latvia": 145,
-	"lebanon": 354,
-	"lesotho": 432,
-	"liberia": 434,
-	"libya": 436,
-	"liechtenstein": 251,
-	"lithuania": 146,
-	"lord howe island": 147,
-	"luxembourg": 254,
-	"macao": 152,
-	"macquarie island": 153,
-	"madagascar": 438,
-	"madeira islands": 256,
-	"malawi": 440,
-	"maldives": 159,
-	"mali": 442,
-	"malpelo island": 161,
-	"malta": 257,
-	"mariana islands": 166,
-	"market reef": 167,
-	"marquesas islands": 509,
-	"marshall islands": 168,
-	"martinique": 84,
-	"mauritania": 444,
-	"mauritius": 165,
-	"mayotte": 169,
-	"mellish reef": 171,
-	"mexico": 50,
-	"micronesia": 173,
-	"midway island": 174,
-	"minami torishima": 177,
-	"moldova": 179,
-	"monaco": 260,
-	"mongolia": 363,
-	"montenegro": 514,
-	"montserrat": 96,
-	"morocco": 446,
-	"mount athos": 180,
-	"mozambique": 181,
-	"myanmar": 309,
-	"n.z. subantarctic is.": 16,
-	"namibia": 464,
-	"nauru": 157,
-	"navassa island": 182,
-	"nepal": 369,
-	"netherlands": 263,
-	"new caledonia": 162,
-	"new zealand": 170,
-	"nicaragua": 86,
-	"niger": 187,
-	"nigeria": 450,
-	"niue": 188,
-	"norfolk island": 189,
-	"north cook islands": 191,
-	"north macedonia": 502,
-	"northern ireland": 265,
-	"norway": 266,
-	"ogasawara": 192,
-	"oman": 370,
-	"pakistan": 372,
-	"palau": 22,
-	"palestine": 510,
+	"central kiribati":         31,
+	"ceuta & melilla":          32,
+	"chad":                     410,
+	"chagos islands":           33,
+	"chatham islands":          34,
+	"chesterfield islands":     512,
+	"chile":                    112,
+	"china":                    318,
+	"christmas island":         35,
+	"clipperton island":        36,
+	"cocos (keeling) islands":  38,
+	"cocos island":             37,
+	"colombia":                 116,
+	"comoros":                  411,
+	"conway reef":              489,
+	"corsica":                  214,
+	"costa rica":               308,
+	"cote d'ivoire":            428,
+	"crete":                    40,
+	"croatia":                  497,
+	"crozet island":            41,
+	"cuba":                     70,
+	"curacao":                  517,
+	"cyprus":                   215,
+	"czech republic":           503,
+	"dem. rep. of the congo":   414,
+	"denmark":                  221,
+	"desecheo island":          43,
+	"djibouti":                 382,
+	"dodecanese":               45,
+	"dominica":                 95,
+	"dominican republic":       72,
+	"dpr of korea":             344,
+	"ducie island":             513,
+	"east malaysia":            46,
+	"easter island":            47,
+	"eastern kiribati":         48,
+	"ecuador":                  120,
+	"egypt":                    478,
+	"el salvador":              74,
+	"england":                  223,
+	"equatorial guinea":        49,
+	"eritrea":                  51,
+	"estonia":                  52,
+	"ethiopia":                 53,
+	"european russia":          54,
+	"european turkey":          390,
+	"falkland islands":         141,
+	"faroe islands":            222,
+	"fed. rep. of germany":     230,
+	"fernando de noronha":      56,
+	"fiji":                     176,
+	"finland":                  224,
+	"france":                   227,
+	"franz josef land":         61,
+	"french guiana":            63,
+	"french polynesia":         175,
+	"gabon":                    420,
+	"galapagos islands":        71,
+	"georgia":                  75,
+	"ghana":                    424,
+	"gibraltar":                233,
+	"glorioso islands":         99,
+	"greece":                   236,
+	"greenland":                237,
+	"grenada":                  77,
+	"guadeloupe":               79,
+	"guam":                     103,
+	"guantanamo bay":           105,
+	"guatemala":                76,
+	"guernsey":                 106,
+	"guinea":                   107,
+	"guinea-bissau":            109,
+	"guyana":                   129,
+	"haiti":                    78,
+	"hawaii":                   110,
+	"heard island":             111,
+	"honduras":                 80,
+	"hong kong":                321,
+	"hungary":                  239,
+	"iceland":                  242,
+	"india":                    324,
+	"indonesia":                327,
+	"iran":                     330,
+	"iraq":                     333,
+	"ireland":                  245,
+	"isle of man":              114,
+	"israel":                   336,
+	"italy":                    248,
+	"itu hq":                   117,
+	"jamaica":                  82,
+	"jan mayen":                118,
+	"japan":                    339,
+	"jersey":                   122,
+	"johnston island":          123,
+	"jordan":                   342,
+	"juan de nova, europa":     124,
+	"juan fernandez islands":   125,
+	"kaliningrad":              126,
+	"kazakhstan":               130,
+	"kenya":                    430,
+	"kerguelen islands":        131,
+	"kermadec islands":         133,
+	"kingdom of eswatini":      468,
+	"kure island":              138,
+	"kuwait":                   348,
+	"kyrgyzstan":               135,
+	"lakshadweep islands":      142,
+	"laos":                     143,
+	"latvia":                   145,
+	"lebanon":                  354,
+	"lesotho":                  432,
+	"liberia":                  434,
+	"libya":                    436,
+	"liechtenstein":            251,
+	"lithuania":                146,
+	"lord howe island":         147,
+	"luxembourg":               254,
+	"macao":                    152,
+	"macquarie island":         153,
+	"madagascar":               438,
+	"madeira islands":          256,
+	"malawi":                   440,
+	"maldives":                 159,
+	"mali":                     442,
+	"malpelo island":           161,
+	"malta":                    257,
+	"mariana islands":          166,
+	"market reef":              167,
+	"marquesas islands":        509,
+	"marshall islands":         168,
+	"martinique":               84,
+	"mauritania":               444,
+	"mauritius":                165,
+	"mayotte":                  169,
+	"mellish reef":             171,
+	"mexico":                   50,
+	"micronesia":               173,
+	"midway island":            174,
+	"minami torishima":         177,
+	"moldova":                  179,
+	"monaco":                   260,
+	"mongolia":                 363,
+	"montenegro":               514,
+	"montserrat":               96,
+	"morocco":                  446,
+	"mount athos":              180,
+	"mozambique":               181,
+	"myanmar":                  309,
+	"n.z. subantarctic is.":    16,
+	"namibia":                  464,
+	"nauru":                    157,
+	"navassa island":           182,
+	"nepal":                    369,
+	"netherlands":              263,
+	"new caledonia":            162,
+	"new zealand":              170,
+	"nicaragua":                86,
+	"niger":                    187,
+	"nigeria":                  450,
+	"niue":                     188,
+	"norfolk island":           189,
+	"north cook islands":       191,
+	"north macedonia":          502,
+	"northern ireland":         265,
+	"norway":                   266,
+	"ogasawara":                192,
+	"oman":                     370,
+	"pakistan":                 372,
+	"palau":                    22,
+	"palestine":                510,
 	"palmyra & jarvis islands": 197,
-	"panama": 88,
-	"papua new guinea": 163,
-	"paraguay": 132,
-	"peru": 136,
-	"peter 1 island": 199,
-	"philippines": 375,
-	"pitcairn island": 172,
-	"poland": 269,
-	"portugal": 272,
-	"pr. edward & marion is.": 201,
-	"pratas island": 505,
-	"puerto rico": 202,
-	"qatar": 376,
-	"republic of korea": 137,
-	"republic of kosovo": 522,
-	"republic of south sudan": 521,
-	"republic of the congo": 412,
-	"reunion island": 453,
-	"revillagigedo": 204,
-	"rodriguez island": 207,
-	"romania": 275,
-	"rotuma island": 460,
-	"rwanda": 454,
-	"saba & st. eustatius": 519,
-	"sable island": 211,
-	"samoa": 190,
+	"panama":                   88,
+	"papua new guinea":         163,
+	"paraguay":                 132,
+	"peru":                     136,
+	"peter 1 island":           199,
+	"philippines":              375,
+	"pitcairn island":          172,
+	"poland":                   269,
+	"portugal":                 272,
+	"pr. edward & marion is.":  201,
+	"pratas island":            505,
+	"puerto rico":              202,
+	"qatar":                    376,
+	"republic of korea":        137,
+	"republic of kosovo":       522,
+	"republic of south sudan":  521,
+	"republic of the congo":    412,
+	"reunion island":           453,
+	"revillagigedo":            204,
+	"rodriguez island":         207,
+	"romania":                  275,
+	"rotuma island":            460,
+	"rwanda":                   454,
+	"saba & st. eustatius":     519,
+	"sable island":             211,
+	"samoa":                    190,
 	"san andres & providencia": 216,
 	"san felix & san ambrosio": 217,
-	"san marino": 278,
-	"sao tome & principe": 219,
-	"sardinia": 225,
-	"saudi arabia": 378,
-	"scarborough reef": 506,
-	"scotland": 279,
-	"senegal": 456,
-	"serbia": 296,
-	"seychelles": 379,
-	"shetland islands": 279,
-	"sierra leone": 458,
-	"singapore": 381,
-	"sint maarten": 518,
-	"slovak republic": 504,
-	"slovenia": 499,
-	"solomon islands": 185,
-	"somalia": 232,
-	"south africa": 462,
-	"south cook islands": 234,
-	"south georgia island": 235,
-	"south orkney islands": 238,
-	"south sandwich islands": 240,
-	"south shetland islands": 241,
-	"sov mil order of malta": 246,
-	"spain": 281,
-	"spratly islands": 247,
-	"sri lanka": 315,
-	"st. barthelemy": 516,
-	"st. helena": 250,
-	"st. kitts & nevis": 249,
-	"st. lucia": 97,
-	"st. martin": 213,
-	"st. paul island": 252,
-	"st. peter & st. paul": 253,
-	"st. pierre & miquelon": 277,
-	"st. vincent": 98,
-	"sudan": 466,
-	"suriname": 140,
-	"svalbard": 259,
-	"swains island": 515,
-	"sweden": 284,
-	"switzerland": 287,
-	"syria": 384,
-	"taiwan": 386,
-	"tajikistan": 262,
-	"tanzania": 470,
-	"temotu province": 507,
-	"thailand": 387,
-	"the gambia": 422,
-	"timor - leste": 511,
-	"togo": 483,
-	"tokelau islands": 270,
-	"tonga": 160,
-	"trindade & martim vaz": 273,
-	"trinidad & tobago": 90,
+	"san marino":               278,
+	"sao tome & principe":      219,
+	"sardinia":                 225,
+	"saudi arabia":             378,
+	"scarborough reef":         506,
+	"scotland":                 279,
+	"senegal":                  456,
+	"serbia":                   296,
+	"seychelles":               379,
+	"shetland islands":         279,
+	"sierra leone":             458,
+	"singapore":                381,
+	"sint maarten":             518,
+	"slovak republic":          504,
+	"slovenia":                 499,
+	"solomon islands":          185,
+	"somalia":                  232,
+	"south africa":             462,
+	"south cook islands":       234,
+	"south georgia island":     235,
+	"south orkney islands":     238,
+	"south sandwich islands":   240,
+	"south shetland islands":   241,
+	"sov mil order of malta":   246,
+	"spain":                    281,
+	"spratly islands":          247,
+	"sri lanka":                315,
+	"st. barthelemy":           516,
+	"st. helena":               250,
+	"st. kitts & nevis":        249,
+	"st. lucia":                97,
+	"st. martin":               213,
+	"st. paul island":          252,
+	"st. peter & st. paul":     253,
+	"st. pierre & miquelon":    277,
+	"st. vincent":              98,
+	"sudan":                    466,
+	"suriname":                 140,
+	"svalbard":                 259,
+	"swains island":            515,
+	"sweden":                   284,
+	"switzerland":              287,
+	"syria":                    384,
+	"taiwan":                   386,
+	"tajikistan":               262,
+	"tanzania":                 470,
+	"temotu province":          507,
+	"thailand":                 387,
+	"the gambia":               422,
+	"timor - leste":            511,
+	"togo":                     483,
+	"tokelau islands":          270,
+	"tonga":                    160,
+	"trindade & martim vaz":    273,
+	"trinidad & tobago":        90,
 	"tristan da cunha & gough": 274,
-	"tromelin island": 276,
-	"tunisia": 474,
-	"turkmenistan": 280,
-	"turks & caicos islands": 89,
-	"tuvalu": 282,
-	"uganda": 286,
-	"uk base areas on cyprus": 283,
-	"ukraine": 288,
-	"united arab emirates": 391,
-	"united nations hq": 289,
-	"united states": 291,
-	"uruguay": 144,
-	"us virgin islands": 285,
-	"uzbekistan": 292,
-	"vanuatu": 158,
-	"vatican city": 295,
-	"venezuela": 148,
-	"vienna intl ctr": 206,
-	"vietnam": 293,
-	"wake island": 297,
-	"wales": 294,
-	"wallis & futuna islands": 298,
-	"west malaysia": 299, // hand-fixed: generation joined it to 155 by mistake (9M2 = ADIF 299)
-	"western kiribati": 301,
-	"western sahara": 302,
-	"willis island": 303,
-	"yemen": 492,
-	"zambia": 482,
-	"zimbabwe": 452,
+	"tromelin island":          276,
+	"tunisia":                  474,
+	"turkmenistan":             280,
+	"turks & caicos islands":   89,
+	"tuvalu":                   282,
+	"uganda":                   286,
+	"uk base areas on cyprus":  283,
+	"ukraine":                  288,
+	"united arab emirates":     391,
+	"united nations hq":        289,
+	"united states":            291,
+	"uruguay":                  144,
+	"us virgin islands":        285,
+	"uzbekistan":               292,
+	"vanuatu":                  158,
+	"vatican city":             295,
+	"venezuela":                148,
+	"vienna intl ctr":          206,
+	"vietnam":                  293,
+	"wake island":              297,
+	"wales":                    294,
+	"wallis & futuna islands":  298,
+	"west malaysia":            299, // hand-fixed: generation joined it to 155 by mistake (9M2 = ADIF 299)
+	"western kiribati":         301,
+	"western sahara":           302,
+	"willis island":            303,
+	"yemen":                    492,
+	"zambia":                   482,
+	"zimbabwe":                 452,
 }

internal/dxcc/dxcc_test.go

@@ -178,9 +178,9 @@ Sicily:                   15:  28:  EU:   37.50:   -14.00:    -1.0:  *IT9:
 		t.Fatalf("load: %v", err)
 	}
 	cases := map[string]string{
-		"IW9EZO": "Italy",    // Sicily (*IT9) → Italy
+		"IW9EZO": "Italy", // Sicily (*IT9) → Italy
 		"IT9CLY": "Italy",
-		"IG9A":   "Italy",    // African Italy (*IG9) → Italy
+		"IG9A":   "Italy", // African Italy (*IG9) → Italy
 		"IK0ABC": "Italy",
 		"IS0XYZ": "Sardinia", // real DXCC entity — must stay Sardinia
 		"IM0ABC": "Sardinia",
@@ -210,25 +210,25 @@ Sicily:                   15:  28:  EU:   37.50:   -14.00:    -1.0:  *IT9:
 
 func TestNormalize(t *testing.T) {
 	cases := map[string]string{
-		"F4BPO":      "F4BPO",
-		"f4bpo":      "F4BPO",
-		" F4BPO ":    "F4BPO",
-		"F4BPO/P":    "F4BPO",
-		"F4BPO/MM":   "F4BPO", // maritime mobile → strip, keep home entity for the log
-		"F4BPO/AM":   "F4BPO", // aeronautical mobile → strip, keep home entity for the log
-		"F4BPO/M":    "F4BPO", // plain mobile keeps the home entity
-		"F4BPO/5":    "F5BPO", // "/5" re-homes to call area 5
-		"HD5MW/8":    "HD8MW", // "/8" → Galápagos call area (HD8)
-		"7X2ARA/4":   "7X4ARA", // "/4" changes the AREA digit (2→4), NOT the 7 of the 7X prefix (was wrongly 4X2ARA = Israel)
-		"3A2ABC/6":   "3A6ABC", // digit-first prefix 3A: area digit is the 2, not the 3
-		"4X1AB/2":    "4X2AB",  // 4X (Israel) area 1→2, keep the leading 4
-		"DL/F4BPO":   "DL",
-		"MM/KA9P":    "MM",    // leading MM = Scotland operating prefix
-		"MM/LY3X/P":  "MM",
-		"F4BPO/W6":   "W6",
-		"VK9/F4BPO":  "VK9",
-		"4U1UN/B":    "4U1UN", // trailing /B = beacon → strip, keep the base call
-		"B/F4BPO":    "B",     // leading B = China operating prefix, NOT a beacon
+		"F4BPO":     "F4BPO",
+		"f4bpo":     "F4BPO",
+		" F4BPO ":   "F4BPO",
+		"F4BPO/P":   "F4BPO",
+		"F4BPO/MM":  "F4BPO",  // maritime mobile → strip, keep home entity for the log
+		"F4BPO/AM":  "F4BPO",  // aeronautical mobile → strip, keep home entity for the log
+		"F4BPO/M":   "F4BPO",  // plain mobile keeps the home entity
+		"F4BPO/5":   "F5BPO",  // "/5" re-homes to call area 5
+		"HD5MW/8":   "HD8MW",  // "/8" → Galápagos call area (HD8)
+		"7X2ARA/4":  "7X4ARA", // "/4" changes the AREA digit (2→4), NOT the 7 of the 7X prefix (was wrongly 4X2ARA = Israel)
+		"3A2ABC/6":  "3A6ABC", // digit-first prefix 3A: area digit is the 2, not the 3
+		"4X1AB/2":   "4X2AB",  // 4X (Israel) area 1→2, keep the leading 4
+		"DL/F4BPO":  "DL",
+		"MM/KA9P":   "MM", // leading MM = Scotland operating prefix
+		"MM/LY3X/P": "MM",
+		"F4BPO/W6":  "W6",
+		"VK9/F4BPO": "VK9",
+		"4U1UN/B":   "4U1UN", // trailing /B = beacon → strip, keep the base call
+		"B/F4BPO":   "B",     // leading B = China operating prefix, NOT a beacon
 	}
 	for in, want := range cases {
 		if got := normalizeCallsign(in); got != want {

internal/dxcc/maritime_test.go

@@ -0,0 +1,39 @@
+package dxcc
+
+import "testing"
+
+// /MM and /AM belong to NO DXCC entity: the station is at sea or in the air.
+//
+// This is not a technicality. RI1FJL/MM resolved to Franz Josef Land while the
+// expedition was still sailing there, which told the operator they had worked
+// an entity they had not.
+func TestMobileNoEntity(t *testing.T) {
+	for _, tc := range []struct {
+		call string
+		want bool
+	}{
+		{"RI1FJL/MM", true},
+		{"YB1SCY/AM", true},
+		{"ri1fjl/mm", true},
+		{" RI1FJL/MM ", true},
+		// A LEADING MM is Scotland and AM is Spain. Treating those as
+		// entity-less would be a far larger error than the one this fixes.
+		{"MM0ABC", false},
+		{"AM5X", false},
+		{"MM/F4BPO", false},
+		{"AM/DL1ABC", false},
+		// Other suffixes keep their entity — a portable station is still ashore.
+		{"F4BPO/P", false},
+		{"F4BPO/M", false},
+		{"4U1UN/B", false},
+		{"F4BPO", false},
+		// Only the LAST element counts: RI1FJL/MM/P is still maritime, and a
+		// call whose /MM is not final is not.
+		{"RI1FJL/MM/P", false},
+		{"", false},
+	} {
+		if got := IsMobileNoEntity(tc.call); got != tc.want {
+			t.Errorf("IsMobileNoEntity(%q) = %v, want %v", tc.call, got, tc.want)
+		}
+	}
+}

internal/email/email.go

@@ -4,6 +4,7 @@ package email
 
 import (
 	"fmt"
+	"os"
 	"time"
 
 	"github.com/wneessen/go-mail"
@@ -85,7 +86,32 @@ func SendFiles(cfg Config, to, subject, body string, attachPaths []string) error
 		return fmt.Errorf("smtp client: %w", err)
 	}
 	if err := client.DialAndSend(m); err != nil {
-		return fmt.Errorf("send: %w", err)
+		return fmt.Errorf("send via %s:%d (%s, %s): %w",
+			cfg.Host, cfg.Port, cfg.Encryption, describeSize(attachPaths), err)
 	}
 	return nil
 }
+
+// describeSize reports what was attached, in bytes.
+//
+// "An existing connection was forcibly closed" during DATA is the same message
+// whether the server refused the size, hit a quota, or simply dropped the
+// socket — and the first of those is the only one the operator can act on
+// directly. Naming the size rules it in or out without a second attempt.
+func describeSize(paths []string) string {
+	var total int64
+	n := 0
+	for _, p := range paths {
+		if p == "" {
+			continue
+		}
+		if fi, err := os.Stat(p); err == nil {
+			total += fi.Size()
+			n++
+		}
+	}
+	if n == 0 {
+		return "no attachment"
+	}
+	return fmt.Sprintf("%d attachment(s), %d KB", n, (total+1023)/1024)
+}

internal/email/size_test.go

@@ -0,0 +1,34 @@
+package email
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// "An existing connection was forcibly closed" during DATA reads the same
+// whether the server refused the SIZE, hit a quota, or just dropped the socket
+// — and only the first is something the operator can act on. Naming the size in
+// the error rules it in or out without a second attempt.
+func TestDescribeSize(t *testing.T) {
+	dir := t.TempDir()
+	a := filepath.Join(dir, "card.jpg")
+	if err := os.WriteFile(a, make([]byte, 2048), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	if got := describeSize(nil); got != "no attachment" {
+		t.Errorf("no attachment = %q", got)
+	}
+	if got := describeSize([]string{""}); got != "no attachment" {
+		t.Errorf("blank path = %q, want it ignored", got)
+	}
+	if got := describeSize([]string{a}); got != "1 attachment(s), 2 KB" {
+		t.Errorf("one file = %q", got)
+	}
+	// A path that does not exist must not be counted — the mail library skips it,
+	// so reporting it would describe a message that was never sent.
+	if got := describeSize([]string{a, filepath.Join(dir, "gone.jpg")}); got != "1 attachment(s), 2 KB" {
+		t.Errorf("missing file counted: %q", got)
+	}
+}

internal/extsvc/extsvc.go

@@ -65,23 +65,25 @@ const (
 // AutoUpload + UploadMode are common to all (timing is per-service, so the
 // user can run e.g. Club Log immediate and QRZ delayed).
 type ServiceConfig struct {
-	APIKey               string     `json:"api_key"`
-	URL                  string     `json:"url"`                    // Cloudlog/Wavelog: base URL of the user's own instance
-	StationID            string     `json:"station_id"`             // Cloudlog/Wavelog: station profile (location) id
-	Email                string     `json:"email"`                  // Club Log account email
-	Username             string     `json:"username"`               // LoTW website login (for confirmation download)
-	Password             string     `json:"password"`               // Club Log account / LoTW website password
-	Callsign             string     `json:"callsign"`               // Club Log / HRDLog logbook (owner) callsign
-	Code                 string     `json:"code"`                   // HRDLog: account upload code
-	QTHNickname          string     `json:"qth_nickname"`           // eQSL: QTH nickname (when the account has several)
-	ForceStationCallsign string     `json:"force_station_callsign"` // QRZ + LoTW: override STATION_CALLSIGN
-	TQSLPath             string     `json:"tqsl_path"`              // LoTW: path to tqsl.exe
-	StationLocation      string     `json:"station_location"`       // LoTW: TQSL Station Location name
-	KeyPassword          string     `json:"key_password"`           // LoTW: certificate private-key password (optional)
-	UploadFlags          []string   `json:"upload_flags"`           // LoTW: set of lotw_sent values that mean "ready to upload" — any of "N"/"R"
-	WriteLog             bool       `json:"write_log"`              // LoTW: pass -t to write a TQSL diagnostic log
-	AutoUpload           bool       `json:"auto_upload"`
-	UploadMode           UploadMode `json:"upload_mode"`
+	APIKey               string   `json:"api_key"`
+	URL                  string   `json:"url"`                    // Cloudlog/Wavelog: base URL of the user's own instance
+	StationID            string   `json:"station_id"`             // Cloudlog/Wavelog: station profile (location) id
+	Email                string   `json:"email"`                  // Club Log account email
+	Username             string   `json:"username"`               // LoTW website login (for confirmation download)
+	Password             string   `json:"password"`               // Club Log account / LoTW website password
+	Callsign             string   `json:"callsign"`               // Club Log / HRDLog logbook (owner) callsign
+	Code                 string   `json:"code"`                   // HRDLog: account upload code
+	QTHNickname          string   `json:"qth_nickname"`           // eQSL: QTH nickname (when the account has several)
+	ForceStationCallsign string   `json:"force_station_callsign"` // QRZ + LoTW: override STATION_CALLSIGN
+	TQSLPath             string   `json:"tqsl_path"`              // LoTW: path to tqsl.exe
+	StationLocation      string   `json:"station_location"`       // LoTW: TQSL Station Location name
+	KeyPassword          string   `json:"key_password"`           // LoTW: certificate private-key password (optional)
+	UploadFlags          []string `json:"upload_flags"`           // LoTW: set of lotw_sent values that mean "ready to upload" — any of "N"/"R"
+	WriteLog             bool     `json:"write_log"`              // LoTW: pass -t to write a TQSL diagnostic log
+	AutoUpload           bool     `json:"auto_upload"`
+	// OnAir: HRDLog only — publish the live frequency, mode and rig on the site.
+	OnAir      bool       `json:"on_air"`
+	UploadMode UploadMode `json:"upload_mode"`
 }
 
 // normalised returns the config with whitespace trimmed and a valid upload
@@ -142,4 +144,10 @@ type UploadResult struct {
 	OK      bool   // the service accepted (or already had) the QSO
 	LogID   string // service-assigned record id, when provided
 	Message string // human-readable detail (reason on failure)
+	// Ignored is set when the service accepted the submission but left some or
+	// all of the QSOs out of it. TQSL does this for contacts already uploaded
+	// AND for contacts outside the certificate's date range, and reports both
+	// with the same exit code — so the caller must show the message rather than
+	// decide on its own that everything went through.
+	Ignored bool
 }

internal/extsvc/hrdlog.go

@@ -6,6 +6,7 @@ import (
 	"io"
 	"net/http"
 	"net/url"
+	"strconv"
 	"strings"
 	"time"
 )
@@ -143,3 +144,59 @@ func TestHRDLog(ctx context.Context, client *http.Client, cfg ServiceConfig) (st
 	}
 	return fmt.Sprintf("Credentials accepted — %s", callsign), nil
 }
+
+// hrdlogOnAirURL is HRDLog's live-status endpoint — what puts "F4BPO is on air
+// 14,074,000 FM IC-7300" on the site's front page.
+//
+// Endpoint and field names taken from HRDLog's own library (github.com/iw1qlh/
+// HRDLOG-net-library, HrdProtocol.SendOnAirAsync), not from guesswork: it posts
+// Frequency in Hz, Mode, Radio, Callsign, Code and App.
+//
+// HTTPS where that library uses plain HTTP. The upload code is a credential and
+// has no business crossing the network in clear; the sibling NewEntry endpoint
+// on the same host already serves TLS.
+const hrdlogOnAirURL = "https://robot.hrdlog.net/OnAir.aspx"
+
+// SendHRDLogOnAir publishes the current frequency, mode and rig.
+//
+// Deliberately fire-and-forget in spirit: it is a status broadcast, so a
+// failure is logged and never surfaced as an error the operator must clear —
+// but the message is returned so the caller can log WHAT the site said rather
+// than only that something went wrong.
+func SendHRDLogOnAir(ctx context.Context, client *http.Client, callsign, code string, freqHz int64, mode, radio string) (string, error) {
+	callsign = strings.ToUpper(strings.TrimSpace(callsign))
+	code = strings.TrimSpace(code)
+	if callsign == "" || code == "" {
+		return "", fmt.Errorf("hrdlog: callsign and upload code required")
+	}
+	if freqHz <= 0 {
+		return "", fmt.Errorf("hrdlog: no frequency to announce")
+	}
+	form := url.Values{}
+	form.Set("Callsign", callsign)
+	form.Set("Code", code)
+	form.Set("App", hrdlogApp)
+	form.Set("Frequency", strconv.FormatInt(freqHz, 10))
+	form.Set("Mode", strings.TrimSpace(mode))
+	form.Set("Radio", strings.TrimSpace(radio))
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, hrdlogOnAirURL, strings.NewReader(form.Encode()))
+	if err != nil {
+		return "", fmt.Errorf("hrdlog on-air: build request: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	if client == nil {
+		client = &http.Client{Timeout: 15 * time.Second}
+	}
+	resp, err := client.Do(req)
+	if err != nil {
+		return "", fmt.Errorf("hrdlog on-air: %w", err)
+	}
+	defer resp.Body.Close()
+	body, _ := io.ReadAll(io.LimitReader(resp.Body, 32*1024))
+	msg := strings.TrimSpace(string(body))
+	if resp.StatusCode != http.StatusOK {
+		return msg, fmt.Errorf("hrdlog on-air: http %d", resp.StatusCode)
+	}
+	return msg, nil
+}

internal/extsvc/lotw.go

@@ -178,8 +178,12 @@ func fileExists(p string) bool {
 //
 //	tqsl -d -x -a all -l "<location>" -u [-p <keypass>] <file.adi>
 //
-// Exit codes (TQSL): 0 = uploaded; 8 = nothing new (all duplicates/out of
-// range); 9 = some uploaded, some skipped; anything else = failure.
+// Exit codes are TQSL's own (see the table in its cmdline help). 8 and 9 are
+// the ones that matter and both used to be read as plain success: 8 means NO
+// QSOs were processed and 9 means some were left out — in each case because
+// they were already uploaded OR outside the callsign certificate's date range.
+// Reporting either as success is how a contact came to be stamped "uploaded"
+// while LoTW had never seen it.
 func UploadLoTW(ctx context.Context, cfg ServiceConfig, tempDir, adifRecord string) (UploadResult, error) {
 	tqsl := strings.TrimSpace(cfg.TQSLPath)
 	loc := strings.TrimSpace(cfg.StationLocation)
@@ -249,11 +253,31 @@ func UploadLoTW(ctx context.Context, cfg ServiceConfig, tempDir, adifRecord stri
 		}
 	}
 
+	// TQSL's exit codes, from its own cmdline documentation. Two of them used to
+	// be read as plain success, and that is how contacts came to be stamped
+	// "uploaded" while LoTW had never seen them:
+	//
+	//	8  NO QSOs were processed — already uploaded OR OUT OF DATE RANGE
+	//	9  some processed, some ignored — same two reasons
+	//	14 some already uploaded, the rest signed
+	//
+	// "Out of date range" is the one that bites: a contact older than the
+	// 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.
 	switch code {
-	case 0, 9:
+	case 0:
 		return UploadResult{OK: true, Message: "uploaded to LoTW"}, nil
+	case 9, 14:
+		return UploadResult{OK: true, Ignored: true, Message: tqslDetail(msg,
+			"uploaded — but TQSL left some contacts out (already uploaded, or outside the certificate's date range)")}, nil
 	case 8:
-		return UploadResult{OK: true, Message: "already uploaded (duplicate)"}, nil
+		// Nothing reached LoTW. NOT stamped as sent: a duplicate left at "R" is
+		// harmless and will be refused again, while a contact wrongly marked sent
+		// is one the operator will never think to look at again.
+		return UploadResult{OK: false, Ignored: true, Message: tqslDetail(msg,
+				"TQSL uploaded nothing — every contact was already uploaded, or outside the certificate's date range")},
+			fmt.Errorf("lotw: no QSOs processed")
 	default:
 		if msg == "" {
 			msg = fmt.Sprintf("tqsl exit code %d", code)
@@ -262,6 +286,29 @@ func UploadLoTW(ctx context.Context, cfg ServiceConfig, tempDir, adifRecord stri
 	}
 }
 
+// tqslDetail keeps the lines of TQSL's own output that say what happened to the
+// contacts, and appends the summary.
+//
+// TQSL is explicit — "414 QSO records were already uploaded", "N QSO records
+// are out of date range" — and that sentence is the whole answer to "why is my
+// contact not on LoTW". It used to be captured and thrown away.
+func tqslDetail(out, summary string) string {
+	var keep []string
+	for _, ln := range strings.Split(out, "\n") {
+		ln = strings.TrimSpace(ln)
+		l := strings.ToLower(ln)
+		if strings.Contains(l, "qso") && (strings.Contains(l, "already uploaded") ||
+			strings.Contains(l, "date range") || strings.Contains(l, "ignored") ||
+			strings.Contains(l, "duplicate")) {
+			keep = append(keep, ln)
+		}
+	}
+	if len(keep) == 0 {
+		return summary
+	}
+	return summary + " — " + strings.Join(keep, "; ")
+}
+
 // TestLoTW validates the LoTW config: tqsl present and the chosen station
 // location exists in station_data.
 func TestLoTW(cfg ServiceConfig, stationDataPath string) (string, error) {

internal/extsvc/lotw_exit_test.go

@@ -0,0 +1,44 @@
+package extsvc
+
+import "testing"
+
+// TQSL's own exit codes, from its cmdline documentation:
+//
+//	0  success
+//	8  NO QSOs were processed — already uploaded OR out of date range
+//	9  some processed, some ignored — same two reasons
+//	14 some already uploaded, the rest signed
+//
+// 8 and 9 both used to be read as plain success, and that is how a contact came
+// to be stamped "uploaded to LoTW" while LoTW had never seen it. The one that
+// bites is "out of date range": a contact older than the callsign certificate's
+// validity is silently left out of the submission.
+func TestTQSLDetailKeepsTheReason(t *testing.T) {
+	out := `13:22:01: Signing using Callsign G0ABC, DXCC Entity ENGLAND
+13:22:02: /tmp/x.adi: 20 QSO records are out of date range
+13:22:02: Final Status: No QSOs were processed (8)`
+	got := tqslDetail(out, "summary")
+	if got == "summary" {
+		t.Fatal("threw away TQSL's explanation — that sentence is the whole answer to \"why is my contact not on LoTW\"")
+	}
+	if !contains(got, "out of date range") {
+		t.Errorf("the reason was lost: %q", got)
+	}
+}
+
+func TestTQSLDetailFallsBackToTheSummary(t *testing.T) {
+	if got := tqslDetail("nothing useful here", "summary"); got != "summary" {
+		t.Errorf("got %q, want the plain summary when TQSL said nothing specific", got)
+	}
+}
+
+func contains(h, n string) bool {
+	return len(h) >= len(n) && (func() bool {
+		for i := 0; i+len(n) <= len(h); i++ {
+			if h[i:i+len(n)] == n {
+				return true
+			}
+		}
+		return false
+	})()
+}

internal/lookup/lookup.go

@@ -21,29 +21,29 @@ var ErrNotFound = errors.New("callsign not found")
 
 // Result is the normalized lookup output regardless of provider.
 type Result struct {
-	Callsign  string    `json:"callsign"`
-	Name      string    `json:"name,omitempty"`
-	QTH       string    `json:"qth,omitempty"`
-	Address   string    `json:"address,omitempty"`
-	State     string    `json:"state,omitempty"`
-	County    string    `json:"cnty,omitempty"`
-	Country   string    `json:"country,omitempty"`
-	Grid      string    `json:"grid,omitempty"`
-	Lat       float64   `json:"lat,omitempty"`
-	Lon       float64   `json:"lon,omitempty"`
-	DXCC      int       `json:"dxcc,omitempty"`
-	CQZ       int       `json:"cqz,omitempty"`
-	ITUZ      int       `json:"ituz,omitempty"`
-	Continent string    `json:"cont,omitempty"`
-	Email     string    `json:"email,omitempty"`
-	QSLVia    string    `json:"qsl_via,omitempty"`
+	Callsign  string  `json:"callsign"`
+	Name      string  `json:"name,omitempty"`
+	QTH       string  `json:"qth,omitempty"`
+	Address   string  `json:"address,omitempty"`
+	State     string  `json:"state,omitempty"`
+	County    string  `json:"cnty,omitempty"`
+	Country   string  `json:"country,omitempty"`
+	Grid      string  `json:"grid,omitempty"`
+	Lat       float64 `json:"lat,omitempty"`
+	Lon       float64 `json:"lon,omitempty"`
+	DXCC      int     `json:"dxcc,omitempty"`
+	CQZ       int     `json:"cqz,omitempty"`
+	ITUZ      int     `json:"ituz,omitempty"`
+	Continent string  `json:"cont,omitempty"`
+	Email     string  `json:"email,omitempty"`
+	QSLVia    string  `json:"qsl_via,omitempty"`
 	// Web is the operator's own site. The QSO table has had a `web` column all
 	// along and nothing ever filled it, because no provider mapping read the
 	// field.
 	Web string `json:"web,omitempty"`
 	// Zip is the postal code. HamQTH and QRZ both send one.
-	Zip      string `json:"zip,omitempty"`
-	ImageURL string `json:"image_url,omitempty"` // profile picture URL
+	Zip       string    `json:"zip,omitempty"`
+	ImageURL  string    `json:"image_url,omitempty"` // profile picture URL
 	Source    string    `json:"source"`              // "qrz", "hamqth", or "cache"
 	FetchedAt time.Time `json:"fetched_at"`
 }

internal/lookup/normalize_test.go

@@ -4,14 +4,14 @@ import "testing"
 
 func TestTitleCase(t *testing.T) {
 	cases := map[string]string{
-		"NOEL CHENAVARD":     "Noel Chenavard",
-		"VETRAZ-MONTHOUX":    "Vetraz-Monthoux",
-		"o'brien":            "O'Brien",
+		"NOEL CHENAVARD":        "Noel Chenavard",
+		"VETRAZ-MONTHOUX":       "Vetraz-Monthoux",
+		"o'brien":               "O'Brien",
 		"866 ROUTE DES VOIRONS": "866 Route Des Voirons",
-		"PARIS":              "Paris",
-		"":                   "",
-		"  saint-étienne  ":  "Saint-Étienne",
-		"JOHN":               "John",
+		"PARIS":                 "Paris",
+		"":                      "",
+		"  saint-étienne  ":     "Saint-Étienne",
+		"JOHN":                  "John",
 	}
 	for in, want := range cases {
 		if got := titleCase(in); got != want {

internal/lookup/qrz.go

@@ -21,8 +21,14 @@ type QRZ struct {
 
 	HTTP *http.Client
 
-	mu      sync.Mutex
-	session string
+	// PreferNickname takes QRZ's <nickname> over the composed first+last name
+	// when the operator has published one. It is the name they go BY on the air,
+	// which is what belongs in a log — HamQTH's <nick> is already used that way,
+	// and this brings QRZ into line for operators who want it.
+	PreferNickname bool
+
+	mu       sync.Mutex
+	session  string
 	loggedAt time.Time
 }
 
@@ -117,7 +123,7 @@ func (q *QRZ) fetch(ctx context.Context, sessionKey, callsign string) (Result, e
 	}
 	r := Result{
 		Callsign:  strings.ToUpper(c.Call),
-		Name:      joinName(c.FName, c.Name),
+		Name:      qrzName(q.PreferNickname, c.Nickname, c.FName, c.Name),
 		QTH:       c.Addr2,
 		Address:   composeQRZAddress(c.Addr1, c.Addr2, c.Zip, c.Country),
 		State:     strings.ToUpper(c.State),
@@ -169,6 +175,7 @@ type qrzSession struct {
 type qrzCallsign struct {
 	Call      string `xml:"call"`
 	FName     string `xml:"fname"`
+	Nickname  string `xml:"nickname"` // the name the operator goes by on the air
 	Name      string `xml:"name"`
 	Addr1     string `xml:"addr1"`
 	Addr2     string `xml:"addr2"`
@@ -213,19 +220,6 @@ func composeQRZAddress(addr1, addr2, zip, country string) string {
 	return strings.Join(parts, ", ")
 }
 
-func joinName(first, last string) string {
-	first = strings.TrimSpace(first)
-	last = strings.TrimSpace(last)
-	switch {
-	case first != "" && last != "":
-		return first + " " + last
-	case first != "":
-		return first
-	default:
-		return last
-	}
-}
-
 func firstNonEmpty(s ...string) string {
 	for _, v := range s {
 		v = strings.TrimSpace(v)
@@ -235,3 +229,28 @@ func firstNonEmpty(s ...string) string {
 	}
 	return ""
 }
+
+// qrzName picks what goes in the log's Name field.
+//
+// The FIRST name only. A log greets an operator, it does not address an
+// envelope: "Robert" is what goes out on the air, and "Robert Smith" filled the
+// field with something no one would ever send. The surname stays available in
+// the record; it simply is not the name of the contact.
+//
+// The nickname is taken ahead of it when the operator asked for that AND QRZ
+// has one — a blank nickname must never blank the name, which is the whole
+// reason this is a fallback rather than a swap.
+//
+// The surname is the last resort: a record with no first name at all is better
+// answered with a surname than with nothing.
+func qrzName(preferNickname bool, nickname, fname, name string) string {
+	if preferNickname {
+		if n := strings.TrimSpace(nickname); n != "" {
+			return n
+		}
+	}
+	if f := strings.TrimSpace(fname); f != "" {
+		return f
+	}
+	return strings.TrimSpace(name)
+}

internal/lookup/qrzname_test.go

@@ -0,0 +1,33 @@
+package lookup
+
+import "testing"
+
+// What goes in a log's Name field is the FIRST name. A log greets an operator;
+// it does not address an envelope. "Robert Smith" filled the field with
+// something no one would ever send on the air.
+//
+// The nickname wins ahead of it when asked for — but a published nickname is
+// optional, so an empty one must fall through rather than blank the name. That
+// is the whole difference between a fallback and a swap.
+func TestQRZName(t *testing.T) {
+	for _, tc := range []struct {
+		name                  string
+		prefer                bool
+		nickname, fname, last string
+		want                  string
+	}{
+		{"first name only, never the surname", false, "Bob", "Robert", "Smith", "Robert"},
+		{"nickname when asked for", true, "Bob", "Robert", "Smith", "Bob"},
+		{"no nickname published falls back to the FIRST name", true, "", "Robert", "Smith", "Robert"},
+		{"a blank nickname is not a nickname", true, "   ", "Robert", "Smith", "Robert"},
+		{"option off ignores the nickname", false, "Bob", "Robert", "Smith", "Robert"},
+		{"surname is the last resort, not the default", true, "", "", "Smith", "Smith"},
+		{"nothing published at all", false, "", "", "", ""},
+		{"nickname alone", true, "Bob", "", "", "Bob"},
+	} {
+		if got := qrzName(tc.prefer, tc.nickname, tc.fname, tc.last); got != tc.want {
+			t.Errorf("%s: qrzName(%v, %q, %q, %q) = %q, want %q",
+				tc.name, tc.prefer, tc.nickname, tc.fname, tc.last, got, tc.want)
+		}
+	}
+}

internal/qso/qso.go

@@ -99,7 +99,9 @@ type QSO struct {
 	QSLRcvd     string `json:"qsl_rcvd,omitempty"`
 	QSLSentDate string `json:"qsl_sent_date,omitempty"`
 	QSLRcvdDate string `json:"qsl_rcvd_date,omitempty"`
-	QSLVia      string `json:"qsl_via,omitempty"`
+	QSLVia      string `json:"qsl_via,omitempty"`      // ADIF QSL_VIA — the QSL manager
+	QSLSentVia  string `json:"qsl_sent_via,omitempty"` // ADIF enumeration B/D/E — how the card was sent
+	QSLRcvdVia  string `json:"qsl_rcvd_via,omitempty"` // same enumeration, for the card received
 	QSLMsg      string `json:"qsl_msg,omitempty"`
 	QSLMsgRcvd  string `json:"qslmsg_rcvd,omitempty"`
 
@@ -246,7 +248,7 @@ const columnList = `callsign, qso_date, qso_date_off, band, band_rx, mode, submo
     grid, gridsquare_ext, vucc_grids,
     country, state, cnty, dxcc, cont, cqz, ituz, iota, sota_ref, pota_ref,
     age, lat, lon, rig, ant,
-    qsl_sent, qsl_rcvd, qsl_sent_date, qsl_rcvd_date, qsl_via, qsl_msg, qslmsg_rcvd,
+    qsl_sent, qsl_rcvd, qsl_sent_date, qsl_rcvd_date, qsl_via, qsl_sent_via, qsl_rcvd_via, qsl_msg, qslmsg_rcvd,
     lotw_sent, lotw_rcvd, lotw_sent_date, lotw_rcvd_date,
     eqsl_sent, eqsl_rcvd, eqsl_sent_date, eqsl_rcvd_date,
     clublog_qso_upload_date, clublog_qso_upload_status,
@@ -321,7 +323,7 @@ func (q *QSO) args() []any {
 		q.Grid, q.GridExt, q.VUCCGrids,
 		q.Country, q.State, q.County, q.DXCC, q.Continent, q.CQZ, q.ITUZ, q.IOTA, q.SOTARef, q.POTARef,
 		q.Age, q.Lat, q.Lon, q.Rig, q.Ant,
-		q.QSLSent, q.QSLRcvd, q.QSLSentDate, q.QSLRcvdDate, q.QSLVia, q.QSLMsg, q.QSLMsgRcvd,
+		q.QSLSent, q.QSLRcvd, q.QSLSentDate, q.QSLRcvdDate, q.QSLVia, q.QSLSentVia, q.QSLRcvdVia, q.QSLMsg, q.QSLMsgRcvd,
 		q.LOTWSent, q.LOTWRcvd, q.LOTWSentDate, q.LOTWRcvdDate,
 		q.EQSLSent, q.EQSLRcvd, q.EQSLSentDate, q.EQSLRcvdDate,
 		q.ClublogUploadDate, q.ClublogUploadStatus,
@@ -771,6 +773,8 @@ var bulkEditableCols = map[string]bool{
 	"qsl_sent":                   true,
 	"qsl_rcvd":                   true,
 	"qsl_via":                    true,
+	"qsl_sent_via":               true,
+	"qsl_rcvd_via":               true,
 	"qrzcom_qso_upload_status":   true,
 	"qrzcom_qso_download_status": true,
 	"clublog_qso_upload_status":  true,
@@ -1250,7 +1254,7 @@ var filterableColumns = map[string]bool{
 	"grid": true, "country": true, "state": true, "cnty": true,
 	"dxcc": true, "cont": true, "cqz": true, "ituz": true,
 	"iota": true, "sota_ref": true, "pota_ref": true, "wwff_ref": true, "rig": true, "ant": true,
-	"qsl_sent": true, "qsl_rcvd": true, "qsl_via": true,
+	"qsl_sent": true, "qsl_rcvd": true, "qsl_via": true, "qsl_sent_via": true, "qsl_rcvd_via": true,
 	"lotw_sent": true, "lotw_rcvd": true, "eqsl_sent": true, "eqsl_rcvd": true,
 	"qrzcom_qso_upload_status": true, "qrzcom_qso_download_status": true,
 	"clublog_qso_upload_status": true, "hrdlog_qso_upload_status": true,
@@ -2265,6 +2269,132 @@ func (r *Repo) WorkedCountyKeys(ctx context.Context, keyFn func(state, cnty stri
 	return out, rows.Err()
 }
 
+// CountQSLViaRouting counts the QSOs whose qsl_via holds a routing method
+// instead of a manager, per isRouting.
+//
+// The test is applied in Go rather than in SQL because it has to hold the same
+// vocabulary as the import and the QSL panel — one list of accepted spellings,
+// in internal/adif, not a LIKE pattern drifting apart from it here. Only the
+// distinct values are examined, so the log is scanned once whatever its size.
+func (r *Repo) CountQSLViaRouting(ctx context.Context, isRouting func(string) bool) (int, error) {
+	rows, err := r.db.QueryContext(ctx,
+		`SELECT qsl_via, COUNT(*) FROM qso
+		 WHERE qsl_via IS NOT NULL AND qsl_via != ''
+		   AND (qsl_sent_via IS NULL OR qsl_sent_via = '')
+		 GROUP BY qsl_via`)
+	if err != nil {
+		return 0, err
+	}
+	defer rows.Close()
+	n := 0
+	for rows.Next() {
+		var via string
+		var c int
+		if err := rows.Scan(&via, &c); err != nil {
+			return 0, err
+		}
+		if isRouting(via) {
+			n += c
+		}
+	}
+	return n, rows.Err()
+}
+
+// RepairQSLViaRouting moves routing words out of qsl_via into qsl_sent_via,
+// returning how many QSOs were changed.
+//
+// One UPDATE per distinct spelling, not per QSO: a log holds a handful of them
+// ("Bureau", "E", "Direct"…), and a remote MySQL logbook must not be made to
+// carry one round trip per contact for a tidy-up. Rows that already have a
+// sent-via are left alone by the same condition the count uses, so running this
+// twice cannot undo a later import.
+func (r *Repo) RepairQSLViaRouting(ctx context.Context, normalise func(string) string) (int, error) {
+	rows, err := r.db.QueryContext(ctx,
+		`SELECT DISTINCT qsl_via FROM qso
+		 WHERE qsl_via IS NOT NULL AND qsl_via != ''
+		   AND (qsl_sent_via IS NULL OR qsl_sent_via = '')`)
+	if err != nil {
+		return 0, err
+	}
+	type move struct{ from, to string }
+	var moves []move
+	for rows.Next() {
+		var via string
+		if err := rows.Scan(&via); err != nil {
+			rows.Close()
+			return 0, err
+		}
+		if to := normalise(via); to != "" {
+			moves = append(moves, move{from: via, to: to})
+		}
+	}
+	rows.Close()
+	if err := rows.Err(); err != nil {
+		return 0, err
+	}
+
+	total := 0
+	for _, m := range moves {
+		res, err := r.db.ExecContext(ctx,
+			`UPDATE qso SET qsl_sent_via = ?, qsl_via = ''
+			 WHERE qsl_via = ? AND (qsl_sent_via IS NULL OR qsl_sent_via = '')`,
+			m.to, m.from)
+		if err != nil {
+			return total, err
+		}
+		if n, err := res.RowsAffected(); err == nil {
+			total += int(n)
+		}
+	}
+	return total, nil
+}
+
+// CallCounties returns callsign → "STATE,County" for every US station already
+// logged with a county, newest QSO winning.
+//
+// It exists so the cluster shows the SAME county the entry panel does. The
+// entry panel gets its county from a callbook, which knows where the licensee
+// actually lives; a spot carries only a callsign, so the cluster falls back to
+// deriving one from the FCC licence address, which is right about 98% of the
+// time. Where the log already holds a callbook's answer for that station, the
+// two panels disagreeing is pure noise — this is what lets the better answer
+// win in both.
+//
+// One DISTINCT scan when the cluster snapshot is rebuilt, then map lookups per
+// spot, like the worked-county and worked-grid sets beside it.
+func (r *Repo) CallCounties(ctx context.Context) (map[string]string, error) {
+	rows, err := r.db.QueryContext(ctx,
+		`SELECT callsign, COALESCE(state,''), COALESCE(cnty,'') FROM qso
+		 WHERE dxcc IN (291,110,6) AND cnty IS NOT NULL AND cnty != ''
+		 ORDER BY qso_date, time_on`)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	out := make(map[string]string, 1024)
+	for rows.Next() {
+		var call, state, cnty string
+		if err := rows.Scan(&call, &state, &cnty); err != nil {
+			return nil, err
+		}
+		call = strings.ToUpper(strings.TrimSpace(call))
+		cnty = strings.TrimSpace(cnty)
+		if call == "" || cnty == "" {
+			continue
+		}
+		// Store the ADIF "STATE,County" shape whatever the log holds, so the
+		// caller has both halves without a second column.
+		if !strings.Contains(cnty, ",") {
+			if state = strings.TrimSpace(state); state == "" {
+				continue
+			}
+			cnty = state + "," + cnty
+		}
+		out[call] = cnty
+	}
+	return out, rows.Err()
+}
+
 // CountyWorked reports whether one US county has already been worked.
 //
 // It exists so the entry panel can flag a new county without loading the whole
@@ -2843,7 +2973,8 @@ func scanQSO(s scanner) (QSO, error) {
 		rig, ant                               sql.NullString
 		qslSent, qslRcvd                       sql.NullString
 		qslSentDate, qslRcvdDate               sql.NullString
-		qslVia, qslMsg, qslMsgRcvd             sql.NullString
+		qslVia, qslSentVia, qslRcvdVia         sql.NullString
+		qslMsg, qslMsgRcvd                     sql.NullString
 		lotwSent, lotwRcvd                     sql.NullString
 		lotwSentDate, lotwRcvdDate             sql.NullString
 		eqslSent, eqslRcvd                     sql.NullString
@@ -2888,7 +3019,7 @@ func scanQSO(s scanner) (QSO, error) {
 		&grid, &gridExt, &vucc,
 		&country, &state, &cnty, &dxcc, &cont, &cqz, &ituz, &iota, &sota, &pota,
 		&age, &lat, &lon, &rig, &ant,
-		&qslSent, &qslRcvd, &qslSentDate, &qslRcvdDate, &qslVia, &qslMsg, &qslMsgRcvd,
+		&qslSent, &qslRcvd, &qslSentDate, &qslRcvdDate, &qslVia, &qslSentVia, &qslRcvdVia, &qslMsg, &qslMsgRcvd,
 		&lotwSent, &lotwRcvd, &lotwSentDate, &lotwRcvdDate,
 		&eqslSent, &eqslRcvd, &eqslSentDate, &eqslRcvdDate,
 		&clublogDate, &clublogStatus,
@@ -2972,6 +3103,8 @@ func scanQSO(s scanner) (QSO, error) {
 	q.QSLSentDate = qslSentDate.String
 	q.QSLRcvdDate = qslRcvdDate.String
 	q.QSLVia = qslVia.String
+	q.QSLSentVia = qslSentVia.String
+	q.QSLRcvdVia = qslRcvdVia.String
 	q.QSLMsg = qslMsg.String
 	q.QSLMsgRcvd = qslMsgRcvd.String
 	q.LOTWSent = lotwSent.String

internal/rigctld/rigctld.go

@@ -32,6 +32,7 @@ package rigctld
 import (
 	"bufio"
 	"fmt"
+	"hamlog/internal/cat"
 	"net"
 	"strconv"
 	"strings"
@@ -244,7 +245,18 @@ func (s *Server) serve(c net.Conn) {
 			s.log("rigctld: client %s disconnected", c.RemoteAddr())
 			return
 		}
-		resp, quit := s.handle(strings.TrimSpace(line))
+		req := strings.TrimSpace(line)
+		resp, quit := s.handle(req)
+		// The whole exchange, when tracing is on.
+		//
+		// Only PTT transitions were ever recorded, so when JTDX aborted a
+		// transmission mid-frame the log showed the abort and not the command
+		// that preceded it — the one thing needed to tell whether OpsLog answered
+		// something the client could not accept. Behind the same switch as the CAT
+		// wire trace: this is one line per poll and would drown an ordinary log.
+		if req != "" && cat.CIVTraceEnabled() {
+			s.log("rigctld: %s → %q ⇒ %q", c.RemoteAddr(), req, strings.TrimRight(resp, "\r\n"))
+		}
 		if resp != "" {
 			if _, err := w.WriteString(resp); err != nil {
 				return
@@ -409,6 +421,17 @@ func (s *Server) handle(line string) (resp string, quit bool) {
 			return rprt(0), false
 		}
 		s.splitWanted.Store(false)
+		// Already simplex? Then there is nothing to do and the request is
+		// satisfied. Reporting a failure here is what broke JTDX in "Fake It":
+		// Fake It uses no split, JTDX still sends "S 0" to be sure, and a backend
+		// that cannot SET split answered an error to a request that was already
+		// true. JTDX read that as rig control failing and abandoned the
+		// transmission a second into the frame.
+		//
+		// A refusal is only honest when something actually needed doing.
+		if on, _ := s.rig.Split(); !on {
+			return rprt(0), false
+		}
 		if err := s.rig.SetSplit(false, 0); err != nil {
 			s.log("rigctld: split off failed: %v", err)
 			return rprt(-9), false
@@ -438,6 +461,34 @@ func (s *Server) handle(line string) (resp string, quit bool) {
 		s.log("rigctld: split ON, TX %.0f Hz", hz)
 		return rprt(0), false
 
+	case "X", "\\set_split_mode":
+		// "X <mode> <passband>" — the mode of the TRANSMIT VFO.
+		//
+		// Accepted rather than refused. WSJT-X and JTDX send it as part of their
+		// normal setup even in "Fake It", where there is no split and therefore no
+		// second VFO to give a mode to; answering "not implemented" made JTDX give
+		// up on rig control mid-transmission.
+		//
+		// The mode is applied when there IS a split — the transmit VFO is a real
+		// one then. Without split the request has no target and succeeding is the
+		// honest answer: the transmit VFO already has that mode, because it is the
+		// same VFO.
+		if len(args) < 1 {
+			return rprt(-1), false
+		}
+		if on, _ := s.rig.Split(); !on {
+			return rprt(0), false
+		}
+		if err := s.rig.SetMode(args[0]); err != nil {
+			s.log("rigctld: split mode %q failed: %v", args[0], err)
+			return rprt(-9), false
+		}
+		return rprt(0), false
+	case "x", "\\get_split_mode":
+		// Mirrors X: the transmit VFO's mode and passband. Without split that is
+		// simply the current mode.
+		return s.rig.Mode() + "\n2400\n", false
+
 	default:
 		// A frame ending in ';' is not a rigctl command at all — it is raw rig
 		// dialect (Kenwood/Elecraft/Yaesu), which means the client is configured

internal/rigctld/split_test.go

@@ -50,3 +50,55 @@ func TestSetSplitRefusalIsReported(t *testing.T) {
 		t.Errorf("a rig that cannot split answered %q — the client will transmit on the wrong frequency", got)
 	}
 }
+
+// "Fake It" uses NO split, and JTDX still sends "S 0" to make sure. A backend
+// that cannot SET split used to answer an error to that — a refusal of a
+// request that was already satisfied — and JTDX read it as rig control failing
+// and abandoned the transmission a second into a 13.8-second frame.
+//
+// Reported against a Yaesu whose backend cannot arm split from software.
+func TestSplitOffOnASimplexRigSucceeds(t *testing.T) {
+	rig := &fakeRig{freq: 14074000, mode: "FT8", noSplit: true}
+	s := New(0, rig, func(string, ...any) {})
+
+	if got, _ := s.handle("S 0 VFOA"); !strings.HasPrefix(got, "RPRT 0") {
+		t.Errorf("split off on a simplex rig answered %q — nothing needed doing", got)
+	}
+	// And it must not have bothered the rig at all.
+	if len(rig.splitCalls) != 0 {
+		t.Errorf("rig was asked to clear a split it did not have: %v", rig.splitCalls)
+	}
+
+	// Arming, however, must still fail loudly: there the request is real and
+	// unmet, and a client that believes it is transmitting up the band while the
+	// radio sits on the DX's frequency is the bug this refusal exists to prevent.
+	if got, _ := s.handle("S 1 VFOB"); !strings.HasPrefix(got, "RPRT 0") {
+		t.Fatalf("arming is deferred to set_split_freq: %q", got)
+	}
+	if got, _ := s.handle("I 14075300.000000"); strings.HasPrefix(got, "RPRT 0") {
+		t.Error("arming split on a backend that cannot must report a failure")
+	}
+}
+
+// X (set_split_mode) is sent by WSJT-X and JTDX during ordinary setup, Fake It
+// included — where there is no second VFO to give a mode to. Answering "not
+// implemented" made JTDX give up on rig control mid-transmission.
+func TestSplitModeIsAccepted(t *testing.T) {
+	rig := &fakeRig{freq: 14074000, mode: "FT8"}
+	s := New(0, rig, func(string, ...any) {})
+
+	// No split: nothing to target, and succeeding is honest — the transmit VFO
+	// already has that mode because it is the same VFO.
+	if got, _ := s.handle("X PKTUSB -1"); !strings.HasPrefix(got, "RPRT 0") {
+		t.Errorf("set_split_mode answered %q", got)
+	}
+	if rig.mode != "FT8" {
+		t.Errorf("the mode was changed with no split in force: %q", rig.mode)
+	}
+
+	// Reading it back must answer a mode and a passband, never an error.
+	got, _ := s.handle("x")
+	if !strings.Contains(got, "FT8") {
+		t.Errorf("get_split_mode = %q, want the current mode", got)
+	}
+}

internal/spe/poweroff_test.go

@@ -0,0 +1,54 @@
+package spe
+
+import (
+	"testing"
+	"time"
+)
+
+// decodeCSV marks the client connected on EVERY frame it parses, and the poll
+// goroutine can be mid-read while PowerOff runs. So the frame from a second ago
+// landed after PowerOff had marked the amp offline and put it straight back —
+// the console kept showing the amplifier on until the operator pressed OFF a
+// second time.
+func TestFrameInFlightDoesNotResurrectASwitchedOffAmp(t *testing.T) {
+	c := &Client{}
+	const frame = ",13K,O,R,A,1,05,1b,0r,M,0000, 0.00, 0.00, 1.3, 0.0, 26,000,000,N,N,"
+
+	// Normal running: a frame marks it connected and reads OPERATE.
+	c.decodeCSV(frame)
+	if !c.GetStatus().Connected || !c.GetStatus().Operate {
+		t.Fatal("a status frame should mark the amp connected")
+	}
+
+	// The operator presses OFF. This is what PowerOff does, in order.
+	c.statusMu.Lock()
+	c.offUntil = time.Now().Add(3 * time.Second)
+	c.statusMu.Unlock()
+	c.setErr(errSwitchedOff{})
+
+	// A frame that was already on the wire arrives now.
+	c.decodeCSV(frame)
+
+	if c.GetStatus().Connected {
+		t.Error("a frame from before the switch-off put the amp back on — this is the double-click on OFF")
+	}
+}
+
+// An amp switched back on at its own front panel must reappear without OpsLog
+// being told, so the suppression has to expire rather than latch.
+func TestSuppressionExpires(t *testing.T) {
+	c := &Client{}
+	c.statusMu.Lock()
+	c.offUntil = time.Now().Add(-time.Second) // window already past
+	c.statusMu.Unlock()
+	c.setErr(errSwitchedOff{})
+
+	c.decodeCSV(",13K,O,R,A,1,05,1b,0r,M,0000, 0.00, 0.00, 1.3, 0.0, 26,000,000,N,N,")
+	if !c.GetStatus().Connected {
+		t.Error("an amp answering after the window must come back on its own")
+	}
+}
+
+type errSwitchedOff struct{}
+
+func (errSwitchedOff) Error() string { return "switched off" }

internal/spe/spe.go

@@ -91,6 +91,15 @@ type Client struct {
 	statusMu sync.RWMutex
 	status   Status
 	lastRaw  string // last raw status payload logged (log only on change)
+	// offUntil suppresses status frames that were already in flight when the amp
+	// was switched off. decodeCSV marks the client connected on every frame it
+	// parses, and the poll goroutine can be mid-read while PowerOff runs — so the
+	// frame from a second ago resurrected an amplifier the operator had just
+	// switched off, and the console only caught up when they pressed OFF twice.
+	//
+	// Time-bounded rather than a latch: an amp switched back on at its own front
+	// panel must reappear on its own.
+	offUntil time.Time
 
 	stop    chan struct{}
 	running bool
@@ -177,6 +186,12 @@ func (c *Client) PowerOn() error {
 	if c.GetStatus().Connected {
 		return nil
 	}
+	// Switching on cancels the suppression window: the operator wants frames
+	// believed again, and waiting out a timer they cannot see would read as the
+	// power-on having failed.
+	c.statusMu.Lock()
+	c.offUntil = time.Time{}
+	c.statusMu.Unlock()
 	// The poll goroutine may still be inside a blocking read on the old handle;
 	// Windows keeps the port "busy" until that read times out (ioTimeout). Retry
 	// the open for a little longer than that.
@@ -205,9 +220,17 @@ func (c *Client) PowerOn() error {
 		time.Sleep(wakePulse)
 		return set(true)
 	}
-	if err = pulse(sp.SetRTS); err == nil {
-		err = pulse(sp.SetDTR)
+	// Each line reported separately. Not every USB-serial chip honours the modem
+	// lines, and some refuse them without saying so — on an amplifier that never
+	// wakes, "which of the two failed, or neither" is the whole diagnosis, and a
+	// single combined error cannot give it.
+	rtsErr := pulse(sp.SetRTS)
+	dtrErr := pulse(sp.SetDTR)
+	if err = rtsErr; err == nil {
+		err = dtrErr
 	}
+	applog.Printf("spe: power ON pulse on %s (model=%q transport=%s) — RTS err=%v, DTR err=%v",
+		c.cfg.ComPort, c.GetStatus().Model, c.cfg.Transport, rtsErr, dtrErr)
 	// Booting, the amp re-enumerates its USB interface, which leaves this handle
 	// pointing at a device that no longer exists — the amp came up and OpsLog
 	// still read "offline". Drop it; the poll loop reopens a fresh one as soon as
@@ -216,6 +239,26 @@ func (c *Client) PowerOn() error {
 	c.dropLocked()
 	c.mu.Unlock()
 	applog.Printf("spe: power ON — RTS then DTR pulsed on %s (err=%v)", c.cfg.ComPort, err)
+
+	// Say whether it actually woke. "The ON button does nothing" is a report with
+	// three different causes — the pulse was refused, the pulse went out and the
+	// amp ignored it, or the amp came up and the UI missed it — and only the log
+	// can separate them. Watched off the caller's goroutine so the click returns
+	// at once.
+	go func() {
+		deadline := time.Now().Add(15 * time.Second)
+		for time.Now().Before(deadline) {
+			time.Sleep(time.Second)
+			if c.GetStatus().Connected {
+				applog.Printf("spe: power ON — amp answered after %.0fs",
+					15-time.Until(deadline).Seconds())
+				return
+			}
+		}
+		applog.Printf("spe: power ON — no answer within 15s on %s. The pulse was sent; "+
+			"either this amplifier does not wake on RTS/DTR, or the adapter does not drive those lines",
+			c.cfg.ComPort)
+	}()
 	return err
 }
 
@@ -226,6 +269,14 @@ func (c *Client) PowerOn() error {
 // the poll loop keeps reopening the port with both lines high and that has
 // never woken it — only the deliberate low→high sequence in PowerOn does.
 func (c *Client) PowerOff() error {
+	// Close the window BEFORE the key goes out, so a frame already travelling up
+	// the wire cannot land after setErr and undo it. Three seconds covers a poll
+	// interval with room to spare; after that a real answer means the amp is
+	// genuinely alive again, which is what happens if it is switched back on at
+	// its own front panel.
+	c.statusMu.Lock()
+	c.offUntil = time.Now().Add(3 * time.Second)
+	c.statusMu.Unlock()
 	err := c.sendCmd(cmdOff)
 	applog.Printf("spe: power OFF — SWITCH OFF key sent (err=%v)", err)
 	// Drop the link and mark the amp offline at once, exactly as a fresh start
@@ -482,6 +533,9 @@ func (c *Client) decodeCSV(payload string) {
 		c.lastRaw = payload
 		applog.Printf("spe: status raw=%q fields=%d", payload, len(f))
 	}
+	if time.Now().Before(c.offUntil) {
+		return // a frame from before the switch-off — the amp is on its way down
+	}
 	c.status.Connected = true
 	c.status.LastError = ""
 	// The real frame carries a leading empty field (it starts with a comma), so the

internal/uls/ctcounty_gen.go

@@ -0,0 +1,440 @@
+// Code generated by cmd/ctzipgen. DO NOT EDIT.
+
+package uls
+
+// ctCounty maps a Connecticut ZIP to its legal county.
+//
+// GeoNames reports Connecticut's 2022 planning regions instead, which no
+// award, callbook or log uses. See cmd/ctzipgen for how this was built and
+// why a name-to-name mapping cannot work.
+var ctCounty = map[string]string{
+	"06001": "Hartford",
+	"06002": "Hartford",
+	"06006": "Hartford",
+	"06010": "Hartford",
+	"06011": "Hartford",
+	"06013": "Hartford",
+	"06016": "Hartford",
+	"06018": "Litchfield",
+	"06019": "Hartford",
+	"06020": "Hartford",
+	"06021": "Litchfield",
+	"06022": "Hartford",
+	"06023": "Hartford",
+	"06024": "Litchfield",
+	"06025": "Hartford",
+	"06026": "Hartford",
+	"06027": "Hartford",
+	"06028": "Hartford",
+	"06029": "Tolland",
+	"06030": "Hartford",
+	"06031": "Litchfield",
+	"06032": "Hartford",
+	"06033": "Hartford",
+	"06034": "Hartford",
+	"06035": "Hartford",
+	"06037": "Hartford",
+	"06039": "Litchfield",
+	"06040": "Hartford",
+	"06041": "Hartford",
+	"06042": "Hartford",
+	"06043": "Tolland",
+	"06045": "Hartford",
+	"06050": "Hartford",
+	"06051": "Hartford",
+	"06052": "Hartford",
+	"06053": "Hartford",
+	"06057": "Litchfield",
+	"06058": "Litchfield",
+	"06059": "Hartford",
+	"06060": "Hartford",
+	"06061": "Litchfield",
+	"06062": "Hartford",
+	"06063": "Litchfield",
+	"06064": "Hartford",
+	"06065": "Hartford",
+	"06066": "Tolland",
+	"06067": "Hartford",
+	"06068": "Litchfield",
+	"06069": "Litchfield",
+	"06070": "Hartford",
+	"06071": "Tolland",
+	"06072": "Tolland",
+	"06073": "Hartford",
+	"06074": "Hartford",
+	"06075": "Tolland",
+	"06076": "Tolland",
+	"06077": "Tolland",
+	"06078": "Hartford",
+	"06079": "Litchfield",
+	"06080": "Hartford",
+	"06081": "Hartford",
+	"06082": "Hartford",
+	"06083": "Hartford",
+	"06084": "Tolland",
+	"06085": "Hartford",
+	"06087": "Hartford",
+	"06088": "Hartford",
+	"06089": "Hartford",
+	"06090": "Hartford",
+	"06091": "Hartford",
+	"06092": "Hartford",
+	"06093": "Hartford",
+	"06094": "Litchfield",
+	"06095": "Hartford",
+	"06096": "Hartford",
+	"06098": "Litchfield",
+	"06101": "Hartford",
+	"06102": "Hartford",
+	"06103": "Hartford",
+	"06104": "Hartford",
+	"06105": "Hartford",
+	"06106": "Hartford",
+	"06107": "Hartford",
+	"06108": "Hartford",
+	"06109": "Hartford",
+	"06110": "Hartford",
+	"06111": "Hartford",
+	"06112": "Hartford",
+	"06114": "Hartford",
+	"06115": "Hartford",
+	"06117": "Hartford",
+	"06118": "Hartford",
+	"06119": "Hartford",
+	"06120": "Hartford",
+	"06123": "Hartford",
+	"06126": "Hartford",
+	"06127": "Hartford",
+	"06128": "Hartford",
+	"06129": "Hartford",
+	"06131": "Hartford",
+	"06132": "Hartford",
+	"06133": "Hartford",
+	"06134": "Hartford",
+	"06137": "Hartford",
+	"06138": "Hartford",
+	"06140": "Hartford",
+	"06141": "Hartford",
+	"06142": "Hartford",
+	"06143": "Hartford",
+	"06144": "Hartford",
+	"06145": "Hartford",
+	"06146": "Hartford",
+	"06147": "Hartford",
+	"06150": "Hartford",
+	"06151": "Hartford",
+	"06152": "Hartford",
+	"06153": "Hartford",
+	"06154": "Hartford",
+	"06155": "Hartford",
+	"06156": "Hartford",
+	"06160": "Hartford",
+	"06161": "Hartford",
+	"06167": "Hartford",
+	"06176": "Hartford",
+	"06180": "Hartford",
+	"06183": "Hartford",
+	"06199": "Hartford",
+	"06226": "Windham",
+	"06230": "Windham",
+	"06231": "Tolland",
+	"06232": "Tolland",
+	"06233": "Windham",
+	"06234": "Windham",
+	"06235": "Windham",
+	"06237": "Tolland",
+	"06238": "Tolland",
+	"06239": "Windham",
+	"06241": "Windham",
+	"06242": "Windham",
+	"06243": "Windham",
+	"06244": "Windham",
+	"06245": "Windham",
+	"06246": "Windham",
+	"06247": "Windham",
+	"06248": "Tolland",
+	"06249": "New London",
+	"06250": "Tolland",
+	"06251": "Tolland",
+	"06254": "New London",
+	"06255": "Windham",
+	"06256": "Windham",
+	"06258": "Windham",
+	"06259": "Windham",
+	"06260": "Windham",
+	"06262": "Windham",
+	"06263": "Windham",
+	"06264": "Windham",
+	"06265": "Tolland",
+	"06266": "Windham",
+	"06267": "Windham",
+	"06268": "Tolland",
+	"06269": "Tolland",
+	"06277": "Windham",
+	"06278": "Windham",
+	"06279": "Tolland",
+	"06280": "Windham",
+	"06281": "Windham",
+	"06282": "Windham",
+	"06320": "New London",
+	"06330": "New London",
+	"06331": "Windham",
+	"06332": "Windham",
+	"06333": "New London",
+	"06334": "New London",
+	"06335": "New London",
+	"06336": "New London",
+	"06338": "New London",
+	"06339": "New London",
+	"06340": "New London",
+	"06349": "New London",
+	"06350": "New London",
+	"06351": "New London",
+	"06353": "New London",
+	"06354": "Windham",
+	"06355": "New London",
+	"06357": "New London",
+	"06359": "New London",
+	"06360": "New London",
+	"06365": "New London",
+	"06370": "New London",
+	"06371": "New London",
+	"06372": "New London",
+	"06373": "Windham",
+	"06374": "Windham",
+	"06375": "New London",
+	"06376": "New London",
+	"06377": "Windham",
+	"06378": "New London",
+	"06379": "New London",
+	"06380": "New London",
+	"06382": "New London",
+	"06383": "New London",
+	"06384": "New London",
+	"06385": "New London",
+	"06387": "Windham",
+	"06388": "New London",
+	"06389": "New London",
+	"06401": "New Haven",
+	"06403": "New Haven",
+	"06404": "Fairfield",
+	"06405": "New Haven",
+	"06408": "New Haven",
+	"06409": "Middlesex",
+	"06410": "New Haven",
+	"06411": "New Haven",
+	"06412": "Middlesex",
+	"06413": "Middlesex",
+	"06414": "Middlesex",
+	"06415": "New London",
+	"06416": "Middlesex",
+	"06417": "Middlesex",
+	"06418": "New Haven",
+	"06419": "Middlesex",
+	"06420": "New London",
+	"06422": "Middlesex",
+	"06423": "Middlesex",
+	"06424": "Middlesex",
+	"06426": "Middlesex",
+	"06437": "New Haven",
+	"06438": "Middlesex",
+	"06439": "New London",
+	"06440": "Fairfield",
+	"06441": "Middlesex",
+	"06442": "Middlesex",
+	"06443": "New Haven",
+	"06444": "Hartford",
+	"06447": "Hartford",
+	"06450": "New Haven",
+	"06451": "New Haven",
+	"06455": "Middlesex",
+	"06456": "Middlesex",
+	"06457": "Middlesex",
+	"06459": "Middlesex",
+	"06460": "New Haven",
+	"06461": "New Haven",
+	"06467": "Hartford",
+	"06468": "Fairfield",
+	"06469": "Middlesex",
+	"06470": "Fairfield",
+	"06471": "New Haven",
+	"06472": "New Haven",
+	"06473": "New Haven",
+	"06474": "New London",
+	"06475": "Middlesex",
+	"06477": "New Haven",
+	"06478": "New Haven",
+	"06479": "Hartford",
+	"06480": "Middlesex",
+	"06481": "Middlesex",
+	"06482": "Fairfield",
+	"06483": "New Haven",
+	"06484": "Fairfield",
+	"06487": "New Haven",
+	"06488": "New Haven",
+	"06489": "Hartford",
+	"06491": "Fairfield",
+	"06492": "New Haven",
+	"06493": "New Haven",
+	"06494": "New Haven",
+	"06495": "New Haven",
+	"06498": "Middlesex",
+	"06501": "New Haven",
+	"06502": "New Haven",
+	"06503": "New Haven",
+	"06504": "New Haven",
+	"06505": "New Haven",
+	"06506": "New Haven",
+	"06507": "New Haven",
+	"06508": "New Haven",
+	"06509": "New Haven",
+	"06510": "New Haven",
+	"06511": "New Haven",
+	"06512": "New Haven",
+	"06513": "New Haven",
+	"06514": "New Haven",
+	"06515": "New Haven",
+	"06516": "New Haven",
+	"06517": "New Haven",
+	"06518": "New Haven",
+	"06519": "New Haven",
+	"06520": "New Haven",
+	"06521": "New Haven",
+	"06524": "New Haven",
+	"06525": "New Haven",
+	"06530": "New Haven",
+	"06531": "New Haven",
+	"06532": "New Haven",
+	"06533": "New Haven",
+	"06534": "New Haven",
+	"06535": "New Haven",
+	"06536": "New Haven",
+	"06537": "New Haven",
+	"06538": "New Haven",
+	"06540": "New Haven",
+	"06601": "Fairfield",
+	"06602": "Fairfield",
+	"06604": "Fairfield",
+	"06605": "Fairfield",
+	"06606": "Fairfield",
+	"06607": "Fairfield",
+	"06608": "Fairfield",
+	"06610": "Fairfield",
+	"06611": "Fairfield",
+	"06612": "Fairfield",
+	"06614": "Fairfield",
+	"06615": "Fairfield",
+	"06673": "Fairfield",
+	"06699": "Fairfield",
+	"06701": "New Haven",
+	"06702": "New Haven",
+	"06703": "New Haven",
+	"06704": "New Haven",
+	"06705": "New Haven",
+	"06706": "New Haven",
+	"06708": "New Haven",
+	"06710": "New Haven",
+	"06712": "New Haven",
+	"06716": "New Haven",
+	"06720": "New Haven",
+	"06721": "New Haven",
+	"06722": "New Haven",
+	"06723": "New Haven",
+	"06724": "New Haven",
+	"06725": "New Haven",
+	"06726": "New Haven",
+	"06749": "New Haven",
+	"06750": "Litchfield",
+	"06751": "Litchfield",
+	"06752": "Litchfield",
+	"06753": "Litchfield",
+	"06754": "Litchfield",
+	"06755": "Litchfield",
+	"06756": "Litchfield",
+	"06757": "Litchfield",
+	"06758": "Litchfield",
+	"06759": "Litchfield",
+	"06762": "New Haven",
+	"06763": "Litchfield",
+	"06770": "New Haven",
+	"06776": "Litchfield",
+	"06777": "Litchfield",
+	"06778": "Litchfield",
+	"06779": "Litchfield",
+	"06781": "Litchfield",
+	"06782": "Litchfield",
+	"06783": "Litchfield",
+	"06784": "Fairfield",
+	"06785": "Litchfield",
+	"06786": "Litchfield",
+	"06787": "Litchfield",
+	"06790": "Litchfield",
+	"06791": "Litchfield",
+	"06792": "Litchfield",
+	"06793": "Litchfield",
+	"06794": "Litchfield",
+	"06795": "Litchfield",
+	"06796": "Litchfield",
+	"06798": "Litchfield",
+	"06801": "Fairfield",
+	"06804": "Fairfield",
+	"06807": "Fairfield",
+	"06810": "Fairfield",
+	"06811": "Fairfield",
+	"06812": "Fairfield",
+	"06813": "Fairfield",
+	"06814": "Fairfield",
+	"06816": "Fairfield",
+	"06817": "Fairfield",
+	"06820": "Fairfield",
+	"06824": "Fairfield",
+	"06825": "Fairfield",
+	"06828": "Fairfield",
+	"06829": "Fairfield",
+	"06830": "Fairfield",
+	"06831": "Fairfield",
+	"06836": "Fairfield",
+	"06838": "Fairfield",
+	"06840": "Fairfield",
+	"06850": "Fairfield",
+	"06851": "Fairfield",
+	"06852": "Fairfield",
+	"06853": "Fairfield",
+	"06854": "Fairfield",
+	"06855": "Fairfield",
+	"06856": "Fairfield",
+	"06857": "Fairfield",
+	"06858": "Fairfield",
+	"06860": "Fairfield",
+	"06870": "Fairfield",
+	"06875": "Fairfield",
+	"06876": "Fairfield",
+	"06877": "Fairfield",
+	"06878": "Fairfield",
+	"06879": "Fairfield",
+	"06880": "Fairfield",
+	"06881": "Fairfield",
+	"06883": "Fairfield",
+	"06888": "Fairfield",
+	"06889": "Fairfield",
+	"06890": "Fairfield",
+	"06896": "Fairfield",
+	"06897": "Fairfield",
+	"06901": "Fairfield",
+	"06902": "Fairfield",
+	"06903": "Fairfield",
+	"06904": "Fairfield",
+	"06905": "Fairfield",
+	"06906": "Fairfield",
+	"06907": "Fairfield",
+	"06910": "Fairfield",
+	"06911": "Fairfield",
+	"06912": "Fairfield",
+	"06913": "Fairfield",
+	"06914": "Fairfield",
+	"06920": "Fairfield",
+	"06921": "Fairfield",
+	"06922": "Fairfield",
+	"06926": "Fairfield",
+	"06927": "Fairfield",
+}

internal/uls/ctcounty_test.go

@@ -0,0 +1,70 @@
+package uls
+
+import (
+	"testing"
+
+	"hamlog/internal/award"
+)
+
+// The eight counties Connecticut still has for every purpose except the Census.
+var ctLegalCounties = map[string]bool{
+	"Fairfield": true, "Hartford": true, "Litchfield": true, "Middlesex": true,
+	"New Haven": true, "New London": true, "Tolland": true, "Windham": true,
+}
+
+// TestCTCountyOnlyLegalCounties makes sure no planning region ever creeps back
+// into the table — a regenerated file that quietly picked up "Capitol Region"
+// would put every Hartford-area station back out of reach of the award, which
+// is exactly the failure this table exists to end.
+func TestCTCountyOnlyLegalCounties(t *testing.T) {
+	if len(ctCounty) < 400 {
+		t.Fatalf("only %d Connecticut ZIPs — the table looks truncated", len(ctCounty))
+	}
+	for zip, county := range ctCounty {
+		if !ctLegalCounties[county] {
+			t.Errorf("ZIP %s → %q, which is not one of Connecticut's eight counties", zip, county)
+		}
+		if len(zip) != 5 {
+			t.Errorf("ZIP %q is not five digits", zip)
+		}
+	}
+}
+
+// TestCTCountyMatchesAward closes the loop: every county in the table has to
+// produce a key the USA-CA reference actually lists. A county the resolver can
+// name but the award cannot match is worth no more than the planning region it
+// replaced.
+func TestCTCountyMatchesAward(t *testing.T) {
+	want := map[string]bool{
+		"CT/FAIRFIELD": true, "CT/HARTFORD": true, "CT/LITCHFIELD": true,
+		"CT/MIDDLESEX": true, "CT/NEWHAVEN": true, "CT/NEWLONDON": true,
+		"CT/TOLLAND": true, "CT/WINDHAM": true,
+	}
+	for zip, county := range ctCounty {
+		if k := award.USCountyKey("CT", county); !want[k] {
+			t.Errorf("ZIP %s → %q → key %q, not a USA-CA county", zip, county, k)
+		}
+	}
+}
+
+// TestCTCountyKnownZips pins a ZIP in each county against ground truth, so a
+// regeneration that silently shifted the whole table is caught. 06419 is the
+// case that started this: Killingworth is in Middlesex, and GeoNames calls it
+// "Lower Connecticut River Valley".
+func TestCTCountyKnownZips(t *testing.T) {
+	for zip, want := range map[string]string{
+		"06419": "Middlesex",  // Killingworth
+		"06001": "Hartford",   // Avon
+		"06106": "Hartford",   // Hartford
+		"06510": "New Haven",  // New Haven
+		"06880": "Fairfield",  // Westport
+		"06340": "New London", // Groton
+		"06226": "Windham",    // Willimantic
+		"06238": "Tolland",    // Coventry
+		"06759": "Litchfield", // Litchfield
+	} {
+		if got := ctCounty[zip]; got != want {
+			t.Errorf("ctCounty[%s] = %q, want %q", zip, got, want)
+		}
+	}
+}

internal/uls/uls.go

@@ -34,6 +34,7 @@ import (
 	"path/filepath"
 	"regexp"
 	"sort"
+	"strconv"
 	"strings"
 	"sync"
 	"time"
@@ -114,6 +115,33 @@ func (s *Store) Count() int {
 	return n
 }
 
+// RulesVersion is bumped whenever a correction applied DURING import changes
+// the county a callsign resolves to. The value is stamped into uls_meta, so a
+// database built by an older OpsLog can be told apart from one built by this
+// one — the rows themselves carry no clue, and the fix cannot be applied
+// retroactively because the ZIP each county was derived from is not stored.
+//
+//	1 — original.
+//	2 — Connecticut ZIPs mapped back to their legal county instead of the
+//	    2022 planning region GeoNames now reports (see ctcounty_gen.go).
+const RulesVersion = 2
+
+// NeedsRefresh reports that the store was built before a correction that
+// changes its answers, so the operator should download it again. False for an
+// empty store: there is nothing stale about data that was never fetched.
+func (s *Store) NeedsRefresh() bool {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	var n int
+	if s.db.QueryRow(`SELECT COUNT(*) FROM uls_callsign`).Scan(&n); n == 0 {
+		return false
+	}
+	var v string
+	s.db.QueryRow(`SELECT value FROM uls_meta WHERE key='rules_version'`).Scan(&v)
+	got, _ := strconv.Atoi(v)
+	return got < RulesVersion
+}
+
 // UpdatedAt returns when the store was last imported (zero if never).
 func (s *Store) UpdatedAt() time.Time {
 	s.mu.RLock()
@@ -285,6 +313,10 @@ func (s *Store) rebuild(ctx context.Context, amatZip string, zipmap map[string]z
 		time.Now().UTC().Format(time.RFC3339)); err != nil {
 		return err
 	}
+	if _, err := tx.ExecContext(ctx, `INSERT OR REPLACE INTO uls_meta(key,value) VALUES('rules_version',?)`,
+		strconv.Itoa(RulesVersion)); err != nil {
+		return err
+	}
 	if err := tx.Commit(); err != nil {
 		return err
 	}
@@ -333,9 +365,21 @@ func parseGeoNames(zipPath string) (map[string]zipRow, error) {
 		}
 		lat := parseFloat(f[9])
 		lon := parseFloat(f[10])
+		state := strings.ToUpper(strings.TrimSpace(f[4]))
+		county := strings.TrimSpace(f[5])
+		// Connecticut: GeoNames reports the 2022 planning regions, which are
+		// county-equivalents for the Census and nothing at all for amateur
+		// radio — no award, no callbook and no log uses them, so every CT
+		// station resolved to a name that matched nothing. Substitute the legal
+		// county for the ZIP. See cmd/ctzipgen.
+		if state == "CT" {
+			if c, ok := ctCounty[zip5]; ok {
+				county = c
+			}
+		}
 		out[zip5] = zipRow{
-			state:  strings.ToUpper(strings.TrimSpace(f[4])),
-			county: strings.TrimSpace(f[5]),
+			state:  state,
+			county: county,
 			lat:    lat,
 			lon:    lon,
 		}

internal/winkeyer/hostopen.go

@@ -0,0 +1,159 @@
+package winkeyer
+
+import (
+	"errors"
+	"fmt"
+	"time"
+
+	"go.bug.st/serial"
+
+	"hamlog/internal/applog"
+)
+
+// The opening handshake, as K1EL specifies it in the WinKeyer2 Application
+// Interface Guide ("WK Init Psuedo Code"). OpsLog used to send Host Open alone
+// and carry on whatever came back, which is how an operator ended up with a
+// keyer reported as connected, a full set of settings written to it, and not
+// one character keyed — the log said "no reply" and then behaved as if there
+// had been one.
+//
+// The steps exist for reasons that are not obvious from the byte values:
+//
+//	400 ms   a WK1 is still powering up off the DTR line when the port opens;
+//	         WK2 and later do not need it, and it costs nothing once.
+//	0x13 ×3  null commands. WinKey's parser may be part-way through a command
+//	         left over from whoever spoke to it last — another logger, or us
+//	         before a crash. A command byte expecting parameters would swallow
+//	         Host Open whole. Three nulls flush that state out.
+//	echo     ask the keyer to send one known byte back. This is the only step
+//	         that answers "is there really a WinKeyer on this port", and it is
+//	         the one to fail on: everything after it assumes a listener.
+//	open     0x00 0x02, and the keyer returns its firmware version.
+const (
+	cmdNull      = 0x13
+	cmdAdmin     = 0x00
+	adminOpen    = 0x02
+	adminEcho    = 0x04
+	echoProbe   = 0x55 // K1EL's own choice; any byte works, this one is 0b01010101
+	bootDelay   = 400 * time.Millisecond
+	echoTimeout = 2 * time.Second // K1EL: "if a WK doesn't respond within 2 seconds abort"
+	openTimeout = 2 * time.Second
+
+	// resetDelay is the second attempt's wait, and it is not there for a K1EL.
+	//
+	// Plenty of "WinKeyers" are a K3NG keyer — an Arduino running an emulation
+	// of the same protocol. On an Arduino, DTR is wired to the reset pin through
+	// a capacitor: raising it when the port opens REBOOTS the board, which then
+	// sits in its bootloader before the sketch even starts. K3NG's own options
+	// file says as much ("disabling Automatic Software Reset is highly
+	// recommended", and an option to "discard errant serial port bytes at
+	// startup" for when it is not). 400 ms is nowhere near long enough, so the
+	// keyer misses the whole handshake and looks absent.
+	//
+	// Rather than make every operator wait for the slowest possible device, the
+	// first attempt stays quick and only the retry allows for a reboot.
+	resetDelay   = 2500 * time.Millisecond
+	handshakeTry = 2
+)
+
+// errNoKeyer is returned when nothing answers the echo probe.
+var errNoKeyer = errors.New("no WinKeyer answered on this port — check the cable, the port, and that no other program holds the keyer")
+
+// hostOpen runs the full documented handshake and returns the firmware version
+// byte. It is tried twice, and the two attempts cover the two ways a keyer that
+// is plugged in and working can miss being spoken to: a parser left mid-command
+// by whoever talked to it last (the first attempt's nulls clear that), and an
+// Arduino-based keyer still rebooting from the DTR edge (the second attempt
+// waits long enough for it).
+// slowBoot skips straight to the long wait, set when this port has already been
+// seen to need it. The second return value says whether the long wait is what
+// worked, so the caller can remember it and open quickly next time.
+func hostOpen(p serial.Port, slowBoot bool) (ver int, needsSlowBoot bool, err error) {
+	var lastErr error
+	for attempt := 1; attempt <= handshakeTry; attempt++ {
+		wait := bootDelay
+		if attempt > 1 || slowBoot {
+			wait = resetDelay
+		}
+		ver, err := hostOpenOnce(p, wait)
+		if err == nil {
+			if attempt > 1 {
+				applog.Printf("winkeyer: answered on attempt %d — this keyer needs %s to boot (a K3NG or another Arduino keyer with auto-reset on); remembering that for this port", attempt, wait)
+			}
+			return ver, wait == resetDelay, nil
+		}
+		lastErr = err
+		if attempt < handshakeTry {
+			applog.Printf("winkeyer: handshake attempt %d failed (%v) — retrying after %s in case the keyer is rebooting", attempt, err, resetDelay)
+		}
+	}
+	return 0, false, lastErr
+}
+
+func hostOpenOnce(p serial.Port, boot time.Duration) (int, error) {
+	// The keyer may still be booting off the DTR line we just raised.
+	time.Sleep(boot)
+	drain(p)
+
+	// Resync the command parser before asking it anything.
+	if _, err := p.Write([]byte{cmdNull, cmdNull, cmdNull}); err != nil {
+		return 0, fmt.Errorf("resync: %w", err)
+	}
+	time.Sleep(50 * time.Millisecond)
+	drain(p)
+
+	// Is anything actually there?
+	if _, err := p.Write([]byte{cmdAdmin, adminEcho, echoProbe}); err != nil {
+		return 0, fmt.Errorf("echo test: %w", err)
+	}
+	b, ok := readByte(p, echoTimeout)
+	if !ok {
+		return 0, errNoKeyer
+	}
+	if b != echoProbe {
+		// Something replied, but not what we asked for. Say what came back —
+		// on a wrong port that byte is the only clue to what is on the other end.
+		return 0, fmt.Errorf("echo test: expected 0x%02X, got 0x%02X — is this the keyer's port?", echoProbe, b)
+	}
+
+	if _, err := p.Write([]byte{cmdAdmin, adminOpen}); err != nil {
+		return 0, fmt.Errorf("host open: %w", err)
+	}
+	ver, ok := readByte(p, openTimeout)
+	if !ok {
+		return 0, errors.New("host open: the keyer echoed but did not return its firmware version")
+	}
+	return int(ver), nil
+}
+
+// readByte waits up to d for one byte. The serial read timeout is per-call and
+// can return 0 bytes without an error, so this loops until the deadline rather
+// than trusting a single Read.
+func readByte(p serial.Port, d time.Duration) (byte, bool) {
+	_ = p.SetReadTimeout(200 * time.Millisecond)
+	deadline := time.Now().Add(d)
+	buf := make([]byte, 1)
+	for time.Now().Before(deadline) {
+		n, err := p.Read(buf)
+		if n > 0 {
+			return buf[0], true
+		}
+		if err != nil {
+			return 0, false
+		}
+	}
+	return 0, false
+}
+
+// drain throws away anything already waiting — a status byte from a previous
+// session, or the tail of a reply we are no longer interested in.
+func drain(p serial.Port) {
+	_ = p.SetReadTimeout(20 * time.Millisecond)
+	buf := make([]byte, 64)
+	for i := 0; i < 16; i++ {
+		n, err := p.Read(buf)
+		if n == 0 || err != nil {
+			return
+		}
+	}
+}

internal/winkeyer/hostopen_test.go

@@ -0,0 +1,216 @@
+package winkeyer
+
+import (
+	"errors"
+	"sync"
+	"testing"
+	"time"
+
+	"go.bug.st/serial"
+)
+
+// fakeKeyer is a serial.Port that behaves like a WinKeyer: it answers the echo
+// probe and Host Open, and records everything the host sent so the handshake
+// can be checked byte for byte against K1EL's documented sequence.
+type fakeKeyer struct {
+	mu      sync.Mutex
+	written []byte
+	toRead  []byte
+	version byte
+	// deaf drops every command — the keyer that is not there, or is not
+	// listening because RTS starved it.
+	deaf bool
+	// mute answers the echo but never returns a version.
+	mute bool
+	// needsResync ignores commands until three nulls have been seen, standing
+	// in for a keyer left mid-command by another program.
+	needsResync bool
+	nulls       int
+}
+
+func (f *fakeKeyer) Write(p []byte) (int, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	f.written = append(f.written, p...)
+	if f.deaf {
+		return len(p), nil
+	}
+	for i := 0; i < len(p); i++ {
+		switch {
+		case p[i] == cmdNull:
+			f.nulls++
+		case f.needsResync && f.nulls < 3:
+			// still confused — swallow it
+		case p[i] == cmdAdmin && i+1 < len(p):
+			i++
+			switch p[i] {
+			case adminEcho:
+				if i+1 < len(p) {
+					i++
+					f.toRead = append(f.toRead, p[i])
+				}
+			case adminOpen:
+				if !f.mute {
+					f.toRead = append(f.toRead, f.version)
+				}
+			}
+		}
+	}
+	return len(p), nil
+}
+
+func (f *fakeKeyer) Read(p []byte) (int, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	if len(f.toRead) == 0 {
+		return 0, nil // a timeout, not an error — what a real port does
+	}
+	n := copy(p, f.toRead)
+	f.toRead = f.toRead[n:]
+	return n, nil
+}
+
+func (f *fakeKeyer) sent() []byte {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	return append([]byte(nil), f.written...)
+}
+
+func (f *fakeKeyer) Drain() error             { return nil }
+func (f *fakeKeyer) ResetInputBuffer() error  { return nil }
+func (f *fakeKeyer) ResetOutputBuffer() error { return nil }
+func (f *fakeKeyer) SetDTR(bool) error        { return nil }
+func (f *fakeKeyer) SetRTS(bool) error        { return nil }
+func (f *fakeKeyer) GetModemStatusBits() (*serial.ModemStatusBits, error) {
+	return &serial.ModemStatusBits{}, nil
+}
+func (f *fakeKeyer) SetReadTimeout(time.Duration) error { return nil }
+func (f *fakeKeyer) Close() error                       { return nil }
+func (f *fakeKeyer) Break(time.Duration) error          { return nil }
+func (f *fakeKeyer) SetMode(*serial.Mode) error         { return nil }
+
+// TestHostOpenFollowsK1ELSequence checks the handshake against the order K1EL
+// publishes: three nulls to resync the parser, an echo probe to prove there is
+// a keyer, then Host Open. OpsLog used to send Host Open alone, which a keyer
+// left mid-command simply absorbed.
+func TestHostOpenFollowsK1ELSequence(t *testing.T) {
+	f := &fakeKeyer{version: 23}
+	ver, _, err := hostOpen(f, false)
+	if err != nil {
+		t.Fatalf("hostOpen: %v", err)
+	}
+	if ver != 23 {
+		t.Errorf("version = %d, want 23", ver)
+	}
+	want := []byte{
+		cmdNull, cmdNull, cmdNull,
+		cmdAdmin, adminEcho, echoProbe,
+		cmdAdmin, adminOpen,
+	}
+	got := f.sent()
+	if len(got) != len(want) {
+		t.Fatalf("sent % X, want % X", got, want)
+	}
+	for i := range want {
+		if got[i] != want[i] {
+			t.Fatalf("sent % X, want % X", got, want)
+		}
+	}
+}
+
+// A keyer left part-way through a command by another program is the everyday
+// cause of a silent WinKeyer. The nulls must recover it without the operator
+// having to unplug anything.
+func TestHostOpenRecoversAConfusedParser(t *testing.T) {
+	f := &fakeKeyer{version: 30, needsResync: true}
+	ver, _, err := hostOpen(f, false)
+	if err != nil {
+		t.Fatalf("hostOpen: %v", err)
+	}
+	if ver != 30 {
+		t.Errorf("version = %d, want 30", ver)
+	}
+}
+
+// Nothing on the port must FAIL the connection. Reporting success and then
+// writing settings and text into the void is what produced a log full of
+// commands and a keyer that never made a sound.
+func TestHostOpenFailsWhenNothingAnswers(t *testing.T) {
+	f := &fakeKeyer{deaf: true}
+	if _, _, err := hostOpen(f, false); !errors.Is(err, errNoKeyer) {
+		t.Fatalf("want errNoKeyer, got %v", err)
+	}
+}
+
+// Echoing but not returning a version is a different fault and must not be
+// reported as "no keyer".
+func TestHostOpenReportsMissingVersion(t *testing.T) {
+	f := &fakeKeyer{mute: true}
+	_, _, err := hostOpen(f, false)
+	if err == nil {
+		t.Fatal("want an error")
+	}
+	if errors.Is(err, errNoKeyer) {
+		t.Fatalf("a keyer that echoed was reported as absent: %v", err)
+	}
+}
+
+// slowKeyer answers nothing until it has been "powered up" for d — a K3NG on an
+// Arduino, which the DTR edge from opening the port drops into its bootloader.
+type slowKeyer struct {
+	fakeKeyer
+	ready time.Time
+}
+
+func (s *slowKeyer) Write(p []byte) (int, error) {
+	if time.Now().Before(s.ready) {
+		return len(p), nil // still in the bootloader — the bytes are lost
+	}
+	return s.fakeKeyer.Write(p)
+}
+
+// TestHostOpenWaitsOutAnArduinoReboot is the case that started this: a K3NG
+// keyer reboots when the port opens, so it misses a handshake sent 400 ms
+// later. The retry has to wait long enough, and must not need the operator to
+// press connect twice.
+func TestHostOpenWaitsOutAnArduinoReboot(t *testing.T) {
+	f := &slowKeyer{ready: time.Now().Add(1500 * time.Millisecond)}
+	f.version = 23
+	ver, slow, err := hostOpen(f, false)
+	if err != nil {
+		t.Fatalf("hostOpen: %v", err)
+	}
+	if ver != 23 {
+		t.Errorf("version = %d, want 23", ver)
+	}
+	// This second value is what gets remembered for the port, and it is the
+	// whole reason the operator is never asked what kind of keyer they own.
+	// Lose it and every later connect pays the same doomed quick attempt.
+	if !slow {
+		t.Error("the long wait is what worked, but it was not reported as needed")
+	}
+}
+
+// A keyer that answers straight away must NOT be remembered as slow — that
+// would add seconds to every connect for a K1EL that never needed them.
+func TestHostOpenDoesNotMarkAFastKeyerSlow(t *testing.T) {
+	f := &fakeKeyer{version: 23}
+	if _, slow, err := hostOpen(f, false); err != nil || slow {
+		t.Fatalf("hostOpen = slow %v, err %v — want a fast keyer left alone", slow, err)
+	}
+}
+
+// A port already known to hold a slow keyer skips the doomed fast attempt, so
+// the second connect is as quick as a K1EL's.
+func TestHostOpenSlowBootSucceedsFirstTry(t *testing.T) {
+	f := &slowKeyer{ready: time.Now().Add(1500 * time.Millisecond)}
+	f.version = 23
+	if _, _, err := hostOpen(f, true); err != nil {
+		t.Fatalf("hostOpen: %v", err)
+	}
+	// One attempt: exactly one handshake on the wire, not two.
+	want := len([]byte{cmdNull, cmdNull, cmdNull, cmdAdmin, adminEcho, echoProbe, cmdAdmin, adminOpen})
+	if got := len(f.sent()); got != want {
+		t.Errorf("sent %d bytes, want %d — the fast attempt was not skipped", got, want)
+	}
+}

internal/winkeyer/winkeyer.go

@@ -51,6 +51,13 @@ type Config struct {
 	UsePTT     bool   `json:"use_ptt"`     // key PTT (Key/PTT output)
 	SerialEcho bool   `json:"serial_echo"` // device echoes sent chars back to host
 
+	// SlowBoot skips the quick opening attempt and waits for a keyer that reboots
+	// when the port opens — a K3NG or any other Arduino-based WinKeyer with its
+	// auto-reset still enabled. Not an operator setting: it is remembered per port
+	// the first time a keyer only answers the long attempt, so the second connect
+	// is as quick as a K1EL's and nobody has to know what is inside the box.
+	SlowBoot bool `json:"-"`
+
 	// Type selects the keyer engine on this serial port:
 	//   "" / "k1el" → a K1EL WinKeyer chip (the default, everything above applies)
 	//   "serial"    → the PC bit-bangs Morse on a control line (no WinKeyer chip):
@@ -108,12 +115,20 @@ type Manager struct {
 
 	onStatus func(Status)
 	onEcho   func(string) // chars the device echoes back as it keys them
+	// onSlowBoot fires when a keyer answered only after the long wait, so the
+	// caller can persist that for this port. See Config.SlowBoot.
+	onSlowBoot func(port string)
 }
 
 func NewManager(onStatus func(Status), onEcho func(string)) *Manager {
 	return &Manager{onStatus: onStatus, onEcho: onEcho}
 }
 
+// OnSlowBoot registers the callback that persists "this port needs the long
+// opening wait". Optional: without it a slow keyer still connects, it just
+// pays the failed quick attempt on every connect.
+func (m *Manager) OnSlowBoot(fn func(port string)) { m.onSlowBoot = fn }
+
 // ListPorts returns the available serial port names (COM3, COM6, …).
 func ListPorts() ([]string, error) {
 	ports, err := serial.GetPortsList()
@@ -152,22 +167,26 @@ func (m *Manager) Connect(cfg Config) error {
 		DataBits: 8,
 		Parity:   serial.NoParity,
 		StopBits: serial.OneStopBit,
+		// DTR on, RTS OFF. K1EL's own init code sets exactly this
+		// (DTR_CONTROL_ENABLE / RTS_CONTROL_DISABLE), and on a serial WinKeyer
+		// the two lines are the chip's power supply: DTR feeds the 3.3 V
+		// regulator, RTS provides the negative rail for the RS-232 swing.
+		// Driving RTS high starves that rail. The serial library defaults BOTH
+		// to true, which is how this was wrong without anyone writing it.
+		InitialStatusBits: &serial.ModemOutputBits{DTR: true, RTS: false},
 	})
 	if err != nil {
 		return fmt.Errorf("winkeyer: open %s: %w", cfg.Port, err)
 	}
-	_ = p.SetReadTimeout(200 * time.Millisecond)
 
-	// Host Open: <0x00 0x02>. Device replies with its firmware version byte.
-	if _, err := p.Write([]byte{0x00, 0x02}); err != nil {
+	ver, slowBoot, err := hostOpen(p, cfg.SlowBoot)
+	if err != nil {
 		_ = p.Close()
-		return fmt.Errorf("winkeyer: host open: %w", err)
+		return fmt.Errorf("winkeyer: %s: %w", cfg.Port, err)
 	}
-	ver := 0
-	buf := make([]byte, 16)
-	_ = p.SetReadTimeout(1 * time.Second)
-	if n, _ := p.Read(buf); n > 0 {
-		ver = int(buf[0])
+	// Tell the caller to remember it, so this port opens quickly next time.
+	if slowBoot && !cfg.SlowBoot && m.onSlowBoot != nil {
+		m.onSlowBoot(cfg.Port)
 	}
 	_ = p.SetReadTimeout(200 * time.Millisecond)
 
@@ -515,7 +534,10 @@ func cmdName(b []byte) string {
 func firmwareFamily(ver int) string {
 	switch {
 	case ver == 0:
-		return "no reply — the keyer did not answer Host Open"
+		// Unreachable from a successful connect — the handshake fails rather
+		// than returning a version of zero. Kept so a future caller that skips
+		// hostOpen cannot print "WK1 (v0)" and be believed.
+		return "unknown firmware (no version returned)"
 	case ver < 20:
 		return fmt.Sprintf("WK1 (v%d)", ver)
 	case ver < 30:

telemetry.go

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

udp_grid_test.go

@@ -0,0 +1,47 @@
+package main
+
+import "testing"
+
+// A CQ in FT8 carries the operator's square and it is where they are NOW.
+// QRZ and HamQTH describe where they LIVE, which for an expedition is the
+// wrong side of the planet — RI0FA transmitted QN35 all evening and was logged
+// with its licence-holder's home square.
+//
+// refineGrid is the referee. What it must never do is let a directory value
+// replace one heard on the air.
+func TestRefineGridKeepsWhatWasHeardOnAir(t *testing.T) {
+	for _, tc := range []struct{ have, found, want string }{
+		// The expedition case: heard QN35, directory says the home square.
+		{"QN35", "KO85", "QN35"},
+		// Nothing heard: the directory is all there is.
+		{"", "KO85", "KO85"},
+		// A finer square from the SAME field is an upgrade, not a contradiction.
+		{"QN35", "QN35SL", "QN35SL"},
+		// A finer square from a DIFFERENT field is a contradiction — refuse it.
+		{"QN35", "KO85AB", "QN35"},
+		// Case and padding must not decide anything.
+		{" qn35 ", "KO85", "QN35"},
+		{"QN35", "", "QN35"},
+	} {
+		if got := refineGrid(tc.have, tc.found); got != tc.want {
+			t.Errorf("refineGrid(%q, %q) = %q, want %q", tc.have, tc.found, got, tc.want)
+		}
+	}
+}
+
+// And the ordering that makes it work: the decoded grid has to be applied
+// BEFORE the lookup, or refineGrid has nothing to defend.
+func TestDecodedGridWinsOverTheDirectory(t *testing.T) {
+	a := &App{}
+	a.rememberDecodeGrid("RI0FA", "QN35", "decode")
+
+	grid := "" // WSJT-X's ADIF carried no GRIDSQUARE, which is the usual case
+	if g := a.lookupDecodeGrid("RI0FA"); g != "" {
+		grid = refineGrid(grid, g)
+	}
+	grid = refineGrid(grid, "KO85") // then the lookup answers with the home square
+
+	if grid != "QN35" {
+		t.Errorf("logged grid = %q, want QN35 — the square the station actually sent", grid)
+	}
+}