update

N0CALL is what WSJT-X transmits under when its owner never set a callsign. It
has a letter, a digit and an ordinary shape, so nothing rejected it: it was
spotted, coloured, counted as a new WPX prefix, and now that CQ grids are read
it would have put a grid into the worked index under a callsign nobody holds.

The obvious fix - adding it to looksLikeCall's reject list - was wrong, and the
test caught it before it shipped. That function answers "could this token be a
callsign at all", and the CQ grammar uses it to decide whether the word after CQ
is a modifier (DX, NA, a zone) or the call itself. Teaching it that N0CALL is
not a callsign made "CQ N0CALL JN36" skip a slot and return JN36. Shape and
policy are different questions and now live in different functions.

Chasing that turned up the real defect behind it: ANY unrecognised word after CQ
made the parser skip a slot, and a four-character grid passes every shape test a
callsign does. "CQ FOO JN36" returned JN36 as the sender - logged, spotted and
coloured as a station. A grid in the callsign slot is now refused outright.

app.go

@@ -11,6 +11,7 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"runtime"
 	"runtime/debug"
 	"sort"
 	"strconv"
@@ -293,6 +294,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
@@ -535,6 +541,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.
@@ -589,6 +597,18 @@ 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
 	// 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
@@ -688,6 +708,9 @@ type App struct {
 	awardSnapMu        sync.Mutex    // guards the award QSO snapshot
 	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
@@ -941,7 +964,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
@@ -1235,6 +1263,8 @@ func (a *App) startup(ctx context.Context) {
 	// behind telnet).
 	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
@@ -1380,6 +1410,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.
@@ -2461,6 +2495,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
@@ -2636,6 +2683,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)
@@ -2652,6 +2716,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))
 			}
@@ -2979,6 +3044,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 == "" {
@@ -4172,6 +4240,7 @@ func (a *App) awardSnapshot() ([]qso.QSO, error) {
 		a.awardSnapMu.Lock()
 		if a.awardSnap != nil && a.awardSnapRev == rev {
 			qs := a.awardSnap
+			a.awardSnapUsed = time.Now()
 			a.awardSnapMu.Unlock()
 			return qs, nil
 		}
@@ -4187,18 +4256,63 @@ func (a *App) awardSnapshot() ([]qso.QSO, error) {
 	}); err != nil {
 		return nil, err
 	}
-	applog.Printf("awardSnapshot: pulled %d qsos from logbook in %v (rev=%s)",
+	// Heap alongside the row count: this snapshot is the single largest thing
-		len(all), time.Since(t0).Round(time.Millisecond), rev)
+	// OpsLog holds, and "OpsLog is eating memory" reports are unanswerable
+	// without a number. A 132 000-QSO logbook was the case that prompted it.
+	var ms runtime.MemStats
+	runtime.ReadMemStats(&ms)
+	applog.Printf("awardSnapshot: pulled %d qsos from logbook in %v (rev=%s) — go heap now %d MB",
+		len(all), time.Since(t0).Round(time.Millisecond), rev, ms.HeapAlloc/(1024*1024))
 
 	if revErr == nil {
 		a.awardSnapMu.Lock()
 		a.awardSnap = all
 		a.awardSnapRev = rev
+		a.awardSnapUsed = time.Now()
 		a.awardSnapMu.Unlock()
 	}
 	return all, nil
 }
 
+// awardSnapIdleTTL is how long the snapshot survives without a reader.
+//
+// Generous on purpose: an operator working through the Awards panel triggers a
+// computation every few seconds, and re-pulling costs seconds on a big remote
+// logbook. This is only meant to catch the far commoner case — awards looked at
+// once, then hours of logging with several hundred megabytes still held.
+const awardSnapIdleTTL = 15 * time.Minute
+
+// awardSnapshotJanitor drops the award snapshot once nothing has read it for a
+// while, and returns the memory to the OS.
+//
+// The snapshot is a whole logbook of QSO structs, each carrying a decoded map of
+// its ADIF extras: ~1.9 KB of struct plus strings and one map allocation per
+// QSO. At 30 000 QSOs that is tens of megabytes and nobody notices; at 132 000
+// it is several hundred, held for the rest of the session because the cache had
+// no expiry — only invalidation when the logbook changed.
+func (a *App) awardSnapshotJanitor() {
+	for {
+		time.Sleep(time.Minute)
+		a.awardSnapMu.Lock()
+		n := len(a.awardSnap)
+		idle := !a.awardSnapUsed.IsZero() && time.Since(a.awardSnapUsed) > awardSnapIdleTTL
+		if a.awardSnap != nil && idle {
+			a.awardSnap = nil
+			a.awardSnapRev = ""
+		}
+		a.awardSnapMu.Unlock()
+		if n > 0 && idle {
+			// FreeOSMemory, not just GC: Go hands pages back lazily, and the whole
+			// point here is that the operator sees the memory come back.
+			debug.FreeOSMemory()
+			var ms runtime.MemStats
+			runtime.ReadMemStats(&ms)
+			applog.Printf("awardSnapshot: released %d cached qsos after %v idle — go heap now %d MB",
+				n, awardSnapIdleTTL, ms.HeapAlloc/(1024*1024))
+		}
+	}
+}
+
 // GetAwardStats computes the worked/confirmed/validated reference counts of one
 // award, broken down by band and by mode category (All/CW/Digital/Phone).
 func (a *App) GetAwardStats(code string) (AwardStatsResult, error) {
@@ -7767,6 +7881,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
@@ -11655,6 +11773,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…).
@@ -11693,6 +11812,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.
@@ -13346,6 +13478,7 @@ func (a *App) GetStationSettings() (StationSettings, error) {
 		MyCountry: p.MyCountry,
 		MySOTARef: p.MySOTARef,
 		MyPOTARef: p.MyPOTARef,
+		MyIOTA:    p.MyIOTA,
 	}, nil
 }
 
@@ -13443,6 +13576,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)
 }
 
@@ -16292,6 +16429,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:
@@ -16318,13 +16459,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
@@ -16340,9 +16507,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
@@ -16352,12 +16521,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
@@ -16397,13 +16567,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
@@ -16447,6 +16621,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
@@ -16477,10 +16666,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

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] }

bandopening.go

@@ -0,0 +1,82 @@
+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"
+
+	"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
+}
+
+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.bandOpen.last = append([]bandopen.Opening{*op}, a.bandOpen.last...)
+		if len(a.bandOpen.last) > maxRememberedOpenings {
+			a.bandOpen.last = a.bandOpen.last[:maxRememberedOpenings]
+		}
+	}
+	a.bandOpen.mu.Unlock()
+	if op == nil {
+		return
+	}
+
+	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
+}

changelog.json

