chore: release v0.26.0

Every station on an already-worked band was flagged NEW MODE.

A WSJT-X Decode does not carry the mode's name. It carries the
one-character marker from the decode line - "~" for FT8, "+" for FT4 - and
that character was passed straight through as though it were a mode. The
status resolver then compared "~" against the modes worked for the entity,
matched nothing, and concluded the mode had never been worked. Same cause
put "~ -07" in the comment of every decode spot pushed to the FlexRadio
panadapter, which nobody had traced back.

Resolved through a marker table, with the mode from the sender's last
Status as the fallback - Status is the message that carries the real name.
So an unlisted or future marker degrades to correct rather than to
nonsense, and a sender that puts the name in the field directly is believed
as-is. With neither available the mode is left empty, which makes the
resolver answer "worked": the safe side, since a wrong mode invents a
new-mode flag exactly as the marker did.

amps_linked_test.go

@@ -1,6 +1,11 @@
 package main
 
-import "testing"
+import (
+	"errors"
+	"sync"
+	"testing"
+	"time"
+)
 
 // The coupling is a SET, not a global switch.
 //
@@ -61,3 +66,73 @@ func TestLinkedAmpsNeedsTwo(t *testing.T) {
 		}
 	}
 }
+
+// Two combined amplifiers must be commanded AT THE SAME TIME, not one after the
+// other.
+//
+// Sequentially, the second was commanded only once the first had answered — and
+// an SPE answers over its own link, in its own time. The combiner heard power
+// appear on one input before the other and beeped about it, on every OFF and
+// every ON. This is what an operator hears, so it is worth a test that would
+// hear it too.
+func TestLinkedAmpCommandsLeaveTogether(t *testing.T) {
+	a := &App{}
+	const slow = 150 * time.Millisecond
+
+	var mu sync.Mutex
+	starts := map[string]time.Time{}
+	err := a.ampFanOut([]string{"one", "two"}, func(id string) error {
+		mu.Lock()
+		starts[id] = time.Now()
+		mu.Unlock()
+		time.Sleep(slow) // an amplifier taking its time to answer
+		return nil
+	})
+	if err != nil {
+		t.Fatalf("fan-out: %v", err)
+	}
+	if len(starts) != 2 {
+		t.Fatalf("%d amplifiers were commanded, want both", len(starts))
+	}
+	// Both goroutines wait on one channel and are released by closing it, so the
+	// gap is scheduling noise. Sequential execution would put a full command
+	// between them.
+	gap := starts["one"].Sub(starts["two"])
+	if gap < 0 {
+		gap = -gap
+	}
+	if gap > slow/3 {
+		t.Errorf("the two amplifiers were commanded %v apart — the combiner hears that as one input arriving late", gap)
+	}
+}
+
+// The amplifier the operator clicked comes first, and its failure is the one
+// reported: "the amp I pressed did not respond" beats the same message about
+// its silent partner.
+func TestLinkedAmpErrorNamesTheOneClicked(t *testing.T) {
+	a := &App{}
+	clicked := errors.New("the one clicked")
+	other := errors.New("the other one")
+	err := a.ampFanOut([]string{"clicked", "other"}, func(id string) error {
+		if id == "clicked" {
+			return clicked
+		}
+		return other
+	})
+	if !errors.Is(err, clicked) {
+		t.Errorf("fan-out reported %v, want the amplifier the operator pressed", err)
+	}
+}
+
+// One amplifier is the ordinary case and must not change: run inline, no
+// goroutine, no barrier, and the error straight back.
+func TestSingleAmpRunsInline(t *testing.T) {
+	a := &App{}
+	boom := errors.New("not running")
+	if err := a.ampFanOut([]string{"solo"}, func(string) error { return boom }); !errors.Is(err, boom) {
+		t.Errorf("a single amplifier reported %v, want the error itself", err)
+	}
+	if err := a.ampFanOut(nil, func(string) error { return boom }); err != nil {
+		t.Errorf("an empty group reported %v, want nothing to do", err)
+	}
+}

appearance.go

@@ -138,6 +138,70 @@ func normRowColors(s RowColorSettings) RowColorSettings {
 	return out
 }
 
+// MatrixColors recolours the band/mode matrix — the PH/CW/DIG grid in the Stats
+// panel, whose five fills and current-entry ring are the fastest read in the
+// whole app and the one an operator is most likely to want in their own colours.
+//
+// Every colour is OPTIONAL and an empty one keeps whatever the active theme
+// paints. That is why this stores OVERRIDES rather than a palette: each of the
+// twelve themes ships a matrix ramp tuned to its own background, and an operator
+// who only wants a different green must not thereby freeze the other four to the
+// theme they happened to be using the day they picked it.
+type MatrixColors struct {
+	// Enabled off leaves the theme's own ramp untouched, so switching it off is a
+	// genuine revert and not "some other set of colours".
+	Enabled         bool   `json:"enabled"`
+	CallConfirmed   string `json:"call_confirmed"`
+	CallWorked      string `json:"call_worked"`
+	EntityConfirmed string `json:"entity_confirmed"`
+	EntityWorked    string `json:"entity_worked"`
+	NotWorked       string `json:"not_worked"`
+	CurrentEntry    string `json:"current_entry"`
+}
+
+// normMatrixColors keeps only plain hex values. Anything else becomes "" — i.e.
+// "use the theme's" — because these are written straight into a CSS custom
+// property, and the same rule as hexColor's own comment applies: what cannot be
+// trusted into a stylesheet is refused rather than passed through.
+func normMatrixColors(c MatrixColors) MatrixColors {
+	clean := func(s string) string {
+		s = strings.TrimSpace(s)
+		if hexColor.MatchString(s) {
+			return strings.ToLower(s)
+		}
+		return ""
+	}
+	return MatrixColors{
+		Enabled:         c.Enabled,
+		CallConfirmed:   clean(c.CallConfirmed),
+		CallWorked:      clean(c.CallWorked),
+		EntityConfirmed: clean(c.EntityConfirmed),
+		EntityWorked:    clean(c.EntityWorked),
+		NotWorked:       clean(c.NotWorked),
+		CurrentEntry:    clean(c.CurrentEntry),
+	}
+}
+
+// GetMatrixColors returns the operator's matrix palette overrides. All-empty
+// (the default) means "whatever the theme says".
+func (a *App) GetMatrixColors() MatrixColors {
+	var c MatrixColors
+	if raw := a.settingOr(keyMatrixColors, ""); raw != "" {
+		_ = json.Unmarshal([]byte(raw), &c)
+	}
+	return normMatrixColors(c)
+}
+
+// SaveMatrixColors persists them.
+func (a *App) SaveMatrixColors(c MatrixColors) error {
+	b, err := json.Marshal(normMatrixColors(c))
+	if err != nil {
+		return err
+	}
+	a.setSetting(keyMatrixColors, string(b))
+	return nil
+}
+
 // GetRowColors returns the row-colouring configuration, defaults included so the
 // panel never has to invent one.
 func (a *App) GetRowColors() RowColorSettings {

bandopen_nearkm_test.go

@@ -0,0 +1,37 @@
+package main
+
+import (
+	"testing"
+
+	"hamlog/internal/pskr"
+)
+
+// The receiver radius is what makes an opening report evidence about the
+// OPERATOR's path rather than someone else's. Both ends of the range destroy
+// that: too small and no receiver is ever near enough, too large and the
+// reports are about a different part of the world. A stored value that would do
+// either has to fall back rather than be honoured.
+func TestBandOpenNearKmClamps(t *testing.T) {
+	for _, tc := range []struct {
+		name string
+		raw  string
+		want int
+	}{
+		{"unset falls back", "", pskr.DefaultNearKm},
+		{"not a number falls back", "soon", pskr.DefaultNearKm},
+		{"zero falls back", "0", pskr.DefaultNearKm},
+		{"negative falls back", "-100", pskr.DefaultNearKm},
+		{"absurdly tight falls back", "5", pskr.DefaultNearKm},
+		{"absurdly wide falls back", "5000", pskr.DefaultNearKm},
+		{"a real choice is kept", "100", 100},
+		{"the lower bound is kept", "25", 25},
+		{"the upper bound is kept", "1000", 1000},
+		{"surrounding space is ignored", "  150 ", 150},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			if got := bandOpenNearKm(tc.raw); got != tc.want {
+				t.Errorf("bandOpenNearKm(%q) = %d, want %d", tc.raw, got, tc.want)
+			}
+		})
+	}
+}

bandopen_sources.go

@@ -16,6 +16,7 @@ package main
 // they no longer need.
 
 import (
+	"strconv"
 	"strings"
 
 	"hamlog/internal/applog"
@@ -28,7 +29,8 @@ import (
 
 const (
 	keyBandOpenEnabled = "bandopen.enabled"
-	keyBandOpenBands   = "bandopen.bands" // comma-separated; empty = the default set
+	keyBandOpenBands   = "bandopen.bands"  // comma-separated; empty = the default set
+	keyBandOpenNearKm  = "bandopen.nearkm" // receiver radius; empty = pskr.DefaultNearKm
 )
 
 // rbnNodes are the two Reverse Beacon Network endpoints the watch wants: CW and
@@ -45,6 +47,18 @@ type BandOpenSettings struct {
 	// Available is every band that can be watched, so the UI does not carry its
 	// own copy of a list that belongs to the detector.
 	Available []string `json:"available"`
+	// NearKm is how close a RECEIVER has to be for its report to count as
+	// evidence about the operator's own path. An opening on these bands reaches
+	// an AREA, and the right radius is a judgement about how big that area is —
+	// a 2 m tropo duct is not a 10 m Es footprint — so it is the operator's to
+	// make rather than a constant.
+	//
+	// Tightening it costs nothing in traffic: the broker subscription is one
+	// ring of squares whatever this says, and this only decides what survives
+	// once the messages are here. It costs SENSITIVITY — too small a radius in a
+	// thinly-populated region leaves no receivers at all, and a watch with
+	// nothing to look at reports nothing while appearing to work.
+	NearKm int `json:"near_km"`
 }
 
 func (a *App) GetBandOpenSettings() BandOpenSettings {
@@ -52,6 +66,7 @@ func (a *App) GetBandOpenSettings() BandOpenSettings {
 		Enabled:   a.settingOr(keyBandOpenEnabled, "") == "1",
 		Bands:     splitCSV(a.settingOr(keyBandOpenBands, "")),
 		Available: pskr.Bands,
+		NearKm:    bandOpenNearKm(a.settingOr(keyBandOpenNearKm, "")),
 	}
 	// Keep only bands that are still offered. A saved selection outlives the code
 	// that made it: 12 m was dropped from the watched set, but every operator who
@@ -78,9 +93,23 @@ func keepKnownBands(want []string) []string {
 	return out
 }
 
+// bandOpenNearKm reads the stored receiver radius, falling back to the default
+// for anything unset or out of range. The bounds are the two ways to make the
+// watch useless: below 25 km almost nobody is ever near enough to hear anything,
+// and past 1000 km the reports stop being about the operator's own path — which
+// is the entire premise of measuring from a receiver rather than a transmitter.
+func bandOpenNearKm(raw string) int {
+	n, err := strconv.Atoi(strings.TrimSpace(raw))
+	if err != nil || n < 25 || n > 1000 {
+		return pskr.DefaultNearKm
+	}
+	return n
+}
+
 func (a *App) SaveBandOpenSettings(s BandOpenSettings) error {
 	a.setSetting(keyBandOpenEnabled, map[bool]string{true: "1", false: "0"}[s.Enabled])
 	a.setSetting(keyBandOpenBands, strings.Join(s.Bands, ","))
+	a.setSetting(keyBandOpenNearKm, strconv.Itoa(bandOpenNearKm(strconv.Itoa(s.NearKm))))
 	if s.Enabled {
 		a.ensureRBNNodes()
 	}
@@ -184,6 +213,7 @@ func (a *App) startBandOpenFeed() {
 	a.pskr = pskr.New(pskr.Config{
 		Bands:   bands,
 		RxGrids: rxGrids,
+		NearKm:  s.NearKm,
 		OpLat:   a.opLat, OpLon: a.opLon,
 		Geo: func(grid string) (int, int, bool) {
 			lat, lon, ok := gridToLatLon(grid)

changelog.json

@@ -1,4 +1,104 @@
 [
+  {
+    "version": "0.26.0",
+    "date": "",
+    "en": [
+      "A new FT decodes tab: every decode from WSJT-X, JTDX or MSHV, grouped by transmit period, with what is new and what you are sending. Clicking a decode asks the application to call that station, exactly as double-clicking the line in its own window does. Columns are resizable and remembered, the filter bar with them, Clear empties the lists and Halt stops the transmission. With two receivers running the table splits into one column per band, each with its own transmit line, Halt and Clear, and the column lights up when that receiver is on the air. On a FlexRadio, answering a decode moves the transmitter to the slice listening on that band — unless that band already transmits, so an existing split is left alone.",
+      "FT decodes: auto-call. OpsLog can answer a decode without you clicking it — pick what qualifies (a new entity, band, mode, band+mode slot, grid, US county, POTA park or WPX prefix) and add a watch list of callsigns, with or without conditions of their own. It answers a CQ only, one station at a time across the whole station, never while any receiver is still mid-QSO, with a cooldown per callsign, and every call is written to the log with its reason. Armed from the decodes toolbar or Settings → FTx decodes, and off until you turn it on.",
+      "A grid-square map (Tools → Grid squares): every 4-character square in the log, confirmed squares solid and worked ones faint, scoped to digital or the FT modes, on the basemap of your choice. It answers the one question a decode list cannot — not who is on the band, but where the station has actually been reaching.",
+      "UDP: a new outbound type relays the WSJT-X stream. Every datagram received from WSJT-X, JTDX or MSHV is re-sent byte for byte to another program — JTAlert, GridTracker, a second logger — which each sender cannot do on its own, since they talk to one address only. Forwarded verbatim, with no origin header of the kind that has to be stripped back off at the far end, and a target naming one of OpsLog’s own ports is refused rather than looped.",
+      "New-grid detection now reads the grid from a reply as well as from a CQ. \"C91RU IZ5EME JN52\" — a station answering with its locator — is the commonest grid-bearing message on a busy band, and only CQs were being read: any station whose CQ you happened to miss had no known grid at all and could never be flagged as a new one. This is why other tools showed far more wanted grids than OpsLog did.",
+      "New-grid chasing is now scoped the way GridTracker scopes it, so the two agree. Pick how a square counts as already worked — this band or any band, crossed with any digital mode, this exact mode, or any FT mode (FT8/FT4/FT2) — and whether to chase only squares never worked or unconfirmed ones too, which are still missing from the award. The two are shown differently: a square never worked is a QSO to make, one worked and awaiting a confirmation is a QSL to chase, and they no longer share a badge. Settings → DX Cluster. The decodes table also gained a Grid column.",
+      "Cluster: NEW badges now clear after a contact however it was logged. Only hand-logging refreshed the worked snapshot, so a station worked through WSJT-X / JTDX / MSHV — or replayed from the offline outbox, arriving from a multi-op partner, or imported from the POTA hunter log — kept its NEW, NEW BAND, NEW MODE, NEW SLOT, NEW GRID, NEW PFX or NEW POTA badge for the rest of the session.",
+      "DX cluster: the Spotter continent filter matches again. One callsign is spotted by skimmers all over the world within a minute, and they all shared a single cached entry belonging to whichever spotter arrived first — so picking AF left the Indian and American skimmers in the list. Each spot now carries its own spotter continent. Alert rules on the spotter’s continent or country were missing RBN spots for a related reason and now match too.",
+      "Recent QSOs: the callsign search takes wildcards. A plain word now matches the START of a call — 4S finds 4S7AB — while * is any run of characters and ? exactly one, so *4S ends with 4S and *4S* contains it anywhere. It was an unconditional contains-match before, which made asking for a prefix impossible.",
+      "QSL Manager: the right-click menu now carries the same actions as Recent QSOs — ADIF export of the selection, export with a chosen field set, Cabrillo, bulk edit, the callbook and cty.dat updates, e-mail and delete. Filtered exports are deliberately not offered here: \"the filter\" means the Recent-QSOs filter, not the rows on screen. Two entries that appeared in this tab and did nothing when clicked are fixed at the same time — the menu now shows an action only where it is actually wired.",
+      "Column pickers and the ADIF export field chooser gained a whole-dialog Select all / Clear. Only per-group links existed, so clearing a selection meant one click per group — a dozen of them before you could tick the handful you actually wanted. Applies to Recent QSOs, Worked before, the cluster list and the export dialog, and covers the award columns the per-group links never touched.",
+      "Rotator: a Compact mode option (Settings → Rotator) reduces the rotor widget to the dial and the short/long-path azimuths under it. Left off, the widget keeps its quick-turn buttons, azimuth box and Stop.",
+      "Band-opening watch: the radius that counts a receiver as \"around here\" is now adjustable (Settings → DX Cluster), 25–1000 km, still 300 km by default. An opening on 10 m reaches a whole region, a 2 m duct does not, and the right distance is a judgement only the operator can make. Tightening it costs no extra traffic — the subscription is unchanged — only sensitivity.",
+      "Club Log uploads are now identified as OpsLog. They were credited to another station's application key, which took the blame for them.",
+      "ADIF import: \"fill my station fields\" now fills the station callsign too, on records that carry none."
+    ],
+    "fr": [
+      "Un onglet Décodages FT : tous les décodages de WSJT-X, JTDX ou MSHV, groupés par période d’émission, avec ce qui est nouveau et ce que tu émets. Cliquer un décodage demande au logiciel d’appeler cette station, exactement comme un double-clic sur la ligne dans sa propre fenêtre. Les colonnes se redimensionnent et sont mémorisées, la barre de filtres avec elles, Vider efface les listes et Stop arrête l’émission. Avec deux récepteurs, le tableau se scinde en une colonne par bande, chacune avec sa ligne d’émission, son Stop et son Vider, et la colonne s’allume quand c’est ce récepteur qui émet. Sur un FlexRadio, répondre à un décodage déplace l’émetteur sur la slice qui écoute cette bande — sauf si cette bande émet déjà, pour ne pas défaire un split en place.",
+      "Décodages FT : appel automatique. OpsLog peut répondre à un décodage sans que tu cliques — choisis ce qui le déclenche (nouvelle entité, bande, mode, couple bande+mode, carré, comté US, parc POTA ou préfixe WPX) et ajoute une liste d’indicatifs surveillés, avec ou sans conditions propres. Uniquement sur un CQ, une station à la fois pour toute la station, jamais tant qu’un récepteur est encore en QSO, avec un délai de garde par indicatif, et chaque appel est écrit dans le journal avec sa raison. S’arme depuis la barre d’outils des décodages ou Réglages → Décodages FTx, et reste désactivé tant que tu ne l’actives pas.",
+      "Une carte des carrés locator (Outils → Carrés locator) : tous les carrés de 4 caractères du journal, les confirmés en plein et les contactés en pâle, au choix en numérique ou en modes FT, sur le fond de carte de ton choix. Elle répond à la seule question qu’une liste de décodages ne peut pas traiter : non pas qui est sur la bande, mais jusqu’où la station porte réellement.",
+      "UDP : un nouveau type sortant relaie le flux WSJT-X. Chaque datagramme reçu de WSJT-X, JTDX ou MSHV est réémis octet pour octet vers un autre logiciel — JTAlert, GridTracker, un second carnet — ce qu’aucun émetteur ne sait faire seul puisqu’il ne parle qu’à une adresse. Transmis tel quel, sans l’en-tête d’origine qu’il faut ensuite retirer à l’autre bout, et une cible désignant un port d’écoute d’OpsLog est refusée au lieu de boucler.",
+      "La détection des nouveaux carrés lit désormais le locator dans une réponse autant que dans un CQ. « C91RU IZ5EME JN52 » — une station qui répond avec son locator — est le message porteur de locator le plus fréquent sur une bande chargée, et seuls les CQ étaient lus : une station dont on avait manqué le CQ n’avait aucun locator connu et ne pouvait jamais être signalée comme nouvelle. C’est ce qui expliquait l’écart avec les autres logiciels sur le nombre de carrés recherchés.",
+      "La chasse aux nouveaux carrés se règle désormais comme dans GridTracker, pour que les deux soient d’accord. Choisis ce qui fait qu’un carré est déjà fait — cette bande ou toutes bandes, croisé avec tout mode numérique, ce mode exact, ou tout mode FT (FT8/FT4/FT2) — et si tu chasses seulement les carrés jamais contactés ou aussi les non confirmés, qui manquent encore au diplôme. Les deux s’affichent différemment : un carré jamais contacté est un QSO à faire, un carré contacté en attente de confirmation est une QSL à relancer, et ils ne partagent plus le même badge. Réglages → Cluster DX. Le tableau des décodages gagne aussi une colonne Locator.",
+      "Cluster : les badges NEW s’effacent enfin après un contact, quel que soit le mode de journalisation. Seule la saisie manuelle rafraîchissait l’instantané des contacts, si bien qu’une station travaillée via WSJT-X / JTDX / MSHV — ou rejouée depuis la file hors-ligne, reçue d’un partenaire multi-op, ou importée du journal chasseur POTA — gardait son badge NEW, NEW BAND, NEW MODE, NEW SLOT, NEW GRID, NEW PFX ou NEW POTA jusqu’à la fin de la session.",
+      "Cluster DX : le filtre Continent du spotter fonctionne à nouveau. Un même indicatif est spotté par des skimmers du monde entier en une minute, et tous partageaient une seule entrée en cache appartenant au premier spotter arrivé — choisir AF laissait donc les skimmers indiens et américains dans la liste. Chaque spot porte désormais son propre continent de spotter. Les règles d’alerte sur le continent ou le pays du spotter rataient les spots RBN pour une raison voisine et fonctionnent aussi.",
+      "QSO récents : la recherche d’indicatif accepte les jokers. Un mot simple correspond désormais au DÉBUT de l’indicatif — 4S trouve 4S7AB — tandis que * remplace n’importe quelle suite de caractères et ? exactement un : *4S se termine par 4S, *4S* le contient n’importe où. C’était auparavant une recherche « contient » systématique, qui rendait impossible la recherche par préfixe.",
+      "Gestionnaire QSL : le menu contextuel propose désormais les mêmes actions que les QSO récents — export ADIF de la sélection, export avec choix des champs, Cabrillo, édition en masse, mises à jour cty.dat et annuaires, e-mail et suppression. Les exports « filtrés » n’y sont volontairement pas offerts : « le filtre » désigne celui des QSO récents, pas les lignes affichées ici. Deux entrées qui apparaissaient dans cet onglet sans rien faire sont corrigées au passage — le menu n’affiche plus une action que là où elle est réellement branchée.",
+      "Les sélecteurs de colonnes et le choix des champs à l’export ADIF ont désormais un Tout sélectionner / Tout décocher global. Seuls les liens par groupe existaient, si bien que vider une sélection demandait un clic par groupe — une douzaine avant de pouvoir cocher les quelques champs voulus. Vaut pour les QSO récents, Déjà contacté, la liste cluster et la fenêtre d’export, et couvre les colonnes de diplômes que les liens par groupe ne touchaient pas.",
+      "Rotor : une option Mode compact (Réglages → Rotor) réduit le widget au cadran et aux azimuts courte/longue distance en dessous. Désactivée, le widget garde ses boutons de rotation rapide, sa case d’azimut et Stop.",
+      "Veille d’ouverture : le rayon qui fait qu’un récepteur compte comme « près d’ici » est désormais réglable (Réglages → Cluster DX), de 25 à 1000 km, toujours 300 km par défaut. Une ouverture sur 10 m couvre toute une région, un conduit sur 2 m non, et la bonne distance est un jugement qui n’appartient qu’à l’opérateur. Le resserrer ne coûte aucun trafic supplémentaire — l’abonnement ne change pas — seulement de la sensibilité.",
+      "Les envois Club Log s’identifient désormais comme OpsLog. Ils étaient attribués à la clé applicative d’une autre station, qui en portait la responsabilité.",
+      "Import ADIF : « remplir mes champs station » renseigne aussi l’indicatif de station, sur les enregistrements qui n’en portent pas."
+    ]
+  },
+  {
+    "version": "0.25.9",
+    "date": "",
+    "en": [
+      "The band/mode matrix colours can be chosen in Appearance, starting from the ones your theme already paints. Its legend is translated too.",
+      "TCI sharing: a refused un-key no longer leaves the rig stuck transmitting, and PTT is dropped if the client dies mid-over.",
+      "Icom: a frequency or mode change whose acknowledgement is lost is sent again, like PTT — losing one made JTDX drop the radio.",
+      "FlexRadio: transmit audio can switch to DAX for a voice message and back afterwards, so your microphone is not left off air.",
+      "Rotor widget: quick-turn buttons you can name and aim yourself, plus an azimuth box where Enter turns the antenna.",
+      "A station portable in another entity no longer inherits its home county, state and grid — TI8/W2RE was logged in New York.",
+      "LoTW confirmations for FT2, FT4 and FT8 match again: LoTW answers “DATA”, and the exact mode never lined up with the log.",
+      "CAT: a transverter offset, so a 28 MHz IF behind a 144 MHz transverter logs, spots and tunes on the band you are really on.",
+      "Band map: zoom goes down to 2 px/kHz for a whole band in one screen, and each band keeps the zoom you left it at."
+    ],
+    "fr": [
+      "Les couleurs de la matrice bandes/modes se choisissent dans Apparence, à partir de celles du thème. Sa légende est traduite aussi.",
+      "Partage TCI : un retour en réception refusé ne laisse plus le poste bloqué en émission, et le PTT retombe si le logiciel meurt.",
+      "Icom : un changement de fréquence ou de mode dont l’accusé se perd est renvoyé, comme le PTT — en perdre un faisait lâcher JTDX.",
+      "FlexRadio : l’audio d’émission peut basculer sur DAX le temps d’un message vocal et revenir après, pour ne pas perdre le micro.",
+      "Widget rotor : des boutons de rotation rapide que tu nommes et vises toi-même, et un champ azimut où Entrée lance l’antenne.",
+      "Une station portable dans une autre entité n’hérite plus de son comté, son état et son locator d’origine : TI8/W2RE sortait à New York.",
+      "Les confirmations LoTW des QSO FT2, FT4 et FT8 se retrouvent : LoTW répond « DATA », et le mode exact ne correspondait jamais au log.",
+      "CAT : un décalage transverter, pour qu’une FI 28 MHz derrière un transverter 144 MHz logue et accorde sur la vraie bande.",
+      "Carte de bande : le zoom descend à 2 px/kHz pour voir toute la bande d’un coup, et chaque bande retient son zoom."
+    ]
+  },
+  {
+    "version": "0.25.8",
+    "date": "",
+    "en": [
+      "An entity that is a single island group now fills the IOTA reference on its own — no callbook subscription needed.",
+      "CAT sharing can now speak TCI instead of Hamlib, split included, so a TCI-only program reaches whatever radio you are on.",
+      "Lookup cache: a TTL of 0 switches it off, so a callbook record you are correcting is re-read every time.",
+      "TCI radios: when the rig forbids transmitting, PTT says so instead of doing nothing silently.",
+      "WAJA carried Japan’s civil prefecture numbers instead of the JARL’s: 35 of the 47 references are renumbered.",
+      "Award references can be renumbered in the editor — the number was the one field it would not let you correct.",
+      "The compass fills the moment Station Control opens, instead of waiting out the rest of a polling interval.",
+      "Combined amplifiers: the power level (L/M/H) is coupled too, and both amps are commanded at once so the combiner stops beeping.",
+      "Generic HTTP relay: an https:// board can be accepted with its own self-signed certificate, per board.",
+      "Club Log: the on-close upload now goes out as one batch — sending hundreds of contacts one at a time got operators blocked.",
+      "eQSL: uploads go out in batches of 100 too, and QRZ.com and HRDLog — which have no batch upload — are spaced out instead.",
+      "A spot you send now shows in your own spot list — most nodes never echo it back, so it looked like nothing had gone out.",
+      "Icom with JTDX in Fake It split: a lost PTT acknowledgement is sent again instead of failing, which made JTDX drop the rig.",
+      "A cluster whose only greeting is “login:” and which then asks for a password now connects — both prompts were being missed."
+    ],
+    "fr": [
+      "Une entité qui est un seul groupe d’îles remplit désormais la référence IOTA toute seule, sans abonnement callbook.",
+      "Le partage CAT peut désormais parler TCI au lieu de Hamlib, split compris : un logiciel TCI atteint la radio, quelle qu’elle soit.",
+      "Cache des recherches : un TTL à 0 le désactive, pour relire à chaque fois une fiche callbook en cours de correction.",
+      "Radios TCI : quand la radio interdit l’émission, le PTT le dit au lieu de ne rien faire en silence.",
+      "WAJA portait les numéros civils des préfectures japonaises et non ceux de la JARL : 35 des 47 références sont renumérotées.",
+      "Les références d’un diplôme se renumérotent dans l’éditeur : le numéro était le seul champ qu’il refusait de corriger.",
+      "La boussole se remplit dès l’ouverture de Station Control, au lieu d’attendre la fin d’un intervalle d’interrogation.",
+      "Amplis combinés : le niveau de puissance (L/M/H) est couplé lui aussi, et les deux amplis sont commandés en même temps — fini le bip du combineur.",
+      "Relais HTTP générique : une carte en https:// peut être acceptée avec son certificat auto-signé, carte par carte.",
+      "Club Log : l’envoi à la fermeture part désormais en un lot — envoyer des centaines de contacts un par un faisait bloquer l’opérateur.",
+      "eQSL : les envois partent aussi par lots de 100, et QRZ.com et HRDLog — qui n’ont pas d’envoi groupé — sont espacés à la place.",
+      "Un spot que tu envoies apparaît maintenant dans ta liste : la plupart des nœuds ne le renvoient pas, il semblait n’être jamais parti.",
+      "Icom avec JTDX en split Fake It : un accusé de réception PTT perdu est renvoyé au lieu d’échouer — JTDX lâchait le poste.",
+      "Un cluster dont tout l’accueil est « login: » puis qui réclame un mot de passe se connecte : les deux invites étaient ignorées."
+    ]
+  },
   {
     "version": "0.25.7",
     "date": "",

frontend/src/App.tsx

@@ -94,7 +94,8 @@ import { ShutdownProgress } from '@/components/ShutdownProgress';
 import { ClusterGrid } from '@/components/ClusterGrid';
 import { cleanSpotter, inferSpotMode, spotModeCategory, spotStatusKey } from '@/lib/spot';
 import { applySpotDisplay, readSpotDisplayOptions, spotIsWorked, SPOT_DISPLAY_OPTIONS_EXPOSED } from '@/lib/spotDisplay';
-import { GetRowColors, GetSpotTTLMinutes, IsNewUSCounty } from '../wailsjs/go/main/App';
+import { AnswerDecode, HaltDecodeTx, LogUIError, FlexTXOnBand, GetMatrixColors, GetRotorPresets, GetRowColors, GetSpotTTLMinutes, IsNewUSCounty } from '../wailsjs/go/main/App';
+import { applyMatrixColors } from '@/lib/matrixColors';
 import { WorkedBeforeGrid } from '@/components/WorkedBeforeGrid';
 import { NetControlPanel } from '@/components/NetControlPanel';
 import { ContestPanel, CONTEST_DEFAULT, type ContestSession } from '@/components/ContestPanel';
@@ -107,6 +108,9 @@ import { DetailsPanel, type DetailsState } from '@/components/DetailsPanel';
 import { SendSpotModal, type RecentSpotQSO } from '@/components/SendSpotModal';
 import { WinkeyerPanel, type WKStatus, type WKMacro } from '@/components/WinkeyerPanel';
 import { RotorCompass } from '@/components/RotorCompass';
+import { GridSquareMap } from '@/components/GridSquareMap';
+import { loadAutoCall, shouldAutoCall, autoCallKey, type AutoCallSettings } from '@/lib/autocall';
+import { DecodesPanel, type Decode as DecodeRow, type TxMsg as TxMsgRow } from '@/components/DecodesPanel';
 import { subscribeRotorHeading, pokeRotorHeading } from '@/lib/rotorHeading';
 import { writeUiPref } from '@/lib/uiPref';
 import { formatDateTimeUTC } from '@/lib/dateFormat';
@@ -1030,6 +1034,36 @@ export default function App() {
     setStationTabOpen(false);
     setActiveTab((t) => (t === 'station' ? 'recent' : t));
   }
+  // FTx decodes — same closable-tab pattern, but its open state is REMEMBERED:
+  // unlike Statistics, which is consulted and closed, this one is a panel an
+  // operator running digital modes leaves open for the session.
+  const [decodesTabOpen, setDecodesTabOpen] = useState(() => localStorage.getItem('opslog.decodesTab') === '1');
+  // The grid-square map is its OWN closable tab, not a column beside the decode
+  // table. It is an analysis view — consulted a few times an evening — and the
+  // space beside the table is worth far more to a second receiver's decodes when
+  // two bands are running. Full width also makes it legible, which it was not in
+  // a 38 % column.
+  const [gridsTabOpen, setGridsTabOpen] = useState(() => localStorage.getItem('opslog.gridsTab') === '1');
+  function openGridsTab() {
+    setGridsTabOpen(true);
+    writeUiPref('opslog.gridsTab', '1');
+    setActiveTab('grids');
+  }
+  function closeGridsTab() {
+    setGridsTabOpen(false);
+    writeUiPref('opslog.gridsTab', '0');
+    setActiveTab((t) => (t === 'grids' ? 'recent' : t));
+  }
+  function openDecodesTab() {
+    setDecodesTabOpen(true);
+    writeUiPref('opslog.decodesTab', '1');
+    setActiveTab('decodes');
+  }
+  function closeDecodesTab() {
+    setDecodesTabOpen(false);
+    writeUiPref('opslog.decodesTab', '0');
+    setActiveTab((t) => (t === 'decodes' ? 'recent' : t));
+  }
   // Recent QSOs row cap, persisted. With AG Grid's virtual scroller
   // huge logs render OK once loaded, but a 25k+ logbook still takes a
   // couple of seconds to round-trip from SQLite at launch. Defaulting
@@ -1640,12 +1674,12 @@ export default function App() {
   // map ("map1"), the locator street map ("map2"), the cluster grid or the
   // worked-before grid. Per-profile (stored via SetUIPref → profile-prefixed),
   // so it's loaded async on mount and re-read on profile:changed below.
-  type MainPaneKind = 'map1' | 'map2' | 'cluster' | 'worked' | 'flex' | 'recent' | 'icom' | 'yaesu' | 'netcontrol';
+  type MainPaneKind = 'map1' | 'map2' | 'cluster' | 'worked' | 'flex' | 'recent' | 'icom' | 'yaesu' | 'netcontrol' | 'decodes';
   const [mapZoomSignal, setMapZoomSignal] = useState(0); // bump → world map auto-zooms now
   const [mainPaneLeft, setMainPaneLeft] = useState<MainPaneKind>('map1');
   const [mainPaneRight, setMainPaneRight] = useState<MainPaneKind>('map2');
   const loadMainPanes = useCallback(async () => {
-    const valid = (v: string): v is MainPaneKind => v === 'map1' || v === 'map2' || v === 'cluster' || v === 'worked' || v === 'flex' || v === 'recent' || v === 'icom' || v === 'yaesu' || v === 'netcontrol';
+    const valid = (v: string): v is MainPaneKind => v === 'map1' || v === 'map2' || v === 'cluster' || v === 'worked' || v === 'flex' || v === 'recent' || v === 'icom' || v === 'yaesu' || v === 'netcontrol' || v === 'decodes';
     const [l, r] = await Promise.all([
       GetUIPref('mainPaneLeft').catch(() => ''),
       GetUIPref('mainPaneRight').catch(() => ''),
@@ -1684,6 +1718,10 @@ export default function App() {
   // a stale closure.
   const spotsRef = useRef(spots);
   useEffect(() => { spotsRef.current = spots; }, [spots]);
+  // The decoded stations, for the same reason: the status refresh and the cache
+  // prune below both need them, and neither may re-subscribe every time a decode
+  // lands. Filled by an effect next to the `decodes` state further down.
+  const decodesRef = useRef<DecodeRow[]>([]);
   // 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
@@ -1695,10 +1733,16 @@ export default function App() {
       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)));
+      // Decoded stations count as live too. They share this cache, and pruning
+      // to the cluster spots alone would evict every one of them — on a busy
+      // band the decodes are what push the cache past the cap in the first
+      // place, so the panel would blank its own badges the moment it filled up.
+      for (const d of decodesRef.current) live.add(`${d.call}|${d.band ?? ''}|${(d.mode ?? '').toUpperCase()}`);
       const pruned: typeof prev = {};
       for (const k of keys) if (live.has(k)) pruned[k] = prev[k];
       return pruned;
     });
+    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [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
@@ -1707,7 +1751,6 @@ export default function App() {
   // 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; spotter: string }[] = [];
     const seen = new Set<string>();
     for (const s of cur) {
@@ -1716,6 +1759,19 @@ export default function App() {
       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 ?? '', spotter: s.spotter ?? '' });
     }
+    // The decoded stations as well. Their verdict is resolved once when the
+    // decode arrives and then cached for ever, so a station worked five minutes
+    // ago went on wearing its NEW SLOT badge for the rest of the half hour it
+    // stays in the list — reported on an EY35S already in the log. Deduplicated
+    // by call+band+mode, so half an hour of a busy band is a few hundred
+    // queries, and the backend answers a whole batch with one pass of the log.
+    for (const d of decodesRef.current) {
+      const mode = (d.mode ?? '').toUpperCase();
+      const k = `${d.call}|${d.band ?? ''}|${mode}`;
+      if (seen.has(k)) continue;
+      seen.add(k);
+      queries.push({ call: d.call, band: d.band ?? '', mode, pota_ref: '', spotter: '' });
+    }
     if (!queries.length) return;
     try {
       const res = await ClusterSpotStatuses(queries as any);
@@ -1748,7 +1804,8 @@ export default function App() {
   const spotsDirtyRef = useRef(false);
   useEffect(() => {
     const vis = mainPaneLeft === 'cluster' || mainPaneRight === 'cluster'
-      || activeTab === 'cluster' || activeTab === 'bandmap' || showBandMap;
+      || mainPaneLeft === 'decodes' || mainPaneRight === 'decodes'
+      || activeTab === 'cluster' || activeTab === 'bandmap' || activeTab === 'decodes' || showBandMap;
     if (vis && !spotsVisibleRef.current && spotsDirtyRef.current) {
       spotsDirtyRef.current = false;
       void refreshSpotStatuses();
@@ -1789,6 +1846,7 @@ export default function App() {
   const [showSettings, setShowSettings] = useState(false);
   // Re-read the "beam on map" toggle when Preferences closes (it's edited there).
   useEffect(() => { if (!showSettings) setShowBeamOnMap(localStorage.getItem('opslog.showBeamOnMap') !== '0'); }, [showSettings]);
+  useEffect(() => { if (!showSettings) setRotorCompact(localStorage.getItem('opslog.rotorCompact') === '1'); }, [showSettings]);
   // Openings under way, for the blinking status-bar badge. Polled rather than
   // event-driven: the badge also has to go OUT when a band goes quiet, and
   // nothing emits an event for something that stopped happening.
@@ -2017,6 +2075,126 @@ export default function App() {
   // settings dialog closes, which is the only place it changes.
   const [rowColors, setRowColors] = useState<any>(null);
   useEffect(() => { GetRowColors().then(setRowColors).catch(() => {}); }, [showSettings]);
+  // ── FTx decodes from the inbound UDP feed ──────────────────────────
+  //
+  // Held in the frontend, like the cluster spots: they are a live view, not
+  // data, and nothing outside this panel reads them. Pruned to a rolling
+  // half hour — long enough to hold a whole opening, short enough that a night
+  // of FT8 on 20 m does not turn the list into something no filter can rescue.
+  const DECODE_KEEP_MS = 30 * 60 * 1000;
+  const [decodes, setDecodes] = useState<DecodeRow[]>([]);
+  const [txMsgs, setTxMsgs] = useState<TxMsgRow[]>([]);
+  // The LIVE transmit state, replaced on every Status — what is going out now
+  // and to whom, which the period history cannot answer between overs.
+  const [txState, setTxState] = useState<TxMsgRow | null>(null);
+  // The same, per receiver. With two instances the single txState is whichever
+  // one reported last, so a split view cannot say WHICH is on the air — which is
+  // the only question worth asking when both are calling.
+  const [txStates, setTxStates] = useState<Record<string, TxMsgRow>>({});
+  useEffect(() => { decodesRef.current = decodes; }, [decodes]);
+
+  // ── Auto-call ──────────────────────────────────────────────────────
+  //
+  // Answers a decode without the operator clicking it. The DECISION lives in
+  // lib/autocall (one pure function, so the dangerous part can be read and
+  // argued with); this is only the plumbing that runs it and keys the radio.
+  //
+  // Re-read when Preferences closes, like every other setting edited there.
+  const [autoCall, setAutoCall] = useState<AutoCallSettings>(loadAutoCall);
+  useEffect(() => { if (!showSettings) setAutoCall(loadAutoCall()); }, [showSettings]);
+  // When each callsign was last answered, so a station still calling CQ is not
+  // re-answered every slot while the QSO it started is still running.
+  const autoCalledRef = useRef<Map<string, number>>(new Map());
+  // Decodes are scanned once. Without this the same decode is reconsidered on
+  // every status refresh, and a cooldown that has just expired would fire again
+  // on a decode minutes old.
+  const autoSeenRef = useRef<Set<string>>(new Set());
+  // Set when a call goes out, so nothing else fires until the receiver's own
+  // status catches up and `busy` can be trusted again.
+  const autoHoldUntilRef = useRef(0);
+  // Per receiver, when the carrier was last up. Feeds the stale-exchange
+  // backstop below.
+  const lastTxAtRef = useRef<Map<string, number>>(new Map());
+  useEffect(() => {
+    if (!autoCall.enabled) return;
+    const now = Date.now();
+    // A QSO is in progress somewhere if ANY receiver is transmitting or still
+    // holding a DX call it has not finished with. Both matter: between overs the
+    // carrier is down but the exchange is not over, and calling someone else
+    // then is exactly the "it never stops" behaviour.
+    const busy = Object.values(txStates).some((tx) => {
+      if (tx?.transmitting) return true;
+      // A DX call still set means the exchange is not finished — but ONLY while
+      // the sender still intends to transmit. The watchdog stops transmission
+      // and leaves the DX call behind, and reading the call alone left auto-call
+      // waiting for a QSO that had already been given up on, for ever.
+      if (!tx?.dx_call?.trim()) return false;
+      if (tx.tx_enabled === false) return false;
+      // Backstop for a sender that never reports the toggle: an exchange with no
+      // transmission for three minutes is over, whatever the DX call still says.
+      // Measured from the last TIME THE CARRIER WAS UP — Status itself arrives
+      // every second and so can never go stale.
+      const last = lastTxAtRef.current.get(tx.instance ?? '');
+      return last === undefined || now - last < 180_000;
+    })
+      // The hold closes the gap between sending a Reply and the receiver saying
+      // it has acted on it — about a second. Without it the OTHER instance still
+      // looks idle in that window and gets a call of its own.
+      || now < autoHoldUntilRef.current;
+    for (const d of decodes) {
+      const seenKey = `${d.call}|${d.ms ?? d.at}|${d.instance ?? ''}`;
+      if (autoSeenRef.current.has(seenKey)) continue;
+      // Only decodes from the CURRENT period are worth answering: replying to a
+      // slot that has closed asks the far end to match a decode it has dropped.
+      if (now - Date.parse(d.at) > 30_000) { autoSeenRef.current.add(seenKey); continue; }
+      const e = spotStatus[`${d.call}|${d.band ?? ''}|${(d.mode ?? '').toUpperCase()}`];
+      // NOT marked seen until its status has resolved. Statuses land a few
+      // hundred milliseconds after the decode, so consuming it on first sight
+      // would throw away almost every decode unjudged — the effect re-runs when
+      // spotStatus changes, and this is what lets it look again.
+      if (!e) continue;
+      autoSeenRef.current.add(seenKey);
+      const verdict = shouldAutoCall(autoCall, d, e as any, {
+        busy,
+        calledAt: autoCalledRef.current,
+        now,
+        myCall: station.callsign,
+      });
+      if (!verdict.call) continue;
+      autoCalledRef.current.set(d.call.toUpperCase(), now);
+      autoHoldUntilRef.current = now + 12_000; // an FT8 slot, near enough
+      // Same reason as a manual click: put the transmitter on the decode's band
+      // before answering, or a second slice answers on the wrong one.
+      FlexTXOnBand(d.band ?? '').catch(() => {});
+      // Logged, always: an automatic transmission with no record of WHY is the
+      // one thing an operator cannot argue with after the fact.
+      LogUIError('auto-call', `calling ${d.call} — ${verdict.reason}`, '');
+      AnswerDecode(
+        d.instance ?? '', d.ms ?? 0, d.snr, d.dt ?? 0,
+        d.audio_hz ?? 0, d.mode_raw || d.mode || '', d.msg_raw ?? d.msg ?? '', !!d.low_conf,
+      ).catch((e2: any) => setError(String(e2?.message ?? e2)));
+      onCallsignInput(d.call, { force: true });
+      break; // one per pass: a period can hold several, and we work one station
+    }
+    // The seen-set is bounded by the same half hour the decode list keeps.
+    if (autoSeenRef.current.size > 20000) autoSeenRef.current.clear();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [decodes, spotStatus, autoCall, txStates]);
+  // Staged like the cluster's, so a period arriving as one burst of fifty
+  // packets costs one status lookup and one render, not fifty of each.
+  const pendingDecodesRef = useRef<DecodeRow[]>([]);
+  const pendingDecodeTimer = useRef<number | undefined>(undefined);
+
+  // Rotor quick-turn buttons (Settings → Rotator). Same reload trigger as the
+  // row colours: the settings dialog is the only place they change.
+  const [rotorPresets, setRotorPresets] = useState<{ label: string; azimuth: number }[]>([]);
+  useEffect(() => { GetRotorPresets().then((p) => setRotorPresets((p ?? []) as any)).catch(() => {}); }, [showSettings]);
+  // Band/mode matrix palette overrides (Settings → Appearance). Stamped onto
+  // <html> rather than held in state: the matrix reads CSS custom properties, so
+  // nothing re-renders and no component has to be told about the colours. Same
+  // reload trigger as the row colours — the settings dialog is where they change,
+  // and the panel already previews live while it is open.
+  useEffect(() => { GetMatrixColors().then((c) => applyMatrixColors(c as any)).catch(() => {}); }, [showSettings]);
   // Spot lifetime (Settings → DX Cluster). Spots are actually REMOVED rather
   // than filtered at render: the cluster list, every band map and the counts all
   // read the same array, so pruning it once is what makes the setting mean the
@@ -2146,6 +2324,11 @@ export default function App() {
   const refreshChaseNew = useCallback(() => { GetChaseNew().then(setChaseNewOn).catch(() => {}); }, []);
   useEffect(() => { refreshChaseNew(); }, [refreshChaseNew]);
   const [showBeamOnMap, setShowBeamOnMap] = useState(() => localStorage.getItem('opslog.showBeamOnMap') !== '0');
+  // Compact rotor widget (Settings → Rotator): dial + SP/LP only. RotorCompass
+  // already draws exactly that when it is given neither presets nor onStop —
+  // withholding them IS the compact mode, so there is no second layout to keep
+  // in step with the first.
+  const [rotorCompact, setRotorCompact] = useState(() => localStorage.getItem('opslog.rotorCompact') === '1');
 
   // Award code → scanned field (e.g. POTA→pota_ref, WWFF→wwff). Used to route
   // picked award references to the QSO field/extras each award actually reads.
@@ -2999,6 +3182,97 @@ export default function App() {
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 
+  // ── FTx decodes ────────────────────────────────────────────────────
+  useEffect(() => {
+    // Resolve the new-entity / new-slot flags into the SAME map the cluster
+    // fills. One cache, one verdict: a call must not be "new band" in the
+    // decodes panel and plain worked in the cluster list two seconds later.
+    const flushDecodes = async () => {
+      pendingDecodeTimer.current = undefined;
+      const batch = pendingDecodesRef.current;
+      pendingDecodesRef.current = [];
+      if (batch.length === 0) return;
+      try {
+        const known = spotStatusRef.current;
+        const seen = new Set<string>();
+        const unknown: { call: string; band: string; mode: string; pota_ref: string; spotter: string }[] = [];
+        for (const d of batch) {
+          const k = `${d.call}|${d.band ?? ''}|${(d.mode ?? '').toUpperCase()}`;
+          if (seen.has(k) || known[k]) continue;
+          seen.add(k);
+          unknown.push({ call: d.call, band: d.band ?? '', mode: (d.mode ?? '').toUpperCase(), pota_ref: '', spotter: '' });
+        }
+        if (unknown.length > 0) {
+          const res = await ClusterSpotStatuses(unknown 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,
+                worked_slot: !!(r as any).worked_slot,
+                new_county: !!(r as any).new_county, lotw: !!(r as any).lotw,
+                grid: (r as any).grid, new_grid: !!(r as any).new_grid,
+                county: (r as any).county, state: (r as any).state,
+                new_pota: !!(r as any).new_pota,
+                new_pfx: !!(r as any).new_pfx, pfx: (r as any).pfx,
+              };
+            }
+            return next;
+          });
+        }
+      } catch { /* status unresolved — the decode still shows, just unflagged */ }
+      setDecodes((arr) => {
+        const cutoff = Date.now() - DECODE_KEEP_MS;
+        const next = [...arr, ...batch].filter((d) => Date.parse(d.at) >= cutoff);
+        return next;
+      });
+    };
+
+    const unsubDecode = EventsOn('udp:decode', (d: DecodeRow) => {
+      pendingDecodesRef.current.push(d);
+      if (pendingDecodeTimer.current === undefined) {
+        pendingDecodeTimer.current = window.setTimeout(flushDecodes, 300);
+      }
+    });
+
+    // The operator's own transmission. Status repeats it about once a second
+    // for the whole over, so it is recorded ONCE per message: the panel wants
+    // "I sent this in that period", not sixty copies of it.
+    const unsubTx = EventsOn('udp:tx_state', (m: any) => {
+      // The live strip takes every Status: it has to say who is being called
+      // even between overs, and on a sender that never reports its transmit
+      // text at all.
+      setTxState(m as TxMsgRow);
+      if (m?.instance) {
+        setTxStates((prev) => ({ ...prev, [m.instance]: m as TxMsgRow }));
+        // When this receiver last actually TRANSMITTED, which is not the same as
+        // when it last spoke: Status arrives about once a second whether the
+        // carrier is up or not, so it can never say how long an exchange has
+        // been stalled.
+        if (m.transmitting) lastTxAtRef.current.set(m.instance, Date.now());
+      }
+      // The period history takes only real transmissions — Status repeats
+      // itself once a second whether the carrier is up or not.
+      if (!m?.transmitting || !String(m?.msg ?? '').trim()) return;
+      setTxMsgs((arr) => {
+        const last = arr[arr.length - 1];
+        if (last && last.msg === m.msg && Date.parse(m.at) - Date.parse(last.at) < 30_000) return arr;
+        const cutoff = Date.now() - DECODE_KEEP_MS;
+        return [...arr, m as TxMsgRow].filter((x) => Date.parse(x.at) >= cutoff);
+      });
+    });
+
+    return () => {
+      unsubDecode?.(); unsubTx?.();
+      if (pendingDecodeTimer.current !== undefined) window.clearTimeout(pendingDecodeTimer.current);
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
   // ── UDP integration events ───────────────────────────────────────────
   // Live updates from external apps (WSJT-X / JTDX / MSHV / DXHunter…).
   // We push the broadcast DX call into the entry field and auto-log any
@@ -4162,6 +4436,8 @@ export default function App() {
       { type: 'item', label: t('tools.qslManager'), action: 'tools.qslmanager' },
       { type: 'item', label: t('stats.tab'), action: 'tools.stats' },
       { type: 'item', label: t('station.title'), action: 'tools.station' },
+      { type: 'item', label: t('dec.tab'), action: 'tools.decodes' },
+      { type: 'item', label: t('gsm.title'), action: 'tools.grids' },
       { type: 'item', label: t('tools.qslDesigner'), action: 'tools.qsldesigner' },
       { type: 'separator' },
       { type: 'item', label: (wkEnabled ? '✓ ' : '') + t('tools.winkeyer'), action: 'tools.winkeyer' },
@@ -4211,6 +4487,8 @@ export default function App() {
       case 'tools.qslmanager':  setQslTabOpen(true); setActiveTab('qsl'); break;
       case 'tools.stats':       setStatsTabOpen(true); setActiveTab('stats'); break;
       case 'tools.station':     setStationTabOpen(true); setActiveTab('station'); break;
+      case 'tools.decodes':     openDecodesTab(); break;
+      case 'tools.grids':       openGridsTab(); break;
       case 'tools.qsldesigner': setQslDesignerOpen(true); break;
       case 'tools.winkeyer':    wkSetEnabled(!wkEnabled); break;
       case 'tools.dvk':         setDvkEnabled((v) => !v); break;
@@ -5040,18 +5318,26 @@ export default function App() {
           || (!!e?.new_grid && clusterStatusFilter.has('new-grid'));
         if (!matches) return false;
       }
-      // LoTW only, and the spotter's continent. Both are properties of the
+      // The spotter's continent comes from the SPOT, never from spotStatus.
-      // station rather than judgements about the spot, so they AND with the
+      // spotStatus is keyed by call|band|mode, and one DX call is spotted by
-      // status chips instead of joining that OR: "a new band, and from Europe".
+      // skimmers on every continent within the same minute — so they all shared
-      if (clusterLotwOnly || clusterSpotterConts.size > 0) {
+      // whichever spotter arrived first, and picking AF left the Indian and
+      // American skimmers exactly where they were. The spot carries its own.
+      //
+      // A spot whose spotter could not be resolved IS dropped here: the value
+      // arrives with the row, so there is no window to flicker through, and
+      // silently keeping unresolved rows is what made the old bug invisible.
+      if (clusterSpotterConts.size > 0) {
+        if (!clusterSpotterConts.has((s as any).spotter_continent ?? '')) return false;
+      }
+      // LoTW is a property of the DX station, so it stays on the status entry —
+      // where call|band|mode is exactly the right key.
+      if (clusterLotwOnly) {
         const k = spotStatusKey(s.dx_call, s.band ?? '', s.comment ?? '', s.freq_hz);
         const e = spotStatus[k];
         // An unresolved spot is not filtered out. The status arrives a moment
         // after the row does, and dropping it meanwhile made the list flicker.
-        if (e) {
+        if (e && !e.lotw) return false;
-          if (clusterLotwOnly && !e.lotw) return false;
-          if (clusterSpotterConts.size > 0 && e.spotter_continent && !clusterSpotterConts.has(e.spotter_continent)) return false;
-        }
       }
       if (clusterHideWorked) {
         const k = spotStatusKey(s.dx_call, s.band ?? '', s.comment ?? '', s.freq_hz);
@@ -5295,6 +5581,74 @@ export default function App() {
     </button>
   );
 
+  // The FT decodes panel, built in ONE place: it is offered both as a tab and as
+  // a Main-view pane, and two copies of this call would be two sets of props to
+  // keep in step.
+  const renderDecodesPanel = () => (
+    <DecodesPanel
+      decodes={decodes}
+      txMsgs={txMsgs}
+      txState={txState}
+      txStates={txStates}
+      autoCallOn={autoCall.enabled}
+      // Written through the same key Preferences uses, so the two can never
+      // disagree about whether the machine is armed.
+      onToggleAutoCall={() => setAutoCall((prev) => {
+        const next = { ...prev, enabled: !prev.enabled };
+        writeUiPref(autoCallKey, JSON.stringify(next));
+        return next;
+      })}
+      spotStatus={spotStatus as any}
+      myCall={station.callsign}
+      // A click ANSWERS the station: it hands the decode back to WSJT-X/MSHV as
+      // a Reply, which is the same thing as double-clicking the line in their
+      // own window.
+      //
+      // Deliberately NOT a rig tune, unlike a cluster spot. On FT8 the whole
+      // band is inside one passband, so moving the dial changes nothing about
+      // who gets answered — and it would only fight the digital application
+      // for the VFO. The entry is still filled, so the QSO can be logged here.
+      onCall={(d) => {
+        onCallsignInput(d.call, { force: true });
+        // With two slices on two bands, the Reply reaches the right INSTANCE but
+        // the radio still transmits on whichever slice holds the TX flag. Move
+        // it to the decode's band first, or an 80 m answer goes out on 20 m.
+        // A no-op on any backend without slices.
+        FlexTXOnBand(d.band ?? '').catch(() => { /* not a Flex, or no such slice */ });
+        AnswerDecode(
+          d.instance ?? '', d.ms ?? 0, d.snr, d.dt ?? 0,
+          // The RAW mode marker, not the resolved name: the receiving
+          // application matches the Reply against its decode list field for
+          // field, and JTDX drops one that says "FT8" where it decoded "~".
+          d.audio_hz ?? 0, d.mode_raw || d.mode || '', d.msg_raw ?? d.msg ?? '', !!d.low_conf,
+        ).catch((e: any) => setError(String(e?.message ?? e)));
+      }}
+      // Wipes the live view only — nothing here is stored, and the staging
+      // buffer goes too or the next flush would put back what was just cleared.
+      onClear={(instance) => {
+        if (!instance) {
+          pendingDecodesRef.current = [];
+          setDecodes([]);
+          setTxMsgs([]);
+          setTxState(null);
+          setTxStates({});
+          return;
+        }
+        // One receiver only: the other pane keeps everything it was showing,
+        // which is the whole reason for clearing just one.
+        pendingDecodesRef.current = pendingDecodesRef.current.filter((d) => (d.instance ?? '') !== instance);
+        setDecodes((a) => a.filter((d) => (d.instance ?? '') !== instance));
+        setTxMsgs((a) => a.filter((m) => (m.instance ?? '') !== instance));
+        setTxStates((prev) => { const n = { ...prev }; delete n[instance]; return n; });
+      }}
+      // An empty instance lets the backend fall back to whichever application
+      // last reported its status — the normal single-receiver case.
+      onHalt={(instance) => {
+        HaltDecodeTx(instance, false).catch((e: any) => setError(String(e?.message ?? e)));
+      }}
+    />
+  );
+
   // Render one Main-view pane. The two sides (mainPaneLeft/Right) each pick from
   // the same four choices, configured per-profile in Settings → Main view.
   const renderMainPane = (kind: MainPaneKind) => {
@@ -5313,6 +5667,14 @@ export default function App() {
         );
       case 'map2':
         return <LocatorMap toGrid={grid} toLabel={callsign} />;
+      case 'decodes':
+        // Same panel as the tab, in a pane. It brings its own filter bar and
+        // column header, so it needs no frame of its own here.
+        return (
+          <div className="h-full w-full min-h-0 flex flex-col bg-card border border-border rounded-lg overflow-hidden">
+            {renderDecodesPanel()}
+          </div>
+        );
       case 'cluster':
         return (
           <div className="h-full w-full min-h-0 flex flex-col bg-card border border-border rounded-lg overflow-hidden">
@@ -6301,10 +6663,14 @@ export default function App() {
             </div>
           )}
           {/* Rotor compass: azimuth dial + needles + click-to-turn. Shows when a
-              rotator is configured or a DX bearing exists. */}
+              rotator is configured or a DX bearing exists. Compact mode drops the
+              controls column, so the widget is just the dial and needs only its
+              width. */}
           {showRotor && (rotatorHeading.enabled || dxPath) && (
-            <div className="w-[186px] shrink-0 min-h-0">
+            <div className={cn('shrink-0 min-h-0', rotorCompact ? 'w-[196px]' : 'w-[320px]')}>
               <RotorCompass
+                presets={rotorCompact ? undefined : rotorPresets}
+                onStop={rotorCompact ? undefined : () => { RotatorStop().then(pokeRotorHeading).catch((err) => setError(String(err?.message ?? err))); }}
                 bearing={dxPath?.bearingShort ?? null}
                 headings={beamHeadings}
                 boomHeading={boomHeading}
@@ -6583,6 +6949,39 @@ export default function App() {
                   </span>
                 </TabsTrigger>
               )}
+              {gridsTabOpen && (
+                <TabsTrigger value="grids" className="gap-1.5">
+                  {t('gsm.title')}
+                  <span
+                    role="button"
+                    aria-label="Close grid squares"
+                    title="Close"
+                    className="inline-flex items-center justify-center size-4 rounded hover:bg-foreground/10 text-muted-foreground hover:text-foreground"
+                    onPointerDown={(e) => { e.stopPropagation(); }}
+                    onClick={(e) => { e.stopPropagation(); closeGridsTab(); }}
+                  >
+                    <X className="size-3" />
+                  </span>
+                </TabsTrigger>
+              )}
+              {decodesTabOpen && (
+                <TabsTrigger value="decodes" className="gap-1.5">
+                  {t('dec.tab')}
+                  {decodes.length > 0 && (
+                    <span className="text-[10px] tabular-nums text-muted-foreground">{decodes.length}</span>
+                  )}
+                  <span
+                    role="button"
+                    aria-label="Close FT decodes"
+                    title="Close"
+                    className="inline-flex items-center justify-center size-4 rounded hover:bg-foreground/10 text-muted-foreground hover:text-foreground"
+                    onPointerDown={(e) => { e.stopPropagation(); }}
+                    onClick={(e) => { e.stopPropagation(); closeDecodesTab(); }}
+                  >
+                    <X className="size-3" />
+                  </span>
+                </TabsTrigger>
+              )}
               {stationTabOpen && (
                 <TabsTrigger value="station" className="gap-1.5">
                   {t('station.title')}
@@ -6624,7 +7023,8 @@ export default function App() {
                 <div className="relative flex-1">
                   <Input
                     className="w-full pr-8 font-mono"
-                    placeholder="Search callsign…"
+                    placeholder={t('rq.searchPh')}
+                    title={t('rq.searchTip')}
                     value={filterCallsign}
                     onChange={(e) => setFilterCallsign(e.target.value.toUpperCase())}
                   />
@@ -6993,7 +7393,26 @@ export default function App() {
                 updating) while you work on other tabs. */}
             {qslTabOpen && (
               <TabsContent value="qsl" forceMount className="mt-0 flex flex-col min-h-0 flex-1 data-[state=inactive]:hidden">
-                <QSLManagerPanel onEditQSO={openEdit} />
+                <QSLManagerPanel
+                  onEditQSO={openEdit}
+                  // The same row actions the Recent QSOs grid offers. Only the
+                  // selection-based exports: exporting "the filter" would mean
+                  // the Recent-QSOs filter, not the rows shown here.
+                  actions={{
+                    onUpdateFromCty: bulkUpdateFromCty,
+                    onUpdateFromQRZ: bulkUpdateFromQRZ,
+                    onUpdateFromClublog: bulkUpdateFromClublog,
+                    onUpdateCountyFromULS: ulsReady ? bulkUpdateCountyFromULS : undefined,
+                    onSendTo: bulkSendTo,
+                    onSendRecording: bulkSendRecording,
+                    onSendEQSL: (ids) => setEqslQsoId(ids[0] ?? null),
+                    onBulkEdit: openBulkEdit,
+                    onExportSelected: exportSelectedADIF,
+                    onExportSelectedFields: exportSelectedFields,
+                    onExportCabrilloSelected: exportSelectedCabrillo,
+                    onDelete: (ids) => setDeletingIds(ids),
+                  }}
+                />
               </TabsContent>
             )}
 
@@ -7032,6 +7451,18 @@ export default function App() {
               </TabsContent>
             )}
 
+            {gridsTabOpen && (
+              <TabsContent value="grids" className="mt-0 flex flex-col min-h-0 flex-1 data-[state=inactive]:hidden">
+                <GridSquareMap myGrid={station.my_grid} className="flex-1 min-h-0" />
+              </TabsContent>
+            )}
+
+            {decodesTabOpen && (
+              <TabsContent value="decodes" className="mt-0 flex flex-col min-h-0 flex-1 data-[state=inactive]:hidden">
+                {renderDecodesPanel()}
+              </TabsContent>
+            )}
+
             {stationTabOpen && (
               <TabsContent value="station" className="mt-0 flex flex-col min-h-0 flex-1 data-[state=inactive]:hidden">
                 <StationControlPanel

frontend/src/components/AppearancePanel.tsx

@@ -1,9 +1,13 @@
 import { useEffect, useState } from 'react';
-import { GetRowColors, SaveRowColors } from '../../wailsjs/go/main/App';
+import { GetMatrixColors, GetRowColors, SaveMatrixColors, SaveRowColors } from '../../wailsjs/go/main/App';
 import { Checkbox } from '@/components/ui/checkbox';
 import { useI18n } from '@/lib/i18n';
 import { cn } from '@/lib/utils';
 import type { RowColorSettings } from '@/lib/rowColors';
+import {
+  MATRIX_VARS, applyMatrixColors, effectiveMatrixColor, emptyMatrixColors,
+  type MatrixColors,
+} from '@/lib/matrixColors';
 
 // A fixed palette plus a free picker. Muted values on purpose: they are
 // composited at low opacity over a dark grid, where a saturated colour reads as
@@ -30,6 +34,111 @@ const CHANNEL_LABELS: Record<string, string> = {
   qsl: 'appr.chQsl', lotw: 'LoTW', eqsl: 'eQSL', qrz: 'QRZ.com',
 };
 
+// MatrixColorsSection recolours the band/mode matrix — the PH/CW/DIG grid in the
+// Stats panel.
+//
+// The pickers are seeded from what the matrix is painting RIGHT NOW (the active
+// theme's ramp, or an existing override), not from a fixed palette: the operator
+// starts from the colours in front of them and moves one, instead of being
+// handed six values that may belong to a theme they stopped using. Every change
+// is applied to the live document at once, so the sample row below is the real
+// thing rather than a mock-up of it.
+function MatrixColorsSection() {
+  const { t } = useI18n();
+  const [cfg, setCfg] = useState<MatrixColors | null>(null);
+
+  useEffect(() => {
+    (async () => {
+      try {
+        setCfg((await GetMatrixColors()) as any);
+      } catch {
+        setCfg(emptyMatrixColors());
+      }
+    })();
+  }, []);
+
+  const save = (next: MatrixColors) => {
+    setCfg(next);
+    applyMatrixColors(next); // live, before the round trip — the panel must not lag the choice
+    SaveMatrixColors(next as any).catch(() => {});
+  };
+
+  // Turning it ON with nothing stored would change nothing at all and read as a
+  // broken switch, so the empty slots are filled from the theme's current ramp:
+  // the operator sees six swatches that match the grid and edits from there.
+  const enable = (on: boolean) => {
+    if (!cfg) return;
+    if (!on) {
+      save({ ...cfg, enabled: false });
+      return;
+    }
+    const seeded = { ...cfg, enabled: true };
+    for (const { key, cssVar } of MATRIX_VARS) {
+      if (!String(seeded[key] ?? '').trim()) seeded[key] = effectiveMatrixColor(cssVar);
+    }
+    save(seeded);
+  };
+
+  // Reset clears the overrides but keeps the section switched on, then re-seeds
+  // from the theme — "back to the theme's colours", which is what an operator
+  // means by reset here, rather than "switch the whole feature off".
+  const reset = () => {
+    if (!cfg) return;
+    applyMatrixColors({ ...emptyMatrixColors(), enabled: false });
+    const seeded = { ...emptyMatrixColors(), enabled: true };
+    for (const { key, cssVar } of MATRIX_VARS) seeded[key] = effectiveMatrixColor(cssVar);
+    save(seeded);
+  };
+
+  if (!cfg) return null;
+
+  return (
+    <div className="space-y-3 border-t border-border/60 pt-4">
+      <label className="flex items-start gap-2 text-sm cursor-pointer">
+        <Checkbox checked={cfg.enabled} className="mt-0.5" onCheckedChange={(c) => enable(!!c)} />
+        <span>
+          {t('appr.matrixEnable')}{' '}
+          <span className="text-xs text-muted-foreground">{t('appr.matrixHint')}</span>
+        </span>
+      </label>
+
+      {cfg.enabled && (
+        <div className="space-y-3">
+          <div className="grid grid-cols-2 gap-x-4 gap-y-2">
+            {MATRIX_VARS.map(({ key, cssVar, label }) => (
+              <label key={key} className="flex items-center gap-2 text-sm cursor-pointer">
+                <input
+                  type="color"
+                  value={String(cfg[key] || '').trim() || effectiveMatrixColor(cssVar)}
+                  onChange={(e) => save({ ...cfg, [key]: e.target.value })}
+                  className="size-6 rounded-md border border-border bg-transparent p-0 cursor-pointer shrink-0"
+                />
+                {t(label)}
+              </label>
+            ))}
+          </div>
+
+          {/* The matrix as it will actually look: same tokens, same shapes. */}
+          <div className="flex items-center gap-1.5">
+            <span className="text-xs text-muted-foreground w-10 shrink-0">{t('appr.matrixSample')}</span>
+            <span className="inline-block w-7 h-5 rounded bg-mx-call-conf" />
+            <span className="inline-block w-7 h-5 rounded bg-mx-call-work" />
+            <span className="inline-block w-7 h-5 rounded bg-mx-dx-conf" />
+            <span className="inline-block w-7 h-5 rounded bg-mx-dx-work" />
+            <span className="inline-block w-7 h-5 rounded bg-mx-none" />
+            <span className="inline-block w-7 h-5 rounded bg-mx-none ring-2 ring-mx-cur ring-inset" />
+          </div>
+
+          <button type="button" onClick={reset}
+            className="text-xs text-muted-foreground underline underline-offset-2 hover:text-foreground">
+            {t('appr.matrixReset')}
+          </button>
+        </div>
+      )}
+    </div>
+  );
+}
+
 export function AppearancePanel() {
   const { t } = useI18n();
   const [cfg, setCfg] = useState<RowColorSettings | null>(null);
@@ -148,6 +257,8 @@ export function AppearancePanel() {
           ))}
         </div>
       )}
+
+      <MatrixColorsSection />
     </div>
   );
 }

frontend/src/components/AwardEditor.tsx

@@ -14,7 +14,7 @@ import { useI18n } from '@/lib/i18n';
 import {
   GetAwardDefs, SaveAwardDefs, ResetAwardDefs, AwardFields,
   GetAwardReferenceMeta, UpdateAwardReferenceList,
-  ListAwardReferences, SearchAwardReferences, SaveAwardReference, DeleteAwardReference,
+  ListAwardReferences, SearchAwardReferences, SaveAwardReference, DeleteAwardReference, RenameAwardReference,
   ImportAwardReferencesText, GetAwardPresets, ApplyAwardPreset,
   ListCountries, DXCCForCountry, DXCCName,
   PopulateBuiltinReferences, HasBuiltinReferences,
@@ -915,6 +915,10 @@ function ReferencesPanel({ code, presets, meta, awardValidFrom, awardValidTo, on
   const [refs, setRefs] = useState<AwardRef[]>([]);
   const [q, setQ] = useState('');
   const [selCode, setSelCode] = useState<string | null>(null);
+  // The code as TYPED. The list and every patch key off selCode, so editing the
+  // code in place would make the editor lose the reference mid-edit; the draft
+  // is applied as a rename when the operator saves.
+  const [codeDraft, setCodeDraft] = useState('');
   const [busy, setBusy] = useState(false);
   const [bulk, setBulk] = useState('');
   const [showBulk, setShowBulk] = useState(false);
@@ -952,6 +956,7 @@ function ReferencesPanel({ code, presets, meta, awardValidFrom, awardValidTo, on
   }
 
   const sel = refs.find((r) => r.code === selCode) || null;
+  useEffect(() => { setCodeDraft(selCode ?? ''); }, [selCode]);
   // Large lists are already filtered by the server; small lists filter locally.
   const filtered = useMemo(() => {
     if (large) return refs;
@@ -965,6 +970,27 @@ function ReferencesPanel({ code, presets, meta, awardValidFrom, awardValidTo, on
     try { await SaveAwardReference(code, r as any); load(); onChanged(); }
     catch (e: any) { setErr(String(e?.message ?? e)); }
   }
+  // Save the selected reference, renumbering it first when the code was edited.
+  //
+  // The rename has to come first and has to be a rename: saving under the new
+  // code would simply create a second reference and leave the old one behind,
+  // which is how a list quietly grows duplicates.
+  async function saveSelected(r: AwardRef) {
+    const next = codeDraft.trim().toUpperCase();
+    if (!next) { setErr(t('awed.refCodeEmpty')); return; }
+    if (next !== r.code) {
+      try {
+        await RenameAwardReference(code, r.code, next);
+      } catch (e: any) {
+        // Most often the number is already taken by another reference. Said
+        // here rather than swallowed: the save has NOT happened.
+        setErr(String(e?.message ?? e));
+        return;
+      }
+      setSelCode(next);
+    }
+    await saveRef({ ...r, code: next });
+  }
   async function addRef() {
     const c = prompt(t('awed.newRefCodePrompt'))?.trim().toUpperCase();
     if (!c) return;
@@ -1046,7 +1072,13 @@ function ReferencesPanel({ code, presets, meta, awardValidFrom, awardValidTo, on
           ) : (
             <div className="space-y-2">
               <div className="flex items-center gap-2">
-                <Input className="h-8 w-28 font-mono font-semibold" value={sel.code} readOnly />
+                {/* Editable, because a shipped list can be wrong about it: WAJA
+                    went out carrying Japan's civil prefecture numbers instead of
+                    the JARL's, and correcting that meant deleting all 47
+                    references and importing a new list. */}
+                <Input className="h-8 w-28 font-mono font-semibold" value={codeDraft}
+                  title={t('awed.refCodeTip')}
+                  onChange={(e) => setCodeDraft(e.target.value)} />
                 <label className="flex items-center gap-1.5 text-xs cursor-pointer"><Checkbox checked={sel.valid} onCheckedChange={(c) => patchSel({ valid: !!c })} /> {t('awed.valid')}</label>
                 <div className="flex-1" />
                 <button className="text-muted-foreground hover:text-destructive" onClick={() => delRef(sel.code)}><Trash2 className="size-4" /></button>
@@ -1084,7 +1116,7 @@ function ReferencesPanel({ code, presets, meta, awardValidFrom, awardValidTo, on
                   ? t('awed.refValidHintAward', { from: openEnded(awardValidFrom), to: openEnded(awardValidTo) })
                   : t('awed.refValidHint')}
               </p>
-              <div className="flex justify-end pt-1"><Button size="sm" className="h-7" onClick={() => sel && saveRef(sel)}><Save className="size-3.5 mr-1" /> {t('awed.saveReference')}</Button></div>
+              <div className="flex justify-end pt-1"><Button size="sm" className="h-7" onClick={() => sel && saveSelected(sel)}><Save className="size-3.5 mr-1" /> {t('awed.saveReference')}</Button></div>
             </div>
           )}
         </div>

frontend/src/components/BandMap.tsx

@@ -1,10 +1,11 @@
-import { useEffect, useMemo, useRef, useState } from 'react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { Minus, Plus, Crosshair, X, PanelLeft, PanelRight } from 'lucide-react';
 import { cn } from '@/lib/utils';
 import { useI18n } from '@/lib/i18n';
 import { spotStatusKey, inferSpotMode, spotModeCategory } from '@/lib/spot';
 import { SPOT_MARKERS, activeMarkers } from '@/lib/spotMarkers';
 import { applySpotDisplay, readSpotDisplayOptions } from '@/lib/spotDisplay';
+import { writeUiPref } from '@/lib/uiPref';
 
 // BandMap — vertical spectrum panel inspired by Log4OM.
 // - Full band is always visible; zoom changes pixels-per-kHz, scroll
@@ -217,7 +218,37 @@ function statusStyle(s: string): { pill: string; bar: string; line: string; dot:
 // Pixels-per-kHz at each zoom step. Base 8 px/kHz means a stacked spot
 // every 2.75 kHz fits without anti-overlap kicking in — comfortable for
 // most bands. Higher levels are for fine inspection of crowded sub-bands.
-const PX_PER_KHZ = [8, 16, 32, 64, 128, 256];
+// Zoom steps, px per kHz. 2 and 4 sit below the old floor of 8 so a whole band
+// fits without FIT taking the scale away from you: 20 m end to end is 700 px at
+// 2 px/kHz, which scrolls in one screen on most displays.
+const PX_PER_KHZ = [2, 4, 8, 16, 32, 64, 128, 256];
+const DEFAULT_ZOOM_IDX = PX_PER_KHZ.indexOf(32);
+
+// Zoom is remembered PER BAND, in ONE json key rather than one key per band:
+// lib/uiPref keeps an explicit list of the preferences that travel with data/,
+// and thirteen entries there to say the same thing would be thirteen chances to
+// forget one.
+const ZOOM_KEY = 'opslog.bandMapZoom';
+
+function readZoomMap(): Record<string, number> {
+  try {
+    const m = JSON.parse(localStorage.getItem(ZOOM_KEY) || '{}');
+    return m && typeof m === 'object' ? m : {};
+  } catch {
+    return {};
+  }
+}
+
+function readZoom(band: string): number {
+  const n = readZoomMap()[band];
+  return Number.isInteger(n) && n >= 0 && n < PX_PER_KHZ.length ? n : DEFAULT_ZOOM_IDX;
+}
+
+function writeZoom(band: string, idx: number): void {
+  const m = readZoomMap();
+  m[band] = idx;
+  writeUiPref(ZOOM_KEY, JSON.stringify(m));
+}
 const SCALE_W = 56;
 const PILL_H = 22;     // px — height of each callsign pill
 const PILL_GAP = 32;   // px between scale border and first pill (room for leader)
@@ -252,7 +283,22 @@ export function BandMap({ band, spots, spotStatus: spotStatusRaw, currentFreqHz,
   }, [spotStatusRaw, dispOpts.muteWorked, dispOpts.slotHighlight]);
   const range = BAND_RANGES[band];
   const segments = SEGMENT_COLORS[band] ?? [];
-  const [zoomIdx, setZoomIdx] = useState(2); // default 32 px/kHz
+  const [zoomIdx, setZoomIdx] = useState(() => readZoom(band));
+  // The docked map follows the rig, so a band change must bring up THAT band's
+  // remembered zoom.
+  useEffect(() => { setZoomIdx(readZoom(band)); }, [band]);
+  // Stored from the interaction, not from an effect on zoomIdx: an effect would
+  // also fire on the band change above, and in the same commit it would still be
+  // holding the PREVIOUS band's index — writing it over the new band's. Doing it
+  // where the operator actually turns the wheel keeps the two apart. (Running
+  // twice under StrictMode is harmless: the same value is stored.)
+  const changeZoom = useCallback((delta: number) => {
+    setZoomIdx((z) => {
+      const n = Math.max(0, Math.min(PX_PER_KHZ.length - 1, z + delta));
+      if (n !== z) writeZoom(band, n);
+      return n;
+    });
+  }, [band]);
   const scrollerRef = useRef<HTMLDivElement | null>(null);
   const [containerH, setContainerH] = useState(400);
 
@@ -421,7 +467,7 @@ export function BandMap({ band, spots, spotStatus: spotStatusRaw, currentFreqHz,
       if (!range) return;
       if (e.ctrlKey || e.metaKey) {
         e.preventDefault();
-        setZoomIdx((z) => Math.max(0, Math.min(PX_PER_KHZ.length - 1, z + (e.deltaY > 0 ? -1 : 1))));
+        changeZoom(e.deltaY > 0 ? -1 : 1);
       }
     };
     el.addEventListener('wheel', onWheel, { passive: false });
@@ -476,8 +522,10 @@ export function BandMap({ band, spots, spotStatus: spotStatusRaw, currentFreqHz,
 
   // Tick step (where small marks land) and label step (where the kHz
   // number is printed) are decoupled so the scale shows ~10-20 numeric
-  // labels per viewport regardless of zoom — at base 8 px/kHz we want
+  // labels per viewport regardless of zoom — at 8 px/kHz we want labels
-  // labels every 25 kHz, not every 250.
+  // every 25 kHz, not every 250. The bare values below are the floor, and
+  // they are what the 2 px/kHz step lands on: a whole band in one screen
+  // wants a number every 100 kHz, not every 25.
   let tickStep = 50;
   let labelStep = 100;
   if (pxPerKHz >= 4)   { tickStep = 25; labelStep = 50;  }
@@ -502,14 +550,17 @@ export function BandMap({ band, spots, spotStatus: spotStatusRaw, currentFreqHz,
   return (
     <div className="h-full w-full flex flex-col min-h-0 bg-card">
       <div className="px-2 py-1.5 text-xs font-semibold uppercase tracking-wider text-muted-foreground bg-muted/40 border-b border-border flex flex-nowrap items-center gap-0.5 shrink-0">
-        <span className="flex-1 min-w-0 truncate">{t('bmp.map')} · {band}</span>
+        {/* The band alone. "Map · 20M" spent a third of a narrow header saying
-        <button type="button" onClick={() => setZoomIdx((z) => Math.max(0, z - 1))} disabled={fitToBand || zoomIdx === 0}
+            what the panel obviously is, and with four band maps side by side it
+            was four times the same word. */}
+        <span className="flex-1 min-w-0 truncate">{band}</span>
+        <button type="button" onClick={() => changeZoom(-1)} disabled={fitToBand || zoomIdx === 0}
           className="size-5 shrink-0 inline-flex items-center justify-center rounded hover:bg-muted disabled:opacity-30"
           title={t('bmp.zoomOut')}>
           <Minus className="size-3" />
         </button>
         <span className="shrink-0 font-mono text-[10px] normal-case tracking-normal whitespace-nowrap px-0.5">{fitToBand ? t('bmp.fit') : `${pxPerKHz}px/kHz`}</span>
-        <button type="button" onClick={() => setZoomIdx((z) => Math.min(PX_PER_KHZ.length - 1, z + 1))} disabled={fitToBand || zoomIdx === PX_PER_KHZ.length - 1}
+        <button type="button" onClick={() => changeZoom(1)} disabled={fitToBand || zoomIdx === PX_PER_KHZ.length - 1}
           className="size-5 shrink-0 inline-flex items-center justify-center rounded hover:bg-muted disabled:opacity-30"
           title={t('bmp.zoomIn')}>
           <Plus className="size-3" />

frontend/src/components/BandSlotGrid.tsx

@@ -4,6 +4,7 @@ import { Badge } from '@/components/ui/badge';
 import { cn } from '@/lib/utils';
 import { sunTimes } from '@/lib/sun';
 import { isQSLConfirmed } from '@/lib/qsl';
+import { useI18n } from '@/lib/i18n';
 import { BandSlotQSOs } from '../../wailsjs/go/main/App';
 import type { WorkedBeforeView } from '@/types';
 
@@ -76,28 +77,31 @@ const STATUS_CLASSES: Record<string, string> = {
   dxcc_w: 'bg-mx-dx-work',
 };
 
-// Legend entries, in the same colour order as the cells. swatch = the
+// Legend entries, in the same colour order as the cells — and the same order and
-// background class (or a special ring marker for the current-entry cell).
+// i18n keys the Appearance panel's colour pickers use, so the two can never
+// disagree about which green is which. swatch = the background class (or a
+// special ring marker for the current-entry cell).
 const LEGEND: { swatch: string; ring?: boolean; label: string }[] = [
-  { swatch: 'bg-mx-call-conf', label: 'Call confirmed' },
+  { swatch: 'bg-mx-call-conf', label: 'mx.callConf' },
-  { swatch: 'bg-mx-call-work', label: 'Call worked' },
+  { swatch: 'bg-mx-call-work', label: 'mx.callWork' },
-  { swatch: 'bg-mx-dx-conf', label: 'Entity confirmed' },
+  { swatch: 'bg-mx-dx-conf', label: 'mx.dxConf' },
-  { swatch: 'bg-mx-dx-work', label: 'Entity worked' },
+  { swatch: 'bg-mx-dx-work', label: 'mx.dxWork' },
-  { swatch: 'bg-mx-none', label: 'Not worked' },
+  { swatch: 'bg-mx-none', label: 'mx.none' },
-  { swatch: 'bg-mx-none', ring: true, label: 'Current entry' },
+  { swatch: 'bg-mx-none', ring: true, label: 'mx.current' },
 ];
 
-function cellTitle(band: string, cls: string, status: string, current: boolean): string {
+function cellTitle(t: (k: string) => string, band: string, cls: string, status: string, current: boolean): string {
   const desc =
-    status === 'call_c' ? 'This callsign confirmed' :
+    status === 'call_c' ? t('mx.tipCallConf') :
-    status === 'call_w' ? 'This callsign worked (not confirmed)' :
+    status === 'call_w' ? t('mx.tipCallWork') :
-    status === 'dxcc_c' ? 'Entity confirmed (other callsign)' :
+    status === 'dxcc_c' ? t('mx.tipDxConf') :
-    status === 'dxcc_w' ? 'Entity worked (other callsign)' :
+    status === 'dxcc_w' ? t('mx.tipDxWork') :
-                          'Never worked';
+                          t('mx.tipNone');
-  return `${band} ${cls}: ${desc}${current ? ' — current entry' : ''}`;
+  return `${band} ${cls}: ${desc}${current ? ' — ' + t('mx.current') : ''}`;
 }
 
 export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, hasCall = true, lat, lon, forCall, onEditQso }: Props) {
+  const { t } = useI18n();
   // 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
@@ -308,7 +312,7 @@ export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, hasCal
                   return (
                     <td
                       key={b.tag}
-                      title={cellTitle(b.tag, cls, st, isCurrent) + (st ? ' — click to list the QSOs' : '')}
+                      title={cellTitle(t, b.tag, cls, st, isCurrent) + (st ? ' — ' + t('mx.tipClick') : '')}
                       onClick={st ? () => setSlot({ band: b.tag, cls }) : undefined}
                       className={cn(
                         'w-[28px] h-[24px] rounded transition-colors p-0',
@@ -316,7 +320,7 @@ export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, hasCal
                         // 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',
+                        isCurrent && 'ring-2 ring-mx-cur ring-inset',
                       )}
                     />
                   );
@@ -335,10 +339,10 @@ export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, hasCal
               className={cn(
                 'inline-block size-3 rounded shrink-0',
                 l.swatch,
-                l.ring && 'ring-2 ring-warning ring-inset',
+                l.ring && 'ring-2 ring-mx-cur ring-inset',
               )}
             />
-            {l.label}
+            {t(l.label)}
           </span>
         ))}
       </div>

frontend/src/components/ClusterGrid.tsx

@@ -69,6 +69,7 @@ export type SpotStatusEntry = {
   spotter_continent?: string;
   grid?: string;
   new_grid?: boolean;
+  grid_state?: string;
 };
 
 type Props = {
@@ -266,12 +267,12 @@ const makeColCatalog = (t: TFn): ColEntry[] => [
       if (s?.new_county) parts.push(t('clg2.newCounty'));
       if (s?.new_pota) parts.push(t('clg2.newPota'));
       if (s?.new_pfx) parts.push(t('clg2.newPfx'));
-      if (s?.new_grid) parts.push(t('clg2.newGrid'));
+      if (s?.new_grid) parts.push(s.grid_state === 'unconf' ? t('clg2.newGridUnconf') : t('clg2.newGrid'));
       return parts.join(' ');
     },
     cellRenderer: (p: any) => {
       const s = statusFor(p);
-      const parts: { text: string; color: string }[] = [];
+      const parts: { text: string; color: string; dim?: boolean }[] = [];
       const main = statusColor(s);
       if (main) {
         const label = s?.status === 'new' ? t('clg2.newDxcc')
@@ -287,12 +288,19 @@ const makeColCatalog = (t: TFn): ColEntry[] => [
       if (s?.new_county) parts.push({ text: t('clg2.newCounty'), color: markerColour('new_county') });
       if (s?.new_pota) parts.push({ text: t('clg2.newPota'), color: markerColour('new_pota') });
       if (s?.new_pfx) parts.push({ text: t('clg2.newPfx'), color: markerColour('new_pfx') });
-      if (s?.new_grid) parts.push({ text: t('clg2.newGrid'), color: markerColour('new_grid') });
+      // Worked-but-unconfirmed is a QSL to chase, not a QSO to make. Same hue
+      // held back, so it reads as "less" of the same thing rather than a
+      // different fact — and the label says which.
+      if (s?.new_grid) {
+        parts.push(s.grid_state === 'unconf'
+          ? { text: t('clg2.newGridUnconf'), color: markerColour('new_grid'), dim: true }
+          : { text: t('clg2.newGrid'), color: markerColour('new_grid') });
+      }
       if (parts.length === 0) return <span style={{ color: 'var(--muted-foreground)', fontSize: 10 }}>—</span>;
       return (
         <span style={{ whiteSpace: 'nowrap' }}>
           {parts.map((pt, i) => (
-            <span key={i} style={{ color: pt.color, fontWeight: 700 }}>
+            <span key={i} style={{ color: pt.color, fontWeight: 700, opacity: pt.dim ? 0.5 : 1 }}>
               {i > 0 ? ' · ' : ''}{pt.text}
             </span>
           ))}
@@ -638,6 +646,17 @@ export function ClusterGrid({ rows, spotStatus, onSpotClick }: Props) {
               {t('clg2.pickerDesc')}
             </DialogDescription>
           </DialogHeader>
+          {/* Whole-dialog controls. showAll/hideAll with no group already mean
+              "every column"; only the buttons were missing, so hiding the lot
+              took one click per group. */}
+          <div className="flex items-center gap-1 px-1 text-[11px] text-muted-foreground">
+            <span>{t('clg2.allGroups')}</span>
+            <button type="button" className="text-[11px] text-primary hover:underline px-1"
+              onClick={() => showAll()}>{t('clg2.all')}</button>
+            <span className="opacity-40">·</span>
+            <button type="button" className="text-[11px] text-muted-foreground hover:underline px-1"
+              onClick={() => hideAll()}>{t('clg2.none')}</button>
+          </div>
           <div className="max-h-[60vh] overflow-y-auto py-2">
             {GROUP_ORDER.map((group) => {
               const cols = COL_CATALOG.filter((c) => c.group === group);

frontend/src/components/ExportFieldsDialog.tsx

@@ -86,6 +86,13 @@ export function ExportFieldsDialog({ open, count, onExport, onClose }: {
     return [...m.entries()];
   }, [official]);
 
+  // Every tag the dialog can offer — the extras AND every group — so "select
+  // all" means what it says rather than "all the official ones".
+  const everyTag = useMemo(
+    () => [...extras, ...groups.flatMap(([, list]) => list.map((d) => d.name))],
+    [extras, groups],
+  );
+
   const toggle = (name: string, on: boolean) =>
     setSel((s) => { const n = new Set(s); if (on) n.add(name); else n.delete(name); return n; });
   const setMany = (names: string[], on: boolean) =>
@@ -114,11 +121,25 @@ export function ExportFieldsDialog({ open, count, onExport, onClose }: {
           <DialogDescription>{t('exf.desc')}</DialogDescription>
         </DialogHeader>
 
+        {/* Whole-dialog select/clear, next to the count they change. Per-group
+            links alone meant clearing the selection was one click PER GROUP —
+            a dozen of them to get to "just the handful I want". */}
         <div className="flex items-center gap-2 px-1 text-[11px] text-muted-foreground">
           <span>{t('exf.chosen', { n: sel.size })}</span>
-          <Button variant="ghost" size="sm" className="ml-auto h-6 text-[11px]" onClick={() => setSel(defaultSet(official))}>
+          <span className="ml-auto inline-flex items-center gap-1">
-            {t('exf.defaults')}
+            <Button variant="ghost" size="sm" className="h-6 text-[11px]"
-          </Button>
+              onClick={() => setSel(new Set(everyTag))}>
+              {t('exf.selectAll')}
+            </Button>
+            <Button variant="ghost" size="sm" className="h-6 text-[11px]"
+              disabled={sel.size === 0}
+              onClick={() => setSel(new Set())}>
+              {t('exf.selectNone')}
+            </Button>
+            <Button variant="ghost" size="sm" className="h-6 text-[11px]" onClick={() => setSel(defaultSet(official))}>
+              {t('exf.defaults')}
+            </Button>
+          </span>
         </div>
 
         <div className="grid grid-cols-3 gap-3 max-h-[56vh] overflow-y-auto pr-1">

frontend/src/components/GridSquareMap.tsx

@@ -0,0 +1,227 @@
+import { useEffect, useMemo, useRef, useState } from 'react';
+import L from 'leaflet';
+import 'leaflet/dist/leaflet.css';
+import { Loader2, RefreshCw } from 'lucide-react';
+import { GridSquares } from '../../wailsjs/go/main/App';
+import { gridSquareBounds, gridToLatLon } from '@/lib/maidenhead';
+import { useI18n } from '@/lib/i18n';
+import { cn } from '@/lib/utils';
+import { BASEMAPS, addBasemap, loadBasemap, type BasemapKey } from '@/components/MainMap';
+import { writeUiPref } from '@/lib/uiPref';
+
+// GridSquareMap — every Maidenhead square in the log, drawn on a world map.
+//
+// A square, not a marker. The question this answers is "where have I been
+// heard", and the shape of the answer is an area: a wall of squares across the
+// Atlantic and a bare Pacific says something about an antenna that a scatter of
+// pins does not. Confirmed and merely worked are two fills of the same hue —
+// the distinction is a STATE of one thing, not two categories, so it must not
+// be two unrelated colours.
+//
+// 4 characters, never 6: at world zoom a 6-character square is sub-pixel, and
+// aggregating to the big square is also how the count means "contacts in this
+// square" rather than "contacts at this exact spot".
+
+type Square = { grid: string; count: number; confirmed: boolean; band?: string; mode?: string };
+
+// The SAME basemaps the Main-tab world map offers, imported rather than copied:
+// two lists of tile servers is how one map ends up on a provider the other has
+// already been blocked by. This map opened on a hardcoded dark Carto, which is
+// the least legible of the four under translucent squares.
+
+// Leaflet geometry is painted onto a CANVAS, and canvas takes a colour, not a
+// stylesheet: "var(--success)" handed to fillStyle is simply invalid and the
+// shape is silently not drawn — a map with a correct square count and nothing
+// on it. So the token is RESOLVED to its literal value here, once per theme,
+// which is also why every other map in this app passes hex.
+function cssColour(token: string, fallback: string): string {
+  try {
+    const v = getComputedStyle(document.documentElement).getPropertyValue(token).trim();
+    return v || fallback;
+  } catch { return fallback; }
+}
+
+// Mode scope. Two, because the map lives beside a panel that decodes FTx: CW,
+// phone and "everything" answer a question nobody is asking here, and a row of
+// choices that are never the right one is just noise to read past.
+//
+// Digital is every digital mode; FTx is the FT family alone, which is the
+// narrower and usually the honest one — a square worked on RTTY in a contest is
+// not a square worked on FT8.
+const SCOPES = [
+  { key: 'DIGI', label: 'gsm.digital' },
+  { key: 'FTX', label: 'gsm.ftx' },
+] as const;
+type ScopeKey = typeof SCOPES[number]['key'];
+
+const SCOPE_KEY = 'opslog.gridMapScope';
+
+export function GridSquareMap({ myGrid, className }: { myGrid?: string; className?: string }) {
+  const { t } = useI18n();
+  const hostRef = useRef<HTMLDivElement>(null);
+  const mapRef = useRef<L.Map | null>(null);
+  const layerRef = useRef<L.LayerGroup | null>(null);
+  const [squares, setSquares] = useState<Square[] | null>(null);
+  const [busy, setBusy] = useState(false);
+  const [err, setErr] = useState('');
+  const [scope, setScope] = useState<ScopeKey>(
+    () => (SCOPES.some((s) => s.key === localStorage.getItem(SCOPE_KEY))
+      ? (localStorage.getItem(SCOPE_KEY) as ScopeKey) : 'DIGI'));
+
+  const [basemap, setBasemap] = useState<BasemapKey>(loadBasemap);
+  // Repaint the squares when the THEME changes, not the basemap: the fills come
+  // from theme tokens resolved at draw time, so a theme switch leaves them on
+  // the old palette until something forces a redraw.
+  const [themeTick, setThemeTick] = useState(0);
+  useEffect(() => {
+    const obs = new MutationObserver(() => setThemeTick((n) => n + 1));
+    obs.observe(document.documentElement, { attributes: true, attributeFilter: ['data-theme'] });
+    return () => obs.disconnect();
+  }, []);
+
+  const load = async (sc: ScopeKey = scope) => {
+    setBusy(true); setErr('');
+    try {
+      const r = (await GridSquares(sc)) as any;
+      setSquares((Array.isArray(r) ? r : []) as Square[]);
+    } catch (e: any) {
+      setErr(String(e?.message ?? e));
+      setSquares([]);
+    } finally { setBusy(false); }
+  };
+  useEffect(() => { void load(scope); /* eslint-disable-next-line react-hooks/exhaustive-deps */ }, [scope]);
+
+  // One-time map creation. preferCanvas: a busy digital log is a few thousand
+  // rectangles, and as SVG that is a few thousand DOM nodes to lay out on every
+  // pan.
+  useEffect(() => {
+    if (!hostRef.current || mapRef.current) return;
+    const m = L.map(hostRef.current, {
+      preferCanvas: true,
+      zoomControl: true,
+      attributionControl: true,
+      worldCopyJump: true,
+      minZoom: 1,
+    }).setView([25, 0], 2);
+    mapRef.current = m;
+    layerRef.current = L.layerGroup().addTo(m);
+    return () => { m.remove(); mapRef.current = null; layerRef.current = null; };
+  }, []);
+
+  // The chosen basemap, shared with the Main-tab map so picking one there and
+  // finding another here cannot happen.
+  const baseRef = useRef<L.TileLayer | null>(null);
+  const labelsRef = useRef<L.TileLayer | null>(null);
+  useEffect(() => {
+    const m = mapRef.current;
+    if (!m) return;
+    addBasemap(m, basemap, baseRef, labelsRef);
+    baseRef.current?.bringToBack();
+  }, [basemap]);
+
+  // Redraw the squares.
+  useEffect(() => {
+    const layer = layerRef.current;
+    if (!layer) return;
+    layer.clearLayers();
+    // Resolved once for the whole redraw, not per square: getComputedStyle
+    // forces a style flush, and doing that a thousand times is a visible stall.
+    const confirmedColour = cssColour('--success', '#16a34a');
+    const workedColour = cssColour('--chart-1', '#2a78d6');
+    const meColour = cssColour('--warning', '#f59e0b');
+    for (const sq of squares ?? []) {
+      const b = gridSquareBounds(sq.grid);
+      if (!b) continue;
+      // One hue, two states. Confirmed is the solid, saturated one; worked is
+      // the same colour held back — so the eye reads "more" and "less" of the
+      // same thing rather than two unrelated facts.
+      const colour = sq.confirmed ? confirmedColour : workedColour;
+      L.rectangle([[b.south, b.west], [b.north, b.east]], {
+        color: colour,
+        weight: 0.5,
+        opacity: sq.confirmed ? 0.9 : 0.5,
+        fillColor: colour,
+        fillOpacity: sq.confirmed ? 0.55 : 0.22,
+      })
+        .bindTooltip(
+          `${sq.grid} — ${sq.count} QSO${sq.count > 1 ? 's' : ''}` +
+          `${sq.band ? ` · ${sq.band}` : ''}${sq.mode ? ` ${sq.mode}` : ''}` +
+          `${sq.confirmed ? ` · ${t('gsm.confirmed')}` : ''}`,
+          { sticky: true },
+        )
+        .addTo(layer);
+    }
+    // The operator's own square, so the pattern has an origin to be read from.
+    const me = myGrid ? gridToLatLon(myGrid) : null;
+    if (me) {
+      L.circleMarker([me.lat, me.lon], {
+        radius: 4, color: meColour, weight: 2,
+        fillColor: meColour, fillOpacity: 1,
+      }).bindTooltip(myGrid!.toUpperCase(), { sticky: true }).addTo(layer);
+    }
+  }, [squares, myGrid, t, themeTick]);
+
+  const stats = useMemo(() => {
+    const list = squares ?? [];
+    return { total: list.length, confirmed: list.filter((s) => s.confirmed).length };
+  }, [squares]);
+
+  return (
+    // isolate is load-bearing, not tidiness. Leaflet puts its panes at z-index
+    // 400 and its zoom control at 1000, in the PAGE's stacking context — and the
+    // modals here are z-50. Without a stacking context of its own the map floats
+    // over Preferences and hides the Save and Close buttons. isolation:isolate
+    // confines every z-index Leaflet sets to this element.
+    <section className={cn('isolate relative flex flex-col min-h-0 rounded-lg border border-border bg-card overflow-hidden', className)}>
+      <header className="flex items-center gap-2 px-2.5 py-1.5 border-b border-border bg-muted/40 shrink-0 flex-wrap">
+        <span className="text-xs font-semibold uppercase tracking-wider text-muted-foreground">
+          {t('gsm.title')}
+        </span>
+        <div className="inline-flex rounded-md border border-border overflow-hidden">
+          {SCOPES.map((s, i) => (
+            <button key={s.key} type="button"
+              onClick={() => { setScope(s.key); try { localStorage.setItem(SCOPE_KEY, s.key); } catch { /* quota */ } }}
+              className={cn('px-1.5 h-6 text-[11px] whitespace-nowrap', i > 0 && 'border-l border-border',
+                scope === s.key ? 'bg-primary text-primary-foreground' : 'hover:bg-muted text-muted-foreground')}>
+              {t(s.label)}
+            </button>
+          ))}
+        </div>
+        <span className="text-[11px] text-muted-foreground tabular-nums">
+          {t('gsm.count', { n: stats.total, c: stats.confirmed })}
+        </span>
+        <select
+          value={basemap}
+          onChange={(e) => { const v = e.target.value as BasemapKey; setBasemap(v); writeUiPref('opslog.mapBasemap', v); }}
+          title={t('gsm.basemap')}
+          className="h-6 rounded border border-border bg-background px-1 text-[11px]"
+        >
+          {(Object.keys(BASEMAPS) as BasemapKey[]).map((k) => (
+            <option key={k} value={k}>{BASEMAPS[k].label}</option>
+          ))}
+        </select>
+        <span className="flex-1" />
+        <button type="button" onClick={() => void load()} disabled={busy} title={t('gsm.refresh')}
+          className="inline-flex items-center justify-center size-6 rounded border border-border hover:bg-muted disabled:opacity-50">
+          {busy ? <Loader2 className="size-3 animate-spin" /> : <RefreshCw className="size-3" />}
+        </button>
+      </header>
+      {err && <p className="px-2.5 py-1 text-[11px] text-destructive shrink-0">{err}</p>}
+      {/* The map host must have a real height or Leaflet renders nothing at all
+          — flex-1 + min-h-0, never a percentage. */}
+      <div ref={hostRef} className="flex-1 min-h-0" />
+      <footer className="flex items-center gap-3 px-2.5 py-1 border-t border-border bg-muted/30 shrink-0 text-[10px] text-muted-foreground">
+        <span className="inline-flex items-center gap-1.5">
+          <span className="inline-block size-2.5 rounded-[2px]"
+            style={{ background: 'var(--success)', opacity: 0.75 }} />
+          {t('gsm.confirmed')}
+        </span>
+        <span className="inline-flex items-center gap-1.5">
+          <span className="inline-block size-2.5 rounded-[2px]"
+            style={{ background: 'var(--chart-1)', opacity: 0.35 }} />
+          {t('gsm.worked')}
+        </span>
+      </footer>
+    </section>
+  );
+}

frontend/src/components/MainMap.tsx

@@ -61,8 +61,8 @@ const ESRI_STREET_ATTR = 'Tiles © Esri — Source: Esri, HERE, Garmin, &cop
 // Selectable basemaps for the world (great-circle) map. All key-free and all
 // LABELLED (country/continent names). `labelsUrl` adds a transparent place-name
 // overlay on top of an imagery basemap (so satellite keeps its names too).
-type BasemapKey = 'light' | 'voyager' | 'street' | 'satellite';
+export type BasemapKey = 'light' | 'voyager' | 'street' | 'satellite';
-const BASEMAPS: Record<BasemapKey, { label: string; url: string; attr: string; subdomains?: string; labelsUrl?: string }> = {
+export const BASEMAPS: Record<BasemapKey, { label: string; url: string; attr: string; subdomains?: string; labelsUrl?: string }> = {
   light:     { label: 'Light',     url: CARTO_LIGHT, attr: CARTO_ATTR, subdomains: 'abcd' },
   voyager:   { label: 'Voyager',   url: 'https://{s}.basemaps.cartocdn.com/rastertiles/voyager/{z}/{x}/{y}{r}.png',
                attr: CARTO_ATTR, subdomains: 'abcd' },
@@ -71,7 +71,7 @@ const BASEMAPS: Record<BasemapKey, { label: string; url: string; attr: string; s
                attr: 'Tiles &copy; Esri — Source: Esri, Maxar, Earthstar Geographics',
                labelsUrl: 'https://server.arcgisonline.com/ArcGIS/rest/services/Reference/World_Boundaries_and_Places/MapServer/tile/{z}/{y}/{x}' },
 };
-function loadBasemap(): BasemapKey {
+export function loadBasemap(): BasemapKey {
   const v = localStorage.getItem('opslog.mapBasemap');
   return v === 'voyager' || v === 'street' || v === 'satellite' ? v : 'light';
 }
@@ -80,7 +80,7 @@ function loadBasemap(): BasemapKey {
 // place-name overlay. updateWhenIdle/keepBuffer keep the number of live tiles
 // down: satellite loads TWO tile layers, so its tile count — and the composited
 // layers WebView2 has to hold — is double every other basemap's.
-function addBasemap(
+export function addBasemap(
   m: L.Map,
   key: BasemapKey,
   base: React.MutableRefObject<L.TileLayer | null>,

frontend/src/components/QSLManagerModal.tsx

@@ -111,7 +111,33 @@ export function fmtQslDate(s?: string): string {
 
 // QSL Manager as an in-app tab panel: upload logged QSOs to online logbooks
 // and download confirmations, while the rest of the app stays usable.
-export function QSLManagerPanel({ onEditQSO }: { onEditQSO?: (id: number) => void } = {}) {
+// GridActions are the row actions the context menu offers, forwarded straight to
+// whichever grid this panel is showing.
+//
+// The FILTERED exports are deliberately absent. "Export everything the filter
+// matches" means the Recent-QSOs filter, and the rows here come from a different
+// query entirely — offering it would export something other than what is on the
+// screen, which is the one thing an export must never do. Selection-based
+// exports have no such ambiguity: the ids are the rows you ticked.
+export type GridActions = {
+  onUpdateFromCty?: (ids: number[]) => void;
+  onUpdateFromQRZ?: (ids: number[]) => void;
+  onUpdateFromClublog?: (ids: number[]) => void;
+  onUpdateCountyFromULS?: (ids: number[]) => void;
+  onSendTo?: (service: string, ids: number[]) => void;
+  onSendRecording?: (ids: number[]) => void;
+  onSendEQSL?: (ids: number[]) => void;
+  onBulkEdit?: (ids: number[]) => void;
+  onExportSelected?: (ids: number[]) => void;
+  onExportSelectedFields?: (ids: number[]) => void;
+  onExportCabrilloSelected?: (ids: number[]) => void;
+  onDelete?: (ids: number[]) => void;
+};
+
+export function QSLManagerPanel({ onEditQSO, actions }: {
+  onEditQSO?: (id: number) => void;
+  actions?: GridActions;
+} = {}) {
   const { t } = useI18n();
   const [service, setService] = useState('lotw');
   // The callsign this profile signs/uploads/downloads as for the selected
@@ -443,6 +469,8 @@ export function QSLManagerPanel({ onEditQSO }: { onEditQSO?: (id: number) => voi
                 total={paperRows.length}
                 selectAllSignal={paperSelAllSig}
                 onRowSelected={(ids) => setPaperSel(new Set(ids))}
+                {...actions}
+                onRowDoubleClicked={onEditQSO ? (q) => onEditQSO(q.id as number) : undefined}
               />
             </div>
           )
@@ -549,6 +577,8 @@ export function QSLManagerPanel({ onEditQSO }: { onEditQSO?: (id: number) => voi
               total={rows.length}
               selectAllSignal={uploadSelAllSig}
               onRowSelected={onUploadRowSelected}
+              {...actions}
+              onRowDoubleClicked={onEditQSO ? (q) => onEditQSO(q.id as number) : undefined}
             />
           </div>
         )}

frontend/src/components/QSOContextMenu.tsx

@@ -7,8 +7,8 @@ export type QSOMenuState = { x: number; y: number; ids: number[] } | null;
 type Props = {
   menu: QSOMenuState;
   onClose: () => void;
-  onUpdateFromCty: (ids: number[]) => void;
+  onUpdateFromCty?: (ids: number[]) => void;
-  onUpdateFromQRZ: (ids: number[]) => void;
+  onUpdateFromQRZ?: (ids: number[]) => void;
   onUpdateFromClublog?: (ids: number[]) => void;
   // Only passed once the offline US county database has been downloaded —
   // an entry that can only ever answer "no database" is not worth a line here.
@@ -98,20 +98,28 @@ export function QSOContextMenu({ menu, onClose, onUpdateFromCty, onUpdateFromQRZ
       <div className="px-3 py-1 text-[11px] uppercase tracking-wider text-muted-foreground">
         {t('qctx.selected', { n })}
       </div>
-      <button
+      {/* Conditional like every other entry. These two were drawn
-        className="flex w-full items-center gap-2 px-3 py-1.5 text-left hover:bg-accent/50"
+          unconditionally, and the grid passes them through an arrow that calls
-        onClick={() => { onUpdateFromCty(menu.ids); onClose(); }}
+          an optional handler — so in a grid that wires neither (the QSL
-      >
+          Manager) both appeared and did precisely nothing when clicked. */}
-        <Globe2 className="size-4 text-primary" />
+      {onUpdateFromCty && (
-        <span>{t('qctx.fixCountry')}</span>
+        <button
-      </button>
+          className="flex w-full items-center gap-2 px-3 py-1.5 text-left hover:bg-accent/50"
-      <button
+          onClick={() => { onUpdateFromCty(menu.ids); onClose(); }}
-        className="flex w-full items-center gap-2 px-3 py-1.5 text-left hover:bg-accent/50"
+        >
-        onClick={() => { onUpdateFromQRZ(menu.ids); onClose(); }}
+          <Globe2 className="size-4 text-primary" />
-      >
+          <span>{t('qctx.fixCountry')}</span>
-        <RefreshCw className="size-4 text-info" />
+        </button>
-        <span>{t('qctx.updateQrz')}</span>
+      )}
-      </button>
+      {onUpdateFromQRZ && (
+        <button
+          className="flex w-full items-center gap-2 px-3 py-1.5 text-left hover:bg-accent/50"
+          onClick={() => { onUpdateFromQRZ(menu.ids); onClose(); }}
+        >
+          <RefreshCw className="size-4 text-info" />
+          <span>{t('qctx.updateQrz')}</span>
+        </button>
+      )}
       {onUpdateFromClublog && (
         <button
           className="flex w-full items-center gap-2 px-3 py-1.5 text-left hover:bg-accent/50"

frontend/src/components/RecentQSOsGrid.tsx

@@ -631,6 +631,20 @@ export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal,
     api.setColumnsVisible(ids, false);
     saveColumnState();
   }
+  // Whole-dialog show/hide. showAll/hideAll cover the CATALOGUE only; the award
+  // columns live in their own persisted code set, so a global that skipped them
+  // would leave a row of columns behind and look broken.
+  function setEverything(visible: boolean) {
+    const api = gridRef.current?.api;
+    if (!api) return;
+    api.setColumnsVisible(COL_CATALOG.map((c) => c.colId!), visible);
+    if (awardCols && awardCols.length > 0) {
+      persistAwardShown(visible ? new Set(awardCols.map((a) => a.code.toUpperCase())) : new Set());
+      api.setColumnsVisible(awardCols.map((a) => `award_${a.code}`), visible);
+    }
+    saveColumnState();
+  }
+
   function resetDefaults() {
     const api = gridRef.current?.api;
     if (!api) return;
@@ -711,11 +725,15 @@ export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal,
         </div>
       </div>
 
+      {/* Every handler is passed STRAIGHT through, never wrapped in an arrow: a
+          wrapper is always truthy, so the menu drew "Fix country" and "Update
+          from the callsign databases" even in a grid that wired neither — and
+          clicking them did nothing at all. */}
       <QSOContextMenu
         menu={menu}
         onClose={() => setMenu(null)}
-        onUpdateFromCty={(ids) => onUpdateFromCty?.(ids)}
+        onUpdateFromCty={onUpdateFromCty}
-        onUpdateFromQRZ={(ids) => onUpdateFromQRZ?.(ids)}
+        onUpdateFromQRZ={onUpdateFromQRZ}
         onUpdateFromClublog={onUpdateFromClublog}
         onUpdateCountyFromULS={onUpdateCountyFromULS}
         onSendTo={onSendTo}
@@ -738,6 +756,16 @@ export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal,
               {t('rqg.pickerDesc')}
             </DialogDescription>
           </DialogHeader>
+          {/* Whole-dialog controls. The per-group links alone meant hiding
+              everything was one click PER GROUP, and there are a dozen. */}
+          <div className="flex items-center gap-1 px-5 text-[11px] text-muted-foreground">
+            <span>{t('rqg.pickerAllGroups')}</span>
+            <button type="button" className="text-[11px] text-primary hover:underline px-1"
+              onClick={() => setEverything(true)}>{t('rqg.all')}</button>
+            <span className="opacity-40">·</span>
+            <button type="button" className="text-[11px] text-muted-foreground hover:underline px-1"
+              onClick={() => setEverything(false)}>{t('rqg.none')}</button>
+          </div>
           <div className="grid grid-cols-3 gap-4 max-h-[60vh] overflow-y-auto px-5 py-3">
             {GROUP_ORDER.map((group) => {
               const cols = COL_CATALOG.filter((c) => c.group === group);

frontend/src/components/RotorCompass.tsx

@@ -5,12 +5,13 @@
 // when an Ultrabeam is bidirectional, the opposite one when reversed); a small
 // red marker on the bezel shows the short-path bearing to the DX. Click the dial
 // to turn the antenna there.
-import { useMemo } from 'react';
+import { useEffect, useMemo, useRef, useState } from 'react';
 import { geoAzimuthalEquidistant, geoPath, geoGraticule10 } from 'd3-geo';
 import { feature } from 'topojson-client';
 import landTopo from 'world-atlas/land-110m.json';
-import { Compass, X } from 'lucide-react';
+import { Compass, X, Play, Square } from 'lucide-react';
 import { cn } from '@/lib/utils';
+import { useI18n } from '@/lib/i18n';
 
 // Decode the coastline outline once (≈110 m simplified land polygons).
 const LAND = feature(landTopo as any, (landTopo as any).objects.land);
@@ -29,6 +30,11 @@ interface Props {
   onSelectRotor?: (i: number) => void; // switch the active rotor
   onGoto?: (az: number) => void; // click-to-turn
   onClose?: () => void;
+  // Quick-turn buttons and the azimuth box, shown only where the caller wants
+  // them: Station Control draws its own GoTo/Stop around this compass, and two
+  // sets of the same controls side by side would be nothing but confusing.
+  presets?: { label: string; azimuth: number }[];
+  onStop?: () => void;
 }
 
 const SIZE = 168;
@@ -41,7 +47,43 @@ function pt(az: number, radius: number): [number, number] {
   return [C + radius * Math.cos(a), C + radius * Math.sin(a)];
 }
 
-export function RotorCompass({ bearing, headings, boomHeading, pattern, centerLat, centerLon, rotorEnabled, rotors, activeRotor, onSelectRotor, onGoto, onClose }: Props) {
+export function RotorCompass({ bearing, headings, boomHeading, pattern, centerLat, centerLon, rotorEnabled, rotors, activeRotor, onSelectRotor, onGoto, onClose, presets, onStop }: Props) {
+  const { t } = useI18n();
+  // Raw text, not a number: binding the input to a normalised value makes
+  // Backspace fight the operator on the way from "230" to "23". It is parsed
+  // when it is sent, and only then.
+  const [azText, setAzText] = useState('');
+  const showControls = !!(presets || onStop);
+
+  // Which preset was just pressed, so it can light up for a moment.
+  //
+  // A rotor takes seconds to start moving and the needle barely twitches at
+  // first, so without this the only answer to "did that register?" is to press
+  // it again — which is how an antenna ends up ordered somewhere twice. The
+  // acknowledgement has to come from the button itself, at once.
+  const [flashIdx, setFlashIdx] = useState<number | null>(null);
+  const flashTimer = useRef<number | undefined>(undefined);
+  useEffect(() => () => window.clearTimeout(flashTimer.current), []);
+  const pressPreset = (i: number, az: number) => {
+    if (!onGoto) return;
+    setFlashIdx(i);
+    window.clearTimeout(flashTimer.current);
+    flashTimer.current = window.setTimeout(() => setFlashIdx(null), 450);
+    onGoto(az);
+  };
+
+  // 0-359 and nothing else. 360 is refused rather than folded to 0 — it is
+  // almost always a typo for 36 or 306, and a rotor swinging through north on a
+  // slip of the finger is worth one rejected keypress.
+  const sendAz = () => {
+    const s = azText.trim();
+    if (s === '' || !onGoto) return;
+    const n = Number(s);
+    if (!Number.isFinite(n) || !Number.isInteger(n) || n < 0 || n > 359) return;
+    onGoto(n);
+    setAzText('');
+  };
+
   const cardinals = useMemo(
     () => [ { d: 0, l: 'N' }, { d: 45, l: 'NE' }, { d: 90, l: 'E' }, { d: 135, l: 'SE' },
             { d: 180, l: 'S' }, { d: 225, l: 'SW' }, { d: 270, l: 'W' }, { d: 315, l: 'NW' } ],
@@ -72,6 +114,35 @@ export function RotorCompass({ bearing, headings, boomHeading, pattern, centerLa
 
   const headLabel = headings.length ? headings[0] : null;
 
+  // Short and long path to the DX, in figures.
+  //
+  // The bezel already carries the short path as a red marker, but a marker is a
+  // direction, not a number — the same pair sits in the status bar at 10px and
+  // operators reported not being able to read it. It lives here because it
+  // belongs to the compass: every place that draws one gets the readout, instead
+  // of each caller inventing its own. Clickable when the caller can turn, like
+  // the status bar's. Built as a value because it is placed in one of two
+  // columns depending on whether the controls are shown.
+  const pathReadout = (
+    <div className="flex gap-1.5 mt-2 font-mono w-full">
+      {([['SP', bearing ?? null], ['LP', bearing == null ? null : (bearing + 180) % 360]] as const).map(([lbl, az]) => (
+        <button key={lbl} type="button" disabled={az == null || !onGoto}
+          onClick={() => { if (az != null && onGoto) onGoto(Math.round(az)); }}
+          title={az == null ? '' : `${lbl} ${Math.round(az)}°`}
+          className={
+            'flex-1 rounded-md border py-1 text-xs font-semibold tabular-nums transition-colors active:scale-95 ' +
+            (az == null
+              ? 'border-border text-muted-foreground/50 cursor-not-allowed'
+              : onGoto
+                ? 'border-info-border text-info-muted-foreground hover:bg-info-muted cursor-pointer'
+                : 'border-border text-muted-foreground cursor-default')
+          }>
+          {lbl} {az == null ? '—' : `${Math.round(az)}°`}
+        </button>
+      ))}
+    </div>
+  );
+
   return (
     <section className="flex flex-col h-full min-h-0 rounded-lg border border-border bg-card overflow-hidden">
       {/* Header — matches the WinKeyer / Voice keyer panels. */}
@@ -128,9 +199,13 @@ export function RotorCompass({ bearing, headings, boomHeading, pattern, centerLa
         </div>
       )}
 
+      {/* Dial on the left, controls on the right. The controls column is sized to
+          fit WITHIN the dial's height: the widget sits in a row whose height is
+          set by the entry strip, so it may grow sideways but never downwards. */}
+      <div className="flex items-start gap-2 p-2 min-h-0">
       {/* flex-col: the readout goes BELOW the dial. This wrapper was a row, so a
           sibling of the <svg> landed beside it. */}
-      <div className="flex flex-col items-center justify-center p-2 min-h-0">
+      <div className="flex flex-col items-center justify-center min-h-0 shrink-0">
         <svg
           viewBox={`0 0 ${SIZE} ${SIZE}`}
           className={onGoto ? 'cursor-pointer select-none' : 'select-none'}
@@ -191,30 +266,85 @@ export function RotorCompass({ bearing, headings, boomHeading, pattern, centerLa
           <circle cx={C} cy={C} r={3.5} fill="#15803d" stroke="#fff" strokeWidth={1} />
         </svg>
 
-        {/* Short and long path to the DX, in figures.
+        {/* With the controls column present the readout goes at the FOOT OF IT
-            The bezel already carries the short path as a red marker, but a
+            instead: the dial sets the widget's height, the controls are shorter
-            marker is a direction, not a number — the same pair sits in the
+            than the dial, and that leftover space is exactly the right size for
-            status bar at 10px and operators reported not being able to read it.
+            the pair. Under the dial it would push the whole widget taller. */}
-            Here because it belongs to the compass: every place that draws one
+        {!showControls && pathReadout}
-            gets the readout, instead of each caller inventing its own.
+      </div>
-            Clickable when the caller can turn, like the status bar's. */}
+
-        <div className="flex gap-1.5 mt-2 font-mono w-full">
+      {/* Quick turns + free azimuth + Stop. */}
-          {([['SP', bearing ?? null], ['LP', bearing == null ? null : (bearing + 180) % 360]] as const).map(([lbl, az]) => (
+      {showControls && (
-            <button key={lbl} type="button" disabled={az == null || !onGoto}
+        <div className="flex flex-col gap-1.5 flex-1 min-w-0">
-              onClick={() => { if (az != null && onGoto) onGoto(Math.round(az)); }}
+          {/* Two columns so six regions fit beside the dial rather than under
-              title={az == null ? '' : `${lbl} ${Math.round(az)}°`}
+              it. An operator with fewer keeps the same compact block. */}
-              className={
+          {!!presets?.length && (
-                'flex-1 rounded-md border py-1 text-xs font-semibold tabular-nums transition-colors ' +
+            <div className="grid grid-cols-2 gap-1">
-                (az == null
+              {presets.map((p, i) => (
-                  ? 'border-border text-muted-foreground/50 cursor-not-allowed'
+                <button
-                  : onGoto
+                  key={`${p.label}-${i}`}
-                    ? 'border-info-border text-info-muted-foreground hover:bg-info-muted cursor-pointer'
+                  type="button"
-                    : 'border-border text-muted-foreground cursor-default')
+                  disabled={!onGoto}
-              }>
+                  onClick={() => pressPreset(i, p.azimuth)}
-              {lbl} {az == null ? '—' : `${Math.round(az)}°`}
+                  title={`${p.label} — ${p.azimuth}°`}
+                  className={cn(
+                    'rounded-md border py-1 text-xs font-semibold truncate transition-all duration-150 active:scale-95',
+                    flashIdx === i
+                      // Lit, and showing the azimuth it just sent: the label alone
+                      // would only say the press landed, not what was ordered.
+                      ? 'border-success bg-success text-success-foreground scale-95'
+                      : 'border-border bg-muted/40',
+                    onGoto && flashIdx !== i ? 'hover:bg-muted' : '',
+                    !onGoto ? 'opacity-50 cursor-not-allowed' : '',
+                  )}
+                >
+                  {flashIdx === i ? `${p.azimuth}°` : p.label}
+                </button>
+              ))}
+            </div>
+          )}
+
+          {/* Free azimuth: Enter sends, so the whole thing is type-three-digits
+              -and-go without reaching for the mouse. */}
+          <div className="flex gap-1">
+            <input
+              type="text"
+              inputMode="numeric"
+              value={azText}
+              onChange={(e) => setAzText(e.target.value.replace(/[^0-9]/g, '').slice(0, 3))}
+              onKeyDown={(e) => { if (e.key === 'Enter') { e.preventDefault(); sendAz(); } }}
+              placeholder={t('rotor.azPh')}
+              title={t('rotor.azTitle')}
+              disabled={!onGoto}
+              className="min-w-0 flex-1 rounded-md border border-border bg-background px-2 py-1 text-xs font-mono tabular-nums text-center disabled:opacity-50"
+            />
+            <button
+              type="button"
+              onClick={sendAz}
+              disabled={!onGoto || azText.trim() === ''}
+              title={t('rotor.go')}
+              className="flex items-center gap-1 rounded-md border border-success/60 bg-success-muted px-2 py-1 text-xs font-bold text-success-muted-foreground transition-transform hover:bg-success/25 active:scale-95 disabled:opacity-40 disabled:cursor-not-allowed"
+            >
+              <Play className="size-3" /> {t('rotor.go')}
             </button>
-          ))}
+          </div>
+
+          {onStop && (
+            <button
+              type="button"
+              onClick={onStop}
+              title={t('rotor.stop')}
+              className="flex items-center justify-center gap-1.5 rounded-md border border-destructive/60 bg-destructive/15 py-1 text-xs font-bold text-destructive hover:bg-destructive/25"
+            >
+              <Square className="size-3 fill-current" /> {t('rotor.stop')}
+            </button>
+          )}
+
+          {/* mt-auto: the readout sits at the FOOT of the column, level with the
+              bottom of the dial, instead of floating under the Stop button. */}
+          <div className="mt-auto">{pathReadout}</div>
         </div>
+      )}
       </div>
     </section>
   );

frontend/src/components/SettingsModal.tsx

@@ -11,6 +11,7 @@ import {
   GetCATSettings, SaveCATSettings, DiscoverFlexRadios,
   ListProfiles, GetActiveProfile, SaveProfile, DeleteProfile, ActivateProfile, DuplicateProfile,
   GetRotators, SaveRotators, TestRotatorDevice, RotatorPark, RotatorStop,
+  GetRotorPresets, SaveRotorPresets, ResetRotorPresets,
   GetUltrabeamSettings, SaveUltrabeamSettings, TestUltrabeam,
   GetAntGeniusSettings, SaveAntGeniusSettings,
   GetTunerGeniusSettings, SaveTunerGeniusSettings,
@@ -54,7 +55,7 @@ import {
   GetFolderSync, SaveFolderSync, PickFolderSyncFolder, GetFolderSyncStatus, SyncFolderNow,
   GetRelayAuto, SaveRelayAuto, GetStationDevices,
   GetAwardDefs, GetTrackedAwards, SaveTrackedAwards,
-  GetBandOpenSettings, SaveBandOpenSettings, GetPSKReporterStatus, GetChaseNewGrids, SetChaseNewGrids, GetChaseNew, SetChaseNew, GetGridCacheStatus, GetLinkedAmps, SetLinkedAmps, GetSpotTTLMinutes, SetSpotTTLMinutes,
+  GetBandOpenSettings, SaveBandOpenSettings, GetGridScopeSettings, SaveGridScopeSettings, GetPSKReporterStatus, GetChaseNewGrids, SetChaseNewGrids, GetChaseNew, SetChaseNew, GetGridCacheStatus, GetLinkedAmps, SetLinkedAmps, GetSpotTTLMinutes, SetSpotTTLMinutes,
 } from '../../wailsjs/go/main/App';
 import type { profile as profileModels } from '../../wailsjs/go/models';
 import type { LookupSettingsForm, StationSettingsForm, ListsSettingsForm, ModePresetForm } from '@/types';
@@ -75,6 +76,7 @@ import {
 } from '@/components/ui/select';
 import { cn } from '@/lib/utils';
 import { writeUiPref } from '@/lib/uiPref';
+import { loadAutoCall, autoCallKey, type AutoCallSettings, type AutoCallCriteria } from '@/lib/autocall';
 import { getDateFormat, setDateFormat, type DateFormat } from '@/lib/dateFormat';
 import { useI18n, FlagGB, FlagFR, type Lang } from '@/lib/i18n';
 import { useTheme, CONCRETE_THEMES, type ThemeChoice } from '@/lib/theme';
@@ -201,6 +203,7 @@ type SectionId =
   | 'uscounties'
   | 'awards'
   | 'cat'
+  | 'ftx'
   | 'rotator'
   | 'winkeyer'
   | 'antenna'
@@ -305,6 +308,7 @@ function buildTree(flexAvailable: boolean, t: (k: string) => string): TreeNode[]
         { kind: 'item', label: t('sec.modes'), id: 'lists-modes' },
       ]},
       { kind: 'item', label: t('sec.cluster'),     id: 'cluster' },
+      { kind: 'item', label: t('sec.ftx'),         id: 'ftx' },
       { kind: 'item', label: t('sec.udp'), id: 'udp' },
       { kind: 'item', label: t('sec.adifmon'), id: 'adifmon' },
       { kind: 'item', label: t('sec.foldersync'), id: 'foldersync' },
@@ -324,7 +328,7 @@ function buildTree(flexAvailable: boolean, t: (k: string) => string): TreeNode[]
 const SECTION_KEY: Partial<Record<SectionId, string>> = {
   station: 'sec.station', profiles: 'sec.profiles', operating: 'sec.operating', confirmations: 'sec.confirmations',
   'external-services': 'sec.external', appearance: 'sec.appearance', lookup: 'sec.lookup', 'lists-bands': 'sec.bands', 'lists-modes': 'sec.modes',
-  cluster: 'sec.cluster', backup: 'sec.backup', database: 'sec.database', autostart: 'sec.autostart', udp: 'sec.udp',
+  cluster: 'sec.cluster', ftx: 'sec.ftx', backup: 'sec.backup', database: 'sec.database', autostart: 'sec.autostart', udp: 'sec.udp',
   adifmon: 'sec.adifmon',
   foldersync: 'sec.foldersync',
   webpublish: 'sec.webpublish',
@@ -1028,7 +1032,7 @@ function RelayAutoPanel() {
 // panes show, independently: the great-circle map, the locator street map, the
 // cluster grid or the worked-before grid. Per-profile (stored via SetUIPref,
 // which is profile-prefixed). Self-contained so it owns its async-loaded state.
-const MAIN_PANE_VALUES = ['map1', 'map2', 'cluster', 'worked', 'recent', 'netcontrol'];
+const MAIN_PANE_VALUES = ['map1', 'map2', 'cluster', 'worked', 'recent', 'netcontrol', 'decodes'];
 function MainViewPanes({ onChanged, flexAvailable, icomAvailable, yaesuAvailable }: { onChanged?: (side: 'left' | 'right', value: string) => void; flexAvailable?: boolean; icomAvailable?: boolean; yaesuAvailable?: boolean }) {
   const { t } = useI18n();
   const [left, setLeft] = useState('map1');
@@ -1399,16 +1403,25 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   const [bandDraft, setBandDraft] = useState('');
   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,
+    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, flex_dvk_dax: false,
     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,
+    tci_host: '', tci_port: 40001, tci_spots: false, poll_ms: 250, delay_ms: 0, offset_on: false, offset_hz: 0,
-    digital_default: 'FT8', share_enabled: false, share_port: 4532,
+    digital_default: 'FT8', share_enabled: false, share_port: 4532, share_proto: 'rigctl', share_tci_port: 40001,
     ptt_hotkey_enabled: false, ptt_hotkey: '', ptt_hotkey_toggle: false,
   });
   // While true, the next key press is captured as the PTT hotkey.
   const [capturingPtt, setCapturingPtt] = useState(false);
   const [rotors, setRotors] = useState<RotatorDevice[]>([]);
+  const [rotorPresets, setRotorPresets] = useState<{ label: string; azimuth: number }[]>([]);
+  // Whether the presets have actually been READ back yet.
+  //
+  // An empty list is a legitimate answer — an operator may want no quick-turn
+  // buttons at all — so the backend stores it as one. That makes "not loaded
+  // yet" and "deliberately none" the same value, and a Save landing in the first
+  // state wiped the buttons for good. Saving is gated on having read them, so
+  // the only empty list that can ever reach the store is one the operator made.
+  const [rotorPresetsLoaded, setRotorPresetsLoaded] = useState(false);
   const [rotatorTesting, setRotatorTesting] = useState(false);
   const [rotatorTest, setRotatorTest] = useState<{ ok: boolean; msg: string } | null>(null);
 
@@ -1509,6 +1522,10 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   const [autofocusWB, setAutofocusWB] = useState(() => localStorage.getItem('opslog.autofocusWB') !== '0');
   const [checkUpdates, setCheckUpdates] = useState(() => localStorage.getItem('opslog.checkUpdates') !== '0');
   const [showBeamMap, setShowBeamMap] = useState(() => localStorage.getItem('opslog.showBeamOnMap') !== '0');
+  // Compact rotor widget: the dial and the SP/LP readout only. Off by default —
+  // the full widget is what the operator has today, and a setting that changes
+  // a panel the moment you upgrade is a setting that gets blamed for it.
+  const [rotorCompact, setRotorCompact] = useState(() => localStorage.getItem('opslog.rotorCompact') === '1');
   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');
@@ -1714,6 +1731,14 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   // has side effects there — adding the RBN nodes, bringing the PSK Reporter
   // feed up or down — so the write has to go where those live.
   const [bandOpen, setBandOpen] = useState<any>({ enabled: false, bands: [], available: [] });
+  // How a worked square is matched, and what counts as still wanted.
+  const [autoCall, setAutoCall] = useState<AutoCallSettings>(loadAutoCall);
+  const [gridScope, setGridScope] = useState<any>({ scope: 'mix_digi', hunt: 'new', scopes: [] });
+  useEffect(() => { GetGridScopeSettings().then((g) => setGridScope(g as any)).catch(() => {}); }, []);
+  const saveGridScope = async (next: any) => {
+    setGridScope(next);
+    try { await SaveGridScopeSettings(next); } catch { /* the panel keeps the choice either way */ }
+  };
   const [chaseGrids, setChaseGrids] = useState(false);
   const [chaseNew, setChaseNew] = useState(false);
   const [spotTTL, setSpotTTL] = useState(0);
@@ -1825,6 +1850,11 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
         await reloadClusterServers();
         setCatCfg(c);
         setRotors((r ?? []) as any);
+        // Loaded HERE, in the loader that runs on mount — not only in the
+        // event-driven one below. Missing from this one, the state stayed empty
+        // on a normal open and Save then wrote an empty list over the operator's
+        // buttons. See rotorPresetsLoaded for the belt to this brace.
+        try { setRotorPresets((((await GetRotorPresets()) ?? []) as any)); setRotorPresetsLoaded(true); } catch {}
         try { setUltrabeam(await GetUltrabeamSettings() as any); } catch {}
         try { setAntgenius(await GetAntGeniusSettings() as any); } catch {}
         try { setTunergenius(await GetTunerGeniusSettings() as any); } catch {}
@@ -1868,6 +1898,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
         try { setLookup(await GetLookupSettings() as any); } catch {}
         try { setCatCfg(await GetCATSettings() as any); } catch {}
         try { setRotors(((await GetRotators()) ?? []) as any); } catch {}
+        try { setRotorPresets((((await GetRotorPresets()) ?? []) as any)); setRotorPresetsLoaded(true); } catch {}
         try { setUltrabeam(await GetUltrabeamSettings() as any); } catch {}
         try { setAntgenius(await GetAntGeniusSettings() as any); } catch {}
         try { setTunergenius(await GetTunerGeniusSettings() as any); } catch {}
@@ -2062,6 +2093,8 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
       await SaveLookupSettings(lookup as any);
       await SaveCATSettings(catCfg as any);
       await SaveRotators(rotors as any);
+      // Only once they have been read back — see rotorPresetsLoaded.
+      if (rotorPresetsLoaded) await SaveRotorPresets(rotorPresets as any);
       await SaveUltrabeamSettings(ultrabeam as any);
       await SaveAntGeniusSettings(antgenius as any);
       await SaveTunerGeniusSettings(tunergenius as any);
@@ -2368,6 +2401,11 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   }
 
   function LookupPanel() {
+    // The cache lifetime as TYPED, so the box can be emptied and re-filled.
+    // Re-seeded when the settings arrive from the backend — which is after the
+    // first render, so it cannot simply be the initial value.
+    const [ttlText, setTtlText] = useState(String(lookup.cache_ttl_days));
+    useEffect(() => { setTtlText(String(lookup.cache_ttl_days)); }, [lookup.cache_ttl_days]);
     // Per-row provider editor — kept inline because it's only used twice
     // and needs closure access to the parent state.
     const row = (
@@ -2504,16 +2542,31 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
           <div className="flex gap-3 items-end">
             <div className="space-y-1 w-40">
               <Label>{t('lk.ttl')}</Label>
+              {/* Raw text, not the stored number. Deriving the value from the
+                  number on every keystroke made the box impossible to empty —
+                  and "0" itself unreachable, since parseInt('0') || 30 is 30.
+                  Zero is now a real setting, so it has to be typeable. */}
               <Input
-                type="number" min={1} max={3650}
+                type="number" min={0} max={3650}
-                value={lookup.cache_ttl_days}
+                value={ttlText}
-                onChange={(e) => setLookup((s) => ({ ...s, cache_ttl_days: parseInt(e.target.value) || 30 }))}
+                onChange={(e) => {
+                  const raw = e.target.value;
+                  setTtlText(raw);
+                  const n = parseInt(raw, 10);
+                  if (Number.isFinite(n) && n >= 0) {
+                    setLookup((s) => ({ ...s, cache_ttl_days: Math.min(n, 3650) }));
+                  }
+                }}
+                onBlur={() => setTtlText(String(lookup.cache_ttl_days))}
               />
             </div>
             <Button variant="outline" onClick={clearCache} disabled={clearing}>
               {clearing ? t('lk.clearing') : t('lk.clearCache')}
             </Button>
           </div>
+          {lookup.cache_ttl_days === 0 && (
+            <p className="text-[11px] text-warning mt-2">{t('lk.cacheOff')}</p>
+          )}
         </div>
       </>
     );
@@ -2842,6 +2895,10 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                   <span className="text-xs text-muted-foreground">{t('cat.flexDecodeSecsHint')}</span>
                 </div>
               )}
+              <label className="col-span-2 flex items-start gap-2 text-sm cursor-pointer">
+                <Checkbox className="mt-0.5" checked={!!catCfg.flex_dvk_dax} onCheckedChange={(c) => setCatCfg((s) => ({ ...s, flex_dvk_dax: !!c }))} />
+                <span>{t('cat.flexDvkDax')} <span className="text-xs text-muted-foreground">{t('cat.flexDvkDaxHint')}</span></span>
+              </label>
             </>
             )}
             {catCfg.backend === 'xiegu' && (
@@ -3122,6 +3179,28 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             </div>
             </>
             )}
+            {/* Transverter offset. OUTSIDE the per-backend blocks on purpose: a
+                transverter hangs off the IF of whatever radio you own, and the
+                offset is applied in the CAT manager, above every backend. Tucked
+                under the OmniRig/Icom section it would have been invisible to the
+                Yaesu, Kenwood, Xiegu, Flex and TCI operators who need it just as
+                much. */}
+            <label className="col-span-2 flex items-start gap-2 text-sm cursor-pointer">
+              <Checkbox className="mt-0.5" checked={!!catCfg.offset_on}
+                onCheckedChange={(c) => setCatCfg((s) => ({ ...s, offset_on: !!c }))} />
+              <span>{t('cat.offsetOn')} <span className="text-xs text-muted-foreground">{t('cat.offsetHint')}</span></span>
+            </label>
+            {catCfg.offset_on && (
+              <div className="col-span-2 flex items-center gap-2 pl-6">
+                <Label className="text-sm">{t('cat.offsetMhz')}</Label>
+                <Input
+                  type="number" step="0.000001" className="w-40"
+                  value={(catCfg.offset_hz ?? 0) / 1e6}
+                  onChange={(e) => setCatCfg((s) => ({ ...s, offset_hz: Math.round((parseFloat(e.target.value) || 0) * 1e6) }))}
+                />
+                <span className="text-xs text-muted-foreground">{t('cat.offsetExample')}</span>
+              </div>
+            )}
             <div className="space-y-1 col-span-2">
               <Label>{t('cat.digitalDefault')}</Label>
               <Select
@@ -3149,15 +3228,47 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             </label>
             <p className="text-[11px] text-muted-foreground">{t('cat.shareHint')}</p>
             {catCfg.share_enabled && (
-              <div className="space-y-1 max-w-[200px]">
+              <div className="flex flex-wrap items-end gap-4">
-                <Label>{t('cat.sharePort')}</Label>
+                {/* One protocol or the other. They answer the same questions about
-                <PortInput
+                    the same radio, and no program speaks both — so this is a
-                  value={catCfg.share_port || 4532}
+                    choice, not two switches. */}
-                  fallback={4532}
+                <div className="space-y-1">
-                  onChange={(n) => setCatCfg((s) => ({ ...s, share_port: n }))}
+                  <Label>{t('cat.shareProto')}</Label>
-                />
+                  <Select
+                    value={(catCfg as any).share_proto === 'tci' ? 'tci' : 'rigctl'}
+                    onValueChange={(v) => setCatCfg((s) => ({ ...s, share_proto: v } as any))}
+                  >
+                    <SelectTrigger className="h-8 w-[240px]"><SelectValue /></SelectTrigger>
+                    <SelectContent>
+                      <SelectItem value="rigctl">{t('cat.shareRigctl')}</SelectItem>
+                      <SelectItem value="tci">{t('cat.shareTci')}</SelectItem>
+                    </SelectContent>
+                  </Select>
+                </div>
+                <div className="space-y-1 max-w-[200px]">
+                  <Label>{t('cat.sharePort')}</Label>
+                  {(catCfg as any).share_proto === 'tci' ? (
+                    <PortInput
+                      value={(catCfg as any).share_tci_port || 40001}
+                      fallback={40001}
+                      onChange={(n) => setCatCfg((s) => ({ ...s, share_tci_port: n } as any))}
+                    />
+                  ) : (
+                    <PortInput
+                      value={catCfg.share_port || 4532}
+                      fallback={4532}
+                      onChange={(n) => setCatCfg((s) => ({ ...s, share_port: n }))}
+                    />
+                  )}
+                </div>
               </div>
             )}
+            {catCfg.share_enabled && (catCfg as any).share_proto === 'tci' && catCfg.backend === 'tci' && (
+              // Both ends TCI: ExpertSDR is almost certainly already holding
+              // 40001 on this machine, and our server would fail to bind. Worth
+              // saying here rather than leaving it in the log.
+              <p className="text-[11px] text-warning">{t('cat.shareTciClash')}</p>
+            )}
           </div>
           {/* PTT hotkey — a keyboard key that keys the rig while OpsLog is focused.
               Uses the Audio → PTT method (CAT / RTS / DTR), falling back to CAT. */}
@@ -4083,6 +4194,56 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
               )}
             </div>
           )}
+
+          {/* How much of the rotor widget to draw. Compact keeps the dial and the
+              SP/LP azimuths and drops the controls — for an operator who turns
+              the antenna from the bearing pill or from PstRotator and wants the
+              dial to take a column, not a panel. */}
+          <div className="border-t border-border/60 pt-3 space-y-2">
+            <div className="text-sm font-semibold">{t('rot.widget')}</div>
+            <label className="flex items-center gap-2 text-sm">
+              <Checkbox checked={rotorCompact}
+                onCheckedChange={(c) => { const v = !!c; setRotorCompact(v); writeUiPref('opslog.rotorCompact', v ? '1' : '0'); }} />
+              {t('rot.compact')}
+            </label>
+            <p className="text-xs text-muted-foreground">{t('rot.compactHint')}</p>
+          </div>
+
+          {/* Quick-turn buttons for the rotor widget. Their azimuths start out
+              computed from the station square, so they are right for THIS QTH
+              rather than copied from someone else's. Hidden in compact mode —
+              editing buttons that are not drawn is a trap. */}
+          <div className={cn('border-t border-border/60 pt-3 space-y-2', rotorCompact && 'opacity-40')}>
+            <div className="text-sm font-semibold">{t('rot.presets')}</div>
+            <p className="text-xs text-muted-foreground">{t('rot.presetsHint')}</p>
+            <div className="space-y-1.5">
+              {rotorPresets.map((p, i) => (
+                <div key={i} className="flex items-center gap-2">
+                  <Input className="w-24" maxLength={6} value={p.label}
+                    placeholder={t('rot.presetName')}
+                    onChange={(e) => setRotorPresets((list) => list.map((x, j) => (j === i ? { ...x, label: e.target.value } : x)))} />
+                  <Input className="w-24" type="number" min={0} max={359} value={p.azimuth}
+                    onChange={(e) => setRotorPresets((list) => list.map((x, j) => (j === i ? { ...x, azimuth: Math.max(0, Math.min(359, parseInt(e.target.value, 10) || 0)) } : x)))} />
+                  <span className="text-xs text-muted-foreground">°</span>
+                  <Button variant="ghost" size="sm" title={t('rot.remove')}
+                    onClick={() => setRotorPresets((list) => list.filter((_, j) => j !== i))}>
+                    <Trash2 className="size-3.5" />
+                  </Button>
+                </div>
+              ))}
+            </div>
+            <div className="flex items-center gap-2">
+              {rotorPresets.length < 8 && (
+                <Button variant="outline" size="sm" onClick={() => setRotorPresets((l) => [...l, { label: '', azimuth: 0 }])}>
+                  <Plus className="size-3.5 mr-1" /> {t('rot.presetAdd')}
+                </Button>
+              )}
+              <Button variant="outline" size="sm"
+                onClick={() => { ResetRotorPresets().then((p) => setRotorPresets((p ?? []) as any)).catch((e) => setErr(String(e?.message ?? e))); }}>
+                {t('rot.presetsReset')}
+              </Button>
+            </div>
+          </div>
           {rotatorTest && (
             <div className={cn(
               'text-xs rounded-md p-2.5 border',
@@ -4429,6 +4590,91 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     setEditingServer(next);
   }
 
+  // FTx decodes: what OpsLog does on its own with the digital stream.
+  //
+  // Auto-call KEYS THE TRANSMITTER without anyone clicking, so the panel is
+  // deliberately explicit about it: off by default, every criterion opt-in, and
+  // a plain statement of what the machine will do once it is on.
+  function FtxPanel() {
+    const set = (patch: Partial<AutoCallSettings>) => {
+      const next = { ...autoCall, ...patch };
+      setAutoCall(next);
+      writeUiPref(autoCallKey, JSON.stringify(next));
+    };
+    const crit = (which: 'criteria' | 'watchCriteria', k: keyof AutoCallCriteria) => (
+      <label key={k} className="flex items-center gap-1.5 text-xs cursor-pointer">
+        <Checkbox
+          checked={!!autoCall[which][k]}
+          onCheckedChange={(v) => set({ [which]: { ...autoCall[which], [k]: !!v } } as any)}
+        />
+        {t(`ftx.c_${k}`)}
+      </label>
+    );
+    const KEYS: (keyof AutoCallCriteria)[] = ['dxcc', 'band', 'mode', 'slot', 'grid', 'county', 'pota', 'pfx'];
+    return (
+      <>
+        <SectionHeader title={t('sec.ftx')} hint={t('ftx.hint')} />
+        <div className="space-y-4">
+          <div className="rounded-md border border-border p-3 space-y-3">
+            <label className="flex items-start gap-2 text-sm cursor-pointer">
+              <Checkbox checked={autoCall.enabled} className="mt-0.5"
+                onCheckedChange={(v) => set({ enabled: !!v })} />
+              <span>
+                {t('ftx.enable')}{' '}
+                <span className="text-xs text-muted-foreground">{t('ftx.enableHint')}</span>
+              </span>
+            </label>
+
+            {autoCall.enabled && (
+              <div className="pl-6 space-y-3">
+                <div>
+                  <p className="text-xs font-semibold text-muted-foreground mb-1.5">{t('ftx.callWhen')}</p>
+                  <div className="grid grid-cols-2 gap-x-4 gap-y-1">{KEYS.map((k) => crit('criteria', k))}</div>
+                </div>
+
+                <div className="border-t border-border/60 pt-3">
+                  <p className="text-xs font-semibold text-muted-foreground mb-1">{t('ftx.watch')}</p>
+                  <p className="text-[11px] text-muted-foreground mb-1.5 leading-relaxed">{t('ftx.watchHint')}</p>
+                  <Textarea
+                    className="h-20 font-mono text-xs"
+                    placeholder={"4S7*\nTM0HQ\n*/P"}
+                    defaultValue={(autoCall.watch ?? []).join('\n')}
+                    key={`w-${(autoCall.watch ?? []).length}`}
+                    onBlur={(e) => set({
+                      watch: e.target.value.split('\n').map((x) => x.trim().toUpperCase()).filter(Boolean),
+                    })}
+                  />
+                  {(autoCall.watch ?? []).length > 0 && (
+                    <div className="mt-2">
+                      <p className="text-[11px] text-muted-foreground mb-1">{t('ftx.watchOnlyIf')}</p>
+                      <div className="grid grid-cols-2 gap-x-4 gap-y-1">{KEYS.map((k) => crit('watchCriteria', k))}</div>
+                    </div>
+                  )}
+                </div>
+
+                <div className="border-t border-border/60 pt-3 flex items-center gap-2 flex-wrap">
+                  <span className="text-xs text-muted-foreground">{t('ftx.cooldown')}</span>
+                  <Input type="number" min={10} max={3600} className="w-24 h-7 text-xs"
+                    defaultValue={autoCall.cooldownSec}
+                    key={`cd-${autoCall.cooldownSec}`}
+                    onBlur={(e) => {
+                      const v = parseInt(e.target.value, 10);
+                      if (!isNaN(v) && v >= 10 && v <= 3600) set({ cooldownSec: v });
+                    }} />
+                  <span className="text-xs text-muted-foreground">s</span>
+                </div>
+
+                <p className="text-[11px] rounded border border-warning-border bg-warning-muted text-warning-muted-foreground px-2 py-1.5 leading-relaxed">
+                  {t('ftx.warn')}
+                </p>
+              </div>
+            )}
+          </div>
+        </div>
+      </>
+    );
+  }
+
   function ClusterPanel() {
     const sorted = [...clusterServers].sort((a, b) => (a.sort_order ?? 0) - (b.sort_order ?? 0));
     return (
@@ -4583,6 +4829,36 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                 {pskrStatus?.running ? ` · ${t('bo.feedUp', { n: pskrStatus.received ?? 0 })}` : ''}
               </p>
             )}
+
+            {/* What counts as "I already have this square". There is no single
+                right answer — a VUCC chaser counts a square per band, someone
+                filling a wall map counts it once — so it is a choice, and the
+                same six GridTracker offers, because a square wanted in one and
+                not the other is a bug report every time. */}
+            <div className="pl-6 space-y-1.5 pt-1">
+              <div className="flex items-center gap-2 flex-wrap">
+                <span className="text-xs text-muted-foreground w-28 shrink-0">{t('gsc.scope')}</span>
+                <Select value={gridScope.scope} onValueChange={(v) => saveGridScope({ ...gridScope, scope: v })}>
+                  <SelectTrigger className="h-7 w-64 text-xs"><SelectValue /></SelectTrigger>
+                  <SelectContent>
+                    {(gridScope.scopes ?? []).map((s: any) => (
+                      <SelectItem key={s.key} value={s.key}>{t(`gsc.scope_${s.key}`)}</SelectItem>
+                    ))}
+                  </SelectContent>
+                </Select>
+              </div>
+              <div className="flex items-center gap-2 flex-wrap">
+                <span className="text-xs text-muted-foreground w-28 shrink-0">{t('gsc.hunt')}</span>
+                <Select value={gridScope.hunt} onValueChange={(v) => saveGridScope({ ...gridScope, hunt: v })}>
+                  <SelectTrigger className="h-7 w-64 text-xs"><SelectValue /></SelectTrigger>
+                  <SelectContent>
+                    <SelectItem value="new">{t('gsc.huntNew')}</SelectItem>
+                    <SelectItem value="new_unconfirmed">{t('gsc.huntUnconf')}</SelectItem>
+                  </SelectContent>
+                </Select>
+              </div>
+              <p className="text-[11px] text-muted-foreground leading-relaxed">{t('gsc.hint')}</p>
+            </div>
           </div>
 
           {/* Chase new — its own option, NOT nested under grid chasing. Chasing
@@ -4623,6 +4899,28 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                     );
                   })}
                 </div>
+                {/* How near a RECEIVER has to be. This is the whole premise of
+                    the watch — a report is evidence about YOUR path only if it
+                    was collected near you — and the right distance differs by
+                    band, so it is the operator's call. Committed on blur/Enter,
+                    not per keystroke: each save restarts the feed. */}
+                <div className="flex items-center gap-2 flex-wrap">
+                  <span className="text-xs text-muted-foreground">{t('bo.nearKm')}</span>
+                  <Input
+                    type="number" min={25} max={1000} step={25}
+                    className="w-24 h-7 text-xs"
+                    defaultValue={bandOpen.near_km ?? 300}
+                    key={`nk-${bandOpen.near_km ?? 300}`}
+                    onBlur={(e) => {
+                      const v = parseInt(e.target.value, 10);
+                      if (!isNaN(v) && v !== bandOpen.near_km) saveBandOpen({ ...bandOpen, near_km: v });
+                    }}
+                    onKeyDown={(e) => { if (e.key === 'Enter') (e.target as HTMLInputElement).blur(); }}
+                  />
+                  <span className="text-xs text-muted-foreground">km</span>
+                </div>
+                <p className="text-[11px] text-muted-foreground leading-relaxed">{t('bo.nearKmHint')}</p>
+
                 {/* A live count, because a feed that is connected but silent looks
                     exactly like one that is broken until a number moves. */}
                 <p className="text-xs text-muted-foreground">
@@ -6539,6 +6837,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     'lists-bands':  BandsPanel,
     'lists-modes':  ModesPanel,
     cluster:        ClusterPanel,
+    ftx:            FtxPanel,
     udp:            UDPIntegrationsPanelWrapper,
     // Module-scope components, wrapped so their props can be passed. The nested
     // panels below go through PanelHost instead — which is what now lets either

frontend/src/components/StationControlPanel.tsx

@@ -3,6 +3,7 @@ import { Plus, Pencil, Trash2, Power, PlugZap, Loader2, Check, X, Compass, Squar
 import { Button } from '@/components/ui/button';
 import { Input } from '@/components/ui/input';
 import { Label } from '@/components/ui/label';
+import { Checkbox } from '@/components/ui/checkbox';
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select';
 import { cn } from '@/lib/utils';
 import { useI18n } from '@/lib/i18n';
@@ -82,7 +83,7 @@ type Device = {
   id: string; type: string; name: string; host: string;
   user?: string; pass?: string; channels?: number; labels: string[];
   // Generic HTTP board only. The per-relay URLs win over the patterns.
-  on_urls?: string[]; off_urls?: string[]; on_pattern?: string; off_pattern?: string;
+  on_urls?: string[]; off_urls?: string[]; on_pattern?: string; off_pattern?: string; insecure_tls?: boolean;
 };
 type Relay = { number: number; label: string; on: boolean };
 type DevStatus = { id: string; name: string; type: string; connected: boolean; error?: string; relays: Relay[] };
@@ -787,6 +788,12 @@ function DeviceEditor({ device, onChange, onSave, onCancel, t }: {
     && [...(device.on_urls ?? []), ...(device.off_urls ?? []), device.on_pattern ?? '', device.off_pattern ?? '']
       .some((s) => (s ?? '').includes('{value}'))
     && device.labels.some((l) => !l.trim());
+  // Any https:// among this board's URLs. A relay box on the LAN signs its own
+  // certificate, so HTTPS to one cannot be verified — the operator has to say
+  // whether to accept that, and the question only arises once they type https.
+  const usesHTTPS = isHTTPGen
+    && [...(device.on_urls ?? []), ...(device.off_urls ?? []), device.on_pattern ?? '', device.off_pattern ?? '']
+      .some((u) => (u ?? '').trim().toLowerCase().startsWith('https://'));
   // COM ports for the generic USB-serial relay picker.
   const [serialPorts, setSerialPorts] = useState<string[]>([]);
   useEffect(() => {
@@ -959,6 +966,19 @@ function DeviceEditor({ device, onChange, onSave, onCancel, t }: {
             </div>
           </div>
           <div className="text-[10px] text-muted-foreground">{t('station.patternHint')}</div>
+          {/* Shown only once an https:// URL is actually in use. A board on
+              plain HTTP has no certificate to argue about, and an option that
+              cannot matter yet is one more thing to wonder about. */}
+          {usesHTTPS && (
+            <label className="flex items-start gap-2 text-xs cursor-pointer">
+              <Checkbox className="mt-0.5" checked={!!device.insecure_tls}
+                onCheckedChange={(c) => onChange({ ...device, insecure_tls: !!c })} />
+              <span>
+                {t('station.insecureTls')}
+                <span className="block text-[10px] text-muted-foreground">{t('station.insecureTlsHint')}</span>
+              </span>
+            </label>
+          )}
           <div className="space-y-1">
             <Label>{t('station.perRelayUrls')}</Label>
             <div className="space-y-1">

frontend/src/components/UDPIntegrationsPanel.tsx

@@ -24,7 +24,7 @@ type UDPConfig = {
   direction: 'inbound' | 'outbound';
   name: string;
   port: number;
-  service_type: 'wsjt' | 'adif' | 'n1mm' | 'remote_call' | 'db_updated' | 'pstrotator_freq' | 'n1mm_radioinfo' | 'wsjt_log' | 'custom';
+  service_type: 'wsjt' | 'adif' | 'n1mm' | 'remote_call' | 'db_updated' | 'pstrotator_freq' | 'n1mm_radioinfo' | 'wsjt_log' | 'wsjt_relay' | 'custom';
   // Custom rows only.
   trigger?: string;
   template?: string;
@@ -95,6 +95,19 @@ const SERVICE_TYPES: Array<{
     hint: 'udpp.svcWsjtLogHint',
     defaults: { port: 2250, destination_ip: '127.0.0.1' },
   },
+  {
+    // Feeds a SECOND application the stream this OpsLog receives. WSJT-X, JTDX
+    // and MSHV each send to ONE address, so without a relay the choice is
+    // between OpsLog and JTAlert/GridTracker rather than both.
+    //
+    // 2238 by default: beside the 2237 the sender uses, and free. Pointing it AT
+    // 2237 would name an OpsLog listener, which the relay refuses.
+    id: 'wsjt_relay',
+    direction: 'outbound',
+    label: 'udpp.svcWsjtRelayLabel',
+    hint: 'udpp.svcWsjtRelayHint',
+    defaults: { port: 2238, destination_ip: '127.0.0.1' },
+  },
   {
     // The general case: the operator picks the moment and writes the message.
     // Mainly for antenna switches, which are driven by a URL and want the band

frontend/src/components/WorkedBeforeGrid.tsx

@@ -298,6 +298,20 @@ export function WorkedBeforeGrid({ wb, myGrid, busy, currentCall, onRowDoubleCli
               {t('wbg.pickerDesc')}
             </DialogDescription>
           </DialogHeader>
+          {/* Whole-dialog controls — the award columns included, which the
+              catalogue-only helpers do not cover. */}
+          <div className="flex items-center gap-1 px-5 text-[11px] text-muted-foreground">
+            <span>{t('wbg.allGroups')}</span>
+            <button type="button" className="text-[11px] text-primary hover:underline px-1"
+              onClick={() => { showAll(); (awardCols ?? []).forEach((a) => setColVisible(`award_${a.code}`, true)); }}>
+              {t('wbg.all')}
+            </button>
+            <span className="opacity-40">·</span>
+            <button type="button" className="text-[11px] text-muted-foreground hover:underline px-1"
+              onClick={() => { hideAll(); (awardCols ?? []).forEach((a) => setColVisible(`award_${a.code}`, false)); }}>
+              {t('wbg.none')}
+            </button>
+          </div>
           <div className="grid grid-cols-2 gap-4 max-h-[60vh] overflow-y-auto px-5 py-3">
             {GROUP_ORDER.map((group) => {
               const cols = COL_CATALOG.filter((c) => c.group === group);

frontend/src/lib/autocall.ts

@@ -0,0 +1,176 @@
+// Auto-call: let OpsLog answer a decode without the operator clicking it.
+//
+// This KEYS THE TRANSMITTER on its own, which is why the rules here are written
+// as a series of refusals rather than a search for a reason to call. Everything
+// below has to be true; anything unknown means no.
+//
+// The decision is made here, in one pure function, precisely because it is the
+// dangerous part: it can be read, argued with and tested without a radio.
+
+export type AutoCallCriteria = {
+  dxcc: boolean;      // entity never worked
+  band: boolean;      // entity never worked on this band
+  mode: boolean;      // entity never worked in this mode
+  slot: boolean;      // band and mode each worked, never together
+  grid: boolean;      // square wanted under the grid scope
+  county: boolean;    // US county never worked
+  pota: boolean;      // park never worked
+  sota: boolean;      // summit never worked (spot-tagged only)
+  pfx: boolean;       // CQ WPX prefix never worked
+};
+
+export type AutoCallSettings = {
+  enabled: boolean;
+  criteria: AutoCallCriteria;
+  // Callsigns to answer on sight, wildcards allowed (4S7*, */P). Each is still
+  // subject to `watchCriteria` — "call TM0HQ, but only if it is a new band" is
+  // the request, not "call it every time it appears".
+  watch: string[];
+  // Empty means call a watched callsign whenever it is not already worked.
+  watchCriteria: AutoCallCriteria;
+  // Seconds to ignore a callsign after calling it, so a station that keeps
+  // sending CQ is not re-answered every slot while the QSO is in progress.
+  cooldownSec: number;
+};
+
+export const emptyCriteria: AutoCallCriteria = {
+  dxcc: false, band: false, mode: false, slot: false,
+  grid: false, county: false, pota: false, sota: false, pfx: false,
+};
+
+export const defaultAutoCall: AutoCallSettings = {
+  // OFF, and it stays off until asked for. Unattended transmit is not something
+  // to inherit from an upgrade.
+  enabled: false,
+  criteria: { ...emptyCriteria },
+  watch: [],
+  watchCriteria: { ...emptyCriteria },
+  cooldownSec: 120,
+};
+
+const AC_KEY = 'opslog.autoCall';
+
+export function loadAutoCall(): AutoCallSettings {
+  try {
+    const raw = localStorage.getItem(AC_KEY);
+    if (!raw) return { ...defaultAutoCall };
+    const v = JSON.parse(raw);
+    return {
+      ...defaultAutoCall,
+      ...v,
+      criteria: { ...emptyCriteria, ...(v?.criteria ?? {}) },
+      watchCriteria: { ...emptyCriteria, ...(v?.watchCriteria ?? {}) },
+      watch: Array.isArray(v?.watch) ? v.watch : [],
+    };
+  } catch { return { ...defaultAutoCall }; }
+}
+
+export const autoCallKey = AC_KEY;
+
+// A decode's resolved novelty, the same shape the panel already renders from.
+export type DecodeStatus = {
+  status?: string;
+  worked_call?: boolean;
+  new_grid?: boolean;
+  grid_state?: string;
+  new_county?: boolean;
+  new_pota?: boolean;
+  new_pfx?: boolean;
+};
+
+// matchesWildcard is the same rule the alert filters use: * is any run, ? is one.
+export function matchesWildcard(pattern: string, call: string): boolean {
+  const p = pattern.trim().toUpperCase();
+  const c = call.trim().toUpperCase();
+  if (!p) return false;
+  const re = new RegExp('^' + p.split('').map((ch) => (
+    ch === '*' ? '.*' : ch === '?' ? '.' : ch.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  )).join('') + '$');
+  return re.test(c);
+}
+
+// anyCriterion is false for an all-off set, which is what makes "watch this
+// callsign, no conditions" expressible.
+function anyCriterion(c: AutoCallCriteria): boolean {
+  return Object.values(c).some(Boolean);
+}
+
+// meets reports whether a decode satisfies at least one ticked criterion.
+function meets(c: AutoCallCriteria, e: DecodeStatus): boolean {
+  if (c.dxcc && e.status === 'new') return true;
+  if (c.band && e.status === 'new-band') return true;
+  if (c.mode && e.status === 'new-mode') return true;
+  if (c.slot && e.status === 'new-slot') return true;
+  // A square that is merely UNCONFIRMED is not called: the QSO is already made,
+  // and calling again would work a duplicate to chase a QSL.
+  if (c.grid && e.new_grid && e.grid_state !== 'unconf') return true;
+  if (c.county && e.new_county) return true;
+  if (c.pota && e.new_pota) return true;
+  if (c.pfx && e.new_pfx) return true;
+  return false;
+}
+
+export type AutoCallDecode = {
+  call: string;
+  cq?: boolean;
+  msg?: string;
+  instance?: string;
+};
+
+// shouldAutoCall decides whether to answer one decode. The reason is returned
+// for the log: an automatic transmission with no record of WHY is the thing an
+// operator cannot argue with after the fact.
+export function shouldAutoCall(
+  s: AutoCallSettings,
+  d: AutoCallDecode,
+  e: DecodeStatus | undefined,
+  opts: {
+    // busy is "some receiver is mid-QSO", NOT "this one is transmitting".
+    //
+    // The distinction is the whole bug it fixes: with two instances the caller
+    // used to test a single global transmit flag, which belonged to whichever
+    // receiver reported last. So while slice A worked a station, slice B looked
+    // idle and auto-call started another QSO on it — and the moment either
+    // finished it chained straight into the next. One station at a time means
+    // one across ALL receivers, not one per receiver.
+    busy: boolean;
+    calledAt: Map<string, number>;
+    now: number;
+    myCall?: string;
+  },
+): { call: boolean; reason: string } {
+  const no = (why: string) => ({ call: false, reason: why });
+  if (!s.enabled) return no('off');
+  if (!e) return no('status not resolved yet');
+  const call = (d.call ?? '').trim().toUpperCase();
+  if (!call) return no('no callsign');
+  // Never answer ourselves, however the decode reached us.
+  if (opts.myCall && call === opts.myCall.trim().toUpperCase()) return no('own callsign');
+  // Only a CQ. Answering a station mid-QSO is both rude and futile — WSJT-X
+  // actions a Reply only for CQ and QRZ anyway.
+  if (!d.cq) return no('not a CQ');
+  // Not while ANY receiver is mid-QSO — transmitting, or holding a DX call it
+  // has not finished with. Starting a second exchange before the first is done
+  // is what turned this into a machine that called without stopping.
+  if (opts.busy) return no('a QSO is already in progress');
+  const last = opts.calledAt.get(call);
+  if (last !== undefined && opts.now - last < s.cooldownSec * 1000) return no('called recently');
+
+  // The watch list first: an explicitly named station outranks the general
+  // criteria, and may carry conditions of its own.
+  const watched = s.watch.some((p) => matchesWildcard(p, call));
+  if (watched) {
+    if (!anyCriterion(s.watchCriteria)) {
+      // No conditions attached: call it unless it is already worked.
+      return e.worked_call ? no('watched, but already worked') : { call: true, reason: 'watch list' };
+    }
+    return meets(s.watchCriteria, e)
+      ? { call: true, reason: 'watch list + criteria' }
+      : no('watched, but no criterion met');
+  }
+
+  if (!anyCriterion(s.criteria)) return no('no criteria ticked');
+  return meets(s.criteria, e)
+    ? { call: true, reason: 'criteria' }
+    : no('no criterion met');
+}

frontend/src/lib/matrixColors.ts

@@ -0,0 +1,66 @@
+// Operator overrides for the band/mode matrix palette.
+//
+// Applied as inline custom properties on <html>, which is what lets them be
+// OVERRIDES rather than a palette: the twelve themes each define their own
+// --mx-* ramp in style.css, an inline value wins over all of them, and removing
+// it hands the colour straight back to the theme. Nothing has to know which
+// theme is active, and switching theme with overrides off is a clean revert.
+
+export type MatrixColors = {
+  enabled: boolean;
+  call_confirmed: string;
+  call_worked: string;
+  entity_confirmed: string;
+  entity_worked: string;
+  not_worked: string;
+  current_entry: string;
+};
+
+// The six settings fields and the CSS custom property each one drives. Also the
+// display order — the same order the legend under the matrix reads in, so the
+// settings panel and the grid can never disagree about which green is which.
+export const MATRIX_VARS: { key: keyof Omit<MatrixColors, 'enabled'>; cssVar: string; label: string }[] = [
+  { key: 'call_confirmed',   cssVar: '--mx-call-conf', label: 'mx.callConf' },
+  { key: 'call_worked',      cssVar: '--mx-call-work', label: 'mx.callWork' },
+  { key: 'entity_confirmed', cssVar: '--mx-dx-conf',   label: 'mx.dxConf' },
+  { key: 'entity_worked',    cssVar: '--mx-dx-work',   label: 'mx.dxWork' },
+  { key: 'not_worked',       cssVar: '--mx-none',      label: 'mx.none' },
+  { key: 'current_entry',    cssVar: '--mx-cur',       label: 'mx.current' },
+];
+
+export const emptyMatrixColors = (): MatrixColors => ({
+  enabled: false,
+  call_confirmed: '', call_worked: '', entity_confirmed: '',
+  entity_worked: '', not_worked: '', current_entry: '',
+});
+
+// applyMatrixColors stamps (or clears) the overrides on <html>. Safe to call as
+// often as you like — it is the whole rendering path, so the settings panel uses
+// it for a live preview and the app uses it once at startup.
+export function applyMatrixColors(c?: MatrixColors | null): void {
+  const root = document.documentElement;
+  for (const { key, cssVar } of MATRIX_VARS) {
+    const v = c?.enabled ? String(c[key] ?? '').trim() : '';
+    if (v) root.style.setProperty(cssVar, v);
+    else root.style.removeProperty(cssVar);
+  }
+}
+
+// effectiveMatrixColor reads what the matrix is ACTUALLY painting right now —
+// the override if there is one, else the active theme's value. It is what seeds
+// the colour pickers, so the operator starts from the colours in front of them
+// instead of from a hardcoded palette that may belong to a different theme.
+//
+// A custom property's computed value has its var() references substituted, so
+// --mx-cur resolves to the theme's --warning rather than to the literal text.
+export function effectiveMatrixColor(cssVar: string): string {
+  try {
+    const v = getComputedStyle(document.documentElement).getPropertyValue(cssVar).trim();
+    // <input type="color"> only accepts #rrggbb. Anything else (a theme that
+    // ever moves to oklch, an empty read during boot) falls back to mid grey
+    // rather than silently resetting the picker to black.
+    return /^#[0-9a-f]{6}$/i.test(v) ? v.toLowerCase() : '#808080';
+  } catch {
+    return '#808080';
+  }
+}

frontend/src/lib/rotorHeading.ts

@@ -36,6 +36,14 @@ let timer: number | undefined;
 let inFlight = false;
 let lastAz: number | null = null;
 let lastMoveAt = 0;
+// The last heading anyone received, replayed to whoever subscribes next.
+//
+// Without it, opening Station Control left the compass blank for one or two
+// seconds while every other panel filled at once. Nothing was slow: the status
+// bar already had the loop running with a tick pending, so a component mounting
+// halfway through an idle interval simply waited out the rest of it. The
+// heading was known the whole time — it just had nowhere to be read from.
+let last: RotorHeading | null = null;
 
 function schedule(delay: number) {
   if (timer !== undefined) window.clearTimeout(timer);
@@ -54,6 +62,7 @@ async function tick() {
       if (lastAz !== null && h.azimuth !== lastAz) lastMoveAt = Date.now();
       lastAz = h.azimuth;
     }
+    last = h;
     subs.forEach((fn) => { try { fn(h); } catch { /* a subscriber must not stop the loop */ } });
   } catch {
     // Leave the last heading alone: a single failed poll on a shared serial port
@@ -69,6 +78,12 @@ async function tick() {
 // unsubscribe. The loop stops when the last subscriber leaves.
 export function subscribeRotorHeading(fn: (h: RotorHeading) => void): () => void {
   subs.add(fn);
+  // Hand over what is already known, at once. An Alpha SPID poll is an open,
+  // a read at 600 baud and a close, so even an immediate one takes a moment —
+  // the cached heading is what makes the compass appear with the panel rather
+  // than after it. In a microtask, so a subscriber is never called back before
+  // subscribeRotorHeading has returned to it.
+  if (last) { const h = last; queueMicrotask(() => { if (subs.has(fn)) fn(h); }); }
   if (timer === undefined && !inFlight) void tick();
   return () => {
     subs.delete(fn);

frontend/src/lib/uiPref.ts

@@ -17,6 +17,8 @@ const PORTABLE_KEYS = [
   'opslog.autofocusWB',   // auto-focus Worked-before
   'hamlog.filterPresets', // Filter Builder saved presets
   'opslog.showRotor',     // rotor compass shown next to the keyers
+  'opslog.rotorCompact',  // rotor widget: dial + SP/LP only, no quick-turn buttons or Stop
+  'opslog.decodesGridMap',// FT decodes tab: grid-square map shown beside the table
   'opslog.showChaseNew',  // Chase New panel shown next to the keyers
   'opslog.showAmpWidget', // amplifier widget shown next to the keyers
   'opslog.ampSel.widget', // which amplifier that widget shows ("all" or an amp id)
@@ -44,6 +46,8 @@ const PORTABLE_KEYS = [
   'opslog.clusterSlotHighlight', // cluster/band map: colour calls not worked on this band+mode
   'opslog.bandMapWidth',    // docked band map: column width (px)
   'opslog.bandMapTabWidth', // Band map tab: shared card width (px)
+  'opslog.bandMapZoom',     // band map zoom (px/kHz step) remembered per band, as one {band: index} map
+  'opslog.decodeColWidths', // FT decodes table: per-column widths (px), as one {col: px} map
   // 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

@@ -85,6 +85,12 @@
   --mx-dx-conf:   #3730a3;   /* entity confirmed*/
   --mx-dx-work:   #a5b4fc;   /* entity worked   */
   --mx-none:      #e7e5e4;   /* never worked    */
+  /* Ring on the cell the operator is entering. Declared ONCE, on :root, and
+     deliberately not repeated per theme: it follows --warning, which every theme
+     already tunes to its own background. The token exists so the matrix ring can
+     be recoloured on its own without dragging every other warning in the app
+     with it (Appearance → matrix colours). */
+  --mx-cur: var(--warning);
 
   --scrollbar-thumb: #b8a880;
   --scrollbar-thumb-hover: #968455;
@@ -974,6 +980,7 @@
   --color-mx-dx-conf: var(--mx-dx-conf);
   --color-mx-dx-work: var(--mx-dx-work);
   --color-mx-none: var(--mx-none);
+  --color-mx-cur: var(--mx-cur);
 
   --radius: 0.5rem;
 

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

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

@@ -53,6 +53,8 @@ export function AmpPower(arg1:string,arg2:boolean):Promise<void>;
 
 export function AmpPowerLevel(arg1:string,arg2:string):Promise<void>;
 
+export function AnswerDecode(arg1:string,arg2:number,arg3:number,arg4:number,arg5:number,arg6:string,arg7:string,arg8:boolean):Promise<void>;
+
 export function AntGeniusActivate(arg1:number,arg2:number):Promise<void>;
 
 export function AntGeniusDeselect(arg1:number):Promise<void>;
@@ -355,6 +357,8 @@ export function FlexSetXITFreq(arg1:number):Promise<void>;
 
 export function FlexStopCW():Promise<void>;
 
+export function FlexTXOnBand(arg1:string):Promise<void>;
+
 export function FlexTune(arg1:boolean):Promise<void>;
 
 export function GetACOMStatus():Promise<acom.Status>;
@@ -457,6 +461,8 @@ export function GetFolderSyncStatus():Promise<main.FolderSyncStatus>;
 
 export function GetGridCacheStatus():Promise<main.GridCacheStatus>;
 
+export function GetGridScopeSettings():Promise<main.GridScopeSettings>;
+
 export function GetIcomState():Promise<cat.IcomTXState>;
 
 export function GetLinkedAmps():Promise<Array<string>>;
@@ -477,6 +483,8 @@ export function GetLogbookRevision():Promise<string>;
 
 export function GetLookupSettings():Promise<main.LookupSettings>;
 
+export function GetMatrixColors():Promise<main.MatrixColors>;
+
 export function GetMySQLSettings():Promise<main.MySQLSettings>;
 
 export function GetOfflineStatus():Promise<main.OfflineStatus>;
@@ -511,6 +519,8 @@ export function GetRotatorHeading():Promise<main.RotatorHeading>;
 
 export function GetRotators():Promise<Array<main.RotatorDevice>>;
 
+export function GetRotorPresets():Promise<Array<main.RotorPreset>>;
+
 export function GetRowColors():Promise<main.RowColorSettings>;
 
 export function GetSPEStatus():Promise<spe.Status>;
@@ -563,6 +573,10 @@ export function GetWorkedCallVariants():Promise<boolean>;
 
 export function GetYaesuState():Promise<cat.YaesuTXState>;
 
+export function GridSquares(arg1:string):Promise<Array<qso.GridSquare>>;
+
+export function HaltDecodeTx(arg1:string,arg2:boolean):Promise<void>;
+
 export function HasBuiltinReferences(arg1:string):Promise<boolean>;
 
 export function IcomRefresh():Promise<void>;
@@ -861,6 +875,8 @@ export function ReloadUDPIntegrations():Promise<Array<string>>;
 
 export function RemovePassphrase(arg1:string):Promise<void>;
 
+export function RenameAwardReference(arg1:string,arg2:string,arg3:string):Promise<void>;
+
 export function RenameDatabase(arg1:string):Promise<void>;
 
 export function RenameLogbook(arg1:string):Promise<void>;
@@ -879,6 +895,8 @@ export function ResetAwardDefs():Promise<Array<award.Def>>;
 
 export function ResetDatabaseToDefault():Promise<void>;
 
+export function ResetRotorPresets():Promise<Array<main.RotorPreset>>;
+
 export function RestartApp():Promise<void>;
 
 export function RestartQSORecorder():Promise<void>;
@@ -943,10 +961,14 @@ export function SaveFlexBandPower(arg1:Record<string, main.FlexBandPower>):Promi
 
 export function SaveFolderSync(arg1:main.FolderSyncConfig):Promise<void>;
 
+export function SaveGridScopeSettings(arg1:main.GridScopeSettings):Promise<void>;
+
 export function SaveListsSettings(arg1:main.ListsSettings):Promise<void>;
 
 export function SaveLookupSettings(arg1:main.LookupSettings):Promise<void>;
 
+export function SaveMatrixColors(arg1:main.MatrixColors):Promise<void>;
+
 export function SaveMySQLSettings(arg1:main.MySQLSettings):Promise<void>;
 
 export function SaveOperatingAntenna(arg1:operating.Antenna):Promise<operating.Antenna>;
@@ -967,6 +989,8 @@ export function SaveRelayAuto(arg1:main.RelayAutoConfig):Promise<void>;
 
 export function SaveRotators(arg1:Array<main.RotatorDevice>):Promise<void>;
 
+export function SaveRotorPresets(arg1:Array<main.RotorPreset>):Promise<void>;
+
 export function SaveRowColors(arg1:main.RowColorSettings):Promise<void>;
 
 export function SaveSelfSpotSettings(arg1:main.SelfSpotSettings):Promise<void>;
@@ -997,6 +1021,8 @@ export function SendClusterCommand(arg1:string):Promise<void>;
 
 export function SendClusterSpot(arg1:string,arg2:number,arg3:string):Promise<void>;
 
+export function SendDecodeFreeText(arg1:string,arg2:string,arg3:boolean):Promise<void>;
+
 export function SendEQSL(arg1:number,arg2:number,arg3:string):Promise<void>;
 
 export function SendLogToDeveloper():Promise<void>;

frontend/wailsjs/go/main/App.js

@@ -46,6 +46,10 @@ export function AmpPowerLevel(arg1, arg2) {
   return window['go']['main']['App']['AmpPowerLevel'](arg1, arg2);
 }
 
+export function AnswerDecode(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) {
+  return window['go']['main']['App']['AnswerDecode'](arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+}
+
 export function AntGeniusActivate(arg1, arg2) {
   return window['go']['main']['App']['AntGeniusActivate'](arg1, arg2);
 }
@@ -650,6 +654,10 @@ export function FlexStopCW() {
   return window['go']['main']['App']['FlexStopCW']();
 }
 
+export function FlexTXOnBand(arg1) {
+  return window['go']['main']['App']['FlexTXOnBand'](arg1);
+}
+
 export function FlexTune(arg1) {
   return window['go']['main']['App']['FlexTune'](arg1);
 }
@@ -854,6 +862,10 @@ export function GetGridCacheStatus() {
   return window['go']['main']['App']['GetGridCacheStatus']();
 }
 
+export function GetGridScopeSettings() {
+  return window['go']['main']['App']['GetGridScopeSettings']();
+}
+
 export function GetIcomState() {
   return window['go']['main']['App']['GetIcomState']();
 }
@@ -894,6 +906,10 @@ export function GetLookupSettings() {
   return window['go']['main']['App']['GetLookupSettings']();
 }
 
+export function GetMatrixColors() {
+  return window['go']['main']['App']['GetMatrixColors']();
+}
+
 export function GetMySQLSettings() {
   return window['go']['main']['App']['GetMySQLSettings']();
 }
@@ -962,6 +978,10 @@ export function GetRotators() {
   return window['go']['main']['App']['GetRotators']();
 }
 
+export function GetRotorPresets() {
+  return window['go']['main']['App']['GetRotorPresets']();
+}
+
 export function GetRowColors() {
   return window['go']['main']['App']['GetRowColors']();
 }
@@ -1066,6 +1086,14 @@ export function GetYaesuState() {
   return window['go']['main']['App']['GetYaesuState']();
 }
 
+export function GridSquares(arg1) {
+  return window['go']['main']['App']['GridSquares'](arg1);
+}
+
+export function HaltDecodeTx(arg1, arg2) {
+  return window['go']['main']['App']['HaltDecodeTx'](arg1, arg2);
+}
+
 export function HasBuiltinReferences(arg1) {
   return window['go']['main']['App']['HasBuiltinReferences'](arg1);
 }
@@ -1662,6 +1690,10 @@ export function RemovePassphrase(arg1) {
   return window['go']['main']['App']['RemovePassphrase'](arg1);
 }
 
+export function RenameAwardReference(arg1, arg2, arg3) {
+  return window['go']['main']['App']['RenameAwardReference'](arg1, arg2, arg3);
+}
+
 export function RenameDatabase(arg1) {
   return window['go']['main']['App']['RenameDatabase'](arg1);
 }
@@ -1698,6 +1730,10 @@ export function ResetDatabaseToDefault() {
   return window['go']['main']['App']['ResetDatabaseToDefault']();
 }
 
+export function ResetRotorPresets() {
+  return window['go']['main']['App']['ResetRotorPresets']();
+}
+
 export function RestartApp() {
   return window['go']['main']['App']['RestartApp']();
 }
@@ -1826,6 +1862,10 @@ export function SaveFolderSync(arg1) {
   return window['go']['main']['App']['SaveFolderSync'](arg1);
 }
 
+export function SaveGridScopeSettings(arg1) {
+  return window['go']['main']['App']['SaveGridScopeSettings'](arg1);
+}
+
 export function SaveListsSettings(arg1) {
   return window['go']['main']['App']['SaveListsSettings'](arg1);
 }
@@ -1834,6 +1874,10 @@ export function SaveLookupSettings(arg1) {
   return window['go']['main']['App']['SaveLookupSettings'](arg1);
 }
 
+export function SaveMatrixColors(arg1) {
+  return window['go']['main']['App']['SaveMatrixColors'](arg1);
+}
+
 export function SaveMySQLSettings(arg1) {
   return window['go']['main']['App']['SaveMySQLSettings'](arg1);
 }
@@ -1874,6 +1918,10 @@ export function SaveRotators(arg1) {
   return window['go']['main']['App']['SaveRotators'](arg1);
 }
 
+export function SaveRotorPresets(arg1) {
+  return window['go']['main']['App']['SaveRotorPresets'](arg1);
+}
+
 export function SaveRowColors(arg1) {
   return window['go']['main']['App']['SaveRowColors'](arg1);
 }
@@ -1934,6 +1982,10 @@ export function SendClusterSpot(arg1, arg2, arg3) {
   return window['go']['main']['App']['SendClusterSpot'](arg1, arg2, arg3);
 }
 
+export function SendDecodeFreeText(arg1, arg2, arg3) {
+  return window['go']['main']['App']['SendDecodeFreeText'](arg1, arg2, arg3);
+}
+
 export function SendEQSL(arg1, arg2, arg3) {
   return window['go']['main']['App']['SendEQSL'](arg1, arg2, arg3);
 }

frontend/wailsjs/go/models.ts

@@ -2001,6 +2001,7 @@ export namespace main {
 	    enabled: boolean;
 	    bands: string[];
 	    available: string[];
+	    near_km: number;
 	
 	    static createFrom(source: any = {}) {
 	        return new BandOpenSettings(source);
@@ -2011,6 +2012,7 @@ export namespace main {
 	        this.enabled = source["enabled"];
 	        this.bands = source["bands"];
 	        this.available = source["available"];
+	        this.near_km = source["near_km"];
 	    }
 	}
 	export class CATSettings {
@@ -2021,6 +2023,7 @@ export namespace main {
 	    flex_host: string;
 	    flex_port: number;
 	    flex_spots: boolean;
+	    flex_dvk_dax: boolean;
 	    flex_decode_spots: boolean;
 	    flex_decode_secs: number;
 	    xiegu_port: string;
@@ -2047,9 +2050,13 @@ export namespace main {
 	    tci_spots: boolean;
 	    poll_ms: number;
 	    delay_ms: number;
+	    offset_on: boolean;
+	    offset_hz: number;
 	    digital_default: string;
 	    share_enabled: boolean;
 	    share_port: number;
+	    share_proto: string;
+	    share_tci_port: number;
 	    ptt_hotkey_enabled: boolean;
 	    ptt_hotkey: string;
 	    ptt_hotkey_toggle: boolean;
@@ -2067,6 +2074,7 @@ export namespace main {
 	        this.flex_host = source["flex_host"];
 	        this.flex_port = source["flex_port"];
 	        this.flex_spots = source["flex_spots"];
+	        this.flex_dvk_dax = source["flex_dvk_dax"];
 	        this.flex_decode_spots = source["flex_decode_spots"];
 	        this.flex_decode_secs = source["flex_decode_secs"];
 	        this.xiegu_port = source["xiegu_port"];
@@ -2093,9 +2101,13 @@ export namespace main {
 	        this.tci_spots = source["tci_spots"];
 	        this.poll_ms = source["poll_ms"];
 	        this.delay_ms = source["delay_ms"];
+	        this.offset_on = source["offset_on"];
+	        this.offset_hz = source["offset_hz"];
 	        this.digital_default = source["digital_default"];
 	        this.share_enabled = source["share_enabled"];
 	        this.share_port = source["share_port"];
+	        this.share_proto = source["share_proto"];
+	        this.share_tci_port = source["share_tci_port"];
 	        this.ptt_hotkey_enabled = source["ptt_hotkey_enabled"];
 	        this.ptt_hotkey = source["ptt_hotkey"];
 	        this.ptt_hotkey_toggle = source["ptt_hotkey_toggle"];
@@ -2557,6 +2569,56 @@ export namespace main {
 	        this.pending = source["pending"];
 	    }
 	}
+	export class gridScope {
+	    key: string;
+	    band: boolean;
+	    mode: string;
+	
+	    static createFrom(source: any = {}) {
+	        return new gridScope(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.key = source["key"];
+	        this.band = source["band"];
+	        this.mode = source["mode"];
+	    }
+	}
+	export class GridScopeSettings {
+	    scope: string;
+	    hunt: string;
+	    scopes: gridScope[];
+	
+	    static createFrom(source: any = {}) {
+	        return new GridScopeSettings(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.scope = source["scope"];
+	        this.hunt = source["hunt"];
+	        this.scopes = this.convertValues(source["scopes"], gridScope);
+	    }
+	
+		convertValues(a: any, classs: any, asMap: boolean = false): any {
+		    if (!a) {
+		        return a;
+		    }
+		    if (a.slice && a.map) {
+		        return (a as any[]).map(elem => this.convertValues(elem, classs));
+		    } else if ("object" === typeof a) {
+		        if (asMap) {
+		            for (const key of Object.keys(a)) {
+		                a[key] = new classs(a[key]);
+		            }
+		            return a;
+		        }
+		        return new classs(a);
+		    }
+		    return a;
+		}
+	}
 	export class ModePreset {
 	    name: string;
 	    default_rst_sent?: string;
@@ -2679,6 +2741,30 @@ export namespace main {
 	        this.cache_ttl_days = source["cache_ttl_days"];
 	    }
 	}
+	export class MatrixColors {
+	    enabled: boolean;
+	    call_confirmed: string;
+	    call_worked: string;
+	    entity_confirmed: string;
+	    entity_worked: string;
+	    not_worked: string;
+	    current_entry: string;
+	
+	    static createFrom(source: any = {}) {
+	        return new MatrixColors(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.enabled = source["enabled"];
+	        this.call_confirmed = source["call_confirmed"];
+	        this.call_worked = source["call_worked"];
+	        this.entity_confirmed = source["entity_confirmed"];
+	        this.entity_worked = source["entity_worked"];
+	        this.not_worked = source["not_worked"];
+	        this.current_entry = source["current_entry"];
+	    }
+	}
 	
 	export class MySQLSettings {
 	    enabled: boolean;
@@ -3178,6 +3264,20 @@ export namespace main {
 	        this.motorized = source["motorized"];
 	    }
 	}
+	export class RotorPreset {
+	    label: string;
+	    azimuth: number;
+	
+	    static createFrom(source: any = {}) {
+	        return new RotorPreset(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.label = source["label"];
+	        this.azimuth = source["azimuth"];
+	    }
+	}
 	export class RowColorRule {
 	    id: string;
 	    color: string;
@@ -3314,6 +3414,7 @@ export namespace main {
 	    new_pota: boolean;
 	    grid?: string;
 	    new_grid: boolean;
+	    grid_state?: string;
 	    spotter_continent?: string;
 	    lotw: boolean;
 	    new_pfx: boolean;
@@ -3339,6 +3440,7 @@ export namespace main {
 	        this.new_pota = source["new_pota"];
 	        this.grid = source["grid"];
 	        this.new_grid = source["new_grid"];
+	        this.grid_state = source["grid_state"];
 	        this.spotter_continent = source["spotter_continent"];
 	        this.lotw = source["lotw"];
 	        this.new_pfx = source["new_pfx"];
@@ -3375,6 +3477,7 @@ export namespace main {
 	    off_urls?: string[];
 	    on_pattern?: string;
 	    off_pattern?: string;
+	    insecure_tls?: boolean;
 	
 	    static createFrom(source: any = {}) {
 	        return new StationDevice(source);
@@ -3394,6 +3497,7 @@ export namespace main {
 	        this.off_urls = source["off_urls"];
 	        this.on_pattern = source["on_pattern"];
 	        this.off_pattern = source["off_pattern"];
+	        this.insecure_tls = source["insecure_tls"];
 	    }
 	}
 	export class StationRelay {
@@ -4469,6 +4573,26 @@ export namespace qso {
 	        this.minutes = source["minutes"];
 	    }
 	}
+	export class GridSquare {
+	    grid: string;
+	    count: number;
+	    confirmed: boolean;
+	    band?: string;
+	    mode?: string;
+	
+	    static createFrom(source: any = {}) {
+	        return new GridSquare(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.grid = source["grid"];
+	        this.count = source["count"];
+	        this.confirmed = source["confirmed"];
+	        this.band = source["band"];
+	        this.mode = source["mode"];
+	    }
+	}
 	export class ListFilter {
 	    callsign?: string;
 	    band?: string;

gridscope.go

@@ -0,0 +1,187 @@
+package main
+
+import (
+	"strings"
+
+	"hamlog/internal/award"
+	"hamlog/internal/qso"
+)
+
+// New-grid scoping: WHICH prior contacts count as "I already have this square".
+//
+// The question has no single right answer, which is why it is a setting rather
+// than a rule. A VUCC chaser counts a square per band; someone filling in a
+// wall map counts it once. GridTracker offers the same six combinations, and an
+// operator running both alongside each other needs them to agree — a square
+// "wanted" in one and not the other is a bug report every time.
+const (
+	keyGridScope = "grid.scope" // band+mode combination — see gridScopes
+	keyGridHunt  = "grid.hunt"  // "new" | "new_unconfirmed"
+)
+
+// gridScope is one band × mode combination.
+type gridScope struct {
+	Key string `json:"key"`
+	// Band is true when the square has to have been worked on THIS band. False
+	// is GridTracker's "Mix Bands": any band counts.
+	Band bool `json:"band"`
+	// Mode is how much of the mode matters:
+	//   "digi" — any digital mode at all
+	//   "ftx"  — any of the FT family (FT8/FT4/FT2)
+	//   "mode" — this exact mode and no other
+	Mode string `json:"mode"`
+}
+
+var gridScopes = []gridScope{
+	{Key: "band_digi", Band: true, Mode: "digi"},
+	{Key: "band_mode", Band: true, Mode: "mode"},
+	{Key: "band_ftx", Band: true, Mode: "ftx"},
+	{Key: "mix_digi", Band: false, Mode: "digi"},
+	{Key: "mix_mode", Band: false, Mode: "mode"},
+	{Key: "mix_ftx", Band: false, Mode: "ftx"},
+}
+
+// defaultGridScope matches what the panel showed before the setting existed:
+// any band, any digital mode. Changing an operator's badges on upgrade is worse
+// than offering them a choice they have not made yet.
+const defaultGridScope = "mix_digi"
+
+func lookupGridScope(key string) gridScope {
+	for _, s := range gridScopes {
+		if s.Key == key {
+			return s
+		}
+	}
+	for _, s := range gridScopes {
+		if s.Key == defaultGridScope {
+			return s
+		}
+	}
+	return gridScopes[0]
+}
+
+// ftxModes is the FT family, which is a narrower thing than "digital": an
+// operator chasing squares on FT8 does not count the RTTY contest contact, and
+// GridTracker draws the same line.
+var ftxModes = map[string]bool{"FT8": true, "FT4": true, "FT2": true}
+
+// gridClassesOf lists every bucket one logged mode belongs to. A single FT8
+// contact counts under its own name, under FTx and under digital — the scopes
+// overlap by construction, so the index stores all three and the lookup picks.
+func gridClassesOf(mode string) []string {
+	m := strings.ToUpper(strings.TrimSpace(mode))
+	if m == "" {
+		return nil
+	}
+	out := []string{"m:" + m}
+	if ftxModes[m] {
+		out = append(out, "ftx")
+	}
+	if award.ModeClass(m) == "DIGI" {
+		out = append(out, "digi")
+	}
+	return out
+}
+
+// gridClassFor turns the scope plus the mode being heard into the one class to
+// look up. Empty means "this scope cannot judge this mode" — a phone contact
+// under an FTx scope — and the caller then flags nothing rather than guessing.
+func gridClassFor(s gridScope, mode string) string {
+	m := strings.ToUpper(strings.TrimSpace(mode))
+	if m == "" {
+		return ""
+	}
+	switch s.Mode {
+	case "mode":
+		return "m:" + m
+	case "ftx":
+		if ftxModes[m] {
+			return "ftx"
+		}
+		return ""
+	default: // digi
+		if award.ModeClass(m) == "DIGI" {
+			return "digi"
+		}
+		return ""
+	}
+}
+
+// GridScopeSettings is the panel's shape.
+type GridScopeSettings struct {
+	Scope string `json:"scope"`
+	Hunt  string `json:"hunt"`
+	// Scopes is the list the UI renders, so it cannot drift from the one the
+	// lookup honours.
+	Scopes []gridScope `json:"scopes"`
+}
+
+func (a *App) GetGridScopeSettings() GridScopeSettings {
+	return GridScopeSettings{
+		Scope:  lookupGridScope(a.settingOr(keyGridScope, "")).Key,
+		Hunt:   gridHunt(a.settingOr(keyGridHunt, "")),
+		Scopes: gridScopes,
+	}
+}
+
+// gridHunt normalises the hunting mode. "new" is never-worked; "new_unconfirmed"
+// also chases a square worked but not yet confirmed — the same square is still
+// missing from the award either way.
+func gridHunt(v string) string {
+	if strings.TrimSpace(v) == "new_unconfirmed" {
+		return "new_unconfirmed"
+	}
+	return "new"
+}
+
+func (a *App) SaveGridScopeSettings(s GridScopeSettings) error {
+	a.setSetting(keyGridScope, lookupGridScope(s.Scope).Key)
+	a.setSetting(keyGridHunt, gridHunt(s.Hunt))
+	// The worked-grid index is built under these rules, so it is now stale.
+	a.clusterStatusMu.Lock()
+	a.clusterStatusIdx = nil
+	a.clusterStatusMu.Unlock()
+	return nil
+}
+
+// Grid states a heard square can be in, from the operator's point of view.
+//
+// "wanted" is not one state but two, and they call for different decisions: a
+// square never worked is a QSO to make, one worked and not yet confirmed is a
+// QSL to chase. Reporting both as plain NEW GRID — which is what this did when
+// the unconfirmed hunt was added — leaves an operator staring at a badge on a
+// station the log plainly says they worked an hour ago.
+const (
+	gridStateNew    = "new"    // never worked under this scope
+	gridStateUnconf = "unconf" // worked under this scope, not yet confirmed
+)
+
+// gridStateFor classifies one heard square. "" means nothing to chase: already
+// confirmed, or a mode this scope cannot judge.
+//
+// band is where it was heard and mode what it was heard in — the SCOPE decides
+// whether either is allowed to matter.
+func gridStateFor(idx map[string]bool, s gridScope, hunt, grid, band, mode string) string {
+	cls := gridClassFor(s, mode)
+	if cls == "" || len(grid) < 4 {
+		return ""
+	}
+	key := qso.GridKey(strings.ToUpper(grid[:4]), "", cls)
+	if s.Band {
+		key = qso.GridKey(strings.ToUpper(grid[:4]), band, cls)
+	}
+	confirmed, worked := idx[key]
+	switch {
+	case !worked:
+		return gridStateNew
+	case !confirmed && hunt == "new_unconfirmed":
+		return gridStateUnconf
+	default:
+		return ""
+	}
+}
+
+// gridIsWanted is gridStateFor reduced to the yes/no the filters need.
+func gridIsWanted(idx map[string]bool, s gridScope, hunt, grid, band, mode string) bool {
+	return gridStateFor(idx, s, hunt, grid, band, mode) != ""
+}

gridscope_test.go

@@ -0,0 +1,126 @@
+package main
+
+import (
+	"testing"
+
+	"hamlog/internal/qso"
+)
+
+// idx builds a worked-grid index the way GridWorkedIndex does, so the test
+// exercises the real key shape rather than a convenient one.
+func idx(entries ...struct {
+	grid, band, mode string
+	confirmed        bool
+}) map[string]bool {
+	m := map[string]bool{}
+	for _, e := range entries {
+		for _, cls := range gridClassesOf(e.mode) {
+			for _, k := range []string{qso.GridKey(e.grid, e.band, cls), qso.GridKey(e.grid, "", cls)} {
+				m[k] = m[k] || e.confirmed
+			}
+		}
+	}
+	return m
+}
+
+type entry = struct {
+	grid, band, mode string
+	confirmed        bool
+}
+
+// The six scopes are six different questions, and the whole point of offering
+// them is that the same square answers differently.
+func TestGridScopes(t *testing.T) {
+	// JN36 worked once: 20 m, FT8, not confirmed.
+	i := idx(entry{"JN36", "20m", "FT8", false})
+
+	for _, tc := range []struct {
+		scope string
+		band  string
+		mode  string
+		want  bool
+		why   string
+	}{
+		{"band_ftx", "20m", "FT8", false, "same band, same family — already mine"},
+		{"band_ftx", "15m", "FT8", true, "another band, and the scope counts bands"},
+		{"mix_ftx", "15m", "FT8", false, "another band, but this scope does not care"},
+		{"band_mode", "20m", "FT4", true, "same band, but FT4 is not FT8 under an exact-mode scope"},
+		{"band_ftx", "20m", "FT4", false, "same band, and FT4 is in the same FT family"},
+		{"band_digi", "20m", "RTTY", false, "digital counts every digital mode"},
+		{"band_ftx", "20m", "RTTY", false, "RTTY is outside an FTx scope — it is not evidence either way, so nothing is flagged"},
+		{"mix_digi", "15m", "FT4", false, "the widest scope: worked anywhere, any digital"},
+	} {
+		got := gridIsWanted(i, lookupGridScope(tc.scope), "new", "JN36", tc.band, tc.mode)
+		if got != tc.want {
+			t.Errorf("scope %s, %s %s → wanted=%v, want %v — %s", tc.scope, tc.band, tc.mode, got, tc.want, tc.why)
+		}
+	}
+}
+
+// "New + unconfirmed" chases a square that is worked but not yet confirmed: it
+// is still missing from the award, which is the only sense in which it is done.
+func TestGridHuntUnconfirmed(t *testing.T) {
+	unconf := idx(entry{"JN36", "20m", "FT8", false})
+	conf := idx(entry{"IO91", "20m", "FT8", true})
+
+	if gridIsWanted(unconf, lookupGridScope("band_ftx"), "new", "JN36", "20m", "FT8") {
+		t.Error("worked-but-unconfirmed must NOT be wanted when hunting only what is new")
+	}
+	if !gridIsWanted(unconf, lookupGridScope("band_ftx"), "new_unconfirmed", "JN36", "20m", "FT8") {
+		t.Error("worked-but-unconfirmed must BE wanted when hunting unconfirmed too")
+	}
+	if gridIsWanted(conf, lookupGridScope("band_ftx"), "new_unconfirmed", "IO91", "20m", "FT8") {
+		t.Error("a confirmed square is finished under either hunt")
+	}
+}
+
+// A mode the scope cannot judge flags nothing rather than guessing: a phone
+// contact under an FTx scope is not evidence either way.
+func TestGridScopeIgnoresModesItCannotJudge(t *testing.T) {
+	i := idx(entry{"JN36", "20m", "FT8", false})
+	for _, mode := range []string{"SSB", "CW", ""} {
+		if gridIsWanted(i, lookupGridScope("band_ftx"), "new", "KO01", "20m", mode) {
+			t.Errorf("mode %q is outside an FTx scope — nothing should be flagged", mode)
+		}
+	}
+}
+
+// An unknown or unset scope falls back rather than answering "wanted" for
+// everything, which is what an empty class would have done.
+func TestGridScopeFallsBack(t *testing.T) {
+	if got := lookupGridScope("").Key; got != defaultGridScope {
+		t.Errorf("unset scope = %q, want the default %q", got, defaultGridScope)
+	}
+	if got := lookupGridScope("nonsense").Key; got != defaultGridScope {
+		t.Errorf("unknown scope = %q, want the default %q", got, defaultGridScope)
+	}
+	if got := gridHunt("nonsense"); got != "new" {
+		t.Errorf("unknown hunt = %q, want new", got)
+	}
+}
+
+// The two wanted states must be told apart, not merged. A square worked an hour
+// ago and awaiting a QSL is a different job from one never worked, and reporting
+// both as plain NEW GRID is what made a station the log plainly shows as worked
+// still wear the badge.
+func TestGridStateSeparatesNewFromUnconfirmed(t *testing.T) {
+	i := idx(
+		entry{"JN74", "20m", "FT8", false}, // worked, no confirmation yet
+		entry{"IO91", "20m", "FT8", true},  // worked and confirmed
+	)
+	s := lookupGridScope("band_ftx")
+
+	if got := gridStateFor(i, s, "new_unconfirmed", "KO99", "20m", "FT8"); got != gridStateNew {
+		t.Errorf("never worked → %q, want %q", got, gridStateNew)
+	}
+	if got := gridStateFor(i, s, "new_unconfirmed", "JN74", "20m", "FT8"); got != gridStateUnconf {
+		t.Errorf("worked but unconfirmed → %q, want %q", got, gridStateUnconf)
+	}
+	if got := gridStateFor(i, s, "new_unconfirmed", "IO91", "20m", "FT8"); got != "" {
+		t.Errorf("confirmed → %q, want nothing to chase", got)
+	}
+	// Under the plain "new" hunt an unconfirmed square is finished business.
+	if got := gridStateFor(i, s, "new", "JN74", "20m", "FT8"); got != "" {
+		t.Errorf("unconfirmed under the new-only hunt → %q, want nothing", got)
+	}
+}

internal/award/catalog/waja.json

@@ -46,11 +46,12 @@
           "qsl"
         ],
         "total": 0,
-        "builtin": true
+        "builtin": true,
+        "version": 2
       },
       "references": [
         {
-          "code": "1",
+          "code": "01",
           "name": "Hokkaido",
           "dxcc": 0,
           "group": "",
@@ -58,16 +59,81 @@
           "valid": true
         },
         {
-          "code": "10",
+          "code": "02",
-          "name": "Gunma",
+          "name": "Aomori",
           "dxcc": 0,
           "group": "",
           "subgrp": "",
           "valid": true
         },
+        {
+          "code": "03",
+          "name": "Iwate",
+          "dxcc": 0,
+          "group": "",
+          "subgrp": "",
+          "valid": true
+        },
+        {
+          "code": "04",
+          "name": "Akita",
+          "dxcc": 0,
+          "group": "",
+          "subgrp": "",
+          "valid": true
+        },
+        {
+          "code": "05",
+          "name": "Yamagata",
+          "dxcc": 0,
+          "group": "",
+          "subgrp": "",
+          "valid": true
+        },
+        {
+          "code": "06",
+          "name": "Miyagi",
+          "dxcc": 0,
+          "group": "",
+          "subgrp": "",
+          "valid": true
+        },
+        {
+          "code": "07",
+          "name": "Fukushima",
+          "dxcc": 0,
+          "group": "",
+          "subgrp": "",
+          "valid": true
+        },
+        {
+          "code": "08",
+          "name": "Niigata",
+          "dxcc": 0,
+          "group": "",
+          "subgrp": "",
+          "valid": true
+        },
+        {
+          "code": "09",
+          "name": "Nagano",
+          "dxcc": 0,
+          "group": "",
+          "subgrp": "",
+          "valid": true
+        },
+        {
+          "code": "10",
+          "name": "Tokyo",
+          "dxcc": 0,
+          "group": "",
+          "subgrp": "",
+          "pattern": "\\bTok[iy]o\\b",
+          "valid": true
+        },
         {
           "code": "11",
-          "name": "Saitama",
+          "name": "Kanagawa",
           "dxcc": 0,
           "group": "",
           "subgrp": "",
@@ -83,16 +149,15 @@
         },
         {
           "code": "13",
-          "name": "Tokyo",
+          "name": "Saitama",
           "dxcc": 0,
           "group": "",
           "subgrp": "",
-          "pattern": "\\bTok[iy]o\\b",
           "valid": true
         },
         {
           "code": "14",
-          "name": "Kanagawa",
+          "name": "Ibaraki",
           "dxcc": 0,
           "group": "",
           "subgrp": "",
@@ -100,7 +165,7 @@
         },
         {
           "code": "15",
-          "name": "Niigata",
+          "name": "Tochigi",
           "dxcc": 0,
           "group": "",
           "subgrp": "",
@@ -108,7 +173,7 @@
         },
         {
           "code": "16",
-          "name": "Toyama",
+          "name": "Gunma",
           "dxcc": 0,
           "group": "",
           "subgrp": "",
@@ -116,22 +181,6 @@
         },
         {
           "code": "17",
-          "name": "Ishikawa",
-          "dxcc": 0,
-          "group": "",
-          "subgrp": "",
-          "valid": true
-        },
-        {
-          "code": "18",
-          "name": "Fukui",
-          "dxcc": 0,
-          "group": "",
-          "subgrp": "",
-          "valid": true
-        },
-        {
-          "code": "19",
           "name": "Yamanashi",
           "dxcc": 0,
           "group": "",
@@ -139,31 +188,7 @@
           "valid": true
         },
         {
-          "code": "2",
+          "code": "18",
-          "name": "Aomori",
-          "dxcc": 0,
-          "group": "",
-          "subgrp": "",
-          "valid": true
-        },
-        {
-          "code": "20",
-          "name": "Nagano",
-          "dxcc": 0,
-          "group": "",
-          "subgrp": "",
-          "valid": true
-        },
-        {
-          "code": "21",
-          "name": "Gifu",
-          "dxcc": 0,
-          "group": "",
-          "subgrp": "",
-          "valid": true
-        },
-        {
-          "code": "22",
           "name": "Shizuoka",
           "dxcc": 0,
           "group": "",
@@ -171,7 +196,15 @@
           "valid": true
         },
         {
-          "code": "23",
+          "code": "19",
+          "name": "Gifu",
+          "dxcc": 0,
+          "group": "",
+          "subgrp": "",
+          "valid": true
+        },
+        {
+          "code": "20",
           "name": "Aichi",
           "dxcc": 0,
           "group": "",
@@ -179,7 +212,7 @@
           "valid": true
         },
         {
-          "code": "24",
+          "code": "21",
           "name": "Mie",
           "dxcc": 0,
           "group": "",
@@ -187,15 +220,7 @@
           "valid": true
         },
         {
-          "code": "25",
+          "code": "22",
-          "name": "Shiga",
-          "dxcc": 0,
-          "group": "",
-          "subgrp": "",
-          "valid": true
-        },
-        {
-          "code": "26",
           "name": "Kyoto",
           "dxcc": 0,
           "group": "",
@@ -203,23 +228,15 @@
           "valid": true
         },
         {
-          "code": "27",
+          "code": "23",
-          "name": "Osaka",
+          "name": "Shiga",
           "dxcc": 0,
           "group": "",
           "subgrp": "",
           "valid": true
         },
         {
-          "code": "28",
+          "code": "24",
-          "name": "Hyogo",
-          "dxcc": 0,
-          "group": "",
-          "subgrp": "",
-          "valid": true
-        },
-        {
-          "code": "29",
           "name": "Nara",
           "dxcc": 0,
           "group": "",
@@ -227,24 +244,56 @@
           "valid": true
         },
         {
-          "code": "3",
+          "code": "25",
-          "name": "Iwate",
+          "name": "Osaka",
           "dxcc": 0,
           "group": "",
           "subgrp": "",
           "valid": true
         },
         {
-          "code": "30",
+          "code": "26",
           "name": "Wakayama",
           "dxcc": 0,
           "group": "",
           "subgrp": "",
           "valid": true
         },
+        {
+          "code": "27",
+          "name": "Hyogo",
+          "dxcc": 0,
+          "group": "",
+          "subgrp": "",
+          "valid": true
+        },
+        {
+          "code": "28",
+          "name": "Toyama",
+          "dxcc": 0,
+          "group": "",
+          "subgrp": "",
+          "valid": true
+        },
+        {
+          "code": "29",
+          "name": "Fukui",
+          "dxcc": 0,
+          "group": "",
+          "subgrp": "",
+          "valid": true
+        },
+        {
+          "code": "30",
+          "name": "Ishikawa",
+          "dxcc": 0,
+          "group": "",
+          "subgrp": "",
+          "valid": true
+        },
         {
           "code": "31",
-          "name": "Tottori",
+          "name": "Okayama",
           "dxcc": 0,
           "group": "",
           "subgrp": "",
@@ -260,31 +309,31 @@
         },
         {
           "code": "33",
-          "name": "Okayama",
-          "dxcc": 0,
-          "group": "",
-          "subgrp": "",
-          "valid": true
-        },
-        {
-          "code": "34",
-          "name": "Hiroshima",
-          "dxcc": 0,
-          "group": "",
-          "subgrp": "",
-          "valid": true
-        },
-        {
-          "code": "35",
           "name": "Yamaguchi",
           "dxcc": 0,
           "group": "",
           "subgrp": "",
           "valid": true
         },
+        {
+          "code": "34",
+          "name": "Tottori",
+          "dxcc": 0,
+          "group": "",
+          "subgrp": "",
+          "valid": true
+        },
+        {
+          "code": "35",
+          "name": "Hiroshima",
+          "dxcc": 0,
+          "group": "",
+          "subgrp": "",
+          "valid": true
+        },
         {
           "code": "36",
-          "name": "Tokushima",
+          "name": "Kagawa",
           "dxcc": 0,
           "group": "",
           "subgrp": "",
@@ -292,7 +341,7 @@
         },
         {
           "code": "37",
-          "name": "Kagawa",
+          "name": "Tokushima",
           "dxcc": 0,
           "group": "",
           "subgrp": "",
@@ -314,14 +363,6 @@
           "subgrp": "",
           "valid": true
         },
-        {
-          "code": "4",
-          "name": "Miyagi",
-          "dxcc": 0,
-          "group": "",
-          "subgrp": "",
-          "valid": true
-        },
         {
           "code": "40",
           "name": "Fukuoka",
@@ -385,46 +426,6 @@
           "group": "",
           "subgrp": "",
           "valid": true
-        },
-        {
-          "code": "5",
-          "name": "Akita",
-          "dxcc": 0,
-          "group": "",
-          "subgrp": "",
-          "valid": true
-        },
-        {
-          "code": "6",
-          "name": "Yamagata",
-          "dxcc": 0,
-          "group": "",
-          "subgrp": "",
-          "valid": true
-        },
-        {
-          "code": "7",
-          "name": "Fukushima",
-          "dxcc": 0,
-          "group": "",
-          "subgrp": "",
-          "valid": true
-        },
-        {
-          "code": "8",
-          "name": "Ibaraki",
-          "dxcc": 0,
-          "group": "",
-          "subgrp": "",
-          "valid": true
-        },
-        {
-          "code": "9",
-          "name": "Tochigi",
-          "dxcc": 0,
-          "group": "",
-          "subgrp": "",
-          "valid": true
         }
       ]
     }

internal/award/waja_test.go

@@ -0,0 +1,101 @@
+package award
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+// WAJA is numbered by the JARL, and the numbering is NOT Japan's ordinary
+// prefecture code.
+//
+// The catalog shipped with the government's JIS numbering instead — 01
+// Hokkaido, 02 Aomori, 03 Iwate, 04 Miyagi… — which agrees with the JARL's for
+// the first three prefectures and then diverges for thirty-five of the
+// remaining forty-four. The names were right throughout, so the award still
+// counted the right contacts; every reference simply carried the wrong number,
+// which is what an operator sends to the JARL when they claim it.
+//
+// The two schemes agree often enough to look correct at a glance, so this pins
+// the places they differ rather than a count. Each pair below is one the old
+// list got wrong, and the comment is what the old list said.
+func TestCatalogWAJAUsesTheJARLNumbering(t *testing.T) {
+	raw, ok := CatalogRefs("WAJA")
+	if !ok {
+		t.Fatal("WAJA has no reference list in the embedded catalog")
+	}
+	var refs []struct {
+		Code    string `json:"code"`
+		Name    string `json:"name"`
+		Pattern string `json:"pattern"`
+	}
+	if err := json.Unmarshal(raw, &refs); err != nil {
+		t.Fatalf("WAJA references: %v", err)
+	}
+	if len(refs) != 47 {
+		t.Fatalf("WAJA has %d prefectures, want exactly 47", len(refs))
+	}
+
+	byName := map[string]string{}
+	byCode := map[string]string{}
+	for _, r := range refs {
+		byName[r.Name] = r.Code
+		if prev, dup := byCode[r.Code]; dup {
+			t.Errorf("number %s is on both %s and %s", r.Code, prev, r.Name)
+		}
+		byCode[r.Code] = r.Name
+	}
+
+	for _, c := range []struct{ name, code string }{
+		{"Hokkaido", "01"},  // the one both schemes agree on, and the anchor
+		{"Miyagi", "06"},    // was 04
+		{"Akita", "04"},     // was 05
+		{"Niigata", "08"},   // was 15 — the JIS number
+		{"Nagano", "09"},    // was 20
+		{"Tokyo", "10"},     // was 13, the JIS number everyone recognises
+		{"Kanagawa", "11"},  // was 14
+		{"Saitama", "13"},   // was 11
+		{"Ibaraki", "14"},   // was 8
+		{"Gunma", "16"},     // was 10
+		{"Yamanashi", "17"}, // was 19
+		{"Kyoto", "22"},     // was 26
+		{"Osaka", "25"},     // was 27
+		{"Toyama", "28"},    // was 16
+		{"Ishikawa", "30"},  // was 17
+		{"Okayama", "31"},   // was 33
+		{"Tottori", "34"},   // was 31
+		{"Kagawa", "36"},    // was 37
+		{"Tokushima", "37"}, // was 36
+		{"Okinawa", "47"},   // unchanged: the far end of the list was already right
+	} {
+		if got := byName[c.name]; got != c.code {
+			t.Errorf("%s is numbered %q, want %q on the JARL list", c.name, got, c.code)
+		}
+	}
+
+	// Two digits throughout, as the JARL prints them. Not cosmetic: the codes
+	// are strings, so "1" sorts between "09" and "10" and the panel showed the
+	// prefectures in an order no list anywhere uses.
+	for _, r := range refs {
+		if len(r.Code) != 2 {
+			t.Errorf("%s is numbered %q — the JARL list is two digits throughout", r.Name, r.Code)
+		}
+	}
+
+	// The Tokyo spelling rule has to sit on Tokyo, and Tokyo moved. Left behind
+	// on the old number it would be matching QTHs for Saitama.
+	for _, r := range refs {
+		if r.Pattern == "" {
+			continue
+		}
+		if r.Name != "Tokyo" {
+			t.Errorf("%s (%s) carries the pattern %q, which belongs to Tokyo", r.Name, r.Code, r.Pattern)
+		}
+	}
+	if byName["Tokyo"] != "" {
+		for _, r := range refs {
+			if r.Name == "Tokyo" && r.Pattern == "" {
+				t.Error("Tokyo lost its spelling pattern in the renumbering — Tokio would stop counting")
+			}
+		}
+	}
+}

internal/awardref/awardref.go

@@ -266,6 +266,48 @@ func (r *Repo) Upsert(ctx context.Context, awardCode string, ref Ref) error {
 	return err
 }
 
+// Rename changes a reference's CODE, keeping everything else about it.
+//
+// Wanted because a shipped list can simply be wrong: WAJA went out numbered by
+// the Japanese state instead of by the JARL, and the only way to correct it was
+// to delete all 47 references and import a new list — losing anything the
+// operator had adjusted. The number is the one field an editor could not touch.
+//
+// A rename, not a delete plus an insert: everything the reference carries — its
+// pattern, its DXCC list, its validity window — travels with it, which is the
+// whole point of correcting a number rather than replacing an entry.
+func (r *Repo) Rename(ctx context.Context, awardCode, oldCode, newCode string) error {
+	ac := strings.ToUpper(strings.TrimSpace(awardCode))
+	from := strings.ToUpper(strings.TrimSpace(oldCode))
+	to := strings.ToUpper(strings.TrimSpace(newCode))
+	if ac == "" || from == "" || to == "" {
+		return fmt.Errorf("empty award or reference code")
+	}
+	if from == to {
+		return nil
+	}
+	// A collision would REPLACE the other reference and take its name, pattern
+	// and dates with it — one silently swallowing another, discovered much later
+	// as a reference that has quietly gone missing.
+	var n int
+	if err := r.db.QueryRowContext(ctx,
+		`SELECT COUNT(*) FROM award_references WHERE award_code = ? AND ref_code = ?`, ac, to).Scan(&n); err != nil {
+		return err
+	}
+	if n > 0 {
+		return fmt.Errorf("%s already has a reference %s", ac, to)
+	}
+	res, err := r.db.ExecContext(ctx,
+		`UPDATE award_references SET ref_code = ? WHERE award_code = ? AND ref_code = ?`, to, ac, from)
+	if err != nil {
+		return err
+	}
+	if rows, _ := res.RowsAffected(); rows == 0 {
+		return fmt.Errorf("%s has no reference %s", ac, from)
+	}
+	return nil
+}
+
 // Delete removes one reference from an award.
 func (r *Repo) Delete(ctx context.Context, awardCode, refCode string) error {
 	_, err := r.db.ExecContext(ctx,

internal/awardref/dxcciota.go

@@ -0,0 +1,129 @@
+package awardref
+
+// One-IOTA DXCC entities: a table of the entities that ARE a single IOTA group.
+//
+// WHY IT EXISTS. QRZ.com carries <iota> for an operator who fills it in, and
+// most do not. But for a great many entities the island reference follows from
+// the entity alone — a station in Ascension Island is on AF-003, there is
+// nothing else it could be — and the entity is known for every callsign, from
+// cty.dat, without any callbook at all. So the reference can be filled for an
+// operator with no QRZ subscription, on a station that has never touched a
+// callbook, before the contact is logged.
+//
+// Only entities that map to EXACTLY ONE reference are here. France is not: a
+// French station is usually on the mainland and on no island at all, and
+// guessing would put a reference on hundreds of contacts that earn none.
+//
+// SOURCE: dxcc_matches_one_iota.json from the IOTA programme
+// (www.iota-world.org/islands-on-the-air/downloads/), fetched 2026-08-17,
+// 99 entities. It changes only when an entity appears or IOTA re-maps one, so
+// it is a table here rather than a download: it then works offline, which is
+// where a portable station usually is. To refresh, fetch that file again and
+// re-emit this map, sorted by entity number.
+//
+// Entity names are comments only, joined from internal/dxcc for readability.
+var iotaByDXCC = map[int]string{
+	5:   "EU-002", // Aland Islands
+	10:  "AF-002", // Amsterdam & St. Paul Is.
+	12:  "NA-022", // Anguilla
+	17:  "NA-020", // Aves Island
+	20:  "OC-089", // Baker & Howland Islands
+	21:  "EU-004", // Balearic Islands
+	24:  "AN-002", // Bouvet
+	29:  "AF-004", // Canary Islands
+	34:  "OC-038", // Chatham Islands
+	35:  "OC-002", // Christmas Island
+	36:  "NA-011", // Clipperton Island
+	37:  "NA-012", // Cocos Island
+	38:  "OC-003", // Cocos (Keeling) Islands
+	41:  "AF-008", // Crozet Island
+	43:  "NA-095", // Desecheo Island
+	45:  "EU-001", // Dodecanese
+	62:  "NA-021", // Barbados
+	64:  "NA-005", // Bermuda
+	65:  "NA-023", // British Virgin Islands
+	69:  "NA-016", // Cayman Islands
+	71:  "SA-004", // Galapagos Islands
+	82:  "NA-097", // Jamaica
+	84:  "NA-107", // Martinique
+	91:  "SA-036", // Aruba
+	94:  "NA-100", // Antigua & Barbuda
+	95:  "NA-101", // Dominica
+	96:  "NA-103", // Montserrat
+	97:  "NA-108", // St. Lucia
+	99:  "AF-011", // Glorioso Islands
+	103: "OC-026", // Guam
+	105: "NA-015", // Guantanamo Bay
+	106: "EU-114", // Guernsey
+	111: "AN-003", // Heard Island
+	114: "EU-116", // Isle Of Man
+	118: "EU-022", // Jan Mayen
+	123: "OC-023", // Johnston Island
+	131: "AF-048", // Kerguelen Islands
+	133: "OC-039", // Kermadec Islands
+	138: "OC-020", // Kure Island
+	141: "SA-002", // Falkland Islands
+	147: "OC-004", // Lord Howe Island
+	153: "AN-005", // Macquarie Island
+	157: "OC-031", // Nauru
+	159: "AS-013", // Maldives
+	161: "SA-007", // Malpelo Island
+	165: "AF-049", // Mauritius
+	166: "OC-086", // Mariana Islands
+	167: "EU-053", // Market Reef
+	169: "AF-027", // Mayotte
+	171: "OC-072", // Mellish Reef
+	174: "OC-030", // Midway Island
+	177: "OC-073", // Minami Torishima
+	182: "NA-098", // Navassa Island
+	188: "OC-040", // Niue
+	189: "OC-005", // Norfolk Island
+	190: "OC-097", // Samoa
+	195: "AF-039", // Annobon Island
+	199: "AN-004", // Peter 1 Island
+	201: "AF-021", // Pr. Edward & Marion Is.
+	205: "AF-003", // Ascension Island
+	207: "AF-017", // Rodriguez Island
+	211: "NA-063", // Sable Island
+	217: "SA-013", // San Felix & San Ambrosio
+	222: "EU-018", // Faroe Islands
+	238: "AN-008", // South Orkney Islands
+	240: "AN-009", // South Sandwich Islands
+	241: "AN-010", // South Shetland Islands
+	247: "AS-051", // Spratly Islands
+	249: "NA-104", // St. Kitts & Nevis
+	250: "AF-022", // St. Helena
+	252: "NA-094", // St. Paul Island
+	253: "SA-014", // St. Peter & St. Paul
+	257: "EU-023", // Malta
+	270: "OC-048", // Tokelau Islands
+	273: "SA-010", // Trindade & Martim Vaz
+	276: "AF-031", // Tromelin Island
+	277: "NA-032", // St. Pierre & Miquelon
+	282: "OC-015", // Tuvalu
+	283: "AS-004", // Uk Base Areas On Cyprus
+	285: "NA-106", // Us Virgin Islands
+	297: "OC-053", // Wake Island
+	301: "OC-017", // Western Kiribati
+	303: "OC-007", // Willis Island
+	381: "AS-019", // Singapore
+	411: "AF-007", // Comoros
+	453: "AF-016", // Reunion Island
+	460: "OC-060", // Rotuma Island
+	489: "OC-112", // Conway Reef
+	490: "OC-018", // Banaba Island
+	505: "AS-110", // Pratas Island
+	506: "AS-116", // Scarborough Reef
+	509: "OC-027", // Marquesas Islands
+	512: "OC-176", // Chesterfield Islands
+	513: "OC-182", // Ducie Island
+	515: "OC-200", // Swains Island
+	516: "NA-146", // St. Barthelemy
+	517: "SA-099", // Curacao
+	519: "NA-145", // Saba & St. Eustatius
+	520: "SA-006", // Bonaire
+}
+
+// IOTAForDXCC returns the island reference of a DXCC entity that is a single
+// IOTA group, or "" for an entity that holds several islands or none.
+func IOTAForDXCC(dxcc int) string { return iotaByDXCC[dxcc] }

internal/awardref/dxcciota_test.go

@@ -0,0 +1,51 @@
+package awardref
+
+import (
+	"regexp"
+	"testing"
+)
+
+// The entities an operator meets: an island group that is its own DXCC, and a
+// mainland country that is not.
+func TestIOTAForDXCC(t *testing.T) {
+	cases := []struct {
+		dxcc int
+		want string
+		why  string
+	}{
+		{205, "AF-003", "Ascension Island is one island and one reference"},
+		{5, "EU-002", "Aland Islands"},
+		{12, "NA-022", "Anguilla"},
+		{24, "AN-002", "Bouvet — the entity whose entry is checked most often and worked least"},
+		// France holds hundreds of islands and, far more to the point, a
+		// mainland. Filling a reference here would earn nothing and would put
+		// one on nearly every European contact in the log.
+		{227, "", "France is not one IOTA"},
+		{291, "", "the United States is not one IOTA"},
+		{0, "", "no entity resolved"},
+		{99999, "", "not an entity at all"},
+	}
+	for _, c := range cases {
+		if got := IOTAForDXCC(c.dxcc); got != c.want {
+			t.Errorf("IOTAForDXCC(%d) = %q, want %q — %s", c.dxcc, got, c.want, c.why)
+		}
+	}
+}
+
+// Every reference in the table must be a well-formed IOTA reference, because
+// one that is not would be written onto a contact's award references and count
+// for nothing — and would then have to be found by hand, one QSO at a time.
+func TestEveryOneIOTAEntryIsWellFormed(t *testing.T) {
+	ref := regexp.MustCompile(`^(AF|AN|AS|EU|NA|OC|SA)-\d{3}$`)
+	if len(iotaByDXCC) < 50 {
+		t.Fatalf("the table holds %d entities — it has been truncated", len(iotaByDXCC))
+	}
+	for dxcc, r := range iotaByDXCC {
+		if dxcc <= 0 {
+			t.Errorf("entity number %d is not a DXCC entity", dxcc)
+		}
+		if !ref.MatchString(r) {
+			t.Errorf("entity %d maps to %q, which is not an IOTA reference", dxcc, r)
+		}
+	}
+}

internal/awardref/rename_test.go

@@ -0,0 +1,112 @@
+package awardref
+
+import (
+	"context"
+	"path/filepath"
+	"testing"
+
+	"hamlog/internal/db"
+)
+
+func renameRepo(t *testing.T) *Repo {
+	t.Helper()
+	conn, err := db.Open(filepath.Join(t.TempDir(), "a.db"))
+	if err != nil {
+		t.Fatalf("open: %v", err)
+	}
+	t.Cleanup(func() { conn.Close() })
+	return NewRepo(conn)
+}
+
+// Correcting a reference's number must keep the reference.
+//
+// WAJA shipped numbered by the Japanese state instead of by the JARL, and until
+// now the only way to fix that was to delete all 47 references and import a new
+// list — losing anything the operator had adjusted. A rename keeps the pattern,
+// the entity list and the validity window, because a wrong NUMBER is all that
+// was wrong.
+func TestRenameKeepsEverythingButTheCode(t *testing.T) {
+	r := renameRepo(t)
+	ctx := context.Background()
+	if err := r.Upsert(ctx, "WAJA", Ref{
+		Code: "13", Name: "Tokyo", Pattern: `\bTok[iy]o\b`, Valid: true,
+		DXCCList: []int{339}, ValidFrom: "1970-01-01",
+	}); err != nil {
+		t.Fatalf("seed: %v", err)
+	}
+
+	if err := r.Rename(ctx, "WAJA", "13", "10"); err != nil {
+		t.Fatalf("rename: %v", err)
+	}
+
+	refs, err := r.List(ctx, "WAJA")
+	if err != nil {
+		t.Fatalf("list: %v", err)
+	}
+	if len(refs) != 1 {
+		t.Fatalf("WAJA holds %d references after a rename, want 1 — it was copied, not renamed", len(refs))
+	}
+	got := refs[0]
+	if got.Code != "10" {
+		t.Errorf("code = %q, want 10", got.Code)
+	}
+	if got.Name != "Tokyo" || got.Pattern != `\bTok[iy]o\b` {
+		t.Errorf("the reference lost what it carried: name=%q pattern=%q", got.Name, got.Pattern)
+	}
+	if len(got.DXCCList) != 1 || got.DXCCList[0] != 339 || got.ValidFrom != "1970-01-01" {
+		t.Errorf("the reference lost its entity list or dates: %+v", got)
+	}
+}
+
+// A number already in use must be refused. Left to REPLACE, the rename would
+// take the other reference's name, pattern and dates with it — one entry
+// silently swallowing another, found much later as a prefecture that has
+// quietly gone missing from the list.
+func TestRenameRefusesANumberAlreadyTaken(t *testing.T) {
+	r := renameRepo(t)
+	ctx := context.Background()
+	if err := r.Upsert(ctx, "WAJA", Ref{Code: "10", Name: "Gunma", Valid: true}); err != nil {
+		t.Fatalf("seed: %v", err)
+	}
+	if err := r.Upsert(ctx, "WAJA", Ref{Code: "13", Name: "Tokyo", Valid: true}); err != nil {
+		t.Fatalf("seed: %v", err)
+	}
+
+	if err := r.Rename(ctx, "WAJA", "13", "10"); err == nil {
+		t.Fatal("renaming onto an existing number was accepted — one reference would have eaten the other")
+	}
+	refs, _ := r.List(ctx, "WAJA")
+	if len(refs) != 2 {
+		t.Fatalf("WAJA holds %d references, want both still there", len(refs))
+	}
+}
+
+// Renaming something that is not there is an error, not a silent no-op: it
+// means the editor and the store disagree about what the award holds.
+func TestRenameAnUnknownReferenceFails(t *testing.T) {
+	r := renameRepo(t)
+	if err := r.Rename(context.Background(), "WAJA", "99", "10"); err == nil {
+		t.Error("renaming a reference the award does not have was accepted")
+	}
+}
+
+// Codes are stored upper-cased, so a rename must compare the same way — else
+// "eu-048" onto "EU-048" looks like a move and is really the same reference,
+// which the collision check has to catch.
+func TestRenameIsCaseInsensitive(t *testing.T) {
+	r := renameRepo(t)
+	ctx := context.Background()
+	if err := r.Upsert(ctx, "IOTA", Ref{Code: "EU-048", Name: "Belle-Ile", Valid: true}); err != nil {
+		t.Fatalf("seed: %v", err)
+	}
+	if err := r.Rename(ctx, "iota", "eu-048", "eu-048"); err != nil {
+		t.Errorf("renaming a reference to itself in another case failed: %v", err)
+	}
+	if err := r.Rename(ctx, "IOTA", "eu-048", "eu-049"); err != nil {
+		t.Fatalf("rename: %v", err)
+	}
+	refs, _ := r.List(ctx, "IOTA")
+	if len(refs) != 1 || refs[0].Code != "EU-049" {
+		t.Errorf("references = %+v, want the one renamed to EU-049 and upper-cased", refs)
+	}
+}

internal/cat/cat.go

@@ -79,6 +79,9 @@ type Manager struct {
 
 	pollEvery time.Duration
 	cmdDelay  time.Duration // pause after each command (some rigs need it)
+	// freqOffset is the transverter offset in Hz — see SetFreqOffset. Added to
+	// what the rig reports, taken off what it is told.
+	freqOffset int64
 }
 
 func NewManager(emit func(RigState)) *Manager {
@@ -185,8 +188,39 @@ func (m *Manager) stopLocked() {
 	}
 }
 
+// SetFreqOffset sets the transverter offset: the number of hertz between what
+// the RIG is tuned to and where the station is actually on the air.
+//
+// A 28 MHz IF driving a 144 MHz transverter is an offset of +116 MHz. Everything
+// above this layer — the entry form, the band, the log, the cluster, the shared
+// CAT servers — then works in real frequencies, and the rig keeps seeing its own.
+//
+// Zero disables it, which is why it is a plain number and not a flag plus a
+// number: "enabled with an offset of nothing" and "disabled" are the same thing
+// to everyone downstream.
+func (m *Manager) SetFreqOffset(hz int64) {
+	m.mu.Lock()
+	m.freqOffset = hz
+	m.mu.Unlock()
+}
+
+// freqOffsetHz reads the offset.
+func (m *Manager) freqOffsetHz() int64 {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	return m.freqOffset
+}
+
 // SetFrequency dispatches a SetFreq call to the CAT goroutine.
+//
+// The caller speaks in REAL frequencies (a 2 m spot is 144.300), so the offset
+// comes back off before the rig hears it. Without this the offset would be a
+// display trick: the readout would say 144 and every spot click, band change and
+// memory recall would send the rig somewhere 116 MHz away.
 func (m *Manager) SetFrequency(hz int64) error {
+	if off := m.freqOffsetHz(); off != 0 && hz > off {
+		hz -= off
+	}
 	return m.exec(func(b Backend) error { return b.SetFrequency(hz) })
 }
 
@@ -215,6 +249,10 @@ type splitSetter interface {
 // band when it was transmitting on the DX's own frequency. A refusal WSJT-X can
 // report is worth far more than a success it cannot check.
 func (m *Manager) SetSplit(on bool, txHz int64) error {
+	// Real frequency in, IF frequency out — same as SetFrequency.
+	if off := m.freqOffsetHz(); off != 0 && txHz > off {
+		txHz -= off
+	}
 	return m.exec(func(b Backend) error {
 		s, ok := b.(splitSetter)
 		if !ok {
@@ -744,6 +782,20 @@ func (m *Manager) run(b Backend, stop, done chan struct{}, cmds chan func(), pol
 			ns.Enabled = true
 			ns.Backend = b.Name()
 			ns.UpdatedAt = time.Now()
+			// Transverter offset: the rig reports its IF, the operator is on the
+			// real band. Applied BEFORE the band is worked out, or a 28 MHz IF
+			// behind a 2 m transverter would log every contact on 10 m — and the
+			// band the backend may already have filled in is the IF's, so it is
+			// recomputed rather than trusted.
+			if off := m.freqOffsetHz(); off != 0 {
+				if ns.FreqHz != 0 {
+					ns.FreqHz += off
+					ns.Band = ""
+				}
+				if ns.RxFreqHz != 0 {
+					ns.RxFreqHz += off
+				}
+			}
 			if ns.FreqHz != 0 && ns.Band == "" {
 				ns.Band = BandFromHz(ns.FreqHz)
 			}

internal/cat/icomserial.go

@@ -1,6 +1,7 @@
 package cat
 
 import (
+	"errors"
 	"fmt"
 	"strings"
 	"sync"
@@ -513,7 +514,8 @@ func (b *IcomSerial) SetFrequency(hz int64) error {
 		return fmt.Errorf("invalid frequency")
 	}
 	b.lastSetFreq, b.lastSetFreqAt = hz, time.Now()
-	return b.exec(append([]byte{civ.CmdSetFreq}, civ.FreqToBCD(hz)...)...)
+	return b.execIdempotent(fmt.Sprintf("set frequency %d Hz", hz),
+		append([]byte{civ.CmdSetFreq}, civ.FreqToBCD(hz)...)...)
 }
 
 func (b *IcomSerial) SetMode(mode string) error {
@@ -523,7 +525,7 @@ func (b *IcomSerial) SetMode(mode string) error {
 	}
 	// Set the base mode (keeping the rig's current filter by sending only the
 	// mode byte), then set the data-mode flag for digital modes.
-	if err := b.exec(civ.CmdSetMode, code); err != nil {
+	if err := b.execIdempotent("set mode "+mode, civ.CmdSetMode, code); err != nil {
 		return err
 	}
 	dataByte := byte(0)
@@ -531,16 +533,48 @@ func (b *IcomSerial) SetMode(mode string) error {
 		dataByte = 1
 	}
 	// Filter 0x01 (FIL1) is the conventional default for the data-mode set.
-	_ = b.exec(civ.CmdExtra, civ.SubDataMode, dataByte, 0x01)
+	_ = b.execIdempotent("set data mode", civ.CmdExtra, civ.SubDataMode, dataByte, 0x01)
 	return nil
 }
 
+// errIcomAckLost is "the reply never came" — as opposed to a reply that said no
+// (NG) or a dead port. Only this one is worth repeating: the command may well
+// have been carried out and only its acknowledgement lost. Sentinel rather than
+// a formatted string so callers can tell the two apart.
+var errIcomAckLost = errors.New("icom: timeout waiting for response")
+
+// execIdempotent runs a SET command and sends it ONCE MORE if the
+// acknowledgement is lost.
+//
+// A missing FB is not a missing command — the rig acts on the frame as soon as it
+// decodes it, and what expires is our wait for the answer on a bus shared with
+// the rig's own transceive updates. JTDX in "Split Operating: Fake It" moves the
+// dial and the mode immediately before every key-down, so those acks queue behind
+// each other, and losing one was fatal: rigctld answers RPRT -9, JTDX reads that
+// as losing rig control and tears the connection down mid-over. An operator's log
+// shows it happening on set_ptt, on set_freq and on set_mode alike, each failure
+// followed within 300 ms by a fresh rigctld client — and shows this resend
+// rescuing a PTT that would otherwise have ended the over.
+//
+// Only for commands that say "be in this state": re-sending one changes nothing
+// if the first arrived. A relative or incremental command must not come through
+// here, which is why this is opt-in per caller rather than folded into exec.
+func (b *IcomSerial) execIdempotent(what string, payload ...byte) error {
+	err := b.exec(payload...)
+	if err == nil || !errors.Is(err, errIcomAckLost) {
+		return err
+	}
+	applog.Printf("icom: %s — no acknowledgement in %s, sending it once more", what, icomCmdTimeout)
+	return b.exec(payload...)
+}
+
+// SetPTT keys or unkeys the transmitter (CI-V 0x1C 0x00).
 func (b *IcomSerial) SetPTT(on bool) error {
 	state := byte(0)
 	if on {
 		state = 1
 	}
-	return b.exec(civ.CmdPTT, civ.SubPTT, state)
+	return b.execIdempotent(fmt.Sprintf("PTT %v", on), civ.CmdPTT, civ.SubPTT, state)
 }
 
 // SetPower turns the transceiver on or off (CI-V 0x18). Power-ON is prefixed with
@@ -619,7 +653,7 @@ func (b *IcomSerial) recv(timeout time.Duration, match func(civ.Decoded) bool) (
 		case <-cancel:
 			return civ.Decoded{}, fmt.Errorf("icom: interrupted")
 		case <-deadline:
-			return civ.Decoded{}, fmt.Errorf("icom: timeout waiting for response")
+			return civ.Decoded{}, errIcomAckLost
 		}
 	}
 }

internal/cat/tci.go

@@ -46,6 +46,18 @@ type TCI struct {
 	mode   string
 	split  bool
 	tx     bool
+	// txAllowed is what the radio last said about TRANSMIT PERMISSION.
+	//
+	// TX_ENABLE is sent by ExpertSDR when a client connects and again whenever
+	// the band changes, "in case transmitter permission was changed" (§4.3). When
+	// it is false the radio silently ignores TRX — which is exactly what an
+	// operator sees as "PTT does nothing", with no error anywhere to explain it.
+	//
+	// txAllowedKnown keeps an OLDER ExpertSDR, or a TCI-compatible program that
+	// never sends TX_ENABLE at all, from being treated as refusing: without a
+	// word from the radio we key and let it decide.
+	txAllowed      bool
+	txAllowedKnown bool
 
 	lastSig string // last logged state signature (log only on change)
 
@@ -109,6 +121,10 @@ func (t *TCI) Connect() error {
 	t.mu.Lock()
 	t.conn = conn
 	t.ready = false
+	// Forget the previous session's transmit permission: the radio announces it
+	// again on connect, and a refusal remembered from a band we have since left
+	// would block PTT until it did.
+	t.txAllowed, t.txAllowedKnown = false, false
 	t.mu.Unlock()
 	debugLog.Printf("TCI: connected to %s", url)
 	go t.reader(conn)
@@ -298,7 +314,22 @@ func (t *TCI) SetMode(mode string) error {
 }
 
 // SetPTT keys or unkeys the transmitter (VFO 0).
+//
+// A refusal by the radio is reported rather than swallowed. ExpertSDR announces
+// transmit permission with TX_ENABLE and then simply IGNORES trx when it is
+// false — out-of-band frequency, TX disabled in the program, no PA. The command
+// went out, nothing happened, and nothing anywhere said why. Now the operator
+// is told, and the message names the place to look.
 func (t *TCI) SetPTT(on bool) error {
+	if on {
+		t.mu.Lock()
+		known, allowed := t.txAllowedKnown, t.txAllowed
+		t.mu.Unlock()
+		if known && !allowed {
+			return fmt.Errorf("the radio is refusing to transmit (TCI reports TX disabled) — " +
+				"check the frequency is inside a transmit band and that TX is enabled in ExpertSDR")
+		}
+	}
 	return t.send(fmt.Sprintf("trx:0,%t;", on))
 }
 
@@ -392,6 +423,14 @@ func (t *TCI) handle(msg string) {
 		if get(0) == "0" {
 			t.tx = get(1) == "true"
 		}
+	case "tx_enable":
+		if get(0) == "0" {
+			allowed := get(1) == "true"
+			if !t.txAllowedKnown || t.txAllowed != allowed {
+				debugLog.Printf("TCI: the radio %s transmitting", map[bool]string{true: "allows", false: "REFUSES"}[allowed])
+			}
+			t.txAllowed, t.txAllowedKnown = allowed, true
+		}
 	default:
 		lname := strings.ToLower(name)
 		// A click on one of our panorama spots comes back as

internal/cat/tci_ptt_test.go

@@ -0,0 +1,80 @@
+//go:build windows
+
+package cat
+
+import "testing"
+
+// feed pushes messages at the backend the way the radio would.
+func feed(t *TCI, msgs ...string) {
+	for _, m := range msgs {
+		t.handle(m)
+	}
+}
+
+// "PTT via CAT does nothing on TCI."
+//
+// ExpertSDR announces transmit permission with TX_ENABLE — on connect, and
+// again whenever the band changes "in case transmitter permission was changed"
+// (§4.3 of the protocol document). When it is false the radio simply IGNORES
+// trx. OpsLog sent the documented command, the radio discarded it, and nothing
+// anywhere said why: the operator pressed a dead key.
+func TestPTTIsRefusedOutLoudWhenTheRadioForbidsTransmitting(t *testing.T) {
+	tci := NewTCI("localhost", 40001, "FT8", false)
+	feed(tci, "tx_enable:0,false")
+
+	err := tci.SetPTT(true)
+	if err == nil {
+		t.Fatal("keying was accepted while the radio forbids transmitting — the operator gets no reason at all")
+	}
+	// The message has to name where to look; "PTT failed" sends nobody anywhere.
+	for _, want := range []string{"transmit", "ExpertSDR"} {
+		if !contains(err.Error(), want) {
+			t.Errorf("the refusal reads %q, which does not mention %q", err.Error(), want)
+		}
+	}
+
+	// Unkeying is never blocked. Whatever the radio thinks about permission, a
+	// request to STOP transmitting must always reach it.
+	if err := tci.SetPTT(false); err != nil && contains(err.Error(), "refusing") {
+		t.Errorf("unkeying was refused: %v", err)
+	}
+}
+
+// Permission comes back when the operator returns to a band they may use, and
+// PTT has to come back with it — not stay blocked until OpsLog is restarted.
+func TestPermissionGrantedAgainRestoresPTT(t *testing.T) {
+	tci := NewTCI("localhost", 40001, "FT8", false)
+	feed(tci, "tx_enable:0,false")
+	if err := tci.SetPTT(true); err == nil {
+		t.Fatal("keying was accepted while forbidden")
+	}
+	feed(tci, "tx_enable:0,true")
+	// No connection here, so the send fails — but it must fail as a TRANSPORT
+	// error, never as a refusal.
+	if err := tci.SetPTT(true); err != nil && contains(err.Error(), "refusing") {
+		t.Errorf("still refusing after permission was granted: %v", err)
+	}
+}
+
+// A radio that never mentions TX_ENABLE — an older ExpertSDR, or one of the
+// other programs that speak TCI — must not be treated as refusing. Silence is
+// not a "no": we key, and let the radio decide.
+func TestSilenceAboutPermissionIsNotARefusal(t *testing.T) {
+	tci := NewTCI("localhost", 40001, "FT8", false)
+	if err := tci.SetPTT(true); err != nil && contains(err.Error(), "refusing") {
+		t.Errorf("a radio that never sent TX_ENABLE was treated as forbidding transmit: %v", err)
+	}
+}
+
+func contains(s, sub string) bool {
+	return len(sub) == 0 || (len(s) >= len(sub) && indexOf(s, sub) >= 0)
+}
+
+func indexOf(s, sub string) int {
+	for i := 0; i+len(sub) <= len(s); i++ {
+		if s[i:i+len(sub)] == sub {
+			return i
+		}
+	}
+	return -1
+}

internal/cluster/cluster.go

@@ -18,6 +18,7 @@ import (
 	"strconv"
 	"strings"
 	"sync"
+	"sync/atomic"
 	"time"
 
 	"hamlog/internal/applog"
@@ -46,7 +47,12 @@ type Spot struct {
 	SourceID   int64     `json:"source_id"`   // ID of the cluster server this came from
 	SourceName string    `json:"source_name"` // display name (handy in the UI when multiple servers)
 	Spotter    string    `json:"spotter"`     // DE field
-	DXCall     string    `json:"dx_call"`     // the DX station heard
+	// SpotterContinent belongs to the SPOT, not to the DX station: one call is
+	// spotted by dozens of skimmers on every continent within a minute. It is
+	// resolved per spot at ingest for exactly that reason — see the note on the
+	// spotter-continent filter in App.tsx.
+	SpotterContinent string `json:"spotter_continent,omitempty"`
+	DXCall           string `json:"dx_call"` // the DX station heard
 	FreqKHz    float64   `json:"freq_khz"`
 	FreqHz     int64     `json:"freq_hz"`
 	Band       string    `json:"band,omitempty"`
@@ -355,6 +361,18 @@ func (s *session) run() {
 // that gets skipped.
 var idleTick = 30 * time.Second
 
+// promptTick is the read deadline used until the login handshake is finished.
+// Short, because a node's "login:" / "password:" carries no newline and is only
+// visible when the read times out — see the read loop. It costs a few wake-ups
+// during the first seconds of a connection and nothing afterwards.
+const promptTick = 700 * time.Millisecond
+
+// handshakeWindow bounds how long the fast promptTick applies. A node that has
+// a password configured but never asks for one would otherwise keep the loop
+// waking every 700 ms for the life of the connection, for a prompt that is never
+// coming. Any real login exchange is over in a second or two.
+const handshakeWindow = 20 * time.Second
+
 // quietNotice is the silence after which the log says so, once.
 const quietNotice = 10 * time.Minute
 
@@ -398,16 +416,37 @@ func (s *session) runOnce() (time.Time, error) {
 
 	// Login: send on first prompt OR blindly after 1.5s. Many DXSpider
 	// nodes accept the callsign without re-prompting.
-	loginSent := false
+	//
+	// Atomic because the blind-login timer below and the read loop both touch
+	// these. loginSent used to be a plain bool that the timer NEVER SET: the
+	// callsign went out and nothing recorded it, so the password branch — gated on
+	// loginSent — was dead code, and the session could only reach "connected" by
+	// recognising a welcome banner. On a node whose entire greeting is a bare
+	// "login:" and which then demands a password (f5mzn.org:9000), that left the
+	// server stuck at "connecting" for ever while telnet logged in by hand fine.
+	var loginSent, pwdSent atomic.Bool
+	// CompareAndSwap, not a plain store: the timer and the loop can reach these at
+	// the same moment, and the callsign must be written exactly once.
+	sendLogin := func() {
+		if s.login != "" && loginSent.CompareAndSwap(false, true) {
+			_, _ = conn.Write([]byte(s.login + "\r\n"))
+		}
+	}
+	// Sent ONCE per connection. A node that re-prompts is refusing the password,
+	// and answering with the same one again only loops — better to let the
+	// refusal show in the console than to hide it behind a retry.
+	sendPassword := func() {
+		if s.cfg.Password != "" && loginSent.Load() && pwdSent.CompareAndSwap(false, true) {
+			_, _ = conn.Write([]byte(s.cfg.Password + "\r\n"))
+		}
+	}
 	if s.login != "" {
 		go func() {
 			select {
 			case <-s.stopCh:
 				return
 			case <-time.After(1500 * time.Millisecond):
-				if !loginSent {
+				sendLogin()
-					_, _ = conn.Write([]byte(s.login + "\r\n"))
-				}
 			}
 		}()
 	}
@@ -453,7 +492,21 @@ func (s *session) runOnce() (time.Time, error) {
 
 	var connectedAt time.Time
 	var quiet time.Duration // how long the node has said nothing
+	var quietNoticed bool   // the long-silence line is said once
 	var pending string      // a line cut in half by a read deadline
+	markConnected := func() {
+		if s.snapshot().State == StateConnected {
+			return
+		}
+		connectedAt = time.Now()
+		s.mu.Lock()
+		s.status.State = StateConnected
+		s.status.ConnectedAt = connectedAt
+		s.status.Error = ""
+		s.mu.Unlock()
+		s.emitStatus()
+		fireInitCommands()
+	}
 	rd := bufio.NewReader(conn)
 	for {
 		select {
@@ -471,7 +524,21 @@ func (s *session) runOnce() (time.Time, error) {
 		// Only a REAL error ends the session. A dead peer still gets caught:
 		// TCP keepalive probes an idle connection and its failure arrives here
 		// as an error, not as a timeout.
-		_ = conn.SetReadDeadline(time.Now().Add(idleTick))
+		// SHORT deadline until the handshake is done, the long idle tick after.
+		//
+		// A cluster writes its prompts WITHOUT a trailing newline, and ReadString
+		// only returns on one — so a prompt is never a "line" at all, it is whatever
+		// is sitting in the buffer when the read deadline expires. At the ordinary
+		// 30 s tick that made a bare "login:" invisible for half a minute and a
+		// following "password:" invisible for another, which is long enough for the
+		// node to give up on us. Only the handshake needs the fast tick; once logged
+		// in, a long deadline is exactly what we want (see idleTick).
+		tick := idleTick
+		if time.Since(linkUpAt) < handshakeWindow &&
+			(!loginSent.Load() || (s.cfg.Password != "" && !pwdSent.Load())) {
+			tick = promptTick
+		}
+		_ = conn.SetReadDeadline(time.Now().Add(tick))
 		chunk, err := rd.ReadString('\n')
 		if err != nil {
 			var ne net.Error
@@ -480,16 +547,48 @@ func (s *session) runOnce() (time.Time, error) {
 				// Keep it: a spot line straddling the deadline would otherwise lose
 				// its first half and arrive as nonsense, or vanish entirely.
 				pending += chunk
-				quiet += idleTick
+				// …but a newline-less PROMPT is not half a line, it is a question,
+				// and this is the only place it can ever be seen. Answer it, show it
+				// in the console (an operator watching a stuck server has a right to
+				// see what the node actually asked), and drop it so it is not glued
+				// onto the front of the next real line.
+				if p := strings.TrimSpace(pending); p != "" {
+					switch {
+					case !loginSent.Load() && s.login != "" && isLoginPrompt(p):
+						s.emitLine(p, false)
+						pending = ""
+						sendLogin()
+						if s.cfg.Password == "" {
+							markConnected()
+						}
+						continue
+					case !pwdSent.Load() && isPasswordPrompt(p):
+						s.emitLine(p, false)
+						pending = ""
+						if s.cfg.Password == "" {
+							// Nothing to answer with. Shown in the console rather than
+							// swallowed: an unanswered "password:" sitting there IS the
+							// explanation for a server that never finishes connecting,
+							// and it is something the operator can act on.
+							continue
+						}
+						sendPassword()
+						markConnected()
+						continue
+					}
+				}
+				quiet += tick
 				// Said once at the first long silence, so a genuinely mute node is
 				// visible without a line every tick.
-				if quiet == quietNotice {
+				if !quietNoticed && quiet >= quietNotice {
+					quietNoticed = true
 					applog.Printf("cluster[%s] no traffic for %s — still connected", s.cfg.Name, quiet)
 				}
 				continue
 			}
 			return connectedAt, fmt.Errorf("read: %w", err)
 		}
+		quietNoticed = false
 		quiet = 0
 		line := pending + chunk
 		pending = ""
@@ -519,28 +618,23 @@ func (s *session) runOnce() (time.Time, error) {
 			}
 		}
 
-		// Login on explicit prompt.
+		// Login on explicit prompt — the case where the node DID terminate it with
-		if !loginSent && s.login != "" && isLoginPrompt(line) {
+		// a newline. The newline-less form is handled on the timeout path above.
-			_, _ = conn.Write([]byte(s.login + "\r\n"))
+		if !loginSent.Load() && s.login != "" && isLoginPrompt(line) {
-			loginSent = true
+			s.emitLine(line, false)
+			sendLogin()
 			continue
 		}
-		// Password on prompt (rare).
+		// Password on prompt.
-		if loginSent && s.cfg.Password != "" && isPasswordPrompt(line) {
+		if !pwdSent.Load() && isPasswordPrompt(line) {
-			_, _ = conn.Write([]byte(s.cfg.Password + "\r\n"))
+			s.emitLine(line, false)
+			sendPassword()
 			continue
 		}
 
 		// Mark connected once we've sent login OR seen a welcome banner.
-		if s.snapshot().State != StateConnected && (loginSent || isWelcome(line)) {
+		if loginSent.Load() || isWelcome(line) {
-			connectedAt = time.Now()
+			markConnected()
-			s.mu.Lock()
-			s.status.State = StateConnected
-			s.status.ConnectedAt = connectedAt
-			s.status.Error = ""
-			s.mu.Unlock()
-			s.emitStatus()
-			fireInitCommands()
 		}
 
 		// EVERY line goes to the console — spot or not. This is the whole point:
@@ -701,6 +795,38 @@ func parseSpot(line string) (Spot, bool) {
 	}, true
 }
 
+// NewLocalSpot builds the Spot for a DX announcement WE just sent, so it lands
+// in the operator's own list at once.
+//
+// A node does not necessarily broadcast a spot back to the station that sent it:
+// DXSpider suppresses the echo to the originator, and a node-side filter can eat
+// it too. So an operator spotted a station, watched their own spot list stay
+// empty, and concluded the spot had never gone out — when it had. This is the
+// spot the echo would have carried, built from what we sent, deliberately the
+// same shape so the UI's call+band de-dupe folds the two into one row on the
+// nodes that DO echo.
+func NewLocalSpot(srv ServerConfig, spotter, dxCall string, freqKHz float64, comment string) Spot {
+	freqHz := int64(freqKHz*1000 + 0.5)
+	now := time.Now()
+	sp := Spot{
+		SourceID:   srv.ID,
+		SourceName: srv.Name,
+		Spotter:    strings.ToUpper(strings.TrimSpace(spotter)),
+		DXCall:     strings.ToUpper(strings.TrimSpace(dxCall)),
+		FreqKHz:    freqKHz,
+		FreqHz:     freqHz,
+		Band:       bandFromHz(freqHz),
+		Comment:    strings.TrimSpace(comment),
+		TimeUTC:    now.UTC().Format("1504") + "Z",
+		ReceivedAt: now,
+	}
+	// Raw reads like the node's own broadcast — it is what anything showing the
+	// source line expects, and it keeps a local spot legible in the log.
+	sp.Raw = fmt.Sprintf("DX de %s: %9.1f  %-12s %-30s %s",
+		sp.Spotter, sp.FreqKHz, sp.DXCall, sp.Comment, sp.TimeUTC)
+	return sp
+}
+
 func isLoginPrompt(s string) bool {
 	low := strings.ToLower(s)
 	return strings.Contains(low, "login:") ||

internal/cluster/login_test.go

@@ -0,0 +1,105 @@
+package cluster
+
+import (
+	"bufio"
+	"net"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+)
+
+// A node whose whole greeting is a bare "login:" — no newline, no banner — and
+// which then demands a password must still log in.
+//
+// Reported on f5mzn.org:9000: telnet by hand worked, OpsLog sat at "connecting"
+// for ever. Two faults met there. The prompts carry no newline, and the read
+// loop only ever looked at complete LINES, so neither prompt was seen at all;
+// and the blind 1.5 s login never recorded that it had sent the callsign, which
+// left the password branch — gated on that flag — permanently switched off.
+//
+// The test speaks the node's side literally: "login:" with no newline, then
+// "password:" with no newline, then a spot. It asserts both answers arrive and
+// that the session reaches Connected without any welcome banner to lean on.
+func TestBareLoginAndPasswordPromptsWithoutNewlines(t *testing.T) {
+	ln, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer ln.Close()
+
+	host, portStr, _ := net.SplitHostPort(ln.Addr().String())
+	port, err := strconv.Atoi(portStr)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	type answers struct{ login, pwd string }
+	got := make(chan answers, 1)
+	go func() {
+		c, err := ln.Accept()
+		if err != nil {
+			return
+		}
+		defer c.Close()
+		rd := bufio.NewReader(c)
+		// No newline, exactly as the node sends it.
+		if _, err := c.Write([]byte("login: ")); err != nil {
+			return
+		}
+		call, err := rd.ReadString('\n')
+		if err != nil {
+			return
+		}
+		if _, err := c.Write([]byte("password: ")); err != nil {
+			return
+		}
+		pwd, err := rd.ReadString('\n')
+		if err != nil {
+			return
+		}
+		got <- answers{strings.TrimSpace(call), strings.TrimSpace(pwd)}
+		// Something to prove the link is live and parsing again afterwards.
+		_, _ = c.Write([]byte("DX de F4BPO:     14074.0  OY1CT        FT8            1234Z\r\n"))
+		time.Sleep(time.Second)
+	}()
+
+	spots := make(chan Spot, 4)
+	s := &session{
+		cfg:      ServerConfig{Name: "pwd node", Host: host, Port: port, Password: "s3cret"},
+		login:    "F4BPO",
+		onSpot:   func(sp Spot) { spots <- sp },
+		onLine:   func(Line) {},
+		onStatus: func() {},
+		stopCh:   make(chan struct{}),
+	}
+	done := make(chan error, 1)
+	go func() { _, err := s.runOnce(); done <- err }()
+	defer func() { close(s.stopCh); <-done }()
+
+	select {
+	case a := <-got:
+		if a.login != "F4BPO" {
+			t.Errorf("callsign sent = %q, want F4BPO", a.login)
+		}
+		if a.pwd != "s3cret" {
+			t.Errorf("password sent = %q, want s3cret — the prompt carried no newline", a.pwd)
+		}
+	case <-time.After(10 * time.Second):
+		t.Fatal("the node's newline-less prompts were never answered")
+	}
+
+	select {
+	case sp := <-spots:
+		if sp.DXCall != "OY1CT" {
+			t.Errorf("spot from the wrong station: %+v", sp)
+		}
+	case <-time.After(5 * time.Second):
+		t.Fatal("no spot after the login — the stream is not being parsed")
+	}
+
+	// Connected without a welcome banner: the handshake alone must be enough.
+	if st := s.snapshot().State; st != StateConnected {
+		t.Errorf("state = %q, want %q — the server would still show as connecting", st, StateConnected)
+	}
+}

internal/extsvc/clublog.go

@@ -40,12 +40,26 @@ func looksLikeHTML(s string) bool {
 // anything in the operator's log, which is what a test button must never do.
 const clublogDownloadURL = "https://clublog.org/getadif.php"
 
-// clublogAppAPIKey is OpsLog's Club Log *application* API key. Club Log
+// clublogAppAPIKey is OpsLog's own Club Log *application* API key, issued to
-// requires an api parameter that identifies the client software (not the
+// "OpsLog" by G7VJR on 2026-08-18.
-// user) — the same way Log4OM embeds its own key — so we ship it baked in
+//
-// rather than asking each user for one. It's an application identifier, not
+// Club Log requires an api parameter identifying the client SOFTWARE, not the
-// a user secret, but note it is visible in the source and the binary.
+// user — the same way Log4OM embeds its own — so it ships baked in rather than
-const clublogAppAPIKey = "5767f19333363a9ef432ee9cd4141fe76b8adf38"
+// asking every operator to request one.
+//
+// It replaces a key that was registered to XV9Q, not to OpsLog. That was not a
+// cosmetic detail: every OpsLog upload in the world was attributed to that
+// callsign, its owner received the abuse warnings OpsLog earned, and a
+// revocation aimed at them would have cut Club Log uploads for every user of
+// this program at once.
+//
+// Club Log asks that the key not be published in source code. The source lives
+// on a private remote and only the built exe is released — but the key is still
+// recoverable from that binary by anyone who looks, as it is for every logger
+// that embeds one. Treat it as an identifier that can be attributed, never as a
+// secret: it authorises nothing on its own, since every request also carries the
+// operator's own e-mail and password.
+const clublogAppAPIKey = "8df47807a412c586787c9401c96c10c135d6e580"
 
 // UploadClublog pushes one ADIF record to Club Log in real time. The user
 // supplies the account email + password and the logbook callsign; the
@@ -117,6 +131,13 @@ func UploadClublogADIF(ctx context.Context, client *http.Client, cfg ServiceConf
 	if api == "" {
 		api = clublogAppAPIKey
 	}
+	// putlogs.php reads the upload as an ADIF *file*, so it needs a header.
+	// Callers that already build a full document (the QSL Manager) pass one;
+	// callers that only have <EOR>-terminated records (the on-close flush) do
+	// not, and a headerless file is rejected. Same rule as the LoTW writer.
+	if !strings.Contains(strings.ToUpper(adifDoc), "<EOH>") {
+		adifDoc = "OpsLog Club Log upload\n<PROGRAMID:6>OpsLog <EOH>\n" + adifDoc
+	}
 
 	var buf bytes.Buffer
 	mw := multipart.NewWriter(&buf)

internal/extsvc/eqsl.go

@@ -267,6 +267,78 @@ func UploadEQSL(ctx context.Context, client *http.Client, user, pswd, qthNick, a
 	return UploadResult{OK: false, Message: reason}, fmt.Errorf("eqsl: upload failed: %s", reason)
 }
 
+// eqslBatchMax is the largest number of records eQSL asks a single upload to
+// carry ("upload only files smaller than about 1000 records at a time", eQSL's
+// own ImportADIF interface notes). Callers chunk to this.
+const eqslBatchMax = 1000
+
+// UploadEQSLBatch pushes MANY ADIF records to eQSL.cc in ONE request.
+//
+// ImportADIF.cfm is a file importer, not a per-QSO endpoint: it takes one *or
+// more* QSOs and answers "Result: X out of Y records added" — the plural in its
+// own reply. So an on-close sweep or a bulk upload is one request, not one per
+// contact. No ADIF header is prepended: the single-record path has always posted
+// bare <EOR> records and eQSL accepts them (per ADIF, a file starting with '<'
+// has no header), and there is no reason to change what is known to work.
+//
+// A PARTIAL result ("97 out of 100") sets Ignored so the caller can say so.
+// eQSL does not identify which records it left out, and in practice they are
+// QSOs it already holds — the same duplicate that UploadEQSL reports as success.
+func UploadEQSLBatch(ctx context.Context, client *http.Client, user, pswd, qthNick string, records []string) (UploadResult, error) {
+	user = strings.ToUpper(strings.TrimSpace(user))
+	if user == "" {
+		return UploadResult{}, fmt.Errorf("eqsl: username (callsign) not set")
+	}
+	if strings.TrimSpace(pswd) == "" {
+		return UploadResult{}, fmt.Errorf("eqsl: password not set")
+	}
+	docs := make([]string, 0, len(records))
+	for _, r := range records {
+		if strings.TrimSpace(r) == "" {
+			continue
+		}
+		docs = append(docs, eqslRecordWithNickname(strings.TrimRight(r, "\r\n"), qthNick))
+	}
+	if len(docs) == 0 {
+		return UploadResult{}, fmt.Errorf("eqsl: empty adif batch")
+	}
+	if len(docs) > eqslBatchMax {
+		return UploadResult{}, fmt.Errorf("eqsl: batch of %d exceeds the %d-record limit", len(docs), eqslBatchMax)
+	}
+
+	body, err := eqslPost(ctx, client, user, pswd, strings.Join(docs, "\n"))
+	if err != nil {
+		return UploadResult{OK: false, Message: body}, err
+	}
+	if reason := authErrEQSL(body); reason != "" {
+		return UploadResult{OK: false, Message: reason}, fmt.Errorf("eqsl: %s", reason)
+	}
+
+	// The counted result is read FIRST here, unlike the single-record path: a
+	// batch reply routinely carries both "Result: 97 out of 100 records added"
+	// and a "Bad record: Duplicate" line for the other three, and matching the
+	// duplicate first would throw away the count that says the rest went in.
+	if m := eqslResultRe.FindStringSubmatch(body); m != nil {
+		added, _ := strconv.Atoi(m[1])
+		total, _ := strconv.Atoi(m[2])
+		if added >= 1 {
+			return UploadResult{OK: true, Message: strings.TrimSpace(m[0]), Ignored: added < total}, nil
+		}
+		// "0 out of N" — nothing added. A re-upload of QSOs eQSL already holds
+		// lands here, and that is not a failure.
+		if strings.Contains(strings.ToLower(body), "duplicate") {
+			return UploadResult{OK: true, Message: "already in logbook"}, nil
+		}
+		reason := eqslReason(body)
+		return UploadResult{OK: false, Message: reason}, fmt.Errorf("eqsl: batch upload failed: %s", reason)
+	}
+	if strings.Contains(strings.ToLower(body), "duplicate") {
+		return UploadResult{OK: true, Message: "already in logbook"}, nil
+	}
+	reason := eqslReason(body)
+	return UploadResult{OK: false, Message: reason}, fmt.Errorf("eqsl: batch upload failed: %s", reason)
+}
+
 // eqslReason trims an eQSL reply to a short human-readable reason: the first
 // "Error:" / "Warning:" / "Bad record:" line if present, else the whole body
 // (capped), else a generic phrase.

internal/extsvc/manager.go

@@ -295,9 +295,10 @@ func (m *Manager) CloseUploadCount() int {
 }
 
 // FlushOnClose uploads every QSO due for an on-close push, scanning the whole
-// logbook (not just this session). Called from the shutdown sequence. QRZ/Club
+// logbook (not just this session). Called from the shutdown sequence. QRZ and
-// Log go one-by-one (fast HTTP); LoTW is signed and uploaded as a single TQSL
+// the rest go one-by-one (fast HTTP, no batch API); LoTW is signed and uploaded
-// batch. Returns the number of QSOs uploaded successfully.
+// as a single TQSL batch, and Club Log goes through its batch endpoint.
+// Returns the number of QSOs uploaded successfully.
 func (m *Manager) FlushOnClose() int {
 	if m.deps.CloseUploadIDs == nil {
 		return 0
@@ -312,41 +313,190 @@ func (m *Manager) FlushOnClose() int {
 		switch svc {
 		case ServiceLoTW:
 			uploaded += m.flushLoTWBatch(ids, cfg.LoTW)
-		case ServiceQRZ:
-			for _, id := range ids {
-				if ok, _ := m.upload(svc, id, cfg.QRZ); ok {
-					uploaded++
-				}
-			}
 		case ServiceClublog:
-			for _, id := range ids {
+			uploaded += m.flushClublogBatch(ids, cfg.Clublog)
-				if ok, _ := m.upload(svc, id, cfg.Clublog); ok {
-					uploaded++
-				}
-			}
-		case ServiceHRDLog:
-			for _, id := range ids {
-				if ok, _ := m.upload(svc, id, cfg.HRDLog); ok {
-					uploaded++
-				}
-			}
 		case ServiceEQSL:
-			for _, id := range ids {
+			uploaded += m.flushEQSLBatch(ids, cfg.EQSL)
-				if ok, _ := m.upload(svc, id, cfg.EQSL); ok {
+		case ServiceQRZ:
-					uploaded++
+			uploaded += m.flushOneByOne(svc, ids, cfg.QRZ)
-				}
+		case ServiceHRDLog:
-			}
+			uploaded += m.flushOneByOne(svc, ids, cfg.HRDLog)
 		case ServiceCloudlog:
-			for _, id := range ids {
+			uploaded += m.flushOneByOne(svc, ids, cfg.Cloudlog)
-				if ok, _ := m.upload(svc, id, cfg.Cloudlog); ok {
-					uploaded++
-				}
-			}
 		}
 	}
 	return uploaded
 }
 
+// uploadPace is the shortest gap between two consecutive single-QSO uploads in
+// an on-close sweep. QRZ, HRDLog and Cloudlog have no batch endpoint — HRDLog's
+// NewEntry.aspx keeps only the first record of a multi-record ADIF — so a sweep
+// of a freshly imported log is unavoidably one request per contact. It does not
+// have to arrive as fast as the link allows, though: that burst is what a
+// service reads as a robot, and what got an operator's IP threatened at Club Log
+// (see flushClublogBatch). The gap costs nothing in practice, since a round trip
+// to any of these already takes longer than it.
+const uploadPace = 200 * time.Millisecond
+
+// flushOneByOne uploads ids one request at a time, paced. For the services that
+// have no batch API; everything else has its own flush<Service>Batch.
+func (m *Manager) flushOneByOne(svc Service, ids []int64, cfg ServiceConfig) int {
+	uploaded := 0
+	for i, id := range ids {
+		if i > 0 {
+			time.Sleep(uploadPace)
+		}
+		if ok, _ := m.upload(svc, id, cfg); ok {
+			uploaded++
+		}
+	}
+	return uploaded
+}
+
+// eqslBatchChunk is how many QSOs go into one ImportADIF.cfm request. eQSL's own
+// limit is ten times this (eqslBatchMax); the smaller chunk keeps one refused
+// record from taking a thousand others down with it, and keeps the form body
+// small enough to be unremarkable.
+const eqslBatchChunk = 100
+
+// flushEQSLBatch uploads the on-close eQSL QSOs through ImportADIF.cfm in
+// batches instead of one request per contact. Same reasoning as
+// flushClublogBatch — eQSL's import endpoint has always taken a whole file, so
+// the one-at-a-time loop was making hundreds of requests it never needed to.
+func (m *Manager) flushEQSLBatch(ids []int64, cfg ServiceConfig) int {
+	uploaded := 0
+	var records []string
+	var kept []int64
+
+	send := func() {
+		if len(records) == 0 {
+			return
+		}
+		// nil client: UploadEQSLBatch then builds one with a 30 s timeout rather
+		// than reusing the 20 s budget of a single realtime QSO.
+		res, err := UploadEQSLBatch(context.Background(), nil, cfg.Username, cfg.Password, cfg.QTHNickname, records)
+		if err != nil || !res.OK {
+			if err == nil {
+				err = errFromResult(res)
+			}
+			m.logf("extsvc: eqsl batch upload (%d QSOs) failed: %v", len(kept), err)
+			if m.deps.NotifyError != nil {
+				m.deps.NotifyError(ServiceEQSL, 0, err)
+			}
+		} else {
+			// res.Ignored means eQSL took the file but left records out. Say the
+			// count out loud: the whole chunk is still marked sent (eQSL never
+			// says WHICH it dropped, and in practice they are QSOs it already
+			// had), so the log line is the only trace of the shortfall.
+			if res.Ignored {
+				m.logf("extsvc: eqsl batch upload PARTIAL (%d QSOs sent) %s", len(kept), res.Message)
+			} else {
+				m.logf("extsvc: eqsl batch upload OK (%d QSOs) %s", len(kept), res.Message)
+			}
+			if m.deps.MarkUploaded != nil {
+				for _, id := range kept {
+					m.deps.MarkUploaded(ServiceEQSL, id, res.LogID)
+				}
+			}
+			uploaded += len(kept)
+		}
+		records = records[:0]
+		kept = kept[:0]
+	}
+
+	for _, id := range ids {
+		if m.deps.ShouldUpload != nil && !m.deps.ShouldUpload(ServiceEQSL, id) {
+			continue
+		}
+		// eQSL keeps the QSO's own station call; the account is identified by the
+		// credentials and the optional QTH nickname — as in upload().
+		rec, ok := m.deps.BuildADIF(id, "")
+		if !ok {
+			continue
+		}
+		records = append(records, rec)
+		kept = append(kept, id)
+		if len(records) >= eqslBatchChunk {
+			send()
+		}
+	}
+	send()
+	return uploaded
+}
+
+// clublogBatchChunk is how many QSOs go into one putlogs.php request. Club Log
+// dedupes server-side, so chunking is not about correctness — it keeps a single
+// malformed record from failing a whole ten-thousand-QSO document, and matches
+// what the QSL Manager's bulk upload already uses.
+const clublogBatchChunk = 100
+
+// flushClublogBatch uploads the on-close Club Log QSOs through the BATCH
+// endpoint (putlogs.php) rather than one realtime.php call each.
+//
+// It used to walk the ids and call UploadClublog per QSO. On-close upload sweeps
+// the WHOLE logbook, so importing an ADIF — or simply switching Club Log on over
+// an existing log — turned one app close into hundreds of realtime.php posts.
+// That endpoint is reserved for an operator logging contacts as they work them,
+// and Club Log blocks the IP of anything that batches through it: an OpsLog user
+// was flagged by G7VJR for 185 QSOs in four minutes, which is this loop, not a
+// pile-up. Batch upload is the mechanism Club Log provides for exactly this.
+func (m *Manager) flushClublogBatch(ids []int64, cfg ServiceConfig) int {
+	uploaded := 0
+	var records []string
+	var kept []int64
+
+	send := func() {
+		if len(records) == 0 {
+			return
+		}
+		// nil client on purpose: UploadClublogADIF then builds one with a 120 s
+		// timeout. m.deps.Client is the 20 s budget of a single realtime QSO,
+		// which a hundred-QSO document on a slow link would blow through.
+		res, err := UploadClublogADIF(context.Background(), nil, cfg, strings.Join(records, "\n"))
+		if err != nil || !res.OK {
+			if err == nil {
+				err = errFromResult(res)
+			}
+			m.logf("extsvc: clublog batch upload (%d QSOs) failed: %v", len(kept), err)
+			if m.deps.NotifyError != nil {
+				m.deps.NotifyError(ServiceClublog, 0, err)
+			}
+		} else {
+			m.logf("extsvc: clublog batch upload OK (%d QSOs) %s", len(kept), res.Message)
+			if m.deps.MarkUploaded != nil {
+				for _, id := range kept {
+					m.deps.MarkUploaded(ServiceClublog, id, res.LogID)
+				}
+			}
+			uploaded += len(kept)
+		}
+		records = records[:0]
+		kept = kept[:0]
+	}
+
+	for _, id := range ids {
+		// Skip QSOs not eligible (already sent). The wrong-logbook guard that
+		// upload() applies per QSO is not repeated here: closeUploadIDs has
+		// already filtered the sweep down to this logbook's callsign.
+		if m.deps.ShouldUpload != nil && !m.deps.ShouldUpload(ServiceClublog, id) {
+			continue
+		}
+		// Club Log takes the logbook callsign as its own form field, so the ADIF
+		// keeps the QSO's own station call (no override) — as in upload().
+		rec, ok := m.deps.BuildADIF(id, "")
+		if !ok {
+			continue
+		}
+		records = append(records, rec)
+		kept = append(kept, id)
+		if len(records) >= clublogBatchChunk {
+			send()
+		}
+	}
+	send()
+	return uploaded
+}
+
 // flushLoTWBatch signs+uploads all queued LoTW QSOs in one TQSL run, then
 // stamps each as uploaded on success.
 func (m *Manager) flushLoTWBatch(ids []int64, cfg ServiceConfig) int {

internal/integrations/udp/config.go

@@ -37,6 +37,19 @@ const (
 	ServiceDBUpdated ServiceType = "db_updated"      // ADIF of each locally-logged QSO (on save)
 	ServicePstFreq   ServiceType = "pstrotator_freq" // <PST><FREQUENCY> radio freq (on freq change)
 	ServiceN1MMRadio ServiceType = "n1mm_radioinfo"  // N1MM RadioInfo XML: freq+mode (on freq/mode change)
+	// ServiceWSJTRelay re-sends every datagram an inbound WSJT listener receives,
+	// byte for byte, to somewhere else.
+	//
+	// WSJT-X, JTDX and MSHV send to ONE address. Anything else that wants the
+	// same stream — JTAlert, GridTracker, a second logger — has to be fed by a
+	// relay, and this is it, so OpsLog stops being the reason you cannot run the
+	// two together.
+	//
+	// VERBATIM, with no origin header prepended. The relays in the field add one
+	// ("127.0.0.1:2237|"), which is precisely why stripForwarderHeader exists on
+	// the receiving side here; inflicting the same thing on whatever is
+	// downstream would be repeating a mistake we had to write code to survive.
+	ServiceWSJTRelay ServiceType = "wsjt_relay"
 	// ServiceWSJTLog wraps the same ADIF in a WSJT-X "Logged ADIF" datagram.
 	// Logger32 and others listen on the WSJT-X interface, not for plain text, and
 	// discard a bare ADIF record without a word — so the two cannot be one row.

internal/integrations/udp/decodegrid_test.go

@@ -0,0 +1,75 @@
+package udp
+
+import (
+	"bytes"
+	"encoding/binary"
+	"testing"
+)
+
+// A grid reaches OpsLog in TWO kinds of message, not one. The reply that
+// answers a CQ with a locator — "C91RU IZ5EME JN52" — is the commonest of them
+// on a busy band, and reading only CQs meant any station whose CQ we happened
+// to miss had no known grid at all, so it could never be flagged as a new one.
+func TestDecodeGridFromBothMessageShapes(t *testing.T) {
+	for _, tc := range []struct {
+		msg  string
+		call string
+		cq   bool
+		grid string
+		why  string
+	}{
+		{"CQ RW9MZ MO74", "RW9MZ", true, "MO74", "a plain CQ"},
+		{"CQ DX F4BPO JN36", "F4BPO", true, "JN36", "a CQ with a modifier"},
+		{"C91RU IZ5EME JN52", "IZ5EME", false, "JN52", "a reply answering with its grid"},
+		{"YB1EWD YO6GLT KN36", "YO6GLT", false, "KN36", "the same, other way round"},
+
+		// Everything else in the third slot is a report or a sign-off, and must
+		// never be mistaken for a locator.
+		{"C91RU IZ5EME -05", "IZ5EME", false, "", "a signal report is not a grid"},
+		{"C91RU IZ5EME R-05", "IZ5EME", false, "", "a rogered report is not a grid"},
+		{"C91RU IZ5EME RRR", "IZ5EME", false, "", "RRR is not a grid"},
+		{"C91RU IZ5EME RR73", "IZ5EME", false, "", "RR73 has the shape of one and is not"},
+		{"C91RU IZ5EME 73", "IZ5EME", false, "", "73 is not a grid"},
+		{"<YO7LBX> 8F81SU RR73", "8F81SU", false, "", "a hashed call, signing off"},
+	} {
+		call, cq, grid := wsjtSender(tc.msg)
+		if call != tc.call || cq != tc.cq || grid != tc.grid {
+			t.Errorf("wsjtSender(%q) = (%q, %v, %q), want (%q, %v, %q) — %s",
+				tc.msg, call, cq, grid, tc.call, tc.cq, tc.grid, tc.why)
+		}
+	}
+}
+
+// The Reply replays the decode field for field, so the message must survive the
+// trip UNTRIMMED. DecodeMsg is trimmed for display; DecodeMsgRaw is what goes
+// back, and a stripped trailing space is a mismatch the far end reports nowhere.
+func TestDecodeKeepsTheUntrimmedMessage(t *testing.T) {
+	qstr := func(b *bytes.Buffer, v string) {
+		binary.Write(b, binary.BigEndian, int32(len(v)))
+		b.WriteString(v)
+	}
+	const padded = "CQ RW9MZ MO74  "
+	var p bytes.Buffer
+	binary.Write(&p, binary.BigEndian, uint32(wsjtMagic))
+	binary.Write(&p, binary.BigEndian, uint32(2))
+	binary.Write(&p, binary.BigEndian, uint32(wsjtMsgDecode))
+	qstr(&p, "JTDX")
+	binary.Write(&p, binary.BigEndian, uint8(1))
+	binary.Write(&p, binary.BigEndian, uint32(45_000_000))
+	binary.Write(&p, binary.BigEndian, int32(-6))
+	binary.Write(&p, binary.BigEndian, float64(0.2))
+	binary.Write(&p, binary.BigEndian, uint32(1500))
+	qstr(&p, "~")
+	qstr(&p, padded)
+
+	ev, ok, err := ParseWSJT(p.Bytes())
+	if err != nil || !ok {
+		t.Fatalf("parse: %v ok=%v", err, ok)
+	}
+	if ev.DecodeMsgRaw != padded {
+		t.Errorf("DecodeMsgRaw = %q, want %q — a Reply built from this will not match", ev.DecodeMsgRaw, padded)
+	}
+	if ev.DecodeMsg != "CQ RW9MZ MO74" {
+		t.Errorf("DecodeMsg = %q, want it trimmed for display", ev.DecodeMsg)
+	}
+}

internal/integrations/udp/decodemode_test.go

@@ -0,0 +1,115 @@
+package udp
+
+import (
+	"bytes"
+	"encoding/binary"
+	"net"
+	"testing"
+)
+
+// A Decode does not carry the mode's NAME. It carries the one-character marker
+// from the decode line — "~" for FT8, "+" for FT4 — and that character used to
+// be passed on as if it were a mode. Everything downstream compared it against
+// the modes in the log, matched nothing, and reported every station on an
+// already-worked band as a NEW MODE.
+func TestDecodeModeNameResolvesTheMarker(t *testing.T) {
+	for raw, want := range map[string]string{
+		"~": "FT8",
+		"+": "FT4",
+		"#": "JT65",
+		"@": "JT9",
+	} {
+		if got := DecodeModeName(raw, "FT8"); got != want {
+			t.Errorf("DecodeModeName(%q) = %q, want %q", raw, got, want)
+		}
+	}
+}
+
+// A sender that puts the real name in the field is believed as-is — several do,
+// and the marker table must not get in their way.
+func TestDecodeModeNameKeepsARealName(t *testing.T) {
+	for _, raw := range []string{"FT8", "ft4", "JS8", "Q65"} {
+		if got := DecodeModeName(raw, ""); got == "" || got != upper(raw) {
+			t.Errorf("DecodeModeName(%q) = %q, want the name itself", raw, got)
+		}
+	}
+}
+
+// The safety net: an unknown marker falls back to the mode from the sender's
+// last Status, which always carries the real name. This is what keeps a future
+// or unlisted marker degrading to correct rather than to nonsense.
+func TestDecodeModeNameFallsBackToStatus(t *testing.T) {
+	if got := DecodeModeName("%", "FT4"); got != "FT4" {
+		t.Errorf("unknown marker resolved to %q, want the Status mode FT4", got)
+	}
+	if got := DecodeModeName("", "FT8"); got != "FT8" {
+		t.Errorf("empty mode resolved to %q, want the Status mode FT8", got)
+	}
+	// Nothing known at all is empty rather than a guess: an empty mode makes the
+	// status resolver answer "worked", which is the safe side — a wrong mode
+	// would invent a new-mode flag exactly as the marker did.
+	if got := DecodeModeName("%", ""); got != "" {
+		t.Errorf("with no Status mode the result was %q, want empty", got)
+	}
+}
+
+func upper(s string) string {
+	out := []rune(s)
+	for i, r := range out {
+		if r >= 'a' && r <= 'z' {
+			out[i] = r - 32
+		}
+	}
+	return string(out)
+}
+
+// Resolving the marker must not DESTROY it. A Reply is matched by the receiving
+// application against its own decode list field for field, and the mode field it
+// compares is the one it sent — the marker. Sending the resolved name instead is
+// accepted silently and simply never transmits: JTDX finds no matching decode,
+// and no error is reported anywhere to say so. Reported as "clicking a CQ does
+// nothing in JTDX".
+//
+// So a Decode has to carry BOTH: Mode for the log and the status resolver,
+// DecodeModeRaw for the Reply.
+func TestDecodeKeepsTheRawModeMarkerForReplies(t *testing.T) {
+	qstr := func(b *bytes.Buffer, v string) {
+		binary.Write(b, binary.BigEndian, int32(len(v)))
+		b.WriteString(v)
+	}
+	var p bytes.Buffer
+	binary.Write(&p, binary.BigEndian, uint32(wsjtMagic))
+	binary.Write(&p, binary.BigEndian, uint32(2))             // schema
+	binary.Write(&p, binary.BigEndian, uint32(wsjtMsgDecode)) // type 2
+	qstr(&p, "JTDX")                                          // id
+	binary.Write(&p, binary.BigEndian, uint8(1))              // is_new
+	binary.Write(&p, binary.BigEndian, uint32(45_000_000))    // time (ms since midnight)
+	binary.Write(&p, binary.BigEndian, int32(-6))             // snr
+	binary.Write(&p, binary.BigEndian, float64(0.2))          // delta_time
+	binary.Write(&p, binary.BigEndian, uint32(1500))          // delta_frequency
+	qstr(&p, "~")                                             // mode — the MARKER
+	qstr(&p, "CQ EN35UKR")                                    // message
+
+	out := make(chan Event, 4)
+	s := &Server{
+		out:      out,
+		cfg:      Config{Name: "JTDX", ServiceType: ServiceWSJT},
+		lastMode: map[string]string{"JTDX": "FT8"},
+		dialHz:   map[string]int64{"JTDX": 14074000},
+	}
+	s.handle(p.Bytes(), &net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 2237})
+
+	var ev Event
+	select {
+	case ev = <-out:
+	default:
+		t.Fatal("no event emitted for the decode")
+	}
+	if ev.Mode != "FT8" {
+		t.Errorf("resolved Mode = %q, want FT8 (what the log and the status resolver need)", ev.Mode)
+	}
+	if ev.DecodeModeRaw != "~" {
+		t.Errorf("DecodeModeRaw = %q, want %q — a Reply built from this will not match and JTDX will not transmit",
+			ev.DecodeModeRaw, "~")
+	}
+}

internal/integrations/udp/decodetime_test.go

@@ -0,0 +1,70 @@
+package udp
+
+import (
+	"testing"
+	"time"
+)
+
+const ms = 1000
+
+func sec(h, m, s int) uint32 { return uint32((h*3600 + m*60 + s) * ms) }
+
+// WSJT-X stamps a decode with a time of DAY and no date, so the date has to come
+// from our own clock — and around midnight the two disagree. A decode stamped
+// 23:59:58 that reaches us at 00:00:01 would be dated the NEW day, putting it
+// almost 24 hours in the future: it would sort to the top of the decodes panel
+// and stay there for the rest of the session, and its period would never line up
+// with the ones around it.
+//
+// The clock is passed IN. The previous version of this test read the real one
+// and so failed every afternoon — a 23:59:58 stamp seen at 17:00 is genuinely
+// hours in the future, and no rule can make it otherwise. A suite that is red
+// for half the day is a suite nobody reads.
+func TestDecodeTimeCrossesMidnight(t *testing.T) {
+	// Just after midnight, a stamp from the last seconds of yesterday.
+	now := time.Date(2026, 3, 14, 0, 0, 1, 0, time.UTC)
+	got := decodeTimeAt(sec(23, 59, 58), now)
+	if want := time.Date(2026, 3, 13, 23, 59, 58, 0, time.UTC); !got.Equal(want) {
+		t.Errorf("23:59:58 seen at 00:00:01 → %s, want %s (yesterday)", got, want)
+	}
+	if got.After(now) {
+		t.Errorf("%s is in the future — it would sort to the top of the list for the session", got)
+	}
+}
+
+// The mirror case: just before midnight, a stamp from the first seconds of
+// tomorrow. Our clock is still on the old day.
+func TestDecodeTimeCrossesMidnightBackwards(t *testing.T) {
+	now := time.Date(2026, 3, 13, 23, 59, 58, 0, time.UTC)
+	got := decodeTimeAt(sec(0, 0, 1), now)
+	if want := time.Date(2026, 3, 14, 0, 0, 1, 0, time.UTC); !got.Equal(want) {
+		t.Errorf("00:00:01 seen at 23:59:58 → %s, want %s (tomorrow)", got, want)
+	}
+}
+
+// The ordinary case, which is every decode that is not within a few seconds of
+// midnight: the stamp belongs to today and is left alone.
+func TestDecodeTimeOrdinary(t *testing.T) {
+	now := time.Date(2026, 3, 13, 14, 30, 0, 0, time.UTC)
+	got := decodeTimeAt(sec(14, 29, 45), now)
+	if want := time.Date(2026, 3, 13, 14, 29, 45, 0, time.UTC); !got.Equal(want) {
+		t.Errorf("a stamp close to now → %s, want %s", got, want)
+	}
+}
+
+// The whole point of the timestamp is grouping, so two decodes from the same
+// fifteen-second slot must floor to the same period however far apart in the
+// slot they were heard.
+func TestDecodesInOneSlotShareAPeriod(t *testing.T) {
+	now := time.Date(2026, 3, 13, 12, 30, 7, 0, time.UTC)
+	at := func(h, m, s int) time.Time { return decodeTimeAt(sec(h, m, s), now) }
+	floor := func(x time.Time) int64 { return x.Unix() / 15 * 15 }
+
+	a, b := at(12, 30, 0), at(12, 30, 14)
+	if floor(a) != floor(b) {
+		t.Errorf("%s and %s fell in different periods", a, b)
+	}
+	if floor(at(12, 30, 14)) == floor(at(12, 30, 15)) {
+		t.Error("12:30:14 and 12:30:15 are different slots and must not share a period")
+	}
+}

internal/integrations/udp/outbound.go

@@ -2,6 +2,7 @@ package udp
 
 import (
 	"fmt"
+	"net"
 	"strings"
 
 	"hamlog/internal/applog"
@@ -185,3 +186,94 @@ func (m *Manager) sendTo(c Config, payload []byte) {
 	applog.Printf("udp: [%s] sent %d bytes to %s (%s)%s",
 		c.Name, len(payload), dst, c.ServiceType, sentPreview(c, payload))
 }
+
+// RelayInbound re-sends one received datagram, unchanged, to every configured
+// relay destination.
+//
+// Called with the RAW bytes as they arrived — before parsing, and whatever the
+// parse made of them. A packet this build cannot decode is still a packet the
+// application downstream may understand perfectly well, and a relay that only
+// forwards what it understood is a relay that silently drops the fields it has
+// not learned about yet.
+//
+// Loop guard: a destination that is one of our OWN inbound ports on a local
+// address would come straight back in and be relayed again, for ever, at line
+// rate. Such a row is skipped and said so once — quietly dropping it would look
+// like a relay that does not work.
+func (m *Manager) RelayInbound(pkt []byte, fromPort int) {
+	if len(pkt) == 0 {
+		return
+	}
+	rows := m.Outbound(ServiceWSJTRelay)
+	if len(rows) == 0 {
+		return
+	}
+	m.mu.Lock()
+	ports := make(map[int]struct{}, len(m.inbound))
+	for _, s := range m.inbound {
+		ports[s.cfg.Port] = struct{}{}
+	}
+	m.mu.Unlock()
+
+	for _, c := range rows {
+		if isLoopback(c.DestinationIP) {
+			if _, mine := ports[c.Port]; mine {
+				m.relayLoopOnce(c)
+				continue
+			}
+		}
+		// Deliberately not sendTo: that logs a line per datagram, and this runs
+		// on every decode of every period — it would bury the log within minutes.
+		host := strings.TrimSpace(c.DestinationIP)
+		if host == "" {
+			host = "127.0.0.1"
+		}
+		dst := fmt.Sprintf("%s:%d", host, c.Port)
+		if err := SendUDP(dst, pkt); err != nil {
+			m.relayErrOnce(c, dst, err)
+		}
+	}
+	_ = fromPort
+}
+
+// isLoopback reports whether a destination names this machine. Empty counts:
+// sendTo defaults it to 127.0.0.1.
+func isLoopback(host string) bool {
+	h := strings.TrimSpace(host)
+	if h == "" || h == "localhost" {
+		return true
+	}
+	ip := net.ParseIP(h)
+	return ip != nil && ip.IsLoopback()
+}
+
+// relayLoopOnce and relayErrOnce keep a repeating relay complaint to one line a
+// session. Both fire per datagram otherwise, which on a busy band is hundreds a
+// minute and makes the log useless for anything else.
+func (m *Manager) relayLoopOnce(c Config) {
+	m.relayWarnMu.Lock()
+	defer m.relayWarnMu.Unlock()
+	if m.relayWarned == nil {
+		m.relayWarned = map[int64]bool{}
+	}
+	if m.relayWarned[c.ID] {
+		return
+	}
+	m.relayWarned[c.ID] = true
+	applog.Printf("udp: [%s] relay target %s:%d is one of OpsLog's OWN listening ports — "+
+		"that would feed the stream back into itself for ever. Nothing is relayed on this row; "+
+		"point it at the other application's port.", c.Name, c.DestinationIP, c.Port)
+}
+
+func (m *Manager) relayErrOnce(c Config, dst string, err error) {
+	m.relayWarnMu.Lock()
+	defer m.relayWarnMu.Unlock()
+	if m.relayWarned == nil {
+		m.relayWarned = map[int64]bool{}
+	}
+	if m.relayWarned[-c.ID-1] {
+		return
+	}
+	m.relayWarned[-c.ID-1] = true
+	applog.Printf("udp: [%s] relay to %s failed: %v (said once)", c.Name, dst, err)
+}

internal/integrations/udp/relay_test.go

@@ -0,0 +1,77 @@
+package udp
+
+import (
+	"net"
+	"testing"
+	"time"
+)
+
+// The relay exists so a second application can be fed the same WSJT-X stream,
+// and the ONE thing it must get right is that the bytes are unchanged. The
+// relays in the field prepend an origin header ("127.0.0.1:2237|") — which is
+// why stripForwarderHeader had to be written on the receiving side — so a
+// header here would inflict on the next program the fault we had to survive.
+func TestRelayForwardsVerbatim(t *testing.T) {
+	dst, err := net.ListenUDP("udp", &net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 0})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer dst.Close()
+	port := dst.LocalAddr().(*net.UDPAddr).Port
+
+	m := &Manager{outbound: []Config{{
+		ID: 1, Name: "relay", ServiceType: ServiceWSJTRelay,
+		DestinationIP: "127.0.0.1", Port: port,
+	}}}
+
+	// A packet with bytes that no parser here understands, on purpose: the relay
+	// must not care what it is carrying.
+	sent := []byte{0xad, 0xbc, 0xcb, 0xda, 0x00, 0x00, 0x00, 0x63, 0xde, 0xad, 0xbe, 0xef}
+	m.RelayInbound(sent, 2237)
+
+	buf := make([]byte, 1024)
+	_ = dst.SetReadDeadline(time.Now().Add(2 * time.Second))
+	n, _, err := dst.ReadFromUDP(buf)
+	if err != nil {
+		t.Fatalf("nothing relayed: %v", err)
+	}
+	if got := buf[:n]; string(got) != string(sent) {
+		t.Errorf("relayed % X, want % X — the bytes must go out unchanged", got, sent)
+	}
+}
+
+// A relay aimed at one of OpsLog's OWN listening ports would come straight back
+// in, be relayed again, and saturate the loopback within seconds. The row is
+// skipped instead.
+func TestRelayRefusesToFeedItself(t *testing.T) {
+	own, err := net.ListenUDP("udp", &net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 0})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer own.Close()
+	port := own.LocalAddr().(*net.UDPAddr).Port
+
+	m := &Manager{
+		inbound: map[int64]*Server{
+			7: {cfg: Config{ID: 7, Port: port, ServiceType: ServiceWSJT}},
+		},
+		outbound: []Config{{
+			ID: 1, Name: "loop", ServiceType: ServiceWSJTRelay,
+			DestinationIP: "127.0.0.1", Port: port,
+		}},
+	}
+	m.RelayInbound([]byte{1, 2, 3, 4}, 2237)
+
+	buf := make([]byte, 64)
+	_ = own.SetReadDeadline(time.Now().Add(300 * time.Millisecond))
+	if n, _, err := own.ReadFromUDP(buf); err == nil {
+		t.Fatalf("relayed %d bytes back into our own listener — that is the loop", n)
+	}
+}
+
+// No relay rows configured must cost nothing and send nothing.
+func TestRelayWithNoRowsIsSilent(t *testing.T) {
+	m := &Manager{}
+	m.RelayInbound([]byte{1, 2, 3}, 2237) // must not panic
+	m.RelayInbound(nil, 2237)
+}

internal/integrations/udp/server.go

@@ -77,6 +77,37 @@ func reusingListenConfig() net.ListenConfig {
 	}
 }
 
+// decodeTime turns WSJT-X's milliseconds-since-midnight into a UTC instant.
+//
+// The sender gives a time of DAY with no date, so the date comes from our own
+// clock — and the two can straddle midnight: a decode stamped 23:59:58 that
+// reaches us at 00:00:01 would otherwise be dated a day late and sort to the top
+// of the list for the rest of the session. More than half a day apart is read as
+// the wrong side of midnight and moved.
+func decodeTime(msSinceMidnight uint32) time.Time {
+	return decodeTimeAt(msSinceMidnight, time.Now().UTC())
+}
+
+// decodeTimeAt is decodeTime with the clock passed in.
+//
+// Split out so the midnight rule can be tested at midnight instead of at
+// whatever time the suite happens to run: the test used to read the real clock
+// and failed every afternoon, because a 23:59:58 stamp seen at 17:00 is hours in
+// the future and no rule can make it otherwise. A test that fails for half the
+// day teaches everyone to ignore the suite.
+func decodeTimeAt(msSinceMidnight uint32, now time.Time) time.Time {
+	now = now.UTC()
+	midnight := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, time.UTC)
+	at := midnight.Add(time.Duration(msSinceMidnight) * time.Millisecond)
+	switch {
+	case at.Sub(now) > 12*time.Hour:
+		at = at.AddDate(0, 0, -1) // stamped late yesterday, arrived after midnight
+	case now.Sub(at) > 12*time.Hour:
+		at = at.AddDate(0, 0, 1) // stamped just after midnight, our clock still on the old day
+	}
+	return at
+}
+
 // Event is what a Server emits to its consumer for every parsed packet.
 // At most one of the fields is populated per event.
 type Event struct {
@@ -92,10 +123,55 @@ type Event struct {
 
 	// A WSJT-X Decode (heard station) to render on the panadapter.
 	DecodeCall   string // transmitting (DE) callsign
-	DecodeGrid   string // 4-char grid, CQ decodes only
+	DecodeGrid   string // 4-char grid: from a CQ, or a reply answering with its locator
 	DecodeFreqHz int64  // RF frequency (dial + audio offset)
 	DecodeSNR    int    // reported SNR (dB)
 	DecodeCQ     bool   // the decode was a CQ
+	DecodeMsg    string // the decoded line as printed ("CQ K1ABC FN42")
+	// DecodeAt is the decode's own UTC timestamp, rebuilt from the sender's
+	// milliseconds-since-midnight. It is what groups decodes into T/R periods:
+	// a period's worth arrives in one burst, so arrival time would put them all
+	// in whichever slot the burst happened to land in.
+	DecodeAt time.Time
+	// DecodeTRPeriod is the transmit/receive period in seconds, from the last
+	// Status of the same program (15 = FT8). 0 when the sender never said.
+	DecodeTRPeriod int
+	DecodeDial     int64 // dial frequency the decode was heard on, for the band
+	DecodeOffAir   bool  // decoded from a file rather than off the air
+	// The three fields below are shown in the panel AND replayed verbatim when
+	// answering the station — WSJT-X matches a Reply against its own decode list,
+	// so every one has to go back exactly as it came.
+	DecodeDT      float64 // seconds into the slot the transmission started
+	DecodeAudioHz int64   // audio offset inside the passband
+	DecodeMs      uint32  // the decode's raw ms-since-midnight, as sent
+	DecodeLowConf bool
+	// DecodeModeRaw is the mode field EXACTLY as the Decode carried it — the
+	// one-character marker ("~", "+"), not the resolved name in Mode.
+	//
+	// Both are needed and they are not interchangeable. Mode is what the log and
+	// the status resolver want. This is what a Reply must echo: the receiving
+	// application matches a Reply against its own decode list field for field,
+	// and JTDX rejects one whose mode reads "FT8" where it decoded "~" — the
+	// click is accepted, nothing is transmitted, and nothing is reported.
+	DecodeModeRaw string
+	// DecodeMsgRaw is the message as sent, untrimmed — see DecodeModeRaw.
+	DecodeMsgRaw string
+	// ProgramID is the sending application's own id ("WSJT-X", "MSHV", or
+	// "WSJT-X - 2" for a second instance started with --rig-name). It is what
+	// tells two receivers apart on one multicast group — and it is the address a
+	// Reply message would have to be sent back to, so it is carried even though
+	// nothing replies yet.
+	ProgramID string
+
+	// TxMessage is what the operator's digital app is sending, with Transmitting
+	// true while the carrier is actually up. From Status, so ~1 Hz.
+	TxMessage    string
+	Transmitting bool
+	// TxEnabled is the sender's Enable Tx toggle — see WSJTEvent.TxEnabled. The
+	// watchdog clears it, which is the only reliable sign an exchange was
+	// abandoned rather than merely paused between overs.
+	TxEnabled bool
+	DECall    string // the operator's own call, as the digital app knows it
 
 	// ClearCall is set when a WSJT/JTDX/MSHV Status message reports an EMPTY DX
 	// Call after previously reporting one — i.e. the operator cleared the call in
@@ -112,7 +188,10 @@ type Event struct {
 
 // Server is a single inbound UDP listener.
 type Server struct {
-	cfg     Config
+	cfg Config
+	// mgr is the owning Manager, so a listener can reach the outbound rows.
+	// The relay is the only thing that needs it.
+	mgr     *Manager
 	conn    *net.UDPConn
 	out     chan<- Event
 	stop    chan struct{}
@@ -127,7 +206,16 @@ type Server struct {
 	// 50.400 panadapter. WSJT-X requires --rig-name for a second instance, so the
 	// 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
+	// trPeriod is the T/R period (seconds) from each program's last Status —
+	// what tells a decode which slot it belongs to.
+	trPeriod map[string]int
+	// lastFrom is the address each program's packets arrive from — where a Reply
+	// has to be sent. See SendReply.
+	lastFrom map[string]*net.UDPAddr
+	// lastMode is the mode NAME from each program's last Status, used to resolve
+	// a Decode's one-character mode marker.
+	lastMode map[string]string
+	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
@@ -171,10 +259,11 @@ func describePacket(pkt []byte) string {
 	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 {
+func newServer(cfg Config, out chan<- Event, mgr *Manager) *Server {
 	return &Server{
 		cfg:  cfg,
 		out:  out,
+		mgr:  mgr,
 		stop: make(chan struct{}),
 		done: make(chan struct{}),
 	}
@@ -340,6 +429,17 @@ func (s *Server) noteIgnoredADIF(pkt []byte) {
 }
 
 func (s *Server) handle(pkt []byte, remote *net.UDPAddr) {
+	// Relay FIRST, and unconditionally: before parsing, and whatever the parse
+	// then makes of it. A datagram this build cannot decode is still one the
+	// application downstream may understand, and a relay that forwards only what
+	// it understood drops exactly the fields it has yet to learn about.
+	//
+	// WSJT listeners only. The other inbound services are text protocols with no
+	// second consumer to speak of, and relaying an ADIF record twice would log
+	// the contact twice.
+	if s.cfg.ServiceType == ServiceWSJT && s.mgr != nil {
+		s.mgr.RelayInbound(pkt, s.cfg.Port)
+	}
 	ev := Event{ConfigID: s.cfg.ID, Service: s.cfg.ServiceType, Source: remote.String()}
 	switch s.cfg.ServiceType {
 	case ServiceWSJT:
@@ -351,6 +451,18 @@ func (s *Server) handle(pkt []byte, remote *net.UDPAddr) {
 		if !ok {
 			return
 		}
+		// Where this application's packets come from, so a Reply can be sent back
+		// to it. Per PROGRAM, not per listener: two receivers share one multicast
+		// group, and a reply must reach the one that heard the station — and it
+		// must go to the sender's own address, never to the group.
+		if w.ProgramID != "" && remote != nil {
+			s.mu.Lock()
+			if s.lastFrom == nil {
+				s.lastFrom = map[string]*net.UDPAddr{}
+			}
+			s.lastFrom[w.ProgramID] = remote
+			s.mu.Unlock()
+		}
 		// Status carries the current dial frequency; remember it so Decode audio
 		// offsets can be turned into RF frequencies for the panadapter.
 		if w.FreqHz > 0 && !w.IsDecode {
@@ -359,11 +471,40 @@ func (s *Server) handle(pkt []byte, remote *net.UDPAddr) {
 				s.dialHz = map[string]int64{}
 			}
 			s.dialHz[w.ProgramID] = w.FreqHz
+			// The T/R period travels with Status, and a decode has to be told
+			// which slot it belongs to — so it is remembered per program the
+			// same way the dial is.
+			if w.TRPeriod > 0 {
+				if s.trPeriod == nil {
+					s.trPeriod = map[string]int{}
+				}
+				s.trPeriod[w.ProgramID] = w.TRPeriod
+			}
+			// The mode NAME, which only Status carries: a Decode gives the
+			// one-character marker instead. See DecodeModeName.
+			if w.Mode != "" {
+				if s.lastMode == nil {
+					s.lastMode = map[string]string{}
+				}
+				s.lastMode[w.ProgramID] = w.Mode
+			}
 			s.mu.Unlock()
 		}
+		if !w.IsDecode && (w.TxMessage != "" || w.DECall != "") {
+			// What the operator is sending, and to whom. Carried on every Status,
+			// so the consumer sees it change as the QSO progresses. The program id
+			// travels with it because a second receiver has a transmit state of
+			// its own.
+			ev.TxMessage = w.TxMessage
+			ev.Transmitting = w.Transmitting
+			ev.DECall = w.DECall
+			ev.ProgramID = w.ProgramID
+		}
 		if w.IsDecode {
 			s.mu.Lock()
 			dial := s.dialHz[w.ProgramID]
+			tr := s.trPeriod[w.ProgramID]
+			statusMode := s.lastMode[w.ProgramID]
 			s.mu.Unlock()
 			if dial <= 0 {
 				// No Status from THIS instance yet. Guessing with another
@@ -376,7 +517,19 @@ func (s *Server) handle(pkt []byte, remote *net.UDPAddr) {
 			ev.DecodeFreqHz = dial + w.DeltaFreqHz
 			ev.DecodeSNR = w.SNR
 			ev.DecodeCQ = w.IsCQ
-			ev.Mode = w.Mode
+			ev.Mode = DecodeModeName(w.Mode, statusMode)
+			ev.DecodeModeRaw = w.Mode
+			ev.DecodeMsg = w.DecodeMsg
+			ev.DecodeMsgRaw = w.DecodeMsgRaw
+			ev.DecodeAt = decodeTime(w.DecodeMsSinceMidnight)
+			ev.DecodeTRPeriod = tr
+			ev.DecodeDial = dial
+			ev.DecodeOffAir = w.OffAir
+			ev.ProgramID = w.ProgramID
+			ev.DecodeDT = w.DeltaTime
+			ev.DecodeAudioHz = w.DeltaFreqHz
+			ev.DecodeMs = w.DecodeMsSinceMidnight
+			ev.DecodeLowConf = w.LowConfidence
 			break
 		}
 		// Only a logged QSO is worth a line — WSJT-X/MSHV send a Status packet
@@ -501,7 +654,10 @@ func (s *Server) handle(pkt []byte, remote *net.UDPAddr) {
 	// Empty events are useless; skip — EXCEPT a clear signal, which is meant to be
 	// empty (the DX Call was cleared in the digital app), and a tune-only
 	// request (freq with no callsign).
-	if ev.DXCall == "" && ev.LoggedADIF == "" && ev.DecodeCall == "" && !ev.ClearCall && ev.TuneFreqHz == 0 {
+	// TxMessage rides on Status, which also carries the DX call — but a Status
+	// with an empty DX call and a live transmit message (calling CQ) used to be
+	// dropped here, and that is exactly the message the decodes panel needs.
+	if ev.DXCall == "" && ev.LoggedADIF == "" && ev.DecodeCall == "" && ev.TxMessage == "" && !ev.ClearCall && ev.TuneFreqHz == 0 {
 		return
 	}
 	select {
@@ -564,6 +720,13 @@ type Manager struct {
 	httpFailMu sync.Mutex
 	httpFailAt map[int64]time.Time
 
+	// relayWarned keeps a relay row's complaint (a loop target, a dead
+	// destination) to one line a session. Keyed by row id for the loop warning
+	// and by -id-1 for the send failure, so one row can say each once.
+	// Without this a busy band writes hundreds of identical lines a minute.
+	relayWarnMu sync.Mutex
+	relayWarned map[int64]bool
+
 	mu       sync.Mutex
 	inbound  map[int64]*Server
 	outbound []Config
@@ -616,7 +779,7 @@ func (m *Manager) Reload(ctx context.Context) []string {
 			m.mu.Unlock()
 			continue
 		}
-		srv := newServer(c, m.out)
+		srv := newServer(c, m.out, m)
 		if err := srv.start(); err != nil {
 			applog.Printf("udp: start %q failed: %v", c.Name, err)
 			errs = append(errs, fmt.Sprintf("%s: %v", c.Name, err))

internal/integrations/udp/wsjt.go

@@ -51,10 +51,54 @@ type WSJTEvent struct {
 	// known dial frequency (from Status) to DeltaFreqHz to get the RF frequency.
 	IsDecode    bool
 	DecodeCall  string // the sender (DE) callsign extracted from the message text
-	DecodeGrid  string // 4-char grid, CQ decodes only — the exchange carries none
+	DecodeGrid  string // 4-char grid: from a CQ, or a reply that answers with its locator
 	DeltaFreqHz int64  // audio offset within the passband (Hz)
 	SNR         int    // reported signal-to-noise (dB)
 	IsCQ        bool   // the decode was a CQ call
+	// DeltaTime is how far into the slot the transmission started, in seconds —
+	// WSJT-X's "DT" column. Read and discarded before; kept now because it is
+	// shown, and because a Reply has to replay the decode field for field.
+	DeltaTime float64
+	// DecodeMsg is the decoded text as WSJT-X printed it ("CQ K1ABC FN42",
+	// "F4BPO K1ABC -07"). Kept whole rather than only its parsed pieces: the
+	// exchange is what tells an operator where a station is in a QSO, and no set
+	// of extracted fields says "R-09" the way the line itself does.
+	DecodeMsg string
+	// DecodeMsgRaw is the message EXACTLY as the datagram carried it, trailing
+	// spaces and all. DecodeMsg above is trimmed for display; a Reply has to
+	// send this one, because the receiving application matches a Reply against
+	// its own decode list field for field and a stripped space is a mismatch it
+	// reports nowhere.
+	DecodeMsgRaw string
+	// DecodeMsSinceMidnight is the decode's own timestamp, in milliseconds since
+	// 00:00 UTC, as the sender reported it. It is what groups decodes into T/R
+	// PERIODS — arrival time cannot, since a whole period's decodes land in one
+	// burst and a slow link shifts the lot into the next slot.
+	DecodeMsSinceMidnight uint32
+	DecodeIsNew           bool // sender's "is_new": first time this line was decoded
+	LowConfidence         bool // sender is unsure of the decode
+	OffAir                bool // decoded from a file, not off the air
+
+	// ---- Status extras ----
+
+	// TxMessage is what the operator is sending right now ("CQ F4BPO JN18"),
+	// with Transmitting saying whether the carrier is actually up. Both come
+	// from Status, so they arrive about once a second.
+	TxMessage    string
+	Transmitting bool
+	// TxEnabled is the sender's "Enable Tx" toggle. It is what the WATCHDOG
+	// turns off: the application stops transmitting but leaves the DX call set,
+	// so a caller that reads only the DX call believes the QSO is still running
+	// and waits for ever. This is the difference between "between overs" and
+	// "given up".
+	TxEnabled bool
+	DECall    string // the operator's own callsign, as the digital app knows it
+	DEGrid    string // and their square
+	// TRPeriod is the transmit/receive period in seconds (15 for FT8, 7 or 8 for
+	// FT4 depending on the sender's rounding). The authority on how long a slot
+	// is — better than inferring it from the mode name, which says nothing about
+	// a custom period.
+	TRPeriod int
 }
 
 // maxFwdHeader bounds how far into a packet the WSJT-X magic may sit behind a
@@ -166,40 +210,81 @@ func ParseWSJT(pkt []byte) (WSJTEvent, bool, error) {
 			return WSJTEvent{}, false, err
 		}
 		ev.DXCall = strings.ToUpper(strings.TrimSpace(dxCall))
-		// Skip report, tx_mode (QUtf8), tx_enabled (bool), transmitting,
+		// report, tx_mode → skipped.
-		// decoding, rx_df (qint32), tx_df (qint32), de_call (QUtf8),
-		// de_grid (QUtf8) → then dx_grid.
 		for _, name := range []string{"report", "tx_mode"} {
 			if _, err := readQString(r); err != nil {
 				return ev, true, fmt.Errorf("read %s: %w", name, err)
 			}
 		}
-		// 3 booleans (each 1 byte)
+		// tx_enabled, transmitting, decoding (1 byte each). The middle one is
-		for i := 0; i < 3; i++ {
+		// worth keeping: it says the carrier is up, which is what turns TxMessage
-			var b uint8
+		// from "what I would send" into "what is going out".
-			if err := binary.Read(r, binary.BigEndian, &b); err != nil {
+		var txEnabled, transmitting, decoding uint8
+		for _, p := range []*uint8{&txEnabled, &transmitting, &decoding} {
+			if err := binary.Read(r, binary.BigEndian, p); err != nil {
 				return ev, true, err
 			}
 		}
-		// 2 int32
+		ev.Transmitting = transmitting != 0
+		ev.TxEnabled = txEnabled != 0
+		// rx_df, tx_df
 		var i32 int32
 		for i := 0; i < 2; i++ {
 			if err := binary.Read(r, binary.BigEndian, &i32); err != nil {
 				return ev, true, err
 			}
 		}
-		// de_call, de_grid, dx_grid
+		deCall, err := readQString(r)
-		if _, err := readQString(r); err != nil {
+		if err != nil {
 			return ev, true, err
 		}
-		if _, err := readQString(r); err != nil {
+		ev.DECall = strings.ToUpper(strings.TrimSpace(deCall))
+		deGrid, err := readQString(r)
+		if err != nil {
 			return ev, true, err
 		}
+		ev.DEGrid = strings.ToUpper(strings.TrimSpace(deGrid))
 		dxGrid, err := readQString(r)
 		if err != nil {
 			return ev, true, err
 		}
 		ev.DXGrid = strings.ToUpper(strings.TrimSpace(dxGrid))
+
+		// Everything past here was APPENDED to the schema over successive
+		// releases, and JTDX and MSHV each stop at their own point. A short
+		// packet is therefore normal, not an error: read as far as the sender
+		// went and keep what we got. That is why the tail below swallows its
+		// errors instead of reporting them — the fields already parsed are good.
+		var b uint8
+		if binary.Read(r, binary.BigEndian, &b) != nil { // tx_watchdog
+			return ev, true, nil
+		}
+		if _, err := readQString(r); err != nil { // sub_mode
+			return ev, true, nil
+		}
+		if binary.Read(r, binary.BigEndian, &b) != nil { // fast_mode
+			return ev, true, nil
+		}
+		if binary.Read(r, binary.BigEndian, &b) != nil { // special_operation_mode
+			return ev, true, nil
+		}
+		var u32 uint32
+		if binary.Read(r, binary.BigEndian, &u32) != nil { // frequency_tolerance
+			return ev, true, nil
+		}
+		if binary.Read(r, binary.BigEndian, &u32) != nil { // tr_period (seconds)
+			return ev, true, nil
+		}
+		// 0xFFFFFFFF is WSJT-X's "not applicable" for the quint32 fields.
+		if u32 > 0 && u32 < 3600 {
+			ev.TRPeriod = int(u32)
+		}
+		if _, err := readQString(r); err != nil { // configuration_name
+			return ev, true, nil
+		}
+		if txMsg, err := readQString(r); err == nil {
+			ev.TxMessage = strings.TrimSpace(txMsg)
+		}
 		return ev, true, nil
 
 	case wsjtMsgDecode:
@@ -217,6 +302,7 @@ func ParseWSJT(pkt []byte) (WSJTEvent, bool, error) {
 		if err := binary.Read(r, binary.BigEndian, &b); err != nil { // is_new
 			return WSJTEvent{}, false, err
 		}
+		ev.DecodeIsNew = b != 0
 		var t32, df uint32
 		var snr int32
 		if err := binary.Read(r, binary.BigEndian, &t32); err != nil { // time
@@ -229,6 +315,7 @@ func ParseWSJT(pkt []byte) (WSJTEvent, bool, error) {
 		if err := binary.Read(r, binary.BigEndian, &dt); err != nil { // delta_time
 			return WSJTEvent{}, false, err
 		}
+		ev.DeltaTime = dt
 		if err := binary.Read(r, binary.BigEndian, &df); err != nil { // delta_frequency
 			return WSJTEvent{}, false, err
 		}
@@ -240,6 +327,11 @@ func ParseWSJT(pkt []byte) (WSJTEvent, bool, error) {
 		if err != nil {
 			return WSJTEvent{}, false, err
 		}
+		// low_confidence and off_air were appended later; absent on older senders.
+		var lowConf, offAir uint8
+		_ = binary.Read(r, binary.BigEndian, &lowConf)
+		_ = binary.Read(r, binary.BigEndian, &offAir)
+
 		call, isCQ, grid := wsjtSender(msg)
 		if call == "" {
 			return WSJTEvent{}, false, nil // free-text / telemetry / unparseable → ignore
@@ -251,6 +343,11 @@ func ParseWSJT(pkt []byte) (WSJTEvent, bool, error) {
 		ev.DeltaFreqHz = int64(df)
 		ev.SNR = int(snr)
 		ev.Mode = strings.ToUpper(strings.TrimSpace(mode))
+		ev.DecodeMsg = strings.TrimSpace(msg)
+		ev.DecodeMsgRaw = msg
+		ev.DecodeMsSinceMidnight = t32
+		ev.LowConfidence = lowConf != 0
+		ev.OffAir = offAir != 0
 		return ev, true, nil
 
 	case wsjtMsgLoggedADIF:
@@ -303,7 +400,21 @@ func wsjtSender(message string) (call string, isCQ bool, grid string) {
 		return "", true, ""
 	}
 	// Standard exchange: the DE (sender) call is the second token.
+	//
+	// And the THIRD token is a grid whenever the station is answering with its
+	// locator — "C91RU IZ5EME JN52", the ordinary first reply to a CQ. This used
+	// to return no grid at all on the grounds that "the exchange carries none",
+	// which is simply not true: it is the commonest grid-bearing message on a
+	// busy band, and only a CQ being read meant a station whose CQ we missed had
+	// no known grid — so it could never be flagged as a new one. GridTracker
+	// reads both, which is why its wanted-grid count ran so far ahead of ours.
+	//
+	// isGridField is what keeps the reports and sign-offs out: -05, R-05, RRR,
+	// 73 and RR73 all fail it, on length, charset or by name.
 	if len(f) >= 2 && looksLikeCall(f[1]) {
+		if len(f) >= 3 && isGridField(f[2]) {
+			return f[1], false, f[2]
+		}
 		return f[1], false, ""
 	}
 	return "", false, ""
@@ -370,3 +481,50 @@ func readQString(r *bytes.Reader) (string, error) {
 	}
 	return string(buf), nil
 }
+
+// decodeModeChar maps the single character WSJT-X puts in a Decode's mode field
+// to the mode it stands for.
+//
+// A Decode does NOT carry the mode's name. It carries the one-character marker
+// that appears in the decode line and in ALL.TXT — "~" for FT8, "+" for FT4 —
+// and that character was being passed straight through as if it were a mode.
+// Everything downstream then compared "~" against the modes in the log, matched
+// nothing, and called every station on an already-worked band a new MODE.
+//
+// The table covers what is common; anything missing falls back to the mode from
+// the sender's last Status, which carries the real name — so an unlisted or
+// future marker degrades to correct rather than to nonsense.
+var decodeModeChar = map[string]string{
+	"~": "FT8",
+	"+": "FT4",
+	"#": "JT65",
+	"@": "JT9",
+	"&": "MSK144",
+	":": "Q65",
+	"`": "FST4",
+}
+
+// DecodeModeName resolves a Decode's mode field to a real mode name. statusMode
+// is the mode from the same program's last Status, used when the field is a
+// marker we do not know, or empty.
+func DecodeModeName(raw, statusMode string) string {
+	raw = strings.TrimSpace(raw)
+	if m, ok := decodeModeChar[raw]; ok {
+		return m
+	}
+	// A mode name is at least two alphanumeric characters ("FT8", "JS8", "Q65").
+	// Anything shorter, or carrying punctuation, is a marker rather than a name.
+	if len(raw) >= 2 {
+		named := true
+		for _, r := range raw {
+			if !(r >= 'A' && r <= 'Z') && !(r >= 'a' && r <= 'z') && !(r >= '0' && r <= '9') {
+				named = false
+				break
+			}
+		}
+		if named {
+			return strings.ToUpper(raw)
+		}
+	}
+	return strings.ToUpper(strings.TrimSpace(statusMode))
+}

internal/integrations/udp/wsjtfreetext.go

@@ -0,0 +1,78 @@
+package udp
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"strings"
+
+	"hamlog/internal/applog"
+)
+
+// WSJT-X Free Text (message type 9) — "put this in the free-text box, and send".
+//
+//	Free Text  type 9
+//	  id    utf8  the target application's own id
+//	  text  utf8  the message
+//	  send  bool  true = transmit it now, false = only fill the box
+//
+// What this is FOR, and what it is not:
+//
+// It is the one "transmit this now" primitive that behaves the same on WSJT-X,
+// WSJT-Z, JTDX, JTDX-Improved and MSHV, because it needs no decode to match
+// against — unlike Reply, which the receiving application will only action if it
+// can find the exact decode being answered.
+//
+// It is NOT a way to call a station. FT8 free text is 13 characters, so a
+// standard "<DX> <ME> <GRID>" does not fit, and more importantly the text goes
+// out AS free text without setting the DX Call — so the sequencer never takes
+// over, and no report, RR73 or logging prompt follows. Use it for a 73, a short
+// note or a CQ; use Reply to start a QSO.
+const wsjtMsgFreeText = 9
+
+// EncodeFreeText builds the datagram. send=false fills the box without keying.
+func EncodeFreeText(programID, text string, send bool) []byte {
+	var b bytes.Buffer
+	_ = binary.Write(&b, binary.BigEndian, uint32(wsjtMagic))
+	_ = binary.Write(&b, binary.BigEndian, uint32(2)) // schema 2 — what every current sender speaks
+	_ = binary.Write(&b, binary.BigEndian, uint32(wsjtMsgFreeText))
+	writeQString(&b, programID)
+	writeQString(&b, text)
+	var s uint8
+	if send {
+		s = 1
+	}
+	_ = binary.Write(&b, binary.BigEndian, s)
+	return b.Bytes()
+}
+
+// SendFreeText hands a free-text message to one decoding application.
+//
+// Routed by program id to the address that instance's packets arrive from, for
+// the same reason as SendReply and SendHaltTx: two receivers can share one
+// multicast group, and transmitting from the wrong one is worse than not
+// transmitting at all.
+func (m *Manager) SendFreeText(programID, text string, send bool) error {
+	if strings.TrimSpace(programID) == "" {
+		return fmt.Errorf("no application id — cannot tell which receiver to send with")
+	}
+	m.mu.Lock()
+	servers := make([]*Server, 0, len(m.inbound))
+	for _, s := range m.inbound {
+		servers = append(servers, s)
+	}
+	m.mu.Unlock()
+
+	for _, s := range servers {
+		conn, addr := s.replyTarget(programID)
+		if conn == nil || addr == nil {
+			continue
+		}
+		if _, err := conn.WriteToUDP(EncodeFreeText(programID, text, send), addr); err != nil {
+			return fmt.Errorf("send free text to %s at %s: %w", programID, addr, err)
+		}
+		applog.Printf("udp: free text sent to %s at %s — %q (send=%v)", programID, addr, text, send)
+		return nil
+	}
+	return fmt.Errorf("no packet has arrived from %q yet — nothing to send to", programID)
+}

internal/integrations/udp/wsjtfreetext_test.go

@@ -0,0 +1,45 @@
+package udp
+
+import (
+	"bytes"
+	"testing"
+)
+
+// The wire format, byte for byte. A malformed Free Text is discarded in silence
+// by the far end, exactly like a malformed Reply — so a wrong byte here shows up
+// as a button that does nothing.
+func TestEncodeFreeText(t *testing.T) {
+	got := EncodeFreeText("JTDX", "73 GL", true)
+	want := []byte{
+		0xad, 0xbc, 0xcb, 0xda, // magic
+		0x00, 0x00, 0x00, 0x02, // schema 2
+		0x00, 0x00, 0x00, 0x09, // type 9 — Free Text
+		0x00, 0x00, 0x00, 0x04, 'J', 'T', 'D', 'X',
+		0x00, 0x00, 0x00, 0x05, '7', '3', ' ', 'G', 'L',
+		0x01, // send now
+	}
+	if !bytes.Equal(got, want) {
+		t.Errorf("EncodeFreeText\n got %#v\nwant %#v", got, want)
+	}
+}
+
+// send=false fills the box without keying — the difference is one byte, and
+// getting it backwards would transmit when the operator only meant to prepare.
+func TestEncodeFreeTextWithoutSending(t *testing.T) {
+	got := EncodeFreeText("MSHV", "", false)
+	if got[len(got)-1] != 0x00 {
+		t.Errorf("send flag = %#x, want 0 — this would transmit unasked", got[len(got)-1])
+	}
+	// An empty text is a zero-length QString, never the -1 that means null:
+	// WSJT-X drops a packet with a null where it expects text.
+	if !bytes.Equal(got[len(got)-5:len(got)-1], []byte{0, 0, 0, 0}) {
+		t.Errorf("empty text was not encoded as a zero-length string: % X", got)
+	}
+}
+
+func TestSendFreeTextRejectsEmptyID(t *testing.T) {
+	m := &Manager{}
+	if err := m.SendFreeText("  ", "73", true); err == nil {
+		t.Fatal("expected an error for a blank program id")
+	}
+}

internal/integrations/udp/wsjthalt.go

@@ -0,0 +1,73 @@
+package udp
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"strings"
+
+	"hamlog/internal/applog"
+)
+
+// WSJT-X Halt Tx (message type 8) — "stop transmitting".
+//
+// The same two things the Halt Tx button and the Enable Tx toggle do in the
+// application's own window:
+//
+//	Halt Tx  type 8
+//	  id            utf8  the target application's own id
+//	  auto_tx_only  bool  false = stop the transmission NOW
+//	                      true  = let this over finish, then stop auto-Tx
+//
+// Both are useful and they are not the same operation. Stopping mid-over is what
+// you want when you have called the wrong station or realised the frequency is
+// occupied; finishing the over first is what you want when the QSO is complete
+// and cutting the transmission would leave the other end waiting for a report
+// that never lands.
+const wsjtMsgHaltTx = 8
+
+// EncodeHaltTx builds the datagram. autoTxOnly false halts immediately.
+func EncodeHaltTx(programID string, autoTxOnly bool) []byte {
+	var b bytes.Buffer
+	_ = binary.Write(&b, binary.BigEndian, uint32(wsjtMagic))
+	_ = binary.Write(&b, binary.BigEndian, uint32(2)) // schema 2 — what every current sender speaks
+	_ = binary.Write(&b, binary.BigEndian, uint32(wsjtMsgHaltTx))
+	writeQString(&b, programID)
+	var auto uint8
+	if autoTxOnly {
+		auto = 1
+	}
+	_ = binary.Write(&b, binary.BigEndian, auto)
+	return b.Bytes()
+}
+
+// SendHaltTx tells one decoding application to stop transmitting.
+//
+// Routed by PROGRAM ID and answered back to the address that instance's packets
+// arrive from, exactly like SendReply: two receivers can share one multicast
+// group, and halting the 20 m instance because the 6 m one is transmitting would
+// be worse than doing nothing.
+func (m *Manager) SendHaltTx(programID string, autoTxOnly bool) error {
+	if strings.TrimSpace(programID) == "" {
+		return fmt.Errorf("no application id — cannot tell which receiver to halt")
+	}
+	m.mu.Lock()
+	servers := make([]*Server, 0, len(m.inbound))
+	for _, s := range m.inbound {
+		servers = append(servers, s)
+	}
+	m.mu.Unlock()
+
+	for _, s := range servers {
+		conn, addr := s.replyTarget(programID)
+		if conn == nil || addr == nil {
+			continue
+		}
+		if _, err := conn.WriteToUDP(EncodeHaltTx(programID, autoTxOnly), addr); err != nil {
+			return fmt.Errorf("send halt to %s at %s: %w", programID, addr, err)
+		}
+		applog.Printf("udp: halt tx sent to %s at %s (auto_tx_only=%v)", programID, addr, autoTxOnly)
+		return nil
+	}
+	return fmt.Errorf("no packet has arrived from %q yet — nothing to halt", programID)
+}

internal/integrations/udp/wsjthalt_test.go

@@ -0,0 +1,75 @@
+package udp
+
+import (
+	"bytes"
+	"testing"
+)
+
+// The Halt Tx datagram, byte for byte. A wrong byte here does not fail loudly —
+// WSJT-X drops a malformed packet in silence, and the operator sees a Halt
+// button that simply does nothing.
+func TestEncodeHaltTx(t *testing.T) {
+	tests := []struct {
+		name       string
+		id         string
+		autoTxOnly bool
+		want       []byte
+	}{
+		{
+			name: "halt now",
+			id:   "WSJT-X",
+			want: []byte{
+				0xad, 0xbc, 0xcb, 0xda, // magic
+				0x00, 0x00, 0x00, 0x02, // schema 2
+				0x00, 0x00, 0x00, 0x08, // type 8 — Halt Tx
+				0x00, 0x00, 0x00, 0x06, // id length
+				'W', 'S', 'J', 'T', '-', 'X',
+				0x00, // auto_tx_only = false → stop mid-over
+			},
+		},
+		{
+			name:       "finish the over first",
+			id:         "MSHV",
+			autoTxOnly: true,
+			want: []byte{
+				0xad, 0xbc, 0xcb, 0xda,
+				0x00, 0x00, 0x00, 0x02,
+				0x00, 0x00, 0x00, 0x08,
+				0x00, 0x00, 0x00, 0x04,
+				'M', 'S', 'H', 'V',
+				0x01,
+			},
+		},
+		{
+			// An empty id is length 0, never the -1 that means a null QString:
+			// a null where text is expected makes WSJT-X discard the packet.
+			name: "empty id is a zero-length string",
+			id:   "",
+			want: []byte{
+				0xad, 0xbc, 0xcb, 0xda,
+				0x00, 0x00, 0x00, 0x02,
+				0x00, 0x00, 0x00, 0x08,
+				0x00, 0x00, 0x00, 0x00,
+				0x00,
+			},
+		},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			got := EncodeHaltTx(tc.id, tc.autoTxOnly)
+			if !bytes.Equal(got, tc.want) {
+				t.Errorf("EncodeHaltTx(%q, %v)\n got %#v\nwant %#v", tc.id, tc.autoTxOnly, got, tc.want)
+			}
+		})
+	}
+}
+
+// SendHaltTx must refuse an empty id rather than broadcast a halt at whatever
+// application happens to answer: with two receivers sharing a multicast group,
+// halting the wrong one is worse than doing nothing.
+func TestSendHaltTxRejectsEmptyID(t *testing.T) {
+	m := &Manager{}
+	if err := m.SendHaltTx("   ", false); err == nil {
+		t.Fatal("expected an error for a blank program id")
+	}
+}

internal/integrations/udp/wsjtreply.go

@@ -0,0 +1,138 @@
+package udp
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"net"
+	"strings"
+
+	"hamlog/internal/applog"
+)
+
+// WSJT-X Reply (message type 4) — "answer this station".
+//
+// It is the same thing as double-clicking the line in WSJT-X's own Band
+// Activity window: the application looks the decode up in its list, sets its
+// transmit frequency to the caller's, fills the DX call and starts the exchange.
+// Which is why OpsLog cannot do this by tuning the radio — on FT8 the whole band
+// sits inside one passband, so moving the dial changes nothing about who gets
+// answered. The decision belongs to the decoding application, and this is the
+// only way to hand it over.
+//
+// The payload REPLAYS the decode being answered, and WSJT-X matches it against
+// what it decoded. Every field has to come back exactly as it went out — which
+// is why the parser now keeps the time, the delta time, the audio offset and the
+// message text rather than only what the panadapter needed.
+//
+//	Reply    type 4
+//	  id                utf8    the target application's own id
+//	  time              quint32 ms since midnight, from the decode
+//	  snr               qint32
+//	  delta_time        double  seconds
+//	  delta_frequency   quint32 audio offset in the passband, Hz
+//	  mode              utf8
+//	  message           utf8
+//	  low_confidence    bool
+//	  modifiers         quint8  keyboard modifiers (0 = a plain click)
+const wsjtMsgReply = 4
+
+// Reply is one "call this station" request, rebuilt from a decode.
+type Reply struct {
+	ProgramID     string // which application to talk to ("WSJT-X", "MSHV", "WSJT-X - 2")
+	MsSinceMidnig uint32
+	SNR           int32
+	DeltaTime     float64
+	DeltaFreqHz   uint32
+	Mode          string
+	Message       string
+	LowConfidence bool
+}
+
+// writeQString writes a Qt QString/QUtf8: a big-endian int32 length then the
+// bytes. An EMPTY string is length 0, not the -1 that means null — WSJT-X reads
+// a null where it expects text as a malformed packet and drops the whole reply.
+func writeQString(b *bytes.Buffer, s string) {
+	_ = binary.Write(b, binary.BigEndian, int32(len(s)))
+	b.WriteString(s)
+}
+
+// EncodeReply builds the datagram.
+func EncodeReply(r Reply) []byte {
+	var b bytes.Buffer
+	_ = binary.Write(&b, binary.BigEndian, uint32(wsjtMagic))
+	_ = binary.Write(&b, binary.BigEndian, uint32(2)) // schema 2 — the one every current sender speaks
+	_ = binary.Write(&b, binary.BigEndian, uint32(wsjtMsgReply))
+	writeQString(&b, r.ProgramID)
+	_ = binary.Write(&b, binary.BigEndian, r.MsSinceMidnig)
+	_ = binary.Write(&b, binary.BigEndian, r.SNR)
+	_ = binary.Write(&b, binary.BigEndian, r.DeltaTime)
+	_ = binary.Write(&b, binary.BigEndian, r.DeltaFreqHz)
+	writeQString(&b, r.Mode)
+	writeQString(&b, r.Message)
+	var low uint8
+	if r.LowConfidence {
+		low = 1
+	}
+	_ = binary.Write(&b, binary.BigEndian, low)
+	_ = binary.Write(&b, binary.BigEndian, uint8(0)) // modifiers: a plain click
+	return b.Bytes()
+}
+
+// SendReply hands a Reply to the application that produced the decode.
+//
+// Routed by PROGRAM ID, not by listener: two receivers can share one multicast
+// group, and answering a station heard on the 6 m instance by talking to the
+// 20 m one would start a call on the wrong band. The id is what tells them
+// apart, and the address the reply goes to is the one that instance's packets
+// actually arrive from — a multicast listener must answer back to the sender,
+// not to the group.
+func (m *Manager) SendReply(r Reply) error {
+	if strings.TrimSpace(r.ProgramID) == "" {
+		return fmt.Errorf("no application id — cannot tell which receiver to answer with")
+	}
+	m.mu.Lock()
+	servers := make([]*Server, 0, len(m.inbound))
+	for _, s := range m.inbound {
+		servers = append(servers, s)
+	}
+	m.mu.Unlock()
+
+	for _, s := range servers {
+		conn, addr := s.replyTarget(r.ProgramID)
+		if conn == nil || addr == nil {
+			continue
+		}
+		pkt := EncodeReply(r)
+		if _, err := conn.WriteToUDP(pkt, addr); err != nil {
+			return fmt.Errorf("send reply to %s at %s: %w", r.ProgramID, addr, err)
+		}
+		// Says whether the decode being answered was a CQ, because that is what
+		// decides whether the far end will act on it at all: the protocol only
+		// requires a Reply to be honoured for a CQ or QRZ. Without this the log
+		// showed a reply going out and nothing happening, and the reason had to
+		// be deduced from the message text by eye.
+		kind := "not a CQ — the far end may ignore it"
+		if strings.HasPrefix(strings.TrimSpace(strings.ToUpper(r.Message)), "CQ ") {
+			kind = "CQ"
+		}
+		applog.Printf("udp: reply sent to %s at %s — %q (%s)", r.ProgramID, addr, r.Message, kind)
+		return nil
+	}
+	return fmt.Errorf("no packet has arrived from %q yet — nothing to answer to", r.ProgramID)
+}
+
+// replyTarget returns this listener's socket and the address the given program
+// last sent from, or nils when it has never been heard here.
+func (s *Server) replyTarget(programID string) (*net.UDPConn, *net.UDPAddr) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if s.conn == nil || s.lastFrom == nil {
+		return nil, nil
+	}
+	addr, ok := s.lastFrom[programID]
+	if !ok {
+		return nil, nil
+	}
+	return s.conn, addr
+}

internal/lookup/cache_off_test.go

@@ -0,0 +1,74 @@
+package lookup
+
+import (
+	"context"
+	"testing"
+	"time"
+)
+
+// A TTL of zero means no cache: nothing is read from it, and nothing is written
+// to it either.
+//
+// It is a real thing to want. An operator correcting their own QRZ record — or
+// chasing a DXpedition whose page changes during the operation — otherwise
+// waits out thirty days before OpsLog will ask again. Clearing the cache by
+// hand works once; switching it off is the setting for a session where the
+// answers are moving.
+func TestATTLOfZeroSwitchesTheCacheOff(t *testing.T) {
+	c := testCache(t)
+	ctx := context.Background()
+
+	if err := c.Put(ctx, Result{Callsign: "M0ABC", Name: "Ann", Source: "qrz"}); err != nil {
+		t.Fatalf("put: %v", err)
+	}
+	if _, ok := c.Get(ctx, "M0ABC"); !ok {
+		t.Fatal("the cache did not hold a fresh entry while switched on")
+	}
+
+	c.SetTTL(0)
+	if c.Enabled() {
+		t.Error("Enabled() is true with a zero TTL")
+	}
+	if _, ok := c.Get(ctx, "M0ABC"); ok {
+		t.Error("a cached entry was still returned with the cache off — the provider would never be asked again")
+	}
+	// And nothing new is stored: those rows would only sit there going stale,
+	// waiting for the day the cache is switched back on.
+	if err := c.Put(ctx, Result{Callsign: "M0XYZ", Name: "Bob", Source: "qrz"}); err != nil {
+		t.Fatalf("put with the cache off: %v", err)
+	}
+	c.SetTTL(30 * 24 * time.Hour)
+	if _, ok := c.Get(ctx, "M0XYZ"); ok {
+		t.Error("a lookup made while the cache was off was written to it anyway")
+	}
+	// The entry from before it was switched off is still there — switching off
+	// is not the same as clearing, and the Clear cache button remains the way to
+	// throw the contents away.
+	if _, ok := c.Get(ctx, "M0ABC"); !ok {
+		t.Error("switching the cache off discarded what it already held")
+	}
+}
+
+// A negative lifetime is meaningless, and rounding it into either "off" or a
+// default would be a guess. It is ignored instead.
+func TestANegativeTTLIsIgnored(t *testing.T) {
+	c := testCache(t)
+	c.SetTTL(7 * 24 * time.Hour)
+	c.SetTTL(-1)
+	if !c.Enabled() {
+		t.Fatal("a negative TTL switched the cache off")
+	}
+	if c.ttl != 7*24*time.Hour {
+		t.Errorf("ttl = %v after a negative value, want the 7 days it already had", c.ttl)
+	}
+}
+
+// The constructor's zero is the DEFAULT, not "off": at startup the settings
+// have not been read, and beginning with no cache would hammer the provider for
+// the first seconds of every launch.
+func TestNewCacheWithZeroStillCaches(t *testing.T) {
+	c := testCache(t) // built with NewCache(conn, 0)
+	if !c.Enabled() {
+		t.Error("a cache built with a zero TTL started switched off")
+	}
+}

internal/lookup/lookup.go

@@ -195,10 +195,7 @@ func (m *Manager) Lookup(ctx context.Context, callsign string) (Result, error) {
 			// operator was looking the call up for, and it came back empty while
 			// the same lookup without the suffix answered perfectly.
 			if !saysNothingAboutLocation(call) {
-				r.Country, r.Continent = "", ""
+				clearHomeLocation(&r)
-				r.CQZ, r.ITUZ, r.DXCC = 0, 0, 0
-				r.Lat, r.Lon = 0, 0
-				r.Grid, r.State, r.County = "", "", ""
 			}
 			fillFromDXCC(&r, dxcc) // entity/zones/lat-lon from the FULL (slashed) call
 			normalizeNames(&r)
@@ -378,6 +375,17 @@ func titleCase(s string) string {
 // the DXCC number since QRZ's value is wrong and we don't have an entity
 // → DXCC# table yet.
 // Returns true if any field was filled.
+// clearHomeLocation drops the fields that say WHERE a callbook record's operator
+// lives, and keeps the ones that say WHO they are — name, address, QSL route.
+// A portable operator's cards still go to the home address, so that address is
+// not wrong; their county is.
+func clearHomeLocation(r *Result) {
+	r.Country, r.Continent = "", ""
+	r.CQZ, r.ITUZ, r.DXCC = 0, 0, 0
+	r.Lat, r.Lon = 0, 0
+	r.Grid, r.State, r.County = "", "", ""
+}
+
 func fillFromDXCC(r *Result, dxcc DXCCResolver) bool {
 	if dxcc == nil {
 		return false
@@ -387,6 +395,33 @@ func fillFromDXCC(r *Result, dxcc DXCCResolver) bool {
 		return false
 	}
 	filled := false
+
+	// A subdivision belongs to an ENTITY, so a record describing one entity has
+	// nothing to say about a station operating from another.
+	//
+	// TI8/W2RE came back as a Costa Rica contact in Dutchess County, New York, on
+	// square FN31 — W2RE's home details, from a QRZ page that carries the home
+	// mailing address as most portable pages do. CNTY is *defined* as a US
+	// county, so that is not a cosmetic slip: it is a US county award credit
+	// recorded against a Costa Rica QSO, and a distance and beam heading computed
+	// from a square 3,600 km from where the station actually is.
+	//
+	// The home-call fallback above already clears these, but it only runs when NO
+	// provider had the slashed form. An operator with a page for their portable
+	// call never reached it. Cleared here instead, where the operating entity is
+	// known — which also heals rows already in the cache, since every cache hit
+	// comes back through here.
+	//
+	// Same-entity portables (F4BPO/P, W2RE/2) are untouched: the entities match,
+	// and there the home details ARE where the operator is.
+	if dxccNum != 0 && strings.ContainsRune(r.Callsign, '/') && !saysNothingAboutLocation(r.Callsign) {
+		if home := homeCall(r.Callsign); home != "" && home != r.Callsign {
+			if homeNum, _, _, _, _, _, _, homeOK := dxcc.Resolve(home); homeOK && homeNum != 0 && homeNum != dxccNum {
+				clearHomeLocation(r)
+				filled = true
+			}
+		}
+	}
 	if country != "" {
 		r.Country = country
 		filled = true
@@ -432,11 +467,21 @@ func fillFromDXCC(r *Result, dxcc DXCCResolver) bool {
 // ----- Cache -----
 
 // Cache is a SQLite-backed cache of lookup results with a TTL.
+//
+// A ttl of zero means NO CACHE: every lookup goes to the provider. That is a
+// real thing to want — an operator correcting their own QRZ record, or chasing
+// a DXpedition whose page changes during the operation, otherwise waits out the
+// cache before OpsLog will look again.
 type Cache struct {
 	db  *sql.DB
 	ttl time.Duration
 }
 
+// NewCache builds the cache. A ttl of zero here is the CONSTRUCTOR default
+// (thirty days), not "off": at startup the settings have not been read yet, and
+// starting with no cache would hammer the provider for the first seconds of
+// every launch. Switching it off is a decision the operator makes, through
+// SetTTL, once their settings are known.
 func NewCache(db *sql.DB, ttl time.Duration) *Cache {
 	if ttl <= 0 {
 		ttl = 30 * 24 * time.Hour
@@ -444,15 +489,25 @@ func NewCache(db *sql.DB, ttl time.Duration) *Cache {
 	return &Cache{db: db, ttl: ttl}
 }
 
-// SetTTL updates the cache TTL (e.g. when user changes settings).
+// SetTTL updates the cache lifetime.
+//
+// ZERO switches the cache OFF — nothing is read from it and nothing is written
+// to it. A NEGATIVE value is meaningless and is ignored, rather than being
+// rounded into one of the two meanings above.
 func (c *Cache) SetTTL(ttl time.Duration) {
-	if ttl > 0 {
+	if ttl >= 0 {
 		c.ttl = ttl
 	}
 }
 
+// Enabled reports whether anything is being cached at all.
+func (c *Cache) Enabled() bool { return c != nil && c.ttl > 0 }
+
 // Get returns the cached result if present and not expired.
 func (c *Cache) Get(ctx context.Context, callsign string) (Result, bool) {
+	if !c.Enabled() {
+		return Result{}, false
+	}
 	row := c.db.QueryRowContext(ctx, `
         SELECT callsign, name, qth, address, state, cnty, country, grid,
                lat, lon, dxcc, cqz, ituz, cont, email, qsl_via, image_url,
@@ -519,6 +574,11 @@ func (c *Cache) Get(ctx context.Context, callsign string) (Result, bool) {
 // Put upserts a lookup result. fetched_at is generated in Go (NowISO) so the
 // INSERT is backend-agnostic; the conflict tail is dialect-specific.
 func (c *Cache) Put(ctx context.Context, r Result) error {
+	if !c.Enabled() {
+		// Nothing reads it, so writing would only grow the table — and leave
+		// stale rows waiting for the day the cache is switched back on.
+		return nil
+	}
 	updateCols := []string{
 		"name", "qth", "address", "state", "cnty",
 		"country", "grid", "lat", "lon",

internal/lookup/portable_location_test.go

@@ -0,0 +1,93 @@
+package lookup
+
+import "testing"
+
+// fakeDXCC resolves a handful of calls, enough to stand in for cty.dat.
+type fakeDXCC map[string]struct {
+	num       int
+	country   string
+	cont      string
+	cqz, ituz int
+	lat, lon  float64
+}
+
+func (f fakeDXCC) Resolve(call string) (int, string, string, int, int, float64, float64, bool) {
+	e, ok := f[call]
+	if !ok {
+		return 0, "", "", 0, 0, 0, 0, false
+	}
+	return e.num, e.country, e.cont, e.cqz, e.ituz, e.lat, e.lon, true
+}
+
+func testDXCC() fakeDXCC {
+	return fakeDXCC{
+		// Costa Rica, as cty.dat reads the OPERATING call.
+		"TI8/W2RE": {num: 308, country: "Costa Rica", cont: "NA", cqz: 7, ituz: 11, lat: 9.9, lon: -84.1},
+		// The home call: United States.
+		"W2RE": {num: 291, country: "United States", cont: "NA", cqz: 5, ituz: 8, lat: 39.8, lon: -98.5},
+		// A same-entity portable: still France either way.
+		"F4BPO/P": {num: 227, country: "France", cont: "EU", cqz: 14, ituz: 27, lat: 46.2, lon: 2.2},
+		"F4BPO":   {num: 227, country: "France", cont: "EU", cqz: 14, ituz: 27, lat: 46.2, lon: 2.2},
+	}
+}
+
+// A callbook record for a portable call routinely carries the operator's HOME
+// address — most QRZ pages for a portable call do — and a subdivision belongs to
+// an entity. Carrying the home county across an entity change is not cosmetic:
+// CNTY is defined as a US county, so TI8/W2RE was coming out as a Costa Rica
+// contact credited to Dutchess County, New York, with the distance and beam
+// heading taken from a square 3,600 km from where the station actually was.
+func TestPortableInAnotherEntityDropsTheHomeSubdivision(t *testing.T) {
+	r := Result{
+		Callsign: "TI8/W2RE",
+		Name:     "Raymond", // who they are — kept
+		QTH:      "Poughquag",
+		Address:  "499 Pleasant Ridge Road", // cards still go there — kept
+		State:    "NY",
+		County:   "Dutchess",
+		Grid:     "FN31",
+		Lat:      41.6, Lon: -73.7,
+		DXCC: 291,
+	}
+	fillFromDXCC(&r, testDXCC())
+
+	if r.County != "" {
+		t.Errorf("county = %q, want empty — a US county on a Costa Rica QSO is a false award credit", r.County)
+	}
+	if r.State != "" {
+		t.Errorf("state = %q, want empty — a subdivision of the entity that is not being worked", r.State)
+	}
+	if r.Grid != "" {
+		t.Errorf("grid = %q, want empty — it is the home square, 3,600 km from the operation", r.Grid)
+	}
+	// The entity and its centroid take over, so distance and bearing mean
+	// something again.
+	if r.DXCC != 308 || r.Country != "Costa Rica" {
+		t.Errorf("entity = %d %q, want 308 Costa Rica", r.DXCC, r.Country)
+	}
+	if r.Lat != 9.9 || r.Lon != -84.1 {
+		t.Errorf("lat/lon = %v/%v, want the Costa Rica centroid — the home coordinates must not survive", r.Lat, r.Lon)
+	}
+	// Who they are, and where their cards go, is unchanged.
+	if r.Name != "Raymond" || r.Address != "499 Pleasant Ridge Road" {
+		t.Errorf("name/address were cleared (%q / %q) — a portable operator's post still reaches home", r.Name, r.Address)
+	}
+}
+
+// The other half of the rule: a portable WITHIN the same entity is at home as
+// far as the entity is concerned, and its details must survive untouched.
+func TestSameEntityPortableKeepsItsLocation(t *testing.T) {
+	r := Result{
+		Callsign: "F4BPO/P",
+		State:    "77", County: "Seine-et-Marne", Grid: "JN18cs",
+		Lat: 48.8, Lon: 2.4, DXCC: 227,
+	}
+	fillFromDXCC(&r, testDXCC())
+
+	if r.Grid != "JN18cs" || r.County != "Seine-et-Marne" || r.State != "77" {
+		t.Errorf("a same-entity portable lost its location: grid=%q county=%q state=%q", r.Grid, r.County, r.State)
+	}
+	if r.Lat != 48.8 || r.Lon != 2.4 {
+		t.Errorf("lat/lon = %v/%v — the precise home position was replaced by the entity centroid", r.Lat, r.Lon)
+	}
+}

internal/qso/modeclass_match_test.go

@@ -0,0 +1,84 @@
+package qso
+
+import (
+	"context"
+	"testing"
+	"time"
+)
+
+// LoTW never hands back the submode it was given: every digital contact comes
+// back as the mode GROUP, "DATA". Matched on the exact mode string that is
+// simply never equal, so an operator downloading their confirmations was told
+// their own QSOs were not in their log — reported for FT2 contacts confirmed as
+// DATA, and true of FT4 and FT8 alike.
+func TestClassKeyMatchesAConfirmationCarryingTheModeGroup(t *testing.T) {
+	r := openRepo(t)
+	ctx := context.Background()
+	when := time.Date(2026, 8, 16, 16, 29, 0, 0, time.UTC)
+	id, err := r.Add(ctx, QSO{Callsign: "F1NQP", QSODate: when, Band: "20m", Mode: "FT2"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	minute := when.Format("2006-01-02T15:04")
+
+	exact, err := r.DedupeKeyIDs(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, found := exact[DedupeKey("F1NQP", minute, "20m", "DATA")]; found {
+		t.Fatal("the exact index matched DATA against FT2 — the test proves nothing")
+	}
+
+	byClass, err := r.DedupeClassKeyIDs(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	got, found := byClass[DedupeClassKey("F1NQP", minute, "20m", "DATA")]
+	if !found || got != id {
+		t.Errorf("class match = (%d, %v), want (%d, true) — the confirmation would be reported as having no local QSO", got, found, id)
+	}
+}
+
+// Two digital contacts with the same station, same band, same minute is barely
+// physical — but if it happens, stamping the confirmation on whichever row the
+// map happened to keep is a silent error in an award credit. Ambiguity maps to
+// 0 so the caller reports it unmatched instead of guessing.
+func TestAnAmbiguousClassKeyIsRefusedRatherThanGuessed(t *testing.T) {
+	r := openRepo(t)
+	ctx := context.Background()
+	when := time.Date(2026, 8, 16, 16, 29, 0, 0, time.UTC)
+	for _, m := range []string{"FT8", "RTTY"} {
+		if _, err := r.Add(ctx, QSO{Callsign: "F1NQP", QSODate: when, Band: "20m", Mode: m}); err != nil {
+			t.Fatal(err)
+		}
+	}
+	byClass, err := r.DedupeClassKeyIDs(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got := byClass[DedupeClassKey("F1NQP", when.Format("2006-01-02T15:04"), "20m", "DATA")]; got != 0 {
+		t.Errorf("ambiguous class key resolved to %d — one of two QSOs was picked at random", got)
+	}
+}
+
+// Phone and CW keep their own classes: a CW confirmation must never land on an
+// SSB contact just because the rest of the key agrees.
+func TestClassMatchDoesNotCrossPhoneAndCW(t *testing.T) {
+	r := openRepo(t)
+	ctx := context.Background()
+	when := time.Date(2026, 8, 16, 16, 29, 0, 0, time.UTC)
+	if _, err := r.Add(ctx, QSO{Callsign: "F1NQP", QSODate: when, Band: "20m", Mode: "SSB"}); err != nil {
+		t.Fatal(err)
+	}
+	byClass, err := r.DedupeClassKeyIDs(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	minute := when.Format("2006-01-02T15:04")
+	if _, found := byClass[DedupeClassKey("F1NQP", minute, "20m", "CW")]; found {
+		t.Error("a CW confirmation matched an SSB contact")
+	}
+	if _, found := byClass[DedupeClassKey("F1NQP", minute, "20m", "USB")]; !found {
+		t.Error("USB did not match the SSB contact — the phone sidebands are one class")
+	}
+}

internal/qso/qso.go

@@ -1475,13 +1475,67 @@ func conditionSQL(c Condition) (string, []any, error) {
 	}
 }
 
+// quickCallsignLike turns the Recent-QSOs search box into a SQL LIKE pattern.
+//
+// The rule, which is the one an operator already has in their head from the
+// alert filters:
+//
+//	4S     → starts with 4S      (4S%)
+//	*4S    → ends with 4S        (%4S)
+//	*4S*   → contains 4S         (%4S%)
+//	4S?    → 4S and one more     (4S_)
+//
+// So a plain word is a PREFIX — the common case, and what makes typing a call
+// feel like a call sign lookup rather than a text search. The moment a wildcard
+// appears the pattern is taken literally end to end, which is the only way
+// "*4S" can mean "ends with" while "4S" means "starts with".
+//
+// This used to be an unconditional contains-match, so there was no way to ask
+// for a prefix at all: searching 4S returned every call with 4S buried in it.
+//
+// % and _ typed by the operator are escaped to literals — otherwise a search
+// for "_" would quietly match everything.
+func quickCallsignLike(pattern string) string {
+	p := strings.TrimSpace(pattern)
+	var b strings.Builder
+	esc := func(r rune) {
+		switch r {
+		case '%', '_', '!':
+			b.WriteByte('!')
+		}
+		b.WriteRune(r)
+	}
+	if !strings.ContainsAny(p, "*?") {
+		for _, r := range p {
+			esc(r)
+		}
+		b.WriteByte('%') // plain text = prefix
+		return b.String()
+	}
+	for _, r := range p {
+		switch r {
+		case '*':
+			b.WriteByte('%')
+		case '?':
+			b.WriteByte('_')
+		default:
+			esc(r)
+		}
+	}
+	return b.String()
+}
+
 // buildWhere assembles the predicate (everything after WHERE) + args.
 func buildWhere(f QueryFilter) (string, []any, error) {
 	pred := "1=1"
 	var args []any
 	if qc := strings.TrimSpace(f.QuickCallsign); qc != "" {
-		pred += " AND callsign LIKE ?"
+		// ESCAPE '!' rather than the usual backslash: the clause is a literal in
-		args = append(args, "%"+qc+"%")
+		// the SQL text, and '\\' is one character to MySQL but two to SQLite,
+		// which rejects it. '!' is one character to both and appears in no
+		// callsign.
+		pred += " AND callsign LIKE ? ESCAPE '!'"
+		args = append(args, quickCallsignLike(qc))
 	}
 	if len(f.Conditions) > 0 {
 		joiner := " AND "
@@ -1605,6 +1659,136 @@ func (r *Repo) IterateByIDs(ctx context.Context, ids []int64, fn func(QSO) error
 	return rows.Err()
 }
 
+// GridKey builds the lookup key for the worked-grid index.
+//
+// band is "" for a "mix bands" scope, which is why the index stores BOTH forms
+// for every contact: asking "worked anywhere" must not mean walking the map.
+func GridKey(grid, band, class string) string {
+	return grid + "|" + strings.ToLower(band) + "|" + class
+}
+
+// GridWorkedIndex maps every worked square to whether it is CONFIRMED, under
+// every band-and-mode scope the operator can choose between.
+//
+// One QSO lands in several buckets, because the scopes overlap: an FT8 contact
+// counts for "this exact mode", for "any FTx mode" and for "any digital mode",
+// and each of those under both its own band and the any-band form. classesOf is
+// supplied by the caller — the meaning of DIGI and FTx belongs upstairs with the
+// rest of the mode vocabulary, not here.
+//
+// The value is "confirmed", not merely "present", so the same index answers both
+// hunting modes: chase what has never been worked, or chase what is not yet
+// confirmed. Confirmed means LoTW, a card or eQSL — the three the award engine
+// counts, so a square cannot be confirmed here and unconfirmed there.
+func (r *Repo) GridWorkedIndex(ctx context.Context, classesOf func(mode string) []string) (map[string]bool, error) {
+	rows, err := r.db.QueryContext(ctx, `
+		SELECT COALESCE(grid,''), UPPER(COALESCE(mode,'')), LOWER(COALESCE(band,'')),
+		       COALESCE(lotw_rcvd,''), COALESCE(qsl_rcvd,''), COALESCE(eqsl_rcvd,'')
+		FROM qso
+		WHERE grid IS NOT NULL AND grid != ''`)
+	if err != nil {
+		return nil, fmt.Errorf("query worked grids: %w", err)
+	}
+	defer rows.Close()
+	out := make(map[string]bool, 8192)
+	for rows.Next() {
+		var grid, mode, band, lotw, card, eqsl string
+		if err := rows.Scan(&grid, &mode, &band, &lotw, &card, &eqsl); err != nil {
+			return nil, err
+		}
+		g := strings.ToUpper(strings.TrimSpace(grid))
+		if len(g) < 4 {
+			continue
+		}
+		g = g[:4]
+		confirmed := lotw == "Y" || card == "Y" || eqsl == "Y"
+		for _, cls := range classesOf(mode) {
+			if cls == "" {
+				continue
+			}
+			// || is never a downgrade: one confirmed contact confirms the square
+			// for that scope, whatever the others say.
+			for _, k := range []string{GridKey(g, band, cls), GridKey(g, "", cls)} {
+				out[k] = out[k] || confirmed
+			}
+		}
+	}
+	return out, rows.Err()
+}
+
+// GridSquare is one 4-character Maidenhead square in the log.
+type GridSquare struct {
+	Grid      string `json:"grid"`
+	Count     int    `json:"count"`
+	Confirmed bool   `json:"confirmed"`
+	// Band and Mode of the most recent contact in the square, for the tooltip.
+	// The square is the subject here, not the QSO, so one example is enough —
+	// listing every band a square was worked on turns a map into a table.
+	Band string `json:"band,omitempty"`
+	Mode string `json:"mode,omitempty"`
+}
+
+// GridSquares aggregates the log into 4-character squares, newest contact
+// deciding the example band/mode.
+//
+// modeOf filters and is supplied by the caller (it owns what "digital" means):
+// return false to drop a QSO. Aggregation to 4 characters happens HERE rather
+// than in SQL — the column holds 4, 6 and 8-character grids, and lower(substr)
+// in SQL would differ between SQLite and MySQL for no gain.
+func (r *Repo) GridSquares(ctx context.Context, keep func(mode string) bool) ([]GridSquare, error) {
+	rows, err := r.db.QueryContext(ctx, `
+		SELECT COALESCE(grid,''), UPPER(COALESCE(mode,'')), LOWER(COALESCE(band,'')),
+		       COALESCE(lotw_rcvd,''), COALESCE(qsl_rcvd,''), COALESCE(eqsl_rcvd,'')
+		FROM qso
+		WHERE grid IS NOT NULL AND grid != ''
+		ORDER BY qso_date ASC, id ASC`)
+	if err != nil {
+		return nil, fmt.Errorf("query grid squares: %w", err)
+	}
+	defer rows.Close()
+	out := map[string]*GridSquare{}
+	for rows.Next() {
+		var grid, mode, band, lotw, card, eqsl string
+		if err := rows.Scan(&grid, &mode, &band, &lotw, &card, &eqsl); err != nil {
+			return nil, err
+		}
+		if keep != nil && !keep(mode) {
+			continue
+		}
+		g := strings.ToUpper(strings.TrimSpace(grid))
+		if len(g) < 4 {
+			continue
+		}
+		g = g[:4]
+		// Guard the shape: a malformed grid would draw a rectangle somewhere
+		// arbitrary, and a map with one square in the sea is a map nobody trusts.
+		if g[0] < 'A' || g[0] > 'R' || g[1] < 'A' || g[1] > 'R' ||
+			g[2] < '0' || g[2] > '9' || g[3] < '0' || g[3] > '9' {
+			continue
+		}
+		sq := out[g]
+		if sq == nil {
+			sq = &GridSquare{Grid: g}
+			out[g] = sq
+		}
+		sq.Count++
+		// Ascending order, so the last write wins = the most recent contact.
+		sq.Band, sq.Mode = band, mode
+		if lotw == "Y" || card == "Y" || eqsl == "Y" {
+			sq.Confirmed = true
+		}
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	list := make([]GridSquare, 0, len(out))
+	for _, sq := range out {
+		list = append(list, *sq)
+	}
+	sort.Slice(list, func(i, j int) bool { return list[i].Grid < list[j].Grid })
+	return list, nil
+}
+
 // 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
@@ -2691,6 +2875,51 @@ func (r *Repo) DedupeKeyIDs(ctx context.Context) (map[string]int64, error) {
 	return out, rows.Err()
 }
 
+// DedupeClassKey is DedupeKey with the mode collapsed to its CLASS (Phone / CW /
+// Digital).
+//
+// For matching a downloaded confirmation whose mode is not the one you logged.
+// LoTW does not hand back the submode it was given: a contact uploaded as FT4,
+// FT8 or anything else digital comes back as the mode GROUP, "DATA". Matched on
+// the exact string that is simply never equal, and the operator is told their
+// own QSO is not in their log — which is how a confirmed contact goes unrecorded.
+func DedupeClassKey(callsign, qsoDateMinute, band, mode string) string {
+	return strings.ToUpper(callsign) + "|" + qsoDateMinute + "|" + strings.ToLower(band) + "|" + modeClass(mode)
+}
+
+// DedupeClassKeyIDs is DedupeKeyIDs at mode-CLASS granularity, for the second
+// pass when the exact key misses.
+//
+// A key shared by more than one QSO maps to 0 — AMBIGUOUS, not "pick one". Two
+// contacts with the same station, on the same band, in the same minute, in two
+// digital modes is barely physical; but if it ever happens, stamping the
+// confirmation on whichever row the map happened to keep would be a silent
+// error in someone's award credit. Better to report it unmatched.
+func (r *Repo) DedupeClassKeyIDs(ctx context.Context) (map[string]int64, error) {
+	rows, err := r.db.QueryContext(ctx, `
+		SELECT id, callsign, substr(qso_date, 1, 16), band, mode
+		FROM qso`)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	out := make(map[string]int64, 1024)
+	for rows.Next() {
+		var id int64
+		var call, when, band, mode string
+		if err := rows.Scan(&id, &call, &when, &band, &mode); err != nil {
+			return nil, err
+		}
+		k := DedupeClassKey(call, when, band, mode)
+		if prev, seen := out[k]; seen && prev != id {
+			out[k] = 0
+			continue
+		}
+		out[k] = id
+	}
+	return out, rows.Err()
+}
+
 // matchRef is one local QSO's time + id, for time-window confirmation matching.
 type matchRef struct {
 	when time.Time

internal/qso/quickcall_test.go

@@ -0,0 +1,28 @@
+package qso
+
+import "testing"
+
+// The search box is the one place an operator types a callsign fragment, and
+// the three shapes below are what they expect from every other logger. A plain
+// word is a PREFIX: it used to be an unconditional contains-match, so asking
+// for "calls starting with 4S" was impossible.
+func TestQuickCallsignLike(t *testing.T) {
+	for _, tc := range []struct{ in, want, why string }{
+		{"4S", "4S%", "plain text is a prefix"},
+		{"*4S", "%4S", "a leading star means ends-with"},
+		{"*4S*", "%4S%", "stars both ends mean contains"},
+		{"4S*", "4S%", "a trailing star is the same prefix, written out"},
+		{"4S?", "4S_", "? is exactly one character"},
+		{"*", "%", "a lone star matches everything"},
+		{"  4S  ", "4S%", "surrounding space is not part of the call"},
+		// Escaping: a LIKE metacharacter the operator typed is a literal.
+		{"A_B", "A!_B%", "_ typed by hand is a literal underscore"},
+		{"50%", "50!%%", "% typed by hand is a literal percent"},
+		{"A!B", "A!!B%", "the escape character escapes itself"},
+		{"*A_B*", "%A!_B%", "escaping still applies inside a wildcard pattern"},
+	} {
+		if got := quickCallsignLike(tc.in); got != tc.want {
+			t.Errorf("quickCallsignLike(%q) = %q, want %q — %s", tc.in, got, tc.want, tc.why)
+		}
+	}
+}

internal/relaydev/denkovi_other.go

@@ -20,8 +20,8 @@ func NewDenkovi(serial string, count int) Device {
 	return denkoviStub{count: count}
 }
 
-func (s denkoviStub) Count() int     { return s.count }
+func (s denkoviStub) Count() int { return s.count }
-func (denkoviStub) Close() error     { return nil }
+func (denkoviStub) Close() error { return nil }
 func (denkoviStub) Status(context.Context) ([]bool, error) {
 	return nil, fmt.Errorf("Denkovi USB relay board is only supported on Windows")
 }

internal/relaydev/httpgen.go

@@ -56,6 +56,9 @@ type httpGen struct {
 	user    string
 	pass    string
 	count   int
+	// insecure accepts a certificate nothing can verify — the self-signed one a
+	// relay board on the LAN presents. Per board, and the operator's choice.
+	insecure bool
 
 	mu    sync.Mutex
 	state []bool
@@ -64,7 +67,7 @@ type httpGen struct {
 // NewHTTPGeneric builds the driver. onURLs/offURLs are per relay (index 0 =
 // relay 1) and may be short or hold empty entries; onPat/offPat are the
 // fallback patterns; labels are the relay names {value} substitutes.
-func NewHTTPGeneric(onURLs, offURLs []string, onPat, offPat, user, pass string, count int, labels []string) Device {
+func NewHTTPGeneric(onURLs, offURLs []string, onPat, offPat, user, pass string, count int, labels []string, insecure bool) Device {
 	if count <= 0 {
 		count = len(onURLs)
 	}
@@ -74,7 +77,7 @@ func NewHTTPGeneric(onURLs, offURLs []string, onPat, offPat, user, pass string,
 	return &httpGen{
 		onURLs: onURLs, offURLs: offURLs,
 		onPat: onPat, offPat: offPat, labels: labels,
-		user: user, pass: pass, count: count,
+		user: user, pass: pass, count: count, insecure: insecure,
 		state: make([]bool, count),
 	}
 }
@@ -196,7 +199,7 @@ func (h *httpGen) Set(ctx context.Context, relay int, on bool) error {
 	}
 	u := h.urlFor(relay, on)
 	u = withScheme(u)
-	if _, err := get(ctx, u, h.user, h.pass); err != nil {
+	if _, err := get(ctx, u, h.user, h.pass, h.insecure); err != nil {
 		return err
 	}
 	h.mu.Lock()

internal/relaydev/httpgen_test.go

@@ -22,7 +22,7 @@ func TestHTTPGenericPattern(t *testing.T) {
 
 	d := NewHTTPGeneric(nil, nil,
 		srv.URL+"/relay?n={relay}&state=on",
-		srv.URL+"/relay?n={relay}&state=off", "", "", 4, nil)
+		srv.URL+"/relay?n={relay}&state=off", "", "", 4, nil, false)
 	if err := d.Set(context.Background(), 2, true); err != nil {
 		t.Fatalf("Set on: %v", err)
 	}
@@ -53,7 +53,7 @@ func TestHTTPGenericPerRelayURLsWinOverThePattern(t *testing.T) {
 	d := NewHTTPGeneric(
 		[]string{srv.URL + "/FF0101", "", srv.URL + "/weird/on"},
 		[]string{srv.URL + "/FF0100", "", ""},
-		srv.URL+"/pattern/on/{relay}", srv.URL+"/pattern/off/{relay}", "", "", 3, nil)
+		srv.URL+"/pattern/on/{relay}", srv.URL+"/pattern/off/{relay}", "", "", 3, nil, false)
 
 	_ = d.Set(context.Background(), 1, true)  // its own URL
 	_ = d.Set(context.Background(), 2, true)  // empty → falls back to the pattern
@@ -82,7 +82,7 @@ func TestHTTPGenericValueIsTheRelayLabel(t *testing.T) {
 		[]string{srv.URL + "/relay?on={value}"}, // per-relay URL
 		nil,
 		"", srv.URL+"/relay?off={value}", // and the pattern, for the other direction
-		"", "", 3, []string{"Ant1", "Beam 20m", ""})
+		"", "", 3, []string{"Ant1", "Beam 20m", ""}, false)
 	_ = d.Set(context.Background(), 1, true)
 	_ = d.Set(context.Background(), 2, false)
 	mu.Lock()
@@ -107,7 +107,7 @@ func TestHTTPGenericRelayOffset(t *testing.T) {
 	defer srv.Close()
 
 	d := NewHTTPGeneric(nil, nil,
-		srv.URL+"/set0/{relay-1}/1", srv.URL+"/set0/{relay-1}/0", "", "", 4, nil)
+		srv.URL+"/set0/{relay-1}/1", srv.URL+"/set0/{relay-1}/0", "", "", 4, nil, false)
 	_ = d.Set(context.Background(), 1, true)
 	_ = d.Set(context.Background(), 4, false)
 	mu.Lock()
@@ -123,7 +123,7 @@ func TestHTTPGenericRelayOffset(t *testing.T) {
 // movement. It must be refused, and the message must say the label is what is
 // missing.
 func TestHTTPGenericRefusesValueWithoutALabel(t *testing.T) {
-	d := NewHTTPGeneric(nil, nil, "http://x/relay?on={value}", "", "", "", 2, []string{"", ""})
+	d := NewHTTPGeneric(nil, nil, "http://x/relay?on={value}", "", "", "", 2, []string{"", ""}, false)
 	err := d.Set(context.Background(), 1, true)
 	if err == nil || !strings.Contains(err.Error(), "label") {
 		t.Errorf("err = %v, want it to name the missing label", err)
@@ -149,7 +149,7 @@ func TestHTTPGenericSuppliesTheScheme(t *testing.T) {
 // A switch with the ON URLs filled and OFF left empty latches. The error has to
 // name the direction, or the operator cannot tell which half is missing.
 func TestHTTPGenericNamesTheMissingDirection(t *testing.T) {
-	d := NewHTTPGeneric([]string{"http://x/on"}, nil, "", "", "", "", 1, nil)
+	d := NewHTTPGeneric([]string{"http://x/on"}, nil, "", "", "", "", 1, nil, false)
 	err := d.Set(context.Background(), 1, false)
 	if err == nil || !strings.Contains(err.Error(), "OFF") {
 		t.Errorf("err = %v, want it to name the OFF direction", err)
@@ -160,7 +160,7 @@ func TestHTTPGenericNamesTheMissingDirection(t *testing.T) {
 func TestHTTPGenericRemembersWhatItCommanded(t *testing.T) {
 	srv := httptest.NewServer(http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}))
 	defer srv.Close()
-	d := NewHTTPGeneric(nil, nil, srv.URL+"/on/{relay}", srv.URL+"/off/{relay}", "", "", 3, nil)
+	d := NewHTTPGeneric(nil, nil, srv.URL+"/on/{relay}", srv.URL+"/off/{relay}", "", "", 3, nil, false)
 	_ = d.Set(context.Background(), 2, true)
 	st, err := d.Status(context.Background())
 	if err != nil {

internal/relaydev/httpstls_test.go

@@ -0,0 +1,80 @@
+package relaydev
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"sync"
+	"testing"
+)
+
+// A relay board on the LAN signs its own certificate — there is no authority
+// anywhere that could have signed it. httptest.NewTLSServer presents exactly
+// that: a certificate from an unknown issuer, which is what the hardware does.
+func selfSignedRelay(t *testing.T) (*httptest.Server, func() []string) {
+	t.Helper()
+	var mu sync.Mutex
+	var got []string
+	srv := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		mu.Lock()
+		got = append(got, r.URL.Path)
+		mu.Unlock()
+		w.WriteHeader(http.StatusOK)
+	}))
+	t.Cleanup(srv.Close)
+	return srv, func() []string {
+		mu.Lock()
+		defer mu.Unlock()
+		return append([]string(nil), got...)
+	}
+}
+
+// With the box ticked, the board answers.
+func TestHTTPSRelayWithASelfSignedCertificate(t *testing.T) {
+	srv, seen := selfSignedRelay(t)
+	d := NewHTTPGeneric(nil, nil, srv.URL+"/on/{relay}", srv.URL+"/off/{relay}", "", "", 2, nil, true)
+	if err := d.Set(context.Background(), 1, true); err != nil {
+		t.Fatalf("Set over HTTPS: %v", err)
+	}
+	if paths := seen(); len(paths) != 1 || paths[0] != "/on/1" {
+		t.Errorf("the board was asked for %v, want /on/1", paths)
+	}
+}
+
+// Without it, the request is refused — and the refusal has to name the box.
+//
+// Go's own message, "x509: certificate signed by unknown authority", is
+// accurate and tells an operator nothing about what to do next. This is the
+// difference between a dead end and an instruction, and it is the whole reason
+// the default can safely stay OFF.
+func TestARefusedCertificateNamesTheSetting(t *testing.T) {
+	srv, seen := selfSignedRelay(t)
+	d := NewHTTPGeneric(nil, nil, srv.URL+"/on/{relay}", srv.URL+"/off/{relay}", "", "", 2, nil, false)
+	err := d.Set(context.Background(), 1, true)
+	if err == nil {
+		t.Fatal("an unverifiable certificate was accepted with the box unticked")
+	}
+	if !strings.Contains(err.Error(), "self-signed") {
+		t.Errorf("the refusal reads %q — it does not say which setting to change", err)
+	}
+	if len(seen()) != 0 {
+		t.Error("the request reached the board despite the certificate being refused")
+	}
+}
+
+// The box belongs to ONE board. An operator with a self-signed switch on the
+// LAN and a second board reached through a proper HTTPS proxy must keep real
+// verification on the second — that link crosses the internet, and it commands
+// an antenna.
+func TestAcceptingOneBoardsCertificateDoesNotAffectAnother(t *testing.T) {
+	srv, _ := selfSignedRelay(t)
+	lan := NewHTTPGeneric(nil, nil, srv.URL+"/on/{relay}", "", "", "", 1, nil, true)
+	if err := lan.Set(context.Background(), 1, true); err != nil {
+		t.Fatalf("the LAN board: %v", err)
+	}
+	strict := NewHTTPGeneric(nil, nil, srv.URL+"/on/{relay}", "", "", "", 1, nil, false)
+	if err := strict.Set(context.Background(), 1, true); err == nil {
+		t.Error("the second board accepted the certificate too — the setting is not per board")
+	}
+}

internal/relaydev/relaydev.go

@@ -17,7 +17,10 @@ package relaydev
 
 import (
 	"context"
+	"crypto/tls"
+	"crypto/x509"
 	"encoding/xml"
+	"errors"
 	"fmt"
 	"io"
 	"net/http"
@@ -28,8 +31,8 @@ import (
 
 // Device is one relay board.
 type Device interface {
-	Count() int                                       // number of user-controllable relays
+	Count() int                                        // number of user-controllable relays
-	Status(ctx context.Context) ([]bool, error)       // state of each relay (index 0 = relay 1)
+	Status(ctx context.Context) ([]bool, error)        // state of each relay (index 0 = relay 1)
 	Set(ctx context.Context, relay int, on bool) error // relay is 1-based
 	// Close releases any OS handle the driver holds (serial port, FTDI handle).
 	// Network boards hold nothing and no-op. MUST be called when a cached driver is
@@ -40,8 +43,47 @@ type Device interface {
 
 func httpClient() *http.Client { return &http.Client{Timeout: 5 * time.Second} }
 
+// insecureClient talks to a board presenting a certificate nothing can verify.
+//
+// Which is nearly every board that offers HTTPS at all: a relay box on the LAN
+// signs its own certificate, and there is no authority anywhere that could have
+// signed it. Refusing that means refusing HTTPS on the hardware, which is not a
+// security decision, only an outcome.
+//
+// So it is offered, per board, and OFF by default — because the other HTTPS
+// case is real and opposite: a board reached from outside through a proxy with
+// a genuine certificate, where verification is the only thing standing between
+// an antenna switch and the internet. One box, on the board that needs it.
+//
+// Built once. A Transport per request would open a fresh TLS connection every
+// time and never reuse one.
+var insecureClient = &http.Client{
+	Timeout: 5 * time.Second,
+	Transport: &http.Transport{
+		TLSClientConfig: &tls.Config{InsecureSkipVerify: true}, //nolint:gosec // the operator ticked the box for this board
+	},
+}
+
+// certError says which box to tick when TLS is what failed.
+//
+// Go's own message — "x509: certificate signed by unknown authority" — is
+// accurate and tells an operator nothing about what to do next. Naming the
+// setting turns a dead end into an instruction.
+func certError(err error) error {
+	var unknown x509.UnknownAuthorityError
+	var host x509.HostnameError
+	var verify *tls.CertificateVerificationError
+	if errors.As(err, &unknown) || errors.As(err, &host) || errors.As(err, &verify) {
+		return fmt.Errorf("%w — the board's HTTPS certificate cannot be verified; "+
+			"tick \"Accept a self-signed certificate\" for this board if it is on your own network", err)
+	}
+	return err
+}
+
 // get issues a GET with optional basic auth and returns the body on 2xx.
-func get(ctx context.Context, url, user, pass string) ([]byte, error) {
+//
+// insecure skips certificate verification, for a board that signs its own.
+func get(ctx context.Context, url, user, pass string, insecure bool) ([]byte, error) {
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
 	if err != nil {
 		return nil, err
@@ -49,9 +91,13 @@ func get(ctx context.Context, url, user, pass string) ([]byte, error) {
 	if user != "" || pass != "" {
 		req.SetBasicAuth(user, pass)
 	}
-	resp, err := httpClient().Do(req)
+	client := httpClient()
+	if insecure {
+		client = insecureClient
+	}
+	resp, err := client.Do(req)
 	if err != nil {
-		return nil, err
+		return nil, certError(err)
 	}
 	defer resp.Body.Close()
 	body, _ := io.ReadAll(resp.Body)
@@ -87,8 +133,8 @@ type webswitch struct {
 // NewWebswitch builds a WebSwitch 1216H client (5 relays).
 func NewWebswitch(host string) Device { return &webswitch{host: host, count: 5} }
 
-func (w *webswitch) Count() int    { return w.count }
+func (w *webswitch) Count() int   { return w.count }
-func (w *webswitch) Close() error  { return nil } // stateless HTTP, nothing to release
+func (w *webswitch) Close() error { return nil } // stateless HTTP, nothing to release
 
 func (w *webswitch) Set(ctx context.Context, relay int, on bool) error {
 	if relay < 1 || relay > w.count {
@@ -98,7 +144,7 @@ func (w *webswitch) Set(ctx context.Context, relay int, on bool) error {
 	if on {
 		action = "on"
 	}
-	_, err := get(ctx, fmt.Sprintf("%s/relaycontrol/%s/%d", relayBase(w.host), action, relay), "", "")
+	_, err := get(ctx, fmt.Sprintf("%s/relaycontrol/%s/%d", relayBase(w.host), action, relay), "", "", false)
 	return err
 }
 
@@ -109,7 +155,7 @@ func (w *webswitch) Status(ctx context.Context) ([]bool, error) {
 		sel.WriteString(strconv.Itoa(i))
 		sel.WriteByte('$')
 	}
-	body, err := get(ctx, fmt.Sprintf("%s/relaystate/get2/%s", relayBase(w.host), sel.String()), "", "")
+	body, err := get(ctx, fmt.Sprintf("%s/relaystate/get2/%s", relayBase(w.host), sel.String()), "", "", false)
 	if err != nil {
 		return nil, err
 	}
@@ -156,7 +202,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("%s/FF%02d%s", relayBase(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, false)
 	return err
 }
 
@@ -170,7 +216,7 @@ type kmStatus struct {
 }
 
 func (k *kmtronic) Status(ctx context.Context) ([]bool, error) {
-	body, err := get(ctx, fmt.Sprintf("%s/status.xml", relayBase(k.host)), k.user, k.pass)
+	body, err := get(ctx, fmt.Sprintf("%s/status.xml", relayBase(k.host)), k.user, k.pass, false)
 	if err != nil {
 		return nil, err
 	}

internal/tciserver/tciserver.go

@@ -0,0 +1,673 @@
+// Package tciserver shares OpsLog's CAT link with programs that speak TCI.
+//
+// It is the second half of internal/rigctld, and exists for the same reason:
+// Windows gives a COM port to ONE process, so the moment OpsLog talks to the
+// radio directly nothing else can. rigctld answers the programs that speak
+// Hamlib NET rigctl (WSJT-X, JTDX, MSHV, Log4OM); this answers the ones built
+// around Expert Electronics' TCI instead — and it answers them whatever radio
+// is actually connected, because it sits on the same backend-agnostic
+// interface. An operator with an Icom or a Yaesu can hand a TCI-only program a
+// working rig.
+//
+// ── The protocol ──────────────────────────────────────────────────────────
+// Text commands over a WebSocket, "name:arg,arg;", the same syntax in both
+// directions. On connection the server sends a block of initialisation
+// commands describing the device, ending with ready; and start;. Thereafter
+// either side may send a control command, and the server echoes every change
+// to all connected clients so they stay in step with each other.
+//
+//	vfo:0,0,14074000;      receiver 0, channel A (RX), Hz
+//	vfo:0,1,14080000;      channel B — the TX frequency when split is on
+//	modulation:0,usb;      mode
+//	trx:0,true;            PTT
+//	split_enable:0,true;   split
+//	vfo:0,0;               a READ: the reply is the three-argument form
+//
+// Written against the official TCI Protocol document (ExpertSDR3/TCI, 12
+// January 2024, MIT) — the initialisation set and the argument order of every
+// command below are from §4.1 and §4.2, not from guesswork about what a client
+// might accept.
+package tciserver
+
+import (
+	"fmt"
+	"net"
+	"net/http"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/gorilla/websocket"
+)
+
+// Rig is what the server needs from OpsLog's CAT manager. An interface, so this
+// package stays testable without a radio and without importing internal/cat —
+// which also keeps it building on every platform.
+type Rig interface {
+	Freq() int64          // TX frequency in Hz (ADIF sense), 0 if unknown
+	RxFreq() int64        // RX frequency in Hz; equals Freq when not split
+	Mode() string         // ADIF mode (SSB, CW, FT8…)
+	Split() (bool, int64) // split on?, and the TX frequency
+	SetFreq(hz int64) error
+	SetMode(mode string) error
+	SetPTT(on bool) error
+	SetSplit(on bool, txHz int64) error
+}
+
+// DefaultPort is TCI's own default, which is what a client offers first.
+const DefaultPort = 40001
+
+// pollInterval is how often the rig is compared with what the clients were last
+// told. TCI is an event protocol — a client is entitled to sit silent and be
+// told when something moves — so this is the rate at which a knob turned on the
+// radio reaches it.
+const pollInterval = 250 * time.Millisecond
+
+type Server struct {
+	port int
+	rig  Rig
+	log  func(string, ...any)
+
+	mu     sync.Mutex
+	ln     net.Listener
+	http   *http.Server
+	conns  map[*client]struct{}
+	closed bool
+
+	// pendingTxHz is a transmit frequency a client set on channel B while the rig
+	// was still simplex.
+	//
+	// It must be REMEMBERED, not discarded. A client working split sends two
+	// commands and is free to send them in either order; when the frequency comes
+	// first, throwing it away means the split is then armed on whatever the
+	// transmit VFO happened to hold — the receive frequency — and the operator
+	// transmits straight onto the DX while their software shows exactly what they
+	// asked for. rigctld learned this the same way, and pairs set_split_vfo with
+	// set_split_freq for the same reason.
+	pendingTxHz int64
+
+	// ptt mirrors the last PTT state a client commanded, so a repeat can be
+	// recognised. A client is free to restate PTT as often as it likes, and one
+	// does: through the rigctl server Nexus sent set_ptt 0 about sixteen times a
+	// second, and the Flex's own "xmit 1" landed between two of them and was
+	// overwritten inside a millisecond — a transmit request that simply did
+	// nothing. The same radio sits behind this server.
+	ptt      bool
+	pttKnown bool
+
+	// last is what the clients have been told, so only changes are sent. TCI
+	// clients redraw on every command they receive; re-sending an unchanged
+	// frequency four times a second makes a VFO readout flicker and, in some
+	// clients, fights the operator's own tuning.
+	last state
+}
+
+// state is the part of the rig the clients are kept in step with.
+type state struct {
+	rxHz  int64
+	txHz  int64
+	mode  string
+	split bool
+	valid bool
+}
+
+// clientLogCap bounds how many of one client's commands reach the log.
+const clientLogCap = 200
+
+// client is one connected program.
+type client struct {
+	conn *websocket.Conn
+	mu   sync.Mutex // one writer at a time: gorilla panics on concurrent writes
+	// logged counts what has been written to the log for this connection. Only
+	// the reader goroutine touches it, so it needs no lock of its own.
+	logged int
+}
+
+func (c *client) send(s string) error {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	if c.conn == nil {
+		return nil // a client with no socket: the tests exercise the protocol, not the transport
+	}
+	_ = c.conn.SetWriteDeadline(time.Now().Add(3 * time.Second))
+	return c.conn.WriteMessage(websocket.TextMessage, []byte(s))
+}
+
+func New(port int, rig Rig, logf func(string, ...any)) *Server {
+	if port <= 0 || port > 65535 {
+		port = DefaultPort
+	}
+	if logf == nil {
+		logf = func(string, ...any) {}
+	}
+	return &Server{port: port, rig: rig, log: logf, conns: map[*client]struct{}{}}
+}
+
+// Start binds the port and serves until Stop.
+func (s *Server) Start() error {
+	ln, err := net.Listen("tcp", fmt.Sprintf(":%d", s.port))
+	if err != nil {
+		return fmt.Errorf("tci server: port %d: %w", s.port, err)
+	}
+	up := websocket.Upgrader{
+		// Any origin: the clients are desktop programs on the same machine or
+		// LAN, and they send whatever Origin their toolkit happens to set. This
+		// is the same trust boundary as the rigctl server on 4532 — a plain TCP
+		// port with no authentication, which is what every logger expects.
+		CheckOrigin: func(*http.Request) bool { return true },
+	}
+	mux := http.NewServeMux()
+	// Any path: clients connect to ws://host:port/ but some append a name.
+	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		conn, err := up.Upgrade(w, r, nil)
+		if err != nil {
+			s.log("tci server: upgrade from %s failed: %v", r.RemoteAddr, err)
+			return
+		}
+		s.serve(&client{conn: conn}, r.RemoteAddr)
+	})
+	srv := &http.Server{Handler: mux}
+	s.mu.Lock()
+	s.ln, s.http, s.closed = ln, srv, false
+	s.mu.Unlock()
+	go func() { _ = srv.Serve(ln) }()
+	go s.pushLoop()
+	s.log("tci server: listening on :%d", s.port)
+	return nil
+}
+
+// Stop closes the listener and every client.
+// releasePTT drops a PTT this server asserted, and does it once.
+//
+// A client that dies mid-over — or a settings save that closes the server —
+// leaves the rig keyed with nobody left to un-key it, into an amplifier that has
+// no idea the transmission ended. rigctld has had this guard for a while (a K3
+// once sat in transmit for 29 s until the CAT link happened to be rebuilt); the
+// TCI server was written without it, so an operator who moved from Hamlib to TCI
+// silently lost the protection.
+//
+// pttKnown is cleared whatever happens: after an emergency unkey the radio's
+// state is a guess, and the next command must reach it rather than be dismissed
+// as a repeat.
+func (s *Server) releasePTT(why string) {
+	s.mu.Lock()
+	keyed := s.ptt
+	s.ptt, s.pttKnown = false, false
+	s.mu.Unlock()
+	if !keyed {
+		return
+	}
+	s.log("tci server: %s while the rig was keyed — dropping PTT", why)
+	if err := s.rig.SetPTT(false); err != nil {
+		s.log("tci server: emergency unkey FAILED: %v", err)
+		return
+	}
+	// Any client still attached is told, so a second logger's transmit indicator
+	// does not stay lit over a rig that is back in receive.
+	s.broadcast("trx:0,false;")
+}
+
+func (s *Server) Stop() {
+	// Before anything is torn down: the CAT backend is still up here, so an unkey
+	// still lands. Same ordering as rigctld.Stop for the same reason.
+	s.releasePTT("TCI server stopped")
+
+	s.mu.Lock()
+	if s.closed {
+		s.mu.Unlock()
+		return
+	}
+	s.closed = true
+	ln, srv := s.ln, s.http
+	conns := make([]*client, 0, len(s.conns))
+	for c := range s.conns {
+		conns = append(conns, c)
+	}
+	s.conns = map[*client]struct{}{}
+	s.last = state{}
+	s.mu.Unlock()
+	for _, c := range conns {
+		_ = c.conn.Close()
+	}
+	if srv != nil {
+		_ = srv.Close()
+	}
+	if ln != nil {
+		_ = ln.Close()
+	}
+	s.log("tci server: stopped")
+}
+
+// Clients reports how many programs are connected — the one thing an operator
+// wants to know when a client says it cannot find the rig.
+func (s *Server) Clients() int {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	return len(s.conns)
+}
+
+// serve runs one connection: the initialisation block, then commands until it
+// closes.
+func (s *Server) serve(c *client, remote string) {
+	s.mu.Lock()
+	if s.closed {
+		s.mu.Unlock()
+		_ = c.conn.Close()
+		return
+	}
+	s.conns[c] = struct{}{}
+	s.mu.Unlock()
+	s.log("tci server: %s connected", remote)
+
+	for _, line := range s.initBlock() {
+		if err := c.send(line); err != nil {
+			break
+		}
+	}
+	for {
+		_, data, err := c.conn.ReadMessage()
+		if err != nil {
+			break
+		}
+		// One frame may carry several ";"-terminated commands.
+		for _, cmd := range strings.Split(string(data), ";") {
+			if cmd = strings.TrimSpace(cmd); cmd == "" {
+				continue
+			}
+			// Every command the client sends, in the log.
+			//
+			// This is the only evidence there will ever be about a program on
+			// someone else's machine: "MSHV's PTT test does nothing" is
+			// unanswerable without knowing whether MSHV sent trx at all, and if
+			// so in what form. Cheap, because TCI is event-driven — a client
+			// speaks when the operator does something, not on a timer.
+			//
+			// Capped so a client that DOES poll cannot quietly fill the
+			// operator's log; the cap says so once and then stays quiet.
+			if c.logged < clientLogCap {
+				c.logged++
+				s.log("tci server: ← %s;", cmd)
+			} else if c.logged == clientLogCap {
+				c.logged++
+				s.log("tci server: (further commands from this client are not logged)")
+			}
+			s.handle(c, cmd)
+		}
+	}
+	s.mu.Lock()
+	delete(s.conns, c)
+	s.mu.Unlock()
+	_ = c.conn.Close()
+	s.log("tci server: %s disconnected", remote)
+	// A client that walks away mid-over must not leave the rig transmitting.
+	s.releasePTT("client " + remote + " left")
+}
+
+// initBlock is the initialisation set from §4.1 of the protocol document, in
+// the documented order, followed by the current state so a client that has just
+// connected shows the right frequency instead of waiting for the first change.
+//
+// A client will not proceed without these: they are how it learns the device
+// exists, what it can do, and that the server has finished setting up.
+func (s *Server) initBlock() []string {
+	rx, tx, mode, split := s.read()
+	return []string{
+		"protocol:ExpertSDR3,1.9;",
+		"device:OpsLog;",
+		"receive_only:false;",
+		"trx_count:1;",
+		"channel_count:2;",
+		// The whole HF/VHF/UHF span OpsLog itself works over. A client uses this
+		// to bound its own tuning; too narrow a range and it refuses to follow the
+		// rig onto 2 m.
+		"vfo_limits:10000,470000000;",
+		"if_limits:-48000,48000;",
+		"modulations_list:am,sam,dsb,lsb,usb,cw,nfm,digl,digu;",
+		"ready;",
+		"start;",
+		fmt.Sprintf("vfo:0,0,%d;", rx),
+		fmt.Sprintf("vfo:0,1,%d;", tx),
+		fmt.Sprintf("modulation:0,%s;", mode),
+		fmt.Sprintf("split_enable:0,%t;", split),
+		"trx:0,false;",
+		// TRANSMIT PERMISSION, and it is not optional in practice.
+		//
+		// The document files TX_ENABLE under unidirectional control rather than
+		// initialisation, but its own note says it is "sent to the client when
+		// connected". A client that models permission — and one written for
+		// ExpertSDR users has every reason to — starts out assuming it may NOT
+		// transmit, and without this it never even tries: PTT does nothing and
+		// the server never sees a trx command to refuse.
+		//
+		// Always true. OpsLog is not the thing that decides: the radio behind
+		// whichever backend is connected does, and its refusal comes back through
+		// SetPTT and into the log.
+		"tx_enable:0,true;",
+		fmt.Sprintf("tx_frequency:%d;", tx),
+	}
+}
+
+// read takes one consistent snapshot of the rig in TCI's terms: channel A is
+// where we LISTEN and channel B where we transmit, which is the opposite way
+// round from ADIF's RigState and the one mistake here that would make a client
+// transmit on the DX's frequency.
+func (s *Server) read() (rxHz, txHz int64, mode string, split bool) {
+	split, txHz = s.rig.Split()
+	rxHz = s.rig.RxFreq()
+	if !split {
+		txHz = s.rig.Freq()
+		if rxHz == 0 {
+			rxHz = txHz
+		}
+	}
+	if rxHz == 0 {
+		rxHz = s.rig.Freq()
+	}
+	if txHz == 0 {
+		txHz = rxHz
+	}
+	mode = adifToTCIMode(s.rig.Mode(), rxHz)
+	return rxHz, txHz, mode, split
+}
+
+// pushLoop tells the clients what has changed on the radio.
+func (s *Server) pushLoop() {
+	t := time.NewTicker(pollInterval)
+	defer t.Stop()
+	for range t.C {
+		s.mu.Lock()
+		done := s.closed
+		s.mu.Unlock()
+		if done {
+			return
+		}
+		s.publish()
+	}
+}
+
+// publish sends only what moved. Returns the lines sent, for the tests.
+func (s *Server) publish() []string {
+	rx, tx, mode, split := s.read()
+	cur := state{rxHz: rx, txHz: tx, mode: mode, split: split, valid: true}
+
+	s.mu.Lock()
+	prev := s.last
+	s.last = cur
+	s.mu.Unlock()
+
+	var lines []string
+	if !prev.valid || prev.rxHz != cur.rxHz {
+		lines = append(lines, fmt.Sprintf("vfo:0,0,%d;", cur.rxHz))
+	}
+	if !prev.valid || prev.txHz != cur.txHz {
+		lines = append(lines, fmt.Sprintf("vfo:0,1,%d;", cur.txHz))
+		// The transmit frequency has its own command, which is what a client
+		// showing "TX 14.080" reads. Channel B alone leaves that stale.
+		lines = append(lines, fmt.Sprintf("tx_frequency:%d;", cur.txHz))
+	}
+	if (!prev.valid || prev.mode != cur.mode) && cur.mode != "" {
+		lines = append(lines, fmt.Sprintf("modulation:0,%s;", cur.mode))
+	}
+	if !prev.valid || prev.split != cur.split {
+		lines = append(lines, fmt.Sprintf("split_enable:0,%t;", cur.split))
+	}
+	for _, l := range lines {
+		s.broadcast(l)
+	}
+	return lines
+}
+
+func (s *Server) broadcast(line string) {
+	s.mu.Lock()
+	conns := make([]*client, 0, len(s.conns))
+	for c := range s.conns {
+		conns = append(conns, c)
+	}
+	s.mu.Unlock()
+	for _, c := range conns {
+		_ = c.send(line)
+	}
+}
+
+// handle answers one command from a client. Returns what was sent back, which
+// is "" for a command that only acts on the radio.
+//
+// A command that SETS something is echoed to every client, not just answered to
+// the one that sent it: the protocol document is explicit that the server
+// synchronises all connected clients, and two loggers that disagree about the
+// frequency are worse than one that is merely slow.
+func (s *Server) handle(c *client, cmd string) string {
+	name, args := cmd, ""
+	if i := strings.IndexByte(cmd, ':'); i >= 0 {
+		name, args = cmd[:i], cmd[i+1:]
+	}
+	f := strings.Split(args, ",")
+	arg := func(i int) string {
+		if i < len(f) {
+			return strings.TrimSpace(f[i])
+		}
+		return ""
+	}
+	num := func(i int) int64 {
+		v, _ := strconv.ParseInt(arg(i), 10, 64)
+		return v
+	}
+	reply := func(line string) string {
+		_ = c.send(line)
+		return line
+	}
+	rx, tx, mode, split := s.read()
+
+	switch strings.ToLower(strings.TrimSpace(name)) {
+	case "vfo":
+		// Read form: two arguments. Set form: three.
+		if len(f) < 3 || arg(2) == "" {
+			if arg(1) == "1" {
+				return reply(fmt.Sprintf("vfo:0,1,%d;", tx))
+			}
+			return reply(fmt.Sprintf("vfo:0,0,%d;", rx))
+		}
+		hz := num(2)
+		if hz <= 0 {
+			return ""
+		}
+		if arg(1) == "1" {
+			// Channel B is the transmit frequency. Setting it while simplex must
+			// not move the rig's only VFO — the client asked to prepare a split
+			// transmit frequency, not to QSY — but it must not be thrown away
+			// either: it is where the split will be armed a moment from now.
+			s.mu.Lock()
+			s.pendingTxHz = hz
+			s.mu.Unlock()
+			if !split {
+				s.broadcast(fmt.Sprintf("vfo:0,1,%d;", hz))
+				return ""
+			}
+			if err := s.rig.SetSplit(true, hz); err != nil {
+				s.log("tci server: split TX %d Hz refused: %v", hz, err)
+				return ""
+			}
+		} else if err := s.rig.SetFreq(hz); err != nil {
+			s.log("tci server: tune to %d Hz refused: %v", hz, err)
+			return ""
+		}
+		s.broadcast(fmt.Sprintf("vfo:0,%s,%d;", orZero(arg(1)), hz))
+		return ""
+
+	case "modulation":
+		if len(f) < 2 || arg(1) == "" {
+			return reply(fmt.Sprintf("modulation:0,%s;", mode))
+		}
+		m := tciModeToADIF(arg(1))
+		if m == "" {
+			return ""
+		}
+		if err := s.rig.SetMode(m); err != nil {
+			s.log("tci server: mode %s refused: %v", m, err)
+			return ""
+		}
+		s.broadcast(fmt.Sprintf("modulation:0,%s;", strings.ToLower(arg(1))))
+		return ""
+
+	case "trx":
+		if len(f) < 2 || arg(1) == "" {
+			return reply("trx:0,false;")
+		}
+		on := strings.EqualFold(arg(1), "true")
+		// Only touch the radio on a CHANGE — restating a state is not a request
+		// to change it. The first command always goes through, since there is no
+		// knowing how the radio was left.
+		s.mu.Lock()
+		known, prev := s.pttKnown, s.ptt
+		s.mu.Unlock()
+		if known && prev == on {
+			s.broadcast(fmt.Sprintf("trx:0,%t;", on))
+			return ""
+		}
+		if err := s.rig.SetPTT(on); err != nil {
+			// The cache is stamped ONLY on success, and a failure clears "known"
+			// outright so the NEXT command — whatever it is — reaches the radio.
+			//
+			// It used to be written before the radio was commanded and left in
+			// place when the command failed. That is how a rig got stuck keyed for
+			// good: the un-key failed on a lost CI-V acknowledgement, the cache
+			// recorded "off" regardless, and from then on every trx:0,false was
+			// dismissed as a repeat of a state the radio had never reached. Not
+			// even reconnecting the client cleared it — this cache is per-server,
+			// not per-connection — so the transmitter stayed keyed into the
+			// amplifier until the operator switched the radio off. A cache must
+			// never claim something the radio refused.
+			s.mu.Lock()
+			s.pttKnown = false
+			s.mu.Unlock()
+			s.log("tci server: PTT %v refused: %v", on, err)
+			return ""
+		}
+		s.mu.Lock()
+		s.ptt, s.pttKnown = on, true
+		s.mu.Unlock()
+		s.log("tci server: PTT %s", map[bool]string{true: "ON", false: "off"}[on])
+		s.broadcast(fmt.Sprintf("trx:0,%t;", on))
+		return ""
+
+	case "split_enable":
+		if len(f) < 2 || arg(1) == "" {
+			return reply(fmt.Sprintf("split_enable:0,%t;", split))
+		}
+		on := strings.EqualFold(arg(1), "true")
+		// Already in the state asked for? Then it is done, and nothing goes to
+		// the radio. This is the lesson the rigctl server paid for: JTDX in "Fake
+		// It" uses no split but still says so to be sure, and a backend that
+		// cannot set split answered an error to a request that was already true.
+		// JTDX read that as rig control failing and abandoned the transmission a
+		// second into the frame. A refusal is only honest when something actually
+		// needed doing.
+		if on == split {
+			s.broadcast(fmt.Sprintf("split_enable:0,%t;", on))
+			return ""
+		}
+		// Arm on the frequency the client gave for channel B, which it is free to
+		// have sent before this command rather than after.
+		s.mu.Lock()
+		pending := s.pendingTxHz
+		s.mu.Unlock()
+		txHz := tx
+		if on && pending > 0 {
+			txHz = pending
+		}
+		if err := s.rig.SetSplit(on, txHz); err != nil {
+			// The refusal is the useful part: a backend that cannot split says
+			// so, and the client can tell the operator instead of transmitting
+			// on the wrong frequency believing all is well.
+			s.log("tci server: split %v refused: %v", on, err)
+			return ""
+		}
+		s.log("tci server: split %s, TX %d Hz", map[bool]string{true: "ON", false: "off"}[on], txHz)
+		s.broadcast(fmt.Sprintf("split_enable:0,%t;", on))
+		return ""
+
+	case "dds":
+		// The panorama's centre frequency. OpsLog has no panorama, so it answers
+		// with the receive frequency — which is where a client draws its own.
+		return reply(fmt.Sprintf("dds:0,%d;", rx))
+
+	case "if":
+		// Offset of the tuning filter inside the panorama: zero, since our "dds"
+		// is the receive frequency itself.
+		return reply("if:0,0,0;")
+
+	case "start", "stop", "ready":
+		return ""
+
+	default:
+		// Everything else — audio streams, CW macros, the E-Coder, the
+		// panorama's own settings — belongs to a radio, not to a CAT link.
+		// Silence rather than an error: a client sends these hopefully at
+		// connect, and a refusal it did not ask for reads as a fault.
+		return ""
+	}
+}
+
+func orZero(s string) string {
+	if s == "" {
+		return "0"
+	}
+	return s
+}
+
+// adifToTCIMode maps an ADIF mode to a TCI modulation.
+//
+// SSB carries no sideband, so it is resolved from the frequency the way every
+// operator does: below 10 MHz lower, above it upper. A client told "ssb" would
+// not recognise it — the modulation list is the vocabulary.
+func adifToTCIMode(mode string, hz int64) string {
+	switch strings.ToUpper(strings.TrimSpace(mode)) {
+	case "":
+		return ""
+	case "CW", "CWR":
+		return "cw"
+	case "USB":
+		return "usb"
+	case "LSB":
+		return "lsb"
+	case "SSB":
+		if hz > 0 && hz < 10_000_000 {
+			return "lsb"
+		}
+		return "usb"
+	case "AM":
+		return "am"
+	case "FM", "NFM":
+		return "nfm"
+	case "RTTY":
+		return "digl"
+	}
+	// Everything else is a data mode: FT8, FT4, JT65, PSK31, MSK144, VARA…
+	// TCI has one pair for the whole family, and the sideband follows the same
+	// rule the data modes themselves use — upper, but for the few HF corners
+	// where LSB is conventional the radio is already there.
+	return "digu"
+}
+
+// tciModeToADIF maps a TCI modulation back to an ADIF mode.
+func tciModeToADIF(m string) string {
+	switch strings.ToLower(strings.TrimSpace(m)) {
+	case "cw":
+		return "CW"
+	case "usb":
+		return "USB"
+	case "lsb":
+		return "LSB"
+	case "am", "sam":
+		return "AM"
+	case "nfm", "fm", "wfm":
+		return "FM"
+	case "digl", "digu", "dsb", "drm":
+		// The data family: the mode the operator is actually running (FT8, RTTY)
+		// is chosen in OpsLog, and a client switching to "digital" must not
+		// overwrite it with a guess. DATA is the honest ADIF answer.
+		return "DATA"
+	}
+	return ""
+}

internal/tciserver/tciserver_test.go

@@ -0,0 +1,386 @@
+package tciserver
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// fakeRig is a radio that remembers what it was told. Everything here is about
+// what OpsLog does with a client's command, so the rig only has to answer and
+// record.
+type fakeRig struct {
+	freq, rxFreq int64
+	mode         string
+	split        bool
+	txHz         int64
+	ptt          bool
+	splitErr     error
+	pttErr       error
+	calls        []string
+}
+
+func (r *fakeRig) Freq() int64          { return r.freq }
+func (r *fakeRig) RxFreq() int64        { return r.rxFreq }
+func (r *fakeRig) Mode() string         { return r.mode }
+func (r *fakeRig) Split() (bool, int64) { return r.split, r.txHz }
+func (r *fakeRig) SetFreq(hz int64) error {
+	r.calls = append(r.calls, fmt.Sprintf("freq=%d", hz))
+	r.freq, r.rxFreq = hz, hz
+	return nil
+}
+func (r *fakeRig) SetMode(m string) error {
+	r.calls = append(r.calls, "mode="+m)
+	r.mode = m
+	return nil
+}
+func (r *fakeRig) SetPTT(on bool) error {
+	// Refused BEFORE the state moves, like a radio that never got the frame.
+	if r.pttErr != nil {
+		return r.pttErr
+	}
+	r.calls = append(r.calls, fmt.Sprintf("ptt=%v", on))
+	r.ptt = on
+	return nil
+}
+func (r *fakeRig) SetSplit(on bool, txHz int64) error {
+	if r.splitErr != nil {
+		return r.splitErr
+	}
+	r.calls = append(r.calls, fmt.Sprintf("split=%v,%d", on, txHz))
+	r.split, r.txHz = on, txHz
+	return nil
+}
+
+// srv builds a server with no listener — handle() and publish() are the whole
+// protocol, and neither needs a socket.
+func srv(r *fakeRig) *Server { return New(0, r, nil) }
+
+// A client with no connection: send() would need one, so reads are checked
+// through the returned line instead. This is why handle returns what it sent.
+func ask(t *testing.T, s *Server, cmd string) string {
+	t.Helper()
+	return s.handle(&client{}, cmd)
+}
+
+// The initialisation block is what a client needs before it will believe there
+// is a radio at all. Its contents come from §4.1 of the protocol document, and
+// a client that does not see ready; simply waits for ever.
+func TestInitBlockCarriesTheDocumentedInitialisationSet(t *testing.T) {
+	s := srv(&fakeRig{freq: 14074000, rxFreq: 14074000, mode: "USB"})
+	block := strings.Join(s.initBlock(), "")
+	for _, want := range []string{
+		"protocol:ExpertSDR3,", "device:", "receive_only:false;", "trx_count:1;",
+		"channel_count:2;", "vfo_limits:", "if_limits:", "modulations_list:",
+		"ready;", "start;",
+		// Transmit permission. A client that models it starts out assuming it
+		// may NOT transmit, and without this never even tries — PTT does
+		// nothing and the server never sees a trx command at all.
+		"tx_enable:0,true;",
+	} {
+		if !strings.Contains(block, want) {
+			t.Errorf("the initialisation block is missing %q — a client would not proceed past connect", want)
+		}
+	}
+	// And the current state, so a client that connects mid-session shows the
+	// right frequency instead of waiting for the operator to touch something.
+	if !strings.Contains(block, "vfo:0,0,14074000;") {
+		t.Errorf("no current frequency in the block:\n%s", block)
+	}
+	if !strings.Contains(block, "modulation:0,usb;") {
+		t.Errorf("no current mode in the block:\n%s", block)
+	}
+}
+
+// Channel A is where we LISTEN, channel B where we transmit. Handing these to a
+// client the wrong way round is the one mistake here that puts a station on the
+// DX's own frequency, so it is pinned in both directions.
+func TestSplitPutsTheListeningFrequencyOnChannelA(t *testing.T) {
+	// OpsLog's RigState is ADIF: Freq is the TRANSMIT frequency, RxFreq where we
+	// listen. A DX transmitting on 14025 and listening up 2.
+	r := &fakeRig{freq: 14027000, rxFreq: 14025000, mode: "CW", split: true, txHz: 14027000}
+	s := srv(r)
+	block := strings.Join(s.initBlock(), "")
+	if !strings.Contains(block, "vfo:0,0,14025000;") {
+		t.Errorf("channel A is not the receive frequency:\n%s", block)
+	}
+	if !strings.Contains(block, "vfo:0,1,14027000;") {
+		t.Errorf("channel B is not the transmit frequency:\n%s", block)
+	}
+	if !strings.Contains(block, "split_enable:0,true;") {
+		t.Errorf("split was not announced:\n%s", block)
+	}
+}
+
+// Simplex: both channels report the one frequency, so a client reading either
+// gets the right answer.
+func TestSimplexReportsTheSameFrequencyOnBothChannels(t *testing.T) {
+	s := srv(&fakeRig{freq: 7100000, rxFreq: 7100000, mode: "SSB"})
+	if got := ask(t, s, "vfo:0,0"); got != "vfo:0,0,7100000;" {
+		t.Errorf("read of channel A = %q", got)
+	}
+	if got := ask(t, s, "vfo:0,1"); got != "vfo:0,1,7100000;" {
+		t.Errorf("read of channel B = %q", got)
+	}
+	// 7 MHz is below 10, so SSB is lower sideband — a client told "ssb" would
+	// not recognise it at all, the modulation list is the vocabulary.
+	if got := ask(t, s, "modulation:0"); got != "modulation:0,lsb;" {
+		t.Errorf("read of the mode = %q, want lsb below 10 MHz", got)
+	}
+}
+
+// The client tunes the radio.
+func TestAClientCanTuneAndSetModeAndKey(t *testing.T) {
+	r := &fakeRig{freq: 14074000, rxFreq: 14074000, mode: "USB"}
+	s := srv(r)
+	ask(t, s, "vfo:0,0,14200000")
+	ask(t, s, "modulation:0,cw")
+	ask(t, s, "trx:0,true")
+	ask(t, s, "trx:0,false")
+	want := []string{"freq=14200000", "mode=CW", "ptt=true", "ptt=false"}
+	if strings.Join(r.calls, " ") != strings.Join(want, " ") {
+		t.Errorf("the radio was told %v, want %v", r.calls, want)
+	}
+}
+
+// Channel B is the SPLIT transmit frequency. Writing it while the rig is
+// simplex must not move the only VFO there is: the client asked to prepare a
+// transmit frequency, not to QSY — and a logger that did this on every spot
+// click would drag the operator off the station they were listening to.
+func TestWritingChannelBWhileSimplexLeavesTheRigAlone(t *testing.T) {
+	r := &fakeRig{freq: 14074000, rxFreq: 14074000, mode: "USB"}
+	s := srv(r)
+	ask(t, s, "vfo:0,1,14080000")
+	if len(r.calls) != 0 {
+		t.Errorf("the radio was told %v — a split TX frequency moved a simplex rig", r.calls)
+	}
+	// With split armed it means what it says.
+	r.split, r.txHz = true, 14074000
+	ask(t, s, "vfo:0,1,14080000")
+	if len(r.calls) != 1 || r.calls[0] != "split=true,14080000" {
+		t.Errorf("with split on the radio was told %v, want the new transmit frequency", r.calls)
+	}
+}
+
+// A backend that cannot split says so, and the refusal must not be dressed up
+// as success: the client can then tell the operator to use Fake It, where
+// before it would transmit on the receive frequency believing all was well.
+func TestARefusedSplitIsNotAnnouncedAsDone(t *testing.T) {
+	r := &fakeRig{freq: 14025000, rxFreq: 14025000, mode: "CW", splitErr: fmt.Errorf("this backend cannot split")}
+	s := srv(r)
+	if got := ask(t, s, "split_enable:0,true"); got != "" {
+		t.Errorf("a refused split answered %q", got)
+	}
+	if r.split {
+		t.Error("the rig was recorded as split after the backend refused")
+	}
+}
+
+// Only what moved is sent. TCI clients redraw on every command they receive, so
+// re-sending an unchanged frequency four times a second makes a VFO readout
+// flicker and, in some clients, fights the operator's own tuning.
+func TestOnlyChangesAreSent(t *testing.T) {
+	r := &fakeRig{freq: 14074000, rxFreq: 14074000, mode: "USB"}
+	s := srv(r)
+
+	first := s.publish()
+	if len(first) == 0 {
+		t.Fatal("the first pass sent nothing — a client would never learn the state")
+	}
+	if got := s.publish(); len(got) != 0 {
+		t.Errorf("an unchanged radio produced %v", got)
+	}
+
+	r.freq, r.rxFreq = 14200000, 14200000
+	got := strings.Join(s.publish(), "")
+	// Both channels move together on a simplex rig, and the transmit frequency
+	// has its own command besides — a client showing "TX 14.200" reads that one,
+	// and channel B alone leaves it stale.
+	for _, want := range []string{"vfo:0,0,14200000;", "vfo:0,1,14200000;", "tx_frequency:14200000;"} {
+		if !strings.Contains(got, want) {
+			t.Errorf("after a QSY the clients were not told %q — got %q", want, got)
+		}
+	}
+	if got := s.publish(); len(got) != 0 {
+		t.Errorf("the QSY was re-sent: %v", got)
+	}
+}
+
+// Modes travel both ways, and the data family is the interesting half: a client
+// switching to "digital" must not overwrite the mode the operator chose in
+// OpsLog with a guess at which data mode it was.
+func TestModeMapping(t *testing.T) {
+	up := []struct {
+		adif string
+		hz   int64
+		want string
+	}{
+		{"CW", 14025000, "cw"},
+		{"SSB", 14200000, "usb"},
+		{"SSB", 7100000, "lsb"},
+		{"USB", 7100000, "usb"}, // an explicit sideband is never second-guessed
+		{"FT8", 14074000, "digu"},
+		{"RTTY", 14080000, "digl"},
+		{"AM", 3700000, "am"},
+		{"FM", 145500000, "nfm"},
+		{"", 14074000, ""},
+	}
+	for _, c := range up {
+		if got := adifToTCIMode(c.adif, c.hz); got != c.want {
+			t.Errorf("adifToTCIMode(%q, %d) = %q, want %q", c.adif, c.hz, got, c.want)
+		}
+	}
+	down := map[string]string{
+		"cw": "CW", "usb": "USB", "lsb": "LSB", "am": "AM", "sam": "AM",
+		"nfm": "FM", "digu": "DATA", "digl": "DATA", "": "",
+	}
+	for in, want := range down {
+		if got := tciModeToADIF(in); got != want {
+			t.Errorf("tciModeToADIF(%q) = %q, want %q", in, got, want)
+		}
+	}
+}
+
+// A command for something OpsLog is not — audio streams, CW macros, the
+// panorama's settings — is met with silence rather than an error. A client
+// sends these hopefully at connect, and a refusal it did not ask for reads as a
+// fault with the rig.
+func TestUnknownCommandsAreQuiet(t *testing.T) {
+	s := srv(&fakeRig{freq: 14074000, rxFreq: 14074000, mode: "USB"})
+	for _, cmd := range []string{"audio_start:0", "cw_macros_speed:25", "rx_filter_band:0,-2700,-100", "iq_start:0"} {
+		if got := ask(t, s, cmd); got != "" {
+			t.Errorf("%q answered %q", cmd, got)
+		}
+	}
+}
+
+// Split, with the client sending the two commands in the order it prefers.
+//
+// A client working split has to say two things: where to transmit, and that
+// split is on. Nothing obliges it to say them in that order, and the frequency
+// arriving first is the dangerous case: discarding it and then arming split
+// leaves the transmit VFO on whatever it held — the RECEIVE frequency — so the
+// operator transmits straight onto the DX while their software shows exactly
+// what they asked for.
+func TestSplitIsArmedOnTheFrequencyTheClientGaveWhicheverOrderItCame(t *testing.T) {
+	// Frequency first, then split — the order that used to lose the frequency.
+	r := &fakeRig{freq: 14025000, rxFreq: 14025000, mode: "CW"}
+	s := srv(r)
+	ask(t, s, "vfo:0,1,14027000")
+	ask(t, s, "split_enable:0,true")
+	if len(r.calls) != 1 || r.calls[0] != "split=true,14027000" {
+		t.Errorf("frequency first: the radio was told %v, want split armed on 14027000", r.calls)
+	}
+
+	// Split first, then the frequency — the order that always worked.
+	r2 := &fakeRig{freq: 14025000, rxFreq: 14025000, mode: "CW"}
+	s2 := srv(r2)
+	ask(t, s2, "split_enable:0,true")
+	ask(t, s2, "vfo:0,1,14027000")
+	if len(r2.calls) == 0 || r2.calls[len(r2.calls)-1] != "split=true,14027000" {
+		t.Errorf("split first: the radio was told %v, want it to end on 14027000", r2.calls)
+	}
+}
+
+// "Fake It" uses no split at all: the client shifts the DIAL at the start of
+// transmit and shifts it back at the end. All it needs is channel A, and it
+// must reach the radio both ways.
+func TestFakeItIsJustTheDialMoving(t *testing.T) {
+	r := &fakeRig{freq: 14074000, rxFreq: 14074000, mode: "USB"}
+	s := srv(r)
+	ask(t, s, "vfo:0,0,14075300") // up for the over
+	ask(t, s, "vfo:0,0,14074000") // and back
+	want := []string{"freq=14075300", "freq=14074000"}
+	if strings.Join(r.calls, " ") != strings.Join(want, " ") {
+		t.Errorf("the radio was told %v, want %v", r.calls, want)
+	}
+}
+
+// A client in Fake It still says "split off" to be sure. The rig is already
+// simplex, so there is nothing to do — and saying so beats asking a backend
+// that may not be able to set split at all.
+//
+// This is what broke JTDX through the rigctl server: an error answered to a
+// request that was already true, read as rig control failing, and the
+// transmission abandoned a second into the frame.
+func TestSayingSplitOffWhenAlreadySimplexTouchesNothing(t *testing.T) {
+	r := &fakeRig{freq: 14074000, rxFreq: 14074000, mode: "USB",
+		splitErr: fmt.Errorf("this backend cannot split")}
+	s := srv(r)
+	ask(t, s, "split_enable:0,false")
+	if len(r.calls) != 0 {
+		t.Errorf("the radio was told %v for a state it was already in", r.calls)
+	}
+}
+
+// A client restating PTT must not re-command the radio. Through the rigctl
+// server, one sent set_ptt 0 sixteen times a second and the Flex's own transmit
+// request was overwritten between two of them inside a millisecond.
+func TestRepeatedPTTIsNotResentToTheRadio(t *testing.T) {
+	r := &fakeRig{freq: 14074000, rxFreq: 14074000, mode: "USB"}
+	s := srv(r)
+	for i := 0; i < 5; i++ {
+		ask(t, s, "trx:0,false")
+	}
+	if len(r.calls) != 1 || r.calls[0] != "ptt=false" {
+		// The FIRST one always goes through: there is no knowing how the radio
+		// was left.
+		t.Errorf("the radio was told %v, want one unkey and no repeats", r.calls)
+	}
+	ask(t, s, "trx:0,true")
+	ask(t, s, "trx:0,true")
+	if len(r.calls) != 2 || r.calls[1] != "ptt=true" {
+		t.Errorf("the radio was told %v, want the change through and the repeat dropped", r.calls)
+	}
+}
+
+// A refused un-key must never be remembered as done.
+//
+// The failure an operator hit running JTDX over TCI with an Icom on CI-V: the
+// rig went to transmit, the un-key was refused on a lost acknowledgement, and
+// from then on NOTHING could take it out of transmit. The cache had stamped
+// "off" before the radio was even commanded and kept it after the refusal, so
+// every later trx:0,false was dismissed as a repeat of a state the radio had
+// never reached. It is per-server, not per-connection, so reconnecting the
+// client changed nothing either — the transmitter stayed keyed into the
+// amplifier, with no drive, until the radio was switched off by hand.
+func TestARefusedUnkeyIsNotRememberedAsDone(t *testing.T) {
+	r := &fakeRig{freq: 14074000, rxFreq: 14074000, mode: "USB"}
+	s := srv(r)
+	ask(t, s, "trx:0,true")
+	if !r.ptt {
+		t.Fatal("the rig was never keyed — the test would prove nothing")
+	}
+
+	r.pttErr = fmt.Errorf("icom: timeout waiting for response")
+	ask(t, s, "trx:0,false")
+	if !r.ptt {
+		t.Fatal("the fake rig un-keyed on a refusal — the test would prove nothing")
+	}
+
+	// The client asks again, and this time the radio answers. It MUST be told.
+	r.pttErr = nil
+	ask(t, s, "trx:0,false")
+	if r.ptt {
+		t.Error("still keyed: the refused un-key was cached as done and the retry was dropped as a repeat")
+	}
+}
+
+// A client that walks away mid-over must not leave the rig transmitting, and
+// the release must be once-only — a second call has nothing to un-key and must
+// not re-command a radio that is already receiving.
+func TestReleasePTTUnkeysOnceWhenTheClientLeaves(t *testing.T) {
+	r := &fakeRig{freq: 14074000, rxFreq: 14074000, mode: "USB"}
+	s := srv(r)
+	ask(t, s, "trx:0,true")
+
+	s.releasePTT("client left")
+	if r.ptt {
+		t.Error("the rig is still keyed after the client left")
+	}
+	n := len(r.calls)
+	s.releasePTT("client left")
+	if len(r.calls) != n {
+		t.Errorf("released twice — the radio was told %v", r.calls)
+	}
+}

offline.go

@@ -161,6 +161,11 @@ func (a *App) replayOfflineQueue() (int, error) {
 			failed = append(failed, q)
 			continue
 		}
+		// These are contacts the operator MADE — the worked indexes have to learn
+		// them, or every one of them keeps its NEW badge in the cluster and decode
+		// lists until the next restart. a.qso.Add is the raw insert; only AddQSO
+		// does this for you, and the outbox replay does not go through it.
+		a.noteWorked(q.Callsign, q.Band, q.Mode)
 		imported++
 	}
 

syncfolder.go

@@ -507,6 +507,10 @@ func (a *App) applySyncRecord(rec syncfolder.Record) bool {
 	if err := a.qso.SetSyncUID(a.ctx, newID, rec.UID); err != nil {
 		applog.Printf("foldersync: stamping the new QSO %d: %v", newID, err)
 	}
+	// A partner's contact counts as worked for this station too — that is the
+	// point of a multi-op log — so the worked indexes must learn it exactly as
+	// they do for our own. Raw insert, so nothing else does it.
+	a.noteWorked(q.Callsign, q.Band, q.Mode)
 	return true
 }
 

telemetry.go

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