chore: release v0.26.12

Dragging a four-pixel slider to change the power by five watts is a fussy
gesture, and the Flex and Yaesu consoles have had the wheel for a while —
an operator moving between them expects it.

React registers onWheel as PASSIVE, so preventDefault() there is ignored
and the panel scrolls under the pointer while the value changes; the
listener is attached natively instead, with the live values read through
refs. Both existing panels solved it the same way, so this is a third
copy turned into one shared component -- used by the new console only.
The other two are left alone deliberately: they work, they are in daily
use, and their styling differs in ways a merge would have to guess at.

Power steps 5 W a notch, matching the K3's own coarse step.

app.go

@@ -312,6 +312,7 @@ const (
 	keyClusterSelfSpot    = "cluster.self_spot"         // "1" → announce ourselves on the cluster as we log
 	keyClusterSelfSpotMin = "cluster.self_spot_minutes" // shortest gap between two self-spots
 	keyClusterSpotTTL     = "cluster.spot_ttl_min"      // drop spots older than this; 0 = keep them
+	keyClusterSpotMax     = "cluster.spot_max"          // how many spots the list holds at once
 
 	keyScpEnabled = "scp.enabled" // Super Check Partial / N+1 suggestions on
 
@@ -782,6 +783,13 @@ type App struct {
 	// a still-running QRZ sync bleed its log into a freshly started LoTW download).
 	confDLMu       sync.Mutex
 	confDLCancel   context.CancelFunc
+
+	// hamlogUnmatched holds the confirmations the last HAMLOG.online import
+	// could not place onto a QSO, kept so they can be exported and worked
+	// through — see ExportHamlogUnmatched. Replaced by each import, never
+	// accumulated: it describes one run, not a history.
+	hamlogUnmatchedMu sync.Mutex
+	hamlogUnmatched   []qso.QSO
 	udpLogMu       sync.Mutex             // serialises UDP auto-log so concurrent packets can't both pass the dedup check
 	adifMonMu      sync.Mutex             // guards the ADIF-monitor config (file list + per-file read offsets)
 	syncMu         sync.Mutex             // serialises folder synchronisation: config, the seq counter, and the append to our own file
@@ -6503,6 +6511,21 @@ func (a *App) deleteRemoteCopies(ids []int64) {
 // withdrawals stop. Three is enough to tell a one-off from a blocked account.
 const maxClublogRefusals = 3
 
+// Club Log's delete endpoint is a REAL-TIME one: it exists for an operator
+// removing a contact they just logged wrongly, at human pace. Club Log watches
+// the rate and blocks the IP of anything that batches through it — they wrote
+// to this station about 167 requests in four minutes, which was one deletion of
+// a couple of hundred rows, not a pile-up.
+//
+// There is no bulk-delete API to move to, so the only honest answer is to go at
+// the pace the endpoint is meant for and to stop rather than push a large
+// deletion through it. Whoever needs to remove hundreds of QSOs from Club Log
+// does it on their site, where the tool for it exists.
+const (
+	clublogDeletePace = 1200 * time.Millisecond
+	maxClublogDeletes = 25
+)
+
 // clublogWasUploaded reports whether this QSO ever reached Club Log. "M"
 // (modified since upload) counts: the copy is there, it is merely out of date.
 func clublogWasUploaded(status string) bool {
@@ -6516,6 +6539,7 @@ func clublogWasUploaded(status string) bool {
 func (a *App) withdrawRemoteCopies(rows []qso.QSO, cfg extsvc.ExternalServices, doQRZ, doClublog bool) {
 	started := time.Now()
 	clublogRefused := 0
+	clublogSent := 0
 	for i := range rows {
 		q := rows[i]
 		id := q.ID
@@ -6546,6 +6570,17 @@ func (a *App) withdrawRemoteCopies(rows []qso.QSO, cfg extsvc.ExternalServices,
 		if doClublog && !clublogWasUploaded(q.ClublogUploadStatus) {
 			applog.Printf("extsvc: QSO %d (%s) was never uploaded to Club Log — nothing to withdraw", id, q.Callsign)
 		} else if doClublog {
+			if clublogSent >= maxClublogDeletes {
+				applog.Printf("extsvc: %d QSOs already withdrawn from Club Log — stopping there. Their delete endpoint is for one contact at a time; remove the rest on clublog.org, which has a tool for it.", clublogSent)
+				doClublog = false
+				continue
+			}
+			if clublogSent > 0 {
+				// Paced deliberately: see clublogDeletePace. This runs in the
+				// background, so the wait costs the operator nothing.
+				time.Sleep(clublogDeletePace)
+			}
+			clublogSent++
 			if msg, err := extsvc.DeleteClublog(a.ctx, nil, cfg.Clublog, q.Callsign, q.QSODate, q.Band); err != nil {
 				clublogRefused++
 				applog.Printf("extsvc: Club Log delete of QSO %d (%s) failed: %v", id, q.Callsign, err)
@@ -15133,6 +15168,9 @@ func (a *App) reloadCAT() {
 			// looking at the same signal, and only the click's origin differs.
 			a.FlexZoomForSpot(mode, hz)
 		}
+		// Spots posted by ANOTHER program — a CW skimmer, in practice. See
+		// flexrstchase.go: a marked report is where the DX was just listening.
+		fb.OnForeignSpot = a.handleForeignSpot
 		a.cat.Start(fb)
 	case "xiegu":
 		// Xiegu G90/X6100/X6200/X5105 — CI-V, but a REDUCED command set: no scope,
@@ -20257,6 +20295,50 @@ func (a *App) SetKenwoodKeySpeed(wpm int) error {
 // and exists only so a mistyped value cannot mean "never".
 const spotTTLMax = 720
 
+// The spot list is a ring buffer, and its size decided the lifetime far more
+// often than the lifetime setting did: on a busy evening a thousand spots
+// arrive in a couple of minutes, so a fifteen-minute lifetime never got the
+// chance to expire anything. Hence a setting.
+//
+// The ceiling is a real limit, not a round number. Every spot is matched against
+// the worked index and the alert rules, and each one is a row the cluster grid
+// and every open band map re-render; past ten thousand that work starts to show
+// on the very evenings the list is worth having.
+const (
+	spotMaxDefault = 1000
+	spotMaxCeiling = 10000
+	spotMaxFloor   = 100
+)
+
+// GetSpotMax returns how many spots the list holds.
+func (a *App) GetSpotMax() int {
+	n, _ := strconv.Atoi(a.settingOr(keyClusterSpotMax, ""))
+	if n <= 0 {
+		return spotMaxDefault
+	}
+	return clampSpotMax(n)
+}
+
+// SetSpotMax sets it. Clamped here as well as in the UI, for the same reason as
+// the lifetime: the value decides how much work arrives on every spot, and a
+// stale frontend must not be able to widen it past the ceiling.
+func (a *App) SetSpotMax(n int) error {
+	a.setSetting(keyClusterSpotMax, strconv.Itoa(clampSpotMax(n)))
+	return nil
+}
+
+func clampSpotMax(n int) int {
+	if n < spotMaxFloor {
+		return spotMaxFloor
+	}
+	if n > spotMaxCeiling {
+		return spotMaxCeiling
+	}
+	return n
+}
+
+
+
 // GetSpotTTLMinutes returns how long a spot stays in the list, in minutes.
 // 0 means spots are kept until the count cap pushes them out, which is what
 // OpsLog always did.

app_k3.go

@@ -0,0 +1,115 @@
+package main
+
+// Elecraft K3/K4 panel bindings.
+//
+// The controls the operator asked for and nothing else: power, volume, the
+// S-meter and SWR, MOX, and an ATU tune. A K3 exposes dozens of commands, but a
+// panel earns its place by covering what is reached for during a QSO — and each
+// one added without a radio to test it against is a control that may or may not
+// do what its label says. See internal/cat/kenwood_panel.go.
+
+import (
+	"fmt"
+
+	"hamlog/internal/cat"
+)
+
+// GetKenwoodState returns the K3/K4 panel snapshot. Zero value when the active
+// CAT backend is something else, which is how the UI knows to hide the panel.
+func (a *App) GetKenwoodState() cat.KenwoodTXState {
+	if a.cat == nil {
+		return cat.KenwoodTXState{}
+	}
+	st, _ := a.cat.KenwoodState()
+	return st
+}
+
+func (a *App) SetKenwoodPower(w int) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodPower(w) })
+}
+
+func (a *App) SetKenwoodAFGain(p int) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodAFGain(p) })
+}
+
+func (a *App) SetKenwoodRFGain(p int) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodRFGain(p) })
+}
+
+func (a *App) SetKenwoodMicGain(p int) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodMicGain(p) })
+}
+
+func (a *App) SetKenwoodSquelch(p int) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodSquelch(p) })
+}
+
+func (a *App) SetKenwoodPreamp(on bool) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodPreamp(on) })
+}
+
+func (a *App) SetKenwoodAtt(on bool) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodAtt(on) })
+}
+
+func (a *App) SetKenwoodNB(on bool) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodNB(on) })
+}
+
+func (a *App) SetKenwoodNR(on bool) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodNR(on) })
+}
+
+func (a *App) SetKenwoodAGC(name string) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodAGC(name) })
+}
+
+func (a *App) SetKenwoodFilter(hz int) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodFilter(hz) })
+}
+
+func (a *App) SetKenwoodAntenna(n int) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodAntenna(n) })
+}
+
+func (a *App) SetKenwoodRIT(on bool) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodRIT(on) })
+}
+
+func (a *App) SetKenwoodXIT(on bool) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodXIT(on) })
+}
+
+// ClearKenwoodRIT zeroes the RIT and XIT offsets together, which is what the
+// radio's own RC does and what an operator means by "clear it".
+func (a *App) ClearKenwoodRIT() error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.ClearKenwoodRIT() })
+}
+
+// SetKenwoodTX is the panel's MOX.
+func (a *App) SetKenwoodTX(on bool) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodTX(on) })
+}
+
+// ToggleKenwoodATU puts the tuner in line or bypasses it (the HOLD of the same
+// front-panel switch the tune uses).
+func (a *App) ToggleKenwoodATU() error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.ToggleKenwoodATU() })
+}
+
+func (a *App) TuneKenwoodATU() error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.TuneKenwoodATU() })
+}
+
+// RefreshKenwood re-reads the settings on the next poll — for when a knob was
+// turned on the radio itself.
+func (a *App) RefreshKenwood() error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.RefreshKenwood() })
+}
+
+func (a *App) kenwoodPanelDo(fn func(cat.KenwoodPanelController) error) error {
+	if a.cat == nil {
+		return fmt.Errorf("CAT not initialized")
+	}
+	return a.cat.KenwoodPanelDo(fn)
+}

changelog.json