@@ -1,4 +1,88 @@
 [
+  {
+    "version": "0.24.5",
+    "date": "",
+    "en": [
+      "Digital decodes: a station's grid square could be logged as its callsign. An unrecognised word after CQ made the parser skip a slot, and a four-character grid passes every shape test a callsign does, so \"CQ FOO JN36\" was read as a contact with JN36 — spotted, coloured and counted like any other station. A grid in the callsign position is now refused."
+    ],
+    "fr": [
+      "Décodes digitaux : le carré locator d une station pouvait être enregistré comme son indicatif. Un mot non reconnu après CQ faisait sauter un cran au parseur, et un grid de quatre caractères passe tous les tests de forme d un indicatif — « CQ FOO JN36 » était donc lu comme un contact avec JN36, spotté, coloré et compté comme n importe quelle autre station. Un grid à la place de l indicatif est maintenant refusé."
+    ]
+  },
+  {
+    "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": "",
+    "en": [
+      "Recent QSOs: the Max box can be lowered again. It could not be emptied — clearing it put the old number straight back — so going from a large figure down to a small one was a fight against the field, and looked like the setting refusing to stick. Type freely now and press Enter (or click away) to apply. The value was already saved and travels with your data folder; only the box was in the way.",
+      "Memory: the awards cache is given back once you stop using it. Opening the Awards panel loads the whole logbook into memory and kept it there for the rest of the session — a few tens of megabytes on a small log, but several hundred on a large one, and it was never released because the cache only expired when the logbook changed. It is now dropped after fifteen minutes without use, and the memory returned to Windows. Fifteen minutes on purpose: working through your awards keeps it warm, since reloading a large log takes seconds. The log also records the heap size each time the cache is built or released, so a memory report can be answered with a figure instead of a guess.",
+      "Performance: the DX-cluster console no longer drags the whole interface down. Every line of traffic — spots, MOTD, everything — was applied to the screen one at a time, and an RBN feed alone sends hundreds a second: that meant two copies of a 2000-line buffer and a redraw for each one, whether the console was open or not. Lines are now grouped and applied five times a second. The difference is most visible on an older PC, where this alone could make the app crawl.",
+      "Update: \"stage current exe: … Accès refusé\" is fixed. Two causes, both handled. The previous build was always staged under the same name, so one leftover that could not be deleted — an antivirus holding it open is the usual reason — blocked every later update, permanently, with no way out but deleting the file by hand; the staging name is now unique. And when the running program cannot be renamed at all, which some endpoint protection deliberately prevents, OpsLog no longer gives up: it leaves the new build beside the old one and swaps them after closing, when its own file is an ordinary file again. If even that fails, OpsLog restarts on the current version rather than leaving you with nothing, and the download is kept for the next attempt.",
+      "Band map: the width can be dragged. Both the map docked beside the tables and the per-band cards in the Band map tab were locked at a fixed width, so an operator watching a busy band could not give the map more room — nor take it back for the log. Grab the edge to resize, double-click it to go back to the default. The width is remembered and travels with your data folder, like the other layout settings. In the tab, one width applies to every card: they sit side by side, and columns of different widths read as a mistake."
+    ],
+    "fr": [
+      "QSO récents : la case Max se laisse enfin baisser. Impossible de la vider — l'effacer y remettait aussitôt l'ancien nombre — donc passer d'un grand chiffre à un petit était un combat contre le champ, et donnait l'impression que le réglage ne tenait pas. Tape librement puis Entrée (ou clique ailleurs) pour appliquer. La valeur était déjà enregistrée et voyage avec ton dossier de données ; c'était la case qui bloquait.",
+      "Mémoire : le cache des diplômes est rendu quand tu ne t'en sers plus. Ouvrir le panneau Diplômes charge tout le journal en mémoire et l'y gardait jusqu'à la fermeture — quelques dizaines de Mo sur un petit journal, plusieurs centaines sur un gros, et jamais libérés puisque le cache n'expirait qu'au changement du journal. Il est désormais abandonné après quinze minutes sans usage, et la mémoire rendue à Windows. Quinze minutes volontairement : parcourir tes diplômes le garde chaud, recharger un gros journal coûtant plusieurs secondes. Le journal technique note aussi la taille du tas à chaque construction ou libération, pour qu'un signalement de mémoire se réponde avec un chiffre plutôt qu'une supposition.",
+      "Performance : la console du cluster DX ne plombe plus toute l'interface. Chaque ligne de trafic — spots, MOTD, tout — était appliquée à l'écran une par une, et un flux RBN en envoie à lui seul des centaines par seconde : cela faisait deux copies d'un tampon de 2000 lignes et un redessin pour chacune, que la console soit ouverte ou non. Les lignes sont désormais groupées et appliquées cinq fois par seconde. La différence se voit surtout sur un PC ancien, où cela suffisait à faire ramer l'application.",
+      "Mise à jour : le « stage current exe : … Accès refusé » est corrigé. Deux causes, traitées toutes les deux. L'ancienne version était toujours mise de côté sous le même nom : un seul reliquat impossible à supprimer — un antivirus qui le garde ouvert, le plus souvent — bloquait définitivement toutes les mises à jour suivantes, sans autre issue que d'effacer le fichier à la main ; ce nom est désormais unique. Et quand le programme en cours d'exécution ne peut pas être renommé du tout, ce que certaines protections empêchent volontairement, OpsLog n'abandonne plus : il laisse la nouvelle version à côté de l'ancienne et les échange après sa fermeture, quand son propre fichier redevient un fichier ordinaire. Si même cela échoue, OpsLog redémarre sur la version actuelle plutôt que de te laisser sans rien, et le téléchargement est conservé pour la prochaine tentative.",
+      "Band map : la largeur se règle à la souris. La carte ancrée à côté des tableaux et les cartes par bande de l'onglet Band map étaient figées à une largeur fixe : impossible de donner plus de place à la carte sur une bande chargée, ni de la reprendre pour le journal. Attrape le bord pour redimensionner, double-clic pour revenir au défaut. La largeur est mémorisée et voyage avec ton dossier de données, comme les autres réglages de disposition. Dans l'onglet, une seule largeur vaut pour toutes les cartes : elles sont côte à côte, et des colonnes de largeurs différentes se lisent comme une erreur."
+    ]
+  },
   {
     "version": "0.24.0",
     "date": "",

frontend/src/App.tsx

@@ -89,6 +89,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';
@@ -907,6 +908,49 @@ export default function App() {
     return Number.isFinite(n) && n >= 15 && n <= 85 ? n : 50;
   });
   useEffect(() => { writeUiPref('opslog.mainSplit', String(Math.round(mainSplit))); }, [mainSplit]);
+
+  // Band-map widths. Two of them, because they are two different things: the
+  // docked map sits beside the tables and competes with them for room, while
+  // the cards in the Band map tab share a scrolling row and want to be uniform.
+  // Both were hardcoded — 300px and 260px — so an operator watching a busy band
+  // could not give the map the space it needed, nor claw it back for the log.
+  const BANDMAP_W_DEFAULT = 300, BANDMAP_W_MIN = 200, BANDMAP_W_MAX = 900;
+  const BANDMAP_TAB_W_DEFAULT = 260, BANDMAP_TAB_W_MIN = 160, BANDMAP_TAB_W_MAX = 700;
+  const readWidth = (key: string, def: number, min: number, max: number) => {
+    const n = parseFloat(localStorage.getItem(key) || '');
+    return Number.isFinite(n) && n >= min && n <= max ? n : def;
+  };
+  const [bandMapWidth, setBandMapWidth] = useState<number>(
+    () => readWidth('opslog.bandMapWidth', BANDMAP_W_DEFAULT, BANDMAP_W_MIN, BANDMAP_W_MAX));
+  const [bandMapTabWidth, setBandMapTabWidth] = useState<number>(
+    () => readWidth('opslog.bandMapTabWidth', BANDMAP_TAB_W_DEFAULT, BANDMAP_TAB_W_MIN, BANDMAP_TAB_W_MAX));
+  useEffect(() => { writeUiPref('opslog.bandMapWidth', String(Math.round(bandMapWidth))); }, [bandMapWidth]);
+  useEffect(() => { writeUiPref('opslog.bandMapTabWidth', String(Math.round(bandMapTabWidth))); }, [bandMapTabWidth]);
+
+  // Drag one edge of a fixed-width column. Measures from the pointer's START
+  // position rather than the container, so it behaves the same whether the grip
+  // is on the left or the right edge — the docked map is docked on either side.
+  const startWidthDrag = (
+    e: React.PointerEvent, current: number, edge: 'left' | 'right',
+    min: number, max: number, apply: (w: number) => void,
+  ) => {
+    e.preventDefault();
+    // Pointer capture, for the same reason as the main splitter: without it a
+    // map or a grid under the cursor swallows the moves.
+    (e.currentTarget as HTMLElement).setPointerCapture(e.pointerId);
+    const x0 = e.clientX;
+    const onMove = (ev: PointerEvent) => {
+      const delta = edge === 'right' ? ev.clientX - x0 : x0 - ev.clientX;
+      apply(Math.min(max, Math.max(min, Math.round(current + delta))));
+    };
+    const onUp = () => {
+      window.removeEventListener('pointermove', onMove);
+      window.removeEventListener('pointerup', onUp);
+    };
+    window.addEventListener('pointermove', onMove);
+    window.addEventListener('pointerup', onUp);
+  };
+
   const mainSplitRef = useRef<HTMLDivElement | null>(null);
   const startMainSplitDrag = (e: React.PointerEvent) => {
     e.preventDefault();
@@ -957,6 +1001,19 @@ export default function App() {
     return Number.isFinite(raw) && raw > 0 ? raw : 500;
   });
   useEffect(() => { writeUiPref('hamlog.qsoLimit', String(qsoLimit)); }, [qsoLimit]);
+  // Raw text for the Max box, committed on blur/Enter — never per keystroke.
+  // Bound straight to the number, the field could not be EMPTIED: clearing it
+  // gives "", Number("") is 0, 0 fails the "> 0" test, so the state never moved
+  // and value={qsoLimit} snapped the old number straight back. Going from 200000
+  // to 100 was a fight against the input, and looked like the setting refusing
+  // to stick. It also wrote the preference once per keystroke (1, 10, 100).
+  const [qsoLimitText, setQsoLimitText] = useState(String(qsoLimit));
+  useEffect(() => { setQsoLimitText(String(qsoLimit)); }, [qsoLimit]);
+  const commitQsoLimit = () => {
+    const n = Math.floor(Number(qsoLimitText));
+    if (Number.isFinite(n) && n > 0) setQsoLimit(n);
+    else setQsoLimitText(String(qsoLimit)); // nonsense typed → put the live value back
+  };
 
   // Contest session: load once, then persist on every change (merge + save).
   useEffect(() => {
@@ -1370,14 +1427,42 @@ export default function App() {
   const [clusterLines, setClusterLines] = useState<ClusterLine[]>([]);
   const [clusterConsoleOpen, setClusterConsoleOpen] = useState(false);
   const clusterConsoleRef = useRef<HTMLDivElement | null>(null);
+  // Console lines are STAGED and flushed on a timer, never applied one by one.
+  //
+  // Every line of cluster traffic reaches this handler — spots, MOTD, WHO, the
+  // lot — and an RBN feed alone puts out hundreds a second. Committing each one
+  // meant two copies of a 2000-element array (spread, then slice) plus a React
+  // render PER LINE: tens of megabytes of garbage per second, and the renders
+  // happened even with the console closed, so an operator paid for a panel they
+  // were not looking at. On an older machine that is enough to make the whole UI
+  // crawl. Batching turns hundreds of updates a second into five.
+  const pendingLinesRef = useRef<ClusterLine[]>([]);
+  const pendingLineTimer = useRef<number | undefined>(undefined);
   useEffect(() => {
-    const off = EventsOn('cluster:line', (l: any) => {
+    const flushLines = () => {
+      pendingLineTimer.current = undefined;
+      const batch = pendingLinesRef.current;
+      if (batch.length === 0) return;
+      pendingLinesRef.current = [];
       setClusterLines((prev) => {
-        const next = [...prev, l as ClusterLine];
+        const total = prev.length + batch.length;
-        return next.length > CONSOLE_CAP ? next.slice(next.length - CONSOLE_CAP) : next;
+        return total > CONSOLE_CAP ? prev.slice(total - CONSOLE_CAP).concat(batch) : prev.concat(batch);
       });
+    };
+    const off = EventsOn('cluster:line', (l: any) => {
+      const buf = pendingLinesRef.current;
+      buf.push(l as ClusterLine);
+      // Bound the staging buffer too: a burst longer than the console can show
+      // would otherwise be carried in full just to be sliced away on commit.
+      if (buf.length > CONSOLE_CAP) buf.splice(0, buf.length - CONSOLE_CAP);
+      if (pendingLineTimer.current === undefined) {
+        pendingLineTimer.current = window.setTimeout(flushLines, 200);
+      }
     });
-    return () => { off?.(); };
+    return () => {
+      off?.();
+      if (pendingLineTimer.current !== undefined) window.clearTimeout(pendingLineTimer.current);
+    };
   }, []);
   // Follow the tail, but ONLY when already at the bottom — otherwise scrolling up
   // to read a SH/DX reply would yank you back down on the next spot.
@@ -1400,7 +1485,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).
@@ -1419,11 +1516,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 : []; }
@@ -1496,7 +1595,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);
@@ -1529,13 +1631,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 {
@@ -1546,7 +1648,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,
           };
         }
@@ -1556,23 +1658,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
+  // merge above). Kept cheap: only while something that DRAWS a spot status is on
-  // hidden marks it dirty and refreshes ONCE on next open), and debounced so a
+  // screen (a log while hidden marks it dirty and refreshes ONCE on the next
-  // fast run coalesces instead of re-scanning per QSO.
+  // open), and debounced so a fast run coalesces instead of re-scanning per QSO.
-  const clusterVisibleRef = useRef(false);
+  //
+  // "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';
+    const vis = mainPaneLeft === 'cluster' || mainPaneRight === 'cluster'
-    if (vis && !clusterVisibleRef.current && spotsDirtyRef.current) {
+      || activeTab === 'cluster' || activeTab === 'bandmap' || showBandMap;
+    if (vis && !spotsVisibleRef.current && spotsDirtyRef.current) {
       spotsDirtyRef.current = false;
       void refreshSpotStatuses();
     }
-    clusterVisibleRef.current = vis;
+    spotsVisibleRef.current = vis;
-  }, [mainPaneLeft, mainPaneRight, activeTab, refreshSpotStatuses]);
+  }, [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);
     });
