chore: release v0.23.5

Checking every profile made a denied call unrecoverable — the process quits
before the operator can change it, and no profile switch could get back in.
Gating on the active profile alone keeps "--profile <other>" as a way back in,
and still turns away a denied operator whose active call is the blocked one.

app.go

@@ -126,6 +126,7 @@ const (
 	// backend's setting.
 	keyCATYaesuLowLines    = "cat.yaesu.low_dtr_rts"   // deassert DTR/RTS on connect
 	keyCATKenwoodLowLines  = "cat.kenwood.low_dtr_rts" // deassert DTR/RTS on connect
+	keyCATKenwoodDataMode  = "cat.kenwood.data_mode"   // data modes → "usb" | "data" (MD6) | "keep"
 	keyCATIcomPort         = "cat.icom.port"           // Icom USB CI-V serial port (e.g. COM5)
 	keyCATIcomBaud         = "cat.icom.baud"           // Icom CI-V baud (default 115200)
 	keyCATIcomAddr         = "cat.icom.addr"           // Icom CI-V address, decimal (IC-7610 = 152 / 0x98)
@@ -403,6 +404,10 @@ type CATSettings struct {
 	// adapter). NOT the radio’s own RJ45, which speaks Kenwood’s KNS/ARCP.
 	KenwoodPort string `json:"kenwood_port"` // Kenwood CAT serial port (TS-590/890/2000, Elecraft)
 	KenwoodBaud int    `json:"kenwood_baud"` // Kenwood CAT baud (TS-590 default 9600)
+	// What a DATA/digital mode (FT8, PSK…) sets on the rig: "usb" (default), "data"
+	// (MD6 — Elecraft K3/K4 DATA mode) or "keep" (leave the rig's mode untouched,
+	// for a TS-590SG/TS-990S whose data mode is a USB modifier set on the rig).
+	KenwoodDataMode string `json:"kenwood_data_mode"`
 	// Per-backend: deassert DTR and RTS after opening the CAT port, for
 	// interfaces that read either line as PTT. Off by default: lowering them
 	// stops some USB-serial interfaces transmitting at all.
@@ -617,6 +622,12 @@ type App struct {
 	dvkRecSlot     int    // slot currently being recorded (DVKStartRecord → DVKStopRecord)
 	dvkPttKeyed    bool   // we keyed PTT for a voice message; unkey when it ends
 	pttMu          sync.Mutex
+	// confDLMu/confDLCancel cancel the in-flight confirmation download (LoTW/QRZ)
+	// so closing the QSL Manager — or starting another download — stops the previous
+	// one instead of leaving it running against the app-lifetime context (which made
+	// a still-running QRZ sync bleed its log into a freshly started LoTW download).
+	confDLMu       sync.Mutex
+	confDLCancel   context.CancelFunc
 	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)
 	relayAutoMu    sync.Mutex             // serialises relay auto-control evaluation
@@ -975,6 +986,12 @@ func (a *App) startup(ctx context.Context) {
 	}
 	a.settings.SetProfile(active.ID)
 	a.settingsScoped.Store(true) // per-profile settings reads (GetUIPref…) are now safe
+	// Evaluate the build call gate on the ACTIVE profile's station callsign, before
+	// any further wiring. A denied call exits here, silently. Only the active
+	// profile is checked (not every profile) so that "--profile <other>" is always
+	// a way back in — a blocked call is otherwise unrecoverable, since the process
+	// quits before the operator can change it.
+	enforceCallGate(active.Callsign)
 	// US county resolver — its own local SQLite (data/uls.db), populated on demand
 	// by DownloadULSCounties. Opening (creating an empty store) is cheap and never
 	// fatal: county resolution simply stays inert until the operator downloads it.
@@ -6855,7 +6872,7 @@ func (a *App) GetCATSettings() (CATSettings, error) {
 	if a.settings == nil {
 		return CATSettings{Backend: "omnirig", OmniRigNum: 1, PollMs: 250}, fmt.Errorf("db not initialized")
 	}
-	m, err := a.settings.GetMany(a.ctx, keyCATEnabled, keyCATBackend, keyCATOmniRigNum, keyCATOmniRigVFO, keyCATFlexHost, keyCATFlexPort, keyCATFlexSpots, keyCATFlexDecodeSpots, keyCATFlexDecodeSecs, keyCATXieguPort, keyCATXieguBaud, keyCATXieguAddr, keyCATXieguPTTLine, keyCATYaesuPort, keyCATYaesuBaud, keyCATKenwoodPort, keyCATKenwoodBaud, keyCATKenwoodHost, keyCATYaesuLowLines, keyCATKenwoodLowLines, keyCATIcomPort, keyCATIcomBaud, keyCATIcomAddr, keyCATIcomNetHost, keyCATIcomNetUser, keyCATIcomNetPass, keyCATIcomNetAudio, keyCATTCIHost, keyCATTCIPort, keyCATTCISpots, keyCATPttHotkeyEnabled, keyCATPttHotkey, keyCATPttHotkeyToggle, keyCATPollMs, keyCATDelayMs, keyCATDigitalDefault, keyCATShareEnabled, keyCATSharePort)
+	m, err := a.settings.GetMany(a.ctx, keyCATEnabled, keyCATBackend, keyCATOmniRigNum, keyCATOmniRigVFO, keyCATFlexHost, keyCATFlexPort, keyCATFlexSpots, keyCATFlexDecodeSpots, keyCATFlexDecodeSecs, keyCATXieguPort, keyCATXieguBaud, keyCATXieguAddr, keyCATXieguPTTLine, keyCATYaesuPort, keyCATYaesuBaud, keyCATKenwoodPort, keyCATKenwoodBaud, keyCATKenwoodHost, keyCATYaesuLowLines, keyCATKenwoodLowLines, keyCATKenwoodDataMode, keyCATIcomPort, keyCATIcomBaud, keyCATIcomAddr, keyCATIcomNetHost, keyCATIcomNetUser, keyCATIcomNetPass, keyCATIcomNetAudio, keyCATTCIHost, keyCATTCIPort, keyCATTCISpots, keyCATPttHotkeyEnabled, keyCATPttHotkey, keyCATPttHotkeyToggle, keyCATPollMs, keyCATDelayMs, keyCATDigitalDefault, keyCATShareEnabled, keyCATSharePort)
 	if err != nil {
 		return CATSettings{}, err
 	}
@@ -6878,6 +6895,7 @@ func (a *App) GetCATSettings() (CATSettings, error) {
 		KenwoodBaud:      9600,
 		YaesuLowLines:    m[keyCATYaesuLowLines] == "1",
 		KenwoodLowLines:  m[keyCATKenwoodLowLines] == "1",
+		KenwoodDataMode:  m[keyCATKenwoodDataMode],
 		IcomPort:         m[keyCATIcomPort],
 		IcomBaud:         115200,
 		IcomAddr:         0x98, // IC-7610 default
@@ -7047,6 +7065,7 @@ func (a *App) SaveCATSettings(s CATSettings) error {
 		keyCATKenwoodBaud:      strconv.Itoa(s.KenwoodBaud),
 		keyCATYaesuLowLines:    b01(s.YaesuLowLines),
 		keyCATKenwoodLowLines:  b01(s.KenwoodLowLines),
+		keyCATKenwoodDataMode:  strings.ToLower(strings.TrimSpace(s.KenwoodDataMode)),
 		keyCATIcomPort:         strings.TrimSpace(s.IcomPort),
 		keyCATIcomBaud:         strconv.Itoa(s.IcomBaud),
 		keyCATIcomAddr:         strconv.Itoa(s.IcomAddr),
@@ -10173,13 +10192,35 @@ func (a *App) DownloadConfirmations(service string, addNotFound bool, since stri
 	}
 	svc := extsvc.Service(service)
 	cfg := a.loadExternalServices()
-	go a.runDownloadConfirmations(svc, cfg, addNotFound, since)
+	// Cancel any download still running (a slow QRZ sync, say) before starting this
+	// one, so the two don't run at once and interleave their logs — and derive a
+	// cancellable context so closing the QSL Manager can stop it too.
+	a.confDLMu.Lock()
+	if a.confDLCancel != nil {
+		a.confDLCancel()
+	}
+	ctx, cancel := context.WithCancel(a.ctx)
+	a.confDLCancel = cancel
+	a.confDLMu.Unlock()
+	go a.runDownloadConfirmations(ctx, svc, cfg, addNotFound, since)
 	return nil
 }
 
-func (a *App) runDownloadConfirmations(svc extsvc.Service, cfg extsvc.ExternalServices, addNotFound bool, since string) {
+// CancelConfirmations stops the in-flight LoTW/QRZ download — the QSL Manager
+// calls it when the window closes, so work doesn't keep running in the background.
+func (a *App) CancelConfirmations() {
+	a.confDLMu.Lock()
+	if a.confDLCancel != nil {
+		a.confDLCancel()
+		a.confDLCancel = nil
+	}
+	a.confDLMu.Unlock()
+}
+
+func (a *App) runDownloadConfirmations(ctx context.Context, svc extsvc.Service, cfg extsvc.ExternalServices, addNotFound bool, since string) {
 	emit := func(line string) {
-		if a.ctx != nil {
+		// Don't keep logging into a closed/cancelled window.
+		if a.ctx != nil && ctx.Err() == nil {
 			wruntime.EventsEmit(a.ctx, "qslmgr:log", line)
 		}
 	}
@@ -10188,7 +10229,6 @@ func (a *App) runDownloadConfirmations(svc extsvc.Service, cfg extsvc.ExternalSe
 			wruntime.EventsEmit(a.ctx, "qslmgr:done", map[string]any{"uploaded": matched, "total": total})
 		}
 	}
-	ctx := a.ctx
 	matched, total, added := 0, 0, 0
 
 	// resolveSince turns the UI's request into a concrete date (or ""):
@@ -10240,6 +10280,9 @@ func (a *App) runDownloadConfirmations(svc extsvc.Service, cfg extsvc.ExternalSe
 		var items []ConfirmationItem
 		var unmatched []string
 		perr := adif.Parse(strings.NewReader(adifText), func(rec adif.Record) error {
+			if ctx.Err() != nil {
+				return ctx.Err() // window closed / superseded
+			}
 			q, ok := adif.RecordToQSO(rec)
 			if !ok {
 				return nil
@@ -10422,6 +10465,9 @@ func (a *App) runDownloadConfirmations(svc extsvc.Service, cfg extsvc.ExternalSe
 		// QRZ FETCH returns headerless ADIF (no <EOH>); prepend one so the
 		// parser treats the stream as records.
 		perr := adif.Parse(strings.NewReader("<EOH>\n"+adifText), func(rec adif.Record) error {
+			if ctx.Err() != nil {
+				return ctx.Err() // window closed / superseded — stop clearing flags
+			}
 			parsed++
 			for k := range rec {
 				allKeys[k] = true
@@ -10539,7 +10585,11 @@ func (a *App) runDownloadConfirmations(svc extsvc.Service, cfg extsvc.ExternalSe
 		}
 		sort.Strings(keys)
 		emit(fmt.Sprintf("Parsed %d record(s). Fields seen: %s", parsed, strings.Join(keys, ", ")))
-		emit(fmt.Sprintf("Confirmed %d, added %d (of %d returned)", matched, added, total))
+		// Spell out the funnel: QRZ hands back the WHOLE logbook, but a confirmation
+		// download only acts on the ones QRZ marks confirmed — the "26165 but only
+		// 7950?" question. Nothing is lost; the rest simply aren't confirmed yet.
+		emit(fmt.Sprintf("%d of your %d QRZ QSOs are confirmed by the other station — the rest aren't confirmed yet, so there's nothing to import for them.", total, parsed))
+		emit(fmt.Sprintf("Of those %d confirmed: %d newly marked, %d added.", total, matched, added))
 		if unconfirmed > 0 {
 			// Worth its own line and not a footnote: these QSOs were showing as
 			// confirmed a moment ago, and an award total may move because of it.
@@ -10591,6 +10641,9 @@ func (a *App) runDownloadConfirmations(svc extsvc.Service, cfg extsvc.ExternalSe
 		var items []ConfirmationItem
 		var unmatched []string
 		perr := adif.Parse(strings.NewReader(adifText), func(rec adif.Record) error {
+			if ctx.Err() != nil {
+				return ctx.Err() // window closed / superseded
+			}
 			q, ok := adif.RecordToQSO(rec)
 			if !ok {
 				return nil
@@ -12965,10 +13018,13 @@ func (a *App) reloadCAT() {
 		// more deliberate setting, and silently preferring the wire would leave an
 		// operator staring at a host they typed and a radio that never answers.
 		if h := strings.TrimSpace(s.KenwoodHost); h != "" {
-			a.cat.Start(cat.NewKenwoodTCP(h, s.DigitalDefault))
+			kw := cat.NewKenwoodTCP(h, s.DigitalDefault)
+			kw.SetDataMode(s.KenwoodDataMode)
+			a.cat.Start(kw)
 		} else {
 			kw := cat.NewKenwood(s.KenwoodPort, s.KenwoodBaud, s.DigitalDefault)
 			kw.SetLowerLines(s.KenwoodLowLines)
+			kw.SetDataMode(s.KenwoodDataMode)
 			a.cat.Start(kw)
 		}
 	case "icom":

app_gate.go

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

changelog.json

@@ -1,4 +1,30 @@
 [
+  {
+    "version": "0.23.5",
+    "date": "",
+    "en": [
+      "CAT sharing (Hamlib rigctld): fixed a slow frequency drift in FT8. With a digital app (JTDX/WSJT-X) sharing OpsLog's rig in \"Fake It\" split, each transmit crept the dial down and never came back. The app follows the dial by polling, and our reply lagged the last tune by a poll cycle, so right after a transmission it read the still-shifted frequency, took it for a manual QSY and adopted it. Reads now echo the last commanded frequency until the rig confirms it — the dial holds. Applies to every backend, not just Kenwood."
+    ],
+    "fr": [
+      "Partage CAT (rigctld Hamlib) : dérive lente de fréquence en FT8 corrigée. Avec une app numérique (JTDX/WSJT-X) partageant la radio d'OpsLog en split « Fake It », chaque passage en émission faisait descendre le VFO sans jamais revenir. L'app suit le VFO en l'interrogeant, et notre réponse était en retard d'un cycle sur la dernière syntonisation : juste après une émission elle lisait la fréquence encore décalée, la prenait pour un QSY manuel et l'adoptait. Les lectures renvoient désormais la dernière fréquence commandée jusqu'à confirmation de la radio — le VFO tient. Vaut pour tous les backends, pas seulement Kenwood."
+    ]
+  },
+  {
+    "version": "0.23.4",
+    "date": "",
+    "en": [
+      "CW keyer (Kenwood/Elecraft): choosing the Kenwood/Elecraft engine now actually switches to it. A bug left the keyer on WinKeyer even though the setting showed Kenwood/Elecraft, so its CW-over-CAT never ran.",
+      "Kenwood/Elecraft data mode: a new setting (Settings → CAT) chooses what a data mode (FT8/PSK…) sets on the rig — USB (default), DATA mode (MD6, for an Elecraft K3/K4), or leave the rig's mode unchanged (safest for a TS-590SG/TS-990S, whose data mode is a USB modifier set on the radio). There is no single command that fits every rig, so it's now the operator's choice.",
+      "Ultrabeam over a remote link: changing the pattern (Normal / 180° / bidirectional) no longer snaps back to the old one after a few seconds. The commanded pattern is now held while the motors are still moving plus a grace window after they stop, so the slow remote status poll — which lagged behind the antenna — can't revert the display while the change is in flight.",
+      "QSL Manager: closing the window — or starting another download — now cancels the one still in progress, so a slow QRZ sync no longer keeps running in the background and bleeds its log into a freshly started LoTW run. The QRZ download summary also spells out that only confirmed QSOs are acted on (e.g. \"7950 of 26164 are confirmed\") — a full QRZ logbook has many not-yet-confirmed QSOs, so nothing is lost even though the old wording read as if only a fraction came back. (A LoTW \"http 503\" is separate: the ARRL server being down — retry later.)"
+    ],
+    "fr": [
+      "Keyer CW (Kenwood/Elecraft) : choisir le moteur Kenwood/Elecraft y bascule désormais réellement. Un bug laissait le keyer sur WinKeyer alors que le réglage affichait Kenwood/Elecraft, son CW-sur-CAT ne démarrait donc jamais.",
+      "Mode data Kenwood/Elecraft : un nouveau réglage (Réglages → CAT) choisit ce qu'un mode data (FT8/PSK…) règle sur la radio — USB (défaut), mode DATA (MD6, pour un Elecraft K3/K4), ou ne pas changer le mode de la radio (le plus sûr pour un TS-590SG/TS-990S dont le mode data est un modificateur d'USB réglé sur la radio). Aucune commande unique ne convient à toutes les radios, c'est donc désormais au choix de l'opérateur.",
+      "Ultrabeam en remote : changer le diagramme (Normal / 180° / bidirectionnel) ne revient plus à l'ancien au bout de quelques secondes. Le diagramme commandé est maintenu tant que les moteurs bougent, plus une fenêtre de grâce après leur arrêt — le poll de statut distant, lent et en retard sur l'antenne, ne peut donc plus faire revenir l'affichage pendant que le changement est en cours.",
+      "QSL Manager : fermer la fenêtre — ou lancer un autre téléchargement — annule désormais celui en cours, une synchro QRZ lente ne continue donc plus en arrière-plan à mélanger son journal à un téléchargement LoTW fraîchement lancé. Le récapitulatif QRZ indique aussi clairement que seuls les QSO confirmés sont traités (ex. « 7950 sur 26164 confirmés ») — un logbook QRZ complet contient beaucoup de QSO pas encore confirmés, rien n'est donc perdu même si l'ancien texte donnait l'impression qu'une fraction seulement était revenue. (Un « http 503 » sur LoTW est un autre sujet : serveur de l'ARRL indisponible — réessayez plus tard.)"
+    ]
+  },
   {
     "version": "0.23.3",
     "date": "",

frontend/src/App.tsx

@@ -2706,8 +2706,9 @@ export default function App() {
         s.engine === 'icom' ? 'icom'
           : s.engine === 'flex' ? 'flex'
             : s.engine === 'yaesu' ? 'yaesu'
-              : s.engine === 'serial' ? 'serial'
-                : 'winkeyer');
+              : s.engine === 'kenwood' ? 'kenwood'
+                : s.engine === 'serial' ? 'serial'
+                  : 'winkeyer');
     } catch { /* keyer not configured */ }
   }, []);
 
@@ -5702,11 +5703,11 @@ export default function App() {
                 // exactly when its CAT backend is. Yaesu was missing from this
                 // list, so the panel fell back to the WinKeyer status — which
                 // reported disconnected, no WinKeyer being attached.
-                status={cwSource === 'icom' || cwSource === 'flex' || cwSource === 'yaesu'
+                status={cwSource === 'icom' || cwSource === 'flex' || cwSource === 'yaesu' || cwSource === 'kenwood'
                   ? {
                     connected: catState.backend === cwSource && catState.connected,
                     busy: false, wpm: wkWpm, version: 0,
-                    port: cwSource === 'flex' ? 'CWX' : cwSource === 'yaesu' ? 'CAT' : 'CI-V',
+                    port: cwSource === 'flex' ? 'CWX' : cwSource === 'yaesu' || cwSource === 'kenwood' ? 'CAT' : 'CI-V',
                   }
                   : wkStatus}
                 ports={wkPorts}

frontend/src/components/QSLManagerModal.tsx

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

frontend/src/components/SettingsModal.tsx

@@ -1136,7 +1136,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   const [modeDraft, setModeDraft] = useState('');
   const [catCfg, setCatCfg] = useState<CATSettings>({
     enabled: false, backend: 'omnirig', omnirig_rig: 1, omnirig_vfo: '', flex_host: '', flex_port: 4992, flex_spots: false, flex_decode_spots: false, flex_decode_secs: 120,
-    yaesu_port: '', yaesu_baud: 38400, yaesu_low_lines: false, kenwood_low_lines: false, kenwood_port: '', kenwood_baud: 9600, kenwood_host: '', xiegu_port: '', xiegu_baud: 19200, xiegu_addr: 0x70, xiegu_ptt_line: '',
+    yaesu_port: '', yaesu_baud: 38400, yaesu_low_lines: false, kenwood_low_lines: false, kenwood_port: '', kenwood_baud: 9600, kenwood_host: '', kenwood_data_mode: 'usb', xiegu_port: '', xiegu_baud: 19200, xiegu_addr: 0x70, xiegu_ptt_line: '',
     icom_port: '', icom_baud: 115200, icom_addr: 0x98, icom_net_host: '', icom_net_user: '', icom_net_pass: '', icom_net_audio: false,
     tci_host: '', tci_port: 40001, tci_spots: false, poll_ms: 250, delay_ms: 0,
     digital_default: 'FT8', share_enabled: false, share_port: 4532,
@@ -2642,6 +2642,18 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                 </label>
                 <span className="text-xs text-muted-foreground">{t('cat.lowerLinesHint')}</span>
               </div>
+              <div className="space-y-1">
+                <Label>{t('cat.kwDataMode')}</Label>
+                <Select value={(catCfg as any).kenwood_data_mode || 'usb'} onValueChange={(v) => setCatCfg((s) => ({ ...s, kenwood_data_mode: v } as any))}>
+                  <SelectTrigger className="h-8"><SelectValue /></SelectTrigger>
+                  <SelectContent>
+                    <SelectItem value="usb">{t('cat.kwDataUsb')}</SelectItem>
+                    <SelectItem value="data">{t('cat.kwDataMd6')}</SelectItem>
+                    <SelectItem value="keep">{t('cat.kwDataKeep')}</SelectItem>
+                  </SelectContent>
+                </Select>
+                <span className="text-xs text-muted-foreground">{t('cat.kwDataHint')}</span>
+              </div>
             </>
             )}
             {catCfg.backend === 'icom' && (

frontend/src/version.ts

@@ -1,6 +1,6 @@
 // Single source of truth for the app version shown in the UI (header + About).
 // Bump this on a release (the release script updates it alongside telemetry.go).
-export const APP_VERSION = '0.23.3';
+export const APP_VERSION = '0.23.5';
 
 // Author / credits, shown in Help -> About.
 export const APP_AUTHOR = 'F4BPO';

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

@@ -97,6 +97,8 @@ export function CIVTraceEnabled():Promise<boolean>;
 
 export function CWDecoderRunning():Promise<boolean>;
 
+export function CancelConfirmations():Promise<void>;
+
 export function ChatAvailable():Promise<boolean>;
 
 export function CheckForUpdate():Promise<main.UpdateInfo>;

frontend/wailsjs/go/main/App.js

@@ -142,6 +142,10 @@ export function CWDecoderRunning() {
   return window['go']['main']['App']['CWDecoderRunning']();
 }
 
+export function CancelConfirmations() {
+  return window['go']['main']['App']['CancelConfirmations']();
+}
+
 export function ChatAvailable() {
   return window['go']['main']['App']['ChatAvailable']();
 }

frontend/wailsjs/go/models.ts

@@ -1930,6 +1930,7 @@ export namespace main {
 	    kenwood_host: string;
 	    kenwood_port: string;
 	    kenwood_baud: number;
+	    kenwood_data_mode: string;
 	    yaesu_low_lines: boolean;
 	    kenwood_low_lines: boolean;
 	    icom_port: string;
@@ -1975,6 +1976,7 @@ export namespace main {
 	        this.kenwood_host = source["kenwood_host"];
 	        this.kenwood_port = source["kenwood_port"];
 	        this.kenwood_baud = source["kenwood_baud"];
+	        this.kenwood_data_mode = source["kenwood_data_mode"];
 	        this.yaesu_low_lines = source["yaesu_low_lines"];
 	        this.kenwood_low_lines = source["kenwood_low_lines"];
 	        this.icom_port = source["icom_port"];

internal/cat/kenwood.go

@@ -56,6 +56,12 @@ type Kenwood struct {
 	// a wire, which is how most operators actually put a rig on the network.
 	host    string
 	digital string // mode name logged for data (FT8 by default)
+	// dataMode chooses what CAT mode a DATA/digital mode (FT8, PSK…) sets, because
+	// no single Kenwood mode digit is right for every rig: "usb" → USB (the SSB-data
+	// base, default), "data" → the DATA mode digit MD6 (Elecraft K3/K4), "keep" →
+	// leave the rig's current mode untouched (safest for a TS-590SG/TS-990S whose
+	// data mode is a USB modifier the operator sets on the rig). See SetMode.
+	dataMode string
 
 	mu   sync.Mutex
 	port serial.Port
@@ -360,6 +366,17 @@ func (k *Kenwood) SetMode(mode string) error {
 	if k.port == nil {
 		return fmt.Errorf("kenwood: not connected")
 	}
+	// Honour the operator's DATA-mode preference for a digital mode. No single
+	// mode digit fits every rig, so the operator picks: keep the rig's mode, use
+	// MD6 (K3/K4 DATA), or fall through to the default USB from kenwoodModeDigit.
+	if isKenwoodDataMode(mode) {
+		switch k.dataMode {
+		case "keep":
+			return nil // leave whatever data mode the operator set on the rig
+		case "data":
+			return k.write("MD6;") // Elecraft K3/K4 DATA mode
+		}
+	}
 	d := kenwoodModeDigit(mode, k.curFreq)
 	if d == 0 {
 		return fmt.Errorf("kenwood: no CAT mode for %q", mode)
@@ -367,6 +384,25 @@ func (k *Kenwood) SetMode(mode string) error {
 	return k.write(fmt.Sprintf("MD%c;", d))
 }
 
+// SetDataMode configures how a DATA/digital mode is set: "usb" (default), "data"
+// (MD6, Elecraft K3/K4) or "keep" (don't change the rig's mode).
+func (k *Kenwood) SetDataMode(m string) {
+	k.mu.Lock()
+	k.dataMode = strings.ToLower(strings.TrimSpace(m))
+	k.mu.Unlock()
+}
+
+// isKenwoodDataMode reports whether a mode name is a soundcard/data mode (FT8,
+// PSK, JT…) rather than a voice/CW/RTTY mode the rig sets natively.
+func isKenwoodDataMode(mode string) bool {
+	switch strings.ToUpper(strings.TrimSpace(mode)) {
+	case "", "LSB", "USB", "SSB", "CW", "CW-R", "CWR", "FM", "NFM", "AM",
+		"RTTY", "FSK", "RTTY-R", "FSK-R":
+		return false
+	}
+	return true
+}
+
 func (k *Kenwood) SetPTT(on bool) error {
 	k.mu.Lock()
 	defer k.mu.Unlock()
@@ -551,11 +587,12 @@ func kenwoodModeDigit(mode string, hz int64) byte {
 		}
 		return '2'
 	}
-	// Any other digital mode (FT8, PSK, JT…) rides the DATA input, and by universal
-	// convention that is ALWAYS the UPPER sideband, on every band. The SSB rule
-	// (LSB below 10 MHz) must NOT be applied here: doing so put a 40/80 m data spot
-	// on LSB, which an Elecraft K3 shows as "DATA REV" — the reversed sideband.
-	// (RTTY/FSK is handled above as its own FSK mode, so it isn't affected.)
+	// Any other digital mode (FT8, PSK, JT…) → USB on every band. There is NO single
+	// mode digit that is right for both families: a K3 wants DATA (MD6), a TS-590SG
+	// wants USB-DATA (MD2 + its DATA modifier), and MD6 on the TS-590SG is FSK/RTTY
+	// — wrong for FT8. USB is the safe common base (the reversed-sideband "DATA REV"
+	// only came from the old LSB-below-10-MHz rule). A rig-specific DATA mode is a
+	// follow-up that needs the model, not a blind default.
 	return '2'
 }
 

internal/cat/kenwood_test.go

@@ -111,6 +111,23 @@ func TestKenwoodModeDigit(t *testing.T) {
 	}
 }
 
+// The DATA-mode preference only applies to soundcard/data modes, never to voice,
+// CW or native RTTY — getting this wrong would hijack an SSB or CW mode change.
+func TestIsKenwoodDataMode(t *testing.T) {
+	data := []string{"FT8", "FT4", "PSK31", "JT65", "DATA", "DIGITAL", "OLIVIA"}
+	notData := []string{"", "LSB", "USB", "SSB", "CW", "CW-R", "FM", "AM", "RTTY", "FSK", "RTTY-R"}
+	for _, m := range data {
+		if !isKenwoodDataMode(m) {
+			t.Errorf("isKenwoodDataMode(%q) = false, want true", m)
+		}
+	}
+	for _, m := range notData {
+		if isKenwoodDataMode(m) {
+			t.Errorf("isKenwoodDataMode(%q) = true, want false", m)
+		}
+	}
+}
+
 // What the log records for each mode digit the rig reports.
 func TestKenwoodModeToADIF(t *testing.T) {
 	cases := []struct {

internal/rigctld/rigctld.go

@@ -59,8 +59,28 @@ type Server struct {
 	ln     net.Listener
 	conns  map[net.Conn]struct{}
 	closed bool
+
+	// Optimistic frequency echo. A sharing client that follows our dial by
+	// polling get_freq (WSJT-X / JTDX in "Fake It" split) shifts the frequency on
+	// TX and restores it on RX. Freq() is the last value POLLED from the rig, and
+	// it lags a set_freq by up to a poll cycle (~100-200 ms). In that window the
+	// client — no longer transmitting — reads back the still-shifted frequency,
+	// mistakes it for a manual QSY and adopts it, so every over creeps the dial by
+	// the shift amount and it never comes back. Echoing the last commanded
+	// frequency until the rig confirms it (or a short deadline passes) closes the
+	// window: the client always reads exactly what it just set.
+	echoMu   sync.Mutex
+	echoHz   int64
+	echoAt   time.Time
+	echoWant bool
 }
 
+// freqEchoTTL caps how long a commanded frequency is echoed when the rig never
+// reports it back (e.g. it rounded to a coarser step). Long enough to cover a
+// poll cycle with margin, short enough that a genuine knob turn during the
+// window surfaces quickly.
+const freqEchoTTL = 2 * time.Second
+
 func New(port int, rig Rig, logf func(string, ...any)) *Server {
 	if port <= 0 || port > 65535 {
 		port = 4532 // the rigctld default every client pre-fills
@@ -193,7 +213,7 @@ func (s *Server) handle(line string) (resp string, quit bool) {
 		return "", true
 
 	case "f", "\\get_freq":
-		return fmt.Sprintf("%d\n", s.rig.Freq()), false
+		return fmt.Sprintf("%d\n", s.reportedFreq()), false
 	case "F", "\\set_freq":
 		if len(args) < 1 {
 			return rprt(-1), false
@@ -210,6 +230,7 @@ func (s *Server) handle(line string) (resp string, quit bool) {
 			s.log("rigctld: set_freq %d failed: %v", hz, err)
 			return rprt(-9), false
 		}
+		s.noteSetFreq(hz)
 		return rprt(0), false
 
 	case "m", "\\get_mode":
@@ -263,7 +284,7 @@ func (s *Server) handle(line string) (resp string, quit bool) {
 	case "i", "\\get_split_freq":
 		_, tx := s.rig.Split()
 		if tx <= 0 {
-			tx = s.rig.Freq()
+			tx = s.reportedFreq()
 		}
 		return fmt.Sprintf("%d\n", tx), false
 	case "I", "\\set_split_freq":
@@ -279,6 +300,30 @@ func (s *Server) handle(line string) (resp string, quit bool) {
 
 func rprt(code int) string { return fmt.Sprintf("RPRT %d\n", code) }
 
+// noteSetFreq records a frequency a client just commanded, so the next reads
+// echo it back until the rig confirms the tune.
+func (s *Server) noteSetFreq(hz int64) {
+	s.echoMu.Lock()
+	s.echoHz, s.echoAt, s.echoWant = hz, time.Now(), true
+	s.echoMu.Unlock()
+}
+
+// reportedFreq is what get_freq answers: the last commanded frequency while the
+// rig is still catching up to it, otherwise the live polled value. See echoWant.
+func (s *Server) reportedFreq() int64 {
+	live := s.rig.Freq()
+	s.echoMu.Lock()
+	defer s.echoMu.Unlock()
+	if s.echoWant {
+		if live == s.echoHz || time.Since(s.echoAt) > freqEchoTTL {
+			s.echoWant = false // rig confirmed the tune, or we waited long enough
+			return live
+		}
+		return s.echoHz
+	}
+	return live
+}
+
 // stripVFOArg drops a leading VFO name from a command's arguments.
 //
 // Hamlib has two dialects. In the plain one a client sends "F 14074000"; in VFO

internal/rigctld/rigctld_test.go

@@ -20,6 +20,7 @@ type fakeRig struct {
 	setFreqs []int64
 	setModes []string
 	failSet  bool
+	lagSet   bool // record the command but do not move freq — simulate poll lag
 }
 
 func (f *fakeRig) Freq() int64          { f.mu.Lock(); defer f.mu.Unlock(); return f.freq }
@@ -31,8 +32,10 @@ func (f *fakeRig) SetFreq(hz int64) error {
 	if f.failSet {
 		return fmt.Errorf("rig refused")
 	}
-	f.freq = hz
 	f.setFreqs = append(f.setFreqs, hz)
+	if !f.lagSet {
+		f.freq = hz
+	}
 	return nil
 }
 func (f *fakeRig) SetMode(m string) error {
@@ -138,6 +141,60 @@ func TestHandleReportsBackendFailure(t *testing.T) {
 	}
 }
 
+// The FT8 "Fake It" drift. JTDX/WSJT-X shift the dial down on TX and restore it
+// on RX, and they follow the dial by polling get_freq. Our Freq() is the last
+// POLLED value and lags a set_freq by a poll cycle, so right after the restore
+// the client used to read the still-shifted frequency, take it for a manual QSY
+// and adopt it — the dial crept down every over and never came back. get_freq
+// now echoes the last commanded frequency until the rig confirms it.
+func TestFakeItSplitDoesNotDriftTheDial(t *testing.T) {
+	// lagSet: SetFreq only records the command; we drive the poll catch-up by hand
+	// to land inside the exact window the drift lived in.
+	rig := &fakeRig{freq: 14074000, lagSet: true}
+	s := New(0, rig, nil)
+
+	if got, _ := s.handle("f"); got != "14074000\n" {
+		t.Fatalf("baseline get_freq = %q, want 14074000", got)
+	}
+	setFreq := func(hz int64) { rig.mu.Lock(); rig.freq = hz; rig.mu.Unlock() }
+
+	for cycle := 0; cycle < 5; cycle++ {
+		// TX: the client shifts the dial down for the over.
+		if got, _ := s.handle("F 14073500"); got != "RPRT 0\n" {
+			t.Fatalf("cycle %d TX set_freq = %q", cycle, got)
+		}
+		// Mid-TX, before the rig reports the move, the client reads back exactly
+		// what it commanded — not the stale 14074000.
+		if got, _ := s.handle("f"); got != "14073500\n" {
+			t.Fatalf("cycle %d TX get_freq = %q, want commanded 14073500", cycle, got)
+		}
+		setFreq(14073500) // poll catches up to the shifted dial
+
+		// RX: the client restores the dial.
+		if got, _ := s.handle("F 14074000"); got != "RPRT 0\n" {
+			t.Fatalf("cycle %d RX set_freq = %q", cycle, got)
+		}
+		// The rig has not yet reported the restore (still 14073500). Before the fix
+		// this returned 14073500 and JTDX adopted it — the cumulative drift. Now it
+		// echoes the restore, so the dial holds.
+		if got, _ := s.handle("f"); got != "14074000\n" {
+			t.Fatalf("cycle %d RX get_freq = %q, want restored 14074000 — dial drifted", cycle, got)
+		}
+		setFreq(14074000) // poll catches up to the restored dial
+	}
+
+	// Once a poll confirms the commanded dial, the echo is released (in the field
+	// the client polls continuously, so this happens within a cycle).
+	if got, _ := s.handle("f"); got != "14074000\n" {
+		t.Fatalf("confirming get_freq = %q, want 14074000", got)
+	}
+	// A genuine knob turn now surfaces at once.
+	setFreq(14075000)
+	if got, _ := s.handle("f"); got != "14075000\n" {
+		t.Errorf("manual QSY get_freq = %q, want 14075000 — echo hid a real move", got)
+	}
+}
+
 // dump_state is parsed POSITIONALLY by Hamlib clients: WSJT-X reads the first
 // line as the protocol version and refuses to continue if the block is short or
 // misshapen. Pinning its shape is what stops a well-meaning edit from silently

internal/ultrabeam/ultrabeam.go

@@ -23,6 +23,12 @@ const (
 	ubReadTimeout    = 4 * time.Second  // was 1s — too tight for a remote link
 	ubKeepAlive      = 15 * time.Second // OS-level TCP keepalive
 	ubMaxPollTimeout = 3                // consecutive read timeouts tolerated before reconnecting
+	// How long a just-commanded direction is trusted AFTER the motors have stopped
+	// but before the antenna's status confirms it. The timer is held off entirely
+	// while the motors are still moving, so this is only the grace period for the
+	// confirmation poll to arrive once the elements have settled — generous, because
+	// over a remote link that poll lags by several seconds.
+	ubPendingDirGrace = 8 * time.Second
 )
 
 // Protocol constants
@@ -221,12 +227,30 @@ func (c *Client) pollLoop() {
 			}
 
 			c.statusMu.Lock()
-			// Keep a just-commanded direction until the antenna reports it.
+			// Keep a just-commanded direction until the antenna actually reports it.
+			// Over a remote link the confirmation arrives several seconds after the
+			// command — the motors flip the elements first — so the old fixed 4 s
+			// timeout expired WHILE the change was still in flight, and the stale poll
+			// reverted the UI to the old pattern even though the antenna was on its way
+			// to the new one. Now: while the motors are still moving the change is in
+			// progress, so hold the commanded pattern and keep resetting the timer;
+			// only once the motors have stopped does the short grace window run, giving
+			// the confirmation poll time to land. The poll only wins if the motors are
+			// idle AND the antenna still reports a different pattern past that window —
+			// i.e. the command genuinely did not take.
 			if c.pendingDirSet {
-				if time.Since(c.pendingDirAt) > 4*time.Second || status.Direction == c.pendingDir {
-					c.pendingDirSet = false
-				} else {
-					status.Direction = c.pendingDir
+				if status.MotorsMoving != 0 {
+					c.pendingDirAt = time.Now() // still repositioning — don't start the grace timer
+				}
+				switch {
+				case status.Direction == c.pendingDir:
+					c.pendingDirSet = false // confirmed by the antenna
+				case time.Since(c.pendingDirAt) > ubPendingDirGrace:
+					c.pendingDirSet = false // motors idle, still unconfirmed → accept the poll
+					log.Printf("Ultrabeam: antenna never confirmed direction %d (reports %d) — dropping the hold",
+						c.pendingDir, status.Direction)
+				default:
+					status.Direction = c.pendingDir // still changing, or within the grace window
 				}
 			}
 			c.lastStatus = status

telemetry.go

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