chore: release v0.24.2

v0.24.1 was tagged and shipped mid-session; the six commits that followed kept appending to its block, so the released version appeared to describe changes it does not contain. 0.24.1 is restored to exactly the five entries that shipped - verified against git show v0.24.1:changelog.json - and the five later ones open 0.24.2.

app.go

@@ -11,6 +11,7 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"runtime"
 	"runtime/debug"
 	"sort"
 	"strconv"
@@ -293,6 +294,17 @@ 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
+	// for. See GetWorkedCallVariants.
+	keyWorkedCallVariants = "worked.call_variants"
+
 	keyBackupEnabled   = "backup.enabled"
 	keyBackupFolder    = "backup.folder"
 	keyBackupRotation  = "backup.rotation"
@@ -682,6 +694,8 @@ 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
 	dataDir            string      // <exeDir>/data — holds config.json, logs, cty.dat
 
 	// shuttingDown gates beforeClose re-entry: the first user attempt to
@@ -1229,6 +1243,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
@@ -1794,6 +1810,24 @@ func writeWindowState(dataDir string, w windowState) {
 	}
 }
 
+// windowIsMinimised reports whether the window is currently minimised.
+//
+// Two tests rather than one: Wails answers the question directly, and the
+// -32000 corner is Windows' own marker for a minimised window — a window that
+// is mid-close or hidden can report that corner while the flag has already been
+// cleared, and either way the geometry is not worth storing.
+func (a *App) windowIsMinimised() bool {
+	if a.ctx == nil {
+		return false
+	}
+	if wruntime.WindowIsMinimised(a.ctx) {
+		return true
+	}
+	x, y := wruntime.WindowGetPosition(a.ctx)
+	const minimisedCorner = -32000
+	return x <= minimisedCorner || y <= minimisedCorner
+}
+
 // saveWindowState captures the current geometry. Called as the window closes.
 // While in compact mode the window is pinned to a tiny fixed size, so we keep the
 // previously-saved normal geometry rather than overwrite it with 1240×158 — only
@@ -1803,6 +1837,18 @@ func (a *App) saveWindowState() {
 		return
 	}
 	prev, _ := readWindowState(a.dataDir)
+	// A MINIMISED window has no usable geometry: Windows parks it at -32000,-32000
+	// with a stub size, and reports it as not-maximised. Closing OpsLog from the
+	// taskbar while minimised captured exactly that — "saving -32000,-32000 237x39
+	// maximised=false" — and window.json then held a position no monitor covers and
+	// a size below the minimum. The restore side rejects both and falls back to the
+	// default placement, so the operator silently lost the size, the position AND
+	// the maximised state they had. Keep what was already stored instead.
+	if a.windowIsMinimised() {
+		applog.Printf("window: minimised at close — keeping the stored geometry %d,%d %dx%d maximised=%v",
+			prev.X, prev.Y, prev.Width, prev.Height, prev.Maximised)
+		return
+	}
 	max := wruntime.WindowIsMaximised(a.ctx)
 	ws := prev
 	ws.Maximised = max
@@ -2616,6 +2662,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))
 			}
@@ -4136,6 +4183,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
 		}
@@ -4151,18 +4199,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) {
@@ -4217,8 +4310,8 @@ func (a *App) GetAwardStats(code string) (AwardStatsResult, error) {
 			continue
 		}
 		bi, hasBand := bandIdx[strings.ToLower(strings.TrimSpace(q.Band))]
-		isConf := award.Confirmed(q, def.Confirm)
+		isConf := award.Confirmed(q, *def, def.Confirm)
-		isVal := award.Confirmed(q, def.Validate)
+		isVal := award.Confirmed(q, *def, def.Validate)
 		cat := strings.ToUpper(award.EmissionOf(q.Mode))
 
 		record := func(c string) {
@@ -6091,6 +6184,31 @@ func (a *App) bulkSetFrequency(ids []int64, value string) (int64, error) {
 	return n, nil
 }
 
+// GetWorkedCallVariants reports whether "worked before" folds an operator's
+// portable forms together (RK3DWA ↔ RK3DWA/3 ↔ RK3DWA/P).
+//
+// Defaults to ON, hence the inverted storage: an install that predates the
+// setting has no key at all, and reading that as OFF would leave every existing
+// operator with the old narrow behaviour they asked us to change.
+func (a *App) GetWorkedCallVariants() (bool, error) {
+	if a.settings == nil {
+		return true, fmt.Errorf("db not initialized")
+	}
+	v, err := a.settings.Get(a.ctx, keyWorkedCallVariants)
+	if err != nil {
+		return true, err
+	}
+	return v != "0", nil
+}
+
+// SetWorkedCallVariants persists the toggle.
+func (a *App) SetWorkedCallVariants(on bool) error {
+	if a.settings == nil {
+		return fmt.Errorf("db not initialized")
+	}
+	return a.settings.Set(a.ctx, keyWorkedCallVariants, boolStr(on))
+}
+
 // WorkedBefore returns prior contacts with the given callsign at both
 // call and DXCC granularity. Pass dxccHint=0 when unknown — the function
 // will infer it from past QSOs with the same call when possible.
@@ -6107,7 +6225,8 @@ func (a *App) WorkedBefore(callsign string, dxccHint int) (qso.WorkedBefore, err
 			dxccHint = dxcc.EntityDXCC(m.Entity.Name)
 		}
 	}
-	wb, err := a.qso.WorkedBefore(a.ctx, callsign, dxccHint)
+	variants, _ := a.GetWorkedCallVariants()
+	wb, err := a.qso.WorkedBefore(a.ctx, callsign, dxccHint, variants)
 	// Attach the ClubLog Most Wanted rank for this entity (opt-in) so the entry
 	// matrix can show it next to the country name.
 	if err == nil && wb.DXCC > 0 && a.clublogMW != nil && a.clublogMostWantedEnabled() {
@@ -11593,6 +11712,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…).

app_qsl_designer.go

@@ -41,7 +41,7 @@ const appQSLCardSentField = "APP_OPSLOG_QSL_SENT"
 
 // appQSLCardRcvdField marks that a QSL was RECEIVED for this QSO (set by the
 // operator, e.g. when a card arrives by e-mail). It drives the PSE/TNX stamp on
-// the card: received → "TNX" (thanks for your card), not received → "PSE QSL"
+// the card: received → "TNX QSL" (thanks for your card), not received → "PSE QSL"
 // (please send one). Independent of ADIF qsl_rcvd, like the sent field.
 const appQSLCardRcvdField = "APP_OPSLOG_QSL_RCVD"
 
@@ -681,7 +681,7 @@ func (a *App) qslVars(q qso.QSO) (map[string]string, qslcard.CountryInfo, error)
 	// QSO (appQSLCardRcvdField): received → thank them, otherwise ask for a card.
 	pseTnx := "PSE QSL"
 	if q.Extras != nil && strings.TrimSpace(q.Extras[appQSLCardRcvdField]) != "" {
-		pseTnx = "TNX"
+		pseTnx = "TNX QSL"
 	}
 	vars := map[string]string{
 		"profile.callsign":      info.Callsign,

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

changelog.json

@@ -1,4 +1,66 @@
 [
+  {
+    "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": "",
+    "en": [
+      "Worked before: an operator's portable callsigns now count as the same station. Typing RK3DWA finds the RK3DWA/3, /P and /MM contacts too, and the other way round — before, the history only appeared if you typed the exact form. Can be turned off in Settings → General; contest dupe checking is unaffected and stays exact.",
+      "QSO editor: the OpsLog card now appears with the other confirmations. It has its own Sent / Received row in the QSL Info table, next to QSL, LoTW, eQSL and the rest, and the \"QSL received\" tick moved there from Contact's details — with its PSE QSL / TNX indicator, which is unchanged. Sent stays read-only: OpsLog stamps it when the card actually goes out.",
+      "QSL card: the {qso.pse_tnx} stamp now prints \"TNX QSL\" instead of just \"TNX\", to read as the counterpart of \"PSE QSL\".",
+      "Four new themes, with real colour this time: Indigo (deep blue-violet, electric accent), Ocean (deep teal, cyan), Plum (aubergine, magenta) and Nordic light (crisp cool white, indigo). The seven existing ones were all neutral — beige, slate, graphite, black — with an orange accent, so picking a theme only ever changed the shade of grey. Each new one colours the surfaces, not just the accent, and takes its own primary. The status colours stay exactly where they were: red still means a problem.",
+      "Awards: the Prefix now completes a reference the operator typed without it. A station that puts just \"74\" in State counts for DDFM (codes D01…D95) with match-by \"code\" and Prefix \"D\" — before, that found nothing and the only way through was to write a regex, in a mode where you had chosen \"code\" and not \"pattern\". The prefix was applied after the reference lookup, that is, after the step that had already failed. A field that already holds the whole code is no longer prefixed twice either (\"D74\" used to become \"DD74\" as soon as a prefix was set).",
+      "UDP: WSJT-X traffic arriving through a relay is read again. A forwarder such as W&P prepends the origin as text — \"127.0.0.1:2237|\" — in front of the packet it re-broadcasts, which pushed the WSJT-X signature 15 bytes in and made every datagram fail. That header is now skipped, so MSHV / WSJT-X / JTDX behind a relay work on the ordinary \"WSJT-X / JTDX / MSHV\" service: no new setting, nothing to reconfigure.",
+      "UDP: an unreadable packet now says who sent it and what it contained — the sender's address, the size, a text preview and a hex dump — instead of just a magic number. And it stops after five: a port receiving the wrong traffic was writing that line a hundred times a second, filling the log and burying everything else. A closing line points at the two things to check, the sender and the service type.",
+      "Awards: the QRZ.com and Custom confirmation sources actually work now. Both were offered in the award editor but neither was implemented, so ticking one marked no QSO as confirmed — silently. QRZ.com reads the download status (them confirming back, not our upload). Custom reads any QSO field or ADIF tag you name, with an optional list of values that count: point it at APP_OPSLOG_QSL_RCVD for a card received through OpsLog, or at a tag stamped by a club list you imported. Leave the value empty and any non-empty content confirms. A Custom source naming no field confirms nothing.",
+      "Window: closing OpsLog while it is minimised no longer loses its size and position. Windows parks a minimised window at -32000,-32000 with a stub size, and that was what got saved — so the next launch found geometry no screen could hold, discarded it, and reopened at the default place. The stored geometry is now kept instead; it repairs itself the first time you close a window that is on screen."
+    ],
+    "fr": [
+      "Déjà contacté : les indicatifs portables d'un opérateur comptent désormais comme la même station. Taper RK3DWA retrouve aussi les QSO en RK3DWA/3, /P et /MM, et inversement — avant, l'historique n'apparaissait que si tu tapais la forme exacte. Désactivable dans Réglages → Général ; le contrôle de doublon en concours n'est pas touché et reste strict.",
+      "Éditeur de QSO : la carte OpsLog rejoint les autres confirmations. Elle a sa propre ligne Envoyée / Reçue dans le tableau de l'onglet QSL Info, à côté de QSL, LoTW, eQSL et les autres, et la case « QSL reçue » y a été déplacée depuis Détails du contact — avec son indicateur PSE QSL / TNX, inchangé. « Envoyée » reste en lecture seule : OpsLog l'inscrit quand la carte part réellement.",
+      "Carte QSL : le tampon {qso.pse_tnx} imprime désormais « TNX QSL » et non plus « TNX » seul, pour répondre à « PSE QSL ».",
+      "Quatre nouveaux thèmes, avec de la vraie couleur cette fois : Indigo (bleu-violet profond, accent électrique), Océan (turquoise profond, cyan), Prune (aubergine, magenta) et Clair nordique (blanc froid net, indigo). Les sept existants étaient tous neutres — beige, ardoise, graphite, noir — avec un accent orange : choisir un thème ne changeait que la nuance de gris. Les nouveaux colorent les surfaces, pas seulement l'accent, et ont chacun leur couleur principale. Les couleurs de statut ne bougent pas : le rouge veut toujours dire un problème.",
+      "Diplômes : le Préfixe complète désormais une référence saisie sans lui. Une station qui met simplement « 74 » dans State compte pour le DDFM (codes D01…D95) avec correspondance « code » et Préfixe « D » — avant, cela ne trouvait rien et le seul recours était d'écrire une regex, dans un mode où tu avais justement choisi « code » et pas « pattern ». Le préfixe était appliqué après la recherche de la référence, c'est-à-dire après l'étape qui venait d'échouer. Un champ contenant déjà le code complet n'est plus préfixé deux fois non plus (« D74 » devenait « DD74 » dès qu'un préfixe était réglé).",
+      "UDP : le trafic WSJT-X qui arrive via un relais est de nouveau lu. Un réexpéditeur comme W&P place l'origine en texte — « 127.0.0.1:2237| » — devant le paquet qu'il rediffuse, ce qui décalait la signature WSJT-X de 15 octets et faisait échouer chaque datagramme. Cet en-tête est désormais ignoré : MSHV / WSJT-X / JTDX derrière un relais fonctionnent avec le service « WSJT-X / JTDX / MSHV » habituel, sans nouveau réglage ni reconfiguration.",
+      "UDP : un paquet illisible indique désormais qui l'a envoyé et ce qu'il contenait — adresse de l'émetteur, taille, aperçu en texte et vidage hexadécimal — au lieu d'un simple nombre magique. Et il s'arrête après cinq : un port recevant le mauvais trafic écrivait cette ligne cent fois par seconde, saturant le journal et enterrant tout le reste. Une ligne finale rappelle les deux choses à vérifier, l'émetteur et le type de service.",
+      "Diplômes : les sources de confirmation QRZ.com et Custom fonctionnent enfin. Les deux étaient proposées dans l'éditeur de diplômes sans être implémentées : cocher l'une ou l'autre ne confirmait aucun QSO, en silence. QRZ.com lit le statut de téléchargement (leur confirmation en retour, pas notre envoi). Custom lit n'importe quel champ de QSO ou balise ADIF que tu désignes, avec une liste facultative de valeurs qui comptent : pointe-la sur APP_OPSLOG_QSL_RCVD pour une carte reçue via OpsLog, ou sur une balise inscrite à l'import d'une liste de club. Laisse la valeur vide et tout contenu non vide confirme. Une source Custom sans champ ne confirme rien.",
+      "Fenêtre : fermer OpsLog alors qu'il est réduit ne fait plus perdre sa taille et sa position. Windows range une fenêtre réduite en -32000,-32000 avec une taille factice, et c'est cela qui était enregistré — au lancement suivant, OpsLog trouvait une géométrie qu'aucun écran ne peut contenir, la rejetait et rouvrait à l'emplacement par défaut. La géométrie déjà enregistrée est désormais conservée ; cela se répare tout seul à la première fermeture d'une fenêtre visible à l'écran."
+    ]
+  },
   {
     "version": "0.23.9",
     "date": "",

frontend/src/App.tsx

@@ -907,6 +907,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 +1000,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 +1426,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.
@@ -1556,23 +1640,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);
     });
@@ -5948,9 +6039,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 +6306,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 +6619,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 +6654,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/AwardEditor.tsx

@@ -38,6 +38,9 @@ export type AwardDef = {
   or_rules?: AwardOrRule[];
   dxcc_filter: number[] | null; valid_bands?: string[]; valid_modes?: string[]; emission?: string[];
   confirm: string[] | null; validate?: string[] | null; grant_codes?: string; export_credit_granted?: boolean;
+  // The "custom" confirmation source: the field it reads and, optionally, the
+  // value(s) that count. Empty value = any non-empty value confirms.
+  confirm_field?: string; confirm_value?: string;
   total: number; builtin?: boolean; version?: number;
 };
 
@@ -622,6 +625,30 @@ export function AwardEditor({ open, onClose, onSaved }: Props) {
                         ))}
                       </div>
                     </div>
