chore: release v0.24.1

The input was bound straight to the number and committed on every keystroke, so
it could not be EMPTIED: clearing it yields "", Number("") is 0, 0 fails the
"> 0" guard, the state never moved, and value={qsoLimit} snapped the old figure
straight back. Going from 200000 down to 100 was a fight against the field — and
read as the setting refusing to persist, which it was not: writeUiPref stores it
and syncPortablePrefs makes the database authoritative at boot. It also wrote
the preference once per keystroke (1, then 10, then 100).

Raw text in local state, committed on blur or Enter, per the controlled-input
note in CLAUDE.md.

app_awards_tracked.go

@@ -0,0 +1,57 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	wruntime "github.com/wailsapp/wails/v2/pkg/runtime"
+)
+
+// keyAwardsTracked holds the PER-PROFILE list of award codes the operator wants
+// to follow (JSON array of award.Def.Code). Award definitions themselves are
+// global (keyAwardDefs, shared across profiles), but WHICH awards a station
+// tracks is a per-profile choice — a DX profile follows DXCC/WPX, a POTA profile
+// follows POTA/WWFF. An empty/unset list means "track them all" so the Awards
+// tab is never blank before the operator has picked anything.
+const keyAwardsTracked = "awards.tracked"
+
+// GetTrackedAwards returns the active profile's followed award codes. An empty
+// slice means the operator has not narrowed the list — the Awards tab then shows
+// every award.
+func (a *App) GetTrackedAwards() ([]string, error) {
+	out := []string{}
+	if a.settings == nil {
+		return out, nil
+	}
+	s, _ := a.settings.Get(a.ctx, keyAwardsTracked)
+	if strings.TrimSpace(s) == "" {
+		return out, nil
+	}
+	if err := json.Unmarshal([]byte(s), &out); err != nil {
+		return []string{}, nil
+	}
+	return out, nil
+}
+
+// SaveTrackedAwards persists the followed award codes for the active profile and
+// notifies the Awards tab to re-filter its list. Codes are stored verbatim; the
+// Awards tab intersects them with the live award definitions, so a code that no
+// longer exists is simply ignored (not an error).
+func (a *App) SaveTrackedAwards(codes []string) error {
+	if a.settings == nil {
+		return fmt.Errorf("db not initialized")
+	}
+	if codes == nil {
+		codes = []string{}
+	}
+	b, err := json.Marshal(codes)
+	if err != nil {
+		return err
+	}
+	if err := a.settings.Set(a.ctx, keyAwardsTracked, string(b)); err != nil {
+		return err
+	}
+	wruntime.EventsEmit(a.ctx, "awards:tracked-changed")
+	return nil
+}

app_gate.go

@@ -0,0 +1,60 @@
+package main
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"os"
+	"strings"
+)
+
+// deniedCallHashes lists station callsigns not permitted to run this build,
+// stored as SHA-256 hex of the base call so the calls themselves appear nowhere
+// in the source or the compiled binary. Enforcement is best-effort by design —
+// the call is entered by the operator and can be changed — so this only turns
+// away straightforward use, not a determined one.
+var deniedCallHashes = map[string]struct{}{
+	"2282a88b3e5e4eebc6b8174d005bb46d32025758b7741bdcf34f2b3621c02205": {},
+	"0ee09fe60817a2a4982f5e5b14a60b8dbb11cff55b3d36661213c4cbdd0933ea": {},
+	"46fb61e71afb40627cb6493a6a59c9d4d0231ee3cad1a2bf3fcc4cdfce36fabc": {},
+}
+
+// callDenied reports whether a callsign is on deniedCallHashes. The call is
+// reduced to its base form (upper-cased, portable prefix/suffix dropped) the
+// same way extsvc does, so F4XYZ/P matches F4XYZ.
+func callDenied(call string) bool {
+	base := denyBaseCall(call)
+	if base == "" {
+		return false
+	}
+	sum := sha256.Sum256([]byte(base))
+	_, bad := deniedCallHashes[hex.EncodeToString(sum[:])]
+	return bad
+}
+
+// denyBaseCall mirrors extsvc.baseCall: for a slashed form it returns the
+// longest token (the real call), otherwise the call itself, upper-cased.
+func denyBaseCall(s string) string {
+	s = strings.ToUpper(strings.TrimSpace(s))
+	if !strings.Contains(s, "/") {
+		return s
+	}
+	best := ""
+	for _, part := range strings.Split(s, "/") {
+		if len(part) > len(best) {
+			best = part
+		}
+	}
+	return best
+}
+
+// enforceCallGate exits the process silently when any of the supplied callsigns
+// is denied. Called once at startup, after the profiles are loaded: the first
+// launch is where the operator enters and saves the call, so a denied build
+// simply does not come back up on the next launch. No window, no message.
+func enforceCallGate(calls ...string) {
+	for _, c := range calls {
+		if callDenied(c) {
+			os.Exit(0)
+		}
+	}
+}

app_qsl_designer.go

@@ -31,13 +31,20 @@ import (
 const (
 	keyQSLEmailSubject = "qsl.email_subject"
 	keyQSLEmailBody    = "qsl.email_body"
-	keyQSLAutoSend     = "qsl.auto_send" // "1" → render+send an eQSL on log when an e-mail and default template exist
+	keyQSLAutoSend     = "qsl.auto_send"      // "1" → render+send an eQSL on log when an e-mail and default template exist
+	keyQSLDefaultMsg   = "qsl.default_message" // fallback QSL message printed on the card when the QSO's own QSLMSG is empty
 )
 
 // appQSLCardSentField is the ADIF APP_ field stamping when OpsLog e-mailed its
 // own QSL card. Deliberately NOT eqsl_sent (that's eQSL.cc's, kept independent).
 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 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"
+
 const (
 	defaultQSLEmailSubject = "eQSL — {CALL} de {MYCALL}"
 	defaultQSLEmailBody    = "Hi,\n\nThank you for our QSO! Please find attached your eQSL card.\n\n{DATE}  ·  {BAND}  ·  {MODE}\n\n73,\n{MYCALL}"
@@ -453,11 +460,37 @@ func (a *App) SendEQSL(qsoID int64, templateID int64, jpegB64 string) error {
 	return nil
 }
 
-// QSLEmailTemplates is the eQSL e-mail subject/body plus the auto-send toggle.
+// qslDefaultMessage returns the operator's default QSL message (Settings), used
+// on the card when a QSO has no QSLMSG of its own.
+func (a *App) qslDefaultMessage() string {
+	if a.settings == nil {
+		return ""
+	}
+	s, _ := a.settings.Get(a.ctx, keyQSLDefaultMsg)
+	return s
+}
+
+// SetOpsLogQSLReceived marks (or clears) that a QSL was received for a QSO. This
+// flips the card's PSE/TNX stamp. Stored as a timestamp in the QSO extras (a
+// single-key UPDATE, like the sent marker) so it survives concurrent uploads.
+func (a *App) SetOpsLogQSLReceived(qsoID int64, on bool) error {
+	if a.qso == nil {
+		return fmt.Errorf("db not initialized")
+	}
+	v := ""
+	if on {
+		v = time.Now().UTC().Format(time.RFC3339)
+	}
+	return a.qso.SetExtra(a.ctx, qsoID, appQSLCardRcvdField, v)
+}
+
+// QSLEmailTemplates is the eQSL e-mail subject/body, the auto-send toggle, and
+// the default QSL message printed on the card when a QSO has none of its own.
 type QSLEmailTemplates struct {
-	Subject  string `json:"subject"`
-	Body     string `json:"body"`
-	AutoSend bool   `json:"auto_send"`
+	Subject        string `json:"subject"`
+	Body           string `json:"body"`
+	AutoSend       bool   `json:"auto_send"`
+	DefaultMessage string `json:"default_message"`
 }
 
 // QSLGetEmailTemplates returns the eQSL e-mail templates (with defaults).
@@ -466,7 +499,7 @@ func (a *App) QSLGetEmailTemplates() (QSLEmailTemplates, error) {
 	if a.settings == nil {
 		return out, nil
 	}
-	m, err := a.settings.GetMany(a.ctx, keyQSLEmailSubject, keyQSLEmailBody, keyQSLAutoSend)
+	m, err := a.settings.GetMany(a.ctx, keyQSLEmailSubject, keyQSLEmailBody, keyQSLAutoSend, keyQSLDefaultMsg)
 	if err != nil {
 		return out, err
 	}
@@ -477,6 +510,7 @@ func (a *App) QSLGetEmailTemplates() (QSLEmailTemplates, error) {
 		out.Body = b
 	}
 	out.AutoSend = m[keyQSLAutoSend] == "1"
+	out.DefaultMessage = m[keyQSLDefaultMsg]
 	return out, nil
 }
 
@@ -495,7 +529,10 @@ func (a *App) QSLSaveEmailTemplates(t QSLEmailTemplates) error {
 	if t.AutoSend {
 		v = "1"
 	}
-	return a.settings.Set(a.ctx, keyQSLAutoSend, v)
+	if err := a.settings.Set(a.ctx, keyQSLAutoSend, v); err != nil {
+		return err
+	}
+	return a.settings.Set(a.ctx, keyQSLDefaultMsg, t.DefaultMessage)
 }
 
 // maybeAutoSendEQSL fires an eQSL render+send for a freshly-logged QSO when the
@@ -634,6 +671,18 @@ func (a *App) qslVars(q qso.QSO) (map[string]string, qslcard.CountryInfo, error)
 		}
 		return strconv.Itoa(z)
 	}
+	// The QSL message on the card: the QSO's own QSLMSG wins; when it's empty the
+	// operator's default message (Settings) is used instead.
+	msg := q.QSLMsg
+	if strings.TrimSpace(msg) == "" {
+		msg = a.qslDefaultMessage()
+	}
+	// PSE/TNX stamp, chosen automatically by whether a QSL was received for this
+	// QSO (appQSLCardRcvdField): received → thank them, otherwise ask for a card.
+	pseTnx := "PSE QSL"
+	if q.Extras != nil && strings.TrimSpace(q.Extras[appQSLCardRcvdField]) != "" {
+		pseTnx = "TNX QSL"
+	}
 	vars := map[string]string{
 		"profile.callsign":      info.Callsign,
 		"profile.operator_name": info.Operator,
@@ -650,7 +699,8 @@ func (a *App) qslVars(q qso.QSO) (map[string]string, qslcard.CountryInfo, error)
 		"qso.mode":     q.Mode,
 		"qso.submode":  q.Submode,
 		"qso.rst_sent": q.RSTSent,
-		"qso.qsl_msg":  q.QSLMsg,
+		"qso.qsl_msg":  msg,
+		"qso.pse_tnx":  pseTnx,
 		"qso.name":     q.Name,
 	}
 	vars["qso.my_rig"], vars["qso.my_antenna"] = a.qslRigAntenna(q)

changelog.json

