chore: release v0.27.6

The colour already said connected; the word beside it said it again, in
the widest part of a row that has to hold five servers. It goes, and the
pills earn the job nothing else in the app had: reaching ONE cluster
without opening Settings. Click connects or drops that session — a
connecting one included, so a server retrying into a dead host can be
stopped. State, retry count, address and last error move into the
tooltip, where they cost no width.

app.go

@@ -38,6 +38,7 @@ import (
 	"hamlog/internal/cwdecode"
 	"hamlog/internal/db"
 	"hamlog/internal/dxcc"
+	"hamlog/internal/dxped"
 	"hamlog/internal/email"
 	"hamlog/internal/extsvc"
 	"hamlog/internal/geo"
@@ -329,6 +330,7 @@ const (
 	keyClusterSpotMax     = "cluster.spot_max"          // how many spots the list holds at once
 
 	keyScpEnabled = "scp.enabled" // Super Check Partial / N+1 suggestions on
+	keyScpClublog = "scp.clublog" // merge Club Log's weekly SCP list (~180k calls)
 
 	// Web publishing: the whole config as one JSON blob. A single key rather than
 	// twenty: it is read and written as a unit by one settings panel, and the FTP
@@ -356,9 +358,11 @@ const (
 	keyQSLDefaultEQSLSent      = "qsl.eqsl_sent"
 	keyQSLDefaultEQSLRcvd      = "qsl.eqsl_rcvd"
 	keyQSLDefaultClublogStatus = "qsl.clublog_status"
+	keyQSLDefaultClublogCfm    = "qsl.clublog_confirmed"
 	keyQSLDefaultHRDLogStatus  = "qsl.hrdlog_status"
 	keyQSLDefaultQRZComStatus  = "qsl.qrzcom_status"
 	keyQSLDefaultQRZComCfm     = "qsl.qrzcom_confirmed"
+	keyQSLDefaultHamqthStatus  = "qsl.hamqth_status"
 	keyQSLDefaultHamlogStatus  = "qsl.hamlog_status"
 	keyQSLDefaultHamlogCfm     = "qsl.hamlog_confirmed"
 
@@ -399,6 +403,12 @@ const (
 	keyExtCloudlogAutoUpload = "extsvc.cloudlog.auto_upload"
 	keyExtCloudlogUploadMode = "extsvc.cloudlog.upload_mode"
 
+	keyExtHamqthUsername   = "extsvc.hamqth.username"
+	keyExtHamqthPassword   = "extsvc.hamqth.password"
+	keyExtHamqthCallsign   = "extsvc.hamqth.callsign"
+	keyExtHamqthAutoUpload = "extsvc.hamqth.auto_upload"
+	keyExtHamqthUploadMode = "extsvc.hamqth.upload_mode"
+
 	keyExtHamlogAPIKey     = "extsvc.hamlog.api_key"
 	keyExtHamlogAutoUpload = "extsvc.hamlog.auto_upload"
 	keyExtHamlogUploadMode = "extsvc.hamlog.upload_mode"
@@ -421,6 +431,8 @@ const (
 	keyExtLoTWLastDownload = "extsvc.lotw.last_download" // YYYY-MM-DD of last confirmation pull
 	keyExtQRZLastDownload  = "extsvc.qrz.last_download"  // YYYY-MM-DD of last QRZ confirmation pull
 	keyExtEQSLLastDownload = "extsvc.eqsl.last_download" // YYYY-MM-DD of last eQSL inbox pull
+
+	keyExtClublogLastDownload = "extsvc.clublog.last_download" // YYYY-MM-DD of last Club Log matches pull
 )
 
 // QSLDefaults is the per-user default for the QSL / eQSL / LoTW / upload
@@ -436,6 +448,7 @@ type QSLDefaults struct {
 	EQSLSent      string `json:"eqsl_sent"`
 	EQSLRcvd      string `json:"eqsl_rcvd"`
 	ClublogStatus string `json:"clublog_status"`
+	ClublogCfm    string `json:"clublog_confirmed"` // Club Log match/download status
 	HRDLogStatus  string `json:"hrdlog_status"`
 	QRZComStatus  string `json:"qrzcom_status"`
 	QRZComCfm     string `json:"qrzcom_confirmed"` // QRZ.com download/confirmed status
@@ -445,6 +458,9 @@ type QSLDefaults struct {
 	// at "N" here exactly as they do for Club Log.
 	HamlogStatus string `json:"hamlog_status"`
 	HamlogCfm    string `json:"hamlog_confirmed"`
+	// HamQTH, same extras story — and SENT only: the site publishes no
+	// confirmation feed, so there is no received side to default.
+	HamqthStatus string `json:"hamqth_status"`
 }
 
 // CATSettings is the user-tweakable rig-control configuration. Stored as
@@ -790,6 +806,9 @@ type App struct {
 	solar        *solar.Manager     // live space-weather (SFI/SSN/A/K) for the header + QSO stamping
 	lotwUsers    *lotwusers.Manager // LoTW user-activity list (badge next to the callsign)
 	scp          *scp.Manager       // Super Check Partial / N+1 callsign master list
+	// dxped reads the ADXO announcements and the DX-World feed for the
+	// DXpeditions tab. Built lazily: nothing fetches until the tab is opened.
+	dxped *dxped.Manager
 
 	// NET Control: persistent net definitions/rosters (global JSON) + the live
 	// session (in-memory only — active stations currently in QSO).
@@ -1129,7 +1148,9 @@ func (a *App) startup(ctx context.Context) {
 	conn, err := db.Open(a.dbPath)
 	if err != nil {
 		a.startupErr = "cannot open db: " + err.Error()
-		fmt.Println("OpsLog:", a.startupErr)
+		// In the rotating log too: the GUI subsystem discards stdout, and this
+		// exact failure once hid for a whole morning behind a println.
+		applog.Printf("startup: %s", a.startupErr)
 		return
 	}
 	a.db = conn
@@ -1395,6 +1416,9 @@ func (a *App) startup(ctx context.Context) {
 	// Super Check Partial / N+1: load the cached MASTER.SCP; when the feature is
 	// enabled, auto-(re)download it if missing or older than a week.
 	a.scp = scp.NewManager(dataDir)
+	if v, _ := a.settings.Get(a.ctx, keyScpClublog); v == "1" {
+		a.scp.SetClublogEnabled(true)
+	}
 	go func() {
 		if v, _ := a.settings.Get(a.ctx, keyScpEnabled); v != "1" {
 			return
@@ -2841,7 +2865,9 @@ func (a *App) RestartApp() error {
 	if err != nil {
 		return fmt.Errorf("locate executable: %w", err)
 	}
-	cmd := exec.Command(exe)
+	// --relaunch: the child waits for OUR mutex instead of declaring us a
+	// duplicate — this instance is quitting, just not always fast enough.
+	cmd := exec.Command(exe, "--relaunch")
 	cmd.Dir = filepath.Dir(exe)
 	if err := cmd.Start(); err != nil {
 		return fmt.Errorf("relaunch OpsLog: %w", err)
@@ -3146,6 +3172,7 @@ type ScpStatus struct {
 	Enabled bool   `json:"enabled"`
 	Count   int    `json:"count"`
 	Updated string `json:"updated,omitempty"` // RFC3339, empty if never
+	Clublog bool   `json:"clublog"`           // Club Log source merged in
 }
 
 // GetScpStatus returns whether SCP is enabled and how many calls are loaded.
@@ -3157,6 +3184,7 @@ func (a *App) GetScpStatus() ScpStatus {
 	}
 	if a.scp != nil {
 		st.Count = a.scp.Count()
+		st.Clublog = a.scp.ClublogEnabled()
 		if u := a.scp.Updated(); !u.IsZero() {
 			st.Updated = u.UTC().Format(time.RFC3339)
 		}
@@ -3164,6 +3192,34 @@ func (a *App) GetScpStatus() ScpStatus {
 	return st
 }
 
+// SetScpClublogEnabled merges (or stops merging) Club Log's weekly SCP list
+// into the Super Check Partial call list, and refreshes the download so the
+// change is visible without waiting for the weekly cycle.
+func (a *App) SetScpClublogEnabled(on bool) error {
+	if a.settings == nil {
+		return fmt.Errorf("db not initialized")
+	}
+	if err := a.settings.Set(a.ctx, keyScpClublog, boolStr(on)); err != nil {
+		return err
+	}
+	if a.scp != nil {
+		a.scp.SetClublogEnabled(on)
+		if on {
+			go func() {
+				if n, err := a.scp.Download(context.Background()); err == nil {
+					applog.Printf("scp: downloaded %d callsigns (with Club Log list)", n)
+					if a.ctx != nil {
+						wruntime.EventsEmit(a.ctx, "scp:updated")
+					}
+				} else {
+					applog.Printf("scp: download failed: %v", err)
+				}
+			}()
+		}
+	}
+	return nil
+}
+
 // SetScpEnabled turns Super Check Partial on/off. Enabling triggers a background
 // download when the list is missing or stale.
 func (a *App) SetScpEnabled(on bool) error {
@@ -6889,6 +6945,7 @@ var bulkFieldColumns = map[string]string{
 	"qrz_sent":     "qrzcom_qso_upload_status",
 	"qrz_rcvd":     "qrzcom_qso_download_status",
 	"clublog_sent": "clublog_qso_upload_status",
+	"clublog_rcvd": "clublog_qso_download_status",
 	"hrdlog_sent":  "hrdlog_qso_upload_status",
 	// Old ids kept so anything holding one keeps working.
 	"qrz_upload":     "qrzcom_qso_upload_status",
@@ -6905,6 +6962,7 @@ var bulkFieldColumns = map[string]string{
 	"qrz_sent_date":     "qrzcom_qso_upload_date",
 	"qrz_rcvd_date":     "qrzcom_qso_download_date",
 	"clublog_sent_date": "clublog_qso_upload_date",
+	"clublog_rcvd_date": "clublog_qso_download_date",
 	"hrdlog_sent_date":  "hrdlog_qso_upload_date",
 	// My station / operator
 	"station_callsign": "station_callsign",
@@ -10898,7 +10956,8 @@ func defaultQSLDefaults() QSLDefaults {
 		QSLSent: "N", QSLRcvd: "N",
 		EQSLSent: "R", EQSLRcvd: "N",
 		LOTWSent: "R", LOTWRcvd: "N",
-		ClublogStatus: "R", HRDLogStatus: "R",
+		ClublogStatus: "R", ClublogCfm: "N", HRDLogStatus: "R",
+		HamqthStatus: "R",
 		QRZComStatus: "R", QRZComCfm: "N",
 	}
 }
@@ -10917,9 +10976,10 @@ func (a *App) GetQSLDefaults() (QSLDefaults, error) {
 		keyQSLDefaultQSLSent, keyQSLDefaultQSLRcvd,
 		keyQSLDefaultLOTWSent, keyQSLDefaultLOTWRcvd,
 		keyQSLDefaultEQSLSent, keyQSLDefaultEQSLRcvd,
-		keyQSLDefaultClublogStatus, keyQSLDefaultHRDLogStatus,
+		keyQSLDefaultClublogStatus, keyQSLDefaultClublogCfm, keyQSLDefaultHRDLogStatus,
 		keyQSLDefaultQRZComStatus, keyQSLDefaultQRZComCfm,
 		keyQSLDefaultHamlogStatus, keyQSLDefaultHamlogCfm,
+		keyQSLDefaultHamqthStatus,
 	)
 	if err != nil {
 		return out, err
@@ -10931,10 +10991,12 @@ func (a *App) GetQSLDefaults() (QSLDefaults, error) {
 	out.EQSLSent = m[keyQSLDefaultEQSLSent]
 	out.EQSLRcvd = m[keyQSLDefaultEQSLRcvd]
 	out.ClublogStatus = m[keyQSLDefaultClublogStatus]
+	out.ClublogCfm = m[keyQSLDefaultClublogCfm]
 	out.HRDLogStatus = m[keyQSLDefaultHRDLogStatus]
 	out.QRZComStatus = m[keyQSLDefaultQRZComStatus]
 	out.QRZComCfm = m[keyQSLDefaultQRZComCfm]
 	out.HamlogStatus = m[keyQSLDefaultHamlogStatus]
+	out.HamqthStatus = m[keyQSLDefaultHamqthStatus]
 	out.HamlogCfm = m[keyQSLDefaultHamlogCfm]
 	return out, nil
 }
@@ -10954,10 +11016,12 @@ func (a *App) SaveQSLDefaults(d QSLDefaults) error {
 		keyQSLDefaultEQSLSent:      strings.ToUpper(strings.TrimSpace(d.EQSLSent)),
 		keyQSLDefaultEQSLRcvd:      strings.ToUpper(strings.TrimSpace(d.EQSLRcvd)),
 		keyQSLDefaultClublogStatus: strings.ToUpper(strings.TrimSpace(d.ClublogStatus)),
+		keyQSLDefaultClublogCfm:    strings.ToUpper(strings.TrimSpace(d.ClublogCfm)),
 		keyQSLDefaultHRDLogStatus:  strings.ToUpper(strings.TrimSpace(d.HRDLogStatus)),
 		keyQSLDefaultQRZComStatus:  strings.ToUpper(strings.TrimSpace(d.QRZComStatus)),
 		keyQSLDefaultQRZComCfm:     strings.ToUpper(strings.TrimSpace(d.QRZComCfm)),
 		keyQSLDefaultHamlogStatus:  strings.ToUpper(strings.TrimSpace(d.HamlogStatus)),
+		keyQSLDefaultHamqthStatus:  strings.ToUpper(strings.TrimSpace(d.HamqthStatus)),
 		keyQSLDefaultHamlogCfm:     strings.ToUpper(strings.TrimSpace(d.HamlogCfm)),
 	} {
 		if err := a.settings.Set(a.ctx, scope+k, v); err != nil {
@@ -11006,6 +11070,7 @@ func applyQSLDefaultsTo(q *qso.QSO, d QSLDefaults) {
 	fill(&q.EQSLSent, d.EQSLSent)
 	fill(&q.EQSLRcvd, d.EQSLRcvd)
 	fill(&q.ClublogUploadStatus, d.ClublogStatus)
+	fill(&q.ClublogDownloadStatus, d.ClublogCfm)
 	fill(&q.HRDLogUploadStatus, d.HRDLogStatus)
 	fill(&q.QRZComUploadStatus, d.QRZComStatus)
 	fill(&q.QRZComDownloadStatus, d.QRZComCfm)
@@ -11013,6 +11078,7 @@ func applyQSLDefaultsTo(q *qso.QSO, d QSLDefaults) {
 	// string field, and these two are map entries. Only set when the QSO does not
 	// already carry them, which is the same rule fill() applies.
 	setExtraDefault(q, hamlogSentKey, d.HamlogStatus)
+	setExtraDefault(q, hamqthSentKey, d.HamqthStatus)
 	setExtraDefault(q, award.HamlogQSLKey, d.HamlogCfm)
 }
 
@@ -11130,7 +11196,9 @@ func (a *App) loadExternalServices() extsvc.ExternalServices {
 		keyExtEQSLUsername, keyExtEQSLPassword, keyExtEQSLQTHNick, keyExtEQSLAutoUpload, keyExtEQSLUploadMode,
 		keyExtCloudlogURL, keyExtCloudlogAPIKey, keyExtCloudlogStationID,
 		keyExtCloudlogAutoUpload, keyExtCloudlogUploadMode, keyExtDeleteRemote,
-		keyExtHamlogAPIKey, keyExtHamlogAutoUpload, keyExtHamlogUploadMode)
+		keyExtHamlogAPIKey, keyExtHamlogAutoUpload, keyExtHamlogUploadMode,
+		keyExtHamqthUsername, keyExtHamqthPassword, keyExtHamqthCallsign,
+		keyExtHamqthAutoUpload, keyExtHamqthUploadMode)
 	if err != nil {
 		return out
 	}
@@ -11214,6 +11282,21 @@ func (a *App) loadExternalServices() extsvc.ExternalServices {
 		AutoUpload: m[keyExtHamlogAutoUpload] == "1",
 		UploadMode: extsvc.UploadMode(m[keyExtHamlogUploadMode]),
 	}
+	out.HamQTH = extsvc.ServiceConfig{
+		Username:   m[keyExtHamqthUsername],
+		Password:   m[keyExtHamqthPassword],
+		Callsign:   m[keyExtHamqthCallsign],
+		AutoUpload: m[keyExtHamqthAutoUpload] == "1",
+		UploadMode: extsvc.UploadMode(m[keyExtHamqthUploadMode]),
+	}
+	// The callbook lookup already knows these credentials; blanks fall back to
+	// them so an operator who set up the lookup years ago is one checkbox away.
+	if out.HamQTH.Username == "" && out.HamQTH.Password == "" {
+		u, _ := a.settings.Get(a.ctx, keyHQUser)
+		p, _ := a.settings.Get(a.ctx, keyHQPassword)
+		out.HamQTH.Username = strings.TrimSpace(u)
+		out.HamQTH.Password = p
+	}
 	return out
 }
 
@@ -11288,6 +11371,7 @@ func (a *App) SaveExternalServices(cfg extsvc.ExternalServices) error {
 	if hamMode == string(extsvc.ModeOnClose) {
 		hamMode = string(extsvc.ModeImmediate)
 	}
+	hqMode := modeOf(cfg.HamQTH.UploadMode)
 	hamAuto := "0"
 	if cfg.Hamlog.AutoUpload {
 		hamAuto = "1"
@@ -11343,6 +11427,11 @@ func (a *App) SaveExternalServices(cfg extsvc.ExternalServices) error {
 		keyExtHamlogAPIKey:     strings.TrimSpace(cfg.Hamlog.APIKey),
 		keyExtHamlogAutoUpload: hamAuto,
 		keyExtHamlogUploadMode: hamMode,
+		keyExtHamqthUsername:   strings.TrimSpace(cfg.HamQTH.Username),
+		keyExtHamqthPassword:   cfg.HamQTH.Password,
+		keyExtHamqthCallsign:   strings.ToUpper(strings.TrimSpace(cfg.HamQTH.Callsign)),
+		keyExtHamqthAutoUpload: boolStr(cfg.HamQTH.AutoUpload),
+		keyExtHamqthUploadMode: hqMode,
 	} {
 		if err := a.settings.Set(a.ctx, scope+k, v); err != nil {
 			return err
@@ -11371,6 +11460,13 @@ func (a *App) TestClublogUpload() (string, error) {
 	return extsvc.TestClublog(a.ctx, a.loadExternalServices().Clublog)
 }
 
+// TestHamQTHUpload checks the HamQTH credentials against the callbook login —
+// authenticated, and unable to touch the log.
+func (a *App) TestHamQTHUpload() (string, error) {
+	cfg := a.loadExternalServices().HamQTH
+	return extsvc.TestHamQTH(a.ctx, nil, cfg)
+}
+
 // TestHRDLogUpload validates that the HRDLog credentials are complete.
 func (a *App) TestHRDLogUpload() (string, error) {
 	return extsvc.TestHRDLog(a.ctx, nil, a.loadExternalServices().HRDLog)
@@ -11430,6 +11526,9 @@ func (a *App) FindQSOsForUpload(service, sentStatus string) ([]qso.QSO, error) {
 	if extsvc.Service(service) == extsvc.ServiceHamlog {
 		return a.qso.ListMissingExtra(a.ctx, hamlogSentKey)
 	}
+	if extsvc.Service(service) == extsvc.ServiceHamQTH {
+		return a.qso.ListMissingExtra(a.ctx, hamqthSentKey)
+	}
 	col := uploadColumnFor(service)
 	if col == "" {
 		return nil, fmt.Errorf("unknown service %q", service)
@@ -11445,7 +11544,7 @@ func (a *App) UploadQSOsManual(service string, ids []int64) error {
 		return fmt.Errorf("db not initialized")
 	}
 	svc := extsvc.Service(service)
-	if uploadColumnFor(service) == "" && svc != extsvc.ServiceHamlog {
+	if uploadColumnFor(service) == "" && svc != extsvc.ServiceHamlog && svc != extsvc.ServiceHamQTH {
 		return fmt.Errorf("unknown service %q", service)
 	}
 	cfg := a.loadExternalServices()
@@ -11669,6 +11768,43 @@ func (a *App) runManualUpload(svc extsvc.Service, ids []int64, cfg extsvc.Extern
 			}
 			flush()
 		}
+	} else if svc == extsvc.ServiceHamlog || svc == extsvc.ServiceHamQTH {
+		// One record per request, extras-stamped services. Hamlog used to fall
+		// through to the QRZ branch below and got uploaded to the WRONG service
+		// with the QRZ key — the context menu offered what the loop never handled.
+		for i, id := range ids {
+			if i > 0 {
+				time.Sleep(manualUploadPace)
+			}
+			q, gerr := a.qso.GetByID(ctx, id)
+			call := ""
+			if gerr == nil {
+				call = q.Callsign
+			}
+			rec, ok := a.buildUploadADIF(id, "")
+			if !ok {
+				emit(call + " — skipped (no record)")
+				continue
+			}
+			var res extsvc.UploadResult
+			var err error
+			if svc == extsvc.ServiceHamlog {
+				res, err = extsvc.UploadHamlog(ctx, nil, cfg.Hamlog, rec)
+			} else {
+				res, err = extsvc.UploadHamQTH(ctx, nil, cfg.HamQTH, rec)
+			}
+			if err == nil && res.OK {
+				a.markExtUploaded(svc, id, res.LogID)
+				uploaded++
+				emit(call + " — OK")
+			} else {
+				msg := res.Message
+				if err != nil {
+					msg = err.Error()
+				}
+				emit(call + " — FAILED: " + msg)
+			}
+		}
 	} else {
 		// QRZ.com: one record per request (its logbook API has no batch upload),
 		// paced for the same reason as HRDLog above.
@@ -11710,6 +11846,7 @@ func (a *App) runManualUpload(svc extsvc.Service, ids []int64, cfg extsvc.Extern
 		label := map[extsvc.Service]string{
 			extsvc.ServiceQRZ: "QRZ.com", extsvc.ServiceClublog: "Club Log", extsvc.ServiceHRDLog: "HRDLog",
 			extsvc.ServiceLoTW: "LoTW", extsvc.ServiceEQSL: "eQSL",
+			extsvc.ServiceHamlog: "HAMLOG.online", extsvc.ServiceHamQTH: "HamQTH",
 		}[svc]
 		if label == "" {
 			label = string(svc)
@@ -12935,6 +13072,90 @@ func (a *App) runDownloadConfirmations(ctx context.Context, svc extsvc.Service,
 			a.setSetting(a.profileScope()+keyExtEQSLLastDownload, time.Now().UTC().Format("2006-01-02"))
 		}
 
+	case extsvc.ServiceClublog:
+		sinceDate := resolveSince(keyExtClublogLastDownload)
+		if sinceDate != "" {
+			emit("Downloading Club Log matches (matched since " + sinceDate + ")…")
+		} else {
+			emit("Downloading ALL Club Log matches (full pull — the date filter is faster next time)…")
+		}
+		matches, err := extsvc.DownloadClublogMatches(ctx, nil, cfg.Clublog, sinceDate)
+		if err != nil {
+			emit("Download failed: " + err.Error())
+			done(matched, total)
+			return
+		}
+		mIdx, kerr := a.qso.BuildMatchIndex(ctx, a.uploadOwnerCall(extsvc.ServiceClublog))
+		if kerr != nil {
+			emit("Error reading local log: " + kerr.Error())
+			done(matched, total)
+			return
+		}
+		// Club Log pairs QSOs within ±15 minutes, same as LoTW.
+		const clublogMatchWindow = 15 * time.Minute
+		today := time.Now().UTC().Format("20060102")
+		// A Club Log match is Club Log's own kind of confirmation, so NEW is
+		// judged only against other Club Log matches.
+		sets, _ := a.qso.ConfirmedSlots(ctx, []string{"clublog_qso_download_status"})
+		var items []ConfirmationItem
+		var unmatched []string
+		for _, m := range matches {
+			if ctx.Err() != nil {
+				return
+			}
+			total++
+			id, found := int64(0), false
+			if m.Band != "" && m.Mode != "" {
+				id, found = mIdx.Match(m.Callsign, m.Band, m.Mode, m.When, clublogMatchWindow)
+			}
+			if !found && m.Band != "" {
+				// Club Log reports "false" for modes it can't infer — fall back to
+				// call+band+time, still unambiguous inside a 15-minute window.
+				id, found = mIdx.MatchBand(m.Callsign, m.Band, m.When, clublogMatchWindow)
+			}
+			if found {
+				if e := a.qso.MarkClublogConfirmed(ctx, id, today); e == nil {
+					matched++
+				}
+			} else {
+				unmatched = append(unmatched, fmt.Sprintf("%s · %s · %s · %s",
+					m.Callsign, m.When.Format("2006-01-02 15:04Z"), m.Band, m.Mode))
+			}
+			it := ConfirmationItem{
+				Callsign: m.Callsign,
+				QSODate:  m.When.Format(time.RFC3339),
+				Band:     m.Band, Mode: m.Mode,
+			}
+			if m.DXCC != 0 {
+				it.Country = dxcc.NameForDXCC(m.DXCC)
+				it.NewDXCC = !sets.DXCC[m.DXCC]
+				it.NewBand = !sets.Band[qso.BandKey(m.DXCC, m.Band)]
+				it.NewMode = !sets.Mode[qso.ModeClassKey(m.DXCC, m.Mode)]
+				it.NewSlot = !sets.Slot[qso.SlotClassKey(m.DXCC, m.Band, m.Mode)]
+				sets.DXCC[m.DXCC] = true
+				sets.Band[qso.BandKey(m.DXCC, m.Band)] = true
+				sets.Mode[qso.ModeClassKey(m.DXCC, m.Mode)] = true
+				sets.Slot[qso.SlotClassKey(m.DXCC, m.Band, m.Mode)] = true
+			}
+			items = append(items, it)
+		}
+		if a.ctx != nil {
+			wruntime.EventsEmit(a.ctx, "qslmgr:confirmations", items)
+		}
+		emit(fmt.Sprintf("Matched %d of %d Club Log match(es)", matched, total))
+		if addNotFound && len(unmatched) > 0 {
+			// A match means BOTH sides uploaded this QSO — one Club Log can't find
+			// locally was deleted or edited here, not missed; adding a skeleton
+			// row from call/band/time alone would just create a duplicate shadow.
+			emit("Club Log matches carry too little detail to add missing QSOs — unmatched ones are listed below.")
+		}
+		for _, u := range unmatched {
+			emit("  ⚠ no local QSO for: " + u)
+		}
+		if a.settings != nil {
+			a.setSetting(a.profileScope()+keyExtClublogLastDownload, time.Now().UTC().Format("2006-01-02"))
+		}
+
 	default:
 		emit(fmt.Sprintf("Confirmation download isn't available for %s yet.", svc))
 	}
@@ -13361,14 +13582,21 @@ func (a *App) extShouldUpload(svc extsvc.Service, id int64) bool {
 		// is not remembered — hence no on-close mode and no manual backlog.
 		return true
 	case extsvc.ServiceHamlog:
-		// The stamp is an extra, not a column — see markExtUploaded. Present means
+		// The stamp is an extra, not a column — see markExtUploaded. A stamp that
-		// it has gone, which is what stops an on-demand re-upload of a whole log
+		// MEANS SENT is what stops an on-demand re-upload of a whole log from
-		// from sending every contact twice.
+		// sending every contact twice.
-		if q.Extras != nil && strings.TrimSpace(q.Extras[hamlogSentKey]) != "" {
+		if q.Extras != nil && extrasSaysSent(q.Extras[hamlogSentKey]) {
 			applog.Printf("extsvc: QSO %d not eligible for hamlog — already sent on %s", id, q.Extras[hamlogSentKey])
 			return false
 		}
 		return true
+	case extsvc.ServiceHamQTH:
+		// Same extras stamp as HAMLOG.online — ADIF names no HamQTH field.
+		if q.Extras != nil && extrasSaysSent(q.Extras[hamqthSentKey]) {
+			applog.Printf("extsvc: QSO %d not eligible for hamqth — already sent on %s", id, q.Extras[hamqthSentKey])
+			return false
+		}
+		return true
 	case extsvc.ServiceLoTW:
 		for _, f := range a.loadExternalServices().LoTW.UploadFlags {
 			if strings.EqualFold(q.LOTWSent, f) {
@@ -13389,8 +13617,26 @@ func (a *App) extShouldUpload(svc extsvc.Service, id int64) bool {
 const (
 	hamlogSentKey     = "APP_OPSLOG_HAMLOG_SENT"
 	hamlogSentDateKey = "APP_OPSLOG_HAMLOG_SENT_DATE"
+	hamqthSentKey     = "APP_OPSLOG_HAMQTH_SENT"
+	hamqthSentDateKey = "APP_OPSLOG_HAMQTH_SENT_DATE"
 )
 
+// extrasSaysSent reads an extras upload stamp as "this QSO has GONE".
+//
+// Mere presence will not do. markExtUploaded writes "Y" (older builds wrote the
+// date), but the Confirmations page pre-fills the same key with a TO-DO status
+// — "R", requested, is the natural default for a service you intend to upload
+// to — and reading that as "already gone" would silently disable the very
+// auto-upload the default was set to arm. So the pending statuses mean pending,
+// and anything else means sent.
+func extrasSaysSent(v string) bool {
+	switch strings.ToUpper(strings.TrimSpace(v)) {
+	case "", "R", "N", "Q", "I":
+		return false
+	}
+	return true
+}
+
 func (a *App) markExtUploaded(svc extsvc.Service, id int64, logID string) {
 	date := time.Now().UTC().Format("20060102")
 	// Use a fresh background context, NOT a.ctx: this stamp often runs during
@@ -13436,6 +13682,10 @@ func (a *App) markExtUploaded(svc extsvc.Service, id int64, logID string) {
 		if err = a.qso.SetExtra(ctx, id, hamlogSentKey, "Y"); err == nil {
 			err = a.qso.SetExtra(ctx, id, hamlogSentDateKey, date)
 		}
+	case extsvc.ServiceHamQTH:
+		if err = a.qso.SetExtra(ctx, id, hamqthSentKey, "Y"); err == nil {
+			err = a.qso.SetExtra(ctx, id, hamqthSentDateKey, date)
+		}
 	}
 	if err != nil {
 		applog.Printf("extsvc: mark %s uploaded %d failed: %v", svc, id, err)
@@ -16098,6 +16348,10 @@ func (a *App) reloadAfterProfileSwitch() {
 	a.restartAsync("tuner", a.startTunerGenius)
 	a.restartAsync("psu", a.startPSU)
 	a.startQSORecorderIfEnabled()
+	// The watchlist's Club Log enrichment (OQRS/QSO-count badges) reads
+	// per-profile settings too — rebuilt so a switch doesn't keep showing the
+	// previous profile's view of who is worth chasing.
+	a.startWatchlistClubLog()
 }
 
 // DuplicateProfile clones an existing profile under newName. Useful when
@@ -18549,19 +18803,51 @@ func (a *App) startAmps() {
 	old := a.ampInsts
 	a.ampInsts = map[string]*ampInst{}
 	a.ampsMu.Unlock()
-	for _, inst := range old {
+	a.pgxl, a.spe, a.acom = nil, nil, nil
+	list, err := a.GetAmplifiers()
+	if err != nil {
+		for _, inst := range old {
+			go inst.stopAll()
+		}
+		return
+	}
+	// An amplifier whose configuration did not change keeps its RUNNING client
+	// across a settings save. Rebuilding closes the serial port, and closing a
+	// COM port makes the Windows driver drop DTR/RTS — which on a KPA500 is the
+	// POWER SWITCH: every save of any Settings page was switching the amplifier
+	// off (F1TPL's report). Reuse also spares the other amps a reconnect blink.
+	reused := map[string]bool{}
+	for _, c := range list {
+		if !c.Enabled {
+			continue
+		}
+		if o, ok := old[c.ID]; ok && o.cfg == c {
+			reused[c.ID] = true
+			if o.pgxl != nil && a.pgxl == nil {
+				a.pgxl = o.pgxl
+			}
+			if o.spe != nil && a.spe == nil {
+				a.spe = o.spe
+			}
+			if o.acom != nil && a.acom == nil {
+				a.acom = o.acom
+			}
+			a.ampsMu.Lock()
+			a.ampInsts[c.ID] = o
+			a.ampsMu.Unlock()
+		}
+	}
+	for id, inst := range old {
+		if reused[id] {
+			continue
+		}
 		// Stop() can block up to the dial timeout waiting for an in-progress
 		// connect; tear down in the background so saving Settings (this runs on
 		// the Wails RPC goroutine) doesn't freeze the UI.
 		go inst.stopAll()
 	}
-	a.pgxl, a.spe, a.acom = nil, nil, nil
-	list, err := a.GetAmplifiers()
-	if err != nil {
-		return
-	}
 	for _, c := range list {
-		if !c.Enabled {
+		if !c.Enabled || reused[c.ID] {
 			continue
 		}
 		isPGXL := c.Type == "" || c.Type == "pgxl"

app_dxped.go

@@ -0,0 +1,153 @@
+package main
+
+import (
+	"strings"
+
+	"hamlog/internal/applog"
+	"hamlog/internal/dxped"
+)
+
+// ── DXpeditions (ADXO announcements + DX-World news) ────────────────────
+//
+// What a logger can say that a news reader cannot: whether the announced
+// operation is worth chasing. Every activation is judged against THIS log —
+// the same verdict the cluster paints on a spot — so the list reads as "what I
+// still need", not "what is on the air".
+
+// DXpedition is one announced operation plus what it is worth here.
+type DXpedition struct {
+	dxped.Activation
+	// Status is the strongest verdict across the announced callsigns, bands and
+	// modes: "new" (entity never worked) beats "new-band-mode", which beats
+	// "new-band", "new-mode", "new-slot", and finally "worked". Empty when the
+	// callsign resolves to no entity — a prefix ADXO knows and cty.dat does not.
+	Status string `json:"status_chase"`
+	// Unconfirmed marks a need that is only a missing QSL, so the badge can be
+	// drawn dimmed exactly as it is in the cluster and the decode list.
+	Unconfirmed bool `json:"unconfirmed"`
+}
+
+// chaseRank orders the verdicts from "most worth chasing" down. The DXpedition
+// list shows ONE badge, so the ranking is the whole decision.
+var chaseRank = map[string]int{
+	"new":           6,
+	"new-band-mode": 5,
+	"new-band":      4,
+	"new-mode":      3,
+	"new-slot":      2,
+	"worked":        1,
+}
+
+// GetDXpeditions returns the announced operations, freshest feed permitting,
+// each carrying its chase verdict.
+func (a *App) GetDXpeditions() ([]DXpedition, error) {
+	if a.dxped == nil {
+		a.dxped = dxped.New()
+	}
+	acts, err := a.dxped.Activations(a.ctx)
+	if err != nil {
+		applog.Printf("dxped: adxo fetch: %v", err)
+		if len(acts) == 0 {
+			return nil, err
+		}
+		// Stale data with a logged error beats an empty tab.
+	}
+	out := make([]DXpedition, 0, len(acts))
+	for _, act := range acts {
+		out = append(out, DXpedition{Activation: act, Status: "", Unconfirmed: false})
+	}
+	a.judgeDXpeditions(out)
+	return out, nil
+}
+
+// judgeDXpeditions fills in the chase verdict, in place.
+//
+// One ClusterSpotStatuses call for the whole list rather than one per row: the
+// worked-index it builds is the expensive part (a full pass over the log), and
+// asking it forty times to answer forty rows was the difference between a tab
+// that opens and a tab that stalls a remote MySQL for a second.
+func (a *App) judgeDXpeditions(list []DXpedition) {
+	if a.qso == nil || len(list) == 0 {
+		return
+	}
+	type slot struct{ row int }
+	var queries []SpotQuery
+	var owners []slot
+	for i, d := range list {
+		calls := d.Calls
+		if len(calls) == 0 {
+			if c := strings.ToUpper(strings.TrimSpace(d.Callsign)); c != "" {
+				calls = []string{c}
+			}
+		}
+		for _, call := range calls {
+			// No announced band/mode: ask the entity-level question alone.
+			if len(d.Bands) == 0 && len(d.Modes) == 0 {
+				queries = append(queries, SpotQuery{Call: call})
+				owners = append(owners, slot{i})
+				continue
+			}
+			bands := d.Bands
+			if len(bands) == 0 {
+				bands = []string{""}
+			}
+			modes := d.Modes
+			if len(modes) == 0 {
+				modes = []string{""}
+			}
+			for _, b := range bands {
+				for _, m := range modes {
+					queries = append(queries, SpotQuery{Call: call, Band: b, Mode: m})
+					owners = append(owners, slot{i})
+				}
+			}
+		}
+	}
+	if len(queries) == 0 {
+		return
+	}
+	res := a.ClusterSpotStatuses(queries)
+	for i, r := range res {
+		if i >= len(owners) {
+			break
+		}
+		row := owners[i].row
+		if chaseRank[r.Status] > chaseRank[list[row].Status] {
+			list[row].Status = r.Status
+			list[row].Unconfirmed = r.UnconfStatus
+		}
+	}
+}
+
+// GetDXWorldNews returns the DX-World headlines, with the callsigns mined out
+// of each one so the reader can watch them.
+//
+// Deliberately NOT judged against the log. A headline names no band, so the
+// only verdict available is entity-level, and a pane of "NEW DXCC" and
+// "worked" badges turned out to say nothing an operator could act on — the
+// same two words on every row is noise wearing the clothes of information.
+// The announcements pane, which knows the bands and modes, is where a chase
+// verdict is worth drawing.
+func (a *App) GetDXWorldNews() ([]dxped.News, error) {
+	if a.dxped == nil {
+		a.dxped = dxped.New()
+	}
+	news, err := a.dxped.News(a.ctx)
+	if err != nil {
+		applog.Printf("dxped: dx-world fetch: %v", err)
+		if len(news) == 0 {
+			return nil, err
+		}
+	}
+	return news, nil
+}
+
+// RefreshDXpeditions drops both caches so the next read goes to the network.
+// Wired to the tab's refresh button: an operator who has just read of a landing
+// on a cluster should not wait out the cache to see it here.
+func (a *App) RefreshDXpeditions() {
+	if a.dxped == nil {
+		a.dxped = dxped.New()
+	}
+	a.dxped.Invalidate()
+}

app_secret.go

@@ -25,6 +25,7 @@ var sensitiveSettingKeys = map[string]bool{
 	keyExtLoTWKeyPassword: true,
 	keyExtLoTWWebPassword: true,
 	keyExtHRDLogCode:      true,
+	keyExtHamqthPassword:  true,
 	keyExtEQSLPassword:    true,
 	keyExtCloudlogAPIKey:  true,
 	// The web-publish config is one JSON blob and the FTP password lives inside

app_watchlist.go

@@ -55,7 +55,11 @@ func (a *App) WatchlistAdd(callsign string, contest bool) error {
 	if a.watchlist == nil {
 		return fmt.Errorf("watchlist not initialized")
 	}
-	return a.watchlist.Add(callsign, contest)
+	if err := a.watchlist.Add(callsign, contest); err != nil {
+		return err
+	}
+	a.notifyWatchlist(callsign, true)
+	return nil
 }
 
 // WatchlistRemove deletes an entry.
@@ -63,7 +67,27 @@ func (a *App) WatchlistRemove(callsign string) error {
 	if a.watchlist == nil {
 		return fmt.Errorf("watchlist not initialized")
 	}
-	return a.watchlist.Remove(callsign)
+	if err := a.watchlist.Remove(callsign); err != nil {
+		return err
+	}
+	a.notifyWatchlist(callsign, false)
+	return nil
+}
+
+// notifyWatchlist announces a membership change to the UI.
+//
+// Emitted from the BINDINGS rather than from the watchlist panel, because a
+// call can now be added from three places (the panel, the cluster's menu, the
+// DXpeditions tab) and an operator who added one from the cluster saw nothing
+// at all — the confirmation lived inside a panel they were not looking at.
+func (a *App) notifyWatchlist(callsign string, added bool) {
+	if a.ctx == nil {
+		return
+	}
+	wruntime.EventsEmit(a.ctx, "watchlist:changed", map[string]any{
+		"call":  strings.ToUpper(strings.TrimSpace(callsign)),
+		"added": added,
+	})
 }
 
 // WatchlistSetNotify arms the existing alert path (sound + toast) for an entry.

changelog.json

@@ -1,16 +1,80 @@
 [
+  {
+    "version": "0.27.6",
+    "date": "",
+    "en": [
+      "Switching the settings database no longer shows “OpsLog is already running”: the automatic relaunch now waits for the closing instance to release its lock instead of racing it.",
+      "HamQTH upload: 8th external service — real-time QSO upload to the HamQTH online logbook with your callbook credentials (auto-upload on log, “Send to…” right-click, QSL Manager backlog upload, connection test).",
+      "Fixed: the right-click “Send to HAMLOG.online” was uploading the selection to QRZ.com with the QRZ key — it now goes to HAMLOG.online.",
+      "LoTW: TQSL no longer refuses non-US stations over MY_CNTY — the field is stripped before signing unless it is the US “XX,County” shape LoTW actually validates (a Canadian “ONTARIO,Kawartha” was rejecting the whole record). Exports also stop gluing a full state name onto the county.",
+      "DX Cluster: two new chase switches — Chase US counties and Chase new prefixes — and unchecking Chase new grids now also withdraws the NEW GRID badge. Each switch removes its badge from the spots AND its chip from the status filters, like Chase POTA always did.",
+      "Confirmations: a HamQTH row — sent only, defaulting to R (to upload), since HamQTH publishes no confirmations to receive. Setting such a default no longer disables the auto-upload it was meant to arm (it also affected HAMLOG.online).",
+      "New DXpeditions tab (Tools): the announced operations from NG3K’s ADXO next to the DX-World news feed. Every announcement is judged against YOUR log and carries one badge — NEW DXCC, NEW BAND, NEW SLOT… — with an “only what I need” filter, and one click adds its callsigns to the watchlist. The news headlines carry the same Watch button, over the callsigns mined out of their titles.",
+      "Watchlist: adding or removing a callsign now raises the same kind of notification as a new version, instead of a message inside the watchlist page — a call can be added from the cluster or the DXpeditions tab, where that message was never seen.",
+      "QSO editor, QSL Info: a HamQTH channel and its row in the status table — sent only, the received column showing a dash since the site publishes no confirmations.",
+      "QSO editor, QSL Info: the confirmation channels are listed paper QSL and LoTW first — the two that carry an ARRL award — then alphabetically, in both the picker and the status table.",
+      "Band map: a chevron in the footer folds the colour legend away and brings it back — four lines of a short screen, remembered between sessions.",
+      "Band map: ctrl+wheel no longer zooms it — that gesture is the window zoom everywhere else in OpsLog. The + and − buttons keep the zoom.",
+      "DX Cluster: the server pills drop the CONNECTED/DISCONNECTED word — the colour already said it — and clicking one now connects or disconnects that server on its own, without opening Settings. State, retries, address and last error moved into the tooltip."
+    ],
+    "fr": [
+      "Changer de base de réglages n’affiche plus « OpsLog is already running » : la relance automatique attend désormais que l’instance qui se ferme libère son verrou au lieu de la prendre de vitesse.",
+      "Upload HamQTH : 8e service externe — envoi des QSO en temps réel vers le logbook HamQTH avec vos identifiants du lookup (upload auto au log, « Envoyer vers… » au clic droit, rattrapage via le QSL Manager, test de connexion).",
+      "Corrigé : le clic droit « Envoyer vers HAMLOG.online » envoyait la sélection à QRZ.com avec la clé QRZ — elle part maintenant vers HAMLOG.online.",
+      "LoTW : TQSL ne refuse plus les stations hors US à cause de MY_CNTY — le champ est retiré avant signature sauf s’il a la forme US « XX,County » que LoTW valide réellement (un « ONTARIO,Kawartha » canadien rejetait tout l’enregistrement). L’export cesse aussi de coller un nom d’état complet devant le comté.",
+      "DX Cluster : deux nouvelles cases — Chasser les comtés US et Chasser les nouveaux préfixes — et décocher Chasser les nouveaux locators retire désormais aussi le badge NEW GRID. Chaque case enlève son badge des spots ET sa puce des filtres de statut, comme Chase POTA le faisait déjà.",
+      "Confirmations : une ligne HamQTH — envoi seulement, à R (à envoyer) par défaut, HamQTH ne publiant aucune confirmation à recevoir. Définir un tel défaut ne désactive plus l’upload automatique qu’il était censé armer (cela touchait aussi HAMLOG.online).",
+      "Nouvel onglet DXpéditions (Outils) : les opérations annoncées par l’ADXO de NG3K à côté du fil d’actualités DX-World. Chaque annonce est jugée sur VOTRE log et porte un badge — NOUVEAU DXCC, NOUVELLE BANDE, NOUVEAU SLOT… — avec un filtre « seulement ce qu’il me manque », et un clic ajoute ses indicatifs à la watchlist. Les actualités portent le même bouton Surveiller, sur les indicatifs extraits de leurs titres.",
+      "Watchlist : ajouter ou retirer un indicatif déclenche désormais une notification du même type que celle des nouvelles versions, au lieu d’un message dans la page watchlist — un indicatif peut être ajouté depuis le cluster ou l’onglet DXpéditions, où ce message n’était jamais vu.",
+      "Éditeur de QSO, onglet QSL : un canal HamQTH et sa ligne dans le tableau des statuts — envoi seulement, la colonne reçu affichant un tiret puisque le site ne publie aucune confirmation.",
+      "Éditeur de QSO, onglet QSL : les canaux de confirmation sont classés QSL papier puis LoTW — les deux qui comptent pour un diplôme ARRL — puis par ordre alphabétique, dans le sélecteur comme dans le tableau.",
+      "Band map : un chevron dans le pied de page replie la légende des couleurs et la fait revenir — quatre lignes gagnées sur un petit écran, mémorisé d’une session à l’autre.",
+      "Band map : ctrl+molette ne zoome plus la carte — ce geste est le zoom de la fenêtre partout ailleurs dans OpsLog. Les boutons + et − gardent le zoom.",
+      "DX Cluster : les pastilles de serveur perdent le mot CONNECTED/DISCONNECTED — la couleur le disait déjà — et cliquer sur l’une connecte ou déconnecte ce serveur seul, sans passer par les réglages. État, tentatives, adresse et dernière erreur passent dans l’infobulle."
+    ]
+  },
+  {
+    "version": "0.27.5",
+    "date": "",
+    "en": [
+      "QSL Manager: Club Log confirmations — downloads your log matches (getmatches API) and stamps two new columns, ClubLog match status and match date, available everywhere: table columns, filters, bulk edit and the QSO editor.",
+      "Super Check Partial: option to merge Club Log’s weekly call list (~180k calls heard on the air in the last 3 years) with MASTER.SCP.",
+      "Fixed: opening the app could silently stop at startup (settings showing as default, “db not initialized”) when a database migration targeted a table that database no longer holds — migrations now skip what does not apply, and a startup failure is written to the log.",
+      "FT Map / Grid squares: the map no longer floats above the menus and the Preferences dialog.",
+      "KPA500: saving ANY settings page no longer power-cycles the amplifier. A save rebuilt every amplifier connection, and closing the COM port drops DTR/RTS — the KPA500’s power switch. An unchanged amplifier now keeps its running connection across saves.",
+      "Column picker: columns are listed alphabetically inside each group.",
+      "Confirmations: a “Club Log received” default for new QSOs, set to No out of the box — the match download flips it to Y."
+    ],
+    "fr": [
+      "QSL Manager : confirmations Club Log — télécharge vos matches de log (API getmatches) et remplit deux nouvelles colonnes, statut et date de match ClubLog, disponibles partout : colonnes du tableau, filtres, édition groupée et éditeur de QSO.",
+      "Super Check Partial : option pour fusionner la liste hebdomadaire de Club Log (~180k indicatifs entendus sur l’air ces 3 dernières années) avec MASTER.SCP.",
+      "Corrigé : l’application pouvait se figer silencieusement au démarrage (réglages par défaut, « db not initialized ») quand une migration visait une table absente de cette base — les migrations ignorent désormais ce qui ne s’applique pas, et un échec de démarrage est écrit dans le log.",
+      "FT Map / Grid squares : la carte ne passe plus au-dessus des menus et de la fenêtre Préférences.",
+      "KPA500 : sauvegarder n’importe quelle page des réglages n’éteint plus l’ampli. Une sauvegarde reconstruisait chaque connexion d’ampli, et fermer le port COM relâche DTR/RTS — l’interrupteur d’alimentation du KPA500. Un ampli inchangé garde désormais sa connexion à travers les sauvegardes.",
+      "Sélecteur de colonnes : les colonnes sont triées alphabétiquement dans chaque groupe.",
+      "Confirmations : un défaut « Club Log reçu » pour les nouveaux QSO, à Non par défaut — le téléchargement des matches le passe à Y."
+    ]
+  },
   {
     "version": "0.27.4",
     "date": "",
     "en": [
       "FT decodes: a State column between the locator and the country — the two-letter badge plus the full name — for the WAS chasers.",
       "FT decodes: a NEW STATE badge and filter — a US state never worked lights up in the status column, and the filter chip shows only those. The WAS chase is complete.",
-      "The hunt goes global: a “Chase” setting (DX Cluster page) decides for EVERY category — DXCC, band, mode, slot, prefix, county, state, grid — whether “worked but never confirmed” still counts as something to chase, judged against the confirmation sources you pick (LoTW, QSL card, eQSL, QRZ.com). Such needs show as dimmed badges: a QSL to chase, not a QSO to make. The grid’s own Chase selector folds into it."
+      "The hunt goes global: a “Chase” setting (DX Cluster page) decides for EVERY category — DXCC, band, mode, slot, prefix, county, state, grid — whether “worked but never confirmed” still counts as something to chase, judged against the confirmation sources you pick (LoTW, QSL card, eQSL, QRZ.com). Such needs show as dimmed badges: a QSL to chase, not a QSO to make. The grid’s own Chase selector folds into it.",
+      "New FTx menu gathering FT Decodes, the new FT Map and the Grid squares map.",
+      "FT Map: a world map of the live FTx decodes — great-circle arcs from your QTH to every station heard in the last 30 minutes, coloured by band, with the PSK-Reporter palette and a basemap picker.",
+      "Maps: one single world (no more side-by-side copies), the surround follows the theme colour, and zooming stays centred — on the FT Map and the Grid squares map.",
+      "Watchlist: fixed columns in the spot rows, so band, mode and frequency line up instead of drifting with the country name."
     ],
     "fr": [
       "FT decodes : une colonne État entre le locator et le pays — le badge deux lettres plus le nom complet — pour les chasseurs de WAS.",
       "FT decodes : un badge et un filtre NOUVEL ÉTAT — un état US jamais contacté s’allume dans la colonne statut, et la puce de filtre ne montre que ceux-là. La chasse WAS est complète.",
-      "La chasse devient globale : un réglage « Chasse » (page DX Cluster) décide pour TOUTES les catégories — DXCC, bande, mode, slot, préfixe, comté, état, grille — si « contacté mais jamais confirmé » reste à chasser, jugé selon les sources de confirmation choisies (LoTW, carte QSL, eQSL, QRZ.com). Ces besoins s’affichent en badges atténués : une QSL à chasser, pas un QSO à faire. Le sélecteur Chasse des grilles fusionne dedans."
+      "La chasse devient globale : un réglage « Chasse » (page DX Cluster) décide pour TOUTES les catégories — DXCC, bande, mode, slot, préfixe, comté, état, grille — si « contacté mais jamais confirmé » reste à chasser, jugé selon les sources de confirmation choisies (LoTW, carte QSL, eQSL, QRZ.com). Ces besoins s’affichent en badges atténués : une QSL à chasser, pas un QSO à faire. Le sélecteur Chasse des grilles fusionne dedans.",
+      "Nouveau menu FTx regroupant FT Decodes, la nouvelle FT Map et la carte Grid squares.",
+      "FT Map : une carte du monde des décodages FTx en direct — arcs orthodromiques depuis votre QTH vers chaque station entendue dans les 30 dernières minutes, colorés par bande, avec la palette PSK Reporter et un choix de fond de carte.",
+      "Cartes : un seul monde (fini les copies côte à côte), le pourtour suit la couleur du thème et le zoom reste centré — sur la FT Map et la carte Grid squares.",
+      "Watchlist : colonnes fixes dans les lignes de spots — bande, mode et fréquence s'alignent au lieu de dériver avec le nom du pays."
     ]
   },
   {

extras_sent_test.go

@@ -0,0 +1,38 @@
+package main
+
+import (
+	"testing"
+
+	"hamlog/internal/qso"
+)
+
+// A Confirmations default of "R" means "I intend to upload this", not "it has
+// gone" — reading it as sent would silently disable the auto-upload the default
+// was set to arm. Only a real stamp blocks.
+func TestExtrasSaysSent(t *testing.T) {
+	pending := []string{"", "  ", "R", "r", "N", "Q", "I"}
+	for _, v := range pending {
+		if extrasSaysSent(v) {
+			t.Errorf("extrasSaysSent(%q) = true, want false (still to upload)", v)
+		}
+	}
+	sent := []string{"Y", "y", "20260831"} // "Y" today, a date in older builds
+	for _, v := range sent {
+		if !extrasSaysSent(v) {
+			t.Errorf("extrasSaysSent(%q) = false, want true (already uploaded)", v)
+		}
+	}
+}
+
+// The HamQTH default lands on the extras key the uploader reads, and must leave
+// the QSO eligible.
+func TestHamQTHDefaultStaysUploadable(t *testing.T) {
+	q := &qso.QSO{Callsign: "F4BPO"}
+	applyQSLDefaultsTo(q, defaultQSLDefaults())
+	if got := q.Extras[hamqthSentKey]; got != "R" {
+		t.Fatalf("HamQTH sent extra = %q, want %q", got, "R")
+	}
+	if extrasSaysSent(q.Extras[hamqthSentKey]) {
+		t.Error("a freshly logged QSO reads as already uploaded to HamQTH")
+	}
+}

frontend/src/App.tsx

@@ -1,7 +1,7 @@
 import { Fragment, useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import {
   Activity, AlertCircle, Antenna, Bell, Check, CheckCircle2, ChevronDown, Clock, CloudOff, Compass, Database, Ear, Eraser, Flame, Gauge, Hash, Loader2, Lock,
-  ChevronUp, Maximize2, Minimize2, Mic, MessageSquare, Pencil, Radar, Radio, RadioTower, RefreshCw, Satellite, Send, SatelliteDish, Settings, SlidersHorizontal, SpellCheck, Square, Terminal, Trash2, Unlock, X, Zap,
+  ChevronUp, Maximize2, Minimize2, Mic, MessageSquare, Pencil, Radar, Radio, RadioTower, RefreshCw, Satellite, Send, SatelliteDish, Settings, SlidersHorizontal, SpellCheck, Square, Star, Terminal, Trash2, Unlock, X, Zap,
 } from 'lucide-react';
 
 import {
@@ -27,7 +27,7 @@ import {
   GetTunerGeniusStatus, GetTunerGeniusSettings, TunerGeniusAutotune, TunerGeniusSetBypass, TunerGeniusSetOperate, TunerGeniusActivate,
   GetScpStatus, ScpLookup,
   OpenExternalURL,
-  ConnectAllClusters, DisconnectAllClusters, GetClusterStatus, SendClusterCommand,
+  ConnectAllClusters, DisconnectAllClusters, ConnectClusterServer, DisconnectClusterServer, GetClusterStatus, SendClusterCommand,
   ListClusterServers, ClusterSpotStatuses, SendClusterSpot,
   GetCATSettings, PTTHotkeyDown, PTTHotkeyUp,
   GetSolarData,
@@ -76,6 +76,7 @@ import { AutoEQSL } from '@/components/qsl/AutoEQSL';
 import { ConfirmDialog } from '@/components/ConfirmDialog';
 import { SettingsModal } from '@/components/SettingsModal';
 import { FTMapPanel } from '@/components/FTMapPanel';
+import { DXpeditionsPanel } from '@/components/DXpeditionsPanel';
 import { FirstRunModal } from '@/components/FirstRunModal';
 import { QSOEditModal } from '@/components/QSOEditModal';
 import { BandMap } from '@/components/BandMap';
@@ -100,7 +101,7 @@ 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, chasePota, readSpotDisplayOptions, spotIsWorked, SPOT_DISPLAY_OPTIONS_EXPOSED } from '@/lib/spotDisplay';
+import { applySpotDisplay, chaseCounty, chaseGrid, chasePfx, chasePota, readSpotDisplayOptions, spotIsWorked, SPOT_DISPLAY_OPTIONS_EXPOSED } from '@/lib/spotDisplay';
 import { AnswerDecode, HaltDecodeTx, LogUIError, FlexTXOnBand, GetMatrixColors, GetRotorPresets, GetRowColors, GetSpotTTLMinutes, GetSpotMax, IsNewUSCounty } from '../wailsjs/go/main/App';
 import { applyMatrixColors } from '@/lib/matrixColors';
 import { WorkedBeforeGrid } from '@/components/WorkedBeforeGrid';
@@ -1315,6 +1316,17 @@ export default function App() {
     setActiveTab((t) => (t === 'grids' ? 'recent' : t));
   }
   const [ftmapTabOpen, setFtmapTabOpen] = useState(() => localStorage.getItem('opslog.ftmapTab') === '1');
+  const [dxpedTabOpen, setDxpedTabOpen] = useState(() => localStorage.getItem('opslog.dxpedTab') === '1');
+  function openDxpedTab() {
+    setDxpedTabOpen(true);
+    writeUiPref('opslog.dxpedTab', '1');
+    setActiveTab('dxped');
+  }
+  function closeDxpedTab() {
+    setDxpedTabOpen(false);
+    writeUiPref('opslog.dxpedTab', '0');
+    setActiveTab((t) => (t === 'dxped' ? 'recent' : t));
+  }
   function openFtmapTab() {
     setFtmapTabOpen(true);
     writeUiPref('opslog.ftmapTab', '1');
@@ -2346,6 +2358,18 @@ export default function App() {
   }, [showSettings]);
   const [showDuplicates, setShowDuplicates] = useState(false);
   const [updateInfo, setUpdateInfo] = useState<{ latest: string; url: string; downloadUrl: string } | null>(null);
+  // Watchlist membership changes announce themselves here rather than inside
+  // the watchlist panel: a call can be added from the cluster or the
+  // DXpeditions tab, and the old inline message lived on a page nobody was
+  // looking at.
+  const [wlNotice, setWlNotice] = useState<{ call: string; added: boolean } | null>(null);
+  const wlNoticeTimer = useRef<number | undefined>(undefined);
+  useEffect(() => EventsOn('watchlist:changed', (e: any) => {
+    if (!e?.call) return;
+    setWlNotice({ call: String(e.call), added: !!e.added });
+    if (wlNoticeTimer.current) window.clearTimeout(wlNoticeTimer.current);
+    wlNoticeTimer.current = window.setTimeout(() => setWlNotice(null), 4000);
+  }), []);
   const [checkingUpdate, setCheckingUpdate] = useState(false);
   // Fresh update check on demand (opening About), so it never shows a stale
   // "you're up to date". Clears updateInfo when the latest check finds nothing.
@@ -5126,6 +5150,7 @@ export default function App() {
     ]},
     { name: 'tools', label: t('menu.tools'), items: [
       { type: 'item', label: t('tools.qslManager'), action: 'tools.qslmanager' },
+      { type: 'item', label: t('dxp.tab'), action: 'tools.dxped' },
       { type: 'item', label: t('stats.tab'), action: 'tools.stats' },
       { type: 'item', label: t('station.title'), action: 'tools.station' },
       { type: 'item', label: t('tools.qslDesigner'), action: 'tools.qsldesigner' },
@@ -5180,6 +5205,7 @@ export default function App() {
       case 'tools.qslmanager':  setQslTabOpen(true); setActiveTab('qsl'); break;
       case 'tools.stats':       setStatsTabOpen(true); setActiveTab('stats'); break;
       case 'tools.station':     setStationTabOpen(true); setActiveTab('station'); break;
+      case 'tools.dxped':       openDxpedTab(); break;
       case 'tools.decodes':     openDecodesTab(); break;
       case 'tools.ftmap':       openFtmapTab(); break;
       case 'tools.grids':       openGridsTab(); break;
@@ -6261,7 +6287,10 @@ export default function App() {
               // worked spots; the separate "Hide worked" checkbox drops them — they
               // are opposite controls, so don't use both at once.
               { k: 'worked'   as SpotFilterKey, label: 'WORKED',   cls: 'bg-info-muted text-info-muted-foreground border-info-border' },
-            ]).filter((s: any) => s.k !== 'new-pota' || chasePota())
+            ]).filter((s: any) => (s.k !== 'new-pota' || chasePota())
+              && (s.k !== 'new-county' || chaseCounty())
+              && (s.k !== 'new-pfx' || chasePfx())
+              && (s.k !== 'new-grid' || chaseGrid()))
               .map((s: any) => fChip(s.k, s.label, s.cls, clusterStatusFilter.has(s.k),
               () => setClusterStatusFilter((cur) => { const n = new Set(cur); if (n.has(s.k)) n.delete(s.k); else n.add(s.k); return n; }), s.style))}
           </div>,
@@ -7073,6 +7102,26 @@ export default function App() {
         <FirstRunModal onDone={() => { setShowFirstRun(false); loadStation(); refresh(); }} />
       )}
 
+      {wlNotice && (
+        <div className={cn('fixed right-4 z-[150] w-72 rounded-lg border bg-card shadow-xl p-3 animate-in slide-in-from-bottom-2 fade-in',
+          wlNotice.added ? 'border-warning/40' : 'border-border',
+          // Stacked above the update card when both are up.
+          updateInfo ? 'bottom-44' : 'bottom-4')}>
+          <div className="flex items-start gap-2">
+            <Star className={cn('size-4 mt-0.5 shrink-0', wlNotice.added ? 'fill-current text-warning' : 'text-muted-foreground')} />
+            <div className="min-w-0 flex-1">
+              <p className="text-sm font-semibold">
+                {t(wlNotice.added ? 'wlnote.added' : 'wlnote.removed', { call: wlNotice.call })}
+              </p>
+              <p className="text-xs text-muted-foreground">{t('wlnote.hint')}</p>
+            </div>
+            <button onClick={() => setWlNotice(null)}
+              className="shrink-0 text-muted-foreground hover:text-foreground" aria-label="Close">
+              <X className="size-3.5" />
+            </button>
+          </div>
+        </div>
+      )}
       {updateInfo && (
         <div className="fixed bottom-4 right-4 z-[150] w-80 rounded-lg border border-primary/40 bg-card shadow-xl p-3 animate-in slide-in-from-bottom-2 fade-in">
           <div className="flex items-start gap-2">
@@ -7813,6 +7862,21 @@ export default function App() {
                   </span>
                 </TabsTrigger>
               )}
+              {dxpedTabOpen && (
+                <TabsTrigger value="dxped" className="gap-1.5">
+                  {t('dxp.tab')}
+                  <span
+                    role="button"
+                    aria-label="Close DXpeditions"
+                    title="Close"
+                    className="inline-flex items-center justify-center size-4 rounded hover:bg-foreground/10 text-muted-foreground hover:text-foreground"
+                    onPointerDown={(e) => { e.stopPropagation(); }}
+                    onClick={(e) => { e.stopPropagation(); closeDxpedTab(); }}
+                  >
+                    <X className="size-3" />
+                  </span>
+                </TabsTrigger>
+              )}
               {ftmapTabOpen && (
                 <TabsTrigger value="ftmap" className="gap-1.5">
                   {t('ftmap.tab')}
@@ -8069,22 +8133,37 @@ export default function App() {
                   const isMaster = clusterServers
                     .filter((x) => x.enabled)
                     .sort((a, b) => a.sort_order - b.sort_order)[0]?.id === s.server_id;
+                  // The colour already says the state, so the word beside it was
+                  // saying it twice — and the pills are the only place a single
+                  // cluster can be reached without opening Settings. Clicking one
+                  // now drops or reopens that session; everything the word used
+                  // to carry (state, retries, last error, address) moves into the
+                  // tooltip, where it costs no width.
+                  const up = s.state === 'connected';
+                  const busy = s.state === 'connecting' || s.state === 'reconnecting';
                   return (
-                    <span
+                    <button
                       key={s.server_id}
+                      type="button"
+                      onClick={async () => {
+                        try {
+                          if (up || busy) await DisconnectClusterServer(s.server_id);
+                          else await ConnectClusterServer(s.server_id);
+                        } catch (e: any) { setError(String(e?.message ?? e)); }
+                        await reloadClusterMeta();
+                      }}
                       className={cn(
-                        'inline-flex items-center gap-1 px-2 py-0.5 rounded-full text-[10px] font-semibold border',
+                        'inline-flex items-center gap-1 px-2 py-0.5 rounded-full text-[10px] font-semibold border transition-opacity hover:opacity-80',
                         s.state === 'connected' ? 'bg-success-muted text-success-muted-foreground border-success-border' :
-                        s.state === 'connecting' || s.state === 'reconnecting' ? 'bg-warning-muted text-warning-muted-foreground border-warning-border' :
+                        busy ? 'bg-warning-muted text-warning-muted-foreground border-warning-border' :
                         s.state === 'error' ? 'bg-danger-muted text-danger-muted-foreground border-danger-border' :
                         'bg-muted text-muted-foreground border-border',
                       )}
-                      title={`${s.host}:${s.port}${s.error ? ' — ' + s.error : ''}`}
+                      title={`${s.name} — ${s.state.toUpperCase()}${s.retries ? ` #${s.retries}` : ''} · ${s.host}:${s.port}${s.error ? ' — ' + s.error : ''}\n${up || busy ? t('clu.pillDisconnect') : t('clu.pillConnect')}`}
                     >
                       {isMaster && <span className="text-warning" title="Master (commands go here)">★</span>}
                       {s.name}
-                      <span className="opacity-60 text-[9px] ml-0.5">{s.state.toUpperCase()}{s.retries ? ` #${s.retries}` : ''}</span>
+                    </button>
-                    </span>
                   );
                 })}
                 <div className="flex-1" />
@@ -8426,6 +8505,15 @@ export default function App() {
               </TabsContent>
             )}
 
+            {dxpedTabOpen && (
+              <TabsContent value="dxped" className="mt-0 flex flex-col min-h-0 flex-1 data-[state=inactive]:hidden">
+                {activeTab === 'dxped' && (
+                  <div className="h-full w-full min-h-0 p-1">
+                    <DXpeditionsPanel />
+                  </div>
+                )}
+              </TabsContent>
+            )}
             {ftmapTabOpen && (
               <TabsContent value="ftmap" className="mt-0 flex flex-col min-h-0 flex-1 data-[state=inactive]:hidden">
                 {activeTab === 'ftmap' && (

frontend/src/components/BandMap.tsx

@@ -1,5 +1,5 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import { Minus, Plus, Crosshair, X, PanelLeft, PanelRight } from 'lucide-react';
+import { Minus, Plus, Crosshair, X, PanelLeft, PanelRight, ChevronDown, ChevronUp } from 'lucide-react';
 import { cn } from '@/lib/utils';
 import { useI18n } from '@/lib/i18n';
 import { bandRange, bandSegments, subscribeIaruRegion, type SegMode } from '@/lib/bandplan';
@@ -283,6 +283,17 @@ export function BandMap({ band, spots, spotStatus: spotStatusRaw, currentFreqHz,
   const range = bandRange(band);
   const segments = bandSegments(band).map(([a, b, m]) => [a, b, SEG_COLOR[m]] as [number, number, string]);
   const [zoomIdx, setZoomIdx] = useState(() => readZoom(band));
+  // The legend is a reference, not a running display: once its colours are
+  // learnt it is four lines of a short screen spent saying nothing new. Folded
+  // away by a toggle, and the choice is remembered.
+  const [legendOpen, setLegendOpen] = useState(() => {
+    try { return localStorage.getItem('opslog.bmpLegend') !== '0'; } catch { return true; }
+  });
+  const toggleLegend = () => setLegendOpen((v) => {
+    const next = !v;
+    try { localStorage.setItem('opslog.bmpLegend', next ? '1' : '0'); } catch { /* private mode */ }
+    return next;
+  });
   // The docked map follows the rig, so a band change must bring up THAT band's
   // remembered zoom.
   useEffect(() => { setZoomIdx(readZoom(band)); }, [band]);
@@ -460,19 +471,10 @@ export function BandMap({ band, spots, spotStatus: spotStatusRaw, currentFreqHz,
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [band, containerH, currentFreqHz, range, lo, hi, pxPerKHz, fitToBand]);
 
-  useEffect(() => {
+  // No ctrl+wheel zoom here any more: ctrl+wheel is the WINDOW zoom everywhere
-    const el = scrollerRef.current;
+  // else in OpsLog (View ▸ Zoom in/out), and one gesture that resizes the whole
-    if (!el) return;
+  // app over one panel and one band map over another is a gesture nobody can
-    const onWheel = (e: WheelEvent) => {
+  // trust. The + / − buttons keep the zoom, deliberately and visibly.
-      if (!range) return;
-      if (e.ctrlKey || e.metaKey) {
-        e.preventDefault();
-        changeZoom(e.deltaY > 0 ? -1 : 1);
-      }
-    };
-    el.addEventListener('wheel', onWheel, { passive: false });
-    return () => el.removeEventListener('wheel', onWheel);
-  }, [range]);
 
   // Ctrl+↑ / Ctrl+↓ hop to the next spot above / below the rig frequency and tune
   // to it. Higher freq is UP on the map (see freqToY), so ↑ = next higher spot.
@@ -753,6 +755,7 @@ export function BandMap({ band, spots, spotStatus: spotStatusRaw, currentFreqHz,
         </div>
       </div>
       {/* Colour legend — what each pill colour means. */}
+      {legendOpen && (
       <div className="px-3 py-1 flex flex-wrap items-center gap-x-2.5 gap-y-0.5 text-[9px] text-muted-foreground bg-muted/20 border-t border-border">
         <LegendDot cls="bg-danger" label={t('bmp.legendNewDxcc')} />
         <LegendDot cls="bg-warning" label={t('bmp.legendNewBand')} />
@@ -769,9 +772,18 @@ export function BandMap({ band, spots, spotStatus: spotStatusRaw, currentFreqHz,
         <LegendDot colour={SEG_COLOR.digi} label={t("bmp.legendData")} />
         <LegendDot colour={SEG_COLOR.phone} label={t("bmp.legendPhone")} />
       </div>
-      <div className="px-3 py-1 text-[9px] text-muted-foreground bg-muted/30 border-t border-border font-mono text-center shrink-0">
+      )}
-        {t('bmp.footerHint')}
+      <div className="px-3 py-1 flex items-center gap-2 text-[9px] text-muted-foreground bg-muted/30 border-t border-border font-mono shrink-0">
-        {hidden > 0 && <span className="text-warning"> · {t('bmp.spotsHidden', { n: hidden, max: MAX_VISIBLE_SPOTS })}</span>}
+        <span className="flex-1 text-center">
+          {t('bmp.footerHint')}
+          {hidden > 0 && <span className="text-warning"> · {t('bmp.spotsHidden', { n: hidden, max: MAX_VISIBLE_SPOTS })}</span>}
+        </span>
+        <button type="button" onClick={toggleLegend}
+          title={legendOpen ? t('bmp.legendHide') : t('bmp.legendShow')}
+          aria-label={legendOpen ? t('bmp.legendHide') : t('bmp.legendShow')}
+          className="shrink-0 inline-flex items-center gap-0.5 rounded px-1 py-px hover:bg-muted hover:text-foreground">
+          {legendOpen ? <ChevronDown className="size-3" /> : <ChevronUp className="size-3" />}
+        </button>
       </div>
     </div>
   );

frontend/src/components/BulkEditModal.tsx

@@ -46,6 +46,8 @@ const FIELDS: FieldDef[] = [
   { id: 'qrz_rcvd_date',     label: 'bulk.fQrzRcvdDate',     group: 'QSL / upload', kind: 'date' },
   { id: 'clublog_sent',      label: 'bulk.fClublogSent',     group: 'QSL / upload', kind: 'status' },
   { id: 'clublog_sent_date', label: 'bulk.fClublogSentDate', group: 'QSL / upload', kind: 'date' },
+  { id: 'clublog_rcvd',      label: 'bulk.fClublogRcvd',     group: 'QSL / upload', kind: 'status' },
+  { id: 'clublog_rcvd_date', label: 'bulk.fClublogRcvdDate', group: 'QSL / upload', kind: 'date' },
   { id: 'hrdlog_sent',       label: 'bulk.fHrdlogSent',      group: 'QSL / upload', kind: 'status' },
   { id: 'hrdlog_sent_date',  label: 'bulk.fHrdlogSentDate',  group: 'QSL / upload', kind: 'date' },
   // HAMLOG.online: no promoted column, written into extras_json (see

frontend/src/components/DXpeditionsPanel.tsx

@@ -0,0 +1,240 @@
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { RefreshCw, Star, ExternalLink } from 'lucide-react';
+import { GetDXpeditions, GetDXWorldNews, RefreshDXpeditions, WatchlistEntries, WatchlistAdd } from '../../wailsjs/go/main/App';
+import { BrowserOpenURL, EventsOn } from '../../wailsjs/runtime/runtime';
+import { Button } from '@/components/ui/button';
+import { cn } from '@/lib/utils';
+import { useI18n } from '@/lib/i18n';
+
+// DXpeditions — the two feeds the DX world announces itself on, side by side.
+//
+// Left: NG3K's ADXO, the structured announcements, each judged against THIS log
+// so the list reads as "what I still need" rather than "what is on". Right:
+// DX-World's headlines, whose callsigns are mined out of the title so they can
+// be watched with the same one click.
+
+type DXped = {
+  dxcc: string; callsign: string; calls?: string[];
+  start_date: string; end_date: string;
+  bands?: string[]; modes?: string[];
+  qsl: string; operators: string; source: string; link: string;
+  status: string;          // active | upcoming
+  status_chase: string;    // new | new-band-mode | new-band | new-mode | new-slot | worked | ''
+  unconfirmed?: boolean;
+};
+
+type News = {
+  title: string; link: string; pub_date: string; excerpt: string;
+  creator: string; image_url: string; tag: string; calls?: string[];
+};
+
+// One badge per expedition, the strongest verdict winning — the same palette
+// and the same words the cluster uses, so the two views teach one vocabulary.
+const CHASE_BADGE: Record<string, { label: string; colour: string }> = {
+  'new':           { label: 'clg2.newDxcc',     colour: 'var(--danger)' },
+  'new-band-mode': { label: 'clg2.newBandMode', colour: 'var(--danger)' },
+  'new-band':      { label: 'clg2.newBand',     colour: 'var(--warning)' },
+  'new-mode':      { label: 'clg2.newMode',     colour: 'var(--caution)' },
+  'new-slot':      { label: 'clg2.newSlot',     colour: '#5AC8FA' },
+  'worked':        { label: 'wl.worked',        colour: 'var(--info)' },
+};
+
+export function DXpeditionsPanel() {
+  const { t } = useI18n();
+  const [peds, setPeds] = useState<DXped[]>([]);
+  const [news, setNews] = useState<News[]>([]);
+  const [watched, setWatched] = useState<Set<string>>(new Set());
+  const [busy, setBusy] = useState(false);
+  const [err, setErr] = useState('');
+  const [neededOnly, setNeededOnly] = useState(() => localStorage.getItem('opslog.dxpedNeeded') === '1');
+
+  const loadWatchlist = useCallback(async () => {
+    try {
+      const e: any[] = await WatchlistEntries();
+      setWatched(new Set((e ?? []).map((x) => String(x.callsign ?? '').toUpperCase())));
+    } catch { /* the list simply shows every call as unwatched */ }
+  }, []);
+
+  const load = useCallback(async () => {
+    setBusy(true);
+    setErr('');
+    const [p, n] = await Promise.allSettled([GetDXpeditions(), GetDXWorldNews()]);
+    if (p.status === 'fulfilled') setPeds((p.value as any) ?? []);
+    else setErr(String((p.reason as any)?.message ?? p.reason));
+    if (n.status === 'fulfilled') setNews((n.value as any) ?? []);
+    setBusy(false);
+  }, []);
+
+  useEffect(() => { void load(); void loadWatchlist(); }, [load, loadWatchlist]);
+  useEffect(() => EventsOn('watchlist:changed', () => { void loadWatchlist(); }), [loadWatchlist]);
+
+  const refresh = async () => { await RefreshDXpeditions(); await load(); };
+
+  const addAll = async (calls: string[]) => {
+    for (const c of calls) {
+      if (!watched.has(c.toUpperCase())) {
+        try { await WatchlistAdd(c, false); } catch { /* reported by the notice */ }
+      }
+    }
+    await loadWatchlist();
+  };
+
+  const shown = useMemo(
+    () => (neededOnly ? peds.filter((p) => p.status_chase && p.status_chase !== 'worked') : peds),
+    [peds, neededOnly]);
+
+  // A row's calls: the mined ones, else whatever the announcement called it.
+  const callsOf = (p: DXped) => (p.calls?.length ? p.calls : p.callsign ? [p.callsign] : []);
+
+  return (
+    <div className="flex h-full min-h-0 gap-3">
+      {/* ── Announcements (ADXO) ── */}
+      <section className="flex flex-col min-h-0 flex-[3] rounded-lg border border-border bg-card overflow-hidden">
+        <header className="flex items-center gap-2 px-3 py-2 border-b border-border shrink-0">
+          <span className="text-sm font-semibold">{t('dxp.announced')}</span>
+          <span className="text-[11px] text-muted-foreground">{t('dxp.source', { name: 'NG3K ADXO' })}</span>
+          <label className="ml-auto flex items-center gap-1.5 text-[11px] cursor-pointer text-muted-foreground hover:text-foreground">
+            <input type="checkbox" checked={neededOnly}
+              onChange={(e) => { setNeededOnly(e.target.checked); localStorage.setItem('opslog.dxpedNeeded', e.target.checked ? '1' : '0'); }} />
+            {t('dxp.neededOnly')}
+          </label>
+          <Button variant="outline" size="sm" onClick={refresh} disabled={busy}>
+            <RefreshCw className={cn('size-3.5', busy && 'animate-spin')} /> {t('dxp.refresh')}
+          </Button>
+        </header>
+
+        {err && <div className="px-3 py-2 text-xs text-danger shrink-0">{err}</div>}
+
+        <div className="flex-1 min-h-0 overflow-y-auto p-2 space-y-1.5">
+          {shown.length === 0 && !busy && (
+            <p className="text-xs text-muted-foreground text-center py-6">{t('dxp.none')}</p>
+          )}
+          {shown.map((p, i) => {
+            const calls = callsOf(p);
+            const badge = CHASE_BADGE[p.status_chase];
+            const allWatched = calls.length > 0 && calls.every((c) => watched.has(c.toUpperCase()));
+            return (
+              <article key={`${p.callsign}-${p.start_date}-${i}`}
+                className={cn('rounded-md border p-2 text-xs',
+                  p.status === 'active' ? 'border-success/40 bg-success/5' : 'border-border bg-muted/20')}>
+                <div className="flex items-center gap-2 flex-wrap">
+                  <span className="font-mono font-bold text-sm text-info">{p.callsign || '—'}</span>
+                  <span className="font-medium">{p.dxcc}</span>
+                  {p.status === 'active' && (
+                    <span className="px-1 py-px rounded text-[10px] font-bold uppercase bg-success-muted text-success-muted-foreground">
+                      {t('dxp.onAir')}
+                    </span>
+                  )}
+                  {badge && (
+                    <span className="px-1 py-px rounded text-[10px] font-bold uppercase tracking-wide border"
+                      title={p.unconfirmed ? t('dec.unconfTip') : undefined}
+                      style={p.unconfirmed
+                        ? { color: badge.colour, borderColor: badge.colour, borderStyle: 'dashed', opacity: 0.6 }
+                        : { color: badge.colour, borderColor: badge.colour }}>
+                      {t(badge.label)}
+                    </span>
+                  )}
+                  <span className="ml-auto text-[11px] text-muted-foreground whitespace-nowrap">
+                    {p.start_date} → {p.end_date}
+                  </span>
+                </div>
+
+                <div className="mt-1 flex items-center gap-2 flex-wrap text-[11px] text-muted-foreground">
+                  {!!p.bands?.length && <span>{p.bands.join(' · ')}</span>}
+                  {!!p.modes?.length && <span className="text-foreground/70">{p.modes.join(' ')}</span>}
+                  {p.qsl && <span>QSL: {p.qsl}</span>}
+                  {p.source && <span>· {p.source}</span>}
+                </div>
+                {p.operators && <p className="mt-0.5 text-[11px] text-muted-foreground truncate">{p.operators}</p>}
+
+                <div className="mt-1.5 flex items-center gap-2">
+                  <Button variant={allWatched ? 'ghost' : 'outline'} size="sm" className="h-6 text-[11px]"
+                    disabled={calls.length === 0 || allWatched}
+                    onClick={() => addAll(calls)}
+                    title={t('dxp.watchTip')}>
+                    <Star className={cn('size-3', allWatched && 'fill-current text-warning')} />
+                    {allWatched ? t('dxp.watched') : t('dxp.watch')}
+                  </Button>
+                  {p.link && (
+                    <button type="button" onClick={() => BrowserOpenURL(p.link)}
+                      className="text-[11px] text-muted-foreground hover:text-foreground inline-flex items-center gap-1">
+                      <ExternalLink className="size-3" /> {t('dxp.open')}
+                    </button>
+                  )}
+                </div>
+              </article>
+            );
+          })}
+        </div>
+      </section>
+
+      {/* ── News (DX-World) ── */}
+      <section className="flex flex-col min-h-0 flex-[2] rounded-lg border border-border bg-card overflow-hidden">
+        <header className="flex items-center gap-2 px-3 py-2 border-b border-border shrink-0">
+          <span className="text-sm font-semibold">{t('dxp.news')}</span>
+          <span className="text-[11px] text-muted-foreground">{t('dxp.source', { name: 'DX-World' })}</span>
+        </header>
+        <div className="flex-1 min-h-0 overflow-y-auto p-2 space-y-1.5">
+          {news.length === 0 && !busy && (
+            <p className="text-xs text-muted-foreground text-center py-6">{t('dxp.noNews')}</p>
+          )}
+          {news.map((n, i) => {
+            const newsCalls = n.calls ?? [];
+            const newsAllWatched = newsCalls.length > 0 && newsCalls.every((c) => watched.has(c.toUpperCase()));
+            return (
+            <article key={`${n.link}-${i}`} className="rounded-md border border-border bg-muted/20 p-2">
+              <div className="flex items-start gap-2">
+                {n.image_url && (
+                  <img src={n.image_url} alt="" className="size-12 rounded object-cover shrink-0"
+                    onError={(e) => { (e.currentTarget as HTMLImageElement).style.display = 'none'; }} />
+                )}
+                <div className="min-w-0 flex-1">
+                  <div className="flex items-center gap-1.5 flex-wrap">
+                    {n.tag && (
+                      <span className="px-1 py-px rounded text-[9px] font-bold uppercase bg-primary/15 text-primary">{n.tag}</span>
+                    )}
+                    <button type="button" onClick={() => n.link && BrowserOpenURL(n.link)}
+                      className="text-xs font-medium text-left hover:underline">{n.title}</button>
+                  </div>
+                  <p className="mt-0.5 text-[11px] text-muted-foreground line-clamp-3">{n.excerpt}</p>
+                  {/* The callsigns are shown, not clicked: watching is the same
+                      one button as an announcement, so the gesture is learned
+                      once for the whole tab. */}
+                  <div className="mt-1 flex items-center gap-1.5 flex-wrap">
+                    {n.pub_date && (
+                      <span className="text-[10px] text-muted-foreground">
+                        {new Date(n.pub_date).toLocaleDateString()}
+                      </span>
+                    )}
+                    {(n.calls ?? []).map((c) => (
+                      <span key={c} className={cn('font-mono text-[10px]',
+                        watched.has(c.toUpperCase()) ? 'text-warning' : 'text-info')}>
+                        {c}
+                      </span>
+                    ))}
+                  </div>
+                  <div className="mt-1.5 flex items-center gap-2">
+                    <Button variant={newsAllWatched ? 'ghost' : 'outline'} size="sm" className="h-6 text-[11px]"
+                      disabled={newsCalls.length === 0 || newsAllWatched}
+                      onClick={() => addAll(newsCalls)}
+                      title={t('dxp.watchTip')}>
+                      <Star className={cn('size-3', newsAllWatched && 'fill-current text-warning')} />
+                      {newsAllWatched ? t('dxp.watched') : t('dxp.watch')}
+                    </Button>
+                    {n.link && (
+                      <button type="button" onClick={() => BrowserOpenURL(n.link)}
+                        className="text-[11px] text-muted-foreground hover:text-foreground inline-flex items-center gap-1">
+                        <ExternalLink className="size-3" /> {t('dxp.open')}
+                      </button>
+                    )}
+                  </div>
+                </div>
+              </div>
+            </article>
+            );
+          })}
+        </div>
+      </section>
+    </div>
+  );
+}

frontend/src/components/FTMapPanel.tsx

@@ -119,7 +119,10 @@ export function FTMapPanel({ decodes, myGrid }: { decodes: FTMapDecode[]; myGrid
 
   const bands = [...new Set(decodes.map((d) => (d.band ?? '').toLowerCase()).filter(Boolean))];
   return (
-    <div className="relative h-full w-full min-h-0">
+    // isolate: Leaflet stacks its panes and controls up to z-index 1000, which
+    // beat the app menus and the Settings dialog. A stacking context of our own
+    // keeps all of it inside this panel.
+    <div className="relative isolate z-0 h-full w-full min-h-0">
       <div ref={divRef} className="absolute inset-0 rounded-lg overflow-hidden" />
       {/* Basemap picker, MainMap's own vocabulary. */}
       <div className="absolute top-2 left-12 z-[1000] flex gap-1 rounded-md bg-background/85 backdrop-blur px-1 py-1 border border-border">

frontend/src/components/FilterBuilder.tsx

@@ -86,6 +86,8 @@ const FIELDS: { value: string; label: string; type: FieldType }[] = [
   { value: 'qrzcom_qso_download_date', label: 'fltb.fQrzRcvdDate', type: 'adifdate' },
   { value: 'clublog_qso_upload_status', label: 'fltb.fClublogSent', type: 'text' },
   { value: 'clublog_qso_upload_date', label: 'fltb.fClublogSentDate', type: 'adifdate' },
+  { value: 'clublog_qso_download_status', label: 'fltb.fClublogRcvd', type: 'text' },
+  { value: 'clublog_qso_download_date', label: 'fltb.fClublogRcvdDate', type: 'adifdate' },
   { value: 'hrdlog_qso_upload_status', label: 'fltb.fHrdlogSent', type: 'text' },
   { value: 'hrdlog_qso_upload_date', label: 'fltb.fHrdlogSentDate', type: 'adifdate' },
   // HAMLOG.online: no promoted column, filtered through extras_json (see

frontend/src/components/QSLManagerModal.tsx

@@ -42,6 +42,7 @@ const SERVICES = [
   { v: 'eqsl',    label: 'eQSL.cc' },
   { v: 'lotw',    label: 'LoTW' },
   { v: 'hamlog',  label: 'HAMLOG.online' },
+  { v: 'hamqth',  label: 'HamQTH' },
   { v: 'pota',    label: 'POTA hunter log' },
   { v: 'paper',   label: 'Paper QSL' },
 ];

frontend/src/components/QSOContextMenu.tsx

@@ -35,6 +35,7 @@ const UPLOAD_TARGETS: { service: string; name: string }[] = [
   { service: 'eqsl', name: 'eQSL.cc' },
   { service: 'lotw', name: 'LoTW' },
   { service: 'hamlog', name: 'HAMLOG.online' },
+  { service: 'hamqth', name: 'HamQTH' },
 ];
 
 // Lightweight right-click menu for the QSO grids. AG Grid's native context

frontend/src/components/QSOEditModal.tsx

@@ -71,7 +71,7 @@ const CONFIRMATIONS: ConfDef[] = [
   { 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 },
-  { key: 'CLUBLOG', label: 'Club Log',    sent: 'clublog_qso_upload_status' as any, sentDate: 'clublog_qso_upload_date' as any },
+  { key: 'CLUBLOG', label: 'Club Log',    sent: 'clublog_qso_upload_status' as any, sentDate: 'clublog_qso_upload_date' as any, rcvd: 'clublog_qso_download_status' as any, rcvdDate: 'clublog_qso_download_date' as any },
   { key: 'HRDLOG',  label: 'HRDLog',      sent: 'hrdlog_qso_upload_status' as any, sentDate: 'hrdlog_qso_upload_date' as any },
 ];
 // i18n label keys for confirmation channels whose label has translatable words
@@ -80,6 +80,19 @@ const CONF_LABEL_KEYS: Record<string, string> = {
   QSL: 'qedit.confQslPaper',
 };
 
+// Reading order for the channel list: the two that carry an ARRL award first —
+// paper QSL and LoTW — then everything else alphabetically, so a channel is
+// found by its name rather than by remembering the order it was added in.
+const CONF_FIRST: Record<string, number> = { QSL: 0, LOTW: 1 };
+function confOrder<T extends { key: string; label: string }>(rows: T[]): T[] {
+  return rows.slice().sort((a, b) => {
+    const ra = CONF_FIRST[a.key] ?? 2;
+    const rb = CONF_FIRST[b.key] ?? 2;
+    if (ra !== rb) return ra - rb;
+    return a.label.localeCompare(b.label);
+  });
+}
+
 // OpsLog's own card. Kept out of CONFIRMATIONS on purpose — that list maps QSO
 // columns and this channel is backed by ADIF extras — but it still belongs in
 // the channel picker and the status table alongside the rest.
@@ -98,6 +111,15 @@ const HAMLOG_KEYS = {
   rcvdDate: 'APP_OPSLOG_HAMLOG_QSL_DATE',
 };
 
+// HamQTH — extras again (ADIF names no HamQTH field), and SENT only: the site
+// publishes no confirmation feed, so a received column here would be a promise
+// nothing can keep.
+const HAMQTH_CONF = 'HAMQTH';
+const HAMQTH_KEYS = {
+  sent: 'APP_OPSLOG_HAMQTH_SENT',
+  sentDate: 'APP_OPSLOG_HAMQTH_SENT_DATE',
+};
+
 // Colour-coded status cell for the confirmation grid.
 function StatusCell({ value }: { value?: string }) {
   const { t } = useI18n();
@@ -747,19 +769,34 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
                         <Select value={confSel} onValueChange={setConfSel}>
                           <SelectTrigger><SelectValue /></SelectTrigger>
                           <SelectContent>
-                            {CONFIRMATIONS.map((c) => <SelectItem key={c.key} value={c.key}>{CONF_LABEL_KEYS[c.key] ? t(CONF_LABEL_KEYS[c.key]) : c.label}</SelectItem>)}
+                            {confOrder([
-                            {/* Listed here but NOT in CONFIRMATIONS: that table maps
+                              ...CONFIRMATIONS.map((c) => ({ key: c.key, label: CONF_LABEL_KEYS[c.key] ? t(CONF_LABEL_KEYS[c.key]) : c.label })),
+                              { key: OPSLOG_CONF, label: t('qedit.confOpsLog') },
+                              { key: HAMLOG_CONF, label: 'HAMLOG.online' },
+                              { key: HAMQTH_CONF, label: 'HamQTH' },
+                            ]).map((c) => <SelectItem key={c.key} value={c.key}>{c.label}</SelectItem>)}
+                            {/* The three above that are NOT in CONFIRMATIONS — the
                                 QSO columns, and this channel lives in the ADIF
-                                extras. It gets its own editor below rather than the
+                                OpsLog card, HAMLOG.online and HamQTH — are backed by
-                                generic sent/received/date grid, which has no field
+                                ADIF extras rather than QSO columns, and each gets its
-                                to bind to. */}
+                                own editor below instead of the generic
-                            <SelectItem value={OPSLOG_CONF}>{t('qedit.confOpsLog')}</SelectItem>
+                                sent/received/date grid, which has no field to bind
-                            <SelectItem value={HAMLOG_CONF}>HAMLOG.online</SelectItem>
+                                to. */}
                           </SelectContent>
                         </Select>
                       </div>
 
-                      {confSel === HAMLOG_CONF ? (
+                      {confSel === HAMQTH_CONF ? (
+                        <>
+                          <div className="grid grid-cols-2 gap-3">
+                            <div><Label>{t('qedit.sent')}</Label><QslSelect value={exVal(HAMQTH_KEYS.sent)} onChange={(v) => exPut(HAMQTH_KEYS.sent, v)} /></div>
+                            <div><Label>{t('qedit.dateSent')}</Label><AdifDateInput value={exVal(HAMQTH_KEYS.sentDate)} onChange={(v) => exPut(HAMQTH_KEYS.sentDate, v)} /></div>
+                          </div>
+                          <p className="text-[11px] text-muted-foreground">
+                            {t('qedit.qslPanelHint')} <strong>{t('qedit.saveChanges')}</strong>.
+                          </p>
+                        </>
+                      ) : confSel === HAMLOG_CONF ? (
                         <>
                           <div className="grid grid-cols-2 gap-3">
                             <div><Label>{t('qedit.sent')}</Label><QslSelect value={exVal(HAMLOG_KEYS.sent)} onChange={(v) => exPut(HAMLOG_KEYS.sent, v)} /></div>
@@ -845,30 +882,32 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
                           </tr>
                         </thead>
                         <tbody>
-                          {CONFIRMATIONS.map((c) => (
+                          {/* The extras-backed channels (OpsLog card,
+                              HAMLOG.online, HamQTH) sit in the same ordered list
+                              as the column-backed ones: the reader is looking for
+                              a name, not for a storage detail. A dash in RECEIVED
+                              means the channel has nothing to receive — Club Log
+                              and HamQTH publish no confirmations — which is not
+                              the same statement as "N". */}
+                          {confOrder([
+                            ...CONFIRMATIONS.map((c) => ({
+                              key: c.key,
+                              label: CONF_LABEL_KEYS[c.key] ? t(CONF_LABEL_KEYS[c.key]) : c.label,
+                              sent: val(c.sent),
+                              rcvd: c.rcvd ? val(c.rcvd) : null,
+                            })),
+                            { key: OPSLOG_CONF, label: t('qedit.confOpsLog'), sent: opslogQslSent ? 'Y' : 'N', rcvd: qslReceived ? 'Y' : 'N' },
+                            { key: HAMLOG_CONF, label: 'HAMLOG.online', sent: exVal(HAMLOG_KEYS.sent), rcvd: exVal(HAMLOG_KEYS.rcvd) },
+                            { key: HAMQTH_CONF, label: 'HamQTH', sent: exVal(HAMQTH_KEYS.sent), rcvd: null },
+                          ]).map((c) => (
                             <tr key={c.key} className="text-xs">
-                              <td className="font-medium pr-3 py-0.5 whitespace-nowrap">{CONF_LABEL_KEYS[c.key] ? t(CONF_LABEL_KEYS[c.key]) : c.label}</td>
+                              <td className="font-medium pr-3 py-0.5 whitespace-nowrap">{c.label}</td>
-                              <td className="w-24"><StatusCell value={val(c.sent)} /></td>
+                              <td className="w-24"><StatusCell value={c.sent} /></td>
-                              <td className="w-24">{c.rcvd ? <StatusCell value={val(c.rcvd)} /> : <span className="block text-center text-[11px] text-muted-foreground">—</span>}</td>
+                              <td className="w-24">{c.rcvd === null
+                                ? <span className="block text-center text-[11px] text-muted-foreground">—</span>
+                                : <StatusCell value={c.rcvd} />}</td>
                             </tr>
                           ))}
-                          {/* OpsLog's own card, read from the ADIF extras rather
-                              than a QSO column — hence a hand-written row instead
-                              of a CONFIRMATIONS entry. "Sent" is stamped by OpsLog
-                              when the card actually goes out, so it stays
-                              read-only here: an operator ticking it by hand would
-                              be recording something that never happened. */}
-                          <tr className="text-xs">
-                            <td className="font-medium pr-3 py-0.5 whitespace-nowrap">{t('qedit.confOpsLog')}</td>
-                            <td className="w-24"><StatusCell value={opslogQslSent ? 'Y' : 'N'} /></td>
-                            <td className="w-24"><StatusCell value={qslReceived ? 'Y' : 'N'} /></td>
-                          </tr>
-                          {/* HAMLOG.online — extras again, same hand-written row. */}
-                          <tr className="text-xs">
-                            <td className="font-medium pr-3 py-0.5 whitespace-nowrap">HAMLOG.online</td>
-                            <td className="w-24"><StatusCell value={exVal(HAMLOG_KEYS.sent)} /></td>
-                            <td className="w-24"><StatusCell value={exVal(HAMLOG_KEYS.rcvd)} /></td>
-                          </tr>
                         </tbody>
                       </table>
                     </div>

frontend/src/components/RecentQSOsGrid.tsx

@@ -235,6 +235,8 @@ export const makeColCatalog = (t: TFn, myGrid?: string): ColEntry[] => [
   { group: 'Uploads', label: t('rqg.c.qrz_rcvd'),      colId: 'qrzcom_qso_download_status', headerName: t('rqg.c.qrz_rcvd'),   field: 'qrzcom_qso_download_status' as any, width: 100 , cellClass: qslStatusCellClass },
   { group: 'Uploads', label: t('rqg.c.qrz_sent_date'), colId: 'qrzcom_qso_upload_date',     headerName: t('rqg.h.qrz_sent_date'), field: 'qrzcom_qso_upload_date' as any,     width: 120, valueFormatter: (p) => fmtDateOnly(p.value) },
   { group: 'Uploads', label: t('rqg.c.qrz_rcvd_date'), colId: 'qrzcom_qso_download_date',   headerName: t('rqg.h.qrz_rcvd_date'), field: 'qrzcom_qso_download_date' as any,   width: 120, valueFormatter: (p) => fmtDateOnly(p.value) },
+  { group: 'Uploads', label: t('rqg.c.clublog_rcvd'),      colId: 'clublog_qso_download_status', headerName: t('rqg.c.clublog_rcvd'),   field: 'clublog_qso_download_status' as any, width: 100 , cellClass: qslStatusCellClass },
+  { group: 'Uploads', label: t('rqg.c.clublog_rcvd_date'), colId: 'clublog_qso_download_date',   headerName: t('rqg.h.clublog_rcvd_date'), field: 'clublog_qso_download_date' as any,   width: 120, valueFormatter: (p) => fmtDateOnly(p.value) },
 
   // ── Contest ──
   { group: 'Contest', label: t('rqg.c.contest_id'),  colId: 'contest_id', headerName: t('rqg.h.contest_id'),     field: 'contest_id' as any, width: 110 },
@@ -784,7 +786,11 @@ export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal,
           </div>
           <div className="grid grid-cols-3 gap-4 max-h-[60vh] overflow-y-auto px-5 py-3">
             {GROUP_ORDER.map((group) => {
-              const cols = COL_CATALOG.filter((c) => c.group === group);
+              // Alphabetical within the group: the catalog's order is the
+              // GRID's column order, which appends newcomers at the end — so
+              // the two ClubLog rows sat at opposite ends of the Uploads box.
+              const cols = COL_CATALOG.filter((c) => c.group === group)
+                .slice().sort((a, b) => (a.label ?? '').localeCompare(b.label ?? ''));
               if (cols.length === 0) return null;
               return (
                 <div key={group} className="rounded-md border border-border p-2.5">

frontend/src/components/SettingsModal.tsx

@@ -45,11 +45,11 @@ import {
   SetCIVTrace,
   CIVTraceEnabled,
   WinkeyerTraceEnabled,
-  GetExternalServices, SaveExternalServices, TestQRZUpload, TestClublogUpload, TestHRDLogUpload, TestEQSLUpload, TestCloudlogUpload,
+  GetExternalServices, SaveExternalServices, TestHamQTHUpload, TestQRZUpload, TestClublogUpload, TestHRDLogUpload, TestEQSLUpload, TestCloudlogUpload,
   GetPOTAToken, SavePOTAToken,
   TestLoTWUpload, ListTQSLStationLocations,
   DownloadLoTWUsers, GetLoTWUsersStatus,
-  GetScpStatus, SetScpEnabled, DownloadScp,
+  GetScpStatus, SetScpEnabled, SetScpClublogEnabled, DownloadScp,
   DownloadULSCounties, ULSStatus, BackfillUSCounties, BackfillRDA, RDADatabaseCount,
   GetCtyDatInfo, RefreshCtyDat, GetAwardReferenceMeta, UpdateAwardReferenceList,
   GetSpotColors, SaveSpotColors, ResetSpotColors, GetFlexZoom, SaveFlexZoom,
@@ -1822,17 +1822,18 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
     qsl_sent: string; qsl_rcvd: string;
     lotw_sent: string; lotw_rcvd: string;
     eqsl_sent: string; eqsl_rcvd: string;
-    clublog_status: string; hrdlog_status: string; qrzcom_status: string;
+    clublog_status: string; clublog_confirmed: string; hrdlog_status: string; qrzcom_status: string;
     qrzcom_confirmed: string;
     hamlog_status: string; hamlog_confirmed: string;
+    hamqth_status: string;
   };
   const [qslDefaults, setQslDefaults] = useState<QSLDefaults>({
     qsl_sent: '', qsl_rcvd: '',
     lotw_sent: '', lotw_rcvd: '',
     eqsl_sent: '', eqsl_rcvd: '',
-    clublog_status: '', hrdlog_status: '', qrzcom_status: '',
+    clublog_status: '', clublog_confirmed: '', hrdlog_status: '', qrzcom_status: '',
     qrzcom_confirmed: '',
-    hamlog_status: '', hamlog_confirmed: '',
+    hamlog_status: '', hamlog_confirmed: '', hamqth_status: '',
   });
 
   // External services (logbook upload). One block per service; only QRZ is
@@ -1848,7 +1849,7 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
     // 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; hamlog: ExtServiceCfg; delete_remote?: boolean };
+  type ExternalServices = { qrz: ExtServiceCfg; clublog: ExtServiceCfg; lotw: ExtServiceCfg; hrdlog: ExtServiceCfg; eqsl: ExtServiceCfg; cloudlog: ExtServiceCfg; hamlog: ExtServiceCfg; hamqth: 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: '',
@@ -1856,7 +1857,7 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
     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(), hamlog: emptyExtCfg(), delete_remote: false,
+    qrz: emptyExtCfg(), clublog: emptyExtCfg(), lotw: emptyExtCfg(), hrdlog: emptyExtCfg(), eqsl: emptyExtCfg(), cloudlog: emptyExtCfg(), hamlog: emptyExtCfg(), hamqth: emptyExtCfg(), delete_remote: false,
   });
   const [qrzTest, setQrzTest] = useState<{ ok: boolean; msg: string } | null>(null);
   const [qrzTesting, setQrzTesting] = useState(false);
@@ -1884,6 +1885,7 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
     try { await SetScpEnabled(on); const s = await GetScpStatus(); setScp(s as any); } catch {}
     finally { setScpBusy(false); }
   };
+  const refreshScp = async () => { try { const s = await GetScpStatus(); setScp(s as any); } catch {} };
   const downloadScp = async () => {
     setScpBusy(true);
     try { await DownloadScp(); const s = await GetScpStatus(); setScp(s as any); } catch {}
@@ -2024,6 +2026,8 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
   const [cloudlogTesting, setCloudlogTesting] = useState(false);
   const [hamlogTest, setHamlogTest] = useState<{ ok: boolean; msg: string } | null>(null);
   const [hamlogTesting, setHamlogTesting] = useState(false);
+  const [hamqthTest, setHamqthTest] = useState<{ ok: boolean; msg: string } | null>(null);
+  const [hamqthTesting, setHamqthTesting] = useState(false);
   const [eqslTest, setEqslTest] = useState<{ ok: boolean; msg: string } | null>(null);
   const [eqslTesting, setEqslTesting] = useState(false);
   const [stationLocations, setStationLocations] = useState<string[]>([]);
@@ -2031,7 +2035,7 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
   // could not hold hooks at all; PanelHost lifted that restriction, and this
   // stays put because moving it down would reset the tab on every reopen —
   // a choice now, not a workaround.
-  const [extSvcTab, setExtSvcTab] = useState<'qrz' | 'clublog' | 'hrdlog' | 'eqsl' | 'lotw' | 'cloudlog' | 'hamlog' | 'pota'>('qrz');
+  const [extSvcTab, setExtSvcTab] = useState<'qrz' | 'clublog' | 'hrdlog' | 'eqsl' | 'lotw' | 'cloudlog' | 'hamlog' | 'hamqth' | 'pota'>('qrz');
   // POTA hunter-log sync (stamps pota_ref on local QSOs from your pota.app log).
   const [potaToken, setPotaToken] = useState('');
   const [potaBusy, setPotaBusy] = useState(false);
@@ -2075,6 +2079,8 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
   };
   const [chaseGrids, setChaseGrids] = useState(false);
   const [chasePotaOn, setChasePotaOn] = useState(() => localStorage.getItem('opslog.chasePota') !== '0');
+  const [chaseCountyOn, setChaseCountyOn] = useState(() => localStorage.getItem('opslog.chaseCounty') !== '0');
+  const [chasePfxOn, setChasePfxOn] = useState(() => localStorage.getItem('opslog.chasePfx') !== '0');
   const [chaseSotaOn, setChaseSotaOn] = useState(() => localStorage.getItem('opslog.chaseSota') !== '0');
   const [chaseNew, setChaseNew] = useState(false);
   const [spotTTL, setSpotTTL] = useState(0);
@@ -2096,7 +2102,13 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
   useEffect(() => {
     (async () => {
       try { setBandOpen(await GetBandOpenSettings()); } catch { /* defaults stand */ }
-      try { setChaseGrids(await GetChaseNewGrids()); } catch { /* defaults stand */ }
+      try {
+        const g = await GetChaseNewGrids();
+        setChaseGrids(g);
+        // Mirror for the display layer (spotDisplay.chaseGrid) — the cluster
+        // gates NEW GRID synchronously from localStorage.
+        writeUiPref('opslog.chaseGrids', g ? '1' : '0');
+      } catch { /* defaults stand */ }
       try { setChaseNew(await GetChaseNew()); } catch { /* defaults stand */ }
       try { setLinkedAmps((await GetLinkedAmps()) ?? []); } catch { /* defaults stand */ }
       try { const n = await GetSpotTTLMinutes(); setSpotTTL(n); setSpotTTLText(String(n)); } catch { /* defaults stand */ }
@@ -5465,9 +5477,19 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
                 onCheckedChange={(c) => { const v = !!c; setChaseSotaOn(v); writeUiPref('opslog.chaseSota', v ? '1' : '0'); }} />
               {t('clu.chaseSota')}
             </label>
+            <label className="flex items-center gap-2 text-sm cursor-pointer" title={t('clu.chaseCountyHint')}>
+              <Checkbox checked={chaseCountyOn}
+                onCheckedChange={(c) => { const v = !!c; setChaseCountyOn(v); writeUiPref('opslog.chaseCounty', v ? '1' : '0'); }} />
+              {t('clu.chaseCounty')}
+            </label>
+            <label className="flex items-center gap-2 text-sm cursor-pointer" title={t('clu.chasePfxHint')}>
+              <Checkbox checked={chasePfxOn}
+                onCheckedChange={(c) => { const v = !!c; setChasePfxOn(v); writeUiPref('opslog.chasePfx', v ? '1' : '0'); }} />
+              {t('clu.chasePfx')}
+            </label>
             <label className="flex items-start gap-2 text-sm cursor-pointer">
               <Checkbox checked={chaseGrids} className="mt-0.5"
-                onCheckedChange={(c) => { setChaseGrids(!!c); SetChaseNewGrids(!!c).catch(() => {}); }} />
+                onCheckedChange={(c) => { setChaseGrids(!!c); writeUiPref('opslog.chaseGrids', c ? '1' : '0'); SetChaseNewGrids(!!c).catch(() => {}); }} />
               <span>{t('clu.chaseGrids')} <span className="text-xs text-muted-foreground">{t('clu.chaseGridsHint')}</span></span>
             </label>
             {chaseGrids && (
@@ -5708,7 +5730,10 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
                 <Label className="text-[10px] text-muted-foreground uppercase tracking-wider mb-1 block">{t('conf.sent')}</Label>
                 {renderSelect('clublog_status', FULL_OPTIONS)}
               </div>
-              <div />
+              <div>
+                <Label className="text-[10px] text-muted-foreground uppercase tracking-wider mb-1 block">{t('conf.rcvd')}</Label>
+                {renderSelect('clublog_confirmed', FULL_OPTIONS)}
+              </div>
             </div>
             {/* HRDLog */}
             <div className="grid grid-cols-[150px_1fr_1fr] gap-3 items-end">
@@ -5731,6 +5756,15 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
                 {renderSelect('qrzcom_confirmed', FULL_OPTIONS)}
               </div>
             </div>
+            {/* HamQTH — no received side: the site has no confirmation feed. */}
+            <div className="grid grid-cols-[150px_1fr_1fr] gap-3 items-end">
+              <Label className="text-sm font-medium pb-1.5">HamQTH</Label>
+              <div>
+                <Label className="text-[10px] text-muted-foreground uppercase tracking-wider mb-1 block">{t('conf.sent')}</Label>
+                {renderSelect('hamqth_status', FULL_OPTIONS)}
+              </div>
+              <div />
+            </div>
             {/* HAMLOG.online */}
             <div className="grid grid-cols-[150px_1fr_1fr] gap-3 items-end">
               <Label className="text-sm font-medium pb-1.5">HAMLOG.online</Label>
@@ -5924,6 +5958,7 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
       { k: 'lotw',    label: 'LOTW', ready: true },
       { k: 'cloudlog', label: 'CLOUDLOG', ready: true },
       { k: 'hamlog',  label: 'HAMLOG.ONLINE', ready: true },
+      { k: 'hamqth',  label: 'HAMQTH', ready: true },
       { k: 'pota',    label: 'POTA', ready: true },
     ];
 
@@ -5993,6 +6028,21 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
       }
     }
 
+    const hamqth = extSvc.hamqth ?? emptyExtCfg();
+    const setHamqth = (patch: Partial<ExtServiceCfg>) =>
+      setExtSvc((s) => ({ ...s, hamqth: { ...(s.hamqth ?? emptyExtCfg()), ...patch } }));
+    async function testHamqth() {
+      setHamqthTesting(true);
+      setHamqthTest(null);
+      try {
+        const msg = await TestHamQTHUpload();
+        setHamqthTest({ ok: true, msg });
+      } catch (e: any) {
+        setHamqthTest({ ok: false, msg: String(e?.message ?? e) });
+      } finally {
+        setHamqthTesting(false);
+      }
+    }
     const hamlog = extSvc.hamlog ?? emptyExtCfg();
     const setHamlog = (patch: Partial<ExtServiceCfg>) =>
       setExtSvc((s) => ({ ...s, hamlog: { ...(s.hamlog ?? emptyExtCfg()), ...patch } }));
@@ -6372,6 +6422,43 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
               </div>
             </div>
           </div>
+        ) : extSvcTab === 'hamqth' ? (
+          <div className="space-y-4 max-w-2xl">
+            <div className="grid grid-cols-[170px_1fr] gap-3 items-center">
+              <Label className="text-sm">{t('es.username')}</Label>
+              <Input value={hamqth.username} onChange={(e) => setHamqth({ username: e.target.value })} className="text-xs w-64" />
+              <Label className="text-sm">{t('es.password')}</Label>
+              <Input type="password" value={hamqth.password} onChange={(e) => setHamqth({ password: e.target.value })} className="text-xs w-64" />
+              <Label className="text-sm">{t('es.hamqthCall')}</Label>
+              <Input value={hamqth.callsign} onChange={(e) => setHamqth({ callsign: e.target.value.toUpperCase() })} className="text-xs w-40 font-mono" placeholder={t('es.optional')} />
+            </div>
+            <div className="text-[10px] text-muted-foreground -mt-1">{t('es.hamqthHint')}</div>
+
+            <div className="border-t border-border/60 pt-3 space-y-3">
+              <label className="flex items-center gap-2 text-sm cursor-pointer">
+                <Checkbox checked={hamqth.auto_upload} onCheckedChange={(c) => setHamqth({ auto_upload: !!c })} />
+                {t('es.autoUpload')}
+              </label>
+              <div className="grid grid-cols-[170px_1fr] gap-3 items-center">
+                <Label className="text-sm">{t('es.uploadTiming')}</Label>
+                <Select value={hamqth.upload_mode === 'delayed' ? 'delayed' : 'immediate'} onValueChange={(v) => setHamqth({ upload_mode: v })}>
+                  <SelectTrigger className="h-8 w-64"><SelectValue /></SelectTrigger>
+                  <SelectContent>
+                    <SelectItem value="immediate">{t('es.immediate')}</SelectItem>
+                    <SelectItem value="delayed">{t('es.delayed')}</SelectItem>
+                  </SelectContent>
+                </Select>
+              </div>
+              <div className="flex items-center gap-3">
+                <Button variant="outline" size="sm" onClick={testHamqth} disabled={hamqthTesting}>
+                  <UploadCloud className="size-3.5" /> {hamqthTesting ? t('es.testing') : t('es.testConn')}
+                </Button>
+                {hamqthTest && (
+                  <span className={cn('text-xs', hamqthTest.ok ? 'text-success' : 'text-danger')}>{hamqthTest.msg}</span>
+                )}
+              </div>
+            </div>
+          </div>
         ) : extSvcTab === 'cloudlog' ? (
           <div className="space-y-4 max-w-2xl">
             <div className="grid grid-cols-[170px_1fr] gap-3 items-center">
@@ -7306,6 +7393,13 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
               <Checkbox checked={scp.enabled} disabled={scpBusy} onCheckedChange={(c) => toggleScp(!!c)} />
               {t('scp.enable')}
             </label>
+            {scp.enabled && (
+              <label className="flex items-center gap-2 text-sm cursor-pointer pl-6" title={t('scp.clublogHint')}>
+                <Checkbox checked={!!(scp as any).clublog} disabled={scpBusy}
+                  onCheckedChange={(c) => { void SetScpClublogEnabled(!!c).then(() => refreshScp()); }} />
+                {t('scp.clublog')}
+              </label>
+            )}
             {scp.enabled && (
               <div className="flex items-center gap-3">
                 <Button variant="outline" size="sm" onClick={downloadScp} disabled={scpBusy}>

frontend/src/components/WatchlistTab.tsx

@@ -181,7 +181,8 @@ export function WatchlistTab({ spots, spotStatus, onSpotSelect, onSpotClick }: P
     try {
       await WatchlistAdd(c, addContest);
       setAddCall('');
-      flash(t(addContest ? 'wl.addedContest' : 'wl.added', { call: c }), false);
+      // The confirmation is the app-level notice (App.tsx, on watchlist:changed)
+      // — saying it twice, once per place a call can be added from, was noise.
       await refresh();
     } catch (e: any) { flash(String(e?.message ?? e), true); }
   };
@@ -190,7 +191,7 @@ export function WatchlistTab({ spots, spotStatus, onSpotSelect, onSpotClick }: P
   // entry is cheap to undo (type it again), so it does not earn a confirmation
   // the other two buttons do not have.
   const remove = async (call: string) => {
-    try { await WatchlistRemove(call); flash(t('wl.removed', { call }), false); await refresh(); }
+    try { await WatchlistRemove(call); await refresh(); }
     catch (e: any) { flash(String(e?.message ?? e), true); }
   };
 

frontend/src/lib/spotDisplay.ts

@@ -20,6 +20,7 @@ export type SpotDisplayOptions = {
   // keep being computed; only the telling stops, so ticking the box back on
   // needs no rescan.
   chasePota: boolean; chaseSota: boolean;
+  chaseCounty: boolean; chasePfx: boolean; chaseGrid: boolean;
 };
 
 // chasePota/chaseSota read the switches directly — for the places that show a
@@ -30,6 +31,18 @@ export function chasePota(): boolean {
 export function chaseSota(): boolean {
   try { return localStorage.getItem('opslog.chaseSota') !== '0'; } catch { return true; }
 }
+export function chaseCounty(): boolean {
+  try { return localStorage.getItem('opslog.chaseCounty') !== '0'; } catch { return true; }
+}
+export function chasePfx(): boolean {
+  try { return localStorage.getItem('opslog.chasePfx') !== '0'; } catch { return true; }
+}
+// chaseGrid mirrors the backend "chase new grids" setting (Settings writes the
+// mirror on load and on toggle) so the display layer can gate NEW GRID without
+// an async round-trip per row.
+export function chaseGrid(): boolean {
+  try { return localStorage.getItem('opslog.chaseGrids') !== '0'; } catch { return true; }
+}
 
 // Both options are withdrawn from the filter panel for now. The machinery below
 // is deliberately kept whole — it is correct and hard-won — so putting the two
@@ -44,16 +57,17 @@ export function readSpotDisplayOptions(): SpotDisplayOptions {
   // The EXPOSED flag only withdraws the two original switches; the chase
   // switches are live regardless.
   if (!SPOT_DISPLAY_OPTIONS_EXPOSED) {
-    return { muteWorked: false, slotHighlight: false, chasePota: chasePota(), chaseSota: chaseSota() };
+    return { muteWorked: false, slotHighlight: false, chasePota: chasePota(), chaseSota: chaseSota(), chaseCounty: chaseCounty(), chasePfx: chasePfx(), chaseGrid: chaseGrid() };
   }
   try {
     return {
       muteWorked: localStorage.getItem('opslog.clusterMuteWorked') === '1',
       slotHighlight: localStorage.getItem('opslog.clusterSlotHighlight') === '1',
       chasePota: chasePota(), chaseSota: chaseSota(),
+      chaseCounty: chaseCounty(), chasePfx: chasePfx(), chaseGrid: chaseGrid(),
     };
   } catch {
-    return { muteWorked: false, slotHighlight: false, chasePota: true, chaseSota: true };
+    return { muteWorked: false, slotHighlight: false, chasePota: true, chaseSota: true, chaseCounty: true, chasePfx: true, chaseGrid: true };
   }
 }
 
@@ -98,6 +112,17 @@ export function applySpotDisplay<T extends Entry>(s: T, o: SpotDisplayOptions):
   if (!o.chasePota && e.new_pota) {
     e = { ...e, new_pota: false } as NonNullable<T>;
   }
+  // Same withdrawal for the other extra markers: the facts keep being
+  // computed, only the telling stops — re-ticking a box needs no rescan.
+  if (!o.chaseCounty && e.new_county) {
+    e = { ...e, new_county: false } as NonNullable<T>;
+  }
+  if (!o.chasePfx && e.new_pfx) {
+    e = { ...e, new_pfx: false } as NonNullable<T>;
+  }
+  if (!o.chaseGrid && e.new_grid) {
+    e = { ...e, new_grid: false } as NonNullable<T>;
+  }
   return e;
 }
 

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

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

@@ -12,6 +12,7 @@ import {award} from '../models';
 import {awardref} from '../models';
 import {bandopen} from '../models';
 import {cluster} from '../models';
+import {dxped} from '../models';
 import {extsvc} from '../models';
 import {powergenius} from '../models';
 import {pskr} from '../models';
@@ -476,6 +477,10 @@ export function GetDVKMessages():Promise<Array<main.DVKMessage>>;
 
 export function GetDVKStatus():Promise<main.DVKStatus>;
 
+export function GetDXWorldNews():Promise<Array<dxped.News>>;
+
+export function GetDXpeditions():Promise<Array<main.DXpedition>>;
+
 export function GetDataDir():Promise<string>;
 
 export function GetDatabaseSettings():Promise<main.DatabaseSettings>;
@@ -944,6 +949,8 @@ export function RecomputeAwardRefsForCode(arg1:string):Promise<number>;
 
 export function RefreshCtyDat():Promise<main.CtyDatInfo>;
 
+export function RefreshDXpeditions():Promise<void>;
+
 export function RefreshKenwood():Promise<void>;
 
 export function RefreshSolar():Promise<void>;
@@ -1202,6 +1209,8 @@ export function SetPSUOutput(arg1:boolean):Promise<void>;
 
 export function SetPassphrase(arg1:string):Promise<void>;
 
+export function SetScpClublogEnabled(arg1:boolean):Promise<void>;
+
 export function SetScpEnabled(arg1:boolean):Promise<void>;
 
 export function SetSpotMax(arg1:number):Promise<void>;
@@ -1332,6 +1341,8 @@ export function TestEmail(arg1:string):Promise<void>;
 
 export function TestHRDLogUpload():Promise<string>;
 
+export function TestHamQTHUpload():Promise<string>;
+
 export function TestLoTWUpload():Promise<string>;
 
 export function TestLookupProvider(arg1:string,arg2:string,arg3:string,arg4:string):Promise<lookup.Result>;

frontend/wailsjs/go/main/App.js

@@ -890,6 +890,14 @@ export function GetDVKStatus() {
   return window['go']['main']['App']['GetDVKStatus']();
 }
 
+export function GetDXWorldNews() {
+  return window['go']['main']['App']['GetDXWorldNews']();
+}
+
+export function GetDXpeditions() {
+  return window['go']['main']['App']['GetDXpeditions']();
+}
+
 export function GetDataDir() {
   return window['go']['main']['App']['GetDataDir']();
 }
@@ -1826,6 +1834,10 @@ export function RefreshCtyDat() {
   return window['go']['main']['App']['RefreshCtyDat']();
 }
 
+export function RefreshDXpeditions() {
+  return window['go']['main']['App']['RefreshDXpeditions']();
+}
+
 export function RefreshKenwood() {
   return window['go']['main']['App']['RefreshKenwood']();
 }
@@ -2342,6 +2354,10 @@ export function SetPassphrase(arg1) {
   return window['go']['main']['App']['SetPassphrase'](arg1);
 }
 
+export function SetScpClublogEnabled(arg1) {
+  return window['go']['main']['App']['SetScpClublogEnabled'](arg1);
+}
+
 export function SetScpEnabled(arg1) {
   return window['go']['main']['App']['SetScpEnabled'](arg1);
 }
@@ -2602,6 +2618,10 @@ export function TestHRDLogUpload() {
   return window['go']['main']['App']['TestHRDLogUpload']();
 }
 
+export function TestHamQTHUpload() {
+  return window['go']['main']['App']['TestHamQTHUpload']();
+}
+
 export function TestLoTWUpload() {
   return window['go']['main']['App']['TestLoTWUpload']();
 }

frontend/wailsjs/go/models.ts

@@ -1466,6 +1466,37 @@ export namespace contest {
 
 }
 
+export namespace dxped {
+	
+	export class News {
+	    title: string;
+	    link: string;
+	    pub_date: string;
+	    excerpt: string;
+	    creator: string;
+	    image_url: string;
+	    tag: string;
+	    calls: string[];
+	
+	    static createFrom(source: any = {}) {
+	        return new News(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.title = source["title"];
+	        this.link = source["link"];
+	        this.pub_date = source["pub_date"];
+	        this.excerpt = source["excerpt"];
+	        this.creator = source["creator"];
+	        this.image_url = source["image_url"];
+	        this.tag = source["tag"];
+	        this.calls = source["calls"];
+	    }
+	}
+
+}
+
 export namespace extsvc {
 	
 	export class ServiceConfig {
@@ -1522,6 +1553,7 @@ export namespace extsvc {
 	    eqsl: ServiceConfig;
 	    cloudlog: ServiceConfig;
 	    hamlog: ServiceConfig;
+	    hamqth: ServiceConfig;
 	    delete_remote: boolean;
 	
 	    static createFrom(source: any = {}) {
@@ -1537,6 +1569,7 @@ export namespace extsvc {
 	        this.eqsl = this.convertValues(source["eqsl"], ServiceConfig);
 	        this.cloudlog = this.convertValues(source["cloudlog"], ServiceConfig);
 	        this.hamlog = this.convertValues(source["hamlog"], ServiceConfig);
+	        this.hamqth = this.convertValues(source["hamqth"], ServiceConfig);
 	        this.delete_remote = source["delete_remote"];
 	    }
 	
@@ -2672,6 +2705,44 @@ export namespace main {
 	        this.rec_slot = source["rec_slot"];
 	    }
 	}
+	export class DXpedition {
+	    dxcc: string;
+	    callsign: string;
+	    calls: string[];
+	    start_date: string;
+	    end_date: string;
+	    bands: string[];
+	    modes: string[];
+	    qsl: string;
+	    operators: string;
+	    source: string;
+	    link: string;
+	    status: string;
+	    status_chase: string;
+	    unconfirmed: boolean;
+	
+	    static createFrom(source: any = {}) {
+	        return new DXpedition(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.dxcc = source["dxcc"];
+	        this.callsign = source["callsign"];
+	        this.calls = source["calls"];
+	        this.start_date = source["start_date"];
+	        this.end_date = source["end_date"];
+	        this.bands = source["bands"];
+	        this.modes = source["modes"];
+	        this.qsl = source["qsl"];
+	        this.operators = source["operators"];
+	        this.source = source["source"];
+	        this.link = source["link"];
+	        this.status = source["status"];
+	        this.status_chase = source["status_chase"];
+	        this.unconfirmed = source["unconfirmed"];
+	    }
+	}
 	export class DatabaseSettings {
 	    path: string;
 	    default_path: string;
@@ -3294,11 +3365,13 @@ export namespace main {
 	    eqsl_sent: string;
 	    eqsl_rcvd: string;
 	    clublog_status: string;
+	    clublog_confirmed: string;
 	    hrdlog_status: string;
 	    qrzcom_status: string;
 	    qrzcom_confirmed: string;
 	    hamlog_status: string;
 	    hamlog_confirmed: string;
+	    hamqth_status: string;
 	
 	    static createFrom(source: any = {}) {
 	        return new QSLDefaults(source);
@@ -3313,11 +3386,13 @@ export namespace main {
 	        this.eqsl_sent = source["eqsl_sent"];
 	        this.eqsl_rcvd = source["eqsl_rcvd"];
 	        this.clublog_status = source["clublog_status"];
+	        this.clublog_confirmed = source["clublog_confirmed"];
 	        this.hrdlog_status = source["hrdlog_status"];
 	        this.qrzcom_status = source["qrzcom_status"];
 	        this.qrzcom_confirmed = source["qrzcom_confirmed"];
 	        this.hamlog_status = source["hamlog_status"];
 	        this.hamlog_confirmed = source["hamlog_confirmed"];
+	        this.hamqth_status = source["hamqth_status"];
 	    }
 	}
 	export class QSLEmailTemplates {
@@ -3852,6 +3927,7 @@ export namespace main {
 	    enabled: boolean;
 	    count: number;
 	    updated?: string;
+	    clublog: boolean;
 	
 	    static createFrom(source: any = {}) {
 	        return new ScpStatus(source);
@@ -3862,6 +3938,7 @@ export namespace main {
 	        this.enabled = source["enabled"];
 	        this.count = source["count"];
 	        this.updated = source["updated"];
+	        this.clublog = source["clublog"];
 	    }
 	}
 	export class SecretStatus {
@@ -5269,6 +5346,8 @@ export namespace qso {
 	    qrzcom_qso_upload_status?: string;
 	    qrzcom_qso_download_date?: string;
 	    qrzcom_qso_download_status?: string;
+	    clublog_qso_download_date?: string;
+	    clublog_qso_download_status?: string;
 	    contest_id?: string;
 	    srx?: number;
 	    stx?: number;
@@ -5411,6 +5490,8 @@ export namespace qso {
 	        this.qrzcom_qso_upload_status = source["qrzcom_qso_upload_status"];
 	        this.qrzcom_qso_download_date = source["qrzcom_qso_download_date"];
 	        this.qrzcom_qso_download_status = source["qrzcom_qso_download_status"];
+	        this.clublog_qso_download_date = source["clublog_qso_download_date"];
+	        this.clublog_qso_download_status = source["clublog_qso_download_status"];
 	        this.contest_id = source["contest_id"];
 	        this.srx = source["srx"];
 	        this.stx = source["stx"];

internal/adif/export.go

@@ -267,6 +267,8 @@ func writeRecord(bw *bufio.Writer, q qso.QSO, includeApp bool, allow map[string]
 	w("QRZCOM_QSO_UPLOAD_STATUS", q.QRZComUploadStatus)
 	w("QRZCOM_QSO_DOWNLOAD_DATE", q.QRZComDownloadDate)
 	w("QRZCOM_QSO_DOWNLOAD_STATUS", q.QRZComDownloadStatus)
+	w("CLUBLOG_QSO_DOWNLOAD_DATE", q.ClublogDownloadDate)
+	w("CLUBLOG_QSO_DOWNLOAD_STATUS", q.ClublogDownloadStatus)
 
 	// --- Contest ---
 	w("CONTEST_ID", q.ContestID)
@@ -441,5 +443,11 @@ func adifCounty(state, county string) string {
 	if c == "" || s == "" || strings.Contains(c, ",") {
 		return c
 	}
+	// The "STATE,County" join is the ADIF secondary-subdivision format, and that
+	// enumeration is a US thing — a two-letter state code. Prefixing a Canadian
+	// "ONTARIO" produced "ONTARIO,Kawartha", which is valid nowhere.
+	if len(s) != 2 {
+		return c
+	}
 	return strings.ToUpper(s) + "," + c
 }

internal/adif/fields.go

@@ -161,6 +161,9 @@ var Fields = []FieldDef{
 	{Name: "QRZCOM_QSO_UPLOAD_STATUS", Kind: KindEnum, Category: "QSL", Promoted: true},
 	{Name: "QRZCOM_QSO_DOWNLOAD_DATE", Kind: KindDate, Category: "QSL", Promoted: true},
 	{Name: "QRZCOM_QSO_DOWNLOAD_STATUS", Kind: KindEnum, Category: "QSL", Promoted: true},
+	// App-defined pair (no standard ADIF field): Club Log's log-match download.
+	{Name: "CLUBLOG_QSO_DOWNLOAD_DATE", Kind: KindDate, Category: "QSL", Promoted: true},
+	{Name: "CLUBLOG_QSO_DOWNLOAD_STATUS", Kind: KindEnum, Category: "QSL", Promoted: true},
 	{Name: "HAMLOGEU_QSO_UPLOAD_DATE", Kind: KindDate, Category: "QSL"},
 	{Name: "HAMLOGEU_QSO_UPLOAD_STATUS", Kind: KindEnum, Category: "QSL"},
 	{Name: "HAMQTH_QSO_UPLOAD_DATE", Kind: KindDate, Category: "QSL"},

internal/adif/import.go

@@ -287,6 +287,7 @@ var adifPromoted = stringSet(
 	"hrdlog_qso_upload_date", "hrdlog_qso_upload_status",
 	"qrzcom_qso_upload_date", "qrzcom_qso_upload_status",
 	"qrzcom_qso_download_date", "qrzcom_qso_download_status",
+	"clublog_qso_download_date", "clublog_qso_download_status",
 	// Contest
 	"contest_id", "srx", "stx", "srx_string", "stx_string",
 	"check", "precedence", "arrl_sect",
@@ -493,6 +494,8 @@ func recordToQSO(rec Record) (qso.QSO, bool) {
 	q.QRZComUploadStatus = rec["qrzcom_qso_upload_status"]
 	q.QRZComDownloadDate = rec["qrzcom_qso_download_date"]
 	q.QRZComDownloadStatus = rec["qrzcom_qso_download_status"]
+	q.ClublogDownloadDate = rec["clublog_qso_download_date"]
+	q.ClublogDownloadStatus = rec["clublog_qso_download_status"]
 
 	// Contest
 	q.ContestID = rec["contest_id"]

internal/db/db.go

@@ -240,6 +240,25 @@ func backupBeforeRewrite(conn *sql.DB, dbPath, migration string) {
 	logf("db: backed up %d QSO(s) to %s in %s before %s", n, dest, time.Since(start).Round(time.Millisecond), migration)
 }
 
+// isIgnorableSQLiteDDLError reports a benign DDL failure: the change is
+// already there, or the statement shapes a table this database does not hold.
+// Scoped to shaping statements only — a CREATE TABLE or data statement that
+// fails must still fail the migration.
+func isIgnorableSQLiteDDLError(err error, stmt string) bool {
+	msg := strings.ToLower(err.Error())
+	if strings.Contains(msg, "duplicate column name") || strings.Contains(msg, "already exists") {
+		return true
+	}
+	if strings.Contains(msg, "no such table") {
+		head := strings.ToLower(strings.TrimSpace(stmt))
+		return strings.HasPrefix(head, "alter table") ||
+			strings.HasPrefix(head, "create index") ||
+			strings.HasPrefix(head, "create unique index") ||
+			strings.HasPrefix(head, "drop ")
+	}
+	return false
+}
+
 // migrate applies all embedded *.sql migrations in alphabetical order,
 // skipping those already applied. Intentionally minimal in-house system
 // (no external dependency). translate, when non-nil, rewrites each statement
@@ -352,6 +371,16 @@ func migrate(conn *sql.DB, translate func(string) string, dbPath, label string,
 				continue
 			}
 			if _, err := tx.Exec(stmt); err != nil {
+				// Same self-healing as the MySQL path, plus one case it never
+				// meets: a table-shaping statement aimed at a table this
+				// database legitimately does not have. A split settings
+				// database dropped its qso table when the QSOs moved to the
+				// logbook, but its role is still RoleAll — so a later
+				// "ALTER TABLE qso ADD COLUMN" must be a no-op there, not a
+				// failure that silently kills the whole startup (v0.27.4+).
+				if isIgnorableSQLiteDDLError(err, stmt) {
+					continue
+				}
 				_ = tx.Rollback()
 				return fmt.Errorf("apply migration %s: %w", name, err)
 			}

internal/db/migrations/0031_clublog_download.sql

@@ -0,0 +1,4 @@
+-- Club Log log-matching (getmatches.php): a QSO both sides uploaded to Club
+-- Log is a confirmation in its own right. Mirrors qrzcom_qso_download_*.
+ALTER TABLE qso ADD COLUMN clublog_qso_download_date   TEXT;
+ALTER TABLE qso ADD COLUMN clublog_qso_download_status TEXT;

internal/dxped/dxped.go

@@ -0,0 +1,546 @@
+// Package dxped reads the two feeds the DX world announces itself on.
+//
+// NG3K's ADXO is the STRUCTURED one: an RSS item per announced operation whose
+// description is a fixed, dash-separated sentence — dates, entity, callsign,
+// QSL route, source, then the operators/bands/modes prose. It is what a
+// DXpedition list is actually made of.
+//
+// DX-World's feed is NEWS: WordPress posts with a headline and an excerpt. It
+// carries no structure to act on, but the headline nearly always names the
+// callsign, so the calls are mined from the title and the reader can act on
+// them the same way (watchlist, chase status).
+//
+// Both are cached: the announcements change a few times a day, the news a few
+// times an hour, and neither is worth a request per screen repaint.
+package dxped
+
+import (
+	"context"
+	"encoding/xml"
+	"fmt"
+	"html"
+	"io"
+	"net/http"
+	"regexp"
+	"strings"
+	"sync"
+	"time"
+)
+
+const (
+	adxoURL    = "https://www.ng3k.com/adxo.xml"
+	dxworldURL = "https://dx-world.net/feed/"
+
+	adxoTTL    = 1 * time.Hour
+	dxworldTTL = 30 * time.Minute
+)
+
+// Activation is one announced operation, as ADXO describes it.
+type Activation struct {
+	DXCC      string   `json:"dxcc"`
+	Callsign  string   `json:"callsign"` // display form; "A, B" when several
+	Calls     []string `json:"calls"`    // the individual callsigns, normalised
+	StartDate string   `json:"start_date"`
+	EndDate   string   `json:"end_date"`
+	Bands     []string `json:"bands"`
+	Modes     []string `json:"modes"`
+	QSL       string   `json:"qsl"`
+	Operators string   `json:"operators"`
+	Source    string   `json:"source"`
+	Link      string   `json:"link"`
+	Status    string   `json:"status"` // "active" | "upcoming"
+}
+
+// News is one DX-World post.
+type News struct {
+	Title    string   `json:"title"`
+	Link     string   `json:"link"`
+	PubDate  string   `json:"pub_date"` // RFC3339, "" when unparseable
+	Excerpt  string   `json:"excerpt"`
+	Creator  string   `json:"creator"`
+	ImageURL string   `json:"image_url"`
+	Tag      string   `json:"tag"`   // NEWS / UPDATE / NEW ACTIVITY…
+	Calls    []string `json:"calls"` // callsigns mined from the headline
+}
+
+// Manager holds both caches and fetches on demand.
+type Manager struct {
+	mu       sync.RWMutex
+	acts     []Activation
+	actsAt   time.Time
+	news     []News
+	newsAt   time.Time
+	client   *http.Client
+	fetching sync.Mutex // one refresh at a time, whichever pane asked
+}
+
+func New() *Manager {
+	return &Manager{client: &http.Client{Timeout: 30 * time.Second}}
+}
+
+// Activations returns the cached announcements, refreshing when stale.
+func (m *Manager) Activations(ctx context.Context) ([]Activation, error) {
+	m.mu.RLock()
+	fresh := time.Since(m.actsAt) < adxoTTL && m.acts != nil
+	out := m.acts
+	m.mu.RUnlock()
+	if fresh {
+		return out, nil
+	}
+	m.fetching.Lock()
+	defer m.fetching.Unlock()
+	// Someone else may have refreshed while we waited for the lock.
+	m.mu.RLock()
+	fresh = time.Since(m.actsAt) < adxoTTL && m.acts != nil
+	out = m.acts
+	m.mu.RUnlock()
+	if fresh {
+		return out, nil
+	}
+	acts, err := m.fetchADXO(ctx)
+	if err != nil {
+		// Stale beats empty: a feed that is down should not blank a list the
+		// operator was reading a minute ago.
+		m.mu.RLock()
+		defer m.mu.RUnlock()
+		return m.acts, err
+	}
+	m.mu.Lock()
+	m.acts, m.actsAt = acts, time.Now()
+	m.mu.Unlock()
+	return acts, nil
+}
+
+// News returns the cached DX-World posts, refreshing when stale.
+func (m *Manager) News(ctx context.Context) ([]News, error) {
+	m.mu.RLock()
+	fresh := time.Since(m.newsAt) < dxworldTTL && m.news != nil
+	out := m.news
+	m.mu.RUnlock()
+	if fresh {
+		return out, nil
+	}
+	m.fetching.Lock()
+	defer m.fetching.Unlock()
+	m.mu.RLock()
+	fresh = time.Since(m.newsAt) < dxworldTTL && m.news != nil
+	out = m.news
+	m.mu.RUnlock()
+	if fresh {
+		return out, nil
+	}
+	news, err := m.fetchDXWorld(ctx)
+	if err != nil {
+		m.mu.RLock()
+		defer m.mu.RUnlock()
+		return m.news, err
+	}
+	m.mu.Lock()
+	m.news, m.newsAt = news, time.Now()
+	m.mu.Unlock()
+	return news, nil
+}
+
+// Invalidate drops both caches so the next read refetches.
+func (m *Manager) Invalidate() {
+	m.mu.Lock()
+	m.actsAt, m.newsAt = time.Time{}, time.Time{}
+	m.mu.Unlock()
+}
+
+func (m *Manager) get(ctx context.Context, url string) ([]byte, error) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("User-Agent", "OpsLog")
+	resp, err := m.client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("http %d", resp.StatusCode)
+	}
+	return io.ReadAll(io.LimitReader(resp.Body, 8<<20))
+}
+
+// ── ADXO ────────────────────────────────────────────────────────────────
+
+type rssItem struct {
+	Title       string `xml:"title"`
+	Description string `xml:"description"`
+	Link        string `xml:"link"`
+	PubDate     string `xml:"pubDate"`
+	Creator     string `xml:"creator"`
+	Enclosure   struct {
+		URL string `xml:"url,attr"`
+	} `xml:"enclosure"`
+	MediaContent struct {
+		URL string `xml:"url,attr"`
+	} `xml:"content"`
+}
+
+type rssFeed struct {
+	Items []rssItem `xml:"channel>item"`
+}
+
+func (m *Manager) fetchADXO(ctx context.Context) ([]Activation, error) {
+	body, err := m.get(ctx, adxoURL)
+	if err != nil {
+		return nil, fmt.Errorf("adxo: %w", err)
+	}
+	var feed rssFeed
+	if err := xml.Unmarshal(body, &feed); err != nil {
+		return nil, fmt.Errorf("adxo: parse: %w", err)
+	}
+	now := time.Now()
+	out := make([]Activation, 0, len(feed.Items))
+	for _, it := range feed.Items {
+		a := parseActivation(it.Description, it.Link)
+		if a == nil {
+			continue
+		}
+		a.Status = activationStatus(a.StartDate, a.EndDate, now)
+		if a.Status == "ended" {
+			continue // the list is about what is on or coming
+		}
+		out = append(out, *a)
+	}
+	return out, nil
+}
+
+var spaceRe = regexp.MustCompile(`\s+`)
+
+// parseActivation reads one ADXO description. Its shape is fixed and has been
+// for twenty years:
+//
+//	"Feb 17-Mar 30, 2026 -- Entity -- CALL -- QSL: route -- Source: who (date)
+//	 -- By ops; bands; modes; notes"
+func parseActivation(desc, link string) *Activation {
+	desc = spaceRe.ReplaceAllString(strings.NewReplacer("\n", " ", "\r", " ").Replace(desc), " ")
+	desc = strings.TrimSpace(html.UnescapeString(desc))
+	if desc == "" {
+		return nil
+	}
+	parts := strings.Split(desc, " -- ")
+	if len(parts) < 3 {
+		return nil
+	}
+	a := &Activation{Link: link}
+	a.StartDate, a.EndDate = parseDateRange(strings.TrimSpace(parts[0]))
+	a.DXCC = strings.TrimSpace(parts[1])
+	a.Callsign = strings.TrimSpace(parts[2])
+
+	for _, p := range parts[3:] {
+		p = strings.TrimSpace(p)
+		switch {
+		case strings.HasPrefix(p, "QSL:"):
+			a.QSL = strings.TrimSpace(strings.TrimPrefix(p, "QSL:"))
+		case strings.HasPrefix(p, "Source:"):
+			a.Source = strings.TrimSpace(strings.TrimPrefix(p, "Source:"))
+		}
+	}
+
+	// The tail carries "By <ops>; <bands>; <modes>; <notes>".
+	tail := parts[len(parts)-1]
+	if i := strings.Index(tail, "By "); i >= 0 {
+		sub := strings.Split(tail[i+3:], ";")
+		if len(sub) > 0 {
+			a.Operators = strings.TrimSpace(sub[0])
+		}
+		if len(sub) > 1 {
+			a.Bands = parseBands(sub[1])
+		}
+		if len(sub) > 2 {
+			a.Modes = parseModes(sub[2])
+		}
+	}
+
+	// The callsign field often holds only the PREFIX; the real calls hide in the
+	// operators prose as "W2APF as PJ2/W2APF". Prefer those when present.
+	if calls := callsAfterAs(a.Operators); len(calls) > 0 {
+		prefix := strings.ToUpper(strings.TrimSpace(parts[2]))
+		for i := range calls {
+			calls[i] = normalizeCall(calls[i], prefix)
+		}
+		a.Calls = calls
+		a.Callsign = strings.Join(calls, ", ")
+	} else if c := strings.ToUpper(a.Callsign); plausibleCall(c) {
+		a.Calls = []string{c}
+	}
+	return a
+}
+
+// parseDateRange handles the two forms ADXO writes: "Feb 17-Mar 30, 2026" and
+// "Mar 3-20, 2026" (the month carried over).
+var (
+	fullRangeRe  = regexp.MustCompile(`(?i)(\w+ \d+)\s*-\s*(\w+ \d+),\s*(\d{4})`)
+	shortRangeRe = regexp.MustCompile(`(?i)(\w+) (\d+)\s*-\s*(\d+),\s*(\d{4})`)
+	singleDayRe  = regexp.MustCompile(`(?i)(\w+ \d+),\s*(\d{4})`)
+)
+
+func parseDateRange(s string) (start, end string) {
+	if m := fullRangeRe.FindStringSubmatch(s); m != nil {
+		return m[1] + ", " + m[3], m[2] + ", " + m[3]
+	}
+	if m := shortRangeRe.FindStringSubmatch(s); m != nil {
+		return m[1] + " " + m[2] + ", " + m[4], m[1] + " " + m[3] + ", " + m[4]
+	}
+	if m := singleDayRe.FindStringSubmatch(s); m != nil {
+		return m[1] + ", " + m[2], m[1] + ", " + m[2]
+	}
+	return s, s
+}
+
+func parseADXODate(s string) (time.Time, bool) {
+	for _, layout := range []string{"Jan 2, 2006", "January 2, 2006"} {
+		if t, err := time.Parse(layout, strings.TrimSpace(s)); err == nil {
+			return t, true
+		}
+	}
+	return time.Time{}, false
+}
+
+func activationStatus(start, end string, now time.Time) string {
+	s, okS := parseADXODate(start)
+	e, okE := parseADXODate(end)
+	if !okS || !okE {
+		return "upcoming" // unreadable dates: keep it, an operator can read them
+	}
+	switch {
+	case now.Before(s):
+		return "upcoming"
+	// The end date is a DAY, so an operation is on until that day is over.
+	case now.After(e.Add(24 * time.Hour)):
+		return "ended"
+	default:
+		return "active"
+	}
+}
+
+// callsAfterAs mines "…as CALL…" out of the operators prose:
+//
+//	"W2APF as PJ2/W2APF"                  → PJ2/W2APF
+//	"SQ2RAD as VP2EAD, M0PLX as VP2ELX"   → VP2EAD, VP2ELX
+var asCallRe = regexp.MustCompile(`(?i)\bas\s+([A-Z0-9]+(?:/[A-Z0-9]+)*)`)
+
+func callsAfterAs(operators string) []string {
+	var out []string
+	seen := map[string]bool{}
+	for _, m := range asCallRe.FindAllStringSubmatch(operators, -1) {
+		c := strings.ToUpper(strings.TrimSpace(m[1]))
+		if !plausibleCall(c) || seen[c] {
+			continue
+		}
+		seen[c] = true
+		out = append(out, c)
+	}
+	return out
+}
+
+// normalizeCall puts the DXCC prefix first: a cluster spot says JD1/JG8NQJ, and
+// matching the log against JG8NQJ/JD1 would find nothing.
+func normalizeCall(call, dxccPrefix string) string {
+	if dxccPrefix == "" || !strings.Contains(call, "/") {
+		return call
+	}
+	left, right, _ := strings.Cut(call, "/")
+	if strings.HasPrefix(right, dxccPrefix) && !strings.HasPrefix(left, dxccPrefix) {
+		return right + "/" + left
+	}
+	return call
+}
+
+var (
+	// A span carries its unit only once — "160-6m" is the commonest way ADXO
+	// states coverage, and reading it as "6m" alone loses the whole low end.
+	bandRe = regexp.MustCompile(`(?i)\b(?:(\d{1,4})\s*-\s*)?(\d{1,4})\s*(m|cm)\b`)
+	// The modes ADXO actually writes. A list beats a pattern here: "FT8" and
+	// "SSB" have no shape in common, and inventing one invites "QSL" as a mode.
+	knownModes = []string{"SSB", "CW", "FT8", "FT4", "RTTY", "PSK", "SSTV", "AM", "FM", "JT65", "JS8", "Q65", "MSK144", "DIGI", "DATA"}
+)
+
+func parseBands(s string) []string {
+	var out []string
+	seen := map[string]bool{}
+	add := func(num, unit string) {
+		if num == "" {
+			return
+		}
+		b := strings.ToLower(num + unit)
+		if seen[b] {
+			return
+		}
+		seen[b] = true
+		out = append(out, b)
+	}
+	// A span keeps only its endpoints: ADXO states coverage in prose, and the
+	// two ends are the part it gives reliably.
+	for _, m := range bandRe.FindAllStringSubmatch(s, -1) {
+		add(m[1], m[3])
+		add(m[2], m[3])
+	}
+	return out
+}
+
+func parseModes(s string) []string {
+	up := strings.ToUpper(s)
+	var out []string
+	seen := map[string]bool{}
+	for _, mode := range knownModes {
+		if seen[mode] {
+			continue
+		}
+		if regexp.MustCompile(`\b` + mode + `\b`).MatchString(up) {
+			seen[mode] = true
+			out = append(out, mode)
+		}
+	}
+	return out
+}
+
+// ── DX-World ────────────────────────────────────────────────────────────
+
+var (
+	htmlTagRe   = regexp.MustCompile(`<[^>]+>`)
+	tagPrefixRe = regexp.MustCompile(`(?i)^\s*\[([^\]]+)\]\s*`)
+)
+
+func stripHTML(s string) string {
+	s = htmlTagRe.ReplaceAllString(s, " ")
+	s = html.UnescapeString(s)
+	return strings.TrimSpace(spaceRe.ReplaceAllString(s, " "))
+}
+
+func (m *Manager) fetchDXWorld(ctx context.Context) ([]News, error) {
+	body, err := m.get(ctx, dxworldURL)
+	if err != nil {
+		return nil, fmt.Errorf("dx-world: %w", err)
+	}
+	var feed rssFeed
+	if err := xml.Unmarshal(body, &feed); err != nil {
+		return nil, fmt.Errorf("dx-world: parse: %w", err)
+	}
+	out := make([]News, 0, len(feed.Items))
+	for _, it := range feed.Items {
+		title := stripHTML(it.Title)
+		tag, title := splitTag(title)
+		n := News{
+			Title:   title,
+			Link:    strings.TrimSpace(it.Link),
+			Creator: strings.TrimSpace(it.Creator),
+			Tag:     tag,
+			Calls:   callsInHeadline(title),
+		}
+		if t, err := time.Parse(time.RFC1123Z, strings.TrimSpace(it.PubDate)); err == nil {
+			n.PubDate = t.UTC().Format(time.RFC3339)
+		} else if t, err := time.Parse(time.RFC1123, strings.TrimSpace(it.PubDate)); err == nil {
+			n.PubDate = t.UTC().Format(time.RFC3339)
+		}
+		ex := stripHTML(it.Description)
+		if t2, rest := splitTag(ex); t2 != "" {
+			if n.Tag == "" {
+				n.Tag = t2
+			}
+			ex = rest
+		}
+		n.Excerpt = truncateRunes(ex, 400)
+		if u := strings.TrimSpace(it.Enclosure.URL); u != "" {
+			n.ImageURL = u
+		} else if u := strings.TrimSpace(it.MediaContent.URL); u != "" {
+			n.ImageURL = u
+		}
+		out = append(out, n)
+	}
+	return out, nil
+}
+
+// splitTag pulls the leading "[UPDATE]" DX-World puts on most posts.
+func splitTag(s string) (tag, rest string) {
+	m := tagPrefixRe.FindStringSubmatchIndex(s)
+	if m == nil {
+		return "", s
+	}
+	tag = strings.ToUpper(strings.TrimSpace(s[m[2]:m[3]]))
+	rest = strings.TrimSpace(s[m[1]:])
+	rest = strings.TrimPrefix(strings.TrimPrefix(rest, "– "), "- ")
+	return tag, strings.TrimSpace(rest)
+}
+
+func truncateRunes(s string, max int) string {
+	r := []rune(s)
+	if len(r) <= max {
+		return s
+	}
+	return strings.TrimSpace(string(r[:max])) + "…"
+}
+
+// callsInHeadline mines callsigns out of a news headline — "3B7M, St Brandon"
+// or "TX5S team lands". The reader can then chase or watch them, which is the
+// whole reason a news feed sits next to the announcements.
+func callsInHeadline(title string) []string {
+	var out []string
+	seen := map[string]bool{}
+	for _, tok := range strings.FieldsFunc(title, func(r rune) bool {
+		return !(r == '/' || (r >= '0' && r <= '9') || (r >= 'A' && r <= 'Z') || (r >= 'a' && r <= 'z'))
+	}) {
+		c := strings.ToUpper(tok)
+		if !plausibleCall(c) || seen[c] {
+			continue
+		}
+		seen[c] = true
+		out = append(out, c)
+	}
+	return out
+}
+
+var (
+	bandTokenRe = regexp.MustCompile(`^\d{1,4}(M|CM)$`)
+	// Jargon shaped exactly like a callsign. Every one of these was seen in a
+	// real headline before it earned its place here.
+	notACall = map[string]bool{
+		"FT8": true, "FT4": true, "JT65": true, "JT9": true, "JS8": true, "Q65": true,
+		"MSK144": true, "PSK31": true, "SSTV": true, "OQRS": true, "LOTW": true,
+		"IOTA": true, "SOTA": true, "POTA": true, "WWFF": true, "DXCC": true,
+		"CQWW": true, "CQWPX": true, "ARRL": true, "3D": true, "4K": true,
+	}
+)
+
+// plausibleCall keeps tokens shaped like an amateur callsign: 3–12 characters
+// of A–Z/0–9 (with optional /prefix or /suffix), at least one letter AND one
+// digit, and a letter somewhere after the first digit — which is what separates
+// a callsign from a band or a year.
+func plausibleCall(s string) bool {
+	s = strings.ToUpper(strings.TrimSpace(s))
+	if len(s) < 3 || len(s) > 12 || notACall[s] || bandTokenRe.MatchString(s) {
+		return false
+	}
+	// Judge the longest part — the real call in "PJ2/W2APF" either way.
+	base := s
+	if strings.Contains(s, "/") {
+		base = ""
+		for _, p := range strings.Split(s, "/") {
+			if len(p) > len(base) {
+				base = p
+			}
+		}
+	}
+	var hasLetter, hasDigit, letterAfterDigit bool
+	seenDigit := false
+	for _, r := range base {
+		switch {
+		case r >= 'A' && r <= 'Z':
+			hasLetter = true
+			if seenDigit {
+				letterAfterDigit = true
+			}
+		case r >= '0' && r <= '9':
+			hasDigit = true
+			seenDigit = true
+		default:
+			return false
+		}
+	}
+	return hasLetter && hasDigit && letterAfterDigit
+}

internal/dxped/dxped_test.go

@@ -0,0 +1,86 @@
+package dxped
+
+import (
+	"reflect"
+	"testing"
+	"time"
+)
+
+// Pinned against REAL feed text: the parser reads a fixed sentence, and a
+// wrong split silently empties a DXpedition list rather than failing loudly.
+func TestParseActivation(t *testing.T) {
+	desc := "Aug 24-31, 2026 -- St Kitts and Nevis -- V47JA -- QSL: LoTW -- " +
+		"Source: W5JON (Aug 1, 2026) -- By W5JON as V47JA fm Calypso Bay; 160-6m; SSB FT8; yagi, verticals"
+	a := parseActivation(desc, "https://www.qrz.com/lookup/v47ja")
+	if a == nil {
+		t.Fatal("parseActivation returned nil on a real ADXO description")
+	}
+	if a.DXCC != "St Kitts and Nevis" {
+		t.Errorf("DXCC = %q", a.DXCC)
+	}
+	if a.Callsign != "V47JA" {
+		t.Errorf("Callsign = %q, want V47JA (mined from 'as')", a.Callsign)
+	}
+	if a.QSL != "LoTW" {
+		t.Errorf("QSL = %q", a.QSL)
+	}
+	if a.StartDate != "Aug 24, 2026" || a.EndDate != "Aug 31, 2026" {
+		t.Errorf("dates = %q..%q", a.StartDate, a.EndDate)
+	}
+	if want := []string{"160m", "6m"}; !reflect.DeepEqual(a.Bands, want) {
+		t.Errorf("Bands = %v, want %v", a.Bands, want)
+	}
+	if want := []string{"SSB", "FT8"}; !reflect.DeepEqual(a.Modes, want) {
+		t.Errorf("Modes = %v, want %v", a.Modes, want)
+	}
+}
+
+// The callsign column often holds only the prefix; the operators prose holds
+// the real thing, and a slashed call must lead with the DXCC prefix or no spot
+// will ever match it.
+func TestCallsAfterAsAndNormalise(t *testing.T) {
+	if got := callsAfterAs("SQ2RAD as VP2EAD, M0PLX as VP2ELX"); !reflect.DeepEqual(got, []string{"VP2EAD", "VP2ELX"}) {
+		t.Errorf("callsAfterAs = %v", got)
+	}
+	if got := normalizeCall("JG8NQJ/JD1", "JD1"); got != "JD1/JG8NQJ" {
+		t.Errorf("normalizeCall = %q, want JD1/JG8NQJ", got)
+	}
+	if got := normalizeCall("PJ2/W2APF", "PJ2"); got != "PJ2/W2APF" {
+		t.Errorf("normalizeCall rewrote an already-correct call: %q", got)
+	}
+}
+
+func TestActivationStatus(t *testing.T) {
+	now := time.Date(2026, 8, 27, 12, 0, 0, 0, time.UTC)
+	cases := []struct{ start, end, want string }{
+		{"Aug 24, 2026", "Aug 31, 2026", "active"},
+		{"Sep 10, 2026", "Sep 20, 2026", "upcoming"},
+		{"Aug 1, 2026", "Aug 10, 2026", "ended"},
+		{"Aug 24, 2026", "Aug 27, 2026", "active"}, // ends TODAY: still on
+		{"garbage", "garbage", "upcoming"},
+	}
+	for _, c := range cases {
+		if got := activationStatus(c.start, c.end, now); got != c.want {
+			t.Errorf("activationStatus(%q,%q) = %q, want %q", c.start, c.end, got, c.want)
+		}
+	}
+}
+
+// Mining a headline must find calls without inventing them out of jargon.
+func TestCallsInHeadline(t *testing.T) {
+	cases := []struct {
+		title string
+		want  []string
+	}{
+		{"3B7M, St Brandon", []string{"3B7M"}},
+		{"TX5S team lands on Clipperton", []string{"TX5S"}},
+		{"FT8 activity on 160m in 2026", nil},
+		{"VP6D QSL via OQRS, LoTW", []string{"VP6D"}},
+		{"JD1/JG8NQJ from Minami Torishima", []string{"JD1/JG8NQJ"}},
+	}
+	for _, c := range cases {
+		if got := callsInHeadline(c.title); !reflect.DeepEqual(got, c.want) {
+			t.Errorf("callsInHeadline(%q) = %v, want %v", c.title, got, c.want)
+		}
+	}
+}

internal/extsvc/clublogmatches.go

@@ -0,0 +1,126 @@
+package extsvc
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// Club Log's log-matching API. A "match" is a QSO that BOTH stations uploaded
+// to Club Log, paired within ±15 minutes — Club Log's own equivalent of a LoTW
+// confirmation. getmatches.php returns a JSON array of 5-element arrays:
+//
+//	[["G0LGJ/M","223","2005-07-16 08:00:00","20","CW"], …]
+//	  callsign   dxcc   qso datetime (UTC)   band  mode ("false" when unknown)
+//
+// The optional start date filters on when Club Log COMPLETED the match (not
+// the QSO date), which is exactly what an incremental "since last download"
+// pull wants.
+const clublogMatchesURL = "https://clublog.org/getmatches.php"
+
+// ClublogMatch is one confirmed pairing from getmatches.php.
+type ClublogMatch struct {
+	Callsign string
+	DXCC     int
+	When     time.Time
+	Band     string // ADIF band ("20m", "70cm"); "" if the id is unknown
+	Mode     string // "" when Club Log doesn't know it
+}
+
+// clublogBandNames maps Club Log's numeric band ids to ADIF band names. The
+// ids are the wavelength number; the only trap is that ids past the metre
+// bands are centimetres (the docs' own example: 70 = 70CM).
+var clublogBandNames = map[string]string{
+	"2200": "2200m", "630": "630m", "160": "160m", "80": "80m", "60": "60m",
+	"40": "40m", "30": "30m", "20": "20m", "17": "17m", "15": "15m",
+	"12": "12m", "10": "10m", "8": "8m", "6": "6m", "5": "5m", "4": "4m",
+	"2": "2m", "70": "70cm", "23": "23cm", "13": "13cm", "9": "9cm", "3": "3cm",
+}
+
+// DownloadClublogMatches pulls the account's log matches for cfg.Callsign,
+// optionally only those Club Log completed since sinceDate ("2006-01-02").
+func DownloadClublogMatches(ctx context.Context, client *http.Client, cfg ServiceConfig, sinceDate string) ([]ClublogMatch, error) {
+	email := strings.TrimSpace(cfg.Email)
+	call := strings.ToUpper(strings.TrimSpace(cfg.Callsign))
+	switch {
+	case email == "":
+		return nil, fmt.Errorf("clublog: account email not set")
+	case cfg.Password == "":
+		return nil, fmt.Errorf("clublog: password not set")
+	case call == "":
+		return nil, fmt.Errorf("clublog: callsign not set")
+	}
+	v := url.Values{}
+	v.Set("api", clublogAppAPIKey)
+	v.Set("email", email)
+	v.Set("password", cfg.Password)
+	v.Set("callsign", call)
+	if t, err := time.Parse("2006-01-02", strings.TrimSpace(sinceDate)); err == nil {
+		v.Set("startyear", strconv.Itoa(t.Year()))
+		v.Set("startmonth", strconv.Itoa(int(t.Month())))
+		v.Set("startday", strconv.Itoa(t.Day()))
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, clublogMatchesURL+"?"+v.Encode(), nil)
+	if err != nil {
+		return nil, err
+	}
+	if client == nil {
+		client = &http.Client{Timeout: 120 * time.Second}
+	}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	body, _ := io.ReadAll(io.LimitReader(resp.Body, 64<<20))
+	text := strings.TrimSpace(string(body))
+	if resp.StatusCode != http.StatusOK {
+		if looksLikeHTML(text) || len(text) > 300 {
+			return nil, fmt.Errorf("clublog: HTTP %d", resp.StatusCode)
+		}
+		return nil, fmt.Errorf("clublog: HTTP %d: %s", resp.StatusCode, text)
+	}
+	if looksLikeHTML(text) {
+		return nil, fmt.Errorf("clublog: got a web page instead of matches — check email/password/callsign")
+	}
+	var raw [][]any
+	if err := json.Unmarshal([]byte(text), &raw); err != nil {
+		return nil, fmt.Errorf("clublog: bad matches JSON: %w", err)
+	}
+	str := func(x any) string {
+		switch t := x.(type) {
+		case string:
+			return t
+		case float64:
+			return strconv.FormatFloat(t, 'f', -1, 64)
+		default:
+			return ""
+		}
+	}
+	out := make([]ClublogMatch, 0, len(raw))
+	for _, rec := range raw {
+		if len(rec) < 5 {
+			continue
+		}
+		m := ClublogMatch{Callsign: strings.ToUpper(strings.TrimSpace(str(rec[0])))}
+		m.DXCC, _ = strconv.Atoi(str(rec[1]))
+		if t, err := time.Parse("2006-01-02 15:04:05", str(rec[2])); err == nil {
+			m.When = t.UTC()
+		}
+		m.Band = clublogBandNames[strings.TrimSpace(str(rec[3]))]
+		if md := strings.TrimSpace(str(rec[4])); md != "" && !strings.EqualFold(md, "false") {
+			m.Mode = strings.ToUpper(md)
+		}
+		if m.Callsign == "" || m.When.IsZero() {
+			continue
+		}
+		out = append(out, m)
+	}
+	return out, nil
+}

internal/extsvc/extsvc.go

@@ -38,6 +38,9 @@ const (
 	ServiceCloudlog Service = "cloudlog"
 	// ServiceHamlog is HAMLOG.online — one API key, an ADIF record per QSO.
 	ServiceHamlog Service = "hamlog"
+	// ServiceHamQTH is the HamQTH online logbook — the callbook credentials,
+	// one ADIF record per QSO.
+	ServiceHamQTH Service = "hamqth"
 )
 
 // UploadMode selects when an auto-upload fires after a QSO is saved.
@@ -133,6 +136,7 @@ type ExternalServices struct {
 	EQSL     ServiceConfig `json:"eqsl"`
 	Cloudlog ServiceConfig `json:"cloudlog"`
 	Hamlog   ServiceConfig `json:"hamlog"`
+	HamQTH   ServiceConfig `json:"hamqth"`
 
 	// DeleteRemote asks OpsLog to withdraw a QSO from QRZ.com and Club Log when
 	// it is deleted locally. Off unless the operator turns it on: neither

internal/extsvc/hamqth.go

@@ -0,0 +1,129 @@
+package extsvc
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+)
+
+// HamQTH real-time QSO upload.
+//
+// One POST per QSO to qso_realtime.php with the account username/password —
+// the same credentials the HamQTH callbook lookup uses. The answer is the
+// HTTP status code, not a body format: 200 saved, 400 rejected (bad band,
+// duplicate…, reason in the body), 403 wrong credentials, 500 server error.
+const hamqthUploadURL = "https://www.hamqth.com/qso_realtime.php"
+
+// hamqthLoginURL is the callbook session login — the one authenticated HamQTH
+// endpoint that cannot change anything in the log, which is what the settings
+// Test button must call.
+const hamqthLoginURL = "https://www.hamqth.com/xml.php"
+
+// UploadHamQTH pushes one ADIF record to the HamQTH online logbook.
+func UploadHamQTH(ctx context.Context, client *http.Client, cfg ServiceConfig, adifRecord string) (UploadResult, error) {
+	return uploadHamQTHTo(ctx, client, hamqthUploadURL, cfg, adifRecord)
+}
+
+func uploadHamQTHTo(ctx context.Context, client *http.Client, endpoint string, cfg ServiceConfig, adifRecord string) (UploadResult, error) {
+	user := strings.TrimSpace(cfg.Username)
+	switch {
+	case user == "":
+		return UploadResult{}, fmt.Errorf("hamqth: username not set")
+	case cfg.Password == "":
+		return UploadResult{}, fmt.Errorf("hamqth: password not set")
+	}
+	rec := strings.TrimSpace(adifRecord)
+	if rec == "" {
+		return UploadResult{}, fmt.Errorf("hamqth: empty ADIF record")
+	}
+	form := url.Values{}
+	form.Set("u", user)
+	form.Set("p", cfg.Password)
+	// c: the logbook callsign when the account holds several; empty means the
+	// account's own call, which is the common case.
+	if c := strings.ToUpper(strings.TrimSpace(cfg.Callsign)); c != "" {
+		form.Set("c", c)
+	}
+	form.Set("adif", rec)
+	form.Set("prg", "OpsLog")
+	form.Set("cmd", "insert")
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, endpoint, strings.NewReader(form.Encode()))
+	if err != nil {
+		return UploadResult{}, err
+	}
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	if client == nil {
+		client = &http.Client{Timeout: 30 * time.Second}
+	}
+	resp, err := client.Do(req)
+	if err != nil {
+		return UploadResult{}, err
+	}
+	defer resp.Body.Close()
+	body, _ := io.ReadAll(io.LimitReader(resp.Body, 64<<10))
+	msg := strings.TrimSpace(string(body))
+
+	switch resp.StatusCode {
+	case http.StatusOK:
+		return UploadResult{OK: true}, nil
+	case http.StatusBadRequest:
+		// "Rejected" covers duplicates too. A duplicate is a SUCCESS for our
+		// purposes — the QSO is in the logbook, retrying it forever isn't —
+		// same treatment HRDLog's <insert>0 gets.
+		if strings.Contains(strings.ToLower(msg), "dupl") {
+			return UploadResult{OK: true, Ignored: true, Message: "already in logbook"}, nil
+		}
+		if msg == "" {
+			msg = "QSO rejected"
+		}
+		return UploadResult{OK: false, Message: msg}, nil
+	case http.StatusForbidden:
+		return UploadResult{}, fmt.Errorf("hamqth: wrong username or password")
+	default:
+		if msg != "" && len(msg) < 200 {
+			return UploadResult{}, fmt.Errorf("hamqth: HTTP %d: %s", resp.StatusCode, msg)
+		}
+		return UploadResult{}, fmt.Errorf("hamqth: HTTP %d", resp.StatusCode)
+	}
+}
+
+// TestHamQTH verifies the credentials against the callbook session login —
+// authenticated, and unable to touch the log.
+func TestHamQTH(ctx context.Context, client *http.Client, cfg ServiceConfig) (string, error) {
+	user := strings.TrimSpace(cfg.Username)
+	if user == "" || cfg.Password == "" {
+		return "", fmt.Errorf("hamqth: set the username and password first")
+	}
+	q := url.Values{}
+	q.Set("u", user)
+	q.Set("p", cfg.Password)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, hamqthLoginURL+"?"+q.Encode(), nil)
+	if err != nil {
+		return "", err
+	}
+	if client == nil {
+		client = &http.Client{Timeout: 30 * time.Second}
+	}
+	resp, err := client.Do(req)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+	body, _ := io.ReadAll(io.LimitReader(resp.Body, 64<<10))
+	s := string(body)
+	if strings.Contains(s, "<session_id>") {
+		return fmt.Sprintf("Connected to HamQTH as %s.", user), nil
+	}
+	if i := strings.Index(s, "<error>"); i >= 0 {
+		e := s[i+len("<error>"):]
+		if j := strings.Index(e, "</error>"); j >= 0 {
+			return "", fmt.Errorf("hamqth: %s", strings.TrimSpace(e[:j]))
+		}
+	}
+	return "", fmt.Errorf("hamqth: unexpected answer — check the username and password")
+}

internal/extsvc/lotw.go

@@ -11,6 +11,8 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"regexp"
+	"strconv"
 	"strings"
 	"sync"
 	"syscall"
@@ -337,7 +339,36 @@ func fileExists(p string) bool {
 // 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.
+// scrubMyCnty removes MY_CNTY fields TQSL would refuse. LoTW's secondary
+// subdivisions are the US county enumeration — "XX,County" with a two-letter
+// state — and TQSL rejects the whole record over anything else, so a Canadian
+// station's "ONTARIO,Kawartha" (or a bare county) must simply not be sent.
+// MY_STATE and MY_GRIDSQUARE already locate the station for LoTW.
+var myCntyRe = regexp.MustCompile(`(?i)<MY_CNTY:([0-9]+)(?::[A-Za-z])?>`)
+
+func scrubMyCnty(adif string) string {
+	for {
+		loc := myCntyRe.FindStringSubmatchIndex(adif)
+		if loc == nil {
+			return adif
+		}
+		n, _ := strconv.Atoi(adif[loc[2]:loc[3]])
+		end := loc[1] + n
+		if end > len(adif) {
+			end = len(adif)
+		}
+		val := adif[loc[1]:end]
+		if len(val) > 3 && val[2] == ',' {
+			// "XX,..." — the US shape TQSL accepts; leave it for the county hunters.
+			rest := scrubMyCnty(adif[end:])
+			return adif[:end] + rest
+		}
+		adif = adif[:loc[0]] + strings.TrimLeft(adif[end:], " ")
+	}
+}
+
 func UploadLoTW(ctx context.Context, cfg ServiceConfig, tempDir, adifRecord string) (UploadResult, error) {
+	adifRecord = scrubMyCnty(adifRecord)
 	tqsl := strings.TrimSpace(cfg.TQSLPath)
 	loc := strings.TrimSpace(cfg.StationLocation)
 	switch {

internal/extsvc/lotw_scrub_test.go

@@ -0,0 +1,23 @@
+package extsvc
+
+import "testing"
+
+// TQSL refuses whole records over a MY_CNTY it cannot validate, and its
+// validation is the US "XX,County" enumeration — so anything else must be
+// stripped before signing, and the US shape must survive untouched.
+func TestScrubMyCnty(t *testing.T) {
+	cases := []struct{ in, want string }{
+		{"<CALL:5>F4BPO<MY_CNTY:16>ONTARIO,Kawartha<MY_STATE:7>ONTARIO<EOR>",
+			"<CALL:5>F4BPO<MY_STATE:7>ONTARIO<EOR>"},
+		{"<MY_CNTY:8>Kawartha<EOR>", "<EOR>"},
+		{"<MY_CNTY:9>NY,Monroe<EOR>", "<MY_CNTY:9>NY,Monroe<EOR>"},
+		{"<CALL:4>K1AB<EOR>", "<CALL:4>K1AB<EOR>"},
+		{"<MY_CNTY:8>Kawartha<EOR>\n<MY_CNTY:9>NY,Monroe<EOR>",
+			"<EOR>\n<MY_CNTY:9>NY,Monroe<EOR>"},
+	}
+	for _, c := range cases {
+		if got := scrubMyCnty(c.in); got != c.want {
+			t.Errorf("scrubMyCnty(%q) = %q, want %q", c.in, got, c.want)
+		}
+	}
+}

internal/extsvc/manager.go

@@ -140,6 +140,7 @@ func (m *Manager) SetConfig(cfg ExternalServices) {
 	cfg.EQSL = cfg.EQSL.normalised()
 	cfg.Cloudlog = cfg.Cloudlog.normalised()
 	cfg.Hamlog = cfg.Hamlog.normalised()
+	cfg.HamQTH = cfg.HamQTH.normalised()
 	m.cfg = cfg
 
 	// Summary of what is armed, written at startup and on every settings save.
@@ -153,7 +154,7 @@ func (m *Manager) SetConfig(cfg ExternalServices) {
 	}{
 		{"qrz", cfg.QRZ}, {"clublog", cfg.Clublog}, {"lotw", cfg.LoTW},
 		{"hrdlog", cfg.HRDLog}, {"eqsl", cfg.EQSL}, {"cloudlog", cfg.Cloudlog},
-		{"hamlog", cfg.Hamlog},
+		{"hamlog", cfg.Hamlog}, {"hamqth", cfg.HamQTH},
 	} {
 		if s.cfg.AutoUpload {
 			on = append(on, fmt.Sprintf("%s(%s)", s.name, s.cfg.UploadMode))
@@ -237,6 +238,14 @@ func (m *Manager) OnQSOLogged(id int64) {
 			m.route(ServiceHamlog, id, h)
 		}
 	}
+	// HamQTH — the callbook credentials double as the logbook login.
+	if h := cfg.HamQTH; h.AutoUpload {
+		if h.Username == "" || h.Password == "" {
+			m.logf("extsvc: hamqth auto-upload is ON but the username/password is not set (QSO %d not sent)", id)
+		} else {
+			m.route(ServiceHamQTH, id, h)
+		}
+	}
 }
 
 // route sends a logged QSO down the configured timing path: queue it for the
@@ -290,6 +299,9 @@ func (m *Manager) onCloseServices() []Service {
 	if h := cfg.Hamlog; h.AutoUpload && h.UploadMode == ModeOnClose && h.APIKey != "" {
 		out = append(out, ServiceHamlog)
 	}
+	if h := cfg.HamQTH; h.AutoUpload && h.UploadMode == ModeOnClose && h.Username != "" && h.Password != "" {
+		out = append(out, ServiceHamQTH)
+	}
 	return out
 }
 
@@ -338,6 +350,8 @@ func (m *Manager) FlushOnClose() int {
 			uploaded += m.flushOneByOne(svc, ids, cfg.Cloudlog)
 		case ServiceHamlog:
 			uploaded += m.flushOneByOne(svc, ids, cfg.Hamlog)
+		case ServiceHamQTH:
+			uploaded += m.flushOneByOne(svc, ids, cfg.HamQTH)
 		}
 	}
 	return uploaded
@@ -577,7 +591,7 @@ func (m *Manager) upload(svc Service, id int64, cfg ServiceConfig) (ok bool, ret
 	switch svc {
 	case ServiceQRZ, ServiceLoTW:
 		owner = cfg.ForceStationCallsign
-	case ServiceClublog, ServiceHRDLog:
+	case ServiceClublog, ServiceHRDLog, ServiceHamQTH:
 		owner = cfg.Callsign
 	case ServiceEQSL:
 		owner = cfg.Username
@@ -669,6 +683,15 @@ func (m *Manager) upload(svc Service, id int64, cfg ServiceConfig) (ok bool, ret
 			return false, false
 		}
 		res, err = UploadHamlog(ctx, m.deps.Client, cfg, record)
+	case ServiceHamQTH:
+		// The c parameter names the logbook when the account holds several;
+		// the QSO keeps its own STATION_CALLSIGN in the ADIF.
+		record, ok := m.deps.BuildADIF(id, "")
+		if !ok {
+			m.logf("extsvc: %s upload of QSO %d skipped (no record)", svc, id)
+			return false, false
+		}
+		res, err = UploadHamQTH(ctx, m.deps.Client, cfg, record)
 	default:
 		return false, false
 	}

internal/qso/qso.go

@@ -123,6 +123,10 @@ type QSO struct {
 	QRZComUploadStatus   string `json:"qrzcom_qso_upload_status,omitempty"`
 	QRZComDownloadDate   string `json:"qrzcom_qso_download_date,omitempty"`
 	QRZComDownloadStatus string `json:"qrzcom_qso_download_status,omitempty"`
+	// Club Log match download (getmatches.php) — app-defined, no standard ADIF
+	// field exists; exported/imported as CLUBLOG_QSO_DOWNLOAD_*.
+	ClublogDownloadDate   string `json:"clublog_qso_download_date,omitempty"`
+	ClublogDownloadStatus string `json:"clublog_qso_download_status,omitempty"`
 
 	// --- Contest ---
 	ContestID  string `json:"contest_id,omitempty"`
@@ -261,6 +265,7 @@ const columnList = `callsign, qso_date, qso_date_off, band, band_rx, mode, submo
     hrdlog_qso_upload_date, hrdlog_qso_upload_status,
     qrzcom_qso_upload_date, qrzcom_qso_upload_status,
     qrzcom_qso_download_date, qrzcom_qso_download_status,
+    clublog_qso_download_date, clublog_qso_download_status,
     contest_id, srx, stx, srx_string, stx_string, check_field, precedence, arrl_sect,
     prop_mode, sat_name, sat_mode, ant_az, ant_el, ant_path,
     station_callsign, operator, my_grid, my_gridsquare_ext, my_country, my_state, my_cnty, my_iota,
@@ -336,6 +341,7 @@ func (q *QSO) args() []any {
 		q.HRDLogUploadDate, q.HRDLogUploadStatus,
 		q.QRZComUploadDate, q.QRZComUploadStatus,
 		q.QRZComDownloadDate, q.QRZComDownloadStatus,
+		q.ClublogDownloadDate, q.ClublogDownloadStatus,
 		q.ContestID, q.SRX, q.STX, q.SRXString, q.STXString, q.Check, q.Precedence, q.ARRLSect,
 		q.PropMode, q.SatName, q.SatMode, q.AntAz, q.AntEl, q.AntPath,
 		q.StationCallsign, q.Operator, q.MyGrid, q.MyGridExt, q.MyCountry, q.MyState, q.MyCounty, q.MyIOTA,
@@ -771,30 +777,32 @@ func (r *Repo) MarkEQSLSent(ctx context.Context, id int64, date string) error {
 // zones, lat/lon) that are meaningless shared.
 var bulkEditableCols = map[string]bool{
 	// QSL / upload status
-	"lotw_sent":                  true,
+	"lotw_sent":                   true,
-	"lotw_rcvd":                  true,
+	"lotw_rcvd":                   true,
-	"eqsl_sent":                  true,
+	"eqsl_sent":                   true,
-	"eqsl_rcvd":                  true,
+	"eqsl_rcvd":                   true,
-	"qsl_sent":                   true,
+	"qsl_sent":                    true,
-	"qsl_rcvd":                   true,
+	"qsl_rcvd":                    true,
-	"qsl_via":                    true,
+	"qsl_via":                     true,
-	"qsl_sent_via":               true,
+	"qsl_sent_via":                true,
-	"qsl_rcvd_via":               true,
+	"qsl_rcvd_via":                true,
-	"qrzcom_qso_upload_status":   true,
+	"qrzcom_qso_upload_status":    true,
-	"qrzcom_qso_download_status": true,
+	"qrzcom_qso_download_status":  true,
-	"clublog_qso_upload_status":  true,
+	"clublog_qso_upload_status":   true,
-	"hrdlog_qso_upload_status":   true,
+	"clublog_qso_download_status": true,
+	"hrdlog_qso_upload_status":    true,
 	// Confirmation DATES. ADIF YYYYMMDD strings, so plain TEXT like the rest.
-	"qsl_sent_date":            true,
+	"qsl_sent_date":             true,
-	"qsl_rcvd_date":            true,
+	"qsl_rcvd_date":             true,
-	"lotw_sent_date":           true,
+	"lotw_sent_date":            true,
-	"lotw_rcvd_date":           true,
+	"lotw_rcvd_date":            true,
-	"eqsl_sent_date":           true,
+	"eqsl_sent_date":            true,
-	"eqsl_rcvd_date":           true,
+	"eqsl_rcvd_date":            true,
-	"qrzcom_qso_upload_date":   true,
+	"qrzcom_qso_upload_date":    true,
-	"qrzcom_qso_download_date": true,
+	"qrzcom_qso_download_date":  true,
-	"clublog_qso_upload_date":  true,
+	"clublog_qso_upload_date":   true,
-	"hrdlog_qso_upload_date":   true,
+	"clublog_qso_download_date": true,
+	"hrdlog_qso_upload_date":    true,
 	// My station / operator
 	"station_callsign": true,
 	"operator":         true,
@@ -1339,15 +1347,17 @@ var filterableColumns = map[string]bool{
 	"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,
+	"clublog_qso_upload_status": true, "clublog_qso_download_status": true,
+	"hrdlog_qso_upload_status": true,
 	// Confirmation DATES. ADIF YYYYMMDD strings, so a plain string comparison is
 	// also chronological — "before 20240101" works with no date parsing.
 	"qsl_sent_date": true, "qsl_rcvd_date": true,
 	"lotw_sent_date": true, "lotw_rcvd_date": true,
 	"eqsl_sent_date": true, "eqsl_rcvd_date": true,
 	"qrzcom_qso_upload_date": true, "qrzcom_qso_download_date": true,
-	"clublog_qso_upload_date": true, "hrdlog_qso_upload_date": true,
+	"clublog_qso_upload_date": true, "clublog_qso_download_date": true,
-	"contest_id": true, "srx": true, "stx": true,
+	"hrdlog_qso_upload_date": true,
+	"contest_id":             true, "srx": true, "stx": true,
 	"prop_mode": true, "sat_name": true,
 	"station_callsign": true, "operator": true, "my_grid": true, "my_country": true,
 	"my_state": true, "my_cnty": true, "my_iota": true, "my_sota_ref": true, "my_pota_ref": true,
@@ -3264,6 +3274,7 @@ type matchRef struct {
 // FT8, FT4 only FT4, CW only CW…). Built in one table scan.
 type MatchIndex struct {
 	byMode map[string][]matchRef // call|band|canonMode → refs
+	byBand map[string][]matchRef // call|band → refs (mode-blind fallback)
 }
 
 // canonMode folds the phone sidebands into a single "SSB" bucket; every other
@@ -3299,7 +3310,7 @@ func parseQSODate(s string) time.Time {
 // for one of the operator's calls (e.g. F4BPO) never touches QSOs logged under
 // another (e.g. TM2Q).
 func (r *Repo) BuildMatchIndex(ctx context.Context, ownerCall string) (*MatchIndex, error) {
-	idx := &MatchIndex{byMode: map[string][]matchRef{}}
+	idx := &MatchIndex{byMode: map[string][]matchRef{}, byBand: map[string][]matchRef{}}
 	query := `SELECT id, callsign, qso_date, band, mode FROM qso`
 	var args []any
 	if oc := strings.ToUpper(strings.TrimSpace(ownerCall)); oc != "" {
@@ -3327,6 +3338,11 @@ func (r *Repo) BuildMatchIndex(ctx context.Context, ownerCall string) (*MatchInd
 func (idx *MatchIndex) add(call, band, mode string, when time.Time, id int64) {
 	mk := matchKeyMode(call, band, mode)
 	idx.byMode[mk] = append(idx.byMode[mk], matchRef{when: when, id: id})
+	if idx.byBand == nil { // tests build the index literally, without byBand
+		idx.byBand = map[string][]matchRef{}
+	}
+	bk := strings.ToUpper(call) + "|" + strings.ToLower(band)
+	idx.byBand[bk] = append(idx.byBand[bk], matchRef{when: when, id: id})
 }
 
 // Add registers a QSO in the index (exported wrapper for callers that inserted a
@@ -3342,6 +3358,12 @@ func (idx *MatchIndex) Match(call, band, mode string, when time.Time, window tim
 	return closestRef(idx.byMode[matchKeyMode(call, band, mode)], when, window)
 }
 
+// MatchBand matches ignoring the mode — for confirmations whose source doesn't
+// carry one (Club Log reports "false" for modes it can't infer).
+func (idx *MatchIndex) MatchBand(call, band string, when time.Time, window time.Duration) (int64, bool) {
+	return closestRef(idx.byBand[strings.ToUpper(call)+"|"+strings.ToLower(band)], when, window)
+}
+
 func closestRef(refs []matchRef, when time.Time, window time.Duration) (int64, bool) {
 	var best int64
 	bestD := window + time.Second
@@ -3500,10 +3522,11 @@ func (r *Repo) GetSlotStats(ctx context.Context) (SlotStats, error) {
 // confirmedCols whitelists the received-status columns ConfirmedSlots may
 // OR together (guards the dynamic SQL).
 var confirmedCols = map[string]bool{
-	"lotw_rcvd":                  true,
+	"lotw_rcvd":                   true,
-	"qsl_rcvd":                   true,
+	"qsl_rcvd":                    true,
-	"eqsl_rcvd":                  true,
+	"eqsl_rcvd":                   true,
-	"qrzcom_qso_download_status": true,
+	"qrzcom_qso_download_status":  true,
+	"clublog_qso_download_status": true,
 }
 
 // ConfirmedSlots returns the set of confirmed DXCC/band/slot combos, counting
@@ -3560,6 +3583,19 @@ func (r *Repo) MarkQRZConfirmed(ctx context.Context, id int64, date string) erro
 	return nil
 }
 
+// MarkClublogConfirmed stamps CLUBLOG_QSO_DOWNLOAD_STATUS=Y and the date on a
+// QSO Club Log reports as matched. date is an ADIF YYYYMMDD string.
+func (r *Repo) MarkClublogConfirmed(ctx context.Context, id int64, date string) error {
+	_, err := r.db.ExecContext(ctx,
+		`UPDATE qso SET clublog_qso_download_status = 'Y', clublog_qso_download_date = ?,
+		   updated_at = ? WHERE id = ?`,
+		date, db.NowISO(), id)
+	if err != nil {
+		return fmt.Errorf("mark clublog confirmed %d: %w", id, err)
+	}
+	return nil
+}
+
 // ClearQRZConfirmed takes back a QRZ confirmation.
 //
 // Needed because OpsLog set some wrongly: it read qrzcom_qso_download_status,
@@ -3638,6 +3674,7 @@ func scanQSO(s scanner) (QSO, error) {
 		hrdlogDate, hrdlogStatus               sql.NullString
 		qrzcomDate, qrzcomStatus               sql.NullString
 		qrzcomDlDate, qrzcomDlStatus           sql.NullString
+		clublogDlDate, clublogDlStatus         sql.NullString
 		contestID                              sql.NullString
 		srx, stx                               sql.NullInt64
 		srxStr, stxStr                         sql.NullString
@@ -3682,6 +3719,7 @@ func scanQSO(s scanner) (QSO, error) {
 		&hrdlogDate, &hrdlogStatus,
 		&qrzcomDate, &qrzcomStatus,
 		&qrzcomDlDate, &qrzcomDlStatus,
+		&clublogDlDate, &clublogDlStatus,
 		&contestID, &srx, &stx, &srxStr, &stxStr, &checkField, &precedence, &arrlSect,
 		&propMode, &satName, &satMode, &antAz, &antEl, &antPath,
 		&stCall, &op, &myGrid, &myGridExt, &myCountry, &myState, &myCnty, &myIOTA,
@@ -3779,6 +3817,8 @@ func scanQSO(s scanner) (QSO, error) {
 	q.QRZComUploadStatus = qrzcomStatus.String
 	q.QRZComDownloadDate = qrzcomDlDate.String
 	q.QRZComDownloadStatus = qrzcomDlStatus.String
+	q.ClublogDownloadDate = clublogDlDate.String
+	q.ClublogDownloadStatus = clublogDlStatus.String
 	q.ContestID = contestID.String
 	if srx.Valid {
 		v := int(srx.Int64)

internal/scp/scp.go

@@ -13,6 +13,7 @@ package scp
 import (
 	"bufio"
 	"bytes"
+	"compress/gzip"
 	"context"
 	"fmt"
 	"io"
@@ -22,6 +23,7 @@ import (
 	"sort"
 	"strings"
 	"sync"
+	"sync/atomic"
 	"time"
 )
 
@@ -29,7 +31,14 @@ import (
 // line, '#'-prefixed header lines. ~50k+ active contest/DX calls.
 const masterURL = "https://www.supercheckpartial.com/MASTER.SCP"
 
+// clublogURL is Club Log's own SCP list, rebuilt weekly from real DX logs:
+// every call from a current entity with 40+ QSOs in the last 3 years (~180k).
+// Broader than MASTER.SCP (which leans contest), so the manager merges the two
+// when the Club Log source is enabled.
+const clublogURL = "https://cdn.clublog.org/clublog.scp.gz"
+
 const cacheFile = "MASTER.SCP"
+const clublogCacheFile = "CLUBLOG.SCP" // stored decompressed
 
 // Result is the two suggestion lists for a typed fragment.
 type Result struct {
@@ -44,6 +53,7 @@ type Manager struct {
 	updated time.Time // when the cache was last refreshed
 	dir     string
 	client  *http.Client
+	clublog atomic.Bool // merge Club Log's list into the master list
 }
 
 // NewManager loads any on-disk cache and returns a ready manager.
@@ -56,14 +66,30 @@ func NewManager(dataDir string) *Manager {
 	return m
 }
 
-func (m *Manager) path() string { return filepath.Join(m.dir, cacheFile) }
+func (m *Manager) path() string        { return filepath.Join(m.dir, cacheFile) }
+func (m *Manager) clublogPath() string { return filepath.Join(m.dir, clublogCacheFile) }
+
+// SetClublogEnabled turns the Club Log source on/off and reparses the on-disk
+// caches so the in-memory list reflects the choice immediately.
+func (m *Manager) SetClublogEnabled(on bool) {
+	if m.clublog.Swap(on) != on {
+		m.loadCache()
+	}
+}
+
+// ClublogEnabled reports whether the Club Log source is merged in.
+func (m *Manager) ClublogEnabled() bool { return m.clublog.Load() }
 
 func (m *Manager) loadCache() {
-	data, err := os.ReadFile(m.path())
+	data, _ := os.ReadFile(m.path())
-	if err != nil {
+	var extra []byte
+	if m.clublog.Load() {
+		extra, _ = os.ReadFile(m.clublogPath())
+	}
+	if data == nil && extra == nil {
 		return
 	}
-	m.parse(data)
+	m.parse(data, extra)
 	if fi, e := os.Stat(m.path()); e == nil {
 		m.mu.Lock()
 		m.updated = fi.ModTime()
@@ -91,7 +117,17 @@ func (m *Manager) Download(ctx context.Context) (int, error) {
 	if err != nil {
 		return 0, fmt.Errorf("scp: read: %w", err)
 	}
-	n := m.parse(body)
+	var extra []byte
+	if m.clublog.Load() {
+		if cl, cerr := m.downloadClublog(ctx); cerr == nil {
+			extra = cl
+		} else {
+			// The master list alone is still worth having; fall back to any
+			// cached Club Log list rather than dropping the source silently.
+			extra, _ = os.ReadFile(m.clublogPath())
+		}
+	}
+	n := m.parse(body, extra)
 	if n == 0 {
 		return 0, fmt.Errorf("scp: file parsed to 0 callsigns")
 	}
@@ -102,25 +138,57 @@ func (m *Manager) Download(ctx context.Context) (int, error) {
 	return n, nil
 }
 
+// downloadClublog fetches Club Log's gzipped SCP list and caches it decompressed.
+func (m *Manager) downloadClublog(ctx context.Context) ([]byte, error) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, clublogURL, nil)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("User-Agent", "OpsLog")
+	resp, err := m.client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("scp: clublog request failed: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("scp: clublog http %d", resp.StatusCode)
+	}
+	gz, err := gzip.NewReader(io.LimitReader(resp.Body, 32*1024*1024))
+	if err != nil {
+		return nil, fmt.Errorf("scp: clublog gunzip: %w", err)
+	}
+	body, err := io.ReadAll(io.LimitReader(gz, 64*1024*1024))
+	if err != nil {
+		return nil, fmt.Errorf("scp: clublog read: %w", err)
+	}
+	_ = os.WriteFile(m.clublogPath(), body, 0o644)
+	return body, nil
+}
+
 // parse loads the SCP bytes into the sorted call slice and returns the count.
-func (m *Manager) parse(data []byte) int {
+func (m *Manager) parse(datasets ...[]byte) int {
 	seen := make(map[string]struct{}, 1<<17)
-	sc := bufio.NewScanner(bytes.NewReader(data))
+	for _, data := range datasets {
-	sc.Buffer(make([]byte, 1024*1024), 1024*1024)
+		if len(data) == 0 {
-	for sc.Scan() {
-		line := strings.ToUpper(strings.TrimSpace(sc.Text()))
-		if line == "" || strings.HasPrefix(line, "#") {
-			continue // blank / header comment
-		}
-		// A call token only (the master file is one call per line, but guard
-		// against stray trailing fields).
-		if i := strings.IndexAny(line, " \t,;"); i >= 0 {
-			line = line[:i]
-		}
-		if !plausibleCall(line) {
 			continue
 		}
-		seen[line] = struct{}{}
+		sc := bufio.NewScanner(bytes.NewReader(data))
+		sc.Buffer(make([]byte, 1024*1024), 1024*1024)
+		for sc.Scan() {
+			line := strings.ToUpper(strings.TrimSpace(sc.Text()))
+			if line == "" || strings.HasPrefix(line, "#") {
+				continue // blank / header comment
+			}
+			// A call token only (the files are one call per line, but guard
+			// against stray trailing fields).
+			if i := strings.IndexAny(line, " \t,;"); i >= 0 {
+				line = line[:i]
+			}
+			if !plausibleCall(line) {
+				continue
+			}
+			seen[line] = struct{}{}
+		}
 	}
 	if len(seen) == 0 {
 		return 0

internal/webpub/webpub.go

@@ -190,6 +190,8 @@ var Columns = []Column{
 	{"eqsl_rcvd_date", "Eqsl rcvd date", "QSL", func(q *qso.QSO) string { return q.EQSLRcvdDate }},
 	{"clublog_qso_upload_date", "Clublog qso upload date", "QSL", func(q *qso.QSO) string { return q.ClublogUploadDate }},
 	{"clublog_qso_upload_status", "Clublog qso upload status", "QSL", func(q *qso.QSO) string { return q.ClublogUploadStatus }},
+	{"clublog_qso_download_date", "Clublog match date", "QSL", func(q *qso.QSO) string { return q.ClublogDownloadDate }},
+	{"clublog_qso_download_status", "Clublog match status", "QSL", func(q *qso.QSO) string { return q.ClublogDownloadStatus }},
 	{"hrdlog_qso_upload_date", "Hrdlog qso upload date", "QSL", func(q *qso.QSO) string { return q.HRDLogUploadDate }},
 	{"hrdlog_qso_upload_status", "Hrdlog qso upload status", "QSL", func(q *qso.QSO) string { return q.HRDLogUploadStatus }},
 	{"qrzcom_qso_upload_date", "Qrzcom qso upload date", "QSL", func(q *qso.QSO) string { return q.QRZComUploadDate }},

main.go

@@ -48,14 +48,14 @@ func hasFlag(args []string, flag string) bool {
 }
 
 // acquireInstance grabs the single-instance mutex. On a normal launch it's a plain
-// try (fail → another OpsLog is running, so exit). On a --post-update relaunch the
+// try (fail → another OpsLog is running, so exit). On a --post-update or
-// previous instance may still be shutting down and holding the mutex, so retry for
+// --relaunch start the previous instance may still be shutting down and holding
-// a few seconds until it frees.
+// the mutex, so retry for a few seconds until it frees.
-func acquireInstance(postUpdate bool) bool {
+func acquireInstance(wait bool) bool {
 	if acquireSingleInstance() {
 		return true
 	}
-	if !postUpdate {
+	if !wait {
 		return false
 	}
 	deadline := time.Now().Add(20 * time.Second)
@@ -90,7 +90,11 @@ func main() {
 	// to free instead of bailing out. Then clear the old exe it left behind.
 	bootLogLaunch()
 	postUpdate := hasFlag(os.Args[1:], "--post-update")
-	if !acquireInstance(postUpdate) {
+	// A self-relaunch (database switch) races its own parent: the new process
+	// regularly wins the start against the old one's teardown, and the operator
+	// got "OpsLog is already running" for following instructions. Same patience
+	// as post-update.
+	if !acquireInstance(postUpdate || hasFlag(os.Args[1:], "--relaunch")) {
 		// SAID, not merely done. This exit is correct — a second instance would
 		// fight the first over the rig — but it happened in total silence: no
 		// window, no data folder, no log, which is indistinguishable from a

telemetry.go

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