+
+                    {/* "Custom" is only meaningful once it names a field, so the
+                        inputs appear as soon as it is ticked in either column —
+                        and a custom source with no field confirms nothing. */}
+                    {((cur.confirm ?? []).includes('custom') || (cur.validate ?? []).includes('custom')) && (
+                      <div className="space-y-2 border-t border-border/60 pt-3">
+                        <Label className="text-xs font-semibold">{t('awed.customLabel')}</Label>
+                        <div className="grid grid-cols-2 gap-3">
+                          <div className="space-y-1">
+                            <Label className="text-[11px] text-muted-foreground">{t('awed.customField')}</Label>
+                            <Input className="h-8 font-mono text-xs" placeholder="APP_OPSLOG_QSL_RCVD"
+                              value={(cur as any).confirm_field ?? ''}
+                              onChange={(e) => patch({ confirm_field: e.target.value.trim().toUpperCase() } as any)} />
+                          </div>
+                          <div className="space-y-1">
+                            <Label className="text-[11px] text-muted-foreground">{t('awed.customValue')}</Label>
+                            <Input className="h-8 font-mono text-xs" placeholder="Y,V"
+                              value={(cur as any).confirm_value ?? ''}
+                              onChange={(e) => patch({ confirm_value: e.target.value } as any)} />
+                          </div>
+                        </div>
+                        <p className="text-[11px] text-muted-foreground leading-relaxed">{t('awed.customHint')}</p>
+                      </div>
+                    )}
                     {/* "Grant codes" and "export credit_granted" used to live here. No
                         ADIF export has ever written CREDIT_GRANTED, so both controls
                         did nothing at all. The stored values are kept (see award.Def);

frontend/src/components/BandMap.tsx

@@ -3,6 +3,7 @@ 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';
 
 // BandMap — vertical spectrum panel inspired by Log4OM.
 // - Full band is always visible; zoom changes pixels-per-kHz, scroll
@@ -24,7 +25,40 @@ 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;
+  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 four. A new PREFIX is left to the cluster list: 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');
+const markersFor = (e: SpotStatusEntry | undefined) =>
+  activeMarkers(e).filter((m) => m.key !== 'new_pfx');
+
+// 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;
@@ -567,10 +601,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 +635,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,7 @@ 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 { loadLocal, loadRemote, saveState, seedLocal, whenGridPrefsReady } from '@/lib/gridPrefs';
 import { useI18n } from '@/lib/i18n';
 
@@ -221,9 +222,11 @@ const makeColCatalog = (t: TFn): ColEntry[] => [
                 : 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 (parts.length === 0) return <span style={{ color: 'var(--muted-foreground)', fontSize: 10 }}>—</span>;
       return (
         <span style={{ whiteSpace: 'nowrap' }}>

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

@@ -73,6 +73,11 @@ const CONF_LABEL_KEYS: Record<string, string> = {
   QSL: 'qedit.confQslPaper',
 };
 
+// OpsLog's own card. Kept out of CONFIRMATIONS on purpose — that list maps QSO
+// columns and this channel is backed by ADIF extras — but it still belongs in
+// the channel picker and the status table alongside the rest.
+const OPSLOG_CONF = 'OPSLOG';
+
 // Colour-coded status cell for the confirmation grid.
 function StatusCell({ value }: { value?: string }) {
   const { t } = useI18n();
@@ -430,10 +435,14 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
   );
 
   // OpsLog QSL "received" marker (ADIF extra). Drives the card's PSE/TNX stamp:
-  // received → TNX (thanks for your card), otherwise PSE QSL (please send one).
+  // received → TNX QSL (thanks for your card), otherwise PSE QSL (please send one).
   // Saved with the normal Save via draft.extras.
   const OPSLOG_QSL_RCVD = 'APP_OPSLOG_QSL_RCVD';
   const qslReceived = !!String(draft.extras?.[OPSLOG_QSL_RCVD] ?? '').trim();
+  // Sent side, for the confirmations table. Two key names because the marker was
+  // renamed once and old QSOs still carry the first one — same test the Recent
+  // QSOs "OpsLog QSL" column makes.
+  const opslogQslSent = !!(draft.extras?.['APP_OPSLOG_QSL_SENT'] || draft.extras?.['APP_OPSLOG_QSL_CARD_SENT']);
   const toggleQslReceived = (on: boolean) => {
     // Reflect immediately in the draft (for the PSE/TNX indicator)…
     const next = { ...(draft.extras ?? {}) };
@@ -617,18 +626,12 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
                     <div className="flex flex-col flex-1"><Label>Lat</Label><Input type="number" step="0.000001" value={draft.lat ?? ''} onChange={(e) => set('lat', numOrUndef(e.target.value) as any)} className="font-mono" /></div>
                     <div className="flex flex-col flex-1"><Label>Lon</Label><Input type="number" step="0.000001" value={draft.lon ?? ''} onChange={(e) => set('lon', numOrUndef(e.target.value) as any)} className="font-mono" /></div>
                   </div>
+                  {/* The OpsLog QSL marker used to sit here, under QSL Msg. It
+                      belongs with the other confirmation channels — see the QSL
+                      Info tab. */}
                   <div>
                     <Label>{t('qedit.qslMsg')}</Label>
                     <Input value={draft.qsl_msg ?? ''} onChange={(e) => set('qsl_msg', e.target.value)} />