@@ -1,4 +1,66 @@
 [
+  {
+    "version": "0.26.12",
+    "date": "",
+    "en": [
+      "When TQSL refuses an upload, the log now carries the exact ADIF record it was given and the station location it was told to sign with. 'No QSOs processed' covers several unrelated causes and the temp file is deleted the moment TQSL returns, so the one piece of evidence that mattered was the one nobody could see.",
+      "An Elecraft console for the K3/K4, in a tab of its own when the CAT backend is Elecraft or Kenwood: power, volume, RF and mic gain, squelch, preamp, attenuator, NB, NR, AGC, filter width, antenna, RIT/XIT with a clear, keyer speed, S-meter, SWR, MOX and an ATU tune. The meter scaling is marked provisional and the raw readings go to the log — it was written from the K3 Programmer's Reference without a radio to hand, and a wrongly scaled SWR bar reports a good match on a bad antenna.",
+      "Type a number in the callsign field and press Enter to move the radio: kHz for a frequency (28500 → 28.500 MHz), or a band on its own (20, 160, 6…). It is where the hands already are — reading a spot and reaching for the frequency box is what loses the station. Ambiguous numbers are read as bands, since 40 kHz and 160 kHz are nowhere anyone tunes.",
+      "Yaesu console: the mic gain is read and written on the rig's own 0-100 scale. It was treated as 0-255, so an FTDX101 set to 80 showed 38 and every attempt to move the slider was refused by the radio and sprang back.",
+      "Yaesu console: the power slider goes to 200 W on the models that make it (FTDX101MP and the like), and follows the radio if it ever reports more than expected. The slider, not the rig, was the 100 W limit.",
+      "Yaesu console: the NAR button (narrow IF filter) is shown only when the radio answers the command, and says what it is. A button that did nothing when pressed read as a fault in the rig.",
+      "The frequency readout now steps the Hz digits under the mouse wheel too, not just the kHz ones — 100, 10 and 1 Hz. Zero-beating a CW signal is a few tens of Hz, and it was the one move the display would not make.",
+      "The split-pile-up chaser only appears in CW: the marker comes from a skimmer decoding a report, so on SSB or FT8 there is nothing for it to chase.",
+      "Cluster: a single click now only fills the callsign, and a DOUBLE click works the spot — QSY, mode and the rest. Running down the list used to drag the radio along with every line looked at.",
+      "Cluster: how many spots the list keeps is now a setting (Preferences → Cluster, beside the spot lifetime). It was fixed at a thousand, and on a busy evening that fills in a couple of minutes — so the cap, not the lifetime, decided when a spot disappeared and a 15-minute lifetime never expired anything.",
+      "Elecraft console: the ATU tune sends the right switch. SWT19 is the ATU row in the K3 reference — TAP starts a tuning cycle, and a HOLD (the new ATU button) puts the tuner in line or bypasses it. It was written as SWT20, which is not an ATU switch at all. Power now takes the K3 range of 0-110 W.",
+      "Elecraft console: the mouse wheel moves the sliders, as it already did on the Flex and Yaesu consoles. Power steps 5 W a notch, the rest one unit."
+    ],
+    "fr": [
+      "Quand TQSL refuse un envoi, le journal contient désormais l'enregistrement ADIF exact qui lui a été remis et l'emplacement de station demandé pour la signature. « No QSOs processed » recouvre plusieurs causes sans rapport et le fichier temporaire est supprimé dès que TQSL rend la main : la seule pièce à conviction utile était justement invisible.",
+      "Une console Elecraft pour les K3/K4, dans un onglet dédié quand le CAT est réglé sur Elecraft ou Kenwood : puissance, volume, gain HF et micro, squelch, préampli, atténuateur, NB, NR, AGC, largeur de filtre, antenne, RIT/XIT avec effacement, vitesse du manipulateur, S-mètre, ROS, MOX et accord de l'ATU. L'échelle des mesures est signalée comme provisoire et les valeurs brutes partent dans le journal — la console a été écrite d'après le manuel de programmation du K3, sans radio sous la main, et une barre de ROS mal calibrée annonce un bon accord sur une mauvaise antenne.",
+      "Taper un nombre dans le champ indicatif puis Entrée déplace la radio : en kHz pour une fréquence (28500 → 28.500 MHz), ou une bande seule (20, 160, 6…). C'est là que sont déjà les mains — lire un spot puis aller chercher la case fréquence, c'est ce qui fait perdre la station. Les nombres ambigus sont lus comme des bandes : 40 kHz ou 160 kHz ne sont nulle part où l'on s'accorde.",
+      "Console Yaesu : le gain micro est lu et écrit sur l'échelle 0-100 de la radio. Il était traité en 0-255 : un FTDX101 réglé sur 80 affichait 38, et toute tentative de bouger le curseur était refusée par la radio et revenait en place.",
+      "Console Yaesu : le curseur de puissance monte à 200 W sur les modèles qui la sortent (FTDX101MP et consorts), et suit la radio si elle annonce davantage. C'était le curseur, pas la radio, qui plafonnait à 100 W.",
+      "Console Yaesu : le bouton NAR (filtre FI étroit) n'apparaît que si la radio répond à la commande, et indique ce qu'il fait. Un bouton sans effet passait pour une panne de la radio.",
+      "L'affichage de fréquence fait maintenant défiler aussi les chiffres des Hz à la molette, pas seulement ceux des kHz — 100, 10 et 1 Hz. Se caler au zéro-beat sur un signal CW se joue à quelques dizaines de Hz, et c'était le seul geste que l'affichage refusait.",
+      "Le chasseur de pile-up en split n'apparaît qu'en CW : le marqueur vient d'un skimmer qui décode un report, donc en SSB ou en FT8 il n'a rien à chasser.",
+      "Cluster : un clic simple ne remplit plus que l'indicatif, et le DOUBLE clic travaille le spot — QSY, mode et le reste. Parcourir la liste entraînait la radio à chaque ligne regardée.",
+      "Cluster : le nombre de spots conservés devient un réglage (Préférences → Cluster, à côté de la durée de vie). Il était fixé à mille, et un soir chargé remplit ça en quelques minutes — c'était donc le plafond, et non la durée de vie, qui décidait de la disparition d'un spot, et une durée de 15 minutes n'expirait jamais rien.",
+      "Console Elecraft : l'accord ATU envoie la bonne touche. SWT19 est la ligne ATU du manuel K3 — l'appui bref lance un cycle d'accord, et le maintien (nouveau bouton ATU) met la boîte en ligne ou la contourne. C'était écrit SWT20, qui n'est pas une touche d'ATU. La puissance suit la plage 0-110 W du K3.",
+      "Console Elecraft : la molette agit sur les curseurs, comme elle le faisait déjà sur les consoles Flex et Yaesu. La puissance avance de 5 W par cran, le reste d'une unité."
+    ]
+  },
+  {
+    "version": "0.26.11",
+    "date": "",
+    "en": [
+      "Withdrawing deleted QSOs from Club Log is now paced and capped at 25 per deletion. Their delete endpoint is a real-time one, meant for an operator removing a contact they just mis-logged; Club Log watches the rate and blocks the IP of anything that batches through it. Past the cap OpsLog stops and says so — there is no bulk-delete API, and hundreds of removals belong on clublog.org, which has a tool for it.",
+      "Auto-call, withdrawn earlier, is now disarmed where it was remembered: a stored 'enabled' is switched off and written back the first time OpsLog reads it. The running guard already stopped this build from calling anyone, but the stored flag survived — and any build without that guard would key the transmitter for a feature with no switch left to turn it off."
+    ],
+    "fr": [
+      "Le retrait des QSO supprimés chez Club Log est désormais cadencé et limité à 25 par suppression. Leur point d'entrée de suppression est temps réel, prévu pour un opérateur qui retire un contact qu'il vient de mal enregistrer ; Club Log surveille le rythme et bloque l'IP de ce qui passe des lots par là. Au-delà de la limite, OpsLog s'arrête et le dit — il n'existe pas d'API de suppression en masse, et des centaines de retraits se font sur clublog.org, qui a l'outil pour ça.",
+      "L'appel automatique, retiré précédemment, est maintenant désarmé là où il était mémorisé : un « activé » enregistré est éteint et réécrit dès la première lecture par OpsLog. Le garde-fou à l'exécution empêchait déjà cette version d'appeler qui que ce soit, mais l'indicateur enregistré survivait — et toute version sans ce garde-fou passait à l'émission pour une fonction dont il ne reste aucun interrupteur."
+    ]
+  },
+  {
+    "version": "0.26.10",
+    "date": "",
+    "en": [
+      "The HAMLOG.online confirmation import now fills the Results view with the contacts it confirmed, flagged new entity / band / mode / slot, and can export the unmatched ones as ADIF. Those are the interesting half: each is a contact their site holds and the log does not confirm — a minute of drift, a portable call, or a QSO genuinely missing.",
+      "Awards: 'county' joins the searchable QSO fields — the CNTY field as it stands. The existing 'us_county' keys the county to its state, which is right for the United States and wrong everywhere else: an RDA district or a Japanese city code is already unique.",
+      "*** FlexRadio: a split pile-up chaser. When a CW skimmer (SDC) marks a report on the panadapter, OpsLog moves the TRANSMIT slice there — where the DX was listening a second ago — plus a signed offset in Hz; the receive slice never moves. The button sits on the FlexRadio panel beside SPLIT, with the offset next to it. Right-click the button to set the marker text — it has to match what SDC is set to write (599 by default, several allowed), so it is edited where it is switched on rather than in a settings page.***",
+      "The radio's spot feed is now subscribed to even when OpsLog draws no spots of its own — that feed is how another program's spots arrive. Clearing the panadapter at connect still only happens when the overlay is OpsLog's: 'spot clear' removes every spot on the radio, a skimmer's included.",
+      "CW keyer: fixed Enter sending nothing on the Icom, Yaesu and Kenwood engines. Send-on-type only exists on the WinKeyer and Flex CWX, but the setting survived a change of engine — so the switch stayed on, invisibly, and the text field believed everything had already been keyed. Macros were unaffected, which is what made it puzzling."
+    ],
+    "fr": [
+      "L'import des confirmations HAMLOG.online alimente maintenant la vue Résultats avec les contacts confirmés, marqués nouvelle entité / bande / mode / slot, et peut exporter les non-rapprochés en ADIF. C'est la moitié intéressante : chacun est un contact que leur site détient et que le journal ne confirme pas — minute décalée, indicatif portable, ou QSO réellement absent.",
+      "Diplômes : « county » rejoint les champs de QSO interrogeables — le champ CNTY tel quel. Le « us_county » existant associe le comté à son État, ce qui est juste aux États-Unis et faux ailleurs : un district RDA ou un code de ville japonais est déjà unique.",
+      "*** FlexRadio : chasseur de pile-up en split. Quand un skimmer CW (SDC) marque un report sur le panadapter, OpsLog déplace la slice d'ÉMISSION dessus — là où le DX écoutait une seconde plus tôt — plus un décalage signé en Hz ; la slice de réception ne bouge jamais. Le bouton est sur le panneau FlexRadio à côté de SPLIT, avec le décalage juste à côté. Clic droit sur le bouton pour régler le texte du marqueur — il doit correspondre à ce que SDC est réglé à écrire (599 par défaut, plusieurs possibles), donc il se modifie là où on l'active plutôt que dans les réglages.***",
+      "Le flux de spots de la radio est désormais suivi même si OpsLog n'affiche aucun spot : c'est par lui qu'arrivent les spots des autres programmes. Le nettoyage du panadapter à la connexion reste réservé au cas où l'affichage est celui d'OpsLog : « spot clear » efface tous les spots de la radio, y compris ceux d'un skimmer.",
+      "Manipulateur CW : correction d'Entrée qui n'envoyait rien sur les moteurs Icom, Yaesu et Kenwood. L'émission au fil de la frappe n'existe que sur le WinKeyer et le Flex CWX, mais le réglage survivait à un changement de moteur — l'interrupteur restait donc actif, invisible, et le champ de texte croyait que tout avait déjà été émis. Les macros n'étaient pas touchées, ce qui rendait la chose incompréhensible."
+    ]
+  },
   {
     "version": "0.26.9",
     "date": "",

flexrstchase.go

@@ -0,0 +1,187 @@
+package main
+
+// Chasing a split pile-up by the report the DX just sent.
+//
+// Working a DXpedition in split means guessing where it is listening. The DX
+// answers one station, sends "5NN", and moves on; the useful information is
+// therefore not the callsign it answered but the FREQUENCY that callsign was
+// transmitting on, because the DX's receiver was there a second ago.
+//
+// A CW skimmer already knows this. SDC (Software Defined Connector) decodes the
+// whole pile-up and marks each report on the panadapter as a spot — the marker
+// TEXT is configured in SDC by the operator ("599" for a fresh report, "X" for
+// an older one, by default). Those spots reach OpsLog already: it subscribes to
+// the radio's spot feed, and every spot another program posts arrives on
+// Flex.OnForeignSpot.
+//
+// So the whole feature is: recognise the marker, move the TRANSMIT slice there,
+// leave the receive slice on the DX. Nothing here decodes anything.
+//
+// Three deliberate choices:
+//
+//   - the marker text is a SETTING, not a constant. It is chosen in SDC, and
+//     any guess made here would be wrong for the operator who chose otherwise.
+//   - only the transmit slice moves, never the receive slice. Losing the DX is
+//     a worse outcome than a missed call.
+//   - the offset is signed and in Hz, because working "up a bit" from where the
+//     last station was answered is exactly how a pile-up is chased.
+
+import (
+	"encoding/json"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"hamlog/internal/applog"
+	"hamlog/internal/cat"
+)
+
+const keyFlexRSTChase = "flex.rst_chase"
+
+// FlexRSTChase is the whole configuration.
+type FlexRSTChase struct {
+	Enabled bool `json:"enabled"`
+	// Markers are the skimmer's marker texts, comma-separated ("599,5NN").
+	// Matched against the spot's callsign field, case-insensitively and whole:
+	// a spot IS the marker or it is an ordinary callsign, and a substring rule
+	// would drag in any station whose call happens to contain the digits.
+	Markers string `json:"markers"`
+	// OffsetHz is added to the marker's frequency. Signed: chasing upward from
+	// the last station worked is the usual tactic, downward happens too.
+	OffsetHz int `json:"offset_hz"`
+	// SplitOnly refuses to act when the radio is not in split. On by default:
+	// out of split the transmit slice IS the receive slice, so "move the TX
+	// slice" would take the operator off the DX they are listening to.
+	SplitOnly bool `json:"split_only"`
+}
+
+var defaultFlexRSTChase = FlexRSTChase{Enabled: false, Markers: "599", OffsetHz: 0, SplitOnly: true}
+
+// rstChaseMinGap throttles the moves. A skimmer marks every report it decodes,
+// and a busy pile-up produces several a second; without a floor the transmit
+// slice would twitch continuously and never be anywhere long enough to call.
+const rstChaseMinGap = 700 * time.Millisecond
+
+// rstChaseMinStep ignores a marker that lands where the slice already is.
+// Re-sending the same frequency is not free: it is a command to the radio and a
+// slice status back, several times a second, for no change at all.
+const rstChaseMinStep = 20 // Hz
+
+var (
+	rstChaseMu   sync.Mutex
+	rstChaseLast time.Time
+	rstChaseFreq int64
+)
+
+// GetFlexRSTChase returns the stored configuration (defaults when unset).
+func (a *App) GetFlexRSTChase() FlexRSTChase {
+	s := defaultFlexRSTChase
+	if a.settings == nil {
+		return s
+	}
+	// settingOr, NOT settings.Get with profileScope(): the store already applies
+	// the active profile's prefix, so scoping the key here wrote p3.flex.rst_chase
+	// and read p3.p3.flex.rst_chase — the switch could never be read back on, and
+	// the feature did nothing at all with no sign of why.
+	if v := a.settingOr(keyFlexRSTChase, ""); strings.TrimSpace(v) != "" {
+		_ = json.Unmarshal([]byte(v), &s)
+	}
+	return normRSTChase(s)
+}
+
+// SaveFlexRSTChase stores the configuration.
+func (a *App) SaveFlexRSTChase(s FlexRSTChase) error {
+	b, err := json.Marshal(normRSTChase(s))
+	if err != nil {
+		return err
+	}
+	a.setSetting(keyFlexRSTChase, string(b))
+	return nil
+}
+
+// SetFlexRSTChaseEnabled flips the switch alone.
+//
+// Its own binding because this belongs on a button in the panel, not in a
+// settings page: it is turned on when a DXpedition appears and off when it is
+// worked, which is a thing done mid-QSO with one hand.
+func (a *App) SetFlexRSTChaseEnabled(on bool) error {
+	s := a.GetFlexRSTChase()
+	s.Enabled = on
+	return a.SaveFlexRSTChase(s)
+}
+
+func normRSTChase(s FlexRSTChase) FlexRSTChase {
+	if strings.TrimSpace(s.Markers) == "" {
+		s.Markers = defaultFlexRSTChase.Markers
+	}
+	// A pile-up is a few kHz wide. Anything past that is a typo (Hz entered as
+	// if it were kHz), and honouring it would transmit far outside the segment.
+	if s.OffsetHz > 10000 {
+		s.OffsetHz = 10000
+	}
+	if s.OffsetHz < -10000 {
+		s.OffsetHz = -10000
+	}
+	return s
+}
+
+// rstChaseMarkerSet splits the configured markers into a comparison set.
+func rstChaseMarkerSet(markers string) map[string]bool {
+	out := map[string]bool{}
+	for _, m := range strings.FieldsFunc(markers, func(r rune) bool { return r == ',' || r == ';' || r == ' ' }) {
+		if m = strings.ToUpper(strings.TrimSpace(m)); m != "" {
+			out[m] = true
+		}
+	}
+	return out
+}
+
+// handleForeignSpot is what a skimmer's spot arrives at.
+func (a *App) handleForeignSpot(callsign string, freqHz int64) {
+	cfg := a.GetFlexRSTChase()
+	if !cfg.Enabled || a.cat == nil {
+		return
+	}
+	if !rstChaseMarkerSet(cfg.Markers)[strings.ToUpper(strings.TrimSpace(callsign))] {
+		return // an ordinary spot: another station's callsign, not a report
+	}
+	// From here on every refusal is logged. A marker WAS recognised, so the
+	// operator is entitled to know why the slice stayed where it was — silence
+	// at this point is indistinguishable from a feature that does not work.
+	if cfg.SplitOnly && !a.cat.State().Split {
+		applog.Printf("rst chase: %s marked at %s, but the radio is not in split — ignored",
+			strings.ToUpper(callsign), hzText(freqHz))
+		return
+	}
+	target := freqHz + int64(cfg.OffsetHz)
+	if target <= 0 {
+		return
+	}
+	now := time.Now()
+	rstChaseMu.Lock()
+	if now.Sub(rstChaseLast) < rstChaseMinGap {
+		rstChaseMu.Unlock()
+		return
+	}
+	if rstChaseFreq != 0 && absInt64(target-rstChaseFreq) < rstChaseMinStep {
+		rstChaseMu.Unlock()
+		return
+	}
+	rstChaseLast, rstChaseFreq = now, target
+	rstChaseMu.Unlock()
+
+	if err := a.cat.FlexDo(func(fc cat.FlexController) error {
+		return fc.SetTXSliceFrequency(target)
+	}); err != nil {
+		applog.Printf("rst chase: moving the TX slice to %s failed: %v", hzText(target), err)
+		return
+	}
+	applog.Printf("rst chase: %s marked at %s → TX slice to %s (offset %+d Hz)",
+		strings.ToUpper(callsign), hzText(freqHz), hzText(target), cfg.OffsetHz)
+}
+
+// hzText renders a frequency the way an operator reads one on a dial.
+func hzText(hz int64) string {
+	return strconv.FormatFloat(float64(hz)/1000, 'f', 3, 64) + " kHz"
+}

frontend/src/App.tsx

@@ -78,6 +78,7 @@ import { WorldMap, LocatorMap } from '@/components/MainMap';
 import { FlexPanel } from '@/components/FlexPanel';
 import { IcomPanel } from '@/components/IcomPanel';
 import { YaesuPanel } from '@/components/YaesuPanel';
+import { ElecraftPanel } from '@/components/ElecraftPanel';
 import { AntGeniusPanel, type AGStatus } from '@/components/AntGeniusPanel';
 import { MotorAntennaWidget, type AntStatus } from '@/components/MotorAntennaWidget';
 import { TunerGeniusPanel, type TGStatus } from '@/components/TunerGeniusPanel';
@@ -94,7 +95,7 @@ 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 { AnswerDecode, HaltDecodeTx, LogUIError, FlexTXOnBand, GetMatrixColors, GetRotorPresets, GetRowColors, GetSpotTTLMinutes, IsNewUSCounty } from '../wailsjs/go/main/App';
+import { AnswerDecode, HaltDecodeTx, LogUIError, FlexTXOnBand, GetMatrixColors, GetRotorPresets, GetRowColors, GetSpotTTLMinutes, GetSpotMax, IsNewUSCounty } from '../wailsjs/go/main/App';
 import { applyMatrixColors } from '@/lib/matrixColors';
 import { WorkedBeforeGrid } from '@/components/WorkedBeforeGrid';
 import { NetControlPanel } from '@/components/NetControlPanel';
@@ -243,10 +244,15 @@ function fmtFreqDots(mhzStr: string): string {
 }
 
 // FreqWheelDisplay renders a frequency (MHz string) like fmtFreqDots — MHz.kHz.Hz
-// — but makes the three kHz digits scroll-sensitive: rolling the mouse wheel over
-// the hundreds / tens / units-of-kHz digit steps the frequency by 100 / 10 / 1 kHz
-// (up = wheel up). onNudge receives the delta in Hz. The MHz and Hz digits are
-// static (only kHz stepping was requested). Used in the header + compact top bar.
+// — and makes the kHz AND Hz digits scroll-sensitive: rolling the wheel over a
+// digit steps the frequency by that digit (100/10/1 kHz, then 100/10/1 Hz; up =
+// wheel up). onNudge receives the delta in Hz.
+//
+// The Hz digits were static at first, on the grounds that only kHz stepping had
+// been asked for. An FTDX101 operator put it plainly: the fine tuning is exactly
+// what a mouse is wanted for — zero-beating a CW signal or nudging onto an SSB
+// voice is a few tens of Hz, and it was the one move the display would not make.
+// The MHz digits stay static: a wheel notch that changes band is not fine tuning.
 function FreqWheelDisplay({ mhz, onNudge, className, placeholder = '—.———.———' }: {
   mhz: string; onNudge: (deltaHz: number) => void; className?: string; placeholder?: string;
 }) {
@@ -256,6 +262,7 @@ function FreqWheelDisplay({ mhz, onNudge, className, placeholder = '—.——
   const khz = frac.slice(0, 3); // [hundreds, tens, units] of kHz
   const hz = frac.slice(3, 6);
   const stepHz = [100_000, 10_000, 1_000]; // per kHz digit: 100 / 10 / 1 kHz
+  const stepHzFine = [100, 10, 1];         // per Hz digit
   return (
     <span className={className}>
       {intPart}.
@@ -267,7 +274,15 @@ function FreqWheelDisplay({ mhz, onNudge, className, placeholder = '—.——
           {d}
         </span>
       ))}
-      .{hz}
+      .
+      {hz.split('').map((d, i) => (
+        <span key={'h' + i}
+          onWheel={(e) => { if (e.ctrlKey || e.metaKey) return; e.preventDefault(); e.stopPropagation(); onNudge(e.deltaY < 0 ? stepHzFine[i] : -stepHzFine[i]); }}
+          className="cursor-ns-resize rounded-[2px] hover:bg-primary/25 transition-colors"
+          title="Scroll to change frequency">
+          {d}
+        </span>
+      ))}
     </span>
   );
 }
@@ -291,6 +306,37 @@ function shortCatError(err?: string): string {
 }
 // bandForMHz maps a dial frequency (MHz) to its ADIF band, or '' if outside
 // every known allocation (used to auto-fill the band when the freq changes).
+// A number typed into the CALLSIGN field is a QSY, not a callsign.
+//
+// It is where the hands already are: an operator watching a cluster or a
+// spotting page reads "28500" and wants to be there, and reaching for the
+// frequency box — or worse, the mouse — is the part that loses the station. So
+// the call field takes it, on Enter, and nothing else in the entry form changes.
+//
+// Two forms, and the AMBIGUOUS ones resolve to the band deliberately. "160" is
+// the 160 m band, not 160 kHz; "40" is 40 m, not 40 kHz. Neither number is a
+// frequency anyone tunes to, so reading them as bands costs nothing and reads
+// the way an operator says it out loud.
+const ENTRY_BAND_WORDS: Record<string, string> = {
+  '2200': '2200m', '630': '630m', '160': '160m', '80': '80m', '60': '60m',
+  '40': '40m', '30': '30m', '20': '20m', '17': '17m', '15': '15m', '12': '12m',
+  '10': '10m', '6': '6m', '4': '4m', '2': '2m', '70': '70cm',
+};
+
+// entryQSYCommand reads what was typed. Returns null for anything that is not
+// unambiguously one of the two — a callsign must never be mistaken for a QSY.
+function entryQSYCommand(text: string): { band?: string; hz?: number } | null {
+  const v = text.trim();
+  if (!/^\d{1,7}$/.test(v)) return null; // digits only: a callsign has letters
+  const band = ENTRY_BAND_WORDS[v];
+  if (band) return { band };
+  const khz = Number(v);
+  // 1500 kHz to 1.3 GHz: below that is not a band anyone works, above it is a
+  // typo. A bare "500" is neither a band nor a frequency, so nothing happens.
+  if (khz >= 1500 && khz <= 1_300_000) return { hz: Math.round(khz * 1000) };
+  return null;
+}
+
 function bandForMHz(mhz: number): string {
   if (!mhz || isNaN(mhz)) return '';
   const plan: [number, number, string][] = [
@@ -701,6 +747,7 @@ export default function App() {
     '15m':  { SSB: 21300000, CW: 21030000, FT8: 21074000, FT4: 21140000, RTTY: 21080000, default: 21300000 },
     '12m':  { SSB: 24950000, CW: 24910000, FT8: 24915000, FT4: 24919000, RTTY: 24920000, default: 24950000 },
     '10m':  { SSB: 28500000, CW: 28030000, FT8: 28074000, FT4: 28180000, RTTY: 28080000, default: 28500000 },
+    '4m':   { SSB: 70200000, CW: 70100000, FT8: 70154000,                               default: 70200000 },
     '6m':   { SSB: 50150000, CW: 50080000, FT8: 50313000, FT4: 50318000,                default: 50150000 },
     '2m':   { SSB: 144300000, CW: 144050000, FT8: 144174000,                            default: 144300000 },
     '70cm': { SSB: 432300000, CW: 432050000, FT8: 432174000,                            default: 432300000 },
@@ -1616,7 +1663,14 @@ export default function App() {
   const [clusterServers, setClusterServers] = useState<{ id: number; name: string; enabled: boolean; sort_order: number }[]>([]);
   // Ring buffer — only keep the last N spots; cluster firehose can be heavy.
   const [spots, setSpots] = useState<ClusterSpot[]>([]);
-  const SPOTS_CAP = 1000;
+  // How many spots the list holds. A setting rather than a constant: at a
+  // thousand, a busy evening filled the buffer in a couple of minutes, so the
+  // spot LIFETIME never had anything left to expire — the cap was deciding the
+  // lifetime. Kept in a ref as well: the append path runs inside a state updater
+  // that must not close over a stale value.
+  const [spotsCap, setSpotsCap] = useState(1000);
+  const spotsCapRef = useRef(1000);
+  useEffect(() => { spotsCapRef.current = spotsCap; }, [spotsCap]);
   // Cluster filter selections persist across restarts (writeUiPref → localStorage
   // + DB, so they also travel with a copied data/ folder). Loaders read the cache
   // synchronously at first render; a single effect below writes them back.
@@ -1861,7 +1915,7 @@ export default function App() {
   // so it's loaded async on mount and re-read on profile:changed below.
   // 'none' is only ever stored for the third and fourth panes: the first two are
   // the Main view, and a layout with no panes at all is not a layout.
-  type MainPaneKind = 'map1' | 'map2' | 'cluster' | 'worked' | 'flex' | 'recent' | 'icom' | 'yaesu' | 'netcontrol' | 'decodes' | 'none';
+  type MainPaneKind = 'map1' | 'map2' | 'cluster' | 'worked' | 'flex' | 'recent' | 'icom' | 'yaesu' | 'elecraft' | 'netcontrol' | 'decodes' | 'none';
   const [mapZoomSignal, setMapZoomSignal] = useState(0); // bump → world map auto-zooms now
   const [mainPaneLeft, setMainPaneLeft] = useState<MainPaneKind>('map1');
   const [mainPaneRight, setMainPaneRight] = useState<MainPaneKind>('map2');
@@ -1872,7 +1926,7 @@ export default function App() {
   // quarter-width map is unreadable.
   const [mainLayout4, setMainLayout4] = useState<'cols' | 'quad'>('quad');
   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' || v === 'decodes';
+    const valid = (v: string): v is MainPaneKind => v === 'map1' || v === 'map2' || v === 'cluster' || v === 'worked' || v === 'flex' || v === 'recent' || v === 'icom' || v === 'yaesu' || v === 'elecraft' || v === 'netcontrol' || v === 'decodes';
     const [l, r, p3, p4, lay] = await Promise.all([
       GetUIPref('mainPaneLeft').catch(() => ''),
       GetUIPref('mainPaneRight').catch(() => ''),
@@ -1930,7 +1984,7 @@ export default function App() {
   useEffect(() => {
     setSpotStatus((prev) => {
       const keys = Object.keys(prev);
-      if (keys.length <= SPOTS_CAP * 2) return prev;
+      if (keys.length <= spotsCapRef.current * 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
@@ -2441,6 +2495,9 @@ export default function App() {
   // same thing everywhere — and it gives the memory back.
   const [spotTTLMin, setSpotTTLMin] = useState(0);
   useEffect(() => { GetSpotTTLMinutes().then(setSpotTTLMin).catch(() => {}); }, [showSettings]);
+  // Same beat as the lifetime: re-read when Preferences closes, since the two
+  // settings decide between them how long a spot survives.
+  useEffect(() => { GetSpotMax().then((n: number) => { if (n > 0) setSpotsCap(n); }).catch(() => {}); }, [showSettings]);
   useEffect(() => {
     if (spotTTLMin <= 0) return; // 0 = keep until the count cap pushes them out
     const sweep = () => {
@@ -3112,6 +3169,19 @@ export default function App() {
   // Clicking a spot (cluster grid or any band map): tune the rig, set the mode,
   // fill the call, pre-fill POTA, (re)start the recording. Shared so every spot
   // source behaves identically.
+  // Single click on a cluster line: fill the callsign, nothing else.
+  //
+  // Reading the cluster means running down dozens of lines, and while a single
+  // click WORKED the spot every pass dragged the radio with it — one stray click
+  // while looking took the operator off the station they were working. Looking
+  // and going are two different intentions, so they are now two gestures: click
+  // to look the call up, double-click to go there.
+  function handleSpotSelect(s: any) {
+    if (!s?.dx_call?.trim()) return;
+    onCallsignInput(s.dx_call, { force: true });
+    applySpotPOTA((s as any).pota_ref);
+  }
+
   function handleSpotClick(s: any) {
     const m = inferSpotMode(s.comment ?? '', s.freq_hz);
     // Reflect the spot's freq/band in the entry strip IMMEDIATELY (optimistic),
@@ -3418,7 +3488,8 @@ export default function App() {
           const filtered = hist(sp) ? next : next.filter((x) => hist(x) || key(x) !== k);
           next = [sp, ...filtered];
         }
-        return next.length > SPOTS_CAP ? next.slice(0, SPOTS_CAP) : next;
+        const cap = spotsCapRef.current;
+        return next.length > cap ? next.slice(0, cap) : next;
       });
     };
     const unsubSpot = EventsOn('cluster:spot', (sp: ClusterSpot) => {
@@ -5468,6 +5539,25 @@ export default function App() {
     noteManualEdit();
     SetCATFrequency(Math.round(mhz * 1_000_000)).catch(() => {});
   };
+  // Carry out what was typed in the call field. Bands go through the ordinary
+  // band change, so the antennas, the power table and the outbound integrations
+  // all hear about it exactly as they would from the dropdown.
+  const applyEntryQSY = (q: { band?: string; hz?: number }) => {
+    if (q.band) {
+      onBandUserChange(q.band);
+      showToast(q.band);
+      return;
+    }
+    const hz = q.hz ?? 0;
+    if (hz <= 0) return;
+    noteManualEdit();
+    setFreqMhz((hz / 1_000_000).toFixed(6));
+    const b = bandForMHz(hz / 1_000_000);
+    if (b) setBand(b);
+    if (catState.enabled && catState.connected) SetCATFrequency(hz).catch(() => {});
+    showToast((hz / 1_000_000).toFixed(3) + ' MHz');
+  };
+
   // Mouse-wheel over a kHz digit of the top frequency readout: step the frequency
   // and (if CAT is connected) QSY the rig. The display updates optimistically on
   // every notch; the actual radio tune is debounced so a fast scroll doesn't flood
@@ -6008,7 +6098,7 @@ export default function App() {
             </div>
             <div className="flex-1 min-h-0 flex">
               <div className="flex-1 min-w-0 flex flex-col min-h-0">
-                <ClusterGrid key={`clg-${activeProfileId ?? 'x'}`} rows={clusterRenderedRows as any} spotStatus={spotStatus} onSpotClick={handleSpotClick} />
+                <ClusterGrid key={`clg-${activeProfileId ?? 'x'}`} rows={clusterRenderedRows as any} spotStatus={spotStatus} onSpotClick={handleSpotClick} onSpotSelect={handleSpotSelect} />
               </div>
               {clusterShowFilters && renderClusterFilters()}
             </div>
@@ -6037,6 +6127,12 @@ export default function App() {
             <YaesuPanel onReportRST={(r) => { setRstSent(r); rstUserEditedRef.current = true; }} onKeySpeed={setCWSpeedEverywhere} />
           </div>
         );
+      case 'elecraft':
+        return (
+          <div className="h-full w-full min-h-0 rounded-lg overflow-hidden border border-border">
+            <ElecraftPanel onReportRST={(r) => { setRstSent(r); rstUserEditedRef.current = true; }} />
+          </div>
+        );
       case 'icom':
         return (
           <div className="h-full w-full min-h-0 rounded-lg overflow-hidden border border-border">
@@ -6828,6 +6924,16 @@ export default function App() {
         onKeyDown={(e) => {
           if (e.key === 'Enter' && (e.target as HTMLElement).tagName === 'INPUT') {
             e.preventDefault();
+            // A number in the call field is a QSY. Checked BEFORE ESM and before
+            // logging: both would otherwise act on a "callsign" of 28500.
+            if (e.target === callsignRef.current) {
+              const q = entryQSYCommand(callsignRef.current?.value ?? '');
+              if (q) {
+                applyEntryQSY(q);
+                setCallsign(''); // the field goes back to what it is for
+                return;
+              }
+            }
             // ESM (Enter Sends Message): fire the stage-appropriate CW macro instead
             // of logging. Falls through to the normal log when ESM isn't active.
             if (esmHandleEnter(e.target as HTMLElement)) return;
@@ -7303,6 +7409,7 @@ export default function App() {
               {catState.backend === 'flex' && <TabsTrigger value="flex">Flex Console</TabsTrigger>}
               {catState.backend === 'icom' && <TabsTrigger value="icom">Icom Console</TabsTrigger>}
               {catState.backend === 'yaesu' && <TabsTrigger value="yaesu">Yaesu Console</TabsTrigger>}
+            {(catState.backend === 'elecraft' || catState.backend === 'kenwood') && <TabsTrigger value="elecraft">{t('k3.console')}</TabsTrigger>}
               {statsTabOpen && (
                 <TabsTrigger value="stats" className="gap-1.5">
                   {t('stats.tab')}
@@ -7669,6 +7776,7 @@ export default function App() {
                     rows={rendered as any}
                     spotStatus={spotStatus}
                     onSpotClick={handleSpotClick}
+                    onSpotSelect={handleSpotSelect}
                   />
                 );
               })()}
@@ -7982,6 +8090,14 @@ export default function App() {
               </TabsContent>
             )}
 
+            {/* Elecraft K3/K4 console. Shown for the Kenwood backend too: the
+                K3 speaks that dialect and the panel reads whatever answers. */}
+            {(catState.backend === 'elecraft' || catState.backend === 'kenwood') && (
+              <TabsContent value="elecraft" className="flex-1 min-h-0 p-0">
+                <ElecraftPanel onReportRST={(r) => { setRstSent(r); rstUserEditedRef.current = true; }} />
+              </TabsContent>
+            )}
+
             {catState.backend === 'icom' && (
               <TabsContent value="icom" className="flex-1 min-h-0 p-0">
                 <IcomPanel isNetwork={catBackend === 'icom-net'} onReportRST={(r) => { setRstSent(r); rstUserEditedRef.current = true; }} />

frontend/src/components/ClusterGrid.tsx

@@ -1,7 +1,7 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import {
   AllCommunityModule, ModuleRegistry,
-  type ColDef, type ColumnState, type GridReadyEvent, type RowClickedEvent,
+  type ColDef, type ColumnState, type GridReadyEvent, type RowClickedEvent, type RowDoubleClickedEvent,
 } from 'ag-grid-community';
 import { hamlogGridTheme } from '@/lib/gridTheme';
 import { AgGridReact } from 'ag-grid-react';
@@ -75,7 +75,13 @@ export type SpotStatusEntry = {
 type Props = {
   rows: ClusterSpot[];
   spotStatus: Record<string, SpotStatusEntry>;
+  // A DOUBLE click works the spot: QSY, mode, callsign, the lot.
   onSpotClick?: (s: ClusterSpot) => void;
+  // A SINGLE click only fills the callsign. Reading the cluster means passing
+  // over dozens of lines, and every pass used to drag the radio with it — one
+  // stray click while looking took the operator off the station they were
+  // working. Looking and going are now two different gestures.
+  onSpotSelect?: (s: ClusterSpot) => void;
 };
 
 const COL_STATE_KEY = 'hamlog.clusterColState.v1';
@@ -500,7 +506,7 @@ const GROUP_ORDER = ['Spot', 'Geo'];
 const CLG_GRP_KEYS: Record<string, string> = { Spot: 'clg2.grpSpot', Geo: 'clg2.grpGeo' };
 const groupLabel = (t: TFn, g: string): string => t(CLG_GRP_KEYS[g] ?? g);
 
-export function ClusterGrid({ rows, spotStatus, onSpotClick }: Props) {
+export function ClusterGrid({ rows, spotStatus, onSpotClick, onSpotSelect }: Props) {
   const { t } = useI18n();
   const gridRef = useRef<any>(null);
   const [pickerOpen, setPickerOpen] = useState(false);
@@ -583,6 +589,10 @@ export function ClusterGrid({ rows, spotStatus, onSpotClick }: Props) {
   }, []);
 
   function handleRowClicked(e: RowClickedEvent<ClusterSpot>) {
+    if (e.data && onSpotSelect) onSpotSelect(e.data);
+  }
+
+  function handleRowDoubleClicked(e: RowDoubleClickedEvent<ClusterSpot>) {
     if (e.data && onSpotClick) onSpotClick(e.data);
   }
 
@@ -647,6 +657,7 @@ export function ClusterGrid({ rows, spotStatus, onSpotClick }: Props) {
             onColumnVisible={saveColumnState}
             onSortChanged={saveColumnState}
             onRowClicked={handleRowClicked}
+            onRowDoubleClicked={handleRowDoubleClicked}
             animateRows={false}
             suppressCellFocus
             getRowId={(p) => `${(p.data as any).received_at}-${(p.data as any).dx_call}-${(p.data as any).source_id}`}

frontend/src/components/ElecraftPanel.tsx

@@ -0,0 +1,314 @@
+import { useEffect, useRef, useState } from 'react';
+import { Radio, Power, Activity, AudioLines, SlidersHorizontal } from 'lucide-react';
+import {
+  GetKenwoodState, RefreshKenwood, SetKenwoodPower, SetKenwoodAFGain, SetKenwoodTX, TuneKenwoodATU,
+  SetKenwoodRFGain, SetKenwoodMicGain, SetKenwoodSquelch, SetKenwoodPreamp, SetKenwoodAtt,
+  SetKenwoodNB, SetKenwoodNR, SetKenwoodAGC, SetKenwoodFilter, SetKenwoodAntenna,
+  SetKenwoodRIT, SetKenwoodXIT, ClearKenwoodRIT, SetKenwoodKeySpeed, ToggleKenwoodATU,
+  GetCATState,
+} from '../../wailsjs/go/main/App';
+import { cn } from '@/lib/utils';
+import { useI18n } from '@/lib/i18n';
+import { sMeterRST } from '@/lib/rst';
+import { MeterBar } from '@/components/MeterBar';
+import { WheelRange } from '@/components/WheelRange';
+
+type KenwoodState = {
+  available: boolean; model?: string; elecraft: boolean; mode?: string;
+  transmitting: boolean; split: boolean; split_tx_hz?: number;
+  s_meter: number; s_meter_raw: number;
+  power_meter: number; swr: number; swr_raw: number;
+  rf_power: number; af_gain: number; rf_gain: number; mic_gain: number; squelch: number;
+  preamp: boolean; att: boolean; nb: boolean; nr: boolean; agc?: string;
+  filter_hz: number; antenna: number; rit: boolean; xit: boolean; key_speed: number;
+  meters_provisional: boolean;
+};
+
+const ZERO: KenwoodState = {
+  available: false, elecraft: false, transmitting: false, split: false,
+  s_meter: 0, s_meter_raw: 0, power_meter: 0, swr: 0, swr_raw: 0,
+  rf_power: 0, af_gain: 0, rf_gain: 0, mic_gain: 0, squelch: 0,
+  preamp: false, att: false, nb: false, nr: false,
+  filter_hz: 0, antenna: 0, rit: false, xit: false, key_speed: 0,
+  meters_provisional: true,
+};
+
+// Filter widths worth a button. CW work happens at 200-500 Hz, SSB at 2.4-2.8
+// kHz; the rest of the range is reachable from the radio's own knob, and a
+// panel offering thirty widths is slower to use than the knob it replaces.
+const FILTERS = [200, 400, 700, 1000, 1800, 2400, 2800];
+
+// Raw S-meter → S units. The K3 answers 0-21 across S0…S9+60; S9 is taken at
+// raw 9 and each step above it as 6 dB. PROVISIONAL, like the rest of the
+// scaling: the raw value is on screen and in the log, so a real radio settles
+// it rather than this comment.
+const S9_RAW = 9;
+const DB_PER_RAW = 6;
+function sParts(rawV: number): { s: number; over: number; label: string } {
+  if (rawV >= S9_RAW) {
+    const over = Math.max(0, Math.round((rawV - S9_RAW) * DB_PER_RAW));
+    return { s: 9, over, label: over > 0 ? `S9+${over}` : 'S9' };
+  }
+  const s = Math.max(0, Math.min(9, rawV));
+  return { s, over: 0, label: `S${s}` };
+}
+
+// Segment colour, printed the way a radio's own meter is: green up to S9, amber
+// through the S9+ range, red once the signal would be reported as 59+20 or more.
+function sSegColor(frac: number) {
+  if (frac > 0.78) return '#dc2626';
+  if (frac > 0.55) return '#f59e0b';
+  return '#16a34a';
+}
+
+// The card shell the Yaesu and Icom consoles use, so the three read alike.
+function Card({ icon: Icon, title, children }: { icon: any; title: string; children: React.ReactNode }) {
+  return (
+    <div className="rounded-xl border border-border bg-card shadow-sm overflow-hidden">
+      <div className="flex items-center gap-2 px-3 py-2 border-b border-border/60 bg-muted/30">
+        <Icon className="size-4 text-primary" />
+        <span className="text-xs font-bold uppercase tracking-wider text-foreground/80">{title}</span>
+      </div>
+      <div className="p-3 space-y-3">{children}</div>
+    </div>
+  );
+}
+
+// One button shape for every on/off control, so the panel reads as one
+// instrument instead of a collection of differently-styled switches.
+function Toggle({ label, on, off, onClick }: { label: string; on: boolean; off: boolean; onClick: () => void }) {
+  return (
+    <button type="button" disabled={off} onClick={onClick}
+      className={cn('px-2 py-1 rounded-md text-[11px] font-bold tracking-wide border transition-all disabled:opacity-30',
+        on ? 'bg-primary text-primary-foreground border-primary' : 'bg-card text-muted-foreground border-border hover:border-primary/60')}>
+      {label}
+    </button>
+  );
+}
+
+export function ElecraftPanel({ onReportRST }: { onReportRST?: (rst: string) => void }) {
+  const { t } = useI18n();
+  const [st, setSt] = useState<KenwoodState>(ZERO);
+  const [freqHz, setFreqHz] = useState(0);
+  const [err, setErr] = useState('');
+  // Optimistic overlay: a slider must follow the finger, not the poll. Dropped
+  // once the radio has had time to answer with the value it actually took.
+  const [local, setLocal] = useState<{ rf_power?: number; af_gain?: number; rf_gain?: number; mic_gain?: number; squelch?: number; key_speed?: number }>({});
+  const localAtRef = useRef(0);
+
+  useEffect(() => {
+    let alive = true;
+    const tick = async () => {
+      try {
+        const s = (await GetKenwoodState()) as KenwoodState;
+        const c = (await GetCATState()) as any;
+        if (!alive) return;
+        setSt(s);
+        setFreqHz(c?.split && c?.freq_rx_hz > 0 ? c.freq_rx_hz : (c?.freq_hz ?? 0));
+        if (Date.now() - localAtRef.current > 1200) setLocal({});
+        setErr('');
+      } catch (e: any) {
+        if (alive) setErr(String(e?.message ?? e));
+      }
+    };
+    tick();
+    const id = window.setInterval(tick, 500);
+    return () => { alive = false; window.clearInterval(id); };
+  }, []);
+
+  const view = { ...st, ...local };
+  const off = !st.available;
+
+  const setErrMsg = (e: any) => setErr(String(e?.message ?? e));
+
+  const put = (patch: typeof local, run: () => Promise<any>) => {
+    setLocal((p) => ({ ...p, ...patch }));
+    localAtRef.current = Date.now();
+    run().catch((e) => setErr(String(e?.message ?? e)));
+  };
+
+  return (
+    <div className="h-full min-h-0 overflow-auto bg-background">
+      {/* Same wrapper as the Yaesu, Icom and Flex consoles: capped width and
+          CENTRED. A console stretched across a 2000 px window puts a slider a
+          hand's width from its own label, and the panel stops reading as one
+          instrument. */}
+      <div className="max-w-5xl mx-auto p-3 space-y-3">
+      {/* VFO + status */}
+      <div className="rounded-xl border border-border bg-card shadow-sm px-4 py-3 flex items-center justify-between gap-3 flex-wrap">
+        <div>
+          <div className="text-[10px] font-bold uppercase tracking-wider text-muted-foreground flex items-center gap-1.5">
+            <Radio className="size-3.5" />
+            {st.elecraft ? 'Elecraft' : 'Kenwood'} {st.model}
+            <span className={cn('size-2 rounded-full', off ? 'bg-muted-foreground/40' : 'bg-success')} />
+          </div>
+          <div className="text-2xl font-mono tabular-nums font-bold">
+            {freqHz > 0 ? (freqHz / 1e6).toFixed(6) : '—'}
+          </div>
+        </div>
+        <button type="button" className="text-[11px] text-muted-foreground hover:text-foreground flex items-center gap-1"
+          onClick={() => RefreshKenwood().catch(() => {})} title={t('k3.refreshHint')}>
+          <SlidersHorizontal className="size-3.5" />
+        </button>
+      </div>
+
+      {off && <div className="text-xs text-muted-foreground px-1">{t('k3.waiting')}</div>}
+      {!!err && <div className="text-[11px] text-danger px-1">{err}</div>}
+
+      {/* Meters */}
+      <Card icon={Activity} title={t('k3.meters')}>
+      <div className="grid grid-cols-1 sm:grid-cols-3 gap-2">
+        <MeterBar label="S-METER" value={view.transmitting ? 0 : view.s_meter} lo={0} hi={100}
+          accent="#16a34a" segColor={sSegColor}
+          display={view.transmitting ? '—' : sParts(view.s_meter_raw).label}
+          onClick={() => {
+            if (view.transmitting || !onReportRST) return;
+            const sp = sParts(view.s_meter_raw);
+            onReportRST(sMeterRST(sp.s, sp.over, view.mode));
+          }}
+          title={t('k3.sMeterHint', { raw: String(view.s_meter_raw) })} />
+        <MeterBar label="PWR" value={view.transmitting ? view.power_meter : 0} lo={0} hi={100} accent="#0ea5e9" />
+        {/* 0 means "not measured", and it must not render as a perfect 1.0:
+            a match that looks ideal on an antenna nobody has measured is the one
+            reading that can cost a radio. */}
+        <MeterBar label="SWR" value={view.transmitting && view.swr > 0 ? view.swr : 1} lo={1} hi={4}
+          accent="#f59e0b"
+          display={view.transmitting && view.swr > 0 ? view.swr.toFixed(1) : '—'} />
+      </div>
+      {view.meters_provisional && (
+        <p className="text-[10px] text-muted-foreground">{t('k3.provisional')}</p>
+      )}
+      </Card>
+
+      {/* MOX + TUNE */}
+      <div className="flex items-center gap-2">
+        <button type="button" disabled={off}
+          onClick={() => SetKenwoodTX(!view.transmitting).catch((e) => setErr(String(e?.message ?? e)))}
+          className={cn('flex-1 px-3 py-2.5 rounded-lg text-sm font-extrabold tracking-wide border-2 transition-all disabled:opacity-30',
+            view.transmitting
+              ? 'bg-danger text-danger-foreground border-danger shadow-[0_0_14px] shadow-danger/50'
+              : 'bg-card text-danger border-danger hover:bg-danger-muted')}>
+          <Power className="size-4 inline mr-1 -mt-0.5" /> MOX
+        </button>
+        <button type="button" disabled={off}
+          onClick={() => TuneKenwoodATU().catch((e) => setErr(String(e?.message ?? e)))}
+          title={t('k3.tuneHint')}
+          className="flex-1 px-3 py-2.5 rounded-lg text-sm font-extrabold tracking-wide border-2 border-warning text-warning bg-card hover:bg-warning-muted transition-all disabled:opacity-30">
+          <Activity className="size-4 inline mr-1 -mt-0.5" /> TUNE
+        </button>
+        {/* The HOLD of the same switch: tuner in line or bypassed. Two buttons
+            because they are two things on the radio — tuning is a cycle you
+            start, bypassing is a state you leave it in. */}
+        <button type="button" disabled={off}
+          onClick={() => ToggleKenwoodATU().catch(setErrMsg)}
+          title={t('k3.atuHint')}
+          className="px-3 py-2.5 rounded-lg text-sm font-extrabold tracking-wide border-2 border-border text-muted-foreground bg-card hover:bg-muted transition-all disabled:opacity-30">
+          ATU
+        </button>
+      </div>
+
+      {/* Levels — two columns, so a slider stays beside the label it belongs to
+          instead of running the width of the window. */}
+      <Card icon={SlidersHorizontal} title={t('k3.levels')}>
+      <div className="grid grid-cols-1 lg:grid-cols-2 gap-x-6 gap-y-2">
+        <label className="flex items-center gap-2 text-xs">
+          <span className="w-16 shrink-0 text-muted-foreground">{t('k3.power')}</span>
+          <WheelRange min={0} max={110} step={5} disabled={off}
+            value={view.rf_power ?? 0}
+            onChange={(n) => put({ rf_power: n }, () => SetKenwoodPower(n))} />
+          <span className="w-12 text-right font-mono tabular-nums">{view.rf_power ?? 0} W</span>
+        </label>
+        <label className="flex items-center gap-2 text-xs">
+          <span className="w-16 shrink-0 text-muted-foreground flex items-center gap-1">
+            <AudioLines className="size-3.5" /> {t('k3.volume')}
+          </span>
+          <WheelRange min={0} max={100} disabled={off}
+            value={view.af_gain ?? 0}
+            onChange={(n) => put({ af_gain: n }, () => SetKenwoodAFGain(n))} />
+          <span className="w-12 text-right font-mono tabular-nums">{view.af_gain ?? 0}</span>
+        </label>
+        <label className="flex items-center gap-2 text-xs">
+          <span className="w-16 shrink-0 text-muted-foreground">{t('k3.rfGain')}</span>
+          <WheelRange min={0} max={100} disabled={off}
+            value={view.rf_gain ?? 0}
+            onChange={(n) => put({ rf_gain: n }, () => SetKenwoodRFGain(n))} />
+          <span className="w-12 text-right font-mono tabular-nums">{view.rf_gain ?? 0}</span>
+        </label>
+        <label className="flex items-center gap-2 text-xs">
+          <span className="w-16 shrink-0 text-muted-foreground">{t('k3.micGain')}</span>
+          <WheelRange min={0} max={100} disabled={off}
+            value={view.mic_gain ?? 0}
+            onChange={(n) => put({ mic_gain: n }, () => SetKenwoodMicGain(n))} />
+          <span className="w-12 text-right font-mono tabular-nums">{view.mic_gain ?? 0}</span>
+        </label>
+        <label className="flex items-center gap-2 text-xs">
+          <span className="w-16 shrink-0 text-muted-foreground">{t('k3.squelch')}</span>
+          <WheelRange min={0} max={100} disabled={off}
+            value={view.squelch ?? 0}
+            onChange={(n) => put({ squelch: n }, () => SetKenwoodSquelch(n))} />
+          <span className="w-12 text-right font-mono tabular-nums">{view.squelch ?? 0}</span>
+        </label>
+        {/* CW keyer speed — the radio's own keyer, the one the K3 sends with. */}
+        <label className="flex items-center gap-2 text-xs">
+          <span className="w-16 shrink-0 text-muted-foreground">{t('k3.keySpeed')}</span>
+          <WheelRange min={8} max={50} disabled={off}
+            value={view.key_speed || 20}
+            onChange={(n) => put({ key_speed: n }, () => SetKenwoodKeySpeed(n))} />
+          <span className="w-12 text-right font-mono tabular-nums">{view.key_speed || 0} wpm</span>
+        </label>
+      </div>
+      </Card>
+
+      {/* Receive chain. Toggles, because that is what they are on the radio:
+          one press each, and the state comes back from the rig rather than from
+          what the button was asked to do. */}
+      <Card icon={AudioLines} title={t('k3.receive')}>
+      <div className="space-y-2">
+        <div className="flex flex-wrap items-center gap-1.5">
+          <Toggle label="PRE" on={view.preamp} off={off} onClick={() => SetKenwoodPreamp(!view.preamp).catch(setErrMsg)} />
+          <Toggle label="ATT" on={view.att} off={off} onClick={() => SetKenwoodAtt(!view.att).catch(setErrMsg)} />
+          <Toggle label="NB" on={view.nb} off={off} onClick={() => SetKenwoodNB(!view.nb).catch(setErrMsg)} />
+          <Toggle label="NR" on={view.nr} off={off} onClick={() => SetKenwoodNR(!view.nr).catch(setErrMsg)} />
+          <span className="w-2" />
+          {['OFF', 'SLOW', 'FAST'].map((a) => (
+            <Toggle key={a} label={a} on={(view.agc || '').toUpperCase() === a} off={off}
+              onClick={() => SetKenwoodAGC(a).catch(setErrMsg)} />
+          ))}
+        </div>
+
+        {/* RIT / XIT. Clear zeroes both offsets at once — the radio's own RC,
+            and what an operator means by "clear it". */}
+        <div className="flex flex-wrap items-center gap-1.5">
+          <Toggle label="RIT" on={view.rit} off={off} onClick={() => SetKenwoodRIT(!view.rit).catch(setErrMsg)} />
+          <Toggle label="XIT" on={view.xit} off={off} onClick={() => SetKenwoodXIT(!view.xit).catch(setErrMsg)} />
+          <Toggle label={t('k3.clear')} on={false} off={off} onClick={() => ClearKenwoodRIT().catch(setErrMsg)} />
+          {/* Antenna only when the radio answered AN — a K3 without the internal
+              ATU has one socket and no switch to offer. */}
+          {view.antenna > 0 && (<>
+            <span className="w-2" />
+            <span className="text-[10px] uppercase tracking-wider text-muted-foreground">{t('k3.antenna')}</span>
+            {[1, 2].map((n) => (
+              <Toggle key={n} label={'ANT' + n} on={view.antenna === n} off={off}
+                onClick={() => SetKenwoodAntenna(n).catch(setErrMsg)} />
+            ))}
+          </>)}
+        </div>
+
+        {/* Filter width */}
+        <div className="flex flex-wrap items-center gap-1.5">
+          <span className="text-[10px] uppercase tracking-wider text-muted-foreground">{t('k3.filter')}</span>
+          {FILTERS.map((hz) => (
+            <Toggle key={hz} label={hz >= 1000 ? (hz / 1000).toFixed(1) + 'k' : String(hz)}
+              on={view.filter_hz === hz} off={off}
+              onClick={() => SetKenwoodFilter(hz).catch(setErrMsg)} />
+          ))}
+          {view.filter_hz > 0 && (
+            <span className="text-[10px] font-mono text-muted-foreground">{view.filter_hz} Hz</span>
+          )}
+        </div>
+      </div>
+      </Card>
+      </div>
+    </div>
+  );
+}

frontend/src/components/FlexPanel.tsx

@@ -8,6 +8,7 @@ import {
   GetTunerGeniusStatus, GetTunerGeniusSettings,
   GetAmpStatuses, AmpOperate, AmpPower, AmpPowerLevel,
   FlexSetAGCMode, FlexSetAGCThreshold, FlexSetAudioLevel, FlexSetMute, FlexSetRXAntenna, FlexSetTXAntenna, FlexSetSplit, FlexSetActiveSlice, FlexSetTXSlice,
+  GetFlexRSTChase, SaveFlexRSTChase, SetFlexRSTChaseEnabled,
   FlexSetRIT, FlexSetRITFreq, FlexSetXIT, FlexSetXITFreq,
   FlexSetNB, FlexSetNBLevel, FlexSetNR, FlexSetNRLevel, FlexSetANF, FlexSetANFLevel,
   FlexSetLMSNR, FlexSetLMSNRLevel, FlexSetLMSANF, FlexSetLMSANFLevel,
@@ -304,6 +305,25 @@ function powerLevelLabel(pl?: string): string {
 // host can keep the WinKeyer (which actually sends the macros) in sync.
 export function FlexPanel({ onCWSpeed, onReportRST }: { onCWSpeed?: (wpm: number) => void; onReportRST?: (rst: string) => void } = {}) {
   const { t } = useI18n();
+  // Split-pile-up chaser (see flexrstchase.go). Held here so the button can
+  // paint its state without polling the backend for it.
+  const [rstChase, setRstChase] = useState<{ enabled: boolean; markers: string; offset_hz: number; split_only: boolean }>(
+    { enabled: false, markers: '599', offset_hz: 0, split_only: true });
+  const [rstChaseOffsetText, setRstChaseOffsetText] = useState('0');
+  // The marker text is edited as raw text and only parsed on blur: it is a
+  // comma-separated list, and normalising it on every keystroke would eat the
+  // comma the moment it is typed.
+  const [rstChaseMarkersText, setRstChaseMarkersText] = useState('599');
+  // The marker field is summoned by right-clicking the button, not parked on
+  // the row: it is set once to agree with SDC and then never touched, while the
+  // row it was sitting in is the busiest in the panel.
+  const [rstChaseEditing, setRstChaseEditing] = useState(false);
+  useEffect(() => {
+    GetFlexRSTChase().then((c: any) => {
+      if (!c) return;
+      setRstChase(c); setRstChaseOffsetText(String(c.offset_hz ?? 0)); setRstChaseMarkersText(String(c.markers ?? '599'));
+    }).catch(() => {});
+  }, []);
   const [st, setSt] = useState<FlexState>(ZERO);
   // Extra/"advanced" DSP rows (WNB + the SmartSDR v4 NRL/NRS/NRF/ANFL/AI-FFT
   // block) collapse behind a button so the RECEIVE card doesn't grow tall — only
@@ -652,6 +672,64 @@ export function FlexPanel({ onCWSpeed, onReportRST }: { onCWSpeed?: (wpm: number
                   st.split ? 'bg-info text-info-foreground border-info shadow-[0_0_12px] shadow-info/50' : 'bg-card text-info border-info hover:bg-info-muted')}>
                 SPLIT
               </button>
+              {/* The split chaser. On the panel and not in a settings page:
+                  it is switched on when a DXpedition appears and off when it is
+                  in the log, which is done mid-QSO with one hand. The offset
+                  sits beside it because it is the one number retuned while
+                  chasing — everything else about the feature is configured once. */}
+              {/* CW ONLY. The marker comes from a skimmer decoding a CW report,
+                  so on SSB or FT8 there is nothing to chase — and a switch that
+                  cannot fire is an invitation to wonder why it does nothing. */}
+              {isCW && (<>
+              <button type="button" disabled={off}
+                title={t('flxp.rstChaseHint', { m: rstChase.markers })}
+                onContextMenu={(e) => { e.preventDefault(); setRstChaseEditing(true); }}
+                onClick={() => { const on = !rstChase.enabled; setRstChase({ ...rstChase, enabled: on }); SetFlexRSTChaseEnabled(on).catch(() => {}); }}
+                className={cn('px-3 py-1.5 rounded-lg text-sm font-extrabold tracking-wide border-2 transition-all disabled:opacity-30',
+                  rstChase.enabled ? 'bg-success text-success-foreground border-success shadow-[0_0_12px] shadow-success/50' : 'bg-card text-success border-success hover:bg-success-muted')}>
+                {rstChase.markers.split(',')[0].trim() || '599'}
+              </button>
+              {/* The marker is whatever SDC was told to write — "599", "5NN", or
+                  several. It has to agree with the skimmer or nothing ever fires,
+                  so it is edited here rather than in a settings page — but only
+                  when asked for, since it is set once and then left alone. */}
+              {rstChaseEditing && (
+                <input type="text" autoFocus value={rstChaseMarkersText}
+                  onChange={(e) => setRstChaseMarkersText(e.target.value)}
+                  onKeyDown={(e) => {
+                    if (e.key === 'Enter') (e.target as HTMLInputElement).blur();
+                    if (e.key === 'Escape') { setRstChaseMarkersText(rstChase.markers); setRstChaseEditing(false); }
+                  }}
+                  onBlur={() => {
+                    const v = rstChaseMarkersText.trim() || '599';
+                    setRstChaseMarkersText(v);
+                    setRstChaseEditing(false);
+                    if (v === rstChase.markers) return;
+                    const next = { ...rstChase, markers: v };
+                    setRstChase(next); SaveFlexRSTChase(next as any).catch(() => {});
+                  }}
+                  title={t('flxp.rstChaseMarkerHint')}
+                  className="w-16 h-6 rounded border border-input bg-background px-1 text-[11px] font-mono uppercase" />
+              )}
+              {rstChase.enabled && (
+                <label className="flex items-center gap-1 text-[11px] text-muted-foreground whitespace-nowrap ml-2">
+                  {t('flxp.rstChaseOffset')}
+                  <input type="number" step={10} value={rstChaseOffsetText}
+                    onChange={(e) => setRstChaseOffsetText(e.target.value)}
+                    onBlur={() => {
+                      // Kept as text while typing: normalising every keystroke
+                      // makes a minus sign impossible to enter.
+                      const n = Math.round(Number(rstChaseOffsetText));
+                      const v = Number.isFinite(n) ? n : 0;
+                      setRstChaseOffsetText(String(v));
+                      const next = { ...rstChase, offset_hz: v };
+                      setRstChase(next); SaveFlexRSTChase(next as any).catch(() => {});
+                    }}
+                    className="w-12 h-6 rounded border border-input bg-background px-1 text-[11px] font-mono" />
+                  Hz
+                </label>
+              )}
+              </>)}
               {st.split && !!st.tx_freq_hz && (
                 <span className="text-[11px] font-mono text-muted-foreground whitespace-nowrap">
                   TX {(st.tx_freq_hz / 1e6).toFixed(3)}

frontend/src/components/QSLManagerModal.tsx

@@ -8,7 +8,7 @@ import {
   Select, SelectTrigger, SelectValue, SelectContent, SelectItem,
 } from '@/components/ui/select';
 import { cn } from '@/lib/utils';
-import { FindQSOsForUpload, UploadQSOsManual, DownloadConfirmations, CancelConfirmations, ImportHamlogConfirmations, OpenADIFFile, SyncPOTAHunterLog, ListQSO, BulkUpdateQSL, UploadCallsign, GetSlotStats } from '../../wailsjs/go/main/App';
+import { FindQSOsForUpload, UploadQSOsManual, DownloadConfirmations, CancelConfirmations, ImportHamlogConfirmations, ExportHamlogUnmatched, OpenADIFFile, SaveADIFFile, SyncPOTAHunterLog, ListQSO, BulkUpdateQSL, UploadCallsign, GetSlotStats } from '../../wailsjs/go/main/App';
 import { Input } from '@/components/ui/input';
 import { RecentQSOsGrid } from '@/components/RecentQSOsGrid';
 import { EventsOn } from '../../wailsjs/runtime/runtime';
@@ -363,6 +363,21 @@ export function QSLManagerPanel({ onEditQSO, actions, paperRequest }: {
     catch (e: any) { setLogLines((p) => [...p, 'Error: ' + String(e?.message ?? e)]); setBusy(false); }
   }
 
+  // The unmatched half of an import. Offered as a file because a few hundred
+  // discrepancies are a list to work through, not something to read in a log
+  // window.
+  async function exportHamlogUnmatched() {
+    try {
+      const path = await SaveADIFFile();
+      if (!path) return;
+      const n = await ExportHamlogUnmatched(path);
+      setLogLines((p) => [...p, `Exported ${n} unmatched confirmation(s) → ${path}`]);
+      setShowLog(true);
+    } catch (e: any) {
+      setLogLines((p) => [...p, 'Error: ' + String(e?.message ?? e)]); setShowLog(true);
+    }
+  }
+
   function viewResults() {
     setShowLog(false);
     if (logAction === 'upload') selectRequired();
@@ -680,10 +695,16 @@ export function QSLManagerPanel({ onEditQSO, actions, paperRequest }: {
       <div className="flex items-center justify-between gap-2 px-3 py-2 border-t border-border bg-muted/20 shrink-0">
         <div className="flex items-center gap-2 flex-wrap">
           {service === 'hamlog' ? (
+            <>
             <Button variant="outline" size="sm" onClick={importHamlogCfm} disabled={busy}
               title={t('qslm.hamlogImportTitle')}>
               <DownloadCloud className="size-3.5" /> {t('qslm.hamlogImportCfm')}
             </Button>
+            <Button variant="outline" size="sm" onClick={exportHamlogUnmatched} disabled={busy}
+              title={t('qslm.hamlogUnmatchedTitle')}>
+              <UploadCloud className="size-3.5 rotate-180" /> {t('qslm.hamlogUnmatched')}
+            </Button>
+            </>
           ) : (
           <Button variant="outline" size="sm" onClick={download} disabled={busy}
             title={t('qslm.downloadTitle')}>

frontend/src/components/SettingsModal.tsx

@@ -58,7 +58,7 @@ import {
   GetFolderSync, SaveFolderSync, PickFolderSyncFolder, GetFolderSyncStatus, SyncFolderNow,
   GetRelayAuto, SaveRelayAuto, GetStationDevices,
   GetAwardDefs, GetTrackedAwards, SaveTrackedAwards,
-  GetBandOpenSettings, SaveBandOpenSettings, GetGridScopeSettings, SaveGridScopeSettings, GetPSKReporterStatus, GetChaseNewGrids, SetChaseNewGrids, GetChaseNew, SetChaseNew, GetGridCacheStatus, GetLinkedAmps, SetLinkedAmps, GetSpotTTLMinutes, SetSpotTTLMinutes,
+  GetBandOpenSettings, SaveBandOpenSettings, GetGridScopeSettings, SaveGridScopeSettings, GetPSKReporterStatus, GetChaseNewGrids, SetChaseNewGrids, GetChaseNew, SetChaseNew, GetGridCacheStatus, GetLinkedAmps, SetLinkedAmps, GetSpotTTLMinutes, SetSpotTTLMinutes, GetSpotMax, SetSpotMax,
 } from '../../wailsjs/go/main/App';
 import type { profile as profileModels } from '../../wailsjs/go/models';
 import type { LookupSettingsForm, StationSettingsForm, ListsSettingsForm, ModePresetForm } from '@/types';
@@ -80,7 +80,6 @@ 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';
@@ -1933,7 +1932,6 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   // 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) => {
@@ -1944,6 +1942,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   const [chaseNew, setChaseNew] = useState(false);
   const [spotTTL, setSpotTTL] = useState(0);
   const [spotTTLText, setSpotTTLText] = useState('0');
+  const [spotMaxText, setSpotMaxText] = useState('1000');
   const [gridStat, setGridStat] = useState<any>(null);
   const [pskrStatus, setPskrStatus] = useState<any>(null);
   const saveBandOpen = async (next: any) => {
@@ -1957,6 +1956,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
       try { setChaseNew(await GetChaseNew()); } catch { /* defaults stand */ }
       try { setLinkedAmps((await GetLinkedAmps()) ?? []); } catch { /* defaults stand */ }
       try { const n = await GetSpotTTLMinutes(); setSpotTTL(n); setSpotTTLText(String(n)); } catch { /* defaults stand */ }
+      try { const n = await GetSpotMax(); setSpotMaxText(String(n)); } catch { /* defaults stand */ }
     })();
     // Poll the feed while the panel is open: a live count is the only thing that
     // distinguishes "connected" from "connected and receiving nothing".
@@ -4975,6 +4975,28 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                 }} />
               <span className="text-xs text-muted-foreground">{t('clu.spotTtlHint')}</span>
             </div>
+            {/* The list size, beside the lifetime because between them they decide
+                the same thing: whichever runs out first removes the spot. */}
+            <div className="flex items-center gap-3 flex-wrap">
+              <span className="text-sm">{t('clu.spotMax')}</span>
+              <div className="inline-flex rounded-md border border-border overflow-hidden text-xs">
+                {[500, 1000, 2500, 5000].map((v) => (
+                  <button key={v} type="button"
+                    onClick={() => { setSpotMaxText(String(v)); SetSpotMax(v).catch(() => {}); }}
+                    className={cn('px-2.5 py-1.5 font-medium', Number(spotMaxText) === v ? 'bg-primary text-primary-foreground' : 'text-muted-foreground hover:bg-muted')}>
+                    {v}
+                  </button>
+                ))}
+              </div>
+              <Input className="h-8 w-24" value={spotMaxText}
+                onChange={(e) => {
+                  const raw = e.target.value.replace(/[^0-9]/g, '');
+                  setSpotMaxText(raw);
+                  const n = parseInt(raw, 10);
+                  if (Number.isFinite(n) && n > 0) SetSpotMax(Math.min(10000, n)).catch(() => {});
+                }} />
+              <span className="text-xs text-muted-foreground">{t('clu.spotMaxHint')}</span>
+            </div>
           </div>
 
           <div className="border-t border-border/60 pt-3 space-y-2">

frontend/src/components/WheelRange.tsx

@@ -0,0 +1,62 @@
+import { useEffect, useRef } from 'react';
+import { cn } from '@/lib/utils';
+
+// A range slider the mouse wheel can move.
+//
+// Dragging a 4-pixel-tall slider to change the power by five watts is a fussy
+// gesture; rolling the wheel over it is not, and it is what an operator reaches
+// for after using the Flex and Yaesu consoles, which have had it for a while.
+//
+// React's own onWheel is registered PASSIVE, so preventDefault() inside it is
+// ignored and the panel scrolls under the pointer while the value changes. The
+// listener therefore has to be attached natively with { passive: false }, and
+// the live values read through refs — the listener is installed once and would
+// otherwise capture the first render's value for ever.
+//
+// The Flex and Yaesu panels each grew their own copy of this before it was worth
+// sharing. They are left alone deliberately: they work, they are in daily use,
+// and their styling differs in small ways that a merge would have to guess at.
+export function WheelRange({ value, onChange, min = 0, max = 100, step = 1, disabled, accent = 'var(--primary)', className }: {
+  value: number; onChange: (v: number) => void;
+  min?: number; max?: number; step?: number; disabled?: boolean; accent?: string; className?: string;
+}) {
+  const v = Math.max(min, Math.min(max, value));
+  const pct = max > min ? ((v - min) / (max - min)) * 100 : 0;
+  const ref = useRef<HTMLInputElement>(null);
+  const valRef = useRef(v); valRef.current = v;
+  const cbRef = useRef(onChange); cbRef.current = onChange;
+  const disRef = useRef(disabled); disRef.current = disabled;
+  const stepRef = useRef(step); stepRef.current = step;
+  const minRef = useRef(min); minRef.current = min;
+  const maxRef = useRef(max); maxRef.current = max;
+
+  useEffect(() => {
+    const el = ref.current;
+    if (!el) return;
+    const onWheel = (e: WheelEvent) => {
+      if (disRef.current) return;
+      e.preventDefault();
+      const d = e.deltaY < 0 ? stepRef.current : -stepRef.current;
+      const nv = Math.max(minRef.current, Math.min(maxRef.current, valRef.current + d));
+      if (nv !== valRef.current) cbRef.current(nv);
+    };
+    el.addEventListener('wheel', onWheel, { passive: false });
+    return () => el.removeEventListener('wheel', onWheel);
+  }, []);
+
+  return (
+    <input
+      ref={ref}
+      type="range" min={min} max={max} step={step} value={v} disabled={disabled}
+      onChange={(e) => onChange(parseInt(e.target.value, 10))}
+      className={cn('flex-1 h-1.5 rounded-full appearance-none cursor-pointer disabled:opacity-30 disabled:cursor-default',
+        '[&::-webkit-slider-thumb]:appearance-none [&::-webkit-slider-thumb]:size-3.5 [&::-webkit-slider-thumb]:rounded-full',
+        '[&::-webkit-slider-thumb]:bg-card [&::-webkit-slider-thumb]:border-2 [&::-webkit-slider-thumb]:shadow-sm [&::-webkit-slider-thumb]:cursor-pointer',
+        className)}
+      style={{
+        background: `linear-gradient(to right, ${accent} ${pct}%, color-mix(in srgb, var(--foreground) 18%, transparent) ${pct}%)`,
+        borderColor: accent,
+      }}
+    />
+  );
+}

frontend/src/components/WinkeyerPanel.tsx

@@ -73,9 +73,17 @@ export function WinkeyerPanel({
 
   const connected = status.connected;
 
+  // Send-on-type only exists where the engine can key one character at a time:
+  // the WinKeyer and Flex CWX. The stored preference survives an engine change,
+  // though, and an Icom or Yaesu operator inherited a hidden switch that was on
+  // — the checkbox is not shown for them, so nothing keyed as they typed AND
+  // Enter sent nothing either, since it believes the text has already gone.
+  // Macros kept working, which is exactly how it looked from the outside.
+  const liveType = sendOnType && (source === 'winkeyer' || source === 'flex');
+
   function sendText() {
     const t = cwText.trim();
-    if (t && !sendOnType) onSend(t); // in send-on-type the text already went out
+    if (t && !liveType) onSend(t); // in send-on-type the text already went out
     setCwText('');
   }
 
@@ -83,7 +91,7 @@ export function WinkeyerPanel({
   // WinKeyer backspace for each deleted char (removes it from the buffer if it
   // hasn't been keyed yet). Only end-of-string edits are mirrored live.
   function onCwChange(v: string) {
-    if (sendOnType && connected) {
+    if (liveType && connected) {
       const old = cwText;
       if (v.length > old.length && v.startsWith(old)) {
         onSendRaw(v.slice(old.length));
@@ -200,13 +208,13 @@ export function WinkeyerPanel({
               value={cwText}
               onChange={(e) => onCwChange(e.target.value)}
               onKeyDown={(e) => { if (e.key === 'Enter') { e.preventDefault(); sendText(); } }}
-              placeholder={sendOnType ? t('wkp.phLive') : t('wkp.phEnter')}
+              placeholder={liveType ? t('wkp.phLive') : t('wkp.phEnter')}
               disabled={!connected}
               className="font-mono uppercase"
             />
           </div>
           <Button size="sm" className="h-8" onClick={sendText} disabled={!connected}>
-            <Send className="size-3.5" /> {sendOnType ? t('wkp.clear') : t('wkp.send')}
+            <Send className="size-3.5" /> {liveType ? t('wkp.clear') : t('wkp.send')}
           </Button>
           <Button variant="destructive" size="sm" className="h-8" onClick={onStop} disabled={!connected} title={t('wkp.abort')}>
             <Square className="size-3.5" /> {t('wkp.stop')}

frontend/src/components/YaesuPanel.tsx

@@ -18,7 +18,8 @@ type YaesuState = {
   s_meter: number; power_meter: number; swr_meter: number;
   rf_power: number; mic_gain: number; af_gain: number; rf_gain: number; squelch: number;
   agc?: string; preamp: number; att: number; antenna: number;
-  nb: boolean; nr: boolean; nr_level: number; narrow: boolean; vox: boolean;
+  nb: boolean; nr: boolean; nr_level: number; narrow: boolean; narrow_supported?: boolean; vox: boolean;
+  max_power?: number;
   split_tx_hz?: number; key_speed?: number; break_in?: boolean; swr?: number; power_w?: number;
 };
 
@@ -445,7 +446,13 @@ export function YaesuPanel({ onReportRST, onKeySpeed }: {
         <div className="flex items-center gap-2 flex-wrap">
           <Chip on={view.nb} onClick={() => push('nb', !view.nb, () => SetYaesuNB(!view.nb))} label="NB" />
           <Chip on={view.nr} onClick={() => push('nr', !view.nr, () => SetYaesuNR(!view.nr))} label="DNR" />
-          <Chip on={view.narrow} onClick={() => push('narrow', !view.narrow, () => SetYaesuNarrow(!view.narrow))} label="NAR" />
+          {/* NAR is the narrow IF filter. Shown only when the rig ANSWERED NA:
+              a button that does nothing when pressed reads as a fault in the
+              radio, which is how it was reported from an FTDX101. */}
+          {view.narrow_supported && (
+            <Chip on={view.narrow} onClick={() => push('narrow', !view.narrow, () => SetYaesuNarrow(!view.narrow))}
+              label="NAR" title={t('yaesu.narrowHint')} />
+          )}
         </div>
         <Row label="DNR">
           {/* 1-15 on the rig, shown as-is rather than rescaled to a percentage:
@@ -462,7 +469,7 @@ export function YaesuPanel({ onReportRST, onKeySpeed }: {
         <Row label="PWR">
           {/* Watts, not a percentage: the rig reports and takes watts, and a
               percentage would be a second unit to reconcile every time. */}
-          <Slider value={view.rf_power || 5} min={5} max={100} accent="var(--destructive)"
+          <Slider value={view.rf_power || 5} min={5} max={Math.max(100, view.max_power || 100)} accent="var(--destructive)"
             onChange={(v) => push('rf_power', v, () => SetYaesuPower(v))} />
           <span className="w-10 text-right text-xs font-mono tabular-nums text-muted-foreground">{view.rf_power}W</span>
         </Row>

frontend/src/lib/autocall.ts

@@ -72,13 +72,26 @@ export function loadAutoCall(): AutoCallSettings {
     const raw = localStorage.getItem(AC_KEY);
     if (!raw) return { ...defaultAutoCall };
     const v = JSON.parse(raw);
-    return {
+    const out: AutoCallSettings = {
       ...defaultAutoCall,
       ...v,
       criteria: { ...emptyCriteria, ...(v?.criteria ?? {}) },
       watchCriteria: { ...emptyCriteria, ...(v?.watchCriteria ?? {}) },
       watch: Array.isArray(v?.watch) ? v.watch : [],
     };
+    // DISARMED ON SIGHT, and written back disabled.
+    //
+    // The runtime guard in App.tsx stops this build from calling anyone, but it
+    // leaves "enabled": true sitting in storage, where any build without the
+    // guard — an older one an operator reinstalls, a machine that upgrades
+    // later — reads it and keys the transmitter for a feature with no switch
+    // left to turn off. A withdrawn feature that keys a radio has to be
+    // disarmed where it is REMEMBERED, not only where it runs.
+    if (out.enabled) {
+      out.enabled = false;
+      try { localStorage.setItem(AC_KEY, JSON.stringify(out)); } catch { /* private mode: the guard still holds */ }
+    }
+    return out;
   } catch { return { ...defaultAutoCall }; }
 }
 

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

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

@@ -119,6 +119,8 @@ export function CheckForUpdate():Promise<main.UpdateInfo>;
 
 export function CheckHamlogKey(arg1:string):Promise<string>;
 
+export function ClearKenwoodRIT():Promise<void>;
+
 export function ClearLookupCache():Promise<void>;
 
 export function CloseAutostartPrograms():Promise<void>;
@@ -233,6 +235,8 @@ export function ExportCabrilloFiltered(arg1:string,arg2:qso.QueryFilter):Promise
 
 export function ExportCabrilloSelected(arg1:string,arg2:Array<number>):Promise<main.CabrilloResult>;
 
+export function ExportHamlogUnmatched(arg1:string):Promise<number>;
+
 export function FilterFields():Promise<Array<string>>;
 
 export function FindDuplicates(arg1:number):Promise<Array<main.DuplicateGroup>>;
@@ -469,6 +473,8 @@ export function GetFlexBandAntennas():Promise<Record<string, main.FlexBandAnt>>;
 
 export function GetFlexBandPower():Promise<Record<string, main.FlexBandPower>>;
 
+export function GetFlexRSTChase():Promise<main.FlexRSTChase>;
+
 export function GetFlexState():Promise<cat.FlexTXState>;
 
 export function GetFlexZoom():Promise<main.FlexZoomSettings>;
@@ -483,6 +489,8 @@ export function GetGridScopeSettings():Promise<main.GridScopeSettings>;
 
 export function GetIcomState():Promise<cat.IcomTXState>;
 
+export function GetKenwoodState():Promise<cat.KenwoodTXState>;
+
 export function GetLinkedAmps():Promise<Array<string>>;
 
 export function GetListsSettings():Promise<main.ListsSettings>;
@@ -555,6 +563,8 @@ export function GetSolarData():Promise<solar.Data>;
 
 export function GetSpotColors():Promise<main.SpotColors>;
 
+export function GetSpotMax():Promise<number>;
+
 export function GetSpotTTLMinutes():Promise<number>;
 
 export function GetStartupStatus():Promise<main.StartupStatus>;
@@ -895,6 +905,8 @@ export function RecomputeAwardRefsForCode(arg1:string):Promise<number>;
 
 export function RefreshCtyDat():Promise<main.CtyDatInfo>;
 
+export function RefreshKenwood():Promise<void>;
+
 export function RefreshSolar():Promise<void>;
 
 export function RefreshYaesuPanel():Promise<void>;
@@ -989,6 +1001,8 @@ export function SaveFlexBandAntennas(arg1:Record<string, main.FlexBandAnt>):Prom
 
 export function SaveFlexBandPower(arg1:Record<string, main.FlexBandPower>):Promise<void>;
 
+export function SaveFlexRSTChase(arg1:main.FlexRSTChase):Promise<void>;
+
 export function SaveFlexZoom(arg1:main.FlexZoomSettings):Promise<void>;
 
 export function SaveFolderSync(arg1:main.FolderSyncConfig):Promise<void>;
@@ -1091,8 +1105,40 @@ export function SetCompactMode(arg1:boolean):Promise<void>;
 
 export function SetDVKLabel(arg1:number,arg2:string):Promise<void>;
 
+export function SetFlexRSTChaseEnabled(arg1:boolean):Promise<void>;
+
+export function SetKenwoodAFGain(arg1:number):Promise<void>;
+
+export function SetKenwoodAGC(arg1:string):Promise<void>;
+
+export function SetKenwoodAntenna(arg1:number):Promise<void>;
+
+export function SetKenwoodAtt(arg1:boolean):Promise<void>;
+
+export function SetKenwoodFilter(arg1:number):Promise<void>;
+
 export function SetKenwoodKeySpeed(arg1:number):Promise<void>;
 
+export function SetKenwoodMicGain(arg1:number):Promise<void>;
+
+export function SetKenwoodNB(arg1:boolean):Promise<void>;
+
+export function SetKenwoodNR(arg1:boolean):Promise<void>;
+
+export function SetKenwoodPower(arg1:number):Promise<void>;
+
+export function SetKenwoodPreamp(arg1:boolean):Promise<void>;
+
+export function SetKenwoodRFGain(arg1:number):Promise<void>;
+
+export function SetKenwoodRIT(arg1:boolean):Promise<void>;
+
+export function SetKenwoodSquelch(arg1:number):Promise<void>;
+
+export function SetKenwoodTX(arg1:boolean):Promise<void>;
+
+export function SetKenwoodXIT(arg1:boolean):Promise<void>;
+
 export function SetLinkedAmps(arg1:Array<string>):Promise<void>;
 
 export function SetMotorFollow(arg1:boolean,arg2:number,arg3:string):Promise<void>;
@@ -1105,6 +1151,8 @@ export function SetPassphrase(arg1:string):Promise<void>;
 
 export function SetScpEnabled(arg1:boolean):Promise<void>;
 
+export function SetSpotMax(arg1:number):Promise<void>;
+
 export function SetSpotTTLMinutes(arg1:number):Promise<void>;
 
 export function SetTelemetryEnabled(arg1:boolean):Promise<void>;
@@ -1199,6 +1247,10 @@ export function TestUltrabeam(arg1:main.UltrabeamSettings):Promise<void>;
 
 export function TestWebPublishFTP(arg1:webpub.Config):Promise<string>;
 
+export function ToggleKenwoodATU():Promise<void>;
+
+export function TuneKenwoodATU():Promise<void>;
+
 export function TuneYaesuATU():Promise<void>;
 
 export function TunerGeniusActivate(arg1:number):Promise<void>;

frontend/wailsjs/go/main/App.js

@@ -178,6 +178,10 @@ export function CheckHamlogKey(arg1) {
   return window['go']['main']['App']['CheckHamlogKey'](arg1);
 }
 
+export function ClearKenwoodRIT() {
+  return window['go']['main']['App']['ClearKenwoodRIT']();
+}
+
 export function ClearLookupCache() {
   return window['go']['main']['App']['ClearLookupCache']();
 }
@@ -406,6 +410,10 @@ export function ExportCabrilloSelected(arg1, arg2) {
   return window['go']['main']['App']['ExportCabrilloSelected'](arg1, arg2);
 }
 
+export function ExportHamlogUnmatched(arg1) {
+  return window['go']['main']['App']['ExportHamlogUnmatched'](arg1);
+}
+
 export function FilterFields() {
   return window['go']['main']['App']['FilterFields']();
 }
@@ -878,6 +886,10 @@ export function GetFlexBandPower() {
   return window['go']['main']['App']['GetFlexBandPower']();
 }
 
+export function GetFlexRSTChase() {
+  return window['go']['main']['App']['GetFlexRSTChase']();
+}
+
 export function GetFlexState() {
   return window['go']['main']['App']['GetFlexState']();
 }
@@ -906,6 +918,10 @@ export function GetIcomState() {
   return window['go']['main']['App']['GetIcomState']();
 }
 
+export function GetKenwoodState() {
+  return window['go']['main']['App']['GetKenwoodState']();
+}
+
 export function GetLinkedAmps() {
   return window['go']['main']['App']['GetLinkedAmps']();
 }
@@ -1050,6 +1066,10 @@ export function GetSpotColors() {
   return window['go']['main']['App']['GetSpotColors']();
 }
 
+export function GetSpotMax() {
+  return window['go']['main']['App']['GetSpotMax']();
+}
+
 export function GetSpotTTLMinutes() {
   return window['go']['main']['App']['GetSpotTTLMinutes']();
 }
@@ -1730,6 +1750,10 @@ export function RefreshCtyDat() {
   return window['go']['main']['App']['RefreshCtyDat']();
 }
 
+export function RefreshKenwood() {
+  return window['go']['main']['App']['RefreshKenwood']();
+}
+
 export function RefreshSolar() {
   return window['go']['main']['App']['RefreshSolar']();
 }
@@ -1918,6 +1942,10 @@ export function SaveFlexBandPower(arg1) {
   return window['go']['main']['App']['SaveFlexBandPower'](arg1);
 }
 
+export function SaveFlexRSTChase(arg1) {
+  return window['go']['main']['App']['SaveFlexRSTChase'](arg1);
+}
+
 export function SaveFlexZoom(arg1) {
   return window['go']['main']['App']['SaveFlexZoom'](arg1);
 }
@@ -2122,10 +2150,74 @@ export function SetDVKLabel(arg1, arg2) {
   return window['go']['main']['App']['SetDVKLabel'](arg1, arg2);
 }
 
+export function SetFlexRSTChaseEnabled(arg1) {
+  return window['go']['main']['App']['SetFlexRSTChaseEnabled'](arg1);
+}
+
+export function SetKenwoodAFGain(arg1) {
+  return window['go']['main']['App']['SetKenwoodAFGain'](arg1);
+}
+
+export function SetKenwoodAGC(arg1) {
+  return window['go']['main']['App']['SetKenwoodAGC'](arg1);
+}
+
+export function SetKenwoodAntenna(arg1) {
+  return window['go']['main']['App']['SetKenwoodAntenna'](arg1);
+}
+
+export function SetKenwoodAtt(arg1) {
+  return window['go']['main']['App']['SetKenwoodAtt'](arg1);
+}
+
+export function SetKenwoodFilter(arg1) {
+  return window['go']['main']['App']['SetKenwoodFilter'](arg1);
+}
+
 export function SetKenwoodKeySpeed(arg1) {
   return window['go']['main']['App']['SetKenwoodKeySpeed'](arg1);
 }
 
+export function SetKenwoodMicGain(arg1) {
+  return window['go']['main']['App']['SetKenwoodMicGain'](arg1);
+}
+
+export function SetKenwoodNB(arg1) {
+  return window['go']['main']['App']['SetKenwoodNB'](arg1);
+}
+
+export function SetKenwoodNR(arg1) {
+  return window['go']['main']['App']['SetKenwoodNR'](arg1);
+}
+
+export function SetKenwoodPower(arg1) {
+  return window['go']['main']['App']['SetKenwoodPower'](arg1);
+}
+
+export function SetKenwoodPreamp(arg1) {
+  return window['go']['main']['App']['SetKenwoodPreamp'](arg1);
+}
+
+export function SetKenwoodRFGain(arg1) {
+  return window['go']['main']['App']['SetKenwoodRFGain'](arg1);
+}
+
+export function SetKenwoodRIT(arg1) {
+  return window['go']['main']['App']['SetKenwoodRIT'](arg1);
+}
+
+export function SetKenwoodSquelch(arg1) {
+  return window['go']['main']['App']['SetKenwoodSquelch'](arg1);
+}
+
+export function SetKenwoodTX(arg1) {
+  return window['go']['main']['App']['SetKenwoodTX'](arg1);
+}
+
+export function SetKenwoodXIT(arg1) {
+  return window['go']['main']['App']['SetKenwoodXIT'](arg1);
+}
+
 export function SetLinkedAmps(arg1) {
   return window['go']['main']['App']['SetLinkedAmps'](arg1);
 }
@@ -2150,6 +2242,10 @@ export function SetScpEnabled(arg1) {
   return window['go']['main']['App']['SetScpEnabled'](arg1);
 }
 
+export function SetSpotMax(arg1) {
+  return window['go']['main']['App']['SetSpotMax'](arg1);
+}
+
 export function SetSpotTTLMinutes(arg1) {
   return window['go']['main']['App']['SetSpotTTLMinutes'](arg1);
 }
@@ -2338,6 +2434,14 @@ export function TestWebPublishFTP(arg1) {
   return window['go']['main']['App']['TestWebPublishFTP'](arg1);
 }
 
+export function ToggleKenwoodATU() {
+  return window['go']['main']['App']['ToggleKenwoodATU']();
+}
+
+export function TuneKenwoodATU() {
+  return window['go']['main']['App']['TuneKenwoodATU']();
+}
+
 export function TuneYaesuATU() {
   return window['go']['main']['App']['TuneYaesuATU']();
 }

frontend/wailsjs/go/models.ts

@@ -1067,6 +1067,72 @@ export namespace cat {
 	        this.anti_vox = source["anti_vox"];
 	    }
 	}
+	export class KenwoodTXState {
+	    available: boolean;
+	    model?: string;
+	    elecraft: boolean;
+	    mode?: string;
+	    transmitting: boolean;
+	    split: boolean;
+	    split_tx_hz: number;
+	    s_meter: number;
+	    s_meter_raw: number;
+	    power_meter: number;
+	    swr: number;
+	    swr_raw: number;
+	    rf_power: number;
+	    af_gain: number;
+	    rf_gain: number;
+	    mic_gain: number;
+	    squelch: number;
+	    preamp: boolean;
+	    att: boolean;
+	    nb: boolean;
+	    nr: boolean;
+	    agc?: string;
+	    filter_hz: number;
+	    antenna: number;
+	    rit: boolean;
+	    xit: boolean;
+	    key_speed: number;
+	    meters_provisional: boolean;
+	
+	    static createFrom(source: any = {}) {
+	        return new KenwoodTXState(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.available = source["available"];
+	        this.model = source["model"];
+	        this.elecraft = source["elecraft"];
+	        this.mode = source["mode"];
+	        this.transmitting = source["transmitting"];
+	        this.split = source["split"];
+	        this.split_tx_hz = source["split_tx_hz"];
+	        this.s_meter = source["s_meter"];
+	        this.s_meter_raw = source["s_meter_raw"];
+	        this.power_meter = source["power_meter"];
+	        this.swr = source["swr"];
+	        this.swr_raw = source["swr_raw"];
+	        this.rf_power = source["rf_power"];
+	        this.af_gain = source["af_gain"];
+	        this.rf_gain = source["rf_gain"];
+	        this.mic_gain = source["mic_gain"];
+	        this.squelch = source["squelch"];
+	        this.preamp = source["preamp"];
+	        this.att = source["att"];
+	        this.nb = source["nb"];
+	        this.nr = source["nr"];
+	        this.agc = source["agc"];
+	        this.filter_hz = source["filter_hz"];
+	        this.antenna = source["antenna"];
+	        this.rit = source["rit"];
+	        this.xit = source["xit"];
+	        this.key_speed = source["key_speed"];
+	        this.meters_provisional = source["meters_provisional"];
+	    }
+	}
 	export class RigState {
 	    enabled: boolean;
 	    connected: boolean;
@@ -1154,6 +1220,8 @@ export namespace cat {
 	    power_meter: number;
 	    swr_meter: number;
 	    rf_power: number;
+	    max_power: number;
+	    narrow_supported: boolean;
 	    mic_gain: number;
 	    af_gain: number;
 	    rf_gain: number;
@@ -1189,6 +1257,8 @@ export namespace cat {
 	        this.power_meter = source["power_meter"];
 	        this.swr_meter = source["swr_meter"];
 	        this.rf_power = source["rf_power"];
+	        this.max_power = source["max_power"];
+	        this.narrow_supported = source["narrow_supported"];
 	        this.mic_gain = source["mic_gain"];
 	        this.af_gain = source["af_gain"];
 	        this.rf_gain = source["rf_gain"];
@@ -2537,6 +2607,24 @@ export namespace main {
 	        this.body = source["body"];
 	    }
 	}
+	export class FlexRSTChase {
+	    enabled: boolean;
+	    markers: string;
+	    offset_hz: number;
+	    split_only: boolean;
+	
+	    static createFrom(source: any = {}) {
+	        return new FlexRSTChase(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.enabled = source["enabled"];
+	        this.markers = source["markers"];
+	        this.offset_hz = source["offset_hz"];
+	        this.split_only = source["split_only"];
+	    }
+	}
 	export class FlexZoomSettings {
 	    enabled: boolean;
 	    cw_khz: number;

hamlogcfm.go

@@ -34,6 +34,11 @@ import (
 	"hamlog/internal/qso"
 )
 
+// hamlogUnmatchedMax bounds what is kept for export. A whole log's worth of
+// unmatched records means the file belongs to another station, not that the
+// operator wants 50 000 of them written back out.
+const hamlogUnmatchedMax = 20000
+
 // HamlogCfmResult is what the import did.
 type HamlogCfmResult struct {
 	Total     int `json:"total"`     // records read from the file
@@ -42,7 +47,9 @@ type HamlogCfmResult struct {
 	ByClass   int `json:"by_class"`  // matched on mode CLASS rather than exact mode
 	Unmatched int `json:"unmatched"` // confirmations with no local QSO
 	// Samples names a few unmatched contacts, so "12 unmatched" can be looked
-	// into rather than merely worried about.
+	// into rather than merely worried about. The full list is kept for export —
+	// see ExportHamlogUnmatched — because 395 of them is not a sample-sized
+	// problem: it is a list to work through.
 	Samples []string `json:"samples"`
 }
 
@@ -86,6 +93,14 @@ func (a *App) ImportHamlogConfirmations(path string) (HamlogCfmResult, error) {
 	}
 	emit("Reading " + path + "…")
 
+	// What already counts towards an award, so each confirmation can be flagged
+	// NEW. LoTW and paper QSL are the two award-valid sources; a HAMLOG
+	// confirmation is "new" when it lands on a slot neither of them holds — which
+	// is the only sense in which it changes anything.
+	sets, _ := a.qso.ConfirmedSlots(ctx, []string{"lotw_rcvd", "qsl_rcvd"})
+	var items []ConfirmationItem
+	var unmatched []qso.QSO
+
 	perr := adif.Parse(f, func(rec adif.Record) error {
 		q, ok := adif.RecordToQSO(rec)
 		if !ok {
@@ -116,6 +131,9 @@ func (a *App) ImportHamlogConfirmations(path string) (HamlogCfmResult, error) {
 				res.Samples = append(res.Samples, fmt.Sprintf("%s · %s · %s · %s",
 					q.Callsign, q.QSODate.UTC().Format("2006-01-02 15:04Z"), q.Band, q.Mode))
 			}
+			if len(unmatched) < hamlogUnmatchedMax {
+				unmatched = append(unmatched, q)
+			}
 			return nil
 		}
 		date := hamlogCfmDate(rec)
@@ -128,12 +146,45 @@ func (a *App) ImportHamlogConfirmations(path string) (HamlogCfmResult, error) {
 		// from their website would otherwise read "never sent, yet confirmed".
 		_ = a.qso.SetExtra(ctx, id, hamlogSentKey, "Y")
 		res.Matched++
+
+		// Feed the Results view, the same rows the LoTW download produces: an
+		// import that only prints counts leaves the operator with no way to see
+		// WHICH contacts were confirmed, which is the reason they ran it.
+		a.enrichContactedFromCty(&q) // country/dxcc, for the entity flags
+		it := ConfirmationItem{
+			Callsign: q.Callsign,
+			QSODate:  q.QSODate.UTC().Format(time.RFC3339),
+			Band:     q.Band,
+			Mode:     q.Mode,
+			Country:  q.Country,
+		}
+		if q.DXCC != nil && *q.DXCC != 0 {
+			n := *q.DXCC
+			it.NewDXCC = !sets.DXCC[n]
+			it.NewBand = !sets.Band[qso.BandKey(n, q.Band)]
+			it.NewMode = !sets.Mode[qso.ModeClassKey(n, q.Mode)]
+			it.NewSlot = !sets.Slot[qso.SlotClassKey(n, q.Band, q.Mode)]
+			// Fold it in, so a repeat inside the same file isn't flagged twice.
+			sets.DXCC[n] = true
+			sets.Band[qso.BandKey(n, q.Band)] = true
+			sets.Mode[qso.ModeClassKey(n, q.Mode)] = true
+			sets.Slot[qso.SlotClassKey(n, q.Band, q.Mode)] = true
+		}
+		items = append(items, it)
 		return nil
 	})
 	if perr != nil {
 		return res, perr
 	}
 	a.invalidateAwardStats() // confirmations move award counts
+	// Kept for ExportHamlogUnmatched. Held rather than written now: the operator
+	// decides whether a list of 395 is worth a file.
+	a.hamlogUnmatchedMu.Lock()
+	a.hamlogUnmatched = unmatched
+	a.hamlogUnmatchedMu.Unlock()
+	if a.ctx != nil {
+		wruntime.EventsEmit(a.ctx, "qslmgr:confirmations", items)
+	}
 	applog.Printf("hamlog cfm import: %d records, %d confirmed, %d matched (%d by mode class), %d unmatched",
 		res.Total, res.Confirmed, res.Matched, res.ByClass, res.Unmatched)
 	emit(fmt.Sprintf("%d records read, %d confirmed by HAMLOG.online, %d matched in the log (%d by mode class), %d unmatched",
@@ -141,12 +192,47 @@ func (a *App) ImportHamlogConfirmations(path string) (HamlogCfmResult, error) {
 	for _, s := range res.Samples {
 		emit("  unmatched: " + s)
 	}
+	if res.Unmatched > len(res.Samples) {
+		emit(fmt.Sprintf("  …and %d more — use \"Export unmatched (ADIF)…\" to get the whole list.",
+			res.Unmatched-len(res.Samples)))
+	}
 	if a.ctx != nil {
 		wruntime.EventsEmit(a.ctx, "qslmgr:done", map[string]any{"uploaded": res.Matched, "total": res.Confirmed})
 	}
 	return res, nil
 }
 
+// ExportHamlogUnmatched writes the confirmations the last import could not
+// place onto a QSO.
+//
+// They are the interesting half of the result: each one is a contact HAMLOG
+// believes it holds and this log does not agree about — a minute of drift, a
+// portable call, a band written differently, or a QSO genuinely missing. A
+// count cannot be worked through; a file can be opened, sorted and compared.
+//
+// Written as ADIF because that is what every other tool reads, and because it
+// can be handed straight back to an import once the discrepancies are settled.
+func (a *App) ExportHamlogUnmatched(path string) (int, error) {
+	a.hamlogUnmatchedMu.Lock()
+	rows := a.hamlogUnmatched
+	a.hamlogUnmatchedMu.Unlock()
+	if len(rows) == 0 {
+		return 0, fmt.Errorf("nothing to export: the last import left no unmatched confirmations")
+	}
+	if strings.TrimSpace(path) == "" {
+		return 0, fmt.Errorf("empty path")
+	}
+	recs := make([]string, 0, len(rows))
+	for i := range rows {
+		recs = append(recs, adif.FullRecordADIF(rows[i]))
+	}
+	if err := os.WriteFile(path, []byte(adif.BatchRecordsADIF(recs)), 0o644); err != nil {
+		return 0, err
+	}
+	applog.Printf("hamlog cfm import: exported %d unmatched confirmation(s) to %s", len(rows), path)
+	return len(rows), nil
+}
+
 // hamlogQSLDateKey stamps WHEN the confirmation was read back. Their export
 // carries no confirmation date of its own, so this is the import date — which
 // is honest about what it knows, unlike borrowing the QSO date.

internal/award/award.go

@@ -344,7 +344,7 @@ func Migrate(defs []Def) ([]Def, bool) {
 func Fields() []string {
 	return []string{
 		"dxcc", "cqz", "ituz", "prefix", "callsign",
-		"state", "us_county", "cont", "country", "grid", "grid4",
+		"state", "county", "us_county", "cont", "country", "grid", "grid4",
 		"iota", "sota_ref", "pota_ref", "wwff",
 		"name", "qth", "address", "comment", "note",
 	}
@@ -1373,6 +1373,13 @@ func fieldRaw(field string, q *qso.QSO) string {
 		return q.Callsign
 	case "state":
 		return q.State
+	case "county":
+		// CNTY as it stands, with nothing prepended. us_county below answers a
+		// different question — it keys the county to its state, because two US
+		// states each have a Jefferson County. Outside the United States that
+		// prefixing is wrong: an RDA district (RO-19) and a Japanese city code
+		// are already unique, and a state is not what qualifies them.
+		return q.County
 	case "us_county":
 		return USCountyKey(q.State, q.County)
 	case "cont":

internal/award/fieldvalue_county_test.go

@@ -0,0 +1,29 @@
+package award
+
+import (
+	"testing"
+
+	"hamlog/internal/qso"
+)
+
+// A district lives in CNTY as-is; the US award field keys it to the state
+// because county names repeat across states. Confusing the two silently breaks
+// whichever award is not American.
+func TestCountyFieldIsRawWhileUSCountyIsKeyed(t *testing.T) {
+	q := &qso.QSO{State: "TX", County: "RO-19"}
+	if got := fieldRaw("county", q); got != "RO-19" {
+		t.Fatalf("county = %q, want RO-19", got)
+	}
+	if got := fieldRaw("us_county", q); got == "RO-19" {
+		t.Fatalf("us_county should key the county to its state, got %q", got)
+	}
+	var found bool
+	for _, f := range Fields() {
+		if f == "county" {
+			found = true
+		}
+	}
+	if !found {
+		t.Fatal("county missing from the award field list")
+	}
+}

internal/cat/cat.go

@@ -487,6 +487,8 @@ type FlexController interface {
 	// keeps freqMHz inside it, re-centring when it must. See Flex.ZoomPan.
 	ZoomPan(bandwidthMHz, freqMHz float64, centre bool) error
 	SetTXSlice(int) error // make slice idx the transmitter (tx=1)
+	// SetTXSliceFrequency moves the TRANSMIT slice only — split pile-up chasing.
+	SetTXSliceFrequency(int64) error
 	SetSplit(bool) error
 	SetNB(bool) error
 	SetNBLevel(int) error
@@ -988,6 +990,30 @@ type KenwoodController interface {
 	SetKeySpeed(int) error
 }
 
+// KenwoodState returns the K3/K4 panel snapshot, or (zero, false) when the
+// active backend is not a Kenwood-dialect rig.
+func (m *Manager) KenwoodState() (KenwoodTXState, bool) {
+	m.mu.RLock()
+	b := m.backend
+	m.mu.RUnlock()
+	if kc, ok := b.(KenwoodPanelController); ok {
+		return kc.KenwoodState(), true
+	}
+	return KenwoodTXState{}, false
+}
+
+// KenwoodPanelDo dispatches a K3/K4 panel control onto the CAT goroutine, so a
+// panel click and the poll loop never share the serial port at the same instant.
+func (m *Manager) KenwoodPanelDo(fn func(KenwoodPanelController) error) error {
+	return m.exec(func(b Backend) error {
+		kc, ok := b.(KenwoodPanelController)
+		if !ok {
+			return fmt.Errorf("active CAT backend is not a Kenwood/Elecraft")
+		}
+		return fn(kc)
+	})
+}
+
 // KenwoodDo dispatches a Kenwood control onto the CAT goroutine.
 func (m *Manager) KenwoodDo(fn func(KenwoodController) error) error {
 	return m.exec(func(b Backend) error {

internal/cat/flex.go

@@ -60,6 +60,9 @@ type Flex struct {
 	txRawLogged    bool         // log the first raw transmit status once (field-name audit)
 
 	spotsEnabled    bool           // push cluster spots + manage the panadapter overlay
+	// foreignSpotSeen counts what probeForeignSpot has already reported, so a
+	// skimmer posting all evening cannot turn the log into its own transcript.
+	foreignSpotSeen int
 	spotIdx         map[int]bool   // panadapter spot indices currently known to the radio
 	pendingSpot     map[int]string // seq → callsign, awaiting the spot index in the R response
 	pendingSpotMode map[int]string // seq → ADIF mode, paired with pendingSpot
@@ -92,6 +95,16 @@ type Flex struct {
 	// the spot, since the radio's own notification carries only an index. The host
 	// wires this to fill the entry form and to size the panadapter. Set before Connect.
 	OnSpotClick func(callsign string, freqHz int64, mode string)
+
+	// OnForeignSpot is called for every spot posted to the radio by a program
+	// OTHER than OpsLog, with the spot's callsign field and its frequency.
+	//
+	// A CW skimmer posts what it decodes, so the marker a DX operator's report
+	// leaves on the panadapter arrives here — that is what the split chaser acts
+	// on. Deliberately raw: this package reports what the radio said and does not
+	// decide what a marker looks like, because the marker text is configured in
+	// the skimmer, by the operator, and only they know what they chose.
+	OnForeignSpot func(callsign string, freqHz int64)
 }
 
 // panView is one panadapter's visible window, in MHz.
@@ -278,11 +291,18 @@ func (f *Flex) Connect() error {
 	f.send("sub pan all")       // panadapter centre/bandwidth, so a zoom knows where the display already is
 	f.send("sub client all")    // learn the GUI client (SmartSDR) so we can bind to it (below)
 	f.startMeters(conn)         // open the UDP VITA-49 stream for live meters
+	// Always subscribed, even when OpsLog draws no spots of its own: the feed is
+	// read-only and it is how the spots posted by OTHER programs arrive — a CW
+	// skimmer's decoded reports, which the split chaser acts on. Tying the
+	// subscription to our own overlay meant a station using SDC and no OpsLog
+	// spots heard nothing at all.
+	f.send("sub spot all")
 	if f.spotsEnabled {
-		// Subscribe so the radio pushes existing spots (we learn their indices),
-		// then wipe the panadapter so stale spots from a previous session or
-		// another logger are cleared before we start adding our own.
-		f.send("sub spot all")
+		// Wipe the panadapter so stale spots from a previous session or another
+		// logger are cleared before we start adding our own. Only when the
+		// overlay is ours to manage: "spot clear" removes EVERY spot on the
+		// radio, a skimmer's included, and taking those away from an operator
+		// who never asked us to draw anything would be pure vandalism.
 		go f.clearSpotsOnConnect(conn)
 	}
 	return nil
@@ -883,6 +903,10 @@ func (f *Flex) handleStatus(payload string) {
 					f.spotIdx[idx] = true
 				}
 				f.mu.Unlock()
+				if !removed {
+					f.probeForeignSpot(payload)
+					f.reportForeignSpot(payload)
+				}
 			}
 			debugLog.Printf("Flex: status %s", payload)
 		}
@@ -1377,6 +1401,105 @@ func (f *Flex) ZoomPan(bandwidthMHz, freqMHz float64, centre bool) error {
 	return nil
 }
 
+// foreignSpotProbeMax bounds the probe below. Enough lines to see what another
+// program writes into a spot, few enough that a running skimmer — which posts
+// hundreds an hour — cannot fill the log file with them.
+const foreignSpotProbeMax = 60
+
+// probeForeignSpot records, verbatim, the spots this radio receives from
+// programs OTHER than OpsLog.
+//
+// A CW skimmer (SDC, for one) posts what it decodes as panadapter spots, the
+// exchange included: chasing a split pileup means finding the "5NN" the DX just
+// sent and moving the transmit slice there. Acting on that requires knowing
+// exactly what the spot looks like — which field carries the text, whether the
+// report is the callsign or the comment, what source names the skimmer — and no
+// amount of reasoning substitutes for reading real lines off a real radio.
+//
+// So this logs and does nothing else. It is deliberately not a feature.
+func (f *Flex) probeForeignSpot(payload string) {
+	if strings.Contains(payload, "source=OpsLog") {
+		return
+	}
+	f.mu.Lock()
+	if f.foreignSpotSeen >= foreignSpotProbeMax {
+		f.mu.Unlock()
+		return
+	}
+	f.foreignSpotSeen++
+	n := f.foreignSpotSeen
+	f.mu.Unlock()
+	debugLog.Printf("flex: foreign spot %d/%d: %s", n, foreignSpotProbeMax, payload)
+	if n == foreignSpotProbeMax {
+		debugLog.Printf("flex: that is enough foreign spots to go on — no more will be logged this session")
+	}
+}
+
+// reportForeignSpot hands another program's spot to OnForeignSpot.
+//
+// Off the reader goroutine, like OnSpotClick: the handler tunes the radio, and
+// a command sent from inside the reader would deadlock against the socket it is
+// reading.
+func (f *Flex) reportForeignSpot(payload string) {
+	if strings.Contains(payload, "source=OpsLog") {
+		return
+	}
+	handler := f.OnForeignSpot
+	if handler == nil {
+		return
+	}
+	var call string
+	var hz int64
+	for _, kv := range strings.Fields(payload) {
+		eq := strings.IndexByte(kv, '=')
+		if eq <= 0 {
+			continue
+		}
+		switch kv[:eq] {
+		case "callsign":
+			call = kv[eq+1:]
+		case "rx_freq":
+			if mhz, err := strconv.ParseFloat(kv[eq+1:], 64); err == nil {
+				hz = int64(math.Round(mhz * 1e6))
+			}
+		}
+	}
+	if call == "" || hz <= 0 {
+		return
+	}
+	go handler(call, hz)
+}
+
+// SetTXSliceFrequency tunes the TRANSMIT slice, leaving the receive slice where
+// it is. That distinction is the whole point in split: the operator listens to
+// the DX on one slice and moves the other around the pile-up.
+func (f *Flex) SetTXSliceFrequency(hz int64) error {
+	if hz <= 0 {
+		return fmt.Errorf("flex: invalid frequency")
+	}
+	f.mu.Lock()
+	idx := -1
+	for i, s := range f.slices {
+		if s != nil && s.inUse && s.tx {
+			idx = i
+			break
+		}
+	}
+	if idx >= 0 && f.slices[idx] != nil {
+		f.slices[idx].freqHz = hz // optimistic, like SetFrequency
+	}
+	connected := f.conn != nil
+	f.mu.Unlock()
+	if idx < 0 {
+		return fmt.Errorf("flex: no transmit slice")
+	}
+	if !connected {
+		return fmt.Errorf("flex: not connected")
+	}
+	f.send(fmt.Sprintf("slice t %d %.6f", idx, float64(hz)/1e6))
+	return nil
+}
+
 // SendSpot renders a cluster spot on the panadapter via "spot add". Spots carry
 // a lifetime so the radio expires them on its own (the API has no "spot clear").
 // Per the SmartSDR API, spaces inside a field value are encoded as 0x7F.

internal/cat/kenwood.go

@@ -92,6 +92,16 @@ type Kenwood struct {
 	// Commands this rig answered "?;" to — asked once, then never again.
 	unsupported map[string]bool
 
+	// Panel state — the K3/K4 control panel, see kenwood_panel.go. Read on the
+	// same serialised link as everything else, on a slow beat for the settings
+	// and every poll for the meters.
+	panel        KenwoodTXState
+	panelCycle   int
+	panelLoaded  bool
+	metersLogged int
+	powerPeak    meterPeak
+	swrPeak      meterPeak
+
 	// rx holds bytes read but not yet consumed, ACROSS calls to ask.
 	//
 	// It has to survive: a rig answers faster than we ask, so one Read often
@@ -422,6 +432,10 @@ func (k *Kenwood) ReadState() (RigState, error) {
 		k.curRXFreq = s.RxFreqHz
 	}
 	k.lastState = s // cache for the transmit window, where we can't poll
+	// The panel rides on the same poll and the same held mutex: its own reader
+	// would have to take turns on the serial port, and the K3 is slow enough
+	// that two readers taking turns is what makes a dial lag.
+	k.readPanel(s.Mode, s.Split, s.FreqHz)
 	return s, nil
 }
 

internal/cat/kenwood_panel.go

@@ -0,0 +1,554 @@
+package cat
+
+// Elecraft K3/K4 control panel — power, volume, S-meter, SWR, MOX and ATU tune.
+//
+// Built on the Kenwood-dialect backend, because a K3 speaks it: plain ASCII,
+// every command terminated by ';'. What is Elecraft-specific is the vocabulary
+// below, taken from the K3 Programmer's Reference; the K4 accepts the same set.
+//
+// NO K3 WAS AVAILABLE WHILE WRITING THIS, and that shapes it:
+//
+//   - The commands that SET something are the ones the reference documents
+//     unambiguously and whose effect is visible and reversible (PC, AG, TX/RX).
+//   - The meters are the opposite: their scaling differs between models and
+//     firmware, and a wrongly scaled SWR bar is worse than none — it reports a
+//     good match on a bad antenna. So the raw answers are LOGGED, for a real
+//     radio to settle, and until then the panel says the scaling is provisional.
+//
+// The same discipline as the Yaesu meters, which were guessed wrong twice and
+// only settled when an FTDX10 keyed a carrier at two known power levels.
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// KenwoodTXState is what the panel shows.
+type KenwoodTXState struct {
+	Available bool   `json:"available"`
+	Model     string `json:"model,omitempty"`
+	Elecraft  bool   `json:"elecraft"` // a K3/K4 rather than a Kenwood
+	Mode      string `json:"mode,omitempty"`
+
+	Transmitting bool  `json:"transmitting"`
+	Split        bool  `json:"split"`
+	SplitTXHz    int64 `json:"split_tx_hz"`
+
+	// SMeter is 0-100 for the bar. SMeterRaw is what the rig actually answered,
+	// kept because the scaling is not yet confirmed on a real K3 and a number
+	// nobody can check is worth less than the reading it came from.
+	SMeter    int `json:"s_meter"`
+	SMeterRaw int `json:"s_meter_raw"`
+	// PowerMeter is 0-100 while transmitting. SWR is the ratio; 0 means "not
+	// measured", NOT a perfect match.
+	PowerMeter int     `json:"power_meter"`
+	SWR        float64 `json:"swr"`
+	SWRRaw     int     `json:"swr_raw"`
+
+	RFPower int `json:"rf_power"` // watts, the PC setting
+	AFGain  int `json:"af_gain"`  // 0-100
+	RFGain  int `json:"rf_gain"`  // 0-100
+	MicGain int `json:"mic_gain"` // 0-100
+	Squelch int `json:"squelch"`  // 0-100
+
+	// Receive controls. Preamp and attenuator are the K3's single-step ones
+	// (PA/RA); a rig that answers neither leaves them false and the row shows
+	// the state it read, not a state it assumed.
+	Preamp bool   `json:"preamp"`
+	Att    bool   `json:"att"`
+	NB     bool   `json:"nb"`
+	NR     bool   `json:"nr"`
+	AGC    string `json:"agc,omitempty"` // "OFF", "SLOW", "FAST"
+	// FilterHz is the DSP bandwidth in Hz (the K3 reports it in 10 Hz units).
+	FilterHz int `json:"filter_hz"`
+	// Antenna is 1 or 2 on a K3 with the internal ATU, 0 when the rig does not
+	// answer AN — which is also how the panel knows to hide the row rather than
+	// offer a switch that goes nowhere.
+	Antenna int `json:"antenna"`
+
+	RIT      bool `json:"rit"`
+	XIT      bool `json:"xit"`
+	KeySpeed int  `json:"key_speed"` // WPM
+
+	// MetersProvisional says the meter scaling has not been confirmed against a
+	// real radio. The panel says so rather than presenting a guess as a
+	// measurement.
+	MetersProvisional bool `json:"meters_provisional"`
+}
+
+// KenwoodPanelController is the K3/K4 panel capability. Separate from
+// KenwoodController (the CW keyer) so a backend can offer one without the other.
+type KenwoodPanelController interface {
+	KenwoodState() KenwoodTXState
+	RefreshKenwood() error
+	SetKenwoodPower(int) error
+	SetKenwoodAFGain(int) error
+	SetKenwoodRFGain(int) error
+	SetKenwoodMicGain(int) error
+	SetKenwoodSquelch(int) error
+	SetKenwoodPreamp(bool) error
+	SetKenwoodAtt(bool) error
+	SetKenwoodNB(bool) error
+	SetKenwoodNR(bool) error
+	SetKenwoodAGC(string) error
+	SetKenwoodFilter(int) error
+	SetKenwoodAntenna(int) error
+	SetKenwoodRIT(bool) error
+	SetKenwoodXIT(bool) error
+	ClearKenwoodRIT() error
+	SetKenwoodTX(bool) error
+	TuneKenwoodATU() error
+	ToggleKenwoodATU() error
+}
+
+// kenwoodPanelSlowBeat is how many polls pass between full re-reads of the
+// settings. The meters are read every poll; a power setting is not.
+const kenwoodPanelSlowBeat = 8
+
+// KenwoodState returns the panel snapshot.
+func (k *Kenwood) KenwoodState() KenwoodTXState {
+	k.mu.Lock()
+	defer k.mu.Unlock()
+	st := k.panel
+	st.Available = k.port != nil
+	st.Model = k.model
+	st.Elecraft = k.elecraft
+	return st
+}
+
+// RefreshKenwood forces the settings to be re-read on the next poll, so a value
+// changed on the radio's own front panel shows up at once.
+func (k *Kenwood) RefreshKenwood() error {
+	k.mu.Lock()
+	k.panelCycle = kenwoodPanelSlowBeat
+	k.mu.Unlock()
+	return nil
+}
+
+// readPanel refreshes the panel. Called from ReadState with the mutex HELD, so
+// it shares the same serialised link as everything else.
+func (k *Kenwood) readPanel(mode string, split bool, txHz int64) {
+	k.panel.Mode = mode
+	k.panel.Split = split
+	k.panel.SplitTXHz = 0
+	if split {
+		k.panel.SplitTXHz = txHz
+	}
+	k.panel.Transmitting = k.tx
+	k.panel.MetersProvisional = true
+
+	if k.panel.Transmitting {
+		k.readTXMeters()
+	} else {
+		// Cleared, not frozen: a power bar left standing after the carrier drops
+		// reads as a live transmission.
+		k.panel.PowerMeter = 0
+		k.panel.SWR, k.panel.SWRRaw = 0, 0
+		k.powerPeak, k.swrPeak = meterPeak{}, meterPeak{}
+		// The S-meter only means anything while receiving.
+		if v, ok := k.askNum("SM;", "SM", 4); ok {
+			k.panel.SMeterRaw = v
+			k.panel.SMeter = kenwoodSMeterPercent(v)
+		}
+	}
+
+	k.panelCycle++
+	if k.panelLoaded && k.panelCycle < kenwoodPanelSlowBeat {
+		return
+	}
+	k.panelCycle = 0
+	k.panelLoaded = true
+	k.readPanelSettings()
+}
+
+// readPanelSettings re-reads what a knob can change.
+func (k *Kenwood) readPanelSettings() {
+	// PC is watts on both the K3 and the Kenwoods — a setting, not a scale.
+	if v, ok := k.askNum("PC;", "PC", 3); ok {
+		k.panel.RFPower = v
+	}
+	// AF gain. The K3 answers three digits 000-255; a Kenwood answers AG0nnn,
+	// which is why the plain form is tried first and the addressed one after.
+	if v, ok := k.askNum("AG;", "AG", 3); ok {
+		k.panel.AFGain = scale255(v)
+	} else if v, ok := k.askNum("AG0;", "AG0", 3); ok {
+		k.panel.AFGain = scale255(v)
+	}
+	// RF gain. The K3 counts 000-250 in dB of reduction; a Kenwood uses the
+	// familiar 0-255. Both are shown as a percentage, so the slider means the
+	// same thing on either radio.
+	if v, ok := k.askNum("RG;", "RG", 3); ok {
+		k.panel.RFGain = scalePercent(v, k.rfGainFull())
+	}
+	if v, ok := k.askNum("MG;", "MG", 3); ok {
+		k.panel.MicGain = scalePercent(v, k.micGainFull())
+	}
+	if v, ok := k.askNum("SQ;", "SQ", 3); ok {
+		k.panel.Squelch = scalePercent(v, k.squelchFull())
+	} else if v, ok := k.askNum("SQ0;", "SQ0", 3); ok {
+		k.panel.Squelch = scale255(v)
+	}
+	if v, ok := k.askNum("PA;", "PA", 1); ok {
+		k.panel.Preamp = v != 0
+	}
+	if v, ok := k.askNum("RA;", "RA", 2); ok {
+		k.panel.Att = v != 0
+	}
+	if v, ok := k.askNum("NB;", "NB", 1); ok {
+		k.panel.NB = v != 0
+	}
+	if v, ok := k.askNum("NR;", "NR", 1); ok {
+		k.panel.NR = v != 0
+	}
+	if v, ok := k.askNum("GT;", "GT", 3); ok {
+		k.panel.AGC = kenwoodAGCName(v)
+	}
+	// Filter width. The K3 answers BW in 10 Hz units (BW0270 = 2.7 kHz); a
+	// Kenwood that does not implement it says nothing and the row stays as it
+	// was rather than showing a zero-width filter.
+	if v, ok := k.askNum("BW;", "BW", 4); ok && v > 0 {
+		k.panel.FilterHz = v * 10
+	}
+	// Antenna. Only a K3 with the internal ATU answers; 0 means "this radio has
+	// no antenna switching", which is what hides the row.
+	if v, ok := k.askNum("AN;", "AN", 1); ok {
+		k.panel.Antenna = v
+	}
+	if v, ok := k.askNum("RT;", "RT", 1); ok {
+		k.panel.RIT = v != 0
+	}
+	if v, ok := k.askNum("XT;", "XT", 1); ok {
+		k.panel.XIT = v != 0
+	}
+	if v, ok := k.askNum("KS;", "KS", 3); ok {
+		k.panel.KeySpeed = v
+	}
+}
+
+// The full-scale value of the analogue controls differs between an Elecraft and
+// a Kenwood, and using one rig's scale on the other silently halves or doubles
+// every setting. Kept as three small functions rather than a table so each one
+// carries the range it comes from.
+func (k *Kenwood) rfGainFull() int {
+	if k.elecraft {
+		return 250 // K3: 000-250, dB of reduction
+	}
+	return 255
+}
+
+func (k *Kenwood) micGainFull() int {
+	if k.elecraft {
+		return 60 // K3: 000-060
+	}
+	return 255
+}
+
+func (k *Kenwood) squelchFull() int {
+	if k.elecraft {
+		return 29 // K3: 000-029
+	}
+	return 255
+}
+
+// scalePercent turns a raw value into 0-100 against its own full scale.
+func scalePercent(v, full int) int {
+	if full <= 0 || v <= 0 {
+		return 0
+	}
+	if v >= full {
+		return 100
+	}
+	return v * 100 / full
+}
+
+// kenwoodAGCName decodes GT. The K3 answers 000 (off), 002 (slow) or 004
+// (fast); a Kenwood uses the same three values for the same three states.
+func kenwoodAGCName(v int) string {
+	switch {
+	case v == 0:
+		return "OFF"
+	case v <= 2:
+		return "SLOW"
+	default:
+		return "FAST"
+	}
+}
+
+// kenwoodAGCValue is the inverse, for the buttons.
+func kenwoodAGCValue(name string) int {
+	switch strings.ToUpper(strings.TrimSpace(name)) {
+	case "OFF":
+		return 0
+	case "SLOW":
+		return 2
+	default:
+		return 4
+	}
+}
+
+// kenwoodMeterProbes are the candidate meter commands, asked once per
+// transmission burst so a real radio can settle what they mean.
+//
+// They are NOT interchangeable — BG is a bargraph position, SM during transmit
+// is something else again — which is exactly why the log records which one
+// answered and what it said, next to the power SETTING: the meter that tracks a
+// known carrier at two different power levels is the power meter, and no amount
+// of reading the reference settles that as well as one transmission does.
+var kenwoodMeterProbes = []struct {
+	cmd    string
+	prefix string
+	digits int
+}{
+	{"SM;", "SM", 4},
+	{"BG;", "BG", 2},
+	{"SW;", "SW", 4},
+	{"PO;", "PO", 3},
+}
+
+// readTXMeters reads the transmit meters.
+func (k *Kenwood) readTXMeters() {
+	now := time.Now()
+	if v, ok := k.askNum("BG;", "BG", 2); ok {
+		k.panel.PowerMeter = k.powerPeak.update(kenwoodBargraphPercent(v), now)
+	}
+	if v, ok := k.askNum("SW;", "SW", 4); ok {
+		k.panel.SWRRaw = v
+		// Tenths of a ratio, provisionally: 15 → 1.5. Reported as raw as well,
+		// so the log can correct this without anyone having to trust the bar.
+		if v > 0 {
+			k.panel.SWR = float64(k.swrPeak.update(v, now)) / 10
+		}
+	}
+	if k.metersLogged >= 20 {
+		return
+	}
+	k.metersLogged++
+	raw := make([]string, 0, len(kenwoodMeterProbes))
+	for _, p := range kenwoodMeterProbes {
+		if v, ok := k.askNum(p.cmd, p.prefix, p.digits); ok {
+			raw = append(raw, fmt.Sprintf("%s=%d", strings.TrimSuffix(p.cmd, ";"), v))
+		} else {
+			raw = append(raw, strings.TrimSuffix(p.cmd, ";")+"=-")
+		}
+	}
+	debugLog.Printf("kenwood: TX meters at PC=%dW: %s (compare two power settings, and a known SWR)",
+		k.panel.RFPower, strings.Join(raw, " "))
+}
+
+// kenwoodSMeterPercent turns the S-meter answer into a bar percentage.
+//
+// The K3 reports 0-21 across S0…S9+60, which is not a linear dB scale but is
+// what its own display shows — and matching the radio's own bar is something an
+// operator can check at a glance. A Kenwood answers 0-30 on the same command;
+// both are covered by clamping rather than by guessing which rig is on the
+// other end.
+func kenwoodSMeterPercent(v int) int {
+	switch {
+	case v <= 0:
+		return 0
+	case v >= 30:
+		return 100
+	}
+	return v * 100 / 21
+}
+
+// kenwoodBargraphPercent scales the K3 bargraph (0-12 segments) to the bar.
+func kenwoodBargraphPercent(v int) int {
+	switch {
+	case v <= 0:
+		return 0
+	case v >= 12:
+		return 100
+	}
+	return v * 100 / 12
+}
+
+// SetKenwoodPower sets the transmit power, in watts.
+//
+// A K3 takes PC000-110: 110 rather than 100 because the radio will make a
+// little over its rated output and the reference says so. A Kenwood of the
+// TS-890 sort goes to 200, so the ceiling follows the radio rather than being
+// one number that is wrong for one of them.
+func (k *Kenwood) SetKenwoodPower(w int) error {
+	max := 200
+	if k.elecraft {
+		max = 110
+	}
+	if w < 0 {
+		w = 0
+	}
+	if w > max {
+		w = max
+	}
+	return k.setPanel(fmt.Sprintf("PC%03d;", w))
+}
+
+// SetKenwoodAFGain sets the volume, 0-100, scaled to the rig's 0-255.
+func (k *Kenwood) SetKenwoodAFGain(p int) error {
+	if p < 0 {
+		p = 0
+	}
+	if p > 100 {
+		p = 100
+	}
+	return k.setPanel(fmt.Sprintf("AG%03d;", p*255/100))
+}
+
+// SetKenwoodRFGain sets the RF gain, 0-100 of the rig's own scale.
+func (k *Kenwood) SetKenwoodRFGain(p int) error {
+	return k.setPanel(fmt.Sprintf("RG%03d;", clampPercentTo(p, k.rfGainFull())))
+}
+
+func (k *Kenwood) SetKenwoodMicGain(p int) error {
+	return k.setPanel(fmt.Sprintf("MG%03d;", clampPercentTo(p, k.micGainFull())))
+}
+
+func (k *Kenwood) SetKenwoodSquelch(p int) error {
+	return k.setPanel(fmt.Sprintf("SQ%03d;", clampPercentTo(p, k.squelchFull())))
+}
+
+func (k *Kenwood) SetKenwoodPreamp(on bool) error {
+	return k.setPanel(fmt.Sprintf("PA%d;", boolDigit(on)))
+}
+
+// SetKenwoodAtt switches the attenuator. Two digits: the K3 reads RA01 as its
+// single 10 dB pad, and a Kenwood with several steps takes the first one.
+func (k *Kenwood) SetKenwoodAtt(on bool) error {
+	if on {
+		return k.setPanel("RA01;")
+	}
+	return k.setPanel("RA00;")
+}
+
+func (k *Kenwood) SetKenwoodNB(on bool) error {
+	return k.setPanel(fmt.Sprintf("NB%d;", boolDigit(on)))
+}
+
+func (k *Kenwood) SetKenwoodNR(on bool) error {
+	return k.setPanel(fmt.Sprintf("NR%d;", boolDigit(on)))
+}
+
+func (k *Kenwood) SetKenwoodAGC(name string) error {
+	return k.setPanel(fmt.Sprintf("GT%03d;", kenwoodAGCValue(name)))
+}
+
+// SetKenwoodFilter sets the DSP bandwidth in Hz — sent in the K3's 10 Hz units.
+func (k *Kenwood) SetKenwoodFilter(hz int) error {
+	if hz < 50 {
+		hz = 50
+	}
+	if hz > 4000 {
+		hz = 4000
+	}
+	return k.setPanel(fmt.Sprintf("BW%04d;", hz/10))
+}
+
+// SetKenwoodAntenna selects antenna 1 or 2 (a K3 with the internal ATU).
+func (k *Kenwood) SetKenwoodAntenna(n int) error {
+	if n < 1 {
+		n = 1
+	}
+	if n > 2 {
+		n = 2
+	}
+	return k.setPanel(fmt.Sprintf("AN%d;", n))
+}
+
+func (k *Kenwood) SetKenwoodRIT(on bool) error {
+	return k.setPanel(fmt.Sprintf("RT%d;", boolDigit(on)))
+}
+
+func (k *Kenwood) SetKenwoodXIT(on bool) error {
+	return k.setPanel(fmt.Sprintf("XT%d;", boolDigit(on)))
+}
+
+// ClearKenwoodRIT zeroes the RIT/XIT offset, both at once — which is what RC
+// does and what the operator means by "clear it".
+func (k *Kenwood) ClearKenwoodRIT() error {
+	return k.setPanel("RC;")
+}
+
+// clampPercentTo maps 0-100 onto a rig's own full scale.
+func clampPercentTo(p, full int) int {
+	if p < 0 {
+		p = 0
+	}
+	if p > 100 {
+		p = 100
+	}
+	return p * full / 100
+}
+
+// SetKenwoodTX keys or unkeys the transmitter — the panel's MOX.
+//
+// Goes through SetPTT rather than writing TX;/RX; here, so the backend's own
+// idea of transmitting stays true: it suppresses polling while the carrier is
+// up, and a panel that keyed behind its back would leave it polling a rig that
+// answers "?;" to everything.
+func (k *Kenwood) SetKenwoodTX(on bool) error {
+	return k.SetPTT(on)
+}
+
+// The K3 has no dedicated "tune" command: the reference exposes the front panel
+// instead, through SWT (tap) and SWH (hold) with a switch number from Table 7.
+// Switch 19 is the ATU row — TAP starts a tuning cycle, HOLD puts the tuner in
+// or out of line.
+//
+// It was written as SWT20 first, from memory of the reference rather than from
+// the table, and 20 is not an ATU switch at all. Corrected against Table 7 of
+// the K3 Programmer's Reference, which an operator read out for us. Every send
+// is still logged: a switch-emulation command presses a real button on a real
+// front panel, so what OpsLog sent must be recoverable afterwards.
+const (
+	kenwoodATUTune   = "SWT19;" // tap ATU TUNE — start a tuning cycle
+	kenwoodATUToggle = "SWH19;" // hold ATU — tuner in line / bypassed
+)
+
+// TuneKenwoodATU starts an ATU tuning cycle.
+func (k *Kenwood) TuneKenwoodATU() error {
+	debugLog.Printf("kenwood: ATU tune — sending %q (K3 Table 7: tap of the ATU TUNE switch)", kenwoodATUTune)
+	return k.setPanel(kenwoodATUTune)
+}
+
+// ToggleKenwoodATU puts the tuner in line or bypasses it — the HOLD of the same
+// switch, which is how it is done on the radio itself.
+func (k *Kenwood) ToggleKenwoodATU() error {
+	debugLog.Printf("kenwood: ATU in/out — sending %q (K3 Table 7: hold of the ATU switch)", kenwoodATUToggle)
+	return k.setPanel(kenwoodATUToggle)
+}
+
+// setPanel writes one command and schedules a settings re-read, so the panel
+// shows what the radio did rather than what it was asked to do.
+func (k *Kenwood) setPanel(cmd string) error {
+	k.mu.Lock()
+	defer k.mu.Unlock()
+	if k.port == nil {
+		return fmt.Errorf("kenwood: not connected")
+	}
+	if err := k.write(cmd); err != nil {
+		return err
+	}
+	k.panelCycle = kenwoodPanelSlowBeat // re-read on the next poll
+	return nil
+}
+
+// askNum asks a command and parses its numeric body. ask() already remembers
+// what this rig answered "?;" to and refuses to ask it again, so an unsupported
+// meter costs one timeout for the life of the session, not one per poll.
+func (k *Kenwood) askNum(cmd, prefix string, digits int) (int, bool) {
+	r, err := k.ask(cmd)
+	if err != nil {
+		return 0, false
+	}
+	body := strings.TrimSuffix(strings.TrimPrefix(r, prefix), ";")
+	if len(body) < digits {
+		return 0, false
+	}
+	n, err := strconv.Atoi(strings.TrimSpace(body[:digits]))
+	if err != nil {
+		return 0, false
+	}
+	return n, true
+}

internal/cat/yaesu_panel.go

@@ -43,7 +43,15 @@ type YaesuTXState struct {
 	PowerMeter int   `json:"power_meter"` // 0-100, TX only
 	SWRMeter   int   `json:"swr_meter"`   // 0-100, TX only
 
-	RFPower int    `json:"rf_power"` // watts
+	RFPower int `json:"rf_power"` // watts
+	// MaxPower is what this model can actually be set to, so the slider stops
+	// where the radio does. An FTDX101MP is a 200 W transmitter and its operator
+	// could not ask for more than 100 W — the slider, not the rig, was the limit.
+	MaxPower int `json:"max_power"`
+	// NarrowSupported says the rig answered NA at all. A button that reports a
+	// state the radio never gave, and does nothing when pressed, is worse than
+	// an absent one: it looks like a fault in the radio.
+	NarrowSupported bool `json:"narrow_supported"`
 	MicGain int    `json:"mic_gain"` // 0-100
 	AFGain  int    `json:"af_gain"`  // 0-100
 	RFGain  int    `json:"rf_gain"`  // 0-100
@@ -110,9 +118,29 @@ func (y *Yaesu) YaesuState() YaesuTXState {
 	st := y.panel
 	st.Available = y.port != nil
 	st.Model = y.model
+	st.MaxPower = yaesuMaxPower(y.model, st.RFPower)
 	return st
 }
 
+// yaesuMaxPower is how far the power slider may go on this model.
+//
+// The rig itself is never asked — there is no CAT command for "how much power
+// can you make" — so it comes from the model name, with one safeguard: a rig
+// REPORTING more than the table expects is believed, because it has just proved
+// what it can do. Anything unknown gets 100 W, which is the family default and
+// errs towards asking for too little.
+func yaesuMaxPower(model string, reported int) int {
+	max := 100
+	switch {
+	case strings.Contains(model, "101MP"), strings.Contains(model, "5000"), strings.Contains(model, "9000"):
+		max = 200
+	}
+	if reported > max {
+		max = reported
+	}
+	return max
+}
+
 // readPanel refreshes the meters, and the settings on the slower beat. Called
 // from ReadState with the mutex HELD, so it shares the same serialised link.
 func (y *Yaesu) readPanel(mode string, split bool, txHz int64) {
@@ -226,8 +254,15 @@ func (y *Yaesu) readPanelSettings() {
 	if v, ok := y.askNum("PC;", "PC", 3); ok {
 		y.panel.RFPower = v // watts, not a 0-255 scale
 	}
+	// MIC GAIN IS 0-100, not 0-255.
+	//
+	// It was read through the 0-255 scale like the audio gains, so an FTDX101
+	// set to 80 showed 38 — and worse, writing sent 80 → 204, outside the range
+	// the rig accepts, so the setting was refused and the slider sprang back to
+	// where it had been. Reported from a real FTDX101; the CAT reference gives
+	// MG000-100 for the whole current family.
 	if v, ok := y.askNum("MG;", "MG", 3); ok {
-		y.panel.MicGain = scale255(v)
+		y.panel.MicGain = clampInt(v, 0, 100)
 	}
 	if v, ok := y.askNum("AG0;", "AG0", 3); ok {
 		y.panel.AFGain = scale255(v)
@@ -276,6 +311,7 @@ func (y *Yaesu) readPanelSettings() {
 	}
 	if v, ok := y.askNum("NA0;", "NA0", 1); ok {
 		y.panel.Narrow = v != 0
+		y.panel.NarrowSupported = true
 	}
 	if v, ok := y.askNum("VX;", "VX", 1); ok {
 		y.panel.VOX = v != 0
@@ -356,7 +392,7 @@ func (y *Yaesu) SetYaesuPower(w int) error {
 }
 
 func (y *Yaesu) SetYaesuMicGain(p int) error {
-	return y.setAndRefresh(fmt.Sprintf("MG%03d;", from100(p)))
+	return y.setAndRefresh(fmt.Sprintf("MG%03d;", clampInt(p, 0, 100)))
 }
 
 func (y *Yaesu) SetYaesuAFGain(p int) error {

internal/extsvc/lotw.go

@@ -265,6 +265,22 @@ func UploadLoTW(ctx context.Context, cfg ServiceConfig, tempDir, adifRecord stri
 	// callsign certificate's validity is silently left out, and reporting that as
 	// success stamped it sent for ever. TQSL says which case it is in its output,
 	// so the message is carried up rather than replaced with a guess.
+	if code != 0 && LogSink != nil {
+		// The ADIF that was handed to TQSL, verbatim, and how TQSL was called.
+		//
+		// TQSL says "no QSOs processed" for several unrelated reasons — already
+		// uploaded, outside the certificate's dates, or a STATION_CALLSIGN that
+		// does not match the station location it was told to sign with — and its
+		// message does not distinguish them. An operator whose contact was
+		// refused, then accepted after a round trip through another logger, is
+		// reporting a difference in THIS RECORD, and there is no way to see it
+		// afterwards: the temp file is deleted as soon as TQSL returns.
+		//
+		// Nothing secret here: it is a QSO, and the key password is not logged.
+		LogSink("lotw: tqsl exit %d for station location %q", code, loc)
+		LogSink("lotw: record was: %s", strings.TrimSpace(adifRecord))
+	}
+
 	switch code {
 	case 0:
 		return UploadResult{OK: true, Message: "uploaded to LoTW"}, nil

telemetry.go

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