@@ -1,4 +1,200 @@
 [
+  {
+    "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": "",
+    "en": [
+      "Backup: new \"Back up on every exit\" option (Settings → Backup). With it on, OpsLog backs up the database each time you quit instead of only the first time of the day — so a second session's QSOs are always captured.",
+      "Cluster details (My station): removed the example placeholders in My rig / My antenna (and the satellite name/mode) — they looked like real values, so an empty field read as already filled.",
+      "QSL: new \"OpsLog QSL received\" marker on the QSO edit window (next to QSL Message), with a live PSE QSL / TNX indicator. When a QSL was received the card prints TNX (thanks), otherwise PSE QSL (please send one) — automatic. The stamp uses the {qso.pse_tnx} token (in the default card footer; placeable anywhere in the designer). A \"QSL received\" column was added to Recent QSOs.",
+      "QSL: a default QSL message (Settings → E-mail, under the QSL card e-mail) now prints on the card when a QSO has no QSL Message of its own — a QSO's own QSL Message always takes precedence.",
+      "UDP outbound: a QSO logged from WSJT-X / JTDX / MSHV (via the inbound UDP listener) is now forwarded to the outbound ADIF integrations too — previously only QSOs typed directly into OpsLog were re-emitted.",
+      "Backup: with \"back up on every exit\", a new \"Keep every backup\" sub-option writes a distinct time-stamped file per exit (opslog-YYYY-MM-DD-HHMMSS.db) instead of overwriting the day's file. Rotation still keeps the newest N — raise it for more history.",
+      "Awards editor: the PRIMARY QSOFIELDS search now has a Prefix field too (prepended to each found reference, e.g. captured 01 → D01) — previously only the OR fallback searches could add a prefix, so a DOK-style award couldn't match on its main rule.",
+      "CAT: new Elecraft K3/K4 backend in the rig list. Select it (it reuses the Kenwood USB/network settings) and digital modes automatically use DATA A (MD6+DT0) — the sub-mode FT8 audio needs, so the K3 no longer keys the transmitter without modulating.",
+      "Settings database: the New / Open existing / Save a copy / Rename / Reset buttons are back (Settings → Database). Only \"Open folder\" was left, which opens Windows Explorer — where a .db can't be selected, it just asks which program should open it. Picking a database now uses a proper file dialog and offers a one-click restart.",
+      "Recent QSOs: a column dragged to sit AFTER an award column now stays there. Award columns were left out of the saved layout, so on reload they were pushed to the far right and jumped back in front of the column you had placed after them.",
+      "Entry form and QSO editor: Name and QTH are capitalised word by word (\"JEAN-PIERRE\" → \"Jean-Pierre\"), Comment and Note get a capital first letter. Applied when you leave the field, so typing is never interrupted; the rest of a comment is left alone, since it usually holds callsigns and modes.",
+      "Recent QSOs: the search box only ever takes callsigns, so it now upper-cases as you type and carries a small clear button.",
+      "CAT Elecraft K3/K4: the rig's mode is read back correctly. MD6 is DATA on a K3 but FSK on a Kenwood, and OpsLog decoded it as RTTY — so a K3 running FT8 showed RTTY, logged its QSOs as RTTY, and told WSJT-X/JTDX over the shared CAT link that the rig was in RTTY while they had asked for a data mode. Applies to the Elecraft K3/K4 backend and to the \"DATA A — MD6\" option; a plain Kenwood still reads MD6 as RTTY.",
+      "CAT sharing: the transmitter is dropped when the program keying it goes away. If WSJT-X/JTDX crashed, was closed, or simply had its connection cut — which is what saving the settings does, since the sharing server is rebuilt — the rig stayed on air with nobody watching: the Kenwood/Elecraft link stops polling while PTT is held, so nothing noticed. A K3 was seen transmitting for 29 seconds.",
+      "DX cluster: new \"Self-spot while I log\" option (Settings → DX Cluster). When you log a QSO, OpsLog announces YOU on the master cluster — your station callsign as the DX, on the frequency you just worked — so callers find you without waiting for someone else to spot you. It fires on the first QSO of a frequency, then no more often than the interval you set; five minutes is the minimum, since a self-spot is traffic every user of the node sees."
+    ],
+    "fr": [
+      "Sauvegarde : nouvelle option \"Sauvegarder à chaque fermeture\" (Réglages → Sauvegarde). Activée, OpsLog sauvegarde la base à chaque fois que tu quittes au lieu d'une seule fois par jour — les QSO d'une seconde session sont ainsi toujours pris.",
+      "Détails cluster (Ma station) : suppression des exemples en filigrane dans Mon rig / Mon antenne (et nom/mode satellite) — ils ressemblaient à de vraies valeurs, faisant croire qu'un champ vide était déjà rempli.",
+      "QSL : nouveau marqueur \"QSL OpsLog reçue\" dans la fenêtre d'édition du QSO (à côté du Message QSL), avec un indicateur PSE QSL / TNX en direct. Si une QSL a été reçue, la carte imprime TNX (merci), sinon PSE QSL (envoie-moi une carte) — automatique. Le tampon utilise le token {qso.pse_tnx} (dans le pied de carte par défaut ; plaçable où tu veux dans le designer). Une colonne \"QSL reçue\" a été ajoutée aux QSO récents.",
+      "QSL : un message QSL par défaut (Réglages → E-mail, sous l'e-mail de carte QSL) s'imprime désormais sur la carte quand un QSO n'a pas son propre Message QSL — le Message QSL du QSO l'emporte toujours.",
+      "UDP sortant : un QSO enregistré depuis WSJT-X / JTDX / MSHV (via l'écouteur UDP entrant) est désormais aussi transmis aux intégrations ADIF sortantes — avant, seuls les QSO saisis directement dans OpsLog étaient réémis.",
+      "Sauvegarde : avec \"sauvegarder à chaque fermeture\", une nouvelle sous-option \"Garder chaque sauvegarde\" écrit un fichier horodaté distinct par fermeture (opslog-AAAA-MM-JJ-HHMMSS.db) au lieu d'écraser le fichier du jour. La rotation garde les N plus récents — augmente-la pour plus d'historique.",
+      "Éditeur de diplômes : la recherche PRINCIPALE QSOFIELDS a aussi un champ Préfixe (ajouté devant chaque référence trouvée, ex. 01 capturé → D01) — avant, seules les recherches OR de repli pouvaient ajouter un préfixe, empêchant un diplôme type DOK de matcher sur sa règle principale.",
+      "CAT : nouveau backend Elecraft K3/K4 dans la liste des rigs. Sélectionne-le (il réutilise les réglages USB/réseau Kenwood) et les modes numériques passent automatiquement en DATA A (MD6+DT0) — le sous-mode dont l'audio FT8 a besoin, donc le K3 ne passe plus en émission sans moduler.",
+      "Base de réglages : les boutons Nouvelle base / Ouvrir existante / Enregistrer une copie / Renommer / Réinitialiser sont de retour (Réglages → Base de données). Il ne restait que \"Ouvrir le dossier\", qui lance l'Explorateur Windows — où un .db n'est pas sélectionnable, il demande juste avec quel logiciel l'ouvrir. Choisir une base passe désormais par un vrai sélecteur de fichier, avec redémarrage en un clic.",
+      "QSO récents : une colonne déplacée APRÈS une colonne de diplôme y reste. Les colonnes de diplômes étaient exclues de la disposition enregistrée, donc au rechargement elles étaient repoussées tout à droite et repassaient devant la colonne que tu avais placée après elles.",
+      "Saisie et éditeur de QSO : Name et QTH sont capitalisés mot par mot (« JEAN-PIERRE » → « Jean-Pierre »), Comment et Note prennent une majuscule en première lettre. Appliqué quand tu quittes le champ, donc la frappe n'est jamais perturbée ; la suite d'un commentaire est laissée telle quelle, puisqu'elle contient souvent des indicatifs et des modes.",
+      "QSO récents : le champ de recherche ne prend que des indicatifs — il passe donc en majuscules à la frappe et reçoit un petit bouton d'effacement.",
+      "CAT Elecraft K3/K4 : le mode de la radio est relu correctement. MD6 vaut DATA sur un K3 mais FSK sur un Kenwood, et OpsLog le décodait en RTTY — un K3 en FT8 affichait donc RTTY, enregistrait ses QSO en RTTY, et annonçait RTTY à WSJT-X/JTDX via le partage CAT alors qu'ils avaient demandé un mode data. Vaut pour le backend Elecraft K3/K4 et pour l'option « DATA A — MD6 » ; un Kenwood classique lit toujours MD6 comme RTTY.",
+      "Partage CAT : l'émission est coupée quand le logiciel qui la commandait disparaît. Si WSJT-X/JTDX plantait, était fermé, ou voyait simplement sa connexion coupée — ce que fait un enregistrement des réglages, puisque le serveur de partage est reconstruit — la radio restait en émission sans surveillance : la liaison Kenwood/Elecraft cesse d'interroger le poste tant que le PTT est tenu, donc rien ne s'en apercevait. Un K3 a été vu en émission pendant 29 secondes.",
+      "Cluster DX : nouvelle option « M'auto-spotter quand j'enregistre » (Réglages → DX Cluster). À chaque QSO enregistré, OpsLog t'annonce sur le cluster maître — ton indicatif de station en DX, sur la fréquence que tu viens de travailler — pour qu'on te trouve sans attendre que quelqu'un te spotte. Déclenché au premier QSO d'une fréquence, puis pas plus souvent que l'intervalle choisi ; cinq minutes est le minimum, un auto-spot étant du trafic que voient tous les utilisateurs du nœud."
+    ]
+  },
+  {
+    "version": "0.23.8",
+    "date": "",
+    "en": [
+      "E-mail: the QSO recording e-mail (subject and body) is now editable in Settings → E-mail, like the QSL card e-mail — with the {CALL} {DATE} {BAND} {MODE} {MYCALL} variables.",
+      "Backup fix: the backup now saves your CONTACTS (the logbook), not just the settings. Once the logbook was split into its own file, the backup kept snapshotting the settings database and silently missed the QSOs. It now writes the log to opslog-*.db and the configuration separately to opslogcfg-*.db (MySQL logs still export to ADIF).",
+      "Performance: much lower CPU and memory on a busy cluster (RBN and other high-volume feeds). The Cluster tab was re-scanning the entire logbook for every batch of spots (~20×/second) and its spot-status cache grew without limit — on a firehose that could climb to gigabytes of RAM and peg a CPU. The worked-index is now cached (rebuilt only when you log a QSO) and the status cache is bounded to the spots actually shown."
+    ],
+    "fr": [
+      "E-mail : le texte de l'e-mail d'enregistrement QSO (objet et corps) est désormais modifiable dans Réglages → E-mail, comme l'e-mail de carte QSL — avec les variables {CALL} {DATE} {BAND} {MODE} {MYCALL}.",
+      "Correction sauvegarde : la sauvegarde enregistre désormais tes CONTACTS (le journal), et plus seulement les réglages. Depuis que le journal a été séparé dans son propre fichier, la sauvegarde continuait à copier la base des réglages et oubliait les QSO. Elle écrit maintenant le log dans opslog-*.db et la configuration à part dans opslogcfg-*.db (les logs MySQL restent exportés en ADIF).",
+      "Performances : CPU et mémoire nettement réduits sur un cluster chargé (RBN et autres flux à fort volume). L'onglet Cluster rescannait tout le journal à chaque lot de spots (~20×/seconde) et son cache de statuts grossissait sans limite — sur un flux intense cela pouvait atteindre des gigaoctets de RAM et saturer un cœur. L'index des contacts est désormais mis en cache (reconstruit seulement quand tu logues un QSO) et le cache de statuts est borné aux spots réellement affichés."
+    ]
+  },
+  {
+    "version": "0.23.7",
+    "date": "",
+    "en": [
+      "QSO edit: added the QRZ ↗ button next to the callsign, like the main entry form — one click opens that station's qrz.com profile.",
+      "PowerGenius XL: the fan mode (Standard / Contest / Broadcast) changes on the amp again. A previous fix dropped the \"setup\" prefix the amp requires (\"setup fanmode=…\"), so the amp rejected the command and the mode snapped straight back. The correct command is restored.",
+      "Performance: fixed a slowdown introduced in 0.23.6. To dim the \"represents nothing\" spots, the DX Cluster grid was redrawing EVERY row on each spot-status update, which pegged the CPU on a busy cluster (some PCs became sluggish). The dimming now updates with a light per-cell refresh instead — same look, no more churn.",
+      "DX Cluster: after you log a QSO, the spots update — a callsign, entity, POTA, prefix or band/mode slot you just worked stops showing its NEW badge, instead of staying \"new\" until a restart. Kept fast: it re-evaluates only while the cluster is actually on screen (nothing runs otherwise — a QSO logged while it's hidden refreshes once when you next open it), and it's debounced so a quick run doesn't re-scan on every QSO.",
+      "Station Control relays (WebSwitch / KMTronic / Dingtian): the Host field now accepts a full URL, so you can reach a network relay board through an HTTPS reverse proxy — e.g. https://relay.yourdomain.com.",
+      "Stats slot drill-down: the pop-up listing the QSOs behind a band/mode square looks tidier (banded rows, cleaner header), and you can now click a callsign in it to open that QSO for editing.",
+      "DCU-1 rotor support: OpsLog can now steer controllers that speak the Hy-Gain DCU-1 protocol (RotorCard DXA for Yaesu DXA rotors, Idiom Press Rotor-EZ, Green Heron) over their COM port or a serial-over-IP bridge.",
+      "Motorized antenna: Settings → Antenna now has a Covered bands selector (40 m–6 m) instead of a min/max range, for both the Ultrabeam and the SteppIR. Tick only the bands your antenna does — untick one you can't (e.g. 30 m without its extension) while keeping the rest — and OpsLog leaves the antenna put on every other band. This overrides an unreliable controller, so 80 m no longer clamps the elements down to 30 m. Existing range settings migrate automatically.",
+      "Motorized antenna: on a band you did not tick in Covered bands, OpsLog no longer inhibits FlexRadio transmit for \"antenna moving\". Un-ticking a band now means hands off completely — no tuning and no TX block — so working it on another antenna is never gagged.",
+      "Awards: a new Settings → Awards picker (under User configuration) lets you choose which awards to follow — a two-column list, all awards on the left, the ones you track on the right. The Awards tab then shows only those you follow (per profile; leave the right side empty to show them all).",
+      "Kenwood/Elecraft CAT: the link no longer drops while the rig is transmitting. A K3 (and other Kenwood-dialect rigs) answers \"?;\" to a status poll during transmit; OpsLog used to read that as \"rig doesn't support IF\" and disconnect — which tore down the shared CAT that WSJT-X / JTDX key through, so the radio wouldn't transmit properly. OpsLog now pauses status polling while PTT is held and keeps the link up.",
+      "New award: Russian District Award (RDA) — tracks the 2660 Russian districts, worked and confirmed per band."
+    ],
+    "fr": [
+      "Édition de QSO : ajout du bouton QRZ ↗ à côté de l'indicatif, comme dans le formulaire de saisie — un clic ouvre le profil qrz.com de la station.",
+      "PowerGenius XL : le mode ventilateur (Standard / Contest / Broadcast) change de nouveau sur l'ampli. Un correctif précédent avait retiré le préfixe « setup » exigé par l'ampli (« setup fanmode=… »), qui rejetait donc la commande et le mode revenait aussitôt en arrière. La bonne commande est rétablie.",
+      "Performance : correction d'un ralentissement apparu en 0.23.6. Pour atténuer les spots « qui ne représentent rien », la grille du DX Cluster redessinait TOUTES les lignes à chaque mise à jour de statut, ce qui saturait le CPU sur un cluster actif (des PC devenaient lents). L'atténuation se met désormais à jour via un rafraîchissement léger par cellule — même rendu, sans le brassage.",
+      "DX Cluster : après avoir loggué un QSO, les spots se mettent à jour — un indicatif, une entité, un POTA, un préfixe ou un slot bande/mode que vous venez de contacter cesse d'afficher son badge NEW, au lieu de rester « new » jusqu'au redémarrage. Reste rapide : la réévaluation n'a lieu que si le cluster est affiché (sinon rien ne tourne — un QSO loggué cluster caché se rafraîchit une fois à sa réouverture), et c'est débouncé pour ne pas re-scanner à chaque QSO en série.",
+      "Relais du Contrôle station (WebSwitch / KMTronic / Dingtian) : le champ Hôte accepte désormais une URL complète ex. https://relais.tondomaine.com derrière Nginx Proxy Manager. Avant, OpsLog forçait http://<hôte>, donc une carte sur le LAN derrière un proxy (quand vos 80/443 vont déjà ailleurs) était injoignable de l'extérieur.",
+      "Détail d’un slot Stats : la fenêtre listant les QSO derrière une case bande/mode est plus soignée (lignes alternées, en-tête plus propre), et vous pouvez maintenant cliquer un indicatif pour ouvrir ce QSO en édition.",
+      "Prise en charge des rotors DCU-1 : OpsLog pilote désormais les contrôleurs parlant le protocole Hy-Gain DCU-1 (RotorCard DXA pour rotors Yaesu DXA, Idiom Press Rotor-EZ, Green Heron) via leur port COM ou un pont série-sur-IP.",
+      "Antenne motorisée : Réglages → Antenne propose désormais un sélecteur Bandes couvertes (40 m–6 m) au lieu d'une plage min/max, pour l'Ultrabeam comme pour la SteppIR. Coche seulement les bandes que fait ton antenne — décoche celle que tu ne fais pas (p. ex. le 30 m sans son extension) en gardant les autres — et OpsLog laisse l'antenne en place sur toutes les autres. Ceci prime sur un contrôleur peu fiable : le 80 m ne replie plus les éléments sur le 30 m. Les anciens réglages de plage sont migrés automatiquement.",
+      "Antenne motorisée : sur une bande non cochée dans Bandes couvertes, OpsLog n'inhibe plus l'émission du FlexRadio pour « antenne en mouvement ». Décocher une bande signifie désormais ne plus y toucher du tout — ni accord ni blocage TX — pour ne jamais couper le trafic sur une autre antenne.",
+      "Diplômes : un nouveau sélecteur Réglages → Diplômes (dans Configuration utilisateur) permet de choisir les diplômes à suivre — une liste à deux colonnes, tous les diplômes à gauche, ceux que tu suis à droite. L'onglet Awards n'affiche alors que ceux-là (par profil ; laisse la colonne de droite vide pour tous les afficher).",
+      "CAT Kenwood/Elecraft : le lien ne tombe plus pendant que le rig émet. Un K3 (et d'autres rigs en dialecte Kenwood) répond \"?;\" à une interrogation d'état pendant l'émission ; OpsLog le prenait pour \"le rig ne supporte pas IF\" et se déconnectait — ce qui cassait le CAT partagé que WSJT-X / JTDX utilisent pour passer en émission, d'où l'absence d'émission. OpsLog suspend désormais l'interrogation d'état tant que le PTT est actif et garde le lien.",
+      "Nouveau diplôme : Russian District Award (RDA) — suit les 2660 districts russes, travaillés et confirmés par bande."
+    ]
+  },
+  {
+    "version": "0.23.6",
+    "date": "",
+    "en": [
+      "Log viewer: the window now keeps twice as much history (512 KB instead of 256 KB, ~3200 lines). During a busy trace the oldest lines used to scroll out of the buffer while you were still reading them; the larger window holds them.",
+      "Ultrabeam over a remote link: fixed intermittent connection drops, phantom frequency jumps and wrong element-length readings. On a slow link a command that timed out left its late reply in the stream, and the next command read it as its own — crossing a status query with an element-length one, for instance. The stream is now flushed of any stale reply before each command, keeping the exchange in step.",
+      "Ultrabeam: the 'moving' indicator and the Flex TX-inhibit now react the instant you click a band or pattern, instead of up to a status poll (~2 s) later. A commanded move reports motion immediately; the real motor state takes over once the next poll reads it.",
+      "CAT sharing (FT8): JTDX/WSJT-X transmit correctly again through OpsLog's shared rig. get_ptt now echoes the PTT state the client last commanded — clients poll it DURING transmit to confirm the rig is keyed, and OpsLog always answering 'receiving' made them give up and drop the over after a second or two. The 0.23.5 'Fake It' anti-drift tweak was also reverted (it had made this total — no transmit at all); the small dial creep in 'Fake It' split can return, and JTDX's 'Split Operation: None' avoids it.",
+      "CAT settings: trimmed the long help text under the Kenwood and CAT-sharing fields down to the essentials — less clutter.",
+      "Entry form: fixed two ways a stray QSO could sneak in. Pressing Enter in the TX/RX frequency field now only tunes the radio — it was also submitting the contact. And a bare number with no letter (JTDX/WSJT-X sometimes broadcasts \"1\" as the DX call) is no longer accepted into the callsign field, where it could get logged as callsign \"1\".",
+      "SPE amplifier: switching the amp off in OpsLog now shows \"off\" straight away and lets you switch it back on without restarting. The already-open connection kept reading as connected after the off keystroke, so the panel stayed \"on\" and the ON button did nothing until a restart. OpsLog now drops the link on power-off, exactly as a fresh start would — the ON button's RTS/DTR wake then works.",
+      "Alt+W clears the QSO entry, the shortcut used by most other loggers. Unlike Esc it always works, even when the CW keyer has Esc reserved.",
+      "The Grid box no longer pops outside the QSO entry panel when the window is narrowed — it wraps to its own line instead.",
+      "Selecting a QSO in the Recent QSOs list now shows that station in the Stats (F1) matrix, instead of leaving it blank.",
+      "Stats (F1): click any coloured band/mode square to list the contacts behind it.",
+      "Awards: the DXCC list now shows each entity’s main prefix (XE, DL, F…) in its own sortable, searchable column.",
+      "DX Cluster: new option \"Already worked only on the same slot\" (Settings → DX Cluster). With it on, a spot reads \"worked\" only when you worked that callsign on the SAME band and mode — not just anywhere. It respects the digital-mode grouping (Settings → General): grouped, a 20m FT8 contact also marks a 20m FT4 spot as worked; ungrouped, FT8 and FT4 are separate slots.",
+      "DX Cluster: added a WORKED status-filter chip, so you can show — or, with the other chips off, isolate — already-worked spots, not only hide them with the \"Hide worked\" checkbox.",
+      "DX Cluster: spots that represent nothing — entity/band/mode already worked, the callsign not in your log, no POTA/county/prefix novelty — are now dimmed, so your eye skips them and the spots worth working stand out. What counts as \"nothing\" follows the \"same slot\" option and the digital-mode grouping.",
+      "Ultrabeam: an older controller (seen over an RS232-to-Ethernet bridge) answers with an 11-byte status frame instead of 12. OpsLog rejected it as \"too short\" and reconnect-looped; it now accepts a shorter checksum-valid frame and defaults the missing tail field.",
+      "Fixed a crash (React #300) that could take down the whole window when the rig briefly reported an unusual band — for example a spurious 33 cm reading from an Icom. The Band Map had a keyboard-navigation hook after its early return for unknown bands, so the number of hooks changed between renders. The hook now always runs."
+    ],
+    "fr": [
+      "Visionneuse de log : la fenêtre conserve deux fois plus d'historique (512 Ko au lieu de 256 Ko, ~3200 lignes). Lors d'une trace chargée, les plus vieilles lignes défilaient hors du buffer pendant qu'on les lisait encore ; la fenêtre agrandie les garde.",
+      "Ultrabeam en remote : coupures de connexion intermittentes, sauts de fréquence fantômes et longueurs d'éléments erronées corrigés. Sur un lien lent, une commande qui expirait laissait sa réponse tardive dans le flux, et la commande suivante la lisait comme la sienne — croisant par exemple une requête de statut avec une requête de longueurs d'éléments. Le flux est désormais vidé de toute réponse périmée avant chaque commande, gardant l'échange synchronisé.",
+      "Ultrabeam : l'indicateur « en mouvement » et l'inhibition d'émission Flex réagissent désormais dès que vous cliquez sur une bande ou un diagramme, au lieu d'attendre jusqu'à un poll de statut (~2 s). Un mouvement commandé signale le déplacement immédiatement ; l'état réel des moteurs prend le relais dès le poll suivant.",
+      "Partage CAT (FT8) : JTDX/WSJT-X émettent de nouveau correctement via la radio partagée d'OpsLog. get_ptt renvoie désormais l'état PTT commandé en dernier par le client — les clients l'interrogent PENDANT l'émission pour confirmer que la radio est en émission, et comme OpsLog répondait toujours « réception », ils abandonnaient et coupaient l'émission au bout d'une seconde ou deux. L'ajustement anti-drift « Fake It » de la 0.23.5 a aussi été annulé (il rendait le problème total — aucune émission) ; le léger glissement du VFO en split « Fake It » peut réapparaître, et « Split Operation : None » dans JTDX l'évite.",
+      "Réglages CAT : textes d'aide raccourcis sous les champs Kenwood et partage CAT — moins de fouillis.",
+      "Formulaire de saisie : deux façons de logguer un QSO parasite corrigées. Appuyer sur Entrée dans le champ fréquence TX/RX ne fait plus que syntoniser la radio — cela validait aussi le contact. Et un nombre nu sans lettre (JTDX/WSJT-X diffuse parfois « 1 » comme DX call) n'est plus accepté dans le champ indicatif, où il pouvait être loggué comme indicatif « 1 ».",
+      "Ampli SPE : éteindre l'ampli depuis OpsLog affiche désormais « off » tout de suite et permet de le rallumer sans redémarrer. La connexion déjà ouverte continuait d'être vue comme connectée après la touche d'extinction, le panneau restait donc « on » et le bouton ON ne faisait rien jusqu'à un redémarrage. OpsLog largue maintenant le lien à l'extinction, exactement comme un démarrage à neuf — le réveil RTS/DTR du bouton ON fonctionne alors.",
+      "Alt+W efface la saisie du QSO, le raccourci utilisé par la plupart des autres logiciels. Contrairement à Échap, il fonctionne toujours, même quand Échap est réservé au manipulateur CW.",
+      "Le champ Locator ne déborde plus du panneau de saisie quand la fenêtre est rétrécie — il passe à la ligne.",
+      "Sélectionner un QSO dans la liste des QSO récents affiche désormais cette station dans la matrice Stats (F1), au lieu de la laisser vide.",
+      "Stats (F1) : cliquer sur une case bande/mode colorée liste les contacts correspondants.",
+      "Diplômes : la liste DXCC affiche le préfixe principal de chaque entité (XE, DL, F…) dans une colonne triable et cherchable.",
+      "DX Cluster : nouvelle option « Déjà contacté seulement sur le même slot » (Réglages → DX Cluster). Activée, un spot n'affiche « contacté » que si vous avez contacté cet indicatif sur la MÊME bande et le MÊME mode — pas juste n'importe où. Elle respecte le groupage des modes numériques (Réglages → Général) : groupé, un contact 20m FT8 marque aussi un spot 20m FT4 comme contacté ; dégroupé, FT8 et FT4 sont des slots distincts.",
+      "DX Cluster : ajout d'un filtre de statut WORKED, pour afficher — ou, en désactivant les autres, isoler — les spots déjà contactés, pas seulement les masquer avec la case « Masquer les contactés ».",
+      "DX Cluster : les spots qui ne représentent rien — entité/bande/mode déjà faite, indicatif absent du journal, aucune nouveauté POTA/comté/préfixe — sont désormais atténués, pour que l'œil les ignore et que les spots à travailler ressortent. Ce qui compte comme « rien » suit l'option « même slot » et le groupage des modes numériques.",
+      "Ultrabeam : un contrôleur plus ancien (vu derrière un pont RS232-Ethernet) répond avec une trame de statut de 11 octets au lieu de 12. OpsLog la rejetait comme « trop courte » et bouclait en reconnexion ; il accepte désormais une trame valide plus courte et met par défaut le champ de fin manquant.",
+      "Correction d'un plantage (React #300) qui pouvait faire tomber toute la fenêtre quand la radio rapportait brièvement une bande inhabituelle — par exemple une lecture 33 cm parasite d'un Icom. La Band Map avait un hook de navigation clavier après son retour anticipé pour les bandes inconnues, changeant le nombre de hooks entre deux rendus. Le hook est désormais toujours exécuté."
+    ]
+  },
+  {
+    "version": "0.23.5",
+    "date": "",
+    "en": [
+      "CAT sharing (Hamlib rigctld): fixed a slow frequency drift in FT8. With a digital app (JTDX/WSJT-X) sharing OpsLog's rig in \"Fake It\" split, each transmit crept the dial down and never came back. The app follows the dial by polling, and our reply lagged the last tune by a poll cycle, so right after a transmission it read the still-shifted frequency, took it for a manual QSY and adopted it. Reads now echo the last commanded frequency until the rig confirms it — the dial holds. Applies to every backend, not just Kenwood."
+    ],
+    "fr": [
+      "Partage CAT (rigctld Hamlib) : dérive lente de fréquence en FT8 corrigée. Avec une app numérique (JTDX/WSJT-X) partageant la radio d'OpsLog en split « Fake It », chaque passage en émission faisait descendre le VFO sans jamais revenir. L'app suit le VFO en l'interrogeant, et notre réponse était en retard d'un cycle sur la dernière syntonisation : juste après une émission elle lisait la fréquence encore décalée, la prenait pour un QSY manuel et l'adoptait. Les lectures renvoient désormais la dernière fréquence commandée jusqu'à confirmation de la radio — le VFO tient. Vaut pour tous les backends, pas seulement Kenwood."
+    ]
+  },
+  {
+    "version": "0.23.4",
+    "date": "",
+    "en": [
+      "CW keyer (Kenwood/Elecraft): choosing the Kenwood/Elecraft engine now actually switches to it. A bug left the keyer on WinKeyer even though the setting showed Kenwood/Elecraft, so its CW-over-CAT never ran.",
+      "Kenwood/Elecraft data mode: a new setting (Settings → CAT) chooses what a data mode (FT8/PSK…) sets on the rig — USB (default), DATA mode (MD6, for an Elecraft K3/K4), or leave the rig's mode unchanged (safest for a TS-590SG/TS-990S, whose data mode is a USB modifier set on the radio). There is no single command that fits every rig, so it's now the operator's choice.",
+      "Ultrabeam over a remote link: changing the pattern (Normal / 180° / bidirectional) no longer snaps back to the old one after a few seconds. The commanded pattern is now held while the motors are still moving plus a grace window after they stop, so the slow remote status poll — which lagged behind the antenna — can't revert the display while the change is in flight.",
+      "QSL Manager: closing the window — or starting another download — now cancels the one still in progress, so a slow QRZ sync no longer keeps running in the background and bleeds its log into a freshly started LoTW run. The QRZ download summary also spells out that only confirmed QSOs are acted on (e.g. \"7950 of 26164 are confirmed\") — a full QRZ logbook has many not-yet-confirmed QSOs, so nothing is lost even though the old wording read as if only a fraction came back. (A LoTW \"http 503\" is separate: the ARRL server being down — retry later.)"
+    ],
+    "fr": [
+      "Keyer CW (Kenwood/Elecraft) : choisir le moteur Kenwood/Elecraft y bascule désormais réellement. Un bug laissait le keyer sur WinKeyer alors que le réglage affichait Kenwood/Elecraft, son CW-sur-CAT ne démarrait donc jamais.",
+      "Mode data Kenwood/Elecraft : un nouveau réglage (Réglages → CAT) choisit ce qu'un mode data (FT8/PSK…) règle sur la radio — USB (défaut), mode DATA (MD6, pour un Elecraft K3/K4), ou ne pas changer le mode de la radio (le plus sûr pour un TS-590SG/TS-990S dont le mode data est un modificateur d'USB réglé sur la radio). Aucune commande unique ne convient à toutes les radios, c'est donc désormais au choix de l'opérateur.",
+      "Ultrabeam en remote : changer le diagramme (Normal / 180° / bidirectionnel) ne revient plus à l'ancien au bout de quelques secondes. Le diagramme commandé est maintenu tant que les moteurs bougent, plus une fenêtre de grâce après leur arrêt — le poll de statut distant, lent et en retard sur l'antenne, ne peut donc plus faire revenir l'affichage pendant que le changement est en cours.",
+      "QSL Manager : fermer la fenêtre — ou lancer un autre téléchargement — annule désormais celui en cours, une synchro QRZ lente ne continue donc plus en arrière-plan à mélanger son journal à un téléchargement LoTW fraîchement lancé. Le récapitulatif QRZ indique aussi clairement que seuls les QSO confirmés sont traités (ex. « 7950 sur 26164 confirmés ») — un logbook QRZ complet contient beaucoup de QSO pas encore confirmés, rien n'est donc perdu même si l'ancien texte donnait l'impression qu'une fraction seulement était revenue. (Un « http 503 » sur LoTW est un autre sujet : serveur de l'ARRL indisponible — réessayez plus tard.)"
+    ]
+  },
   {
     "version": "0.23.3",
     "date": "",

frontend/src/App.tsx

@@ -103,6 +103,7 @@ import { WinkeyerPanel, type WKStatus, type WKMacro } from '@/components/Winkeye
 import { RotorCompass } from '@/components/RotorCompass';
 import { writeUiPref } from '@/lib/uiPref';
 import { formatDateTimeUTC } from '@/lib/dateFormat';
+import { titleCase, sentenceCase } from '@/lib/textCase';
 import { setGridPrefsProfile, flushGridPrefs } from '@/lib/gridPrefs';
 import { DvkPanel, type DVKMsg, type DVKStat } from '@/components/DvkPanel';
 
@@ -906,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();
@@ -956,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(() => {
@@ -1369,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];
-        return next.length > CONSOLE_CAP ? next.slice(next.length - CONSOLE_CAP) : next;
+        const total = prev.length + batch.length;
+        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.
@@ -1500,6 +1585,83 @@ export default function App() {
   // still need resolving without re-subscribing the cluster:spot listener.
   const spotStatusRef = useRef(spotStatus);
   useEffect(() => { spotStatusRef.current = spotStatus; }, [spotStatus]);
+  // Mirror of spots so the log-triggered refresh reads the current list without
+  // a stale closure.
+  const spotsRef = useRef(spots);
+  useEffect(() => { spotsRef.current = spots; }, [spots]);
+  // Bound the status cache. Keyed per call|band|mode, it otherwise kept an entry
+  // for every station ever seen — under an RBN firehose (thousands of unique
+  // calls/hour) that grew without limit to gigabytes. Prune it back to the live
+  // (SPOTS_CAP-limited) spots once it drifts well past them. The size check bails
+  // cheaply the rest of the time (returning the same reference, so no dependent
+  // memo re-runs); an evicted spot is just re-resolved if it reappears.
+  useEffect(() => {
+    setSpotStatus((prev) => {
+      const keys = Object.keys(prev);
+      if (keys.length <= SPOTS_CAP * 2) return prev;
+      const live = new Set(spots.map((x) => spotStatusKey(x.dx_call, x.band ?? '', x.comment ?? '', x.freq_hz)));
+      const pruned: typeof prev = {};
+      for (const k of keys) if (live.has(k)) pruned[k] = prev[k];
+      return pruned;
+    });
+  }, [spots]);
+  // Re-fetch the status of every SHOWN spot and OVERWRITE the cache (merge, never
+  // clear). Overwriting keeps the other NEW badges on screen until their fresh
+  // value lands, instead of blanking the whole grid and letting the badges pop
+  // back a moment later. The backend cost is one status batch regardless of spot
+  // count (it scans the logbook once), so this is as cheap as the poll already is.
+  const refreshSpotStatuses = useCallback(async () => {
+    const cur = spotsRef.current;
+    if (!cur.length) return;
+    const queries: { call: string; band: string; mode: string; pota_ref: string }[] = [];
+    const seen = new Set<string>();
+    for (const s of cur) {
+      const k = spotStatusKey(s.dx_call, s.band ?? '', s.comment ?? '', s.freq_hz);
+      if (seen.has(k)) continue;
+      seen.add(k);
+      queries.push({ call: s.dx_call, band: s.band ?? '', mode: inferSpotMode(s.comment ?? '', s.freq_hz), pota_ref: (s as any).pota_ref ?? '' });
+    }
+    if (!queries.length) return;
+    try {
+      const res = await ClusterSpotStatuses(queries as any);
+      setSpotStatus((prev) => {
+        const next = { ...prev };
+        for (const r of res) {
+          const k = `${r.call}|${r.band ?? ''}|${(r.mode ?? '').toUpperCase()}`;
+          next[k] = {
+            status: r.status ?? '', country: r.country, continent: (r as any).continent,
+            worked_call: !!(r as any).worked_call, new_county: !!(r as any).new_county,
+            new_pota: !!(r as any).new_pota, new_pfx: !!(r as any).new_pfx, pfx: (r as any).pfx,
+          };
+        }
+        return next;
+      });
+    } catch { /* leave the old statuses in place on failure */ }
+  }, []);
+  // After a QSO is logged, refresh the shown spots so a call/entity/POTA/prefix/
+  // slot just worked drops its NEW badge — WITHOUT blanking the others (see the
+  // merge above). Kept cheap: only while the cluster is on screen (a log while
+  // hidden marks it dirty and refreshes ONCE on next open), and debounced so a
+  // fast run coalesces instead of re-scanning per QSO.
+  const clusterVisibleRef = useRef(false);
+  const spotsDirtyRef = useRef(false);
+  useEffect(() => {
+    const vis = mainPaneLeft === 'cluster' || mainPaneRight === 'cluster' || activeTab === 'cluster';
+    if (vis && !clusterVisibleRef.current && spotsDirtyRef.current) {
+      spotsDirtyRef.current = false;
+      void refreshSpotStatuses();
+    }
+    clusterVisibleRef.current = vis;
+  }, [mainPaneLeft, mainPaneRight, activeTab, refreshSpotStatuses]);
+  useEffect(() => {
+    let t: number | undefined;
+    const off = EventsOn('qso:logged', () => {
+      if (!clusterVisibleRef.current) { spotsDirtyRef.current = true; return; }
+      if (t) window.clearTimeout(t);
+      t = window.setTimeout(() => void refreshSpotStatuses(), 2000);
+    });
+    return () => { off(); if (t) window.clearTimeout(t); };
+  }, [refreshSpotStatuses]);
   // Incoming spots are staged here for a few ms, their status resolved, then
   // committed to `spots` together — so a row paints with its NEW BAND/MODE badge
   // already on, instead of flashing plain text then flipping to the pill.
@@ -1512,6 +1674,11 @@ export default function App() {
   const [deletingIds, setDeletingIds] = useState<number[]>([]);
   const [selectedId, setSelectedId] = useState<number | null>(null);
   const [selectedIds, setSelectedIds] = useState<number[]>([]);
+  // Call/band/mode of the QSO highlighted in the Recent-QSOs grid. Drives the
+  // Stats (F1) matrix whenever the entry form is empty — clicking a past contact
+  // is the natural way to ask "what else have I got with this one?", and until
+  // now the panel just sat blank.
+  const [selQso, setSelQso] = useState<{ call: string; band: string; mode: string } | null>(null);
   const [bulkEditIds, setBulkEditIds] = useState<number[]>([]);
   const [bulkEditOpen, setBulkEditOpen] = useState(false);
   const [showSettings, setShowSettings] = useState(false);
@@ -2607,6 +2774,11 @@ export default function App() {
     const applyUdpCall = (raw: string, force = false): boolean => {
       const call = String(raw ?? '').trim();
       if (!call) return false;
+      // A callsign always has at least one letter. WSJT-X/JTDX (and relayed spot
+      // clicks) sometimes broadcast a bare number in the DX-call field — famously
+      // "1" — which would land in the entry and, on the next Enter, log a QSO
+      // with callsign "1". Reject anything with no letter.
+      if (!/[a-z]/i.test(call)) return false;
       const upper = call.toUpperCase();
       const current = callsignValRef.current.trim().toUpperCase();
       const prev = lastUdpCallRef.current;
@@ -2706,8 +2878,9 @@ export default function App() {
         s.engine === 'icom' ? 'icom'
           : s.engine === 'flex' ? 'flex'
             : s.engine === 'yaesu' ? 'yaesu'
-              : s.engine === 'serial' ? 'serial'
-                : 'winkeyer');
+              : s.engine === 'kenwood' ? 'kenwood'
+                : s.engine === 'serial' ? 'serial'
+                  : 'winkeyer');
     } catch { /* keyer not configured */ }
   }, []);
 
@@ -3309,6 +3482,24 @@ export default function App() {
     finally { setDeletingAll(false); }
   }
 
+  // Worked-before for the QSO highlighted in the grid. Deliberately NOT
+  // runWorkedBefore: that one owns the entry form's wbRef and can trigger a
+  // field backfill, which browsing the log must never do.
+  const [selWb, setSelWb] = useState<WB | null>(null);
+  const [selWbBusy, setSelWbBusy] = useState(false);
+  useEffect(() => {
+    const call = (selQso?.call ?? '').trim().toUpperCase();
+    // The entry form wins whenever it has a call — it's the live QSO.
+    if (!call || callsign.trim()) { setSelWb(null); return; }
+    let dead = false;
+    setSelWbBusy(true);
+    WorkedBefore(call, 0)
+      .then((w: any) => { if (!dead) setSelWb(w); })
+      .catch(() => { if (!dead) setSelWb(null); })
+      .finally(() => { if (!dead) setSelWbBusy(false); });
+    return () => { dead = true; };
+  }, [selQso, callsign]);
+
   async function runWorkedBefore(call: string, dxccHint: number = 0) {
     setWbBusy(true);
     try {
@@ -3853,6 +4044,16 @@ export default function App() {
       if ((e.ctrlKey || e.metaKey) && e.key.toLowerCase() === 'o') {
         e.preventDefault(); importAdif(); return;
       }
+      // Alt+W: wipe the entry. The near-universal logger convention (N1MM,
+      // Log4OM, DXLog), and unlike ESC it is never swallowed by the CW keyer —
+      // so there is always one key that clears, whatever else is running.
+      // Alt-combos carry no character on Windows, so this is safe while typing.
+      if (e.altKey && !e.ctrlKey && !e.metaKey && e.key.toLowerCase() === 'w') {
+        e.preventDefault();
+        resetEntry();
+        callsignRef.current?.focus();
+        return;
+      }
       if (typing) return;
       if (selectedId !== null) {
         if (e.key === 'Delete') { e.preventDefault(); askDeleteSelected(); return; }
@@ -4106,7 +4307,8 @@ export default function App() {
   );
   const nameBlock = (
     <div className="flex flex-col flex-1 min-w-[110px]"><Label className="mb-1 h-3.5">{t('field.name')}</Label>
-      <Input value={name} onChange={(e) => { setName(e.target.value); markEdited('name'); }} />
+      <Input value={name} onChange={(e) => { setName(e.target.value); markEdited('name'); }}
+        onBlur={() => setName(titleCase)} />
     </div>
   );
   // In contest mode QTH is replaced by the sent (read-only, auto) and received
@@ -4125,8 +4327,9 @@ export default function App() {
       </div>
     </>
   ) : (
-    <div className="flex flex-col flex-1 min-w-[130px]"><Label className="mb-1 h-3.5">{t('field.qth')}</Label>
-      <Input value={qth} onChange={(e) => { setQth(e.target.value); markEdited('qth'); }} />
+    <div className="flex flex-col flex-1 min-w-[80px]"><Label className="mb-1 h-3.5">{t('field.qth')}</Label>
+      <Input value={qth} onChange={(e) => { setQth(e.target.value); markEdited('qth'); }}
+        onBlur={() => setQth(titleCase)} />
     </div>
   );
   const gridBlock = (
@@ -4271,7 +4474,7 @@ export default function App() {
   );
   const commentSm = (
     <div className="flex flex-col w-40"><Label className="mb-1 h-3.5">{t('field.comment')}</Label>
-      <Input value={comment} onChange={(e) => setComment(e.target.value)} />
+      <Input value={comment} onChange={(e) => setComment(e.target.value)} onBlur={() => setComment(sentenceCase)} />
     </div>
   );
   // Inline-label variants (label to the LEFT of the control, Log4OM-style) —
@@ -4354,7 +4557,7 @@ export default function App() {
         title={catState.connected ? t('field.freqTuneHint') : undefined}
         onFocus={() => setFreqFocused(true)}
         onBlur={() => setFreqFocused(false)}
-        onKeyDown={(e) => { if (e.key === 'Enter') tuneRadioTo(freqMhz); }}
+        onKeyDown={(e) => { if (e.key === 'Enter') { e.preventDefault(); e.stopPropagation(); tuneRadioTo(freqMhz); } }}
         onChange={(e) => { setFreqMhz(e.target.value); noteManualEdit(); const b = bandForMHz(parseFloat(e.target.value)); if (b) setBand(b); }}
       />
     </div>
@@ -4369,7 +4572,7 @@ export default function App() {
         title={catState.connected ? t('field.freqTuneHint') : undefined}
         onFocus={() => setFreqFocused(true)}
         onBlur={() => setFreqFocused(false)}
-        onKeyDown={(e) => { if (e.key === 'Enter') tuneRadioTo(rxFreqMhz); }}
+        onKeyDown={(e) => { if (e.key === 'Enter') { e.preventDefault(); e.stopPropagation(); tuneRadioTo(rxFreqMhz); } }}
         onChange={(e) => { setRxFreqMhz(e.target.value); noteManualEdit(); const rb = bandForMHz(parseFloat(e.target.value)); if (rb) setBandRx(rb); }}
         className={cn('font-mono', catState.split && 'bg-danger-muted/40 border-danger-border focus:bg-card')}
       />
@@ -4387,12 +4590,12 @@ export default function App() {
   // column). No flex-1 so they stay one row tall.
   const commentLine = (
     <div className="flex flex-col"><Label className="mb-1 h-3.5">{t('field.comment')}</Label>
-      <Input value={comment} onChange={(e) => setComment(e.target.value)} />
+      <Input value={comment} onChange={(e) => setComment(e.target.value)} onBlur={() => setComment(sentenceCase)} />
     </div>
   );
   const noteLine = (
     <div className="flex flex-col"><Label className="mb-1 h-3.5">{t('field.note')}</Label>
-      <Input value={note} onChange={(e) => setNote(e.target.value)} />
+      <Input value={note} onChange={(e) => setNote(e.target.value)} onBlur={() => setNote(sentenceCase)} />
     </div>
   );
   const logButtons = (
@@ -4406,7 +4609,7 @@ export default function App() {
           </Button>
         )}
         <Button type="button" size="sm" variant="outline" onClick={() => { resetEntry(); callsignRef.current?.focus(); }} className="h-8 px-2.5 text-xs"
-          title="Clear the QSO entry (always — unlike Esc which may be reserved for the CW keyer)">
+          title="Clear the QSO entry — Alt+W (always works, unlike Esc which may be reserved for the CW keyer)">
           <Eraser className="size-3.5" />
           {t('btn.clear')}
         </Button>
@@ -4451,11 +4654,14 @@ export default function App() {
         const k = spotStatusKey(s.dx_call, s.band ?? '', s.comment ?? '', s.freq_hz);
         const e = spotStatus[k];
         const st = (e?.status || '') as SpotStatusKey;
-        // A previously-worked call counts as WORKED for filtering even when its
-        // entity status is still new-band/new-slot (the grid flags it WKD CALL),
-        // matching the "Hide worked" toggle. Additive: it still matches its own
-        // entity status too, so it stays visible under NEW BAND / NEW SLOT.
-        const matches = clusterStatusFilter.has(st)
+        // WORKED means "I've worked THIS callsign" — the blue WKD-CALL flag —
+        // NOT the entity status 'worked' (entity/band/mode already worked, which
+        // the grid shows as a plain "—"). So the 'worked' key is matched ONLY via
+        // worked_call below; exclude the entity status 'worked' from the generic
+        // match, or every "already-worked-entity" spot would slip through. A
+        // worked call still matches its own entity status too (new-band/new-slot),
+        // so it stays visible under those chips.
+        const matches = (st !== 'worked' && clusterStatusFilter.has(st))
           || (!!e?.worked_call && clusterStatusFilter.has('worked'))
           || (!!e?.new_pota && clusterStatusFilter.has('new-pota'))
           || (!!e?.new_county && clusterStatusFilter.has('new-county'))
@@ -4580,7 +4786,10 @@ export default function App() {
               { k: 'new-pota'   as SpotFilterKey, label: 'NEW POTA',   cls: 'bg-success-muted text-success-muted-foreground border-success-border' },
               { k: 'new-county' as SpotFilterKey, label: 'NEW COUNTY', cls: 'bg-success-muted text-success-muted-foreground border-success-border' },
               { k: 'new-pfx'    as SpotFilterKey, label: 'NEW PFX',    cls: 'bg-caution-muted text-caution-muted-foreground border-caution-border' },
-              // (no WORKED chip — use the "Hide worked" checkbox to drop dupes.)
+              // Blue, like the already-worked call in the grid. Selecting it keeps
+              // worked spots; the separate "Hide worked" checkbox drops them — they
+              // are opposite controls, so don't use both at once.
+              { k: 'worked'   as SpotFilterKey, label: 'WORKED',   cls: 'bg-info-muted text-info-muted-foreground border-info-border' },
             ]).map((s) => {
               const on = clusterStatusFilter.has(s.k);
               return (
@@ -4740,6 +4949,7 @@ export default function App() {
               onExportFiltered={exportFilteredADIF}
               onDelete={(ids) => setDeletingIds(ids)}
               onRowSelected={(ids) => { setSelectedIds(ids); setSelectedId(ids[0] ?? null); }}
+              onRowSelectedQso={(r) => setSelQso(r ? { call: String(r.callsign ?? ""), band: String(r.band ?? ""), mode: String(r.mode ?? "") } : null)}
             />
           </div>
         );
@@ -5477,9 +5687,13 @@ export default function App() {
             {/* Row 2: Name fixed to the Band/Mode/Country column width (300px) so
                 its right edge lines up with that column below; QTH grows to fill.
                 gap-4 matches Row 3 so QTH's left edge aligns with Comment/Note. */}
-            <div className="flex gap-4 items-end">
+            {/* flex-wrap, not overflow: at the narrowest window the Grid box used
+                to be pushed outside the entry panel and clipped. Wrapping drops
+                it to its own line instead, which stays readable. */}
+            <div className="flex gap-4 items-end flex-wrap">
               <div className="flex flex-col w-[300px] shrink-0"><Label className="mb-1 h-3.5">Name</Label>
-                <Input value={name} onChange={(e) => { setName(e.target.value); markEdited('name'); }} />
+                <Input value={name} onChange={(e) => { setName(e.target.value); markEdited('name'); }}
+                  onBlur={() => setName(titleCase)} />
               </div>
               {qthBlock}
               {gridBlock}
@@ -5543,6 +5757,11 @@ export default function App() {
             band={band}
             mode={mode}
             bands={bands}
+            onEditQso={openEdit}
+            {...(!callsign.trim() && selQso ? {
+              slotCall: selQso.call, slotBand: selQso.band, slotMode: selQso.mode,
+              slotWb: selWb, slotWbBusy: selWbBusy,
+            } : {})}
             tab={detailTab}
             onTab={setDetailTab}
             keyerActive={(wkEnabled && wkStatus.connected) || dvkEnabled}
@@ -5702,11 +5921,11 @@ export default function App() {
                 // exactly when its CAT backend is. Yaesu was missing from this
                 // list, so the panel fell back to the WinKeyer status — which
                 // reported disconnected, no WinKeyer being attached.
-                status={cwSource === 'icom' || cwSource === 'flex' || cwSource === 'yaesu'
+                status={cwSource === 'icom' || cwSource === 'flex' || cwSource === 'yaesu' || cwSource === 'kenwood'
                   ? {
                     connected: catState.backend === cwSource && catState.connected,
                     busy: false, wpm: wkWpm, version: 0,
-                    port: cwSource === 'flex' ? 'CWX' : cwSource === 'yaesu' ? 'CAT' : 'CI-V',
+                    port: cwSource === 'flex' ? 'CWX' : cwSource === 'yaesu' || cwSource === 'kenwood' ? 'CAT' : 'CI-V',
                   }
                   : wkStatus}
                 ports={wkPorts}
@@ -5813,9 +6032,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)]',
-        showBandMap ? (bandMapSide === 'left' ? 'grid-cols-[300px_1fr]' : 'grid-cols-[1fr_300px]') : 'grid-cols-[1fr]')}>
-        <section className="bg-card border border-border rounded-lg shadow-sm flex flex-col min-h-0 overflow-hidden">
+      {/* The band map is a fixed-width column with a draggable grip on its inner
+          edge — the gap between the two panes doubles as the handle, so no room
+          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>
@@ -5914,12 +6139,29 @@ export default function App() {
 
             <TabsContent value="recent" className="mt-0 flex flex-col min-h-0 flex-1">
               <div className="flex gap-2 p-2.5 border-b border-border/60">
-                <Input
-                  className="flex-1"
-                  placeholder="Search callsign…"
-                  value={filterCallsign}
-                  onChange={(e) => setFilterCallsign(e.target.value)}
-                />
+                {/* Callsign-only search: forced upper-case (a call is never
+                    lower-case, and the operator shouldn't have to hold shift)
+                    with an inline clear so wiping the filter is one click
+                    instead of a select-all + delete. */}
+                <div className="relative flex-1">
+                  <Input
+                    className="w-full pr-8 font-mono"
+                    placeholder="Search callsign…"
+                    value={filterCallsign}
+                    onChange={(e) => setFilterCallsign(e.target.value.toUpperCase())}
+                  />
+                  {filterCallsign && (
+                    <button
+                      type="button"
+                      aria-label={t('btn.clear')}
+                      title={t('btn.clear')}
+                      className="absolute right-1.5 top-1/2 -translate-y-1/2 inline-flex items-center justify-center size-5 rounded text-muted-foreground hover:text-foreground hover:bg-foreground/10"
+                      onClick={() => setFilterCallsign('')}
+                    >
+                      <X className="size-3.5" />
+                    </button>
+                  )}
+                </div>
                 <Button variant="outline" size="sm" onClick={() => refresh()}>
                   <RefreshCw className="size-3.5" /> Refresh
                 </Button>
@@ -5993,6 +6235,7 @@ export default function App() {
                 onExportCabrilloFiltered={exportFilteredCabrillo}
                 onDelete={(ids) => setDeletingIds(ids)}
                 onRowSelected={(ids) => { setSelectedIds(ids); setSelectedId(ids[0] ?? null); }}
+              onRowSelectedQso={(r) => setSelQso(r ? { call: String(r.callsign ?? ""), band: String(r.band ?? ""), mode: String(r.mode ?? "") } : null)}
               />
               <div className="px-3 py-1.5 border-t border-border/60 text-[11px] text-muted-foreground flex items-center justify-between gap-3 bg-muted/30">
                 <div className="flex items-center gap-3">
@@ -6056,11 +6299,11 @@ export default function App() {
                     min={1}
                     step={100}
                     className="w-24 h-7 font-mono text-xs"
-                    value={qsoLimit}
-                    onChange={(e) => {
-                      const n = Number(e.target.value);
-                      if (Number.isFinite(n) && n > 0) setQsoLimit(Math.floor(n));
-                    }}
+                    value={qsoLimitText}
+                    onChange={(e) => setQsoLimitText(e.target.value)}
+                    onBlur={commitQsoLimit}
+                    onKeyDown={(e) => { if (e.key === 'Enter') (e.target as HTMLInputElement).blur(); }}
+                    title="Rows loaded into the list — press Enter to apply"
                   />
                   <Button
                     variant="ghost"
@@ -6369,7 +6612,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)}
@@ -6388,7 +6647,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

@@ -34,10 +34,13 @@ export type AwardDef = {
   url?: string; download_url?: string; ref_url?: string; valid_from?: string; valid_to?: string; alias?: string;
   ref_display?: string; // grid column shows: ref | name | both
   type?: string; field: string; match_by?: string; exact_match?: boolean; one_ref_per_qso?: boolean; pattern: string;
-  leading_str?: string; trailing_str?: string; dynamic?: boolean;
+  leading_str?: string; trailing_str?: string; prefix?: string; dynamic?: boolean;
   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;
 };
 
@@ -556,9 +559,10 @@ export function AwardEditor({ open, onClose, onSaved }: Props) {
                       <label className="flex items-center gap-2 text-xs cursor-pointer pl-[128px]"><Checkbox checked={!!cur.exact_match} onCheckedChange={(c) => patch({ exact_match: !!c })} /> {t('awed.exactMatch')}</label>
                       <label className="flex items-center gap-2 text-xs cursor-pointer pl-[128px]" title={t('awed.oneRefHint')}><Checkbox checked={!!cur.one_ref_per_qso} onCheckedChange={(c) => patch({ one_ref_per_qso: !!c })} /> {t('awed.oneRef')}</label>
                       <Field2 label={t('awed.patternRegex')}><Input className="h-8 font-mono text-xs" value={cur.pattern} onChange={(e) => patch({ pattern: e.target.value })} placeholder={t('awed.patternPlaceholder')} /></Field2>
-                      <div className="grid grid-cols-2 gap-3">
+                      <div className="grid grid-cols-3 gap-3">
                         <Field2 label={t('awed.leadingString')}><Input className="h-8 font-mono text-xs" value={cur.leading_str ?? ''} onChange={(e) => patch({ leading_str: e.target.value })} /></Field2>
                         <Field2 label={t('awed.trailingString')}><Input className="h-8 font-mono text-xs" value={cur.trailing_str ?? ''} onChange={(e) => patch({ trailing_str: e.target.value })} /></Field2>
+                        <Field2 label={t('awed.prefix')}><Input className="h-8 font-mono text-xs" value={cur.prefix ?? ''} onChange={(e) => patch({ prefix: e.target.value })} placeholder={t('awed.prefixPlaceholder')} title={t('awed.prefixTitle')} /></Field2>
                       </div>
 
                       {/* Fallback searches: tried in order, only while nothing
@@ -621,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/AwardsPanel.tsx

@@ -1,6 +1,7 @@
 import { useEffect, useMemo, useState } from 'react';
 import { Award as AwardIcon, RefreshCw, Loader2, Search, Pencil, X, Grid3x3, List, BarChart3, AlertTriangle, ChevronUp, ChevronDown } from 'lucide-react';
-import { GetAwardDefs, GetAward, AwardCellQSOs, GetAwardStats, AwardMissingQSOs, ListAwardReferences, AssignAwardRefToQSOs, RescanAwards } from '../../wailsjs/go/main/App';
+import { GetAwardDefs, GetAward, AwardCellQSOs, GetAwardStats, AwardMissingQSOs, ListAwardReferences, AssignAwardRefToQSOs, RescanAwards, GetTrackedAwards } from '../../wailsjs/go/main/App';
+import { EventsOn } from '../../wailsjs/runtime/runtime';
 import { Input } from '@/components/ui/input';
 import { Button } from '@/components/ui/button';
 import { Checkbox } from '@/components/ui/checkbox';
@@ -137,13 +138,20 @@ export function AwardsPanel({ onEditQSO, onAwardsChanged }: { onEditQSO?: (id: n
     }
   }
 
-  // Load the award list (no QSO scan), then compute only the first award.
+  // Load the award list (no QSO scan), then compute only the first award. The
+  // list is narrowed to the awards the operator follows (Settings → Awards); an
+  // empty follow-set means "show them all" so the tab is never blank.
   async function loadList() {
     try {
-      const defs = ((await GetAwardDefs()) ?? []) as any[];
-      const list: AwardListItem[] = defs
+      const [defs, tracked] = await Promise.all([
+        GetAwardDefs().then((d) => (d ?? []) as any[]),
+        GetTrackedAwards().then((t) => (t ?? []) as string[]).catch(() => [] as string[]),
+      ]);
+      const follow = new Set(tracked);
+      let list: AwardListItem[] = defs
         .map((d) => ({ code: d.code, name: d.name, valid: d.valid, bands: d.valid_bands ?? [], emission: d.emission ?? [] }))
         .sort((a, b) => a.code.localeCompare(b.code));
+      if (follow.size > 0) list = list.filter((a) => follow.has(a.code));
       setAwardList(list);
       const first = list.find((a) => a.code === selected) ?? list[0];
       if (first) compute(first.code);
@@ -152,6 +160,12 @@ export function AwardsPanel({ onEditQSO, onAwardsChanged }: { onEditQSO?: (id: n
     }
   }
   useEffect(() => { loadList(); }, []);
+  // Re-filter when the operator changes their followed awards in Settings.
+  useEffect(() => {
+    const off = EventsOn('awards:tracked-changed', () => { loadList(); });
+    return () => { off(); };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
 
   const current = byCode[`${selected}|${modeFilter}`];
   // Recompute when the mode class changes: the bands, counts and confirmations
@@ -211,11 +225,14 @@ export function AwardsPanel({ onEditQSO, onAwardsChanged }: { onEditQSO?: (id: n
   // Alicante" — which reference order scatters across the whole table.
   // Remembered through writeUiPref rather than localStorage, so the choice
   // travels with a copied data/ folder like every other UI preference here.
-  const [refSort, setRefSort] = useState<'ref' | 'name'>(
-    () => (localStorage.getItem('opslog.awardRefSort') === 'name' ? 'name' : 'ref'));
+  const [refSort, setRefSort] = useState<'ref' | 'name' | 'group'>(
+    () => {
+      const v = localStorage.getItem('opslog.awardRefSort');
+      return v === 'name' || v === 'group' ? v : 'ref';
+    });
   const [refSortDir, setRefSortDir] = useState<'asc' | 'desc'>(
     () => (localStorage.getItem('opslog.awardRefSortDir') === 'desc' ? 'desc' : 'asc'));
-  const toggleRefSort = (k: 'ref' | 'name') => {
+  const toggleRefSort = (k: 'ref' | 'name' | 'group') => {
     if (k === refSort) {
       const d = refSortDir === 'asc' ? 'desc' : 'asc';
       setRefSortDir(d);
@@ -258,10 +275,26 @@ export function AwardsPanel({ onEditQSO, onAwardsChanged }: { onEditQSO?: (id: n
         if (c !== 0) return c * dir;
         return a.ref.localeCompare(b.ref) * dir; // stable tie-break
       }
+      if (refSort === 'group') {
+        // Prefix order (XE, YV, ZL…) — how a DX operator actually thinks about
+        // entities. Blank prefixes sink to the bottom regardless of direction,
+        // so an unresolved entity never heads the list.
+        const ag = a.group ?? '', bg = b.group ?? '';
+        if (!ag !== !bg) return ag ? -1 : 1;
+        const c = ag.localeCompare(bg, undefined, { sensitivity: 'base' });
+        if (c !== 0) return c * dir;
+        return a.ref.localeCompare(b.ref, undefined, { numeric: true }) * dir;
+      }
       return a.ref.localeCompare(b.ref, undefined, { numeric: true }) * dir;
     });
   }, [current, refSearch, refFilter, modeFilter, refSort, refSortDir]);
 
+  // The group column earns its width only when the list actually carries one
+  // (DXCC prefixes, POTA locations); most custom lists have none. For DXCC the
+  // value IS the primary prefix, so it is labelled as such.
+  const hasGroup = useMemo(() => filteredRefs.some((r) => !!r.group), [filteredRefs]);
+  const groupColLabel = current && current.code.toUpperCase() === 'DXCC' ? t('awp.prefixCol') : t('awp.groupCol');
+
   return (
     <div className="flex h-full min-h-0">
       {/* Award list */}
@@ -459,6 +492,14 @@ export function AwardsPanel({ onEditQSO, onAwardsChanged }: { onEditQSO?: (id: n
                           {refSort === 'ref' && (refSortDir === 'asc' ? <ChevronUp className="size-3" /> : <ChevronDown className="size-3" />)}
                         </button>
                       </th>
+                      {hasGroup && (
+                        <th className="text-left py-1.5 pr-3 font-medium border-b border-border w-20">
+                          <button type="button" onClick={() => toggleRefSort('group')} className="inline-flex items-center gap-1 hover:text-foreground">
+                            {groupColLabel}
+                            {refSort === 'group' && (refSortDir === 'asc' ? <ChevronUp className="size-3" /> : <ChevronDown className="size-3" />)}
+                          </button>
+                        </th>
+                      )}
                       <th className="text-left py-1.5 pr-3 font-medium border-b border-border">
                         <button type="button" onClick={() => toggleRefSort('name')} className="inline-flex items-center gap-1 hover:text-foreground">
                           {t('awp.description')}
@@ -474,9 +515,10 @@ export function AwardsPanel({ onEditQSO, onAwardsChanged }: { onEditQSO?: (id: n
                     {filteredRefs.map((r) => (
                       <tr key={r.ref} className={cn('hover:bg-accent/20', !r.worked && 'opacity-60')}>
                         <td className="sticky left-0 bg-card hover:bg-accent/20 py-1 pr-2 font-mono font-semibold border-b border-border/30">{r.ref}</td>
-                        <td className="py-1 pr-3 text-muted-foreground truncate max-w-[360px] border-b border-border/30">
-                          {r.name}{r.group ? <span className="text-muted-foreground/60"> · {r.group}</span> : ''}
-                        </td>
+                        {hasGroup && (
+                          <td className="py-1 pr-3 font-mono font-semibold border-b border-border/30">{r.group}</td>
+                        )}
+                        <td className="py-1 pr-3 text-muted-foreground truncate max-w-[360px] border-b border-border/30">{r.name}</td>
                         {gridBands.map((b) => {
                           const s = cellStatus(r, b);
                           return (
@@ -513,7 +555,12 @@ export function AwardsPanel({ onEditQSO, onAwardsChanged }: { onEditQSO?: (id: n
                           {refSort === 'name' && (refSortDir === 'asc' ? <ChevronUp className="size-3" /> : <ChevronDown className="size-3" />)}
                         </button>
                       </th>
-                      <th className="py-1.5 pr-2 font-medium w-40">{t('awp.groupCol')}</th>
+                      <th className="py-1.5 pr-2 font-medium w-40">
+                        <button type="button" onClick={() => toggleRefSort('group')} className="inline-flex items-center gap-1 hover:text-foreground">
+                          {groupColLabel}
+                          {refSort === 'group' && (refSortDir === 'asc' ? <ChevronUp className="size-3" /> : <ChevronDown className="size-3" />)}
+                        </button>
+                      </th>
                       <th className="py-1.5 pr-2 font-medium w-24">{t('awp.status')}</th>
                       <th className="py-1.5 font-medium">{t('awp.bands')}</th>
                     </tr>

frontend/src/components/BandMap.tsx

@@ -358,6 +358,43 @@ export function BandMap({ band, spots, spotStatus, currentFreqHz, onSpotClick, o
     return () => el.removeEventListener('wheel', onWheel);
   }, [range]);
 
+  // Ctrl+↑ / Ctrl+↓ hop to the next spot above / below the rig frequency and tune
+  // to it. Higher freq is UP on the map (see freqToY), so ↑ = next higher spot.
+  // Only active on the docked Main-view map (keyNav) and ignored while typing.
+  // MUST stay ABOVE the `if (!range)` early return below: on an unknown band
+  // (e.g. a spurious 33 cm CAT reading from an Icom) that return skipped this
+  // hook, so the hook count changed between renders and React crashed with #300
+  // ("rendered fewer hooks than expected"). lo/hi are always defined (they fall
+  // back to [0,1] when there's no range), so it's safe to run here.
+  useEffect(() => {
+    if (!keyNav) return;
+    const onKey = (e: KeyboardEvent) => {
+      if (!e.ctrlKey || e.altKey || e.metaKey) return;
+      if (e.key !== 'ArrowUp' && e.key !== 'ArrowDown') return;
+      const ae = document.activeElement as HTMLElement | null;
+      const tag = (ae?.tagName || '').toLowerCase();
+      if (tag === 'input' || tag === 'textarea' || tag === 'select' || ae?.isContentEditable) return;
+      const list = spots
+        .filter((s) => (s.band ?? '') === band && s.freq_hz > 0)
+        .slice()
+        .sort((a, b) => a.freq_hz - b.freq_hz);
+      if (!list.length) return;
+      const cur = currentFreqHz || (lo + hi) * 500; // mid-band kHz→Hz when no rig freq
+      const EPS = 50; // Hz, so we don't re-pick the spot we're already sitting on
+      let target: Spot | undefined;
+      if (e.key === 'ArrowUp') {
+        target = list.find((s) => s.freq_hz > cur + EPS);
+      } else {
+        for (let i = list.length - 1; i >= 0; i--) { if (list[i].freq_hz < cur - EPS) { target = list[i]; break; } }
+      }
+      if (!target) return;
+      e.preventDefault();
+      onSpotClick(target);
+    };
+    window.addEventListener('keydown', onKey);
+    return () => window.removeEventListener('keydown', onKey);
+  }, [keyNav, spots, band, currentFreqHz, lo, hi, onSpotClick]);
+
   if (!range) {
     return (
       <div className="h-full w-full flex flex-col items-center justify-center text-xs text-muted-foreground p-3 bg-muted/20">
@@ -388,38 +425,6 @@ export function BandMap({ band, spots, spotStatus, currentFreqHz, onSpotClick, o
     scrollerRef.current.scrollTop = Math.max(0, y - containerH / 2);
   }
 
-  // Ctrl+↑ / Ctrl+↓ hop to the next spot above / below the rig frequency and tune
-  // to it. Higher freq is UP on the map (see freqToY), so ↑ = next higher spot.
-  // Only active on the docked Main-view map (keyNav) and ignored while typing.
-  useEffect(() => {
-    if (!keyNav) return;
-    const onKey = (e: KeyboardEvent) => {
-      if (!e.ctrlKey || e.altKey || e.metaKey) return;
-      if (e.key !== 'ArrowUp' && e.key !== 'ArrowDown') return;
-      const ae = document.activeElement as HTMLElement | null;
-      const tag = (ae?.tagName || '').toLowerCase();
-      if (tag === 'input' || tag === 'textarea' || tag === 'select' || ae?.isContentEditable) return;
-      const list = spots
-        .filter((s) => (s.band ?? '') === band && s.freq_hz > 0)
-        .slice()
-        .sort((a, b) => a.freq_hz - b.freq_hz);
-      if (!list.length) return;
-      const cur = currentFreqHz || (lo + hi) * 500; // mid-band kHz→Hz when no rig freq
-      const EPS = 50; // Hz, so we don't re-pick the spot we're already sitting on
-      let target: Spot | undefined;
-      if (e.key === 'ArrowUp') {
-        target = list.find((s) => s.freq_hz > cur + EPS);
-      } else {
-        for (let i = list.length - 1; i >= 0; i--) { if (list[i].freq_hz < cur - EPS) { target = list[i]; break; } }
-      }
-      if (!target) return;
-      e.preventDefault();
-      onSpotClick(target);
-    };
-    window.addEventListener('keydown', onKey);
-    return () => window.removeEventListener('keydown', onKey);
-  }, [keyNav, spots, band, currentFreqHz, lo, hi, onSpotClick]);
-
   const currentKHz = currentFreqHz ? currentFreqHz / 1000 : 0;
   const showRigPointer = currentKHz >= lo && currentKHz <= hi;
   const rigY = freqToY(currentKHz);

frontend/src/components/BandSlotGrid.tsx

@@ -1,8 +1,9 @@
-import { useMemo } from 'react';
-import { Star, Radio, Sunrise, Sunset } from 'lucide-react';
+import { useEffect, useMemo, useState } from 'react';
+import { Star, Radio, Sunrise, Sunset, X, Loader2 } from 'lucide-react';
 import { Badge } from '@/components/ui/badge';
 import { cn } from '@/lib/utils';
 import { sunTimes } from '@/lib/sun';
+import { BandSlotQSOs } from '../../wailsjs/go/main/App';
 import type { WorkedBeforeView } from '@/types';
 
 type WorkedBefore = WorkedBeforeView;
@@ -18,6 +19,12 @@ interface Props {
   // to an entity with no position at all, and the block simply does not appear.
   lat?: number;
   lon?: number;
+  // Set when the matrix is showing a QSO picked in the log grid rather than the
+  // entry form — labelled so the two can never be confused.
+  forCall?: string;
+  // Open the QSO editor for a contact — makes callsigns in the cell drill-down
+  // clickable. Threaded down from App.openEdit.
+  onEditQso?: (id: number) => void;
 }
 
 // Compact column label for a band tag: keep the classic V/U for 2m/70cm,
@@ -89,7 +96,9 @@ function cellTitle(band: string, cls: string, status: string, current: boolean):
   return `${band} ${cls}: ${desc}${current ? ' — current entry' : ''}`;
 }
 
-export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, hasCall = true, lat, lon }: Props) {
+export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, hasCall = true, lat, lon, forCall, onEditQso }: Props) {
+  // Cell drill-down: which band+class the operator clicked, or null.
+  const [slot, setSlot] = useState<{ band: string; cls: string } | null>(null);
   // Columns from the operator's configured bands (so the matrix shows only the
   // bands they actually use), falling back to the built-in default set.
   const cols = useMemo(
@@ -208,6 +217,14 @@ export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, hasCal
           </>
         ) : hasDxcc ? (
           <>
+            {/* Says WHOSE stats these are when they come from a row picked in
+                the log rather than from what's being typed. */}
+            {forCall && (
+              <Badge variant="outline" className="px-2 py-0.5 text-[10px] font-mono shrink-0"
+                title="Stats for the QSO selected in the log">
+                {forCall}
+              </Badge>
+            )}
             <Badge className="bg-primary text-primary-foreground px-3 py-1 text-xs normal-case font-semibold tracking-normal">
               {dxccName || `DXCC #${dxcc}`}
             </Badge>
@@ -282,10 +299,14 @@ export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, hasCal
                   return (
                     <td
                       key={b.tag}
-                      title={cellTitle(b.tag, cls, st, isCurrent)}
+                      title={cellTitle(b.tag, cls, st, isCurrent) + (st ? ' — click to list the QSOs' : '')}
+                      onClick={st ? () => setSlot({ band: b.tag, cls }) : undefined}
                       className={cn(
                         'w-[28px] h-[24px] rounded transition-colors p-0',
                         st ? STATUS_CLASSES[st] : 'bg-mx-none',
+                        // Only a filled cell has anything to show — an empty one
+                        // stays inert rather than opening a "no QSOs" dialog.
+                        st && 'cursor-pointer hover:brightness-110',
                         isCurrent && 'ring-2 ring-warning ring-inset',
                       )}
                     />
@@ -313,6 +334,119 @@ export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, hasCal
         ))}
       </div>
       </div>
+
+      {slot && (
+        <SlotQSOModal
+          call={wb?.callsign ?? ''}
+          dxcc={dxcc}
+          entity={dxccName}
+          band={slot.band}
+          cls={slot.cls}
+          onClose={() => setSlot(null)}
+          onEdit={onEditQso}
+        />
+      )}
     </section>
   );
 }
+
+// ── Cell drill-down ──────────────────────────────────────────────────────────
+// The contacts behind one band+class cell: this exact callsign AND anyone else
+// in the entity, because that is the pair of facts the cell's colour encodes.
+// The call's own QSOs are marked so the two never blur together.
+
+function SlotQSOModal({ call, dxcc, entity, band, cls, onClose, onEdit }: {
+  call: string; dxcc: number; entity: string; band: string; cls: string; onClose: () => void; onEdit?: (id: number) => void;
+}) {
+  const [rows, setRows] = useState<any[] | null>(null);
+  const [err, setErr] = useState('');
+
+  useEffect(() => {
+    let dead = false;
+    BandSlotQSOs(call, dxcc, band, cls)
+      .then((r: any) => { if (!dead) setRows((r ?? []) as any[]); })
+      .catch((e: any) => { if (!dead) { setErr(String(e?.message ?? e)); setRows([]); } });
+    return () => { dead = true; };
+  }, [call, dxcc, band, cls]);
+
+  useEffect(() => {
+    // Capture phase: the app's global ESC handler resets the entry form, and
+    // closing a dialog must not also wipe what the operator was typing.
+    function onKey(e: KeyboardEvent) {
+      if (e.key === 'Escape') { e.stopImmediatePropagation(); e.preventDefault(); onClose(); }
+    }
+    window.addEventListener('keydown', onKey, true);
+    return () => window.removeEventListener('keydown', onKey, true);
+  }, [onClose]);
+
+  return (
+    <div className="fixed inset-0 z-50 flex items-center justify-center bg-black/60 backdrop-blur-[2px] p-4" onClick={onClose}>
+      <div className="bg-card border border-border rounded-xl shadow-2xl w-[760px] max-w-full max-h-[72vh] flex flex-col overflow-hidden ring-1 ring-black/5"
+        onClick={(e) => e.stopPropagation()}>
+        <div className="flex items-center gap-2.5 px-4 py-2.5 border-b border-border bg-muted/30">
+          <span className="inline-flex items-center justify-center h-6 min-w-6 px-1.5 rounded-md bg-primary/15 text-primary text-[11px] font-bold shrink-0 tabular-nums">{band}</span>
+          <div className="min-w-0">
+            <div className="font-semibold text-sm leading-tight truncate">
+              {cls}{entity && <span className="text-muted-foreground font-normal"> · {entity}</span>}
+            </div>
+            {onEdit && <div className="text-[10px] text-muted-foreground leading-tight">Click a callsign to edit the QSO</div>}
+          </div>
+          <span className="ml-auto text-xs text-muted-foreground tabular-nums shrink-0">{rows ? `${rows.length} QSO${rows.length > 1 ? 's' : ''}` : ''}</span>
+          <button type="button" onClick={onClose} className="text-muted-foreground hover:text-foreground shrink-0 rounded p-0.5 hover:bg-muted transition-colors">
+            <X className="size-4" />
+          </button>
+        </div>
+        <div className="flex-1 overflow-auto">
+          {err && <p className="p-3 text-xs text-destructive">{err}</p>}
+          {!rows ? (
+            <p className="p-4 text-xs text-muted-foreground flex items-center gap-2">
+              <Loader2 className="size-3.5 animate-spin" /> Loading…
+            </p>
+          ) : rows.length === 0 ? (
+            <p className="p-4 text-xs text-muted-foreground italic">No QSOs.</p>
+          ) : (
+            <table className="w-full text-xs border-collapse">
+              <thead className="sticky top-0 z-10 bg-muted/80 backdrop-blur text-[10px] uppercase tracking-wider text-muted-foreground">
+                <tr>
+                  <th className="text-left font-medium px-3 py-1.5">Date UTC</th>
+                  <th className="text-left font-medium px-3 py-1.5">Callsign</th>
+                  <th className="text-left font-medium px-3 py-1.5">Mode</th>
+                  <th className="text-left font-medium px-3 py-1.5">Freq</th>
+                  <th className="text-left font-medium px-3 py-1.5">Name</th>
+                  <th className="text-center font-medium px-3 py-1.5">Cfm</th>
+                </tr>
+              </thead>
+              <tbody>
+                {rows.map((q, i) => {
+                  const cfm = q.lotw_rcvd === 'Y' || q.eqsl_rcvd === 'Y' || q.qsl_rcvd === 'Y';
+                  const mine = q.callsign === call;
+                  return (
+                    <tr key={q.id ?? i} className="border-t border-border/40 even:bg-muted/[0.06] hover:bg-primary/[0.06] transition-colors">
+                      <td className="px-3 py-1.5 tabular-nums text-muted-foreground whitespace-nowrap">
+                        {String(q.qso_date ?? '').slice(0, 16).replace('T', ' ')}
+                      </td>
+                      <td className="px-3 py-1.5">
+                        {onEdit ? (
+                          <button type="button" onClick={() => { onEdit(q.id as number); onClose(); }} title="Edit this QSO"
+                            className={cn('font-mono cursor-pointer text-left hover:underline underline-offset-2', mine ? 'font-bold text-primary' : 'text-foreground hover:text-primary')}>
+                            {q.callsign}
+                          </button>
+                        ) : (
+                          <span className={cn('font-mono', mine && 'font-bold text-primary')}>{q.callsign}</span>
+                        )}
+                      </td>
+                      <td className="px-3 py-1.5">{q.mode}</td>
+                      <td className="px-3 py-1.5 tabular-nums text-muted-foreground">{q.freq_hz ? (q.freq_hz / 1e6).toFixed(3) : ''}</td>
+                      <td className="px-3 py-1.5 text-muted-foreground truncate max-w-[180px]">{q.name}</td>
+                      <td className="px-3 py-1.5 text-center">{cfm ? <span className="text-success">✓</span> : <span className="text-muted-foreground/30">·</span>}</td>
+                    </tr>
+                  );
+                })}
+              </tbody>
+            </table>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+}

frontend/src/components/ClusterGrid.tsx

@@ -140,6 +140,19 @@ function statusColor(s: SpotStatusEntry | undefined): string | null {
   }
 }
 
+// isDull reports a spot that "represents nothing" under the current worked/slot
+// rules: the entity/band/mode is already worked (status resolved, not new in any
+// dimension), the callsign itself isn't in the log, and there's no POTA / county
+// / prefix novelty. Such rows are dimmed so the eye skips them. Because the
+// status obeys the DX-cluster "same slot" option and the digital-mode grouping,
+// what counts as dull follows those settings automatically. Unresolved statuses
+// (still loading, or entity unknown) are NOT dimmed — that would flicker.
+function isDull(s: SpotStatusEntry | undefined): boolean {
+  if (!s || !s.status) return false;
+  if (s.status === 'new' || s.status === 'new-band' || s.status === 'new-mode' || s.status === 'new-slot') return false;
+  return !(s.worked_call || s.new_pota || s.new_county || s.new_pfx);
+}
+
 const makeColCatalog = (t: TFn): ColEntry[] => [
   {
     group: 'Spot', label: t('clg2.c.time'),  colId: 'time',
@@ -397,6 +410,11 @@ export function ClusterGrid({ rows, spotStatus, onSpotClick }: Props) {
 
   const defaultColDef = useMemo<ColDef>(() => ({
     sortable: true, resizable: true, filter: true, suppressMovable: false,
+    // Dim "represents nothing" spots at the CELL level, via a class that
+    // refreshCells re-applies. Doing it with a row STYLE needed redrawRows() on
+    // every status update, which re-rendered the whole grid continuously and
+    // pegged the CPU on a busy cluster (the 0.23.6 slowdown).
+    cellClassRules: { 'opacity-40': (p: any) => isDull(statusFor(p)) },
   }), []);
 
   // Pass spotStatus through AG Grid's context so cell renderers can look up
@@ -406,12 +424,22 @@ export function ClusterGrid({ rows, spotStatus, onSpotClick }: Props) {
   const context = useMemo(() => ({ spotStatus }), [spotStatus]);
 
   // Spot statuses arrive asynchronously (~after the rows render). The Call/Band/
-  // Mode cellStyles depend on them but their cell VALUE doesn't change, so ag-grid
-  // won't re-render those cells on its own — force a refresh so e.g. a worked call
-  // turns blue once its status loads.
+  // Mode cellStyles and the dimmed "represents nothing" class depend on them but
+  // the cell VALUE doesn't change, so ag-grid won't re-render on its own — force a
+  // refresh so e.g. a worked call turns blue once its status loads.
+  //
+  // THROTTLED: under an RBN firehose spotStatus updates ~20×/second, and firing a
+  // full refreshCells that often is pure churn on a slow PC. Coalesce the bursts
+  // into one refresh every 200 ms (still imperceptible) instead of one per update.
+  const refreshPending = useRef<number | undefined>(undefined);
   useEffect(() => {
-    gridRef.current?.api?.refreshCells({ force: true });
+    if (refreshPending.current !== undefined) return; // a refresh is already queued
+    refreshPending.current = window.setTimeout(() => {
+      refreshPending.current = undefined;
+      gridRef.current?.api?.refreshCells({ force: true });
+    }, 200);
   }, [spotStatus]);
+  useEffect(() => () => { if (refreshPending.current !== undefined) window.clearTimeout(refreshPending.current); }, []);
 
   // Restore AFTER the profile scope is known — this grid has no key= remount to
   // save it from reading the wrong (unscoped) cache key at first paint.

frontend/src/components/DetailsPanel.tsx

@@ -69,6 +69,14 @@ interface Props {
   band: string;
   mode: string;
   bands?: string[]; // configured bands for the worked-before matrix columns
+  // When the entry form is empty and a QSO is selected in the log grid, the
+  // Stats (F1) matrix shows THAT contact's entity instead of sitting blank.
+  // Only the matrix is redirected — every other tab still edits the live entry.
+  slotCall?: string;
+  slotBand?: string;
+  slotMode?: string;
+  slotWb?: any;
+  slotWbBusy?: boolean;
   imageUrl?: string;
   onOpenImage?: () => void;
   // Optional controlled active tab (so the app can switch it via keyboard).
@@ -77,6 +85,8 @@ interface Props {
   // When the WinKeyer is active, F1-F12 fire macros, so the tab shortcut is
   // shown as Ctrl+F1…F5 instead of F1…F5.
   keyerActive?: boolean;
+  // Open the QSO editor — makes callsigns clickable in the band-slot drill-down.
+  onEditQso?: (id: number) => void;
 }
 
 export type TabName = 'stats' | 'info' | 'awards' | 'my' | 'extended';
@@ -139,7 +149,7 @@ function Field({ label, span = 1, className, children }: { label: string; span?:
   );
 }
 
-export function DetailsPanel({ callsign, prefix, operatorGrid, remoteGrid, qth, name, country, comment, note, details, onChange, wb, wbBusy, band, mode, bands, tab, onTab, keyerActive }: Props) {
+export function DetailsPanel({ callsign, prefix, operatorGrid, remoteGrid, qth, name, country, comment, note, details, onChange, wb, wbBusy, band, mode, bands, slotCall, slotBand, slotMode, slotWb, slotWbBusy, tab, onTab, keyerActive, onEditQso }: Props) {
   const { t } = useI18n();
   const [internalOpen, setInternalOpen] = useState<TabName>('stats');
   const open = tab ?? internalOpen; // controlled when `tab` is provided
@@ -272,7 +282,15 @@ export function DetailsPanel({ callsign, prefix, operatorGrid, remoteGrid, qth,
       <div className={cn('flex-1 min-h-0', open === 'stats' ? 'overflow-hidden' : 'overflow-y-auto')}>
       {open === 'stats' && (
         <div className="px-3 py-2.5">
-          <BandSlotGrid wb={wb} busy={!!wbBusy} currentBand={band} currentMode={mode} bands={bands} hasCall={callsign.trim() !== ''}
+          <BandSlotGrid
+            wb={slotCall ? slotWb : wb}
+            busy={slotCall ? !!slotWbBusy : !!wbBusy}
+            currentBand={slotCall ? (slotBand ?? '') : band}
+            currentMode={slotCall ? (slotMode ?? '') : mode}
+            bands={bands}
+            hasCall={slotCall ? true : callsign.trim() !== ''}
+            forCall={slotCall}
+            onEditQso={onEditQso}
             lat={dxLL?.lat} lon={dxLL?.lon} />
         </div>
       )}
@@ -447,18 +465,18 @@ export function DetailsPanel({ callsign, prefix, operatorGrid, remoteGrid, qth,
             </Select>
           </Field>
           <Field label={t('detp.rig')} span={3}>
-            <Input value={details.my_rig} placeholder="Flex 8600" onChange={(e) => onChange({ my_rig: e.target.value })} />
+            <Input value={details.my_rig} onChange={(e) => onChange({ my_rig: e.target.value })} />
           </Field>
           <Field label={t('detp.antenna')} span={3}>
-            <Input value={details.my_antenna} placeholder="UB640" onChange={(e) => onChange({ my_antenna: e.target.value })} />
+            <Input value={details.my_antenna} onChange={(e) => onChange({ my_antenna: e.target.value })} />
           </Field>
           {satelliteMode && (
             <>
               <Field label={t('detp.satName')} span={3}>
-                <Input value={details.sat_name} placeholder="AO-91" onChange={(e) => onChange({ sat_name: e.target.value })} />
+                <Input value={details.sat_name} onChange={(e) => onChange({ sat_name: e.target.value })} />
               </Field>
               <Field label={t('detp.satelliteMode')} span={3}>
-                <Input value={details.sat_mode} placeholder="U/V" onChange={(e) => onChange({ sat_mode: e.target.value })} />
+                <Input value={details.sat_mode} onChange={(e) => onChange({ sat_mode: e.target.value })} />
               </Field>
             </>
           )}

frontend/src/components/LogViewer.tsx

@@ -21,7 +21,13 @@ import { TailLogFile, GetLogFilePath } from '../../wailsjs/go/main/App';
 //     256 KB blob: with "cluster" or "acom" typed in, the window becomes exactly
 //     the subsystem trace you would have grepped for.
 //   • It polls only while open. A closed dialog costs nothing.
-const TAIL_BYTES = 256 * 1024;
+// 512 KB ≈ 3200 lines. The window is a sliding tail: once new lines push past it
+// the oldest fall out of the fetched text entirely, so a small buffer dropped
+// lines the operator was still reading during a busy trace (CAT/cluster/antenna
+// polling). This is double the old 256 KB — 1 MB was tried but the per-second
+// fetch + split + re-render of ~6500 lines made the window lag. 512 KB keeps a
+// useful backlog while staying smooth. The backend caps this at 4 MB.
+const TAIL_BYTES = 512 * 1024;
 const POLL_MS = 1000;
 
 export function LogViewer({ open, onOpenChange }: { open: boolean; onOpenChange: (v: boolean) => void }) {

frontend/src/components/QSLManagerModal.tsx

@@ -8,7 +8,7 @@ import {
   Select, SelectTrigger, SelectValue, SelectContent, SelectItem,
 } from '@/components/ui/select';
 import { cn } from '@/lib/utils';
-import { FindQSOsForUpload, UploadQSOsManual, DownloadConfirmations, SyncPOTAHunterLog, ListQSO, BulkUpdateQSL, UploadCallsign, GetSlotStats } from '../../wailsjs/go/main/App';
+import { FindQSOsForUpload, UploadQSOsManual, DownloadConfirmations, CancelConfirmations, SyncPOTAHunterLog, ListQSO, BulkUpdateQSL, UploadCallsign, GetSlotStats } from '../../wailsjs/go/main/App';
 import { Input } from '@/components/ui/input';
 import { RecentQSOsGrid } from '@/components/RecentQSOsGrid';
 import { EventsOn } from '../../wailsjs/runtime/runtime';
@@ -120,6 +120,10 @@ export function QSLManagerPanel({ onEditQSO }: { onEditQSO?: (id: number) => voi
     if (service === 'pota' || service === 'paper') { setUploadCall(''); return; }
     UploadCallsign(service).then((c) => setUploadCall(c || '')).catch(() => setUploadCall(''));
   }, [service]);
+  // Closing the QSL Manager (the tab's ×) unmounts this panel — cancel any download
+  // still running so a slow QRZ/LoTW sync doesn't keep going in the background and
+  // bleed its log into the next one.
+  useEffect(() => () => { CancelConfirmations().catch(() => {}); }, []);
   const [potaSyncing, setPotaSyncing] = useState(false);
   const [potaRes, setPotaRes] = useState<POTASync | null>(null);
   const [potaErr, setPotaErr] = useState('');

frontend/src/components/QSOEditModal.tsx

@@ -1,6 +1,6 @@
 import { useEffect, useMemo, useRef, useState } from 'react';
 import { Trash2, Search, Loader2, CalendarDays } from 'lucide-react';
-import { LookupCallsign, LookupCallsignFresh, DXCCForCountry, GetAwardDefs, ComputeQSOAwardRefs, GetListsSettings } from '../../wailsjs/go/main/App';
+import { LookupCallsign, LookupCallsignFresh, DXCCForCountry, GetAwardDefs, ComputeQSOAwardRefs, GetListsSettings, OpenExternalURL, SetOpsLogQSLReceived } from '../../wailsjs/go/main/App';
 import { rstOptions, type RSTLists } from '@/lib/rst';
 import { AwardRefSelector } from '@/components/AwardRefSelector';
 import { AdifExtrasEditor } from '@/components/AdifExtrasEditor';
@@ -22,6 +22,7 @@ import { Combobox } from '@/components/ui/combobox';
 import { cn } from '@/lib/utils';
 import { flagURL } from '@/lib/flags';
 import { useI18n } from '@/lib/i18n';
+import { titleCase, sentenceCase } from '@/lib/textCase';
 import type { QSOForm } from '@/types';
 
 type QSO = QSOForm;
@@ -72,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();
@@ -428,6 +434,26 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
     [draft.extras],
   );
 
+  // OpsLog QSL "received" marker (ADIF extra). Drives the card's PSE/TNX stamp:
+  // 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 ?? {}) };
+    if (on) next[OPSLOG_QSL_RCVD] = new Date().toISOString();
+    else delete next[OPSLOG_QSL_RCVD];
+    set('extras', next as any);
+    // …and persist right away with a targeted write that reliably sets OR clears
+    // the key (the modal's extras-merge on Save wouldn't clear a removed key).
+    if ((draft as any).id) SetOpsLogQSLReceived((draft as any).id, on).catch(() => {});
+  };
+
   return (
     <Dialog open onOpenChange={(o) => { if (!o) onClose(); }}>
       <DialogContent className="max-w-5xl max-h-[92vh] grid grid-rows-[auto_1fr_auto] gap-0 p-0">
@@ -466,7 +492,22 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
               {/* Top: Callsign + RST + Fetch */}
               <div className="flex items-end gap-2 mb-3">
                 <div className="flex flex-col flex-1 min-w-0">
-                  <Label>{t('qedit.callsign')}</Label>
+                  <div className="flex items-center">
+                    <Label>{t('qedit.callsign')}</Label>
+                    {(draft.callsign ?? '').trim() && (
+                      <button
+                        type="button"
+                        title={t('qrz.openTitle', { call: (draft.callsign ?? '').trim().toUpperCase() })}
+                        onClick={() => {
+                          const c = (draft.callsign ?? '').trim().toUpperCase().split('/').map(encodeURIComponent).join('/');
+                          if (c) OpenExternalURL(`https://www.qrz.com/db/${c}`).catch((e: any) => setLocalErr(String(e?.message ?? e)));
+                        }}
+                        className="ml-auto shrink-0 inline-flex items-center gap-0.5 text-[9px] font-semibold normal-case tracking-wider text-primary hover:underline"
+                      >
+                        QRZ ↗
+                      </button>
+                    )}
+                  </div>
                   <Input className="font-mono text-lg font-bold tracking-wider uppercase h-10"
                     value={draft.callsign ?? ''} onChange={(e) => set('callsign', e.target.value)} />
                 </div>
@@ -483,7 +524,8 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
               <div className="grid grid-cols-2 gap-x-6 gap-y-2.5">
                 {/* ── Left column ── */}
                 <div className="flex flex-col gap-2.5">
-                  <div><Label>{t('qedit.name')}</Label><Input value={draft.name ?? ''} onChange={(e) => set('name', e.target.value)} /></div>
+                  <div><Label>{t('qedit.name')}</Label><Input value={draft.name ?? ''} onChange={(e) => set('name', e.target.value)}
+                    onBlur={() => set('name', titleCase(draft.name ?? '') as any)} /></div>
                   <div className="flex items-center gap-2">
                     <Label className="w-20 shrink-0">{t('qedit.band')}</Label>
                     <Select value={draft.band || ''} onValueChange={(v) => set('band', v)}>
@@ -549,8 +591,10 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
                     <div className="flex flex-col flex-1"><Label>{t('qedit.grid')}</Label><Input value={draft.grid ?? ''} onChange={(e) => set('grid', e.target.value)} className="font-mono uppercase" /></div>
                     <div className="flex flex-col w-24"><Label>PFX</Label><Input readOnly value={pfxOf(draft.callsign ?? '')} className="font-mono bg-muted/40" /></div>
                   </div>
-                  <div><Label>{t('qedit.comment')}</Label><Input value={draft.comment ?? ''} onChange={(e) => set('comment', e.target.value)} /></div>
-                  <div><Label>{t('qedit.note')}</Label><Textarea rows={3} value={draft.notes ?? ''} onChange={(e) => set('notes', e.target.value)} /></div>
+                  <div><Label>{t('qedit.comment')}</Label><Input value={draft.comment ?? ''} onChange={(e) => set('comment', e.target.value)}
+                    onBlur={() => set('comment', sentenceCase(draft.comment ?? '') as any)} /></div>
+                  <div><Label>{t('qedit.note')}</Label><Textarea rows={3} value={draft.notes ?? ''} onChange={(e) => set('notes', e.target.value)}
+                    onBlur={() => set('notes', sentenceCase(draft.notes ?? '') as any)} /></div>
                 </div>
               </div>
             </TabsContent>
@@ -571,7 +615,8 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
                       </SelectContent>
                     </Select>
                   </div>
-                  <div><Label>QTH</Label><Input value={draft.qth ?? ''} onChange={(e) => set('qth', e.target.value)} /></div>
+                  <div><Label>QTH</Label><Input value={draft.qth ?? ''} onChange={(e) => set('qth', e.target.value)}
+                    onBlur={() => set('qth', titleCase(draft.qth ?? '') as any)} /></div>
                   <div><Label>{t('qedit.address')}</Label><Textarea rows={4} value={draft.address ?? ''} onChange={(e) => set('address', e.target.value)} /></div>
                 </div>
                 {/* Right column */}
@@ -581,7 +626,13 @@ 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>
-                  <div><Label>{t('qedit.qslMsg')}</Label><Input value={draft.qsl_msg ?? ''} onChange={(e) => set('qsl_msg', e.target.value)} /></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>
                   <div><Label>{t('qedit.qslVia')}</Label><Input value={draft.qsl_via ?? ''} onChange={(e) => set('qsl_via', e.target.value)} /></div>
                 </div>
               </div>
@@ -629,25 +680,69 @@ 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>
-                      <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>
-                          {def.rcvd
-                            ? <QslSelect value={val(def.rcvd)} onChange={(v) => put(def.rcvd, v)} />
-                            : <Input disabled value="—" />}
+
+                      {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><Label>{t('qedit.dateSent')}</Label><AdifDateInput value={val(def.sentDate)} onChange={(v) => put(def.sentDate, v)} /></div>
-                        <div><Label>{t('qedit.dateReceived')}</Label><AdifDateInput value={val(def.rcvdDate)} onChange={(v) => put(def.rcvdDate, v)} disabled={!def.rcvdDate} /></div>
-                        {def.via && (
-                          <div className="col-span-2"><Label>{t('qedit.via')}</Label><Input value={val(def.via)} onChange={(e) => put(def.via, e.target.value)} placeholder={t('qedit.viaPlaceholder')} /></div>
-                        )}
-                      </div>
-                      <p className="text-[11px] text-muted-foreground">
-                        {t('qedit.qslPanelHint')} <strong>{t('qedit.saveChanges')}</strong>.
-                      </p>
+                      ) : (
+                        <>
+                          <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>
+                              {def.rcvd
+                                ? <QslSelect value={val(def.rcvd)} onChange={(v) => put(def.rcvd, v)} />
+                                : <Input disabled value="—" />}
+                            </div>
+                            <div><Label>{t('qedit.dateSent')}</Label><AdifDateInput value={val(def.sentDate)} onChange={(v) => put(def.sentDate, v)} /></div>
+                            <div><Label>{t('qedit.dateReceived')}</Label><AdifDateInput value={val(def.rcvdDate)} onChange={(v) => put(def.rcvdDate, v)} disabled={!def.rcvdDate} /></div>
+                            {def.via && (
+                              <div className="col-span-2"><Label>{t('qedit.via')}</Label><Input value={val(def.via)} onChange={(e) => put(def.via, e.target.value)} placeholder={t('qedit.viaPlaceholder')} /></div>
+                            )}
+                          </div>
+                          <p className="text-[11px] text-muted-foreground">
+                            {t('qedit.qslPanelHint')} <strong>{t('qedit.saveChanges')}</strong>.
+                          </p>
+                        </>
+                      )}
                     </div>
 
                     {/* Right: live status grid for every channel.
@@ -672,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/RecentQSOsGrid.tsx

@@ -56,6 +56,10 @@ type Props = {
   onRowDoubleClicked?: (q: QSOForm) => void;
   onRowClicked?: (q: QSOForm) => void;
   onRowSelected?: (ids: number[]) => void;
+  // The full first selected row — the Stats (F1) panel shows its entity when the
+  // entry form is empty, so browsing the log answers "what have I got with this
+  // one?" without retyping the call.
+  onRowSelectedQso?: (row: QSOForm | null) => void;
   onUpdateFromCty?: (ids: number[]) => void;
   onUpdateFromQRZ?: (ids: number[]) => void;
   onUpdateFromClublog?: (ids: number[]) => void;
@@ -191,6 +195,8 @@ export const makeColCatalog = (t: TFn, myGrid?: string): ColEntry[] => [
   { group: 'eQSL', label: t('rqg.c.eqsl_rcvd_date'), colId: 'eqsl_rcvd_date', headerName: t('rqg.h.eqsl_rcvd_date'), field: 'eqsl_rcvd_date' as any, width: 120, valueFormatter: (p) => fmtDateOnly(p.value) },
   // App-specific: when OpsLog e-mailed its own QSL card. Distinct from eQSL.cc.
   { group: 'QSL', label: t('rqg.c.opslog_qsl_card_sent'), colId: 'opslog_qsl_card_sent', headerName: t('rqg.c.opslog_qsl_card_sent'), width: 100, cellClass: qslStatusCellClass, valueGetter: (p) => { const e = (p.data as any)?.extras ?? {}; return (e['APP_OPSLOG_QSL_SENT'] || e['APP_OPSLOG_QSL_CARD_SENT']) ? 'Y' : 'N'; }, defaultVisible: true },
+  // App-specific: operator marked a QSL as RECEIVED for this QSO (drives PSE/TNX).
+  { group: 'QSL', label: t('rqg.c.opslog_qsl_card_rcvd'), colId: 'opslog_qsl_card_rcvd', headerName: t('rqg.c.opslog_qsl_card_rcvd'), width: 100, cellClass: qslStatusCellClass, valueGetter: (p) => { const e = (p.data as any)?.extras ?? {}; return e['APP_OPSLOG_QSL_RCVD'] ? 'Y' : 'N'; }, defaultVisible: false },
   // App-specific: when the QSO's audio recording was e-mailed to the station.
   { group: 'QSL', label: t('rqg.c.opslog_recording_sent'), colId: 'opslog_recording_sent', headerName: t('rqg.h.opslog_recording_sent'), width: 100, cellClass: qslStatusCellClass, valueGetter: (p) => { const e = (p.data as any)?.extras ?? {}; return e['APP_OPSLOG_RECORDING_SENT'] ? 'Y' : 'N'; }, defaultVisible: false },
 
@@ -276,14 +282,24 @@ const GRP_KEYS: Record<string, string> = {
 };
 export const groupLabel = (t: TFn, g: string): string => t(GRP_KEYS[g] ?? g);
 
-// Award columns are governed SOLELY by the awardShown code-set, never by AG
-// Grid's saved column state. Stripping them here (on both save and restore)
-// stops a stale saved state from re-hiding a shown award column on every
-// awardCols rebuild — the desync that made award columns vanish mid-session.
-const stripAwardCols = (st: any[] | null | undefined): any[] =>
-  (st ?? []).filter((s) => !String(s?.colId ?? '').startsWith('award_'));
+// Award-column VISIBILITY is governed SOLELY by the awardShown code-set, never
+// by AG Grid's saved column state: dropping `hide` here (on both save and
+// restore) stops a stale saved state from re-hiding a shown award column on
+// every awardCols rebuild — the desync that made award columns vanish
+// mid-session.
+//
+// Their POSITION, however, has to stay in the state. Filtering the entries out
+// entirely left applyColumnState({applyOrder:true}) with no place for them, and
+// AG Grid appends what the state doesn't mention — so a column the operator
+// dragged to sit AFTER an award column jumped back in front of it on reload.
+const sanitizeAwardCols = (st: any[] | null | undefined): any[] =>
+  (st ?? []).map((s) => {
+    if (!String(s?.colId ?? '').startsWith('award_')) return s;
+    const { hide: _hide, ...rest } = s as any;
+    return rest;
+  });
 
-export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal, rowDragCall, passOrder, onGridApi, storageKey, onRowDoubleClicked, onRowClicked, onRowSelected, onUpdateFromCty, onUpdateFromQRZ, onUpdateFromClublog, onSendTo, onSendRecording, onSendEQSL, onBulkEdit, onExportSelected, onExportSelectedFields, onExportFiltered, onExportCabrilloSelected, onExportCabrilloFiltered, onDelete, onFilteredCountChange, awardCols }: Props) {
+export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal, rowDragCall, passOrder, onGridApi, storageKey, onRowDoubleClicked, onRowClicked, onRowSelected, onRowSelectedQso, onUpdateFromCty, onUpdateFromQRZ, onUpdateFromClublog, onSendTo, onSendRecording, onSendEQSL, onBulkEdit, onExportSelected, onExportSelectedFields, onExportFiltered, onExportCabrilloSelected, onExportCabrilloFiltered, onDelete, onFilteredCountChange, awardCols }: Props) {
   const { t } = useI18n();
   const gridRef = useRef<any>(null);
   const [pickerOpen, setPickerOpen] = useState(false);
@@ -464,12 +480,12 @@ export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal,
   function onGridReady(e: GridReadyEvent) {
     onGridApi?.(e.api);
     const local = loadLocal(colStateKey);
-    if (local) e.api.applyColumnState({ state: sanitizeState(stripAwardCols(local)) as ColumnState[], applyOrder: true });
+    if (local) e.api.applyColumnState({ state: sanitizeState(sanitizeAwardCols(local)) as ColumnState[], applyOrder: true });
     // Fall back to the portable DB copy when the local cache is empty
     // (fresh machine / after a reinstall), then re-seed the cache.
     loadRemote(colStateKey).then((remote) => {
       if (remote && !local) {
-        e.api.applyColumnState({ state: sanitizeState(stripAwardCols(remote)) as ColumnState[], applyOrder: true });
+        e.api.applyColumnState({ state: sanitizeState(sanitizeAwardCols(remote)) as ColumnState[], applyOrder: true });
         seedLocal(colStateKey, remote);
       }
     });
@@ -493,7 +509,7 @@ export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal,
     if (restoringRef.current) return; // ignore the events fired by a column rebuild
     const state = gridRef.current?.api?.getColumnState();
     if (!state) return;
-    saveState(colStateKey, stripAwardCols(state));
+    saveState(colStateKey, sanitizeAwardCols(state));
     // Award columns are stripped above, so persist their widths on the side.
     let changed = false;
     for (const s of state) {
@@ -521,7 +537,7 @@ export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal,
   useEffect(() => {
     const api = gridRef.current?.api;
     const local = loadLocal(colStateKey);
-    if (api && local) api.applyColumnState({ state: sanitizeState(stripAwardCols(local)) as ColumnState[], applyOrder: true });
+    if (api && local) api.applyColumnState({ state: sanitizeState(sanitizeAwardCols(local)) as ColumnState[], applyOrder: true });
     // Re-enable saving once AG Grid has settled the column events from the rebuild.
     const t = window.setTimeout(() => { restoringRef.current = false; }, 0);
     return () => window.clearTimeout(t);
@@ -542,6 +558,7 @@ export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal,
     setSelCount(sel.length);
     setDispCount(api?.getDisplayedRowCount?.() ?? 0);
     onRowSelected?.(sel.map((r) => r.id as number).filter((id) => id != null));
+    onRowSelectedQso?.(sel[0] ?? null);
   }
   // Select every row when the caller bumps selectAllSignal (QSL Manager search).
   useEffect(() => {

frontend/src/components/SettingsModal.tsx

@@ -2,7 +2,7 @@ import { useEffect, useMemo, useRef, useState } from 'react';
 import {
   ArrowDown, ArrowUp, ArrowLeft, ArrowRight, Copy, Plus, Star, StarOff, Trash2,
   ChevronDown, ChevronRight,
-  User, Database, Radio, Cog, Server, Award, Antenna as AntennaIcon,
+  User, Database, Radio, Cog, Server, Antenna as AntennaIcon,
   Compass, Wifi, Construction, UploadCloud, Loader2, FolderOpen, Play, Power, Check, Pencil,
 } from 'lucide-react';
 import {
@@ -26,7 +26,8 @@ import {
   AudioStartMonitor, AudioStopMonitor, AudioMonitorActive,
   AudioStartTX, AudioStopTX, AudioTXActive,
   ListClusterServers, SaveClusterServer, DeleteClusterServer,
-  GetClusterAutoConnect, SetClusterAutoConnect,
+  GetClusterAutoConnect, SetClusterAutoConnect, GetSelfSpotSettings, SaveSelfSpotSettings,
+  GetWorkedCallVariants, SetWorkedCallVariants,
   ConnectClusterServer, DisconnectClusterServer,
   ConnectAllClusters, DisconnectAllClusters, GetClusterStatus,
   GetBackupSettings, SaveBackupSettings, RunBackupNow, PickBackupFolder,
@@ -50,6 +51,7 @@ import {
   GetFlexState, GetFlexBandAntennas, SaveFlexBandAntennas, GetFlexBandPower, SaveFlexBandPower,
   GetADIFMonitor, SaveADIFMonitor, PickADIFMonitorFile,
   GetRelayAuto, SaveRelayAuto, GetStationDevices,
+  GetAwardDefs, GetTrackedAwards, SaveTrackedAwards,
 } from '../../wailsjs/go/main/App';
 import type { profile as profileModels } from '../../wailsjs/go/models';
 import type { LookupSettingsForm, StationSettingsForm, ListsSettingsForm, ModePresetForm } from '@/types';
@@ -254,6 +256,7 @@ function buildTree(flexAvailable: boolean, t: (k: string) => string): TreeNode[]
       { kind: 'item', label: t('sec.profiles'), id: 'profiles' },
       { kind: 'item', label: t('sec.operating'), id: 'operating' },
       { kind: 'item', label: t('sec.confirmations'), id: 'confirmations' },
+      { kind: 'item', label: t('sec.awards'), id: 'awards' },
       { kind: 'item', label: t('sec.external'), id: 'external-services' },
     ],
   },
@@ -400,9 +403,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' },
 };
 
@@ -673,6 +680,9 @@ type AmpUI = { id: string; name: string; enabled: boolean; type: string; transpo
 type RelayRuleUI = { device_id: string; relay: number; mode: string; freq_lo_khz: number; freq_hi_khz: number; bands: string[] };
 type StationDevUI = { id: string; type: string; name: string; labels: string[] };
 const RELAY_BANDS = ['160m', '80m', '60m', '40m', '30m', '20m', '17m', '15m', '12m', '10m', '6m', '4m', '2m', '70cm'];
+// Bands a motorized HF/6 m antenna (Ultrabeam / SteppIR) can cover — the follow
+// filter is a subset of these. Must match motorBands in app.go, low → high.
+const MOTOR_BANDS = ['40m', '30m', '20m', '17m', '15m', '12m', '10m', '6m'];
 const relayCountUI = (type: string) => (type === 'kmtronic' || type === 'denkovi' ? 8 : 5);
 
 // Live status + OPERATE/STANDBY toggle for ONE configured amplifier (by config
@@ -941,6 +951,91 @@ function FlexDiscover({ onPick }: { onPick: (ip: string, port: number) => void }
   );
 }
 
+// AwardsSelectionPanel is a two-column transfer list: every defined award on the
+// left, the ones the operator follows on the right. The Awards tab shows only the
+// followed set (empty = all). Per-profile, saved immediately (local SQLite).
+function AwardsSelectionPanel({ profile }: { profile?: { name?: string; callsign?: string } }) {
+  const { t } = useI18n();
+  const [all, setAll] = useState<{ code: string; name: string }[]>([]);
+  const [tracked, setTracked] = useState<string[]>([]);
+  const [err, setErr] = useState('');
+  const [q, setQ] = useState('');
+
+  useEffect(() => {
+    (async () => {
+      try {
+        const [defs, tr] = await Promise.all([
+          GetAwardDefs().then((d) => (d ?? []) as any[]),
+          GetTrackedAwards().then((v) => (v ?? []) as string[]).catch(() => [] as string[]),
+        ]);
+        setAll(defs.map((d) => ({ code: d.code, name: d.name })).sort((a, b) => a.code.localeCompare(b.code)));
+        setTracked(tr);
+      } catch (e: any) { setErr(String(e?.message ?? e)); }
+    })();
+  }, []);
+
+  async function persist(next: string[]) {
+    setTracked(next);
+    try { await SaveTrackedAwards(next); } catch (e: any) { setErr(String(e?.message ?? e)); }
+  }
+  const trackedSet = new Set(tracked);
+  const byCode = new Map(all.map((a) => [a.code, a] as const));
+  const needle = q.trim().toLowerCase();
+  const available = all.filter((a) => !trackedSet.has(a.code)
+    && (needle === '' || `${a.code} ${a.name}`.toLowerCase().includes(needle)));
+  const trackedItems = (tracked.map((c) => byCode.get(c)).filter(Boolean) as { code: string; name: string }[])
+    .sort((a, b) => a.code.localeCompare(b.code));
+
+  return (
+    <div>
+      <SectionHeader title={t('sec.awards')} hint={t('awards.followHint')} />
+      <ProfileScopeNote profile={profile} />
+      {err && <div className="mb-2 text-xs text-destructive">{err}</div>}
+      <div className="grid grid-cols-2 gap-3">
+        <div className="rounded-lg border border-border bg-card/40 flex flex-col">
+          <div className="flex items-center justify-between px-3 py-2 border-b border-border/60">
+            <span className="text-sm font-medium">{t('awards.available')} <span className="text-muted-foreground">({available.length})</span></span>
+            <button type="button" className="text-xs text-primary hover:underline disabled:opacity-40"
+              disabled={available.length === 0} onClick={() => persist(all.map((a) => a.code))}>{t('awards.addAll')}</button>
+          </div>
+          <div className="p-2 border-b border-border/60">
+            <Input value={q} onChange={(e) => setQ(e.target.value)} placeholder={t('awards.search')} className="h-8" />
+          </div>
+          <div className="max-h-[340px] overflow-y-auto p-1.5 space-y-0.5">
+            {available.map((a) => (
+              <button key={a.code} type="button" onClick={() => persist([...tracked, a.code])}
+                className="group w-full flex items-center gap-2 rounded-md px-2 py-1 text-left hover:bg-primary/10">
+                <span className="font-mono text-xs shrink-0">{a.code}</span>
+                <span className="text-xs text-muted-foreground truncate flex-1">{a.name}</span>
+                <span className="text-primary opacity-0 group-hover:opacity-100">→</span>
+              </button>
+            ))}
+            {available.length === 0 && <div className="p-2 text-xs text-muted-foreground">{t('awards.allTracked')}</div>}
+          </div>
+        </div>
+        <div className="rounded-lg border border-primary/40 bg-primary/5 flex flex-col">
+          <div className="flex items-center justify-between px-3 py-2 border-b border-border/60">
+            <span className="text-sm font-medium">{t('awards.followed')} <span className="text-muted-foreground">({tracked.length})</span></span>
+            <button type="button" className="text-xs text-primary hover:underline disabled:opacity-40"
+              disabled={tracked.length === 0} onClick={() => persist([])}>{t('awards.clear')}</button>
+          </div>
+          <div className="max-h-[392px] overflow-y-auto p-1.5 space-y-0.5">
+            {trackedItems.map((a) => (
+              <button key={a.code} type="button" onClick={() => persist(tracked.filter((c) => c !== a.code))}
+                className="group w-full flex items-center gap-2 rounded-md px-2 py-1 text-left hover:bg-primary/10">
+                <span className="text-muted-foreground opacity-0 group-hover:opacity-100">←</span>
+                <span className="font-mono text-xs shrink-0">{a.code}</span>
+                <span className="text-xs text-muted-foreground truncate flex-1">{a.name}</span>
+              </button>
+            ))}
+            {tracked.length === 0 && <div className="p-2 text-xs text-muted-foreground">{t('awards.noneFollowed')}</div>}
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+}
+
 function ComingSoon({ id, icon: Icon }: { id: SectionId; icon?: any }) {
   const label = SECTION_LABELS[id] ?? id;
   const IconCmp = Icon ?? Construction;
@@ -1136,7 +1231,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   const [modeDraft, setModeDraft] = useState('');
   const [catCfg, setCatCfg] = useState<CATSettings>({
     enabled: false, backend: 'omnirig', omnirig_rig: 1, omnirig_vfo: '', flex_host: '', flex_port: 4992, flex_spots: false, flex_decode_spots: false, flex_decode_secs: 120,
-    yaesu_port: '', yaesu_baud: 38400, yaesu_low_lines: false, kenwood_low_lines: false, kenwood_port: '', kenwood_baud: 9600, kenwood_host: '', xiegu_port: '', xiegu_baud: 19200, xiegu_addr: 0x70, xiegu_ptt_line: '',
+    yaesu_port: '', yaesu_baud: 38400, yaesu_low_lines: false, kenwood_low_lines: false, kenwood_port: '', kenwood_baud: 9600, kenwood_host: '', kenwood_data_mode: 'usb', xiegu_port: '', xiegu_baud: 19200, xiegu_addr: 0x70, xiegu_ptt_line: '',
     icom_port: '', icom_baud: 115200, icom_addr: 0x98, icom_net_host: '', icom_net_user: '', icom_net_pass: '', icom_net_audio: false,
     tci_host: '', tci_port: 40001, tci_spots: false, poll_ms: 250, delay_ms: 0,
     digital_default: 'FT8', share_enabled: false, share_port: 4532,
@@ -1149,8 +1244,8 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   const [rotatorTest, setRotatorTest] = useState<{ ok: boolean; msg: string } | null>(null);
 
   // Motorized antenna (Ultrabeam TCP or SteppIR TCP/serial) settings.
-  const [ultrabeam, setUltrabeam] = useState<{ enabled: boolean; type: string; transport: string; host: string; port: number; com: string; baud: number; follow: boolean; step_khz: number; tx_inhibit: boolean; freq_min_mhz: number; freq_max_mhz: number }>({
-    enabled: false, type: 'ultrabeam', transport: 'tcp', host: '', port: 23, com: '', baud: 9600, follow: false, step_khz: 50, tx_inhibit: false, freq_min_mhz: 13, freq_max_mhz: 54,
+  const [ultrabeam, setUltrabeam] = useState<{ enabled: boolean; type: string; transport: string; host: string; port: number; com: string; baud: number; follow: boolean; step_khz: number; tx_inhibit: boolean; bands: string[]; freq_min_mhz: number; freq_max_mhz: number }>({
+    enabled: false, type: 'ultrabeam', transport: 'tcp', host: '', port: 23, com: '', baud: 9600, follow: false, step_khz: 50, tx_inhibit: false, bands: [], freq_min_mhz: 13, freq_max_mhz: 54,
   });
   const [ubTesting, setUbTesting] = useState(false);
   const [ubTest, setUbTest] = useState<{ ok: boolean; msg: string } | null>(null);
@@ -1246,6 +1341,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   const [startEqEnd, setStartEqEnd] = useState(() => localStorage.getItem('opslog.startEqualsEnd') === '1');
   const [lookupOnBlur, setLookupOnBlur] = useState(() => localStorage.getItem('opslog.lookupOnBlur') === '1');
   const [groupDigital, setGroupDigital] = useState(() => localStorage.getItem('opslog.groupDigitalSlots') === '1');
+  const [clusterWorkedSameSlot, setClusterWorkedSameSlot] = useState(() => localStorage.getItem('opslog.clusterWorkedSameSlot') === '1');
   const [showQsoRate, setShowQsoRate] = useState(() => localStorage.getItem('opslog.showQsoRate') === '1');
   const [catModeBeforeFreq, setCatModeBeforeFreq] = useState(() => localStorage.getItem('opslog.catModeBeforeFreq') === '1');
   // Password-encryption (secret vault) state.
@@ -1282,8 +1378,8 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   const [emailMsg, setEmailMsg] = useState('');
   const setEmailField = (patch: Partial<EmailCfg>) => setEmailCfg((s) => ({ ...s, ...patch }));
   // eQSL card e-mail (subject/body templates + auto-send on log).
-  type EQSLCfg = { subject: string; body: string; auto_send: boolean };
-  const [eqslCfg, setEqslCfg] = useState<EQSLCfg>({ subject: '', body: '', auto_send: false });
+  type EQSLCfg = { subject: string; body: string; auto_send: boolean; default_message: string };
+  const [eqslCfg, setEqslCfg] = useState<EQSLCfg>({ subject: '', body: '', auto_send: false, default_message: '' });
   const setEqslField = (patch: Partial<EQSLCfg>) => setEqslCfg((s) => ({ ...s, ...patch }));
   // ClubLog Country File (cty.xml) exception status.
   type ClubInfo = { enabled: boolean; loaded: boolean; date: string; count: number };
@@ -1433,19 +1529,30 @@ 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.
+  const SELF_SPOT_MIN_MIN = 5;
+  const [selfSpot, setSelfSpot] = useState({ enabled: false, minutes: SELF_SPOT_MIN_MIN });
+  const [selfSpotText, setSelfSpotText] = useState(String(SELF_SPOT_MIN_MIN));
   const [clusterStatuses, setClusterStatuses] = useState<ClusterServerStatus[]>([]);
   const [editingServer, setEditingServer] = useState<ClusterServer | null>(null);
 
   async function reloadClusterServers() {
     try {
-      const [list, ac, st] = await Promise.all([
+      const [list, ac, st, ss] = await Promise.all([
         ListClusterServers(),
         GetClusterAutoConnect(),
         GetClusterStatus(),
+        GetSelfSpotSettings(),
       ]);
       setClusterServers((list ?? []) as ClusterServer[]);
       setClusterAutoConnectState(ac);
       setClusterStatuses((st ?? []) as ClusterServerStatus[]);
+      setSelfSpot(ss as any);
+      setSelfSpotText(String((ss as any).minutes ?? SELF_SPOT_MIN_MIN));
     } catch (e: any) { setErr(String(e?.message ?? e)); }
   }
 
@@ -1532,6 +1639,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) {
@@ -1758,6 +1866,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
       await SaveQSLDefaults(qslDefaults as any);
       await SaveExternalServices(extSvc as any);
       await SetClusterAutoConnect(clusterAutoConnect);
+      await SaveSelfSpotSettings(selfSpot as any);
 
       setMsg('Settings saved.');
       onSaved();
@@ -2436,6 +2545,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                   <SelectItem value="flex">{t('cat.optFlex')}</SelectItem>
                   <SelectItem value="yaesu">{t('cat.optYaesu')}</SelectItem>
                   <SelectItem value="kenwood">{t('cat.optKenwood')}</SelectItem>
+                  <SelectItem value="elecraft">{t('cat.optElecraft')}</SelectItem>
                   <SelectItem value="xiegu">{t('cat.optXiegu')}</SelectItem>
                   <SelectItem value="icom">{t('cat.optIcom')}</SelectItem>
                   <SelectItem value="icom-net">{t('cat.optIcomNet')}</SelectItem>
@@ -2595,11 +2705,9 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                 <label className="flex items-center gap-2 text-sm cursor-pointer">
                   <Checkbox checked={civTrace} onCheckedChange={(c) => { setCivTrace(!!c); SetCIVTrace(!!c); }} />
                   {t('cat.civTrace')}
-                </label>
-                <p className="text-[10px] text-muted-foreground mt-1">{t('cat.civTraceHint')}</p>
-              </div>
+                </label>              </div>
             )}
-            {catCfg.backend === 'kenwood' && (
+            {(catCfg.backend === 'kenwood' || catCfg.backend === 'elecraft') && (
             <>
               <div className="space-y-1">
                 <Label>{t('cat.kenwoodPort')}</Label>
@@ -2613,9 +2721,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                   </Select>
                   <Button type="button" variant="outline" size="sm"
                     onClick={() => ListSerialPorts().then((p) => setWkPorts((p ?? []) as string[])).catch(() => {})}>↻</Button>
-                </div>
-                <span className="text-xs text-muted-foreground">{t('cat.kenwoodPortHint')}</span>
-              </div>
+                </div>              </div>
               <div className="space-y-1">
                 <Label>{t('cat.baud')}</Label>
                 <Select value={String(catCfg.kenwood_baud || 9600)} onValueChange={(v) => setCatCfg((s) => ({ ...s, kenwood_baud: parseInt(v) || 9600 }))}>
@@ -2623,18 +2729,14 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                   <SelectContent>
                     {[4800, 9600, 19200, 38400, 57600, 115200].map((r) => <SelectItem key={r} value={String(r)}>{r}</SelectItem>)}
                   </SelectContent>
-                </Select>
-                <span className="text-xs text-muted-foreground">{t('cat.kenwoodBaudHint')}</span>
-              </div>
+                </Select>              </div>
               <div className="space-y-1">
                 <Label>{t('cat.kenwoodHost')}</Label>
                 <Input
                   value={catCfg.kenwood_host || ''}
                   placeholder="192.168.1.50:4532"
                   onChange={(e) => setCatCfg((s) => ({ ...s, kenwood_host: e.target.value }))}
-                />
-                <span className="text-xs text-muted-foreground">{t('cat.kenwoodHostHint')}</span>
-              </div>
+                />              </div>
               <div className="space-y-1">
                 <label className="flex items-center gap-2 text-xs cursor-pointer">
                   <Checkbox checked={!!catCfg.kenwood_low_lines} onCheckedChange={(c) => setCatCfg((s) => ({ ...s, kenwood_low_lines: !!c }))} />
@@ -2642,6 +2744,21 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                 </label>
                 <span className="text-xs text-muted-foreground">{t('cat.lowerLinesHint')}</span>
               </div>
+              {catCfg.backend === 'kenwood' ? (
+                <div className="space-y-1">
+                  <Label>{t('cat.kwDataMode')}</Label>
+                  <Select value={(catCfg as any).kenwood_data_mode || 'usb'} onValueChange={(v) => setCatCfg((s) => ({ ...s, kenwood_data_mode: v } as any))}>
+                    <SelectTrigger className="h-8"><SelectValue /></SelectTrigger>
+                    <SelectContent>
+                      <SelectItem value="usb">{t('cat.kwDataUsb')}</SelectItem>
+                      <SelectItem value="data">{t('cat.kwDataMd6')}</SelectItem>
+                      <SelectItem value="keep">{t('cat.kwDataKeep')}</SelectItem>
+                    </SelectContent>
+                  </Select>
+                </div>
+              ) : (
+                <span className="text-xs text-muted-foreground">{t('cat.elecraftHint')}</span>
+              )}
             </>
             )}
             {catCfg.backend === 'icom' && (
@@ -2855,9 +2972,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                     onCheckedChange={(c) => setCatCfg((s) => ({ ...s, ptt_hotkey_toggle: !!c } as any))}
                   />
                   {t('cat.pttKeyToggle')}
-                </label>
-                <p className="text-[11px] text-muted-foreground">{t('cat.pttKeyHint')}</p>
-              </>
+                </label>              </>
             )}
           </div>
           {catCfg.backend === 'omnirig' && (
@@ -3011,20 +3126,28 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
               </div>
             )}
           </div>
-          {isSteppir && (
-            <div className="border-t border-border/60 pt-3 space-y-1">
-              <div className="flex items-center gap-2 flex-wrap">
-                <Label className="text-sm">{t('hw.steppirRange')}</Label>
-                <input type="number" min={1} max={60} value={ultrabeam.freq_min_mhz}
-                  onChange={(e) => setUltrabeam((s) => ({ ...s, freq_min_mhz: parseInt(e.target.value, 10) || 0 }))}
-                  className="h-8 w-16 rounded-md border border-input bg-background px-2 text-sm" />
-                <span className="text-xs text-muted-foreground">–</span>
-                <input type="number" min={1} max={60} value={ultrabeam.freq_max_mhz}
-                  onChange={(e) => setUltrabeam((s) => ({ ...s, freq_max_mhz: parseInt(e.target.value, 10) || 0 }))}
-                  className="h-8 w-16 rounded-md border border-input bg-background px-2 text-sm" />
-                <span className="text-xs text-muted-foreground">MHz</span>
+          {(isSteppir || ultrabeam.type === 'ultrabeam') && (
+            <div className="border-t border-border/60 pt-3 space-y-2">
+              <Label className="text-sm">{t('hw.motorBands')}</Label>
+              <div className="flex items-center gap-1.5 flex-wrap">
+                {MOTOR_BANDS.map((b) => {
+                  const on = ultrabeam.bands.includes(b);
+                  return (
+                    <button key={b} type="button"
+                      onClick={() => setUltrabeam((s) => ({
+                        ...s,
+                        bands: on ? s.bands.filter((x) => x !== b) : [...s.bands, b],
+                      }))}
+                      className={`h-8 min-w-[3rem] rounded-md border px-2 text-sm font-medium transition-colors ${
+                        on
+                          ? 'border-primary bg-primary/15 text-primary'
+                          : 'border-input bg-background text-muted-foreground hover:bg-muted'
+                      }`}>
+                      {b}
+                    </button>
+                  );
+                })}
               </div>
-              <p className="text-xs text-muted-foreground">{t('hw.steppirRangeHint')}</p>
             </div>
           )}
           <div className="border-t border-border/60 pt-3 space-y-1">
@@ -3387,6 +3510,8 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             const dev = d as any;
             const isRG = dev.type === 'rotgenius';
             const isARCO = dev.type === 'arco';
+            const isDCU1 = dev.type === 'dcu1';
+            const isSerialCap = isARCO || isDCU1; // COM-port or serial-over-IP controllers
             const transport = dev.transport ?? 'tcp';
             return (
               <div key={dev.id || i} className="rounded-xl border border-border bg-card/40 p-3 space-y-3">
@@ -3405,12 +3530,13 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                     {/* Each backend gets its default port: Rotator Genius 9006, ARCO 4001
                         (placeholder — must match the ARCO's LAN menu), PstRotator 12000. */}
                     <Select value={dev.type ?? 'pst'}
-                      onValueChange={(v) => patch(i, { type: v as any, port: v === 'rotgenius' ? 9006 : v === 'arco' ? 4001 : 12000 })}>
+                      onValueChange={(v) => patch(i, { type: v as any, port: v === 'rotgenius' ? 9006 : (v === 'arco' || v === 'dcu1') ? 4001 : 12000, ...(v === 'dcu1' ? { transport: 'serial' } : {}) })}>
                       <SelectTrigger className="h-9"><SelectValue /></SelectTrigger>
                       <SelectContent>
                         <SelectItem value="pst">PstRotator (UDP)</SelectItem>
                         <SelectItem value="rotgenius">Rotator Genius (4O3A, native)</SelectItem>
                         <SelectItem value="arco">GS-232A controller (microHAM ARCO, ERC…)</SelectItem>
+                        <SelectItem value="dcu1">Hy-Gain DCU-1 (RotorCard DXA, Rotor-EZ, Green Heron)</SelectItem>
                       </SelectContent>
                     </Select>
                   </div>
@@ -3427,8 +3553,8 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                       </Select>
                     </div>
                   )}
-                  {/* The ARCO is reachable over the LAN (TCP) or its USB virtual COM. */}
-                  {isARCO && (
+                  {/* ARCO and DCU-1 controllers reach over the LAN (TCP) or a serial COM. */}
+                  {isSerialCap && (
                     <div className="space-y-1">
                       <Label>Connection</Label>
                       <Select value={transport} onValueChange={(v) => patch(i, { transport: v as any })}>
@@ -3448,7 +3574,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                     {t('rot.rgDual')}
                   </label>
                 )}
-                {isARCO && transport === 'serial' ? (
+                {isSerialCap && transport === 'serial' ? (
                   <div className="space-y-1 max-w-xs">
                     <Label>COM port</Label>
                     <div className="flex items-center gap-2">
@@ -3477,16 +3603,16 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                     <div className="space-y-1 col-span-2">
                       <Label>Host / IP</Label>
                       <Input value={dev.host ?? ''} onChange={(e) => patch(i, { host: e.target.value })}
-                        placeholder={isRG || isARCO ? '192.168.1.60' : '127.0.0.1'} className="font-mono" />
+                        placeholder={isRG || isSerialCap ? '192.168.1.60' : '127.0.0.1'} className="font-mono" />
                     </div>
                     <div className="space-y-1">
-                      <Label>{isRG || isARCO ? 'TCP port' : 'UDP port'}</Label>
+                      <Label>{isRG || isSerialCap ? 'TCP port' : 'UDP port'}</Label>
                       <PortInput value={dev.port} onChange={(n) => patch(i, { port: n })}
-                        fallback={isRG ? 9006 : isARCO ? 4001 : 12000} className="font-mono" />
+                        fallback={isRG ? 9006 : isSerialCap ? 4001 : 12000} className="font-mono" />
                     </div>
                   </div>
                 )}
-                {!isRG && !isARCO && (
+                {!isRG && !isSerialCap && (
                   <label className="flex items-center gap-2 text-sm cursor-pointer">
                     <Checkbox checked={!!dev.has_elevation} onCheckedChange={(c) => patch(i, { has_elevation: !!c })} />
                     This rotator supports elevation (VHF / satellite)
@@ -3494,6 +3620,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                 )}
                 {isRG && <p className="text-xs text-muted-foreground">{t('rot.rgHint')}</p>}
                 {isARCO && <p className="text-xs text-muted-foreground">{t('rot.arcoHint')}</p>}
+                {isDCU1 && <p className="text-xs text-muted-foreground">{t('rot.dcu1Hint')}</p>}
                 {/* Which antenna this rotor carries — only relevant with >1 rotor. */}
                 {multi && (
                   <div className="space-y-1 max-w-xs">
@@ -4000,6 +4127,44 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             <span className="font-mono">dx.maritimecontestclub.net:7300</span>,{' '}
             <span className="font-mono">w8avi.net:7300</span>.
           </p>
+          <label className="flex items-start gap-2 text-sm cursor-pointer border-t border-border/60 pt-3">
+            <Checkbox checked={clusterWorkedSameSlot} className="mt-0.5"
+              onCheckedChange={(c) => { const v = !!c; setClusterWorkedSameSlot(v); writeUiPref('opslog.clusterWorkedSameSlot', v ? '1' : '0'); }} />
+            <span>{t('clu.workedSameSlot')} <span className="text-xs text-muted-foreground">{t('clu.workedSameSlotHint')}</span></span>
+          </label>
+
+          {/* Self-spot. The interval only shows once it's on — an interval for
+              something switched off is just a question the operator can't act on. */}
+          <div className="border-t border-border/60 pt-3 space-y-2">
+            <div className="flex items-center gap-3 flex-wrap">
+              <label className="flex items-center gap-2 text-sm cursor-pointer">
+                <Checkbox checked={selfSpot.enabled}
+                  onCheckedChange={(c) => setSelfSpot((s) => ({ ...s, enabled: !!c }))} />
+                {t('clu.selfSpot')}
+              </label>
+              {selfSpot.enabled && (
+                <div className="flex items-center gap-2 text-sm">
+                  <span className="text-muted-foreground">{t('clu.selfSpotEvery')}</span>
+                  <Input
+                    type="number"
+                    min={SELF_SPOT_MIN_MIN}
+                    max={240}
+                    className="w-20 h-8 font-mono text-xs"
+                    value={selfSpotText}
+                    onChange={(e) => setSelfSpotText(e.target.value)}
+                    onBlur={() => {
+                      const n = Math.floor(Number(selfSpotText));
+                      const v = Number.isFinite(n) && n > SELF_SPOT_MIN_MIN ? Math.min(n, 240) : SELF_SPOT_MIN_MIN;
+                      setSelfSpotText(String(v));
+                      setSelfSpot((s) => ({ ...s, minutes: v }));
+                    }}
+                  />
+                  <span className="text-muted-foreground">{t('clu.selfSpotMinutes')}</span>
+                </div>
+              )}
+            </div>
+            <p className="text-xs text-muted-foreground leading-relaxed">{t('clu.selfSpotHint')}</p>
+          </div>
         </div>
 
         {editingServer && (
@@ -4197,7 +4362,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
           title={t('sec.backup')}
           hint={mysqlCfg.enabled ? t('bk.hintMysql') : t('bk.hint')}
         />
-        <div className="space-y-4 max-w-xl">
+        <div className="space-y-5 max-w-2xl">
           <label className="flex items-center gap-2 text-sm cursor-pointer">
             <Checkbox
               checked={!!backupCfg.enabled}
@@ -4238,28 +4403,53 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             </div>
           </div>
 
-          <div className="flex items-end gap-3">
-            <div className="space-y-1.5">
-              <Label className="text-xs text-muted-foreground">{t('bk.rotation')}</Label>
-              <Input
-                type="number"
-                min={1}
-                max={365}
-                className="w-24 font-mono text-xs"
-                value={backupCfg.rotation || 5}
-                onChange={(e) => {
-                  const n = Number(e.target.value);
-                  if (Number.isFinite(n) && n > 0) setBackupCfg((b) => ({ ...b, rotation: Math.floor(n) }));
-                }}
-              />
-            </div>
-            <label className="flex items-center gap-2 text-sm cursor-pointer pb-2">
+          <div className="space-y-1.5">
+            <Label className="text-xs text-muted-foreground">{t('bk.rotation')}</Label>
+            <Input
+              type="number"
+              min={1}
+              max={365}
+              className="w-24 font-mono text-xs"
+              value={backupCfg.rotation || 5}
+              onChange={(e) => {
+                const n = Number(e.target.value);
+                if (Number.isFinite(n) && n > 0) setBackupCfg((b) => ({ ...b, rotation: Math.floor(n) }));
+              }}
+            />
+          </div>
+
+          {/* Stacked, not one flex row: these labels are full sentences and the
+              "keep every backup" hint is two lines — side by side they wrapped
+              into unreadable slivers. It also puts keep-all under the option it
+              depends on rather than beside it. */}
+          <div className="space-y-2.5">
+            <label className="flex items-center gap-2 text-sm cursor-pointer">
               <Checkbox
                 checked={!!backupCfg.zip}
                 onCheckedChange={(c) => setBackupCfg((b) => ({ ...b, zip: !!c }))}
               />
               <span>{t('bk.zip')}</span>
             </label>
+            <label className="flex items-center gap-2 text-sm cursor-pointer">
+              <Checkbox
+                checked={!!(backupCfg as any).every_exit}
+                onCheckedChange={(c) => setBackupCfg((b) => ({ ...b, every_exit: !!c } as any))}
+              />
+              <span>{t('bk.everyExit')}</span>
+            </label>
+            {!!(backupCfg as any).every_exit && (
+              <label className="flex items-start gap-2 text-sm cursor-pointer pl-6">
+                <Checkbox
+                  className="mt-0.5"
+                  checked={!!(backupCfg as any).keep_all}
+                  onCheckedChange={(c) => setBackupCfg((b) => ({ ...b, keep_all: !!c } as any))}
+                />
+                <span>
+                  {t('bk.keepAll')}
+                  <span className="block text-xs text-muted-foreground mt-0.5 leading-relaxed">{t('bk.keepAllHint')}</span>
+                </span>
+              </label>
+            )}
           </div>
 
           <div className="border-t border-border/60 pt-3 flex items-center gap-3">
@@ -5071,8 +5261,23 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
           </div>
           <p className="text-[11px] text-muted-foreground">{t('db.appDbHint')}</p>
           <div className="flex flex-wrap gap-2">
+            <Button variant="outline" size="sm" onClick={createNew}><Plus className="size-3.5" /> {t('db.newDb')}</Button>
+            <Button variant="outline" size="sm" onClick={openExisting}><Database className="size-3.5" /> {t('db.openExisting')}</Button>
+            <Button variant="outline" size="sm" onClick={saveCopy}><Copy className="size-3.5" /> {t('db.saveCopy')}</Button>
+            <Button variant="outline" size="sm" onClick={renameDb} title={t('db.renameTip')}><Pencil className="size-3.5" /> {t('db.rename')}</Button>
             <Button variant="outline" size="sm" onClick={revealFolder}><FolderOpen className="size-3.5" /> {t('db.openFolder')}</Button>
+            {dbSettings.is_custom && <Button variant="ghost" size="sm" onClick={resetDefault}>{t('db.resetDefault')}</Button>}
           </div>
+          {/* The DB pointer is only read at startup, so offer the restart inline. */}
+          {dbMsg && (
+            <div className="text-[11px] text-success space-y-1 pt-1">
+              <div>{t('db.savedRestart')} <span className="font-mono break-all">{dbMsg}</span></div>
+              <Button size="sm" className="h-7" onClick={() => RestartApp().catch((e: any) => setErr(String(e?.message ?? e)))}>
+                <Power className="size-3.5" /> {t('db.restartNow')}
+              </Button>
+              <span className="ml-2 text-muted-foreground">{t('db.restartHint')}</span>
+            </div>
+          )}
         </div>
 
         {/* Logbook (QSOs) — this profile: default SQLite file, a dedicated file, or MySQL. */}
@@ -5469,6 +5674,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')}
@@ -5694,6 +5906,17 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             <span className="text-[11px] text-muted-foreground">{emailMsg}</span>
           </div>
 
+          <div className="pt-2 mt-2 border-t border-border space-y-2">
+            <Label className="text-sm font-semibold">{t('em.recEmail')}</Label>
+            <div className="text-[11px] text-muted-foreground">
+              {t('em.recVarsHint')} {'{CALL}'} {'{DATE}'} {'{BAND}'} {'{MODE}'} {'{MYCALL}'}.
+            </div>
+            <Input className="h-8" placeholder={t('em.subject')} value={emailCfg.subject}
+              onChange={(e) => setEmailField({ subject: e.target.value })} />
+            <Textarea rows={3} className="text-sm" placeholder={t('em.body')} value={emailCfg.body}
+              onChange={(e) => setEmailField({ body: e.target.value })} />
+          </div>
+
           <div className="pt-2 mt-2 border-t border-border space-y-2">
             <Label className="text-sm font-semibold">{t('em.qslCardEmail')}</Label>
             <div className="text-[11px] text-muted-foreground">
@@ -5710,6 +5933,12 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             <div className="text-[11px] text-muted-foreground">
               {t('em.autoSendHint')}
             </div>
+            <div className="pt-2 space-y-1">
+              <Label className="text-sm">{t('em.qslDefaultMsg')}</Label>
+              <Input className="h-8" placeholder={t('em.qslDefaultMsgPh')} value={eqslCfg.default_message ?? ''}
+                onChange={(e) => setEqslField({ default_message: e.target.value })} />
+              <div className="text-[11px] text-muted-foreground">{t('em.qslDefaultMsgHint')}</div>
+            </div>
           </div>
         </div>
       </>
@@ -5801,7 +6030,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     database:       DatabasePanel,
     uscounties:     USCountiesPanel,
     autostart:      () => <AutostartPanelComponent />,
-    awards:         () => <ComingSoon id="awards" icon={Award} />,
+    awards:         () => <AwardsSelectionPanel profile={activeProfile ?? undefined} />,
     cat:            CATPanel,
     rotator:        RotatorPanel,
     winkeyer:       WinkeyerPanel,

frontend/src/components/StationControlPanel.tsx

@@ -672,6 +672,7 @@ function DeviceEditor({ device, onChange, onSave, onCancel, t }: {
         <div className={cn('space-y-1', (isKM || isDingtian) ? '' : 'max-w-xs')}>
           <Label>{t('station.host')}</Label>
           <Input className="font-mono" value={device.host} placeholder="192.168.1.100" onChange={(e) => onChange({ ...device, host: e.target.value })} />
+          <span className="text-[10px] text-muted-foreground">{t('station.hostHint')}</span>
         </div>
         {/* Dingtian: both are OFF on a factory board — the session ID only when
             "HTTP Session" is enabled in its web page, the password only when a

frontend/src/lib/textCase.ts

@@ -0,0 +1,28 @@
+// Capitalisation helpers for the free-text QSO fields (Name / QTH / Comment /
+// Note).
+//
+// The same station reaches the log SHOUTED by QRZ, lower-cased by a hurried
+// operator, and in whatever case the other logger stored it in an imported
+// ADIF — so one callsign ends up as "JEAN", "jean" and "Jean" across a log,
+// and sorting or reading a QTH column becomes a mess.
+//
+// Both helpers are meant to run on BLUR, never per keystroke: rewriting the
+// value while the operator is still typing a word fights them mid-word (see
+// the controlled-input note in CLAUDE.md).
+
+// titleCase upper-cases the first letter of every word and lower-cases the
+// rest. Separators are kept, so "SAINT-JULIEN" → "Saint-Julien" and
+// "o'brien" → "O'Brien".
+export function titleCase(s: string): string {
+  return s
+    .toLowerCase()
+    .replace(/(^|[\s\-'’/.])(\p{L})/gu, (_m, sep: string, ch: string) => sep + ch.toUpperCase());
+}
+
+// sentenceCase upper-cases the first letter and leaves everything after it as
+// typed. A comment routinely carries callsigns, modes and abbreviations
+// ("TNX QSO F5ABC, FT8 59") that lower-casing would quietly destroy — which is
+// why this is NOT titleCase.
+export function sentenceCase(s: string): string {
+  return s.replace(/^(\s*)(\p{L})/u, (_m, sp: string, ch: string) => sp + ch.toUpperCase());
+}

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

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

@@ -87,6 +87,8 @@ export function AwardsFolder():Promise<string>;
 
 export function BackfillUSCounties():Promise<main.BackfillUSCountiesResult>;
 
+export function BandSlotQSOs(arg1:string,arg2:number,arg3:string,arg4:string):Promise<Array<qso.QSO>>;
+
 export function BrowseExecutable():Promise<string>;
 
 export function BulkUpdateField(arg1:Array<number>,arg2:string,arg3:string):Promise<number>;
@@ -97,6 +99,8 @@ export function CIVTraceEnabled():Promise<boolean>;
 
 export function CWDecoderRunning():Promise<boolean>;
 
+export function CancelConfirmations():Promise<void>;
+
 export function ChatAvailable():Promise<boolean>;
 
 export function CheckForUpdate():Promise<main.UpdateInfo>;
@@ -477,6 +481,8 @@ export function GetScpStatus():Promise<main.ScpStatus>;
 
 export function GetSecretStatus():Promise<main.SecretStatus>;
 
+export function GetSelfSpotSettings():Promise<main.SelfSpotSettings>;
+
 export function GetSlotStats():Promise<qso.SlotStats>;
 
 export function GetSolarData():Promise<solar.Data>;
@@ -491,6 +497,8 @@ export function GetStationStatus():Promise<Array<main.StationDeviceStatus>>;
 
 export function GetTelemetryEnabled():Promise<boolean>;
 
+export function GetTrackedAwards():Promise<Array<string>>;
+
 export function GetTunerGeniusSettings():Promise<main.TunerGeniusSettings>;
 
 export function GetTunerGeniusStatus():Promise<tunergenius.Status>;
@@ -507,6 +515,8 @@ 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>;
@@ -889,10 +899,14 @@ export function SaveRelayAuto(arg1:main.RelayAutoConfig):Promise<void>;
 
 export function SaveRotators(arg1:Array<main.RotatorDevice>):Promise<void>;
 
+export function SaveSelfSpotSettings(arg1:main.SelfSpotSettings):Promise<void>;
+
 export function SaveStationDevices(arg1:Array<main.StationDevice>):Promise<void>;
 
 export function SaveStationSettings(arg1:main.StationSettings):Promise<void>;
 
+export function SaveTrackedAwards(arg1:Array<string>):Promise<void>;
+
 export function SaveTunerGeniusSettings(arg1:main.TunerGeniusSettings):Promise<void>;
 
 export function SaveUDPIntegration(arg1:udp.Config):Promise<udp.Config>;
@@ -941,6 +955,8 @@ export function SetDVKLabel(arg1:number,arg2:string):Promise<void>;
 
 export function SetKenwoodKeySpeed(arg1:number):Promise<void>;
 
+export function SetOpsLogQSLReceived(arg1:number,arg2:boolean):Promise<void>;
+
 export function SetPassphrase(arg1:string):Promise<void>;
 
 export function SetScpEnabled(arg1:boolean):Promise<void>;
@@ -953,6 +969,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>;

frontend/wailsjs/go/main/App.js

@@ -122,6 +122,10 @@ export function BackfillUSCounties() {
   return window['go']['main']['App']['BackfillUSCounties']();
 }
 
+export function BandSlotQSOs(arg1, arg2, arg3, arg4) {
+  return window['go']['main']['App']['BandSlotQSOs'](arg1, arg2, arg3, arg4);
+}
+
 export function BrowseExecutable() {
   return window['go']['main']['App']['BrowseExecutable']();
 }
@@ -142,6 +146,10 @@ export function CWDecoderRunning() {
   return window['go']['main']['App']['CWDecoderRunning']();
 }
 
+export function CancelConfirmations() {
+  return window['go']['main']['App']['CancelConfirmations']();
+}
+
 export function ChatAvailable() {
   return window['go']['main']['App']['ChatAvailable']();
 }
@@ -902,6 +910,10 @@ export function GetSecretStatus() {
   return window['go']['main']['App']['GetSecretStatus']();
 }
 
+export function GetSelfSpotSettings() {
+  return window['go']['main']['App']['GetSelfSpotSettings']();
+}
+
 export function GetSlotStats() {
   return window['go']['main']['App']['GetSlotStats']();
 }
@@ -930,6 +942,10 @@ export function GetTelemetryEnabled() {
   return window['go']['main']['App']['GetTelemetryEnabled']();
 }
 
+export function GetTrackedAwards() {
+  return window['go']['main']['App']['GetTrackedAwards']();
+}
+
 export function GetTunerGeniusSettings() {
   return window['go']['main']['App']['GetTunerGeniusSettings']();
 }
@@ -962,6 +978,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']();
 }
@@ -1726,6 +1746,10 @@ export function SaveRotators(arg1) {
   return window['go']['main']['App']['SaveRotators'](arg1);
 }
 
+export function SaveSelfSpotSettings(arg1) {
+  return window['go']['main']['App']['SaveSelfSpotSettings'](arg1);
+}
+
 export function SaveStationDevices(arg1) {
   return window['go']['main']['App']['SaveStationDevices'](arg1);
 }
@@ -1734,6 +1758,10 @@ export function SaveStationSettings(arg1) {
   return window['go']['main']['App']['SaveStationSettings'](arg1);
 }
 
+export function SaveTrackedAwards(arg1) {
+  return window['go']['main']['App']['SaveTrackedAwards'](arg1);
+}
+
 export function SaveTunerGeniusSettings(arg1) {
   return window['go']['main']['App']['SaveTunerGeniusSettings'](arg1);
 }
@@ -1830,6 +1858,10 @@ export function SetKenwoodKeySpeed(arg1) {
   return window['go']['main']['App']['SetKenwoodKeySpeed'](arg1);
 }
 
+export function SetOpsLogQSLReceived(arg1, arg2) {
+  return window['go']['main']['App']['SetOpsLogQSLReceived'](arg1, arg2);
+}
+
 export function SetPassphrase(arg1) {
   return window['go']['main']['App']['SetPassphrase'](arg1);
 }
@@ -1854,6 +1886,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);
 }

frontend/wailsjs/go/models.ts

@@ -315,6 +315,7 @@ export namespace award {
 	    pattern: string;
 	    leading_str?: string;
 	    trailing_str?: string;
+	    prefix?: string;
 	    dynamic?: boolean;
 	    one_ref_per_qso?: boolean;
 	    or_rules?: OrRule[];
@@ -324,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;
@@ -356,6 +359,7 @@ export namespace award {
 	        this.pattern = source["pattern"];
 	        this.leading_str = source["leading_str"];
 	        this.trailing_str = source["trailing_str"];
+	        this.prefix = source["prefix"];
 	        this.dynamic = source["dynamic"];
 	        this.one_ref_per_qso = source["one_ref_per_qso"];
 	        this.or_rules = this.convertValues(source["or_rules"], OrRule);
@@ -365,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"];
@@ -1894,6 +1900,8 @@ export namespace main {
 	    folder: string;
 	    rotation: number;
 	    zip: boolean;
+	    every_exit: boolean;
+	    keep_all: boolean;
 	    last_backup_at: string;
 	    default_folder: string;
 	
@@ -1907,6 +1915,8 @@ export namespace main {
 	        this.folder = source["folder"];
 	        this.rotation = source["rotation"];
 	        this.zip = source["zip"];
+	        this.every_exit = source["every_exit"];
+	        this.keep_all = source["keep_all"];
 	        this.last_backup_at = source["last_backup_at"];
 	        this.default_folder = source["default_folder"];
 	    }
@@ -1930,6 +1940,7 @@ export namespace main {
 	    kenwood_host: string;
 	    kenwood_port: string;
 	    kenwood_baud: number;
+	    kenwood_data_mode: string;
 	    yaesu_low_lines: boolean;
 	    kenwood_low_lines: boolean;
 	    icom_port: string;
@@ -1975,6 +1986,7 @@ export namespace main {
 	        this.kenwood_host = source["kenwood_host"];
 	        this.kenwood_port = source["kenwood_port"];
 	        this.kenwood_baud = source["kenwood_baud"];
+	        this.kenwood_data_mode = source["kenwood_data_mode"];
 	        this.yaesu_low_lines = source["yaesu_low_lines"];
 	        this.kenwood_low_lines = source["kenwood_low_lines"];
 	        this.icom_port = source["icom_port"];
@@ -2633,6 +2645,7 @@ export namespace main {
 	    subject: string;
 	    body: string;
 	    auto_send: boolean;
+	    default_message: string;
 	
 	    static createFrom(source: any = {}) {
 	        return new QSLEmailTemplates(source);
@@ -2643,6 +2656,7 @@ export namespace main {
 	        this.subject = source["subject"];
 	        this.body = source["body"];
 	        this.auto_send = source["auto_send"];
+	        this.default_message = source["default_message"];
 	    }
 	}
 	export class QSLFontInfo {
@@ -2904,6 +2918,20 @@ export namespace main {
 	        this.unlocked = source["unlocked"];
 	    }
 	}
+	export class SelfSpotSettings {
+	    enabled: boolean;
+	    minutes: number;
+	
+	    static createFrom(source: any = {}) {
+	        return new SelfSpotSettings(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.enabled = source["enabled"];
+	        this.minutes = source["minutes"];
+	    }
+	}
 	export class SpotQuery {
 	    call: string;
 	    band: string;
@@ -3154,6 +3182,7 @@ export namespace main {
 	    follow: boolean;
 	    step_khz: number;
 	    tx_inhibit: boolean;
+	    bands: string[];
 	    freq_min_mhz: number;
 	    freq_max_mhz: number;
 	
@@ -3173,6 +3202,7 @@ export namespace main {
 	        this.follow = source["follow"];
 	        this.step_khz = source["step_khz"];
 	        this.tx_inhibit = source["tx_inhibit"];
+	        this.bands = source["bands"];
 	        this.freq_min_mhz = source["freq_min_mhz"];
 	        this.freq_max_mhz = source["freq_max_mhz"];
 	    }

internal/award/award.go

@@ -74,6 +74,7 @@ type Def struct {
 	Pattern     string    `json:"pattern"`                // award-level Go regexp; group 1 = reference
 	LeadingStr  string    `json:"leading_str,omitempty"`  // strip this prefix before matching
 	TrailingStr string    `json:"trailing_str,omitempty"` // strip this suffix before matching
+	Prefix      string    `json:"prefix,omitempty"`       // prepended to each found reference (e.g. captured "01" + "D" → "D01"), same as OrRule.Prefix
 	Dynamic     bool      `json:"dynamic,omitempty"`      // references not predefined (any value counts)
 	// OneRefPerQSO refuses an AMBIGUOUS match rather than guessing.
 	//
@@ -110,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
@@ -522,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)
-			isVal := confirmed(q, d.Validate)
+			isConf := confirmed(q, d.Confirm, d)
+			isVal := confirmed(q, d.Validate, d)
 			for _, ref := range refs {
 				a := agg[i][ref]
 				if a == nil {
@@ -684,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.
-func Confirmed(q *qso.QSO, sources []string) bool { return confirmed(q, sources) }
+// sources (lotw|qsl|eqsl|qrzcom|custom). Exported for the statistics view.
+// 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
@@ -779,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.
@@ -787,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 {
@@ -809,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 {
@@ -825,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]
 		}
@@ -960,7 +993,7 @@ func candidatesTrace(d *Def, re *regexp.Regexp, q *qso.QSO, rl refList, hasList
 	// Testing the raw candidate would call that a hit, skip every fallback, and
 	// only then drop it as unlisted — leaving the QSO unmatched even though the
 	// next rule ("find the code inside the QTH") would have found BG.
-	found := run("primary", d.Field, d.MatchBy, d.Pattern, re, d.ExactMatch, d.LeadingStr, d.TrailingStr, "")
+	found := run("primary", d.Field, d.MatchBy, d.Pattern, re, d.ExactMatch, d.LeadingStr, d.TrailingStr, d.Prefix)
 	for i := range d.OrRules {
 		r := &d.OrRules[i]
 		label := fmt.Sprintf("OR %d", i+1)
@@ -1373,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":
@@ -1388,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/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/backup/backup.go

@@ -23,10 +23,10 @@ import (
 // every time we add a field).
 type Settings struct {
 	Enabled      bool   `json:"enabled"`
-	Folder       string `json:"folder"`        // empty → DefaultFolder
-	Rotation     int    `json:"rotation"`      // how many backups to keep; 0/neg = 5
-	Zip          bool   `json:"zip"`           // compress with deflate
-	LastBackupAt string `json:"last_backup_at"`// RFC3339; empty if never
+	Folder       string `json:"folder"`         // empty → DefaultFolder
+	Rotation     int    `json:"rotation"`       // how many backups to keep; 0/neg = 5
+	Zip          bool   `json:"zip"`            // compress with deflate
+	LastBackupAt string `json:"last_backup_at"` // RFC3339; empty if never
 }
 
 // DefaultFolder returns the folder used when Settings.Folder is empty.
@@ -44,7 +44,7 @@ func DefaultFolder(dataDir string) string {
 // statement (no torn-copy window while the app keeps writing), and compacts
 // the destination as a bonus. It replaces the old "checkpoint + raw io.Copy",
 // which could capture a half-written page during a concurrent write.
-func Run(ctx context.Context, dbConn *sql.DB, dbPath, folder string, rotation int, doZip bool) (string, error) {
+func Run(ctx context.Context, dbConn *sql.DB, dbPath, folder string, rotation int, doZip bool, prefix string, unique bool) (string, error) {
 	if dbConn == nil {
 		return "", fmt.Errorf("nil db connection")
 	}
@@ -54,12 +54,20 @@ func Run(ctx context.Context, dbConn *sql.DB, dbPath, folder string, rotation in
 	if folder == "" {
 		return "", fmt.Errorf("backup folder not set")
 	}
+	if prefix == "" {
+		prefix = "opslog"
+	}
 	if err := os.MkdirAll(folder, 0o755); err != nil {
 		return "", fmt.Errorf("create backup folder: %w", err)
 	}
 
+	// One file per DAY by default (same-day runs overwrite). With `unique`, add the
+	// time so every run is a distinct file — rotation still keeps the newest N.
 	stamp := time.Now().Format("2006-01-02")
-	base := fmt.Sprintf("opslog-%s", stamp)
+	if unique {
+		stamp = time.Now().Format("2006-01-02-150405")
+	}
+	base := fmt.Sprintf("%s-%s", prefix, stamp)
 
 	// VACUUM INTO requires a non-existent target → use a temp file, then
 	// move/zip it into place.
@@ -92,7 +100,7 @@ func Run(ctx context.Context, dbConn *sql.DB, dbPath, folder string, rotation in
 		}
 	}
 
-	if err := rotate(folder, rotation); err != nil {
+	if err := rotateMatch(folder, rotation, prefix+"-", ".db", ".db.zip"); err != nil {
 		// Rotation errors are non-fatal — the backup itself succeeded.
 		return dstPath, fmt.Errorf("rotate: %w (backup OK at %s)", err, dstPath)
 	}
@@ -103,7 +111,7 @@ func Run(ctx context.Context, dbConn *sql.DB, dbPath, folder string, rotation in
 // log lives on a shared MySQL server, where VACUUM INTO can't snapshot it — an
 // ADIF export is a portable, re-importable backup of the actual contacts.
 // writeADIF must write the full ADIF to the path it's handed.
-func RunADIF(folder string, rotation int, doZip bool, writeADIF func(path string) error) (string, error) {
+func RunADIF(folder string, rotation int, doZip bool, unique bool, writeADIF func(path string) error) (string, error) {
 	if rotation <= 0 {
 		rotation = 5
 	}
@@ -113,7 +121,11 @@ func RunADIF(folder string, rotation int, doZip bool, writeADIF func(path string
 	if err := os.MkdirAll(folder, 0o755); err != nil {
 		return "", fmt.Errorf("create backup folder: %w", err)
 	}
-	base := "opslog-log-" + time.Now().Format("2006-01-02")
+	stamp := time.Now().Format("2006-01-02")
+	if unique {
+		stamp = time.Now().Format("2006-01-02-150405")
+	}
+	base := "opslog-log-" + stamp
 	tmp := filepath.Join(folder, base+".adi.tmp")
 	_ = os.Remove(tmp)
 	if err := writeADIF(tmp); err != nil {
@@ -203,12 +215,6 @@ func copyZipped(src, dst, innerName string) error {
 	return out.Close()
 }
 
-// rotate keeps the most recent `keep` SQLite backups (opslog-*.db /
-// opslog-*.db.zip) and deletes the rest.
-func rotate(folder string, keep int) error {
-	return rotateMatch(folder, keep, "opslog-", ".db", ".db.zip")
-}
-
 // rotateMatch keeps the most recent `keep` files in folder whose name has the
 // given prefix and one of the given suffixes, deleting older ones. Only matching
 // files are touched — never unrelated user files in the same folder. The suffix

internal/cat/kenwood.go

@@ -56,6 +56,16 @@ type Kenwood struct {
 	// a wire, which is how most operators actually put a rig on the network.
 	host    string
 	digital string // mode name logged for data (FT8 by default)
+	// dataMode chooses what CAT mode a DATA/digital mode (FT8, PSK…) sets, because
+	// no single Kenwood mode digit is right for every rig: "usb" → USB (the SSB-data
+	// base, default), "data" → the DATA mode digit MD6 (Elecraft K3/K4), "keep" →
+	// leave the rig's current mode untouched (safest for a TS-590SG/TS-990S whose
+	// data mode is a USB modifier the operator sets on the rig). See SetMode.
+	dataMode string
+	// elecraft marks a K3/K4 (the "Elecraft" backend). It reuses this Kenwood-dialect
+	// client but, being an Elecraft, always drives digital modes to DATA A (MD6+DT0)
+	// — the sub-mode FT8 audio needs — instead of going through the dataMode option.
+	elecraft bool
 
 	mu   sync.Mutex
 	port serial.Port
@@ -109,6 +119,17 @@ type Kenwood struct {
 	// nothing. Off by default: that is how this backend behaved for its whole
 	// life before the question came up.
 	lowerLines bool
+
+	// tx tracks whether we currently hold PTT (SetPTT true). A Kenwood/Elecraft rig
+	// answers "?;" to a status poll (IF;) WHILE TRANSMITTING; OpsLog used to read
+	// that as "the rig doesn't support IF;", latch it off and drop the whole CAT
+	// link — which tore down the shared-CAT PTT that WSJT-X / JTDX key through, so a
+	// K3 keyed but the logger's transmission fell apart. While PTT is held we skip
+	// the wire poll and hand back the last good state (lastState) instead. txAt caps
+	// the skip so a missed SetPTT(false) can't freeze the state for ever.
+	tx        bool
+	txAt      time.Time
+	lastState RigState
 }
 
 // SetLowerLines chooses whether DTR and RTS are deasserted on connect. Set
@@ -249,6 +270,15 @@ func (k *Kenwood) ReadState() (RigState, error) {
 	if k.port == nil {
 		return RigState{}, fmt.Errorf("kenwood: not connected")
 	}
+	// While transmitting, don't poll: the rig returns "?;" to IF; during TX, and
+	// treating that as a fault dropped the shared CAT link the digital-mode
+	// software keys through. Hand back the last known state. The 30 s cap resyncs
+	// if a SetPTT(false) was somehow missed, so a stuck TX can't freeze state.
+	if k.tx && !k.txAt.IsZero() && time.Since(k.txAt) < 30*time.Second {
+		s := k.lastState
+		s.Connected = true
+		return s, nil
+	}
 	raw, err := k.ask("IF;")
 	if err != nil {
 		return RigState{}, err
@@ -261,7 +291,10 @@ func (k *Kenwood) ReadState() (RigState, error) {
 	s := RigState{Connected: true, Backend: "kenwood"}
 	k.curVFO = f.VFO
 	s.Vfo = f.VFO
-	s.Mode = kenwoodModeToADIF(f.Mode, k.digital)
+	// Both branches of SetMode that emit MD6 identify a K3/K4: the Elecraft
+	// backend, and the "MD6" data-mode option that exists for it. Decode the
+	// read-back the same way, or OpsLog contradicts the mode it just set.
+	s.Mode = kenwoodModeToADIF(f.Mode, k.digital, k.elecraft || k.dataMode == "data")
 	s.Rig = k.model
 
 	// IF reports the frequency of the VFO in USE (what the operator hears).
@@ -333,6 +366,7 @@ func (k *Kenwood) ReadState() (RigState, error) {
 	if s.Split {
 		k.curRXFreq = s.RxFreqHz
 	}
+	k.lastState = s // cache for the transmit window, where we can't poll
 	return s, nil
 }
 
@@ -360,6 +394,36 @@ func (k *Kenwood) SetMode(mode string) error {
 	if k.port == nil {
 		return fmt.Errorf("kenwood: not connected")
 	}
+	// Honour the operator's DATA-mode preference for a digital mode. No single
+	// mode digit fits every rig, so the operator picks: keep the rig's mode, use
+	// MD6 (K3/K4 DATA), or fall through to the default USB from kenwoodModeDigit.
+	if isKenwoodDataMode(mode) {
+		// An Elecraft always uses DATA A for a soundcard digital mode — that's what
+		// the "Elecraft" backend means, so the dataMode option doesn't apply.
+		if k.elecraft {
+			if err := k.write("MD6;"); err != nil {
+				return err
+			}
+			return k.write("DT0;")
+		}
+		switch k.dataMode {
+		case "keep":
+			return nil // leave whatever data mode the operator set on the rig
+		case "data":
+			// Elecraft K3/K4 DATA mode (MD6) PLUS the DATA-A submode (DT0). MD6 alone
+			// can leave the rig in an FSK/PSK data submode (from a prior RTTY/PSK
+			// session), where FT8 keys the transmitter but the rear sound-card audio
+			// never modulates — "transmits but nothing comes out". DT0 forces DATA A,
+			// the audio submode FT8 needs. This is the Elecraft path (the option is
+			// labelled K3/K4); a real K3/K4 answers DT with nothing. A plain Kenwood
+			// has no DT command and would "?;" it — but that's a misconfiguration
+			// (pick USB there), and IF is never latched so the link self-recovers.
+			if err := k.write("MD6;"); err != nil {
+				return err
+			}
+			return k.write("DT0;")
+		}
+	}
 	d := kenwoodModeDigit(mode, k.curFreq)
 	if d == 0 {
 		return fmt.Errorf("kenwood: no CAT mode for %q", mode)
@@ -367,13 +431,42 @@ func (k *Kenwood) SetMode(mode string) error {
 	return k.write(fmt.Sprintf("MD%c;", d))
 }
 
+// SetDataMode configures how a DATA/digital mode is set: "usb" (default), "data"
+// (MD6, Elecraft K3/K4) or "keep" (don't change the rig's mode).
+func (k *Kenwood) SetDataMode(m string) {
+	k.mu.Lock()
+	k.dataMode = strings.ToLower(strings.TrimSpace(m))
+	k.mu.Unlock()
+}
+
+// SetElecraft marks this client as driving a K3/K4 (the "Elecraft" backend), so
+// digital modes always land in DATA A (MD6+DT0). Set before Start.
+func (k *Kenwood) SetElecraft(v bool) {
+	k.mu.Lock()
+	k.elecraft = v
+	k.mu.Unlock()
+}
+
+// isKenwoodDataMode reports whether a mode name is a soundcard/data mode (FT8,
+// PSK, JT…) rather than a voice/CW/RTTY mode the rig sets natively.
+func isKenwoodDataMode(mode string) bool {
+	switch strings.ToUpper(strings.TrimSpace(mode)) {
+	case "", "LSB", "USB", "SSB", "CW", "CW-R", "CWR", "FM", "NFM", "AM",
+		"RTTY", "FSK", "RTTY-R", "FSK-R":
+		return false
+	}
+	return true
+}
+
 func (k *Kenwood) SetPTT(on bool) error {
 	k.mu.Lock()
 	defer k.mu.Unlock()
 	if k.port == nil {
 		return fmt.Errorf("kenwood: not connected")
 	}
+	k.tx = on
 	if on {
+		k.txAt = time.Now()
 		return k.write("TX;")
 	}
 	return k.write("RX;")
@@ -431,10 +524,15 @@ func (k *Kenwood) ask(cmd string) (string, error) {
 			k.rx = k.rx[i+1:]
 			traceText("kenwood", "RX", frame)
 			if frame == "?;" {
-				// The rig rejected the command. Remember it so the poll loop stops
-				// paying a 600 ms timeout for it on every cycle.
-				k.unsupported[want] = true
-				debugLog.Printf("kenwood: this rig does not support %q — not asking again", cmd)
+				// IF; and ID; are universal on Kenwood/Elecraft — a "?;" to them is a
+				// transient "busy" (typically mid-transmit, or a menu open on the rig),
+				// NOT "unsupported". Latching them off would blind the poll loop for
+				// good and read as "lost the rig". Only remember the OPTIONAL commands
+				// (FR/FT/…) so the poll loop stops paying a 600 ms timeout for those.
+				if want != "IF" && want != "ID" {
+					k.unsupported[want] = true
+					debugLog.Printf("kenwood: this rig does not support %q — not asking again", cmd)
+				}
 				return "", fmt.Errorf("kenwood: %s rejected", want)
 			}
 			if strings.HasPrefix(frame, want) {
@@ -551,11 +649,12 @@ func kenwoodModeDigit(mode string, hz int64) byte {
 		}
 		return '2'
 	}
-	// Any other digital mode (FT8, PSK, JT…) rides the DATA input, and by universal
-	// convention that is ALWAYS the UPPER sideband, on every band. The SSB rule
-	// (LSB below 10 MHz) must NOT be applied here: doing so put a 40/80 m data spot
-	// on LSB, which an Elecraft K3 shows as "DATA REV" — the reversed sideband.
-	// (RTTY/FSK is handled above as its own FSK mode, so it isn't affected.)
+	// Any other digital mode (FT8, PSK, JT…) → USB on every band. There is NO single
+	// mode digit that is right for both families: a K3 wants DATA (MD6), a TS-590SG
+	// wants USB-DATA (MD2 + its DATA modifier), and MD6 on the TS-590SG is FSK/RTTY
+	// — wrong for FT8. USB is the safe common base (the reversed-sideband "DATA REV"
+	// only came from the old LSB-below-10-MHz rule). A rig-specific DATA mode is a
+	// follow-up that needs the model, not a blind default.
 	return '2'
 }
 
@@ -563,7 +662,11 @@ func kenwoodModeDigit(mode string, hz int64) byte {
 // Digital modes are indistinguishable from SSB over CAT — the rig only knows
 // it is on USB — so the operator's configured digital mode is used, exactly as
 // the other backends do.
-func kenwoodModeToADIF(d byte, digital string) string {
+//
+// md6IsData says whether MD6 means DATA on THIS rig — true for an Elecraft
+// (the K3/K4 backend, and the "MD6" data-mode option that targets it), false
+// for a plain Kenwood. See below.
+func kenwoodModeToADIF(d byte, digital string, md6IsData bool) string {
 	switch d {
 	case '1':
 		return "LSB"
@@ -576,6 +679,15 @@ func kenwoodModeToADIF(d byte, digital string) string {
 	case '5':
 		return "AM"
 	case '6', '9':
+		// One digit, two meanings. On a Kenwood MD6/MD9 is FSK/FSK-R; on an
+		// Elecraft it is DATA / DATA-REV — and DATA is precisely what SetMode
+		// puts a K3/K4 into for FT8. Reading it straight back as RTTY meant a K3
+		// running FT8 reported RTTY: the QSO was logged on the wrong mode, and
+		// the shared CAT link told WSJT-X/JTDX the rig sat in RTTY while they had
+		// asked for a data mode.
+		if md6IsData {
+			return digital
+		}
 		return "RTTY"
 	}
 	return ""

internal/cat/kenwood_test.go

@@ -111,6 +111,23 @@ func TestKenwoodModeDigit(t *testing.T) {
 	}
 }
 
+// The DATA-mode preference only applies to soundcard/data modes, never to voice,
+// CW or native RTTY — getting this wrong would hijack an SSB or CW mode change.
+func TestIsKenwoodDataMode(t *testing.T) {
+	data := []string{"FT8", "FT4", "PSK31", "JT65", "DATA", "DIGITAL", "OLIVIA"}
+	notData := []string{"", "LSB", "USB", "SSB", "CW", "CW-R", "FM", "AM", "RTTY", "FSK", "RTTY-R"}
+	for _, m := range data {
+		if !isKenwoodDataMode(m) {
+			t.Errorf("isKenwoodDataMode(%q) = false, want true", m)
+		}
+	}
+	for _, m := range notData {
+		if isKenwoodDataMode(m) {
+			t.Errorf("isKenwoodDataMode(%q) = true, want false", m)
+		}
+	}
+}
+
 // What the log records for each mode digit the rig reports.
 func TestKenwoodModeToADIF(t *testing.T) {
 	cases := []struct {
@@ -124,8 +141,23 @@ func TestKenwoodModeToADIF(t *testing.T) {
 		{'0', ""}, // unknown → say nothing rather than guess
 	}
 	for _, c := range cases {
-		if got := kenwoodModeToADIF(c.d, "FT8"); got != c.want {
+		if got := kenwoodModeToADIF(c.d, "FT8", false); got != c.want {
 			t.Errorf("kenwoodModeToADIF(%q) = %q, want %q", c.d, got, c.want)
 		}
 	}
 }
+
+// On a K3/K4 the same digits mean DATA / DATA-REV, not FSK — and DATA is what
+// OpsLog itself sets for FT8. Decoding them as RTTY logged a K3 running FT8 on
+// the wrong mode and told the shared-CAT clients the rig was in RTTY.
+func TestKenwoodModeToADIFElecraftData(t *testing.T) {
+	for _, d := range []byte{'6', '9'} {
+		if got := kenwoodModeToADIF(d, "FT8", true); got != "FT8" {
+			t.Errorf("kenwoodModeToADIF(%q, elecraft) = %q, want %q", d, got, "FT8")
+		}
+	}
+	// Everything else is unaffected by the Elecraft dialect.
+	if got := kenwoodModeToADIF('2', "FT8", true); got != "USB" {
+		t.Errorf("kenwoodModeToADIF('2', elecraft) = %q, want USB", got)
+	}
+}

internal/dxcc/manager.go

@@ -173,6 +173,39 @@ func (m *Manager) EntityNames() []string {
 	return out
 }
 
+// PrefixByDXCC maps ADIF DXCC entity number → canonical primary prefix (F, DL,
+// XE…) from the loaded cty.dat. cty.dat is keyed by entity NAME, so the join
+// goes through EntityDXCC; entries whose name doesn't resolve are skipped
+// rather than guessed. Empty until cty.dat has loaded.
+func (m *Manager) PrefixByDXCC() map[int]string {
+	m.mu.RLock()
+	db := m.db
+	m.mu.RUnlock()
+	if db == nil {
+		return nil
+	}
+	out := make(map[int]string, 400)
+	for _, e := range db.Entities() {
+		p := strings.TrimSpace(e.Primary)
+		if p == "" {
+			continue
+		}
+		// cty.dat marks non-DXCC sub-entities with a leading '*' — they report
+		// under a parent entity and must not overwrite the parent's prefix.
+		if strings.HasPrefix(p, "*") {
+			continue
+		}
+		if n := EntityDXCC(e.Name); n > 0 {
+			if _, dup := out[n]; !dup {
+				// DXCC prefixes are conventionally upper-case; cty.dat spells some
+				// sub-entity suffixes in lower case (3D2/c → 3D2/C).
+				out[n] = strings.ToUpper(p)
+			}
+		}
+	}
+	return out
+}
+
 // Info returns metadata about the currently-loaded cty.dat (or zero value
 // if nothing loaded).
 func (m *Manager) Info() ctySource {

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/powergenius/powergenius.go

@@ -125,14 +125,19 @@ func (c *Client) SetFanMode(mode string) error {
 	default:
 		return fmt.Errorf("powergenius: invalid fan mode %q", mode)
 	}
-	// Set with the bare "key=value" verb the amp uses for its own status fields
-	// (same convention as "operate=1"). The earlier "setup fanmode=…" carried a
-	// bogus prefix the amp silently ignored, so the fan never changed and the next
-	// status kept reporting the old mode — the revert-to-Contest the operator saw.
-	reply, err := c.command("fanmode=" + m)
+	// The verb the amp wants is "setup fanmode=VALUE" — confirmed LIVE: with the
+	// "setup " prefix the amp replies code 0 (accepted), while the bare
+	// "fanmode=VALUE" we switched to earlier is rejected (reply code 0x50000015).
+	// That regression is what stopped the fan from changing; restoring "setup "
+	// fixes it.
+	reply, err := c.command("setup fanmode=" + m)
 	if err != nil {
 		return err
 	}
+	if code := replyCode(reply); code != "" && code != "0" {
+		applog.Printf("pgxl: set fanmode=%s REJECTED, reply=%q", m, reply)
+		return fmt.Errorf("powergenius: amp rejected fanmode=%s (code %s)", m, code)
+	}
 	applog.Printf("pgxl: set fanmode=%s reply=%q", m, reply)
 	c.statusMu.Lock()
 	c.status.FanMode = m // optimistic
@@ -141,6 +146,19 @@ func (c *Client) SetFanMode(mode string) error {
 	return nil
 }
 
+// replyCode returns the result code from an "R<id>|<code>|…" reply — "0" means
+// the amp accepted the command. Returns "" when the line isn't an R reply.
+func replyCode(reply string) string {
+	if !strings.HasPrefix(reply, "R") {
+		return ""
+	}
+	p := strings.SplitN(reply, "|", 3)
+	if len(p) < 2 {
+		return ""
+	}
+	return strings.TrimSpace(p[1])
+}
+
 // SetOperate puts the amp in OPERATE (1) or STANDBY (0).
 func (c *Client) SetOperate(on bool) error {
 	v := "0"

internal/qslcard/placement.go

@@ -734,7 +734,10 @@ func placeQSOBox(profile ProfileInfo, zone pxRect, occupied []pxRect) QSOBox {
 		BG: "#ffffff", BGOpacity: 0.88, Radius: 12,
 		Title:  "Confirming QSO with {qso.callsign}",
 		Fields: []string{"qso_date", "time_on", "band", "mode", "rst_sent"},
-		Footer: "{qso.qsl_msg}",
+		// PSE/TNX stamp (auto: TNX if a QSL was received, else PSE QSL) leads the
+		// message. {qso.pse_tnx} is a normal token — it can be moved to its own
+		// element anywhere on the card in the designer.
+		Footer: "{qso.pse_tnx}   {qso.qsl_msg}",
 	}
 	box.Y = cardH - box.H - 110
 	if zone.y+zone.h/2 > cardH/2 {

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

@@ -1461,6 +1461,51 @@ func (r *Repo) IterateByIDs(ctx context.Context, ids []int64, fn func(QSO) error
 	return rows.Err()
 }
 
+// BandSlotQSOs returns every contact on one band that belongs to a slot of the
+// entry matrix: the exact callsign, or any callsign in the same DXCC entity.
+// Mode is NOT filtered here — the class (phone / CW / digital) is a derived
+// notion the caller owns, so it filters the (small) band-scoped result itself.
+//
+// The DXCC arm matches the stored dxcc column only. A QSO logged before the
+// entity was resolved has a NULL there and is genuinely unattributed; guessing
+// it back from the callsign here would disagree with the matrix above, which is
+// built from the same column.
+func (r *Repo) BandSlotQSOs(ctx context.Context, callsign string, dxccNum int, band string) ([]QSO, error) {
+	call := upperTrim(callsign)
+	b := strings.TrimSpace(band)
+	if b == "" || (call == "" && dxccNum <= 0) {
+		return []QSO{}, nil
+	}
+	where := "band = ?"
+	args := []any{b}
+	switch {
+	case call != "" && dxccNum > 0:
+		where += " AND (callsign = ? OR dxcc = ?)"
+		args = append(args, call, dxccNum)
+	case call != "":
+		where += " AND callsign = ?"
+		args = append(args, call)
+	default:
+		where += " AND dxcc = ?"
+		args = append(args, dxccNum)
+	}
+	rows, err := r.db.QueryContext(ctx,
+		`SELECT `+selectCols+` FROM qso WHERE `+where+` ORDER BY qso_date DESC, id DESC LIMIT 500`, args...)
+	if err != nil {
+		return nil, fmt.Errorf("query band slot: %w", err)
+	}
+	defer rows.Close()
+	out := []QSO{}
+	for rows.Next() {
+		q, err := scanQSO(rows)
+		if err != nil {
+			return nil, err
+		}
+		out = append(out, q)
+	}
+	return out, rows.Err()
+}
+
 // WorkedBefore summarises prior contacts at two granularities:
 //   - by exact callsign  → shown as "this call worked N×"
 //   - by DXCC entity     → drives NEW ONE / NEW BAND / NEW MODE / NEW SLOT
@@ -1540,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{},
@@ -1560,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)
 		}
@@ -1603,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)
 			}
@@ -1628,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
-            ORDER BY qso_date DESC LIMIT 1`, wb.Callsign).Scan(&d)
+            WHERE `+pred+` AND dxcc IS NOT NULL
+            ORDER BY qso_date DESC LIMIT 1`, predArgs...).Scan(&d)
 		if d.Valid {
 			dxcc = int(d.Int64)
 		}
@@ -2118,6 +2188,36 @@ func (r *Repo) WorkedCallBandModeKeys(ctx context.Context) (map[string]struct{},
 	return out, rows.Err()
 }
 
+// WorkedCallSlotKeys backs the cluster "already worked only on the same slot"
+// option. It returns each worked slot keyed BOTH as "CALL|band" (mode-agnostic,
+// for a spot whose mode couldn't be inferred) and "CALL|band|MODE" with the mode
+// run through normMode — so when digital grouping is on, FT8/FT4/RTTY fold into
+// one "DIG" and a call worked on 20m FT8 also matches a 20m FT4 spot. Call is
+// upper-cased and band lower-cased to match the spot keys ClusterSpotStatuses
+// builds. normMode may be nil (no grouping).
+func (r *Repo) WorkedCallSlotKeys(ctx context.Context, normMode func(string) string) (map[string]struct{}, error) {
+	rows, err := r.db.QueryContext(ctx,
+		`SELECT upper(callsign), lower(band), upper(mode) FROM qso
+		 WHERE callsign != '' AND band IS NOT NULL AND band != '' AND mode IS NOT NULL AND mode != ''`)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	out := make(map[string]struct{}, 4096)
+	for rows.Next() {
+		var c, b, m string
+		if err := rows.Scan(&c, &b, &m); err != nil {
+			return nil, err
+		}
+		if normMode != nil {
+			m = normMode(m)
+		}
+		out[c+"|"+b] = struct{}{}
+		out[c+"|"+b+"|"+m] = struct{}{}
+	}
+	return out, rows.Err()
+}
+
 // WorkedPOTARefs returns the set of POTA park references already worked
 // (upper-cased). A QSO's pota_ref may hold several comma-separated parks
 // (an n-fer); each is added separately.

internal/relaydev/relaydev.go

@@ -61,6 +61,22 @@ func get(ctx context.Context, url, user, pass string) ([]byte, error) {
 	return body, nil
 }
 
+// relayBase turns a configured host into the base URL of a network relay board.
+// A bare host or host:port keeps the default http:// (the boards serve plain
+// HTTP on their LAN). A host that already carries a scheme is used verbatim, so
+// a board can be reached through an HTTPS reverse proxy — e.g. a Nginx Proxy
+// Manager entry "https://relay.example.com" fronting the LAN board's port 80,
+// which is how an operator reaches shack relays from outside when 80/443 are
+// already taken by the proxy. A trailing slash is trimmed so path parts append
+// cleanly; an optional sub-path in the host is preserved (a sub-path proxy).
+func relayBase(host string) string {
+	h := strings.TrimSpace(host)
+	if strings.HasPrefix(h, "http://") || strings.HasPrefix(h, "https://") {
+		return strings.TrimRight(h, "/")
+	}
+	return "http://" + h
+}
+
 // ── WebSwitch 1216H ────────────────────────────────────────────────────
 
 type webswitch struct {
@@ -82,7 +98,7 @@ func (w *webswitch) Set(ctx context.Context, relay int, on bool) error {
 	if on {
 		action = "on"
 	}
-	_, err := get(ctx, fmt.Sprintf("http://%s/relaycontrol/%s/%d", w.host, action, relay), "", "")
+	_, err := get(ctx, fmt.Sprintf("%s/relaycontrol/%s/%d", relayBase(w.host), action, relay), "", "")
 	return err
 }
 
@@ -93,7 +109,7 @@ func (w *webswitch) Status(ctx context.Context) ([]bool, error) {
 		sel.WriteString(strconv.Itoa(i))
 		sel.WriteByte('$')
 	}
-	body, err := get(ctx, fmt.Sprintf("http://%s/relaystate/get2/%s", w.host, sel.String()), "", "")
+	body, err := get(ctx, fmt.Sprintf("%s/relaystate/get2/%s", relayBase(w.host), sel.String()), "", "")
 	if err != nil {
 		return nil, err
 	}
@@ -140,7 +156,7 @@ func (k *kmtronic) Set(ctx context.Context, relay int, on bool) error {
 		state = "01"
 	}
 	// FF<rr><ss>: e.g. FF0101 = relay 1 on, FF0800 = relay 8 off.
-	_, err := get(ctx, fmt.Sprintf("http://%s/FF%02d%s", k.host, relay, state), k.user, k.pass)
+	_, err := get(ctx, fmt.Sprintf("%s/FF%02d%s", relayBase(k.host), relay, state), k.user, k.pass)
 	return err
 }
 
@@ -154,7 +170,7 @@ type kmStatus struct {
 }
 
 func (k *kmtronic) Status(ctx context.Context) ([]bool, error) {
-	body, err := get(ctx, fmt.Sprintf("http://%s/status.xml", k.host), k.user, k.pass)
+	body, err := get(ctx, fmt.Sprintf("%s/status.xml", relayBase(k.host)), k.user, k.pass)
 	if err != nil {
 		return nil, err
 	}
@@ -259,8 +275,8 @@ func (d *dingtian) Set(ctx context.Context, relay int, on bool) error {
 	}
 	// type=0 is plain ON/OFF (1 = jogging, 2 = delay, 3 = flash, 4 = toggle),
 	// and time is then unused.
-	body, err := d.getCGI(ctx, fmt.Sprintf("http://%s/relay_cgi.cgi?type=0&relay=%d&on=%d&time=0&pwd=%s&",
-		d.host, relay-1, state, d.pwd))
+	body, err := d.getCGI(ctx, fmt.Sprintf("%s/relay_cgi.cgi?type=0&relay=%d&on=%d&time=0&pwd=%s&",
+		relayBase(d.host), relay-1, state, d.pwd))
 	if err != nil {
 		return err
 	}
@@ -274,7 +290,7 @@ func (d *dingtian) Set(ctx context.Context, relay int, on bool) error {
 }
 
 func (d *dingtian) Status(ctx context.Context) ([]bool, error) {
-	body, err := d.getCGI(ctx, fmt.Sprintf("http://%s/relay_cgi_load.cgi", d.host))
+	body, err := d.getCGI(ctx, fmt.Sprintf("%s/relay_cgi_load.cgi", relayBase(d.host)))
 	if err != nil {
 		return nil, err
 	}

internal/relaydev/relaydev_test.go

@@ -172,3 +172,19 @@ func TestDingtianSetRefusalIsAnError(t *testing.T) {
 		t.Fatal("a refused command answered HTTP 200 and was reported as success")
 	}
 }
+
+func TestRelayBase(t *testing.T) {
+	cases := map[string]string{
+		"192.168.1.5":                  "http://192.168.1.5",
+		"192.168.1.5:8080":             "http://192.168.1.5:8080",
+		"https://relay.example.com":    "https://relay.example.com",
+		"https://relay.example.com/":   "https://relay.example.com",
+		"http://relay.example.com/sw/": "http://relay.example.com/sw",
+		"  relay.local  ":              "http://relay.local",
+	}
+	for in, want := range cases {
+		if got := relayBase(in); got != want {
+			t.Errorf("relayBase(%q) = %q, want %q", in, got, want)
+		}
+	}
+}

internal/rigctld/rigctld.go

@@ -36,6 +36,7 @@ import (
 	"strconv"
 	"strings"
 	"sync"
+	"sync/atomic"
 	"time"
 )
 
@@ -59,6 +60,13 @@ type Server struct {
 	ln     net.Listener
 	conns  map[net.Conn]struct{}
 	closed bool
+
+	// ptt mirrors the last PTT state a client commanded via set_ptt. WSJT-X/JTDX
+	// poll get_ptt DURING transmit to confirm the rig is keyed; if get_ptt reads
+	// RX they conclude PTT failed and abort the over after a second or two. We
+	// don't read PTT back from every backend, so echo what the client last set —
+	// always consistent with its own command, and enough to satisfy the check.
+	ptt atomic.Bool
 }
 
 func New(port int, rig Rig, logf func(string, ...any)) *Server {
@@ -110,7 +118,32 @@ func (s *Server) Start() error {
 	return nil
 }
 
+// releasePTT drops the transmitter when whoever was holding it goes away.
+//
+// Nothing else will. The Kenwood/Elecraft backend deliberately suspends its
+// wire poll while PTT is held (a K3 answers "?;" to IF; during transmit), so a
+// client that crashes, is killed, or simply has its socket closed under it
+// leaves the rig keyed with nobody watching — and closing the socket is exactly
+// what Stop() does on every settings save. Seen in the field: a K3 sat in
+// transmit for 29 s, until the CAT link happened to be rebuilt.
+//
+// Swap makes this once-only, so the Stop() path and the per-connection defer it
+// triggers can both call it without double-unkeying.
+func (s *Server) releasePTT(why string) {
+	if !s.ptt.Swap(false) {
+		return
+	}
+	s.log("rigctld: %s while the rig was keyed — dropping PTT", why)
+	if err := s.rig.SetPTT(false); err != nil {
+		s.log("rigctld: emergency unkey failed: %v", err)
+	}
+}
+
 func (s *Server) Stop() {
+	// Before anything is torn down: reloadCAT calls us BEFORE it restarts the CAT
+	// backend, so the rig is still reachable here and an unkey still lands.
+	s.releasePTT("CAT sharing stopped")
+
 	s.mu.Lock()
 	s.closed = true
 	ln := s.ln
@@ -138,6 +171,8 @@ func (s *Server) serve(c net.Conn) {
 		delete(s.conns, c)
 		s.mu.Unlock()
 		_ = c.Close()
+		// A client that walks away mid-over must not leave the rig transmitting.
+		s.releasePTT(fmt.Sprintf("client %s left", c.RemoteAddr()))
 	}()
 	s.log("rigctld: client connected from %s", c.RemoteAddr())
 	r := bufio.NewReader(c)
@@ -228,10 +263,12 @@ func (s *Server) handle(line string) (resp string, quit bool) {
 		return rprt(0), false
 
 	case "t", "\\get_ptt":
-		// We do not read PTT back from every backend, and answering "transmitting"
-		// wrongly would make a client hold off for ever. Reporting RX is the safe
-		// direction: the worst case is a client that transmits when we said it
-		// could, which is what it was going to do anyway.
+		// Echo the last commanded PTT state. WSJT-X/JTDX poll this WHILE
+		// transmitting to confirm the rig is keyed; answering a blanket "0" (RX)
+		// made them decide PTT had failed and abort the over after ~1-2 s.
+		if s.ptt.Load() {
+			return "1\n", false
+		}
 		return "0\n", false
 	case "T", "\\set_ptt":
 		if len(args) < 1 {
@@ -242,6 +279,7 @@ func (s *Server) handle(line string) (resp string, quit bool) {
 			s.log("rigctld: set_ptt %v failed: %v", on, err)
 			return rprt(-9), false
 		}
+		s.ptt.Store(on)
 		return rprt(0), false
 
 	case "v", "\\get_vfo":

internal/rigctld/rigctld_test.go

@@ -7,6 +7,7 @@ import (
 	"strings"
 	"sync"
 	"testing"
+	"time"
 )
 
 // fakeRig stands in for the CAT manager.
@@ -138,6 +139,28 @@ func TestHandleReportsBackendFailure(t *testing.T) {
 	}
 }
 
+// get_ptt must echo the last commanded PTT state. WSJT-X/JTDX poll get_ptt while
+// transmitting to confirm the rig is keyed; a blanket "0" made them decide PTT
+// had failed and abort the over after a second or two.
+func TestGetPTTEchoesSetPTT(t *testing.T) {
+	s := New(0, &fakeRig{}, nil)
+	if got, _ := s.handle("t"); got != "0\n" {
+		t.Fatalf("initial get_ptt = %q, want 0", got)
+	}
+	if got, _ := s.handle("T 1"); got != "RPRT 0\n" {
+		t.Fatalf("set_ptt 1 = %q, want RPRT 0", got)
+	}
+	if got, _ := s.handle("t"); got != "1\n" {
+		t.Fatalf("get_ptt after T 1 = %q, want 1 — client would abort TX", got)
+	}
+	if got, _ := s.handle("T 0"); got != "RPRT 0\n" {
+		t.Fatalf("set_ptt 0 = %q, want RPRT 0", got)
+	}
+	if got, _ := s.handle("t"); got != "0\n" {
+		t.Fatalf("get_ptt after T 0 = %q, want 0", got)
+	}
+}
+
 // dump_state is parsed POSITIONALLY by Hamlib clients: WSJT-X reads the first
 // line as the protocol version and refuses to continue if the block is short or
 // misshapen. Pinning its shape is what stops a well-meaning edit from silently
@@ -212,6 +235,66 @@ func TestServerOverTCP(t *testing.T) {
 	}
 }
 
+// A client that vanishes mid-over must not leave the transmitter keyed. Nothing
+// else would notice: the Kenwood/Elecraft backend stops polling while PTT is
+// held, so a K3 was seen sitting in transmit for 29 s after WSJT-X's socket was
+// closed under it by a settings save.
+func TestPTTIsDroppedWhenTheClientDisappears(t *testing.T) {
+	rig := &fakeRig{freq: 14074000, mode: "FT8"}
+	s := New(0, rig, nil)
+	ln, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatalf("listen: %v", err)
+	}
+	s.mu.Lock()
+	s.ln = ln
+	s.mu.Unlock()
+	go func() {
+		for {
+			c, err := ln.Accept()
+			if err != nil {
+				return
+			}
+			go s.serve(c)
+		}
+	}()
+	defer s.Stop()
+
+	c, err := net.DialTimeout("tcp", ln.Addr().String(), dialTimeout)
+	if err != nil {
+		t.Fatalf("dial: %v", err)
+	}
+	r := bufio.NewReader(c)
+	// "T 3" is what WSJT-X sends for PTT_ON_DATA — the form seen in the field.
+	if _, err := c.Write([]byte("T 3\n")); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+	line, _ := r.ReadString('\n')
+	if strings.TrimSpace(line) != "RPRT 0" {
+		t.Fatalf("set_ptt = %q, want RPRT 0", strings.TrimSpace(line))
+	}
+	rig.mu.Lock()
+	keyed := rig.ptt
+	rig.mu.Unlock()
+	if !keyed {
+		t.Fatalf("rig is not keyed after T 3 — the test proves nothing")
+	}
+
+	_ = c.Close()
+	// The unkey happens on the serve goroutine's defer, so poll briefly.
+	deadline := time.Now().Add(2 * time.Second)
+	for time.Now().Before(deadline) {
+		rig.mu.Lock()
+		keyed = rig.ptt
+		rig.mu.Unlock()
+		if !keyed {
+			return
+		}
+		time.Sleep(10 * time.Millisecond)
+	}
+	t.Error("rig still keyed after the client disconnected — the transmitter was left on air")
+}
+
 func TestModeMapping(t *testing.T) {
 	for _, c := range []struct{ adif, hamlib string }{
 		{"SSB", "USB"}, {"LSB", "LSB"}, {"CW", "CW"}, {"RTTY", "RTTY"},

internal/rotator/dcu1/dcu1.go

@@ -0,0 +1,158 @@
+// Package dcu1 drives rotator controllers that speak the Hy-Gain DCU-1 protocol,
+// over a serial COM port (or a raw TCP socket, e.g. a serial-over-IP bridge).
+//
+// DCU-1 is used by the Hy-Gain DCU-1, the Idiom Press Rotor-EZ, Green Heron
+// controllers, and the RotorCard DXA (hamsupply) for Yaesu DXA rotors. It is a
+// DIFFERENT command set from Yaesu GS-232 (see internal/rotator/gs232):
+// semicolon-terminated, azimuth only.
+//
+// Commands (';' terminated — roundTrip appends the ';'):
+//
+//	AP1nnn   set the target bearing nnn (000-359)
+//	AM1      rotate to the target (some controllers move on AP1 alone; AM1 is
+//	         harmless and makes the Rotor-EZ/DCU-1 variants that need it work)
+//	AI1      query the current bearing → the reply carries the 3-digit azimuth
+//
+// The base DCU-1 set has no dedicated stop; Stop re-commands the current bearing,
+// which halts rotation.
+package dcu1
+
+import (
+	"fmt"
+	"io"
+	"net"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+
+	"go.bug.st/serial"
+)
+
+const (
+	dialTimeout = 3 * time.Second
+	ioTimeout   = 2 * time.Second
+)
+
+// Client is a stateless per-call sender, mirroring the gs232/pst/rotgenius idiom.
+// Exactly one of (Host, Port) or ComPort is used.
+type Client struct {
+	Host    string
+	Port    int
+	ComPort string // serial transport: "COM5" etc.
+	// Baud varies by controller (a Hy-Gain DCU-1 is 4800; Green Heron / RotorCard
+	// can differ). Zero keeps 4800.
+	Baud int
+}
+
+// New returns a TCP Client (a serial-over-IP bridge in front of the controller).
+func New(host string, port int) *Client {
+	if host == "" {
+		host = "127.0.0.1"
+	}
+	if port <= 0 || port > 65535 {
+		port = 4001
+	}
+	return &Client{Host: host, Port: port}
+}
+
+// NewSerial returns a Client over the controller's COM port.
+func NewSerial(comPort string, baud int) *Client {
+	return &Client{ComPort: comPort, Baud: baud}
+}
+
+// roundTrip opens a connection, sends one ';'-terminated command and (when
+// wantReply) reads until a 3-digit bearing is present. cmd must NOT carry the
+// ';'.
+func (c *Client) roundTrip(cmd string, wantReply bool) (string, error) {
+	var conn io.ReadWriteCloser
+	if c.ComPort != "" {
+		baud := c.Baud
+		if baud <= 0 {
+			baud = 4800
+		}
+		sp, err := serial.Open(c.ComPort, &serial.Mode{BaudRate: baud})
+		if err != nil {
+			return "", fmt.Errorf("open rotator %s @ %d baud: %w", c.ComPort, baud, err)
+		}
+		_ = sp.SetReadTimeout(200 * time.Millisecond)
+		conn = sp
+	} else {
+		nc, err := net.DialTimeout("tcp", net.JoinHostPort(c.Host, strconv.Itoa(c.Port)), dialTimeout)
+		if err != nil {
+			return "", fmt.Errorf("connect DCU-1 %s:%d: %w", c.Host, c.Port, err)
+		}
+		_ = nc.SetDeadline(time.Now().Add(ioTimeout))
+		conn = nc
+	}
+	defer conn.Close()
+	if _, err := conn.Write([]byte(cmd + ";")); err != nil {
+		return "", fmt.Errorf("send %q: %w", cmd, err)
+	}
+	if !wantReply {
+		return "", nil
+	}
+	buf := make([]byte, 64)
+	var sb strings.Builder
+	deadline := time.Now().Add(ioTimeout)
+	for time.Now().Before(deadline) {
+		n, err := conn.Read(buf)
+		if n > 0 {
+			sb.Write(buf[:n])
+			// The DCU-1 reply carries the bearing as three digits (framing varies —
+			// ";nnn", "nnn;", "+0nnn"). Stop once we have them rather than on a
+			// specific terminator, so any flavour reads cleanly.
+			if azRe.MatchString(sb.String()) {
+				break
+			}
+		}
+		// A serial read that times out returns (0, nil) — keep polling until the
+		// overall deadline; a real error ends the read.
+		if err != nil {
+			break
+		}
+	}
+	line := strings.TrimSpace(sb.String())
+	if line == "" {
+		return "", fmt.Errorf("no reply to %q", cmd)
+	}
+	return line, nil
+}
+
+// GoTo points the antenna at az (0-359): set the target, then rotate.
+func (c *Client) GoTo(az int) error {
+	az = ((az % 360) + 360) % 360
+	if _, err := c.roundTrip(fmt.Sprintf("AP1%03d", az), false); err != nil {
+		return err
+	}
+	_, err := c.roundTrip("AM1", false)
+	return err
+}
+
+// Stop halts rotation. The base DCU-1 set has no stop command, so re-command the
+// current bearing — the controller stops when the target equals where it is.
+func (c *Client) Stop() error {
+	az, _, err := c.Heading()
+	if err != nil {
+		return err
+	}
+	_, err = c.roundTrip(fmt.Sprintf("AP1%03d", az), false)
+	return err
+}
+
+// azRe matches the 3-digit bearing in any of the DCU-1 reply framings.
+var azRe = regexp.MustCompile(`(\d{3})`)
+
+// Heading queries the current azimuth. Returns the raw reply for diagnostics.
+func (c *Client) Heading() (az int, raw string, err error) {
+	raw, err = c.roundTrip("AI1", true)
+	if err != nil {
+		return 0, raw, err
+	}
+	m := azRe.FindStringSubmatch(raw)
+	if m == nil {
+		return 0, raw, fmt.Errorf("unrecognised azimuth reply %q", raw)
+	}
+	az, _ = strconv.Atoi(m[1])
+	return az % 360, raw, nil
+}

internal/spe/spe.go

@@ -228,6 +228,18 @@ func (c *Client) PowerOn() error {
 func (c *Client) PowerOff() error {
 	err := c.sendCmd(cmdOff)
 	applog.Printf("spe: power OFF — SWITCH OFF key sent (err=%v)", err)
+	// Drop the link and mark the amp offline at once, exactly as a fresh start
+	// would see it. The amp stops answering its UART once off, but the connection
+	// that was already open BEFORE the off keystroke kept reading as "connected"
+	// (stale/queued frames), so the UI never showed OFF and PowerOn — which only
+	// wakes a DISCONNECTED amp — did nothing until the operator restarted OpsLog.
+	// The poll loop reopens the port on its next tick; a plain reopen never wakes a
+	// switched-off amp (only PowerOn's RTS/DTR edge does), so it stays offline.
+	time.Sleep(100 * time.Millisecond) // let the 6-byte OFF command flush before we close
+	c.mu.Lock()
+	c.dropLocked()
+	c.mu.Unlock()
+	c.setErr(fmt.Errorf("switched off"))
 	return err
 }
 

internal/ultrabeam/ultrabeam.go

@@ -23,6 +23,12 @@ const (
 	ubReadTimeout    = 4 * time.Second  // was 1s — too tight for a remote link
 	ubKeepAlive      = 15 * time.Second // OS-level TCP keepalive
 	ubMaxPollTimeout = 3                // consecutive read timeouts tolerated before reconnecting
+	// How long a just-commanded direction is trusted AFTER the motors have stopped
+	// but before the antenna's status confirms it. The timer is held off entirely
+	// while the motors are still moving, so this is only the grace period for the
+	// confirmation poll to arrive once the elements have settled — generous, because
+	// over a remote link that poll lags by several seconds.
+	ubPendingDirGrace = 8 * time.Second
 )
 
 // Protocol constants
@@ -82,8 +88,22 @@ type Client struct {
 	// yet (Frequency==0) — otherwise the deadband is bypassed and every small QSY
 	// re-tunes the motors.
 	lastSetKHz int
+
+	// moveCmdAt is when a move (frequency or direction) was last COMMANDED. The
+	// status poll runs every couple of seconds, so without this the "moving" flag
+	// — which drives the UI indicator and the Flex TX-inhibit — appeared up to a
+	// poll late even though the elements start moving at once. GetStatus reports
+	// motion during a short window after a command so both react immediately.
+	moveCmdAt time.Time
 }
 
+// ubMoveOptimisticWindow is how long after a commanded move GetStatus reports
+// "moving" before the status poll has had a chance to read the real motor state.
+// It only needs to bridge one poll interval; once a poll sees real motion, that
+// takes over. Bounded, so if the antenna never reports motion the flag still
+// clears rather than latching the TX-inhibit on for ever.
+const ubMoveOptimisticWindow = 3 * time.Second
+
 // LastSetKHz returns the frequency (kHz) most recently commanded to the antenna,
 // or 0 if none yet.
 func (c *Client) LastSetKHz() int {
@@ -221,12 +241,30 @@ func (c *Client) pollLoop() {
 			}
 
 			c.statusMu.Lock()
-			// Keep a just-commanded direction until the antenna reports it.
+			// Keep a just-commanded direction until the antenna actually reports it.
+			// Over a remote link the confirmation arrives several seconds after the
+			// command — the motors flip the elements first — so the old fixed 4 s
+			// timeout expired WHILE the change was still in flight, and the stale poll
+			// reverted the UI to the old pattern even though the antenna was on its way
+			// to the new one. Now: while the motors are still moving the change is in
+			// progress, so hold the commanded pattern and keep resetting the timer;
+			// only once the motors have stopped does the short grace window run, giving
+			// the confirmation poll time to land. The poll only wins if the motors are
+			// idle AND the antenna still reports a different pattern past that window —
+			// i.e. the command genuinely did not take.
 			if c.pendingDirSet {
-				if time.Since(c.pendingDirAt) > 4*time.Second || status.Direction == c.pendingDir {
-					c.pendingDirSet = false
-				} else {
-					status.Direction = c.pendingDir
+				if status.MotorsMoving != 0 {
+					c.pendingDirAt = time.Now() // still repositioning — don't start the grace timer
+				}
+				switch {
+				case status.Direction == c.pendingDir:
+					c.pendingDirSet = false // confirmed by the antenna
+				case time.Since(c.pendingDirAt) > ubPendingDirGrace:
+					c.pendingDirSet = false // motors idle, still unconfirmed → accept the poll
+					log.Printf("Ultrabeam: antenna never confirmed direction %d (reports %d) — dropping the hold",
+						c.pendingDir, status.Direction)
+				default:
+					status.Direction = c.pendingDir // still changing, or within the grace window
 				}
 			}
 			c.lastStatus = status
@@ -246,7 +284,19 @@ func (c *Client) GetStatus() (*Status, error) {
 		return &Status{Connected: false}, nil
 	}
 
-	return c.lastStatus, nil
+	// Copy so the optimistic-motion tweak below never mutates the cached status
+	// the poll goroutine owns.
+	st := *c.lastStatus
+	// Optimistic motion: right after a commanded move, report "moving" until a
+	// status poll can read the real motor state (~one poll interval). The elements
+	// start moving the instant the operator clicks a band/pattern, so this makes
+	// the UI indicator and the Flex TX-inhibit react immediately instead of a poll
+	// later. Real polled motion takes over once seen; the window is bounded so the
+	// flag can't latch the inhibit on for ever.
+	if st.Connected && st.MotorsMoving == 0 && !c.moveCmdAt.IsZero() && time.Since(c.moveCmdAt) < ubMoveOptimisticWindow {
+		st.MotorsMoving = 1 // sentinel: optimistically moving (read only as != 0)
+	}
+	return &st, nil
 }
 
 // getNextSeq returns the next sequence number
@@ -277,10 +327,9 @@ func quoteByte(b byte) []byte {
 	return []byte{b}
 }
 
-// buildPacket creates a complete packet with checksum and escaping
-func (c *Client) buildPacket(cmd byte, data []byte) []byte {
-	seq := c.getNextSeq()
-
+// buildPacket creates a complete packet with checksum and escaping. The seq is
+// supplied by the caller so sendCommand can match the reply against it.
+func (c *Client) buildPacket(seq, cmd byte, data []byte) []byte {
 	// Calculate checksum on unquoted data
 	payload := append([]byte{seq, cmd}, data...)
 	chk := calculateChecksum(payload)
@@ -365,39 +414,27 @@ func (c *Client) sendCommand(cmd byte, data []byte) ([]byte, error) {
 		return nil, fmt.Errorf("not connected")
 	}
 
-	// Build and send packet
-	packet := c.buildPacket(cmd, data)
+	// Flush anything already sitting in the stream before we send. The antenna
+	// does NOT echo our sequence number — its replies carry their own counter — so
+	// a reply cannot be matched to its request. Instead we keep the exchange 1:1:
+	// a reply left behind by an earlier timed-out command is discarded here, so
+	// the reply we read next belongs to THIS command. Reading a stale reply as the
+	// current one crossed STATUS with READ_BANDS/PROGRESS — phantom frequencies (a
+	// spurious follow-loop re-tune), dropped connections and wrong element lengths.
+	c.drainStale()
 
-	_, err := c.conn.Write(packet)
-	if err != nil {
+	seq := c.getNextSeq()
+	packet := c.buildPacket(seq, cmd, data)
+	if _, err := c.conn.Write(packet); err != nil {
 		return nil, fmt.Errorf("failed to write: %w", err)
 	}
 
-	// Read reply with timeout (generous — tolerates remote-link latency).
+	// Read the reply with a timeout generous enough for a remote link.
 	c.conn.SetReadDeadline(time.Now().Add(ubReadTimeout))
-
-	// Read until we get a complete packet
-	var buffer []byte
-	for {
-		b, err := c.reader.ReadByte()
-		if err != nil {
-			return nil, fmt.Errorf("failed to read: %w", err)
-		}
-
-		buffer = append(buffer, b)
-
-		// Check if we have a complete packet
-		if b == ETX && len(buffer) > 0 && buffer[0] == STX {
-			break
-		}
-
-		// Prevent infinite loop
-		if len(buffer) > 256 {
-			return nil, fmt.Errorf("packet too long")
-		}
+	buffer, err := c.readPacket()
+	if err != nil {
+		return nil, err
 	}
-
-	// Parse reply
 	_, replyCmd, payload, err := parsePacket(buffer)
 	if err != nil {
 		return nil, fmt.Errorf("failed to parse reply: %w", err)
@@ -426,6 +463,45 @@ func (c *Client) sendCommand(cmd byte, data []byte) ([]byte, error) {
 	}
 }
 
+// drainStale discards any bytes already waiting in the stream — a reply left
+// behind by a command that timed out. A short read deadline lets it consume what
+// is there and stop quickly when the stream is clean. Caller holds connMu.
+func (c *Client) drainStale() {
+	c.conn.SetReadDeadline(time.Now().Add(5 * time.Millisecond))
+	buf := make([]byte, 256)
+	for {
+		n, err := c.reader.Read(buf)
+		if n == 0 || err != nil {
+			return
+		}
+	}
+}
+
+// readPacket reads one complete STX…ETX frame, skipping any leading bytes until
+// an STX so a partial/garbage remnant left in the stream can't derail the parse.
+// STX/ETX/DLE are all high-bit (0xF5/0xFA/0xF6) and the escaping clears the MSB,
+// so a raw ETX only ever appears as the real terminator. Caller holds connMu and
+// has set a read deadline.
+func (c *Client) readPacket() ([]byte, error) {
+	var buffer []byte
+	for {
+		b, err := c.reader.ReadByte()
+		if err != nil {
+			return nil, fmt.Errorf("failed to read: %w", err)
+		}
+		if len(buffer) == 0 && b != STX {
+			continue // resync to the start of a frame
+		}
+		buffer = append(buffer, b)
+		if b == ETX {
+			return buffer, nil
+		}
+		if len(buffer) > 256 {
+			return nil, fmt.Errorf("packet too long")
+		}
+	}
+}
+
 // queryStatus queries general status (command 1)
 func (c *Client) queryStatus() (*Status, error) {
 	reply, err := c.sendCommand(CMD_STATUS, nil)
@@ -433,7 +509,13 @@ func (c *Client) queryStatus() (*Status, error) {
 		return nil, err
 	}
 
-	if len(reply) < 12 {
+	// An RCU-06 controller — seen behind an RS232-to-Ethernet bridge — answers with
+	// an 11-byte status frame: the standard one WITHOUT the trailing FreqMax byte.
+	// The packet checksum was already verified, so a short-but-valid frame is real,
+	// not a fragment. Accept it and default the missing tail fields instead of
+	// reconnect-looping on "reply too short". reply[9]/[10] (MotorsMoving, FreqMin)
+	// are the last we truly need, so 10 bytes is the floor.
+	if len(reply) < 10 {
 		return nil, fmt.Errorf("status reply too short: %d bytes", len(reply))
 	}
 
@@ -446,8 +528,12 @@ func (c *Client) queryStatus() (*Status, error) {
 		Direction:        int(reply[6] & 0x0F),
 		OffState:         (reply[7] & 0x02) != 0,
 		MotorsMoving:     int(reply[9]),
-		FreqMin:          int(reply[10]),
-		FreqMax:          int(reply[11]),
+	}
+	if len(reply) > 10 {
+		status.FreqMin = int(reply[10])
+	}
+	if len(reply) > 11 {
+		status.FreqMax = int(reply[11])
 	}
 
 	return status, nil
@@ -513,6 +599,7 @@ func (c *Client) SetFrequency(freqKhz int, direction int) error {
 		c.statusMu.Lock()
 		c.pendingDir, c.pendingDirAt, c.pendingDirSet = direction, time.Now(), true
 		c.lastSetKHz = freqKhz
+		c.moveCmdAt = time.Now() // start reporting motion at once — see ubMoveOptimisticWindow
 		if c.lastStatus != nil {
 			c.lastStatus.Direction = direction // reflect immediately
 		}

internal/ultrabeam/ultrabeam_test.go

@@ -0,0 +1,94 @@
+package ultrabeam
+
+import (
+	"bufio"
+	"bytes"
+	"net"
+	"testing"
+	"time"
+)
+
+// sendCommand must flush any bytes already in the stream (a reply left by an
+// earlier timed-out command) before reading, then return the reply to THIS
+// command. The antenna does not echo our sequence number, so keeping the stream
+// clean is the only way to stay in sync.
+func TestSendCommandFlushesStaleThenReadsReply(t *testing.T) {
+	srvConn, cliConn := net.Pipe()
+	defer srvConn.Close()
+	defer cliConn.Close()
+
+	c := &Client{conn: cliConn, reader: bufio.NewReader(cliConn)}
+	srv := &Client{reader: bufio.NewReader(srvConn)}
+
+	errc := make(chan error, 1)
+	go func() {
+		// Leftover from a "previous" command still sitting in the stream. The Write
+		// blocks until drainStale consumes it, so it is guaranteed flushed before
+		// the real exchange.
+		if _, err := srvConn.Write(c.buildPacket(9, UB_OK, []byte{0xDE, 0xAD})); err != nil {
+			errc <- err
+			return
+		}
+		// Now serve the actual request.
+		req, err := srv.readPacket()
+		if err != nil {
+			errc <- err
+			return
+		}
+		seq, _, _, err := parsePacket(req)
+		if err != nil {
+			errc <- err
+			return
+		}
+		_, err = srvConn.Write(c.buildPacket(seq, UB_OK, []byte{0x11, 0x22, 0x33}))
+		errc <- err
+	}()
+
+	payload, err := c.sendCommand(CMD_STATUS, nil)
+	if err != nil {
+		t.Fatalf("sendCommand: %v", err)
+	}
+	if !bytes.Equal(payload, []byte{0x11, 0x22, 0x33}) {
+		t.Fatalf("payload = % X, want 11 22 33 — stale reply not flushed", payload)
+	}
+	if err := <-errc; err != nil {
+		t.Fatalf("server: %v", err)
+	}
+}
+
+// readPacket must resynchronise to the next STX, dropping any partial/garbage
+// bytes left in the stream, so one corrupt frame can't misalign every frame
+// after it.
+func TestReadPacketResyncsToSTX(t *testing.T) {
+	frame := (&Client{}).buildPacket(5, UB_OK, []byte{0x01, 0x02})
+	stream := append([]byte{0x11, 0x22, 0x33}, frame...) // leading garbage, then a real frame
+	c := &Client{reader: bufio.NewReader(bytes.NewReader(stream))}
+
+	got, err := c.readPacket()
+	if err != nil {
+		t.Fatalf("readPacket: %v", err)
+	}
+	seq, cmd, payload, err := parsePacket(got)
+	if err != nil {
+		t.Fatalf("parsePacket: %v", err)
+	}
+	if seq != 5 || cmd != UB_OK || !bytes.Equal(payload, []byte{0x01, 0x02}) {
+		t.Fatalf("seq=%d cmd=%d payload=% X, want 5 / OK / 01 02", seq, cmd, payload)
+	}
+}
+
+// A commanded move must report motion immediately (before the next status poll),
+// then fall back to the real motor state once the window elapses.
+func TestOptimisticMotionAfterCommand(t *testing.T) {
+	c := &Client{lastStatus: &Status{Connected: true, MotorsMoving: 0}}
+
+	c.moveCmdAt = time.Now()
+	if st, _ := c.GetStatus(); st.MotorsMoving == 0 {
+		t.Fatal("just after a move command, GetStatus should report motion")
+	}
+
+	c.moveCmdAt = time.Now().Add(-ubMoveOptimisticWindow - time.Second)
+	if st, _ := c.GetStatus(); st.MotorsMoving != 0 {
+		t.Fatal("past the window with motors idle, GetStatus must report no motion")
+	}
+}

telemetry.go

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

update.go

@@ -150,15 +150,55 @@ 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)
-	if err := os.Rename(exe, oldExe); err != nil {
-		_ = os.Remove(newExe)
-		return fmt.Errorf("stage current exe: %w", err)
+	//
+	// The staging name is UNIQUE, not a fixed ".old". With a fixed name, one
+	// leftover that could not be deleted — an antivirus holding it open is the
+	// usual reason — poisoned every later update: the rename replaces its target,
+	// 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 err := os.Rename(newExe, exe); err != nil {
-		_ = os.Rename(oldExe, exe) // roll back
-		return fmt.Errorf("install new exe: %w", err)
+
+	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
@@ -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
-// (exe + ".old"). Called at startup after a --post-update relaunch. Best-effort:
-// the file may still be briefly locked, in which case the next launch gets it.
+// cleanupOldUpdateBinary removes what a self-update left behind. Called at
+// startup after a --post-update relaunch. Best-effort throughout: a file may
+// 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 {
-		_ = os.Remove(exe + ".old")
+	exe, err := os.Executable()
+	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)
 	}
 }
 

wiki/Import-and-Export-ADIF.md

@@ -6,19 +6,54 @@ export modes.
 
 ## Import
 
-Import an `.adi` / `.adif` file into the active profile's logbook. On import,
-OpsLog parses every field, maps standard fields to columns and keeps unknown but
-valid ADIF fields in a per-QSO **extras** store (editable later). Country /
-zones are enriched from `cty.dat` where missing. A file **without a header**
-(records pasted from another log) imports fine.
+**File → Import** (`Ctrl+O`) → pick an `.adi` / `.adif` file → the **Import ADIF**
+dialog opens with the options below. Import runs into the **active profile's**
+logbook. A file **without a header** (records pasted from another log) imports
+fine. Progress shows live; a summary follows — imported / updated / duplicates /
+skipped / total — with expandable **error** and **duplicate** lists.
 
-- **Field remapping**: the import dialog can move a field as it reads it —
-  e.g. the RSGB IOTA contest exports the island reference in `STATE`; add a
-  `STATE → IOTA` row and it lands where the award looks.
-- **Fill from profile**: optionally stamps your station fields *and* your
-  default confirmation statuses (paper QSL, LoTW, eQSL, Club Log, HRDLog,
-  QRZ.com) on QSOs the file leaves empty — a WSJT-X log carries almost none.
-  Existing values are never overwritten.
+### Duplicate handling
+
+A **duplicate** is a record with the same **callsign + UTC minute + band + mode**
+as a QSO already in the logbook. Pick how they are treated:
+
+| Mode | What it does |
+|------|--------------|
+| **Skip duplicates** *(default)* | Adds only new QSOs; existing ones left untouched. Safe default. |
+| **Update duplicates** | Merges the file's non-empty fields (QSL / LoTW / eQSL / QRZ statuses & dates, etc.) onto the matching QSO — fields the file omits are kept. Use to re-sync from Log4OM or LoTW. |
+| **Import everything** | Inserts every record, duplicates included. For deliberately merging two overlapping logs. |
+
+### Enrichment options
+
+- **Fix country & zones (cty.dat + ClubLog)** *(on by default)* — recompute
+  Country, DXCC and CQ/ITU zones from `cty.dat`, overriding the file. Corrects
+  what contest software exports wrong (e.g. RG2Y tagged Asiatic instead of
+  European Russia). ClubLog's date-ranged DXpedition overrides are applied on top
+  per QSO date (e.g. TO2A in 2012 → French Guiana) whenever the ClubLog data is
+  downloaded. Everything else in the ADIF is kept as-is. *Tip: combine with
+  **Update duplicates** to re-fix QSOs already in your log.*
+- **Fill my station fields from my profile** *(off by default)* — backfill empty
+  `MY_*` fields (grid, rig, antenna, address, city, state, county, SOTA/POTA ref,
+  TX power…) plus Operator and Owner callsign from the active profile. Existing
+  values are kept; only `STATION_CALLSIGN` is left untouched so a mixed-call log
+  isn't re-routed. It **also** stamps your default confirmation statuses (paper
+  QSL, LoTW, eQSL, Club Log, HRDLog, QRZ.com — sent & received) on QSOs the file
+  leaves empty. Enable when importing **your own** log; leave off for someone
+  else's.
+
+### Field remapping (move fields on import)
+
+Contest software stores the exchange where its own module keeps it. The RSGB IOTA
+contest, for example, exports the island reference in `STATE` — imported as-is it
+becomes a US state and the IOTA award stays empty. Click **"The file puts a field
+in the wrong place…"**, then add a `STATE → IOTA` row (add as many rows as you
+need). The destination is filled **only where the file left it blank**.
+
+### Unknown fields
+
+Any valid ADIF field OpsLog doesn't promote to a column is preserved in a per-QSO
+**extras** store — editable later and re-exported intact. Nothing valid is
+dropped.
 
 ## Export
 
@@ -41,4 +76,7 @@ not lose your award-reference assignments.
 
 - To move a batch of QSOs between logs, export selected → import into the other
   profile.
+- Re-syncing statuses from another logger (Log4OM, LoTW, QRZ)? Import the file
+  with **Update duplicates** — it merges the new confirmations onto your existing
+  QSOs without creating copies.
 - Use **Find duplicates** (Tools) after importing to catch overlaps.