-                    <div className="mt-1 flex items-center gap-2">
-                      <label className="flex items-center gap-2 text-sm cursor-pointer">
-                        <Checkbox checked={qslReceived} onCheckedChange={(c) => toggleQslReceived(!!c)} />
-                        {t('qedit.qslReceived')}
-                      </label>
-                      <span className="text-[11px] font-mono px-1.5 py-0.5 rounded bg-muted text-muted-foreground" title={t('qedit.pseTnxHint')}>
-                        {qslReceived ? 'TNX' : 'PSE QSL'}
-                      </span>
-                    </div>
                   </div>
                   <div><Label>{t('qedit.qslVia')}</Label><Input value={draft.qsl_via ?? ''} onChange={(e) => set('qsl_via', e.target.value)} /></div>
                 </div>
@@ -677,9 +680,51 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
                         <Label>{t('qedit.manageConf')}</Label>
                         <Select value={confSel} onValueChange={setConfSel}>
                           <SelectTrigger><SelectValue /></SelectTrigger>
-                          <SelectContent>{CONFIRMATIONS.map((c) => <SelectItem key={c.key} value={c.key}>{CONF_LABEL_KEYS[c.key] ? t(CONF_LABEL_KEYS[c.key]) : c.label}</SelectItem>)}</SelectContent>
+                          <SelectContent>
+                            {CONFIRMATIONS.map((c) => <SelectItem key={c.key} value={c.key}>{CONF_LABEL_KEYS[c.key] ? t(CONF_LABEL_KEYS[c.key]) : c.label}</SelectItem>)}
+                            {/* Listed here but NOT in CONFIRMATIONS: that table maps
+                                QSO columns, and this channel lives in the ADIF
+                                extras. It gets its own editor below rather than the
+                                generic sent/received/date grid, which has no field
+                                to bind to. */}
+                            <SelectItem value={OPSLOG_CONF}>{t('qedit.confOpsLog')}</SelectItem>
+                          </SelectContent>
                         </Select>
                       </div>
+
+                      {confSel === OPSLOG_CONF ? (
+                        /* OpsLog's own card. "Sent" is stamped when the card
+                           actually goes out, so it is shown, not offered: ticking
+                           it by hand would record something that never happened.
+                           "Received" drives the PSE/TNX stamp printed on the card,
+                           which is the whole reason the flag exists — hence the
+                           live indicator next to it. It writes immediately rather
+                           than on Save, because clearing an extras key would not
+                           survive the merge Save does. */
+                        <div className="space-y-3">
+                          <div className="grid grid-cols-2 gap-3">
+                            <div>
+                              <Label>{t('qedit.sent')}</Label>
+                              <Input disabled value={opslogQslSent ? t('qedit.qslYes') : t('qedit.qslNo')} />
+                            </div>
+                            <div>
+                              <Label>{t('qedit.received')}</Label>
+                              <label className="flex h-9 items-center gap-2 text-sm cursor-pointer">
+                                <Checkbox checked={qslReceived} onCheckedChange={(c) => toggleQslReceived(!!c)} />
+                                {t('qedit.qslReceived')}
+                              </label>
+                            </div>
+                          </div>
+                          <div className="flex items-center gap-2">
+                            <span className="text-[11px] font-mono px-1.5 py-0.5 rounded bg-muted text-muted-foreground">
+                              {qslReceived ? 'TNX QSL' : 'PSE QSL'}
+                            </span>
+                            <span className="text-[11px] text-muted-foreground">{t('qedit.pseTnxHint')}</span>
+                          </div>
+                          <p className="text-[11px] text-muted-foreground">{t('qedit.opslogSentHint')}</p>
+                        </div>
+                      ) : (
+                        <>
                           <div className="grid grid-cols-2 gap-3">
                             <div><Label>{t('qedit.sent')}</Label><QslSelect value={val(def.sent)} onChange={(v) => put(def.sent, v)} /></div>
                             <div><Label>{t('qedit.received')}</Label>
@@ -696,6 +741,8 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
                           <p className="text-[11px] text-muted-foreground">
                             {t('qedit.qslPanelHint')} <strong>{t('qedit.saveChanges')}</strong>.
                           </p>
+                        </>
+                      )}
                     </div>
 
                     {/* Right: live status grid for every channel.
@@ -720,6 +767,17 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
                               <td className="w-24">{c.rcvd ? <StatusCell value={val(c.rcvd)} /> : <span className="block text-center text-[11px] text-muted-foreground">—</span>}</td>
                             </tr>
                           ))}
+                          {/* OpsLog's own card, read from the ADIF extras rather
+                              than a QSO column — hence a hand-written row instead
+                              of a CONFIRMATIONS entry. "Sent" is stamped by OpsLog
+                              when the card actually goes out, so it stays
+                              read-only here: an operator ticking it by hand would
+                              be recording something that never happened. */}
+                          <tr className="text-xs">
+                            <td className="font-medium pr-3 py-0.5 whitespace-nowrap">{t('qedit.confOpsLog')}</td>
+                            <td className="w-24"><StatusCell value={opslogQslSent ? 'Y' : 'N'} /></td>
+                            <td className="w-24"><StatusCell value={qslReceived ? 'Y' : 'N'} /></td>
+                          </tr>
                         </tbody>
                       </table>
                     </div>

frontend/src/components/SettingsModal.tsx