@@ -1824,7 +1933,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();
@@ -1986,6 +2095,23 @@ 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;
+      const season = o.in_season ? '' : ` — ${t('bmp.openUnusual')}`;
+      showToast(`📡 ${t('bmp.openToast', {
+        band: String(o.band).toUpperCase(), n: o.calls, km: o.median_km,
+      })}${season}`);
+    });
+    return () => { off(); };
+  }, [showToast, t]);
+
   // 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(() => {
@@ -2598,7 +2724,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);
@@ -2608,6 +2734,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) {
@@ -2621,7 +2748,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,
@@ -3067,14 +3195,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 {
@@ -3088,7 +3216,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,
@@ -4568,7 +4697,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
@@ -4581,9 +4713,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];
@@ -4610,11 +4756,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>
+        <span className="text-[11px] font-semibold uppercase tracking-wider text-muted-foreground">{t('clu.filters')}</span>
-        <button type="button" onClick={toggleClusterFilters} title="Hide filters"
+        <button type="button" onClick={toggleClusterFilters} title={t('clu.hideFilters')}
           className="text-muted-foreground hover:text-foreground">
           <X className="size-3.5" />
         </button>
@@ -4623,42 +4804,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 */}
+        {/* Behaviours: each is on or off, and none of them narrows by a property
-        <div className="space-y-1.5">
+            of the station. The last two also drive the band map, via
-          <label className="flex items-center gap-1.5 cursor-pointer">
+            lib/spotDisplay — they live here rather than in Preferences because
-            <Checkbox checked={clusterHideWorked} onCheckedChange={(c) => setClusterHideWorked(!!c)} />
+            they are changed while working a run. */}
-            Hide worked
+        <div className="space-y-0.5">
-          </label>
+          {fSwitch(t('clu.hideWorked'), clusterHideWorked, setClusterHideWorked)}
-          <label className="flex items-center gap-1.5 cursor-pointer">
+          {fSwitch(t('clu.groupDup'), clusterGroup, setClusterGroup)}
-            <Checkbox checked={clusterGroup} onCheckedChange={(c) => setClusterGroup(!!c)} />
+          {fSwitch(t('clu.muteWorkedShort'), clusterMuteWorked, (v) => { setClusterMuteWorked(v); writeUiPref('opslog.clusterMuteWorked', v ? '1' : '0'); })}
-            Group duplicates
+          {fSwitch(t('clu.slotHighlightShort'), clusterSlotHighlight, (v) => { setClusterSlotHighlight(v); writeUiPref('opslog.clusterSlotHighlight', v ? '1' : '0'); })}
-          </label>
+          {fSwitch(t('clu.lotwOnly'), clusterLotwOnly, (v) => { setClusterLotwOnly(v); writeUiPref('opslog.clusterLotwOnly', v ? '1' : '0'); })}
         </div>
 
