chore: release v0.24.6

QRZ has no record under M0BFS/QRP, so the lookup falls back to the home call —
that part worked. What followed did not: the home record's location is then
discarded, on the reasoning that a portable operator is not at their registered
address. True for /P and /M, and simply wrong for /QRP, which says something
about the transmitter and nothing about where it is.

So the grid came back empty for M0BFS/QRP while the same call without the suffix
answered perfectly, which is exactly how it was reported.

The distinction is now explicit rather than lumped in with the other operational
suffixes. /P and /M keep clearing the location, because mobile and portable both
mean somewhere other than home — that behaviour was correct and is untouched.
A power suffix stacked on a portable one (F4BPO/P/QRP) still clears: one of them
moved the operator.

app.go

@@ -40,6 +40,7 @@ import (
 	"hamlog/internal/dxcc"
 	"hamlog/internal/email"
 	"hamlog/internal/extsvc"
+	"hamlog/internal/geo"
 	"hamlog/internal/integrations/udp"
 	"hamlog/internal/lookup"
 	"hamlog/internal/lotwusers"
@@ -49,6 +50,7 @@ import (
 	"hamlog/internal/pota"
 	"hamlog/internal/powergenius"
 	"hamlog/internal/profile"
+	"hamlog/internal/pskr"
 	"hamlog/internal/qslcard"
 	"hamlog/internal/qso"
 	"hamlog/internal/relaydev"
@@ -294,6 +296,11 @@ const (
 
 	keyScpEnabled = "scp.enabled" // Super Check Partial / N+1 suggestions on
 
+	// 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
+	// password rides inside it — see isSensitiveSetting.
+	keyWebPublish = "webpublish.config"
+
 	// Worked-before: fold an operator's portable forms (X, X/3, X/P) together.
 	// Stored inverted — "0" means OFF — so the feature is ON for an existing
 	// install that has never seen the key, which is the behaviour operators asked
@@ -536,6 +543,8 @@ type StationSettings struct {
 	MyCountry string `json:"my_country"`
 	MySOTARef string `json:"my_sota_ref"`
 	MyPOTARef string `json:"my_pota_ref"`
+	// MyIOTA is the island the station operates FROM (ADIF MY_IOTA), e.g. EU-005.
+	MyIOTA string `json:"my_iota"`
 }
 
 // LookupSettings is the JSON shape exchanged with the frontend.
@@ -590,6 +599,22 @@ type App struct {
 	// or when a setting that shapes the maps flips.
 	clusterStatusIdx *clusterStatusCache
 	clusterStatusMu  sync.Mutex
+	// decodeGrids maps a callsign to the 4-character grid it announced in a CQ
+	// heard over the WSJT-X UDP link. It is the ONLY source of grids we have for
+	// a spot: a DX-cluster line carries the spotter's grid at best, never the
+	// DX's, and a per-callsign QRZ lookup under an RBN firehose is out of the
+	// question. So grids are known for the stations this station's own receiver
+	// decoded — which is exactly the FT8/FT4 watering hole an operator is looking
+	// at when grid chasing.
+	//
+	// In memory only, and bounded: it is a session-local view of who is on the
+	// air now, not a database.
+	decodeGrids   map[string]string
+	decodeGridsMu sync.RWMutex
+	// pskr is the PSK Reporter MQTT feed, up only while the opening watch is on.
+	// It is the source that makes VHF detection work at all: the cluster and RBN
+	// carry a handful of 6 m spots where PSK Reporter carries hundreds.
+	pskr *pskr.Watcher
 	// Self-spot throttle: when and on what frequency we last announced ourselves.
 	// Held in memory only — a restart legitimately re-announces the station.
 	selfSpotMu     sync.Mutex
@@ -690,6 +715,8 @@ type App struct {
 	awardSnap          []qso.QSO     // light-scanned + enriched logbook snapshot reused across award computations
 	awardSnapRev       string        // logbook revision the snapshot was built at ("" = none)
 	awardSnapUsed      time.Time     // last read — the snapshot is dropped once it goes cold (see awardSnapshotJanitor)
+	webpub             webPublisher  // log-to-website publishing: debounce timer, periodic ticker, last result
+	bandOpen           bandOpenState // sporadic-E / band-opening detector over the spot stream
 	dataDir            string        // <exeDir>/data — holds config.json, logs, cty.dat
 
 	// shuttingDown gates beforeClose re-entry: the first user attempt to
@@ -720,48 +747,16 @@ type App struct {
 	udpLastMode   string
 }
 
-// gridToLatLon parses a Maidenhead locator (4 or 6 chars) and returns the
-// centre lat/lon in degrees. Returns ok=false on malformed input.
-func gridToLatLon(grid string) (lat, lon float64, ok bool) {
-	g := strings.ToUpper(strings.TrimSpace(grid))
-	if len(g) < 4 {
-		return 0, 0, false
-	}
-	A := g[0] - 'A'
-	B := g[1] - 'A'
-	C := g[2] - '0'
-	D := g[3] - '0'
-	if A > 17 || B > 17 || C > 9 || D > 9 {
-		return 0, 0, false
-	}
-	lon = -180 + float64(A)*20 + float64(C)*2
-	lat = -90 + float64(B)*10 + float64(D)*1
-	if len(g) >= 6 {
-		E := g[4] - 'A'
-		F := g[5] - 'A'
-		if E <= 23 && F <= 23 {
-			lon += float64(E)*(5.0/60.0) + 2.5/60.0
-			lat += float64(F)*(2.5/60.0) + 1.25/60.0
-			return lat, lon, true
-		}
-	}
-	// 4-char locator: aim at the centre of the square.
-	lon += 1
-	lat += 0.5
-	return lat, lon, true
-}
+// gridToLatLon and haversineKm live in internal/geo, which the internal
+// packages can import — package main cannot be imported by anything. These
+// forward so there is exactly ONE implementation: the PSK Reporter watcher and
+// the web publisher measure the same path the cluster does, and a bearing that
+// disagrees with itself between two panels is a fault nobody reports, because
+// each screen looks plausible alone.
+func gridToLatLon(grid string) (lat, lon float64, ok bool) { return geo.GridToLatLon(grid) }
 
-// haversineKm returns the great-circle distance between two lat/lon pairs
-// in kilometres. Standard Haversine, mean Earth radius 6371 km.
 func haversineKm(lat1, lon1, lat2, lon2 float64) float64 {
-	const R = 6371.0
-	rad := math.Pi / 180.0
-	dLat := (lat2 - lat1) * rad
-	dLon := (lon2 - lon1) * rad
-	a := math.Sin(dLat/2)*math.Sin(dLat/2) +
-		math.Cos(lat1*rad)*math.Cos(lat2*rad)*math.Sin(dLon/2)*math.Sin(dLon/2)
-	c := 2 * math.Atan2(math.Sqrt(a), math.Sqrt(1-a))
-	return R * c
+	return geo.HaversineKm(lat1, lon1, lat2, lon2)
 }
 
 // initialBearingDeg returns the initial great-circle bearing (azimuth) in
@@ -943,7 +938,12 @@ func (a *App) startup(ctx context.Context) {
 	// impossible: the copy someone is actually running is not always the one they
 	// think they installed, and the version shown in the UI is the only clue.
 	exe, _ := os.Executable()
-	applog.Printf("startup: OpsLog %s — %s", appVersion, exe)
+	// Everything before this line is outside our control: Windows mapping a 30 MB
+	// binary, an antivirus reading all of it, and Wails creating the WebView2
+	// environment. Logging it separates "OpsLog is slow" from "starting OpsLog is
+	// slow", which are two different problems with two different fixes.
+	applog.Printf("startup: OpsLog %s — %s (%.0f ms before startup: exe load + WebView2)",
+		appVersion, exe, float64(time.Since(processStart).Microseconds())/1000)
 	applog.Printf("startup: data dir = %s", dataDir)
 	// The local SQLite file ALWAYS holds per-operator configuration — settings,
 	// station profiles, rigs/antennas, cluster nodes, UDP, QSL templates, award
@@ -1238,6 +1238,7 @@ func (a *App) startup(ctx context.Context) {
 	a.clusterEvents = newClusterQueue()
 	go a.clusterEventWorker()
 	go a.awardSnapshotJanitor() // give the award snapshot's memory back once it goes cold
+	a.restartWebPublishTimer()  // periodic log-to-website refresh, if configured
 
 	a.cluster = cluster.NewManager(
 		// onSpot / onLine run on the session's socket-read goroutine, so they must
@@ -1372,6 +1373,11 @@ func (a *App) startup(ctx context.Context) {
 	go a.sendTelemetryHeartbeat()
 	go a.liveStatusLoop() // multi-op: heartbeat current activity to shared MySQL
 	go a.chatLoop()       // multi-op: poll the shared chat + heartbeat presence
+	// PSK Reporter, when the opening watch is on. After the operator's grid is
+	// known: without it there is no distance to measure and the feed stays down.
+	a.startBandOpenFeed()
+	// One-time tidy-up of a field nothing used to record. Background, once.
+	a.backfillDistancesOnce()
 
 	fmt.Println("OpsLog: db ready at", a.dbPath)
 }
@@ -1383,6 +1389,10 @@ func (a *App) startup(ctx context.Context) {
 func (a *App) domReady(ctx context.Context) {
 	a.restoreWindowPosition()
 	wruntime.WindowShow(ctx)
+	// The one number that matches what the operator actually experiences: click
+	// to window. Anything else measures a part of it.
+	applog.Printf("startup: window visible %.0f ms after launch",
+		float64(time.Since(processStart).Microseconds())/1000)
 }
 
 // StartupStatus returns a diagnostic snapshot for the frontend.
@@ -2464,6 +2474,19 @@ func (a *App) groupDigitalSlots() bool {
 // Off (default) → a call worked on any band/mode reads as already worked. On →
 // the WORKED-call flag needs the same band and mode (digital-grouped when that
 // option is also on).
+// clusterSlotHighlight reports the "colour the stations I have NOT worked on
+// this band and mode" preference (Settings -> DX Cluster). It needs the same
+// per-slot index as clusterWorkedSameSlot, which is why the index is built when
+// EITHER is on: that map is one entry per worked call+band+mode, so on a large
+// log it is not something to hold for an operator using neither.
+func (a *App) clusterSlotHighlight() bool {
+	if a.settings == nil {
+		return false
+	}
+	v, _ := a.settings.Get(a.ctx, "ui.opslog.clusterSlotHighlight")
+	return v == "1"
+}
+
 func (a *App) clusterWorkedSameSlot() bool {
 	if a.settings == nil {
 		return false
@@ -2599,6 +2622,7 @@ func (a *App) AddQSO(q qso.QSO) (id int64, err error) {
 		}
 	}()
 	a.applyStationDefaults(&q, true)
+	fillDistance(&q)
 	a.applyDXCCNumber(&q)
 	a.applyULSCounty(&q)               // fill blank US county/grid from the offline ULS store
 	a.applyClublogException(&q, false) // override entity for date-ranged DXpeditions
@@ -2639,6 +2663,23 @@ func (a *App) AddQSO(q qso.QSO) (id int64, err error) {
 		// and the audio was discarded (recordings silently stopped working). The
 		// snapshot is an in-memory copy; the heavy file encode still runs async.
 		a.saveQSORecording(&q)
+		// Drop the cluster worked-index snapshot BEFORE announcing, so the refresh
+		// the frontend fires on qso:logged rebuilds it and sees this QSO.
+		//
+		// Without this the spot colours never moved after a contact. Logging emitted
+		// the event, the frontend dutifully re-queried every visible spot two
+		// seconds later, and ClusterSpotStatuses answered out of a snapshot built
+		// before the QSO — the same "new band" as before, for ever. Reported on an
+		// E51 and again on a ZD7 that stayed yellow on the band map with the QSO
+		// plainly in the log.
+		//
+		// Deliberately NOT invalidateAwardStats(): that also drops the award
+		// matrices, which are expensive to rebuild on a large log, and a contest run
+		// would pay for it once per QSO. This index is a handful of DISTINCT scans
+		// and it is what the spot colours actually read.
+		a.clusterStatusMu.Lock()
+		a.clusterStatusIdx = nil
+		a.clusterStatusMu.Unlock()
 		// Announce the log RIGHT AWAY so the grid/UI refresh at once and the entry
 		// form clears immediately — the operator is not made to wait on the DB.
 		wruntime.EventsEmit(a.ctx, "qso:logged", id)
@@ -2655,6 +2696,7 @@ func (a *App) AddQSO(q qso.QSO) (id int64, err error) {
 			}
 			a.maybeAutoSendEQSL(qc)
 			a.maybeSelfSpot(qc)
+			a.publishSoon() // refresh the published web page, debounced
 			if a.udp != nil {
 				a.udp.EmitLoggedADIF(adif.SingleRecordADIF(qc))
 			}
@@ -2924,6 +2966,27 @@ func (a *App) refineDistrictZones(q *qso.QSO) {
 	}
 }
 
+// fillDistance computes DISTANCE from the two locators when nothing supplied one.
+//
+// Its own function, NOT part of applyStationDefaults, because the import only
+// applies those when the operator ticks the box — and a distance is not a
+// station default. It is derived from the QSO's own two grids and is true
+// whatever the operator chose about profile fields.
+//
+// Nothing recorded it before, so the field went out empty in every ADIF export
+// and left the same gap in whoever imported the file: a hole that travels. An
+// imported value always wins, having come from the log that made the contact,
+// which knew the real positions rather than two four-character squares.
+func fillDistance(q *qso.QSO) {
+	if q == nil || (q.Distance != nil && *q.Distance > 0) {
+		return
+	}
+	if km, ok := geo.DistanceBetweenGrids(q.MyGrid, q.Grid); ok && km > 0 {
+		v := math.Round(km)
+		q.Distance = &v
+	}
+}
+
 // applyStationDefaults fills any empty MY_* / station field on q with the
 // currently-active profile's values. Multi-profile support means a user
 // can be /P with a different callsign + grid + SOTA ref than home — the
@@ -2982,6 +3045,9 @@ func (a *App) applyStationDefaults(q *qso.QSO, includeIdentity bool) {
 	if q.MyPOTARef == "" {
 		q.MyPOTARef = p.MyPOTARef
 	}
+	if q.MyIOTA == "" {
+		q.MyIOTA = p.MyIOTA
+	}
 	// MY_NAME = the operator's personal name (profile OpName, e.g. "Greg") — stamped
 	// like the other My* fields so every QSO carries it, not just those edited by hand.
 	if q.MyName == "" {
@@ -6096,6 +6162,12 @@ var bulkFieldColumns = map[string]string{
 	"iota":     "iota",
 	"sig":      "sig",
 	"sig_info": "sig_info",
+	// The contact itself — repair fields. Setting mode also clears submode, in
+	// qso.BulkSetField: a submode left over from the old mode contradicts the new.
+	"mode":     "mode",
+	"submode":  "submode",
+	"rst_sent": "rst_sent",
+	"rst_rcvd": "rst_rcvd",
 	// Misc text
 	"comment": "comment",
 	"notes":   "notes",
@@ -6412,6 +6484,8 @@ func (a *App) ImportADIF(path string, dupMode string, applyCty bool, applyStatio
 					a.applyClublogException(q, true) // force: explicit import-time correction
 				}
 			}
+			// Unconditional: see fillDistance.
+			fillDistance(q)
 			if applyStation {
 				// Backfill empty MY_* descriptive fields from the active profile
 				// (identity fields left alone to keep mixed-call routing intact).
@@ -7816,6 +7890,10 @@ func (a *App) clusterEventWorker() {
 		if s.Historical {
 			continue
 		}
+		// Band-opening detector. Deliberately AFTER the Historical guard above: a
+		// SH/DX reply replays a hundred past spots in a second, which is exactly
+		// the shape of a burst and would announce an opening that ended hours ago.
+		a.detectBandOpening(s)
 		// Fire any matching alert rules (sound / visual / e-mail).
 		a.evaluateAlerts(s)
 		// Mirror the spot onto the FlexRadio panadapter when enabled. Infer the
@@ -10291,6 +10369,97 @@ func (a *App) DownloadULSCounties() error {
 }
 
 // BackfillUSCountiesResult summarises a bulk county/grid backfill over the log.
+// keyDistanceBackfilled marks the one-time distance fill as done.
+//
+// A migration, not a setting. It was briefly a button in Preferences, which was
+// the wrong shape twice over: a maintenance chore does not belong beside the
+// options an operator actually chooses, and nobody should have to be TOLD their
+// log is missing a field before it gets filled in. It runs once, in the
+// background, and never asks.
+const keyDistanceBackfilled = "migr.distance_from_grids.v1"
+
+// backfillDistancesOnce fills DISTANCE across the log the first time this
+// version runs, then records that it is done.
+//
+// In the background: on a large log over a remote MySQL this is thousands of
+// row updates, and startup must not wait for a tidy-up. Marked done only on
+// success — a run cut short by a closed program should try again next time
+// rather than leave half the log filled for ever.
+func (a *App) backfillDistancesOnce() {
+	if a.settings == nil || a.qso == nil {
+		return
+	}
+	if v, _ := a.settings.GetGlobal(a.ctx, keyDistanceBackfilled); v == "1" {
+		return
+	}
+	go func() {
+		res, err := a.BackfillDistances()
+		if err != nil {
+			applog.Printf("distance backfill: %v — will try again next start", err)
+			return
+		}
+		_ = a.settings.SetGlobal(a.ctx, keyDistanceBackfilled, "1")
+		applog.Printf("distance backfill: done once for this log (%d filled)", res.Filled)
+	}()
+}
+
+// BackfillDistancesResult reports what a distance backfill did.
+type BackfillDistancesResult struct {
+	Scanned int `json:"scanned"` // QSOs examined
+	Filled  int `json:"filled"`  // QSOs that gained a distance
+	NoGrid  int `json:"no_grid"` // skipped: one of the two locators is missing
+}
+
+// BackfillDistances computes DISTANCE for past QSOs that have both locators and
+// no distance recorded.
+//
+// Nothing has ever computed it when logging — the column is only filled by an
+// ADIF import that carried one — so a log made in OpsLog has it empty
+// throughout. The published web page works around that by deriving the distance
+// as it renders, but the column still travels empty into every ADIF export, and
+// that is what leaves the gap in someone else's log.
+//
+// Only fills what is EMPTY. A stored distance came from the log that recorded
+// the contact, which knew the real positions; two four-character squares are a
+// worse answer and must not overwrite a better one.
+func (a *App) BackfillDistances() (BackfillDistancesResult, error) {
+	var res BackfillDistancesResult
+	if a.qso == nil {
+		return res, fmt.Errorf("db not initialized")
+	}
+	rows, err := a.qso.List(a.ctx, qso.ListFilter{Limit: 1_000_000})
+	if err != nil {
+		return res, err
+	}
+	for i := range rows {
+		q := rows[i]
+		res.Scanned++
+		if q.Distance != nil && *q.Distance > 0 {
+			continue
+		}
+		km, ok := geo.DistanceBetweenGrids(q.MyGrid, q.Grid)
+		if !ok || km <= 0 {
+			res.NoGrid++
+			continue
+		}
+		// Whole kilometres: the squares are tens of kilometres across and a
+		// decimal would assert an accuracy the grids do not carry.
+		v := math.Round(km)
+		q.Distance = &v
+		if err := a.qso.Update(a.ctx, q); err != nil {
+			applog.Printf("backfill distance: QSO %d: %v", q.ID, err)
+			continue
+		}
+		res.Filled++
+	}
+	applog.Printf("backfill distance: %d scanned, %d filled, %d without both grids",
+		res.Scanned, res.Filled, res.NoGrid)
+	if res.Filled > 0 {
+		a.invalidateAwardStats()
+	}
+	return res, nil
+}
+
 type BackfillUSCountiesResult struct {
 	Scanned int `json:"scanned"` // US QSOs examined
 	County  int `json:"county"`  // QSOs that gained a county
@@ -11704,6 +11873,7 @@ func (a *App) LogUDPLoggedADIF(adifText string) (int64, error) {
 		}
 		a.maybeAutoSendEQSL(qc)
 		a.maybeSelfSpot(qc)
+		a.publishSoon() // refresh the published web page, debounced
 		// Forward to the outbound UDP integrations, exactly like the manual log
 		// path — otherwise a QSO logged FROM WSJT-X/JTDX/MSHV was never re-emitted
 		// to the outbound ADIF listeners (Log4OM, N1MM, gridtracker…).
@@ -11742,6 +11912,19 @@ func (a *App) consumeUDPEvents() {
 		}
 		switch {
 		case ev.DecodeCall != "":
+			// Remember the grid before anything else: a CQ is the one message that
+			// carries it, and the station may never send another.
+			if ev.DecodeGrid != "" {
+				a.decodeGridsMu.Lock()
+				if a.decodeGrids == nil {
+					a.decodeGrids = make(map[string]string, 512)
+				}
+				if len(a.decodeGrids) > 20000 {
+					a.decodeGrids = make(map[string]string, 512) // bound a long session
+				}
+				a.decodeGrids[strings.ToUpper(ev.DecodeCall)] = ev.DecodeGrid
+				a.decodeGridsMu.Unlock()
+			}
 			// A WSJT-X decode (heard station). Render it on the FlexRadio
 			// panadapter when the option is on; green + SNR comment, auto-expiring
 			// after the configured duration. De-duped per call in the Flex backend.
@@ -13395,6 +13578,7 @@ func (a *App) GetStationSettings() (StationSettings, error) {
 		MyCountry: p.MyCountry,
 		MySOTARef: p.MySOTARef,
 		MyPOTARef: p.MyPOTARef,
+		MyIOTA:    p.MyIOTA,
 	}, nil
 }
 
@@ -13492,6 +13676,10 @@ func (a *App) SaveStationSettings(s StationSettings) error {
 	p.MyCountry = s.MyCountry
 	p.MySOTARef = s.MySOTARef
 	p.MyPOTARef = s.MyPOTARef
+	// Uppercased on the way in: ADIF spells it EU-005, and an operator typing
+	// "eu-005" would otherwise put a reference no award matcher recognises on
+	// every QSO of an activation.
+	p.MyIOTA = strings.ToUpper(strings.TrimSpace(s.MyIOTA))
 	return a.profiles.Save(a.ctx, &p)
 }
 
@@ -14626,12 +14814,10 @@ func (a *App) startUltrabeam() {
 	}
 	a.motorAnt = c
 	_ = a.motorAnt.Start()
-	if s.Follow {
-		stop := make(chan struct{})
-		a.ubFollowStop = stop
-		applog.Printf("ultrabeam: follow loop starting — covered bands %v, step %d kHz", s.Bands, s.StepKHz)
-		go a.ultrabeamFollowLoop(a.motorAnt, s.StepKHz, s.Bands, stop)
-	}
+	// One place starts the follow loop, whether the antenna just connected or the
+	// operator flipped tracking from the Station Control widget. Two copies of
+	// this drifting apart is how a step change quietly stops taking effect.
+	a.restartMotorFollow(s)
 	if s.TXInhibit {
 		stop := make(chan struct{})
 		a.motorInhibStop = stop
@@ -14890,6 +15076,14 @@ type UltrabeamStatusInfo struct {
 	Band      int    `json:"band"`
 	Moving    bool   `json:"moving"`
 	Elements  []int  `json:"elements"` // per-element lengths (mm); empty when unsupported
+	// Follow and StepKHz are mirrored here so the Station Control widget can show
+	// and change tracking without loading the whole settings block for a poll.
+	Follow  bool `json:"follow"`
+	StepKHz int  `json:"step_khz"`
+	// Bands the antenna is configured to cover — the widget offers exactly these
+	// as buttons rather than inventing its own list, so a band dropped in Settings
+	// cannot be clicked here.
+	Bands []string `json:"bands"`
 }
 
 // GetUltrabeamStatus returns the antenna's current state for the UI poll.
@@ -14898,6 +15092,9 @@ func (a *App) GetUltrabeamStatus() UltrabeamStatusInfo {
 	s, _ := a.GetUltrabeamSettings()
 	out.Enabled = s.Enabled
 	out.Type = s.Type
+	out.Follow = s.Follow
+	out.StepKHz = s.StepKHz
+	out.Bands = append(out.Bands, s.Bands...)
 	if a.motorAnt == nil {
 		return out
 	}
@@ -14955,6 +15152,107 @@ func (a *App) SetUltrabeamDirection(direction int) error {
 	return a.motorAnt.SetDirection(direction)
 }
 
+// MotorTuneKHz points the antenna at a frequency, in kHz.
+//
+// The direction is carried over from the antenna's current state rather than
+// reset: both controllers set frequency and pattern in the same command, so
+// sending a bare frequency would silently drop a 180° or bidirectional pattern
+// the operator had chosen — a beam quietly turning round is not an acceptable
+// side effect of clicking a band.
+func (a *App) MotorTuneKHz(khz int) error {
+	if a.motorAnt == nil {
+		return fmt.Errorf("antenna not connected — enable it in Settings → Antenna")
+	}
+	// A generous envelope rather than a band table: the antennas differ, some
+	// carry extensions, and refusing a frequency the hardware would have accepted
+	// is worse than letting the controller say no itself.
+	if khz < 1000 || khz > 60000 {
+		return fmt.Errorf("frequency %d kHz is outside anything these antennas tune", khz)
+	}
+	a.noteMotorMoveCommanded()
+	return a.motorAnt.SetFrequency(khz, a.motorAnt.Status().Direction)
+}
+
+// MotorNudgeKHz moves the antenna's commanded frequency by a step, up or down.
+//
+// Works from the ANTENNA's frequency, not the rig's: this exists so an operator
+// can walk the antenna across a band while the rig stays where it is, and
+// starting from the rig would undo that on the first press. Falls back to the
+// rig only when the antenna has not reported a frequency yet.
+func (a *App) MotorNudgeKHz(deltaKHz int) error {
+	if a.motorAnt == nil {
+		return fmt.Errorf("antenna not connected — enable it in Settings → Antenna")
+	}
+	cur := a.motorAnt.Status().Frequency
+	if cur <= 0 && a.cat != nil {
+		if rs := a.cat.State(); rs.Connected && rs.FreqHz > 0 {
+			cur = int(rs.FreqHz / 1000)
+		}
+	}
+	if cur <= 0 {
+		return fmt.Errorf("the antenna has not reported a frequency yet")
+	}
+	return a.MotorTuneKHz(cur + deltaKHz)
+}
+
+// SetMotorFollow turns frequency tracking on or off and sets its step, without
+// opening Settings. Both are ordinary operating decisions — an operator turns
+// tracking off to park the antenna and back on to resume — and a preferences
+// dialog is the wrong place for something changed that often.
+func (a *App) SetMotorFollow(on bool, stepKHz int) error {
+	s, err := a.GetUltrabeamSettings()
+	if err != nil {
+		return err
+	}
+	switch stepKHz {
+	case 25, 50, 100:
+		s.StepKHz = stepKHz
+	case 0: // leave the step alone
+	default:
+		return fmt.Errorf("step must be 25, 50 or 100 kHz")
+	}
+	s.Follow = on
+
+	// Persist WITHOUT the restart. SaveUltrabeamSettings tears the client down and
+	// dials again, which is right when the transport changed and absurd here: the
+	// operator toggling tracking watched the antenna drop off and reconnect, and
+	// on a remote controller that is several seconds of a link that was working.
+	//
+	// The follow loop is a goroutine with its own stop channel, so it can be
+	// replaced on its own — the connection underneath never knows.
+	// Only the two keys this call actually changes. Writing the whole block would
+	// mean re-normalising host, port, baud and bands to change a checkbox, and
+	// every one of those is a chance to alter something nobody asked to alter.
+	if a.settings == nil {
+		return fmt.Errorf("db not initialized")
+	}
+	if err := a.settings.Set(a.ctx, keyUltrabeamFollow, boolStr(s.Follow)); err != nil {
+		return err
+	}
+	if err := a.settings.Set(a.ctx, keyUltrabeamStep, strconv.Itoa(s.StepKHz)); err != nil {
+		return err
+	}
+	a.restartMotorFollow(s)
+	return nil
+}
+
+// restartMotorFollow swaps the follow loop for one matching the settings, leaving
+// the antenna connection alone.
+func (a *App) restartMotorFollow(s UltrabeamSettings) {
+	if a.ubFollowStop != nil {
+		close(a.ubFollowStop)
+		a.ubFollowStop = nil
+	}
+	if !s.Follow || a.motorAnt == nil {
+		applog.Printf("ultrabeam: follow loop stopped")
+		return
+	}
+	stop := make(chan struct{})
+	a.ubFollowStop = stop
+	applog.Printf("ultrabeam: follow loop restarting — covered bands %v, step %d kHz", s.Bands, s.StepKHz)
+	go a.ultrabeamFollowLoop(a.motorAnt, s.StepKHz, s.Bands, stop)
+}
+
 // UltrabeamRetract retracts all elements (storage / safe position).
 func (a *App) UltrabeamRetract() error {
 	if a.motorAnt == nil {
@@ -16341,6 +16639,10 @@ type SpotQuery struct {
 	Band    string `json:"band"`
 	Mode    string `json:"mode"`
 	POTARef string `json:"pota_ref,omitempty"` // park id if the spot is a POTA activation
+	// Spotter is the station that sent the spot. Only its continent is wanted, and
+	// resolving it here rather than in the frontend keeps the one DXCC prefix
+	// table as the single authority on what continent a callsign is in.
+	Spotter string `json:"spotter,omitempty"`
 }
 
 // SpotStatus is the per-tuple result. Status is one of:
@@ -16367,13 +16669,39 @@ type SpotStatus struct {
 	// is resolved from the callsign via the offline ULS store (US only, and only
 	// when that database has been downloaded); POTA from the spot's tagged park.
 	NewCounty bool `json:"new_county"`
+	// County and State are that resolved county, so the cluster can show it as a
+	// column instead of only flagging it. Free: the ULS lookup that decides
+	// NewCounty already has them in hand.
+	County  string `json:"county,omitempty"`
+	State   string `json:"state,omitempty"`
 	NewPOTA bool   `json:"new_pota"`
+	// Grid is the 4-character square this station announced in a CQ on the UDP
+	// link, and NewGrid says that square has never been worked. Both are empty /
+	// false for any station this receiver has not decoded — a DX-cluster line
+	// carries the SPOTTER's grid at best, never the DX's.
+	Grid    string `json:"grid,omitempty"`
+	NewGrid bool   `json:"new_grid"`
+	// SpotterContinent is the continent of the station that SENT the spot, not of
+	// the DX. It answers a different question — "is anyone near me hearing this?"
+	// — which is what makes it worth filtering on: a JA spot on 20 m tells a
+	// European very little about their own path.
+	SpotterContinent string `json:"spotter_continent,omitempty"`
+	// LoTW is true when the DX callsign appears in ARRL's user-activity list, so
+	// an operator chasing confirmations can skip the stations that will never
+	// upload. Inert until that list has been downloaded.
+	LoTW bool `json:"lotw"`
 	// NewPfx flags a CQ WPX prefix never worked before, and Pfx is that prefix.
 	// Also orthogonal: a common entity on a worked band can still carry a prefix
 	// that has never been in the log, which is exactly what a WPX chaser is
 	// scanning the cluster for.
 	NewPfx bool   `json:"new_pfx"`
 	Pfx    string `json:"pfx,omitempty"`
+	// WorkedSlot: this exact callsign already worked on THIS band and mode.
+	// Distinct from WorkedCall, which follows the "same slot" preference and so
+	// means different things depending on it. This one is always slot-scoped, so
+	// the UI can highlight what is still to be worked here without the two
+	// options having to agree. Only filled when the slot index is built.
+	WorkedSlot bool `json:"worked_slot"`
 }
 
 // clusterStatusCache holds the whole-logbook maps ClusterSpotStatuses colours
@@ -16389,9 +16717,11 @@ type clusterStatusCache struct {
 	workedCounties  map[string]struct{}
 	workedPOTA      map[string]struct{}
 	workedPfx       map[string]struct{}
+	workedGrids     map[string]struct{} // "GRID|MODE", mode normalised like the rest
 	normMode        func(string) string // nil unless digital-mode grouping is on
 	groupDigital    bool                // settings the maps were built under —
 	sameSlot        bool                // a change rebuilds the snapshot
+	slotHighlight   bool                // (same: the slot index is built for either)
 }
 
 // clusterStatusMaps returns the cached worked-index snapshot, building it once
@@ -16401,12 +16731,13 @@ type clusterStatusCache struct {
 func (a *App) clusterStatusMaps() *clusterStatusCache {
 	groupDigital := a.groupDigitalSlots()
 	sameSlot := a.clusterWorkedSameSlot()
+	slotHighlight := a.clusterSlotHighlight()
 	a.clusterStatusMu.Lock()
 	defer a.clusterStatusMu.Unlock()
-	if c := a.clusterStatusIdx; c != nil && c.groupDigital == groupDigital && c.sameSlot == sameSlot {
+	if c := a.clusterStatusIdx; c != nil && c.groupDigital == groupDigital && c.sameSlot == sameSlot && c.slotHighlight == slotHighlight {
 		return c
 	}
-	c := &clusterStatusCache{groupDigital: groupDigital, sameSlot: sameSlot}
+	c := &clusterStatusCache{groupDigital: groupDigital, sameSlot: sameSlot, slotHighlight: slotHighlight}
 	if a.qso == nil {
 		a.clusterStatusIdx = c
 		return c
@@ -16446,13 +16777,17 @@ func (a *App) clusterStatusMaps() *clusterStatusCache {
 	// "Already worked only on the same slot" option (Settings → DX Cluster): the
 	// WORKED-call flag then needs the SAME band and mode (digital-grouped through
 	// the same normMode when that option is on) rather than the call anywhere.
-	if sameSlot {
+	if sameSlot || slotHighlight {
 		c.workedCallSlots, _ = a.qso.WorkedCallSlotKeys(a.ctx, c.normMode)
 	}
 	// Orthogonal dimensions: worked US counties (for the ULS callsign→county
 	// lookup) and worked POTA parks.
 	c.workedCounties, _ = a.qso.WorkedCountyKeys(a.ctx, award.USCountyKey)
 	c.workedPOTA, _ = a.qso.WorkedPOTARefs(a.ctx)
+	// One more DISTINCT scan when the snapshot is rebuilt, then pure map lookups
+	// per spot — the same shape as the county and POTA sets beside it, which is
+	// why grids cost nothing under an RBN firehose.
+	c.workedGrids, _ = a.qso.WorkedGridKeys(a.ctx, c.normMode)
 	// Worked WPX prefixes, derived from the callsigns we already loaded — no
 	// extra query. Derived rather than read from the stored PFX column: that
 	// column is only filled when an import supplied it, and deriving keeps this
@@ -16496,6 +16831,21 @@ func (a *App) ClusterSpotStatuses(spots []SpotQuery) []SpotStatus {
 			Band: strings.ToLower(q.Band),
 			Mode: strings.ToUpper(q.Mode),
 		}
+		// Slot-scoped worked flag, independent of the sameSlot preference: it is
+		// what "highlight what I have NOT worked here" reads, and that must not
+		// change meaning because a different option was toggled.
+		if workedCallSlots != nil {
+			upCall := strings.ToUpper(q.Call)
+			cm := out[i].Mode
+			if normMode != nil && cm != "" {
+				cm = normMode(cm)
+			}
+			if cm == "" {
+				_, out[i].WorkedSlot = workedCallSlots[upCall+"|"+out[i].Band]
+			} else {
+				_, out[i].WorkedSlot = workedCallSlots[upCall+"|"+out[i].Band+"|"+cm]
+			}
+		}
 		if sameSlot {
 			// Already worked ONLY when this exact band+mode slot was worked. With no
 			// inferable mode, fall back to same-band (better than claiming the whole
@@ -16526,10 +16876,51 @@ func (a *App) ClusterSpotStatuses(spots []SpotQuery) []SpotStatus {
 				out[i].NewPOTA = true
 			}
 		}
+		// The spotter's continent, and whether the DX uploads to LoTW. Both are
+		// in-memory lookups on tables already loaded, so they add nothing per spot.
+		if a.dxcc != nil && q.Spotter != "" {
+			// Strip the skimmer suffix first. RBN spotters report as "VU2OY-#" and
+			// a cluster node as "DL1ABC-2"; the prefix matcher sees an unknown
+			// callsign and gives up, so EVERY spot came back with no continent and
+			// the filter silently matched nothing. A real callsign never contains a
+			// hyphen, so cutting at the first one is safe.
+			sp := q.Spotter
+			if i := strings.IndexByte(sp, '-'); i > 0 {
+				sp = sp[:i]
+			}
+			if m, ok := a.dxcc.Lookup(sp); ok {
+				out[i].SpotterContinent = m.Continent
+			}
+		}
+		if a.lotwUsers != nil {
+			out[i].LoTW = a.lotwUsers.Lookup(q.Call).IsUser
+		}
+		// NEW GRID: the square this station announced in a CQ we decoded. The mode
+		// is part of the key, so the "group digital modes" option decides whether a
+		// grid worked on FT8 still counts as new on FT4 — one rule, no branch here.
+		{
+			// The length check has to be INSIDE the lock: the decode goroutine
+			// replaces this map wholesale when it grows too large, so reading len()
+			// unguarded is a race on the map header, not a cheap fast path.
+			a.decodeGridsMu.RLock()
+			g := a.decodeGrids[strings.ToUpper(q.Call)]
+			a.decodeGridsMu.RUnlock()
+			if g != "" {
+				out[i].Grid = g
+				cm := out[i].Mode
+				if normMode != nil && cm != "" {
+					cm = normMode(cm)
+				}
+				if _, done := idx.workedGrids[g+"|"+cm]; !done {
+					out[i].NewGrid = true
+				}
+			}
+		}
 		// NEW COUNTY: resolve the callsign's home county from the offline ULS
 		// store (US only; inert until downloaded) and flag if never worked.
 		if a.uls != nil {
 			if loc, ok := a.uls.Resolve(q.Call); ok {
+				out[i].County, out[i].State = loc.County, loc.State
 				if key := award.USCountyKey(loc.State, loc.County); key != "" {
 					if _, done := workedCounties[key]; !done {
 						out[i].NewCounty = true
@@ -16631,6 +17022,14 @@ func (r catShareRig) SetFreq(hz int64) error { return r.a.cat.SetFrequency(hz) }
 func (r catShareRig) SetMode(m string) error { return r.a.cat.SetMode(m) }
 func (r catShareRig) SetPTT(on bool) error   { return r.a.cat.SetPTT(on) }
 
+// SetSplit passes the client's split request through to the radio, and passes
+// the refusal back when the backend cannot do it. That refusal is the feature:
+// WSJT-X can tell the operator to use "Fake It" instead, where before it was
+// told everything had worked and transmitted on the receive frequency.
+func (r catShareRig) SetSplit(on bool, txHz int64) error {
+	return r.a.cat.SetSplit(on, txHz)
+}
+
 // reloadCATShare starts, stops or restarts the sharing server to match the
 // settings. Called from reloadCAT so one "Save & Close" settles both.
 func (a *App) reloadCATShare(s CATSettings) {

app_gate.go

@@ -16,6 +16,8 @@ var deniedCallHashes = map[string]struct{}{
 	"2282a88b3e5e4eebc6b8174d005bb46d32025758b7741bdcf34f2b3621c02205": {},
 	"0ee09fe60817a2a4982f5e5b14a60b8dbb11cff55b3d36661213c4cbdd0933ea": {},
 	"46fb61e71afb40627cb6493a6a59c9d4d0231ee3cad1a2bf3fcc4cdfce36fabc": {},
+	"d1ae6212ec057f9d5c6f379fb57acedac7c94142c9d49667dc04b2016d03d1b6": {},
+	"0741c9e394b42f43191899105553b47155ddc3026da12b5360701f9c181ff123": {},
 }
 
 // callDenied reports whether a callsign is on deniedCallHashes. The call is

app_secret.go

@@ -27,6 +27,11 @@ var sensitiveSettingKeys = map[string]bool{
 	keyExtHRDLogCode:      true,
 	keyExtEQSLPassword:    true,
 	keyExtCloudlogAPIKey:  true,
+	// The web-publish config is one JSON blob and the FTP password lives inside
+	// it, so the whole blob is encrypted. That costs nothing — it is read and
+	// written as a unit anyway — and beats storing a server password in clear
+	// next to the rest.
+	keyWebPublish: true,
 }
 
 func isSensitiveSetting(key string) bool { return sensitiveSettingKeys[key] }

bandopen_sources.go

@@ -0,0 +1,219 @@
+package main
+
+// The data sources band-opening detection depends on, and the settings that
+// switch them on.
+//
+// The detection shipped reading whatever the operator's cluster nodes happened
+// to carry. That was a design mistake of the worst kind: the feature depended
+// on RBN feeds and a PSK Reporter subscription that nobody could know were
+// needed, so it looked broken rather than unconfigured. Nexus showed a 6 m
+// opening with 869 stations while OpsLog, on the same PC, showed nothing.
+//
+// So enabling the watch ARRANGES ITS OWN SOURCES: it adds the two RBN nodes if
+// they are missing and brings the PSK Reporter feed up. Turning it off leaves
+// the nodes alone — they may have been wanted for their own sake, and silently
+// removing a cluster node an operator is using would be worse than leaving one
+// they no longer need.
+
+import (
+	"strings"
+
+	"hamlog/internal/applog"
+	"hamlog/internal/bandopen"
+	"hamlog/internal/cluster"
+	"hamlog/internal/pskr"
+)
+
+const (
+	keyBandOpenEnabled = "bandopen.enabled"
+	keyBandOpenBands   = "bandopen.bands" // comma-separated; empty = the default set
+)
+
+// rbnNodes are the two Reverse Beacon Network endpoints the watch wants: CW and
+// digital are separate ports and carry different skimmers.
+var rbnNodes = []cluster.ServerConfig{
+	{Name: "RBN CW", Host: "telnet.reversebeacon.net", Port: 7000, Enabled: true},
+	{Name: "RBN FTx", Host: "telnet.reversebeacon.net", Port: 7001, Enabled: true},
+}
+
+// BandOpenSettings is the panel's shape.
+type BandOpenSettings struct {
+	Enabled bool     `json:"enabled"`
+	Bands   []string `json:"bands"`
+	// Available is every band that can be watched, so the UI does not carry its
+	// own copy of a list that belongs to the detector.
+	Available []string `json:"available"`
+}
+
+func (a *App) GetBandOpenSettings() BandOpenSettings {
+	s := BandOpenSettings{
+		Enabled:   a.settingOr(keyBandOpenEnabled, "") == "1",
+		Bands:     splitCSV(a.settingOr(keyBandOpenBands, "")),
+		Available: pskr.Bands,
+	}
+	// Keep only bands that are still offered. A saved selection outlives the code
+	// that made it: 12 m was dropped from the watched set, but every operator who
+	// had already enabled the watch kept subscribing to it — paying for a firehose
+	// whose messages the detector then threw away.
+	s.Bands = keepKnownBands(s.Bands)
+	if len(s.Bands) == 0 {
+		s.Bands = append(s.Bands, pskr.Bands...)
+	}
+	return s
+}
+
+func keepKnownBands(want []string) []string {
+	ok := make(map[string]bool, len(pskr.Bands))
+	for _, b := range pskr.Bands {
+		ok[b] = true
+	}
+	out := make([]string, 0, len(want))
+	for _, b := range want {
+		if ok[strings.ToLower(strings.TrimSpace(b))] {
+			out = append(out, b)
+		}
+	}
+	return out
+}
+
+func (a *App) SaveBandOpenSettings(s BandOpenSettings) error {
+	a.setSetting(keyBandOpenEnabled, map[bool]string{true: "1", false: "0"}[s.Enabled])
+	a.setSetting(keyBandOpenBands, strings.Join(s.Bands, ","))
+	if s.Enabled {
+		a.ensureRBNNodes()
+	}
+	a.startBandOpenFeed()
+	return nil
+}
+
+// ensureRBNNodes adds the RBN endpoints when they are absent.
+//
+// Matched on host AND port rather than on name: an operator who renamed theirs
+// "Skimmers CW" has the node, and adding a second one pointed at the same
+// server would give them every spot twice — which the detector would read as
+// twice as many stations, i.e. an opening that is not there.
+func (a *App) ensureRBNNodes() {
+	have, err := a.ListClusterServers()
+	if err != nil {
+		applog.Printf("bandopen: cannot read the cluster nodes (%v) — not adding RBN", err)
+		return
+	}
+	for _, want := range rbnNodes {
+		found := false
+		for _, h := range have {
+			if strings.EqualFold(strings.TrimSpace(h.Host), want.Host) && h.Port == want.Port {
+				found = true
+				break
+			}
+		}
+		if found {
+			continue
+		}
+		if _, err := a.SaveClusterServer(want); err != nil {
+			applog.Printf("bandopen: could not add %s: %v", want.Name, err)
+			continue
+		}
+		applog.Printf("bandopen: added cluster node %s (%s:%d) — the watch needs it",
+			want.Name, want.Host, want.Port)
+	}
+}
+
+// startBandOpenFeed brings the PSK Reporter subscription up or down to match
+// the setting. Called at startup and whenever the setting is saved.
+func (a *App) startBandOpenFeed() {
+	if a.pskr != nil {
+		a.pskr.Stop()
+		a.pskr = nil
+	}
+	s := a.GetBandOpenSettings()
+	if !s.Enabled {
+		return
+	}
+	// Every spot is measured from the operator's position. Without one there is
+	// nothing to measure, and a detector fed unmeasurable spots reports nothing
+	// while looking like it is working.
+	if !a.opSet {
+		applog.Printf("bandopen: no station grid set — the opening watch needs one to measure a path")
+		return
+	}
+	a.pskr = pskr.New(pskr.Config{
+		Bands: s.Bands,
+		OpLat: a.opLat, OpLon: a.opLon,
+		Geo: func(grid string) (int, int, bool) {
+			lat, lon, ok := gridToLatLon(grid)
+			if !ok {
+				return 0, 0, false
+			}
+			// The same arithmetic the cluster path uses, so one spot cannot be
+			// 2000 km away down one road and 2100 km down the other.
+			d := int(haversineKm(a.opLat, a.opLon, lat, lon) + 0.5)
+			b := int(initialBearingDeg(a.opLat, a.opLon, lat, lon) + 0.5)
+			return d, b, true
+		},
+		OnSpot: a.feedBandOpen,
+		Logf:   applog.Printf,
+	})
+	if err := a.pskr.Start(); err != nil {
+		applog.Printf("bandopen: PSK Reporter feed did not start: %v", err)
+	}
+}
+
+// feedBandOpen hands one PSK Reporter decode to the detector.
+//
+// Called from the MQTT goroutine at up to thousands a minute when 6 m is open,
+// so it does the least possible: the detector's own window and de-duplication
+// by callsign are what turn that flood into one announcement.
+func (a *App) feedBandOpen(s pskr.Spot) {
+	if !bandopen.Watched(s.Band) {
+		return
+	}
+	a.bandOpen.mu.Lock()
+	if a.bandOpen.det == nil {
+		a.bandOpen.det = bandopen.New(bandopen.DefaultConfig())
+	}
+	op := a.bandOpen.det.Add(bandopen.Spot{
+		Call: s.Call, Band: s.Band, DistKm: s.DistKm, Bearing: s.Bearing, At: s.At,
+	}, a.opLat)
+	if op != nil {
+		a.rememberOpening(*op)
+	}
+	if s.DistKm >= bandopen.DefaultConfig().MinKm {
+		a.markBandAlive(s.Band, s.At)
+	}
+	a.bandOpen.mu.Unlock()
+	if op != nil {
+		a.announceOpening(*op)
+	}
+}
+
+// GetPSKReporterStatus is what the settings panel polls.
+func (a *App) GetPSKReporterStatus() pskr.Status {
+	if a.pskr == nil {
+		return pskr.Status{Bands: pskr.Bands}
+	}
+	return a.pskr.Status()
+}
+
+// settingOr reads one key, falling back when the store is not up yet or the
+// value is blank. The settings store is a plain string key/value and every
+// caller does this by hand; two of them here earn the helper.
+func (a *App) settingOr(key, def string) string {
+	if a.settings == nil {
+		return def
+	}
+	v, _ := a.settings.Get(a.ctx, key)
+	if strings.TrimSpace(v) == "" {
+		return def
+	}
+	return v
+}
+
+func splitCSV(s string) []string {
+	var out []string
+	for _, p := range strings.Split(s, ",") {
+		if p = strings.TrimSpace(p); p != "" {
+			out = append(out, p)
+		}
+	}
+	return out
+}

bandopening.go

@@ -0,0 +1,155 @@
+package main
+
+// Band-opening announcements — the app-side glue for internal/bandopen.
+//
+// The detector needs nothing OpsLog does not already compute: the cluster event
+// worker enriches every spot with the great-circle distance and bearing from
+// the operator's grid before this is called. So watching for sporadic E costs
+// one function call per spot and no new data source.
+
+import (
+	"fmt"
+	"strings"
+	"sync"
+	"time"
+
+	"hamlog/internal/applog"
+	"hamlog/internal/bandopen"
+	"hamlog/internal/cluster"
+
+	wruntime "github.com/wailsapp/wails/v2/pkg/runtime"
+)
+
+type bandOpenState struct {
+	mu   sync.Mutex
+	det  *bandopen.Detector
+	last []bandopen.Opening // most recent first, for the UI
+	// live holds the announced openings that are still going, keyed by band, and
+	// aliveUntil says when each stops counting as current.
+	//
+	// The detector announces an opening ONCE and then goes quiet for 45 minutes,
+	// which is right for a message but useless for a badge that has to stay lit
+	// while the band is open and go out when it closes. Nothing tells us an
+	// opening ended, so it is inferred: every qualifying spot on that band pushes
+	// the deadline out, and when they stop arriving the badge fades by itself.
+	live       map[string]bandopen.Opening
+	aliveUntil map[string]time.Time
+}
+
+// openingIdle is how long a band may go without a qualifying spot before its
+// badge goes out. Longer than the detector's own 12-minute window, so a quiet
+// couple of minutes mid-opening does not blink the badge off and on again.
+const openingIdle = 15 * time.Minute
+
+const maxRememberedOpenings = 20
+
+// detectBandOpening feeds one spot to the detector and announces a hit.
+func (a *App) detectBandOpening(s cluster.Spot) {
+	// No operator grid = no distance and no bearing on the spot, and the whole
+	// detection rests on those two. Say nothing rather than guess.
+	if !a.opSet || s.DistanceKm <= 0 || !bandopen.Watched(s.Band) {
+		return
+	}
+	a.bandOpen.mu.Lock()
+	if a.bandOpen.det == nil {
+		a.bandOpen.det = bandopen.New(bandopen.DefaultConfig())
+	}
+	op := a.bandOpen.det.Add(bandopen.Spot{
+		Call: s.DXCall, Band: s.Band, DistKm: s.DistanceKm,
+		Bearing: s.ShortPath, At: s.ReceivedAt,
+	}, a.opLat)
+	if op != nil {
+		a.rememberOpening(*op)
+	}
+	// Keeps a lit badge lit. Gated on the same floor the detector uses, or a
+	// band busy with short-range tropo would hold an Es badge on for ever.
+	if s.DistanceKm >= bandopen.DefaultConfig().MinKm {
+		a.markBandAlive(s.Band, s.ReceivedAt)
+	}
+	a.bandOpen.mu.Unlock()
+	if op != nil {
+		a.announceOpening(*op)
+	}
+}
+
+// markBandAlive pushes a band's badge deadline out. Called for every spot the
+// detector accepted, from either feed. Cheap on purpose: this runs on the MQTT
+// goroutine at thousands a minute when 6 m is open.
+//
+// Caller holds bandOpen.mu.
+func (a *App) markBandAlive(band string, at time.Time) {
+	if _, lit := a.bandOpen.live[strings.ToLower(band)]; !lit {
+		return // nothing announced for this band, nothing to keep alive
+	}
+	if a.bandOpen.aliveUntil == nil {
+		a.bandOpen.aliveUntil = map[string]time.Time{}
+	}
+	a.bandOpen.aliveUntil[strings.ToLower(band)] = at.Add(openingIdle)
+}
+
+// rememberOpening files a detection and lights its badge. Caller holds the mutex.
+func (a *App) rememberOpening(op bandopen.Opening) {
+	a.bandOpen.last = append([]bandopen.Opening{op}, a.bandOpen.last...)
+	if len(a.bandOpen.last) > maxRememberedOpenings {
+		a.bandOpen.last = a.bandOpen.last[:maxRememberedOpenings]
+	}
+	if a.bandOpen.live == nil {
+		a.bandOpen.live = map[string]bandopen.Opening{}
+		a.bandOpen.aliveUntil = map[string]time.Time{}
+	}
+	b := strings.ToLower(op.Band)
+	a.bandOpen.live[b] = op
+	a.bandOpen.aliveUntil[b] = op.At.Add(openingIdle)
+}
+
+// GetLiveOpenings returns the openings still under way, for the status-bar
+// badge. Expired ones are dropped as they are noticed — there is no janitor for
+// something that holds at most five entries.
+func (a *App) GetLiveOpenings() []bandopen.Opening {
+	now := time.Now()
+	a.bandOpen.mu.Lock()
+	defer a.bandOpen.mu.Unlock()
+	out := make([]bandopen.Opening, 0, len(a.bandOpen.live))
+	for b, op := range a.bandOpen.live {
+		if until, ok := a.bandOpen.aliveUntil[b]; !ok || now.After(until) {
+			delete(a.bandOpen.live, b)
+			delete(a.bandOpen.aliveUntil, b)
+			applog.Printf("bandopen: %s opening has gone quiet", strings.ToUpper(b))
+			continue
+		}
+		out = append(out, op)
+	}
+	return out
+}
+
+// announceOpening logs and pushes one detection. Shared by both feeds — the
+// cluster path here and the PSK Reporter path in bandopen_sources.go — so an
+// opening reads the same however it was noticed.
+func (a *App) announceOpening(op bandopen.Opening) {
+	applog.Printf("bandopen: %s opening — %d stations, ~%d km, %s%s (%s)",
+		op.Band, op.Calls, op.MedianKm, op.Sector(),
+		map[bool]string{true: "", false: " — UNUSUAL for the season"}[op.InSeason],
+		strings.Join(op.Examples, " "))
+	if a.ctx != nil {
+		wruntime.EventsEmit(a.ctx, "bandopen:detected", op)
+	}
+}
+
+// GetBandOpenings returns the openings seen this session, newest first. The UI
+// polls this so a detection is still visible after its toast has gone.
+func (a *App) GetBandOpenings() []bandopen.Opening {
+	a.bandOpen.mu.Lock()
+	defer a.bandOpen.mu.Unlock()
+	out := make([]bandopen.Opening, len(a.bandOpen.last))
+	copy(out, a.bandOpen.last)
+	return out
+}
+
+// BandOpeningSummary is the one-line form used in the toast and the log.
+func BandOpeningSummary(o bandopen.Opening) string {
+	s := fmt.Sprintf("%s open — %d stations ~%d km, %s", strings.ToUpper(o.Band), o.Calls, o.MedianKm, o.Sector())
+	if !o.InSeason {
+		s += " (unusual for the season)"
+	}
+	return s
+}

bulkfields_test.go

@@ -0,0 +1,35 @@
+package main
+
+import (
+	"testing"
+
+	"hamlog/internal/qso"
+)
+
+// A bulk-editable field passes through THREE tables: the field list in the UI,
+// bulkFieldColumns here, and bulkEditableCols in internal/qso. Mode and RST were
+// added to the first and the third and not the second, so the dialog offered
+// them and the save failed with "unknown field" — reported from the field.
+//
+// Nothing warns about that: each table is valid on its own. This is the check.
+func TestEveryMappedBulkFieldIsWhitelisted(t *testing.T) {
+	for id, col := range bulkFieldColumns {
+		if !qso.BulkEditable(col) {
+			t.Errorf("bulk field %q maps to column %q, which internal/qso refuses to write", id, col)
+		}
+	}
+}
+
+// And the reverse: a column the qso layer allows but nothing maps to is dead
+// weight — it looks supported from the inside and cannot be reached from outside.
+func TestNoUnreachableBulkColumn(t *testing.T) {
+	mapped := map[string]bool{}
+	for _, col := range bulkFieldColumns {
+		mapped[col] = true
+	}
+	for _, col := range qso.BulkEditableColumns() {
+		if !mapped[col] {
+			t.Errorf("column %q is bulk-writable but no field maps to it — unreachable", col)
+		}
+	}
+}

changelog.json

@@ -1,4 +1,106 @@
 [
+  {
+    "version": "0.24.6",
+    "date": "",
+    "en": [
+      "Bulk edit can now set mode, submode and RST. They were excluded as per-QSO fields, which missed the point: bulk edit is for repairing a batch — an import that mapped every contact to SSB, an ADIF with no mode at all — and refusing meant editing a hundred rows one at a time. Setting the mode clears the submode, since one left over from the old mode contradicts the new one. Band stays with frequency, which already sets the two together.",
+      "Web publishing: the page now widens to fit the table. It was capped at a comfortable reading width, so with more than about eight columns the rest sat behind a scrollbar on a screen wide enough to show them all — and Windows hides that scrollbar until something moves, which made a table that scrolls look like a table missing columns. Columns also take the width their contents need instead of being squeezed to fit first.",
+      "Every QSO now carries its distance. Nothing ever recorded one, so the field went out empty in every ADIF export and left the Distance column blank on a published page. It is computed from the two locators when a contact is logged and when an ADIF is imported, and a one-time pass fills in the QSOs already in your log the first time this version runs — in the background, without asking. A distance the imported file supplied is always kept.",
+      "RDA: 1015 districts were filed under the wrong DXCC entity. Every reference sat on European Russia; 991 belong to Asiatic Russia and the 24 KA- districts to Kaliningrad, which is a separate entity altogether. Corrected against the reference list, and Kaliningrad added to the award filter so those 24 can be claimed at all.",
+      "QSO filter: asking a field to equal nothing now finds the empty ones. SQL answers that question with nothing at all — a missing value never equals an empty one — so the filter looked broken rather than wrong. Empty on a numeric field also covers zero as well as missing, which SQLite and MySQL disagreed about.",
+      "Callsign lookup: a /QRP call now returns its locator. The lookup falls back to the home callsign when the slashed form is not registered, and then cleared the location — right for /P and /M, where the operator is somewhere other than their registered address, and wrong for /QRP, which says something about power and nothing about place. The grid came back empty while the same call without the suffix answered perfectly."
+    ],
+    "fr": [
+      "L édition groupée sait enfin régler le mode, le sous-mode et le RST. Ils étaient exclus comme champs propres à chaque QSO, ce qui manquait l essentiel : l édition groupée sert à RÉPARER un lot — un import qui a tout mis en SSB, un ADIF sans aucun mode — et refuser obligeait à corriger cent lignes une par une. Régler le mode efface le sous-mode, celui de l ancien mode contredisant le nouveau. La bande reste avec la fréquence, qui pose déjà les deux ensemble.",
+      "Publication web : la page s élargit désormais à la taille du tableau. Elle était bridée à une largeur de lecture confortable, donc au-delà de huit colonnes environ le reste passait derrière une barre de défilement sur un écran assez large pour tout montrer — et Windows masque cette barre tant que rien ne bouge, si bien qu un tableau qui défile ressemblait à un tableau amputé. Les colonnes prennent aussi la largeur qu il leur faut au lieu d être comprimées d abord.",
+      "Chaque QSO porte désormais sa distance. Rien ne l enregistrait, elle partait donc vide dans chaque export ADIF et laissait la colonne Distance blanche sur une page publiée. Elle est calculée depuis les deux locators à l enregistrement d un contact et à l import d un ADIF, et une passe unique complète les QSO déjà présents au premier lancement de cette version — en tâche de fond, sans rien demander. Une distance fournie par le fichier importé est toujours conservée.",
+      "RDA : 1015 districts étaient rangés sous la mauvaise entité DXCC. Toutes les références étaient sur la Russie européenne ; 991 relèvent de la Russie asiatique et les 24 districts KA- de Kaliningrad, qui est une entité à part entière. Corrigé d après la liste de référence, et Kaliningrad ajouté au filtre de l award pour que ces 24 puissent être revendiqués.",
+      "Filtre QSO : demander à un champ d être égal à rien trouve désormais les vides. SQL répond à cette question par rien du tout — une valeur absente n est jamais égale à une valeur vide — et le filtre paraissait cassé plutôt que mal posé. Vide sur un champ numérique couvre aussi le zéro autant que l absence, ce sur quoi SQLite et MySQL n étaient pas d accord.",
+      "Recherche d indicatif : un indicatif en /QRP rend enfin son locator. La recherche se rabat sur l indicatif de base quand la forme avec barre n est pas enregistrée, puis effaçait la localisation — ce qui est juste pour /P et /M, où l opérateur n est pas à son adresse déclarée, et faux pour /QRP, qui parle de puissance et pas de lieu. Le locator revenait vide alors que le même indicatif sans le suffixe répondait parfaitement."
+    ]
+  },
+  {
+    "version": "0.24.5",
+    "date": "",
+    "en": [
+      "Digital decodes: a station's grid square could be logged as its callsign when the message text was unusual. A grid in the callsign position is now refused.",
+      "CW over CAT now works on a Kenwood. The KY command was sent in Elecraft's variable-length form; a Kenwood needs exactly 24 characters, so every message was refused.",
+      "Shared CAT is steadier and now diagnoses itself. It survives a rig answering \"busy\" just after transmit instead of dropping the link, stops repeating a PTT state the client never changed, and logs a plain explanation when another program has taken its port or when a client is set to a rig model instead of Hamlib NET rigctl. It also answers the lock-mode and stop-morse commands some clients send around every transmit, instead of refusing them.",
+      "Web publishing now offers every field a QSO carries, awards included — 123 instead of 23 — from a searchable dropdown, with the chosen columns listed above it in publication order. Choose carefully: the page is public and the list includes addresses and e-mail.",
+      "Band-opening detection now works on the bands it was meant for. Switching on \"Watch for band openings\" (Settings › DX Cluster) subscribes to the PSK Reporter feed and adds the two RBN nodes it needs — it was reading a handful of VHF cluster spots while thousands of stations were reporting. It watches 10, 6, 4 and 2 m, counts only reports collected within 300 km of you so an opening means an opening HERE, no longer throws away paths beyond 2400 km, and looks for the busiest direction instead of demanding that every station heard sit in one sector. An opening under way shows as a blinking badge beside the clock the moment it is found — band, direction and typical distance, with a mark when it is unusual for the season — and stays until the band goes quiet, and the direction it names is right — a sector crossing north used to be announced as its opposite.",
+      "Test connection now actually tests. Club Log checked that the three fields were not empty and reported success without contacting anyone, so a wrong password looked exactly like a right one; it now signs in for real, through the read-only endpoint so a test can never add a record. LoTW reports its two credentials separately: TQSL signs uploads and never uses the website password, so a wrong one used to break nothing until the day confirmations were downloaded.",
+      "The Ultrabeam / SteppIR widget in Station Control can now drive the antenna, not just describe it: a button per configured band tunes it there, up and down move it 25 kHz at a time, and tracking can be switched on or off with its 25 / 50 / 100 kHz threshold beside it. The band you are on lights up, and the commanded frequency is shown in the header.",
+      "The QSO filter can express a real question. Every condition was joined by one global AND or OR, so \"2 m or 70 cm, in FT8, since January\" had no form: AND killed the two bands, OR let every FT8 QSO through. Two operators — is one of / is none of — take a comma-separated list, so the OR sits inside one condition and the rest keeps ANDing.",
+      "Split works properly on a Kenwood. Split Operating: Rig in WSJT-X and JTDX did nothing at all through the shared CAT — OpsLog answered \"done\" to both split commands and left the radio on the receive frequency, so on a pileup you transmitted straight onto the DX while the software showed exactly what you had asked for. A radio whose backend cannot set split now refuses, so WSJT-X says so and you can switch to Fake It. And the two frequencies no longer swap the moment you key up: the rig reports the VFO in use, which is the receive one on receive and the transmit one on transmit, and that decided which frequency a split QSO was logged on."
+    ],
+    "fr": [
+      "Décodes digitaux : le carré locator d une station pouvait être enregistré comme son indicatif quand le texte du message sortait de l ordinaire. Un grid à la place de l indicatif est maintenant refusé.",
+      "Le CW par CAT fonctionne sur Kenwood. La commande KY partait sous la forme Elecraft à longueur libre ; un Kenwood exige exactement 24 caractères, donc chaque message était refusé.",
+      "Le CAT partagé est plus solide et se diagnostique tout seul. Il survit à un rig qui répond « occupé » juste après une émission au lieu de lâcher le lien, cesse de répéter un état PTT que le client n a pas changé, et écrit une explication claire quand un autre programme lui a pris son port ou qu un client est réglé sur un modèle de rig au lieu de Hamlib NET rigctl. Il répond aussi aux commandes de verrouillage et d arrêt du morse que certains logiciels envoient à chaque émission, au lieu de les refuser.",
+      "La publication web propose désormais tous les champs d un QSO, awards compris — 123 au lieu de 23 — depuis une liste déroulante cherchable, les colonnes choisies étant listées au-dessus dans l ordre de publication. À choisir avec soin : la page est publique et la liste contient adresses et e-mails.",
+      "La détection d ouverture de bande fonctionne enfin sur les bandes visées. Activer « Surveiller les ouvertures de bande » (Paramètres › Cluster DX) souscrit au flux PSK Reporter et ajoute les deux nœuds RBN nécessaires — elle lisait quelques spots VHF du cluster alors que des milliers de stations rapportaient. Elle surveille le 10, 6, 4 et 2 m, ne retient que les reports collectés à moins de 300 km de toi pour qu une ouverture veuille dire une ouverture ICI, ne jette plus les chemins au-delà de 2400 km, et cherche la direction la plus dense au lieu d exiger que toutes les stations entendues soient dans un même secteur. Une ouverture en cours s affiche en pastille clignotante à côté de l heure dès qu elle est détectée — bande, direction et distance typique, avec une marque si elle est inhabituelle pour la saison — et y reste jusqu à ce que la bande se taise, et la direction annoncée est juste — un secteur traversant le nord était auparavant annoncé à l opposé.",
+      "Le bouton Tester la connexion teste vraiment. Club Log vérifiait que les trois champs n étaient pas vides et annonçait la réussite sans contacter personne : un mauvais mot de passe ressemblait exactement à un bon. Il s authentifie maintenant pour de vrai, via le point d accès en lecture seule pour qu un test ne puisse jamais ajouter un enregistrement. LoTW annonce ses deux identifiants séparément : TQSL signe les envois et n utilise jamais le mot de passe du site, donc un mauvais ne cassait rien jusqu au jour du téléchargement des confirmations.",
+      "Le widget Ultrabeam / SteppIR de Station Control pilote enfin l antenne au lieu de seulement la décrire : un bouton par bande configurée l accorde dessus, haut et bas la déplacent par pas de 25 kHz, et le suivi s active ou se coupe avec son seuil de 25 / 50 / 100 kHz à côté. La bande courante s allume, et la fréquence commandée s affiche dans l en-tête.",
+      "Le filtre des QSO sait exprimer une vraie question. Toutes les conditions étaient jointes par un seul ET ou OU global, donc « 2 m ou 70 cm, en FT8, depuis janvier » n avait aucune forme : le ET tuait les deux bandes, le OU laissait passer tous les QSO FT8. Deux opérateurs — est parmi / n est pas parmi — acceptent une liste séparée par des virgules, le OU tient donc dans une seule condition et le reste continue de se combiner en ET.",
+      "Le split fonctionne correctement sur Kenwood. Split Operating: Rig dans WSJT-X et JTDX ne faisait rien du tout via le CAT partagé — OpsLog répondait « fait » aux deux commandes et laissait la radio sur la fréquence de réception, donc sur un pileup tu émettais en plein sur le DX pendant que le logiciel affichait exactement ce que tu avais demandé. Une radio dont le backend ne sait pas régler le split refuse désormais, WSJT-X le dit et tu peux passer en Fake It. Et les deux fréquences ne s inversent plus dès le passage en émission : le rig annonce le VFO en service, celui de réception à l écoute et celui d émission en émission, ce qui décidait sur quelle fréquence un QSO en split était enregistré."
+    ]
+  },
+  {
+    "version": "0.24.4",
+    "date": "",
+    "en": [
+      "DX cluster: an L badge next to a callsign marks a station that uploads to LoTW, with a matching LoTW users only filter, and a Spotter continent filter narrows the list by where the spot came FROM — a JA report on 20 m tells a European little about their own path. The filter panel has been tidied along one rule: a switch is a behaviour you turn on or off, chips pick any number from a set. Nothing appears in both shapes any more, the Lock buttons sit in the heading of the section they lock, every section can be cleared the same way, and the whole panel is finally translated.",
+      "DX cluster: the Spotter continent filter now actually matches. RBN skimmers report as VU2OY-# and cluster nodes as DL1ABC-2, and the suffix was passed straight to the prefix lookup, so every spot came back with no continent and the filter silently selected nothing.",
+      "A spot now stops being NEW the moment you log it. Logging announced the QSO but never dropped the cluster worked-index snapshot, so the refresh that follows re-read the answer computed BEFORE the contact — a station stayed yellow on the band map and in the cluster with the QSO plainly in the log, until something else happened to rebuild the index.",
+      "Station information gains an IOTA field (ADIF MY_IOTA, e.g. EU-005), stamped on every QSO like the SOTA and POTA references beside it. The QSO table has carried the field since the first release and both ADIF import and export already handled it — only the station profile could not supply it, so an island activation meant typing the reference on every contact.",
+      "PowerGenius XL: fixed the amplifier link dropping and reconnecting every few seconds, and the stall while transmitting. The amp pushes status frames on the same socket it answers commands on, and it pushes them constantly once in OPERATE; OpsLog read one line per command and took whatever arrived first as its answer, so the stream slipped permanently one reply behind until a command timed out and the connection was dropped. Replies are now matched to the command that asked for them. Only ever visible over a remote link with the amplifier in OPERATE.",
+      "No colour on worked stations now does only that: it removes the blue already-worked mark and leaves everything else alone. It used to blank the spot status as well, and the status is what dims a quiet row — so turning the option on made every grey row bright white, which is the opposite of what it is for.",
+      "Grid squares in the cluster. Every CQ decoded over the WSJT-X UDP link carries the sender grid, and OpsLog now keeps it: a Grid column shows the square and NEW GRID flags one never worked, as a badge, a filled cell and a filter of its own. Whether a grid counts as new follows the group digital modes setting — with it on, a square worked on FT8 is no longer new on FT4; with it off the two are separate. Only stations your own receiver decodes have a grid: a cluster line carries the spotter grid at best, never the DX one. Turn the column on in Columns."
+    ],
+    "fr": [
+      "Cluster DX : un badge L à côté de l indicatif signale une station qui utilise LoTW, avec le filtre Utilisateurs LoTW seulement qui va avec, et un filtre Continent du spotter restreint selon l origine du spot — un report JA sur 20 m dit peu de chose à un Européen sur son propre chemin. Le panneau de filtres a été remis d aplomb selon une seule règle : un interrupteur est un comportement qu on active ou non, les pastilles choisissent dans un ensemble. Plus rien n existe sous les deux formes, les boutons de verrouillage sont dans le titre de la section qu ils verrouillent, chaque section s efface de la même façon, et le panneau est enfin traduit.",
+      "Cluster DX : le filtre Continent du spotter fonctionne enfin. Les skimmers RBN s annoncent en VU2OY-# et les nœuds cluster en DL1ABC-2, et ce suffixe partait tel quel dans la recherche de préfixe — tous les spots revenaient sans continent et le filtre ne sélectionnait rien.",
+      "Un spot cesse enfin d être NOUVEAU dès que tu l enregistres. La journalisation annonçait le QSO mais ne vidait jamais l instantané de l index des contacts, donc le rafraîchissement qui suit relisait la réponse calculée AVANT le contact — une station restait jaune sur le bandmap et dans le cluster alors que le QSO était bien au log, jusqu à ce qu autre chose reconstruise l index.",
+      "Les informations station gagnent un champ IOTA (MY_IOTA en ADIF, par exemple EU-005), estampillé sur chaque QSO comme les références SOTA et POTA à côté. La table des QSO portait le champ depuis la première version et l import comme l export ADIF le géraient déjà — seul le profil station ne savait pas le fournir, donc une activation d île obligeait à retaper la référence à chaque contact.",
+      "PowerGenius XL : corrigé le lien avec l ampli qui tombait et se reconnectait toutes les quelques secondes, et le blocage en émission. L ampli pousse des trames d état sur la socket même où il répond aux commandes, et il en pousse en permanence dès qu il est en OPERATE ; OpsLog lisait une ligne par commande et prenait la première arrivée pour sa réponse, donc le flux glissait définitivement d une réponse de retard jusqu à expiration et fermeture du lien. Les réponses sont désormais appariées à la commande qui les a demandées. Visible uniquement en liaison distante avec l ampli en OPERATE.",
+      "Aucune couleur sur les stations déjà contactées ne fait plus que ça : la marque bleue disparaît, le reste ne bouge pas. L option vidait aussi le statut du spot, or c est le statut qui estompe une ligne sans intérêt — l activer rendait donc toutes les lignes grises blanches et éclatantes, soit l inverse du but recherché.",
+      "Les carrés locator dans le cluster. Chaque CQ décodé sur le lien UDP WSJT-X porte le grid de l émetteur, et OpsLog le conserve désormais : une colonne Grid affiche le carré et NOUV GRID signale celui jamais contacté, en badge, en cellule remplie et avec son propre filtre. Ce qui compte comme nouveau suit le réglage de regroupement des modes digitaux — activé, un carré fait en FT8 n est plus neuf en FT4 ; désactivé, les deux sont distincts. Seules les stations décodées par ton propre récepteur ont un grid : une ligne de cluster porte le grid du spotter au mieux, jamais celui du DX. Colonne à activer dans Colonnes."
+    ]
+  },
+  {
+    "version": "0.24.3",
+    "date": "",
+    "en": [
+      "Band openings: OpsLog now tells you when 6, 4 or 2 m opens. It watches the spots already arriving from your clusters and RBN — several different stations appearing at single-hop range (500–2400 km) in the same bearing sector within a few minutes is the signature of sporadic E, and nothing else looks like it. You get one message per band per opening, naming the sector and the typical distance. An opening outside the usual season is still announced, and flagged as unusual: those are the ones worth knowing about. Nothing to configure — but the quality depends on having a cluster or RBN feed carrying VHF spots, and 2 m openings are often worked without ever being spotted.",
+      "DX cluster, two display options (Settings › DX cluster). The first drops the colour and the badges on stations you have already worked: they stay in the list, they simply stop competing for your attention. The second colours every callsign you have not worked on this band and this mode, even when the entity itself is long since confirmed — the view for filling slots rather than chasing new ones. Both apply to the cluster list and to the band map, so the two panels always agree.",
+      "DX cluster, clearer at a glance. A novelty now FILLS the cell that carries it — a filled Band cell means new band, a filled Pfx cell means new prefix, a filled County cell means new county — instead of only tinting the text. A US County column joins the list, resolved offline from the ULS database. The station-not-worked-here highlight is its own NEW CALL status with its own filter chip, no longer borrowed from NEW SLOT, which means something narrower. The two display options moved from Preferences into the cluster filter panel, next to Hide worked. The Locator column is now labelled Spotter locator, because that is what a cluster line actually carries.",
+      "Web publishing: the published page sorts properly. The Date column would not sort at all, and neither would callsigns starting with a digit — the script read a number from the front of the text, so every date in the same year counted as equal. A third click on a header now puts the table back in the order it was published in, and an arrow shows which way a column is pointing."
+    ],
+    "fr": [
+      "Ouvertures de bande : OpsLog te signale désormais l ouverture du 6, du 4 ou du 2 m. Il surveille les spots qui arrivent déjà de tes clusters et du RBN — plusieurs stations différentes apparaissant à distance de saut simple (500–2400 km) dans le même secteur d azimut en quelques minutes, c est la signature de l Es, et rien d autre n y ressemble. Un message par bande et par ouverture, avec le secteur et la distance typique. Une ouverture hors saison est annoncée quand même, et signalée comme inhabituelle : ce sont celles qu il ne faut surtout pas manquer. Rien à configurer — mais la qualité dépend d avoir un flux cluster ou RBN qui porte des spots VHF, et les ouvertures 2 m sont souvent travaillées sans jamais être spottées.",
+      "Cluster DX, deux options d affichage (Paramètres › Cluster DX). La première enlève la couleur et les badges sur les stations déjà contactées : elles restent dans la liste, elles cessent simplement d attirer l œil. La seconde colore tout indicatif non contacté sur cette bande et ce mode, même si l entité est confirmée depuis longtemps — la vue pour remplir des slots plutôt que pour chasser du nouveau. Les deux s appliquent à la liste cluster et au bandmap, les deux panneaux restent donc cohérents.",
+      "Cluster DX, plus lisible d un coup d œil. Une nouveauté REMPLIT désormais la cellule qui la porte — cellule Bande remplie = nouvelle bande, cellule Préf. remplie = nouveau préfixe, cellule Comté remplie = nouveau comté — au lieu de seulement colorer le texte. Une colonne Comté US rejoint la liste, résolue hors ligne depuis la base ULS. La mise en couleur des stations non contactées ici devient un statut CALL NEUF à part entière, avec sa propre puce de filtre, au lieu d emprunter NOUV SLOT qui veut dire autre chose. Les deux options d affichage passent des Préférences au panneau de filtres du cluster, à côté de Hide worked. La colonne Locator s appelle maintenant Locator du spotter, puisque c est ce qu une ligne de cluster porte réellement.",
+      "Publication web : la page publiée se trie correctement. La colonne Date ne se triait pas du tout, ni les indicatifs commençant par un chiffre — le script lisait un nombre au début du texte, donc toutes les dates d une même année se valaient. Un troisième clic sur un en-tête remet le tableau dans l ordre de publication, et une flèche indique le sens du tri."
+    ]
+  },
+  {
+    "version": "0.24.2",
+    "date": "",
+    "en": [
+      "Web publishing: OpsLog can now write your log to a file for a website — a standalone HTML page (sortable, dark/light, no external request of any kind) or a CSV. You pick the columns and how many QSOs, it refreshes when you log and, if you want, on a timer, and it can upload the result by FTP or FTPS. The file is always written locally first, so a network failure leaves a good file on disk instead of a truncated one on the server. Settings → Web publishing.",
+      "Icom console: an IC-9700 gets the bands it actually has. The band row was hardwired to 160–6 m, so the one radio in the range with no HF at all showed ten dead buttons and none of 2 m, 70 cm or 23 cm. The row now follows the model, as the attenuator steps already did — an IC-705 gains 2 m and 70 cm, an IC-9100 those plus 23 cm.",
+      "Maps: the tiles are back. OpenStreetMap blocked OpsLog on its volunteer-run tile servers and every map filled with \"Access blocked\" squares. Their policy requires an application to identify itself with its own User-Agent on each request — something a program drawing maps inside a web view cannot do, the browser sets that header itself. So the two layers that still used those servers, the Street basemap and the locator map, have moved to services whose terms do cover a distributed application: Esri for Street, Carto for the locator map. OpenStreetMap is still credited — Carto's tiles are built from its data — and the locator map now throttles its tile requests like the world map already did.",
+      "Band map: a station you have just worked stops showing as NEW. After each QSO the spot colours are refreshed, but only when the DX-cluster list was on screen — the band map was left out, so working a station with the usual layout (Recent QSOs on the left, band map on the right) left its pill orange until you happened to open the cluster tab. The band map, docked or in its own tab, now counts as on screen like the cluster does.",
+      "Band map: new POTA, new county and already-worked callsign are shown at last. The band map only ever coloured the entity status — new DXCC, new band, new slot, worked — and ignored the other three markers, even though it was already receiving them: a new park on an entity you have worked looked like any other worked spot. They now appear on the pill's left strip, in the same colours the DX-cluster list uses, so a fact is not blue in one panel and green in the next. They stack rather than replace: a worked entity that is also a new park shows both, the way the cluster list already spells them out side by side. A new county is now violet instead of sharing green with a new park — in BOTH panels, since the two would otherwise disagree; the marker colours moved to one shared table, which is also what a per-marker colour setting will drive."
+    ],
+    "fr": [
+      "Publication web : OpsLog peut désormais écrire ton journal dans un fichier destiné à un site — une page HTML autonome (triable, claire ou sombre, sans aucune requête externe) ou un CSV. Tu choisis les colonnes et le nombre de QSO, il se rafraîchit à chaque enregistrement et, si tu veux, périodiquement, et il peut envoyer le résultat par FTP ou FTPS. Le fichier est toujours écrit en local d abord : une panne réseau laisse donc un bon fichier sur le disque plutôt qu un fichier tronqué sur le serveur. Réglages → Publication web.",
+      "Console Icom : un IC-9700 reçoit enfin les bandes qu il possède. La rangée de bandes était figée sur 160–6 m, si bien que la seule radio de la gamme sans aucune HF affichait dix boutons morts et aucune de ses bandes 2 m, 70 cm et 23 cm. La rangée suit maintenant le modèle, comme le faisaient déjà les pas d atténuateur — un IC-705 gagne le 2 m et le 70 cm, un IC-9100 ceux-là plus le 23 cm.",
+      "Cartes : les tuiles sont de retour. OpenStreetMap a bloqué OpsLog sur ses serveurs de tuiles bénévoles et toutes les cartes se sont remplies de carrés « Access blocked ». Leur politique exige qu'une application s'identifie par son propre User-Agent à chaque requête — ce qu'un programme qui dessine ses cartes dans une vue web ne peut pas faire, c'est le navigateur qui pose cet en-tête. Les deux couches qui utilisaient encore ces serveurs, le fond Street et la carte des locators, passent donc sur des services dont les conditions couvrent une application distribuée : Esri pour Street, Carto pour les locators. OpenStreetMap reste crédité — les tuiles Carto sont construites à partir de ses données — et la carte des locators limite désormais son débit de requêtes comme le faisait déjà la carte du monde.",
+      "Band map : une station que tu viens de contacter cesse d'apparaître en NEW. Après chaque QSO, les couleurs des spots sont rafraîchies, mais seulement quand la liste du cluster DX était à l'écran — la band map avait été oubliée. Contacter une station dans la disposition habituelle (QSO récents à gauche, band map à droite) laissait donc sa pastille en orange jusqu'à ce qu'on ouvre l'onglet cluster. La band map, ancrée ou dans son onglet, compte désormais comme visible au même titre que le cluster.",
+      "Band map : nouveau POTA, nouveau comté et indicatif déjà contacté sont enfin visibles. La band map ne colorait que le statut d'entité — nouveau DXCC, nouvelle bande, nouveau créneau, contacté — et ignorait les trois autres marqueurs alors qu'elle les recevait déjà : un nouveau parc sur une entité déjà travaillée ressemblait à n'importe quel spot contacté. Ils apparaissent désormais sur la bande latérale de la pastille, dans les couleurs de la liste du cluster DX, pour qu'un même fait ne soit pas bleu dans un panneau et vert dans l'autre. Ils s'empilent au lieu de se remplacer : une entité contactée qui est aussi un nouveau parc affiche les deux, comme la liste du cluster les énumère déjà côte à côte. Un nouveau comté passe en violet au lieu de partager le vert avec un nouveau parc — dans les DEUX panneaux, sinon ils se contrediraient ; les couleurs des marqueurs sont désormais dans une table unique, celle-là même que pilotera l'option de couleur à venir."
+    ]
+  },
   {
     "version": "0.24.1",
     "date": "",

frontend/src/App.tsx

@@ -51,6 +51,7 @@ import {
   ReportLiveActivity, LiveLastQSOAgeSec,
   GetAmpStatuses, AmpOperate,
   GetFlexState, FlexAmpOperate,
+  GetPSKReporterStatus, GetLiveOpenings,
 } from '../wailsjs/go/main/App';
 import { Combobox } from '@/components/ui/combobox';
 import { applyAwardRefs } from '@/lib/awardRefs';
@@ -89,6 +90,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, readSpotDisplayOptions } from '@/lib/spotDisplay';
 import { WorkedBeforeGrid } from '@/components/WorkedBeforeGrid';
 import { NetControlPanel } from '@/components/NetControlPanel';
 import { ContestPanel, CONTEST_DEFAULT, type ContestSession } from '@/components/ContestPanel';
@@ -1484,7 +1486,19 @@ export default function App() {
   // county or a new park is not a DXCC state, it is another dimension of the
   // same spot — which is why the grid shows them as separate badges. Filtering
   // is an OR across all of them, as it already was for a worked callsign.
-  type SpotFilterKey = SpotStatusKey | 'new-pota' | 'new-county' | 'new-pfx';
+  // 'new-call' is a DISPLAY status, produced by the slot-highlight option rather
+  // than by the backend, so it is named here and not in SpotStatusKey.
+  type SpotFilterKey = SpotStatusKey | 'new-pota' | 'new-county' | 'new-pfx' | 'new-call' | 'new-grid';
+  // Display options, shared with the band map through lib/spotDisplay. Kept in
+  // localStorage (mirrored to settings by writeUiPref) so both panels and the
+  // filter predicate read one source without prop-drilling through three levels.
+  // LoTW-only, and the spotter's continent. Both narrow the list by a property
+  // of the station rather than by what the spot is worth, which is why they sit
+  // beside Hide worked and not among the status chips.
+  const [clusterLotwOnly, setClusterLotwOnly] = useState(() => localStorage.getItem('opslog.clusterLotwOnly') === '1');
+  const [clusterSpotterConts, setClusterSpotterConts] = useState<Set<string>>(() => lsSet<string>('opslog.clusterSpotterCont'));
+  const [clusterMuteWorked, setClusterMuteWorked] = useState(() => localStorage.getItem('opslog.clusterMuteWorked') === '1');
+  const [clusterSlotHighlight, setClusterSlotHighlight] = useState(() => localStorage.getItem('opslog.clusterSlotHighlight') === '1');
   const [clusterStatusFilter, setClusterStatusFilter] = useState<Set<SpotFilterKey>>(() => lsSet<SpotFilterKey>('opslog.clusterStatusFilter'));
   // Mode filter chips. Empty set = show every mode. Categories map the
   // inferred per-spot mode onto SSB (phone) / CW / DATA (digital).
@@ -1503,11 +1517,13 @@ export default function App() {
     writeUiPref('opslog.clusterLockBand', clusterLockBand ? '1' : '0');
     writeUiPref('opslog.clusterLockMode', clusterLockMode ? '1' : '0');
     writeUiPref('opslog.clusterStatusFilter', JSON.stringify([...clusterStatusFilter]));
+    writeUiPref('opslog.clusterSpotterCont', JSON.stringify([...clusterSpotterConts]));
     writeUiPref('opslog.clusterModeFilter', JSON.stringify([...clusterModeFilter]));
     writeUiPref('opslog.clusterSearch', clusterSearch);
     writeUiPref('opslog.clusterHideWorked', clusterHideWorked ? '1' : '0');
   }, [clusterFilterSource, clusterGroup, clusterBands, clusterLockBand, clusterLockMode,
-      clusterStatusFilter, clusterModeFilter, clusterSearch, clusterHideWorked]);
+      clusterStatusFilter, clusterModeFilter, clusterSearch, clusterHideWorked,
+      clusterLotwOnly, clusterSpotterConts]);
   // Bands shown side-by-side in the Band Map tab (portable).
   const [bandMapBands, setBandMapBands] = useState<string[]>(() => {
     try { const v = JSON.parse(localStorage.getItem('opslog.bandMapBands') || '[]'); return Array.isArray(v) ? v : []; }
@@ -1580,7 +1596,10 @@ export default function App() {
   // Cached per-call slot status: "new" | "new-band" | "new-slot" | "worked".
   // Keyed by `${call}|${band}|${mode}` so two spots of the same call on
   // different slots don't share the same colour.
-  const [spotStatus, setSpotStatus] = useState<Record<string, { status: string; country?: string; continent?: string; worked_call?: boolean; new_county?: boolean; new_pota?: boolean; new_pfx?: boolean; pfx?: string }>>({});
+  // worked_slot must be carried explicitly like every other field: this map is
+  // assembled field by field, so a backend flag that nobody copies here simply
+  // never reaches the panels — silently, since the extra key is just dropped.
+  const [spotStatus, setSpotStatus] = useState<Record<string, { status: string; country?: string; continent?: string; worked_call?: boolean; worked_slot?: boolean; new_county?: boolean; county?: string; state?: string; lotw?: boolean; spotter_continent?: string; grid?: string; new_grid?: boolean; new_pota?: boolean; new_pfx?: boolean; pfx?: string }>>({});
   // Live mirror of spotStatus so the incoming-spot buffer can tell which slots
   // still need resolving without re-subscribing the cluster:spot listener.
   const spotStatusRef = useRef(spotStatus);
@@ -1613,13 +1632,13 @@ export default function App() {
   const refreshSpotStatuses = useCallback(async () => {
     const cur = spotsRef.current;
     if (!cur.length) return;
-    const queries: { call: string; band: string; mode: string; pota_ref: string }[] = [];
+    const queries: { call: string; band: string; mode: string; pota_ref: string; spotter: string }[] = [];
     const seen = new Set<string>();
     for (const s of cur) {
       const k = spotStatusKey(s.dx_call, s.band ?? '', s.comment ?? '', s.freq_hz);
       if (seen.has(k)) continue;
       seen.add(k);
-      queries.push({ call: s.dx_call, band: s.band ?? '', mode: inferSpotMode(s.comment ?? '', s.freq_hz), pota_ref: (s as any).pota_ref ?? '' });
+      queries.push({ call: s.dx_call, band: s.band ?? '', mode: inferSpotMode(s.comment ?? '', s.freq_hz), pota_ref: (s as any).pota_ref ?? '', spotter: s.spotter ?? '' });
     }
     if (!queries.length) return;
     try {
@@ -1630,7 +1649,7 @@ export default function App() {
           const k = `${r.call}|${r.band ?? ''}|${(r.mode ?? '').toUpperCase()}`;
           next[k] = {
             status: r.status ?? '', country: r.country, continent: (r as any).continent,
-            worked_call: !!(r as any).worked_call, new_county: !!(r as any).new_county,
+            worked_call: !!(r as any).worked_call, worked_slot: !!(r as any).worked_slot, new_county: !!(r as any).new_county, lotw: !!(r as any).lotw, spotter_continent: (r as any).spotter_continent, grid: (r as any).grid, new_grid: !!(r as any).new_grid, county: (r as any).county, state: (r as any).state,
             new_pota: !!(r as any).new_pota, new_pfx: !!(r as any).new_pfx, pfx: (r as any).pfx,
           };
         }
@@ -1640,23 +1659,30 @@ export default function App() {
   }, []);
   // After a QSO is logged, refresh the shown spots so a call/entity/POTA/prefix/
   // slot just worked drops its NEW badge — WITHOUT blanking the others (see the
-  // merge above). Kept cheap: only while the cluster is on screen (a log while
-  // hidden marks it dirty and refreshes ONCE on next open), and debounced so a
-  // fast run coalesces instead of re-scanning per QSO.
-  const clusterVisibleRef = useRef(false);
+  // merge above). Kept cheap: only while something that DRAWS a spot status is on
+  // screen (a log while hidden marks it dirty and refreshes ONCE on the next
+  // open), and debounced so a fast run coalesces instead of re-scanning per QSO.
+  //
+  // "Something" means the band map as much as the cluster list. The test used to
+  // name only the cluster, so working a station while the docked band map was up
+  // — the ordinary layout: Recent QSOs on the left, band map on the right — left
+  // its pill NEW until the cluster tab happened to be opened. Reported on an E51
+  // that stayed orange after the QSO was in the log.
+  const spotsVisibleRef = useRef(false);
   const spotsDirtyRef = useRef(false);
   useEffect(() => {
-    const vis = mainPaneLeft === 'cluster' || mainPaneRight === 'cluster' || activeTab === 'cluster';
-    if (vis && !clusterVisibleRef.current && spotsDirtyRef.current) {
+    const vis = mainPaneLeft === 'cluster' || mainPaneRight === 'cluster'
+      || activeTab === 'cluster' || activeTab === 'bandmap' || showBandMap;
+    if (vis && !spotsVisibleRef.current && spotsDirtyRef.current) {
       spotsDirtyRef.current = false;
       void refreshSpotStatuses();
     }
-    clusterVisibleRef.current = vis;
-  }, [mainPaneLeft, mainPaneRight, activeTab, refreshSpotStatuses]);
+    spotsVisibleRef.current = vis;
+  }, [mainPaneLeft, mainPaneRight, activeTab, showBandMap, refreshSpotStatuses]);
   useEffect(() => {
     let t: number | undefined;
     const off = EventsOn('qso:logged', () => {
-      if (!clusterVisibleRef.current) { spotsDirtyRef.current = true; return; }
+      if (!spotsVisibleRef.current) { spotsDirtyRef.current = true; return; }
       if (t) window.clearTimeout(t);
       t = window.setTimeout(() => void refreshSpotStatuses(), 2000);
     });
@@ -1684,6 +1710,27 @@ export default function App() {
   const [showSettings, setShowSettings] = useState(false);
   // Re-read the "beam on map" toggle when Preferences closes (it's edited there).
   useEffect(() => { if (!showSettings) setShowBeamOnMap(localStorage.getItem('opslog.showBeamOnMap') !== '0'); }, [showSettings]);
+  // Openings under way, for the blinking status-bar badge. Polled rather than
+  // event-driven: the badge also has to go OUT when a band goes quiet, and
+  // nothing emits an event for something that stopped happening.
+  const [liveOpenings, setLiveOpenings] = useState<any[]>([]);
+  useEffect(() => {
+    const load = () => { GetLiveOpenings().then((v: any) => setLiveOpenings(v ?? [])).catch(() => {}); };
+    load();
+    const t = window.setInterval(load, 20000);
+    return () => window.clearInterval(t);
+  }, []);
+
+  // PSK Reporter feed, for the status-bar chip. Polled slowly: the chip only
+  // says up or down, and the count behind it is a tooltip.
+  const [pskr, setPskr] = useState<any>(null);
+  useEffect(() => {
+    const load = () => { GetPSKReporterStatus().then(setPskr).catch(() => {}); };
+    load();
+    const t = window.setInterval(load, 10000);
+    return () => window.clearInterval(t);
+  }, []);
+
   // "ON AIR" status-bar badge: mirrors the multi-op live status this operator
   // publishes — online (blinking) when a QSO was logged in the last 5 min, else
   // offline. Publishing is always on for a shared MySQL logbook (no user toggle:
@@ -1908,7 +1955,7 @@ export default function App() {
   // === Station ===
   const [station, setStation] = useState<StationSettings>({
     callsign: '', operator: '',
-    my_grid: '', my_country: '', my_sota_ref: '', my_pota_ref: '',
+    my_grid: '', my_country: '', my_sota_ref: '', my_pota_ref: '', my_iota: '',
   });
   const [showFirstRun, setShowFirstRun] = useState(false);
   myCallRef.current = (station.callsign || '').toUpperCase();
@@ -2070,6 +2117,28 @@ export default function App() {
     return () => { off(); };
   }, [showToast]);
 
+  // Band openings — sporadic E on 6/4/2 m, detected from the spot stream.
+  //
+  // A toast rather than a rule-based alert: this is not "a station you wanted
+  // appeared", it is "the band itself just changed", and it fires a handful of
+  // times a season. The detector already announces each band once per opening,
+  // so there is nothing to throttle here.
+  useEffect(() => {
+    const off = EventsOn('bandopen:detected', (o: any) => {
+      if (!o?.band) return;
+      // The badge appears on the EVENT, not on the next poll. It used to wait for
+      // one, so the announcement and the badge were up to twenty seconds apart and
+      // read as two unrelated things happening to mention the same band.
+      //
+      // No toast any more: the badge says the same thing and does not vanish after
+      // five seconds. An operator who was tuning when the toast passed had no way
+      // back to it, which is exactly what the badge was built to fix — keeping
+      // both meant announcing an opening twice and still losing it once.
+      setLiveOpenings((cur) => [...cur.filter((x: any) => x.band !== o.band), o]);
+    });
+    return () => { off(); };
+  }, []);
+
   // DX-cluster spot alerts: a matched rule fires here. Play a beep (WebAudio, no
   // asset needed — CSP-safe) and/or show a toast, per the rule's chosen actions.
   useEffect(() => {
@@ -2682,7 +2751,7 @@ export default function App() {
       // Resolve unknown statuses before the rows go in.
       try {
         const known = spotStatusRef.current;
-        const unknown: { call: string; band: string; mode: string; pota_ref: string }[] = [];
+        const unknown: { call: string; band: string; mode: string; pota_ref: string; spotter: string }[] = [];
         const seen = new Set<string>();
         for (const s of batch) {
           const k = spotStatusKey(s.dx_call, s.band ?? '', s.comment ?? '', s.freq_hz);
@@ -2692,6 +2761,7 @@ export default function App() {
             call: s.dx_call, band: s.band ?? '',
             mode: inferSpotMode(s.comment ?? '', s.freq_hz),
             pota_ref: (s as any).pota_ref ?? '',
+            spotter: s.spotter ?? '',
           });
         }
         if (unknown.length > 0) {
@@ -2705,7 +2775,8 @@ export default function App() {
                 country: r.country,
                 continent: (r as any).continent,
                 worked_call: !!(r as any).worked_call,
-                new_county: !!(r as any).new_county,
+                worked_slot: !!(r as any).worked_slot,
+                new_county: !!(r as any).new_county, lotw: !!(r as any).lotw, spotter_continent: (r as any).spotter_continent, grid: (r as any).grid, new_grid: !!(r as any).new_grid, county: (r as any).county, state: (r as any).state,
                 new_pota: !!(r as any).new_pota,
                 new_pfx: !!(r as any).new_pfx,
                 pfx: (r as any).pfx,
@@ -3151,14 +3222,14 @@ export default function App() {
   // "new-slot" because the lookup key carried mode="".
   useEffect(() => {
     const t = window.setTimeout(async () => {
-      const unknown: { call: string; band: string; mode: string; pota_ref: string }[] = [];
+      const unknown: { call: string; band: string; mode: string; pota_ref: string; spotter: string }[] = [];
       const seen = new Set<string>();
       for (const s of spots) {
         const mode = inferSpotMode(s.comment ?? '', s.freq_hz);
         const k = spotStatusKey(s.dx_call, s.band ?? '', s.comment ?? '', s.freq_hz);
         if (seen.has(k) || spotStatus[k]) continue;
         seen.add(k);
-        unknown.push({ call: s.dx_call, band: s.band ?? '', mode, pota_ref: (s as any).pota_ref ?? '' });
+        unknown.push({ call: s.dx_call, band: s.band ?? '', mode, pota_ref: (s as any).pota_ref ?? '', spotter: s.spotter ?? '' });
       }
       if (unknown.length === 0) return;
       try {
@@ -3172,7 +3243,8 @@ export default function App() {
               country: r.country,
               continent: (r as any).continent,
               worked_call: !!(r as any).worked_call,
-              new_county: !!(r as any).new_county,
+              worked_slot: !!(r as any).worked_slot,
+              new_county: !!(r as any).new_county, lotw: !!(r as any).lotw, spotter_continent: (r as any).spotter_continent, grid: (r as any).grid, new_grid: !!(r as any).new_grid, county: (r as any).county, state: (r as any).state,
               new_pota: !!(r as any).new_pota,
               new_pfx: !!(r as any).new_pfx,
               pfx: (r as any).pfx,
@@ -4652,7 +4724,10 @@ export default function App() {
       }
       if (clusterStatusFilter.size > 0) {
         const k = spotStatusKey(s.dx_call, s.band ?? '', s.comment ?? '', s.freq_hz);
-        const e = spotStatus[k];
+        // Filter on what is DISPLAYED, not on the raw backend status: NEW CALL is
+        // produced by the slot-highlight option, so a filter reading the raw
+        // entry would offer a chip that never matches a single row.
+        const e = applySpotDisplay(spotStatus[k], readSpotDisplayOptions());
         const st = (e?.status || '') as SpotStatusKey;
         // WORKED means "I've worked THIS callsign" — the blue WKD-CALL flag —
         // NOT the entity status 'worked' (entity/band/mode already worked, which
@@ -4665,9 +4740,23 @@ export default function App() {
           || (!!e?.worked_call && clusterStatusFilter.has('worked'))
           || (!!e?.new_pota && clusterStatusFilter.has('new-pota'))
           || (!!e?.new_county && clusterStatusFilter.has('new-county'))
-          || (!!e?.new_pfx && clusterStatusFilter.has('new-pfx'));
+          || (!!e?.new_pfx && clusterStatusFilter.has('new-pfx'))
+          || (!!e?.new_grid && clusterStatusFilter.has('new-grid'));
         if (!matches) return false;
       }
+      // LoTW only, and the spotter's continent. Both are properties of the
+      // station rather than judgements about the spot, so they AND with the
+      // status chips instead of joining that OR: "a new band, and from Europe".
+      if (clusterLotwOnly || clusterSpotterConts.size > 0) {
+        const k = spotStatusKey(s.dx_call, s.band ?? '', s.comment ?? '', s.freq_hz);
+        const e = spotStatus[k];
+        // An unresolved spot is not filtered out. The status arrives a moment
+        // after the row does, and dropping it meanwhile made the list flicker.
+        if (e) {
+          if (clusterLotwOnly && !e.lotw) return false;
+          if (clusterSpotterConts.size > 0 && e.spotter_continent && !clusterSpotterConts.has(e.spotter_continent)) return false;
+        }
+      }
       if (clusterHideWorked) {
         const k = spotStatusKey(s.dx_call, s.band ?? '', s.comment ?? '', s.freq_hz);
         const e = spotStatus[k];
@@ -4694,11 +4783,46 @@ export default function App() {
   // The Log4OM-style cluster filter sidebar (callsign search, hide-worked,
   // group, band/mode/status/source). Rendered both in the Cluster tab and the
   // Main-view cluster pane; toggled by clusterShowFilters.
+  // One rule for the whole panel, because two shapes for the same kind of choice
+  // is what made it unreadable:
+  //
+  //   SWITCH — a behaviour that is on or off (hide worked, group duplicates).
+  //   CHIPS  — pick any number from a set; none picked means all (status, mode,
+  //            continent). Selected is solid, unselected is the same chip faded,
+  //            so the palette teaches the colour code even while switched off.
+  //
+  // Nothing appears in both shapes. A control that exists twice is not more
+  // discoverable, it is one control the operator has to recognise twice.
+  const fSection = (label: string, children: any, right?: any) => (
+    <div>
+      <div className="flex items-center justify-between mb-1 min-h-[16px]">
+        <span className="text-[10px] uppercase tracking-wider text-muted-foreground">{label}</span>
+        {right}
+      </div>
+      {children}
+    </div>
+  );
+
+  const fSwitch = (label: string, on: boolean, set: (v: boolean) => void) => (
+    <label className="flex items-center gap-2 cursor-pointer rounded px-1 py-1 -mx-1 hover:bg-accent/40">
+      <Checkbox checked={on} onCheckedChange={(c) => set(!!c)} />
+      <span className="leading-none">{label}</span>
+    </label>
+  );
+
+  const F_CHIP = 'px-1.5 py-[3px] rounded-md border text-[10px] font-bold tracking-wider transition-opacity';
+  const fChip = (key: string, label: string, cls: string, on: boolean, toggle: () => void) => (
+    <button key={key} type="button" onClick={toggle}
+      className={cn(F_CHIP, on ? cls : `${cls} opacity-40 hover:opacity-80`)}>
+      {label}
+    </button>
+  );
+
   const renderClusterFilters = () => (
     <div className="w-56 shrink-0 border-l border-border/60 flex flex-col min-h-0 bg-muted/10">
       <div className="px-2.5 py-2 border-b border-border/60 flex items-center justify-between">
-        <span className="text-[11px] font-semibold uppercase tracking-wider text-muted-foreground">Filters</span>
-        <button type="button" onClick={toggleClusterFilters} title="Hide filters"
+        <span className="text-[11px] font-semibold uppercase tracking-wider text-muted-foreground">{t('clu.filters')}</span>
+        <button type="button" onClick={toggleClusterFilters} title={t('clu.hideFilters')}
           className="text-muted-foreground hover:text-foreground">
           <X className="size-3.5" />
         </button>
@@ -4707,42 +4831,48 @@ export default function App() {
         {/* Callsign search */}
         <Input
           className="h-7 text-xs font-mono uppercase"
-          placeholder="Search call…"
+          placeholder={t('clu.searchCall')}
           value={clusterSearch}
           onChange={(e) => setClusterSearch(e.target.value.toUpperCase())}
         />
 
-        {/* Toggles */}
-        <div className="space-y-1.5">
-          <label className="flex items-center gap-1.5 cursor-pointer">
-            <Checkbox checked={clusterHideWorked} onCheckedChange={(c) => setClusterHideWorked(!!c)} />
-            Hide worked
-          </label>
-          <label className="flex items-center gap-1.5 cursor-pointer">
-            <Checkbox checked={clusterGroup} onCheckedChange={(c) => setClusterGroup(!!c)} />
-            Group duplicates
-          </label>
+        {/* Behaviours: each is on or off, and none of them narrows by a property
+            of the station. The last two also drive the band map, via
+            lib/spotDisplay — they live here rather than in Preferences because
+            they are changed while working a run. */}
+        <div className="space-y-0.5">
+          {fSwitch(t('clu.hideWorked'), clusterHideWorked, setClusterHideWorked)}
+          {fSwitch(t('clu.groupDup'), clusterGroup, setClusterGroup)}
+          {fSwitch(t('clu.muteWorkedShort'), clusterMuteWorked, (v) => { setClusterMuteWorked(v); writeUiPref('opslog.clusterMuteWorked', v ? '1' : '0'); })}
+          {fSwitch(t('clu.slotHighlightShort'), clusterSlotHighlight, (v) => { setClusterSlotHighlight(v); writeUiPref('opslog.clusterSlotHighlight', v ? '1' : '0'); })}
+          {fSwitch(t('clu.lotwOnly'), clusterLotwOnly, (v) => { setClusterLotwOnly(v); writeUiPref('opslog.clusterLotwOnly', v ? '1' : '0'); })}
         </div>
 
-        {/* Band filter — multi-select listbox */}
-        <div>
-          <div className="flex items-center justify-between mb-1">
-            <span className="text-[10px] uppercase tracking-wider text-muted-foreground">Bands</span>
-            <div className="flex items-center gap-2">
-              <button
-                type="button"
-                onClick={() => setClusterLockBand((v) => !v)}
-                className={cn('inline-flex items-center gap-0.5 text-[10px] px-1 py-0.5 rounded border',
-                  clusterLockBand ? 'bg-warning-muted text-warning-muted-foreground border-warning-border' : 'text-muted-foreground border-border hover:bg-muted')}
-                title="Lock to the entry strip's current band"
-              >
-                {clusterLockBand ? <Lock className="size-2.5" /> : <Unlock className="size-2.5" />} {band}
-              </button>
-              {clusterBands.size > 0 && (
-                <button type="button" onClick={() => setClusterBands(new Set())} className="text-[10px] text-muted-foreground hover:text-foreground underline">clear</button>
+        {/* The SPOTTER's continent, not the DX's: this asks whether anyone near
+            you is hearing the band at all. Chips rather than a dropdown — seven
+            two-letter codes fit on two lines, they read as a set the way Status
+            and Mode do, and several can be picked at once, which "EU or NA" needs
+            and a dropdown cannot express. */}
+        {fSection(t('clu.spotterCont'),
+          <div className="flex flex-wrap gap-1">
+            {['AF', 'AN', 'AS', 'EU', 'NA', 'OC', 'SA'].map((c) => fChip(
+              c, c, 'bg-muted text-foreground border-border',
+              clusterSpotterConts.has(c),
+              () => setClusterSpotterConts((cur) => {
+                const n = new Set(cur);
+                if (n.has(c)) n.delete(c); else n.add(c);
+                return n;
+              }),
+            ))}
+          </div>,
+          clusterSpotterConts.size > 0 ? (
+            <button type="button" onClick={() => setClusterSpotterConts(new Set())}
+              className="text-[10px] text-muted-foreground hover:text-foreground underline">{t('clu.clear')}</button>
+          ) : undefined,
         )}
-            </div>
-          </div>
+
+        {/* Band filter — multi-select listbox */}
+        {fSection(t('clu.bands'),
           <div className={cn('rounded border border-border max-h-36 overflow-auto bg-background', clusterLockBand && 'opacity-40 pointer-events-none')}>
             {bands.map((b) => {
               const on = clusterBands.has(b);
@@ -4758,83 +4888,82 @@ export default function App() {
                 </button>
               );
             })}
-          </div>
-        </div>
-
-        {/* Mode lock */}
+          </div>,
+          <div className="flex items-center gap-2">
               <button
                 type="button"
-          onClick={() => setClusterLockMode((v) => !v)}
-          className={cn('inline-flex items-center gap-1 px-1.5 py-0.5 rounded border text-[10px]',
-            clusterLockMode ? 'bg-warning-muted text-warning-muted-foreground border-warning-border' : 'text-muted-foreground border-border hover:bg-muted')}
-          title="Only show spots whose mode matches the entry strip"
+                onClick={() => setClusterLockBand((v) => !v)}
+                className={cn('inline-flex items-center gap-0.5 text-[10px] px-1 py-0.5 rounded border',
+                  clusterLockBand ? 'bg-warning-muted text-warning-muted-foreground border-warning-border' : 'text-muted-foreground border-border hover:bg-muted')}
+                title={t('clu.lockBandTitle')}
               >
-          {clusterLockMode ? <Lock className="size-2.5" /> : <Unlock className="size-2.5" />} Lock mode ({mode})
+                {clusterLockBand ? <Lock className="size-2.5" /> : <Unlock className="size-2.5" />} {band}
               </button>
+              {clusterBands.size > 0 && (
+                <button type="button" onClick={() => setClusterBands(new Set())} className="text-[10px] text-muted-foreground hover:text-foreground underline">{t('clu.clear')}</button>
+              )}
+          </div>,
+        )}
 
         {/* Status filter */}
-        <div>
-          <div className="text-[10px] uppercase tracking-wider text-muted-foreground mb-1">Status</div>
+        {fSection(t('clu.status'),
           <div className="flex flex-wrap gap-1">
             {([
               { k: 'new'      as SpotFilterKey, label: 'NEW',       cls: 'bg-danger-muted text-danger-muted-foreground border-danger-border' },
               { k: 'new-band' as SpotFilterKey, label: 'NEW BAND',  cls: 'bg-warning-muted text-warning-muted-foreground border-warning-border' },
               { k: 'new-mode' as SpotFilterKey, label: 'NEW MODE',  cls: 'bg-caution-muted text-caution-muted-foreground border-caution-border' },
               { k: 'new-slot' as SpotFilterKey, label: 'NEW SLOT',  cls: 'bg-caution-muted text-caution-muted-foreground border-caution-border' },
+              // NEW CALL is about the CALLSIGN, not the entity: never worked on this
+              // band and mode. Only appears when the slot-highlight option is on.
+              { k: 'new-call' as SpotFilterKey, label: 'NEW CALL',  cls: 'bg-caution-muted text-caution-muted-foreground border-caution-border' },
               // Same colours as the badges in the grid — a filter that does not
               // look like what it selects has to be learned twice.
               { k: 'new-pota'   as SpotFilterKey, label: 'NEW POTA',   cls: 'bg-success-muted text-success-muted-foreground border-success-border' },
               { k: 'new-county' as SpotFilterKey, label: 'NEW COUNTY', cls: 'bg-success-muted text-success-muted-foreground border-success-border' },
               { k: 'new-pfx'    as SpotFilterKey, label: 'NEW PFX',    cls: 'bg-caution-muted text-caution-muted-foreground border-caution-border' },
+              // Only ever set for a station this receiver decoded over the UDP link.
+              { k: 'new-grid'   as SpotFilterKey, label: 'NEW GRID',   cls: 'bg-muted text-foreground border-border' },
               // Blue, like the already-worked call in the grid. Selecting it keeps
               // 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' },
-            ]).map((s) => {
-              const on = clusterStatusFilter.has(s.k);
-              return (
-                <button key={s.k} type="button"
-                  onClick={() => setClusterStatusFilter((cur) => { const n = new Set(cur); if (n.has(s.k)) n.delete(s.k); else n.add(s.k); return n; })}
-                  className={cn('px-1.5 py-0.5 rounded border text-[10px] font-bold tracking-wider transition-opacity', on ? s.cls : `${s.cls} opacity-40 hover:opacity-100`)}>
-                  {s.label}
-                </button>
-              );
-            })}
-          </div>
-        </div>
+            ]).map((s) => 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; })))}
+          </div>,
+          clusterStatusFilter.size > 0 ? (
+            <button type="button" onClick={() => setClusterStatusFilter(new Set())}
+              className="text-[10px] text-muted-foreground hover:text-foreground underline">{t('clu.clear')}</button>
+          ) : undefined,
+        )}
 
         {/* Mode filter */}
-        <div>
-          <div className="text-[10px] uppercase tracking-wider text-muted-foreground mb-1">Mode</div>
+        {fSection(t('clu.mode'),
           <div className="flex flex-wrap gap-1">
             {([
               { k: 'SSB'  as SpotModeCat, label: 'SSB',  cls: 'bg-info-muted text-info-muted-foreground border-info-border' },
               { k: 'CW'   as SpotModeCat, label: 'CW',   cls: 'bg-info-muted text-info-muted-foreground border-info-border' },
               { k: 'DATA' as SpotModeCat, label: 'DATA', cls: 'bg-success-muted text-success-muted-foreground border-success-border' },
-            ]).map((s) => {
-              const on = clusterModeFilter.has(s.k);
-              return (
-                <button key={s.k} type="button"
-                  onClick={() => setClusterModeFilter((cur) => { const n = new Set(cur); if (n.has(s.k)) n.delete(s.k); else n.add(s.k); return n; })}
-                  className={cn('px-1.5 py-0.5 rounded border text-[10px] font-bold tracking-wider transition-opacity', on ? s.cls : `${s.cls} opacity-40 hover:opacity-100`)}>
-                  {s.label}
-                </button>
-              );
-            })}
-          </div>
-        </div>
+            ]).map((s) => fChip(s.k, s.label, s.cls, clusterModeFilter.has(s.k),
+              () => setClusterModeFilter((cur) => { const n = new Set(cur); if (n.has(s.k)) n.delete(s.k); else n.add(s.k); return n; })))}
+          </div>,
+          <button type="button" onClick={() => setClusterLockMode((v) => !v)}
+            className={cn('inline-flex items-center gap-0.5 text-[10px] px-1 py-0.5 rounded border',
+              clusterLockMode ? 'bg-warning-muted text-warning-muted-foreground border-warning-border' : 'text-muted-foreground border-border hover:bg-muted')}
+            title={t('clu.lockModeTitle')}>
+            {clusterLockMode ? <Lock className="size-2.5" /> : <Unlock className="size-2.5" />} {mode}
+          </button>,
+        )}
 
         {/* Source */}
-        <div>
-          <div className="text-[10px] uppercase tracking-wider text-muted-foreground mb-1">Source</div>
+        {fSection(t('clu.source'),
           <Select value={String(clusterFilterSource || '_')} onValueChange={(v) => setClusterFilterSource(v === '_' ? '' : parseInt(v, 10))}>
-            <SelectTrigger className="w-full h-7 text-xs"><SelectValue placeholder="All sources" /></SelectTrigger>
+            <SelectTrigger className="w-full h-7 text-xs"><SelectValue placeholder={t('clu.allSources')} /></SelectTrigger>
             <SelectContent>
-              <SelectItem value="_">All sources</SelectItem>
+              <SelectItem value="_">{t('clu.allSources')}</SelectItem>
               {clusterServers.map((s) => <SelectItem key={s.id} value={String(s.id)}>{s.name}</SelectItem>)}
             </SelectContent>
-          </Select>
-        </div>
+          </Select>,
+        )}
       </div>
     </div>
   );
@@ -6752,6 +6881,26 @@ export default function App() {
                 </button>
               );
             })}
+            {/* PSK Reporter, next to the hardware chips because it is the same
+                kind of fact: a link that is either up or it is not. Shown ONLY
+                when the opening watch is on — a permanently grey chip for a
+                feature nobody enabled is clutter, and the bar is 28 px.
+
+                The decode count is in the tooltip rather than the chip: it moves
+                several times a second on an open band, and a number flickering in
+                the corner of the eye is not information, it is a distraction. */}
+            {pskr?.running && (
+              <button
+                type="button"
+                title={t('pskr.tip', { n: pskr.received ?? 0, bands: (pskr.bands ?? []).join(' ') })}
+                onClick={() => { setSettingsSection('cluster'); setShowSettings(true); }}
+                className="inline-flex items-center gap-1.5 px-2 h-5 rounded border text-[11px] transition-colors border-border hover:bg-muted cursor-pointer shrink-0"
+              >
+                <span className={cn('size-2 rounded-full',
+                  (pskr.received ?? 0) > 0 ? 'bg-success' : 'bg-warning')} />
+                MQTT
+              </button>
+            )}
             {/* ON AIR badge: "did I log a QSO in the last 5 min" — meaningful on ANY
                 logbook backend (only the live_status PUBLISHING is MySQL-specific),
                 so it is always shown. Gating it on MySQL made it vanish for
@@ -6809,6 +6958,45 @@ export default function App() {
             {/* UTC clock — moved out of the header, where it competed with the
                 frequency for the eye. It belongs with the other passive
                 indicators. */}
+            {/* Openings under way. Right-hand end, before the clock, because it is
+                a state of the world rather than a state of this station — the
+                same side as the time and the logbook.
+
+                It BLINKS and it stays. The toast that announces an opening is
+                gone in seconds, and an operator who was tuning at that moment
+                had no way back to it; a band opening lasts hours and deserves
+                something that lasts with it. It goes out by itself when the
+                spots stop arriving. */}
+            {liveOpenings.map((o: any) => (
+              <button
+                key={o.band}
+                type="button"
+                onClick={() => { setActiveTab('bandmap'); }}
+                title={t('bo.liveTip', {
+                  band: String(o.band).toUpperCase(), n: o.calls, km: o.median_km,
+                  sector: `${o.compass ?? ''} ${o.bearing_min}–${o.bearing_max}°`,
+                  season: o.in_season ? '' : ' — ' + t('bmp.openUnusual'),
+                })}
+                className="inline-flex items-center gap-1.5 rounded-md border px-2 py-0.5 text-[11px] font-bold uppercase tracking-wider shrink-0
+                           border-warning-border bg-warning-muted text-warning-muted-foreground hover:bg-warning-muted/70 animate-pulse"
+              >
+                <Radio className="size-3 shrink-0" />
+                {/* The three facts that decide whether to act: which band, which
+                    way to point, how far it reaches. They were in a tooltip
+                    nobody hovers, which made the badge an alarm with no content —
+                    it said something was happening and refused to say what. */}
+                <span>{String(o.band).toUpperCase()}</span>
+                <span className="font-mono">{o.compass}</span>
+                {/* Plain kilometres. An earlier attempt abbreviated 1500 to
+                    "1.5k" and then appended the unit, giving "1.5kkm" — and even
+                    written correctly, "1.5k km" makes a reader do arithmetic to
+                    recover a number that was four characters long to begin with. */}
+                <span className="font-mono opacity-80">{o.median_km} km</span>
+                {/* Out of season is the one an operator must not learn last, so it
+                    earns a mark on the badge rather than a line in the tooltip. */}
+                {!o.in_season && <span className="opacity-90">!</span>}
+              </button>
+            ))}
             <span className="inline-flex items-center gap-1 font-mono text-[11px] text-muted-foreground shrink-0" title="UTC">
               <Clock className="size-3" />
               {utcNow}<span className="text-[9px]">Z</span>

frontend/src/components/BandMap.tsx

@@ -3,6 +3,8 @@ import { Minus, Plus, Crosshair, X, PanelLeft, PanelRight } from 'lucide-react';
 import { cn } from '@/lib/utils';
 import { useI18n } from '@/lib/i18n';
 import { spotStatusKey, inferSpotMode, spotModeCategory } from '@/lib/spot';
+import { SPOT_MARKERS, activeMarkers } from '@/lib/spotMarkers';
+import { applySpotDisplay, readSpotDisplayOptions } from '@/lib/spotDisplay';
 
 // BandMap — vertical spectrum panel inspired by Log4OM.
 // - Full band is always visible; zoom changes pixels-per-kHz, scroll
@@ -24,7 +26,43 @@ interface Spot {
   spotter?: string;
 }
 
-type SpotStatusEntry = { status: string; country?: string };
+// The FULL status entry, not the two fields the map used to declare. The extra
+// markers were already arriving in this object — the local type simply never
+// mentioned them, so they could not be drawn.
+type SpotStatusEntry = {
+  status?: string;
+  country?: string;
+  worked_call?: boolean;
+  // worked_slot: this exact callsign already worked on THIS band and mode.
+  worked_slot?: boolean;
+  new_county?: boolean;
+  new_pota?: boolean;
+  new_pfx?: boolean;
+};
+
+// The extra markers are ORTHOGONAL to the entity status: a spot can be a worked
+// entity AND a new park. The cluster list stacks them as separate badges instead
+// of letting one replace another, so the map stacks them too — as segments of
+// the pill's left accent bar, which until now only repeated the pill's own
+// colour and carried no information of its own.
+//
+// Their colours come from lib/spotMarkers, shared with the cluster list: the
+// same fact must not be violet in one panel and green in the next.
+// The map shows three of the five. A new PREFIX and a new GRID are left to the
+// cluster list, which has the width to name them: the
+// pill is 22 px tall, and a fourth segment turns the strip into a colour code
+// nobody can read at a glance. Add it here the day the strip earns more room.
+const BMP_MARKERS = SPOT_MARKERS.filter((m) => m.key !== 'new_pfx' && m.key !== 'new_grid');
+const markersFor = (e: SpotStatusEntry | undefined) =>
+  activeMarkers(e).filter((m) => m.key !== 'new_pfx' && m.key !== 'new_grid');
+
+// The legend spells the markers out; the cluster list's badges are abbreviated
+// ("NEW CTY") because they sit in a narrow cell, and there is room here.
+const BMP_MARKER_LABEL: Record<string, string> = {
+  new_pota: 'bmp.legendNewPota',
+  new_county: 'bmp.legendNewCounty',
+  worked_call: 'bmp.legendWorkedCall',
+};
 
 interface Props {
   band: string;
@@ -116,12 +154,26 @@ function statusLabel(s: string, t: (k: string) => string): string {
   switch (s) {
     case 'new':      return t('bmp.statusNew');
     case 'new-band': return t('bmp.statusNewBand');
+    case 'new-mode': return t('bmp.statusNewMode');
     case 'new-slot': return t('bmp.statusNewSlot');
+    case 'new-call': return t('bmp.statusNewCall');
     case 'worked':   return t('bmp.statusWorked');
+    // An empty status means the entity could not be resolved. Nothing else
+    // empties it: the mute option leaves the status alone and takes only the
+    // already-worked-callsign mark.
     default:         return t('bmp.statusUnresolved');
   }
 }
 
+// QUIET: no status colour at all. The pill keeps the card background and the
+// accent drops to a plain border grey, so the spot is present but says nothing.
+const QUIET_STYLE = {
+  pill: 'bg-card text-muted-foreground border-border/60 hover:bg-muted/50',
+  bar:  'bg-muted-foreground/30',
+  line: 'stroke-border',
+  dot:  'fill-border',
+};
+
 function statusStyle(s: string): { pill: string; bar: string; line: string; dot: string } {
   // pill = full pill background+text+border
   // bar  = thick left accent inside the pill
@@ -140,18 +192,14 @@ function statusStyle(s: string): { pill: string; bar: string; line: string; dot:
       line: 'stroke-warning',
       dot:  'fill-warning',
     };
+    case 'new-call':
     case 'new-slot': return {
       pill: 'bg-caution-muted text-caution-muted-foreground border-caution-border hover:bg-caution-muted',
       bar:  'bg-caution',
       line: 'stroke-caution',
       dot:  'fill-caution',
     };
-    case 'worked':   return {
-      pill: 'bg-card text-muted-foreground border-border/60 hover:bg-muted/50',
-      bar:  'bg-muted-foreground/30',
-      line: 'stroke-border',
-      dot:  'fill-border',
-    };
+    case 'worked':   return QUIET_STYLE;
     default:         return {
       pill: 'bg-card text-foreground border-border hover:bg-accent/40',
       bar:  'bg-primary/60',
@@ -179,8 +227,24 @@ const BOT_PAD = 14;    // the top-most freq label isn't clipped at y=0
 // last; ties broken by closeness to the rig freq).
 const MAX_VISIBLE_SPOTS = 30;
 
-export function BandMap({ band, spots, spotStatus, currentFreqHz, onSpotClick, onClose, side = 'right', onToggleSide, hideDigital = false, fitToBand = false, keyNav = false }: Props) {
+export function BandMap({ band, spots, spotStatus: spotStatusRaw, currentFreqHz, onSpotClick, onClose, side = 'right', onToggleSide, hideDigital = false, fitToBand = false, keyNav = false }: Props) {
   const { t } = useI18n();
+
+  // The two display options are applied ONCE here, on the whole map, so the
+  // leader lines, the dots, the pills and the badges can never disagree — and so
+  // the map and the cluster list share the single rule set in lib/spotDisplay.
+  // Re-derived whenever the poll delivers a new status map, which is also when a
+  // just-changed option takes effect.
+  // Read at render time, not inside the memo: the options must be part of the
+  // dependencies. Keyed only on spotStatusRaw, toggling an option changed
+  // nothing until the next poll happened to hand over a fresh object.
+  const dispOpts = readSpotDisplayOptions();
+  const spotStatus = useMemo(() => {
+    if (!dispOpts.muteWorked && !dispOpts.slotHighlight) return spotStatusRaw;
+    const out: Record<string, SpotStatusEntry> = {};
+    for (const k of Object.keys(spotStatusRaw)) out[k] = applySpotDisplay(spotStatusRaw[k], dispOpts) as SpotStatusEntry;
+    return out;
+  }, [spotStatusRaw, dispOpts.muteWorked, dispOpts.slotHighlight]);
   const range = BAND_RANGES[band];
   const segments = SEGMENT_COLORS[band] ?? [];
   const [zoomIdx, setZoomIdx] = useState(2); // default 32 px/kHz
@@ -248,6 +312,7 @@ export function BandMap({ band, spots, spotStatus, currentFreqHz, onSpotClick, o
         case 'new':      return 0;
         case 'new-band': return 1;
         case 'new-slot': return 2;
+        case 'new-call': return 2;
         case 'worked':   return 4;
         default:         return 3;
       }
@@ -567,10 +632,21 @@ export function BandMap({ band, spots, spotStatus, currentFreqHz, onSpotClick, o
                   'hover:translate-x-0.5 hover:shadow',
                   style.pill,
                 )}
-                title={`${p.spot.dx_call}${entry?.country ? ' · ' + entry.country : ''} · ${p.spot.freq_khz.toFixed(1)} kHz · ${statusLabel(st, t)}${p.spot.comment ? ' · ' + p.spot.comment : ''}${p.spot.spotter ? ' · de ' + p.spot.spotter : ''}`}
+                title={`${p.spot.dx_call}${entry?.country ? ' · ' + entry.country : ''} · ${p.spot.freq_khz.toFixed(1)} kHz · ${statusLabel(st, t)}${markersFor(entry).map((m) => ' · ' + t(BMP_MARKER_LABEL[m.key])).join('')}${p.spot.comment ? ' · ' + p.spot.comment : ''}${p.spot.spotter ? ' · de ' + p.spot.spotter : ''}`}
               >
-                {/* Status accent strip on the left */}
-                <span className={cn('w-1 shrink-0', style.bar)} aria-hidden />
+                {/* Left accent strip. With no extra marker it repeats the status
+                    colour, exactly as before; otherwise it splits into one
+                    segment per marker, so "worked entity + new park" shows both
+                    instead of one hiding the other. */}
+                {(() => {
+                  const marks = markersFor(entry);
+                  if (marks.length === 0) return <span className={cn('w-1 shrink-0', style.bar)} aria-hidden />;
+                  return (
+                    <span className="w-1 shrink-0 flex flex-col" aria-hidden>
+                      {marks.map((m) => <span key={m.key} className="flex-1" style={{ background: m.colour }} />)}
+                    </span>
+                  );
+                })()}
                 <span className="flex items-center gap-1.5 px-2 font-mono text-[11px] font-bold leading-none">
                   <span>{p.spot.dx_call}</span>
                   {mode && (
@@ -590,6 +666,11 @@ export function BandMap({ band, spots, spotStatus, currentFreqHz, onSpotClick, o
         <LegendDot cls="bg-warning" label={t('bmp.legendNewBand')} />
         <LegendDot cls="bg-caution" label={t('bmp.legendNewSlot')} />
         <LegendDot cls="bg-muted-foreground/30" label={t("bmp.legendWorked")} />
+        {/* The stacked markers, straight from the shared table so the legend
+            cannot drift from what the pills actually draw. */}
+        {BMP_MARKERS.map((m) => (
+          <LegendDot key={m.key} colour={m.colour} label={t(BMP_MARKER_LABEL[m.key])} />
+        ))}
         {/* Sub-band shading, so the wash behind the pills is never colour-alone. */}
         <span className="mx-0.5 opacity-40">|</span>
         <LegendDot colour={SEG_CW} label={t("bmp.legendCW")} />

frontend/src/components/BandSlotGrid.tsx

@@ -172,8 +172,17 @@ export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, hasCal
     () => (lat == null || lon == null ? null : sunTimes(new Date(), lat, lon)),
     [lat, lon],
   );
+  // Stacked, not side by side. Laid out in a row this cost about 150 px of a
+  // header that has to hold the callsign, the badges and the band grid, and it
+  // was what pushed the whole row onto a second line. Two short times one above
+  // the other take a fraction of that and no extra height: the row is already
+  // taller than one line of text.
+  //
+  // "UTC" moves into the tooltip with them — the times are monospaced and always
+  // UTC everywhere in OpsLog, so the label was spending width to repeat a
+  // convention the operator already lives by.
   const sunBlock = sun ? (
-    <div className="ml-auto flex items-center gap-3 text-xs shrink-0"
+    <div className="ml-auto flex flex-col items-end leading-tight text-xs shrink-0"
       title="Sunrise / sunset at the DX station (UTC)">
       {sun.polarDay ? (
         <span className="font-semibold text-warning">midnight sun</span>
@@ -182,14 +191,13 @@ export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, hasCal
       ) : (
         <>
           <span className="flex items-center gap-1">
-            <Sunrise className="size-3.5 text-warning" />
+            <Sunrise className="size-3 text-warning" />
             <span className="font-mono tabular-nums">{sun.rise || '—'}</span>
           </span>
           <span className="flex items-center gap-1">
-            <Sunset className="size-3.5 text-info" />
+            <Sunset className="size-3 text-info" />
             <span className="font-mono tabular-nums">{sun.set || '—'}</span>
           </span>
-          <span className="text-muted-foreground">UTC</span>
         </>
       )}
     </div>

frontend/src/components/BulkEditModal.tsx

@@ -91,6 +91,17 @@ const FIELDS: FieldDef[] = [
   { id: 'iota',     label: 'bulk.fIota',    group: 'Contacted station', kind: 'text', upper: true },
   { id: 'sig',      label: 'bulk.fSig',     group: 'Contacted station', kind: 'text' },
   { id: 'sig_info', label: 'bulk.fSigInfo', group: 'Contacted station', kind: 'text' },
+  // The contact itself — repair fields, not description fields. An import that
+  // mapped every QSO to SSB, or an ADIF with no MODE at all, is fixed here
+  // instead of one row at a time.
+  //
+  // Band is deliberately absent: it travels with the frequency below, because a
+  // band contradicting its own frequency is invalid ADIF and every export would
+  // carry the contradiction.
+  { id: 'mode',     label: 'bulk.fMode',    group: 'The contact', kind: 'text', upper: true },
+  { id: 'submode',  label: 'bulk.fSubmode', group: 'The contact', kind: 'text', upper: true },
+  { id: 'rst_sent', label: 'bulk.fRstSent', group: 'The contact', kind: 'text' },
+  { id: 'rst_rcvd', label: 'bulk.fRstRcvd', group: 'The contact', kind: 'text' },
   // Misc
   // Frequency (MHz) — sets freq_hz AND recomputes band. Main use: fixing a batch
   // logged on a stale/default frequency after CAT dropped.
@@ -110,7 +121,12 @@ const STATUS_VALUES: { v: string; label: string }[] = [
   { v: '_', label: 'bulk.statusBlank' },
 ];
 
-const GROUPS = ['QSL / upload', 'My station', 'Contacted station', 'Contest', 'Propagation', 'Misc'];
+// Derived from the fields themselves, in the order they are declared.
+//
+// This used to be a hand-written list, and a group added to FIELDS but not to it
+// simply never rendered — the fields existed, passed every check, and could not
+// be picked. Two lists that must agree, with nothing to make them.
+const GROUPS = [...new Set(FIELDS.map((f) => f.group))];
 // Maps the internal group key → its i18n label key.
 const GROUP_LABELS: Record<string, string> = {
   'QSL / upload': 'bulk.groupQsl',
@@ -119,6 +135,7 @@ const GROUP_LABELS: Record<string, string> = {
   'Contest': 'bulk.groupContest',
   'Propagation': 'bulk.groupPropagation',
   'Misc': 'bulk.groupMisc',
+  'The contact': 'bulk.groupContact',
 };
 
 type Props = {
@@ -177,7 +194,7 @@ export function BulkEditModal({ open, ids, onClose, onApplied }: Props) {
               <SelectContent>
                 {GROUPS.map((g) => (
                   <div key={g}>
-                    <div className="px-2 py-1 text-[10px] uppercase tracking-wider text-muted-foreground">{t(GROUP_LABELS[g])}</div>
+                    <div className="px-2 py-1 text-[10px] uppercase tracking-wider text-muted-foreground">{GROUP_LABELS[g] ? t(GROUP_LABELS[g]) : g}</div>
                     {FIELDS.filter((f) => f.group === g)
                       .map((f) => ({ f, txt: t(f.label) }))
                       .sort((a, b) => a.txt.localeCompare(b.txt))

frontend/src/components/ClusterGrid.tsx

@@ -12,6 +12,8 @@ import {
 import { Button } from '@/components/ui/button';
 import { Checkbox } from '@/components/ui/checkbox';
 import { cleanSpotter, inferSpotMode, spotStatusKey } from '@/lib/spot';
+import { markerColour } from '@/lib/spotMarkers';
+import { applySpotDisplay, readSpotDisplayOptions } from '@/lib/spotDisplay';
 import { loadLocal, loadRemote, saveState, seedLocal, whenGridPrefsReady } from '@/lib/gridPrefs';
 import { useI18n } from '@/lib/i18n';
 
@@ -51,10 +53,22 @@ export type SpotStatusEntry = {
   country?: string;
   continent?: string;
   worked_call?: boolean;
+  // worked_slot: this exact callsign already worked on THIS band and mode.
+  // Always slot-scoped, unlike worked_call which follows the "same slot" option.
+  worked_slot?: boolean;
   new_county?: boolean;
+  // The resolved US county and state, so the grid can SHOW them and not merely
+  // flag them. Filled from the offline ULS store, US callsigns only.
+  county?: string;
+  state?: string;
   new_pota?: boolean;
   new_pfx?: boolean;
   pfx?: string;
+  // lotw: the DX uploads to LoTW, per ARRL user list. Inert until downloaded.
+  lotw?: boolean;
+  spotter_continent?: string;
+  grid?: string;
+  new_grid?: boolean;
 };
 
 type Props = {
@@ -96,26 +110,54 @@ type ColEntry = ColDef<ClusterSpot> & { group: string; label: string; defaultVis
 // statusFor resolves the precomputed spot status (new / new-band / new-slot /
 // worked-call) for an ag-Grid cell's row.
 function statusFor(p: any): SpotStatusEntry | undefined {
-  return p?.context?.spotStatus?.[
+  const s = p?.context?.spotStatus?.[
     spotStatusKey(p.data?.dx_call, p.data?.band ?? '', p.data?.comment ?? '', p.data?.freq_hz)
   ];
+  // One chokepoint: the colour, the badges and the Status text all read through
+  // here, so the two display options are applied once rather than in each
+  // renderer — and the band map applies the very same function.
+  return applySpotDisplay(s, readSpotDisplayOptions());
 }
 
-// Spot status is shown by COLOURING THE TEXT, never by a pill or a badge.
+// Spot status is shown on the CELL that carries the fact — filled background for
+// a novelty, tinted text otherwise — never by a pill or a badge.
 //
-// The pills were dropped: a rounded box has its own height and padding, so it
-// sat off the row's baseline and the callsign inside it no longer lined up with
-// the plain callsigns above and below. A whole column of them read as chrome
-// rather than as data. Same reasoning — and the same semantic tokens — as the
-// Y/N/R QSL columns in lib/qslStatus.ts.
+// The pills were dropped and stay dropped: a rounded box has its own height and
+// padding, so it sat off the row's baseline and the callsign inside it no longer
+// lined up with the plain callsigns above and below. A whole column of them read
+// as chrome rather than as data. Same reasoning — and the same semantic tokens —
+// as the Y/N/R QSL columns in lib/qslStatus.ts.
 //
-// Which cell is coloured IS the message, so one colour is enough for all three:
+// Which cell is marked IS the message:
 //
-//   yellow call → new DXCC     yellow band → new band     yellow mode → new mode
-//   blue call   → already worked
+//   filled call → new DXCC    filled band → new band    filled mode → new mode
+//   filled pfx  → new prefix  filled POTA → new park    filled county → new county
+//   blue call   → already worked (not a novelty, so text only)
 const NEW = 'var(--warning)'; // yellow: something here is new
 const WKD = 'var(--info)';    // blue: this callsign is already in the log
 
+// FILLING the cell that carries the fact, rather than only tinting its text.
+//
+// This is not a return to the pills that were dropped. A pill is a box INSIDE
+// the cell: it has its own height and padding, so it sat off the row baseline
+// and the callsign inside it stopped lining up with the plain callsigns above
+// and below. A cell background has no geometry of its own — the text does not
+// move by a single pixel — and it reads from across the room, which a tinted
+// glyph does not.
+//
+// Which cell is filled is still the whole message: filled Band means new band,
+// filled Pfx means new prefix, filled County means new county.
+//
+// The colours come from the same places they already came from — the semantic
+// status tokens and lib/spotMarkers — so a fact keeps one colour across the
+// grid, the band map and the filter chips. 22 % is the wash that survived both
+// themes: enough to see at a glance, not enough to fight the text on it.
+const fillStyle = (colour: string) => ({
+  background: `color-mix(in srgb, ${colour} 22%, transparent)`,
+  color: colour,
+  fontWeight: 700,
+});
+
 // cellText renders a cell value in an optional colour. An empty value keeps the
 // muted dash the grid used before, so blank cells still read as "nothing here"
 // rather than as a gap.
@@ -134,6 +176,7 @@ function statusColor(s: SpotStatusEntry | undefined): string | null {
     case 'new-band':
     case 'new-mode':
     case 'new-slot':
+    case 'new-call':
       return NEW;
     default:
       return s?.worked_call ? WKD : null;
@@ -149,8 +192,8 @@ function statusColor(s: SpotStatusEntry | undefined): string | null {
 // (still loading, or entity unknown) are NOT dimmed — that would flicker.
 function isDull(s: SpotStatusEntry | undefined): boolean {
   if (!s || !s.status) return false;
-  if (s.status === 'new' || s.status === 'new-band' || s.status === 'new-mode' || s.status === 'new-slot') return false;
-  return !(s.worked_call || s.new_pota || s.new_county || s.new_pfx);
+  if (s.status === 'new' || s.status === 'new-band' || s.status === 'new-mode' || s.status === 'new-slot' || s.status === 'new-call') return false;
+  return !(s.worked_call || s.new_pota || s.new_county || s.new_pfx || s.new_grid);
 }
 
 const makeColCatalog = (t: TFn): ColEntry[] => [
@@ -176,12 +219,27 @@ const makeColCatalog = (t: TFn): ColEntry[] => [
     headerName: t('clg2.c.call'), field: 'dx_call' as any, width: 120,
     defaultVisible: true,
     cellClass: 'font-mono',
-    // NEW DXCC → yellow call. Already worked → blue call. Anything else keeps
-    // the theme's normal ink so ordinary callsigns don't shout.
+    // NEW DXCC fills the call cell. Already worked only tints the text blue:
+    // 'worked' is not a novelty, and filling it would wash most of the rows.
+    cellStyle: (p: any) => (statusFor(p)?.status === 'new' ? fillStyle('var(--danger)') : null) as any,
     cellRenderer: (p: any) => {
       const s = statusFor(p);
-      const color = s?.status === 'new' ? NEW : s?.worked_call ? WKD : null;
-      return <span style={{ color: color ?? undefined, fontWeight: 700 }}>{p.value ?? ''}</span>;
+      const color = s?.status === 'new' ? null : s?.worked_call ? WKD : null;
+      return (
+        <span style={{ color: color ?? undefined, fontWeight: 700 }}>
+          {p.value ?? ''}
+          {/* A single letter rather than a word: the column is 120 px and holds a
+              callsign. It stays the muted-blue of a confirmation, never a status
+              colour — whether a station uploads to LoTW says nothing about
+              whether the spot is worth chasing. */}
+          {s?.lotw ? (
+            <span title={t('clu.lotwBadge')} style={{
+              marginLeft: 4, padding: '0 3px', borderRadius: 3, fontSize: 9, verticalAlign: 'middle',
+              background: 'color-mix(in srgb, var(--info) 22%, transparent)', color: 'var(--info)',
+            }}>L</span>
+          ) : null}
+        </span>
+      );
     },
     tooltipValueGetter: (p: any) => {
       const s = statusFor(p);
@@ -203,10 +261,12 @@ const makeColCatalog = (t: TFn): ColEntry[] => [
       else if (s?.status === 'new-band') parts.push(t('clg2.newBand'));
       else if (s?.status === 'new-mode') parts.push(t('clg2.newMode'));
       else if (s?.status === 'new-slot') parts.push(t('clg2.newSlot'));
+      else if (s?.status === 'new-call') parts.push(t('clg2.newCall'));
       else if (s?.worked_call) parts.push(t('clg2.wkdCall'));
       if (s?.new_county) parts.push(t('clg2.newCounty'));
       if (s?.new_pota) parts.push(t('clg2.newPota'));
       if (s?.new_pfx) parts.push(t('clg2.newPfx'));
+      if (s?.new_grid) parts.push(t('clg2.newGrid'));
       return parts.join(' ');
     },
     cellRenderer: (p: any) => {
@@ -218,12 +278,16 @@ const makeColCatalog = (t: TFn): ColEntry[] => [
           : s?.status === 'new-band' ? t('clg2.newBand')
             : s?.status === 'new-mode' ? t('clg2.newMode')
               : s?.status === 'new-slot' ? t('clg2.newSlot')
+                : s?.status === 'new-call' ? t('clg2.newCall')
                 : t('clg2.wkdCall');
         parts.push({ text: label, color: main });
       }
-      if (s?.new_county) parts.push({ text: t('clg2.newCounty'), color: 'var(--success)' });
-      if (s?.new_pota) parts.push({ text: t('clg2.newPota'), color: 'var(--success)' });
-      if (s?.new_pfx) parts.push({ text: t('clg2.newPfx'), color: 'var(--caution)' });
+      // Colours from lib/spotMarkers — shared with the band map so a marker is
+      // never one colour here and another there.
+      if (s?.new_county) parts.push({ text: t('clg2.newCounty'), color: markerColour('new_county') });
+      if (s?.new_pota) parts.push({ text: t('clg2.newPota'), color: markerColour('new_pota') });
+      if (s?.new_pfx) parts.push({ text: t('clg2.newPfx'), color: markerColour('new_pfx') });
+      if (s?.new_grid) parts.push({ text: t('clg2.newGrid'), color: markerColour('new_grid') });
       if (parts.length === 0) return <span style={{ color: 'var(--muted-foreground)', fontSize: 10 }}>—</span>;
       return (
         <span style={{ whiteSpace: 'nowrap' }}>
@@ -240,6 +304,7 @@ const makeColCatalog = (t: TFn): ColEntry[] => [
       if (s?.status === 'new') return t('clg2.tipNewDxcc', { country: s?.country ?? '' });
       if (s?.status === 'new-band') return t('clg2.tipNewBand');
       if (s?.status === 'new-slot') return t('clg2.tipNewSlotBand');
+      if (s?.status === 'new-call') return t('clg2.tipNewCall');
       if (s?.worked_call) return t('clg2.tipWorkedCall');
       return undefined;
     },
@@ -248,7 +313,9 @@ const makeColCatalog = (t: TFn): ColEntry[] => [
     group: 'Spot', label: t('clg2.c.pota'), colId: 'pota',
     headerName: t('clg2.c.pota'), field: 'pota_ref' as any, width: 92, cellClass: 'font-mono',
     defaultVisible: true,
-    cellStyle: { color: 'var(--success)' },
+    cellStyle: (p: any) => (statusFor(p)?.new_pota
+      ? fillStyle(markerColour('new_pota'))
+      : { color: 'var(--success)' }) as any,
     tooltipValueGetter: (p: any) => (p.data?.pota_name ? t('clg2.tipPota', { name: p.data.pota_name }) : undefined),
   },
   {
@@ -263,8 +330,9 @@ const makeColCatalog = (t: TFn): ColEntry[] => [
     headerName: t('clg2.c.band'), field: 'band' as any, width: 75,
     defaultVisible: true,
     cellClass: 'font-mono',
-    // NEW BAND for this entity → the band text turns yellow.
-    cellRenderer: (p: any) => cellText(p.value, statusFor(p)?.status === 'new-band' ? NEW : null),
+    // NEW BAND for this entity → the band cell is filled.
+    cellStyle: (p: any) => (statusFor(p)?.status === 'new-band' ? fillStyle(NEW) : null) as any,
+    cellRenderer: (p: any) => cellText(p.value, null),
     tooltipValueGetter: (p: any) => (statusFor(p)?.status === 'new-band' ? t('clg2.tipNewBand') : undefined),
   },
   {
@@ -277,7 +345,8 @@ const makeColCatalog = (t: TFn): ColEntry[] => [
     // for the entity. NEW SLOT means band AND mode were each worked before (just
     // not together), so highlighting the mode cell would wrongly imply "CW is new";
     // that case is signalled by the Status badge alone.
-    cellRenderer: (p: any) => cellText(p.value, statusFor(p)?.status === 'new-mode' ? NEW : null),
+    cellStyle: (p: any) => (statusFor(p)?.status === 'new-mode' ? fillStyle('var(--caution)') : null) as any,
+    cellRenderer: (p: any) => cellText(p.value, null),
     tooltipValueGetter: (p: any) => {
       const st = statusFor(p)?.status;
       if (st === 'new-mode') return t('clg2.tipNewMode');
@@ -289,7 +358,37 @@ const makeColCatalog = (t: TFn): ColEntry[] => [
     group: 'Spot', label: t('clg2.c.pfx'), colId: 'pfx',
     headerName: t('clg2.c.pfx'), width: 60, cellClass: 'font-mono',
     valueGetter: (p: any) => fmtPfx(p.data?.dx_call ?? ''),
-    cellStyle: { color: 'var(--muted-foreground)' },
+    // NEW PFX fills the prefix cell, in the prefix marker's own colour.
+    cellStyle: (p: any) => (statusFor(p)?.new_pfx
+      ? fillStyle(markerColour('new_pfx'))
+      : { color: 'var(--muted-foreground)' }) as any,
+    tooltipValueGetter: (p: any) => (statusFor(p)?.new_pfx ? t('clg2.tipNewPfx') : undefined),
+  },
+  {
+    group: 'Geo', label: t('clg2.c.grid'), colId: 'grid',
+    headerName: t('clg2.c.grid'), width: 70, cellClass: 'font-mono',
+    // Not on the spot: the square a station announced in a CQ that THIS receiver
+    // decoded over the WSJT-X link, so it is filled for the digital watering
+    // hole being monitored and empty everywhere else. A cluster line carries the
+    // spotter's grid at best, never the DX's.
+    valueGetter: (p: any) => statusFor(p)?.grid ?? '',
+    cellStyle: (p: any) => (statusFor(p)?.new_grid ? fillStyle(markerColour('new_grid')) : null) as any,
+    cellRenderer: (p: any) => cellText(p.value, null),
+    tooltipValueGetter: (p: any) => (statusFor(p)?.new_grid ? t('clg2.tipNewGrid') : undefined),
+  },
+  {
+    group: 'Geo', label: t('clg2.c.county'), colId: 'county',
+    headerName: t('clg2.c.county'), width: 130, cellClass: 'font-mono',
+    // Not on the spot: resolved per callsign from the offline ULS store, so it
+    // stays empty for non-US calls and until that database is downloaded.
+    valueGetter: (p: any) => {
+      const s = statusFor(p);
+      if (!s?.county) return '';
+      return s.state ? s.county + ', ' + s.state : s.county;
+    },
+    cellStyle: (p: any) => (statusFor(p)?.new_county ? fillStyle(markerColour('new_county')) : null) as any,
+    cellRenderer: (p: any) => cellText(p.value, null),
+    tooltipValueGetter: (p: any) => (statusFor(p)?.new_county ? t('clg2.tipNewCounty') : undefined),
   },
   {
     group: 'Geo', label: t('clg2.c.cqz'), colId: 'cqz',

frontend/src/components/FilterBuilder.tsx

@@ -13,7 +13,8 @@ import { useI18n } from '@/lib/i18n';
 
 export type FilterOp =
   | 'eq' | 'ne' | 'gt' | 'lt' | 'ge' | 'le'
-  | 'contains' | 'startswith' | 'endswith' | 'empty' | 'notempty';
+  | 'contains' | 'startswith' | 'endswith' | 'empty' | 'notempty'
+  | 'in' | 'notin';
 
 export interface FilterCondition { field: string; op: FilterOp; value: string }
 export interface QueryFilter {
@@ -121,9 +122,15 @@ const OPS: { value: FilterOp; label: string }[] = [
   { value: 'le', label: 'fltb.opLe' },
   { value: 'empty', label: 'fltb.opEmpty' },
   { value: 'notempty', label: 'fltb.opNotEmpty' },
+  // 'in' is what makes a real question askable. Every condition is joined by ONE
+  // AND or OR, so "2 m or 70 cm, in FT8, since January" had no expression: AND
+  // killed the two bands, OR let every FT8 QSO through. The OR lives inside the
+  // condition instead, and the rest keeps ANDing.
+  { value: 'in', label: 'fltb.opIn' },
+  { value: 'notin', label: 'fltb.opNotIn' },
 ];
 
-const TEXT_OPS: FilterOp[] = ['contains', 'startswith', 'endswith', 'eq', 'ne', 'empty', 'notempty'];
+const TEXT_OPS: FilterOp[] = ['contains', 'startswith', 'endswith', 'eq', 'ne', 'in', 'notin', 'empty', 'notempty'];
 const NUM_OPS: FilterOp[] = ['eq', 'ne', 'gt', 'lt', 'ge', 'le', 'empty', 'notempty'];
 
 function opsFor(field: string): { value: FilterOp; label: string }[] {
@@ -257,6 +264,7 @@ export function FilterBuilder({ open, initial, onApply, onClose }: Props) {
           )}
           {conditions.map((c, i) => {
             const needsValue = c.op !== 'empty' && c.op !== 'notempty';
+            const isList = c.op === 'in' || c.op === 'notin';
             const fieldType = FIELDS.find((f) => f.value === c.field)?.type ?? 'text';
             return (
               <div key={i} className="flex items-center gap-2">
@@ -281,19 +289,28 @@ export function FilterBuilder({ open, initial, onApply, onClose }: Props) {
                   // An ADIF date is picked with a calendar but STORED as the
                   // 8-digit form the column holds, so the comparison stays a
                   // plain string one on both sides.
-                  type={fieldType === 'date' || fieldType === 'adifdate' ? 'date' : fieldType === 'number' ? 'number' : 'text'}
+                  // A list is typed by hand, commas and all, so it stays a text
+                  // box even on a date or number field: a calendar cannot express
+                  // "any one of these".
+                  type={isList ? 'text'
+                    : fieldType === 'date' || fieldType === 'adifdate' ? 'date'
+                      : fieldType === 'number' ? 'number' : 'text'}
                   className="h-8 flex-1 text-xs"
                   disabled={!needsValue}
-                  placeholder={needsValue ? (fieldType === 'date' ? 'YYYY-MM-DD' : t('fltb.valuePh')) : '—'}
+                  placeholder={!needsValue ? '—'
+                    : isList ? t('fltb.listPh')
+                      : fieldType === 'date' ? 'YYYY-MM-DD' : t('fltb.valuePh')}
                   // \d, not d: the escape was missing, so the test never matched
                   // an 8-digit ADIF date and the calendar input was handed
                   // "20260728" — which type=date rejects, showing an empty box
                   // over a value that was really there.
-                  value={fieldType === 'adifdate' && /^\d{8}$/.test(c.value)
+                  // The ADIF reshaping is skipped for a list: it would eat the
+                  // commas and leave one unreadable run of digits.
+                  value={!isList && fieldType === 'adifdate' && /^\d{8}$/.test(c.value)
                     ? `${c.value.slice(0, 4)}-${c.value.slice(4, 6)}-${c.value.slice(6, 8)}`
                     : c.value}
                   onChange={(e) => setCond(i, {
-                    value: fieldType === 'adifdate' ? e.target.value.replace(/-/g, '') : e.target.value,
+                    value: !isList && fieldType === 'adifdate' ? e.target.value.replace(/-/g, '') : e.target.value,
                   })}
                   onKeyDown={(e) => { if (e.key === 'Enter') apply(); }}
                 />

frontend/src/components/IcomPanel.tsx

@@ -47,12 +47,33 @@ const ZERO: IcomState = {
 
 // Band buttons jump the VFO to a sensible default frequency (SSB/CW mix) using
 // the plain SetFrequency command — no band-stacking codes needed. Hz values.
-const BANDS: { l: string; hz: number }[] = [
+type Band = { l: string; hz: number };
+
+const HF_BANDS: Band[] = [
   { l: '160', hz: 1_840_000 }, { l: '80', hz: 3_750_000 }, { l: '40', hz: 7_100_000 },
   { l: '30', hz: 10_130_000 }, { l: '20', hz: 14_150_000 }, { l: '17', hz: 18_130_000 },
   { l: '15', hz: 21_250_000 }, { l: '12', hz: 24_950_000 }, { l: '10', hz: 28_400_000 },
-  { l: '6', hz: 50_150_000 },
 ];
+const B6 = { l: '6', hz: 50_150_000 };
+const B2 = { l: '2', hz: 144_300_000 };       // SSB calling
+const B70 = { l: '70cm', hz: 432_200_000 };   // SSB calling
+const B23 = { l: '23cm', hz: 1_296_200_000 }; // SSB calling
+
+// Band buttons jump the VFO to a sensible default frequency (SSB/CW mix) using
+// the plain SetFrequency command — no band-stacking codes needed.
+//
+// Which buttons to OFFER depends on the radio, exactly as the attenuator steps
+// do below. An IC-9700 has no HF at all, yet the console was showing it 160
+// through 6 and none of the bands it actually covers: ten dead buttons, and no
+// way to change band from here on the only rig where you would want to.
+function bandsFor(model?: string): Band[] {
+  const m = (model ?? '').toUpperCase();
+  if (m.includes('9700')) return [B2, B70, B23];          // VHF/UHF/SHF only
+  if (m.includes('705')) return [...HF_BANDS, B6, B2, B70];
+  if (m.includes('9100')) return [...HF_BANDS, B6, B2, B70, B23];
+  // 7300 / 7610 / 7100 / unknown: HF + 6 m, the historical list.
+  return [...HF_BANDS, B6];
+}
 
 // Mode buttons for the console (like RS-BA1's row). SetCATMode picks USB/LSB for
 // SSB by frequency and the rig's data variant for digital modes.
@@ -85,7 +106,10 @@ function bandOfHz(hz?: number): string {
     ['160', 1.8, 2.0], ['80', 3.5, 4.0], ['60', 5.25, 5.45], ['40', 7.0, 7.3],
     ['30', 10.1, 10.15], ['20', 14.0, 14.35], ['17', 18.068, 18.168],
     ['15', 21.0, 21.45], ['12', 24.89, 24.99], ['10', 28.0, 29.7],
-    ['6', 50.0, 54.0], ['4', 70.0, 70.5], ['2', 144.0, 148.0], ['70', 430.0, 450.0],
+    // Labels must match the band buttons' exactly — this is only used to light
+    // the button for the band the rig is on, and '70' never matched '70cm'.
+    ['6', 50.0, 54.0], ['4', 70.0, 70.5], ['2', 144.0, 148.0],
+    ['70cm', 430.0, 450.0], ['23cm', 1240.0, 1300.0],
   ];
   for (const [name, lo, hi] of bands) if (mhz >= lo && mhz <= hi) return name;
   return '';
@@ -749,7 +773,7 @@ export function IcomPanel({ onReportRST, isNetwork = false }: { onReportRST?: (r
       {/* Band buttons + antenna selection. */}
       <Card icon={Antenna} title={t('icmp.bandsAntenna')} accent="#0891b2">
         <div className="grid grid-cols-5 gap-1.5">
-          {BANDS.map((b) => {
+          {bandsFor(st.model).map((b) => {
             const here = bandOfHz(mainHz) === b.l;
             return (
               <button key={b.l} type="button" onClick={() => SetCATFrequency(b.hz).catch(() => {})}

frontend/src/components/MainMap.tsx

@@ -43,9 +43,20 @@ function unwrapLon(ring: [number, number][]): [number, number][] {
 }
 
 const CARTO_LIGHT = 'https://{s}.basemaps.cartocdn.com/light_all/{z}/{x}/{y}{r}.png';
-const OSM = 'https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png';
 const CARTO_ATTR = '© OpenStreetMap © CARTO';
-const OSM_ATTR = '© OpenStreetMap contributors';
+
+// NOT tile.openstreetmap.org. Those are OpenStreetMap's VOLUNTEER-run servers,
+// and their usage policy does not cover a desktop application handed to an
+// unbounded number of operators — they blocked OpsLog for it, and every user's
+// map filled with "Access blocked / 403" tiles at once.
+//
+// The replacements are tile services whose terms do cover redistributed apps,
+// with no API key: Carto (whose tiles are OSM-derived, hence the attribution
+// still credits OpenStreetMap) and Esri. Anything added here later must be
+// checked the same way — a free tile URL is not the same thing as a tile URL we
+// are allowed to ship.
+const ESRI_STREET = 'https://server.arcgisonline.com/ArcGIS/rest/services/World_Street_Map/MapServer/tile/{z}/{y}/{x}';
+const ESRI_STREET_ATTR = 'Tiles © Esri — Source: Esri, HERE, Garmin, © OpenStreetMap contributors';
 
 // Selectable basemaps for the world (great-circle) map. All key-free and all
 // LABELLED (country/continent names). `labelsUrl` adds a transparent place-name
@@ -55,7 +66,7 @@ const BASEMAPS: Record<BasemapKey, { label: string; url: string; attr: string; s
   light:     { label: 'Light',     url: CARTO_LIGHT, attr: CARTO_ATTR, subdomains: 'abcd' },
   voyager:   { label: 'Voyager',   url: 'https://{s}.basemaps.cartocdn.com/rastertiles/voyager/{z}/{x}/{y}{r}.png',
                attr: CARTO_ATTR, subdomains: 'abcd' },
-  street:    { label: 'Street',    url: OSM, attr: OSM_ATTR },
+  street:    { label: 'Street',    url: ESRI_STREET, attr: ESRI_STREET_ATTR },
   satellite: { label: 'Satellite', url: 'https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}',
                attr: 'Tiles &copy; Esri — Source: Esri, Maxar, Earthstar Geographics',
                labelsUrl: 'https://server.arcgisonline.com/ArcGIS/rest/services/Reference/World_Boundaries_and_Places/MapServer/tile/{z}/{y}/{x}' },
@@ -416,7 +427,14 @@ export function LocatorMap({ toGrid, toLabel }: LocatorProps) {
     if (locatorRef.current && !locatorMap.current) {
       const m = L.map(locatorRef.current, { zoomControl: true, attributionControl: true })
         .setView([20, 0], 2);
-      L.tileLayer(OSM, { attribution: OSM_ATTR, maxZoom: 19 }).addTo(m);
+      // Same restraint as the world map: fetch on idle, not mid-pan, and keep a
+      // single ring of buffer tiles. Requesting tiles as fast as the pointer
+      // moves is what gets an app blocked, and the next provider is under no
+      // more obligation to tolerate it than the last one was.
+      L.tileLayer(CARTO_LIGHT, {
+        attribution: CARTO_ATTR, subdomains: 'abcd', maxZoom: 19,
+        updateWhenIdle: true, updateWhenZooming: false, keepBuffer: 1,
+      }).addTo(m);
       locatorOverlay.current = L.layerGroup().addTo(m);
       locatorMap.current = m;
     }

frontend/src/components/SettingsModal.tsx

@@ -52,6 +52,7 @@ import {
   GetADIFMonitor, SaveADIFMonitor, PickADIFMonitorFile,
   GetRelayAuto, SaveRelayAuto, GetStationDevices,
   GetAwardDefs, GetTrackedAwards, SaveTrackedAwards,
+  GetBandOpenSettings, SaveBandOpenSettings, GetPSKReporterStatus,
 } from '../../wailsjs/go/main/App';
 import type { profile as profileModels } from '../../wailsjs/go/models';
 import type { LookupSettingsForm, StationSettingsForm, ListsSettingsForm, ModePresetForm } from '@/types';
@@ -61,6 +62,7 @@ import { EventsOn } from '../../wailsjs/runtime/runtime';
 import {
   Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter, DialogDescription,
 } from '@/components/ui/dialog';
+import { WebPublishPanel } from '@/components/WebPublishPanel';
 import { Button } from '@/components/ui/button';
 import { Input } from '@/components/ui/input';
 import { Label } from '@/components/ui/label';
@@ -143,7 +145,7 @@ const emptyProfile = (): Profile => ({
   my_grid: '', my_country: '',
   my_state: '', my_cnty: '',
   my_street: '', my_city: '', my_postal_code: '',
-  my_sota_ref: '', my_pota_ref: '',
+  my_sota_ref: '', my_pota_ref: '', my_iota: '',
   my_rig: '', my_antenna: '',
   tx_pwr: undefined,
   is_active: false,
@@ -182,6 +184,7 @@ type SectionId =
   | 'external-services'
   | 'udp'
   | 'adifmon'
+  | 'webpublish'
   | 'lookup'
   | 'lists-bands'
   | 'lists-modes'
@@ -272,6 +275,7 @@ function buildTree(flexAvailable: boolean, t: (k: string) => string): TreeNode[]
       { kind: 'item', label: t('sec.cluster'),     id: 'cluster' },
       { kind: 'item', label: t('sec.udp'), id: 'udp' },
       { kind: 'item', label: t('sec.adifmon'), id: 'adifmon' },
+      { kind: 'item', label: t('sec.webpublish'), id: 'webpublish' },
       { kind: 'item', label: t('sec.uscounties'), id: 'uscounties' },
       { kind: 'item', label: t('sec.database'), id: 'database' },
       { kind: 'item', label: t('sec.autostart'), id: 'autostart' },
@@ -289,6 +293,7 @@ const SECTION_KEY: Partial<Record<SectionId, string>> = {
   'external-services': 'sec.external', lookup: 'sec.lookup', 'lists-bands': 'sec.bands', 'lists-modes': 'sec.modes',
   cluster: 'sec.cluster', backup: 'sec.backup', database: 'sec.database', autostart: 'sec.autostart', udp: 'sec.udp',
   adifmon: 'sec.adifmon',
+  webpublish: 'sec.webpublish',
   uscounties: 'sec.uscounties',
   awards: 'sec.awards', cat: 'sec.cat', rotator: 'sec.rotator', winkeyer: 'sec.winkeyer', antenna: 'sec.antenna',
   antgenius: 'sec.antgenius', tunergenius: 'sec.tunergenius', pgxl: 'sec.pgxl', flex: 'sec.flex', audio: 'sec.audio', general: 'sec.general', email: 'sec.email',
@@ -311,6 +316,7 @@ const SECTION_LABELS: Partial<Record<SectionId, string>> = {
   autostart: 'Autostart',
   udp: 'UDP integrations',
   adifmon: 'ADIF monitor',
+  webpublish: 'Web publishing',
   awards: 'Awards',
   cat: 'CAT interface',
   rotator: 'Rotator',
@@ -1535,6 +1541,26 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   // blur, not per keystroke, or typing "10" would be rewritten to "5" the moment
   // the "1" landed and the field would fight the operator.
   const SELF_SPOT_MIN_MIN = 5;
+  // Band-opening watch. Saved through the backend rather than as a UI pref: it
+  // has side effects there — adding the RBN nodes, bringing the PSK Reporter
+  // feed up or down — so the write has to go where those live.
+  const [bandOpen, setBandOpen] = useState<any>({ enabled: false, bands: [], available: [] });
+  const [pskrStatus, setPskrStatus] = useState<any>(null);
+  const saveBandOpen = async (next: any) => {
+    setBandOpen(next);
+    try { await SaveBandOpenSettings(next); } catch { /* the status line shows the result */ }
+  };
+  useEffect(() => {
+    (async () => {
+      try { setBandOpen(await GetBandOpenSettings()); } catch { /* defaults stand */ }
+    })();
+    // Poll the feed while the panel is open: a live count is the only thing that
+    // distinguishes "connected" from "connected and receiving nothing".
+    const t = window.setInterval(async () => {
+      try { setPskrStatus(await GetPSKReporterStatus()); } catch { /* ignore */ }
+    }, 3000);
+    return () => window.clearInterval(t);
+  }, []);
   const [selfSpot, setSelfSpot] = useState({ enabled: false, minutes: SELF_SPOT_MIN_MIN });
   const [selfSpotText, setSelfSpotText] = useState(String(SELF_SPOT_MIN_MIN));
   const [clusterStatuses, setClusterStatuses] = useState<ClusterServerStatus[]>([]);
@@ -1849,6 +1875,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
           my_grid:      (activeProfile.my_grid      ?? '').trim().toUpperCase(),
           my_sota_ref:  (activeProfile.my_sota_ref  ?? '').trim().toUpperCase(),
           my_pota_ref:  (activeProfile.my_pota_ref  ?? '').trim().toUpperCase(),
+          my_iota:      (activeProfile.my_iota      ?? '').trim().toUpperCase(),
         } as any);
       }
       await SaveLookupSettings(lookup as any);
@@ -2008,6 +2035,10 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             <Label>{t('station.pota')}</Label>
             <Input className="font-mono uppercase" value={p.my_pota_ref ?? ''} onChange={(e) => updateActive({ my_pota_ref: e.target.value })} placeholder="FF-1234" />
           </div>
+          <div className="space-y-1">
+            <Label>{t('station.iota')}</Label>
+            <Input className="font-mono uppercase" value={p.my_iota ?? ''} onChange={(e) => updateActive({ my_iota: e.target.value })} placeholder="EU-005" />
+          </div>
         </div>
       </>
     );
@@ -4132,6 +4163,49 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
               onCheckedChange={(c) => { const v = !!c; setClusterWorkedSameSlot(v); writeUiPref('opslog.clusterWorkedSameSlot', v ? '1' : '0'); }} />
             <span>{t('clu.workedSameSlot')} <span className="text-xs text-muted-foreground">{t('clu.workedSameSlotHint')}</span></span>
           </label>
+          {/* "No colour on worked" and "colour what is unworked here" used to live
+              here. They moved to the Cluster tab's filter panel, next to Hide
+              worked: they are things an operator changes while working a run, not
+              things set up once. A preferences dialog you reopen every ten minutes
+              is a filter in the wrong place. */}
+
+          {/* Band-opening watch. It lives HERE, with the cluster nodes, because
+              switching it on adds two of them — the operator should see that
+              happen where it happens rather than find nodes they did not add. */}
+          <div className="border-t border-border/60 pt-3 space-y-2">
+            <label className="flex items-start gap-2 text-sm cursor-pointer">
+              <Checkbox checked={bandOpen.enabled} className="mt-0.5"
+                onCheckedChange={(c) => saveBandOpen({ ...bandOpen, enabled: !!c })} />
+              <span>{t('bo.enable')} <span className="text-xs text-muted-foreground">{t('bo.enableHint')}</span></span>
+            </label>
+            {bandOpen.enabled && (
+              <div className="pl-6 space-y-2">
+                <div className="flex flex-wrap gap-1.5">
+                  {(bandOpen.available ?? []).map((b: string) => {
+                    const on = (bandOpen.bands ?? []).includes(b);
+                    return (
+                      <button key={b} type="button"
+                        onClick={() => saveBandOpen({
+                          ...bandOpen,
+                          bands: on ? bandOpen.bands.filter((x: string) => x !== b) : [...(bandOpen.bands ?? []), b],
+                        })}
+                        className={cn('px-2 py-0.5 rounded-md border text-[11px] font-bold tracking-wider font-mono',
+                          on ? 'bg-primary text-primary-foreground border-primary' : 'text-muted-foreground border-border hover:bg-muted')}>
+                        {b}
+                      </button>
+                    );
+                  })}
+                </div>
+                {/* A live count, because a feed that is connected but silent looks
+                    exactly like one that is broken until a number moves. */}
+                <p className="text-xs text-muted-foreground">
+                  {pskrStatus?.running
+                    ? t('bo.feedUp', { n: pskrStatus.received ?? 0 })
+                    : t('bo.feedDown')}
+                </p>
+              </div>
+            )}
+          </div>
 
           {/* Self-spot. The interval only shows once it's on — an interval for
               something switched off is just a question the operator can't act on. */}
@@ -6025,6 +6099,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     // — useState/useEffect/useI18n — get a proper component context; PANELS[x]()
     // is a plain call and hook-holding panels must go through JSX like this.
     adifmon:        () => <ADIFMonitorPanel />,
+    webpublish:     () => <WebPublishPanel />,
     relayauto:      () => <RelayAutoPanel />,
     backup:         BackupPanel,
     database:       DatabasePanel,

frontend/src/components/StationControlPanel.tsx

@@ -1,5 +1,5 @@
 import { useCallback, useEffect, useLayoutEffect, useRef, useState } from 'react';
-import { Plus, Pencil, Trash2, Power, PlugZap, Loader2, Check, X, Compass, Square, Antenna as AntennaIcon, ArrowDownToLine, Minus, RefreshCw, GripVertical } from 'lucide-react';
+import { Plus, Pencil, Trash2, Power, PlugZap, Loader2, Check, X, Compass, Square, Antenna as AntennaIcon, ArrowDownToLine, Minus, RefreshCw, GripVertical, ChevronUp, ChevronDown } from 'lucide-react';
 import { Button } from '@/components/ui/button';
 import { Input } from '@/components/ui/input';
 import { Label } from '@/components/ui/label';
@@ -15,6 +15,7 @@ import {
   GetStationDevices, SaveStationDevices, GetStationStatus, StationSetRelay,
   GetRotatorHeading, RotatorGoTo, RotatorStop, SetActiveRotor,
   GetUltrabeamStatus, SetUltrabeamDirection, UltrabeamRetract, MotorSetElement, MotorReadElements,
+  MotorTuneKHz, MotorNudgeKHz, SetMotorFollow,
   ListDenkoviDevices, ListSerialPorts, TestStationDevice,
   GetAmpStatuses, GetFlexState,
   GetTunerGeniusStatus, GetTunerGeniusSettings,
@@ -115,7 +116,37 @@ function RotatorWidget({ hd, refetch, centerLat, centerLon, bearing, t }: Rotato
   );
 }
 
-type AntStatus = { enabled: boolean; type: string; connected: boolean; direction: number; frequency: number; moving: boolean; elements: number[] };
+type AntStatus = { enabled: boolean; type: string; connected: boolean; direction: number; frequency: number; moving: boolean; elements: number[]; follow?: boolean; step_khz?: number; bands?: string[] };
+
+// Where each band button points the antenna.
+//
+// Not the arithmetic centre of the band. An antenna is tuned for where people
+// actually work: 20 m centres on 14175 but nobody lives there, and 10 m spans
+// 1.7 MHz of which the top half is empty. These are the points that leave the
+// elements closest to right for the whole band, and one nudge away from the rest.
+const ANT_BAND_KHZ: Record<string, number> = {
+  '40m': 7100, '30m': 10125, '20m': 14150, '17m': 18110,
+  '15m': 21150, '12m': 24930, '10m': 28400, '6m': 50150,
+};
+
+// NUDGE_KHZ is the up/down step. 25 kHz because that is also the finest tracking
+// threshold: a nudge smaller than the tracking step would be undone by the next
+// poll while tracking is on.
+const NUDGE_KHZ = 25;
+
+// bandOfKHz names the band a frequency sits in, so a band button can light up
+// when the ANTENNA is already there. Deliberately generous at the edges: the
+// antenna's reported frequency is where it was commanded, which can sit slightly
+// outside the allocation.
+function bandOfKHz(khz: number): string {
+  const edges: [number, number, string][] = [
+    [6900, 7300, '40m'], [10050, 10200, '30m'], [13900, 14400, '20m'],
+    [18000, 18200, '17m'], [20900, 21500, '15m'], [24800, 25000, '12m'],
+    [27900, 29800, '10m'], [49900, 50600, '6m'],
+  ];
+  for (const [lo, hi, b] of edges) if (khz >= lo && khz <= hi) return b;
+  return '';
+}
 
 // MotorAntennaWidget controls a motorized antenna (Ultrabeam / SteppIR) from the
 // Station Control tab: pattern (Normal / 180° / Bi), Retract, and — Ultrabeam
@@ -203,6 +234,70 @@ function MotorAntennaWidget({ ant, refetch, t }: { ant: AntStatus; refetch: () =
             ))}
           </div>
         </div>
+        {/* Bands, then a nudge, then tracking — in the order an operator uses
+            them: get to the band, fine-tune inside it, decide whether the
+            antenna should follow the rig from here. */}
+        <div>
+          <div className="text-[10px] font-semibold uppercase tracking-wider text-muted-foreground mb-1">{t('station.bands')}</div>
+          <div className="grid grid-cols-5 gap-1">
+            {(ant.bands ?? []).map((b: string) => {
+              const khz = ANT_BAND_KHZ[b];
+              if (!khz) return null;
+              // "On this band" from the antenna's own frequency, not the rig's:
+              // the widget must show where the ANTENNA is, which is the whole
+              // reason for tuning it by hand.
+              const here = ant.frequency > 0 && bandOfKHz(ant.frequency) === b;
+              return (
+                <button key={b} type="button" disabled={!ant.connected}
+                  onClick={() => run(MotorTuneKHz(khz))}
+                  title={`${(khz / 1000).toFixed(3)} MHz`}
+                  className={cn('rounded-md border py-1 text-[11px] font-mono font-semibold transition-colors disabled:opacity-40',
+                    here ? 'bg-primary text-primary-foreground border-primary' : 'border-border hover:bg-muted')}>
+                  {b}
+                </button>
+              );
+            })}
+          </div>
+        </div>
+
+        <div className="flex items-center gap-1">
+          <button type="button" disabled={!ant.connected}
+            onClick={() => run(MotorNudgeKHz(-NUDGE_KHZ))}
+            title={t('station.nudgeDown', { n: NUDGE_KHZ })}
+            className="flex-1 flex items-center justify-center gap-1 rounded-md border border-border py-1.5 text-xs font-semibold hover:bg-muted disabled:opacity-40">
+            <ChevronDown className="size-3.5" /> {NUDGE_KHZ}
+          </button>
+          <button type="button" disabled={!ant.connected}
+            onClick={() => run(MotorNudgeKHz(NUDGE_KHZ))}
+            title={t('station.nudgeUp', { n: NUDGE_KHZ })}
+            className="flex-1 flex items-center justify-center gap-1 rounded-md border border-border py-1.5 text-xs font-semibold hover:bg-muted disabled:opacity-40">
+            <ChevronUp className="size-3.5" /> {NUDGE_KHZ}
+          </button>
+        </div>
+
+        {/* Tracking. Here rather than only in Settings because it is an operating
+            decision — off to park the antenna, on to resume — not something set
+            up once. The step only shows when tracking is on: a threshold for
+            something switched off is a question the operator cannot act on. */}
+        <div className="flex items-center gap-2">
+          <button type="button"
+            onClick={() => run(SetMotorFollow(!ant.follow, 0))}
+            className={cn('flex-1 rounded-md border py-1.5 text-xs font-semibold transition-colors',
+              ant.follow ? 'bg-success-muted text-success-muted-foreground border-success-border' : 'border-border hover:bg-muted')}>
+            {ant.follow ? t('station.trackOn') : t('station.trackOff')}
+          </button>
+          {ant.follow && (
+            <select
+              value={String(ant.step_khz || 50)}
+              onChange={(e) => run(SetMotorFollow(true, parseInt(e.target.value, 10)))}
+              className="h-[30px] rounded-md border border-border bg-background px-1 text-xs font-mono"
+              title={t('station.trackStepTip')}
+            >
+              {[25, 50, 100].map((s) => <option key={s} value={s}>{s} kHz</option>)}
+            </select>
+          )}
+        </div>
+
         <button type="button" disabled={!ant.connected}
           onClick={() => run(UltrabeamRetract())}
           className="w-full flex items-center justify-center gap-1.5 rounded-md border border-warning-border bg-warning-muted text-warning-muted-foreground py-1.5 text-xs font-semibold hover:brightness-95 disabled:opacity-40">

frontend/src/components/WebPublishPanel.tsx

@@ -0,0 +1,275 @@
+import { useEffect, useState } from 'react';
+import { Upload, FolderOpen, Loader2, ChevronsUpDown } from 'lucide-react';
+import {
+  GetWebPublishConfig, SaveWebPublishConfig, WebPublishColumns,
+  TestWebPublishFTP, PublishLogNow, GetWebPublishStatus, PickBackupFolder,
+} from '../../wailsjs/go/main/App';
+import { Button } from '@/components/ui/button';
+import { Input } from '@/components/ui/input';
+import { Label } from '@/components/ui/label';
+import { Checkbox } from '@/components/ui/checkbox';
+import { Select, SelectTrigger, SelectValue, SelectContent, SelectItem } from '@/components/ui/select';
+import {
+  DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuCheckboxItem,
+} from '@/components/ui/dropdown-menu';
+import { useI18n } from '@/lib/i18n';
+import { cn } from '@/lib/utils';
+
+type Cfg = {
+  enabled: boolean; format: string; folder: string; file_name: string; title: string;
+  count: number; interval_min: number; columns: string[];
+  ftp_enabled: boolean; ftp_host: string; ftp_port: number; ftp_user: string;
+  ftp_password: string; ftp_tls: boolean; ftp_folder: string; ftp_file_name: string;
+};
+type Col = { key: string; header: string; group: string };
+
+export function WebPublishPanel() {
+  const { t } = useI18n();
+  const [cfg, setCfg] = useState<Cfg | null>(null);
+  const [cols, setCols] = useState<Col[]>([]);
+  // The catalogue is 123 fields, so the picker is a dropdown with a search box
+  // rather than anything laid out on the page. Chosen columns stay visible above
+  // it, in publication order: after picking eight out of a hundred the question
+  // stops being 'what exists' and becomes 'what did I pick, and how will it print'.
+  const [colSearch, setColSearch] = useState('');
+  const [busy, setBusy] = useState<'' | 'test' | 'publish'>('');
+  const [msg, setMsg] = useState('');
+  const [err, setErr] = useState('');
+  // Raw text for the two numeric boxes: bound straight to the number they could
+  // not be cleared, the same trap as the Recent-QSOs Max field.
+  const [countText, setCountText] = useState('');
+  const [everyText, setEveryText] = useState('');
+
+  useEffect(() => {
+    (async () => {
+      try {
+        const [c, k, st] = await Promise.all([GetWebPublishConfig(), WebPublishColumns(), GetWebPublishStatus()]);
+        setCfg(c as any);
+        setCols((k ?? []) as Col[]);
+        setCountText(String((c as any).count ?? 100));
+        setEveryText(String((c as any).interval_min ?? 0));
+        const s: any = st;
+        if (s?.last_err) setErr(s.last_err);
+        else if (s?.last_run) setMsg(t('wpub.lastRun') + ' ' + s.last_run);
+      } catch (e: any) { setErr(String(e?.message ?? e)); }
+    })();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  if (!cfg) return <p className="text-xs text-muted-foreground">…</p>;
+  const set = (p: Partial<Cfg>) => setCfg((c) => (c ? { ...c, ...p } : c));
+
+  // Every control saves immediately: this panel has no Save button of its own,
+  // matching the other "saved instantly" panels.
+  const save = async (next: Cfg) => {
+    setCfg(next);
+    try { await SaveWebPublishConfig(next as any); setErr(''); }
+    catch (e: any) { setErr(String(e?.message ?? e)); }
+  };
+  const patch = (p: Partial<Cfg>) => save({ ...cfg, ...p });
+
+  const toggleCol = (key: string) => {
+    const has = cfg.columns?.includes(key);
+    patch({ columns: has ? cfg.columns.filter((c) => c !== key) : [...(cfg.columns ?? []), key] });
+  };
+
+  const run = async (what: 'test' | 'publish') => {
+    setBusy(what); setMsg(''); setErr('');
+    try {
+      const r = what === 'test' ? await TestWebPublishFTP(cfg as any) : await PublishLogNow();
+      setMsg(String(r));
+    } catch (e: any) { setErr(String(e?.message ?? e)); }
+    finally { setBusy(''); }
+  };
+
+  return (
+    <div className="space-y-4 max-w-3xl">
+      <p className="text-xs text-muted-foreground leading-relaxed">{t('wpub.hint')}</p>
+
+      <label className="flex items-center gap-2 text-sm cursor-pointer">
+        <Checkbox checked={cfg.enabled} onCheckedChange={(c) => patch({ enabled: !!c })} />
+        {t('wpub.enable')}
+      </label>
+
+      {cfg.enabled && (<>
+        {/* ── The file ── */}
+        <div className="space-y-2 border-t border-border/60 pt-3">
+          <Label className="text-xs font-semibold">{t('wpub.fileSection')}</Label>
+          <div className="grid grid-cols-[130px_1fr] gap-2 items-center">
+            <Label className="text-sm">{t('wpub.format')}</Label>
+            <Select value={cfg.format} onValueChange={(v) => patch({ format: v })}>
+              <SelectTrigger className="h-8 w-56"><SelectValue /></SelectTrigger>
+              <SelectContent>
+                <SelectItem value="html">{t('wpub.formatHtml')}</SelectItem>
+                <SelectItem value="csv">{t('wpub.formatCsv')}</SelectItem>
+              </SelectContent>
+            </Select>
+
+            <Label className="text-sm">{t('wpub.folder')}</Label>
+            <div className="flex gap-2">
+              <Input className="h-8 font-mono text-xs flex-1" value={cfg.folder}
+                onChange={(e) => set({ folder: e.target.value })} onBlur={() => patch({ folder: cfg.folder })} />
+              <Button variant="outline" size="sm" className="h-8" onClick={async () => {
+                try { const p = await PickBackupFolder(); if (p) patch({ folder: p }); } catch { /* cancelled */ }
+              }}><FolderOpen className="size-3.5" /> {t('wpub.browse')}</Button>
+            </div>
+
+            <Label className="text-sm">{t('wpub.fileName')}</Label>
+            <Input className="h-8 w-56 font-mono text-xs" value={cfg.file_name}
+              onChange={(e) => set({ file_name: e.target.value })} onBlur={() => patch({ file_name: cfg.file_name })} />
+
+            <Label className="text-sm">{t('wpub.title')}</Label>
+            <Input className="h-8" placeholder={t('wpub.titlePh')} value={cfg.title}
+              onChange={(e) => set({ title: e.target.value })} onBlur={() => patch({ title: cfg.title })} />
+
+            <Label className="text-sm">{t('wpub.count')}</Label>
+            <Input type="number" min={1} max={100000} className="h-8 w-28 font-mono text-xs" value={countText}
+              onChange={(e) => setCountText(e.target.value)}
+              onBlur={() => {
+                const n = Math.floor(Number(countText));
+                if (Number.isFinite(n) && n > 0) patch({ count: n }); else setCountText(String(cfg.count));
+              }} />
+
+            <Label className="text-sm">{t('wpub.every')}</Label>
+            <div className="flex items-center gap-2">
+              <Input type="number" min={0} max={1440} className="h-8 w-28 font-mono text-xs" value={everyText}
+                onChange={(e) => setEveryText(e.target.value)}
+                onBlur={() => {
+                  const n = Math.floor(Number(everyText));
+                  if (Number.isFinite(n) && n >= 0) patch({ interval_min: n }); else setEveryText(String(cfg.interval_min));
+                }} />
+              <span className="text-xs text-muted-foreground">{t('wpub.everyHint')}</span>
+            </div>
+          </div>
+        </div>
+
+        {/* ── Columns ── */}
+        <div className="space-y-2 border-t border-border/60 pt-3">
+          <div className="flex items-center justify-between">
+            <Label className="text-xs font-semibold">{t('wpub.columns')}</Label>
+            <span className="text-[11px] text-muted-foreground">
+              {t('wpub.columnsCount', { n: cfg.columns?.length ?? 0, total: cols.length })}
+            </span>
+          </div>
+
+          {/* CHOSEN, in publication order — this is the list that answers "what
+              will the page look like", which a sectioned catalogue cannot. */}
+          {(cfg.columns?.length ?? 0) > 0 && (
+            <div className="flex flex-wrap gap-1.5">
+              {cfg.columns.map((k) => {
+                const c = cols.find((x) => x.key === k);
+                return (
+                  <button key={k} type="button" onClick={() => toggleCol(k)}
+                    title={t('wpub.removeColumn')}
+                    className="px-2 py-0.5 rounded-full border border-primary bg-primary text-primary-foreground text-[11px] font-medium">
+                    {c?.header ?? k} ×
+                  </button>
+                );
+              })}
+            </div>
+          )}
+
+          {/* One dropdown, alphabetical, filtered as you type. The catalogue is
+              123 fields: laid out on the page it buries every other setting, and
+              sorting by anything but the alphabet means hunting. The menu stays
+              open while ticking — picking eight columns should be one visit. */}
+          <DropdownMenu>
+            <DropdownMenuTrigger asChild>
+              <Button variant="outline" size="sm" className="w-full justify-between h-8 text-xs font-normal">
+                {t('wpub.columnsPick')}
+                <ChevronsUpDown className="size-3.5 opacity-60" />
+              </Button>
+            </DropdownMenuTrigger>
+            {/* The search box is OUTSIDE the scrolling area, not sticky inside it.
+                Sticky kept it in place but the rows scrolled over it: a menu item
+                carries its own background and its own stacking, so it wins over a
+                sticky sibling however high its z-index. A header that never
+                scrolls has nothing to lose the fight with. */}
+            <DropdownMenuContent align="start" className="w-72 p-0 flex flex-col max-h-80">
+              <div className="p-1.5 border-b border-border/60 bg-popover shrink-0">
+                <Input className="h-7 text-xs" placeholder={t('wpub.columnsSearch')}
+                  value={colSearch}
+                  onChange={(e) => setColSearch(e.target.value)}
+                  onKeyDown={(e) => e.stopPropagation()} />
+              </div>
+              <div className="overflow-y-auto p-1">
+              {[...cols]
+                .sort((a, b) => a.header.localeCompare(b.header))
+                .filter((c) => {
+                  const q = colSearch.trim().toLowerCase();
+                  return !q || c.header.toLowerCase().includes(q) || c.key.toLowerCase().includes(q);
+                })
+                .map((c) => (
+                  <DropdownMenuCheckboxItem
+                    key={c.key}
+                    checked={cfg.columns?.includes(c.key) ?? false}
+                    onCheckedChange={() => toggleCol(c.key)}
+                    onSelect={(e) => e.preventDefault()}
+                    className="text-xs"
+                  >
+                    {c.header}
+                    <span className="ml-auto pl-2 text-[10px] text-muted-foreground font-mono">{c.group}</span>
+                  </DropdownMenuCheckboxItem>
+                ))}
+              </div>
+            </DropdownMenuContent>
+          </DropdownMenu>
+          <p className="text-[11px] text-muted-foreground">{t('wpub.columnsHint')}</p>
+        </div>
+
+        {/* ── Upload ── */}
+        <div className="space-y-2 border-t border-border/60 pt-3">
+          <label className="flex items-center gap-2 text-sm cursor-pointer">
+            <Checkbox checked={cfg.ftp_enabled} onCheckedChange={(c) => patch({ ftp_enabled: !!c })} />
+            {t('wpub.ftpEnable')}
+          </label>
+          {cfg.ftp_enabled && (
+            <div className="grid grid-cols-[130px_1fr] gap-2 items-center">
+              <Label className="text-sm">{t('wpub.ftpHost')}</Label>
+              <div className="flex gap-2">
+                <Input className="h-8 flex-1" placeholder="ftp.example.com" value={cfg.ftp_host}
+                  onChange={(e) => set({ ftp_host: e.target.value })} onBlur={() => patch({ ftp_host: cfg.ftp_host })} />
+                <Input type="number" className="h-8 w-24 font-mono text-xs" value={cfg.ftp_port}
+                  onChange={(e) => set({ ftp_port: Number(e.target.value) || 21 })}
+                  onBlur={() => patch({ ftp_port: cfg.ftp_port })} />
+              </div>
+              <Label className="text-sm">{t('wpub.ftpUser')}</Label>
+              <Input className="h-8" value={cfg.ftp_user}
+                onChange={(e) => set({ ftp_user: e.target.value })} onBlur={() => patch({ ftp_user: cfg.ftp_user })} />
+              <Label className="text-sm">{t('wpub.ftpPassword')}</Label>
+              <Input type="password" className="h-8" value={cfg.ftp_password}
+                onChange={(e) => set({ ftp_password: e.target.value })} onBlur={() => patch({ ftp_password: cfg.ftp_password })} />
+              <Label className="text-sm">{t('wpub.ftpFolder')}</Label>
+              <Input className="h-8 font-mono text-xs" placeholder="/www/log" value={cfg.ftp_folder}
+                onChange={(e) => set({ ftp_folder: e.target.value })} onBlur={() => patch({ ftp_folder: cfg.ftp_folder })} />
+              <Label className="text-sm">{t('wpub.ftpFileName')}</Label>
+              <Input className="h-8 w-56 font-mono text-xs" value={cfg.ftp_file_name}
+                onChange={(e) => set({ ftp_file_name: e.target.value })} onBlur={() => patch({ ftp_file_name: cfg.ftp_file_name })} />
+              <span />
+              <label className="flex items-center gap-2 text-sm cursor-pointer">
+                <Checkbox checked={cfg.ftp_tls} onCheckedChange={(c) => patch({ ftp_tls: !!c })} />
+                {t('wpub.ftpTls')}
+              </label>
+            </div>
+          )}
+        </div>
+
+        <div className="flex items-center gap-3 border-t border-border/60 pt-3 flex-wrap">
+          <Button size="sm" onClick={() => run('publish')} disabled={busy !== ''}>
+            {busy === 'publish' ? <Loader2 className="size-3.5 animate-spin" /> : <Upload className="size-3.5" />}
+            {t('wpub.publishNow')}
+          </Button>
+          {cfg.ftp_enabled && (
+            <Button variant="outline" size="sm" onClick={() => run('test')} disabled={busy !== ''}>
+              {busy === 'test' ? <Loader2 className="size-3.5 animate-spin" /> : null}
+              {t('wpub.testFtp')}
+            </Button>
+          )}
+        </div>
+      </>)}
+
+      {msg && <p className="text-xs text-success break-all">{msg}</p>}
+      {err && <p className="text-xs text-danger break-all">{err}</p>}
+    </div>
+  );
+}

frontend/src/lib/spotDisplay.ts

@@ -0,0 +1,66 @@
+// Two operator options that change how a spot LOOKS, shared by the DX-cluster
+// list and the band map so the two panels can never disagree about the same
+// spot — the lesson already learnt with the marker colours.
+//
+//   muteWorked    — a station already worked gets no colour and no badge. It
+//                   stays in the list, it simply stops competing for attention.
+//   slotHighlight — a callsign not yet worked on THIS band and mode is coloured,
+//                   whatever the entity says. For an operator filling slots, a
+//                   common entity on a new band+mode is the whole point, and the
+//                   entity-level status calls it "worked".
+//
+// They compose deliberately: mute what is done, light up what is not.
+
+export type SpotDisplayOptions = { muteWorked: boolean; slotHighlight: boolean };
+
+export function readSpotDisplayOptions(): SpotDisplayOptions {
+  try {
+    return {
+      muteWorked: localStorage.getItem('opslog.clusterMuteWorked') === '1',
+      slotHighlight: localStorage.getItem('opslog.clusterSlotHighlight') === '1',
+    };
+  } catch {
+    return { muteWorked: false, slotHighlight: false };
+  }
+}
+
+type Entry = {
+  status?: string;
+  worked_call?: boolean;
+  worked_slot?: boolean;
+  new_county?: boolean;
+  new_pota?: boolean;
+  new_pfx?: boolean;
+  new_grid?: boolean;
+} | undefined;
+
+// applySpotDisplay rewrites a status entry per the options, so every consumer —
+// colour, badge, status text — follows from one decision instead of each panel
+// re-deriving it.
+export function applySpotDisplay<T extends Entry>(s: T, o: SpotDisplayOptions): T {
+  if (!s) return s;
+  let e = s;
+
+  // Slot promotion runs first: a callsign not yet worked on this band and mode
+  // is not done, whatever the entity says, so it earns a status before the mute
+  // below can take its colour away.
+  if (o.slotHighlight && e.worked_slot === false && (!e.status || e.status === 'worked')) {
+    e = { ...e, status: 'new-call' } as NonNullable<T>;
+  }
+
+  // Mute drops the blue already-worked-callsign mark, and NOTHING else.
+  //
+  // It used to blank the status as well, on the theory that a spot bringing no
+  // novelty should stop painting entirely. That was wrong twice over. The status
+  // is what the cluster list reads to DIM a row, so blanking it turned every
+  // quiet grey row bright white — the option made the list louder, not quieter.
+  // And an empty status means "entity not resolved" everywhere else, so muted
+  // spots had to carry a flag saying they did not really mean that.
+  //
+  // Leaving the status alone costs nothing: a worked entity already renders with
+  // no colour and gets dimmed, so removing the blue is the entire job.
+  if (o.muteWorked) {
+    e = { ...e, worked_call: false } as NonNullable<T>;
+  }
+  return e;
+}

frontend/src/lib/spotMarkers.ts

@@ -0,0 +1,45 @@
+// The "extra" spot markers — the ones ORTHOGONAL to the entity status.
+//
+// A spot's entity status (new DXCC / new band / new slot / worked) answers one
+// question. These answer others that can be true at the same time: the park is
+// new even if the entity is worked, the county is new even if the band is not.
+// Both the DX-cluster list and the band map show them, and they have to agree —
+// the same fact must not be green in one panel and violet in the next, so the
+// colours live HERE and nowhere else. This is also the table a per-marker colour
+// setting will drive, which is why it is a table rather than three constants.
+//
+// Colour choices:
+//   POTA    green   — parks; the association is worth keeping
+//   county  violet  — a chart hue, because every semantic token was already
+//                     spoken for: red, orange and yellow are the entity
+//                     statuses, blue is "callsign worked", green is POTA
+//   worked  blue    — matches the WKD-CALL badge the cluster list has always used
+//   prefix  yellow  — unchanged
+//   grid    magenta — the last hue in the categorical set that is not already
+//                     spoken for here and does not read as a status; a grid is
+//                     never urgent the way a new entity is
+export type SpotMarkerKey = 'new_pota' | 'new_county' | 'new_pfx' | 'worked_call' | 'new_grid';
+
+export type SpotMarker = {
+  key: SpotMarkerKey;
+  colour: string;  // a CSS colour — a var() reference, so it follows the theme
+  labelKey: string; // i18n key, short form (badge / legend)
+};
+
+// Order is the display order, in both panels.
+export const SPOT_MARKERS: SpotMarker[] = [
+  { key: 'new_pota', colour: 'var(--success)', labelKey: 'clg2.newPota' },
+  { key: 'new_county', colour: 'var(--chart-5)', labelKey: 'clg2.newCounty' },
+  { key: 'new_pfx', colour: 'var(--caution)', labelKey: 'clg2.newPfx' },
+  { key: 'new_grid', colour: 'var(--chart-7)', labelKey: 'clg2.newGrid' },
+  { key: 'worked_call', colour: 'var(--info)', labelKey: 'clg2.wkdCall' },
+];
+
+export const markerColour = (key: SpotMarkerKey): string =>
+  SPOT_MARKERS.find((m) => m.key === key)?.colour ?? 'var(--muted-foreground)';
+
+// activeMarkers returns the markers set on a status entry, in display order.
+export function activeMarkers(e: Record<string, unknown> | undefined): SpotMarker[] {
+  if (!e) return [];
+  return SPOT_MARKERS.filter((m) => !!e[m.key]);
+}

frontend/src/lib/uiPref.ts

@@ -39,6 +39,8 @@ const PORTABLE_KEYS = [
   'opslog.clusterModeFilter', 'opslog.clusterSearch', 'opslog.clusterHideWorked',
   'opslog.activeTab',     // last selected tab
   'opslog.mainSplit',    // Main tab: width share of the left pane (percent)
+  'opslog.clusterMuteWorked',    // cluster/band map: no colour or badge on worked spots
+  'opslog.clusterSlotHighlight', // cluster/band map: colour calls not worked on this band+mode
   'opslog.bandMapWidth',    // docked band map: column width (px)
   'opslog.bandMapTabWidth', // Band map tab: shared card width (px)
   // NOTE: 'hamlog.awardColsShown' and the grid column layouts are NOT listed here.

frontend/src/version.ts

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

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

@@ -10,12 +10,15 @@ import {catemu} from '../models';
 import {antgenius} from '../models';
 import {award} from '../models';
 import {awardref} from '../models';
+import {bandopen} from '../models';
 import {cluster} from '../models';
 import {extsvc} from '../models';
 import {powergenius} from '../models';
+import {pskr} from '../models';
 import {spe} from '../models';
 import {solar} from '../models';
 import {tunergenius} from '../models';
+import {webpub} from '../models';
 import {winkeyer} from '../models';
 import {alerts} from '../models';
 import {audio} from '../models';
@@ -85,6 +88,8 @@ export function AwardRefsForQSOs(arg1:Array<number>):Promise<Record<number, Reco
 
 export function AwardsFolder():Promise<string>;
 
+export function BackfillDistances():Promise<main.BackfillDistancesResult>;
+
 export function BackfillUSCounties():Promise<main.BackfillUSCountiesResult>;
 
 export function BandSlotQSOs(arg1:string,arg2:number,arg3:string,arg4:string):Promise<Array<qso.QSO>>;
@@ -385,6 +390,10 @@ export function GetAwards():Promise<Array<award.Result>>;
 
 export function GetBackupSettings():Promise<main.BackupSettings>;
 
+export function GetBandOpenSettings():Promise<main.BandOpenSettings>;
+
+export function GetBandOpenings():Promise<Array<bandopen.Opening>>;
+
 export function GetCATSettings():Promise<main.CATSettings>;
 
 export function GetCATState():Promise<cat.RigState>;
@@ -435,6 +444,8 @@ export function GetIcomState():Promise<cat.IcomTXState>;
 
 export function GetListsSettings():Promise<main.ListsSettings>;
 
+export function GetLiveOpenings():Promise<Array<bandopen.Opening>>;
+
 export function GetLiveStations():Promise<Array<main.LiveStation>>;
 
 export function GetLoTWUsersStatus():Promise<main.LoTWUsersStatus>;
@@ -461,6 +472,8 @@ export function GetPGXLStatus():Promise<powergenius.Status>;
 
 export function GetPOTAToken():Promise<string>;
 
+export function GetPSKReporterStatus():Promise<pskr.Status>;
+
 export function GetPendingQSOs():Promise<Array<qso.QSO>>;
 
 export function GetQSLDefaults():Promise<main.QSLDefaults>;
@@ -509,6 +522,10 @@ export function GetUltrabeamSettings():Promise<main.UltrabeamSettings>;
 
 export function GetUltrabeamStatus():Promise<main.UltrabeamStatusInfo>;
 
+export function GetWebPublishConfig():Promise<webpub.Config>;
+
+export function GetWebPublishStatus():Promise<main.WebPublishStatus>;
+
 export function GetWhatsNew():Promise<Array<main.ChangelogEntry>>;
 
 export function GetWinkeyerSettings():Promise<main.WinkeyerSettings>;
@@ -667,10 +684,14 @@ export function LookupCallsign(arg1:string):Promise<lookup.Result>;
 
 export function LookupCallsignFresh(arg1:string):Promise<lookup.Result>;
 
+export function MotorNudgeKHz(arg1:number):Promise<void>;
+
 export function MotorReadElements():Promise<Array<number>>;
 
 export function MotorSetElement(arg1:number,arg2:number):Promise<void>;
 
+export function MotorTuneKHz(arg1:number):Promise<void>;
+
 export function MoveDatabase(arg1:string):Promise<void>;
 
 export function NetActivate(arg1:string):Promise<qso.QSO>;
@@ -737,6 +758,8 @@ export function PickSaveDatabase():Promise<string>;
 
 export function PopulateBuiltinReferences(arg1:string):Promise<number>;
 
+export function PublishLogNow():Promise<string>;
+
 export function QSLDefaultTemplateID():Promise<number>;
 
 export function QSLDeleteTemplate(arg1:number):Promise<void>;
@@ -863,6 +886,8 @@ export function SaveAwardReference(arg1:string,arg2:awardref.Ref):Promise<void>;
 
 export function SaveBackupSettings(arg1:main.BackupSettings):Promise<void>;
 
+export function SaveBandOpenSettings(arg1:main.BandOpenSettings):Promise<void>;
+
 export function SaveCATSettings(arg1:main.CATSettings):Promise<void>;
 
 export function SaveCabrilloFile():Promise<string>;
@@ -913,6 +938,8 @@ export function SaveUDPIntegration(arg1:udp.Config):Promise<udp.Config>;
 
 export function SaveUltrabeamSettings(arg1:main.UltrabeamSettings):Promise<void>;
 
+export function SaveWebPublishConfig(arg1:webpub.Config):Promise<void>;
+
 export function SaveWinkeyerSettings(arg1:main.WinkeyerSettings):Promise<void>;
 
 export function ScpLookup(arg1:string):Promise<scp.Result>;
@@ -955,6 +982,8 @@ export function SetDVKLabel(arg1:number,arg2:string):Promise<void>;
 
 export function SetKenwoodKeySpeed(arg1:number):Promise<void>;
 
+export function SetMotorFollow(arg1:boolean,arg2:number):Promise<void>;
+
 export function SetOpsLogQSLReceived(arg1:number,arg2:boolean):Promise<void>;
 
 export function SetPassphrase(arg1:string):Promise<void>;
@@ -1047,6 +1076,8 @@ export function TestStationDevice(arg1:main.StationDevice):Promise<main.StationT
 
 export function TestUltrabeam(arg1:main.UltrabeamSettings):Promise<void>;
 
+export function TestWebPublishFTP(arg1:webpub.Config):Promise<string>;
+
 export function TuneYaesuATU():Promise<void>;
 
 export function TunerGeniusActivate(arg1:number):Promise<void>;
@@ -1079,6 +1110,8 @@ export function UploadCallsign(arg1:string):Promise<string>;
 
 export function UploadQSOsManual(arg1:string,arg2:Array<number>):Promise<void>;
 
+export function WebPublishColumns():Promise<Array<Record<string, string>>>;
+
 export function WinkeyerBackspace():Promise<void>;
 
 export function WinkeyerConnect():Promise<void>;

frontend/wailsjs/go/main/App.js

@@ -118,6 +118,10 @@ export function AwardsFolder() {
   return window['go']['main']['App']['AwardsFolder']();
 }
 
+export function BackfillDistances() {
+  return window['go']['main']['App']['BackfillDistances']();
+}
+
 export function BackfillUSCounties() {
   return window['go']['main']['App']['BackfillUSCounties']();
 }
@@ -718,6 +722,14 @@ export function GetBackupSettings() {
   return window['go']['main']['App']['GetBackupSettings']();
 }
 
+export function GetBandOpenSettings() {
+  return window['go']['main']['App']['GetBandOpenSettings']();
+}
+
+export function GetBandOpenings() {
+  return window['go']['main']['App']['GetBandOpenings']();
+}
+
 export function GetCATSettings() {
   return window['go']['main']['App']['GetCATSettings']();
 }
@@ -818,6 +830,10 @@ export function GetListsSettings() {
   return window['go']['main']['App']['GetListsSettings']();
 }
 
+export function GetLiveOpenings() {
+  return window['go']['main']['App']['GetLiveOpenings']();
+}
+
 export function GetLiveStations() {
   return window['go']['main']['App']['GetLiveStations']();
 }
@@ -870,6 +886,10 @@ export function GetPOTAToken() {
   return window['go']['main']['App']['GetPOTAToken']();
 }
 
+export function GetPSKReporterStatus() {
+  return window['go']['main']['App']['GetPSKReporterStatus']();
+}
+
 export function GetPendingQSOs() {
   return window['go']['main']['App']['GetPendingQSOs']();
 }
@@ -966,6 +986,14 @@ export function GetUltrabeamStatus() {
   return window['go']['main']['App']['GetUltrabeamStatus']();
 }
 
+export function GetWebPublishConfig() {
+  return window['go']['main']['App']['GetWebPublishConfig']();
+}
+
+export function GetWebPublishStatus() {
+  return window['go']['main']['App']['GetWebPublishStatus']();
+}
+
 export function GetWhatsNew() {
   return window['go']['main']['App']['GetWhatsNew']();
 }
@@ -1282,6 +1310,10 @@ export function LookupCallsignFresh(arg1) {
   return window['go']['main']['App']['LookupCallsignFresh'](arg1);
 }
 
+export function MotorNudgeKHz(arg1) {
+  return window['go']['main']['App']['MotorNudgeKHz'](arg1);
+}
+
 export function MotorReadElements() {
   return window['go']['main']['App']['MotorReadElements']();
 }
@@ -1290,6 +1322,10 @@ export function MotorSetElement(arg1, arg2) {
   return window['go']['main']['App']['MotorSetElement'](arg1, arg2);
 }
 
+export function MotorTuneKHz(arg1) {
+  return window['go']['main']['App']['MotorTuneKHz'](arg1);
+}
+
 export function MoveDatabase(arg1) {
   return window['go']['main']['App']['MoveDatabase'](arg1);
 }
@@ -1422,6 +1458,10 @@ export function PopulateBuiltinReferences(arg1) {
   return window['go']['main']['App']['PopulateBuiltinReferences'](arg1);
 }
 
+export function PublishLogNow() {
+  return window['go']['main']['App']['PublishLogNow']();
+}
+
 export function QSLDefaultTemplateID() {
   return window['go']['main']['App']['QSLDefaultTemplateID']();
 }
@@ -1674,6 +1714,10 @@ export function SaveBackupSettings(arg1) {
   return window['go']['main']['App']['SaveBackupSettings'](arg1);
 }
 
+export function SaveBandOpenSettings(arg1) {
+  return window['go']['main']['App']['SaveBandOpenSettings'](arg1);
+}
+
 export function SaveCATSettings(arg1) {
   return window['go']['main']['App']['SaveCATSettings'](arg1);
 }
@@ -1774,6 +1818,10 @@ export function SaveUltrabeamSettings(arg1) {
   return window['go']['main']['App']['SaveUltrabeamSettings'](arg1);
 }
 
+export function SaveWebPublishConfig(arg1) {
+  return window['go']['main']['App']['SaveWebPublishConfig'](arg1);
+}
+
 export function SaveWinkeyerSettings(arg1) {
   return window['go']['main']['App']['SaveWinkeyerSettings'](arg1);
 }
@@ -1858,6 +1906,10 @@ export function SetKenwoodKeySpeed(arg1) {
   return window['go']['main']['App']['SetKenwoodKeySpeed'](arg1);
 }
 
+export function SetMotorFollow(arg1, arg2) {
+  return window['go']['main']['App']['SetMotorFollow'](arg1, arg2);
+}
+
 export function SetOpsLogQSLReceived(arg1, arg2) {
   return window['go']['main']['App']['SetOpsLogQSLReceived'](arg1, arg2);
 }
@@ -2042,6 +2094,10 @@ export function TestUltrabeam(arg1) {
   return window['go']['main']['App']['TestUltrabeam'](arg1);
 }
 
+export function TestWebPublishFTP(arg1) {
+  return window['go']['main']['App']['TestWebPublishFTP'](arg1);
+}
+
 export function TuneYaesuATU() {
   return window['go']['main']['App']['TuneYaesuATU']();
 }
@@ -2106,6 +2162,10 @@ export function UploadQSOsManual(arg1, arg2) {
   return window['go']['main']['App']['UploadQSOsManual'](arg1, arg2);
 }
 
+export function WebPublishColumns() {
+  return window['go']['main']['App']['WebPublishColumns']();
+}
+
 export function WinkeyerBackspace() {
   return window['go']['main']['App']['WinkeyerBackspace']();
 }

frontend/wailsjs/go/models.ts

@@ -677,6 +677,58 @@ export namespace awardref {
 
 }
 
+export namespace bandopen {
+	
+	export class Opening {
+	    band: string;
+	    calls: number;
+	    median_km: number;
+	    bearing_min: number;
+	    bearing_max: number;
+	    compass: string;
+	    in_season: boolean;
+	    // Go type: time
+	    at: any;
+	    examples: string[];
+	
+	    static createFrom(source: any = {}) {
+	        return new Opening(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.band = source["band"];
+	        this.calls = source["calls"];
+	        this.median_km = source["median_km"];
+	        this.bearing_min = source["bearing_min"];
+	        this.bearing_max = source["bearing_max"];
+	        this.compass = source["compass"];
+	        this.in_season = source["in_season"];
+	        this.at = this.convertValues(source["at"], null);
+	        this.examples = source["examples"];
+	    }
+	
+		convertValues(a: any, classs: any, asMap: boolean = false): any {
+		    if (!a) {
+		        return a;
+		    }
+		    if (a.slice && a.map) {
+		        return (a as any[]).map(elem => this.convertValues(elem, classs));
+		    } else if ("object" === typeof a) {
+		        if (asMap) {
+		            for (const key of Object.keys(a)) {
+		                a[key] = new classs(a[key]);
+		            }
+		            return a;
+		        }
+		        return new classs(a);
+		    }
+		    return a;
+		}
+	}
+
+}
+
 export namespace cat {
 	
 	export class FlexMeter {
@@ -1879,6 +1931,22 @@ export namespace main {
 	        this.to = source["to"];
 	    }
 	}
+	export class BackfillDistancesResult {
+	    scanned: number;
+	    filled: number;
+	    no_grid: number;
+	
+	    static createFrom(source: any = {}) {
+	        return new BackfillDistancesResult(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.scanned = source["scanned"];
+	        this.filled = source["filled"];
+	        this.no_grid = source["no_grid"];
+	    }
+	}
 	export class BackfillUSCountiesResult {
 	    scanned: number;
 	    county: number;
@@ -1921,6 +1989,22 @@ export namespace main {
 	        this.default_folder = source["default_folder"];
 	    }
 	}
+	export class BandOpenSettings {
+	    enabled: boolean;
+	    bands: string[];
+	    available: string[];
+	
+	    static createFrom(source: any = {}) {
+	        return new BandOpenSettings(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.enabled = source["enabled"];
+	        this.bands = source["bands"];
+	        this.available = source["available"];
+	    }
+	}
 	export class CATSettings {
 	    enabled: boolean;
 	    backend: string;
@@ -2937,6 +3021,7 @@ export namespace main {
 	    band: string;
 	    mode: string;
 	    pota_ref?: string;
+	    spotter?: string;
 	
 	    static createFrom(source: any = {}) {
 	        return new SpotQuery(source);
@@ -2948,6 +3033,7 @@ export namespace main {
 	        this.band = source["band"];
 	        this.mode = source["mode"];
 	        this.pota_ref = source["pota_ref"];
+	        this.spotter = source["spotter"];
 	    }
 	}
 	export class SpotStatus {
@@ -2959,9 +3045,16 @@ export namespace main {
 	    status: string;
 	    worked_call: boolean;
 	    new_county: boolean;
+	    county?: string;
+	    state?: string;
 	    new_pota: boolean;
+	    grid?: string;
+	    new_grid: boolean;
+	    spotter_continent?: string;
+	    lotw: boolean;
 	    new_pfx: boolean;
 	    pfx?: string;
+	    worked_slot: boolean;
 	
 	    static createFrom(source: any = {}) {
 	        return new SpotStatus(source);
@@ -2977,9 +3070,16 @@ export namespace main {
 	        this.status = source["status"];
 	        this.worked_call = source["worked_call"];
 	        this.new_county = source["new_county"];
+	        this.county = source["county"];
+	        this.state = source["state"];
 	        this.new_pota = source["new_pota"];
+	        this.grid = source["grid"];
+	        this.new_grid = source["new_grid"];
+	        this.spotter_continent = source["spotter_continent"];
+	        this.lotw = source["lotw"];
 	        this.new_pfx = source["new_pfx"];
 	        this.pfx = source["pfx"];
+	        this.worked_slot = source["worked_slot"];
 	    }
 	}
 	export class StartupStatus {
@@ -3110,6 +3210,7 @@ export namespace main {
 	    my_country: string;
 	    my_sota_ref: string;
 	    my_pota_ref: string;
+	    my_iota: string;
 	
 	    static createFrom(source: any = {}) {
 	        return new StationSettings(source);
@@ -3123,6 +3224,7 @@ export namespace main {
 	        this.my_country = source["my_country"];
 	        this.my_sota_ref = source["my_sota_ref"];
 	        this.my_pota_ref = source["my_pota_ref"];
+	        this.my_iota = source["my_iota"];
 	    }
 	}
 	export class StationTestResult {
@@ -3216,6 +3318,9 @@ export namespace main {
 	    band: number;
 	    moving: boolean;
 	    elements: number[];
+	    follow: boolean;
+	    step_khz: number;
+	    bands: string[];
 	
 	    static createFrom(source: any = {}) {
 	        return new UltrabeamStatusInfo(source);
@@ -3231,6 +3336,9 @@ export namespace main {
 	        this.band = source["band"];
 	        this.moving = source["moving"];
 	        this.elements = source["elements"];
+	        this.follow = source["follow"];
+	        this.step_khz = source["step_khz"];
+	        this.bands = source["bands"];
 	    }
 	}
 	export class UpdateInfo {
@@ -3267,6 +3375,20 @@ export namespace main {
 	        this.text = source["text"];
 	    }
 	}
+	export class WebPublishStatus {
+	    last_run: string;
+	    last_err: string;
+	
+	    static createFrom(source: any = {}) {
+	        return new WebPublishStatus(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.last_run = source["last_run"];
+	        this.last_err = source["last_err"];
+	    }
+	}
 	export class WinkeyerSettings {
 	    enabled: boolean;
 	    port: string;
@@ -3633,6 +3755,7 @@ export namespace profile {
 	    my_city: string;
 	    my_postal_code: string;
 	    my_sota_ref: string;
+	    my_iota: string;
 	    my_pota_ref: string;
 	    my_rig: string;
 	    my_antenna: string;
@@ -3670,6 +3793,7 @@ export namespace profile {
 	        this.my_city = source["my_city"];
 	        this.my_postal_code = source["my_postal_code"];
 	        this.my_sota_ref = source["my_sota_ref"];
+	        this.my_iota = source["my_iota"];
 	        this.my_pota_ref = source["my_pota_ref"];
 	        this.my_rig = source["my_rig"];
 	        this.my_antenna = source["my_antenna"];
@@ -3707,6 +3831,52 @@ export namespace profile {
 
 }
 
+export namespace pskr {
+	
+	export class Status {
+	    running: boolean;
+	    received: number;
+	    // Go type: time
+	    last_at: any;
+	    last_err?: string;
+	    broker: string;
+	    bands: string[];
+	
+	    static createFrom(source: any = {}) {
+	        return new Status(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.running = source["running"];
+	        this.received = source["received"];
+	        this.last_at = this.convertValues(source["last_at"], null);
+	        this.last_err = source["last_err"];
+	        this.broker = source["broker"];
+	        this.bands = source["bands"];
+	    }
+	
+		convertValues(a: any, classs: any, asMap: boolean = false): any {
+		    if (!a) {
+		        return a;
+		    }
+		    if (a.slice && a.map) {
+		        return (a as any[]).map(elem => this.convertValues(elem, classs));
+		    } else if ("object" === typeof a) {
+		        if (asMap) {
+		            for (const key of Object.keys(a)) {
+		                a[key] = new classs(a[key]);
+		            }
+		            return a;
+		        }
+		        return new classs(a);
+		    }
+		    return a;
+		}
+	}
+
+}
+
 export namespace qslcard {
 	
 	export class Bevel {
@@ -4813,6 +4983,53 @@ export namespace udp {
 
 }
 
+export namespace webpub {
+	
+	export class Config {
+	    enabled: boolean;
+	    format: string;
+	    folder: string;
+	    file_name: string;
+	    title: string;
+	    count: number;
+	    interval_min: number;
+	    columns: string[];
+	    ftp_enabled: boolean;
+	    ftp_host: string;
+	    ftp_port: number;
+	    ftp_user: string;
+	    ftp_password: string;
+	    ftp_tls: boolean;
+	    ftp_folder: string;
+	    ftp_file_name: string;
+	
+	    static createFrom(source: any = {}) {
+	        return new Config(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.enabled = source["enabled"];
+	        this.format = source["format"];
+	        this.folder = source["folder"];
+	        this.file_name = source["file_name"];
+	        this.title = source["title"];
+	        this.count = source["count"];
+	        this.interval_min = source["interval_min"];
+	        this.columns = source["columns"];
+	        this.ftp_enabled = source["ftp_enabled"];
+	        this.ftp_host = source["ftp_host"];
+	        this.ftp_port = source["ftp_port"];
+	        this.ftp_user = source["ftp_user"];
+	        this.ftp_password = source["ftp_password"];
+	        this.ftp_tls = source["ftp_tls"];
+	        this.ftp_folder = source["ftp_folder"];
+	        this.ftp_file_name = source["ftp_file_name"];
+	    }
+	}
+
+}
+
 export namespace winkeyer {
 	
 	export class Status {

go.mod

@@ -4,14 +4,16 @@ go 1.25.0
 
 require (
 	github.com/braheezy/shine-mp3 v0.1.0
+	github.com/eclipse/paho.mqtt.golang v1.5.1
 	github.com/go-ole/go-ole v1.3.0
 	github.com/go-sql-driver/mysql v1.10.0
 	github.com/gorilla/websocket v1.5.3
+	github.com/jlaffaye/ftp v0.2.2
 	github.com/moutend/go-wca v0.3.0
 	github.com/wailsapp/wails/v2 v2.11.0
 	github.com/wneessen/go-mail v0.7.3
 	go.bug.st/serial v1.7.1
-	golang.org/x/net v0.35.0
+	golang.org/x/net v0.44.0
 	golang.org/x/sys v0.45.0
 	golang.org/x/text v0.37.0
 	modernc.org/sqlite v1.50.1
@@ -43,7 +45,8 @@ require (
 	github.com/valyala/fasttemplate v1.2.2 // indirect
 	github.com/wailsapp/go-webview2 v1.0.22 // indirect
 	github.com/wailsapp/mimetype v1.4.1 // indirect
-	golang.org/x/crypto v0.33.0 // indirect
+	golang.org/x/crypto v0.42.0 // indirect
+	golang.org/x/sync v0.20.0 // indirect
 	modernc.org/libc v1.72.3 // indirect
 	modernc.org/mathutil v1.7.1 // indirect
 	modernc.org/memory v1.11.0 // indirect

go.sum

@@ -8,6 +8,8 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
 github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
+github.com/eclipse/paho.mqtt.golang v1.5.1 h1:/VSOv3oDLlpqR2Epjn1Q7b2bSTplJIeV2ISgCl2W7nE=
+github.com/eclipse/paho.mqtt.golang v1.5.1/go.mod h1:1/yJCneuyOoCOzKSsOTUc0AJfpsItBGWvYpBLimhArU=
 github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
 github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE=
 github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78=
@@ -25,6 +27,8 @@ github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs
 github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM=
 github.com/jchv/go-winloader v0.0.0-20210711035445-715c2860da7e h1:Q3+PugElBCf4PFpxhErSzU3/PY5sFL5Z6rfv4AbGAck=
 github.com/jchv/go-winloader v0.0.0-20210711035445-715c2860da7e/go.mod h1:alcuEEnZsY1WQsagKhZDsoPCRoOijYqhZvPwLG0kzVs=
+github.com/jlaffaye/ftp v0.2.2 h1:JwjrXCAIjN9ZYrF1/8qlmHFXDteh9MHYaiEIh/Oqtd8=
+github.com/jlaffaye/ftp v0.2.2/go.mod h1:zuLAKdqFqFvNgkCrH0SC7K1XyUiydS7BFCmmoHUWWg0=
 github.com/labstack/echo/v4 v4.13.3 h1:pwhpCPrTl5qry5HRdM5FwdXnhXSLSY+WE+YQSeCaafY=
 github.com/labstack/echo/v4 v4.13.3/go.mod h1:o90YNEeQWjDozo584l7AwhJMHN0bOC4tAfg+Xox9q5g=
 github.com/labstack/gommon v0.4.2 h1:F8qTUNXgG1+6WQmqoUWnz8WiEU60mXVVw0P4ht1WRA0=
@@ -64,8 +68,8 @@ github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
 github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/samber/lo v1.49.1 h1:4BIFyVfuQSEpluc7Fua+j1NolZHiEHEpaSEKdsH0tew=
 github.com/samber/lo v1.49.1/go.mod h1:dO6KHFzUKXgP8LDhU0oI8d2hekjXnGOu0DB8Jecxd6o=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 github.com/tkrajina/go-reflector v0.5.8 h1:yPADHrwmUbMq4RGEyaOUpz2H90sRsETNVpjzo3DLVQQ=
 github.com/tkrajina/go-reflector v0.5.8/go.mod h1:ECbqLgccecY5kPmPmXg1MrHW585yMcDkVl6IvJe64T4=
 github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
@@ -82,13 +86,13 @@ github.com/wneessen/go-mail v0.7.3 h1:g3DravXC5SMlVdboFrQA8Jx95A8sOzoBeS5F+vzNRK
 github.com/wneessen/go-mail v0.7.3/go.mod h1:QGhBX0yNbc1J+Mkjcu7z2rpj4B4l+BmDY8gYznPC9sk=
 go.bug.st/serial v1.7.1 h1:5aP8wYL0UjEYOVs3oPAGscjaSfRQLHtCvBFXNN/rwtc=
 go.bug.st/serial v1.7.1/go.mod h1:d0MmS16Qt9b1m06yoYRNUXhRRTJV5Qg2S5EKqQtnayQ=
-golang.org/x/crypto v0.33.0 h1:IOBPskki6Lysi0lo9qQvbxiQ+FvsCC/YWOecCHAixus=
-golang.org/x/crypto v0.33.0/go.mod h1:bVdXmD7IV/4GdElGPozy6U7lWdRXA4qyRVGJV57uQ5M=
+golang.org/x/crypto v0.42.0 h1:chiH31gIWm57EkTXpwnqf8qeuMUi0yekh6mT2AvFlqI=
+golang.org/x/crypto v0.42.0/go.mod h1:4+rDnOTJhQCx2q7/j6rAN5XDw8kPjeaXEUR2eL94ix8=
 golang.org/x/mod v0.35.0 h1:Ww1D637e6Pg+Zb2KrWfHQUnH2dQRLBQyAtpr/haaJeM=
 golang.org/x/mod v0.35.0/go.mod h1:+GwiRhIInF8wPm+4AoT6L0FA1QWAad3OMdTRx4tFYlU=
 golang.org/x/net v0.0.0-20210505024714-0287a6fb4125/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.35.0 h1:T5GQRQb2y08kTAByq9L4/bz8cipCdA8FbRTXewonqY8=
-golang.org/x/net v0.35.0/go.mod h1:EglIi67kWsHKlRzzVMUD93VMSWGFOMSZgxFjparz1Qk=
+golang.org/x/net v0.44.0 h1:evd8IRDyfNBMBTTY5XRF1vaZlD+EmWx6x8PkhR04H/I=
+golang.org/x/net v0.44.0/go.mod h1:ECOoLqd5U3Lhyeyo/QDCEVQ4sNgYsqvCZ722XogGieY=
 golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
 golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
 golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=

internal/bandopen/bandopen.go

@@ -0,0 +1,355 @@
+// Package bandopen spots a band OPENING in the cluster stream — sporadic-E on
+// 6 m, 4 m and 2 m above all.
+//
+// This is observation, not prediction. Every spot OpsLog receives is already
+// enriched with the great-circle distance and bearing from the operator's own
+// grid, so the signature of a single-hop Es opening is directly measurable:
+// several distinct stations appearing on a VHF band, all at single-hop range,
+// all in the same bearing sector, within a few minutes. That combination does
+// not happen by chance — scattered spots at random distances and bearings are
+// just a busy band.
+//
+// The season is REPORTED, never used to suppress. Es peaks in late spring and
+// summer, so an opening in November is unusual — and an unusual opening is
+// precisely the one an operator must not be told about last. InSeason only
+// labels the announcement.
+package bandopen
+
+import (
+	"math"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// Spot is the little a detection needs, taken from an enriched cluster spot.
+type Spot struct {
+	Call    string
+	Band    string
+	DistKm  int
+	Bearing int // degrees from the operator, short path
+	At      time.Time
+}
+
+// Config tunes the detector. The defaults describe single-hop sporadic E.
+type Config struct {
+	Window        time.Duration // how far back a burst may span
+	MinCalls      int           // distinct DX calls before it counts as an opening
+	MinKm, MaxKm  int           // path length accepted; MaxKm 0 = no ceiling
+	BearingSpread int           // widest arc (degrees) the spots may cover
+	Requiet       time.Duration // silence after announcing a band, so it is announced once
+}
+
+// DefaultConfig is the Es envelope.
+//
+// Below ~500 km a 6 m contact is ordinary tropo or ground wave and says nothing
+// about the ionosphere, so that floor stays.
+//
+// There is NO ceiling. There used to be one at 2400 km, on the reasoning that
+// past a single hop the bearing test stops meaning anything. That was wrong, and
+// it silently threw away exactly the openings worth hearing about: multi-hop Es
+// is ordinary on 6 m, 5000 km paths are common and 10000 km happens. Those are
+// still directional — a double hop leaves the same sector it entered — so the
+// bearing test holds perfectly well, and it is the test doing the real work here.
+//
+// 90° of spread because a genuine Es cloud illuminates a sector, not the whole
+// horizon: the constraint that separates an opening from a merely busy evening.
+func DefaultConfig() Config {
+	return Config{
+		Window:        12 * time.Minute,
+		MinCalls:      4,
+		MinKm:         500,
+		MaxKm:         0, // no ceiling — see above
+		BearingSpread: 90,
+		Requiet:       45 * time.Minute,
+	}
+}
+
+// Bands watched.
+//
+// 10 m is in, and it is HF. The line is not "HF versus VHF" but "is an opening
+// here an event": 20 m being open is the normal state of the band and saying so
+// is noise, while 10 m spends most of a solar cycle shut and opens sharply when
+// it goes — which is what an operator wants interrupting them for.
+//
+// 12 m was tried and dropped. It behaves too much like 20 m at this point in the
+// cycle: open often enough that announcing it is a notification rather than
+// news, and every band that cries wolf costs the ones that do not.
+var watched = map[string]bool{"10m": true, "6m": true, "4m": true, "2m": true}
+
+// Watched reports whether a band is one the detector looks at.
+func Watched(band string) bool { return watched[strings.ToLower(strings.TrimSpace(band))] }
+
+// Opening is a detected opening, ready to be announced.
+type Opening struct {
+	Band       string `json:"band"`
+	Calls      int    `json:"calls"`       // distinct DX stations seen
+	MedianKm   int    `json:"median_km"`   // typical hop length
+	BearingMin int    `json:"bearing_min"` // sector, degrees
+	BearingMax int    `json:"bearing_max"`
+	// Compass is the sector as a point of the compass ("NE"), computed here so
+	// the UI never has to redo the wrap-round-north arithmetic that Sector()
+	// already gets right — two answers to that question is how a badge ends up
+	// naming the opposite direction.
+	Compass  string    `json:"compass"`
+	InSeason bool      `json:"in_season"` // false = unusual for the time of year
+	At       time.Time `json:"at"`
+	Examples []string  `json:"examples"` // a few callsigns, for the announcement
+}
+
+// Detector keeps the rolling window and the per-band quiet period.
+type Detector struct {
+	cfg      Config
+	recent   []Spot
+	lastFire map[string]time.Time
+}
+
+func New(cfg Config) *Detector {
+	if cfg.Window <= 0 {
+		cfg = DefaultConfig()
+	}
+	return &Detector{cfg: cfg, lastFire: map[string]time.Time{}}
+}
+
+// Add records a spot and returns an Opening when this spot completes one.
+//
+// Returns nil far more often than not; that is the point. lat is the operator's
+// latitude, for the hemisphere the season depends on.
+func (d *Detector) Add(s Spot, lat float64) *Opening {
+	if !Watched(s.Band) {
+		return nil
+	}
+	band := strings.ToLower(strings.TrimSpace(s.Band))
+	s.Band = band
+	if s.At.IsZero() {
+		s.At = time.Now()
+	}
+	// Out-of-range spots are dropped rather than stored: they can never be part
+	// of a single-hop detection, and keeping them only grows the window.
+	if s.DistKm < d.cfg.MinKm || (d.cfg.MaxKm > 0 && s.DistKm > d.cfg.MaxKm) {
+		return nil
+	}
+	d.recent = append(d.recent, s)
+	d.prune(s.At)
+
+	if last, ok := d.lastFire[band]; ok && s.At.Sub(last) < d.cfg.Requiet {
+		return nil // already announced this band recently
+	}
+
+	inBand := make([]Spot, 0, len(d.recent))
+	for _, r := range d.recent {
+		if r.Band == band {
+			inBand = append(inBand, r)
+		}
+	}
+	op := evaluate(band, inBand, d.cfg)
+	if op == nil {
+		return nil
+	}
+	op.At = s.At
+	op.InSeason = InSeason(band, s.At, lat)
+	d.lastFire[band] = s.At
+	return op
+}
+
+func (d *Detector) prune(now time.Time) {
+	cut := now.Add(-d.cfg.Window)
+	keep := d.recent[:0]
+	for _, r := range d.recent {
+		if r.At.After(cut) {
+			keep = append(keep, r)
+		}
+	}
+	d.recent = keep
+}
+
+// evaluate decides whether a band's recent spots look like one opening.
+func evaluate(band string, spots []Spot, cfg Config) *Opening {
+	// Distinct callsigns, not spot count: one station spotted by six skimmers is
+	// six spots and one station, and it is not an opening.
+	seen := map[string]Spot{}
+	for _, s := range spots {
+		c := strings.ToUpper(strings.TrimSpace(s.Call))
+		if c == "" {
+			continue
+		}
+		if _, dup := seen[c]; !dup {
+			seen[c] = s
+		}
+	}
+	if len(seen) < cfg.MinCalls {
+		return nil
+	}
+	bearings := make([]int, 0, len(seen))
+	dists := make([]int, 0, len(seen))
+	calls := make([]string, 0, len(seen))
+	for c, s := range seen {
+		bearings = append(bearings, ((s.Bearing%360)+360)%360)
+		dists = append(dists, s.DistKm)
+		calls = append(calls, c)
+	}
+	// The DENSEST sector, not the sector covering everything.
+	//
+	// This used to demand that EVERY station fit inside one 90° arc, which is the
+	// right shape for a sporadic-E cloud and hopeless for anything else. With 10
+	// and 12 m open on F2 the reports come from all round the compass, the arc is
+	// 360°, and the test can never pass — so the busier the band, the less likely
+	// an opening was announced. Backwards.
+	//
+	// Finding the busiest 90° instead keeps the Es signature intact — a cloud
+	// still makes one direction dense — and lets an F2 opening toward South
+	// America be seen through the handful of Europeans that are always there.
+	lo, hi, n := densestSector(bearings, cfg.BearingSpread)
+	if n < cfg.MinCalls {
+		return nil // nothing concentrated anywhere: a busy band, not an opening
+	}
+	sort.Ints(dists)
+	sort.Strings(calls)
+	if len(calls) > 5 {
+		calls = calls[:5]
+	}
+	op := &Opening{
+		Band: band, Calls: len(seen), MedianKm: dists[len(dists)/2],
+		BearingMin: lo, BearingMax: hi, Examples: calls,
+	}
+	op.Compass = compass(midBearing(lo, hi))
+	return op
+}
+
+// arc returns the smallest compass sector containing every bearing, coping with
+// the wrap at north: 350° and 10° are 20° apart, not 340°.
+// densestSector returns the width-degree arc containing the most bearings, as
+// its start, end and count.
+//
+// Brute force over each bearing as a starting edge. n is at most a few hundred
+// distinct callsigns in a twelve-minute window, so n² is nothing, and it runs
+// once per accepted spot rather than once per decode.
+//
+// The arc STARTS on a real bearing rather than sweeping every degree: the
+// densest window can always be slid until its leading edge sits on a station, so
+// nothing is missed and there are 360 fewer positions to try.
+func densestSector(b []int, width int) (lo, hi, count int) {
+	if len(b) == 0 {
+		return 0, 0, 0
+	}
+	s := append([]int(nil), b...)
+	sort.Ints(s)
+	best, bestAt := 0, 0
+	for i, start := range s {
+		n := 0
+		for _, x := range s {
+			// Distance clockwise from start to x, so the wrap through 0° needs no
+			// special case — which is where the old arc() logic earned its keep and
+			// this one has to match it.
+			d := x - start
+			if d < 0 {
+				d += 360
+			}
+			if d <= width {
+				n++
+			}
+		}
+		if n > best {
+			best, bestAt = n, i
+		}
+	}
+	lo = s[bestAt]
+	// The end is the furthest station actually inside the window, not lo+width:
+	// reporting an empty 90° when every station sits in the first 20° would
+	// overstate the opening's width by four times.
+	hi = lo
+	for _, x := range s {
+		d := x - lo
+		if d < 0 {
+			d += 360
+		}
+		if d <= width {
+			if e := (lo + d) % 360; d >= ((hi-lo)+360)%360 {
+				hi = e
+			}
+		}
+	}
+	return lo, hi, best
+}
+
+func arc(b []int) (lo, hi, spread int) {
+	if len(b) == 0 {
+		return 0, 0, 0
+	}
+	s := append([]int(nil), b...)
+	sort.Ints(s)
+	// The widest GAP between consecutive bearings (round the circle) is the part
+	// NOT covered; the sector is everything else.
+	worst, at := -1, 0
+	for i := range s {
+		next := s[(i+1)%len(s)]
+		gap := next - s[i]
+		if i == len(s)-1 {
+			gap = next + 360 - s[i]
+		}
+		if gap > worst {
+			worst, at = gap, i
+		}
+	}
+	lo = s[(at+1)%len(s)]
+	hi = s[at]
+	spread = 360 - worst
+	return lo, hi, spread
+}
+
+// InSeason reports whether the time of year is one where sporadic E is common
+// at the operator's latitude.
+//
+// Each hemisphere has a strong summer peak AND a smaller winter one, and both
+// count as expected: a December opening in Europe surprises nobody. What the
+// label marks is the genuinely odd month — an equinox opening.
+//
+// This LABELS a detection, it never gates one. Out-of-season Es exists, and it
+// is precisely the opening an operator must not be told about last.
+func InSeason(band string, t time.Time, lat float64) bool {
+	m := t.UTC().Month()
+	var months map[time.Month]bool
+	if lat >= 0 {
+		months = map[time.Month]bool{
+			time.May: true, time.June: true, time.July: true, time.August: true, // main
+			time.December: true, time.January: true, // lesser winter peak
+		}
+	} else {
+		months = map[time.Month]bool{
+			time.November: true, time.December: true, time.January: true, time.February: true,
+			time.June: true, time.July: true,
+		}
+	}
+	return months[m]
+}
+
+// Sector renders the bearing range for a human, e.g. "NE (35–75°)".
+func (o *Opening) Sector() string {
+	return compass(midBearing(o.BearingMin, o.BearingMax)) +
+		" (" + strconv.Itoa(o.BearingMin) + "–" + strconv.Itoa(o.BearingMax) + "°)"
+}
+
+// midBearing is the middle of the arc running CLOCKWISE from min to max.
+//
+// Not the arithmetic mean, which is wrong for every sector crossing north and
+// wrong by the worst possible amount: an opening reported as 353–61° averaged to
+// 207° and was announced as SW when it was NE — the exact opposite direction, to
+// an operator who might turn a beam on it. The detector itself has handled the
+// 0/360 wrap since it was written; only this label did not.
+func midBearing(min, max int) float64 {
+	span := max - min
+	if span < 0 {
+		span += 360
+	}
+	return math.Mod(float64(min)+float64(span)/2, 360)
+}
+
+func compass(deg float64) string {
+	names := []string{"N", "NE", "E", "SE", "S", "SW", "W", "NW"}
+	i := int(math.Round(deg/45)) % 8
+	if i < 0 {
+		i += 8
+	}
+	return names[i]
+}

internal/bandopen/bandopen_test.go

@@ -0,0 +1,310 @@
+package bandopen
+
+import (
+	"strings"
+	"testing"
+	"time"
+)
+
+func at(min int) time.Time {
+	return time.Date(2026, time.June, 15, 12, min, 0, 0, time.UTC)
+}
+
+// feed pushes spots and returns the last Opening produced, if any.
+func feed(d *Detector, lat float64, spots ...Spot) *Opening {
+	var last *Opening
+	for _, s := range spots {
+		if o := d.Add(s, lat); o != nil {
+			last = o
+		}
+	}
+	return last
+}
+
+// The signature that must fire: several distinct stations, single-hop range,
+// one bearing sector, within the window.
+func TestDetectsSingleHopEs(t *testing.T) {
+	d := New(DefaultConfig())
+	o := feed(d, 46,
+		Spot{Call: "I0ABC", Band: "6m", DistKm: 1100, Bearing: 140, At: at(0)},
+		Spot{Call: "IK1DEF", Band: "6m", DistKm: 900, Bearing: 150, At: at(1)},
+		Spot{Call: "9A2GHI", Band: "6m", DistKm: 1200, Bearing: 120, At: at(2)},
+		Spot{Call: "S51JKL", Band: "6m", DistKm: 1000, Bearing: 130, At: at(3)},
+	)
+	if o == nil {
+		t.Fatal("four stations at single-hop range in one sector must read as an opening")
+	}
+	if o.Band != "6m" || o.Calls != 4 {
+		t.Errorf("got band=%s calls=%d, want 6m/4", o.Band, o.Calls)
+	}
+	if o.MedianKm < 900 || o.MedianKm > 1200 {
+		t.Errorf("median %d km outside the fed range", o.MedianKm)
+	}
+	if !o.InSeason {
+		t.Error("June in the northern hemisphere is Es season")
+	}
+}
+
+// Spots all round the compass are a busy band, not an opening — the bearing
+// test is what separates the two.
+func TestScatteredBearingsAreNotAnOpening(t *testing.T) {
+	d := New(DefaultConfig())
+	if o := feed(d, 46,
+		Spot{Call: "A", Band: "6m", DistKm: 1100, Bearing: 10, At: at(0)},
+		Spot{Call: "B", Band: "6m", DistKm: 900, Bearing: 110, At: at(1)},
+		Spot{Call: "C", Band: "6m", DistKm: 1200, Bearing: 210, At: at(2)},
+		Spot{Call: "D", Band: "6m", DistKm: 1000, Bearing: 300, At: at(3)},
+	); o != nil {
+		t.Errorf("bearings spread round the compass must not fire (got %+v)", o)
+	}
+}
+
+// One station spotted by six skimmers is six spots and one station.
+func TestRepeatedSpotsOfOneStationDoNotFire(t *testing.T) {
+	d := New(DefaultConfig())
+	var spots []Spot
+	for i := 0; i < 6; i++ {
+		spots = append(spots, Spot{Call: "I0ABC", Band: "6m", DistKm: 1100, Bearing: 140, At: at(i)})
+	}
+	if o := feed(d, 46, spots...); o != nil {
+		t.Error("one distinct callsign is not an opening however often it is spotted")
+	}
+}
+
+// Out of the single-hop window there is nothing to conclude: under ~500 km a
+// 6 m contact is ordinary tropo.
+func TestTropoRangeIsIgnored(t *testing.T) {
+	d := New(DefaultConfig())
+	if o := feed(d, 46,
+		Spot{Call: "A", Band: "6m", DistKm: 120, Bearing: 140, At: at(0)},
+		Spot{Call: "B", Band: "6m", DistKm: 200, Bearing: 145, At: at(1)},
+		Spot{Call: "C", Band: "6m", DistKm: 90, Bearing: 150, At: at(2)},
+		Spot{Call: "D", Band: "6m", DistKm: 150, Bearing: 135, At: at(3)},
+	); o != nil {
+		t.Error("short-range spots must not read as sporadic E")
+	}
+}
+
+// Spread over more than the window is not one burst.
+func TestSpotsOutsideTheWindowDoNotAccumulate(t *testing.T) {
+	d := New(DefaultConfig())
+	if o := feed(d, 46,
+		Spot{Call: "A", Band: "6m", DistKm: 1100, Bearing: 140, At: at(0)},
+		Spot{Call: "B", Band: "6m", DistKm: 900, Bearing: 150, At: at(20)},
+		Spot{Call: "C", Band: "6m", DistKm: 1200, Bearing: 120, At: at(40)},
+		Spot{Call: "D", Band: "6m", DistKm: 1000, Bearing: 130, At: at(60)},
+	); o != nil {
+		t.Error("spots an hour apart are not one opening")
+	}
+}
+
+// HF is never announced: an "opening" on 20 m is the band's normal state.
+func TestHFIsNotWatched(t *testing.T) {
+	if Watched("20m") || Watched("40m") {
+		t.Error("HF must not be watched")
+	}
+	if !Watched("6m") || !Watched("2m") || !Watched("4m") {
+		t.Error("6/4/2 m must be watched")
+	}
+}
+
+// Announced once, then quiet — an opening lasts hours and produces hundreds of
+// spots; one alert is information, forty is noise.
+func TestOneAnnouncementPerOpening(t *testing.T) {
+	d := New(DefaultConfig())
+	base := []Spot{
+		{Call: "A", Band: "6m", DistKm: 1100, Bearing: 140, At: at(0)},
+		{Call: "B", Band: "6m", DistKm: 900, Bearing: 150, At: at(1)},
+		{Call: "C", Band: "6m", DistKm: 1200, Bearing: 120, At: at(2)},
+		{Call: "D", Band: "6m", DistKm: 1000, Bearing: 130, At: at(3)},
+	}
+	if o := feed(d, 46, base...); o == nil {
+		t.Fatal("expected the first opening")
+	}
+	if o := d.Add(Spot{Call: "E", Band: "6m", DistKm: 1050, Bearing: 135, At: at(4)}, 46); o != nil {
+		t.Error("a second alert inside the quiet period is noise")
+	}
+}
+
+// Out-of-season openings still fire — they are the ones worth knowing about —
+// and are simply labelled as unusual.
+func TestOutOfSeasonStillFiresButIsLabelled(t *testing.T) {
+	d := New(DefaultConfig())
+	nov := func(m int) time.Time { return time.Date(2026, time.November, 3, 9, m, 0, 0, time.UTC) }
+	o := feed(d, 46,
+		Spot{Call: "A", Band: "6m", DistKm: 1100, Bearing: 140, At: nov(0)},
+		Spot{Call: "B", Band: "6m", DistKm: 900, Bearing: 150, At: nov(1)},
+		Spot{Call: "C", Band: "6m", DistKm: 1200, Bearing: 120, At: nov(2)},
+		Spot{Call: "D", Band: "6m", DistKm: 1000, Bearing: 130, At: nov(3)},
+	)
+	if o == nil {
+		t.Fatal("an out-of-season opening must still be announced")
+	}
+	if o.InSeason {
+		t.Error("November in the north is not Es season — it must be flagged unusual")
+	}
+}
+
+// Both hemispheres have a summer peak and a lesser winter one, and both read as
+// expected. What must come out as UNUSUAL is an equinox month.
+func TestSeasonFollowsTheHemisphere(t *testing.T) {
+	on := func(m time.Month) time.Time { return time.Date(2026, m, 15, 0, 0, 0, 0, time.UTC) }
+	const north, south = 46.0, -33.0
+
+	if !InSeason("6m", on(time.June), north) {
+		t.Error("June is the northern main season")
+	}
+	if !InSeason("6m", on(time.December), north) {
+		t.Error("December is the northern winter peak — not a surprise")
+	}
+	if !InSeason("6m", on(time.December), south) {
+		t.Error("December is the southern main season")
+	}
+	if !InSeason("6m", on(time.June), south) {
+		t.Error("June is the southern winter peak")
+	}
+	// The equinoxes are the quiet months in both hemispheres.
+	for _, lat := range []float64{north, south} {
+		for _, m := range []time.Month{time.March, time.April, time.September, time.October} {
+			if InSeason("6m", on(m), lat) {
+				t.Errorf("%v at lat %.0f should read as unusual", m, lat)
+			}
+		}
+	}
+}
+
+// The sector must cope with the wrap at north: 350° and 10° are 20° apart.
+func TestBearingArcWrapsAtNorth(t *testing.T) {
+	lo, hi, spread := arc([]int{350, 10, 0, 355})
+	if spread > 30 {
+		t.Errorf("spread %d° across north should be small (lo=%d hi=%d)", spread, lo, hi)
+	}
+	if _, _, s := arc([]int{0, 90, 180, 270}); s < 270 {
+		t.Errorf("bearings on all four quadrants should span nearly the circle, got %d", s)
+	}
+}
+
+// Multi-hop must be detected, not thrown away.
+//
+// The detector used to cap paths at 2400 km, on the reasoning that past one hop
+// the bearing test stops meaning anything. Nexus flagged a 6 m opening at
+// 5477 km that OpsLog never saw: the spots were discarded before any test ran.
+// Multi-hop Es is directional — a second hop leaves the sector the first one
+// entered — so distance is not what tells an opening from noise. The sector is.
+func TestMultiHopOpeningIsDetected(t *testing.T) {
+	d := New(DefaultConfig())
+	base := time.Date(2026, 6, 15, 18, 0, 0, 0, time.UTC)
+	var got *Opening
+	for i, call := range []string{"LU1AA", "PY2BB", "LU3CC", "PY4DD"} {
+		if op := d.Add(Spot{
+			Call: call, Band: "6m",
+			DistKm:  5400 + i*40, // double hop, far past the old ceiling
+			Bearing: +i * 5,      // one sector, as a real cloud illuminates
+			At:      base.Add(time.Duration(i) * time.Minute),
+		}, 47.0); op != nil {
+			got = op
+		}
+	}
+	if got == nil {
+		t.Fatal("a four-station 5400 km burst in one sector was not reported as an opening")
+	}
+	if got.Band != "6m" {
+		t.Errorf("band = %q, want 6m", got.Band)
+	}
+}
+
+// The floor stays: a short path says nothing about the ionosphere.
+func TestGroundWaveIsStillIgnored(t *testing.T) {
+	d := New(DefaultConfig())
+	base := time.Date(2026, 6, 15, 18, 0, 0, 0, time.UTC)
+	for i, call := range []string{"F1AA", "F2BB", "F3CC", "F4DD"} {
+		if op := d.Add(Spot{
+			Call: call, Band: "6m", DistKm: 120, Bearing: 90,
+			At: base.Add(time.Duration(i) * time.Minute),
+		}, 47.0); op != nil {
+			t.Fatalf("a 120 km burst was reported as an opening: %+v", op)
+		}
+	}
+}
+
+// A sector crossing north must not be labelled by its opposite.
+//
+// Sector() averaged the two bearings arithmetically, so 353–61° — plainly north
+// — came out as (353+61)/2 = 207°, announced as SW. The worst possible error:
+// not vague, but exactly reversed, to an operator who may turn a beam on it.
+func TestSectorAcrossNorth(t *testing.T) {
+	cases := []struct {
+		min, max int
+		want     string
+	}{
+		{353, 61, "NE"}, // the one seen in the field
+		{303, 11, "NW"}, // the other one
+		{35, 75, "NE"},  // no wrap, unchanged
+		{170, 190, "S"}, // due south, no wrap
+		{340, 20, "N"},  // straddling north evenly
+		{260, 300, "W"}, // due west
+	}
+	for _, c := range cases {
+		o := Opening{BearingMin: c.min, BearingMax: c.max}
+		got := o.Sector()
+		if !strings.HasPrefix(got, c.want+" ") {
+			t.Errorf("Sector(%d–%d°) = %q, want it to start with %q", c.min, c.max, got, c.want)
+		}
+	}
+}
+
+// A band open in one direction must be found THROUGH the everyday noise.
+//
+// The detector used to demand that every station fit inside one 90° arc. On 10
+// and 12 m with F2 open, reports arrive from all round the compass, the arc is
+// 360°, and the test could never pass: the busier the band, the less likely an
+// opening was announced. Reported from the field — 70 000 decodes, 10 and 12 m
+// plainly open, nothing said.
+func TestOpeningFoundThroughAllRoundNoise(t *testing.T) {
+	d := New(DefaultConfig())
+	base := time.Date(2026, 8, 11, 14, 0, 0, 0, time.UTC)
+	// Four stations concentrated to the south-west — the opening.
+	south := []struct {
+		call string
+		deg  int
+	}{{"PY2AA", 220}, {"LU3BB", 228}, {"PY5CC", 235}, {"CX4DD", 240}}
+	// And the usual Europeans scattered everywhere, which is what used to veto it.
+	noise := []struct {
+		call string
+		deg  int
+	}{{"DL1XX", 40}, {"SM2YY", 20}, {"EA3ZZ", 190}, {"UA9QQ", 70}, {"G4WW", 320}}
+
+	var got *Opening
+	for i, s := range noise {
+		d.Add(Spot{Call: s.call, Band: "10m", DistKm: 1200, Bearing: s.deg,
+			At: base.Add(time.Duration(i) * time.Second)}, 47.0)
+	}
+	for i, s := range south {
+		if op := d.Add(Spot{Call: s.call, Band: "10m", DistKm: 9800, Bearing: s.deg,
+			At: base.Add(time.Duration(10+i) * time.Second)}, 47.0); op != nil {
+			got = op
+		}
+	}
+	if got == nil {
+		t.Fatal("an opening concentrated to the SW was not found among stations all round the compass")
+	}
+	mid := midBearing(got.BearingMin, got.BearingMax)
+	if mid < 200 || mid > 260 {
+		t.Errorf("sector middle %.0f° — the reported sector is not the busy one (%d–%d°)",
+			mid, got.BearingMin, got.BearingMax)
+	}
+}
+
+// Stations evenly all round the compass and nothing concentrated: still nothing.
+// The point of the change was to stop requiring global agreement, not to start
+// calling every busy band an opening.
+func TestScatteredBandIsNotAnOpening(t *testing.T) {
+	d := New(DefaultConfig())
+	base := time.Date(2026, 8, 11, 14, 0, 0, 0, time.UTC)
+	for i, deg := range []int{0, 60, 120, 180, 240, 300} {
+		if op := d.Add(Spot{Call: string(rune('A'+i)) + "1AAA", Band: "10m",
+			DistKm: 3000, Bearing: deg, At: base.Add(time.Duration(i) * time.Second)}, 47.0); op != nil {
+			t.Fatalf("evenly scattered stations were called an opening: %+v", op)
+		}
+	}
+}

internal/cat/cat.go

@@ -200,6 +200,31 @@ func (m *Manager) SetPTT(on bool) error {
 	return m.exec(func(b Backend) error { return b.SetPTT(on) })
 }
 
+// splitSetter is implemented by the backends that can arm split AND place the
+// transmit frequency. Both together: arming without setting the dial transmits
+// on whatever the transmit VFO happened to hold, which is worse than refusing.
+type splitSetter interface {
+	SetSplit(on bool, txHz int64) error
+}
+
+// SetSplit arms or clears split on the rig, with the transmit frequency.
+//
+// Returns a plain error on a backend that cannot do it, and that is the point.
+// The shared-CAT server used to answer "done" to WSJT-X's split commands while
+// doing nothing at all — the software then believed it was transmitting up the
+// band when it was transmitting on the DX's own frequency. A refusal WSJT-X can
+// report is worth far more than a success it cannot check.
+func (m *Manager) SetSplit(on bool, txHz int64) error {
+	return m.exec(func(b Backend) error {
+		s, ok := b.(splitSetter)
+		if !ok {
+			return fmt.Errorf("cat: this radio's backend cannot set split from software — " +
+				"use Split Operating: Fake It in WSJT-X/JTDX, or set split on the radio itself")
+		}
+		return s.SetSplit(on, txHz)
+	})
+}
+
 // SpotInfo is one cluster spot to render on a backend that supports a spot
 // overlay (the FlexRadio panadapter). Color is an optional "#AARRGGBB" string;
 // the backend picks a default when it's empty. (Status-based colouring can be

internal/cat/kenwood.go

@@ -130,8 +130,30 @@ type Kenwood struct {
 	tx        bool
 	txAt      time.Time
 	lastState RigState
+	// ifRejects counts consecutive "?;" answers to IF;. See State().
+	ifRejects int
 }
 
+// errRigRejected marks a "?;" — the rig understood the frame and declined it.
+// Distinct from a serial fault on purpose: one is "ask again in a moment", the
+// other is "the link is gone", and collapsing them is what dropped CAT sharing.
+var errRigRejected = errors.New("rejected by rig")
+
+// ifRejectGrace is how many consecutive "?;" answers to IF; are ridden out
+// before the link is called dead.
+//
+// A Kenwood answers "?;" while it is busy — the tail of a transmission, a menu
+// open on the front panel. The TS-590SG does it for a moment after RX;, which is
+// exactly when the poll resumes: WSJT-X keyed through shared CAT, dropped PTT,
+// and the very next IF; came back "?;". One rejected poll then tore down the
+// whole link, WSJT-X lost the rig, and Hamlib went on to send an uninitialised
+// frequency (2^63) that OpsLog rightly refused — an alarming error message whose
+// real cause was three lines earlier in the log.
+//
+// Three at 250 ms is under a second of tolerance: long enough for the rig to
+// finish whatever it was doing, far too short to hide an unplugged cable.
+const ifRejectGrace = 3
+
 // SetLowerLines chooses whether DTR and RTS are deasserted on connect. Set
 // before Connect.
 func (k *Kenwood) SetLowerLines(v bool) {
@@ -281,8 +303,21 @@ func (k *Kenwood) ReadState() (RigState, error) {
 	}
 	raw, err := k.ask("IF;")
 	if err != nil {
+		// A "?;" is the rig saying "busy", not "gone". Ride out a few and keep
+		// serving the last known state, so the CAT link the digital software keys
+		// through survives the moment after a transmission. A serial fault is NOT
+		// covered: that returns a different error and drops through at once.
+		if errors.Is(err, errRigRejected) && k.lastState.Connected && k.ifRejects < ifRejectGrace {
+			k.ifRejects++
+			debugLog.Printf("kenwood: IF; rejected (%d/%d) — rig busy, keeping the link", k.ifRejects, ifRejectGrace)
+			s := k.lastState
+			s.Connected = true
+			return s, nil
+		}
+		k.ifRejects = 0
 		return RigState{}, err
 	}
+	k.ifRejects = 0
 	f, ok := parseKenwoodIF(raw)
 	if !ok {
 		return RigState{}, fmt.Errorf("kenwood: unparsable IF frame %q", raw)
@@ -342,16 +377,36 @@ func (k *Kenwood) ReadState() (RigState, error) {
 	f.Split = split
 
 	if f.Split {
-		// The transmit VFO is the other one. Read it rather than assume, and fall
-		// back to simplex if it cannot be read: a wrong TX frequency is written
-		// into the log, which is worse than showing no split at all.
+		// The OTHER VFO is the one IF did not report. Read it rather than assume,
+		// and fall back to simplex if it cannot be read: a wrong TX frequency is
+		// written into the log, which is worse than showing no split at all.
 		other := "FB;"
 		if f.VFO == "B" {
 			other = "FA;"
 		}
+		var otherHz int64
 		if r, err := k.ask(other); err == nil {
 			if hz, ok := parseKenwoodFreq(r, strings.TrimSuffix(other, ";")); ok && hz > 0 && hz != rx {
-				tx = hz
+				otherHz = hz
+			}
+		}
+		if otherHz > 0 {
+			// WHICH of the two is the transmit frequency depends on whether the rig
+			// is transmitting RIGHT NOW.
+			//
+			// IF reports the VFO "in use", and in split that is the RECEIVE VFO on
+			// receive and the TRANSMIT VFO on transmit. The code took it as the
+			// receive VFO always, so the moment the operator keyed up the two
+			// frequencies swapped: correct on receive, reversed on transmit, which
+			// is exactly how it was reported from a TS-590 on USB.
+			//
+			// It matters beyond the display. FreqHz is what a QSO is logged on, and
+			// a contact made in split would have gone into the log on the DX's
+			// frequency instead of the operator's.
+			if f.TX {
+				tx, rx = rx, otherHz
+			} else {
+				tx = otherHz
 			}
 		}
 	}
@@ -458,6 +513,43 @@ func isKenwoodDataMode(mode string) bool {
 	return true
 }
 
+// SetSplit arms or clears split, and when arming puts txHz on the transmit VFO.
+//
+// Both halves in one call on purpose. WSJT-X sends "split on, VFO B" and "VFO B
+// to 14075300" as two commands, and honouring only the first is worse than
+// honouring neither: split would arm on whatever VFO B happened to hold, so the
+// operator transmits somewhere they never chose while the software reports
+// exactly what they asked for. Nothing is armed here until the frequency is on
+// the dial.
+//
+// FR selects the receive VFO, FT the transmit one — the same pair the poll loop
+// already reads to detect split, so this writes what State() knows how to read.
+func (k *Kenwood) SetSplit(on bool, txHz int64) error {
+	k.mu.Lock()
+	defer k.mu.Unlock()
+	if k.port == nil {
+		return fmt.Errorf("kenwood: not connected")
+	}
+	if !on {
+		// Transmit follows receive again. FR is left alone: which VFO the operator
+		// listens on is theirs to choose, and clearing split should not move them.
+		return k.write("FT0;")
+	}
+	if txHz <= 0 || txHz > 99_999_999_999 {
+		return fmt.Errorf("kenwood: split TX frequency %d out of the 11-digit CAT range", txHz)
+	}
+	// The transmit dial FIRST, then arm. Arming first would transmit on the old
+	// contents of VFO B for however long the next command takes to arrive — brief,
+	// but on the wrong frequency, and this runs the instant before a transmission.
+	if err := k.write(fmt.Sprintf("FB%011d;", txHz)); err != nil {
+		return err
+	}
+	if err := k.write("FR0;"); err != nil { // receive on A
+		return err
+	}
+	return k.write("FT1;") // transmit on B
+}
+
 func (k *Kenwood) SetPTT(on bool) error {
 	k.mu.Lock()
 	defer k.mu.Unlock()
@@ -524,6 +616,10 @@ func (k *Kenwood) ask(cmd string) (string, error) {
 			k.rx = k.rx[i+1:]
 			traceText("kenwood", "RX", frame)
 			if frame == "?;" {
+				// Sentinel-wrapped so the poll loop can tell "the rig said no" apart
+				// from a serial fault. The two look identical as plain errors and must
+				// not be handled the same way: one means try again in a moment, the
+				// other means the link is gone.
 				// IF; and ID; are universal on Kenwood/Elecraft — a "?;" to them is a
 				// transient "busy" (typically mid-transmit, or a menu open on the rig),
 				// NOT "unsupported". Latching them off would blind the poll loop for
@@ -533,7 +629,7 @@ func (k *Kenwood) ask(cmd string) (string, error) {
 					k.unsupported[want] = true
 					debugLog.Printf("kenwood: this rig does not support %q — not asking again", cmd)
 				}
-				return "", fmt.Errorf("kenwood: %s rejected", want)
+				return "", fmt.Errorf("kenwood: %s rejected: %w", want, errRigRejected)
 			}
 			if strings.HasPrefix(frame, want) {
 				return frame, nil

internal/cat/kenwood_cw.go

@@ -29,7 +29,30 @@ const kenwoodCWChunk = 24
 
 // kenwoodCWAllowed is what the keyer can send; anything else is dropped, since an
 // unsupported byte can abort the buffer and lose the rest of the message.
-const kenwoodCWAllowed = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 /?.,-=+:;()"
+// The semicolon is deliberately absent: it TERMINATES a CAT frame. The TS-590
+// manual says so outright for P2, and one in a macro would close the command
+// early and leave the rest of the text to be read as commands of its own.
+const kenwoodCWAllowed = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 /?.,-=+:()"
+
+// padCW pads a piece to the fixed 24-character P2 a Kenwood demands.
+//
+// This is where CW over CAT failed on a TS-590SG. The KY command was written
+// against Elecraft's, which takes a variable-length string, so "KY OH5CX;" went
+// out and the radio answered "?;" — read as "this rig refuses CW over CAT", and
+// the operator was told to go and buy a serial keyer.
+//
+// The TS-590 manual is explicit: P2 has a FIXED length of 24, and characters
+// left blank are filled with spaces which are NOT keyed. So the padding costs
+// nothing on air — it is simply the shape the command has to have.
+//
+// Elecraft is left variable-length: it accepts short strings, and padding there
+// would key the trailing spaces as word gaps.
+func (k *Kenwood) padCW(chunk string) string {
+	if k.elecraft || len(chunk) >= kenwoodCWChunk {
+		return chunk
+	}
+	return chunk + strings.Repeat(" ", kenwoodCWChunk-len(chunk))
+}
 
 // SendCW queues a message on the rig's keyer, fed in 24-character pieces, waiting
 // for buffer room between pieces so a long macro doesn't lose its tail.
@@ -51,7 +74,7 @@ func (k *Kenwood) SendCW(text string) error {
 		chunk := msg[:n]
 		msg = msg[n:]
 		k.waitCWBuffer(3 * time.Second)
-		if err := k.write("KY " + chunk + ";"); err != nil {
+		if err := k.write("KY " + k.padCW(chunk) + ";"); err != nil {
 			return err
 		}
 		if err := k.afterKY(); err != nil {

internal/cat/kenwood_cw_test.go

@@ -0,0 +1,42 @@
+package cat
+
+import (
+	"strings"
+	"testing"
+)
+
+// The TS-590 wants a FIXED 24-character P2. Sending the bare text is what made
+// CW over CAT fail on a real TS-590SG: "KY OH5CX;" came back "?;", which OpsLog
+// reported as "this radio rejected CW over CAT" and sent the operator off to buy
+// a serial keyer he did not need.
+func TestKenwoodCWPadsToTheFixedWidth(t *testing.T) {
+	k := &Kenwood{}
+	got := k.padCW("OH5CX")
+	if len(got) != kenwoodCWChunk {
+		t.Errorf("padCW(%q) is %d chars, want exactly %d — the rig rejects anything else",
+			"OH5CX", len(got), kenwoodCWChunk)
+	}
+	if got[:5] != "OH5CX" || strings.TrimRight(got, " ") != "OH5CX" {
+		t.Errorf("padCW = %q — the text must be intact and the rest spaces", got)
+	}
+	// A full piece is already the right width and must not grow.
+	full := strings.Repeat("A", kenwoodCWChunk)
+	if k.padCW(full) != full {
+		t.Error("a full 24-character piece was padded further")
+	}
+
+	// Elecraft takes variable length, and padding there would key the trailing
+	// spaces as word gaps.
+	e := &Kenwood{elecraft: true}
+	if e.padCW("OH5CX") != "OH5CX" {
+		t.Errorf("Elecraft piece was padded: %q", e.padCW("OH5CX"))
+	}
+}
+
+// ";" terminates a CAT frame. The manual forbids it in P2, and one arriving in a
+// macro would close the command early and leave the rest to be read as commands.
+func TestKenwoodCWDropsTheSemicolon(t *testing.T) {
+	if got := filterKenwoodCW("CQ; DE OH5CX"); strings.Contains(got, ";") {
+		t.Errorf("filterKenwoodCW kept a semicolon: %q", got)
+	}
+}

internal/cat/kenwood_loopback_test.go

@@ -108,6 +108,9 @@ type ts2000 struct {
 	mode       byte
 	onB        bool
 	split      bool
+	// tx models the rig KEYED. On a real Kenwood in split, IF then reports the
+	// TRANSMIT VFO as the one in use — which is the whole point of the test below.
+	tx bool
 	// lazyIF models a rig that answers FR/FT correctly but never fills IF's
 	// split bit — the behaviour reported on a Flex through its Kenwood CAT
 	// emulation, where the frequency reads perfectly and split never appears.
@@ -138,8 +141,12 @@ func (r *ts2000) answer(cmd string) string {
 		}
 		// The catemu layout: IF | freq(11) | step(4) | RIT(±5) | 3 | mem(2) |
 		// rx/tx | mode | VFO | scan | split | tone | tone#(2) | shift | ;
+		txByte := 0
+		if r.tx {
+			txByte = 1
+		}
 		return fmt.Sprintf("IF%011d%04d%+06d%03d%02d%01d%c%c%01d%c%01d%02d%01d;",
-			cur, 0, 0, 0, 0, 0, r.mode, vfoDigit, 0, split, 0, 0, 0)
+			cur, 0, 0, 0, 0, txByte, r.mode, vfoDigit, 0, split, 0, 0, 0)
 	case strings.HasPrefix(cmd, "FA") && len(cmd) > 3:
 		fmt.Sscanf(cmd, "FA%d;", &r.vfoA)
 		return ""
@@ -174,6 +181,19 @@ func dialTo(rig *ts2000) func() (serial.Port, error) {
 	}
 }
 
+// dialToBusy is dialTo with a hook that makes the rig answer "?;" instead —
+// what a real Kenwood does while it is busy, rather than staying silent.
+func dialToBusy(rig *ts2000, busy func(cmd string) bool) func() (serial.Port, error) {
+	return func() (serial.Port, error) {
+		return &fakeSerial{toRig: &strings.Builder{}, answer: func(cmd string) string {
+			if busy(cmd) {
+				return "?;"
+			}
+			return rig.answer(cmd)
+		}}, nil
+	}
+}
+
 func TestKenwoodAgainstEmulatedRig(t *testing.T) {
 	rig := &ts2000{vfoA: 14250000, vfoB: 14260000, mode: '2'} // 20 m USB
 	k := NewKenwood("COM-TEST", 9600, "FT8")
@@ -383,3 +403,103 @@ func TestKenwoodNoisyRigIsReportedAsNoiseNotSilence(t *testing.T) {
 		t.Errorf("error was %q — it should say data arrived, and quote it", err)
 	}
 }
+
+// A "?;" to IF; must not tear the link down.
+//
+// The TS-590SG answers "?;" for a moment after coming out of transmit, which is
+// exactly when the poll resumes. In the field that single rejected poll dropped
+// the whole CAT link: WSJT-X, keying through shared CAT, lost the rig, and
+// Hamlib then sent an uninitialised frequency (2^63) that OpsLog refused — an
+// alarming error whose real cause was three lines earlier.
+func TestKenwoodBusyRigKeepsTheLink(t *testing.T) {
+	rig := &ts2000{vfoA: 14250000, vfoB: 14260000, mode: '2'}
+	busy := 0
+	k := NewKenwood("COM-TEST", 9600, "FT8")
+	k.dialPort = dialToBusy(rig, func(cmd string) bool {
+		if strings.HasPrefix(cmd, "IF") && busy > 0 {
+			busy--
+			return true
+		}
+		return false
+	})
+	if err := k.Connect(); err != nil {
+		t.Fatalf("connect: %v", err)
+	}
+	defer k.Disconnect()
+
+	// One good read establishes the state the busy window will keep serving.
+	first, err := k.ReadState()
+	if err != nil || !first.Connected {
+		t.Fatalf("first read: %+v err=%v", first, err)
+	}
+
+	// Inside the grace: still connected, still reporting the last good frequency.
+	busy = ifRejectGrace
+	for i := 1; i <= ifRejectGrace; i++ {
+		s, err := k.ReadState()
+		if err != nil {
+			t.Fatalf("reject %d dropped the link: %v", i, err)
+		}
+		if !s.Connected || s.FreqHz != first.FreqHz {
+			t.Errorf("reject %d gave %+v — want the last good state, still connected", i, s)
+		}
+	}
+
+	// The rig answers again → the tolerance resets, so a later busy spell gets
+	// the full allowance instead of inheriting the previous one.
+	if s, err := k.ReadState(); err != nil || !s.Connected {
+		t.Fatalf("recovery read failed: %+v err=%v", s, err)
+	}
+
+	// Past the grace, a persistent refusal IS a fault and must surface.
+	busy = ifRejectGrace + 1
+	var lastErr error
+	for i := 0; i <= ifRejectGrace; i++ {
+		if _, lastErr = k.ReadState(); lastErr != nil {
+			break
+		}
+	}
+	if lastErr == nil {
+		t.Error("a rig refusing IF; forever was still reported as healthy")
+	}
+}
+
+// In split, the two frequencies must not swap the moment the operator keys up.
+//
+// IF reports the VFO "in use", and in split that is the RECEIVE VFO on receive
+// and the TRANSMIT VFO on transmit. The backend took it as the receive VFO
+// always, so everything read correctly until the PTT closed and then reversed —
+// reported from a TS-590 on USB.
+//
+// It matters beyond the display: FreqHz is what a QSO is LOGGED on, so a split
+// contact would have been logged on the DX's frequency instead of the operator's.
+func TestKenwoodSplitDoesNotSwapOnTransmit(t *testing.T) {
+	rig := &ts2000{vfoA: 14200000, vfoB: 14205000, mode: '2', split: true}
+	k := NewKenwood("COM-TEST", 9600, "FT8")
+	k.dialPort = dialTo(rig)
+	if err := k.Connect(); err != nil {
+		t.Fatalf("connect: %v", err)
+	}
+	defer k.Disconnect()
+
+	// Receiving: IF reports VFO A, the receive dial.
+	s, err := k.ReadState()
+	if err != nil {
+		t.Fatalf("read on receive: %v", err)
+	}
+	if !s.Split || s.FreqHz != 14205000 || s.RxFreqHz != 14200000 {
+		t.Fatalf("on receive: split=%v tx=%d rx=%d — want tx 14205000, rx 14200000",
+			s.Split, s.FreqHz, s.RxFreqHz)
+	}
+
+	// Keyed: the rig switches to the transmit VFO and sets IF's TX byte.
+	rig.onB, rig.tx = true, true
+	s, err = k.ReadState()
+	if err != nil {
+		t.Fatalf("read on transmit: %v", err)
+	}
+	if s.FreqHz != 14205000 || s.RxFreqHz != 14200000 {
+		t.Errorf("on transmit: tx=%d rx=%d — the two swapped; want tx 14205000, rx 14200000",
+			s.FreqHz, s.RxFreqHz)
+	}
+}

internal/db/migrations/0025_profile_iota.sql

@@ -0,0 +1,7 @@
+-- MY_IOTA: the island reference the station operates FROM, e.g. "EU-005".
+--
+-- An official ADIF field, and the QSO table has carried my_iota since 0001 —
+-- only the station profile could not supply it, so an island activation had to
+-- have the reference typed on every contact or added afterwards. Blank by
+-- default: the overwhelming majority of stations are not on an island.
+ALTER TABLE station_profiles ADD COLUMN my_iota TEXT NOT NULL DEFAULT '';

internal/extsvc/clublog.go

@@ -27,6 +27,19 @@ const clublogBatchURL = "https://clublog.org/putlogs.php"
 // must send a real, app-identifying User-Agent.
 const clublogUserAgent = "OpsLog/1.0 (+https://github.com/GregTroar/OpsLog)"
 
+// looksLikeHTML reports a body that is a web page rather than an answer. Club
+// Log serves its normal site for refusals and blocks, so this is what separates
+// "here is what went wrong" from 4 KB of markup an operator cannot act on.
+func looksLikeHTML(s string) bool {
+	l := strings.ToLower(strings.TrimSpace(s))
+	return strings.HasPrefix(l, "<!doctype html") || strings.HasPrefix(l, "<html")
+}
+
+// clublogDownloadURL is Club Log's ADIF export. Used ONLY to verify credentials
+// (see TestClublog): it is the one authenticated endpoint that cannot change
+// anything in the operator's log, which is what a test button must never do.
+const clublogDownloadURL = "https://clublog.org/getadif.php"
+
 // clublogAppAPIKey is OpsLog's Club Log *application* API key. Club Log
 // requires an api parameter that identifies the client software (not the
 // user) — the same way Log4OM embeds its own key — so we ship it baked in
@@ -204,17 +217,84 @@ func stripHTMLBrief(s string) string {
 // TestClublog validates the configured credentials by attempting a no-op
 // style check. Club Log has no dedicated status endpoint, so we report the
 // fields look complete; a real failure surfaces on the first upload.
+// TestClublog checks the credentials against Club Log, not against themselves.
+//
+// It used to verify that the three fields were non-empty and then report
+// "Ready — <call> via <email>". Nothing was sent anywhere, so a wrong password
+// produced exactly the same green message as a right one. That is worse than
+// having no button: it is confidence the test never earned, and it cost an
+// operator the one moment they were actually looking for the problem.
+//
+// The download endpoint is used because it is READ-ONLY: testing a password
+// must not put a record into someone's log. Club Log answers a rejected login
+// with 403 before sending any body, so the answer arrives immediately; on
+// success the body is a log, and we read a few bytes and hang up rather than
+// pull it down to prove a point.
 func TestClublog(ctx context.Context, cfg ServiceConfig) (string, error) {
-	_ = ctx
+	email := strings.TrimSpace(cfg.Email)
+	call := strings.ToUpper(strings.TrimSpace(cfg.Callsign))
 	switch {
-	case strings.TrimSpace(cfg.Email) == "":
+	case email == "":
 		return "", fmt.Errorf("clublog: account email not set")
 	case cfg.Password == "":
 		return "", fmt.Errorf("clublog: password not set")
-	case strings.TrimSpace(cfg.Callsign) == "":
+	case call == "":
 		return "", fmt.Errorf("clublog: logbook callsign not set")
 	}
-	return fmt.Sprintf("Ready — %s via %s", strings.ToUpper(strings.TrimSpace(cfg.Callsign)), strings.TrimSpace(cfg.Email)), nil
+
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
+	defer cancel()
+
+	form := url.Values{}
+	form.Set("email", email)
+	form.Set("password", cfg.Password)
+	form.Set("call", call)
+	// No date filter. A "startyear=2099" was tried to keep the reply small, but
+	// Club Log answers an unrecognised request with the SAME 403 it uses for a
+	// refused login — so an unverified parameter would have made every correct
+	// password look wrong, which is the failure this whole change exists to end.
+	// The reply is capped at 4 KB and the body closed immediately instead; the
+	// status code arrives before any of it.
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, clublogDownloadURL, strings.NewReader(form.Encode()))
+	if err != nil {
+		return "", fmt.Errorf("clublog: build request: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	req.Header.Set("User-Agent", clublogUserAgent)
+
+	resp, err := (&http.Client{Timeout: 30 * time.Second}).Do(req)
+	if err != nil {
+		return "", fmt.Errorf("clublog: could not reach Club Log: %w", err)
+	}
+	defer resp.Body.Close()
+	body, _ := io.ReadAll(io.LimitReader(resp.Body, 4096))
+	msg := strings.TrimSpace(string(body))
+
+	switch resp.StatusCode {
+	case http.StatusOK:
+		return fmt.Sprintf("Ready — %s via %s (Club Log accepted the login)", call, email), nil
+	case http.StatusUnauthorized, http.StatusForbidden:
+		// Club Log refuses with its ordinary web page, not an error string, so the
+		// body is 4 KB of markup that says nothing to an operator. It goes to the
+		// log — that is where a real diagnosis happens — and the message says the
+		// one thing there is to do about it.
+		LogSink("clublog: login refused (http %d), body: %s", resp.StatusCode, msg)
+		return "", fmt.Errorf("Club Log refused the login — check the account e-mail, " +
+			"the password and the logbook callsign. They are the Club Log website's own credentials")
+	default:
+		LogSink("clublog: unexpected http %d, body: %s", resp.StatusCode, msg)
+		if looksLikeHTML(msg) {
+			return "", fmt.Errorf("clublog: Club Log answered with a web page (http %d) instead of a log — see the log file", resp.StatusCode)
+		}
+		if len(msg) > 200 {
+			msg = msg[:200] + "…"
+		}
+		return "", fmt.Errorf("clublog: http %d %s", resp.StatusCode, msg)
+	}
 }
 
 // clublogPost performs the form POST and maps the HTTP status to a result.

internal/extsvc/clublog_test.go

@@ -0,0 +1,26 @@
+package extsvc
+
+import "testing"
+
+// Club Log answers a refused login with its ordinary web page. The operator must
+// get a sentence they can act on, not four kilobytes of markup — that was the
+// first thing reported once the test started working at all.
+func TestLooksLikeHTML(t *testing.T) {
+	cases := []struct {
+		body string
+		want bool
+	}{
+		{"<!DOCTYPE html>\n<html lang='en'>…403 - Access denied…", true},
+		{"  <html><head><title>403</title></head></html>", true},
+		{"<HTML>", true},
+		{"Invalid credentials", false},
+		{"", false},
+		// An ADIF answer must never be mistaken for a page.
+		{"<eoh>\n<call:5>F4BPO <band:3>20m <eor>", false},
+	}
+	for _, c := range cases {
+		if got := looksLikeHTML(c.body); got != c.want {
+			t.Errorf("looksLikeHTML(%.40q) = %v, want %v", c.body, got, c.want)
+		}
+	}
+}

internal/extsvc/lotw.go

@@ -277,10 +277,33 @@ func TestLoTW(cfg ServiceConfig, stationDataPath string) (string, error) {
 	if err != nil {
 		return "", fmt.Errorf("lotw: can't read station locations: %w", err)
 	}
+	found := ""
 	for _, l := range locs {
 		if strings.EqualFold(l.Name, loc) {
-			return fmt.Sprintf("Ready — TQSL found, location %q (%s)", l.Name, l.Call), nil
+			found = l.Call
+			break
 		}
 	}
+	if found == "" {
 		return "", fmt.Errorf("lotw: station location %q not found in TQSL", loc)
 	}
+
+	// LoTW is TWO credentials doing two jobs, and the button used to report only
+	// the first. Uploading goes through TQSL and is signed by the certificate —
+	// the website password is never involved, so a wrong one breaks nothing until
+	// the day confirmations are downloaded and nobody connects the two events.
+	//
+	// So the download login is tested separately, and said separately. A future
+	// "since" date makes LoTW return an empty report rather than the whole
+	// account: the credentials are what is being checked, not the log.
+	up := fmt.Sprintf("Ready — TQSL found, location %q (%s)", loc, found)
+	if strings.TrimSpace(cfg.Username) == "" || cfg.Password == "" {
+		return up + ". Download login not set — confirmations cannot be fetched.", nil
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+	if _, err := DownloadLoTWConfirmations(ctx, nil, cfg, "2099-01-01", ""); err != nil {
+		return "", fmt.Errorf("%s — but the DOWNLOAD login failed: %w", up, err)
+	}
+	return up + ". Download login accepted.", nil
+}

internal/geo/geo.go

@@ -0,0 +1,69 @@
+// Package geo is the one place that turns Maidenhead locators into positions,
+// and positions into distances and bearings.
+//
+// It exists because there were about to be three copies. These functions lived
+// in package main, which the internal packages cannot import, so the PSK
+// Reporter watcher had its geometry injected from main and the web publisher
+// was about to grow its own. A bearing that disagrees with itself between two
+// panels is the kind of fault nobody reports, because each screen looks
+// plausible on its own.
+package geo
+
+import (
+	"math"
+	"strings"
+)
+
+// GridToLatLon parses a Maidenhead locator (4 or 6 characters) and returns the
+// centre of that square in degrees. ok=false on malformed input.
+func GridToLatLon(grid string) (lat, lon float64, ok bool) {
+	g := strings.ToUpper(strings.TrimSpace(grid))
+	if len(g) < 4 {
+		return 0, 0, false
+	}
+	A := g[0] - 'A'
+	B := g[1] - 'A'
+	C := g[2] - '0'
+	D := g[3] - '0'
+	if A > 17 || B > 17 || C > 9 || D > 9 {
+		return 0, 0, false
+	}
+	lon = -180 + float64(A)*20 + float64(C)*2
+	lat = -90 + float64(B)*10 + float64(D)*1
+	if len(g) >= 6 {
+		E := g[4] - 'A'
+		F := g[5] - 'A'
+		if E <= 23 && F <= 23 {
+			lon += float64(E)*(5.0/60.0) + 2.5/60.0
+			lat += float64(F)*(2.5/60.0) + 1.25/60.0
+			return lat, lon, true
+		}
+	}
+	// 4-character locator: aim at the centre of the square.
+	lon += 1
+	lat += 0.5
+	return lat, lon, true
+}
+
+// HaversineKm returns the great-circle distance between two positions in
+// kilometres. Mean Earth radius 6371 km.
+func HaversineKm(lat1, lon1, lat2, lon2 float64) float64 {
+	const R = 6371.0
+	rad := math.Pi / 180.0
+	dLat := (lat2 - lat1) * rad
+	dLon := (lon2 - lon1) * rad
+	a := math.Sin(dLat/2)*math.Sin(dLat/2) +
+		math.Cos(lat1*rad)*math.Cos(lat2*rad)*math.Sin(dLon/2)*math.Sin(dLon/2)
+	return R * 2 * math.Atan2(math.Sqrt(a), math.Sqrt(1-a))
+}
+
+// DistanceBetweenGrids is the distance in kilometres between two locators,
+// ok=false when either cannot be parsed.
+func DistanceBetweenGrids(a, b string) (km float64, ok bool) {
+	lat1, lon1, ok1 := GridToLatLon(a)
+	lat2, lon2, ok2 := GridToLatLon(b)
+	if !ok1 || !ok2 {
+		return 0, false
+	}
+	return HaversineKm(lat1, lon1, lat2, lon2), true
+}

internal/integrations/udp/server.go

@@ -59,6 +59,7 @@ type Event struct {
 
 	// A WSJT-X Decode (heard station) to render on the panadapter.
 	DecodeCall   string // transmitting (DE) callsign
+	DecodeGrid   string // 4-char grid, CQ decodes only
 	DecodeFreqHz int64  // RF frequency (dial + audio offset)
 	DecodeSNR    int    // reported SNR (dB)
 	DecodeCQ     bool   // the decode was a CQ
@@ -300,6 +301,7 @@ func (s *Server) handle(pkt []byte, remote *net.UDPAddr) {
 				return
 			}
 			ev.DecodeCall = w.DecodeCall
+			ev.DecodeGrid = w.DecodeGrid
 			ev.DecodeFreqHz = dial + w.DeltaFreqHz
 			ev.DecodeSNR = w.SNR
 			ev.DecodeCQ = w.IsCQ

internal/integrations/udp/wsjt.go

@@ -51,6 +51,7 @@ type WSJTEvent struct {
 	// known dial frequency (from Status) to DeltaFreqHz to get the RF frequency.
 	IsDecode    bool
 	DecodeCall  string // the sender (DE) callsign extracted from the message text
+	DecodeGrid  string // 4-char grid, CQ decodes only — the exchange carries none
 	DeltaFreqHz int64  // audio offset within the passband (Hz)
 	SNR         int    // reported signal-to-noise (dB)
 	IsCQ        bool   // the decode was a CQ call
@@ -239,13 +240,14 @@ func ParseWSJT(pkt []byte) (WSJTEvent, bool, error) {
 		if err != nil {
 			return WSJTEvent{}, false, err
 		}
-		call, isCQ := wsjtSender(msg)
+		call, isCQ, grid := wsjtSender(msg)
 		if call == "" {
 			return WSJTEvent{}, false, nil // free-text / telemetry / unparseable → ignore
 		}
 		ev.IsDecode = true
 		ev.DecodeCall = call
 		ev.IsCQ = isCQ
+		ev.DecodeGrid = grid
 		ev.DeltaFreqHz = int64(df)
 		ev.SNR = int(snr)
 		ev.Mode = strings.ToUpper(strings.TrimSpace(mode))
@@ -263,17 +265,20 @@ func ParseWSJT(pkt []byte) (WSJTEvent, bool, error) {
 	return WSJTEvent{}, false, nil
 }
 
-// wsjtSender extracts the transmitting (DE) callsign from a WSJT-X message and
-// whether it was a CQ. Grammar:
+// wsjtSender extracts the transmitting (DE) callsign from a WSJT-X message,
+// whether it was a CQ, and the grid when the message carries one. Grammar:
 //
-//	CQ [modifier] <de_call> [grid]      → de_call, isCQ=true
+//	CQ [modifier] <de_call> [grid]      → de_call, isCQ=true, grid
 //	<to_call> <de_call> [report|…]      → de_call, isCQ=false
 //
+// Only a CQ carries a grid: the standard exchange puts a signal report in that
+// third slot, never a locator.
+//
 // Returns "" for free-text / telemetry / hashed-call messages we can't resolve.
-func wsjtSender(message string) (call string, isCQ bool) {
+func wsjtSender(message string) (call string, isCQ bool, grid string) {
 	f := strings.Fields(strings.ToUpper(strings.TrimSpace(message)))
 	if len(f) == 0 {
-		return "", false
+		return "", false, ""
 	}
 	if f[0] == "CQ" {
 		// Skip an optional modifier after CQ (DX / a region like NA / a zone like
@@ -282,16 +287,41 @@ func wsjtSender(message string) (call string, isCQ bool) {
 		if len(f) > 2 && !looksLikeCall(f[1]) {
 			idx = 2
 		}
-		if idx < len(f) && looksLikeCall(f[idx]) {
-			return f[idx], true
+		if idx < len(f) {
+			c := f[idx]
+			// A GRID sitting in the callsign slot means the real call was
+			// unparseable and the skip above went one word too far. JN36 has letters
+			// and digits and passes every shape test there is, so without this the
+			// station's grid gets logged, spotted and coloured as its callsign.
+			if looksLikeCall(c) && !isGridField(c) {
+				if idx+1 < len(f) && isGridField(f[idx+1]) {
+					grid = f[idx+1]
 				}
-		return "", true
+				return c, true, grid
+			}
+		}
+		return "", true, ""
 	}
 	// Standard exchange: the DE (sender) call is the second token.
 	if len(f) >= 2 && looksLikeCall(f[1]) {
-		return f[1], false
+		return f[1], false, ""
 	}
-	return "", false
+	return "", false, ""
+}
+
+// isGridField reports a 4-character Maidenhead field+square (JN36).
+//
+// RR73 is the reason this is not a bare pattern match: it is a sign-off, not a
+// locator, yet R falls inside A–R and 73 inside 00–99, so it satisfies the
+// Maidenhead shape exactly. WSJT-X never puts it in the slot after a CQ call,
+// but a station sending "CQ RR73" style free text would silently plant a
+// nonexistent grid in the log's grid index, and nothing downstream could tell.
+func isGridField(s string) bool {
+	if len(s) != 4 || s == "RR73" {
+		return false
+	}
+	return s[0] >= 'A' && s[0] <= 'R' && s[1] >= 'A' && s[1] <= 'R' &&
+		s[2] >= '0' && s[2] <= '9' && s[3] >= '0' && s[3] <= '9'
 }
 
 // looksLikeCall is a loose callsign test: 3–12 chars of A–Z/0–9//, with at least

internal/integrations/udp/wsjt_sender_test.go

@@ -7,26 +7,37 @@ func TestWSJTSender(t *testing.T) {
 		msg      string
 		wantCall string
 		wantCQ   bool
+		wantGrid string
 	}{
-		{"CQ K1ABC FN42", "K1ABC", true},
-		{"CQ DX W2XYZ EM12", "W2XYZ", true},   // modifier "DX" skipped
-		{"CQ NA VE3ABC FN03", "VE3ABC", true}, // region modifier skipped
-		{"CQ 020 JA1XYZ PM95", "JA1XYZ", true},// zone modifier skipped
-		{"W2XYZ K1ABC -10", "K1ABC", false},   // exchange → sender is 2nd call
-		{"W2XYZ K1ABC R-10", "K1ABC", false},
-		{"W2XYZ K1ABC RR73", "K1ABC", false},
-		{"F4BPO K1ABC/P 73", "K1ABC/P", false},// portable call kept
-		{"CQ F/DL1ABC JO31", "F/DL1ABC", true},// compound prefix
+		{"CQ K1ABC FN42", "K1ABC", true, "FN42"},
+		{"CQ DX W2XYZ EM12", "W2XYZ", true, "EM12"},    // modifier "DX" skipped
+		{"CQ NA VE3ABC FN03", "VE3ABC", true, "FN03"},  // region modifier skipped
+		{"CQ 020 JA1XYZ PM95", "JA1XYZ", true, "PM95"}, // zone modifier skipped
+		{"W2XYZ K1ABC -10", "K1ABC", false, ""},        // exchange → sender is 2nd call
+		{"W2XYZ K1ABC R-10", "K1ABC", false, ""},
+		{"W2XYZ K1ABC RR73", "K1ABC", false, ""},
+		{"F4BPO K1ABC/P 73", "K1ABC/P", false, ""},     // portable call kept
+		{"CQ F/DL1ABC JO31", "F/DL1ABC", true, "JO31"}, // compound prefix, grid still valid
+		{"CQ K1ABC", "K1ABC", true, ""},                // CQ without a grid
+		{"CQ K1ABC RR73", "K1ABC", true, ""},           // RR73 is a sign-off, NOT grid RR73
+		{"CQ K1ABC FN4", "K1ABC", true, ""},            // 3 chars is not a field+square
+		{"CQ K1ABC FN42AB", "K1ABC", true, ""},         // 6-char: WSJT-X never sends it here
+		{"CQ K1ABC 73", "K1ABC", true, ""},             // bare sign-off
+		{"CQ K1ABC SS42", "K1ABC", true, ""},           // S is past R — no such field
+		// An unknown word after CQ made the parser skip a slot; a grid passes every
+		// shape test a callsign does, so it came back AS the callsign.
+		{"CQ FOO JN36", "", true, ""},
 		// Non-callsign / free text → no sender.
-		{"TNX 73 GL", "", false},
-		{"K1ABC RR73", "", false}, // only one call + a token → 2nd token not a call
-		{"", "", false},
-		{"CQ CQ CQ", "", true}, // CQ but no resolvable call
+		{"TNX 73 GL", "", false, ""},
+		{"K1ABC RR73", "", false, ""}, // only one call + a token → 2nd token not a call
+		{"", "", false, ""},
+		{"CQ CQ CQ", "", true, ""}, // CQ but no resolvable call
 	}
 	for _, c := range cases {
-		call, cq := wsjtSender(c.msg)
-		if call != c.wantCall || cq != c.wantCQ {
-			t.Errorf("wsjtSender(%q) = (%q,%v), want (%q,%v)", c.msg, call, cq, c.wantCall, c.wantCQ)
+		call, cq, grid := wsjtSender(c.msg)
+		if call != c.wantCall || cq != c.wantCQ || grid != c.wantGrid {
+			t.Errorf("wsjtSender(%q) = (%q,%v,%q), want (%q,%v,%q)",
+				c.msg, call, cq, grid, c.wantCall, c.wantCQ, c.wantGrid)
 		}
 	}
 }

internal/lookup/lookup.go

@@ -176,12 +176,20 @@ func (m *Manager) Lookup(ctx context.Context, callsign string) (Result, error) {
 			r.Callsign = call
 			r.Source = p.Name()
 			r.FetchedAt = time.Now().UTC()
-			// The home record's location is the operator's HOME, not where they
-			// are portable now — clear it so cty.dat fills the real entity.
+			// The home record's location is the operator's HOME — clear it so
+			// cty.dat fills in where they actually are.
+			//
+			// UNLESS the suffix says nothing about location. /QRP is a statement
+			// about power, not about place: M0BFS/QRP is M0BFS, at home, running
+			// five watts. Wiping the grid there threw away the one field the
+			// operator was looking the call up for, and it came back empty while
+			// the same lookup without the suffix answered perfectly.
+			if !saysNothingAboutLocation(call) {
 				r.Country, r.Continent = "", ""
 				r.CQZ, r.ITUZ, r.DXCC = 0, 0, 0
 				r.Lat, r.Lon = 0, 0
 				r.Grid, r.State, r.County = "", "", ""
+			}
 			fillFromDXCC(&r, dxcc) // entity/zones/lat-lon from the FULL (slashed) call
 			normalizeNames(&r)
 			_ = m.cache.Put(ctx, r)
@@ -232,6 +240,33 @@ var LogSink = func(string, ...any) {}
 // right and must be looked up exactly as entered.
 var opSuffixes = map[string]bool{"M": true, "MM": true, "AM": true, "P": true, "QRP": true}
 
+// nonLocationSuffixes say nothing about WHERE the operator is.
+//
+// /QRP is a statement about power. /M and /P and their kin are not: mobile and
+// portable both mean "somewhere other than the home station", which is exactly
+// why the home record's location is discarded for them. Keeping that distinction
+// is the difference between a grid that is stale and a grid that is absent.
+var nonLocationSuffixes = map[string]bool{"QRP": true}
+
+// saysNothingAboutLocation reports a call whose every suffix leaves the operator
+// at their registered address — so the home record's location can be trusted.
+func saysNothingAboutLocation(call string) bool {
+	parts := strings.Split(strings.ToUpper(strings.TrimSpace(call)), "/")
+	if len(parts) < 2 {
+		return false
+	}
+	base := strings.TrimSpace(parts[0])
+	if len(base) < 3 || !strings.ContainsAny(base, "0123456789") {
+		return false // "JW/OR1A": the first part is a prefix — a location change
+	}
+	for _, p := range parts[1:] {
+		if !nonLocationSuffixes[strings.TrimSpace(p)] {
+			return false
+		}
+	}
+	return true
+}
+
 // stripOpSuffix returns the bare callsign when call carries nothing but
 // operational suffixes ("F4LYI/M" → "F4LYI", true). Reports false for anything
 // that changes entity or area ("JW/OR1A", "F4BPO/8"), and for a call whose base

internal/lookup/suffix_location_test.go

@@ -0,0 +1,27 @@
+package lookup
+
+import "testing"
+
+// A grid came back empty for M0BFS/QRP while the same lookup without the suffix
+// answered perfectly. The home-call pass wiped the location on the grounds that
+// a portable operator is not at their registered address — true for /P and /M,
+// and simply wrong for /QRP, which is a statement about power.
+func TestSaysNothingAboutLocation(t *testing.T) {
+	keep := []string{"M0BFS/QRP", "f4bpo/qrp", "G0ABC/QRP"}
+	for _, c := range keep {
+		if !saysNothingAboutLocation(c) {
+			t.Errorf("%s: the home location should be kept — /QRP does not move anyone", c)
+		}
+	}
+	// These DO move the operator, or change the entity outright.
+	drop := []string{"F4BPO/P", "F4BPO/M", "F4BPO/MM", "F4BPO/AM", "JW/OR1A", "VP8/F4BPO", "F4BPO/8", "F4BPO"}
+	for _, c := range drop {
+		if saysNothingAboutLocation(c) {
+			t.Errorf("%s: the home location must NOT be trusted", c)
+		}
+	}
+	// A power suffix on top of a portable one still moves them.
+	if saysNothingAboutLocation("F4BPO/P/QRP") {
+		t.Error("F4BPO/P/QRP is portable — location must not be kept")
+	}
+}

internal/powergenius/powergenius.go

@@ -240,12 +240,10 @@ func (c *Client) authLocked() error {
 		if _, err := fmt.Fprintf(c.conn, "C%d|auth code=%s\n", id, c.password); err != nil {
 			return err
 		}
-		_ = c.conn.SetReadDeadline(time.Now().Add(ioTimeout))
-		line, err := c.reader.ReadString('\n')
+		line, err := c.readReplyLocked(fmt.Sprintf("R%d|", id))
 		if err != nil {
 			return err
 		}
-		line = strings.TrimSpace(line)
 		applog.Printf("pgxl: auth reply=%q (try %d)", line, try)
 		hex, msg := "", ""
 		if p := strings.SplitN(line, "|", 3); len(p) >= 2 {
@@ -264,6 +262,39 @@ func (c *Client) authLocked() error {
 	return fmt.Errorf("powergenius: authentication failed after 4 tries (R|%s|) — check the remote code", lastHex)
 }
 
+// readReplyLocked reads until the reply carrying `want` as its prefix arrives,
+// feeding every unsolicited frame it passes to parse() on the way.
+//
+// The amplifier PUSHES status frames ("S0|state=…") on the same socket, and it
+// pushes them constantly once it is in OPERATE — power, SWR and temperature all
+// move while transmitting. The old code read exactly one line per command and
+// took whatever came first as its answer, so a single pushed frame put the
+// stream permanently one reply behind: every later command read the PREVIOUS
+// command's answer, and the last one waited out the 3 s deadline, failed, and
+// dropped the connection. That is the reconnect-every-few-seconds seen in the
+// field, and the stall in transmit — command() holds the mutex across that whole
+// dead wait, so anything else touching the amplifier queued behind it.
+//
+// It only showed up remotely and in OPERATE: on a LAN with an idle amplifier
+// there is almost nothing to push and the race hardly ever opens.
+func (c *Client) readReplyLocked(want string) (string, error) {
+	deadline := time.Now().Add(ioTimeout)
+	for {
+		_ = c.conn.SetReadDeadline(deadline)
+		line, err := c.reader.ReadString('\n')
+		if err != nil {
+			return "", err
+		}
+		line = strings.TrimSpace(line)
+		// Every frame is worth having, ours or not — a pushed status is fresher
+		// than the one we were about to ask for.
+		c.parse(line)
+		if strings.HasPrefix(line, want) {
+			return line, nil
+		}
+	}
+}
+
 func (c *Client) dropConn() {
 	c.mu.Lock()
 	if c.conn != nil {
@@ -286,14 +317,7 @@ func (c *Client) command(cmd string) (string, error) {
 	if _, err := fmt.Fprintf(c.conn, "C%d|%s\n", id, cmd); err != nil {
 		return "", err
 	}
-	_ = c.conn.SetReadDeadline(time.Now().Add(ioTimeout))
-	line, err := c.reader.ReadString('\n')
-	if err != nil {
-		return "", err
-	}
-	line = strings.TrimSpace(line)
-	c.parse(line)
-	return line, nil
+	return c.readReplyLocked(fmt.Sprintf("R%d|", id))
 }
 
 // parse handles "R<id>|0|<k=v …>" and "S0|<k=v …>" status lines.

internal/profile/profile.go

@@ -52,6 +52,7 @@ type Profile struct {
 	MyCity        string    `json:"my_city"`
 	MyPostalCode  string    `json:"my_postal_code"`
 	MySOTARef     string    `json:"my_sota_ref"`
+	MyIOTA        string    `json:"my_iota"`
 	MyPOTARef     string    `json:"my_pota_ref"`
 	MyRig         string    `json:"my_rig"`
 	MyAntenna     string    `json:"my_antenna"`
@@ -75,7 +76,7 @@ type Repo struct{ db *sql.DB }
 func NewRepo(db *sql.DB) *Repo { return &Repo{db: db} }
 
 const selectCols = `id, name, callsign, operator, op_name, owner_callsign, my_grid, my_country, my_state, my_cnty,
-    my_street, my_city, my_postal_code, my_sota_ref, my_pota_ref,
+    my_street, my_city, my_postal_code, my_sota_ref, my_pota_ref, my_iota,
     my_rig, my_antenna, my_dxcc, my_cqz, my_ituz, my_lat, my_lon, tx_pwr,
     is_active, sort_order, db_config, created_at, updated_at`
 
@@ -124,12 +125,12 @@ func (r *Repo) Save(ctx context.Context, p *Profile) error {
 		res, err := r.db.ExecContext(ctx, `
 			INSERT INTO station_profiles
 			    (name, callsign, operator, op_name, owner_callsign, my_grid, my_country, my_state, my_cnty,
-			     my_street, my_city, my_postal_code, my_sota_ref, my_pota_ref,
+			     my_street, my_city, my_postal_code, my_sota_ref, my_pota_ref, my_iota,
 			     my_rig, my_antenna, my_dxcc, my_cqz, my_ituz, my_lat, my_lon, tx_pwr,
 			     is_active, sort_order, created_at, updated_at)
-			VALUES(?,?,?,?,?,?,?,?,?, ?,?,?,?,?, ?,?,?,?,?,?,?,?, ?,?,?,?)`,
+			VALUES(?,?,?,?,?,?,?,?,?, ?,?,?,?,?,?, ?,?,?,?,?,?,?,?, ?,?,?,?)`,
 			p.Name, p.Callsign, p.Operator, p.OpName, p.OwnerCallsign, p.MyGrid, p.MyCountry, p.MyState, p.MyCounty,
-			p.MyStreet, p.MyCity, p.MyPostalCode, p.MySOTARef, p.MyPOTARef,
+			p.MyStreet, p.MyCity, p.MyPostalCode, p.MySOTARef, p.MyPOTARef, p.MyIOTA,
 			p.MyRig, p.MyAntenna, nullableInt(p.MyDXCC), nullableInt(p.MyCQZone), nullableInt(p.MyITUZone),
 			nullableFloat(p.MyLat), nullableFloat(p.MyLon), nullableFloat(p.TxPower),
 			boolInt(p.IsActive), p.SortOrder, now, now)
@@ -144,13 +145,13 @@ func (r *Repo) Save(ctx context.Context, p *Profile) error {
 		UPDATE station_profiles SET
 		    name = ?, callsign = ?, operator = ?, op_name = ?, owner_callsign = ?, my_grid = ?, my_country = ?,
 		    my_state = ?, my_cnty = ?, my_street = ?, my_city = ?, my_postal_code = ?,
-		    my_sota_ref = ?, my_pota_ref = ?, my_rig = ?, my_antenna = ?,
+		    my_sota_ref = ?, my_pota_ref = ?, my_iota = ?, my_rig = ?, my_antenna = ?,
 		    my_dxcc = ?, my_cqz = ?, my_ituz = ?, my_lat = ?, my_lon = ?, tx_pwr = ?,
 		    sort_order = ?, updated_at = ?
 		WHERE id = ?`,
 		p.Name, p.Callsign, p.Operator, p.OpName, p.OwnerCallsign, p.MyGrid, p.MyCountry,
 		p.MyState, p.MyCounty, p.MyStreet, p.MyCity, p.MyPostalCode,
-		p.MySOTARef, p.MyPOTARef, p.MyRig, p.MyAntenna,
+		p.MySOTARef, p.MyPOTARef, p.MyIOTA, p.MyRig, p.MyAntenna,
 		nullableInt(p.MyDXCC), nullableInt(p.MyCQZone), nullableInt(p.MyITUZone),
 		nullableFloat(p.MyLat), nullableFloat(p.MyLon), nullableFloat(p.TxPower),
 		p.SortOrder, now, p.ID)
@@ -264,7 +265,7 @@ func scan(row scannable) (Profile, error) {
 	var p Profile
 	var (
 		callsign, operator, opName, ownerCall, myGrid, myCountry, myState, myCnty,
-		myStreet, myCity, myPostal, mySOTA, myPOTA,
+		myStreet, myCity, myPostal, mySOTA, myPOTA, myIOTA,
 		myRig, myAntenna sql.NullString
 		myDXCC, myCQZ, myITUZ sql.NullInt64
 		myLat, myLon, txPwr   sql.NullFloat64
@@ -273,7 +274,7 @@ func scan(row scannable) (Profile, error) {
 		createdAt, updatedAt  string
 	)
 	err := row.Scan(&p.ID, &p.Name, &callsign, &operator, &opName, &ownerCall, &myGrid, &myCountry, &myState, &myCnty,
-		&myStreet, &myCity, &myPostal, &mySOTA, &myPOTA,
+		&myStreet, &myCity, &myPostal, &mySOTA, &myPOTA, &myIOTA,
 		&myRig, &myAntenna, &myDXCC, &myCQZ, &myITUZ, &myLat, &myLon, &txPwr,
 		&isActive, &sortOrder, &dbConfig, &createdAt, &updatedAt)
 	if err != nil {
@@ -294,6 +295,7 @@ func scan(row scannable) (Profile, error) {
 	p.MyCity = myCity.String
 	p.MyPostalCode = myPostal.String
 	p.MySOTARef = mySOTA.String
+	p.MyIOTA = myIOTA.String
 	p.MyPOTARef = myPOTA.String
 	p.MyRig = myRig.String
 	p.MyAntenna = myAntenna.String

internal/pskr/pskr.go

@@ -0,0 +1,264 @@
+// Package pskr subscribes to PSK Reporter's MQTT feed and turns it into the
+// spots the band-opening detector already eats.
+//
+// Why this exists at all: the detector was fed from the DX cluster and the RBN,
+// and on VHF that is a few hundred skimmers, nearly all of them on HF. A 6 m
+// opening carrying 869 stations reached OpsLog as a handful of spots, or none.
+// PSK Reporter is every ordinary station running WSJT-X and reporting what it
+// decodes — the difference is two orders of magnitude, not a threshold.
+//
+// The feed's shape happens to suit us exactly:
+//
+//	topic   pskr/filter/v2/<band>/<mode>/<tx call>/<rx call>/...
+//	payload {"f":50313000,"md":"FT8","rp":-12,"sc":"F4BPO","sl":"JN36",
+//	         "rc":"OH5CX","rl":"KP30","b":"6m"}
+//
+// BOTH grids are in the message, so distance and bearing are arithmetic. No
+// lookup, no DXCC-centre approximation, no extra network call — which is what
+// made the cluster path's bearings coarse.
+//
+// Volume is the real design constraint. Six metres open is thousands of
+// messages a minute, and OpsLog runs on some very old PCs. So: no history is
+// kept here, nothing is persisted, each message is parsed and handed on or
+// dropped, and the callback does the deciding.
+package pskr
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+	"sync"
+	"time"
+
+	mqtt "github.com/eclipse/paho.mqtt.golang"
+)
+
+// DefaultBroker is PSK Reporter's public MQTT endpoint, TLS.
+const DefaultBroker = "tls://mqtt.pskreporter.info:1884"
+
+// DefaultNearKm is the radius that counts as "around here" for a receiver.
+const DefaultNearKm = 300
+
+// Bands offered. Anything below 10 m is deliberately absent, 12 m included: an
+// "opening" on 20 m is the normal state of the band and announcing it says
+// nothing, and 12 m is close enough to that at this point in the cycle to be the
+// same problem. These are the bands where an opening is an event.
+//
+// Fewer subscriptions is also less traffic, which matters here: the operator's
+// PC pays for every message the broker sends, whether or not anything comes of it.
+var Bands = []string{"10m", "6m", "4m", "2m"}
+
+// Spot is one decode, already reduced to what a detector needs.
+type Spot struct {
+	Call    string // the transmitting station
+	Band    string
+	Mode    string
+	Grid    string // transmitter's grid, 4 characters
+	DistKm  int    // from the operator
+	Bearing int    // degrees from the operator, short path
+	At      time.Time
+}
+
+// Config is what the watcher needs to run.
+type Config struct {
+	Broker string
+	Bands  []string
+	// OpLat/OpLon are the operator's position: every spot is measured from it,
+	// so with no position there is nothing to measure and the watcher stays down.
+	OpLat, OpLon float64
+	// NearKm is how close a RECEIVER must be to count as "around here". A report
+	// collected further away proves a path that is not the operator's.
+	//
+	// 300 km by default: far enough to borrow the ears of a whole region, which
+	// is the point — an opening reaches an area, not a postcode, and waiting for
+	// a decode at one's own station is just working the band. Close enough that
+	// the ionosphere doing something there is the ionosphere doing it here.
+	NearKm int
+	// Geo turns two grids into distance and bearing. Injected rather than
+	// implemented here so it stays the SAME arithmetic the cluster path uses —
+	// two answers for one question is how a bearing quietly becomes wrong.
+	Geo func(grid string) (distKm int, bearing int, ok bool)
+	// OnSpot receives every accepted decode. Called from the MQTT goroutine, so
+	// it must not block: the broker's buffer is what pays for it if it does.
+	OnSpot func(Spot)
+	Logf   func(string, ...any)
+}
+
+// Watcher owns the MQTT connection and its subscriptions.
+type Watcher struct {
+	mu      sync.Mutex
+	cfg     Config
+	client  mqtt.Client
+	running bool
+
+	// received counts accepted spots since start, for the status panel: a
+	// connection that is up but silent looks identical to one that is working
+	// until you can see a number moving.
+	received uint64
+	lastAt   time.Time
+	lastErr  string
+}
+
+func New(cfg Config) *Watcher {
+	if cfg.Broker == "" {
+		cfg.Broker = DefaultBroker
+	}
+	if len(cfg.Bands) == 0 {
+		cfg.Bands = Bands
+	}
+	if cfg.NearKm <= 0 {
+		cfg.NearKm = DefaultNearKm
+	}
+	if cfg.Logf == nil {
+		cfg.Logf = func(string, ...any) {}
+	}
+	return &Watcher{cfg: cfg}
+}
+
+// Start connects and subscribes. Safe to call when already running.
+func (w *Watcher) Start() error {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	if w.running {
+		return nil
+	}
+	if w.cfg.Geo == nil || w.cfg.OnSpot == nil {
+		return fmt.Errorf("pskr: Geo and OnSpot are required")
+	}
+
+	opts := mqtt.NewClientOptions().
+		AddBroker(w.cfg.Broker).
+		// A stable client id would collide with another OpsLog on the same
+		// account; the broker is anonymous, so uniqueness is ours to provide.
+		SetClientID(fmt.Sprintf("opslog-%d", time.Now().UnixNano())).
+		SetCleanSession(true).
+		SetAutoReconnect(true).
+		SetConnectRetry(true).
+		SetConnectRetryInterval(30 * time.Second).
+		SetConnectTimeout(15 * time.Second).
+		// No message is worth keeping if we cannot handle it now: an opening is
+		// a thing happening at this moment, and a queue of stale decodes would
+		// announce one that finished twenty minutes ago.
+		SetOrderMatters(false)
+
+	opts.OnConnect = func(c mqtt.Client) {
+		w.cfg.Logf("pskr: connected to %s", w.cfg.Broker)
+		for _, b := range w.cfg.Bands {
+			// Every mode, every pair of stations, on this band. That firehose IS
+			// the point: the detector's job is to find the shape in it.
+			topic := "pskr/filter/v2/" + b + "/#"
+			if tok := c.Subscribe(topic, 0, w.handle); tok.Wait() && tok.Error() != nil {
+				w.cfg.Logf("pskr: subscribe %s failed: %v", topic, tok.Error())
+				continue
+			}
+			w.cfg.Logf("pskr: watching %s", topic)
+		}
+	}
+	opts.OnConnectionLost = func(_ mqtt.Client, err error) {
+		w.mu.Lock()
+		w.lastErr = err.Error()
+		w.mu.Unlock()
+		w.cfg.Logf("pskr: connection lost: %v (will retry)", err)
+	}
+
+	c := mqtt.NewClient(opts)
+	// Deliberately NOT waiting on the connect token: the broker may be slow or
+	// unreachable and startup must not hang on a feature that is decoration.
+	// ConnectRetry brings it up in the background when it can.
+	c.Connect()
+	w.client = c
+	w.running = true
+	return nil
+}
+
+// Stop disconnects. Safe to call when already stopped.
+func (w *Watcher) Stop() {
+	w.mu.Lock()
+	c, running := w.client, w.running
+	w.client, w.running = nil, false
+	w.mu.Unlock()
+	if running && c != nil {
+		c.Disconnect(250)
+	}
+}
+
+// wire is the payload as PSK Reporter sends it — short keys, no nesting.
+type wire struct {
+	Freq   int64  `json:"f"`
+	Mode   string `json:"md"`
+	SNR    int    `json:"rp"`
+	TxCall string `json:"sc"`
+	TxGrid string `json:"sl"`
+	RxCall string `json:"rc"`
+	RxGrid string `json:"rl"`
+	Band   string `json:"b"`
+}
+
+func (w *Watcher) handle(_ mqtt.Client, m mqtt.Message) {
+	var p wire
+	if err := json.Unmarshal(m.Payload(), &p); err != nil {
+		return // malformed payloads are not worth a log line at this rate
+	}
+	call := strings.ToUpper(strings.TrimSpace(p.TxCall))
+	grid := strings.ToUpper(strings.TrimSpace(p.TxGrid))
+	rxGrid := strings.ToUpper(strings.TrimSpace(p.RxGrid))
+	if call == "" || len(grid) < 4 || len(rxGrid) < 4 {
+		return
+	}
+
+	// THE RECEIVER HAS TO BE NEAR THE OPERATOR. This is the whole difference
+	// between a useful feed and a world map.
+	//
+	// A PSK Reporter message says "X was heard BY Y". Without this check, a
+	// station 1400 km from here heard by somebody in Japan counted as evidence
+	// of an opening — it proves the path from X to JAPAN, and says nothing at all
+	// about whether anything reaches this station. That is how a "2 m opening"
+	// came to be announced from a KX9X in the United States.
+	//
+	// Only reports collected by a receiver in the operator's own region show that
+	// signals are actually arriving HERE, which is the only question worth asking.
+	if rxDist, _, ok := w.cfg.Geo(rxGrid[:4]); !ok || rxDist > w.cfg.NearKm {
+		return
+	}
+
+	// The TRANSMITTER is the station on the air, so it is the transmitter's grid
+	// that gives the direction and length of the path that just proved itself.
+	dist, brg, ok := w.cfg.Geo(grid[:4])
+	if !ok {
+		return
+	}
+	s := Spot{
+		Call: call, Band: strings.ToLower(strings.TrimSpace(p.Band)),
+		Mode: strings.ToUpper(strings.TrimSpace(p.Mode)), Grid: grid[:4],
+		DistKm: dist, Bearing: brg,
+		// Stamped on receipt: the broker's own timestamps vary between payload
+		// versions, and the window this feeds is measured in minutes.
+		At: time.Now(),
+	}
+	w.mu.Lock()
+	w.received++
+	w.lastAt = s.At
+	w.mu.Unlock()
+	w.cfg.OnSpot(s)
+}
+
+// Status is the snapshot the settings panel shows.
+type Status struct {
+	Running  bool      `json:"running"`
+	Received uint64    `json:"received"`
+	LastAt   time.Time `json:"last_at"`
+	LastErr  string    `json:"last_err,omitempty"`
+	Broker   string    `json:"broker"`
+	Bands    []string  `json:"bands"`
+}
+
+func (w *Watcher) Status() Status {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	st := Status{
+		Running: w.running, Received: w.received, LastAt: w.lastAt,
+		LastErr: w.lastErr, Broker: w.cfg.Broker,
+	}
+	st.Bands = append(st.Bands, w.cfg.Bands...)
+	return st
+}

internal/qso/bulkmode_test.go

@@ -0,0 +1,26 @@
+package qso
+
+import "testing"
+
+// Mode, submode and RST are repair fields: an import that mapped every contact
+// to SSB, or an ADIF that carried no MODE, is fixed in one pass instead of one
+// row at a time. They were excluded as "per-QSO", which confused describing a
+// QSO with repairing a batch of them.
+func TestModeAndRSTAreBulkEditable(t *testing.T) {
+	for _, col := range []string{"mode", "submode", "rst_sent", "rst_rcvd"} {
+		if !bulkEditableCols[col] {
+			t.Errorf("%s should be bulk-editable", col)
+		}
+	}
+}
+
+// Band must NOT be bulk-editable on its own: it travels with the frequency
+// through BulkSetFrequency. A band contradicting its own frequency is invalid
+// ADIF, and every export would carry the contradiction out into the world.
+func TestBandIsNotBulkEditableAlone(t *testing.T) {
+	for _, col := range []string{"band", "freq_hz", "callsign", "qso_date"} {
+		if bulkEditableCols[col] {
+			t.Errorf("%s must not be bulk-editable on its own", col)
+		}
+	}
+}

internal/qso/filter_empty_test.go

@@ -0,0 +1,41 @@
+package qso
+
+import (
+	"strings"
+	"testing"
+)
+
+// "equals nothing" and "is empty" are the same question. SQL answers the first
+// with nothing at all — a NULL never equals ” — so a filter written in plain
+// words returned zero rows and looked broken rather than wrong.
+func TestEqualsBlankMeansEmpty(t *testing.T) {
+	sql, args, err := conditionSQL(Condition{Field: "freq_hz", Op: "eq", Value: ""})
+	if err != nil {
+		t.Fatalf("eq blank: %v", err)
+	}
+	if len(args) != 0 || !strings.Contains(sql, "IS NULL") {
+		t.Errorf("sql = %q args = %v — want the empty test", sql, args)
+	}
+	sql, _, _ = conditionSQL(Condition{Field: "name", Op: "ne", Value: "  "})
+	if !strings.Contains(sql, "<> ''") {
+		t.Errorf("ne blank on text gave %q — want the not-empty test", sql)
+	}
+}
+
+// A numeric column is empty when NULL *or* zero, and that must be explicit:
+// SQLite compares 0 against ” as false while MySQL calls it true, so one
+// expression would answer two different questions depending on the backend.
+func TestEmptyOnNumericCoversZeroAndNull(t *testing.T) {
+	sql, _, err := conditionSQL(Condition{Field: "freq_hz", Op: "empty"})
+	if err != nil {
+		t.Fatalf("empty: %v", err)
+	}
+	if !strings.Contains(sql, "IS NULL") || !strings.Contains(sql, "= 0") {
+		t.Errorf("sql = %q — want both NULL and zero", sql)
+	}
+	// Text keeps the string test: '' is a real value there, 0 is not.
+	sql, _, _ = conditionSQL(Condition{Field: "name", Op: "empty"})
+	if !strings.Contains(sql, "IFNULL") || strings.Contains(sql, "= 0") {
+		t.Errorf("text empty gave %q", sql)
+	}
+}

internal/qso/filter_in_test.go

@@ -0,0 +1,57 @@
+package qso
+
+import (
+	"strings"
+	"testing"
+)
+
+// "2 m or 70 cm, in FT8, since January" could not be asked before: the filter
+// joins every condition with ONE AND or OR, so AND killed the two bands and OR
+// let every FT8 QSO through. The OR now lives inside a single condition.
+func TestInConditionExpressesSeveralValuesForOneField(t *testing.T) {
+	sql, args, err := conditionSQL(Condition{Field: "band", Op: "in", Value: "2m, 70cm"})
+	if err != nil {
+		t.Fatalf("in: %v", err)
+	}
+	if !strings.Contains(sql, "IN (?,?)") {
+		t.Errorf("sql = %q, want an IN with two placeholders", sql)
+	}
+	if len(args) != 2 || args[0] != "2m" || args[1] != "70cm" {
+		t.Errorf("args = %v, want [2m 70cm] trimmed", args)
+	}
+}
+
+// A trailing comma while typing must not add an empty value that matches nothing.
+func TestInIgnoresBlanks(t *testing.T) {
+	_, args, err := conditionSQL(Condition{Field: "mode", Op: "in", Value: "FT8, ,FT4,"})
+	if err != nil {
+		t.Fatalf("in: %v", err)
+	}
+	if len(args) != 2 {
+		t.Errorf("args = %v, want the two real values only", args)
+	}
+}
+
+// An empty list matches nothing. Dropping the condition instead would WIDEN the
+// result set — the opposite of what someone typing a filter expects.
+func TestEmptyInMatchesNothing(t *testing.T) {
+	sql, _, err := conditionSQL(Condition{Field: "band", Op: "in", Value: "  , "})
+	if err != nil {
+		t.Fatalf("in: %v", err)
+	}
+	if sql != "1=0" {
+		t.Errorf("sql = %q, want 1=0", sql)
+	}
+}
+
+// NOT IN must keep rows whose column is NULL: the row is not one of the listed
+// values, so it belongs in the answer. Raw SQL NOT IN drops them.
+func TestNotInKeepsNulls(t *testing.T) {
+	sql, _, err := conditionSQL(Condition{Field: "band", Op: "notin", Value: "2m"})
+	if err != nil {
+		t.Fatalf("notin: %v", err)
+	}
+	if !strings.HasPrefix(sql, "IFNULL(") {
+		t.Errorf("sql = %q, want the column wrapped in IFNULL", sql)
+	}
+}

internal/qso/qso.go

@@ -734,13 +734,26 @@ func (r *Repo) MarkEQSLSent(ctx context.Context, id int64, date string) error {
 	return nil
 }
 
-// bulkEditableCols whitelists the columns BulkSetField may write. Limited to
-// TEXT fields where setting one value across many QSOs is meaningful: the
-// per-service QSL/upload status fields, plus "my station"/operator fields that
-// are naturally constant across a run (grid, antenna, rig, address, …). It
-// deliberately excludes per-QSO fields (callsign, band, mode, date, RST, the
-// contacted station's details) and numeric columns (power, zones, lat/lon),
-// which would be corrupted or meaningless if bulk-set to a single value.
+// bulkEditableCols whitelists the columns BulkSetField may write.
+//
+// Mostly TEXT fields where one value across many QSOs is meaningful: the
+// per-service QSL/upload status fields, plus "my station"/operator fields
+// naturally constant across a run (grid, antenna, rig, address, …).
+//
+// Mode, submode and RST are here too, which the original rule excluded as
+// "per-QSO". That rule confused two different things. Bulk edit is not for
+// describing QSOs, it is for REPAIRING a batch — an import that mapped every
+// contact to SSB, an ADIF with no MODE at all — and refusing to fix a hundred
+// rows because a hundred rows should not normally share a value leaves the
+// operator editing them one at a time.
+//
+// Band is NOT here, and frequency is not either: both go through
+// BulkSetFrequency, which writes the pair together. A band that contradicts its
+// own frequency is invalid ADIF, and every export would carry the contradiction.
+//
+// Still excluded, and this part of the rule stands: callsign and date, which
+// identify the contact rather than describe it, and the numeric columns (power,
+// zones, lat/lon) that are meaningless shared.
 var bulkEditableCols = map[string]bool{
 	// QSL / upload status
 	"lotw_sent":                  true,
@@ -820,6 +833,14 @@ var bulkEditableCols = map[string]bool{
 	"iota":     true,
 	"sig":      true,
 	"sig_info": true,
+	// The contact itself. Repair fields: an import that mapped everything to SSB,
+	// or an ADIF that carried no MODE. Setting mode CLEARS submode (see
+	// BulkSetField) — a submode left over from the old mode contradicts the new
+	// one, and "FT8 / USB" is not a thing.
+	"mode":     true,
+	"submode":  true,
+	"rst_sent": true,
+	"rst_rcvd": true,
 	// Misc text
 	"comment": true,
 	"notes":   true,
@@ -843,8 +864,16 @@ func (r *Repo) BulkSetField(ctx context.Context, ids []int64, column, value stri
 		ph[i] = "?"
 		args = append(args, id)
 	}
+	set := column + " = ?, updated_at = ?"
+	if column == "mode" {
+		// A submode belongs to the mode it was recorded under. Left behind, it
+		// contradicts the new one — "FT8" with a submode of "USB" is not a thing,
+		// and it is the submode that most ADIF readers believe. Clearing it is the
+		// only outcome that leaves the row meaning what the operator asked for.
+		set += ", submode = ''"
+	}
 	res, err := r.db.ExecContext(ctx,
-		`UPDATE qso SET `+column+` = ?, updated_at = ? WHERE id IN (`+strings.Join(ph, ",")+`)`,
+		`UPDATE qso SET `+set+` WHERE id IN (`+strings.Join(ph, ",")+`)`,
 		args...)
 	if err != nil {
 		return 0, fmt.Errorf("bulk set %s: %w", column, err)
@@ -867,6 +896,23 @@ var bulkEditableExtras = map[string]string{
 // BulkExtraKey maps a frontend field id to its ADIF key in extras_json, or "".
 func BulkExtraKey(field string) string { return bulkEditableExtras[field] }
 
+// BulkEditable reports whether a COLUMN may be bulk-written. Exported so the
+// app layer can check its own field mapping against this whitelist: the two
+// lists are separate, valid on their own, and a field present in one and absent
+// from the other fails only when an operator tries to use it.
+func BulkEditable(column string) bool { return bulkEditableCols[column] }
+
+// BulkEditableColumns lists every bulk-writable column, for the same check from
+// the other side: a column nothing maps to looks supported and cannot be used.
+func BulkEditableColumns() []string {
+	out := make([]string, 0, len(bulkEditableCols))
+	for c := range bulkEditableCols {
+		out = append(out, c)
+	}
+	sort.Strings(out)
+	return out
+}
+
 // BulkSetExtra sets one whitelisted extras_json field on every listed QSO,
 // leaving the other extras untouched. An empty value REMOVES the key rather than
 // storing a blank — an empty extra would otherwise be carried into every export.
@@ -1220,6 +1266,17 @@ var filterableColumns = map[string]bool{
 // value compares on the date part (see conditionSQL) so day filters are exact.
 var dateColumns = map[string]bool{"qso_date": true, "qso_date_off": true}
 
+// numericColumns are the filterable columns holding numbers rather than text.
+//
+// "Empty" means something different for them: NULL *or* zero. It has to be said
+// explicitly because the two backends disagree — SQLite compares 0 against ”
+// as false, MySQL calls it true — so one expression would quietly answer two
+// different questions depending on where the logbook lives.
+var numericColumns = map[string]bool{
+	"freq_hz": true, "freq_rx_hz": true, "dxcc": true, "cqz": true, "ituz": true,
+	"srx": true, "stx": true, "tx_pwr": true,
+}
+
 // bareDateRe matches a plain calendar date with no time component.
 var bareDateRe = regexp.MustCompile(`^\d{4}-\d{2}-\d{2}$`)
 
@@ -1289,6 +1346,23 @@ func columnExpr(field string) (string, bool) {
 }
 
 // conditionSQL turns one condition into a parameterised predicate.
+// splitList parses the comma-separated value of an "in" / "not in" condition.
+//
+// Blanks are dropped, so a trailing comma or a stray space while typing does not
+// silently add an empty value that matches nothing. Case is left alone: the
+// columns this is used on (band, mode, country) are stored in the case the log
+// was written in, and forcing it here would break the ones that are not.
+func splitList(v string) []string {
+	parts := strings.Split(v, ",")
+	out := make([]string, 0, len(parts))
+	for _, p := range parts {
+		if p = strings.TrimSpace(p); p != "" {
+			out = append(out, p)
+		}
+	}
+	return out
+}
+
 func conditionSQL(c Condition) (string, []any, error) {
 	col, ok := columnExpr(c.Field)
 	if !ok {
@@ -1303,6 +1377,18 @@ func conditionSQL(c Condition) (string, []any, error) {
 		col = "substr(" + col + ",1,10)"
 		v = strings.TrimSpace(v)
 	}
+	// "equals nothing" and "is empty" are the same question, and SQL answers the
+	// first with nothing at all: a NULL never equals '', so a filter written that
+	// way returns zero rows and looks broken rather than wrong. Asking it in
+	// plain words is not a mistake worth punishing.
+	if strings.TrimSpace(v) == "" {
+		switch c.Op {
+		case "eq":
+			c.Op = "empty"
+		case "ne":
+			c.Op = "notempty"
+		}
+	}
 	switch c.Op {
 	case "eq":
 		return col + " = ?", []any{v}, nil
@@ -1322,9 +1408,49 @@ func conditionSQL(c Condition) (string, []any, error) {
 		return col + " LIKE ?", []any{v + "%"}, nil
 	case "endswith":
 		return col + " LIKE ?", []any{"%" + v}, nil
+	case "in", "notin":
+		// Several values for ONE field, comma-separated.
+		//
+		// This is what makes a real question expressible. The filter joins every
+		// condition with a single AND or OR, so "2 m or 70 cm, in FT8, since
+		// January" could not be asked: AND killed the two bands, OR let every FT8
+		// QSO through. Rather than grow the model nested groups — a tree in the UI
+		// to answer a question that is nearly always "this field, any of these
+		// values" — the OR lives INSIDE one condition and everything else keeps
+		// ANDing.
+		vals := splitList(v)
+		if len(vals) == 0 {
+			// An empty list matches nothing, which is the honest reading. Silently
+			// dropping the condition would widen the result set instead.
+			if c.Op == "in" {
+				return "1=0", nil, nil
+			}
+			return "1=1", nil, nil
+		}
+		ph := strings.TrimSuffix(strings.Repeat("?,", len(vals)), ",")
+		args := make([]any, 0, len(vals))
+		for _, s := range vals {
+			args = append(args, s)
+		}
+		if c.Op == "notin" {
+			// IFNULL, or a NULL column would fail "NOT IN" and vanish from the
+			// result — the row is not one of the listed values, so it belongs.
+			return "IFNULL(" + col + ",'') NOT IN (" + ph + ")", args, nil
+		}
+		return col + " IN (" + ph + ")", args, nil
 	case "empty":
+		// A numeric column is empty when it is NULL *or* zero, and that has to be
+		// said explicitly: SQLite compares 0 against '' as false while MySQL calls
+		// it true, so IFNULL(col,'')='' quietly means different things on the two
+		// backends OpsLog supports.
+		if numericColumns[strings.ToLower(strings.TrimSpace(c.Field))] {
+			return "(" + col + " IS NULL OR " + col + " = 0)", nil, nil
+		}
 		return "IFNULL(" + col + ",'') = ''", nil, nil
 	case "notempty":
+		if numericColumns[strings.ToLower(strings.TrimSpace(c.Field))] {
+			return "(" + col + " IS NOT NULL AND " + col + " <> 0)", nil, nil
+		}
 		return "IFNULL(" + col + ",'') <> ''", nil, nil
 	default:
 		return "", nil, fmt.Errorf("unknown operator %q", c.Op)
@@ -3002,3 +3128,45 @@ func IsFilterable(column string) bool { return filterableColumns[column] }
 // column of their own and live in extras_json.
 func IsBulkEditableExtra(field string) bool { _, ok := bulkEditableExtras[field]; return ok }
 func IsFilterableExtra(field string) bool   { _, ok := filterableExtras[field]; return ok }
+
+// WorkedGridKeys returns the set of "GRID|MODE" keys already in the log, where
+// GRID is the 4-character field+square and MODE has been through normMode.
+//
+// The mode is part of the key, and normMode is what makes the DX-cluster
+// "group digital modes" option apply to grids for free: with grouping on, FT8
+// and FT4 both normalise to the same token, so a grid worked on FT8 is not new
+// on FT4; with it off they stay separate keys and it is.
+//
+// Truncated to four characters on the way in. A log holds a mix of JN36 and
+// JN36QU depending on where each QSO came from, and grid chasing is a
+// field+square game — without the truncation the same square counts as new
+// forever, once per subsquare.
+func (r *Repo) WorkedGridKeys(ctx context.Context, normMode func(string) string) (map[string]struct{}, error) {
+	rows, err := r.db.QueryContext(ctx,
+		// The column is "grid", not "gridsquare" — that is the ADIF field name, and
+		// gridsquare_ext is a different (six-plus character) column entirely.
+		`SELECT DISTINCT COALESCE(grid,''), COALESCE(mode,'') FROM qso
+		 WHERE grid IS NOT NULL AND grid != ''`)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	out := make(map[string]struct{}, 4096)
+	for rows.Next() {
+		var grid, mode string
+		if err := rows.Scan(&grid, &mode); err != nil {
+			return nil, err
+		}
+		grid = strings.ToUpper(strings.TrimSpace(grid))
+		if len(grid) < 4 {
+			continue
+		}
+		grid = grid[:4]
+		mode = strings.ToUpper(strings.TrimSpace(mode))
+		if normMode != nil && mode != "" {
+			mode = normMode(mode)
+		}
+		out[grid+"|"+mode] = struct{}{}
+	}
+	return out, rows.Err()
+}

internal/rigctld/rigctld.go

@@ -49,6 +49,10 @@ type Rig interface {
 	SetFreq(hz int64) error
 	SetMode(mode string) error
 	SetPTT(on bool) error
+	// SetSplit arms or clears split and places the transmit frequency. Returns an
+	// error on a rig that cannot: a refusal the client can report is worth far
+	// more than a success it has no way to check.
+	SetSplit(on bool, txHz int64) error
 }
 
 type Server struct {
@@ -61,12 +65,24 @@ type Server struct {
 	conns  map[net.Conn]struct{}
 	closed bool
 
+	// accepted counts every connection this listener has taken. Only selfTest
+	// reads it, to tell "a client reached us" from "a client reached someone
+	// else on our port".
+	accepted atomic.Int64
+
 	// ptt mirrors the last PTT state a client commanded via set_ptt. WSJT-X/JTDX
 	// poll get_ptt DURING transmit to confirm the rig is keyed; if get_ptt reads
 	// RX they conclude PTT failed and abort the over after a second or two. We
 	// don't read PTT back from every backend, so echo what the client last set —
 	// always consistent with its own command, and enough to satisfy the check.
 	ptt atomic.Bool
+	// pttKnown says ptt reflects a state we actually commanded, so a repeat can
+	// be told from the very first call — where the radio's state is unknown and
+	// the command must go through.
+	pttKnown atomic.Bool
+	// splitWanted remembers a set_split_vfo that arrived before the frequency it
+	// needs, so the pair can be honoured in the order the client sends them.
+	splitWanted atomic.Bool
 }
 
 func New(port int, rig Rig, logf func(string, ...any)) *Server {
@@ -109,15 +125,58 @@ func (s *Server) Start() error {
 				}
 				return
 			}
+			s.accepted.Add(1)
 			s.mu.Lock()
 			s.conns[c] = struct{}{}
 			s.mu.Unlock()
 			go s.serve(c)
 		}
 	}()
+	go s.selfTest()
 	return nil
 }
 
+// selfTest checks that a client connecting to 127.0.0.1:<port> actually reaches
+// THIS listener, and says so in the log when it does not.
+//
+// Binding successfully is not the same as being reachable. OpsLog listens on
+// 0.0.0.0, and Windows lets a second program bind the SAME port on the specific
+// address 127.0.0.1. Connections to localhost then go to the MORE SPECIFIC
+// listener — the other program — while ours sits there having logged "sharing
+// CAT on port 4532" and never seeing a single client.
+//
+// Seen in the field with Nexus, which starts its own rigctld on 127.0.0.1:4532
+// and connects to it. Neither program reports anything wrong; the operator gets
+// a CAT timeout from a daemon with no radio behind it, and OpsLog's log is
+// silent because nothing ever arrived. Three exchanges went into finding that,
+// so it is worth one line at startup.
+//
+// The counter can only be raised by our own accept loop, so a real client
+// arriving during the probe makes this pass, never fail wrongly.
+func (s *Server) selfTest() {
+	before := s.accepted.Load()
+	addr := fmt.Sprintf("127.0.0.1:%d", s.port)
+	c, err := net.DialTimeout("tcp", addr, 2*time.Second)
+	if err != nil {
+		s.log("rigctld: WARNING — could not reach our own CAT port at %s (%v); "+
+			"clients on this PC will not find OpsLog", addr, err)
+		return
+	}
+	defer c.Close()
+	// Give the accept loop a moment: the dial returns as soon as the handshake
+	// completes, which can be marginally before Accept hands the connection over.
+	for i := 0; i < 20; i++ {
+		if s.accepted.Load() > before {
+			return // it reached us — nothing to say
+		}
+		time.Sleep(50 * time.Millisecond)
+	}
+	s.log("rigctld: WARNING — another program is already answering on %s. "+
+		"It will receive the CAT connections meant for OpsLog, which will look "+
+		"like a timeout in that program and silence here. Close it, or move "+
+		"OpsLog's shared CAT to a different port.", addr)
+}
+
 // releasePTT drops the transmitter when whoever was holding it goes away.
 //
 // Nothing else will. The Kenwood/Elecraft backend deliberately suspends its
@@ -224,6 +283,24 @@ func (s *Server) handle(line string) (resp string, quit bool) {
 		return "CHKVFO 0\n", false
 	case "\\get_powerstat", "get_powerstat":
 		return "1\n", false
+
+	// Three commands a client may issue as a matter of course. Refusing them with
+	// RPRT -11 is allowed, and a tolerant client carries on — but nothing obliges
+	// it to, and Nexus sends all three around every transmit. Answering costs
+	// nothing and removes them as suspects when something really is wrong.
+	case "\\get_lock_mode", "get_lock_mode":
+		// Truthful: OpsLog never locks the dial against its own clients.
+		return "0\n", false
+	case "\\set_lock_mode", "set_lock_mode":
+		// Accepted and ignored, like set_vfo below: there is no lock to set, and
+		// failing here would abort a client's whole transmit sequence over a
+		// setting that has no effect either way.
+		return rprt(0), false
+	case "\\stop_morse", "stop_morse":
+		// Nothing is queued here — CW over CAT is keyed by the rig's own keyer
+		// through the backend, not buffered in this server. "Stopped" is therefore
+		// accurate rather than polite.
+		return rprt(0), false
 	case "q", "Q", "\\quit":
 		return "", true
 
@@ -275,11 +352,27 @@ func (s *Server) handle(line string) (resp string, quit bool) {
 			return rprt(-1), false
 		}
 		on := args[0] != "0"
+		// Only touch the radio on a CHANGE.
+		//
+		// A client is free to restate PTT as often as it likes, and one does:
+		// Nexus sends set_ptt 0 about sixteen times a second, so the Flex was
+		// getting "xmit 0" every 60 ms forever. Worse than wasteful — its own
+		// "xmit 1" landed between two of them and was overwritten in the same
+		// millisecond, so the radio never stayed keyed and the operator saw a
+		// transmit request that simply did nothing.
+		//
+		// Repeating a state is not a request to change it. The first call always
+		// goes through, since we cannot know how the radio was left.
+		if s.pttKnown.Load() && s.ptt.Load() == on {
+			return rprt(0), false
+		}
 		if err := s.rig.SetPTT(on); err != nil {
 			s.log("rigctld: set_ptt %v failed: %v", on, err)
 			return rprt(-9), false
 		}
 		s.ptt.Store(on)
+		s.pttKnown.Store(true)
+		s.log("rigctld: PTT %s", map[bool]string{true: "ON", false: "off"}[on])
 		return rprt(0), false
 
 	case "v", "\\get_vfo":
@@ -297,7 +390,31 @@ func (s *Server) handle(line string) (resp string, quit bool) {
 		}
 		return fmt.Sprintf("%d\nVFOB\n", n), false
 	case "S", "\\set_split_vfo":
-		return rprt(0), false // see set_vfo — split is driven from the rig
+		// "S <0|1> <VFO>". The VFO argument is ignored: which dial transmits is the
+		// rig's own business, and every backend here puts it on the second one.
+		//
+		// This used to answer RPRT 0 and do NOTHING. WSJT-X in "Split Operating:
+		// Rig" sends this and set_split_freq, believed both, and transmitted on the
+		// RECEIVE frequency — on a pileup, straight onto the DX, while the software
+		// showed exactly what the operator had asked for. A lie that leaves no
+		// trace anywhere is the worst kind of bug, so it now works or says so.
+		if len(args) < 1 {
+			return rprt(-1), false
+		}
+		if args[0] != "0" {
+			// Arming needs a frequency, and WSJT-X sends set_split_freq AFTER this.
+			// Remember the request and let that command do the work: alone, this
+			// would arm split on whatever the transmit VFO happens to hold.
+			s.splitWanted.Store(true)
+			return rprt(0), false
+		}
+		s.splitWanted.Store(false)
+		if err := s.rig.SetSplit(false, 0); err != nil {
+			s.log("rigctld: split off failed: %v", err)
+			return rprt(-9), false
+		}
+		s.log("rigctld: split off")
+		return rprt(0), false
 	case "i", "\\get_split_freq":
 		_, tx := s.rig.Split()
 		if tx <= 0 {
@@ -305,9 +422,37 @@ func (s *Server) handle(line string) (resp string, quit bool) {
 		}
 		return fmt.Sprintf("%d\n", tx), false
 	case "I", "\\set_split_freq":
+		if len(args) < 1 {
+			return rprt(-1), false
+		}
+		// Hamlib sends a float ("14075300.000000"), so parse as one.
+		hz, err := strconv.ParseFloat(args[0], 64)
+		if err != nil || hz <= 0 {
+			return rprt(-1), false
+		}
+		if err := s.rig.SetSplit(true, int64(hz)); err != nil {
+			s.log("rigctld: split TX %.0f Hz failed: %v", hz, err)
+			return rprt(-9), false
+		}
+		s.splitWanted.Store(true)
+		s.log("rigctld: split ON, TX %.0f Hz", hz)
 		return rprt(0), false
 
 	default:
+		// A frame ending in ';' is not a rigctl command at all — it is raw rig
+		// dialect (Kenwood/Elecraft/Yaesu), which means the client is configured
+		// with a RIG MODEL pointing at this port instead of "Hamlib NET rigctl".
+		//
+		// Worth naming, because the symptom hides the cause completely: we answer
+		// RPRT -11 like any unknown command, but that reply has no ';' to terminate
+		// on, so the client's parser waits and then reports "reply incomplete, got
+		// nothing". The operator sees a timeout and concludes the CAT share is
+		// broken, when it is a one-line setting in the other program.
+		if strings.HasSuffix(line, ";") && !strings.Contains(line, " ") {
+			s.log("rigctld: %q is a raw rig command, not rigctl — the client is set to a RIG MODEL; "+
+				"it must be set to \"Hamlib NET rigctl\" (rig 2) at this address", line)
+			return rprt(-11), false
+		}
 		// RPRT -11 is "command not implemented". Answering something is essential:
 		// a client waiting on a silent socket hangs rather than degrading.
 		s.log("rigctld: unimplemented command %q", line)

internal/rigctld/rigctld_selftest_test.go

@@ -0,0 +1,94 @@
+package rigctld
+
+import (
+	"fmt"
+	"net"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+)
+
+// A listener that binds successfully is not necessarily the one clients reach.
+// Windows lets a second program bind the same port on the specific address
+// 127.0.0.1 while ours holds 0.0.0.0, and localhost connections then go to the
+// more specific one. Seen with Nexus, which starts its own rigctld on 4532.
+func TestSelfTestWarnsWhenAnotherProgramHoldsLocalhost(t *testing.T) {
+	// Squat 127.0.0.1 first, the way the other program does.
+	squat, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Skipf("cannot bind localhost here: %v", err)
+	}
+	defer squat.Close()
+	port := squat.Addr().(*net.TCPAddr).Port
+	go func() {
+		for {
+			c, err := squat.Accept()
+			if err != nil {
+				return
+			}
+			c.Close()
+		}
+	}()
+
+	var mu sync.Mutex
+	var lines []string
+	s := New(port, nil, func(f string, a ...any) {
+		mu.Lock()
+		lines = append(lines, fmt.Sprintf(f, a...))
+		mu.Unlock()
+	})
+	if err := s.Start(); err != nil {
+		// The wildcard bind is refused on some setups; nothing to prove then.
+		t.Skipf("wildcard bind refused: %v", err)
+	}
+	defer s.Stop()
+
+	deadline := time.Now().Add(4 * time.Second)
+	for time.Now().Before(deadline) {
+		mu.Lock()
+		got := strings.Join(lines, "\n")
+		mu.Unlock()
+		if strings.Contains(got, "another program is already answering") {
+			return
+		}
+		time.Sleep(50 * time.Millisecond)
+	}
+	mu.Lock()
+	defer mu.Unlock()
+	t.Errorf("no warning was logged while another listener owned localhost:%d.\nlog was:\n%s",
+		port, strings.Join(lines, "\n"))
+}
+
+// The healthy case must stay silent: a warning on every clean start would be
+// noise, and noise in a log is what makes the real line easy to miss.
+func TestSelfTestIsSilentWhenReachable(t *testing.T) {
+	// A real, free port: with 0 the OS picks one but s.port stays 0, so the probe
+	// would dial 127.0.0.1:0 and prove nothing.
+	probe, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Skipf("cannot bind: %v", err)
+	}
+	port := probe.Addr().(*net.TCPAddr).Port
+	probe.Close()
+
+	var mu sync.Mutex
+	var lines []string
+	s := New(port, nil, func(f string, a ...any) {
+		mu.Lock()
+		lines = append(lines, fmt.Sprintf(f, a...))
+		mu.Unlock()
+	})
+	if err := s.Start(); err != nil {
+		t.Skipf("start: %v", err)
+	}
+	defer s.Stop()
+	time.Sleep(1500 * time.Millisecond)
+	mu.Lock()
+	defer mu.Unlock()
+	for _, l := range lines {
+		if strings.Contains(l, "WARNING") {
+			t.Errorf("a reachable port still warned: %q", l)
+		}
+	}
+}

internal/rigctld/rigctld_test.go

@@ -2,6 +2,7 @@ package rigctld
 
 import (
 	"bufio"
+	"errors"
 	"fmt"
 	"net"
 	"strings"
@@ -21,11 +22,26 @@ type fakeRig struct {
 	setFreqs []int64
 	setModes []string
 	failSet  bool
+	// noSplit models a backend that cannot set split — the case that must reach
+	// the client as a refusal instead of a silent success.
+	noSplit    bool
+	splitCalls []string
 }
 
 func (f *fakeRig) Freq() int64          { f.mu.Lock(); defer f.mu.Unlock(); return f.freq }
 func (f *fakeRig) Mode() string         { f.mu.Lock(); defer f.mu.Unlock(); return f.mode }
 func (f *fakeRig) Split() (bool, int64) { f.mu.Lock(); defer f.mu.Unlock(); return f.split, f.txFreq }
+
+func (f *fakeRig) SetSplit(on bool, txHz int64) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	if f.noSplit {
+		return errors.New("this radio cannot set split from software")
+	}
+	f.splitCalls = append(f.splitCalls, fmt.Sprintf("%v:%d", on, txHz))
+	f.split, f.txFreq = on, txHz
+	return nil
+}
 func (f *fakeRig) SetFreq(hz int64) error {
 	f.mu.Lock()
 	defer f.mu.Unlock()

internal/rigctld/split_test.go

@@ -0,0 +1,52 @@
+package rigctld
+
+import (
+	"strings"
+	"testing"
+)
+
+// WSJT-X in "Split Operating: Rig" sends set_split_vfo then set_split_freq. Both
+// used to answer RPRT 0 and do NOTHING: the software believed it was
+// transmitting up the band while the radio stayed on the receive frequency —
+// on a pileup, straight onto the DX, with no trace anywhere.
+func TestSetSplitReachesTheRig(t *testing.T) {
+	rig := &fakeRig{freq: 14074000, mode: "FT8"}
+	s := New(0, rig, func(string, ...any) {})
+
+	if got, _ := s.handle("S 1 VFOB"); !strings.HasPrefix(got, "RPRT 0") {
+		t.Fatalf("set_split_vfo answered %q", got)
+	}
+	// Arming alone must NOT touch the rig: without a frequency it would transmit
+	// on whatever the second VFO happened to hold.
+	if len(rig.splitCalls) != 0 {
+		t.Errorf("split was armed before a frequency arrived: %v", rig.splitCalls)
+	}
+
+	if got, _ := s.handle("I 14075300.000000"); !strings.HasPrefix(got, "RPRT 0") {
+		t.Fatalf("set_split_freq answered %q", got)
+	}
+	if len(rig.splitCalls) != 1 || rig.splitCalls[0] != "true:14075300" {
+		t.Fatalf("rig saw %v, want one call arming split on 14075300", rig.splitCalls)
+	}
+
+	if got, _ := s.handle("S 0 VFOA"); !strings.HasPrefix(got, "RPRT 0") {
+		t.Fatalf("split off answered %q", got)
+	}
+	if len(rig.splitCalls) != 2 || !strings.HasPrefix(rig.splitCalls[1], "false:") {
+		t.Errorf("rig saw %v, want split cleared", rig.splitCalls)
+	}
+}
+
+// A backend that cannot do split must produce an ERROR the client can report.
+// Answering success and doing nothing is what caused the original fault, and it
+// is the one outcome that must never come back.
+func TestSetSplitRefusalIsReported(t *testing.T) {
+	rig := &fakeRig{freq: 14074000, noSplit: true}
+	s := New(0, rig, func(string, ...any) {})
+
+	s.handle("S 1 VFOB")
+	got, _ := s.handle("I 14075300.000000")
+	if strings.HasPrefix(got, "RPRT 0") {
+		t.Errorf("a rig that cannot split answered %q — the client will transmit on the wrong frequency", got)
+	}
+}

internal/webpub/webpub.go

@@ -0,0 +1,588 @@
+// Package webpub publishes the log as a file an operator can put on a website:
+// a self-contained HTML page or a CSV, written locally and optionally uploaded
+// by FTP/FTPS.
+//
+// Design notes that matter:
+//
+//   - The local file is ALWAYS written first and the upload layered on top. A
+//     network failure then leaves a good file on disk rather than a truncated
+//     one on the server, and the operator can publish it by any other means.
+//   - The page is self-contained: no external CSS, font or script. It has to
+//     work dropped into any hosting, including one that blocks third-party
+//     requests, and it must not leak the reader's visit to anyone.
+//   - Every ADIF field is offered, because an operator publishing a county hunt
+//     or an award chase needs fields no curated list would have guessed. That
+//     puts the judgement on them, and it is a real one: this page is PUBLIC, and
+//     the catalogue includes the correspondent's address, e-mail and the
+//     operator's own street. Nothing is published unless it is chosen, and the
+//     default selection stays the eight columns a reader of someone else's log
+//     actually looks for.
+package webpub
+
+import (
+	"crypto/tls"
+	"encoding/csv"
+	"fmt"
+	"html"
+	"os"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/jlaffaye/ftp"
+
+	"hamlog/internal/geo"
+	"hamlog/internal/qso"
+)
+
+// Config is the whole feature's configuration. Stored per profile.
+type Config struct {
+	Enabled  bool   `json:"enabled"`
+	Format   string `json:"format"`    // "html" | "csv"
+	Folder   string `json:"folder"`    // local output folder
+	FileName string `json:"file_name"` // e.g. "log.html"
+	Title    string `json:"title"`     // page heading; blank → callsign
+	Count    int    `json:"count"`     // publish the last N QSOs
+	// IntervalMin is the periodic refresh in minutes. 0 = only republish when a
+	// QSO is logged. Every publish is debounced regardless (see Publisher).
+	IntervalMin int      `json:"interval_min"`
+	Columns     []string `json:"columns"`
+
+	FTPEnabled  bool   `json:"ftp_enabled"`
+	FTPHost     string `json:"ftp_host"`
+	FTPPort     int    `json:"ftp_port"`
+	FTPUser     string `json:"ftp_user"`
+	FTPPassword string `json:"ftp_password"`
+	FTPTLS      bool   `json:"ftp_tls"` // explicit AUTH TLS (FTPS)
+	FTPFolder   string `json:"ftp_folder"`
+	FTPFileName string `json:"ftp_file_name"`
+}
+
+// Column is one publishable field: a stable key, the header printed in the
+// file, and how to read it off a QSO.
+type Column struct {
+	Key    string
+	Header string
+	// Group is the section a picker shows this under. With every ADIF field on
+	// offer, a flat list is unusable — the grouping IS what makes it navigable.
+	Group string
+	Value func(q *qso.QSO) string
+}
+
+func str(p *int) string {
+	if p == nil {
+		return ""
+	}
+	return strconv.Itoa(*p)
+}
+
+func str64(p *int64) string {
+	if p == nil {
+		return ""
+	}
+	return strconv.FormatInt(*p, 10)
+}
+
+// flt drops a trailing ".0": a distance reads better as "1420" than "1420.0",
+// and a bearing as "142.5" keeps the half-degree that matters.
+func flt(p *float64) string {
+	if p == nil {
+		return ""
+	}
+	return strconv.FormatFloat(*p, 'f', -1, 64)
+}
+
+// distanceKm is the path length for the Distance column.
+//
+// The stored DISTANCE field is only ever filled by an ADIF import that carried
+// one — OpsLog does not compute it when logging — so publishing it straight gave
+// an empty column for every QSO made here, which is how this was reported.
+//
+// So it falls back to the two locators, which are on the QSO already. Rounded to
+// whole kilometres: the grids are squares tens of kilometres across, and a
+// decimal on a figure that imprecise claims an accuracy nobody has.
+func distanceKm(q *qso.QSO) string {
+	if q.Distance != nil && *q.Distance > 0 {
+		return flt(q.Distance)
+	}
+	km, ok := geo.DistanceBetweenGrids(q.MyGrid, q.Grid)
+	if !ok || km <= 0 {
+		return ""
+	}
+	return strconv.FormatFloat(km, 'f', 0, 64)
+}
+
+func stamp(t time.Time) string {
+	if t.IsZero() {
+		return ""
+	}
+	return t.UTC().Format("2006-01-02 15:04")
+}
+
+// Columns is every field a QSO can carry, in ADIF order, grouped for the picker.
+//
+// Generated from the qso.QSO struct rather than curated by hand: the previous
+// list held 23 of them, so anyone wanting to publish a county, a satellite pass
+// or an award reference simply could not. A hand list also silently rots — a new
+// ADIF field is added to the struct and nobody remembers this file exists.
+//
+// The stored configuration keeps KEYS, so order and grouping can change freely.
+var Columns = []Column{
+	// Date and time are one column in the database and two here: a log reads by
+	// day, and a reader scanning for "that evening" should not have to parse a
+	// timestamp. Frequency is stored in Hz and published in MHz.
+	{"date", "Date", "QSO", func(q *qso.QSO) string { return q.QSODate.UTC().Format("2006-01-02") }},
+	{"time", "UTC", "QSO", func(q *qso.QSO) string { return q.QSODate.UTC().Format("15:04") }},
+	{"freq", "Freq", "QSO", func(q *qso.QSO) string {
+		if q.FreqHz == nil || *q.FreqHz == 0 {
+			return ""
+		}
+		return strconv.FormatFloat(float64(*q.FreqHz)/1e6, 'f', 3, 64)
+	}},
+	{"callsign", "Callsign", "QSO", func(q *qso.QSO) string { return q.Callsign }},
+	{"qso_date_off", "End", "QSO", func(q *qso.QSO) string { return stamp(q.QSODateOff) }},
+	{"band", "Band", "QSO", func(q *qso.QSO) string { return q.Band }},
+	{"band_rx", "Band RX", "QSO", func(q *qso.QSO) string { return q.BandRX }},
+	{"mode", "Mode", "QSO", func(q *qso.QSO) string { return q.Mode }},
+	{"submode", "Submode", "QSO", func(q *qso.QSO) string { return q.Submode }},
+	{"freq_rx_hz", "Freq RX", "QSO", func(q *qso.QSO) string { return str64(q.FreqRXHz) }},
+	{"rst_sent", "RST S", "QSO", func(q *qso.QSO) string { return q.RSTSent }},
+	{"rst_rcvd", "RST R", "QSO", func(q *qso.QSO) string { return q.RSTRcvd }},
+	{"name", "Name", "QSO", func(q *qso.QSO) string { return q.Name }},
+	{"qth", "QTH", "QSO", func(q *qso.QSO) string { return q.QTH }},
+	{"address", "Address", "QSO", func(q *qso.QSO) string { return q.Address }},
+	{"email", "Email", "QSO", func(q *qso.QSO) string { return q.Email }},
+	{"web", "Web", "QSO", func(q *qso.QSO) string { return q.Web }},
+	{"grid", "Grid", "Location", func(q *qso.QSO) string { return q.Grid }},
+	{"gridsquare_ext", "Grid ext", "Location", func(q *qso.QSO) string { return q.GridExt }},
+	{"vucc_grids", "VUCC", "Location", func(q *qso.QSO) string { return q.VUCCGrids }},
+	{"country", "Country", "Location", func(q *qso.QSO) string { return q.Country }},
+	{"state", "State", "Location", func(q *qso.QSO) string { return q.State }},
+	{"cnty", "County", "Location", func(q *qso.QSO) string { return q.County }},
+	{"dxcc", "Dxcc", "Location", func(q *qso.QSO) string { return str(q.DXCC) }},
+	{"cont", "Cont", "Location", func(q *qso.QSO) string { return q.Continent }},
+	{"cqz", "CQ", "Location", func(q *qso.QSO) string { return str(q.CQZ) }},
+	{"ituz", "ITU", "Location", func(q *qso.QSO) string { return str(q.ITUZ) }},
+	{"iota", "Iota", "Awards", func(q *qso.QSO) string { return q.IOTA }},
+	{"sota_ref", "SOTA", "Awards", func(q *qso.QSO) string { return q.SOTARef }},
+	{"pota_ref", "POTA", "Awards", func(q *qso.QSO) string { return q.POTARef }},
+	{"age", "Age", "QSO", func(q *qso.QSO) string { return str(q.Age) }},
+	{"lat", "Lat", "Location", func(q *qso.QSO) string { return flt(q.Lat) }},
+	{"lon", "Lon", "Location", func(q *qso.QSO) string { return flt(q.Lon) }},
+	{"rig", "Rig", "QSO", func(q *qso.QSO) string { return q.Rig }},
+	{"ant", "Ant", "QSO", func(q *qso.QSO) string { return q.Ant }},
+	{"qsl_sent", "QSL S", "QSL", func(q *qso.QSO) string { return q.QSLSent }},
+	{"qsl_rcvd", "QSL R", "QSL", func(q *qso.QSO) string { return q.QSLRcvd }},
+	{"qsl_sent_date", "Qsl sent date", "QSL", func(q *qso.QSO) string { return q.QSLSentDate }},
+	{"qsl_rcvd_date", "Qsl rcvd date", "QSL", func(q *qso.QSO) string { return q.QSLRcvdDate }},
+	{"qsl_via", "Qsl via", "QSL", func(q *qso.QSO) string { return q.QSLVia }},
+	{"qsl_msg", "Qsl msg", "QSL", func(q *qso.QSO) string { return q.QSLMsg }},
+	{"qslmsg_rcvd", "Qslmsg rcvd", "QSL", func(q *qso.QSO) string { return q.QSLMsgRcvd }},
+	{"lotw_sent", "LoTW S", "QSL", func(q *qso.QSO) string { return q.LOTWSent }},
+	{"lotw_rcvd", "LoTW R", "QSL", func(q *qso.QSO) string { return q.LOTWRcvd }},
+	{"lotw_sent_date", "Lotw sent date", "QSL", func(q *qso.QSO) string { return q.LOTWSentDate }},
+	{"lotw_rcvd_date", "Lotw rcvd date", "QSL", func(q *qso.QSO) string { return q.LOTWRcvdDate }},
+	{"eqsl_sent", "eQSL S", "QSL", func(q *qso.QSO) string { return q.EQSLSent }},
+	{"eqsl_rcvd", "eQSL R", "QSL", func(q *qso.QSO) string { return q.EQSLRcvd }},
+	{"eqsl_sent_date", "Eqsl sent date", "QSL", func(q *qso.QSO) string { return q.EQSLSentDate }},
+	{"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 }},
+	{"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 }},
+	{"qrzcom_qso_upload_status", "Qrzcom qso upload status", "QSL", func(q *qso.QSO) string { return q.QRZComUploadStatus }},
+	{"qrzcom_qso_download_date", "Qrzcom qso download date", "QSL", func(q *qso.QSO) string { return q.QRZComDownloadDate }},
+	{"qrzcom_qso_download_status", "Qrzcom qso download status", "QSL", func(q *qso.QSO) string { return q.QRZComDownloadStatus }},
+	{"contest_id", "Contest", "Contest", func(q *qso.QSO) string { return q.ContestID }},
+	{"srx", "Srx", "Contest", func(q *qso.QSO) string { return str(q.SRX) }},
+	{"stx", "Stx", "Contest", func(q *qso.QSO) string { return str(q.STX) }},
+	{"srx_string", "SRX str", "QSO", func(q *qso.QSO) string { return q.SRXString }},
+	{"stx_string", "STX str", "QSO", func(q *qso.QSO) string { return q.STXString }},
+	{"check", "Check", "Contest", func(q *qso.QSO) string { return q.Check }},
+	{"precedence", "Precedence", "Contest", func(q *qso.QSO) string { return q.Precedence }},
+	{"arrl_sect", "Section", "Contest", func(q *qso.QSO) string { return q.ARRLSect }},
+	{"prop_mode", "Prop", "QSO", func(q *qso.QSO) string { return q.PropMode }},
+	{"sat_name", "Sat", "QSO", func(q *qso.QSO) string { return q.SatName }},
+	{"sat_mode", "Sat mode", "QSO", func(q *qso.QSO) string { return q.SatMode }},
+	{"ant_az", "Ant az", "QSO", func(q *qso.QSO) string { return flt(q.AntAz) }},
+	{"ant_el", "Ant el", "QSO", func(q *qso.QSO) string { return flt(q.AntEl) }},
+	{"ant_path", "Ant path", "QSO", func(q *qso.QSO) string { return q.AntPath }},
+	{"station_callsign", "Station", "QSO", func(q *qso.QSO) string { return q.StationCallsign }},
+	{"operator", "Operator", "QSO", func(q *qso.QSO) string { return q.Operator }},
+	{"my_grid", "My grid", "My station", func(q *qso.QSO) string { return q.MyGrid }},
+	{"my_gridsquare_ext", "My gridsquare ext", "My station", func(q *qso.QSO) string { return q.MyGridExt }},
+	{"my_country", "My country", "My station", func(q *qso.QSO) string { return q.MyCountry }},
+	{"my_state", "My state", "My station", func(q *qso.QSO) string { return q.MyState }},
+	{"my_cnty", "My cnty", "My station", func(q *qso.QSO) string { return q.MyCounty }},
+	{"my_iota", "My iota", "My station", func(q *qso.QSO) string { return q.MyIOTA }},
+	{"my_sota_ref", "My sota ref", "My station", func(q *qso.QSO) string { return q.MySOTARef }},
+	{"my_pota_ref", "My pota ref", "My station", func(q *qso.QSO) string { return q.MyPOTARef }},
+	{"my_dxcc", "My dxcc", "My station", func(q *qso.QSO) string { return str(q.MyDXCC) }},
+	{"my_cq_zone", "My cq zone", "My station", func(q *qso.QSO) string { return str(q.MyCQZone) }},
+	{"my_itu_zone", "My itu zone", "My station", func(q *qso.QSO) string { return str(q.MyITUZone) }},
+	{"my_lat", "My lat", "My station", func(q *qso.QSO) string { return flt(q.MyLat) }},
+	{"my_lon", "My lon", "My station", func(q *qso.QSO) string { return flt(q.MyLon) }},
+	{"my_street", "My street", "My station", func(q *qso.QSO) string { return q.MyStreet }},
+	{"my_city", "My city", "My station", func(q *qso.QSO) string { return q.MyCity }},
+	{"my_postal_code", "My postal code", "My station", func(q *qso.QSO) string { return q.MyPostalCode }},
+	{"my_rig", "My rig", "My station", func(q *qso.QSO) string { return q.MyRig }},
+	{"my_antenna", "My antenna", "My station", func(q *qso.QSO) string { return q.MyAntenna }},
+	{"tx_pwr", "TX pwr", "QSO", func(q *qso.QSO) string { return flt(q.TXPower) }},
+	{"comment", "Comment", "QSO", func(q *qso.QSO) string { return q.Comment }},
+	{"notes", "Notes", "QSO", func(q *qso.QSO) string { return q.Notes }},
+	{"sig", "Sig", "Awards", func(q *qso.QSO) string { return q.SIG }},
+	{"sig_info", "Sig info", "Awards", func(q *qso.QSO) string { return q.SIGInfo }},
+	{"my_sig", "My sig", "My station", func(q *qso.QSO) string { return q.MySIG }},
+	{"my_sig_info", "My sig info", "My station", func(q *qso.QSO) string { return q.MySIGInfo }},
+	{"wwff_ref", "WWFF", "Awards", func(q *qso.QSO) string { return q.WWFFRef }},
+	{"my_wwff_ref", "My wwff ref", "My station", func(q *qso.QSO) string { return q.MyWWFFRef }},
+	{"distance", "Distance", "Location", distanceKm},
+	{"rx_pwr", "RX pwr", "QSO", func(q *qso.QSO) string { return flt(q.RXPower) }},
+	{"a_index", "A", "QSO", func(q *qso.QSO) string { return flt(q.AIndex) }},
+	{"k_index", "K", "QSO", func(q *qso.QSO) string { return flt(q.KIndex) }},
+	{"sfi", "SFI", "QSO", func(q *qso.QSO) string { return flt(q.SFI) }},
+	{"skcc", "Skcc", "Awards", func(q *qso.QSO) string { return q.SKCC }},
+	{"fists", "Fists", "Awards", func(q *qso.QSO) string { return q.FISTS }},
+	{"ten_ten", "10-10", "Awards", func(q *qso.QSO) string { return q.TenTen }},
+	{"contacted_op", "Op worked", "QSO", func(q *qso.QSO) string { return q.ContactedOp }},
+	{"eq_call", "Eq call", "QSO", func(q *qso.QSO) string { return q.EqCall }},
+	{"pfx", "Pfx", "Location", func(q *qso.QSO) string { return q.PFX }},
+	{"my_name", "My name", "My station", func(q *qso.QSO) string { return q.MyName }},
+	{"class", "Class", "Contest", func(q *qso.QSO) string { return q.Class }},
+	{"darc_dok", "DOK", "Awards", func(q *qso.QSO) string { return q.DarcDOK }},
+	{"my_darc_dok", "My darc dok", "My station", func(q *qso.QSO) string { return q.MyDarcDOK }},
+	{"region", "Region", "Location", func(q *qso.QSO) string { return q.Region }},
+	{"silent_key", "SK", "QSO", func(q *qso.QSO) string { return q.SilentKey }},
+	{"swl", "Swl", "QSO", func(q *qso.QSO) string { return q.SWL }},
+	{"qso_complete", "Complete", "QSO", func(q *qso.QSO) string { return q.QSOComplete }},
+	{"qso_random", "Random", "QSO", func(q *qso.QSO) string { return q.QSORandom }},
+	{"credit_granted", "Credit granted", "QSL", func(q *qso.QSO) string { return q.CreditGranted }},
+	{"credit_submitted", "Credit sub.", "QSL", func(q *qso.QSO) string { return q.CreditSubmitted }},
+	{"my_arrl_sect", "My arrl sect", "My station", func(q *qso.QSO) string { return q.MyARRLSect }},
+	{"my_vucc_grids", "My vucc grids", "My station", func(q *qso.QSO) string { return q.MyVUCCGrids }},
+	{"award_refs", "Award refs", "Awards", func(q *qso.QSO) string { return q.AwardRefs }},
+}
+
+// DefaultColumns is what a fresh configuration publishes — the columns a reader
+// of someone else's log actually looks for.
+var DefaultColumns = []string{"date", "time", "callsign", "band", "mode", "rst_sent", "rst_rcvd", "country"}
+
+// legacyKeys maps the short names the hand-written table used onto the ADIF
+// names the generated one uses. A configuration saved before this change still
+// publishes the same columns; without it, three of them would vanish silently on
+// upgrade, which is the worst way for a setting to change.
+var legacyKeys = map[string]string{
+	"pota":    "pota_ref",
+	"sota":    "sota_ref",
+	"station": "station_callsign",
+}
+
+func columnsFor(keys []string) []Column {
+	if len(keys) == 0 {
+		keys = DefaultColumns
+	}
+	byKey := make(map[string]Column, len(Columns))
+	for _, c := range Columns {
+		byKey[c.Key] = c
+	}
+	out := make([]Column, 0, len(keys))
+	for _, k := range keys {
+		k = strings.TrimSpace(k)
+		if alias, ok := legacyKeys[k]; ok {
+			k = alias
+		}
+		if c, ok := byKey[k]; ok {
+			out = append(out, c)
+		}
+	}
+	if len(out) == 0 { // every stored key unknown (config from a newer build)
+		return columnsFor(DefaultColumns)
+	}
+	return out
+}
+
+// KnownColumnKeys lists the offered columns, for the settings UI.
+func KnownColumnKeys() []Column {
+	out := make([]Column, len(Columns))
+	copy(out, Columns)
+	sort.SliceStable(out, func(i, j int) bool { return false }) // keep declared order
+	return out
+}
+
+// Normalise fills in the defaults a half-filled config would otherwise carry
+// into the renderer.
+func (c *Config) Normalise() {
+	if c.Format != "csv" {
+		c.Format = "html"
+	}
+	if strings.TrimSpace(c.FileName) == "" {
+		if c.Format == "csv" {
+			c.FileName = "log.csv"
+		} else {
+			c.FileName = "log.html"
+		}
+	}
+	if c.Count <= 0 {
+		c.Count = 100
+	}
+	if c.FTPPort <= 0 {
+		c.FTPPort = 21
+	}
+	if len(c.Columns) == 0 {
+		c.Columns = append([]string{}, DefaultColumns...)
+	}
+	if strings.TrimSpace(c.FTPFileName) == "" {
+		c.FTPFileName = c.FileName
+	}
+}
+
+// Render builds the file contents for the given QSOs.
+func Render(cfg Config, qsos []qso.QSO, stationCall string) ([]byte, error) {
+	cfg.Normalise()
+	cols := columnsFor(cfg.Columns)
+	if cfg.Format == "csv" {
+		return renderCSV(cols, qsos)
+	}
+	return renderHTML(cfg, cols, qsos, stationCall), nil
+}
+
+func renderCSV(cols []Column, qsos []qso.QSO) ([]byte, error) {
+	var b strings.Builder
+	w := csv.NewWriter(&b)
+	head := make([]string, len(cols))
+	for i, c := range cols {
+		head[i] = c.Header
+	}
+	if err := w.Write(head); err != nil {
+		return nil, err
+	}
+	row := make([]string, len(cols))
+	for i := range qsos {
+		for j, c := range cols {
+			row[j] = c.Value(&qsos[i])
+		}
+		if err := w.Write(row); err != nil {
+			return nil, err
+		}
+	}
+	w.Flush()
+	if err := w.Error(); err != nil {
+		return nil, err
+	}
+	return []byte(b.String()), nil
+}
+
+// renderHTML writes a standalone page: inline CSS, inline sort script, no
+// external request of any kind.
+func renderHTML(cfg Config, cols []Column, qsos []qso.QSO, stationCall string) []byte {
+	title := strings.TrimSpace(cfg.Title)
+	if title == "" {
+		if stationCall != "" {
+			title = stationCall + " — log"
+		} else {
+			title = "Log"
+		}
+	}
+	esc := html.EscapeString
+
+	var b strings.Builder
+	b.WriteString(`<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>` + esc(title) + `</title>
+<style>
+:root{color-scheme:light dark;--bg:#fff;--fg:#16181d;--mut:#5b6270;--line:#e2e5ea;--head:#f4f6f8;--zebra:#fafbfc;--accent:#2a78d6}
+@media (prefers-color-scheme:dark){:root{--bg:#16181d;--fg:#e6e8ec;--mut:#9aa2b1;--line:#2e343f;--head:#1f232b;--zebra:#1b1f26;--accent:#6da7ec}}
+*{box-sizing:border-box}
+body{margin:0;padding:1.5rem 1rem;background:var(--bg);color:var(--fg);
+     font:14px/1.5 system-ui,-apple-system,"Segoe UI",Roboto,sans-serif}
+/* The page grows with its table instead of being capped at a comfortable
+   READING width. 1100px suits eight columns and hides the rest behind a
+   scrollbar on a screen wide enough to show them all — which is how this was
+   reported. max-content lets a wide table use the window; min-width keeps a
+   narrow one from collapsing to nothing on a large display. */
+.wrap{max-width:max-content;min-width:min(1100px,100%);margin:0 auto}
+h1{margin:0 0 .25rem;font-size:1.35rem}
+.meta{margin:0 0 1rem;color:var(--mut);font-size:.8rem}
+/* A visible scrollbar. Windows hides overlay scrollbars until something moves,
+   so a table that scrolls looks exactly like a table that is missing columns. */
+.scroll{overflow-x:auto;border:1px solid var(--line);border-radius:8px;
+        scrollbar-width:thin;scrollbar-color:var(--line) transparent}
+.scroll::-webkit-scrollbar{height:10px}
+.scroll::-webkit-scrollbar-thumb{background:var(--line);border-radius:5px}
+/* width:auto, not 100%: columns take the width their contents need. With
+   width:100% the browser squeezes them to fit the container first and only then
+   overflows, so a callsign could end up wrapped while empty space sat further
+   along the row. min-width keeps a two-column table filling the frame. */
+table{border-collapse:collapse;width:auto;min-width:100%;font-variant-numeric:tabular-nums}
+th,td{padding:.45rem .6rem;text-align:left;border-bottom:1px solid var(--line);white-space:nowrap}
+th{position:sticky;top:0;background:var(--head);font-size:.72rem;letter-spacing:.05em;
+   text-transform:uppercase;color:var(--mut);cursor:pointer;user-select:none}
+th:hover{color:var(--fg)}
+th::after{content:'';font-size:.7em;opacity:.7}
+th[data-asc="1"]::after{content:' \25B2'}
+th[data-asc="0"]::after{content:' \25BC'}
+tbody tr:nth-child(even){background:var(--zebra)}
+tbody tr:last-child td{border-bottom:0}
+td.call{font-family:ui-monospace,Consolas,monospace;font-weight:700;color:var(--accent)}
+.foot{margin-top:.75rem;color:var(--mut);font-size:.75rem}
+</style>
+</head>
+<body><div class="wrap">
+<h1>` + esc(title) + `</h1>
+<p class="meta">` + strconv.Itoa(len(qsos)) + ` QSO · ` + time.Now().UTC().Format("2006-01-02 15:04") + ` UTC</p>
+<div class="scroll"><table><thead><tr>`)
+	for _, c := range cols {
+		b.WriteString(`<th>` + esc(c.Header) + `</th>`)
+	}
+	b.WriteString(`</tr></thead><tbody>`)
+	for i := range qsos {
+		// The row's position as published. Sorting is a view on top of it, so a
+		// third click can put the table back the way the operator first saw it.
+		b.WriteString(`<tr data-i="` + strconv.Itoa(i) + `">`)
+		for _, c := range cols {
+			cls := ""
+			if c.Key == "callsign" {
+				cls = ` class="call"`
+			}
+			b.WriteString(`<td` + cls + `>` + esc(c.Value(&qsos[i])) + `</td>`)
+		}
+		b.WriteString(`</tr>`)
+	}
+	b.WriteString(`</tbody></table></div>
+<p class="foot">Generated by OpsLog</p>
+</div>
+<script>
+// Click a header to sort: ascending, descending, then back to the published
+// order. Kept tiny and dependency-free — the page has to work offline and on any
+// hosting, so no library is loaded.
+//
+// NUM is deliberately strict: the whole cell must be a number. parseFloat alone
+// accepts a numeric PREFIX, so "2026-08-10" became 2026 and every date in a year
+// compared equal — the date column looked as though it simply would not sort.
+// Callsigns starting with a digit (8B81SU) hit the same trap.
+var NUM=/^[+-]?\d+(\.\d+)?$/;
+document.querySelectorAll('th').forEach(function(th,i){
+  th.addEventListener('click',function(){
+    var tb=th.closest('table').tBodies[0],
+        rows=Array.prototype.slice.call(tb.rows),
+        cur=th.dataset.asc,
+        next=cur===undefined?'1':(cur==='1'?'0':'');
+    if(next===''){
+      // Third click: restore the order the page was published in.
+      rows.sort(function(a,b){return a.dataset.i-b.dataset.i});
+    }else{
+      var asc=next==='1';
+      rows.sort(function(a,b){
+        var x=a.cells[i].textContent.trim(), y=b.cells[i].textContent.trim();
+        // Blanks always sink, whichever way the column is pointing: an empty
+        // cell is missing data, not the smallest value.
+        if(x===''||y==='') return x===y?0:(x===''?1:-1);
+        var c=NUM.test(x)&&NUM.test(y)?(parseFloat(x)-parseFloat(y)):x.localeCompare(y);
+        return asc?c:-c;
+      });
+    }
+    rows.forEach(function(r){tb.appendChild(r)});
+    th.closest('tr').querySelectorAll('th').forEach(function(o){delete o.dataset.asc});
+    if(next!=='') th.dataset.asc=next;
+  });
+});
+</script>
+</body></html>
+`)
+	return []byte(b.String())
+}
+
+// WriteLocal writes the payload into the configured folder and returns the path.
+func WriteLocal(cfg Config, data []byte) (string, error) {
+	cfg.Normalise()
+	dir := strings.TrimSpace(cfg.Folder)
+	if dir == "" {
+		return "", fmt.Errorf("no output folder set")
+	}
+	if err := os.MkdirAll(dir, 0o755); err != nil {
+		return "", fmt.Errorf("create %s: %w", dir, err)
+	}
+	path := filepath.Join(dir, cfg.FileName)
+	// Write to a temp file and rename over the target: a reader (or a syncing
+	// client) never sees a half-written page.
+	tmp := path + ".tmp"
+	if err := os.WriteFile(tmp, data, 0o644); err != nil {
+		return "", fmt.Errorf("write %s: %w", tmp, err)
+	}
+	if err := os.Rename(tmp, path); err != nil {
+		_ = os.Remove(tmp)
+		return "", fmt.Errorf("replace %s: %w", path, err)
+	}
+	return path, nil
+}
+
+// Upload sends the payload to the configured FTP/FTPS server.
+func Upload(cfg Config, data []byte) error {
+	cfg.Normalise()
+	host := strings.TrimSpace(cfg.FTPHost)
+	if host == "" {
+		return fmt.Errorf("no FTP server set")
+	}
+	c, err := dial(cfg)
+	if err != nil {
+		return err
+	}
+	defer func() { _ = c.Quit() }()
+
+	if err := c.Login(cfg.FTPUser, cfg.FTPPassword); err != nil {
+		return fmt.Errorf("login as %q: %w", cfg.FTPUser, err)
+	}
+	if dir := strings.TrimSpace(cfg.FTPFolder); dir != "" {
+		if err := c.ChangeDir(dir); err != nil {
+			return fmt.Errorf("enter remote folder %q: %w", dir, err)
+		}
+	}
+	if err := c.Stor(cfg.FTPFileName, strings.NewReader(string(data))); err != nil {
+		return fmt.Errorf("upload %q: %w", cfg.FTPFileName, err)
+	}
+	return nil
+}
+
+func dial(cfg Config) (*ftp.ServerConn, error) {
+	addr := fmt.Sprintf("%s:%d", strings.TrimSpace(cfg.FTPHost), cfg.FTPPort)
+	opts := []ftp.DialOption{ftp.DialWithTimeout(20 * time.Second)}
+	if cfg.FTPTLS {
+		// Explicit FTPS (AUTH TLS), the form virtually every web host offers.
+		// InsecureSkipVerify is NOT set: a certificate that does not validate is
+		// a real warning, and silently accepting it would defeat the point of
+		// ticking the TLS box in the first place.
+		opts = append(opts, ftp.DialWithExplicitTLS(&tls.Config{ServerName: strings.TrimSpace(cfg.FTPHost)}))
+	}
+	c, err := ftp.Dial(addr, opts...)
+	if err != nil {
+		return nil, fmt.Errorf("connect to %s: %w", addr, err)
+	}
+	return c, nil
+}
+
+// Test connects, logs in and enters the remote folder without uploading — the
+// "Test connection" button. Returns a short human-readable success line.
+func Test(cfg Config) (string, error) {
+	cfg.Normalise()
+	c, err := dial(cfg)
+	if err != nil {
+		return "", err
+	}
+	defer func() { _ = c.Quit() }()
+	if err := c.Login(cfg.FTPUser, cfg.FTPPassword); err != nil {
+		return "", fmt.Errorf("login as %q: %w", cfg.FTPUser, err)
+	}
+	if dir := strings.TrimSpace(cfg.FTPFolder); dir != "" {
+		if err := c.ChangeDir(dir); err != nil {
+			return "", fmt.Errorf("enter remote folder %q: %w", dir, err)
+		}
+	}
+	cwd, _ := c.CurrentDir()
+	return "connected — remote folder " + cwd, nil
+}

internal/webpub/webpub_distance_test.go

@@ -0,0 +1,39 @@
+package webpub
+
+import (
+	"testing"
+
+	"hamlog/internal/qso"
+)
+
+// The Distance column was published empty for every QSO logged in OpsLog: the
+// stored DISTANCE field is only ever filled by an ADIF import that carried one,
+// and nothing computes it when logging. It falls back to the two locators.
+func TestDistanceFallsBackToTheGrids(t *testing.T) {
+	// JN36 (French Alps) to IO91 (southern England): a few hundred kilometres.
+	got := distanceKm(&qso.QSO{MyGrid: "JN36DG", Grid: "IO91"})
+	if got == "" {
+		t.Fatal("no distance from two perfectly good locators")
+	}
+	if got == "0" {
+		t.Errorf("distance = %q", got)
+	}
+}
+
+// A stored distance wins: it came from the log that recorded the QSO, which knew
+// more than two four-character squares do.
+func TestStoredDistanceWins(t *testing.T) {
+	d := 1234.0
+	if got := distanceKm(&qso.QSO{Distance: &d, MyGrid: "JN36", Grid: "IO91"}); got != "1234" {
+		t.Errorf("distance = %q, want the stored 1234", got)
+	}
+}
+
+// No grids, no invention. An empty cell is honest; a zero is a claim.
+func TestNoGridsNoDistance(t *testing.T) {
+	for _, q := range []qso.QSO{{}, {MyGrid: "JN36"}, {Grid: "IO91"}, {MyGrid: "??", Grid: "IO91"}} {
+		if got := distanceKm(&q); got != "" {
+			t.Errorf("distance(%+v) = %q, want empty", q, got)
+		}
+	}
+}

internal/webpub/webpub_test.go

@@ -0,0 +1,49 @@
+package webpub
+
+import (
+	"strings"
+	"testing"
+	"time"
+
+	"hamlog/internal/qso"
+)
+
+// The published page carries its own sort script, so a regression there is
+// silent: the table still renders, it just sorts wrongly. These pin the two
+// things that were actually broken in the field.
+
+func renderSample(t *testing.T) string {
+	t.Helper()
+	cfg := Config{Columns: []string{"qso_date", "callsign", "freq"}}
+	cfg.Normalise()
+	qsos := []qso.QSO{
+		{Callsign: "8B81SU", QSODate: time.Date(2026, 8, 10, 9, 56, 0, 0, time.UTC)},
+		{Callsign: "LZ8NG", QSODate: time.Date(2025, 12, 31, 23, 1, 0, 0, time.UTC)},
+	}
+	return string(renderHTML(cfg, columnsFor(cfg.Columns), qsos, "F4BPO"))
+}
+
+// A third click restores the published order, which is only possible if each row
+// remembers where it started.
+func TestRowsCarryTheirPublishedIndex(t *testing.T) {
+	html := renderSample(t)
+	for _, want := range []string{`<tr data-i="0">`, `<tr data-i="1">`} {
+		if !strings.Contains(html, want) {
+			t.Errorf("published page is missing %s — the reset-to-original click cannot work", want)
+		}
+	}
+}
+
+// parseFloat accepts a numeric PREFIX, so "2026-08-10" became 2026 and every
+// date in the same year compared equal: the Date column looked unsortable.
+// Callsigns starting with a digit ("8B81SU") hit the same trap. The whole cell
+// must match for a numeric comparison to be used.
+func TestSortScriptRejectsNumericPrefixes(t *testing.T) {
+	html := renderSample(t)
+	if !strings.Contains(html, `var NUM=/^[+-]?\d+(\.\d+)?$/;`) {
+		t.Error("the anchored numeric test is gone; a bare parseFloat makes dates and 8-prefixed calls sort as equal")
+	}
+	if strings.Contains(html, "n=!isNaN(nx)&&!isNaN(ny)") {
+		t.Error("the old prefix-tolerant numeric detection is back")
+	}
+}

main.go

@@ -67,6 +67,17 @@ func acquireInstance(postUpdate bool) bool {
 	return false
 }
 
+// processStart is stamped on the very first instruction of main, before the
+// single-instance guard and before anything else runs.
+//
+// It exists to split a slow launch in two, because the log alone could not: the
+// first line applog writes already sits inside startup(), so everything spent
+// loading the binary and creating the WebView2 environment happened before the
+// log begins and was invisible. An operator reporting "nothing happens for three
+// seconds" was impossible to answer from a file whose first timestamp is the
+// moment the app was already running.
+var processStart = time.Now()
+
 func main() {
 	// Single-instance guard: if OpsLog is already running, focus that window and
 	// exit instead of spawning a duplicate. A second process would open its own

telemetry.go

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

webpublish.go

@@ -0,0 +1,229 @@
+package main
+
+// Web publishing — the Wails boundary for internal/webpub, plus the scheduling.
+//
+// Two triggers, deliberately: a QSO is logged, or the periodic timer fires.
+// Both go through publishSoon, which DEBOUNCES: a run of contacts must not
+// produce one FTP session per QSO, and a page that is fifteen seconds stale is
+// indistinguishable from a live one to anybody reading it on the web.
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+	"sync"
+	"time"
+
+	"hamlog/internal/applog"
+	"hamlog/internal/qso"
+	"hamlog/internal/webpub"
+
+	wruntime "github.com/wailsapp/wails/v2/pkg/runtime"
+)
+
+// publishDebounce is how long a publish request waits for company. Long enough
+// to fold a burst of logging into one upload, short enough that the page looks
+// live to a reader who just heard you on the air.
+const publishDebounce = 15 * time.Second
+
+type webPublisher struct {
+	mu      sync.Mutex
+	timer   *time.Timer
+	ticker  *time.Ticker
+	tickStp chan struct{}
+	last    time.Time
+	lastErr string
+}
+
+// WebPublishStatus is what the settings panel shows under the buttons.
+//
+// No column list here: the panel gets that from WebPublishColumns(). An
+// anonymous struct in a bound type also breaks the Wails generator, which has
+// no name to emit for it.
+type WebPublishStatus struct {
+	LastRun string `json:"last_run"` // "" = never this session
+	LastErr string `json:"last_err"`
+}
+
+// GetWebPublishConfig reads the stored configuration (defaults applied).
+func (a *App) GetWebPublishConfig() (webpub.Config, error) {
+	var cfg webpub.Config
+	if a.settings == nil {
+		cfg.Normalise()
+		return cfg, fmt.Errorf("db not initialized")
+	}
+	raw, err := a.settings.Get(a.ctx, keyWebPublish)
+	if err == nil && strings.TrimSpace(raw) != "" {
+		// A locked vault hands back "" rather than ciphertext — that reads as "not
+		// configured", which is exactly right here: publishing must not run with a
+		// password we cannot decrypt.
+		_ = json.Unmarshal([]byte(raw), &cfg)
+	}
+	cfg.Normalise()
+	return cfg, nil
+}
+
+// SaveWebPublishConfig persists it and restarts the periodic timer.
+func (a *App) SaveWebPublishConfig(cfg webpub.Config) error {
+	if a.settings == nil {
+		return fmt.Errorf("db not initialized")
+	}
+	cfg.Normalise()
+	b, err := json.Marshal(cfg)
+	if err != nil {
+		return err
+	}
+	if err := a.settings.Set(a.ctx, keyWebPublish, string(b)); err != nil {
+		return err
+	}
+	a.restartWebPublishTimer()
+	return nil
+}
+
+// WebPublishColumns lists the offered columns for the picker.
+func (a *App) WebPublishColumns() []map[string]string {
+	cols := webpub.KnownColumnKeys()
+	out := make([]map[string]string, 0, len(cols))
+	for _, c := range cols {
+		out = append(out, map[string]string{"key": c.Key, "header": c.Header})
+	}
+	return out
+}
+
+// TestWebPublishFTP validates the server settings without uploading anything.
+func (a *App) TestWebPublishFTP(cfg webpub.Config) (string, error) {
+	return webpub.Test(cfg)
+}
+
+// PublishLogNow renders and publishes immediately, ignoring the debounce, and
+// reports what happened. This is the "Publish now" button: the operator is
+// waiting on the answer, so it runs synchronously and returns the real error.
+func (a *App) PublishLogNow() (string, error) {
+	cfg, _ := a.GetWebPublishConfig()
+	return a.publish(cfg)
+}
+
+// publish does the work: read the QSOs, render, write locally, then upload.
+//
+// Local FIRST and upload second, always. A network failure then leaves a good
+// file on disk that the operator can publish another way, instead of a
+// truncated one on the server.
+func (a *App) publish(cfg webpub.Config) (string, error) {
+	if a.qso == nil {
+		return "", fmt.Errorf("logbook not ready")
+	}
+	cfg.Normalise()
+	qsos, err := a.qso.List(a.ctx, qso.ListFilter{Limit: cfg.Count})
+	if err != nil {
+		return "", fmt.Errorf("read the log: %w", err)
+	}
+	station := ""
+	if p, perr := a.profiles.Active(a.ctx); perr == nil {
+		station = p.Callsign
+	}
+	data, err := webpub.Render(cfg, qsos, station)
+	if err != nil {
+		return "", fmt.Errorf("build the page: %w", err)
+	}
+	path, err := webpub.WriteLocal(cfg, data)
+	if err != nil {
+		return "", err
+	}
+	msg := fmt.Sprintf("%d QSO → %s", len(qsos), path)
+	if cfg.FTPEnabled {
+		if err := webpub.Upload(cfg, data); err != nil {
+			// The local file IS written — say so, so the operator knows the failure
+			// is the transfer and not the export.
+			return msg, fmt.Errorf("written locally, but the upload failed: %w", err)
+		}
+		msg += fmt.Sprintf(" → ftp://%s/%s", cfg.FTPHost, strings.TrimPrefix(cfg.FTPFolder+"/"+cfg.FTPFileName, "/"))
+	}
+	return msg, nil
+}
+
+// publishSoon schedules a debounced publish. Called on every logged QSO.
+func (a *App) publishSoon() {
+	cfg, _ := a.GetWebPublishConfig()
+	if !cfg.Enabled {
+		return
+	}
+	a.webpub.mu.Lock()
+	defer a.webpub.mu.Unlock()
+	if a.webpub.timer != nil {
+		a.webpub.timer.Stop()
+	}
+	a.webpub.timer = time.AfterFunc(publishDebounce, a.publishNowBackground)
+}
+
+// publishNowBackground runs a scheduled publish and records the outcome for the
+// settings panel. Never surfaces a dialog: this fires while the operator is
+// working, and a web server that is down must not interrupt logging.
+func (a *App) publishNowBackground() {
+	cfg, _ := a.GetWebPublishConfig()
+	if !cfg.Enabled {
+		return
+	}
+	msg, err := a.publish(cfg)
+	a.webpub.mu.Lock()
+	a.webpub.last = time.Now()
+	if err != nil {
+		a.webpub.lastErr = err.Error()
+	} else {
+		a.webpub.lastErr = ""
+	}
+	a.webpub.mu.Unlock()
+	if err != nil {
+		applog.Printf("webpublish: %v", err)
+	} else {
+		applog.Printf("webpublish: %s", msg)
+	}
+	if a.ctx != nil {
+		wruntime.EventsEmit(a.ctx, "webpublish:done", msg)
+	}
+}
+
+// GetWebPublishStatus reports the last run for the settings panel.
+func (a *App) GetWebPublishStatus() WebPublishStatus {
+	var st WebPublishStatus
+	a.webpub.mu.Lock()
+	if !a.webpub.last.IsZero() {
+		st.LastRun = a.webpub.last.UTC().Format("2006-01-02 15:04:05") + " UTC"
+	}
+	st.LastErr = a.webpub.lastErr
+	a.webpub.mu.Unlock()
+	return st
+}
+
+// restartWebPublishTimer (re)arms the periodic refresh from the saved interval.
+// Stopped and rebuilt on every save, so a changed interval takes effect at once
+// rather than after the old one has fired.
+func (a *App) restartWebPublishTimer() {
+	a.webpub.mu.Lock()
+	if a.webpub.tickStp != nil {
+		close(a.webpub.tickStp)
+		a.webpub.tickStp = nil
+	}
+	a.webpub.mu.Unlock()
+
+	cfg, _ := a.GetWebPublishConfig()
+	if !cfg.Enabled || cfg.IntervalMin <= 0 {
+		return
+	}
+	stop := make(chan struct{})
+	a.webpub.mu.Lock()
+	a.webpub.tickStp = stop
+	a.webpub.mu.Unlock()
+
+	go func(every time.Duration) {
+		t := time.NewTicker(every)
+		defer t.Stop()
+		for {
+			select {
+			case <-stop:
+				return
+			case <-t.C:
+				a.publishNowBackground()
+			}
+		}
+	}(time.Duration(cfg.IntervalMin) * time.Minute)
+}