@@ -27,6 +27,7 @@ import {
   AudioStartTX, AudioStopTX, AudioTXActive,
   ListClusterServers, SaveClusterServer, DeleteClusterServer,
   GetClusterAutoConnect, SetClusterAutoConnect, GetSelfSpotSettings, SaveSelfSpotSettings,
+  GetWorkedCallVariants, SetWorkedCallVariants,
   ConnectClusterServer, DisconnectClusterServer,
   ConnectAllClusters, DisconnectAllClusters, GetClusterStatus,
   GetBackupSettings, SaveBackupSettings, RunBackupNow, PickBackupFolder,
@@ -60,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';
@@ -181,6 +183,7 @@ type SectionId =
   | 'external-services'
   | 'udp'
   | 'adifmon'
+  | 'webpublish'
   | 'lookup'
   | 'lists-bands'
   | 'lists-modes'
@@ -271,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' },
@@ -288,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',
@@ -310,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',
@@ -402,9 +408,13 @@ const THEME_SWATCH: Record<Exclude<ThemeChoice, 'auto'>, { bg: string; card: str
   'light-warm':    { bg: '#e8dfc9', card: '#faf6ea', accent: '#b8410c' },
   'light-cool':    { bg: '#f4f6f8', card: '#ffffff', accent: '#2563eb' },
   'light-sage':    { bg: '#eef1ec', card: '#f8faf6', accent: '#2f855a' },
+  'light-nordic':  { bg: '#eef1f7', card: '#ffffff', accent: '#4f46e5' },
   'dim-slate':     { bg: '#343b47', card: '#3d4552', accent: '#fb923c' },
   'dark-warm':     { bg: '#221d18', card: '#2e2820', accent: '#e07a2e' },
   'dark-graphite': { bg: '#16181d', card: '#1f232b', accent: '#f97316' },
+  'dark-indigo':   { bg: '#0e0f1f', card: '#181a30', accent: '#7c6cff' },
+  'dark-teal':     { bg: '#061c21', card: '#0d2c33', accent: '#22d3ee' },
+  'dark-plum':     { bg: '#180f1e', card: '#251830', accent: '#f472b6' },
   'high-contrast': { bg: '#000000', card: '#0d0d0d', accent: '#ff7a1a' },
 };
 
@@ -1524,6 +1534,8 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
 
   const [clusterServers, setClusterServers] = useState<ClusterServer[]>([]);
   const [clusterAutoConnect, setClusterAutoConnectState] = useState(false);
+  // Defaults to true so the checkbox matches the backend before the read lands.
+  const [workedVariants, setWorkedVariants] = useState(true);
   // Self-spot. SELF_SPOT_MIN_MIN mirrors the backend floor — the input clamps on
   // blur, not per keystroke, or typing "10" would be rewritten to "5" the moment
   // the "1" landed and the field would fight the operator.
@@ -1632,6 +1644,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
         try { setAudioCfg(await GetAudioSettings() as any); } catch {}
         try { setEmailCfg(await GetEmailSettings() as any); } catch {}
         try { setEqslCfg(await QSLGetEmailTemplates() as any); } catch {}
+        try { setWorkedVariants(await GetWorkedCallVariants()); } catch {}
         reloadAudioDevices();
         reloadDvk();
       } catch (e: any) {
@@ -5666,6 +5679,13 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             <Checkbox checked={autofocusWB} onCheckedChange={(c) => { const v = !!c; setAutofocusWB(v); writeUiPref('opslog.autofocusWB', v ? '1' : '0'); }} />
             {t('gen.autofocusWB')}
           </label>
+          {/* Backend setting, not a UI pref: the fold happens in the SQL. Saved
+              instantly like the rest of this panel. */}
+          <label className="flex items-center gap-2 text-sm cursor-pointer">
+            <Checkbox checked={workedVariants}
+              onCheckedChange={(c) => { const v = !!c; setWorkedVariants(v); SetWorkedCallVariants(v).catch((e: any) => setErr(String(e?.message ?? e))); }} />
+            {t('gen.workedVariants')} <span className="text-xs text-muted-foreground">{t('gen.workedVariantsHint')}</span>
+          </label>
           <label className="flex items-center gap-2 text-sm cursor-pointer">
             <Checkbox checked={showBeamMap} onCheckedChange={(c) => { const v = !!c; setShowBeamMap(v); writeUiPref('opslog.showBeamOnMap', v ? '1' : '0'); }} />
             {t('gen.showBeam')}
@@ -6010,6 +6030,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/spotMarkers.ts

@@ -0,0 +1,41 @@
+// 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
+export type SpotMarkerKey = 'new_pota' | 'new_county' | 'new_pfx' | 'worked_call';
+
+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: '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/theme.tsx

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

frontend/src/lib/uiPref.ts

@@ -39,6 +39,8 @@ const PORTABLE_KEYS = [
   'opslog.clusterModeFilter', 'opslog.clusterSearch', 'opslog.clusterHideWorked',
   'opslog.activeTab',     // last selected tab
   'opslog.mainSplit',    // Main tab: width share of the left pane (percent)
+  'opslog.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/style.css

@@ -495,6 +495,286 @@
   color-scheme: dark;
 }
 
+/* ---- Theme 5: Indigo — deep blue-violet, electric accent ----------------
+   The first seven themes are all neutral (beige, slate, graphite, black) with an
+   orange accent, so "another dark theme" only ever meant another grey. These
+   four carry a real hue in the SURFACES, not just in the accent, and each takes
+   a different primary — violet, cyan, pink, indigo — so they are told apart at a
+   glance in the picker.
+
+   Every one keeps the same contract: the semantic colours (success / warning /
+   caution / danger / info) must stay recognisable as themselves. A logger is
+   read for hours and "red = a problem" cannot become a decorative choice, so the
+   hue budget is spent on the surfaces and the primary, never on the meanings. */
+[data-theme="dark-indigo"] {
+  --background: #0e0f1f;
+  --foreground: #e4e5f2;
+  --card: #181a30;
+  --card-foreground: #e4e5f2;
+  --popover: #181a30;
+  --popover-foreground: #e4e5f2;
+  --primary: #7c6cff;                /* electric violet */
+  --primary-foreground: #0b0a1a;
+  --secondary: #222542;
+  --secondary-foreground: #e4e5f2;
+  --muted: #1e2038;
+  --muted-foreground: #9d9fbe;
+  --accent: #2a2d51;
+  --accent-foreground: #c7c9ee;
+  --destructive: #f2555a;
+  --destructive-foreground: #12030a;
+  --destructive-muted: #34131c;
+  --destructive-muted-foreground: #fca5a5;
+  --border: #2a2d4c;
+  --input: #2a2d4c;
+  --ring: #9b8dff;
+
+  --success: #34d399;
+  --success-foreground: #052018;
+  --success-muted: #0e2f27;
+  --success-muted-foreground: #6ee7b7;
+  --success-border: #165241;
+
+  --warning: #fbbf24;
+  --warning-foreground: #221803;
+  --warning-muted: #33280f;
+  --warning-muted-foreground: #fcd34d;
+  --warning-border: #4f3e15;
+
+  --caution: #facc15;
+  --caution-foreground: #221e04;
+  --caution-muted: #322d0e;
+  --caution-muted-foreground: #fde047;
+  --caution-border: #4b4315;
+
+  --danger: #fb7185;
+  --danger-foreground: #250912;
+  --danger-muted: #37151f;
+  --danger-muted-foreground: #fda4af;
+  --danger-border: #562533;
+
+  --info: #38bdf8;
+  --info-foreground: #051d29;
+  --info-muted: #0b2a3a;
+  --info-muted-foreground: #7dd3fc;
+  --info-border: #12475c;
+
+  /* The entity ramp moves to CYAN here: violet is the primary, and a violet
+     "entity confirmed" cell would read as a button. */
+  --mx-call-conf: #22c55e;
+  --mx-call-work: #2c7a52;
+  --mx-dx-conf:   #22d3ee;
+  --mx-dx-work:   #1b6b7c;
+  --mx-none:      #2c2f4d;
+
+  --scrollbar-thumb: #383c63;
+  --scrollbar-thumb-hover: #4c5182;
+  --card-shadow: 0 1px 2px rgba(0, 0, 0, 0.5), 0 0 0 1px rgba(228, 229, 242, 0.05);
+  color-scheme: dark;
+}
+
+/* ---- Theme 6: Ocean — deep teal, cyan accent --------------------------- */
+[data-theme="dark-teal"] {
+  --background: #061c21;
+  --foreground: #dcecee;
+  --card: #0d2c33;
+  --card-foreground: #dcecee;
+  --popover: #0d2c33;
+  --popover-foreground: #dcecee;
+  --primary: #22d3ee;                /* cyan */
+  --primary-foreground: #041d24;
+  --secondary: #143b44;
+  --secondary-foreground: #dcecee;
+  --muted: #10333b;
+  --muted-foreground: #92b4ba;
+  --accent: #15424c;
+  --accent-foreground: #a5d8e0;
+  --destructive: #f2555a;
+  --destructive-foreground: #12030a;
+  --destructive-muted: #35161a;
+  --destructive-muted-foreground: #fca5a5;
+  --border: #1a4652;
+  --input: #1a4652;
+  --ring: #5fe3f5;
+
+  --success: #4ade80;
+  --success-foreground: #04220f;
+  --success-muted: #0e3020;
+  --success-muted-foreground: #86efac;
+  --success-border: #17593a;
+
+  --warning: #fbbf24;
+  --warning-foreground: #221803;
+  --warning-muted: #33280f;
+  --warning-muted-foreground: #fcd34d;
+  --warning-border: #4f3e15;
+
+  --caution: #facc15;
+  --caution-foreground: #221e04;
+  --caution-muted: #312d0e;
+  --caution-muted-foreground: #fde047;
+  --caution-border: #4a4315;
+
+  --danger: #fb7185;
+  --danger-foreground: #250912;
+  --danger-muted: #38161f;
+  --danger-muted-foreground: #fda4af;
+  --danger-border: #572634;
+
+  /* Info moves to a BLUE: a cyan "info" would be the primary colour again. */
+  --info: #7aa2f7;
+  --info-foreground: #04122e;
+  --info-muted: #16233f;
+  --info-muted-foreground: #a9c2fb;
+  --info-border: #2b3d66;
+
+  --mx-call-conf: #4ade80;
+  --mx-call-work: #2b7a4d;
+  --mx-dx-conf:   #a78bfa;
+  --mx-dx-work:   #5b4a9c;
+  --mx-none:      #1c4550;
+
+  --scrollbar-thumb: #235a68;
+  --scrollbar-thumb-hover: #31788a;
+  --card-shadow: 0 1px 2px rgba(0, 0, 0, 0.5), 0 0 0 1px rgba(220, 236, 238, 0.05);
+  color-scheme: dark;
+}
+
+/* ---- Theme 7: Plum — aubergine, magenta accent ------------------------- */
+[data-theme="dark-plum"] {
+  --background: #180f1e;
+  --foreground: #eee0f0;
+  --card: #251830;
+  --card-foreground: #eee0f0;
+  --popover: #251830;
+  --popover-foreground: #eee0f0;
+  --primary: #f472b6;                /* magenta-pink */
+  --primary-foreground: #250518;
+  --secondary: #33203f;
+  --secondary-foreground: #eee0f0;
+  --muted: #2b1b36;
+  --muted-foreground: #b39dbd;
+  --accent: #3b2648;
+  --accent-foreground: #dcc2e6;
+  --destructive: #f2555a;
+  --destructive-foreground: #12030a;
+  --destructive-muted: #3a1620;
+  --destructive-muted-foreground: #fca5a5;
+  --border: #3a2547;
+  --input: #3a2547;
+  --ring: #f9a8d4;
+
+  --success: #34d399;
+  --success-foreground: #052018;
+  --success-muted: #10302a;
+  --success-muted-foreground: #6ee7b7;
+  --success-border: #1a5745;
+
+  --warning: #fbbf24;
+  --warning-foreground: #221803;
+  --warning-muted: #352a12;
+  --warning-muted-foreground: #fcd34d;
+  --warning-border: #524019;
+
+  --caution: #facc15;
+  --caution-foreground: #221e04;
+  --caution-muted: #342e12;
+  --caution-muted-foreground: #fde047;
+  --caution-border: #4e4519;
+
+  /* Danger goes RED here, not rose: a rose "danger" beside a pink primary is
+     indistinguishable, and this is the one colour that must never be missed. */
+  --danger: #f43f3f;
+  --danger-foreground: #2a0606;
+  --danger-muted: #3d1418;
+  --danger-muted-foreground: #fca5a5;
+  --danger-border: #5c2128;
+
+  --info: #38bdf8;
+  --info-foreground: #051d29;
+  --info-muted: #0f2b3a;
+  --info-muted-foreground: #7dd3fc;
+  --info-border: #16485d;
+
+  --mx-call-conf: #22c55e;
+  --mx-call-work: #2f7d55;
+  --mx-dx-conf:   #60a5fa;
+  --mx-dx-work:   #35538c;
+  --mx-none:      #3a2647;
+
+  --scrollbar-thumb: #4a3159;
+  --scrollbar-thumb-hover: #644176;
+  --card-shadow: 0 1px 2px rgba(0, 0, 0, 0.5), 0 0 0 1px rgba(238, 224, 240, 0.05);
+  color-scheme: dark;
+}
+
+/* ---- Theme 8: Nordic light — crisp cool white, indigo accent ----------- */
+[data-theme="light-nordic"] {
+  --background: #eef1f7;
+  --foreground: #1b2130;
+  --card: #ffffff;
+  --card-foreground: #1b2130;
+  --popover: #ffffff;
+  --popover-foreground: #1b2130;
+  --primary: #4f46e5;                /* indigo */
+  --primary-foreground: #ffffff;
+  --secondary: #dfe4ee;
+  --secondary-foreground: #1b2130;
+  --muted: #e2e7f0;
+  --muted-foreground: #4a5468;
+  --accent: #dcdcfb;
+  --accent-foreground: #312a91;
+  --destructive: #b91c1c;
+  --destructive-foreground: #ffffff;
+  --destructive-muted: #fef2f2;
+  --destructive-muted-foreground: #b91c1c;
+  --border: #c9d1e0;
+  --input: #c9d1e0;
+  --ring: #6366f1;
+
+  --success: #15803d;
+  --success-foreground: #ffffff;
+  --success-muted: #dcfce7;
+  --success-muted-foreground: #14532d;
+  --success-border: #86efac;
+
+  --warning: #b45309;
+  --warning-foreground: #ffffff;
+  --warning-muted: #fef3c7;
+  --warning-muted-foreground: #92400e;
+  --warning-border: #fcd34d;
+
+  --caution: #a16207;
+  --caution-foreground: #ffffff;
+  --caution-muted: #fef9c3;
+  --caution-muted-foreground: #854d0e;
+  --caution-border: #fde047;
+
+  --danger: #dc2626;
+  --danger-foreground: #ffffff;
+  --danger-muted: #fee2e2;
+  --danger-muted-foreground: #991b1b;
+  --danger-border: #fca5a5;
+
+  --info: #0369a1;
+  --info-foreground: #ffffff;
+  --info-muted: #e0f2fe;
+  --info-muted-foreground: #075985;
+  --info-border: #7dd3fc;
+
+  /* Entity ramp shifts to TEAL: indigo is the primary here. */
+  --mx-call-conf: #15803d;
+  --mx-call-work: #86efac;
+  --mx-dx-conf:   #0f766e;
+  --mx-dx-work:   #99f6e4;
+  --mx-none:      #dde3ec;
+
+  --scrollbar-thumb: #b6c0d2;
+  --scrollbar-thumb-hover: #93a0b8;
+  --card-shadow: 0 1px 2px rgba(27, 33, 48, 0.06), 0 0 0 1px rgba(27, 33, 48, 0.03);
+  color-scheme: light;
+}
+
 /* ── Data-viz palette (Statistics dashboard) ────────────────────────────────
    A VALIDATED categorical palette, not hand-picked: the slot ORDER is what makes
    it colour-blind-safe (worst adjacent ΔE 24.2 light / 10.3 dark), so never
@@ -512,7 +792,8 @@
 :root,
 [data-theme="light-warm"],
 [data-theme="light-cool"],
-[data-theme="light-sage"] {
+[data-theme="light-sage"],
+[data-theme="light-nordic"] {
   --chart-1: #2a78d6; /* blue    — default single-series hue */
   --chart-2: #1baf7a; /* aqua    */
   --chart-3: #eda100; /* yellow  */
@@ -533,7 +814,10 @@
 [data-theme="dim-slate"],
 [data-theme="dark-warm"],
 [data-theme="dark-graphite"],
-[data-theme="high-contrast"] {
+[data-theme="high-contrast"],
+[data-theme="dark-indigo"],
+[data-theme="dark-teal"],
+[data-theme="dark-plum"] {
   --chart-1: #3987e5;
   --chart-2: #199e70;
   --chart-3: #c98500;
@@ -681,7 +965,8 @@
    help. */
    Every temporal input carries the same glyph, so the rule names them all:
    datetime-local was left out at first and its icon stayed invisible. */
-:is([data-theme='dim-slate'], [data-theme='dark-warm'], [data-theme='dark-graphite'], [data-theme='high-contrast'])
+:is([data-theme='dim-slate'], [data-theme='dark-warm'], [data-theme='dark-graphite'], [data-theme='high-contrast'],
+    [data-theme='dark-indigo'], [data-theme='dark-teal'], [data-theme='dark-plum'])
   :is(input[type='date'], input[type='datetime-local'], input[type='time'], input[type='month'], input[type='week'])::-webkit-calendar-picker-indicator {
   filter: invert(1) brightness(1.8);
   opacity: 0.9;

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

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

@@ -16,6 +16,7 @@ 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';
@@ -509,12 +510,18 @@ 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>;
 
 export function GetWinkeyerStatus():Promise<winkeyer.Status>;
 
+export function GetWorkedCallVariants():Promise<boolean>;
+
 export function GetYaesuState():Promise<cat.YaesuTXState>;
 
 export function HasBuiltinReferences(arg1:string):Promise<boolean>;
@@ -735,6 +742,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>;
@@ -911,6 +920,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>;
@@ -967,6 +978,8 @@ export function SetUltrabeamDirection(arg1:number):Promise<void>;
 
 export function SetWinkeyerTrace(arg1:boolean):Promise<void>;
 
+export function SetWorkedCallVariants(arg1:boolean):Promise<void>;
+
 export function SetYaesuAFGain(arg1:number):Promise<void>;
 
 export function SetYaesuAGC(arg1:string):Promise<void>;
@@ -1043,6 +1056,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>;
@@ -1075,6 +1090,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

@@ -966,6 +966,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']();
 }
@@ -978,6 +986,10 @@ export function GetWinkeyerStatus() {
   return window['go']['main']['App']['GetWinkeyerStatus']();
 }
 
+export function GetWorkedCallVariants() {
+  return window['go']['main']['App']['GetWorkedCallVariants']();
+}
+
 export function GetYaesuState() {
   return window['go']['main']['App']['GetYaesuState']();
 }
@@ -1418,6 +1430,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']();
 }
@@ -1770,6 +1786,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);
 }