-        {/* Band filter — multi-select listbox */}
+        {/* The SPOTTER's continent, not the DX's: this asks whether anyone near
-        <div>
+            you is hearing the band at all. Chips rather than a dropdown — seven
-          <div className="flex items-center justify-between mb-1">
+            two-letter codes fit on two lines, they read as a set the way Status
-            <span className="text-[10px] uppercase tracking-wider text-muted-foreground">Bands</span>
+            and Mode do, and several can be picked at once, which "EU or NA" needs
-            <div className="flex items-center gap-2">
+            and a dropdown cannot express. */}
-              <button
+        {fSection(t('clu.spotterCont'),
-                type="button"
+          <div className="flex flex-wrap gap-1">
-                onClick={() => setClusterLockBand((v) => !v)}
+            {['AF', 'AN', 'AS', 'EU', 'NA', 'OC', 'SA'].map((c) => fChip(
-                className={cn('inline-flex items-center gap-0.5 text-[10px] px-1 py-0.5 rounded border',
+              c, c, 'bg-muted text-foreground border-border',
-                  clusterLockBand ? 'bg-warning-muted text-warning-muted-foreground border-warning-border' : 'text-muted-foreground border-border hover:bg-muted')}
+              clusterSpotterConts.has(c),
-                title="Lock to the entry strip's current band"
+              () => setClusterSpotterConts((cur) => {
-              >
+                const n = new Set(cur);
-                {clusterLockBand ? <Lock className="size-2.5" /> : <Unlock className="size-2.5" />} {band}
+                if (n.has(c)) n.delete(c); else n.add(c);
-              </button>
+                return n;
-              {clusterBands.size > 0 && (
+              }),
-                <button type="button" onClick={() => setClusterBands(new Set())} className="text-[10px] text-muted-foreground hover:text-foreground underline">clear</button>
+            ))}
+          </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);
@@ -4674,83 +4861,82 @@ export default function App() {
                 </button>
               );
             })}
-          </div>
+          </div>,
-        </div>
+          <div className="flex items-center gap-2">
-
-        {/* Mode lock */}
               <button
                 type="button"
-          onClick={() => setClusterLockMode((v) => !v)}
+                onClick={() => setClusterLockBand((v) => !v)}
-          className={cn('inline-flex items-center gap-1 px-1.5 py-0.5 rounded border text-[10px]',
+                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')}
+                  clusterLockBand ? '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"
+                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>
+        {fSection(t('clu.status'),
-          <div className="text-[10px] uppercase tracking-wider text-muted-foreground mb-1">Status</div>
           <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) => {
+            ]).map((s) => fChip(s.k, s.label, s.cls, clusterStatusFilter.has(s.k),
-              const on = 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; })))}
-              return (
+          </div>,
-                <button key={s.k} type="button"
+          clusterStatusFilter.size > 0 ? (
-                  onClick={() => setClusterStatusFilter((cur) => { const n = new Set(cur); if (n.has(s.k)) n.delete(s.k); else n.add(s.k); return n; })}
+            <button type="button" onClick={() => setClusterStatusFilter(new Set())}
-                  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`)}>
+              className="text-[10px] text-muted-foreground hover:text-foreground underline">{t('clu.clear')}</button>
-                  {s.label}
+          ) : undefined,
-                </button>
+        )}
-              );
-            })}
-          </div>
-        </div>
 
         {/* Mode filter */}
-        <div>
+        {fSection(t('clu.mode'),
-          <div className="text-[10px] uppercase tracking-wider text-muted-foreground mb-1">Mode</div>
           <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) => {
+            ]).map((s) => fChip(s.k, s.label, s.cls, clusterModeFilter.has(s.k),
-              const on = 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; })))}
-              return (
+          </div>,
-                <button key={s.k} type="button"
+          <button type="button" onClick={() => setClusterLockMode((v) => !v)}
-                  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('inline-flex items-center gap-0.5 text-[10px] px-1 py-0.5 rounded border',
-                  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`)}>
+              clusterLockMode ? 'bg-warning-muted text-warning-muted-foreground border-warning-border' : 'text-muted-foreground border-border hover:bg-muted')}
-                  {s.label}
+            title={t('clu.lockModeTitle')}>
-                </button>
+            {clusterLockMode ? <Lock className="size-2.5" /> : <Unlock className="size-2.5" />} {mode}
-              );
+          </button>,
-            })}
+        )}
-          </div>
-        </div>
 
         {/* Source */}
