fix: read the FIRST digit of the Yaesu VFO reply — I inverted it yesterday

Reported both ways round, which is what settles it. With RX and TX on SUB
everything worked; with them on MAIN the frequency froze and a spot click tuned
the sub VFO. The log shows the rig answering FR01 in the MAIN case.

So on an FTDX101 the state is the FIRST digit — 0 = main — and the second is a
separate parameter. Yesterday I changed this to the LAST digit, which read FR01
as SUB and inverted the whole thing. The fault that change was meant to fix ("SUB
shows MAIN") came from reading VS instead of FR, and probing FR had already fixed
it on its own; the digit change was an unnecessary guess layered on a real fix.

Nothing else needed changing for the operator's two questions: the display and
SetFrequency already follow curVFO, so a spot now tunes whichever VFO holds RX
and TX, and the main frequency is read when on main. A test states that in those
terms — active VFO and which command a spot writes — rather than only as a byte,
because the byte is what I got wrong while believing the logic was right.

CLAUDE.md

@@ -93,6 +93,8 @@ Where two devices are interchangeable (Ultrabeam / SteppIR), `app.go` defines a
 
 **Changelog is mandatory.** Every user-visible change gets an entry in `changelog.json`, **in both `en` and `fr`**, in the same session as the change. Keep entries to one or two sentences — rationale belongs in the commit message. New work goes under the next version number; the release script bumps the version constants.
 
+**Append new entries at the BOTTOM of a version block**, never at the top. A block is read top to bottom, so a feature must appear before the fixes made to it — prepending meant an operator read "the Yaesu meters are corrected" several entries before learning a Yaesu console existed at all.
+
 **Version lives in two places** and must stay in lockstep: `appVersion` in `telemetry.go` and `APP_VERSION` in `frontend/src/version.ts`.
 
 **Bilingual UI.** Every user-visible string goes through `t()` from `frontend/src/lib/i18n.tsx` (~700 keys), with both English and French provided. No hardcoded display strings.

app.go

@@ -8734,36 +8734,33 @@ func (a *App) applyQSLDefaults(q *qso.QSO) {
 	if err != nil {
 		return
 	}
-	if q.QSLSent == "" {
+	applyQSLDefaultsTo(q, d)
-		q.QSLSent = d.QSLSent
+}
-	}
+
-	if q.QSLRcvd == "" {
+// applyQSLDefaultsTo stamps the operator's default confirmation statuses on the
-		q.QSLRcvd = d.QSLRcvd
+// fields a QSO leaves EMPTY. Split from the settings lookup so the rule can be
-	}
+// tested: fill the blanks, never touch a value that is already there.
-	if q.LOTWSent == "" {
+//
-		q.LOTWSent = d.LOTWSent
+// The distinction matters on import. A WSJT-X log carries almost no QSL fields,
-	}
+// so without this every imported QSO would sit with blank statuses; a log
-	if q.LOTWRcvd == "" {
+// exported from another program carries real ones, and overwriting those would
-		q.LOTWRcvd = d.LOTWRcvd
+// erase confirmations the operator has actually received.
-	}
+func applyQSLDefaultsTo(q *qso.QSO, d QSLDefaults) {
-	if q.EQSLSent == "" {
+	fill := func(dst *string, def string) {
-		q.EQSLSent = d.EQSLSent
+		if *dst == "" {
-	}
+			*dst = def
-	if q.EQSLRcvd == "" {
+		}
-		q.EQSLRcvd = d.EQSLRcvd
-	}
-	if q.ClublogUploadStatus == "" {
-		q.ClublogUploadStatus = d.ClublogStatus
-	}
-	if q.HRDLogUploadStatus == "" {
-		q.HRDLogUploadStatus = d.HRDLogStatus
-	}
-	if q.QRZComUploadStatus == "" {
-		q.QRZComUploadStatus = d.QRZComStatus
-	}
-	if q.QRZComDownloadStatus == "" {
-		q.QRZComDownloadStatus = d.QRZComCfm
 	}
+	fill(&q.QSLSent, d.QSLSent)
+	fill(&q.QSLRcvd, d.QSLRcvd)
+	fill(&q.LOTWSent, d.LOTWSent)
+	fill(&q.LOTWRcvd, d.LOTWRcvd)
+	fill(&q.EQSLSent, d.EQSLSent)
+	fill(&q.EQSLRcvd, d.EQSLRcvd)
+	fill(&q.ClublogUploadStatus, d.ClublogStatus)
+	fill(&q.HRDLogUploadStatus, d.HRDLogStatus)
+	fill(&q.QRZComUploadStatus, d.QRZComStatus)
+	fill(&q.QRZComDownloadStatus, d.QRZComCfm)
 }
 
 // ── External services (logbook upload) ─────────────────────────────────
@@ -10071,21 +10068,27 @@ func (a *App) runDownloadConfirmations(svc extsvc.Service, cfg extsvc.ExternalSe
 }
 
 // qrzRecordConfirmed reports whether a QRZ FETCH ADIF record represents a
-// confirmed QSO. QRZ's confirmation marker isn't clearly documented, so we
+// QSO confirmed BY QRZ.COM.
-// accept the likely candidates; the download's one-time field dump lets us
+//
-// pin the exact field against real data and tighten this if needed.
+// It used to accept qsl_rcvd = Y as well, and that was wrong: qsl_rcvd is the
+// operator's own PAPER QSL flag, which they uploaded to QRZ themselves. Any QSO
+// with a paper card was therefore marked QRZ-confirmed on download — reported as
+// "they all turn to Y" (2026-07-29), and on a log full of paper QSLs that is
+// most of it.
+//
+// A QRZ confirmation is QRZ's own statement, and only two fields carry it:
+//
+//	app_qrzlog_status = C   QRZ's confirmed marker on the record
+//	qrzcom_qso_download_status = Y   the ADIF field QRZ sets for it
+//
+// Anything else is a claim from some other source and must not be read as a QRZ
+// confirmation — this status feeds award slots, so a false Y is a QSO counted as
+// confirmed when it is not.
 func qrzRecordConfirmed(rec adif.Record) bool {
-	if strings.EqualFold(rec["qsl_rcvd"], "Y") {
-		return true
-	}
 	if strings.EqualFold(rec["qrzcom_qso_download_status"], "Y") {
 		return true
 	}
-	switch strings.ToUpper(strings.TrimSpace(rec["app_qrzlog_status"])) {
+	return strings.EqualFold(strings.TrimSpace(rec["app_qrzlog_status"]), "C")
-	case "C", "Y":
-		return true
-	}
-	return false
 }
 
 // enrichContactedFromCty fills a QSO's contacted-station country/DXCC/zones
@@ -10844,9 +10847,24 @@ func (a *App) consumeUDPEvents() {
 				"service": string(ev.Service),
 				"source":  ev.Source,
 			})
-		case ev.DXCall != "" && ev.Service == udp.ServiceRemoteCall:
+		case (ev.DXCall != "" || ev.TuneFreqHz > 0) && ev.Service == udp.ServiceRemoteCall:
-			applog.Printf("udp: emit udp:remote_call %q\n", ev.DXCall)
+			// CAT tune riding along with the callsign (DXHunter spot click:
-			wruntime.EventsEmit(a.ctx, "udp:remote_call", ev.DXCall)
+			// "<CALLSIGN>VP5G<FREQ>10.136<MODE>FT8"). Freq first so the rig is
+			// already moving while the frontend fills the entry field.
+			if ev.TuneFreqHz > 0 {
+				applog.Printf("udp: remote_call tune request %.3f MHz mode=%q\n", float64(ev.TuneFreqHz)/1e6, ev.TuneMode)
+				if err := a.SetCATFrequency(ev.TuneFreqHz); err != nil {
+					applog.Printf("udp: remote_call tune failed: %v\n", err)
+				} else if ev.TuneMode != "" {
+					if err := a.SetCATMode(ev.TuneMode); err != nil {
+						applog.Printf("udp: remote_call mode set failed: %v\n", err)
+					}
+				}
+			}
+			if ev.DXCall != "" {
+				applog.Printf("udp: emit udp:remote_call %q\n", ev.DXCall)
+				wruntime.EventsEmit(a.ctx, "udp:remote_call", ev.DXCall)
+			}
 		case ev.DXCall != "":
 			applog.Printf("udp: emit udp:dx_call %q (mode=%s freq=%d)\n", ev.DXCall, ev.Mode, ev.FreqHz)
 			wruntime.EventsEmit(a.ctx, "udp:dx_call", map[string]any{

changelog.json

@@ -1,46 +1,74 @@
 [
+  {
+    "version": "0.22.1",
+    "date": "2026-07-29",
+    "en": [
+      "Clicking a cluster spot while listening on the SUB VFO no longer pulls the radio back to MAIN. The command used to tune sets the main VFO by definition; on SUB the sub VFO is now written directly and the VFO selection is left alone.",
+      "Split showed the opposite of the radio on some Yaesus. Where the rig reports which VFO transmits rather than a split flag, that has to be compared with the VFO you are listening to — so it read backwards for an operator working on SUB and correctly for one on MAIN. Setting split had the same fault.",
+      "A shared MySQL logbook could fail to build its schema, leaving OpsLog on the local SQLite database with a message that only said the connection failed. Column declarations that are quoted, or share a line with others, escaped the SQLite-to-MySQL type conversion — so MySQL refused an index and a default value. A database already left in that state is now repaired at startup instead of failing at every launch.",
+      "Yaesu: OpsLog now follows the VFO you are actually on — the displayed frequency, and the VFO a cluster spot tunes. An FTDX101 answers the receive-VFO query with two digits where an FTDX10 uses one, and the wrong one was read.",
+      "Clicking a spot in DXHunter can now tune the radio: a remote-call UDP packet carrying <FREQ> and <MODE> sets the frequency and mode on whichever CAT backend is active, as well as filling the callsign. A packet without them still just fills the callsign.",
+      "The ADIF import option that fills your station fields from your profile also stamps your default confirmation statuses (paper QSL, LoTW, eQSL, Club Log, HRDLog, QRZ.com) on the ones the file leaves empty — it always did, but nothing said so, and a WSJT-X log carries almost none. Existing confirmations are never overwritten.",
+      "QRZ.com confirmation download marked far too many QSOs as confirmed: it accepted the paper-QSL received flag, which you uploaded to QRZ yourself, as if it were a QRZ confirmation. Only QRZ own confirmation now counts — check the QRZ received column after your next download, as earlier ones may have set it wrongly.",
+      "The Recent QSOs counter labels each of its three numbers — shown, matching the filter, and in the log — with thousands separators. \"Showing 10000 of 23683 matches · 28648 total\" read as if the filter had found more QSOs than the log holds."
+    ],
+    "fr": [
+      "Cliquer sur un spot du cluster en écoutant sur le VFO SUB ne ramène plus la radio sur le VFO principal. La commande utilisée pour s'accorder agit par définition sur le VFO principal ; sur SUB, c'est désormais le VFO secondaire qui est écrit, sans toucher à la sélection.",
+      "Le split affichait l'inverse de la radio sur certains Yaesu. Quand la radio indique quel VFO émet plutôt qu'un indicateur de split, il faut le comparer au VFO écouté — l'affichage était donc inversé pour un opérateur travaillant sur SUB et correct pour un autre sur MAIN. Le réglage du split souffrait du même défaut.",
+      "Un carnet MySQL partagé pouvait échouer à créer son schéma, laissant OpsLog sur la base SQLite locale avec un message indiquant seulement l'échec de la connexion. Les déclarations de colonnes entre guillemets, ou partageant une ligne avec d'autres, échappaient à la conversion de types SQLite vers MySQL — d'où le refus d'un index et d'une valeur par défaut. Une base déjà dans cet état est désormais réparée au démarrage au lieu d'échouer à chaque lancement.",
+      "Yaesu : OpsLog suit désormais le VFO réellement utilisé — la fréquence affichée, et le VFO qu'un spot du cluster accorde. Un FTDX101 répond à la question du VFO de réception avec deux chiffres là où un FTDX10 n'en donne qu'un, et c'est le mauvais qui était lu.",
+      "Cliquer un spot dans DXHunter peut désormais accorder la radio : un paquet UDP remote_call contenant <FREQ> et <MODE> règle la fréquence et le mode sur le backend CAT actif, en plus de renseigner l'indicatif. Un paquet sans ces balises se contente, comme avant, de renseigner l'indicatif.",
+      "L'option d'import ADIF qui remplit vos champs station depuis votre profil applique aussi vos statuts de confirmation par défaut (QSL papier, LoTW, eQSL, Club Log, HRDLog, QRZ.com) sur ceux que le fichier laisse vides — c'était déjà le cas, mais rien ne le disait, et un log WSJT-X n'en contient pratiquement aucun. Les confirmations existantes ne sont jamais écrasées.",
+      "Le téléchargement des confirmations QRZ.com marquait beaucoup trop de QSO comme confirmés : il acceptait l'indicateur de QSL papier reçue — que vous avez vous-même envoyé à QRZ — comme une confirmation QRZ. Seule la confirmation propre à QRZ compte désormais ; vérifiez la colonne QRZ.com reçu après votre prochain téléchargement, les précédents ayant pu la remplir à tort.",
+      "Le compteur des QSO récents nomme chacun de ses trois nombres — affichés, correspondant au filtre, et présents dans le log — avec des séparateurs de milliers. « Showing 10000 of 23683 matches · 28648 total » se lisait comme si le filtre trouvait plus de QSO que le log n'en contient."
+    ]
+  },
   {
     "version": "0.22.0",
     "date": "2026-07-28",
     "en": [
-      "WinKeyer 2: keying is fixed. The dit/dah ratio was sent on the command that sets KEY COMPENSATION, so every element got 50 ms of extra key-down — at 25 wpm a dit is 48 ms — and the keyer sent one element then stalled. The compensation is also cleared, since a keyer already set that way keeps it.",
+      "CQ and ITU zones you correct by hand in your profile stay corrected. They are derived from cty.dat, which gives the zones of the whole entity — in a country spanning several, the automatic value is wrong and it came back at every restart. They now only fill in when empty, and recompute when the callsign or grid changes.",
-      "The voice keyer PTT list now names the Yaesu and Xiegu backends too — with a native backend selected it showed no CAT name, which read as \"CAT PTT is not available for my radio\".",
-      "Voice keyer: a level control for the messages sent to the radio (Settings → Audio). They went out exactly as recorded, so a quietly recorded microphone drove the rig quietly with nothing in OpsLog to fix it. Play previews at the same level, and the hint names the rig setting to check when it transmits almost nothing (on an FTDX10, SSB MOD SOURCE = REAR).",
-      "Yaesu console meters are right: power now reads the meter that follows the RF (in watts, on a curve measured against the rig own display, not the power setting) and SWR shows the ratio itself. Both were reading the wrong index — the SWR bar sat near 80 on a perfect match. The bars also hold their peak for a moment before falling back, so they stay readable through the gaps between words in a CQ, in CW as in SSB.",
-      "CW speed is now one setting wherever you change it: the Yaesu console slider and the CW panel drive the keyer that is actually sending, and the rig own keyer follows so its front panel agrees.",
-      "Antenna Genius: port A no longer jumps onto port B antenna a few seconds after a change. Only one port can hold the transmit antenna, so the switch reports the same one on both — the display now follows each port own receive antenna.",
-      "CW through the Yaesu keyer: a fifth CW engine sends your macros with the radio own keyer (CAT \"KY\") — no WinKeyer, no second cable. Pick \"Yaesu (rig keyer)\" in Settings → CW keyer. For the FTDX101 / FT-991A / FT-710 family: an FTDX10 does not accept it (DAKY included), and OpsLog says so, pointing to the serial DTR keyer on the rig second COM port, which works.",
-      "The Yaesu console follows the mode: in CW the microphone gain and VOX disappear and a CW card takes their place with keyer speed, break-in and ZIN (zero-in).",
-      "Native Xiegu CAT (G90, X6100, X6200, X5105): a new backend talks CI-V straight to the radio — frequency, mode, split and PTT. Pick \"Xiegu (native CI-V)\" in Settings → CAT. Untested on a radio so far, feedback welcome.",
-      "CAT sharing: OpsLog can now serve its rig connection to other programs (Settings → CAT → Share CAT). WSJT-X, JTDX, MSHV or Log4OM connect with rig model \"Hamlib NET rigctl\" at 127.0.0.1:4532 — needed because a native CAT backend holds the radio serial port on its own. Works with every backend, and with both Hamlib command dialects (JTDX names the VFO, MSHV does not).",
-      "Native Yaesu CAT: a new backend talks to an FTDX10/FTDX101 directly over its serial port, without OmniRig — frequency, mode, VFO A/B, split and PTT. Pick \"Yaesu (native CAT)\" in Settings → CAT. First release, feedback welcome.",
-      "Changing band from OpsLog now updates the displayed frequency straight away. The rig moved, but its answer arrived inside the short grace window that protects what you are typing and was discarded — so the frequency stayed on the old band until you nudged the VFO.",
-      "Bulk edit can now set the contacted station gridsquare, so a batch of QSOs imported without a locator can be corrected in one go.",
-      "Filter builder: a confirmation date typed into a condition showed an empty box. The value was stored correctly, only the calendar field failed to display it.",
-      "The Icom model list gains the IC-7300MKII (CI-V B6), plus the IC-7100, IC-7410, IC-7600 and IC-7851. The IC-7700 and IC-7800 were listed at the IC-7100's and IC-7410's addresses, so picking them set an address the rig never answers on.",
-      "Icom over the LAN: the frequency no longer stays frozen after another program (WSJT-X through OmniRig, the Remote Utility) takes the CI-V session. The rig kept answering pings while sending nothing, so OpsLog showed the last known frequency until it was restarted; it now reconnects on its own.",
       "The offline FCC (ULS) database now answers while you type a US callsign, filling state, county and a 6-character grid. It was only applied when the QSO was saved, so without a QRZ.com or HamQTH account you saw nothing but the country and a coarse grid. Online lookups still win — ULS only fills what is blank.",
-      "CQ and ITU zones you correct by hand in your profile stay corrected. They are derived from cty.dat, which gives the zones of the whole entity — in a country spanning several, the automatic value is wrong and it came back at every restart. They now only fill in when empty, and recompute when the callsign or grid changes."
+      "Icom over the LAN: the frequency no longer stays frozen after another program (WSJT-X through OmniRig, the Remote Utility) takes the CI-V session. The rig kept answering pings while sending nothing, so OpsLog showed the last known frequency until it was restarted; it now reconnects on its own.",
+      "The Icom model list gains the IC-7300MKII (CI-V B6), plus the IC-7100, IC-7410, IC-7600 and IC-7851. The IC-7700 and IC-7800 were listed at the IC-7100's and IC-7410's addresses, so picking them set an address the rig never answers on.",
+      "Filter builder: a confirmation date typed into a condition showed an empty box. The value was stored correctly, only the calendar field failed to display it.",
+      "Bulk edit can now set the contacted station gridsquare, so a batch of QSOs imported without a locator can be corrected in one go.",
+      "Changing band from OpsLog now updates the displayed frequency straight away. The rig moved, but its answer arrived inside the short grace window that protects what you are typing and was discarded — so the frequency stayed on the old band until you nudged the VFO.",
+      "Native Yaesu CAT: a new backend talks to an FTDX10/FTDX101 directly over its serial port, without OmniRig — frequency, mode, VFO A/B, split and PTT. Pick \"Yaesu (native CAT)\" in Settings → CAT. First release, feedback welcome.",
+      "Yaesu console: with the native Yaesu backend, a console tab and a Main-view pane give S/PO/SWR meters, band and mode buttons, AF/RF/squelch, AGC, IPO-AMP1-AMP2, a 6/12/18 dB attenuator, NB, DNR, narrow filter, power, mic gain, VOX, split and ATU tune. CW, RTTY, DIGI and PSK show their sideband — click an active button again to switch it. Pressing SPLIT places the transmit VFO up 1 kHz on CW and data, up 5 kHz on phone, and shows the transmit frequency.",
+      "CAT sharing: OpsLog can now serve its rig connection to other programs (Settings → CAT → Share CAT). WSJT-X, JTDX, MSHV or Log4OM connect with rig model \"Hamlib NET rigctl\" at 127.0.0.1:4532 — needed because a native CAT backend holds the radio serial port on its own. Works with every backend, and with both Hamlib command dialects (JTDX names the VFO, MSHV does not).",
+      "Native Xiegu CAT (G90, X6100, X6200, X5105): a new backend talks CI-V straight to the radio — frequency, mode, split and PTT. Pick \"Xiegu (native CI-V)\" in Settings → CAT. Untested on a radio so far, feedback welcome.",
+      "The Yaesu console follows the mode: in CW the microphone gain and VOX disappear and a CW card takes their place with keyer speed, break-in and ZIN (zero-in).",
+      "CW through the Yaesu keyer: a fifth CW engine sends your macros with the radio own keyer (CAT \"KY\") — no WinKeyer, no second cable. Pick \"Yaesu (rig keyer)\" in Settings → CW keyer. For the FTDX101 / FT-991A / FT-710 family: an FTDX10 does not accept it (DAKY included), and OpsLog says so, pointing to the serial DTR keyer on the rig second COM port, which works.",
+      "Antenna Genius: port A no longer jumps onto port B antenna a few seconds after a change. Only one port can hold the transmit antenna, so the switch reports the same one on both — the display now follows each port own receive antenna.",
+      "CW speed is now one setting wherever you change it: the Yaesu console slider and the CW panel drive the keyer that is actually sending, and the rig own keyer follows so its front panel agrees.",
+      "Yaesu console meters are right: power now reads the meter that follows the RF (in watts, on a curve measured against the rig own display, not the power setting) and SWR shows the ratio itself. Both were reading the wrong index — the SWR bar sat near 80 on a perfect match. The bars also hold their peak for a moment before falling back, so they stay readable through the gaps between words in a CQ, in CW as in SSB.",
+      "Voice keyer: a level control for the messages sent to the radio (Settings → Audio). They went out exactly as recorded, so a quietly recorded microphone drove the rig quietly with nothing in OpsLog to fix it. Play previews at the same level, and the hint names the rig setting to check when it transmits almost nothing (on an FTDX10, SSB MOD SOURCE = REAR).",
+      "The voice keyer PTT list now names the Yaesu and Xiegu backends too — with a native backend selected it showed no CAT name, which read as \"CAT PTT is not available for my radio\".",
+      "WinKeyer 2: keying is fixed. The dit/dah ratio was sent on the command that sets KEY COMPENSATION, so every element got 50 ms of extra key-down — at 25 wpm a dit is 48 ms — and the keyer sent one element then stalled. The compensation is also cleared, since a keyer already set that way keeps it.",
+      "ADIF import accepts a file with no header. Records pasted straight out of another log — a few lines lifted from wsjtx_log.adi into a new .adi — imported as \"0 imported, 0 ignored, 0 total\", which reads as an empty file rather than a missing tag."
     ],
     "fr": [
-      "WinKeyer 2 : la manipulation est réparée. Le rapport point/trait était envoyé sur la commande qui règle la COMPENSATION DE MANIPULATION : chaque élément recevait donc 50 ms de fermeture supplémentaire — à 25 mots/minute un point dure 48 ms — et le keyer envoyait un élément puis se bloquait. La compensation est aussi remise à zéro, car un keyer déjà réglé ainsi la conserve.",
+      "Les zones CQ et ITU corrigées à la main dans votre profil restent corrigées. Elles proviennent de cty.dat, qui donne les zones de l'entité entière — dans un pays qui en couvre plusieurs, la valeur automatique est fausse et revenait à chaque redémarrage. Elles ne se remplissent désormais que si le champ est vide, et se recalculent quand l'indicatif ou le locator change.",
-      "La liste PTT du voice keyer nomme aussi les backends Yaesu et Xiegu — avec un backend natif sélectionné, aucun nom de CAT n'apparaissait, ce qui se lisait « il n'y a pas de PTT CAT pour ma radio ».",
-      "Voice keyer : un réglage de niveau pour les messages envoyés à la radio (Réglages → Audio). Ils partaient exactement tels qu'enregistrés : un micro capté faiblement attaquait donc la radio faiblement, sans rien dans OpsLog pour y remédier. Le bouton Lire fait entendre ce même niveau, et l'aide indique le réglage radio à vérifier quand elle n'émet presque rien (sur un FTDX10, SSB MOD SOURCE = REAR).",
-      "Les mesures de la console Yaesu sont justes : la puissance lit l'instrument qui suit la HF (en watts, sur une courbe relevée face à l'affichage de la radio, et non le réglage de puissance) et le ROS affiche le rapport lui-même. Les deux lisaient le mauvais index — la barre de ROS restait vers 80 sur une antenne parfaite. Les barres retiennent aussi leur crête un instant avant de redescendre : elles restent lisibles pendant les silences entre les mots d’un CQ, en CW comme en phonie.",
-      "La vitesse CW est désormais un réglage unique où que vous la changiez : le curseur de la console Yaesu et le panneau CW pilotent le manipulateur qui émet réellement, et le keyer interne de la radio suit pour que sa façade affiche la même valeur.",
-      "Antenna Genius : le port A ne bascule plus sur l'antenne du port B quelques secondes après un changement. Un seul port peut porter l'antenne d'émission, le switch renvoie donc la même sur les deux — l'affichage suit désormais l'antenne de réception propre à chaque port.",
-      "CW par le keyer Yaesu : un cinquième moteur CW envoie vos macros avec le keyer de la radio (CAT « KY ») — sans WinKeyer ni second câble. À choisir dans Réglages → Keyer CW sous « Yaesu (keyer de la radio) ». Pour la famille FTDX101 / FT-991A / FT-710 : un FTDX10 ne l'accepte pas (DAKY compris), et OpsLog le dit en renvoyant vers le keyer série DTR sur son second port COM, qui fonctionne.",
-      "La console Yaesu suit le mode : en CW, le gain micro et le VOX disparaissent au profit d'une carte CW avec la vitesse du manipulateur, le break-in et ZIN (zéro-in).",
-      "CAT Xiegu natif (G90, X6100, X6200, X5105) : un nouveau backend dialogue en CI-V directement avec la radio — fréquence, mode, split et PTT. À choisir dans Réglages → CAT sous « Xiegu (CI-V natif) ». Pas encore testé sur une radio, retours bienvenus.",
-      "Partage du CAT : OpsLog peut désormais servir sa liaison radio aux autres logiciels (Réglages → CAT → Partager le CAT). WSJT-X, JTDX, MSHV ou Log4OM s'y connectent avec le modèle « Hamlib NET rigctl » sur 127.0.0.1:4532 — nécessaire car un backend CAT natif occupe seul le port série. Fonctionne avec tous les backends, et avec les deux dialectes Hamlib (JTDX nomme le VFO, MSHV non).",
-      "CAT Yaesu natif : un nouveau backend dialogue directement avec un FTDX10/FTDX101 par son port série, sans OmniRig — fréquence, mode, VFO A/B, split et PTT. À choisir dans Réglages → CAT sous « Yaesu (CAT natif) ». Première version, retours bienvenus.",
-      "Changer de bande depuis OpsLog met désormais la fréquence affichée à jour immédiatement. La radio se déplaçait bien, mais sa réponse arrivait pendant le court délai qui protège votre saisie et était ignorée — la fréquence restait donc sur l'ancienne bande jusqu'à ce qu'on touche le VFO.",
-      "L'édition groupée peut désormais définir le locator de la station contactée : un lot de QSO importés sans locator se corrige en une fois.",
-      "Constructeur de filtres : une date de confirmation saisie dans une condition s'affichait dans une case vide. La valeur était bien enregistrée, seul le champ calendrier ne la montrait pas.",
-      "La liste des modèles Icom gagne l'IC-7300MKII (CI-V B6), ainsi que les IC-7100, IC-7410, IC-7600 et IC-7851. Les IC-7700 et IC-7800 y figuraient avec les adresses des IC-7100 et IC-7410 : les choisir réglait une adresse sur laquelle la radio ne répond jamais.",
-      "Icom via le réseau : la fréquence ne reste plus figée après qu'un autre programme (WSJT-X via OmniRig, la Remote Utility) a pris la session CI-V. La radio continuait de répondre aux pings sans rien émettre, si bien qu'OpsLog affichait la dernière fréquence connue jusqu'à son redémarrage ; il se reconnecte désormais tout seul.",
       "La base FCC (ULS) hors ligne répond désormais pendant la saisie d'un indicatif américain, en remplissant l'état, le comté et un locator 6 caractères. Elle n'était appliquée qu'à l'enregistrement du QSO : sans compte QRZ.com ou HamQTH, vous ne voyiez que le pays et un locator approximatif. Les recherches en ligne restent prioritaires — l'ULS ne comble que ce qui est vide.",
-      "Les zones CQ et ITU corrigées à la main dans votre profil restent corrigées. Elles proviennent de cty.dat, qui donne les zones de l'entité entière — dans un pays qui en couvre plusieurs, la valeur automatique est fausse et revenait à chaque redémarrage. Elles ne se remplissent désormais que si le champ est vide, et se recalculent quand l'indicatif ou le locator change."
+      "Icom via le réseau : la fréquence ne reste plus figée après qu'un autre programme (WSJT-X via OmniRig, la Remote Utility) a pris la session CI-V. La radio continuait de répondre aux pings sans rien émettre, si bien qu'OpsLog affichait la dernière fréquence connue jusqu'à son redémarrage ; il se reconnecte désormais tout seul.",
+      "La liste des modèles Icom gagne l'IC-7300MKII (CI-V B6), ainsi que les IC-7100, IC-7410, IC-7600 et IC-7851. Les IC-7700 et IC-7800 y figuraient avec les adresses des IC-7100 et IC-7410 : les choisir réglait une adresse sur laquelle la radio ne répond jamais.",
+      "Constructeur de filtres : une date de confirmation saisie dans une condition s'affichait dans une case vide. La valeur était bien enregistrée, seul le champ calendrier ne la montrait pas.",
+      "L'édition groupée peut désormais définir le locator de la station contactée : un lot de QSO importés sans locator se corrige en une fois.",
+      "Changer de bande depuis OpsLog met désormais la fréquence affichée à jour immédiatement. La radio se déplaçait bien, mais sa réponse arrivait pendant le court délai qui protège votre saisie et était ignorée — la fréquence restait donc sur l'ancienne bande jusqu'à ce qu'on touche le VFO.",
+      "CAT Yaesu natif : un nouveau backend dialogue directement avec un FTDX10/FTDX101 par son port série, sans OmniRig — fréquence, mode, VFO A/B, split et PTT. À choisir dans Réglages → CAT sous « Yaesu (CAT natif) ». Première version, retours bienvenus.",
+      "Console Yaesu : avec le backend Yaesu natif, un onglet console et un volet de la vue principale offrent les mesures S/PO/ROS, les boutons de bande et de mode, AF/RF/squelch, AGC, IPO-AMP1-AMP2, un atténuateur 6/12/18 dB, NB, DNR, filtre étroit, puissance, gain micro, VOX, split et accord d'antenne. CW, RTTY, DIGI et PSK affichent leur bande latérale — recliquez sur le bouton actif pour en changer. Appuyer sur SPLIT place le VFO d'émission à +1 kHz en CW et numérique, +5 kHz en phonie, et affiche la fréquence d'émission.",
+      "Partage du CAT : OpsLog peut désormais servir sa liaison radio aux autres logiciels (Réglages → CAT → Partager le CAT). WSJT-X, JTDX, MSHV ou Log4OM s'y connectent avec le modèle « Hamlib NET rigctl » sur 127.0.0.1:4532 — nécessaire car un backend CAT natif occupe seul le port série. Fonctionne avec tous les backends, et avec les deux dialectes Hamlib (JTDX nomme le VFO, MSHV non).",
+      "CAT Xiegu natif (G90, X6100, X6200, X5105) : un nouveau backend dialogue en CI-V directement avec la radio — fréquence, mode, split et PTT. À choisir dans Réglages → CAT sous « Xiegu (CI-V natif) ». Pas encore testé sur une radio, retours bienvenus.",
+      "La console Yaesu suit le mode : en CW, le gain micro et le VOX disparaissent au profit d'une carte CW avec la vitesse du manipulateur, le break-in et ZIN (zéro-in).",
+      "CW par le keyer Yaesu : un cinquième moteur CW envoie vos macros avec le keyer de la radio (CAT « KY ») — sans WinKeyer ni second câble. À choisir dans Réglages → Keyer CW sous « Yaesu (keyer de la radio) ». Pour la famille FTDX101 / FT-991A / FT-710 : un FTDX10 ne l'accepte pas (DAKY compris), et OpsLog le dit en renvoyant vers le keyer série DTR sur son second port COM, qui fonctionne.",
+      "Antenna Genius : le port A ne bascule plus sur l'antenne du port B quelques secondes après un changement. Un seul port peut porter l'antenne d'émission, le switch renvoie donc la même sur les deux — l'affichage suit désormais l'antenne de réception propre à chaque port.",
+      "La vitesse CW est désormais un réglage unique où que vous la changiez : le curseur de la console Yaesu et le panneau CW pilotent le manipulateur qui émet réellement, et le keyer interne de la radio suit pour que sa façade affiche la même valeur.",
+      "Les mesures de la console Yaesu sont justes : la puissance lit l'instrument qui suit la HF (en watts, sur une courbe relevée face à l'affichage de la radio, et non le réglage de puissance) et le ROS affiche le rapport lui-même. Les deux lisaient le mauvais index — la barre de ROS restait vers 80 sur une antenne parfaite. Les barres retiennent aussi leur crête un instant avant de redescendre : elles restent lisibles pendant les silences entre les mots d’un CQ, en CW comme en phonie.",
+      "Voice keyer : un réglage de niveau pour les messages envoyés à la radio (Réglages → Audio). Ils partaient exactement tels qu'enregistrés : un micro capté faiblement attaquait donc la radio faiblement, sans rien dans OpsLog pour y remédier. Le bouton Lire fait entendre ce même niveau, et l'aide indique le réglage radio à vérifier quand elle n'émet presque rien (sur un FTDX10, SSB MOD SOURCE = REAR).",
+      "La liste PTT du voice keyer nomme aussi les backends Yaesu et Xiegu — avec un backend natif sélectionné, aucun nom de CAT n'apparaissait, ce qui se lisait « il n'y a pas de PTT CAT pour ma radio ».",
+      "WinKeyer 2 : la manipulation est réparée. Le rapport point/trait était envoyé sur la commande qui règle la COMPENSATION DE MANIPULATION : chaque élément recevait donc 50 ms de fermeture supplémentaire — à 25 mots/minute un point dure 48 ms — et le keyer envoyait un élément puis se bloquait. La compensation est aussi remise à zéro, car un keyer déjà réglé ainsi la conserve.",
+      "L'import ADIF accepte un fichier sans en-tête. Des enregistrements collés depuis un autre log — quelques lignes reprises de wsjtx_log.adi dans un nouveau .adi — donnaient « 0 importé, 0 ignoré, 0 au total », ce qui se lit comme un fichier vide plutôt que comme une balise manquante."
     ]
   },
   {

frontend/src/App.tsx

@@ -5560,16 +5560,31 @@ export default function App() {
                       onClick={() => { setActiveFilter({ conditions: [], match: 'AND' }); setFilterCallsign(''); }}
                     >clear</button>
                   ) : null}
+                  {/* Three different numbers, so each one is LABELLED. "Showing
+                      10000 of 23683 matches · 28648 total" was read as a filter
+                      matching more than the log holds: the middle number belonged
+                      to "matches" but sat where "of N" normally means the total.
+                      Thousands separators for the same reason — 23683 and 28648
+                      are hard to compare at a glance. */}
                   {gridFilteredCount != null ? (
                     <span>
-                      Showing <span className="font-semibold text-foreground">{gridFilteredCount}</span> of{' '}
+                      Showing <span className="font-semibold text-foreground">{gridFilteredCount.toLocaleString()}</span> of{' '}
-                      <span className="font-semibold text-foreground">{qsos.length}</span> (column filter)
+                      <span className="font-semibold text-foreground">{qsos.length.toLocaleString()}</span> (column filter)
                     </span>
                   ) : (
                     <span>
-                      Showing <span className="font-semibold text-foreground">{qsos.length}</span> of{' '}
+                      {(activeFilter.conditions?.length || filterCallsign) ? (
-                      <span className="font-semibold text-foreground">{(activeFilter.conditions?.length || filterCallsign) && matchCount != null ? matchCount : total}</span>
+                        <>
-                      {(activeFilter.conditions?.length || filterCallsign) ? ` matches · ${total} total` : ''}
+                          Showing <span className="font-semibold text-foreground">{qsos.length.toLocaleString()}</span>
+                          {' · '}<span className="font-semibold text-foreground">{(matchCount ?? 0).toLocaleString()}</span> match the filter
+                          {' · '}<span className="font-semibold text-foreground">{total.toLocaleString()}</span> in the log
+                        </>
+                      ) : (
+                        <>
+                          Showing <span className="font-semibold text-foreground">{qsos.length.toLocaleString()}</span> of{' '}
+                          <span className="font-semibold text-foreground">{total.toLocaleString()}</span>
+                        </>
+                      )}
                     </span>
                   )}
                 </div>

frontend/src/lib/i18n.tsx

@@ -134,7 +134,7 @@ const en: Dict = {
   'imp.ctyTitle': 'Fix country & zones (cty.dat + ClubLog)',
   'imp.ctyDesc': "Recompute Country, DXCC & CQ/ITU zones from cty.dat, overriding the file — corrects what contest software exports wrong (e.g. RG2Y as Asiatic instead of European Russia). ClubLog's DXpedition overrides are applied on top per QSO date (e.g. TO974REF → Reunion, TO2A 2012 → French Guiana) whenever the ClubLog data is downloaded. Everything else in the ADIF is kept as-is. Tip: use Update duplicates to re-fix QSOs already in your log.",
   'imp.stationTitle': 'Fill my station fields from my profile',
-  'imp.stationDesc': "Backfill empty MY_* fields (my grid, rig, antenna, address, city, state, county, SOTA/POTA ref, TX power…) plus Operator and Owner callsign from your active profile. Existing values are kept. Only STATION_CALLSIGN is left untouched so a mixed-call log isn't re-routed. Enable when importing your own log.",
+  'imp.stationDesc': "Backfill empty MY_* fields (my grid, rig, antenna, address, city, state, county, SOTA/POTA ref, TX power…) plus Operator and Owner callsign from your active profile. Existing values are kept. Only STATION_CALLSIGN is left untouched so a mixed-call log isn't re-routed. It ALSO stamps your default confirmation statuses (paper QSL, LoTW, eQSL, Club Log, HRDLog, QRZ.com sent and received) on the ones the file leaves empty — a WSJT-X log carries almost none. Enable when importing your own log.",
   'imp.cancel': 'Cancel', 'imp.import': 'Import',
   'imp.progressTitle': 'Importing ADIF…',
   'imp.progressCount': '{done} / {tot} records · {pct}%', 'imp.progressCountOnly': '{done} records…',
@@ -545,7 +545,7 @@ const fr: Dict = {
   'imp.ctyTitle': 'Corriger pays & zones (cty.dat + ClubLog)',
   'imp.ctyDesc': "Recalcule Pays, DXCC & zones CQ/ITU depuis cty.dat, en écrasant le fichier — corrige ce que les logiciels de contest exportent mal (ex. RG2Y en Russie asiatique au lieu d'européenne). Les exceptions DXpédition de ClubLog s'appliquent par-dessus selon la date du QSO (ex. TO974REF → Réunion, TO2A 2012 → Guyane française) dès que les données ClubLog sont téléchargées. Tout le reste de l'ADIF est conservé tel quel. Astuce : utilise Mettre à jour les doublons pour re-corriger des QSO déjà dans le log.",
   'imp.stationTitle': 'Remplir mes champs station depuis mon profil',
-  'imp.stationDesc': "Complète les champs MY_* vides (locator, rig, antenne, adresse, ville, état, comté, réf. SOTA/POTA, puissance TX…) plus Opérateur et Indicatif propriétaire depuis le profil actif. Les valeurs existantes sont conservées. Seul STATION_CALLSIGN n'est jamais touché pour ne pas re-router un log multi-indicatifs. À activer quand tu importes ton propre log.",
+  'imp.stationDesc': "Complète les champs MY_* vides (locator, rig, antenne, adresse, ville, état, comté, réf. SOTA/POTA, puissance TX…) plus Opérateur et Indicatif propriétaire depuis le profil actif. Les valeurs existantes sont conservées. Seul STATION_CALLSIGN n'est jamais touché pour ne pas re-router un log multi-indicatifs. Elle applique AUSSI tes statuts de confirmation par défaut (QSL papier, LoTW, eQSL, Club Log, HRDLog, QRZ.com envoyé et reçu) sur ceux que le fichier laisse vides — un log WSJT-X n'en contient pratiquement aucun. À activer quand tu importes ton propre log.",
   'imp.cancel': 'Annuler', 'imp.import': 'Importer',
   'imp.progressTitle': 'Import ADIF en cours…',
   'imp.progressCount': '{done} / {tot} enregistrements · {pct}%', 'imp.progressCountOnly': '{done} enregistrements…',

import_defaults_test.go

@@ -0,0 +1,63 @@
+package main
+
+import (
+	"testing"
+
+	"hamlog/internal/qso"
+)
+
+// The confirmation statuses an import fills in, and the ones it must not touch.
+//
+// An operator asked for this feature believing it missing — it has been there
+// since v0.14, but the option's description never mentioned it, so nobody could
+// know. The behaviour is pinned here so a future edit cannot quietly drop what
+// the description now promises.
+//
+// The rule is fill-if-empty: a WSJT-X log carries almost no QSL fields, while a
+// log exported from another program carries real ones that must survive.
+func TestQSLDefaultsFillOnlyEmptyFields(t *testing.T) {
+	defaults := QSLDefaults{
+		QSLSent: "N", QSLRcvd: "N",
+		LOTWSent: "N", LOTWRcvd: "N",
+		EQSLSent: "N", EQSLRcvd: "N",
+		ClublogStatus: "N", HRDLogStatus: "N",
+		QRZComStatus: "N", QRZComCfm: "N",
+	}
+
+	// A record as WSJT-X writes it: no confirmation fields at all.
+	bare := &qso.QSO{Callsign: "F4XYZ"}
+	applyQSLDefaultsTo(bare, defaults)
+	for name, got := range map[string]string{
+		"qsl_sent": bare.QSLSent, "qsl_rcvd": bare.QSLRcvd,
+		"lotw_sent": bare.LOTWSent, "lotw_rcvd": bare.LOTWRcvd,
+		"eqsl_sent": bare.EQSLSent, "eqsl_rcvd": bare.EQSLRcvd,
+		"clublog": bare.ClublogUploadStatus, "hrdlog": bare.HRDLogUploadStatus,
+		"qrz_sent": bare.QRZComUploadStatus, "qrz_rcvd": bare.QRZComDownloadStatus,
+	} {
+		if got != "N" {
+			t.Errorf("%s = %q on an empty record, want the default \"N\"", name, got)
+		}
+	}
+
+	// A record that already carries confirmations — from a real logbook export.
+	// Overwriting these would erase QSLs the operator has actually received.
+	kept := &qso.QSO{
+		Callsign: "F4XYZ",
+		QSLRcvd:  "Y", LOTWRcvd: "Y", EQSLSent: "Y",
+		ClublogUploadStatus: "Y", QRZComDownloadStatus: "Y",
+	}
+	applyQSLDefaultsTo(kept, defaults)
+	for name, got := range map[string]string{
+		"qsl_rcvd": kept.QSLRcvd, "lotw_rcvd": kept.LOTWRcvd, "eqsl_sent": kept.EQSLSent,
+		"clublog": kept.ClublogUploadStatus, "qrz_rcvd": kept.QRZComDownloadStatus,
+	} {
+		if got != "Y" {
+			t.Errorf("%s = %q — an existing confirmation was overwritten", name, got)
+		}
+	}
+	// …while its empty ones still get the default.
+	if kept.QSLSent != "N" || kept.LOTWSent != "N" {
+		t.Errorf("empty fields on a partly-filled record were not defaulted: qsl_sent=%q lotw_sent=%q",
+			kept.QSLSent, kept.LOTWSent)
+	}
+}

internal/adif/parser.go

@@ -22,9 +22,11 @@ import (
 // Record is a single ADIF record. Keys are lowercased field names.
 type Record map[string]string
 
-// Parse reads an ADI stream and invokes fn for each record (after <EOH>).
+// Parse reads an ADI stream and invokes fn for each record.
 // Returning a non-nil error from fn stops parsing and is propagated.
-// The header (text before <EOH>) is silently discarded.
+//
+// The header (text before <EOH>) is silently discarded. A file with NO header is
+// read as records from the first tag — hand-assembled files often have none.
 func Parse(r io.Reader, fn func(Record) error) error {
 	return parseWith(r, nil, fn)
 }
@@ -44,7 +46,6 @@ func parseWith(r io.Reader, decodeValue func([]byte) string, fn func(Record) err
 	br := bufio.NewReaderSize(r, 64*1024)
 
 	rec := Record{}
-	headerDone := false
 
 	for {
 		// Seek next '<'. Bytes before it are either header text or
@@ -65,11 +66,19 @@ func parseWith(r io.Reader, decodeValue func([]byte) string, fn func(Record) err
 		name, length := parseSpec(spec)
 		switch name {
 		case "eoh":
-			headerDone = true
+			rec = Record{} // everything collected so far was the header
-			rec = Record{}
 			continue
 		case "eor":
-			if headerDone && len(rec) > 0 {
+			// An <eor> proves we are in the record section, whether or not an <eoh>
+			// came first. Files pasted together by hand — a few lines lifted out of
+			// wsjtx_log.adi into a new file — have no header at all, and requiring
+			// one made every record invisible: the import reported 0 imported,
+			// 0 ignored, 0 total, which reads as "the file is empty" rather than
+			// "there was no header".
+			//
+			// A real header cannot contain <eor>, so accepting it costs nothing for
+			// well-formed files: theirs ends at <eoh> long before any record.
+			if len(rec) > 0 {
 				if err := fn(rec); err != nil {
 					return err
 				}
@@ -95,7 +104,14 @@ func parseWith(r io.Reader, decodeValue func([]byte) string, fn func(Record) err
 			if decodeValue == nil && !utf8.Valid(val) {
 				val = extendToRunes(br, val, length)
 			}
-			if headerDone && name != "" {
+			// Fields are collected ALWAYS, and thrown away at <eoh>.
+			//
+			// Collecting them only after the header meant a headerless file lost its
+			// FIRST record whole: its fields were discarded as header text, and the
+			// <eor> that followed found nothing to emit. Discarding at <eoh> instead
+			// keeps real headers out of the data just as well — that tag is exactly
+			// what says "everything before this was the header".
+			if name != "" {
 				if decodeValue != nil {
 					rec[name] = decodeValue(val)
 				} else {

internal/adif/parser_test.go

@@ -51,19 +51,28 @@ func TestParseValueWithAngleBracket(t *testing.T) {
 }
 
 func TestParseNoHeader(t *testing.T) {
-	// Some loggers omit the header entirely — records before <EOH> are
+	// A file without a header is IMPORTED, not discarded.
-	// discarded by design. Verify nothing is emitted in that case.
+	//
+	// This test asserted the opposite until 2026-07-29, when an operator pasted a
+	// dozen lines out of wsjtx_log.adi into a new .adi and got "0 imported,
+	// 0 ignored, 0 total". Discarding records before <EOH> was a defensible
+	// reading of the spec, but the file it rejects is one people really make, and
+	// the rejection is silent: the count says the file was empty, not that a tag
+	// was missing. An <eor> is proof enough that a record ended.
 	src := `<CALL:5>F4XYZ<EOR>`
-	var got int
+	var got []Record
 	err := Parse(strings.NewReader(src), func(r Record) error {
-		got++
+		got = append(got, r)
 		return nil
 	})
 	if err != nil {
 		t.Fatalf("parse: %v", err)
 	}
-	if got != 0 {
+	if len(got) != 1 {
-		t.Errorf("expected 0 records without <EOH>, got %d", got)
+		t.Fatalf("expected the record to be imported without <EOH>, got %d", len(got))
+	}
+	if got[0]["call"] != "F4XYZ" {
+		t.Errorf("call = %q, want F4XYZ", got[0]["call"])
 	}
 }
 
@@ -82,3 +91,57 @@ func TestParseTypedField(t *testing.T) {
 		t.Errorf("freq mismatch: %q", got["freq"])
 	}
 }
+
+// A file with NO header must still import.
+//
+// Reported from the field: an operator lifted a dozen lines out of wsjtx_log.adi
+// into a new .adi and got "0 imported, 0 ignored, 0 total" — which reads as an
+// empty file rather than as a missing header. Records were only emitted after
+// <EOH>, so a hand-assembled file was invisible in its entirety.
+func TestParseHeaderlessFile(t *testing.T) {
+	// The operator's exact shape: records straight from a WSJT-X log, no header.
+	in := "<call:5>PY2VE <gridsquare:4>GG67 <mode:3>FT8 <rst_sent:3>-18 <rst_rcvd:3>-15 " +
+		"<qso_date:8>20260728 <time_on:6>194200 <band:3>15m <eor>\n" +
+		"<call:5>W8OBX <gridsquare:4>FM25 <mode:3>FT8 <rst_sent:3>-19 <rst_rcvd:3>-12 " +
+		"<qso_date:8>20260728 <time_on:6>194500 <band:3>15m <eor>\n"
+
+	var got []Record
+	if err := Parse(strings.NewReader(in), func(r Record) error {
+		got = append(got, r)
+		return nil
+	}); err != nil {
+		t.Fatalf("Parse: %v", err)
+	}
+	if len(got) != 2 {
+		t.Fatalf("parsed %d records from a headerless file, want 2", len(got))
+	}
+	if got[0]["call"] != "PY2VE" || got[1]["call"] != "W8OBX" {
+		t.Errorf("callsigns = %q, %q — want PY2VE, W8OBX", got[0]["call"], got[1]["call"])
+	}
+	if got[0]["gridsquare"] != "GG67" {
+		t.Errorf("gridsquare = %q, want GG67", got[0]["gridsquare"])
+	}
+}
+
+// And a normal file must be unaffected: its header is still discarded, so header
+// fields never leak into the first record.
+func TestParseHeaderStillDiscarded(t *testing.T) {
+	in := "Generated by SomeLogger\n<adif_ver:5>3.1.4 <programid:6>OpsLog <eoh>\n" +
+		"<call:4>F4AA <mode:2>CW <eor>\n"
+	var got []Record
+	if err := Parse(strings.NewReader(in), func(r Record) error {
+		got = append(got, r)
+		return nil
+	}); err != nil {
+		t.Fatalf("Parse: %v", err)
+	}
+	if len(got) != 1 {
+		t.Fatalf("parsed %d records, want 1", len(got))
+	}
+	if _, leaked := got[0]["programid"]; leaked {
+		t.Error("a header field leaked into the record")
+	}
+	if got[0]["call"] != "F4AA" {
+		t.Errorf("call = %q, want F4AA", got[0]["call"])
+	}
+}

internal/cat/omnirig.go

@@ -493,12 +493,24 @@ func (o *OmniRig) SetFrequency(hz int64) error {
 	// method (RX=TX=freq, simplex). It works on rigs — notably Icom (IC-9100) —
 	// where direct FreqA/FreqB writes are accepted but never move the radio.
 	// Clearing split is the right thing when tuning to a spot anyway.
+	// …but ONLY when the operator is on the main VFO. SetSimplexMode means
+	// "receive and transmit here, simplex", and OmniRig implements that on the
+	// MAIN VFO — so on an FTDX101 listening on SUB, clicking a cluster spot
+	// dragged the radio back to MAIN (F4NBZ, 2026-07-29). The operator picked SUB
+	// deliberately; a spot click is a request to change frequency, not to change
+	// VFO. On SUB the direct FreqB write below does the whole job.
+	onSubVFO := vfo == "B" || vfo == "BB" || vfo == "BA"
 	simplexOK := false
-	if _, err := oleutil.CallMethod(o.rig, "SetSimplexMode", int32(hz32)); err == nil {
+	switch {
-		simplexOK = true
+	case onSubVFO:
-		debugLog.Printf("OmniRig.SetFrequency: SetSimplexMode(%d) OK", hz32)
+		debugLog.Printf("OmniRig.SetFrequency: on VFO %q — skipping SetSimplexMode so the rig stays on SUB", vfo)
-	} else {
+	default:
-		debugLog.Printf("OmniRig.SetFrequency: SetSimplexMode unavailable (%v)", err)
+		if _, err := oleutil.CallMethod(o.rig, "SetSimplexMode", int32(hz32)); err == nil {
+			simplexOK = true
+			debugLog.Printf("OmniRig.SetFrequency: SetSimplexMode(%d) OK", hz32)
+		} else {
+			debugLog.Printf("OmniRig.SetFrequency: SetSimplexMode unavailable (%v)", err)
+		}
 	}
 
 	// On Yaesu / Kenwood (and anything non-Icom), SetSimplexMode frequently returns
@@ -511,12 +523,18 @@ func (o *OmniRig) SetFrequency(hz int64) error {
 	isIcom := strings.HasPrefix(strings.ToUpper(strings.TrimSpace(rigType)), "IC")
 	if !isIcom || !simplexOK {
 		prop := "FreqA"
-		switch vfo {
+		if onSubVFO {
-		case "B", "BB", "BA":
 			prop = "FreqB"
 		}
 		okAny := false
-		for _, p := range []string{prop, "Freq"} {
+		// The generic "Freq" property is written too — but NOT on SUB, where it is
+		// the main VFO's frequency on several rig files and would move the VFO the
+		// operator is not using, or pull them back to it.
+		props := []string{prop, "Freq"}
+		if onSubVFO {
+			props = []string{prop}
+		}
+		for _, p := range props {
 			if _, e := oleutil.PutProperty(o.rig, p, hz32); e != nil {
 				debugLog.Printf("OmniRig.SetFrequency: PutProperty(%s) error: %v", p, e)
 			} else {

internal/cat/omnirig_vfo_test.go

@@ -83,3 +83,45 @@ func TestResolveOmniRigVFOs(t *testing.T) {
 		}
 	}
 }
+
+// Which VFO a frequency set writes to, and whether it may call SetSimplexMode.
+//
+// Reported on an FTDX101 (F4NBZ, 2026-07-29): listening on SUB, clicking a
+// cluster spot dragged the radio back to MAIN. SetSimplexMode means "receive and
+// transmit here, simplex" and OmniRig applies it to the MAIN VFO — so it must
+// not be used when the operator is on SUB. They chose that VFO deliberately; a
+// spot click asks for a frequency, not for a VFO change.
+func TestOmniRigWriteTarget(t *testing.T) {
+	// Mirrors the decision made in SetFrequency.
+	target := func(vfo string) (prop string, simplexAllowed bool) {
+		onSub := vfo == "B" || vfo == "BB" || vfo == "BA"
+		if onSub {
+			return "FreqB", false
+		}
+		return "FreqA", true
+	}
+
+	cases := []struct {
+		vfo     string
+		prop    string
+		simplex bool
+	}{
+		// On the main VFO nothing changes: SetSimplexMode is what moves the Icoms
+		// whose direct writes are ignored.
+		{"", "FreqA", true},
+		{"A", "FreqA", true},
+		{"AA", "FreqA", true},
+		{"AB", "FreqA", true},
+		// On SUB, write FreqB and leave the VFO selection alone.
+		{"B", "FreqB", false},
+		{"BB", "FreqB", false},
+		{"BA", "FreqB", false},
+	}
+	for _, c := range cases {
+		prop, simplex := target(c.vfo)
+		if prop != c.prop || simplex != c.simplex {
+			t.Errorf("VFO %q → write %s, simplex=%v; want %s, simplex=%v",
+				c.vfo, prop, simplex, c.prop, c.simplex)
+		}
+	}
+}

internal/cat/yaesu.go

@@ -18,7 +18,8 @@ package cat
 //	FA;            → FA014074000;   VFO A frequency, 9 digits, Hz
 //	FB;            → FB014100000;   VFO B frequency
 //	MD0;           → MD02;          operating mode of the main receiver
-//	VS;            → VS0;           which VFO is selected (0=A, 1=B)
+//	FR;            → FR1;           RECEIVE VFO (0=main/A, 1=sub/B)
+//	VS;            → VS0;           selected VFO, on models without FR
 //	ST;            → ST1;           split (FTDX10/FTDX101)
 //	FT;            → FT1;           TX VFO (FT-991A/FT-710/FT-891 family)
 //	TX1; / TX0;                     key / unkey
@@ -93,6 +94,9 @@ type Yaesu struct {
 	// answers. Empty means the rig answered neither, and split is reported as
 	// off rather than invented.
 	splitCmd string
+	// rxVFOCmd is "FR" when the rig reports its receive VFO that way, else empty
+	// and VS is used — see ReadState.
+	rxVFOCmd string
 
 	curFreq   int64
 	curRXFreq int64
@@ -159,6 +163,16 @@ func (y *Yaesu) Connect() error {
 	// remembering the answer keeps the poll loop from paying for two round trips
 	// per cycle, and makes "neither answered" an explicit, logged state instead
 	// of a silent assumption that split is off.
+	// Which command reports the RECEIVE VFO. FR is the right one where it exists;
+	// VS is a weaker substitute that an FTDX101 answers with the main VFO even
+	// when the operator has moved both RX and TX to sub.
+	if r, err := y.ask("FR;"); err == nil && strings.HasPrefix(r, "FR") {
+		y.rxVFOCmd = "FR"
+		debugLog.Printf("yaesu: receive VFO is read through FR (answered %q)", r)
+	} else {
+		debugLog.Printf("yaesu: no FR; — falling back to VS for the receive VFO")
+	}
+
 	for _, c := range []string{"ST", "FT"} {
 		if r, err := y.ask(c + ";"); err == nil && strings.HasPrefix(r, c) {
 			y.splitCmd = c
@@ -212,18 +226,30 @@ func (y *Yaesu) ReadState() (RigState, error) {
 		freqB, _ = parseYaesuFreq(r, "FB")
 	}
 
-	// Which VFO the operator is listening on. Unlike OmniRig there is no
+	// Which VFO the operator is LISTENING on.
-	// interpretation to do: VS answers 0 or 1.
+	//
+	// FR is the command that answers that — it selects the receive VFO — and VS
+	// does not: on an FTDX101 with both RX and TX moved to SUB, VS still reported
+	// the main VFO, so OpsLog displayed VFO A while the operator was entirely on
+	// B. Reported 2026-07-29. FR is asked first and VS is the fallback for models
+	// that do not implement it.
 	vfo := "A"
-	if r, err := y.ask("VS;"); err == nil && len(r) >= 3 && r[2] == '1' {
+	switch {
-		vfo = "B"
+	case y.rxVFOCmd != "":
+		if r, err := y.ask(y.rxVFOCmd + ";"); err == nil && yaesuStateDigit(r, y.rxVFOCmd) == '1' {
+			vfo = "B"
+		}
+	default:
+		if r, err := y.ask("VS;"); err == nil && yaesuStateDigit(r, "VS") == '1' {
+			vfo = "B"
+		}
 	}
 	y.curVFO = vfo
 
 	split := false
 	if y.splitCmd != "" {
 		if r, err := y.ask(y.splitCmd + ";"); err == nil {
-			split = yaesuSplitOn(r, y.splitCmd)
+			split = yaesuSplitFromReply(r, y.splitCmd, vfo)
 		}
 	}
 
@@ -396,18 +422,32 @@ func parseYaesuFreq(reply, prefix string) (int64, bool) {
 	return hz, true
 }
 
-// yaesuSplitOn reads the split reply for whichever command the rig answers.
+// yaesuSplitFromReply turns the split reply into a yes or no.
 //
-// ST is a split flag: ST1 means split. FT names the TX VFO: FT1 means transmit
+// The two commands say DIFFERENT things and reading them alike is a real fault,
-// on VFO B, which IS split when the operator is listening on A. The two are not
+// reported on an FTDX101 (F4NBZ, 2026-07-29) where the panel showed split ON with
-// the same statement, which is why the command in use is remembered rather than
+// the radio OFF and the reverse:
-// both being tried and merged.
+//
-func yaesuSplitOn(reply, cmd string) bool {
+//	ST is a split FLAG      — ST1 means split, whatever VFO is in use.
-	r := strings.TrimSpace(reply)
+//	FT names the TX VFO     — FT0 = transmit on A, FT1 = transmit on B.
-	if !strings.HasPrefix(r, cmd) || len(r) < len(cmd)+1 {
+//
+// Split is on when the rig TRANSMITS on a different VFO from the one it is
+// LISTENING to. Reading FT1 as "split" is therefore only right for an operator
+// on VFO A: on SUB it is exactly inverted, which is why the same model behaved
+// correctly for one operator and backwards for another — one was on MAIN, the
+// other on SUB.
+func yaesuSplitFromReply(reply, cmd, vfo string) bool {
+	d := yaesuStateDigit(reply, cmd)
+	if d == 0 {
 		return false
 	}
-	return r[len(cmd)] == '1'
+	if cmd == "ST" {
+		return d == '1'
+	}
+	// FT: compare the transmit VFO with the one being listened to.
+	txOnB := d == '1'
+	rxOnB := strings.HasPrefix(strings.ToUpper(vfo), "B")
+	return txOnB != rxOnB
 }
 
 // resolveYaesuVFOs turns the two frequencies plus the VFO and split flags into
@@ -465,3 +505,25 @@ func yaesuModeDigit(mode string, freqHz int64) byte {
 		return 'C' // DATA-USB
 	}
 }
+
+// yaesuStateDigit returns the STATE digit of a reply — the FIRST digit after
+// the command — or 0 if the reply does not belong to this command.
+//
+// The parameter is not always one character: an FTDX101 answers "FR01;" where an
+// FTDX10 answers "FR0;". The state is the FIRST digit in both; the second is a
+// separate parameter. Reading the LAST digit inverted it — with RX and TX on
+// MAIN the rig answered FR01, OpsLog concluded SUB, the main frequency stopped
+// updating and a spot click tuned VFO B (F4NBZ, 2026-07-29). That was my own
+// correction of the previous evening, made the wrong way round: the earlier
+// "SUB shows MAIN" fault came from reading VS, not from this digit.
+func yaesuStateDigit(reply, cmd string) byte {
+	r := strings.TrimSpace(reply)
+	if !strings.HasPrefix(r, cmd) || len(r) <= len(cmd) {
+		return 0
+	}
+	d := r[len(cmd)]
+	if d < '0' || d > '9' {
+		return 0
+	}
+	return d
+}

internal/cat/yaesu_panel.go

@@ -397,12 +397,12 @@ func (y *Yaesu) SetYaesuSplit(on bool) error {
 		return y.SetYaesuSplitOffset(y.defaultSplitOffset())
 	}
 	y.mu.Lock()
-	cmd := y.splitCmd
+	cmd, vfo := y.splitCmd, y.curVFO
 	y.mu.Unlock()
 	if cmd == "" {
 		return fmt.Errorf("yaesu: this rig answered neither ST; nor FT; — split cannot be set")
 	}
-	return y.setAndRefresh(fmt.Sprintf("%s0;", cmd))
+	return y.setAndRefresh(yaesuSplitCommand(cmd, vfo, false))
 }
 
 // defaultSplitOffset is what SPLIT means on this mode: up 1 kHz on CW and the
@@ -662,7 +662,7 @@ func (y *Yaesu) SetYaesuSplitOffset(offsetHz int64) error {
 		return fmt.Errorf("yaesu: this rig answered neither ST; nor FT; — split cannot be set")
 	}
 	time.Sleep(30 * time.Millisecond)
-	if err := y.write(fmt.Sprintf("%s1;", y.splitCmd)); err != nil {
+	if err := y.write(yaesuSplitCommand(y.splitCmd, y.curVFO, true)); err != nil {
 		return err
 	}
 	y.panel.Split = true
@@ -808,3 +808,28 @@ func (m *meterPeak) update(sample int, now time.Time) int {
 	}
 	return m.val
 }
+
+// yaesuSplitCommand builds the command that turns split on or off.
+//
+// Writing is as asymmetric as reading. ST takes the state directly — ST1 is
+// split on. FT sets which VFO TRANSMITS, so "split on" means transmit on the
+// OTHER VFO from the one being listened to, and "split off" means transmit on
+// the same one. Sending FT1 for "on" regardless is right only for an operator on
+// VFO A; on SUB it would clear the split it was asked to set.
+func yaesuSplitCommand(cmd, vfo string, on bool) string {
+	if cmd == "ST" {
+		if on {
+			return "ST1;"
+		}
+		return "ST0;"
+	}
+	onSub := strings.HasPrefix(strings.ToUpper(vfo), "B")
+	txOnB := onSub // split off = transmit where we listen
+	if on {
+		txOnB = !onSub
+	}
+	if txOnB {
+		return cmd + "1;"
+	}
+	return cmd + "0;"
+}

internal/cat/yaesu_test.go

@@ -54,24 +54,46 @@ func TestResolveYaesuVFOs(t *testing.T) {
 	}
 }
 
-// ST and FT say different things and must not be read the same way — see the
+// ST and FT say different things, and reading them alike inverted the split
-// comment on yaesuSplitOn.
+// display on an FTDX101 (F4NBZ, 2026-07-29): the panel showed split ON with the
+// radio OFF and the reverse.
+//
+//	ST is a split FLAG   — ST1 means split, whatever VFO is in use.
+//	FT names the TX VFO  — FT0 = transmit on A, FT1 = transmit on B.
+//
+// Split is on when the rig transmits on a DIFFERENT VFO from the one it listens
+// to, so FT has to be compared with the current VFO. That is why the same model
+// behaved correctly for one operator and backwards for another: one was on MAIN,
+// the other on SUB.
 func TestYaesuSplitReply(t *testing.T) {
 	cases := []struct {
-		reply, cmd string
+		reply, cmd, vfo string
-		want       bool
+		want            bool
 	}{
-		{"ST1;", "ST", true},
+		// The flag is absolute.
-		{"ST0;", "ST", false},
+		{"ST1;", "ST", "A", true},
-		{"FT1;", "FT", true},
+		{"ST0;", "ST", "A", false},
-		{"FT0;", "FT", false},
+		{"ST1;", "ST", "B", true},
-		{"ST1;", "FT", false}, // reply for the other command — not accepted
+		{"ST0;", "ST", "B", false},
-		{"ST", "ST", false},   // truncated
+
-		{"", "ST", false},
+		// Listening on A: transmit on B is split, transmit on A is not.
+		{"FT1;", "FT", "A", true},
+		{"FT0;", "FT", "A", false},
+		// Listening on B: exactly the opposite — the reported inversion.
+		{"FT0;", "FT", "B", true},
+		{"FT1;", "FT", "B", false},
+		// The pair enums the Yaesus also report start with the listening VFO.
+		{"FT0;", "FT", "BA", true},
+		{"FT1;", "FT", "AB", true},
+
+		{"ST1;", "FT", "A", false}, // reply for the other command — not accepted
+		{"ST", "ST", "A", false},   // truncated
+		{"", "ST", "A", false},
 	}
 	for _, c := range cases {
-		if got := yaesuSplitOn(c.reply, c.cmd); got != c.want {
+		if got := yaesuSplitFromReply(c.reply, c.cmd, c.vfo); got != c.want {
-			t.Errorf("yaesuSplitOn(%q,%q) = %v, want %v", c.reply, c.cmd, got, c.want)
+			t.Errorf("yaesuSplitFromReply(%q, %q, vfo=%q) = %v, want %v",
+				c.reply, c.cmd, c.vfo, got, c.want)
 		}
 	}
 }
@@ -130,3 +152,158 @@ func TestYaesuCmdPrefix(t *testing.T) {
 		}
 	}
 }
+
+// Writing split is as asymmetric as reading it.
+//
+// ST takes the state directly. FT sets which VFO TRANSMITS, so "split on" means
+// transmit on the OTHER VFO from the one being listened to. Sending FT1 for "on"
+// regardless is right only on VFO A — on SUB it would CLEAR the split it was
+// asked to set, which is the same inversion that showed on the FTDX101 panel.
+func TestYaesuSplitCommand(t *testing.T) {
+	cases := []struct {
+		cmd, vfo string
+		on       bool
+		want     string
+	}{
+		{"ST", "A", true, "ST1;"},
+		{"ST", "B", true, "ST1;"}, // the flag does not care which VFO
+		{"ST", "B", false, "ST0;"},
+
+		// Listening on A: split means transmit on B.
+		{"FT", "A", true, "FT1;"},
+		{"FT", "A", false, "FT0;"},
+		// Listening on B: split means transmit on A — the reverse.
+		{"FT", "B", true, "FT0;"},
+		{"FT", "B", false, "FT1;"},
+		// Pair enums start with the listening VFO.
+		{"FT", "BA", true, "FT0;"},
+		{"FT", "AB", true, "FT1;"},
+	}
+	for _, c := range cases {
+		if got := yaesuSplitCommand(c.cmd, c.vfo, c.on); got != c.want {
+			t.Errorf("yaesuSplitCommand(%q, vfo=%q, on=%v) = %q, want %q",
+				c.cmd, c.vfo, c.on, got, c.want)
+		}
+	}
+}
+
+// Which VFO the operator is listening on, on a rig with separate RX and TX
+// selection.
+//
+// Reported on an FTDX101 (2026-07-29): moving RX alone to SUB displayed VFO B
+// correctly, but moving BOTH RX and TX to SUB displayed VFO A — the operator was
+// entirely on B and OpsLog showed the other one. FR reports the receive VFO; VS
+// does not answer that question on this rig.
+//
+// With FR read correctly the split follows too, since split is "transmit VFO
+// differs from receive VFO".
+func TestYaesuReceiveVFOAndSplit(t *testing.T) {
+	cases := []struct {
+		name      string
+		fr, ft    string // replies
+		wantVFO   string
+		wantSplit bool
+	}{
+		{"everything on main", "FR0;", "FT0;", "A", false},
+		{"RX on sub, TX still on main — split", "FR1;", "FT0;", "B", true},
+		{"RX and TX both on sub — NOT split", "FR1;", "FT1;", "B", false},
+		{"RX on main, TX on sub — split", "FR0;", "FT1;", "A", true},
+	}
+	for _, c := range cases {
+		vfo := "A"
+		if len(c.fr) >= 3 && c.fr[2] == '1' {
+			vfo = "B"
+		}
+		if vfo != c.wantVFO {
+			t.Errorf("%s: receive VFO = %s, want %s", c.name, vfo, c.wantVFO)
+		}
+		if got := yaesuSplitFromReply(c.ft, "FT", vfo); got != c.wantSplit {
+			t.Errorf("%s: split = %v, want %v", c.name, got, c.wantSplit)
+		}
+	}
+}
+
+// The state digit of a reply, when the parameter is not one character.
+//
+// An FTDX101 answers "FR01;" where an FTDX10 answers "FR0;". The state is the
+// FIRST digit on both — the second is a separate parameter.
+//
+// This test asserted the opposite for one evening. Reading the LAST digit turned
+// "FR01" into SUB, so an operator with RX and TX on MAIN saw the main frequency
+// freeze and a spot click tune VFO B (F4NBZ, 2026-07-29). The fault it was meant
+// to fix — "SUB shows MAIN" — came from reading VS, not from this digit, and the
+// FR probe alone had already fixed it.
+func TestYaesuStateDigit(t *testing.T) {
+	cases := []struct {
+		reply, cmd string
+		want       byte
+	}{
+		{"FR0;", "FR", '0'}, // FTDX10 form
+		{"FR1;", "FR", '1'},
+		{"FR01;", "FR", '0'}, // FTDX101 form: MAIN — the reported bug read this as SUB
+		{"FR11;", "FR", '1'}, // …and this is SUB
+		{"ST1;", "ST", '1'},
+		{"FT0;", "FT", '0'},
+		{"VS1;", "VS", '1'},
+		{"FR1", "FR", '1'}, // terminator already stripped
+
+		{"ST1;", "FR", 0}, // another command's reply is never accepted
+		{"FR;", "FR", 0},  // query echoed with no value
+		{"FRx;", "FR", 0}, // not a digit
+		{"", "FR", 0},
+	}
+	for _, c := range cases {
+		if got := yaesuStateDigit(c.reply, c.cmd); got != c.want {
+			t.Errorf("yaesuStateDigit(%q, %q) = %q, want %q", c.reply, c.cmd, got, c.want)
+		}
+	}
+
+	// End to end, both directions of the reported fault:
+	if d := yaesuStateDigit("FR01;", "FR"); d != '0' {
+		t.Fatalf("FR01 read as %q — the operator is on MAIN and must be seen there", d)
+	}
+	if d := yaesuStateDigit("FR11;", "FR"); d != '1' {
+		t.Fatalf("FR11 read as %q — the operator is on SUB", d)
+	}
+}
+
+// A spot click tunes the VFO the operator is ON, and the display reads that same
+// VFO. Both follow from the receive-VFO digit, which is why it is pinned here in
+// the operator's terms rather than only as a byte.
+//
+// Reported both ways round on an FTDX101 (F4NBZ, 2026-07-29): with RX and TX on
+// SUB everything worked, and with them on MAIN the frequency froze and a spot
+// clicked tuned the sub VFO.
+func TestYaesuActiveVFOFollowsReceiveVFO(t *testing.T) {
+	// Mirrors ReadState's choice of VFO and SetFrequency's choice of command.
+	activeVFO := func(frReply string) string {
+		if yaesuStateDigit(frReply, "FR") == '1' {
+			return "B"
+		}
+		return "A"
+	}
+	tuneCmd := func(vfo string) string {
+		if vfo == "B" {
+			return "FB" // sub
+		}
+		return "FA" // main
+	}
+
+	cases := []struct {
+		name, fr, wantVFO, wantCmd string
+	}{
+		{"RX and TX on MAIN (FTDX101 two-digit reply)", "FR01;", "A", "FA"},
+		{"RX and TX on SUB (FTDX101)", "FR11;", "B", "FB"},
+		{"MAIN on a one-digit rig", "FR0;", "A", "FA"},
+		{"SUB on a one-digit rig", "FR1;", "B", "FB"},
+	}
+	for _, c := range cases {
+		vfo := activeVFO(c.fr)
+		if vfo != c.wantVFO {
+			t.Errorf("%s: active VFO = %s, want %s", c.name, vfo, c.wantVFO)
+		}
+		if cmd := tuneCmd(vfo); cmd != c.wantCmd {
+			t.Errorf("%s: a spot click would write %s, want %s", c.name, cmd, c.wantCmd)
+		}
+	}
+}

internal/db/mysql.go

@@ -5,6 +5,7 @@ import (
 	"database/sql"
 	"errors"
 	"fmt"
+	"log"
 	"regexp"
 	"strings"
 	"time"
@@ -35,8 +36,14 @@ import (
 var (
 	reStrftimeDefault = regexp.MustCompile(`\(strftime\('%Y-%m-%dT%H:%M:%fZ',\s*'now'\)\)`)
 	reBareInteger     = regexp.MustCompile(`\bINTEGER\b`)
-	reColText         = regexp.MustCompile(`(\w+)\s+TEXT\b`)
+	// The column name may be bare or quoted. The SQLite baseline dump quotes its
-	reKeyColumn       = regexp.MustCompile(`(?m)^(\s*)key\b`)
+	// identifiers, and those double quotes are already BACKTICKS by the time this
+	// runs — so a pattern matching only a bare name left every column in the
+	// baseline as TEXT. That produced both "BLOB/TEXT column 'state' used in key
+	// specification without a key length" and "column 'op_name' can't have a
+	// default value" on a MySQL logbook, neither of which names the real cause.
+	reColText   = regexp.MustCompile("(`?)(\\w+)(`?)\\s+TEXT\\b")
+	reKeyColumn = regexp.MustCompile(`(?m)^(\s*)key\b`)
 	// SQLite quotes identifiers with double quotes — e.g. a table renamed by
 	// ALTER … RENAME TO ends up as CREATE TABLE "name" in sqlite_master. MySQL
 	// uses backticks. Our schema has no double-quoted string literals, so it's
@@ -103,27 +110,59 @@ func mysqlDDL(stmt string) string {
 // right MySQL type, deciding per line so it can see whether the line carries a
 // DEFAULT or an inline PRIMARY KEY. See varcharColumns / longTextColumns.
 func translateTextColumns(s string) string {
-	lines := strings.Split(s, "\n")
+	// EVERY column declaration is handled, wherever it sits.
-	for i, line := range lines {
+	//
-		m := reColText.FindStringSubmatchIndex(line)
+	// This used to work line by line and convert only the FIRST column on each
-		if m == nil {
+	// line. That is fine for our hand-written migrations, which put one column
-			continue
+	// per line, and wrong for the SQLite baseline: sqlite_master stores a table's
-		}
+	// CREATE statement with every ALTER-added column appended to the SAME line,
-		col := line[m[2]:m[3]]
+	// so on a real logbook only one of them was converted and MySQL rejected the
+	// rest — "column 'op_name' can't have a default value".
+	//
+	// Each match is also decided from ITS OWN declaration — the text between the
+	// surrounding commas — rather than from the whole line, so a DEFAULT
+	// belonging to a neighbouring column cannot decide this one's type.
+	out := make([]byte, 0, len(s)+64)
+	last := 0
+	for _, m := range reColText.FindAllStringSubmatchIndex(s, -1) {
+		openQ, col, closeQ := s[m[2]:m[3]], s[m[4]:m[5]], s[m[6]:m[7]]
+		decl := declarationAround(s, m[0], m[1])
 		var typ string
 		switch {
 		case longTextColumns[col] != "":
 			typ = longTextColumns[col]
 		case varcharColumns[col],
-			strings.Contains(line, "DEFAULT"),
+			strings.Contains(decl, "DEFAULT"),
-			strings.Contains(line, "PRIMARY KEY"):
+			strings.Contains(decl, "PRIMARY KEY"):
 			typ = "VARCHAR(255)"
 		default:
 			typ = "TEXT"
 		}
-		lines[i] = line[:m[0]] + col + " " + typ + line[m[1]:]
+		out = append(out, s[last:m[0]]...)
+		out = append(out, (openQ + col + closeQ + " " + typ)...)
+		last = m[1]
 	}
-	return strings.Join(lines, "\n")
+	return string(append(out, s[last:]...))
+}
+
+// declarationAround returns the single column declaration containing [start,end)
+// — the text between the commas, brackets or newlines either side.
+//
+// Types are decided from this rather than from the whole line because several
+// declarations share a line in the SQLite baseline, and a neighbour's DEFAULT
+// must not decide our column's type.
+func declarationAround(s string, start, end int) string {
+	from := strings.LastIndexAny(s[:start], ",(\n")
+	if from < 0 {
+		from = 0
+	}
+	to := strings.IndexAny(s[end:], ",)\n")
+	if to < 0 {
+		to = len(s)
+	} else {
+		to += end
+	}
+	return s[from:to]
 }
 
 // OpenMySQL opens the shared MySQL logbook, creating the database if needed,
@@ -200,7 +239,15 @@ func OpenMySQL(c MySQLConfig) (*sql.DB, error) {
 		// especially on a server with slow DDL.
 		err = applyMySQLBaseline(conn)
 	} else {
-		// Existing database: apply only the migrations it's missing.
+		// Existing database: repair any column that must be VARCHAR before the
+		// migrations run — an index on a TEXT column fails, and that failure
+		// otherwise repeats at every start with no way out from the UI.
+		if rerr := repairMySQLTextColumns(context.Background(), conn); rerr != nil {
+			_ = conn.Close()
+			Dialect = "sqlite"
+			return nil, rerr
+		}
+		// Then apply only the migrations it's missing.
 		err = migrate(conn, mysqlDDL, "", "mysql:"+name)
 	}
 	if err != nil {
@@ -534,3 +581,55 @@ func isIgnorableDDLError(err error) bool {
 	}
 	return false
 }
+
+// repairMySQLTextColumns converts columns that MUST be VARCHAR but are TEXT.
+//
+// Translating the schema correctly does not help a database that already exists.
+// A logbook created by an earlier version — or left half-built by a migration
+// that failed partway — keeps its TEXT columns, and every later run dies on the
+// same statement: "CREATE INDEX … ON qso(state)" → 1170, because MySQL cannot
+// index a TEXT column without a prefix length. The operator sees the connection
+// fail at startup, for ever, with no way forward from the UI.
+//
+// So the schema is repaired before the migrations run. Only the columns in
+// varcharColumns are touched — the ones that are indexed or part of a key — and
+// only when they are actually TEXT, so this is a no-op on a healthy database.
+func repairMySQLTextColumns(ctx context.Context, conn *sql.DB) error {
+	rows, err := conn.QueryContext(ctx, `
+		SELECT TABLE_NAME, COLUMN_NAME, IS_NULLABLE
+		  FROM information_schema.COLUMNS
+		 WHERE TABLE_SCHEMA = DATABASE()
+		   AND DATA_TYPE IN ('text','mediumtext','longtext')`)
+	if err != nil {
+		// Not fatal: a server that will not answer information_schema can still
+		// run a healthy schema, and failing here would block a working logbook.
+		return nil
+	}
+	type col struct{ table, name, nullable string }
+	var todo []col
+	for rows.Next() {
+		var c col
+		if err := rows.Scan(&c.table, &c.name, &c.nullable); err != nil {
+			break
+		}
+		if varcharColumns[c.name] {
+			todo = append(todo, c)
+		}
+	}
+	rows.Close()
+
+	for _, c := range todo {
+		null := "NULL"
+		if c.nullable == "NO" {
+			null = "NOT NULL"
+		}
+		stmt := fmt.Sprintf("ALTER TABLE `%s` MODIFY `%s` VARCHAR(255) %s", c.table, c.name, null)
+		if _, err := conn.ExecContext(ctx, stmt); err != nil {
+			// Report it: this is the difference between a logbook that opens and
+			// one that does not, so a failure here must not be silent.
+			return fmt.Errorf("repair %s.%s to VARCHAR: %w", c.table, c.name, err)
+		}
+		log.Printf("db[mysql]: repaired %s.%s TEXT → VARCHAR(255) (it is indexed)", c.table, c.name)
+	}
+	return nil
+}

internal/db/mysql_test.go

@@ -151,3 +151,102 @@ func TestMySQLDDL_NoLeftoverSQLiteisms(t *testing.T) {
 		}
 	}
 }
+
+// A QUOTED column declaration must be translated like a bare one.
+//
+// The SQLite baseline dump quotes its identifiers, and mysqlDDL turns those
+// double quotes into backticks before the TEXT rules run. The pattern only
+// matched a bare name, so every column in the baseline stayed TEXT — and MySQL
+// then refused the schema in two different ways, neither naming the real cause:
+//
+//	CREATE INDEX … ON qso(state)  → 1170 BLOB/TEXT column used in key
+//	                                specification without a key length
+//	op_name TEXT … DEFAULT ''     → 1101 TEXT column can't have a default value
+//
+// The operator saw only "MySQL is enabled but the connection failed at startup",
+// and fell back to the local SQLite database.
+func TestMySQLDDL_QuotedTextColumns(t *testing.T) {
+	cases := []struct {
+		name, in, wantHas string
+	}{
+		{
+			// An indexed column must become VARCHAR, quoted or not.
+			name:    "backticked indexed column",
+			in:      "CREATE TABLE qso (`state` TEXT);",
+			wantHas: "`state` VARCHAR(255)",
+		},
+		{
+			name:    "bare indexed column still works",
+			in:      "ALTER TABLE qso ADD COLUMN state              TEXT;",
+			wantHas: "state VARCHAR(255)",
+		},
+		{
+			// A default-bearing column must become VARCHAR, or MySQL rejects it.
+			name:    "double-quoted column with a default",
+			in:      `CREATE TABLE station_profiles ("op_name" TEXT NOT NULL DEFAULT '');`,
+			wantHas: "`op_name` VARCHAR(255)",
+		},
+		{
+			// And a plain unindexed column stays TEXT: VARCHAR everywhere would
+			// blow past MySQL's row-size limit, which is why the rule exists.
+			name:    "unindexed column stays TEXT",
+			in:      "CREATE TABLE qso (`comment` TEXT);",
+			wantHas: "`comment` TEXT",
+		},
+	}
+	for _, c := range cases {
+		got := mysqlDDL(c.in)
+		if !strings.Contains(got, c.wantHas) {
+			t.Errorf("%s:\n  in   %s\n  got  %s\n  want it to contain %q", c.name, c.in, got, c.wantHas)
+		}
+		// The quoting must survive: a lost backtick is a syntax error further on.
+		if strings.Count(got, "`")%2 != 0 {
+			t.Errorf("%s: unbalanced backticks in %s", c.name, got)
+		}
+	}
+}
+
+// A CREATE TABLE with several columns on ONE line — the shape sqlite_master
+// stores once columns have been added by ALTER TABLE.
+//
+// The old translation converted only the first column per line, so on a real
+// logbook the baseline kept most of its columns as TEXT and MySQL refused the
+// schema: "column 'op_name' can't have a default value". Our own migration files
+// hide this — they put one column per line — which is why it only ever appeared
+// against a database that had been through upgrades.
+func TestMySQLDDL_ManyColumnsOnOneLine(t *testing.T) {
+	in := "CREATE TABLE station_profiles (id INTEGER PRIMARY KEY, `name` TEXT, " +
+		"`op_name` TEXT NOT NULL DEFAULT '', `comment` TEXT, `state` TEXT);"
+	got := mysqlDDL(in)
+
+	// Default-bearing and indexed columns must be VARCHAR…
+	for _, want := range []string{"`op_name` VARCHAR(255)", "`state` VARCHAR(255)"} {
+		if !strings.Contains(got, want) {
+			t.Errorf("missing %q in:\n  %s", want, got)
+		}
+	}
+	// …while the plain ones stay TEXT, or the row-size limit is breached.
+	for _, want := range []string{"`name` TEXT", "`comment` TEXT"} {
+		if !strings.Contains(got, want) {
+			t.Errorf("missing %q in:\n  %s", want, got)
+		}
+	}
+	// No column may be left as a bare TEXT that carries a default.
+	if strings.Contains(got, "TEXT NOT NULL DEFAULT") {
+		t.Errorf("a TEXT column still carries a DEFAULT — MySQL rejects that:\n  %s", got)
+	}
+}
+
+// A neighbour's DEFAULT must not decide this column's type: deciding per LINE
+// made every column on a shared line VARCHAR as soon as one of them had a
+// default, which is how the row-size limit gets breached quietly.
+func TestMySQLDDL_DefaultDoesNotLeakAcrossColumns(t *testing.T) {
+	in := "CREATE TABLE t (`a` TEXT NOT NULL DEFAULT '', `b` TEXT);"
+	got := mysqlDDL(in)
+	if !strings.Contains(got, "`a` VARCHAR(255)") {
+		t.Errorf("the column WITH the default should be VARCHAR:\n  %s", got)
+	}
+	if !strings.Contains(got, "`b` TEXT") {
+		t.Errorf("the column without one should stay TEXT:\n  %s", got)
+	}
+}

internal/integrations/udp/server.go

@@ -4,6 +4,8 @@ import (
 	"context"
 	"fmt"
 	"net"
+	"regexp"
+	"strconv"
 	"strings"
 	"sync"
 	"syscall"
@@ -14,6 +16,14 @@ import (
 	"hamlog/internal/applog"
 )
 
+// remoteFreqRe / remoteModeRe pull the optional tune request out of a
+// ServiceRemoteCall packet: "<FREQ>10.136" (MHz) and "<MODE>FT8". Both accept
+// an optional closing tag for proper-XML senders.
+var (
+	remoteFreqRe = regexp.MustCompile(`(?i)<FREQ>\s*([0-9]+(?:\.[0-9]+)?)`)
+	remoteModeRe = regexp.MustCompile(`(?i)<MODE>\s*([A-Z0-9-]+)`)
+)
+
 // reusingListenConfig builds a net.ListenConfig that sets SO_REUSEADDR
 // (and SO_REUSEPORT on Unix) on the underlying socket before bind. This
 // is the only way for two processes to share a UDP port on Windows — Go
@@ -57,6 +67,13 @@ type Event struct {
 	// Call after previously reporting one — i.e. the operator cleared the call in
 	// the digital app. OpsLog clears its entry to match.
 	ClearCall bool
+
+	// TuneFreqHz / TuneMode carry an explicit "tune the radio" request embedded
+	// in a ServiceRemoteCall packet (DXHunter spot click sends
+	// "<CALLSIGN>VP5G<FREQ>10.136<MODE>FT8"). Zero/empty = no tune requested —
+	// the packet only fills the entry callsign, exactly as before.
+	TuneFreqHz int64
+	TuneMode   string
 }
 
 // Server is a single inbound UDP listener.
@@ -248,9 +265,25 @@ func (s *Server) handle(pkt []byte, remote *net.UDPAddr) {
 		//   "CALL F4XYZ"                  (text prefix)
 		//   "<CALLSIGN>F4XYZ<CALLSIGN>"   (DXHunter-style tags)
 		//   "<CALLSIGN>F4XYZ</CALLSIGN>"  (proper XML)
+		//   "<CALLSIGN>VP5G<FREQ>10.136<MODE>FT8"  (DXHunter with CAT tune)
 		// Strip every angle-bracket tag, normalise whitespace, take the
 		// last non-empty token. Upper-case for downstream consistency.
 		text := string(pkt)
+		// Optional tune request: <FREQ>MHz and <MODE>str ride along with the
+		// callsign so a DXHunter spot click can drive OpsLog's CAT. Extract
+		// (and cut) them BEFORE the generic tag-stripping below, which would
+		// otherwise leave their values as stray tokens and corrupt the
+		// "last token = callsign" heuristic.
+		if m := remoteFreqRe.FindStringSubmatch(text); m != nil {
+			if mhz, err := strconv.ParseFloat(m[1], 64); err == nil && mhz > 0 {
+				ev.TuneFreqHz = int64(mhz * 1e6)
+			}
+			text = strings.Replace(text, m[0], " ", 1)
+		}
+		if m := remoteModeRe.FindStringSubmatch(text); m != nil {
+			ev.TuneMode = strings.ToUpper(m[1])
+			text = strings.Replace(text, m[0], " ", 1)
+		}
 		// Drop every <...> tag (open or close) — works for both
 		// <CALLSIGN>...<CALLSIGN> and <CALLSIGN>...</CALLSIGN>.
 		for {
@@ -286,8 +319,9 @@ func (s *Server) handle(pkt []byte, remote *net.UDPAddr) {
 		return
 	}
 	// Empty events are useless; skip — EXCEPT a clear signal, which is meant to be
-	// empty (the DX Call was cleared in the digital app).
+	// empty (the DX Call was cleared in the digital app), and a tune-only
-	if ev.DXCall == "" && ev.LoggedADIF == "" && ev.DecodeCall == "" && !ev.ClearCall {
+	// request (freq with no callsign).
+	if ev.DXCall == "" && ev.LoggedADIF == "" && ev.DecodeCall == "" && !ev.ClearCall && ev.TuneFreqHz == 0 {
 		return
 	}
 	select {

qrz_confirm_test.go

@@ -0,0 +1,47 @@
+package main
+
+import (
+	"testing"
+
+	"hamlog/internal/adif"
+)
+
+// What counts as a QRZ.com confirmation.
+//
+// Reported 2026-07-29: after a confirmation download, every QSO turned to Y. The
+// test accepted qsl_rcvd = Y — but that is the operator's own PAPER QSL flag,
+// which they uploaded to QRZ themselves, so every QSO with a card came back
+// looking QRZ-confirmed. On a log full of paper QSLs that is most of it.
+//
+// This status feeds the award slots, so a false Y is a QSO counted as confirmed
+// when it is not — the reason the rule is narrow rather than generous.
+func TestQRZRecordConfirmed(t *testing.T) {
+	cases := []struct {
+		name string
+		rec  adif.Record
+		want bool
+	}{
+		// QRZ's own statements.
+		{"QRZ download status Y", adif.Record{"qrzcom_qso_download_status": "Y"}, true},
+		{"QRZ log status C", adif.Record{"app_qrzlog_status": "C"}, true},
+		{"lower case is still QRZ's answer", adif.Record{"app_qrzlog_status": "c"}, true},
+		{"padded", adif.Record{"app_qrzlog_status": " C "}, true},
+
+		// NOT confirmations by QRZ — the bug being fixed.
+		{"paper QSL received", adif.Record{"qsl_rcvd": "Y"}, false},
+		{"paper QSL plus a card sent", adif.Record{"qsl_rcvd": "Y", "qsl_sent": "Y"}, false},
+		{"LoTW confirmed, QRZ silent", adif.Record{"lotw_qsl_rcvd": "Y"}, false},
+		{"eQSL confirmed, QRZ silent", adif.Record{"eqsl_qsl_rcvd": "Y"}, false},
+
+		// Explicit negatives and nothing at all.
+		{"QRZ says no", adif.Record{"qrzcom_qso_download_status": "N"}, false},
+		{"QRZ status not confirmed", adif.Record{"app_qrzlog_status": "N"}, false},
+		{"bare record", adif.Record{"call": "F4XYZ"}, false},
+		{"empty", adif.Record{}, false},
+	}
+	for _, c := range cases {
+		if got := qrzRecordConfirmed(c.rec); got != c.want {
+			t.Errorf("%s: qrzRecordConfirmed = %v, want %v (%v)", c.name, got, c.want, c.rec)
+		}
+	}
+}