@@ -1882,6 +1902,10 @@ export function SetWinkeyerTrace(arg1) {
   return window['go']['main']['App']['SetWinkeyerTrace'](arg1);
 }
 
+export function SetWorkedCallVariants(arg1) {
+  return window['go']['main']['App']['SetWorkedCallVariants'](arg1);
+}
+
 export function SetYaesuAFGain(arg1) {
   return window['go']['main']['App']['SetYaesuAFGain'](arg1);
 }
@@ -2034,6 +2058,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']();
 }
@@ -2098,6 +2126,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

@@ -325,6 +325,8 @@ export namespace award {
 	    emission?: string[];
 	    confirm: string[];
 	    validate?: string[];
+	    confirm_field?: string;
+	    confirm_value?: string;
 	    grant_codes?: string;
 	    export_credit_granted?: boolean;
 	    total: number;
@@ -367,6 +369,8 @@ export namespace award {
 	        this.emission = source["emission"];
 	        this.confirm = source["confirm"];
 	        this.validate = source["validate"];
+	        this.confirm_field = source["confirm_field"];
+	        this.confirm_value = source["confirm_value"];
 	        this.grant_codes = source["grant_codes"];
 	        this.export_credit_granted = source["export_credit_granted"];
 	        this.total = source["total"];
@@ -3263,6 +3267,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;
@@ -4809,6 +4827,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/award/award.go

@@ -111,6 +111,18 @@ type Def struct {
 	// --- Confirmation ---
 	Confirm  []string `json:"confirm"`            // worked-confirmed: lotw|qsl|eqsl|qrzcom|custom
 	Validate []string `json:"validate,omitempty"` // validated/granted sources
+	// The "custom" source, for confirmations OpsLog has no dedicated column for:
+	// ConfirmField names a QSO field or an ADIF extras key, ConfirmValue the
+	// value(s) that count (comma-separated, case-insensitive).
+	//
+	// An EMPTY ConfirmValue means "any non-empty value confirms" — which is what
+	// the OpsLog card marker needs: APP_OPSLOG_QSL_RCVD stores the timestamp of
+	// the day the card arrived, not a Y/N flag. The same shape serves a key
+	// stamped by an outside source (a club's CSV imported into an extras field),
+	// so one mechanism covers every "confirmed somewhere else" case instead of a
+	// new checkbox per site.
+	ConfirmField string `json:"confirm_field,omitempty"`
+	ConfirmValue string `json:"confirm_value,omitempty"`
 	// NOT IMPLEMENTED. Kept so the values operators already typed are not lost, but
 	// nothing reads them: no ADIF export has ever written CREDIT_GRANTED. Their
 	// controls have been removed from the editor — a checkbox that quietly does
@@ -523,8 +535,8 @@ func Compute(defs []Def, qsos []qso.QSO, refMetas map[string][]RefMeta, nameOf N
 			}
 			band := strings.ToLower(strings.TrimSpace(q.Band))
 			modeClass := ModeClass(q.Mode)
-			isConf := confirmed(q, d.Confirm)
+			isConf := confirmed(q, d.Confirm, d)
-			isVal := confirmed(q, d.Validate)
+			isVal := confirmed(q, d.Validate, d)
 			for _, ref := range refs {
 				a := agg[i][ref]
 				if a == nil {
@@ -685,8 +697,9 @@ func manualRefs(q *qso.QSO, code string) []string {
 }
 
 // Confirmed reports whether a QSO satisfies any of the given confirmation
-// sources (lotw|qsl|eqsl). Exported for the statistics view.
+// sources (lotw|qsl|eqsl|qrzcom|custom). Exported for the statistics view.
-func Confirmed(q *qso.QSO, sources []string) bool { return confirmed(q, sources) }
+// The Def is needed for the "custom" source, which reads the field IT names.
+func Confirmed(q *qso.QSO, d Def, sources []string) bool { return confirmed(q, sources, &d) }
 
 // InScope reports whether a QSO falls within an award's scope (DXCC entity,
 // bands, modes, emission, dates) — independent of whether a reference was
@@ -780,6 +793,10 @@ func searchOne(field, matchBy string, re *regexp.Regexp, exact bool, leading, tr
 	byDesc := predefined && strings.EqualFold(strings.TrimSpace(matchBy), "description")
 
 	var found []string
+	// codesAreFinal: this branch produced references straight from the award's
+	// LIST, so they are already whole codes. The blanket prefix at the end must
+	// leave them alone — prefixing a code that is already "D74" yields "DD74".
+	codesAreFinal := false
 	switch {
 	case re != nil:
 		// Award-level regex: capture group 1 (or whole match) for each hit.
@@ -788,6 +805,7 @@ func searchOne(field, matchBy string, re *regexp.Regexp, exact bool, leading, tr
 		// Match references by their DESCRIPTION/name appearing in the field
 		// (e.g. WAJA finds the prefecture name inside the QTH). ExactMatch means
 		// the field equals the name; otherwise the name is a substring of it.
+		codesAreFinal = true
 		up := strings.ToUpper(raw)
 		for _, nc := range rl.names {
 			if exact {
@@ -810,9 +828,23 @@ func searchOne(field, matchBy string, re *regexp.Regexp, exact bool, leading, tr
 		// "Search reference inside the field": look up each token of the field in
 		// the list — O(tokens), not O(all references) — plus test the few
 		// references that declare a regex.
+		codesAreFinal = true
 		for _, tok := range tokenize(raw) {
 			if _, ok := rl.byCode[tok]; ok {
 				found = append(found, tok)
+				continue
+			}
+			// The field may carry the reference WITHOUT the award's letter: a French
+			// operator writes "74" in STATE while the DDFM codes are "D74". Prefix is
+			// exactly what that case is for, so try the prefixed form HERE — applying
+			// it after the lookup (as the blanket pass below used to) could never
+			// help, because the lookup is the step that failed. Without this, the
+			// only way to match a bare department was to write a regex, in a mode
+			// where the operator had chosen "code" and not "pattern".
+			if prefix != "" {
+				if _, ok := rl.byCode[prefix+tok]; ok {
+					found = append(found, prefix+tok)
+				}
 			}
 		}
 		for _, code := range rl.withPattern {
@@ -826,7 +858,7 @@ func searchOne(field, matchBy string, re *regexp.Regexp, exact bool, leading, tr
 		// counts each reference separately.
 		found = splitRefs(raw)
 	}
-	if prefix != "" {
+	if prefix != "" && !codesAreFinal {
 		for i := range found {
 			found[i] = prefix + found[i]
 		}
@@ -1374,7 +1406,7 @@ func dxccAllowed(dxcc *int, filter []int) bool {
 
 // confirmed reports whether the QSO satisfies any accepted confirmation source.
 // ADIF *_QSL_RCVD values Y (confirmed) and V (verified) both count.
-func confirmed(q *qso.QSO, sources []string) bool {
+func confirmed(q *qso.QSO, sources []string, d *Def) bool {
 	for _, s := range sources {
 		switch s {
 		case "lotw":
@@ -1389,11 +1421,66 @@ func confirmed(q *qso.QSO, sources []string) bool {
 			if isYes(q.EQSLRcvd) {
 				return true
 			}
+		case "qrzcom":
+			// The DOWNLOAD status, not the upload one: uploading a QSO to QRZ is
+			// us telling them, not them confirming it back.
+			if isYes(q.QRZComDownloadStatus) {
+				return true
+			}
+		case "custom":
+			if customConfirmed(q, d) {
+				return true
+			}
 		}
 	}
 	return false
 }
 
+// customConfirmed answers the operator-defined confirmation source: the field
+// named by ConfirmField, optionally required to hold one of ConfirmValue's
+// comma-separated values.
+//
+// A source that names no field confirms NOTHING. That is deliberate: ticking
+// "custom" without saying what it means used to mark every QSO as unconfirmed
+// anyway, and silently marking them all CONFIRMED instead would be far worse.
+func customConfirmed(q *qso.QSO, d *Def) bool {
+	if d == nil {
+		return false
+	}
+	field := strings.TrimSpace(d.ConfirmField)
+	if field == "" {
+		return false
+	}
+	got := strings.TrimSpace(customFieldValue(q, field))
+	if got == "" {
+		return false
+	}
+	want := strings.TrimSpace(d.ConfirmValue)
+	if want == "" {
+		return true // any value at all counts — see ConfirmField's doc
+	}
+	for _, w := range strings.Split(want, ",") {
+		if w = strings.TrimSpace(w); w != "" && strings.EqualFold(w, got) {
+			return true
+		}
+	}
+	return false
+}
+
+// customFieldValue resolves the field a custom confirmation names: one of the
+// engine's known QSO fields first, then the ADIF extras — which is where the
+// OpsLog card marker (APP_OPSLOG_QSL_RCVD) and anything stamped by an outside
+// import actually live.
+func customFieldValue(q *qso.QSO, field string) string {
+	if v := strings.TrimSpace(fieldRaw(field, q)); v != "" {
+		return v
+	}
+	if q.Extras == nil {
+		return ""
+	}
+	return q.Extras[strings.ToUpper(strings.TrimSpace(field))]
+}
+
 func isYes(v string) bool {
 	switch strings.ToUpper(strings.TrimSpace(v)) {
 	case "Y", "V":

internal/award/catalog/rda.json

@@ -20,7 +20,10 @@
         "match_by": "description"
       }
     ],
-    "dxcc_filter": null,
+    "dxcc_filter": [
+      15,
+      54
+    ],
     "valid_bands": [
       "160m",
       "60m",
@@ -43,7 +46,7 @@
     ],
     "total": 0,
     "builtin": true,
-    "version": 1
+    "version": 2
   },
   "references": [
     {

internal/award/confirm_test.go

@@ -0,0 +1,66 @@
+package award
+
+import (
+	"testing"
+
+	"hamlog/internal/qso"
+)
+
+// Every source the editor offers must actually do something. "qrzcom" and
+// "custom" were listed in the UI and in Def's doc comment but had no case in the
+// switch, so ticking either marked nothing as confirmed — a checkbox that is
+// trusted and silently inert.
+func TestConfirmedSources(t *testing.T) {
+	cases := []struct {
+		name    string
+		q       qso.QSO
+		d       Def
+		sources []string
+		want    bool
+	}{
+		{"lotw", qso.QSO{LOTWRcvd: "Y"}, Def{}, []string{"lotw"}, true},
+		{"qsl", qso.QSO{QSLRcvd: "Y"}, Def{}, []string{"qsl"}, true},
+		{"eqsl", qso.QSO{EQSLRcvd: "Y"}, Def{}, []string{"eqsl"}, true},
+
+		// QRZ confirms on the DOWNLOAD status. The upload one is us telling QRZ
+		// about the QSO, which is not a confirmation of anything.
+		{"qrz download", qso.QSO{QRZComDownloadStatus: "Y"}, Def{}, []string{"qrzcom"}, true},
+		{"qrz upload only", qso.QSO{QRZComUploadStatus: "Y"}, Def{}, []string{"qrzcom"}, false},
+
+		// Custom, no value required: any non-empty value counts. This is the
+		// OpsLog card case — the marker holds a timestamp, not a flag.
+		{"custom any value",
+			qso.QSO{Extras: map[string]string{"APP_OPSLOG_QSL_RCVD": "2026-08-09T01:00:00Z"}},
+			Def{ConfirmField: "APP_OPSLOG_QSL_RCVD"}, []string{"custom"}, true},
+		{"custom field empty",
+			qso.QSO{Extras: map[string]string{"APP_OPSLOG_QSL_RCVD": ""}},
+			Def{ConfirmField: "APP_OPSLOG_QSL_RCVD"}, []string{"custom"}, false},
+
+		// Custom with an explicit value list, matched case-insensitively.
+		{"custom value match",
+			qso.QSO{Extras: map[string]string{"APP_CLUB_CONF": "v"}},
+			Def{ConfirmField: "APP_CLUB_CONF", ConfirmValue: "Y,V"}, []string{"custom"}, true},
+		{"custom value mismatch",
+			qso.QSO{Extras: map[string]string{"APP_CLUB_CONF": "N"}},
+			Def{ConfirmField: "APP_CLUB_CONF", ConfirmValue: "Y,V"}, []string{"custom"}, false},
+
+		// A custom source naming no field must confirm NOTHING — never everything.
+		{"custom without a field",
+			qso.QSO{Extras: map[string]string{"APP_OPSLOG_QSL_RCVD": "x"}},
+			Def{}, []string{"custom"}, false},
+
+		// Known QSO fields resolve too, not just extras.
+		{"custom on a known field", qso.QSO{State: "TX"},
+			Def{ConfirmField: "state", ConfirmValue: "TX"}, []string{"custom"}, true},
+
+		// Any source in the list is enough.
+		{"first source misses, second hits", qso.QSO{EQSLRcvd: "Y"}, Def{},
+			[]string{"lotw", "eqsl"}, true},
+		{"no source set", qso.QSO{LOTWRcvd: "Y"}, Def{}, nil, false},
+	}
+	for _, c := range cases {
+		if got := Confirmed(&c.q, c.d, c.sources); got != c.want {
+			t.Errorf("%s: Confirmed = %v, want %v", c.name, got, c.want)
+		}
+	}
+}

internal/award/prefix_test.go

@@ -0,0 +1,81 @@
+package award
+
+import (
+	"testing"
+
+	"hamlog/internal/qso"
+)
+
+// ddfmLike is a small stand-in for the French departments award: predefined
+// references whose codes carry a letter the operator does not type.
+func ddfmLike() []Def {
+	return []Def{{
+		Code: "DDFM", Name: "Departments", Type: TypeQSOFields,
+		Field: "state", MatchBy: "code", Prefix: "D",
+	}}
+}
+
+func ddfmRefs() map[string][]RefMeta {
+	return map[string][]RefMeta{"DDFM": {
+		{Code: "D29", Name: "Finistère", Valid: true},
+		{Code: "D49", Name: "Maine-et-Loire", Valid: true},
+		{Code: "D74", Name: "Haute-Savoie", Valid: true},
+	}}
+}
+
+func refsOf(t *testing.T, defs []Def, q qso.QSO) []string {
+	t.Helper()
+	res := Compute(defs, []qso.QSO{q}, ddfmRefs(), nil)
+	if len(res) != 1 {
+		t.Fatalf("want 1 result, got %d", len(res))
+	}
+	var out []string
+	for _, r := range res[0].Refs {
+		if r.Worked {
+			out = append(out, r.Ref)
+		}
+	}
+	return out
+}
+
+// The reported case: the operator writes just "74" in STATE, the award's codes
+// are "D74", match-by is "code" and a Prefix of "D" is set. That found nothing —
+// the prefix was applied only AFTER the list lookup, i.e. after the step that
+// had already failed — so the only workaround was a regex, in a mode where the
+// operator had explicitly chosen "code" rather than "pattern".
+func TestPrefixCompletesABareReference(t *testing.T) {
+	got := refsOf(t, ddfmLike(), qso.QSO{Callsign: "F5AYE", State: "74"})
+	if len(got) != 1 || got[0] != "D74" {
+		t.Errorf("bare state 74 with prefix D → %v, want [D74]", got)
+	}
+}
+
+// And a field that ALREADY holds the whole code must not be prefixed twice.
+// The blanket pass turned "D74" into "DD74" whenever a prefix was configured.
+func TestPrefixDoesNotDoubleUpOnACompleteCode(t *testing.T) {
+	got := refsOf(t, ddfmLike(), qso.QSO{Callsign: "F5AYE", State: "D74"})
+	if len(got) != 1 || got[0] != "D74" {
+		t.Errorf("state D74 with prefix D → %v, want [D74]", got)
+	}
+}
+
+// A token that is neither a code nor a prefixable one stays unmatched: the
+// prefix must not invent references.
+func TestPrefixDoesNotInventReferences(t *testing.T) {
+	if got := refsOf(t, ddfmLike(), qso.QSO{Callsign: "F5AYE", State: "99"}); len(got) != 0 {
+		t.Errorf("unknown department 99 → %v, want none", got)
+	}
+}
+
+// Without a prefix nothing changes: a bare number matches nothing, a full code
+// matches itself.
+func TestNoPrefixKeepsExactCodeMatching(t *testing.T) {
+	defs := ddfmLike()
+	defs[0].Prefix = ""
+	if got := refsOf(t, defs, qso.QSO{Callsign: "F5AYE", State: "74"}); len(got) != 0 {
+		t.Errorf("no prefix, state 74 → %v, want none", got)
+	}
+	if got := refsOf(t, defs, qso.QSO{Callsign: "F5AYE", State: "D74"}); len(got) != 1 || got[0] != "D74" {
+		t.Errorf("no prefix, state D74 → %v, want [D74]", got)
+	}
+}

internal/integrations/udp/describe_test.go

@@ -0,0 +1,43 @@
+package udp
+
+import (
+	"strings"
+	"testing"
+)
+
+// The diagnostic that matters: a text payload arriving on a WSJT port must be
+// READABLE in the log. "bad magic 0x3132372e" alone told the operator nothing —
+// those four bytes are ASCII "127.", i.e. some program broadcasting an address
+// where WSJT-X binary was expected.
+func TestDescribePacketShowsTextAndHex(t *testing.T) {
+	got := describePacket([]byte("127.0.0.1:4532"))
+	for _, want := range []string{`14 bytes`, `"127.0.0.1:4532"`, `31 32 37 2e`} {
+		if !strings.Contains(got, want) {
+			t.Errorf("describePacket missing %q\ngot: %s", want, got)
+		}
+	}
+}
+
+// Binary stays inspectable: unprintable bytes become dots in the preview and
+// the hex carries the real values.
+func TestDescribePacketHandlesBinary(t *testing.T) {
+	got := describePacket([]byte{0xad, 0xbc, 0xcb, 0xda, 0x00})
+	if !strings.Contains(got, `"....."`) || !strings.Contains(got, "ad bc cb da 00") {
+		t.Errorf("binary preview wrong: %s", got)
+	}
+}
+
+// A long datagram is truncated, and says so, rather than dumping a whole packet
+// into the log on every line.
+func TestDescribePacketTruncates(t *testing.T) {
+	got := describePacket([]byte(strings.Repeat("A", 300)))
+	if !strings.Contains(got, "300 bytes") {
+		t.Errorf("lost the real length: %s", got)
+	}
+	if !strings.Contains(got, "…") {
+		t.Errorf("truncation not marked: %s", got)
+	}
+	if strings.Count(got, "41 ") > 96 {
+		t.Errorf("hex not capped: %s", got)
+	}
+}

internal/integrations/udp/forwarder_test.go

@@ -0,0 +1,63 @@
+package udp
+
+import (
+	"bytes"
+	"testing"
+)
+
+// Bytes captured from a real W&P relay in front of MSHV: the origin as text,
+// a '|', then the untouched WSJT-X packet. This exact datagram produced
+// "bad magic 0x3132372e" — 0x3132372e being ASCII "127.".
+var wpDecode = []byte{
+	// "127.0.0.1:2237|"
+	0x31, 0x32, 0x37, 0x2e, 0x30, 0x2e, 0x30, 0x2e, 0x31, 0x3a, 0x32, 0x32, 0x33, 0x37, 0x7c,
+	// magic, schema 3, type 2 (Decode), id "MSHV"
+	0xad, 0xbc, 0xcb, 0xda, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
+	0x00, 0x00, 0x00, 0x04, 0x4d, 0x53, 0x48, 0x56,
+	0x01, 0x01, 0x4b, 0x31, 0x28, 0x00, 0x00, 0x00, 0x16,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x8a,
+	0x00, 0x00, 0x00, 0x03, 0x46, 0x54, 0x38, // "FT8"
+	0x00, 0x00, 0x00, 0x0e, 0x54, 0x4e, 0x38, 0x47, 0x44, 0x20, 0x39, 0x41, 0x31, 0x4d, 0x4d, 0x20, 0x37, 0x33, // "TN8GD 9A1MM 73"
+	0x00, 0x00,
+}
+
+func TestParseWSJTBehindAForwarder(t *testing.T) {
+	if _, _, err := ParseWSJT(wpDecode); err != nil {
+		t.Fatalf("relayed packet still fails: %v", err)
+	}
+	// And the header is what was in the way: without it the same bytes parse.
+	if _, _, err := ParseWSJT(wpDecode[15:]); err != nil {
+		t.Fatalf("bare packet fails: %v", err)
+	}
+}
+
+func TestStripForwarderHeader(t *testing.T) {
+	bare := wpDecode[15:]
+
+	if got := stripForwarderHeader(bare); !bytes.Equal(got, bare) {
+		t.Error("a packet with no header must be returned untouched")
+	}
+	if got := stripForwarderHeader(wpDecode); !bytes.Equal(got, bare) {
+		t.Error("the text header was not stripped")
+	}
+
+	// A BINARY prefix is not a forwarder header — refusing it is what stops a
+	// corrupt packet that merely contains the magic from becoming a QSO.
+	binPrefix := append([]byte{0x00, 0x01, 0x02}, bare...)
+	if got := stripForwarderHeader(binPrefix); !bytes.Equal(got, binPrefix) {
+		t.Error("a non-printable prefix must not be treated as a header")
+	}
+
+	// Beyond the window, the magic is ignored however printable the prefix is.
+	far := append(bytes.Repeat([]byte("A"), maxFwdHeader+1), bare...)
+	if got := stripForwarderHeader(far); !bytes.Equal(got, far) {
+		t.Error("magic past maxFwdHeader must not be trusted")
+	}
+
+	// No magic anywhere, and runt packets, must not panic or invent anything.
+	for _, junk := range [][]byte{[]byte("127.0.0.1:2237|hello"), {}, {0xad}, {0xad, 0xbc, 0xcb}} {
+		if got := stripForwarderHeader(junk); !bytes.Equal(got, junk) {
+			t.Errorf("junk %q was altered", junk)
+		}
+	}
+}

internal/integrations/udp/server.go

@@ -94,6 +94,47 @@ type Server struct {
 	// id is distinct whenever there is more than one.
 	dialHz map[string]int64
 	lastDX     string // WSJT: last non-empty DX Call seen, to detect a clear
+
+	// badPkts counts datagrams this listener could not parse, so the diagnostic
+	// dump below stays bounded. A misconfigured port is not a one-off: the
+	// sender that produced "bad magic 0x3132372e" put out ~150 packets a second,
+	// which fills the whole rotating log with the same line and buries the
+	// evidence of anything else.
+	badPkts int
+}
+
+// maxBadPktDumps is how many unparseable datagrams a listener describes in full
+// before going quiet. Enough to identify the sender and the payload; few enough
+// that a permanently misconfigured port costs a handful of lines, not a log.
+const maxBadPktDumps = 5
+
+// describePacket renders a datagram for the log: its size, a printable preview
+// and the first bytes in hex.
+//
+// Both forms, deliberately. "bad magic 0x3132372e" is already readable as ASCII
+// "127." to someone who thinks to decode it — and that one fact (the sender is
+// emitting text, not WSJT-X binary) is the whole diagnosis. The hex stays for
+// the case where the payload really is binary and the preview shows nothing.
+func describePacket(pkt []byte) string {
+	const maxShown = 96
+	head := pkt
+	if len(head) > maxShown {
+		head = head[:maxShown]
+	}
+	var text, hex strings.Builder
+	for _, b := range head {
+		if b >= 0x20 && b < 0x7f {
+			text.WriteByte(b)
+		} else {
+			text.WriteByte('.')
+		}
+		fmt.Fprintf(&hex, "%02x ", b)
+	}
+	more := ""
+	if len(pkt) > maxShown {
+		more = "…"
+	}
+	return fmt.Sprintf("%d bytes | text %q%s | hex %s%s", len(pkt), text.String(), more, strings.TrimSpace(hex.String()), more)
 }
 
 func newServer(cfg Config, out chan<- Event) *Server {
@@ -201,13 +242,38 @@ func (s *Server) run() {
 	}
 }
 
+// logBadPacket reports a datagram this listener could not parse, with enough of
+// it to identify the sender — then falls silent.
+//
+// The point is the SENDER: an unparseable packet on a WSJT port almost always
+// means another program is broadcasting on it, or the service type is wrong for
+// what is actually arriving. The remote address names the culprit, and the
+// payload preview says what it really is. Neither was logged before, so the
+// operator saw only a magic number repeated a few hundred times a second.
+func (s *Server) logBadPacket(kind string, remote *net.UDPAddr, pkt []byte, err error) {
+	s.mu.Lock()
+	s.badPkts++
+	n := s.badPkts
+	s.mu.Unlock()
+	if n > maxBadPktDumps {
+		return
+	}
+	applog.Printf("udp: [%s] %s parse error from %s: %v — %s\n",
+		s.cfg.Name, kind, remote, err, describePacket(pkt))
+	if n == maxBadPktDumps {
+		applog.Printf("udp: [%s] further unparseable packets on port %d will not be logged — "+
+			"check that the sender belongs on this port and that the service type matches\n",
+			s.cfg.Name, s.cfg.Port)
+	}
+}
+
 func (s *Server) handle(pkt []byte, remote *net.UDPAddr) {
 	ev := Event{ConfigID: s.cfg.ID, Service: s.cfg.ServiceType, Source: remote.String()}
 	switch s.cfg.ServiceType {
 	case ServiceWSJT:
 		w, ok, err := ParseWSJT(pkt)
 		if err != nil {
-			applog.Printf("udp: [%s] WSJT parse error: %v\n", s.cfg.Name, err)
+			s.logBadPacket("WSJT", remote, pkt, err)
 			return
 		}
 		if !ok {
@@ -321,7 +387,7 @@ func (s *Server) handle(pkt []byte, remote *net.UDPAddr) {
 	case ServiceN1MM:
 		adifText, ok, err := ParseN1MM(pkt)
 		if err != nil {
-			applog.Printf("udp: [%s] N1MM parse error: %v\n", s.cfg.Name, err)
+			s.logBadPacket("N1MM", remote, pkt, err)
 			return
 		}
 		if !ok {

internal/integrations/udp/wsjt.go

@@ -56,12 +56,61 @@ type WSJTEvent struct {
 	IsCQ        bool   // the decode was a CQ call
 }
 
+// maxFwdHeader bounds how far into a packet the WSJT-X magic may sit behind a
+// forwarder's header. The one seen in the field ("127.0.0.1:2237|") is 15 bytes;
+// 64 leaves room for a longer address without ever scanning a real payload.
+const maxFwdHeader = 64
+
+// stripForwarderHeader removes the origin header a UDP relay prepends.
+//
+// A relay that re-broadcasts WSJT-X traffic has to say where each datagram came
+// from, and it does so as plain text in front of the payload:
+//
+//	"127.0.0.1:2237|" + <the original, untouched WSJT-X packet>
+//
+// The magic then sits 15 bytes in, every packet fails on "bad magic", and an
+// operator running MSHV behind such a relay gets nothing at all. There is no
+// need for a separate service type: what follows the header IS a WSJT-X packet,
+// so the whole parser and everything downstream apply unchanged.
+//
+// Deliberately narrow. The magic must appear within maxFwdHeader bytes AND
+// everything before it must be printable ASCII — a truncated or corrupt packet
+// that happens to contain those four bytes somewhere is not resurrected into a
+// QSO. Anything else is returned untouched, and still fails as it did.
+func stripForwarderHeader(pkt []byte) []byte {
+	if len(pkt) < 4 {
+		return pkt
+	}
+	if binary.BigEndian.Uint32(pkt) == wsjtMagic {
+		return pkt // no header — the overwhelmingly common case
+	}
+	limit := len(pkt) - 4
+	if limit > maxFwdHeader {
+		limit = maxFwdHeader
+	}
+	for i := 1; i <= limit; i++ {
+		if binary.BigEndian.Uint32(pkt[i:]) != wsjtMagic {
+			continue
+		}
+		for _, b := range pkt[:i] {
+			if b < 0x20 || b >= 0x7f {
+				return pkt // not a text header — leave it alone
+			}
+		}
+		return pkt[i:]
+	}
+	return pkt
+}
+
 // ParseWSJT decodes one UDP packet. Returns ok=false for messages we
 // don't care about (heartbeat, clears, etc.).
 func ParseWSJT(pkt []byte) (WSJTEvent, bool, error) {
 	if len(pkt) < 12 {
 		return WSJTEvent{}, false, fmt.Errorf("packet too short")
 	}
+	// A relay (W&P and friends) puts its own origin header in front — skip it so
+	// the packet parses exactly as if it had arrived from WSJT-X directly.
+	pkt = stripForwarderHeader(pkt)
 	r := bytes.NewReader(pkt)
 	var magic, schema, mtype uint32
 	if err := binary.Read(r, binary.BigEndian, &magic); err != nil {

internal/qso/callmatch_test.go

@@ -0,0 +1,34 @@
+package qso
+
+import "testing"
+
+// The predicate behind "Worked before". Exact when folding is off; with it on,
+// a station's portable forms are one operator — and the fold has to work from
+// either end, because you may type the base call or the portable one.
+func TestCallMatch(t *testing.T) {
+	if pred, args := callMatch("RK3DWA", false); pred != "callsign = ?" || len(args) != 1 || args[0] != "RK3DWA" {
+		t.Errorf("exact: got %q %v", pred, args)
+	}
+
+	// Typing the base call: match it and everything suffixed off it.
+	pred, args := callMatch("RK3DWA", true)
+	if pred != "(callsign = ? OR callsign LIKE ?)" {
+		t.Errorf("variants predicate = %q", pred)
+	}
+	if len(args) != 2 || args[0] != "RK3DWA" || args[1] != "RK3DWA/%" {
+		t.Errorf("variants args = %v, want [RK3DWA RK3DWA/%%]", args)
+	}
+
+	// Typing a portable form must reach the plain call too — the suffix is
+	// stripped from the INPUT, not just matched in the column.
+	_, args = callMatch("RK3DWA/3", true)
+	if len(args) != 2 || args[0] != "RK3DWA" || args[1] != "RK3DWA/%" {
+		t.Errorf("portable input args = %v, want [RK3DWA RK3DWA/%%]", args)
+	}
+
+	// A leading slash is not a suffix marker — dropping to "" there would match
+	// the entire logbook.
+	if _, args := callMatch("/RK3DWA", true); args[0] != "/RK3DWA" {
+		t.Errorf("leading slash: args[0] = %v, want the call unchanged", args[0])
+	}
+}

internal/qso/qso.go

@@ -1585,11 +1585,35 @@ type BandMode struct {
 // rendering a recent-contacts mini-list.
 const maxWorkedEntries = 50
 
+// callMatch builds the WHERE fragment that selects one station's QSOs.
+//
+// Exact by default. With variants on, an operator's portable forms count as the
+// same station: RK3DWA, RK3DWA/3, RK3DWA/P and RK3DWA/QRP are one person, and
+// someone asking "have I worked RK3DWA?" means the person, not the string.
+// Typing 21 QSOs' worth of history only when you happen to add "/3" is the
+// behaviour this replaces. The suffix is stripped from what was TYPED too, so
+// it matches both ways round — RK3DWA/3 also finds the plain RK3DWA contacts.
+//
+// Deliberately NOT a bare "starts with": LIKE 'RK3DWA%' would also drag in
+// RK3DWAB, which is a different station. The '/' is what makes it the same one.
+func callMatch(call string, variants bool) (string, []any) {
+	if !variants {
+		return "callsign = ?", []any{call}
+	}
+	base := call
+	if i := strings.IndexByte(base, '/'); i > 0 {
+		base = base[:i]
+	}
+	return "(callsign = ? OR callsign LIKE ?)", []any{base, base + "/%"}
+}
+
 // WorkedBefore returns aggregated history at both callsign and DXCC level.
 // dxccHint lets the caller pass a known DXCC number (e.g. from a fresh QRZ
 // lookup) when the call has never been worked. If 0, the DXCC is inferred
 // from the most recent prior QSO with the same callsign.
-func (r *Repo) WorkedBefore(ctx context.Context, callsign string, dxccHint int) (WorkedBefore, error) {
+//
+// matchVariants folds the portable forms of the call together — see callMatch.
+func (r *Repo) WorkedBefore(ctx context.Context, callsign string, dxccHint int, matchVariants bool) (WorkedBefore, error) {
 	wb := WorkedBefore{
 		Callsign:      upperTrim(callsign),
 		Bands:         []string{},
@@ -1605,17 +1629,18 @@ func (r *Repo) WorkedBefore(ctx context.Context, callsign string, dxccHint int)
 	}
 
 	// ---- Per-callsign stats ----
+	pred, predArgs := callMatch(wb.Callsign, matchVariants)
 	if err := r.db.QueryRowContext(ctx,
-		`SELECT COUNT(*) FROM qso WHERE callsign = ?`, wb.Callsign).Scan(&wb.Count); err != nil {
+		`SELECT COUNT(*) FROM qso WHERE `+pred, predArgs...).Scan(&wb.Count); err != nil {
 		return wb, fmt.Errorf("count worked: %w", err)
 	}
 	if wb.Count > 0 {
 		// Pull the full QSO records (same columns as the Recent QSOs list) so
 		// the Worked-before grid can offer the same rich column picker.
 		rows, err := r.db.QueryContext(ctx, `SELECT `+selectCols+`
-            FROM qso WHERE callsign = ?
+            FROM qso WHERE `+pred+`
             ORDER BY qso_date DESC, id DESC
-            LIMIT ?`, wb.Callsign, maxWorkedEntries)
+            LIMIT ?`, append(append([]any{}, predArgs...), maxWorkedEntries)...)
 		if err != nil {
 			return wb, fmt.Errorf("query worked: %w", err)
 		}
@@ -1648,7 +1673,7 @@ func (r *Repo) WorkedBefore(ctx context.Context, callsign string, dxccHint int)
 		if wb.Count > maxWorkedEntries {
 			var firstStr sql.NullString
 			_ = r.db.QueryRowContext(ctx,
-				`SELECT MIN(qso_date) FROM qso WHERE callsign = ?`, wb.Callsign).Scan(&firstStr)
+				`SELECT MIN(qso_date) FROM qso WHERE `+pred, predArgs...).Scan(&firstStr)
 			if firstStr.Valid {
 				wb.First = parseTimeLoose(firstStr.String)
 			}
@@ -1673,8 +1698,8 @@ func (r *Repo) WorkedBefore(ctx context.Context, callsign string, dxccHint int)
 		var d sql.NullInt64
 		_ = r.db.QueryRowContext(ctx, `
             SELECT dxcc FROM qso
-            WHERE callsign = ? AND dxcc IS NOT NULL
+            WHERE `+pred+` AND dxcc IS NOT NULL
-            ORDER BY qso_date DESC LIMIT 1`, wb.Callsign).Scan(&d)
+            ORDER BY qso_date DESC LIMIT 1`, predArgs...).Scan(&d)
 		if d.Valid {
 			dxcc = int(d.Int64)
 		}

internal/webpub/webpub.go

@@ -0,0 +1,377 @@
+// 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)}
+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 {
+		b.WriteString(`<tr>`)
+		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. Kept tiny and dependency-free: the page has to work
+// offline and on any hosting.
+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),
+        asc=th.dataset.asc!=='1';
+    rows.sort(function(a,b){
+      var x=a.cells[i].textContent.trim(), y=b.cells[i].textContent.trim(),
+          nx=parseFloat(x), ny=parseFloat(y),
+          n=!isNaN(nx)&&!isNaN(ny)&&x!==''&&y!=='';
+      var c=n?(nx-ny):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});
+    th.dataset.asc=asc?'1':'0';
+  });
+});
+</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
+}

telemetry.go

@@ -21,7 +21,7 @@ import (
 
 const (
 	// appVersion is stamped on every heartbeat (and could feed the About box).
-	appVersion = "0.23.9"
+	appVersion = "0.24.2"
 
 	// 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)
+}