-        <div>
+        {fSection(t('clu.source'),
-          <div className="text-[10px] uppercase tracking-wider text-muted-foreground mb-1">Source</div>
           <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>
+          </Select>,
-        </div>
+        )}
       </div>
     </div>
   );
@@ -5948,9 +6134,15 @@ export default function App() {
 
       {/* ===== LOWER: tabbed table / cluster / band map ===== */}
       {compact ? null : <>
-      <div className={cn('grid gap-2.5 p-2.5 flex-1 min-h-0 grid-rows-[minmax(0,1fr)]',
+      {/* The band map is a fixed-width column with a draggable grip on its inner
-        showBandMap ? (bandMapSide === 'left' ? 'grid-cols-[300px_1fr]' : 'grid-cols-[1fr_300px]') : 'grid-cols-[1fr]')}>
+          edge — the gap between the two panes doubles as the handle, so no room
-        <section className="bg-card border border-border rounded-lg shadow-sm flex flex-col min-h-0 overflow-hidden">
+          is spent on it. Same idiom as the Main tab's splitter. */}
+      <div className={cn('grid gap-0 p-2.5 flex-1 min-h-0 grid-rows-[minmax(0,1fr)]', !showBandMap && 'grid-cols-[1fr]')}
+        style={showBandMap
+          ? { gridTemplateColumns: bandMapSide === 'left' ? `${bandMapWidth}px 10px 1fr` : `1fr 10px ${bandMapWidth}px` }
+          : undefined}>
+        <section className={cn('bg-card border border-border rounded-lg shadow-sm flex flex-col min-h-0 overflow-hidden',
+          showBandMap && (bandMapSide === 'left' ? 'order-3' : 'order-1'))}>
           <Tabs value={activeTab} onValueChange={setActiveTab} className="flex flex-col min-h-0 flex-1">
             <TabsList className="px-3 shrink-0">
               <TabsTrigger value="main">{t('tab.main')}</TabsTrigger>
@@ -6209,11 +6401,11 @@ export default function App() {
                     min={1}
                     step={100}
                     className="w-24 h-7 font-mono text-xs"
-                    value={qsoLimit}
+                    value={qsoLimitText}
-                    onChange={(e) => {
+                    onChange={(e) => setQsoLimitText(e.target.value)}
-                      const n = Number(e.target.value);
+                    onBlur={commitQsoLimit}
-                      if (Number.isFinite(n) && n > 0) setQsoLimit(Math.floor(n));
+                    onKeyDown={(e) => { if (e.key === 'Enter') (e.target as HTMLInputElement).blur(); }}
-                    }}
+                    title="Rows loaded into the list — press Enter to apply"
                   />
                   <Button
                     variant="ghost"
@@ -6522,7 +6714,23 @@ export default function App() {
                     Pick one or more bands above to show their band maps side by side.
                   </div>
                 ) : bandMapBands.map((b) => (
-                  <div key={b} className="w-[260px] shrink-0 min-h-0 border border-border rounded-lg overflow-hidden flex flex-col">
+                  <div key={b} className="relative shrink-0 min-h-0 border border-border rounded-lg overflow-hidden flex flex-col"
+                    style={{ width: bandMapTabWidth }}>
+                    {/* One width for every card: they sit side by side in a
+                        scrolling row, and columns of different widths read as a
+                        mistake rather than a choice. Grip on the right edge. */}
+                    <div
+                      role="separator"
+                      aria-orientation="vertical"
+                      title={t('bmp.widthTip')}
+                      onPointerDown={(e) => startWidthDrag(
+                        e, bandMapTabWidth, 'right',
+                        BANDMAP_TAB_W_MIN, BANDMAP_TAB_W_MAX, setBandMapTabWidth)}
+                      onDoubleClick={() => setBandMapTabWidth(BANDMAP_TAB_W_DEFAULT)}
+                      className="group absolute inset-y-0 right-0 z-10 w-2 cursor-col-resize flex items-center justify-center"
+                    >
+                      <span className="h-10 w-[3px] rounded-full bg-transparent group-hover:bg-primary transition-colors" />
+                    </div>
                     <BandMap
                       band={b}
                       spots={spots.filter((s) => s.band === b)}
@@ -6541,7 +6749,22 @@ export default function App() {
         </section>
 
         {showBandMap && (
-          <div className={cn('bg-card border border-border rounded-lg shadow-sm flex flex-col min-h-0 overflow-hidden', bandMapSide === 'left' && 'order-first')}>
+          <div
+            role="separator"
+            aria-orientation="vertical"
+            title={t('bmp.widthTip')}
+            onPointerDown={(e) => startWidthDrag(
+              e, bandMapWidth, bandMapSide === 'left' ? 'right' : 'left',
+              BANDMAP_W_MIN, BANDMAP_W_MAX, setBandMapWidth)}
+            onDoubleClick={() => setBandMapWidth(BANDMAP_W_DEFAULT)}
+            className="group relative order-2 cursor-col-resize flex items-center justify-center"
+          >
+            <span className="h-10 w-[3px] rounded-full bg-border group-hover:bg-primary transition-colors" />
+          </div>
+        )}
+        {showBandMap && (
+          <div className={cn('bg-card border border-border rounded-lg shadow-sm flex flex-col min-h-0 overflow-hidden',
+            bandMapSide === 'left' ? 'order-1' : 'order-3')}>
             <BandMap
               side={bandMapSide}
               onToggleSide={toggleBandMapSide}

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 {
+    case 'worked':   return 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',
-    };
     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 */}
+                {/* Left accent strip. With no extra marker it repeats the status
-                <span className={cn('w-1 shrink-0', style.bar)} aria-hidden />
+                    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/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
+// The pills were dropped and stay dropped: a rounded box has its own height and
-// sat off the row's baseline and the callsign inside it no longer lined up with
+// padding, so it sat off the row's baseline and the callsign inside it no longer
-// the plain callsigns above and below. A whole column of them read as chrome
+// lined up with the plain callsigns above and below. A whole column of them read
-// rather than as data. Same reasoning — and the same semantic tokens — as the
+// as chrome rather than as data. Same reasoning — and the same semantic tokens —
-// Y/N/R QSL columns in lib/qslStatus.ts.
+// 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
+//   filled call → new DXCC    filled band → new band    filled mode → new mode
-//   blue call   → already worked
+//   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;
+  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);
+  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
+    // NEW DXCC fills the call cell. Already worked only tints the text blue:
-    // the theme's normal ink so ordinary callsigns don't shout.
+    // '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;
+      const color = s?.status === 'new' ? null : s?.worked_call ? WKD : null;
-      return <span style={{ color: color ?? undefined, fontWeight: 700 }}>{p.value ?? ''}</span>;
+      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)' });
+      // Colours from lib/spotMarkers — shared with the band map so a marker is
-      if (s?.new_pota) parts.push({ text: t('clg2.newPota'), color: 'var(--success)' });
+      // never one colour here and another there.
-      if (s?.new_pfx) parts.push({ text: t('clg2.newPfx'), color: 'var(--caution)' });
+      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.
+    // NEW BAND for this entity → the band cell is filled.
-    cellRenderer: (p: any) => cellText(p.value, statusFor(p)?.status === 'new-band' ? NEW : null),
+    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/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

@@ -61,6 +61,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 +144,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 +183,7 @@ type SectionId =
   | 'external-services'
   | 'udp'
   | 'adifmon'
+  | 'webpublish'
   | 'lookup'
   | 'lists-bands'
   | 'lists-modes'
@@ -272,6 +274,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 +292,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 +315,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',
@@ -1849,6 +1854,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 +2014,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 +4142,11 @@ 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. */}
 
           {/* 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 +6040,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/WebPublishPanel.tsx

@@ -0,0 +1,211 @@
+import { useEffect, useState } from 'react';
+import { Upload, FolderOpen, Loader2 } 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 { 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 };
+
+export function WebPublishPanel() {
+  const { t } = useI18n();
+  const [cfg, setCfg] = useState<Cfg | null>(null);
+  const [cols, setCols] = useState<Col[]>([]);
+  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">
+          <Label className="text-xs font-semibold">{t('wpub.columns')}</Label>
+          <div className="flex flex-wrap gap-1.5">
+            {cols.map((c) => {
+              const on = cfg.columns?.includes(c.key);
+              return (
+                <button key={c.key} type="button" onClick={() => toggleCol(c.key)}
+                  className={cn('px-2 py-0.5 rounded-full border text-[11px] font-medium transition-colors',
+                    on ? 'border-primary bg-primary text-primary-foreground' : 'border-border text-muted-foreground hover:bg-muted')}>
+                  {c.header}
+                </button>
+              );
+            })}
+          </div>
+          <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,10 @@ 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.
   // They are handled by lib/gridPrefs, which scopes the localStorage cache PER
   // PROFILE and mirrors to the DB (already per-profile) itself — mirroring them

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

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

@@ -10,12 +10,14 @@ 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 {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';
@@ -385,6 +387,8 @@ export function GetAwards():Promise<Array<award.Result>>;
 
 export function GetBackupSettings():Promise<main.BackupSettings>;
 
+export function GetBandOpenings():Promise<Array<bandopen.Opening>>;
+
 export function GetCATSettings():Promise<main.CATSettings>;
 
 export function GetCATState():Promise<cat.RigState>;
@@ -509,6 +513,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>;
@@ -737,6 +745,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>;
@@ -913,6 +923,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>;
@@ -1047,6 +1059,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 +1093,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

@@ -718,6 +718,10 @@ export function GetBackupSettings() {
   return window['go']['main']['App']['GetBackupSettings']();
 }
 
+export function GetBandOpenings() {
+  return window['go']['main']['App']['GetBandOpenings']();
+}
+
 export function GetCATSettings() {
   return window['go']['main']['App']['GetCATSettings']();
 }
@@ -966,6 +970,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']();
 }
@@ -1422,6 +1434,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']();
 }
@@ -1774,6 +1790,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);
 }
@@ -2042,6 +2062,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 +2130,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,56 @@ export namespace awardref {
 
 }
 
+export namespace bandopen {
+	
+	export class Opening {
+	    band: string;
+	    calls: number;
+	    median_km: number;
+	    bearing_min: number;
+	    bearing_max: number;
+	    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.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 {
@@ -2937,6 +2987,7 @@ export namespace main {
 	    band: string;
 	    mode: string;
 	    pota_ref?: string;
+	    spotter?: string;
 	
 	    static createFrom(source: any = {}) {
 	        return new SpotQuery(source);
@@ -2948,6 +2999,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 +3011,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 +3036,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 +3176,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 +3190,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 {
@@ -3267,6 +3335,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 +3715,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 +3753,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"];
@@ -4813,6 +4897,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

@@ -7,6 +7,7 @@ require (
 	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.sum

@@ -25,6 +25,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 +66,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.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+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=

internal/bandopen/bandopen.go

@@ -0,0 +1,253 @@
+// 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           // single-hop Es range
+	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 single-hop Es envelope.
+//
+// 500–2400 km: below ~500 km a 6 m contact is ordinary tropo or ground wave and
+// says nothing about the ionosphere; beyond ~2400 km it is no longer one hop, so
+// the bearing test stops meaning anything. 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:         2400,
+		BearingSpread: 90,
+		Requiet:       45 * time.Minute,
+	}
+}
+
+// Bands watched. HF is deliberately absent: an "opening" on 20 m is the normal
+// state of the band and announcing it would be noise.
+var watched = map[string]bool{"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"`
+	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 || 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)
+	}
+	lo, hi, spread := arc(bearings)
+	if spread > cfg.BearingSpread {
+		return nil // spots all round the compass — a busy band, not an opening
+	}
+	sort.Ints(dists)
+	sort.Strings(calls)
+	if len(calls) > 5 {
+		calls = calls[:5]
+	}
+	return &Opening{
+		Band: band, Calls: len(seen), MedianKm: dists[len(dists)/2],
+		BearingMin: lo, BearingMax: hi, Examples: calls,
+	}
+}
+
+// arc returns the smallest compass sector containing every bearing, coping with
+// the wrap at north: 350° and 10° are 20° apart, not 340°.
+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(float64(o.BearingMin+o.BearingMax)/2) +
+		" (" + strconv.Itoa(o.BearingMin) + "–" + strconv.Itoa(o.BearingMax) + "°)"
+}
+
+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,184 @@
+package bandopen
+
+import (
+	"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)
+	}
+}

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/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
+// wsjtSender extracts the transmitting (DE) callsign from a WSJT-X message,
-// whether it was a CQ. Grammar:
+// 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]) {
+		if idx < len(f) {
-			return f[idx], true
+			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 K1ABC FN42", "K1ABC", true, "FN42"},
-		{"CQ DX W2XYZ EM12", "W2XYZ", true},   // modifier "DX" skipped
+		{"CQ DX W2XYZ EM12", "W2XYZ", true, "EM12"},    // modifier "DX" skipped
-		{"CQ NA VE3ABC FN03", "VE3ABC", true}, // region modifier skipped
+		{"CQ NA VE3ABC FN03", "VE3ABC", true, "FN03"},  // region modifier skipped
-		{"CQ 020 JA1XYZ PM95", "JA1XYZ", true},// zone modifier skipped
+		{"CQ 020 JA1XYZ PM95", "JA1XYZ", true, "PM95"}, // zone modifier skipped
-		{"W2XYZ K1ABC -10", "K1ABC", false},   // exchange → sender is 2nd call
+		{"W2XYZ K1ABC -10", "K1ABC", false, ""},        // exchange → sender is 2nd call
-		{"W2XYZ K1ABC R-10", "K1ABC", false},
+		{"W2XYZ K1ABC R-10", "K1ABC", false, ""},
-		{"W2XYZ K1ABC RR73", "K1ABC", false},
+		{"W2XYZ K1ABC RR73", "K1ABC", false, ""},
-		{"F4BPO K1ABC/P 73", "K1ABC/P", false},// portable call kept
+		{"F4BPO K1ABC/P 73", "K1ABC/P", false, ""},     // portable call kept
-		{"CQ F/DL1ABC JO31", "F/DL1ABC", true},// compound prefix
+		{"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},
+		{"TNX 73 GL", "", false, ""},
-		{"K1ABC RR73", "", false}, // only one call + a token → 2nd token not a call
+		{"K1ABC RR73", "", false, ""}, // only one call + a token → 2nd token not a call
-		{"", "", false},
+		{"", "", false, ""},
-		{"CQ CQ CQ", "", true}, // CQ but no resolvable call
+		{"CQ CQ CQ", "", true, ""}, // CQ but no resolvable call
 	}
 	for _, c := range cases {
-		call, cq := wsjtSender(c.msg)
+		call, cq, grid := wsjtSender(c.msg)
-		if call != c.wantCall || cq != c.wantCQ {
+		if call != c.wantCall || cq != c.wantCQ || grid != c.wantGrid {
-			t.Errorf("wsjtSender(%q) = (%q,%v), want (%q,%v)", c.msg, call, cq, c.wantCall, c.wantCQ)
+			t.Errorf("wsjtSender(%q) = (%q,%v,%q), want (%q,%v,%q)",
+				c.msg, call, cq, grid, c.wantCall, c.wantCQ, c.wantGrid)
 		}
 	}
 }

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.readReplyLocked(fmt.Sprintf("R%d|", id))
-		line, err := c.reader.ReadString('\n')
 		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))
+	return c.readReplyLocked(fmt.Sprintf("R%d|", id))
-	line, err := c.reader.ReadString('\n')
-	if err != nil {
-		return "", err
-	}
-	line = strings.TrimSpace(line)
-	c.parse(line)
-	return line, nil
 }
 
 // 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/qso/qso.go

@@ -3002,3 +3002,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/webpub/webpub.go

@@ -0,0 +1,397 @@
+// 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.
+//   - Columns are a fixed, curated set rather than "every ADIF field". This is
+//     a page shown to the public: RST and QSL status belong, the operator's
+//     home address does not.
+package webpub
+
+import (
+	"crypto/tls"
+	"encoding/csv"
+	"fmt"
+	"html"
+	"os"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/jlaffaye/ftp"
+
+	"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
+	Value  func(q *qso.QSO) string
+}
+
+func str(p *int) string {
+	if p == nil {
+		return ""
+	}
+	return strconv.Itoa(*p)
+}
+
+// Columns is the curated set, in default display order. Add here to offer a new
+// one; the stored config keeps keys, so order changes are safe.
+var Columns = []Column{
+	{"date", "Date", func(q *qso.QSO) string { return q.QSODate.UTC().Format("2006-01-02") }},
+	{"time", "UTC", func(q *qso.QSO) string { return q.QSODate.UTC().Format("15:04") }},
+	{"callsign", "Call", func(q *qso.QSO) string { return q.Callsign }},
+	{"band", "Band", func(q *qso.QSO) string { return q.Band }},
+	{"mode", "Mode", func(q *qso.QSO) string { return q.Mode }},
+	{"freq", "Freq", func(q *qso.QSO) string {
+		if q.FreqHz == nil || *q.FreqHz == 0 {
+			return ""
+		}
+		return strconv.FormatFloat(float64(*q.FreqHz)/1e6, 'f', 3, 64)
+	}},
+	{"rst_sent", "RST S", func(q *qso.QSO) string { return q.RSTSent }},
+	{"rst_rcvd", "RST R", func(q *qso.QSO) string { return q.RSTRcvd }},
+	{"name", "Name", func(q *qso.QSO) string { return q.Name }},
+	{"qth", "QTH", func(q *qso.QSO) string { return q.QTH }},
+	{"country", "Country", func(q *qso.QSO) string { return q.Country }},
+	{"grid", "Grid", func(q *qso.QSO) string { return q.Grid }},
+	{"dxcc", "DXCC", func(q *qso.QSO) string { return str(q.DXCC) }},
+	{"cqz", "CQ", func(q *qso.QSO) string { return str(q.CQZ) }},
+	{"ituz", "ITU", func(q *qso.QSO) string { return str(q.ITUZ) }},
+	{"iota", "IOTA", func(q *qso.QSO) string { return q.IOTA }},
+	{"pota", "POTA", func(q *qso.QSO) string { return q.POTARef }},
+	{"sota", "SOTA", func(q *qso.QSO) string { return q.SOTARef }},
+	{"qsl_sent", "QSL S", func(q *qso.QSO) string { return q.QSLSent }},
+	{"qsl_rcvd", "QSL R", func(q *qso.QSO) string { return q.QSLRcvd }},
+	{"lotw_rcvd", "LoTW", func(q *qso.QSO) string { return q.LOTWRcvd }},
+	{"station", "Station", func(q *qso.QSO) string { return q.StationCallsign }},
+	{"comment", "Comment", func(q *qso.QSO) string { return q.Comment }},
+}
+
+// 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"}
+
+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 {
+		if c, ok := byKey[strings.TrimSpace(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}
+.wrap{max-width:1100px;margin:0 auto}
+h1{margin:0 0 .25rem;font-size:1.35rem}
+.meta{margin:0 0 1rem;color:var(--mut);font-size:.8rem}
+.scroll{overflow-x:auto;border:1px solid var(--line);border-radius:8px}
+table{border-collapse:collapse;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_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.0"
+	appVersion = "0.24.4"
 
 	// posthogHost is the PostHog ingestion endpoint. EU cloud by default; change
 	// to https://us.i.posthog.com for a US project.

update.go

@@ -150,16 +150,56 @@ func (a *App) DownloadAndApplyUpdate(url string) error {
 	// Swap: rename the running exe out of the way (Windows allows renaming a
 	// running image), move the new one into its place, then relaunch. Roll back if
 	// the second rename fails so we never end up with no exe.
-	oldExe := exe + ".old"
+	//
-	_ = os.Remove(oldExe)
+	// The staging name is UNIQUE, not a fixed ".old". With a fixed name, one
-	if err := os.Rename(exe, oldExe); err != nil {
+	// leftover that could not be deleted — an antivirus holding it open is the
-		_ = os.Remove(newExe)
+	// usual reason — poisoned every later update: the rename replaces its target,
-		return fmt.Errorf("stage current exe: %w", err)
+	// the target was locked, and the operator got "stage current exe: … Accès
+	// refusé" for ever with no way out but deleting the file by hand.
+	oldExe := fmt.Sprintf("%s.old-%d", exe, time.Now().UnixNano())
+	var stageErr error
+	staged := false
+	// Retry briefly: a real-time scanner opens the file it has just seen written
+	// and holds it for a moment, so the first attempt lands exactly in that window.
+	for attempt := 0; attempt < 5; attempt++ {
+		if stageErr = os.Rename(exe, oldExe); stageErr == nil {
+			staged = true
+			break
 		}
+		time.Sleep(time.Duration(150*(attempt+1)) * time.Millisecond)
+	}
+
+	if staged {
 		if err := os.Rename(newExe, exe); err != nil {
 			_ = os.Rename(oldExe, exe) // roll back
 			return fmt.Errorf("install new exe: %w", err)
 		}
+	} else {
+		// Could not rename our own running image at all. Some endpoint protection
+		// (Bitdefender's ransomware remediation among them) blocks precisely that,
+		// and no amount of retrying gets past it.
+		//
+		// So don't fight it: leave the new build beside the old one and let the
+		// relaunch helper do the swap AFTER this process has exited, when the file
+		// is no longer a running image. Reported by several operators, all with the
+		// same "Accès refusé" on the staging rename.
+		applog.Printf("update: cannot rename the running exe (%v) — deferring the swap to after exit", stageErr)
+		pending := exe + ".new"
+		_ = os.Remove(pending)
+		if err := os.Rename(newExe, pending); err != nil {
+			_ = os.Remove(newExe)
+			return fmt.Errorf("stage new exe: %w (the folder %s must be writable, and an antivirus may be holding OpsLog.exe)", err, dir)
+		}
+		if err := a.scheduleDeferredSwap(exe, pending); err != nil {
+			return err
+		}
+		if a.ctx != nil {
+			wruntime.Quit(a.ctx)
+		} else {
+			os.Exit(0)
+		}
+		return nil
+	}
 	// Clear the "downloaded from the internet" mark (NTFS Zone.Identifier stream).
 	// Otherwise Windows SmartScreen wants to prompt "are you sure you want to open
 	// this?" — but since we launch the exe programmatically that prompt never shows,
@@ -189,6 +229,46 @@ func (a *App) DownloadAndApplyUpdate(url string) error {
 	return nil
 }
 
+// scheduleDeferredSwap hands the exe swap to a detached helper that runs AFTER
+// this process is gone.
+//
+// The fallback for when the running image cannot be renamed at all. Once OpsLog
+// has exited its exe is an ordinary file again, so the move that was refused a
+// moment earlier succeeds — and the helper keeps trying for ten seconds, because
+// an antivirus that was holding the file usually lets go a beat after the
+// process dies rather than instantly.
+//
+// OpsLog is restarted either way. If the move failed, that starts the OLD build
+// — the update simply has not applied — and the operator keeps a working logger
+// instead of having it vanish mid-session, which for someone in a QSO is worse
+// than an update that waits. Only a successful swap passes --post-update, so a
+// failure leaves the .new file in place for the next attempt rather than having
+// the cleanup delete the download.
+func (a *App) scheduleDeferredSwap(exe, pending string) error {
+	// Clear the "downloaded from the internet" mark before it becomes the exe —
+	// SmartScreen silently blocks a programmatic launch of a marked file, and the
+	// mark follows the file across the move.
+	_ = os.Remove(pending + ":Zone.Identifier")
+
+	q := func(s string) string { return strings.ReplaceAll(s, "'", "''") }
+	ps := fmt.Sprintf(
+		"Wait-Process -Id %d -ErrorAction SilentlyContinue; "+
+			"$ok=$false; "+
+			"for ($i=0; $i -lt 40; $i++) { "+
+			"try { Move-Item -LiteralPath '%s' -Destination '%s' -Force -ErrorAction Stop; $ok=$true; break } "+
+			"catch { Start-Sleep -Milliseconds 250 } }; "+
+			"if ($ok) { Start-Process -FilePath '%s' -ArgumentList '--post-update' } "+
+			"else { Start-Process -FilePath '%s' }",
+		os.Getpid(), q(pending), q(exe), q(exe), q(exe))
+	cmd := exec.Command("powershell", "-NoProfile", "-WindowStyle", "Hidden", "-Command", ps)
+	cmd.SysProcAttr = &syscall.SysProcAttr{HideWindow: true, CreationFlags: 0x08000000} // CREATE_NO_WINDOW
+	if err := cmd.Start(); err != nil {
+		return fmt.Errorf("schedule the update swap: %w", err)
+	}
+	applog.Printf("update: swap scheduled for after exit (%s → %s)", filepath.Base(pending), filepath.Base(exe))
+	return nil
+}
+
 // downloadWithProgress streams url into dest, emitting "update:progress" (0-100).
 func (a *App) downloadWithProgress(url, dest string) error {
 	client := &http.Client{Timeout: 10 * time.Minute}
@@ -274,12 +354,27 @@ func extractExeFromZip(zipPath, dir string) (string, error) {
 	return "", fmt.Errorf("no .exe inside the archive")
 }
 
-// cleanupOldUpdateBinary removes the previous exe left behind by a self-update
+// cleanupOldUpdateBinary removes what a self-update left behind. Called at
-// (exe + ".old"). Called at startup after a --post-update relaunch. Best-effort:
+// startup after a --post-update relaunch. Best-effort throughout: a file may
-// the file may still be briefly locked, in which case the next launch gets it.
+// still be locked by a scanner, and the next launch will get it.
+//
+// Sweeps a PATTERN, not one name. Staging uses a unique ".old-<nanos>" precisely
+// so a locked leftover cannot block the next update, which means leftovers
+// accumulate unless something collects them — and the pre-0.24.1 ".old" may be
+// sitting there too, from the very update that could not delete it.
 func cleanupOldUpdateBinary() {
-	if exe, err := os.Executable(); err == nil {
+	exe, err := os.Executable()
-		_ = os.Remove(exe + ".old")
+	if err != nil {
+		return
+	}
+	_ = os.Remove(exe + ".old")  // the old fixed name
+	_ = os.Remove(exe + ".new")  // a deferred swap that has been applied
+	matches, err := filepath.Glob(exe + ".old-*")
+	if err != nil {
+		return
+	}
+	for _, m := range matches {
+		_ = os.Remove(m)
 	}
 }
 

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