chore: release v0.20.12

A SteppIR only covers part of the spectrum (a standard one is 20 m–6 m) but
can't report its own range, so the follow loop's existing out-of-range guard
(FreqMin/FreqMax) never engaged for it. Tuning the rig to a band the antenna
can't reach (e.g. 30 m) made the loop keep trying — the immediate cause of the
stuck TX interlock addressed in the previous commit.

Add a Tunable range (MHz) setting to the Antenna panel, wired into the SteppIR
adapter's Status().FreqMin/FreqMax so the follow loop skips out-of-range
frequencies entirely: no tune command, no TX inhibit. Defaults to 13–54 MHz
(20 m–6 m, the common model) when unset; widen the low edge for a 40 m-equipped
SteppIR. Ultrabeam is unaffected (it reports its own per-band coverage).

Keeps the last-commanded-freq deadband from the previous commit as a universal
safety net for any flaky-status case within the valid range.

app.go

@@ -33,6 +33,7 @@ import (
 	"hamlog/internal/clublog"
 	"hamlog/internal/cluster"
 	"hamlog/internal/contest"
+	"hamlog/internal/cwdecode"
 	"hamlog/internal/db"
 	"hamlog/internal/dxcc"
 	"hamlog/internal/email"
@@ -136,6 +137,7 @@ const (
 	keyAwardEditsSeeded = "awards.defs.editflag" // one-shot: back-fill the user-edited flag
 
 	keyClublogCtyEnabled = "clublog.cty_exceptions" // "1" → apply ClubLog exceptions
+	keyClublogMostWanted = "clublog.most_wanted"    // "1" → show ClubLog Most Wanted rank in the entry matrix
 
 	// E-mail / SMTP — send QSO recordings to the correspondent.
 	keyEmailEnabled    = "email.enabled"
@@ -178,6 +180,8 @@ const (
 	keyMotorCOM         = "ultrabeam.com"        // serial device name (COM3, /dev/ttyUSB0)
 	keyMotorBaud        = "ultrabeam.baud"       // serial baud (SteppIR default 9600)
 	keyMotorTXInhibit   = "ultrabeam.tx_inhibit" // "1" → block Flex TX while the antenna is moving
+	keyMotorFreqMin     = "ultrabeam.freq_min"   // SteppIR tunable range low edge (MHz); out-of-range = don't follow/inhibit
+	keyMotorFreqMax     = "ultrabeam.freq_max"   // SteppIR tunable range high edge (MHz)
 	keyStationDevices   = "station.devices"      // JSON list of relay boards for the Station Control tab
 
 	// Antenna Genius (4O3A) antenna switch — Hardware → Antenna Genius. TCP
@@ -214,9 +218,11 @@ const (
 	keyWKUsePTT     = "winkeyer.use_ptt"
 	keyWKSerialEcho = "winkeyer.serial_echo"
 	keyWKMacros     = "winkeyer.macros"          // JSON array of {label,text}
-	keyWKEngine     = "winkeyer.engine"          // "winkeyer" | "icom" | "tci"
+	keyWKEngine     = "winkeyer.engine"          // "winkeyer" | "serial" | "icom" | "flex" | "tci"
 	keyWKEscClears  = "winkeyer.esc_clears_call" // ESC also clears the callsign
 	keyWKSendOnType = "winkeyer.send_on_type"    // key characters live as typed
+	keyWKCWLine     = "winkeyer.cw_key_line"     // serial engine: "dtr" (CW) / "rts" (PTT) or swapped
+	keyWKCWInvert   = "winkeyer.cw_invert"       // serial engine: invert line polarity (active-LOW)
 
 	keyClusterAutoConnect = "cluster.auto_connect" // open every enabled server at app start
 
@@ -462,6 +468,7 @@ type App struct {
 	extsvc         *extsvc.Manager
 	winkeyer       *winkeyer.Manager
 	clublog        *clublog.Manager
+	clublogMW      *clublog.MostWanted // ClubLog "Most Wanted" DXCC ranking (opt-in)
 	motorAnt       motorAntenna        // motorized antenna (Ultrabeam or SteppIR); nil when disabled
 	ubFollowStop   chan struct{}       // stops the "follow frequency" loop; nil when off
 	motorInhibStop chan struct{}       // stops the "inhibit TX while moving" loop; nil when off
@@ -488,6 +495,11 @@ type App struct {
 
 	alertStore *alerts.Store // DX-cluster spot alert rules (global JSON)
 
+	cwMu      sync.Mutex        // guards the CW decoder lifecycle
+	cwStop    chan struct{}     // stops the CW decoder capture loop; nil when off
+	cwDecoder *cwdecode.Decoder // live decoder (for retargeting the pitch)
+	cwPitchHz int               // manual pitch override (0 = auto / follow Flex)
+
 	startupProfile string // --profile <name> from the command line (activate at startup)
 	dvkRecSlot     int    // slot currently being recorded (DVKStartRecord → DVKStopRecord)
 	dvkPttKeyed    bool   // we keyed PTT for a voice message; unkey when it ends
@@ -952,6 +964,30 @@ func (a *App) startup(ctx context.Context) {
 		}
 	}()
 
+	// ClubLog "Most Wanted" DXCC ranking (opt-in, Settings → General). Loaded from
+	// the cached JSON, then refreshed daily and whenever the operator's callsign
+	// changes (the ranking is personalised per callsign). Best-effort.
+	a.clublogMW = clublog.NewMostWanted(dataDir)
+	go func() {
+		if a.settings == nil {
+			return
+		}
+		if v, _ := a.settings.Get(a.ctx, keyClublogMostWanted); v != "1" {
+			return // feature off — don't touch the network
+		}
+		_ = a.clublogMW.LoadFromDisk()
+		call := a.activeCallsign()
+		if a.clublogMW.NeedsRefresh(call, 24*time.Hour) {
+			if err := a.clublogMW.Download(context.Background(), call); err != nil {
+				applog.Printf("clublog most-wanted: auto-refresh failed: %v", err)
+			}
+		}
+		if a.clublogMW.Loaded() {
+			c, d, n := a.clublogMW.Info()
+			applog.Printf("clublog most-wanted: loaded %d entities for %s (%s)", n, c, d)
+		}
+	}()
+
 	// POTA: background poller of api.pota.app so cluster spots can be tagged
 	// when the DX station is currently activating a park. Best-effort.
 	a.pota = pota.New(func(format string, args ...any) { applog.Printf(format, args...) })
@@ -1833,7 +1869,14 @@ func (a *App) groupDigitalSlots() bool {
 
 func (a *App) GetUIPref(key string) (string, error) {
 	if a.settings == nil {
-		return "", nil
+		// Distinct from a genuinely-empty pref: the (LOCAL SQLite) settings store
+		// isn't wired yet. There's a brief window at launch where the frontend can
+		// call this before OnStartup has opened the DB and built the store. The UI
+		// uses the error to keep RETRYING rather than treat it as "unset" and fall
+		// back to a default — the "dark theme reverts to light after an update" bug
+		// (the update cleared localStorage, and the DB read gave up too early while
+		// the store was still coming up).
+		return "", fmt.Errorf("settings store not ready")
 	}
 	return a.settings.Get(a.ctx, "ui."+key)
 }
@@ -5238,7 +5281,13 @@ func (a *App) WorkedBefore(callsign string, dxccHint int) (qso.WorkedBefore, err
 			dxccHint = dxcc.EntityDXCC(m.Entity.Name)
 		}
 	}
-	return a.qso.WorkedBefore(a.ctx, callsign, dxccHint)
+	wb, err := a.qso.WorkedBefore(a.ctx, callsign, dxccHint)
+	// Attach the ClubLog Most Wanted rank for this entity (opt-in) so the entry
+	// matrix can show it next to the country name.
+	if err == nil && wb.DXCC > 0 && a.clublogMW != nil && a.clublogMostWantedEnabled() {
+		wb.MWRank = a.clublogMW.Rank(wb.DXCC)
+	}
+	return wb, err
 }
 
 // SetCompactMode toggles a tiny always-on-top window that exposes just the
@@ -5418,37 +5467,55 @@ func (a *App) ADIFFields() []adif.FieldDef { return adif.Fields }
 // ADIFVersion returns the ADIF spec version OpsLog conforms to (e.g. "3.1.7").
 func (a *App) ADIFVersion() string { return adif.ADIFVersion() }
 
+// adifFieldSet turns a list of ADIF tag names into an allow-set (uppercased),
+// or nil when the list is empty — nil means "all fields" (standard/full mode),
+// so the two-mode export path is unchanged when no explicit field list is given.
+func adifFieldSet(fields []string) map[string]bool {
+	if len(fields) == 0 {
+		return nil
+	}
+	set := make(map[string]bool, len(fields))
+	for _, f := range fields {
+		if t := strings.ToUpper(strings.TrimSpace(f)); t != "" {
+			set[t] = true
+		}
+	}
+	return set
+}
+
 // ExportADIF writes every QSO to the given file path in ADIF 3.1 format.
 // Streams from DB so memory stays flat even with 100k+ records.
 // includeAppFields=false → portable standard ADIF (for other loggers);
 // true → full export keeping OpsLog/app-specific APP_* fields (round-trip).
-func (a *App) ExportADIF(path string, includeAppFields bool) (adif.ExportResult, error) {
+// fields (optional): when non-empty, export EXACTLY those ADIF tags — the
+// "choose which fields to export" mode (overrides includeAppFields).
+func (a *App) ExportADIF(path string, includeAppFields bool, fields []string) (adif.ExportResult, error) {
 	if a.qso == nil {
 		return adif.ExportResult{}, fmt.Errorf("db not initialized")
 	}
 	if path == "" {
 		return adif.ExportResult{}, fmt.Errorf("empty path")
 	}
-	ex := &adif.Exporter{Repo: a.qso, AppName: "OpsLog", AppVersion: "0.1", IncludeAppFields: includeAppFields}
+	ex := &adif.Exporter{Repo: a.qso, AppName: "OpsLog", AppVersion: "0.1", IncludeAppFields: includeAppFields, Fields: adifFieldSet(fields)}
 	return ex.ExportFile(a.ctx, path)
 }
 
 // ExportADIFFiltered writes the QSOs matching the current filter to path, with
 // NO row limit (the on-screen list is capped by the threshold; this is not).
-func (a *App) ExportADIFFiltered(path string, includeAppFields bool, f qso.QueryFilter) (adif.ExportResult, error) {
+func (a *App) ExportADIFFiltered(path string, includeAppFields bool, f qso.QueryFilter, fields []string) (adif.ExportResult, error) {
 	if a.qso == nil {
 		return adif.ExportResult{}, fmt.Errorf("db not initialized")
 	}
 	if path == "" {
 		return adif.ExportResult{}, fmt.Errorf("empty path")
 	}
-	ex := &adif.Exporter{Repo: a.qso, AppName: "OpsLog", AppVersion: "0.1", IncludeAppFields: includeAppFields}
+	ex := &adif.Exporter{Repo: a.qso, AppName: "OpsLog", AppVersion: "0.1", IncludeAppFields: includeAppFields, Fields: adifFieldSet(fields)}
 	return ex.ExportFileFiltered(a.ctx, path, f)
 }
 
 // ExportADIFSelected writes only the QSOs whose ids are given (the rows the
 // operator highlighted in the grid).
-func (a *App) ExportADIFSelected(path string, includeAppFields bool, ids []int64) (adif.ExportResult, error) {
+func (a *App) ExportADIFSelected(path string, includeAppFields bool, ids []int64, fields []string) (adif.ExportResult, error) {
 	if a.qso == nil {
 		return adif.ExportResult{}, fmt.Errorf("db not initialized")
 	}
@@ -5458,10 +5525,32 @@ func (a *App) ExportADIFSelected(path string, includeAppFields bool, ids []int64
 	if len(ids) == 0 {
 		return adif.ExportResult{}, fmt.Errorf("no QSOs selected")
 	}
-	ex := &adif.Exporter{Repo: a.qso, AppName: "OpsLog", AppVersion: "0.1", IncludeAppFields: includeAppFields}
+	ex := &adif.Exporter{Repo: a.qso, AppName: "OpsLog", AppVersion: "0.1", IncludeAppFields: includeAppFields, Fields: adifFieldSet(fields)}
 	return ex.ExportFileByIDs(a.ctx, path, ids)
 }
 
+// ADIFExtraFields returns the distinct NON-standard ADIF tags actually present
+// in the logbook's stored extras (APP_* and vendor tags) — the "OpsLog / extra
+// fields" group in the export field picker, alongside the static official-ADIF
+// list from ADIFFields(). Sampled + capped so it stays fast on a big remote log.
+func (a *App) ADIFExtraFields() []string {
+	if a.qso == nil {
+		return nil
+	}
+	keys, err := a.qso.DistinctExtraKeys(a.ctx, 5000)
+	if err != nil {
+		return nil
+	}
+	out := make([]string, 0, len(keys))
+	for _, k := range keys {
+		if t := strings.ToUpper(strings.TrimSpace(k)); t != "" && !adif.IsStandardField(t) {
+			out = append(out, t)
+		}
+	}
+	sort.Strings(out)
+	return out
+}
+
 // CabrilloResult reports how many QSOs a Cabrillo export wrote and where.
 type CabrilloResult struct {
 	Count int    `json:"count"`
@@ -7318,6 +7407,74 @@ func (a *App) DownloadClublogCty() (ClublogCtyInfo, error) {
 	return a.GetClublogCtyInfo(), nil
 }
 
+// activeCallsign is the current profile's callsign (upper-cased), "" if none.
+func (a *App) activeCallsign() string {
+	if a.profiles == nil {
+		return ""
+	}
+	if p, err := a.profiles.Active(a.ctx); err == nil {
+		return strings.ToUpper(strings.TrimSpace(p.Callsign))
+	}
+	return ""
+}
+
+func (a *App) clublogMostWantedEnabled() bool {
+	if a.settings == nil {
+		return false
+	}
+	v, _ := a.settings.Get(a.ctx, keyClublogMostWanted)
+	return v == "1"
+}
+
+// ClublogMostWantedInfo is the UI status of the ClubLog Most Wanted data.
+type ClublogMostWantedInfo struct {
+	Enabled  bool   `json:"enabled"`
+	Loaded   bool   `json:"loaded"`
+	Callsign string `json:"callsign"`
+	Date     string `json:"date"`
+	Count    int    `json:"count"`
+}
+
+// GetClublogMostWantedInfo returns the current Most Wanted status.
+func (a *App) GetClublogMostWantedInfo() ClublogMostWantedInfo {
+	info := ClublogMostWantedInfo{Enabled: a.clublogMostWantedEnabled()}
+	if a.clublogMW != nil {
+		info.Loaded = a.clublogMW.Loaded()
+		info.Callsign, info.Date, info.Count = a.clublogMW.Info()
+	}
+	return info
+}
+
+// SetClublogMostWantedEnabled toggles the Most Wanted feature. On first enable it
+// loads the cached list (the UI then calls Download to fetch a fresh one).
+func (a *App) SetClublogMostWantedEnabled(on bool) error {
+	if a.settings == nil {
+		return fmt.Errorf("db not initialized")
+	}
+	v := "0"
+	if on {
+		v = "1"
+	}
+	if err := a.settings.Set(a.ctx, keyClublogMostWanted, v); err != nil {
+		return err
+	}
+	if on && a.clublogMW != nil && !a.clublogMW.Loaded() {
+		_ = a.clublogMW.LoadFromDisk() // ok if not downloaded yet
+	}
+	return nil
+}
+
+// DownloadClublogMostWanted fetches a fresh Most Wanted list for the active call.
+func (a *App) DownloadClublogMostWanted() (ClublogMostWantedInfo, error) {
+	if a.clublogMW == nil {
+		return ClublogMostWantedInfo{}, fmt.Errorf("clublog not initialized")
+	}
+	if err := a.clublogMW.Download(a.ctx, a.activeCallsign()); err != nil {
+		return a.GetClublogMostWantedInfo(), err
+	}
+	return a.GetClublogMostWantedInfo(), nil
+}
+
 // applyClublogException overrides a QSO's entity fields from a ClubLog
 // exception matching its callsign at its date. force=true ignores the
 // enable toggle (used by the explicit "Update from ClubLog" action).
@@ -12059,7 +12216,10 @@ func (a ubAdapter) Status() motorStatus {
 	return motorStatus{Connected: st.Connected, Direction: st.Direction, Frequency: st.Frequency, Band: st.Band, Moving: st.MotorsMoving != 0, FreqMin: st.FreqMin, FreqMax: st.FreqMax}
 }
 
-type steppirAdapter struct{ c *steppir.Client }
+type steppirAdapter struct {
+	c                *steppir.Client
+	freqMin, freqMax int // MHz; tunable range (the SteppIR can't report its own)
+}
 
 func (a steppirAdapter) Start() error                { return a.c.Start() }
 func (a steppirAdapter) Stop()                       { a.c.Stop() }
@@ -12079,7 +12239,7 @@ func (a steppirAdapter) Status() motorStatus {
 	if err != nil || st == nil {
 		return motorStatus{}
 	}
-	return motorStatus{Connected: st.Connected, Direction: st.Direction, Frequency: st.Frequency, Band: st.Band, Moving: st.MotorsMoving != 0}
+	return motorStatus{Connected: st.Connected, Direction: st.Direction, Frequency: st.Frequency, Band: st.Band, Moving: st.MotorsMoving != 0, FreqMin: a.freqMin, FreqMax: a.freqMax}
 }
 
 // UltrabeamSettings is the JSON shape for the Hardware → Antenna panel. The name
@@ -12095,6 +12255,12 @@ type UltrabeamSettings struct {
 	Follow    bool   `json:"follow"`     // re-tune the antenna to the rig's frequency
 	StepKHz   int    `json:"step_khz"`   // re-tune only when the freq moved this far (25/50/100)
 	TXInhibit bool   `json:"tx_inhibit"` // block Flex transmission while the elements are moving
+	// SteppIR tunable range (MHz). The follow loop skips frequencies outside it —
+	// no tune command AND no TX inhibit — so a band the antenna can't cover (e.g.
+	// 30 m on a 20 m–6 m SteppIR) never traps TX. Ignored for the Ultrabeam, which
+	// reports its own per-band coverage. 0 = defaults filled in on load for SteppIR.
+	FreqMinMHz int `json:"freq_min_mhz"`
+	FreqMaxMHz int `json:"freq_max_mhz"`
 }
 
 // GetUltrabeamSettings returns the persisted motorized-antenna config, defaulting
@@ -12106,7 +12272,7 @@ func (a *App) GetUltrabeamSettings() (UltrabeamSettings, error) {
 		return out, fmt.Errorf("db not initialized")
 	}
 	m, err := a.settings.GetMany(a.ctx, keyUltrabeamEnabled, keyUltrabeamHost, keyUltrabeamPort, keyUltrabeamFollow, keyUltrabeamStep,
-		keyMotorType, keyMotorTransport, keyMotorCOM, keyMotorBaud, keyMotorTXInhibit)
+		keyMotorType, keyMotorTransport, keyMotorCOM, keyMotorBaud, keyMotorTXInhibit, keyMotorFreqMin, keyMotorFreqMax)
 	if err != nil {
 		return out, err
 	}
@@ -12130,6 +12296,20 @@ func (a *App) GetUltrabeamSettings() (UltrabeamSettings, error) {
 	if st, _ := strconv.Atoi(m[keyUltrabeamStep]); st == 25 || st == 50 || st == 100 {
 		out.StepKHz = st
 	}
+	out.FreqMinMHz, _ = strconv.Atoi(m[keyMotorFreqMin])
+	out.FreqMaxMHz, _ = strconv.Atoi(m[keyMotorFreqMax])
+	// A SteppIR doesn't report its coverage, so default to the standard 20 m–6 m
+	// range (13–54 MHz) when unset — the common model. Widen it (e.g. min 6 for a
+	// 40 m-equipped SteppIR) in Settings. This is what lets the follow loop leave
+	// TX alone on a band the antenna can't reach.
+	if out.Type == "steppir" {
+		if out.FreqMinMHz <= 0 {
+			out.FreqMinMHz = 13
+		}
+		if out.FreqMaxMHz <= 0 {
+			out.FreqMaxMHz = 54
+		}
+	}
 	return out, nil
 }
 
@@ -12154,6 +12334,16 @@ func (a *App) SaveUltrabeamSettings(s UltrabeamSettings) error {
 	if s.Baud < 1200 || s.Baud > 115200 {
 		s.Baud = 9600
 	}
+	// Sanity: keep the range ordered; 0 = "no limit" (stored as-is).
+	if s.FreqMinMHz < 0 {
+		s.FreqMinMHz = 0
+	}
+	if s.FreqMaxMHz < 0 {
+		s.FreqMaxMHz = 0
+	}
+	if s.FreqMinMHz > 0 && s.FreqMaxMHz > 0 && s.FreqMinMHz > s.FreqMaxMHz {
+		s.FreqMinMHz, s.FreqMaxMHz = s.FreqMaxMHz, s.FreqMinMHz
+	}
 	for k, v := range map[string]string{
 		keyUltrabeamEnabled: boolStr(s.Enabled),
 		keyUltrabeamHost:    strings.TrimSpace(s.Host),
@@ -12165,6 +12355,8 @@ func (a *App) SaveUltrabeamSettings(s UltrabeamSettings) error {
 		keyMotorCOM:         strings.TrimSpace(s.COM),
 		keyMotorBaud:        strconv.Itoa(s.Baud),
 		keyMotorTXInhibit:   boolStr(s.TXInhibit),
+		keyMotorFreqMin:     strconv.Itoa(s.FreqMinMHz),
+		keyMotorFreqMax:     strconv.Itoa(s.FreqMaxMHz),
 	} {
 		if err := a.settings.Set(a.ctx, k, v); err != nil {
 			return err
@@ -12186,7 +12378,7 @@ func newMotorClient(s UltrabeamSettings) motorAntenna {
 		if tr.Mode != "serial" && tr.Host == "" {
 			return nil
 		}
-		return steppirAdapter{steppir.New(tr)}
+		return steppirAdapter{c: steppir.New(tr), freqMin: s.FreqMinMHz, freqMax: s.FreqMaxMHz}
 	}
 	// Ultrabeam is TCP only.
 	if strings.TrimSpace(s.Host) == "" {
@@ -12299,6 +12491,7 @@ func (a *App) ultrabeamFollowLoop(c motorAntenna, stepKHz int, stop <-chan struc
 	ticker := time.NewTicker(1500 * time.Millisecond)
 	defer ticker.Stop()
 	lastRigKHz := 0 // only log when the followed rig frequency actually changes
+	lastCmdKHz := 0 // rig freq we last issued a move for — the deadband reference
 	for {
 		select {
 		case <-stop:
@@ -12332,13 +12525,21 @@ func (a *App) ultrabeamFollowLoop(c motorAntenna, stepKHz int, stop <-chan struc
 					continue
 				}
 			}
-			// Deadband reference = the antenna's reported freq, or (when it hasn't
+			// Deadband reference = the rig freq we LAST commanded a move for, not the
-			// reported one yet) the last freq we commanded — so a 0/blank status
+			// antenna's reported freq. A SteppIR reports a flaky/stale status
-			// doesn't bypass the deadband and re-tune on every small QSY.
+			// frequency (it flips between the commanded freq and its home/6 m value),
-			ref := st.Frequency
+			// which would trip the deadband and re-issue a SET on almost every poll —
+			// and each SET refreshes the "recently commanded" window that inhibits TX,
+			// leaving the operator permanently unable to transmit. Following the rig
+			// (only re-tune when the RIG actually QSYs beyond the step) is immune to
+			// that. Falls back to the antenna's own freq only until we've commanded once.
+			ref := lastCmdKHz
+			if ref <= 0 {
+				ref = st.Frequency
 				if ref <= 0 {
 					ref = c.LastSetKHz()
 				}
+			}
 			diff := rigKHz - ref
 			if diff < 0 {
 				diff = -diff
@@ -12350,6 +12551,7 @@ func (a *App) ultrabeamFollowLoop(c motorAntenna, stepKHz int, stop <-chan struc
 			if err := c.SetFrequency(rigKHz, st.Direction); err != nil {
 				applog.Printf("ultrabeam: follow re-tune to %d kHz failed: %v", rigKHz, err)
 			} else {
+				lastCmdKHz = rigKHz
 				applog.Printf("ultrabeam: followed rig → %d kHz (dir %d, was ref %d kHz, step %d)", rigKHz, st.Direction, ref, stepKHz)
 			}
 		}
@@ -13052,13 +13254,17 @@ func (a *App) GetWinkeyerSettings() (WinkeyerSettings, error) {
 		keyWKEnabled, keyWKPort, keyWKBaud, keyWKWPM, keyWKWeight, keyWKLeadIn,
 		keyWKTail, keyWKRatio, keyWKFarnsworth, keyWKSidetone, keyWKMode,
 		keyWKSwap, keyWKAutoSpace, keyWKUsePTT, keyWKSerialEcho, keyWKMacros,
-		keyWKEngine, keyWKEscClears, keyWKSendOnType)
+		keyWKEngine, keyWKEscClears, keyWKSendOnType, keyWKCWLine, keyWKCWInvert)
 	if err != nil {
 		return out, err
 	}
 	if v := m[keyWKEngine]; v != "" {
 		out.Engine = v
 	}
+	if v := m[keyWKCWLine]; v != "" {
+		out.CWKeyLine = v
+	}
+	out.CWInvert = m[keyWKCWInvert] == "1"
 	if v := m[keyWKEscClears]; v != "" {
 		out.EscClearsCall = v == "1"
 	}
@@ -13125,11 +13331,21 @@ func (a *App) SaveWinkeyerSettings(s WinkeyerSettings) error {
 		keyWKEngine:     strings.TrimSpace(s.Engine),
 		keyWKEscClears:  boolStr(s.EscClearsCall),
 		keyWKSendOnType: boolStr(s.SendOnType),
+		keyWKCWLine:     strings.TrimSpace(s.CWKeyLine),
+		keyWKCWInvert:   boolStr(s.CWInvert),
 	} {
 		if err := a.settings.Set(a.ctx, k, v); err != nil {
 			return err
 		}
 	}
+	// Apply line-control changes (PTT keying, key line, invert, lead/tail, speed)
+	// to a running serial keyer immediately — no reconnect needed. Harmless when
+	// the keyer isn't the serial type or isn't connected.
+	if a.winkeyer != nil && s.Engine == "serial" {
+		cfg := s.Config
+		cfg.Type = "serial"
+		a.winkeyer.ApplySerialConfig(cfg)
+	}
 	return nil
 }
 
@@ -13142,7 +13358,13 @@ func (a *App) WinkeyerConnect() error {
 	if err != nil {
 		return err
 	}
-	return a.winkeyer.Connect(s.Config)
+	cfg := s.Config
+	// The "serial" engine keys CW on the port's DTR/RTS lines (SCU-17 style)
+	// instead of talking the K1EL WinKeyer protocol — flag it for the manager.
+	if s.Engine == "serial" {
+		cfg.Type = "serial"
+	}
+	return a.winkeyer.Connect(cfg)
 }
 
 // WinkeyerDisconnect closes the serial link.

app_cw.go

@@ -0,0 +1,149 @@
+package main
+
+import (
+	"fmt"
+	"time"
+
+	"hamlog/internal/applog"
+	"hamlog/internal/audio"
+	"hamlog/internal/cwdecode"
+
+	wruntime "github.com/wailsapp/wails/v2/pkg/runtime"
+)
+
+// CW decoder: taps the RX audio device (the same "From radio" capture the DVK
+// and QSO recorder use) and streams decoded Morse text to the UI. It is started
+// only by the frontend, and only while the entry mode is CW.
+//
+// Pitch targeting: the single-channel decoder is far more reliable when it locks
+// to a KNOWN pitch (a narrow filter at the signal frequency, like a skimmer)
+// instead of auto-searching for the loudest tone. So we follow the radio's CW
+// pitch (FlexRadio cw_pitch) when available — or a manual override — and fall
+// back to auto-search otherwise.
+
+// cwTargetPitch returns the pitch (Hz) the decoder should lock to: the manual
+// override if set, else the FlexRadio's CW pitch when it's in CW, else 0 (auto).
+func (a *App) cwTargetPitch() int {
+	if a.cwPitchHz > 0 {
+		return a.cwPitchHz
+	}
+	if a.cat != nil {
+		if st, ok := a.cat.FlexState(); ok && st.Available {
+			// Only trust the radio's pitch when it's actually in CW.
+			if st.Mode == "CW" || st.Mode == "CWL" || st.Mode == "CWU" {
+				if st.CWPitch > 0 {
+					return st.CWPitch
+				}
+			}
+		}
+	}
+	return 0
+}
+
+// StartCWDecoder begins decoding CW from the configured RX audio device. The
+// frontend calls this when the decoder toggle is on AND the mode is CW. Safe to
+// call repeatedly; a second call is a no-op while already running.
+func (a *App) StartCWDecoder() error {
+	a.cwMu.Lock()
+	defer a.cwMu.Unlock()
+	if a.cwStop != nil {
+		return nil // already running
+	}
+	dev := ""
+	if a.settings != nil {
+		dev, _ = a.settings.Get(a.ctx, keyAudioFromRadio)
+	}
+	if dev == "" {
+		return fmt.Errorf("no RX audio device configured (set \"From radio\" in Audio settings)")
+	}
+
+	dec := cwdecode.New(audio.SampleRate,
+		func(text string) {
+			if a.ctx != nil {
+				wruntime.EventsEmit(a.ctx, "cw:text", text)
+			}
+		},
+		func(st cwdecode.Status) {
+			if a.ctx != nil {
+				wruntime.EventsEmit(a.ctx, "cw:status", st)
+			}
+		},
+	)
+	dec.SetTarget(a.cwTargetPitch())
+	a.cwDecoder = dec
+
+	stop := make(chan struct{})
+	a.cwStop = stop
+	go func() {
+		if err := audio.StreamCapture(dev, stop, dec.Process); err != nil {
+			applog.Printf("cw: capture failed: %v", err)
+			if a.ctx != nil {
+				wruntime.EventsEmit(a.ctx, "cw:error", err.Error())
+			}
+		}
+		a.cwMu.Lock()
+		if a.cwStop == stop {
+			a.cwStop = nil
+			a.cwDecoder = nil
+		}
+		a.cwMu.Unlock()
+	}()
+	// Follow the radio's CW pitch live (every second) while this run is active.
+	go a.cwFollowPitch(stop, dec)
+	return nil
+}
+
+// cwFollowPitch keeps the decoder locked to the current target pitch until stop.
+func (a *App) cwFollowPitch(stop <-chan struct{}, dec *cwdecode.Decoder) {
+	t := time.NewTicker(time.Second)
+	defer t.Stop()
+	for {
+		select {
+		case <-stop:
+			return
+		case <-t.C:
+			dec.SetTarget(a.cwTargetPitch())
+		}
+	}
+}
+
+// StopCWDecoder halts the CW decoder if running.
+func (a *App) StopCWDecoder() {
+	a.cwMu.Lock()
+	stop := a.cwStop
+	a.cwStop = nil
+	a.cwDecoder = nil
+	a.cwMu.Unlock()
+	if stop != nil {
+		close(stop)
+	}
+}
+
+// CWDecoderRunning reports whether the decoder is currently capturing.
+func (a *App) CWDecoderRunning() bool {
+	a.cwMu.Lock()
+	defer a.cwMu.Unlock()
+	return a.cwStop != nil
+}
+
+// SetCWDecoderPitch sets a manual decode pitch (Hz); 0 returns to auto (follow
+// the Flex CW pitch, or search). Applies live to a running decoder.
+func (a *App) SetCWDecoderPitch(hz int) {
+	if hz < 0 {
+		hz = 0
+	}
+	a.cwMu.Lock()
+	a.cwPitchHz = hz
+	dec := a.cwDecoder
+	a.cwMu.Unlock()
+	if dec != nil {
+		dec.SetTarget(a.cwTargetPitch())
+	}
+}
+
+// GetCWDecoderPitch returns the manual override (0 = auto / follow Flex).
+func (a *App) GetCWDecoderPitch() int {
+	a.cwMu.Lock()
+	defer a.cwMu.Unlock()
+	return a.cwPitchHz
+}

changelog.json

@@ -1,4 +1,52 @@
 [
+  {
+    "version": "0.20.12",
+    "date": "2026-07-24",
+    "en": [
+      "Fixed a motorized-antenna bug that could leave a FlexRadio permanently unable to transmit (‘Interlock is preventing transmission’). With a SteppIR whose status frequency reads intermittently (it flipped between the commanded frequency and its home value), the ‘follow the rig’ loop re-sent a tune command on almost every poll, and each command re-armed the ‘block TX while the antenna moves’ window — so the interlock never released. The follow loop now keys its deadband off the rig’s frequency (only re-tuning when the RADIO actually QSYs), immune to a flaky antenna status. Also dropped an ‘interlock set reason=’ command that SmartSDR rejects (it’s read-only) and only produced a harmless error line — the transmit-inhibit itself is unchanged and still holds TX safely while the elements move. New: a SteppIR ‘Tunable range’ setting (Settings → Hardware → Antenna, default 13–54 MHz = 20 m–6 m) — on a band outside it OpsLog leaves the antenna and TX completely alone, so tuning to 30 m on a 20 m–6 m SteppIR no longer tries to move it or touches the interlock.",
+      "New built-in award: The Helvetia 26 Award (H26) — the 26 cantons of Switzerland (USKA). Ships with the full canton reference list; matches the canton from the QSO's address or QTH, on HF, for Swiss (HB) contacts. Enable it in Awards and rescan to see your standings.",
+      "FlexRadio panel: the RECEIVE card is shorter again. All the noise controls added recently made it tower, so only the everyday ones — NB, NR, ANF — now stay visible; WNB and the SmartSDR v4 DSP block (NRL/NRS/NRF/ANFL and the AI/FFT RNN & ANFT) tuck behind a 'DSP' button you expand when you need them. The button carries a dot and highlights when one of the hidden controls is switched on, so nothing active is ever out of sight, and its open/closed state is remembered.",
+      "ADIF export can now pick exactly which fields to write. The global 'Export to ADIF' dialog gains a third choice, 'Choose fields…', alongside 'Standard ADIF fields' and 'All OpsLog fields'; and right-clicking selected QSOs adds 'Export selected — choose fields…'. The picker separates the official ADIF 3.1.7 fields (grouped by category) from OpsLog / non-standard tags actually present in your log, with All/None per group and a one-click reset to defaults. Your selection is remembered for next time.",
+      "Fixed 'Incorrect string value' (MySQL error 1366) when a QSO contained non-Latin characters — Cyrillic (Я), Polish ł, etc. — e.g. updating from QRZ. It happened when the shared MySQL database had been pre-created by the hosting panel as latin1, so OpsLog's tables couldn't store those letters. OpsLog now converts the database and its tables to utf8mb4 on connect (once, automatically), and everything stores correctly. Local SQLite logbooks were never affected.",
+      "NET Control: the on-air list now follows a mic-pass order you control instead of log time. A pinned '#' column numbers the round, ⬆⬇ buttons move the selected station up/down the queue, new check-ins join the end, and 'Log & end' advances to the next in line. The order is remembered per net. Header sorting is disabled on this list so a click can't shuffle the round.",
+      "The CW decoder (RX audio → text) is back, with a rebuilt decoding engine. The first version struggled on real signals; the new one adds a windowed tone detector, an adaptive dB envelope with noise squelch, two-way debouncing (a brief fade inside a dash no longer shatters it into dots), per-character dit/dah classification (even the first letter of an over decodes at any speed), and gap-fed speed tracking. It rides QSB, ignores QRM on other pitches, follows 12–40 WPM and sloppy hand keying — all proven by a synthetic-signal test suite. Tools → CW decoder (or the ear button): decodes while the mode is CW, with WPM/pitch/level display, pitch lock (follows the FlexRadio CW pitch automatically), and click-a-word to fill the callsign. Weak signals in heavy QRM remain hard — that's CW Skimmer territory — but clean-to-moderate signals now decode solidly.",
+      "Finished translating the Settings dialog: several panels that had stayed in English are now French too — the CW Keyer panel (and its long serial-engine paragraph removed for clarity), Password encryption, the ClubLog exceptions / Most Wanted blocks in General, and the External services tabs (HRDLOG, eQSL, LoTW, POTA).",
+      "Serial CW keyer: fixed the rig dropping to RX between words during a macro (PTT not held). On USB-serial interfaces like the Yaesu SCU-17 (CP210x), the previous method of driving the DTR/RTS lines would drop the held RTS (PTT) as soon as DTR (CW) toggled. OpsLog now drives the lines with the direct Win32 method N1MM/WSJT use (EscapeCommFunction), so RTS stays asserted for the whole transmission. 'Key PTT line' also defaults on for the Serial engine, and PTT / key-line / speed changes apply immediately without reconnecting the keyer.",
+      "New (Settings → General): show the ClubLog 'Most Wanted' rank in the entry-strip band matrix. When on, a 'MW #rank' pill appears next to the DXCC entity name (1 = the most wanted entity), coloured hotter the more wanted it is. The list is fetched from ClubLog and personalised to your callsign, refreshed daily.",
+      "Fixed the colour theme sometimes resetting to light after an update/relaunch: an update can clear the WebView's localStorage, and the fallback that restores the theme from the local settings database gave up after ~2.4s — occasionally too soon during the brief startup window before that store is ready. It now keeps retrying until the store actually answers, so a dark theme is reliably restored."
+    ],
+    "fr": [
+      "Correction d'un bug d'antenne motorisée qui pouvait laisser un FlexRadio définitivement incapable d'émettre (« Interlock is preventing transmission »). Avec une SteppIR dont la fréquence de statut se lit par intermittence (elle alternait entre la fréquence commandée et sa valeur de repos), la boucle de suivi renvoyait un ordre d'accord à presque chaque cycle, et chaque ordre réarmait la fenêtre « bloquer l'émission pendant que l'antenne bouge » — l'interlock ne se relâchait donc jamais. La boucle de suivi se base maintenant sur la fréquence de la RADIO (elle ne réaccorde que quand le poste change réellement de fréquence), insensible à un statut d'antenne erratique. Retrait aussi d'une commande « interlock set reason= » que SmartSDR refuse (champ en lecture seule) et qui ne produisait qu'une ligne d'erreur sans effet — l'inhibition d'émission elle-même est inchangée et protège toujours pendant le mouvement des éléments. Nouveau : un réglage « Plage accordable » pour la SteppIR (Réglages → Matériel → Antenne, défaut 13-54 MHz = 20 m-6 m) — sur une bande hors de cette plage, OpsLog laisse totalement l'antenne et l'émission tranquilles, donc passer sur 30 m avec une SteppIR 20 m-6 m ne tente plus de la bouger ni ne touche à l'interlock.",
+      "Nouveau diplôme intégré : The Helvetia 26 Award (H26) — les 26 cantons de Suisse (USKA). Livré avec la liste complète des cantons ; il reconnaît le canton depuis l'adresse ou le QTH du QSO, en HF, pour les contacts suisses (HB). Active-le dans les Diplômes et relance un scan pour voir ton avancement.",
+      "Panneau FlexRadio : la carte RÉCEPTION est de nouveau plus compacte. Tous les contrôles de bruit ajoutés récemment la faisaient s'allonger, donc seuls ceux du quotidien — NB, NR, ANF — restent visibles ; le WNB et le bloc DSP SmartSDR v4 (NRL/NRS/NRF/ANFL ainsi que RNN & ANFT IA/FFT) se replient derrière un bouton « DSP » que tu déplies au besoin. Le bouton porte un point et s'illumine quand l'un des contrôles masqués est activé, pour ne jamais perdre de vue quelque chose d'actif, et son état ouvert/fermé est mémorisé.",
+      "L'export ADIF permet maintenant de choisir précisément les champs à écrire. La fenêtre globale « Exporter en ADIF » gagne un troisième choix, « Choisir les champs… », à côté de « Champs ADIF standard » et « Tous les champs OpsLog » ; et le clic droit sur des QSO sélectionnés ajoute « Exporter la sélection — choisir les champs… ». Le sélecteur sépare les champs ADIF 3.1.7 officiels (regroupés par catégorie) des balises OpsLog / non standard réellement présentes dans ton log, avec Tout/Aucun par groupe et un retour aux valeurs par défaut en un clic. Ta sélection est mémorisée pour la prochaine fois.",
+      "Correction de « Incorrect string value » (erreur MySQL 1366) quand un QSO contenait des caractères non latins — cyrillique (Я), polonais ł, etc. — p. ex. lors d'une mise à jour depuis QRZ. Ça arrivait quand la base MySQL partagée avait été pré-créée en latin1 par le panel d'hébergement, empêchant les tables d'OpsLog de stocker ces lettres. OpsLog convertit désormais la base et ses tables en utf8mb4 à la connexion (une seule fois, automatiquement), et tout s'enregistre correctement. Les logbooks SQLite locaux n'étaient pas concernés.",
+      "NET Control : la liste on-air suit maintenant un ordre de passage du micro que tu contrôles, au lieu de l'heure de log. Une colonne « # » épinglée numérote le tour, les boutons ⬆⬇ montent/descendent la station sélectionnée dans la file, les nouveaux arrivants rejoignent la fin, et « Logger & terminer » passe au suivant. L'ordre est mémorisé par NET. Le tri par en-tête est désactivé sur cette liste pour qu'un clic ne bouscule pas le tour.",
+      "Le décodeur CW (audio RX → texte) est de retour, avec un moteur de décodage reconstruit. La première version peinait sur les vrais signaux ; la nouvelle ajoute un détecteur de tonalité fenêtré, une enveloppe dB adaptative avec squelch de bruit, un anti-rebond bilatéral (un bref fading dans un trait ne le brise plus en points), une classification point/trait par caractère (même la première lettre d'un over se décode à n'importe quelle vitesse) et un suivi de vitesse nourri par les espaces. Il tient le QSB, ignore le QRM sur d'autres tonalités, suit de 12 à 40 WPM et la manipulation humaine approximative — le tout prouvé par une suite de tests sur signaux synthétiques. Outils → Décodeur CW (ou le bouton oreille) : décode quand le mode est CW, avec affichage WPM/tonalité/niveau, verrouillage de tonalité (suit automatiquement le pitch CW du FlexRadio) et clic-sur-un-mot pour remplir l'indicatif. Les signaux faibles dans un fort QRM restent difficiles — c'est le territoire de CW Skimmer — mais les signaux propres à moyens se décodent maintenant solidement.",
+      "Fin de la traduction de la fenêtre Réglages : plusieurs panneaux restés en anglais sont maintenant en français aussi — le Manipulateur CW (et son long paragraphe moteur série retiré pour l'alléger), le Chiffrement des mots de passe, les blocs Exceptions ClubLog / Most Wanted dans Général, et les onglets Services externes (HRDLOG, eQSL, LoTW, POTA).",
+      "Keyer CW série : correction de la radio qui retombait en RX entre les mots pendant une macro (PTT non tenu). Sur les interfaces USB-série comme le Yaesu SCU-17 (CP210x), l'ancienne méthode de pilotage des lignes DTR/RTS faisait retomber le RTS (PTT) dès que DTR (CW) basculait. OpsLog pilote maintenant les lignes avec la méthode Win32 directe qu'utilisent N1MM/WSJT (EscapeCommFunction), donc RTS reste asserté toute l'émission. « Key PTT line » est aussi activé par défaut pour le moteur Série, et les changements PTT / ligne / vitesse s'appliquent immédiatement sans reconnecter le keyer.",
+      "Nouveau (Réglages → Général) : afficher le rang « Most Wanted » de ClubLog dans la matrice de bandes de la barre de saisie. Activé, une pastille « MW #rang » apparaît à côté du nom de l'entité DXCC (1 = l'entité la plus recherchée), d'autant plus colorée qu'elle est recherchée. La liste est récupérée depuis ClubLog et personnalisée selon ton indicatif, rafraîchie quotidiennement.",
+      "Correction du thème de couleur qui revenait parfois au clair après une mise à jour/relancement : une mise à jour peut vider le localStorage de la WebView, et le repli qui restaure le thème depuis la base de réglages locale abandonnait après ~2,4s — parfois trop tôt pendant le court instant de démarrage avant que ce store soit prêt. Il réessaie maintenant jusqu'à ce que le store réponde vraiment, donc un thème sombre est restauré de façon fiable."
+    ]
+  },
+  {
+    "version": "0.20.11",
+    "date": "2026-07-23",
+    "en": [
+      "Fixed clicking a spot / band-map entry not moving the radio on Yaesu (and other non-Icom) rigs controlled through OmniRig — e.g. the FT-891. OpsLog tuned via OmniRig's SetSimplexMode, which on these rigs returns success but silently doesn't move the VFO (mode changes worked, so it looked like a puzzle). It now also writes the VFO frequency property directly, which does move them. Icom rigs are unchanged (there SetSimplexMode is the reliable path).",
+      "New CW keyer engine: 'Serial port (DTR=CW / RTS=PTT)'. OpsLog can now key CW by toggling a serial control line itself — the hardware-keying method N1MM/WSJT use with a Yaesu SCU-17 and generic keying interfaces — without a K1EL WinKeyer. Settings → CW Keyer → Keyer engine: pick 'Serial port', choose the keying COM port and whether CW is on DTR (PTT on RTS) or swapped. Speed, Farnsworth, lead-in/tail and PTT keying all apply; macros, auto-CQ and <LOGQSO> work exactly as with the WinKeyer. An 'Invert keying (active-LOW)' option is there for interfaces that key backwards / transmit at rest.",
+      "Fixed the spectrum scope never displaying on the IC-7300: its CI-V waveform frames actually carry the same leading main-scope selector byte as the dual-scope IC-7610/9700, but OpsLog assumed the 7300 omitted it — so it read the frame sequence number from the wrong byte (always 0), discarded every frame, and drew nothing. The frame layout is now detected from the data itself, so the 7300 (and other single-scope Icoms) render correctly, in both center and fixed modes. The IC-7610/9700 are unaffected.",
+      "IC-7300 scope: the center/fixed mode and edge-frequency commands now include the selector byte the rig requires, so switching the scope between center-on-VFO and fixed span from OpsLog is accepted instead of being rejected.",
+      "Closing OpsLog no longer switches off the scope display on the radio itself: turning the scope off used to send both 'stop CI-V data' and 'display off', so quitting blanked a local IC-7300's own scope screen. It now only stops the CI-V data stream on disable and never touches the radio's display (the display-on command is sent solely when enabling)."
+    ],
+    "fr": [
+      "Correction : cliquer un spot / une entrée de band-map ne changeait pas la fréquence sur les Yaesu (et autres radios non-Icom) pilotées via OmniRig — p. ex. le FT-891. OpsLog accordait via SetSimplexMode d'OmniRig, qui sur ces radios renvoie « OK » mais ne bouge pas le VFO (le changement de mode marchait, d'où l'énigme). Il écrit maintenant aussi directement la propriété fréquence du VFO, ce qui les fait bien QSY. Les Icom sont inchangés (là, SetSimplexMode reste la bonne méthode).",
+      "Nouveau moteur de keyer CW : « Port série (DTR=CW / RTS=PTT) ». OpsLog peut désormais manipuler la CW en basculant lui-même une ligne de contrôle série — la méthode de keying matériel qu'utilisent N1MM/WSJT avec un Yaesu SCU-17 et les interfaces génériques — sans WinKeyer K1EL. Réglages → Keyer CW → Moteur : choisis « Port série », le port COM de keying et si la CW est sur DTR (PTT sur RTS) ou l'inverse. Vitesse, Farnsworth, lead-in/tail et PTT s'appliquent ; les macros, l'auto-CQ et <LOGQSO> fonctionnent exactement comme avec le WinKeyer. Une option « Inverser le keying (actif-BAS) » est prévue pour les interfaces qui manipulent à l'envers / émettent au repos.",
+      "Correction du scope spectral qui ne s'affichait jamais sur l'IC-7300 : ses trames de forme d'onde CI-V portent en réalité le même octet sélecteur de scope en tête que les IC-7610/9700 (dual-scope), mais OpsLog supposait que le 7300 ne l'envoyait pas — il lisait donc le numéro de séquence de la trame sur le mauvais octet (toujours 0), jetait toutes les trames et ne dessinait rien. La disposition des trames est maintenant détectée à partir des données elles-mêmes, donc le 7300 (et les autres Icom mono-scope) s'affichent correctement, en mode centre comme en fixe. Les IC-7610/9700 ne sont pas affectés.",
+      "Scope IC-7300 : les commandes de mode centre/fixe et de fréquences de bords incluent maintenant l'octet sélecteur requis par la radio, donc basculer le scope entre centre-sur-VFO et span fixe depuis OpsLog est accepté au lieu d'être rejeté.",
+      "Fermer OpsLog n'éteint plus le scope sur la radio elle-même : couper le scope envoyait à la fois « stop données CI-V » et « affichage OFF », donc quitter éteignait l'écran scope d'un IC-7300 local. Désormais seule la diffusion des données CI-V est coupée à la désactivation, l'affichage de la radio n'est jamais touché (la commande d'allumage n'est envoyée qu'à l'activation)."
+    ]
+  },
   {
     "version": "0.20.10",
     "date": "2026-07-23",

frontend/src/App.tsx

@@ -1,6 +1,6 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import {
-  Activity, AlertCircle, Antenna, Bell, CheckCircle2, Clock, CloudOff, Compass, Database, Eraser, Hash, Loader2, Lock,
+  Activity, AlertCircle, Antenna, Bell, CheckCircle2, Clock, CloudOff, Compass, Database, Ear, Eraser, Hash, Loader2, Lock,
   Maximize2, Minimize2, Mic, MessageSquare, Pencil, Radio, RadioTower, RefreshCw, Satellite, Send, Settings, SlidersHorizontal, Square, Terminal, Trash2, Unlock, X, Zap,
 } from 'lucide-react';
 
@@ -39,6 +39,7 @@ import {
   IcomSendCW, IcomStopCW, IcomSetKeySpeed, IcomSetBreakIn, GetIcomState,
   FlexSendCW, FlexStopCW, FlexSetKeySpeed, FlexBackspaceCW,
   GetDVKMessages, GetDVKStatus, DVKPlay, DVKStop,
+  StartCWDecoder, StopCWDecoder, SetCWDecoderPitch,
   ChatAvailable, GetChatHistory, SendChatMessage, GetOnlineOperators,
   QSOAudioBegin, QSOAudioCancel, QSOAudioRestart, QSOAudioResetClock,
   GetAwardDefs,
@@ -73,6 +74,7 @@ import { AwardsPanel } from '@/components/AwardsPanel';
 import { StatsPanel } from '@/components/StatsPanel';
 import { StationControlPanel } from '@/components/StationControlPanel';
 import { RecentQSOsGrid } from '@/components/RecentQSOsGrid';
+import { ExportFieldsDialog } from '@/components/ExportFieldsDialog';
 import { ShutdownProgress } from '@/components/ShutdownProgress';
 import { ClusterGrid } from '@/components/ClusterGrid';
 import { cleanSpotter, inferSpotMode, spotModeCategory, spotStatusKey } from '@/lib/spot';
@@ -852,6 +854,37 @@ export default function App() {
 
   // === Digital Voice Keyer (DVK) ===
 
+  // CW decoder: taps RX audio and decodes Morse. Runs only when enabled AND the
+  // mode is CW. The decoded text appears in a strip above the tabs.
+  const [cwEnabled, setCwEnabled] = useState(() => localStorage.getItem('opslog.cwDecoder') === '1');
+  const [cwText, setCwText] = useState('');
+  const [cwStatus, setCwStatus] = useState<{ wpm: number; pitch: number; level: number; active: boolean }>({ wpm: 0, pitch: 0, level: 0, active: false });
+  const cwOn = cwEnabled && mode === 'CW';
+  // Keep the decoded line scrolled to the newest text (left-aligned, no scrollbar).
+  const cwScrollRef = useRef<HTMLDivElement>(null);
+  useEffect(() => { const el = cwScrollRef.current; if (el) el.scrollLeft = el.scrollWidth; }, [cwText]);
+  // Manual pitch override ('' = Auto: follow the radio's CW pitch / search).
+  const [cwPitch, setCwPitch] = useState(() => localStorage.getItem('opslog.cwPitch') || '');
+  useEffect(() => {
+    const hz = parseInt(cwPitch, 10);
+    SetCWDecoderPitch(Number.isFinite(hz) ? hz : 0).catch(() => {});
+    localStorage.setItem('opslog.cwPitch', cwPitch);
+  }, [cwPitch, cwOn]);
+  useEffect(() => {
+    const offT = EventsOn('cw:text', (txt: string) => setCwText((s) => (s + txt).slice(-200)));
+    const offS = EventsOn('cw:status', (st: any) => setCwStatus(st));
+    const offE = EventsOn('cw:error', (e: string) => { setError(String(e)); setCwEnabled(false); });
+    return () => { offT?.(); offS?.(); offE?.(); };
+  }, []);
+  // Start/stop the backend decoder as the (enabled, mode) combination changes.
+  useEffect(() => {
+    if (cwOn) { StartCWDecoder().catch((e: any) => { setError(String(e?.message ?? e)); setCwEnabled(false); }); }
+    else { StopCWDecoder().catch(() => {}); }
+  }, [cwOn]);
+  function toggleCwDecoder() {
+    setCwEnabled((v) => { const n = !v; localStorage.setItem('opslog.cwDecoder', n ? '1' : '0'); return n; });
+  }
+
   // === Multi-op chat (shared MySQL logbook) — docked panel like rotor/DVK ===
   const [chatAvailable, setChatAvailable] = useState(false);
   const [chatOpen, setChatOpen] = useState(false);
@@ -1296,6 +1329,9 @@ export default function App() {
   const [exporting, setExporting] = useState(false);
   // Export mode chooser: standard ADIF (other loggers) vs full (OpsLog round-trip).
   const [showExportChoice, setShowExportChoice] = useState(false);
+  // Field-picker export: null when closed; ids present = export those selected
+  // rows, absent = export the whole logbook (global "choose fields" flow).
+  const [fieldPicker, setFieldPicker] = useState<{ ids?: number[]; count: number } | null>(null);
   const [importResult, setImportResult] = useState<ImportResult | null>(null);
   const [importErrorsOpen, setImportErrorsOpen] = useState(false);
   const [importDupsOpen, setImportDupsOpen] = useState(false);
@@ -2130,7 +2166,7 @@ export default function App() {
       setWkMacros((s.macros ?? []) as WKMacro[]);
       setWkEscClears(s.esc_clears_call !== false);
       setWkSendOnType(!!s.send_on_type);
-      setWkEngine(s.engine === 'icom' ? 'icom' : s.engine === 'flex' ? 'flex' : 'winkeyer');
+      setWkEngine(s.engine === 'icom' ? 'icom' : s.engine === 'flex' ? 'flex' : s.engine === 'serial' ? 'serial' : 'winkeyer');
     } catch { /* keyer not configured */ }
   }, []);
 
@@ -2582,25 +2618,32 @@ export default function App() {
   }
   // Right-click "Export filtered to ADIF (no limit)": exports every QSO that
   // matches the current filter, bypassing the on-screen row threshold.
-  async function exportFilteredADIF() {
+  // fields (optional): a chosen ADIF-tag list — the "choose which fields" export.
+  // Empty = the standard/full behaviour (all fields, includeAppFields=false here).
+  async function exportFilteredADIF(fields: string[] = []) {
     try {
       const path = await SaveADIFFile();
       if (!path) return;
       const f = buildActiveFilter();
-      const r = await ExportADIFFiltered(path, false, { ...f, limit: 0, offset: 0 } as any);
+      const r = await ExportADIFFiltered(path, false, { ...f, limit: 0, offset: 0 } as any, fields);
       showToast(`Exported ${r.count} QSO${r.count > 1 ? 's' : ''} → ${r.path}`);
     } catch (e: any) { setError(String(e?.message ?? e)); }
   }
   // Right-click "Export selected to ADIF": only the highlighted rows.
-  async function exportSelectedADIF(ids: number[]) {
+  async function exportSelectedADIF(ids: number[], fields: string[] = []) {
     if (ids.length === 0) return;
     try {
       const path = await SaveADIFFile();
       if (!path) return;
-      const r = await ExportADIFSelected(path, false, ids as any);
+      const r = await ExportADIFSelected(path, false, ids as any, fields);
       showToast(`Exported ${r.count} selected QSO${r.count > 1 ? 's' : ''} → ${r.path}`);
     } catch (e: any) { setError(String(e?.message ?? e)); }
   }
+  // Open the field-picker to export the highlighted rows with chosen fields.
+  function exportSelectedFields(ids: number[]) {
+    if (ids.length === 0) return;
+    setFieldPicker({ ids, count: ids.length });
+  }
   // Cabrillo (contest log) export → a .log file. The contest name comes from the
   // QSOs' ADIF CONTEST_ID (no prompt). All / filtered / selected mirror the ADIF ones.
   async function exportCabrillo() {
@@ -2840,7 +2883,10 @@ export default function App() {
     if (exporting) return;
     setShowExportChoice(true); // pick standard vs full first
   }
-  async function runExport(includeAppFields: boolean) {
+  // includeAppFields is ignored when fields is a non-empty chosen set (the set
+  // decides everything). Used by both the standard/full buttons and the
+  // "choose fields" flow (global export of the whole logbook).
+  async function runExport(includeAppFields: boolean, fields: string[] = []) {
     setShowExportChoice(false);
     if (exporting) return;
     setError('');
@@ -2848,9 +2894,10 @@ export default function App() {
       const path = await SaveADIFFile();
       if (!path) return;
       setExporting(true);
-      const res = await ExportADIF(path, includeAppFields);
+      const res = await ExportADIF(path, includeAppFields, fields);
+      const kind = fields.length ? ` (${fields.length} fields)` : includeAppFields ? ' (full)' : ' (standard)';
       // Green success toast (auto-dismiss) — not the red error banner.
-      showToast(`ADIF exported${includeAppFields ? ' (full)' : ' (standard)'}: ${res.count.toLocaleString()} QSOs → ${res.path} (${res.size_kb.toLocaleString()} KB)`);
+      showToast(`ADIF exported${kind}: ${res.count.toLocaleString()} QSOs → ${res.path} (${res.size_kb.toLocaleString()} KB)`);
     } catch (e: any) {
       setError(`ADIF export failed: ${String(e?.message ?? e)}`);
     } finally {
@@ -2908,6 +2955,7 @@ export default function App() {
       { type: 'separator' },
       { type: 'item', label: (wkEnabled ? '✓ ' : '') + t('tools.winkeyer'), action: 'tools.winkeyer' },
       { type: 'item', label: (dvkEnabled ? '✓ ' : '') + t('tools.dvk'), action: 'tools.dvk' },
+      { type: 'item', label: (cwEnabled ? '✓ ' : '') + t('tools.cwDecoder'), action: 'tools.cwdecoder' },
       { type: 'separator' },
       { type: 'item', label: (netEnabled ? '✓ ' : '') + t('tools.net'), action: 'tools.net' },
       { type: 'item', label: (contestTabEnabled ? '✓ ' : '') + t('tools.contest'), action: 'tools.contest' },
@@ -2930,7 +2978,7 @@ export default function App() {
       { type: 'separator' },
       { type: 'item', label: t('help.about'), action: 'help.about' },
     ]},
-  ], [total, selectedId, selectedIds, ctyRefreshing, refsDownloading, exporting, wkEnabled, dvkEnabled, netEnabled, contestTabEnabled, smtpConfigured, sendingLog, t]);
+  ], [total, selectedId, selectedIds, ctyRefreshing, refsDownloading, exporting, wkEnabled, dvkEnabled, cwEnabled, netEnabled, contestTabEnabled, smtpConfigured, sendingLog, t]);
 
   function handleMenu(action: string) {
     switch (action) {
@@ -2951,6 +2999,7 @@ export default function App() {
       case 'tools.qsldesigner': setQslDesignerOpen(true); break;
       case 'tools.winkeyer':    wkSetEnabled(!wkEnabled); break;
       case 'tools.dvk':         setDvkEnabled((v) => !v); break;
+      case 'tools.cwdecoder':   toggleCwDecoder(); break;
       case 'tools.net':         setNetEnabled((v) => { const nv = !v; if (nv) setActiveTab('net'); return nv; }); break;
       case 'tools.contest':     setContestTabEnabled((v) => { const nv = !v; if (nv) setActiveTab('contest'); else setActiveTab((tb) => (tb === 'contest' ? 'recent' : tb)); return nv; }); break;
       case 'tools.alerts':      setAlertsOpen(true); break;
@@ -3821,6 +3870,7 @@ export default function App() {
               onSendEQSL={(ids) => setEqslQsoId(ids[0] ?? null)}
               onBulkEdit={openBulkEdit}
               onExportSelected={exportSelectedADIF}
+              onExportSelectedFields={exportSelectedFields}
               onExportFiltered={exportFilteredADIF}
               onDelete={(ids) => setDeletingIds(ids)}
               onRowSelected={(ids) => { setSelectedIds(ids); setSelectedId(ids[0] ?? null); }}
@@ -4000,6 +4050,20 @@ export default function App() {
               <Zap className="size-4" />
               {wkStatus.busy && <span className="absolute -top-0.5 -right-0.5 size-2 rounded-full bg-warning animate-pulse" />}
             </button>
+            <button
+              type="button"
+              onClick={toggleCwDecoder}
+              title={cwEnabled ? (mode === 'CW' ? t('cwd.tipOnCw') : t('cwd.tipOnIdle')) : t('cwd.tipOff')}
+              className={cn(
+                'relative inline-flex items-center justify-center size-7 rounded-md border transition-colors',
+                cwOn && cwStatus.active ? 'border-success bg-success-muted text-success-muted-foreground'
+                  : cwEnabled ? 'border-success-border bg-success-muted text-success-muted-foreground hover:bg-success-muted'
+                  : 'border-border text-muted-foreground hover:bg-muted',
+              )}
+            >
+              <Ear className="size-4" />
+              {cwOn && cwStatus.active && <span className="absolute -top-0.5 -right-0.5 size-2 rounded-full bg-success animate-pulse" />}
+            </button>
             <button
               type="button"
               onClick={() => { const v = !showRotor; setShowRotor(v); writeUiPref('opslog.showRotor', v ? '1' : '0'); }}
@@ -4664,6 +4728,53 @@ export default function App() {
       </div>{/* /entry + aside row */}
 
       {/* ===== CW decoder strip (only when enabled AND mode is CW) ===== */}
+      {cwOn && (
+        <div className="ml-2.5 mt-1.5 -mb-1 w-[45%] flex items-center gap-2 rounded-md border border-success-border/70 bg-success-muted/60 px-2 py-1.5 text-xs">
+          <Ear className={cn('size-4 shrink-0', cwStatus.active ? 'text-success' : 'text-muted-foreground')} />
+          {/* Input-level meter — if this stays flat with a strong signal, the RX
+              audio device is wrong/silent rather than a decode problem. */}
+          <div className="shrink-0 w-12 h-1.5 rounded bg-muted overflow-hidden" title={t('cwd.levelTip', { pct: Math.round(cwStatus.level * 100) })}>
+            <div className="h-full bg-success transition-[width] duration-100" style={{ width: `${Math.min(100, Math.round(cwStatus.level * 100))}%` }} />
+          </div>
+          <span className="shrink-0 font-mono text-[10px] text-muted-foreground tabular-nums">
+            {cwStatus.wpm > 0 ? `${cwStatus.wpm} WPM` : '— WPM'} · {cwStatus.pitch > 0 ? `${cwStatus.pitch} Hz` : '— Hz'}
+          </span>
+          {/* Lock pitch: blank = Auto (follow the Flex CW pitch / search). */}
+          <input
+            type="number"
+            value={cwPitch}
+            onChange={(e) => setCwPitch(e.target.value)}
+            placeholder="auto"
+            title={t('cwd.pitchTip')}
+            className="shrink-0 w-14 h-5 rounded border border-success-border/70 bg-card/60 px-1 text-[10px] font-mono text-center outline-none"
+          />
+          {/* Left-aligned single line, no scrollbar; auto-scrolled to the newest
+              text (see cwScrollRef effect) so the latest stays in view. */}
+          <div ref={cwScrollRef} className="flex-1 min-w-0 overflow-hidden font-mono leading-none flex items-center">
+            {cwText.trim() === '' ? (
+              <span className="text-muted-foreground italic">{t('cwd.listening')}</span>
+            ) : (
+              <div className="inline-flex items-center whitespace-nowrap">
+                {cwText.trim().split(/\s+/).map((tok, i) => (
+                  <button
+                    key={i}
+                    type="button"
+                    className="mr-1 shrink-0 rounded px-1 leading-none hover:bg-success-muted/70"
+                    title={t('cwd.useCall')}
+                    onClick={() => onCallsignInput(tok, { force: true })}
+                  >
+                    {tok}
+                  </button>
+                ))}
+              </div>
+            )}
+          </div>
+          <button type="button" className="shrink-0 text-muted-foreground hover:text-foreground" title={t('cwd.clear')} onClick={() => setCwText('')}>
+            <Eraser className="size-3.5" />
+          </button>
+        </div>
+      )}
+
       {/* ===== LOWER: tabbed table / cluster / band map ===== */}
       {compact ? null : <>
       <div className={cn('grid gap-2.5 p-2.5 flex-1 min-h-0 grid-rows-[minmax(0,1fr)]',
@@ -4838,6 +4949,7 @@ export default function App() {
                 onSendEQSL={(ids) => setEqslQsoId(ids[0] ?? null)}
                 onBulkEdit={openBulkEdit}
                 onExportSelected={exportSelectedADIF}
+                onExportSelectedFields={exportSelectedFields}
                 onExportFiltered={exportFilteredADIF}
                 onExportCabrilloSelected={exportSelectedCabrillo}
                 onExportCabrilloFiltered={exportFilteredCabrillo}
@@ -5471,10 +5583,8 @@ export default function App() {
         <Dialog open onOpenChange={(o) => { if (!o) setShowExportChoice(false); }}>
           <DialogContent className="max-w-lg px-6">
             <DialogHeader className="px-2">
-              <DialogTitle>Export ADIF</DialogTitle>
+              <DialogTitle>{t('exp.title')}</DialogTitle>
-              <DialogDescription>
+              <DialogDescription>{t('exp.desc')}</DialogDescription>
-                Choose which fields to include. OpsLog writes ADIF 3.1.7.
-              </DialogDescription>
             </DialogHeader>
             <div className="px-2 py-1 space-y-2.5">
               <button
@@ -5482,30 +5592,46 @@ export default function App() {
                 onClick={() => runExport(false)}
                 className="w-full text-left rounded-lg border border-border p-3 hover:border-primary/60 hover:bg-accent/30 transition-colors"
               >
-                <div className="font-semibold text-sm">Standard ADIF only</div>
+                <div className="font-semibold text-sm">{t('exp.stdTitle')}</div>
-                <div className="text-xs text-muted-foreground mt-0.5">
+                <div className="text-xs text-muted-foreground mt-0.5">{t('exp.stdDesc')}</div>
-                  Only fields defined in the ADIF 3.1.7 spec — portable to other loggers (Log4OM, N1MM, LoTW…).
-                  Application-specific <span className="font-mono">APP_*</span> and any non-standard / vendor tags are stripped.
-                </div>
               </button>
               <button
                 type="button"
                 onClick={() => runExport(true)}
                 className="w-full text-left rounded-lg border border-border p-3 hover:border-primary/60 hover:bg-accent/30 transition-colors"
               >
-                <div className="font-semibold text-sm">All fields (OpsLog round-trip)</div>
+                <div className="font-semibold text-sm">{t('exp.allTitle')}</div>
-                <div className="text-xs text-muted-foreground mt-0.5">
+                <div className="text-xs text-muted-foreground mt-0.5">{t('exp.allDesc')}</div>
-                  Every field including application-specific <span className="font-mono">APP_*</span> and vendor tags —
+              </button>
-                  a lossless backup you'll re-import into OpsLog.
+              <button
-                </div>
+                type="button"
+                onClick={() => { setShowExportChoice(false); setFieldPicker({ count: total }); }}
+                className="w-full text-left rounded-lg border border-border p-3 hover:border-primary/60 hover:bg-accent/30 transition-colors"
+              >
+                <div className="font-semibold text-sm">{t('exp.chooseTitle')}</div>
+                <div className="text-xs text-muted-foreground mt-0.5">{t('exp.chooseDesc')}</div>
               </button>
             </div>
             <DialogFooter className="px-2 bg-transparent border-t-0">
-              <Button variant="outline" onClick={() => setShowExportChoice(false)}>Cancel</Button>
+              <Button variant="outline" onClick={() => setShowExportChoice(false)}>{t('exf.cancel')}</Button>
             </DialogFooter>
           </DialogContent>
         </Dialog>
       )}
+      {fieldPicker && (
+        <ExportFieldsDialog
+          open
+          count={fieldPicker.count}
+          onClose={() => setFieldPicker(null)}
+          onExport={(fields) => {
+            const fp = fieldPicker;
+            setFieldPicker(null);
+            if (!fp) return;
+            if (fp.ids) exportSelectedADIF(fp.ids, fields);
+            else runExport(false, fields);
+          }}
+        />
+      )}
       {pendingImportPath && (
         <Dialog open onOpenChange={(o) => { if (!o) setPendingImportPath(null); }}>
           <DialogContent className="max-w-lg px-6">

frontend/src/components/BandSlotGrid.tsx

@@ -94,6 +94,7 @@ export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, hasCal
   const dxcc = wb?.dxcc ?? 0;
   const dxccName = wb?.dxcc_name ?? '';
   const dxccCount = wb?.dxcc_count ?? 0;
+  const mwRank = wb?.mw_rank ?? 0; // ClubLog Most Wanted rank (1 = most wanted; 0 = off/unknown)
   const callCount = wb?.count ?? 0; // QSOs with this exact callsign
   const hasDxcc = dxcc > 0;
   const newOne = hasDxcc && dxccCount === 0;
@@ -136,6 +137,20 @@ export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, hasCal
   const newMode = slotNew && bandWorked && !modeWorked;
   const newSlot = slotNew && bandWorked && modeWorked;
 
+  // ClubLog Most Wanted rank pill (shown next to the entity name when the feature
+  // is on). Hotter colour the more wanted the entity is.
+  const mwBadge = mwRank > 0 ? (
+    <Badge
+      title={`ClubLog Most Wanted #${mwRank}`}
+      className={cn('px-1.5 py-0 text-[10px] font-bold shrink-0',
+        mwRank <= 100 ? 'bg-danger text-danger-foreground'
+          : mwRank <= 250 ? 'bg-warning text-warning-foreground'
+            : 'bg-muted text-muted-foreground')}
+    >
+      MW #{mwRank}
+    </Badge>
+  ) : null;
+
   return (
     <section
       className={cn(
@@ -154,12 +169,14 @@ export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, hasCal
               <strong className="text-warning-muted-foreground font-semibold">{dxccName || `DXCC #${dxcc}`}</strong>
               {' '}· never worked this entity
             </span>
+            {mwBadge}
           </>
         ) : hasDxcc ? (
           <>
             <Badge className="bg-primary text-primary-foreground px-3 py-1 text-xs normal-case font-semibold tracking-normal">
               {dxccName || `DXCC #${dxcc}`}
             </Badge>
+            {mwBadge}
             <span className="text-xs text-muted-foreground">
               <strong className="text-foreground font-semibold">{dxccCount}</strong>{' '}
               QSO{dxccCount > 1 ? 's' : ''} with this entity

frontend/src/components/ExportFieldsDialog.tsx

@@ -0,0 +1,120 @@
+import { useEffect, useMemo, useState } from 'react';
+import {
+  Dialog, DialogContent, DialogHeader, DialogTitle, DialogDescription, DialogFooter,
+} from '@/components/ui/dialog';
+import { Button } from '@/components/ui/button';
+import { Checkbox } from '@/components/ui/checkbox';
+import { useI18n } from '@/lib/i18n';
+import { writeUiPref } from '@/lib/uiPref';
+import { ADIFFields, ADIFExtraFields } from '@/../wailsjs/go/main/App';
+import { adif } from '@/../wailsjs/go/models';
+
+type FieldDef = adif.FieldDef;
+const PREF_KEY = 'opslog.exportFields';
+
+// ExportFieldsDialog lets the operator pick exactly which ADIF fields an export
+// writes. Two groups: the official ADIF 3.1.7 dictionary (grouped by category)
+// and the OpsLog / non-standard tags actually present in the log's extras. The
+// chosen set is returned to the parent (which runs the selected/global export)
+// and persisted so it's the default next time.
+export function ExportFieldsDialog({ open, count, onExport, onClose }: {
+  open: boolean;
+  count: number;              // how many QSOs the pending export covers
+  onExport: (fields: string[]) => void;
+  onClose: () => void;
+}) {
+  const { t } = useI18n();
+  const [official, setOfficial] = useState<FieldDef[]>([]);
+  const [extras, setExtras] = useState<string[]>([]);
+  const [sel, setSel] = useState<Set<string>>(new Set());
+
+  const defaultSet = (flds: FieldDef[]) =>
+    new Set(flds.filter((d) => d.promoted && !d.deprecated).map((d) => d.name));
+
+  useEffect(() => {
+    if (!open) return;
+    let cancelled = false;
+    (async () => {
+      const [f, e] = await Promise.all([ADIFFields(), ADIFExtraFields()]);
+      if (cancelled) return;
+      const flds = (f ?? []) as FieldDef[];
+      setOfficial(flds);
+      setExtras((e ?? []) as string[]);
+      let saved: string[] | null = null;
+      try { const raw = localStorage.getItem(PREF_KEY); if (raw) saved = JSON.parse(raw); } catch { /* ignore */ }
+      setSel(saved && saved.length ? new Set(saved.map((x) => x.toUpperCase())) : defaultSet(flds));
+    })().catch(() => {});
+    return () => { cancelled = true; };
+  }, [open]);
+
+  // Official fields grouped by category (deprecated ones are import-only → hidden).
+  const groups = useMemo(() => {
+    const m = new Map<string, FieldDef[]>();
+    for (const d of official) {
+      if (d.deprecated) continue;
+      const g = d.category || 'Misc';
+      (m.get(g) ?? m.set(g, []).get(g)!).push(d);
+    }
+    return [...m.entries()];
+  }, [official]);
+
+  const toggle = (name: string, on: boolean) =>
+    setSel((s) => { const n = new Set(s); if (on) n.add(name); else n.delete(name); return n; });
+  const setMany = (names: string[], on: boolean) =>
+    setSel((s) => { const n = new Set(s); for (const x of names) { if (on) n.add(x); else n.delete(x); } return n; });
+
+  const doExport = () => {
+    const fields = [...sel];
+    writeUiPref(PREF_KEY, JSON.stringify(fields));
+    onExport(fields);
+  };
+
+  const GroupCard = ({ title, tags, warn }: { title: string; tags: string[]; warn?: boolean }) => (
+    <div className={`rounded-md border p-2 ${warn ? 'border-warning-border/50 bg-warning-muted/20' : 'border-border/60'}`}>
+      <div className="flex items-center justify-between mb-1 gap-2">
+        <span className={`text-[11px] font-semibold uppercase tracking-wide ${warn ? 'text-warning-muted-foreground' : 'text-muted-foreground'}`}>{title}</span>
+        <span className="flex gap-1.5 shrink-0">
+          <button type="button" className="text-[10px] text-primary hover:underline" onClick={() => setMany(tags, true)}>{t('exf.all')}</button>
+          <button type="button" className="text-[10px] text-muted-foreground hover:underline" onClick={() => setMany(tags, false)}>{t('exf.none')}</button>
+        </span>
+      </div>
+      {tags.map((name) => (
+        <label key={name} className="flex items-center gap-1.5 text-[11px] cursor-pointer py-0.5">
+          <Checkbox checked={sel.has(name)} onCheckedChange={(c) => toggle(name, !!c)} />
+          <span className="font-mono break-all">{name}</span>
+        </label>
+      ))}
+    </div>
+  );
+
+  return (
+    <Dialog open={open} onOpenChange={(o) => { if (!o) onClose(); }}>
+      <DialogContent className="max-w-4xl">
+        <DialogHeader>
+          <DialogTitle>{t('exf.title')}</DialogTitle>
+          <DialogDescription>{t('exf.desc')}</DialogDescription>
+        </DialogHeader>
+
+        <div className="flex items-center gap-2 px-1 text-[11px] text-muted-foreground">
+          <span>{t('exf.chosen', { n: sel.size })}</span>
+          <Button variant="ghost" size="sm" className="ml-auto h-6 text-[11px]" onClick={() => setSel(defaultSet(official))}>
+            {t('exf.defaults')}
+          </Button>
+        </div>
+
+        <div className="grid grid-cols-3 gap-3 max-h-[56vh] overflow-y-auto pr-1">
+          {/* OpsLog / non-standard group first (most relevant to keep or drop). */}
+          {extras.length > 0 && <GroupCard title={t('exf.opslogGroup')} tags={extras} warn />}
+          {groups.map(([g, list]) => (
+            <GroupCard key={g} title={g} tags={list.map((d) => d.name)} />
+          ))}
+        </div>
+
+        <DialogFooter>
+          <Button variant="outline" onClick={onClose}>{t('exf.cancel')}</Button>
+          <Button disabled={sel.size === 0} onClick={doExport}>{t('exf.export', { n: count })}</Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}

frontend/src/components/FlexPanel.tsx

@@ -1,5 +1,5 @@
 import { useEffect, useRef, useState } from 'react';
-import { Radio, Zap, Power, AudioLines, Flame, Gauge, Volume2, VolumeX } from 'lucide-react';
+import { Radio, Zap, Power, AudioLines, Flame, Gauge, Volume2, VolumeX, ChevronDown, SlidersHorizontal } from 'lucide-react';
 import {
   GetFlexState, FlexSetPower, FlexSetTunePower, FlexTune, FlexSetVox, FlexSetVoxLevel, FlexSetVoxDelay,
   FlexSetProcessor, FlexSetProcessorLevel, FlexSetMon, FlexSetMonLevel, FlexSetMic,
@@ -295,6 +295,11 @@ function powerLevelLabel(pl?: string): string {
 export function FlexPanel({ onCWSpeed, onReportRST }: { onCWSpeed?: (wpm: number) => void; onReportRST?: (rst: string) => void } = {}) {
   const { t } = useI18n();
   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
+  // NB/NR/ANF stay visible by default. Remembered across sessions.
+  const [dspOpen, setDspOpen] = useState<boolean>(() => localStorage.getItem('opslog.flexDspOpen') === '1');
+  const toggleDsp = () => setDspOpen((o) => { const n = !o; localStorage.setItem('opslog.flexDspOpen', n ? '1' : '0'); return n; });
   const hold = useRef<Record<string, number>>({});
   // Keep the host's keyer speed (used for CW-length estimates and the keyer panel)
   // in step with the radio's ACTUAL CW speed — including when it's changed on the
@@ -768,13 +773,28 @@ export function FlexPanel({ onCWSpeed, onReportRST }: { onCWSpeed?: (wpm: number
               <span className="w-8 text-right text-xs font-mono tabular-nums text-muted-foreground">{st.agc_threshold}</span>
             </div>
             <div className="border-t border-border/60 pt-3 space-y-3">
+              {/* Core noise controls stay visible; WNB + the SmartSDR v4 DSP block
+                  hide behind the 'DSP' toggle so the card doesn't tower. When any
+                  hidden control is ON we badge the toggle so it's not forgotten. */}
+              {(() => {
+                const hiddenOn = st.wnb || (st.dsp_v4 && (!!st.lms_nr || !!st.speex_nr || !!st.nrf || (!isCW && !!st.lms_anf) || !!st.rnn || (!isCW && !!st.anft)));
+                return (
+                  <div className="flex items-center justify-between">
+                    <span className="text-[11px] font-bold text-muted-foreground">{t('flxp.dspNoise')}</span>
+                    <button type="button" onClick={toggleDsp} title={t('flxp.dspMore')}
+                      className={cn('flex items-center gap-1 h-6 px-2 rounded-md border text-[10px] font-bold uppercase tracking-wide transition-colors',
+                        hiddenOn && !dspOpen ? 'bg-primary/15 text-primary border-primary/40' : 'bg-card text-muted-foreground border-border hover:bg-muted')}>
+                      <SlidersHorizontal className="size-3" />
+                      DSP
+                      {hiddenOn && !dspOpen && <span className="ml-0.5 size-1.5 rounded-full bg-primary" />}
+                      <ChevronDown className={cn('size-3 transition-transform', dspOpen && 'rotate-180')} />
+                    </button>
+                  </div>
+                );
+              })()}
               <LevelRow label="NB" on={st.nb} disabled={rxOff} value={st.nb_level} accent="amber" sliderAccent="#d97706"
                 onToggle={() => change('nb', !st.nb, () => FlexSetNB(!st.nb))}
                 onLevel={(v) => change('nb_level', v, () => FlexSetNBLevel(v))} />
-              {/* WNB — wideband noise blanker (the extra hardware NR the Flex has). */}
-              <LevelRow label="WNB" on={st.wnb} disabled={rxOff} value={st.wnb_level} accent="amber" sliderAccent="#f59e0b"
-                onToggle={() => change('wnb', !st.wnb, () => FlexSetWNB(!st.wnb))}
-                onLevel={(v) => change('wnb_level', v, () => FlexSetWNBLevel(v))} />
               <LevelRow label="NR" on={st.nr} disabled={rxOff} value={st.nr_level} accent="cyan" sliderAccent="#0891b2"
                 onToggle={() => change('nr', !st.nr, () => FlexSetNR(!st.nr))}
                 onLevel={(v) => change('nr_level', v, () => FlexSetNRLevel(v))} />
@@ -784,13 +804,19 @@ export function FlexPanel({ onCWSpeed, onReportRST }: { onCWSpeed?: (wpm: number
                   onToggle={() => change('anf', !st.anf, () => FlexSetANF(!st.anf))}
                   onLevel={(v) => change('anf_level', v, () => FlexSetANFLevel(v))} />
               )}
-            </div>
+              {/* Advanced / supplementary DSP — collapsed by default. WNB (wideband
-            {/* SmartSDR v4 DSP (8000/Aurora series) — NRL/ANFL (legacy LMS), NRS
+                  noise blanker) plus the SmartSDR v4 block (8000/Aurora): NRL/ANFL
-                (spectral subtraction), NRF (NR w/ filter), RNN (AI NR), ANFT (FFT
+                  (legacy LMS), NRS (spectral subtraction), NRF (NR w/ filter), RNN
-                notch). Only shown when the radio actually reports these slice keys
+                  (AI NR), ANFT (FFT notch). The v4 rows only exist when the radio
-                (older 6000s never do). API keys per the FlexLib slice docs. */}
+                  reports those slice keys (older 6000s never do). */}
+              {dspOpen && (
+                <div className="space-y-3 border-t border-dashed border-border/50 pt-3">
+                  {/* WNB — wideband noise blanker (the extra hardware NR the Flex has). */}
+                  <LevelRow label="WNB" on={st.wnb} disabled={rxOff} value={st.wnb_level} accent="amber" sliderAccent="#f59e0b"
+                    onToggle={() => change('wnb', !st.wnb, () => FlexSetWNB(!st.wnb))}
+                    onLevel={(v) => change('wnb_level', v, () => FlexSetWNBLevel(v))} />
                   {st.dsp_v4 && (
-              <div className="border-t border-border/60 pt-3 space-y-3">
+                    <>
                       <LevelRow label="NRL" on={!!st.lms_nr} disabled={rxOff} value={st.lms_nr_level ?? 0} accent="cyan" sliderAccent="#0e7490"
                         onToggle={() => change('lms_nr', !st.lms_nr, () => FlexSetLMSNR(!st.lms_nr))}
                         onLevel={(v) => change('lms_nr_level', v, () => FlexSetLMSNRLevel(v))} />
@@ -826,8 +852,11 @@ export function FlexPanel({ onCWSpeed, onReportRST }: { onCWSpeed?: (wpm: number
                           </button>
                         )}
                       </div>
+                    </>
+                  )}
                 </div>
               )}
+            </div>
             {isCW && (
               <div className="border-t border-border/60 pt-3 space-y-3">
                 <LevelRow label="APF" on={st.apf} disabled={rxOff} value={st.apf_level} accent="emerald" sliderAccent="#16a34a"

frontend/src/components/NetControlPanel.tsx

@@ -5,7 +5,7 @@ import {
 } from 'ag-grid-community';
 import { hamlogGridTheme } from '@/lib/gridTheme';
 import { AgGridReact } from 'ag-grid-react';
-import { Plus, Trash2, Radio, PlusCircle, MinusCircle, Search, UserPlus, History } from 'lucide-react';
+import { Plus, Trash2, Radio, PlusCircle, MinusCircle, Search, UserPlus, History, ChevronUp, ChevronDown } from 'lucide-react';
 import {
   Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter, DialogDescription,
 } from '@/components/ui/dialog';
@@ -166,6 +166,53 @@ export function NetControlPanel({ onLogged, countries, bands, modes, qsoMenuHand
     catch { /* ignore */ }
   }, []);
 
+  // ---- Mic pass order ------------------------------------------------------
+  // The on-air grid shows the stations in the order the mic goes around — NOT
+  // by log time. The order is owned here as a list of draft ids: new check-ins
+  // join at the END of the queue, logged/cancelled ones drop out, and the ⬆⬇
+  // buttons move the selected station. Persisted per net so a panel remount
+  // (tab switch) keeps the round.
+  const [orderIds, setOrderIds] = useState<number[]>([]);
+  const orderKey = openId ? `opslog.netOrder.${openId}` : '';
+  // Load the saved order when a net opens.
+  useEffect(() => {
+    if (!orderKey) { setOrderIds([]); return; }
+    try { setOrderIds(JSON.parse(localStorage.getItem(orderKey) || '[]')); }
+    catch { setOrderIds([]); }
+  }, [orderKey]);
+  // Reconcile with the live list: keep known ids in their order, append new
+  // ones, drop the gone. Persist.
+  useEffect(() => {
+    setOrderIds((cur) => {
+      const liveIds = active.map((a) => a.id as number).filter((id) => id != null);
+      const liveSet = new Set(liveIds);
+      const kept = cur.filter((id) => liveSet.has(id));
+      const keptSet = new Set(kept);
+      const next = [...kept, ...liveIds.filter((id) => !keptSet.has(id))];
+      if (next.length === cur.length && next.every((v, i) => v === cur[i])) return cur;
+      if (orderKey) { try { localStorage.setItem(orderKey, JSON.stringify(next)); } catch { /* quota */ } }
+      return next;
+    });
+  }, [active, orderKey]);
+  const activeOrdered = useMemo(() => {
+    const byId = new Map(active.map((a) => [a.id as number, a]));
+    return orderIds.map((id) => byId.get(id)).filter(Boolean) as QSOForm[];
+  }, [active, orderIds]);
+  // Move the selected on-air station up/down the queue.
+  const moveSelected = useCallback((dir: -1 | 1) => {
+    const id = selectedActiveIds[0];
+    if (id == null) return;
+    setOrderIds((cur) => {
+      const i = cur.indexOf(id);
+      const j = i + dir;
+      if (i < 0 || j < 0 || j >= cur.length) return cur;
+      const next = [...cur];
+      [next[i], next[j]] = [next[j], next[i]];
+      if (orderKey) { try { localStorage.setItem(orderKey, JSON.stringify(next)); } catch { /* quota */ } }
+      return next;
+    });
+  }, [selectedActiveIds, orderKey]);
+
   useEffect(() => { refreshNets(); }, [refreshNets]);
   useEffect(() => { refreshRoster(selId); }, [selId, refreshRoster]);
   useEffect(() => { if (isOpen) refreshActive(); else setActive([]); }, [isOpen, refreshActive]);
@@ -221,11 +268,11 @@ export function NetControlPanel({ onLogged, countries, bands, modes, qsoMenuHand
     catch (e: any) { setError(String(e?.message ?? e)); }
   }
   // Active → logged (end QSO, removed from session, written to the logbook).
-  // Then auto-select the FIRST remaining on-air station, so the operator can
+  // Then auto-select the NEXT station in the mic-pass order, so the operator
-  // chain "log → log → log" without re-clicking a row each time.
+  // can chain "log → log → log" without re-clicking a row each time.
   async function deactivate(id?: number) {
     if (id == null) return;
-    const next = active.find((a) => a.id !== id); // computed BEFORE the list shrinks
+    const next = activeOrdered.find((a) => a.id !== id); // computed BEFORE the list shrinks
     try {
       await NetDeactivate(id);
       await refreshActive();
@@ -356,11 +403,12 @@ export function NetControlPanel({ onLogged, countries, bands, modes, qsoMenuHand
           </div>
           <div ref={onAirWrap} className="flex flex-col min-h-0 flex-1">
             <RecentQSOsGrid
-              rows={active}
+              rows={activeOrdered}
-              total={active.length}
+              total={activeOrdered.length}
               storageKey="net.onair"
               selectRowSignal={selectRow}
               rowDragCall
+              passOrder
               onGridApi={(api) => { onAirApi.current = api; wireDropZones(); }}
               onRowClicked={(q) => showWorkedBefore(q.callsign, (q as any).dxcc ?? 0)}
               onRowDoubleClicked={(q) => setEditingDraft(q)}
@@ -373,6 +421,19 @@ export function NetControlPanel({ onLogged, countries, bands, modes, qsoMenuHand
                 onClick={() => { if (selectedActiveIds[0] != null) deactivate(selectedActiveIds[0]); }}>
                 <MinusCircle className="size-3.5" /> {t('ncp.logEndSelected')}
               </Button>
+              {/* Mic pass order: move the selected station up/down the round. */}
+              <div className="flex items-center gap-0.5 pl-1 border-l border-border/50">
+                <Button variant="ghost" size="icon" className="size-7" title={t('ncp.moveUp')}
+                  disabled={selectedActiveIds[0] == null || orderIds.indexOf(selectedActiveIds[0]) <= 0}
+                  onClick={() => moveSelected(-1)}>
+                  <ChevronUp className="size-4" />
+                </Button>
+                <Button variant="ghost" size="icon" className="size-7" title={t('ncp.moveDown')}
+                  disabled={selectedActiveIds[0] == null || orderIds.indexOf(selectedActiveIds[0]) >= orderIds.length - 1}
+                  onClick={() => moveSelected(1)}>
+                  <ChevronDown className="size-4" />
+                </Button>
+              </div>
               <Button variant="ghost" size="sm" className="h-7 text-[11px] ml-auto" onClick={logAll}>
                 <MinusCircle className="size-3.5" /> {t('ncp.logAll', { n: active.length })}
               </Button>

frontend/src/components/QSOContextMenu.tsx

@@ -15,6 +15,7 @@ type Props = {
   onSendEQSL?: (ids: number[]) => void;
   onBulkEdit?: (ids: number[]) => void;
   onExportSelected?: (ids: number[]) => void;
+  onExportSelectedFields?: (ids: number[]) => void;
   onExportFiltered?: () => void;
   onExportCabrilloSelected?: (ids: number[]) => void;
   onExportCabrilloFiltered?: () => void;
@@ -35,7 +36,7 @@ const UPLOAD_TARGETS: { service: string; name: string }[] = [
 // or picks a command. (We deliberately do NOT close on scroll/resize: the QSO
 // list auto-refreshes and AG Grid fires internal scroll events on refresh,
 // which used to dismiss the menu the instant it appeared.)
-export function QSOContextMenu({ menu, onClose, onUpdateFromCty, onUpdateFromQRZ, onUpdateFromClublog, onSendTo, onSendRecording, onSendEQSL, onBulkEdit, onExportSelected, onExportFiltered, onExportCabrilloSelected, onExportCabrilloFiltered, onDelete }: Props) {
+export function QSOContextMenu({ menu, onClose, onUpdateFromCty, onUpdateFromQRZ, onUpdateFromClublog, onSendTo, onSendRecording, onSendEQSL, onBulkEdit, onExportSelected, onExportSelectedFields, onExportFiltered, onExportCabrilloSelected, onExportCabrilloFiltered, onDelete }: Props) {
   const { t } = useI18n();
   useEffect(() => {
     if (!menu) return;
@@ -137,6 +138,15 @@ export function QSOContextMenu({ menu, onClose, onUpdateFromCty, onUpdateFromQRZ
               <span>{t('qctx.exportSelectedAdif', { n })}</span>
             </button>
           )}
+          {onExportSelectedFields && (
+            <button
+              className="flex w-full items-center gap-2 px-3 py-1.5 text-left hover:bg-accent/50"
+              onClick={() => { onExportSelectedFields(menu.ids); onClose(); }}
+            >
+              <FileDown className="size-4 text-info" />
+              <span>{t('qctx.exportSelectedFields', { n })}</span>
+            </button>
+          )}
           {onExportFiltered && (
             <button
               className="flex w-full items-center gap-2 px-3 py-1.5 text-left hover:bg-accent/50"

frontend/src/components/RecentQSOsGrid.tsx

@@ -37,6 +37,11 @@ type Props = {
   // row onto the roster to log it). Pair with onGridApi so the parent can
   // register external drop zones via api.addRowDropZone.
   rowDragCall?: boolean;
+  // Pass-order mode (NET Control on-air queue): the ROW ORDER GIVEN IN `rows`
+  // is the display order — a pinned "#" column numbers it, and all column
+  // sorting is disabled (including saved sorts) so the queue can't be shuffled
+  // by a header click. The parent owns/reorders the array.
+  passOrder?: boolean;
   onGridApi?: (api: any) => void;
   // storageKey scopes the persisted column layout/visibility. Omit for the main
   // log (keeps the historical keys); pass a distinct value (e.g. "net.onair") to
@@ -53,6 +58,7 @@ type Props = {
   onSendEQSL?: (ids: number[]) => void;
   onBulkEdit?: (ids: number[]) => void;
   onExportSelected?: (ids: number[]) => void;
+  onExportSelectedFields?: (ids: number[]) => void;
   onExportFiltered?: () => void;
   onExportCabrilloSelected?: (ids: number[]) => void;
   onExportCabrilloFiltered?: () => void;
@@ -257,7 +263,7 @@ export const groupLabel = (t: TFn, g: string): string => t(GRP_KEYS[g] ?? g);
 const stripAwardCols = (st: any[] | null | undefined): any[] =>
   (st ?? []).filter((s) => !String(s?.colId ?? '').startsWith('award_'));
 
-export function RecentQSOsGrid({ rows, selectAllSignal, selectRowSignal, rowDragCall, onGridApi, storageKey, onRowDoubleClicked, onRowClicked, onRowSelected, onUpdateFromCty, onUpdateFromQRZ, onUpdateFromClublog, onSendTo, onSendRecording, onSendEQSL, onBulkEdit, onExportSelected, onExportFiltered, onExportCabrilloSelected, onExportCabrilloFiltered, onDelete, onFilteredCountChange, awardCols }: Props) {
+export function RecentQSOsGrid({ rows, selectAllSignal, selectRowSignal, rowDragCall, passOrder, onGridApi, storageKey, onRowDoubleClicked, onRowClicked, onRowSelected, onUpdateFromCty, onUpdateFromQRZ, onUpdateFromClublog, onSendTo, onSendRecording, onSendEQSL, onBulkEdit, onExportSelected, onExportSelectedFields, onExportFiltered, onExportCabrilloSelected, onExportCabrilloFiltered, onDelete, onFilteredCountChange, awardCols }: Props) {
   const { t } = useI18n();
   const gridRef = useRef<any>(null);
   const [pickerOpen, setPickerOpen] = useState(false);
@@ -330,8 +336,20 @@ export function RecentQSOsGrid({ rows, selectAllSignal, selectRowSignal, rowDrag
       if (rowDragCall && ((rest as any).colId === 'callsign' || (rest as any).field === 'callsign')) {
         col.rowDrag = true;
       }
+      if (passOrder) {
+        delete (col as any).sort; // e.g. the date column's default 'desc'
+        col.sortable = false;
+      }
       return col;
     });
+    if (passOrder) {
+      base.unshift({
+        colId: '__order', headerName: '#', width: 46, pinned: 'left',
+        sortable: false, resizable: false, suppressMovable: true, filter: false,
+        cellClass: 'font-mono text-muted-foreground tabular-nums',
+        valueGetter: (p) => (p.node?.rowIndex ?? 0) + 1,
+      } as ColDef<QSOForm>);
+    }
     const awards: ColDef<QSOForm>[] = (awardCols ?? []).map((a) => ({
       colId: `award_${a.code}`,
       headerName: a.code,
@@ -344,7 +362,7 @@ export function RecentQSOsGrid({ rows, selectAllSignal, selectRowSignal, rowDrag
       valueGetter: (p) => (p.data as any)?.award_refs?.[a.code.toUpperCase()] ?? '',
     }));
     return [...base, ...awards];
-  }, [awardCols, COL_CATALOG, t, awardShown, rowDragCall]);
+  }, [awardCols, COL_CATALOG, t, awardShown, rowDragCall, passOrder]);
 
   // Enforce award-column visibility via the API after the columns (re)appear —
   // colDef.hide alone isn't honoured by AG Grid for a column that already exists,
@@ -360,21 +378,27 @@ export function RecentQSOsGrid({ rows, selectAllSignal, selectRowSignal, rowDrag
   }, [awardCols, awardShown]);
 
   const defaultColDef = useMemo<ColDef>(() => ({
-    sortable: true,
+    sortable: !passOrder,
     resizable: true,
     filter: true,
     suppressMovable: false,
-  }), []);
+  }), [passOrder]);
+
+  // In pass-order mode a saved sort (from before the mode existed, or synced
+  // from elsewhere) must not shuffle the queue — strip sorts when restoring.
+  const sanitizeState = useCallback((state: any[]) => (
+    passOrder ? state.map((s) => ({ ...s, sort: null })) : state
+  ), [passOrder]);
 
   function onGridReady(e: GridReadyEvent) {
     onGridApi?.(e.api);
     const local = loadLocal(colStateKey);
-    if (local) e.api.applyColumnState({ state: stripAwardCols(local) as ColumnState[], applyOrder: true });
+    if (local) e.api.applyColumnState({ state: sanitizeState(stripAwardCols(local)) as ColumnState[], applyOrder: true });
     // Fall back to the portable DB copy when the local cache is empty
     // (fresh machine / after a reinstall), then re-seed the cache.
     loadRemote(colStateKey).then((remote) => {
       if (remote && !local) {
-        e.api.applyColumnState({ state: stripAwardCols(remote) as ColumnState[], applyOrder: true });
+        e.api.applyColumnState({ state: sanitizeState(stripAwardCols(remote)) as ColumnState[], applyOrder: true });
         seedLocal(colStateKey, remote);
       }
     });
@@ -384,9 +408,16 @@ export function RecentQSOsGrid({ rows, selectAllSignal, selectRowSignal, rowDrag
   const reportFilteredCount = useCallback((e: { api?: any }) => {
     const api = e?.api ?? gridRef.current?.api;
     if (api?.getDisplayedRowCount) setDispCount(api.getDisplayedRowCount());
+    // Pass-order "#" is a rowIndex-based valueGetter; AG-Grid keeps the same
+    // row node across a reorder (getRowId by id), so the number is cached and
+    // stale until we force it. Refresh it on every model update (a reorder
+    // fires one). force:true bypasses the value cache.
+    if (passOrder && api?.refreshCells) {
+      api.refreshCells({ columns: ['__order'], force: true });
+    }
     if (!api || !onFilteredCountChange) return;
     onFilteredCountChange(api.isAnyFilterPresent?.() ? api.getDisplayedRowCount() : null);
-  }, [onFilteredCountChange]);
+  }, [onFilteredCountChange, passOrder]);
   const saveColumnState = useCallback(() => {
     if (restoringRef.current) return; // ignore the events fired by a column rebuild
     const state = gridRef.current?.api?.getColumnState();
@@ -403,7 +434,7 @@ export function RecentQSOsGrid({ rows, selectAllSignal, selectRowSignal, rowDrag
   useEffect(() => {
     const api = gridRef.current?.api;
     const local = loadLocal(colStateKey);
-    if (api && local) api.applyColumnState({ state: stripAwardCols(local) as ColumnState[], applyOrder: true });
+    if (api && local) api.applyColumnState({ state: sanitizeState(stripAwardCols(local)) as ColumnState[], applyOrder: true });
     // Re-enable saving once AG Grid has settled the column events from the rebuild.
     const t = window.setTimeout(() => { restoringRef.current = false; }, 0);
     return () => window.clearTimeout(t);
@@ -570,6 +601,7 @@ export function RecentQSOsGrid({ rows, selectAllSignal, selectRowSignal, rowDrag
         onSendEQSL={onSendEQSL}
         onBulkEdit={onBulkEdit}
         onExportSelected={onExportSelected}
+        onExportSelectedFields={onExportSelectedFields}
         onExportFiltered={onExportFiltered}
         onExportCabrilloSelected={onExportCabrilloSelected}
         onExportCabrilloFiltered={onExportCabrilloFiltered}

frontend/src/components/SettingsModal.tsx

@@ -17,6 +17,7 @@ import {
   GetWinkeyerSettings, SaveWinkeyerSettings, ListSerialPorts,
   GetAudioSettings, SaveAudioSettings, ListAudioInputDevices, ListAudioOutputDevices, PickAudioFolder, TestPTT,
   GetClublogCtyInfo, SetClublogCtyEnabled, DownloadClublogCty,
+  GetClublogMostWantedInfo, SetClublogMostWantedEnabled, DownloadClublogMostWanted,
   GetSecretStatus, SetPassphrase, RemovePassphrase,
   GetEmailSettings, SaveEmailSettings, TestEmail,
   QSLGetEmailTemplates, QSLSaveEmailTemplates,
@@ -1054,8 +1055,8 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   const [rotatorTest, setRotatorTest] = useState<{ ok: boolean; msg: string } | null>(null);
 
   // Motorized antenna (Ultrabeam TCP or SteppIR TCP/serial) settings.
-  const [ultrabeam, setUltrabeam] = useState<{ enabled: boolean; type: string; transport: string; host: string; port: number; com: string; baud: number; follow: boolean; step_khz: number; tx_inhibit: boolean }>({
+  const [ultrabeam, setUltrabeam] = useState<{ enabled: boolean; type: string; transport: string; host: string; port: number; com: string; baud: number; follow: boolean; step_khz: number; tx_inhibit: boolean; freq_min_mhz: number; freq_max_mhz: number }>({
-    enabled: false, type: 'ultrabeam', transport: 'tcp', host: '', port: 23, com: '', baud: 9600, follow: false, step_khz: 50, tx_inhibit: false,
+    enabled: false, type: 'ultrabeam', transport: 'tcp', host: '', port: 23, com: '', baud: 9600, follow: false, step_khz: 50, tx_inhibit: false, freq_min_mhz: 13, freq_max_mhz: 54,
   });
   const [ubTesting, setUbTesting] = useState(false);
   const [ubTest, setUbTest] = useState<{ ok: boolean; msg: string } | null>(null);
@@ -1074,13 +1075,13 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     port: string; baud: number; wpm: number; weight: number;
     lead_in_ms: number; tail_ms: number; ratio: number; farnsworth: number;
     sidetone_hz: number; mode: string; swap: boolean; autospace: boolean;
-    use_ptt: boolean; serial_echo: boolean; macros: WKMac[];
+    use_ptt: boolean; serial_echo: boolean; cw_key_line: string; cw_invert: boolean; macros: WKMac[];
   };
   const [wk, setWk] = useState<WKSettings>({
     enabled: false, engine: 'winkeyer', esc_clears_call: true,
     port: '', baud: 1200, wpm: 25, weight: 50, lead_in_ms: 10,
     tail_ms: 50, ratio: 50, farnsworth: 0, sidetone_hz: 600, mode: 'iambic_b',
-    swap: false, autospace: true, use_ptt: false, serial_echo: true, macros: [],
+    swap: false, autospace: true, use_ptt: false, serial_echo: true, cw_key_line: 'dtr', cw_invert: false, macros: [],
   });
   const [wkPorts, setWkPorts] = useState<string[]>([]);
   const setWkField = (patch: Partial<WKSettings>) => setWk((s) => ({ ...s, ...patch }));
@@ -1148,7 +1149,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   const refreshSecret = async () => { try { setSecret(await GetSecretStatus() as any); } catch {} };
   useEffect(() => { refreshSecret(); }, []);
   const applyPassphrase = async () => {
-    if (ppNew !== ppConfirm) { setPpErr('Passphrases do not match'); return; }
+    if (ppNew !== ppConfirm) { setPpErr(t('gen.pwMismatch')); return; }
     setPpBusy(true); setPpErr('');
     try { await SetPassphrase(ppNew); setPpNew(''); setPpConfirm(''); await refreshSecret(); }
     catch (e: any) { setPpErr(String(e?.message ?? e)); }
@@ -1183,6 +1184,12 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   const [clubBusy, setClubBusy] = useState(false);
   const [clubErr, setClubErr] = useState('');
   useEffect(() => { GetClublogCtyInfo().then((i) => setClubInfo(i as ClubInfo)).catch(() => {}); }, []);
+  // ClubLog Most Wanted (rank shown in the entry matrix).
+  type MWInfo = { enabled: boolean; loaded: boolean; callsign: string; date: string; count: number };
+  const [mwInfo, setMwInfo] = useState<MWInfo>({ enabled: false, loaded: false, callsign: '', date: '', count: 0 });
+  const [mwBusy, setMwBusy] = useState(false);
+  const [mwErr, setMwErr] = useState('');
+  useEffect(() => { GetClublogMostWantedInfo().then((i) => setMwInfo(i as MWInfo)).catch(() => {}); }, []);
   const reloadDvk = () => { GetDVKMessages().then((m) => setDvkMsgs((m ?? []) as DVKMsg[])).catch(() => {}); };
   useEffect(() => {
     GetDVKStatus().then((s) => setDvkStat(s as DVKStat)).catch(() => {});
@@ -2632,6 +2639,22 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
               </div>
             )}
           </div>
+          {isSteppir && (
+            <div className="border-t border-border/60 pt-3 space-y-1">
+              <div className="flex items-center gap-2 flex-wrap">
+                <Label className="text-sm">{t('hw.steppirRange')}</Label>
+                <input type="number" min={1} max={60} value={ultrabeam.freq_min_mhz}
+                  onChange={(e) => setUltrabeam((s) => ({ ...s, freq_min_mhz: parseInt(e.target.value, 10) || 0 }))}
+                  className="h-8 w-16 rounded-md border border-input bg-background px-2 text-sm" />
+                <span className="text-xs text-muted-foreground">–</span>
+                <input type="number" min={1} max={60} value={ultrabeam.freq_max_mhz}
+                  onChange={(e) => setUltrabeam((s) => ({ ...s, freq_max_mhz: parseInt(e.target.value, 10) || 0 }))}
+                  className="h-8 w-16 rounded-md border border-input bg-background px-2 text-sm" />
+                <span className="text-xs text-muted-foreground">MHz</span>
+              </div>
+              <p className="text-xs text-muted-foreground">{t('hw.steppirRangeHint')}</p>
+            </div>
+          )}
           <div className="border-t border-border/60 pt-3 space-y-1">
             <label className="flex items-center gap-2 text-sm cursor-pointer">
               <Checkbox checked={ultrabeam.tx_inhibit} onCheckedChange={(c) => setUltrabeam((s) => ({ ...s, tx_inhibit: !!c }))} />
@@ -3014,44 +3037,45 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
         <div className="space-y-4 max-w-2xl">
           <label className="flex items-center gap-2 text-sm cursor-pointer">
             <Checkbox checked={wk.enabled} onCheckedChange={(c) => setWkField({ enabled: !!c })} />
-            Enable CW keyer (shows the keyer panel)
+            {t('wk.enable')}
           </label>
 
           <div className="grid grid-cols-4 gap-3 items-end">
             <div className="space-y-1">
-              <Label>Keyer engine</Label>
+              <Label>{t('wk.engine')}</Label>
-              <Select value={wk.engine} onValueChange={(v) => setWkField({ engine: v })}>
+              {/* Picking the serial engine defaults PTT-keying ON: without RTS held,
+                  the rig drops to RX between words (semi-break-in). */}
+              <Select value={wk.engine} onValueChange={(v) => setWkField(v === 'serial' ? { engine: v, use_ptt: true } : { engine: v })}>
                 <SelectTrigger className="h-8"><SelectValue /></SelectTrigger>
                 <SelectContent>
-                  <SelectItem value="winkeyer">WinKeyer (serial)</SelectItem>
+                  <SelectItem value="winkeyer">{t('wk.engWinkeyer')}</SelectItem>
-                  <SelectItem value="icom">Icom CI-V (rig keyer)</SelectItem>
+                  <SelectItem value="serial">{t('wk.engSerial')}</SelectItem>
-                  <SelectItem value="flex">FlexRadio (CWX)</SelectItem>
+                  <SelectItem value="icom">{t('wk.engIcom')}</SelectItem>
-                  <SelectItem value="tci" disabled>TCI (coming soon)</SelectItem>
+                  <SelectItem value="flex">{t('wk.engFlex')}</SelectItem>
+                  <SelectItem value="tci" disabled>{t('wk.engTci')}</SelectItem>
                 </SelectContent>
               </Select>
             </div>
             <label className="flex items-center gap-2 text-sm cursor-pointer col-span-3 pb-1.5">
               <Checkbox checked={wk.esc_clears_call} onCheckedChange={(c) => setWkField({ esc_clears_call: !!c })} />
-              ESC clears the callsign too (otherwise ESC only stops transmission)
+              {t('wk.escClears')}
             </label>
           </div>
 
           {wk.engine === 'icom' ? (
             <>
               <p className="text-xs text-muted-foreground -mt-2">
-                Icom CI-V keys CW through the rig's own keyer over the existing CAT connection (command 0x17) — it reuses the CAT COM port set in Settings → CAT, so there's nothing else to wire up here. Put the rig in CW mode. Weight, ratio, sidetone, paddle mode… are configured on the radio; only the speed is set from here (the rig's KEY SPEED).
+                {t('wk.icomNote')}
               </p>
               {(!catCfg.enabled || catCfg.backend !== 'icom') && (
                 <p className="text-xs font-medium text-warning -mt-1 flex items-start gap-1.5">
                   <span aria-hidden>⚠</span>
-                  <span>
+                  <span>{t('wk.catWarnIcom', { backend: catCfg.enabled ? (catCfg.backend || 'none') : 'disabled' })}</span>
-                    Your CAT backend is set to <strong>{catCfg.enabled ? (catCfg.backend || 'none') : 'disabled'}</strong>. Icom CI-V CW needs the CAT backend set to <strong>Icom</strong> and connected — change it under Settings → CAT interface, otherwise sending CW will fail.
-                  </span>
                 </p>
               )}
               <div className="grid grid-cols-4 gap-3">
                 <div className="space-y-1">
-                  <Label>Speed (WPM)</Label>
+                  <Label>{t('wk.speed')}</Label>
                   <Input type="number" min={6} max={48} value={wk.wpm} onChange={(e) => setWkField({ wpm: num(e.target.value, 25) })} className="font-mono" />
                 </div>
               </div>
@@ -3059,44 +3083,98 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
           ) : wk.engine === 'flex' ? (
             <>
               <p className="text-xs text-muted-foreground -mt-2">
-                FlexRadio keys CW through the radio's <strong>CWX</strong> keyer over the existing SmartSDR CAT connection — no WinKeyer or SmartCAT needed. It reuses the connection set in Settings → CAT, so there's nothing else to wire up here. Put a slice in CW mode. Only the speed is set from here; weight, sidetone and break-in are configured on the radio (break-in must be on for CW to actually transmit).
+                {t('wk.flexNote')}
               </p>
               {(!catCfg.enabled || catCfg.backend !== 'flex') && (
                 <p className="text-xs font-medium text-warning -mt-1 flex items-start gap-1.5">
                   <span aria-hidden>⚠</span>
-                  <span>
+                  <span>{t('wk.catWarnFlex', { backend: catCfg.enabled ? (catCfg.backend || 'none') : 'disabled' })}</span>
-                    Your CAT backend is set to <strong>{catCfg.enabled ? (catCfg.backend || 'none') : 'disabled'}</strong>. Flex CWX needs the CAT backend set to <strong>FlexRadio</strong> and connected — change it under Settings → CAT interface, otherwise sending CW will fail.
-                  </span>
                 </p>
               )}
               <div className="grid grid-cols-4 gap-3">
                 <div className="space-y-1">
-                  <Label>Speed (WPM)</Label>
+                  <Label>{t('wk.speed')}</Label>
                   <Input type="number" min={6} max={48} value={wk.wpm} onChange={(e) => setWkField({ wpm: num(e.target.value, 25) })} className="font-mono" />
                 </div>
               </div>
             </>
-          ) : (
+          ) : wk.engine === 'serial' ? (
             <>
               <div className="grid grid-cols-4 gap-3">
                 <div className="space-y-1 col-span-2">
-                  <Label>Serial port</Label>
+                  <Label>{t('wk.keyingPort')}</Label>
                   <div className="flex items-center gap-2">
                     <Select value={wk.port || '_'} onValueChange={(v) => setWkField({ port: v === '_' ? '' : v })}>
-                      <SelectTrigger className="h-8 flex-1"><SelectValue placeholder="— COM port —" /></SelectTrigger>
+                      <SelectTrigger className="h-8 flex-1"><SelectValue placeholder={t('wk.comPort')} /></SelectTrigger>
                       <SelectContent>
-                        {wkPorts.length === 0 && <SelectItem value="_" disabled>No ports found</SelectItem>}
+                        {wkPorts.length === 0 && <SelectItem value="_" disabled>{t('wk.noPorts')}</SelectItem>}
                         {wkPorts.map((p) => <SelectItem key={p} value={p}>{p}</SelectItem>)}
                       </SelectContent>
                     </Select>
-                    <Button variant="ghost" size="sm" className="h-8 px-2" title="Reload ports"
+                    <Button variant="ghost" size="sm" className="h-8 px-2" title={t('wk.reloadPorts')}
                       onClick={() => ListSerialPorts().then((p) => setWkPorts((p ?? []) as string[])).catch(() => {})}>
                       <ArrowDown className="size-3.5 rotate-90" />
                     </Button>
                   </div>
                 </div>
                 <div className="space-y-1">
-                  <Label>Baud</Label>
+                  <Label>{t('wk.cwKeyLine')}</Label>
+                  <Select value={wk.cw_key_line === 'rts' ? 'rts' : 'dtr'} onValueChange={(v) => setWkField({ cw_key_line: v })}>
+                    <SelectTrigger className="h-8"><SelectValue /></SelectTrigger>
+                    <SelectContent>
+                      <SelectItem value="dtr">{t('wk.lineDtr')}</SelectItem>
+                      <SelectItem value="rts">{t('wk.lineRts')}</SelectItem>
+                    </SelectContent>
+                  </Select>
+                </div>
+                <div className="space-y-1">
+                  <Label>{t('wk.speed')}</Label>
+                  <Input type="number" min={5} max={99} value={wk.wpm} onChange={(e) => setWkField({ wpm: num(e.target.value, 25) })} className="font-mono" />
+                </div>
+              </div>
+              <div className="grid grid-cols-4 gap-3">
+                <div className="space-y-1">
+                  <Label>{t('wk.farnsworth')}</Label>
+                  <Input type="number" min={0} max={99} value={wk.farnsworth} onChange={(e) => setWkField({ farnsworth: num(e.target.value, 0) })} className="font-mono" />
+                </div>
+                <div className="space-y-1">
+                  <Label>{t('wk.leadIn')}</Label>
+                  <Input type="number" min={0} value={wk.lead_in_ms} onChange={(e) => setWkField({ lead_in_ms: num(e.target.value, 10) })} className="font-mono" />
+                </div>
+                <div className="space-y-1">
+                  <Label>{t('wk.tail')}</Label>
+                  <Input type="number" min={0} value={wk.tail_ms} onChange={(e) => setWkField({ tail_ms: num(e.target.value, 50) })} className="font-mono" />
+                </div>
+                <label className="flex items-center gap-2 text-sm cursor-pointer pb-1.5 self-end">
+                  <Checkbox checked={wk.use_ptt} onCheckedChange={(c) => setWkField({ use_ptt: !!c })} /> {t('wk.keyPtt')}
+                </label>
+              </div>
+              <label className="flex items-center gap-2 text-sm cursor-pointer">
+                <Checkbox checked={wk.cw_invert} onCheckedChange={(c) => setWkField({ cw_invert: !!c })} />
+                {t('wk.invert')}
+              </label>
+            </>
+          ) : (
+            <>
+              <div className="grid grid-cols-4 gap-3">
+                <div className="space-y-1 col-span-2">
+                  <Label>{t('wk.serialPort')}</Label>
+                  <div className="flex items-center gap-2">
+                    <Select value={wk.port || '_'} onValueChange={(v) => setWkField({ port: v === '_' ? '' : v })}>
+                      <SelectTrigger className="h-8 flex-1"><SelectValue placeholder={t('wk.comPort')} /></SelectTrigger>
+                      <SelectContent>
+                        {wkPorts.length === 0 && <SelectItem value="_" disabled>{t('wk.noPorts')}</SelectItem>}
+                        {wkPorts.map((p) => <SelectItem key={p} value={p}>{p}</SelectItem>)}
+                      </SelectContent>
+                    </Select>
+                    <Button variant="ghost" size="sm" className="h-8 px-2" title={t('wk.reloadPorts')}
+                      onClick={() => ListSerialPorts().then((p) => setWkPorts((p ?? []) as string[])).catch(() => {})}>
+                      <ArrowDown className="size-3.5 rotate-90" />
+                    </Button>
+                  </div>
+                </div>
+                <div className="space-y-1">
+                  <Label>{t('wk.baud')}</Label>
                   <Select value={String(wk.baud)} onValueChange={(v) => setWkField({ baud: num(v, 1200) })}>
                     <SelectTrigger className="h-8"><SelectValue /></SelectTrigger>
                     <SelectContent>
@@ -3105,38 +3183,38 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                   </Select>
                 </div>
                 <div className="space-y-1">
-                  <Label>Speed (WPM)</Label>
+                  <Label>{t('wk.speed')}</Label>
                   <Input type="number" min={5} max={99} value={wk.wpm} onChange={(e) => setWkField({ wpm: num(e.target.value, 25) })} className="font-mono" />
                 </div>
               </div>
 
               <div className="grid grid-cols-4 gap-3">
                 <div className="space-y-1">
-                  <Label>Weight</Label>
+                  <Label>{t('wk.weight')}</Label>
                   <Input type="number" min={10} max={90} value={wk.weight} onChange={(e) => setWkField({ weight: num(e.target.value, 50) })} className="font-mono" />
                 </div>
                 <div className="space-y-1">
-                  <Label>Lead-in (ms)</Label>
+                  <Label>{t('wk.leadIn')}</Label>
                   <Input type="number" min={0} value={wk.lead_in_ms} onChange={(e) => setWkField({ lead_in_ms: num(e.target.value, 10) })} className="font-mono" />
                 </div>
                 <div className="space-y-1">
-                  <Label>Tail (ms)</Label>
+                  <Label>{t('wk.tail')}</Label>
                   <Input type="number" min={0} value={wk.tail_ms} onChange={(e) => setWkField({ tail_ms: num(e.target.value, 50) })} className="font-mono" />
                 </div>
                 <div className="space-y-1">
-                  <Label>Ratio (33-66)</Label>
+                  <Label>{t('wk.ratio')}</Label>
                   <Input type="number" min={33} max={66} value={wk.ratio} onChange={(e) => setWkField({ ratio: num(e.target.value, 50) })} className="font-mono" />
                 </div>
                 <div className="space-y-1">
-                  <Label>Farnsworth</Label>
+                  <Label>{t('wk.farnsworth')}</Label>
                   <Input type="number" min={0} max={99} value={wk.farnsworth} onChange={(e) => setWkField({ farnsworth: num(e.target.value, 0) })} className="font-mono" />
                 </div>
                 <div className="space-y-1">
-                  <Label>Sidetone (Hz)</Label>
+                  <Label>{t('wk.sidetone')}</Label>
                   <Input type="number" min={0} value={wk.sidetone_hz} onChange={(e) => setWkField({ sidetone_hz: num(e.target.value, 600) })} className="font-mono" />
                 </div>
                 <div className="space-y-1 col-span-2">
-                  <Label>Paddle mode</Label>
+                  <Label>{t('wk.paddleMode')}</Label>
                   <Select value={wk.mode} onValueChange={(v) => setWkField({ mode: v })}>
                     <SelectTrigger className="h-8"><SelectValue /></SelectTrigger>
                     <SelectContent>
@@ -3151,16 +3229,16 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
 
               <div className="flex flex-wrap gap-x-5 gap-y-2">
                 <label className="flex items-center gap-2 text-sm cursor-pointer">
-                  <Checkbox checked={wk.swap} onCheckedChange={(c) => setWkField({ swap: !!c })} /> Swap paddles
+                  <Checkbox checked={wk.swap} onCheckedChange={(c) => setWkField({ swap: !!c })} /> {t('wk.swapPaddles')}
                 </label>
                 <label className="flex items-center gap-2 text-sm cursor-pointer">
-                  <Checkbox checked={wk.autospace} onCheckedChange={(c) => setWkField({ autospace: !!c })} /> Auto-space
+                  <Checkbox checked={wk.autospace} onCheckedChange={(c) => setWkField({ autospace: !!c })} /> {t('wk.autospace')}
                 </label>
                 <label className="flex items-center gap-2 text-sm cursor-pointer">
-                  <Checkbox checked={wk.use_ptt} onCheckedChange={(c) => setWkField({ use_ptt: !!c })} /> Key PTT
+                  <Checkbox checked={wk.use_ptt} onCheckedChange={(c) => setWkField({ use_ptt: !!c })} /> {t('wk.keyPttShort')}
                 </label>
                 <label className="flex items-center gap-2 text-sm cursor-pointer">
-                  <Checkbox checked={wk.serial_echo} onCheckedChange={(c) => setWkField({ serial_echo: !!c })} /> Serial echo
+                  <Checkbox checked={wk.serial_echo} onCheckedChange={(c) => setWkField({ serial_echo: !!c })} /> {t('wk.serialEcho')}
                 </label>
               </div>
             </>
@@ -3168,9 +3246,9 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
 
           {/* Macro editor */}
           <div className="border-t border-border/60 pt-3">
-            <Label className="text-sm font-medium">CW message macros (F1…)</Label>
+            <Label className="text-sm font-medium">{t('wk.macroTitle')}</Label>
             <p className="text-[11px] text-muted-foreground mb-2">
-              Use variables: <span className="font-mono">&lt;MY_CALL&gt; &lt;CALL&gt; &lt;STX&gt; &lt;STRX&gt; &lt;MY_NAME&gt; &lt;HIS_NAME&gt; &lt;MY_QTH&gt; &lt;GRID&gt; &lt;CONT_TX&gt; &lt;n&gt;</span> (cut numbers: 9→N, 0→T). <span className="font-mono">*</span>=my call, <span className="font-mono">!</span>=his call. <span className="font-mono">&lt;LOGQSO&gt;</span> = log the QSO when the macro is sent (e.g. <span className="font-mono">73 TU &lt;LOGQSO&gt;</span>).
+              {t('wk.macroVars')} <span className="font-mono">&lt;MY_CALL&gt; &lt;CALL&gt; &lt;STX&gt; &lt;STRX&gt; &lt;MY_NAME&gt; &lt;HIS_NAME&gt; &lt;MY_QTH&gt; &lt;GRID&gt; &lt;CONT_TX&gt; &lt;n&gt;</span> {t('wk.macroCut')} <span className="font-mono">*</span>={t('wk.macroMyCall')}, <span className="font-mono">!</span>={t('wk.macroHisCall')}. <span className="font-mono">&lt;LOGQSO&gt;</span> = {t('wk.macroLog')} (<span className="font-mono">73 TU &lt;LOGQSO&gt;</span>).
             </p>
             <div className="space-y-1.5 max-h-[34vh] overflow-y-auto pr-1">
               {Array.from({ length: 12 }).map((_, i) => {
@@ -3178,7 +3256,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                 return (
                   <div key={i} className="flex items-center gap-2">
                     <span className="font-mono text-[10px] text-primary font-semibold w-6 shrink-0">F{i + 1}</span>
-                    <Input className="h-8 w-28 shrink-0 text-xs" placeholder="Label" value={m.label} onChange={(e) => setMacro(i, { label: e.target.value })} />
+                    <Input className="h-8 w-28 shrink-0 text-xs" placeholder={t('wk.label')} value={m.label} onChange={(e) => setMacro(i, { label: e.target.value })} />
                     <Input className="h-8 flex-1 font-mono text-xs" placeholder="CQ CQ DE <MY_CALL> K" value={m.text} onChange={(e) => setMacro(i, { text: e.target.value })} />
                   </div>
                 );
@@ -3743,20 +3821,20 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
 
         {/* Tab strip */}
         <div className="flex flex-wrap gap-1 border-b border-border mb-4">
-          {TABS.map((t) => (
+          {TABS.map((tab) => (
             <button
-              key={t.k}
+              key={tab.k}
               type="button"
-              onClick={() => setExtSvcTab(t.k)}
+              onClick={() => setExtSvcTab(tab.k)}
               className={cn(
                 'px-3 py-1.5 text-xs font-semibold rounded-t-md border-x border-t -mb-px transition-colors',
-                extSvcTab === t.k
+                extSvcTab === tab.k
                   ? 'bg-card border-border text-foreground'
                   : 'bg-muted/40 border-transparent text-muted-foreground hover:text-foreground',
               )}
             >
-              {t.label}
+              {tab.label}
-              {!t.ready && <span className="ml-1 text-[9px] opacity-60">soon</span>}
+              {!tab.ready && <span className="ml-1 text-[9px] opacity-60">{t('es.soon')}</span>}
             </button>
           ))}
         </div>
@@ -3768,14 +3846,14 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
               <Input
                 value={qrz.api_key}
                 onChange={(e) => setQrz({ api_key: e.target.value })}
-                placeholder="QRZ.com logbook API key (XXXX-XXXX-XXXX-XXXX)"
+                placeholder={t('es.qrzApiPh')}
                 className="font-mono text-xs"
               />
               <Label className="text-sm">{t('es.forceCall')}</Label>
               <Input
                 value={qrz.force_station_callsign}
                 onChange={(e) => setQrz({ force_station_callsign: e.target.value.toUpperCase() })}
-                placeholder="e.g. F4BPO — optional"
+                placeholder={t('es.forceCallPh')}
                 className="font-mono text-xs"
               />
             </div>
@@ -3824,7 +3902,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                 type="email"
                 value={clublog.email}
                 onChange={(e) => setClublog({ email: e.target.value })}
-                placeholder="your Club Log account email"
+                placeholder={t('es.clubEmailPh')}
                 className="text-xs"
               />
               <Label className="text-sm">{t('es.password')}</Label>
@@ -3832,14 +3910,14 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                 type="password"
                 value={clublog.password}
                 onChange={(e) => setClublog({ password: e.target.value })}
-                placeholder="Club Log account password"
+                placeholder={t('es.clubPwPh')}
                 className="text-xs"
               />
               <Label className="text-sm">{t('es.logbookCall')}</Label>
               <Input
                 value={clublog.callsign}
                 onChange={(e) => setClublog({ callsign: e.target.value.toUpperCase() })}
-                placeholder="defaults to the active profile's callsign"
+                placeholder={t('es.callDefaultPh')}
                 className="font-mono text-xs"
               />
             </div>
@@ -3883,24 +3961,24 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
         ) : extSvcTab === 'hrdlog' ? (
           <div className="space-y-4 max-w-2xl">
             <div className="grid grid-cols-[170px_1fr] gap-3 items-center">
-              <Label className="text-sm">Station callsign</Label>
+              <Label className="text-sm">{t('es.stationCall')}</Label>
               <Input
                 value={hrdlog.callsign}
                 onChange={(e) => setHrdlog({ callsign: e.target.value.toUpperCase() })}
-                placeholder="defaults to the active profile's callsign"
+                placeholder={t('es.callDefaultPh')}
                 className="font-mono text-xs"
               />
-              <Label className="text-sm">Upload code</Label>
+              <Label className="text-sm">{t('es.uploadCode')}</Label>
               <Input
                 type="password"
                 value={hrdlog.code}
                 onChange={(e) => setHrdlog({ code: e.target.value })}
-                placeholder="HRDLog account → My Account → Upload code"
+                placeholder={t('es.hrdCodePh')}
                 className="text-xs"
               />
             </div>
             <div className="text-[10px] text-muted-foreground -mt-1">
-              Find the upload code on HRDLog.net under <em>My Account</em>. It authorises uploads for this callsign.
+              {t('es.hrdHint')}
             </div>
 
             <div className="border-t border-border/60 pt-3 space-y-3">
@@ -3942,11 +4020,11 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
         ) : extSvcTab === 'eqsl' ? (
           <div className="space-y-4 max-w-2xl">
             <div className="grid grid-cols-[170px_1fr] gap-3 items-center">
-              <Label className="text-sm">Username (callsign)</Label>
+              <Label className="text-sm">{t('es.usernameCall')}</Label>
               <Input
                 value={eqsl.username}
                 onChange={(e) => setEqsl({ username: e.target.value.toUpperCase() })}
-                placeholder="your eQSL.cc login (callsign)"
+                placeholder={t('es.eqslUserPh')}
                 className="font-mono text-xs"
               />
               <Label className="text-sm">{t('es.password')}</Label>
@@ -3954,19 +4032,19 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                 type="password"
                 value={eqsl.password}
                 onChange={(e) => setEqsl({ password: e.target.value })}
-                placeholder="eQSL.cc account password"
+                placeholder={t('es.eqslPwPh')}
                 className="text-xs"
               />
-              <Label className="text-sm">QTH nickname</Label>
+              <Label className="text-sm">{t('es.qthNick')}</Label>
               <Input
                 value={eqsl.qth_nickname}
                 onChange={(e) => setEqsl({ qth_nickname: e.target.value })}
-                placeholder="optional — required only if your eQSL account has several QTHs"
+                placeholder={t('es.qthNickPh')}
                 className="text-xs"
               />
             </div>
             <div className="text-[10px] text-muted-foreground -mt-1">
-              The QTH nickname tells eQSL which location profile to file the QSO under. Leave blank if you have only one.
+              {t('es.eqslHint')}
             </div>
 
             <div className="border-t border-border/60 pt-3 space-y-3">
@@ -4008,38 +4086,38 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
         ) : extSvcTab === 'lotw' ? (
           <div className="space-y-4 max-w-2xl">
             <div className="grid grid-cols-[170px_1fr] gap-3 items-center">
-              <Label className="text-sm">LoTW user</Label>
+              <Label className="text-sm">{t('es.lotwUser')}</Label>
               <Input
                 value={lotw.username}
                 onChange={(e) => setLotw({ username: e.target.value })}
-                placeholder="LoTW website login (for downloading confirmations)"
+                placeholder={t('es.lotwUserPh')}
                 className="font-mono text-xs"
               />
-              <Label className="text-sm">LoTW password</Label>
+              <Label className="text-sm">{t('es.lotwPw')}</Label>
               <Input
                 type="password"
                 value={lotw.password}
                 onChange={(e) => setLotw({ password: e.target.value })}
-                placeholder="LoTW website password"
+                placeholder={t('es.lotwPwPh')}
                 className="text-xs"
               />
-              <Label className="text-sm">TQSL path</Label>
+              <Label className="text-sm">{t('es.tqslPath')}</Label>
               <Input
                 value={lotw.tqsl_path}
                 onChange={(e) => setLotw({ tqsl_path: e.target.value })}
                 placeholder="C:\Program Files (x86)\TrustedQSL\tqsl.exe"
                 className="font-mono text-xs"
               />
-              <Label className="text-sm">Station location</Label>
+              <Label className="text-sm">{t('es.stationLoc')}</Label>
               <div className="flex items-center gap-2">
                 <Select value={lotw.station_location || '_'} onValueChange={(v) => setLotw({ station_location: v === '_' ? '' : v })}>
-                  <SelectTrigger className="h-8 flex-1"><SelectValue placeholder="— pick a TQSL location —" /></SelectTrigger>
+                  <SelectTrigger className="h-8 flex-1"><SelectValue placeholder={t('es.pickLoc')} /></SelectTrigger>
                   <SelectContent>
-                    {stationLocations.length === 0 && <SelectItem value="_" disabled>No TQSL locations found</SelectItem>}
+                    {stationLocations.length === 0 && <SelectItem value="_" disabled>{t('es.noLoc')}</SelectItem>}
                     {stationLocations.map((n) => <SelectItem key={n} value={n}>{n}</SelectItem>)}
                   </SelectContent>
                 </Select>
-                <Button variant="ghost" size="sm" className="h-8 px-2" onClick={refreshLocations} title="Reload locations from TQSL">
+                <Button variant="ghost" size="sm" className="h-8 px-2" onClick={refreshLocations} title={t('es.reloadLoc')}>
                   <ArrowDown className="size-3.5 rotate-90" />
                 </Button>
               </div>
@@ -4048,23 +4126,22 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                 <Input
                   value={lotw.force_station_callsign}
                   onChange={(e) => setLotw({ force_station_callsign: e.target.value.toUpperCase() })}
-                  placeholder="e.g. F4BPO/P — leave blank to use the QSO's own call"
+                  placeholder={t('es.lotwForcePh')}
                   className="font-mono uppercase w-64"
                 />
                 <div className="text-[10px] text-muted-foreground mt-1">
-                  Overrides STATION_CALLSIGN at sign time so one certificate can sign several calls
+                  {t('es.lotwForceHint')}
-                  (F4BPO, F4BPO/P, TM2Q). Pick the matching Station Location above.
                 </div>
               </div>
-              <Label className="text-sm">Key password</Label>
+              <Label className="text-sm">{t('es.keyPw')}</Label>
               <Input
                 type="password"
                 value={lotw.key_password}
                 onChange={(e) => setLotw({ key_password: e.target.value })}
-                placeholder="only if your certificate key has a password"
+                placeholder={t('es.keyPwPh')}
                 className="text-xs"
               />
-              <Label className="text-sm">Consider as unsent</Label>
+              <Label className="text-sm">{t('es.considerUnsent')}</Label>
               <div>
                 <div className="flex items-center gap-4">
                   {(['N', 'R'] as const).map((f) => {
@@ -4081,15 +4158,13 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                             setLotw({ upload_flags: next });
                           }}
                         />
-                        {f === 'N' ? 'No (N)' : 'Requested (R)'}
+                        {f === 'N' ? t('es.flagN') : t('es.flagR')}
                       </label>
                     );
                   })}
                 </div>
                 <div className="text-[10px] text-muted-foreground mt-1">
-                  At app close, every QSO whose LoTW <em>sent</em> status is one of these is signed and
+                  {t('es.lotwUnsentHint')}
-                  uploaded in one TQSL batch — including QSOs imported from an ADIF. Uploaded QSOs become
-                  <em> Y</em> and won't be re-sent. Must include your default <em>sent</em> status from Confirmations.
                 </div>
               </div>
             </div>
@@ -4100,14 +4175,14 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                   checked={lotw.auto_upload}
                   onCheckedChange={(c) => setLotw({ auto_upload: !!c, upload_mode: 'on_close' })}
                 />
-                Automatic upload on application close
+                {t('es.lotwAutoClose')}
               </label>
               <label className="flex items-center gap-2 text-sm cursor-pointer">
                 <Checkbox
                   checked={lotw.write_log}
                   onCheckedChange={(c) => setLotw({ write_log: !!c })}
                 />
-                Write TQSL diagnostic log (-t)
+                {t('es.lotwWriteLog')}
               </label>
 
               <div className="flex items-center gap-3">
@@ -4142,13 +4217,10 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
         ) : extSvcTab === 'pota' ? (
           <div className="space-y-4 max-w-2xl">
             <p className="text-xs text-muted-foreground leading-relaxed">
-              Update your QSOs with the park reference from your <strong>pota.app hunter log</strong>.
+              {t('es.potaHint')}
-              Paste your session token: log in at <span className="font-mono">pota.app</span>, open the browser
-              DevTools → <strong>Network</strong> tab, click any <span className="font-mono">api.pota.app</span> request,
-              and copy the full <strong>Authorization</strong> header value. The token expires after a while — re-copy it if the sync fails.
             </p>
             <div className="grid grid-cols-[170px_1fr] gap-3 items-start">
-              <Label className="text-sm pt-2">Session token</Label>
+              <Label className="text-sm pt-2">{t('es.sessionToken')}</Label>
               <Textarea
                 value={potaToken}
                 onChange={(e) => setPotaToken(e.target.value)}
@@ -4158,10 +4230,10 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             </div>
             <div className="flex items-center gap-3">
               <Button onClick={savePotaToken} disabled={potaBusy}>
-                {potaBusy ? <><Loader2 className="size-4 mr-1.5 animate-spin" /> Saving…</> : 'Save token'}
+                {potaBusy ? <><Loader2 className="size-4 mr-1.5 animate-spin" /> {t('es.saving')}</> : t('es.saveToken')}
               </Button>
               <span className="text-[11px] text-muted-foreground">
-                Then run the sync from the <strong>QSL Manager</strong> tab → service <strong>POTA hunter log</strong> (you can see and fix unmatched QSOs there).
+                {t('es.potaThen')}
               </span>
             </div>
             {potaResult && (
@@ -4175,9 +4247,9 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
           <div className="flex flex-col items-center justify-center text-muted-foreground gap-2 py-16">
             <Construction className="size-10 opacity-30" />
             <div className="text-sm font-semibold text-foreground/70">
-              {TABS.find((t) => t.k === extSvcTab)?.label} — coming soon
+              {t('es.comingSoon', { name: TABS.find((tab) => tab.k === extSvcTab)?.label ?? '' })}
             </div>
-            <div className="text-xs">This external service isn't wired up yet.</div>
+            <div className="text-xs">{t('es.notWired')}</div>
           </div>
         )}
       </>
@@ -4643,35 +4715,35 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
           <MainViewPanes onChanged={onMainPaneChanged} flexAvailable={flexAvailable} icomAvailable={icomAvailable} />
 
           <div className="border-t border-border/60 pt-4 space-y-2">
-            <h4 className="text-sm font-semibold text-foreground">Password encryption</h4>
+            <h4 className="text-sm font-semibold text-foreground">{t('gen.pwEnc')}</h4>
             {secret.has_passphrase ? (
               <>
                 <p className="text-xs text-muted-foreground">
-                  Passwords encrypted{' '}
+                  {t('gen.pwEncrypted')}{' '}
                   {secret.unlocked
-                    ? <span className="text-success font-medium">— unlocked</span>
+                    ? <span className="text-success font-medium">{t('gen.pwUnlocked')}</span>
-                    : <span className="text-warning font-medium">— locked (unlock at launch)</span>}.
+                    : <span className="text-warning font-medium">{t('gen.pwLocked')}</span>}.
                 </p>
                 {secret.unlocked && (
                   <>
                     <div className="flex items-center gap-2 max-w-md">
-                      <Input type="password" placeholder="New passphrase (to change)" value={ppNew} onChange={(e) => { setPpNew(e.target.value); setPpErr(''); }} className="h-8" />
+                      <Input type="password" placeholder={t('gen.pwNewPh')} value={ppNew} onChange={(e) => { setPpNew(e.target.value); setPpErr(''); }} className="h-8" />
-                      <Input type="password" placeholder="Confirm" value={ppConfirm} onChange={(e) => { setPpConfirm(e.target.value); setPpErr(''); }} className="h-8" />
+                      <Input type="password" placeholder={t('gen.pwConfirm')} value={ppConfirm} onChange={(e) => { setPpConfirm(e.target.value); setPpErr(''); }} className="h-8" />
-                      <Button size="sm" disabled={!ppNew || ppBusy} onClick={applyPassphrase}>Change</Button>
+                      <Button size="sm" disabled={!ppNew || ppBusy} onClick={applyPassphrase}>{t('gen.pwChange')}</Button>
                     </div>
-                    <Button variant="outline" size="sm" disabled={ppBusy} onClick={removePassphrase}>Remove encryption (store passwords in clear)</Button>
+                    <Button variant="outline" size="sm" disabled={ppBusy} onClick={removePassphrase}>{t('gen.pwRemove')}</Button>
                   </>
                 )}
               </>
             ) : (
               <>
                 <p className="text-xs text-muted-foreground">
-                  Encrypt saved passwords with a passphrase (asked at launch). Stays portable — re-enter it on another PC.
+                  {t('gen.pwHint')}
                 </p>
                 <div className="flex items-center gap-2 max-w-md">
-                  <Input type="password" placeholder="Passphrase" value={ppNew} onChange={(e) => { setPpNew(e.target.value); setPpErr(''); }} className="h-8" />
+                  <Input type="password" placeholder={t('gen.pwPassphrase')} value={ppNew} onChange={(e) => { setPpNew(e.target.value); setPpErr(''); }} className="h-8" />
-                  <Input type="password" placeholder="Confirm" value={ppConfirm} onChange={(e) => { setPpConfirm(e.target.value); setPpErr(''); }} className="h-8" />
+                  <Input type="password" placeholder={t('gen.pwConfirm')} value={ppConfirm} onChange={(e) => { setPpConfirm(e.target.value); setPpErr(''); }} className="h-8" />
-                  <Button size="sm" disabled={!ppNew || ppNew !== ppConfirm || ppBusy} onClick={applyPassphrase}>Encrypt</Button>
+                  <Button size="sm" disabled={!ppNew || ppNew !== ppConfirm || ppBusy} onClick={applyPassphrase}>{t('gen.pwEncrypt')}</Button>
                 </div>
               </>
             )}
@@ -4679,7 +4751,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
           </div>
 
           <div className="border-t border-border/60 pt-4 space-y-2">
-            <h4 className="text-sm font-semibold text-foreground">ClubLog exceptions (DXpedition overrides)</h4>
+            <h4 className="text-sm font-semibold text-foreground">{t('gen.clubTitle')}</h4>
             <label className="flex items-start gap-2 text-sm cursor-pointer">
               <Checkbox
                 checked={clubInfo.enabled}
@@ -4700,27 +4772,67 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                 className="mt-0.5"
               />
               <span>
-                Use ClubLog Country File for callsign resolution
+                {t('gen.clubUse')}
                 <span className="block text-xs text-muted-foreground mt-0.5">
-                  Applies ClubLog's date-ranged full-callsign <strong>exceptions</strong> that cty.dat lacks — e.g. VK2/SP9FIH
+                  {t('gen.clubDesc')}
-                  resolves to Lord Howe Island (not Australia) for the DXpedition dates. Used on entry, import, UDP, and the
-                  right-click <em>Update from ClubLog</em>.
                 </span>
               </span>
             </label>
             <div className="flex items-center gap-3 pl-6">
               <Button variant="outline" size="sm" className="h-8" disabled={clubBusy}
                 onClick={() => { setClubBusy(true); setClubErr(''); DownloadClublogCty().then((i) => setClubInfo(i as ClubInfo)).catch((e: any) => setClubErr(String(e?.message ?? e))).finally(() => setClubBusy(false)); }}>
-                {clubBusy ? 'Downloading…' : (clubInfo.loaded ? 'Update ClubLog data' : 'Download ClubLog data')}
+                {clubBusy ? t('gen.downloading') : (clubInfo.loaded ? t('gen.clubUpdate') : t('gen.clubDownload'))}
               </Button>
               <span className="text-[11px] text-muted-foreground">
                 {clubInfo.loaded
-                  ? `${clubInfo.count.toLocaleString()} exceptions${clubInfo.date ? ' · ' + clubInfo.date.slice(0, 10) : ''}`
+                  ? t('gen.clubCount', { n: clubInfo.count.toLocaleString() }) + (clubInfo.date ? ' · ' + clubInfo.date.slice(0, 10) : '')
-                  : 'not downloaded'}
+                  : t('gen.notDownloaded')}
               </span>
             </div>
             {clubErr && <p className="text-[11px] text-destructive pl-6">{clubErr}</p>}
           </div>
+
+          <div className="border-t border-border/60 pt-4 space-y-2">
+            <h4 className="text-sm font-semibold text-foreground">{t('gen.mwTitle')}</h4>
+            <label className="flex items-start gap-2 text-sm cursor-pointer">
+              <Checkbox
+                checked={mwInfo.enabled}
+                onCheckedChange={async (c) => {
+                  const v = !!c; setMwInfo((s) => ({ ...s, enabled: v })); setMwErr('');
+                  try {
+                    await SetClublogMostWantedEnabled(v);
+                    let info = (await GetClublogMostWantedInfo()) as MWInfo;
+                    // First enable with no cached list → fetch it now (for the active call).
+                    if (v && !info.loaded) {
+                      setMwBusy(true);
+                      try { info = (await DownloadClublogMostWanted()) as MWInfo; }
+                      finally { setMwBusy(false); }
+                    }
+                    setMwInfo(info);
+                  } catch (e: any) { setMwErr(String(e?.message ?? e)); }
+                }}
+                className="mt-0.5"
+              />
+              <span>
+                {t('gen.mwShow')}
+                <span className="block text-xs text-muted-foreground mt-0.5">
+                  {t('gen.mwDesc')}
+                </span>
+              </span>
+            </label>
+            <div className="flex items-center gap-3 pl-6">
+              <Button variant="outline" size="sm" className="h-8" disabled={mwBusy}
+                onClick={() => { setMwBusy(true); setMwErr(''); DownloadClublogMostWanted().then((i) => setMwInfo(i as MWInfo)).catch((e: any) => setMwErr(String(e?.message ?? e))).finally(() => setMwBusy(false)); }}>
+                {mwBusy ? t('gen.downloading') : (mwInfo.loaded ? t('gen.mwUpdate') : t('gen.mwDownload'))}
+              </Button>
+              <span className="text-[11px] text-muted-foreground">
+                {mwInfo.loaded
+                  ? t('gen.mwCount', { n: mwInfo.count.toLocaleString() }) + (mwInfo.callsign ? ' · ' + mwInfo.callsign : '') + (mwInfo.date ? ' · ' + mwInfo.date : '')
+                  : t('gen.notDownloaded')}
+              </span>
+            </div>
+            {mwErr && <p className="text-[11px] text-destructive pl-6">{mwErr}</p>}
+          </div>
         </div>
       </>
     );

frontend/src/lib/theme.tsx

@@ -73,16 +73,24 @@ export function ThemeProvider({ children }: { children: ReactNode }) {
     const load = () => {
       tries += 1;
       GetUIPref(LS_KEY).then((raw) => {
+        // Backend ANSWERED (settings store ready). Apply a valid stored value; an
+        // empty/invalid one means the theme is genuinely unset → keep the default.
+        // Either way we're done — do NOT retry (retrying only matters while the
+        // backend is still starting, which now surfaces as a rejected promise).
         if (cancelled || userPicked.current) return;
         const v = raw as ThemeChoice;
         if (v && ALL.includes(v)) {
           try { localStorage.setItem(LS_KEY, v); } catch { /* quota */ }
           applyThemeToDom(v); // idempotent — safe to call unconditionally
           setThemeState(v);
-          return; // restored
         }
-        if (tries < 8) window.setTimeout(load, 300); // empty (unset or backend not ready yet) → retry
+      }).catch(() => {
-      }).catch(() => { if (!cancelled && tries < 8) window.setTimeout(load, 300); });
+        // Settings store not ready yet — a brief startup window before the backend
+        // has opened the local DB and built the store (the frontend can query it
+        // first). Keep retrying well past the old 2.4s cap so a dark theme isn't
+        // lost to the light default after an update cleared localStorage.
+        if (!cancelled && !userPicked.current && tries < 120) window.setTimeout(load, 300);
+      });
     };
     load();
     return () => { cancelled = true; };

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

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

@@ -28,6 +28,8 @@ export function ACOMSetOperate(arg1:boolean):Promise<void>;
 
 export function ACOMSetPower(arg1:boolean):Promise<void>;
 
+export function ADIFExtraFields():Promise<Array<string>>;
+
 export function ADIFFields():Promise<Array<adif.FieldDef>>;
 
 export function ADIFVersion():Promise<string>;
@@ -86,6 +88,8 @@ export function BulkUpdateField(arg1:Array<number>,arg2:string,arg3:string):Prom
 
 export function BulkUpdateQSL(arg1:Array<number>,arg2:main.QSLBulkUpdate):Promise<number>;
 
+export function CWDecoderRunning():Promise<boolean>;
+
 export function ChatAvailable():Promise<boolean>;
 
 export function CheckForUpdate():Promise<main.UpdateInfo>;
@@ -162,6 +166,8 @@ export function DownloadAndApplyUpdate(arg1:string):Promise<void>;
 
 export function DownloadClublogCty():Promise<main.ClublogCtyInfo>;
 
+export function DownloadClublogMostWanted():Promise<main.ClublogMostWantedInfo>;
+
 export function DownloadConfirmations(arg1:string,arg2:boolean,arg3:string):Promise<void>;
 
 export function DownloadLoTWUsers():Promise<number>;
@@ -172,11 +178,11 @@ export function DuplicateProfile(arg1:number,arg2:string):Promise<profile.Profil
 
 export function ExplainAward(arg1:string,arg2:string):Promise<Array<main.AwardExplain>>;
 
-export function ExportADIF(arg1:string,arg2:boolean):Promise<adif.ExportResult>;
+export function ExportADIF(arg1:string,arg2:boolean,arg3:Array<string>):Promise<adif.ExportResult>;
 
-export function ExportADIFFiltered(arg1:string,arg2:boolean,arg3:qso.QueryFilter):Promise<adif.ExportResult>;
+export function ExportADIFFiltered(arg1:string,arg2:boolean,arg3:qso.QueryFilter,arg4:Array<string>):Promise<adif.ExportResult>;
 
-export function ExportADIFSelected(arg1:string,arg2:boolean,arg3:Array<number>):Promise<adif.ExportResult>;
+export function ExportADIFSelected(arg1:string,arg2:boolean,arg3:Array<number>,arg4:Array<string>):Promise<adif.ExportResult>;
 
 export function ExportAward(arg1:string):Promise<string>;
 
@@ -366,6 +372,8 @@ export function GetCATSettings():Promise<main.CATSettings>;
 
 export function GetCATState():Promise<cat.RigState>;
 
+export function GetCWDecoderPitch():Promise<number>;
+
 export function GetCatalogCodes():Promise<Array<string>>;
 
 export function GetChangelog():Promise<Array<main.ChangelogEntry>>;
@@ -374,6 +382,8 @@ export function GetChatHistory(arg1:number):Promise<Array<main.ChatMessage>>;
 
 export function GetClublogCtyInfo():Promise<main.ClublogCtyInfo>;
 
+export function GetClublogMostWantedInfo():Promise<main.ClublogMostWantedInfo>;
+
 export function GetClusterAutoConnect():Promise<boolean>;
 
 export function GetClusterStatus():Promise<Array<cluster.ServerStatus>>;
@@ -854,8 +864,12 @@ export function SetCATFrequency(arg1:number):Promise<void>;
 
 export function SetCATMode(arg1:string):Promise<void>;
 
+export function SetCWDecoderPitch(arg1:number):Promise<void>;
+
 export function SetClublogCtyEnabled(arg1:boolean):Promise<void>;
 
+export function SetClublogMostWantedEnabled(arg1:boolean):Promise<void>;
+
 export function SetClusterAutoConnect(arg1:boolean):Promise<void>;
 
 export function SetCompactMode(arg1:boolean):Promise<void>;
@@ -870,8 +884,12 @@ export function SetUIPref(arg1:string,arg2:string):Promise<void>;
 
 export function SetUltrabeamDirection(arg1:number):Promise<void>;
 
+export function StartCWDecoder():Promise<void>;
+
 export function StationSetRelay(arg1:string,arg2:number,arg3:boolean):Promise<void>;
 
+export function StopCWDecoder():Promise<void>;
+
 export function SwitchCATRig(arg1:number):Promise<void>;
 
 export function SyncPOTAHunterLog(arg1:boolean,arg2:boolean):Promise<main.POTASyncResult>;

frontend/wailsjs/go/main/App.js

@@ -10,6 +10,10 @@ export function ACOMSetPower(arg1) {
   return window['go']['main']['App']['ACOMSetPower'](arg1);
 }
 
+export function ADIFExtraFields() {
+  return window['go']['main']['App']['ADIFExtraFields']();
+}
+
 export function ADIFFields() {
   return window['go']['main']['App']['ADIFFields']();
 }
@@ -126,6 +130,10 @@ export function BulkUpdateQSL(arg1, arg2) {
   return window['go']['main']['App']['BulkUpdateQSL'](arg1, arg2);
 }
 
+export function CWDecoderRunning() {
+  return window['go']['main']['App']['CWDecoderRunning']();
+}
+
 export function ChatAvailable() {
   return window['go']['main']['App']['ChatAvailable']();
 }
@@ -278,6 +286,10 @@ export function DownloadClublogCty() {
   return window['go']['main']['App']['DownloadClublogCty']();
 }
 
+export function DownloadClublogMostWanted() {
+  return window['go']['main']['App']['DownloadClublogMostWanted']();
+}
+
 export function DownloadConfirmations(arg1, arg2, arg3) {
   return window['go']['main']['App']['DownloadConfirmations'](arg1, arg2, arg3);
 }
@@ -298,16 +310,16 @@ export function ExplainAward(arg1, arg2) {
   return window['go']['main']['App']['ExplainAward'](arg1, arg2);
 }
 
-export function ExportADIF(arg1, arg2) {
+export function ExportADIF(arg1, arg2, arg3) {
-  return window['go']['main']['App']['ExportADIF'](arg1, arg2);
+  return window['go']['main']['App']['ExportADIF'](arg1, arg2, arg3);
 }
 
-export function ExportADIFFiltered(arg1, arg2, arg3) {
+export function ExportADIFFiltered(arg1, arg2, arg3, arg4) {
-  return window['go']['main']['App']['ExportADIFFiltered'](arg1, arg2, arg3);
+  return window['go']['main']['App']['ExportADIFFiltered'](arg1, arg2, arg3, arg4);
 }
 
-export function ExportADIFSelected(arg1, arg2, arg3) {
+export function ExportADIFSelected(arg1, arg2, arg3, arg4) {
-  return window['go']['main']['App']['ExportADIFSelected'](arg1, arg2, arg3);
+  return window['go']['main']['App']['ExportADIFSelected'](arg1, arg2, arg3, arg4);
 }
 
 export function ExportAward(arg1) {
@@ -686,6 +698,10 @@ export function GetCATState() {
   return window['go']['main']['App']['GetCATState']();
 }
 
+export function GetCWDecoderPitch() {
+  return window['go']['main']['App']['GetCWDecoderPitch']();
+}
+
 export function GetCatalogCodes() {
   return window['go']['main']['App']['GetCatalogCodes']();
 }
@@ -702,6 +718,10 @@ export function GetClublogCtyInfo() {
   return window['go']['main']['App']['GetClublogCtyInfo']();
 }
 
+export function GetClublogMostWantedInfo() {
+  return window['go']['main']['App']['GetClublogMostWantedInfo']();
+}
+
 export function GetClusterAutoConnect() {
   return window['go']['main']['App']['GetClusterAutoConnect']();
 }
@@ -1662,10 +1682,18 @@ export function SetCATMode(arg1) {
   return window['go']['main']['App']['SetCATMode'](arg1);
 }
 
+export function SetCWDecoderPitch(arg1) {
+  return window['go']['main']['App']['SetCWDecoderPitch'](arg1);
+}
+
 export function SetClublogCtyEnabled(arg1) {
   return window['go']['main']['App']['SetClublogCtyEnabled'](arg1);
 }
 
+export function SetClublogMostWantedEnabled(arg1) {
+  return window['go']['main']['App']['SetClublogMostWantedEnabled'](arg1);
+}
+
 export function SetClusterAutoConnect(arg1) {
   return window['go']['main']['App']['SetClusterAutoConnect'](arg1);
 }
@@ -1694,10 +1722,18 @@ export function SetUltrabeamDirection(arg1) {
   return window['go']['main']['App']['SetUltrabeamDirection'](arg1);
 }
 
+export function StartCWDecoder() {
+  return window['go']['main']['App']['StartCWDecoder']();
+}
+
 export function StationSetRelay(arg1, arg2, arg3) {
   return window['go']['main']['App']['StationSetRelay'](arg1, arg2, arg3);
 }
 
+export function StopCWDecoder() {
+  return window['go']['main']['App']['StopCWDecoder']();
+}
+
 export function SwitchCATRig(arg1) {
   return window['go']['main']['App']['SwitchCATRig'](arg1);
 }

frontend/wailsjs/go/models.ts

@@ -1949,6 +1949,26 @@ export namespace main {
 	        this.count = source["count"];
 	    }
 	}
+	export class ClublogMostWantedInfo {
+	    enabled: boolean;
+	    loaded: boolean;
+	    callsign: string;
+	    date: string;
+	    count: number;
+	
+	    static createFrom(source: any = {}) {
+	        return new ClublogMostWantedInfo(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.enabled = source["enabled"];
+	        this.loaded = source["loaded"];
+	        this.callsign = source["callsign"];
+	        this.date = source["date"];
+	        this.count = source["count"];
+	    }
+	}
 	export class ContestBandRow {
 	    band: string;
 	    count: number;
@@ -2940,6 +2960,8 @@ export namespace main {
 	    follow: boolean;
 	    step_khz: number;
 	    tx_inhibit: boolean;
+	    freq_min_mhz: number;
+	    freq_max_mhz: number;
 	
 	    static createFrom(source: any = {}) {
 	        return new UltrabeamSettings(source);
@@ -2957,6 +2979,8 @@ export namespace main {
 	        this.follow = source["follow"];
 	        this.step_khz = source["step_khz"];
 	        this.tx_inhibit = source["tx_inhibit"];
+	        this.freq_min_mhz = source["freq_min_mhz"];
+	        this.freq_max_mhz = source["freq_max_mhz"];
 	    }
 	}
 	export class UltrabeamStatusInfo {
@@ -3035,6 +3059,9 @@ export namespace main {
 	    autospace: boolean;
 	    use_ptt: boolean;
 	    serial_echo: boolean;
+	    type: string;
+	    cw_key_line: string;
+	    cw_invert: boolean;
 	    engine: string;
 	    esc_clears_call: boolean;
 	    send_on_type: boolean;
@@ -3061,6 +3088,9 @@ export namespace main {
 	        this.autospace = source["autospace"];
 	        this.use_ptt = source["use_ptt"];
 	        this.serial_echo = source["serial_echo"];
+	        this.type = source["type"];
+	        this.cw_key_line = source["cw_key_line"];
+	        this.cw_invert = source["cw_invert"];
 	        this.engine = source["engine"];
 	        this.esc_clears_call = source["esc_clears_call"];
 	        this.send_on_type = source["send_on_type"];
@@ -4219,6 +4249,7 @@ export namespace qso {
 	    dxcc_bands: string[];
 	    dxcc_modes: string[];
 	    dxcc_band_modes: BandMode[];
+	    mw_rank?: number;
 	    band_status: BandStatus[];
 	
 	    static createFrom(source: any = {}) {
@@ -4243,6 +4274,7 @@ export namespace qso {
 	        this.dxcc_bands = source["dxcc_bands"];
 	        this.dxcc_modes = source["dxcc_modes"];
 	        this.dxcc_band_modes = this.convertValues(source["dxcc_band_modes"], BandMode);
+	        this.mw_rank = source["mw_rank"];
 	        this.band_status = this.convertValues(source["band_status"], BandStatus);
 	    }
 	

internal/adif/export.go

@@ -34,6 +34,12 @@ type Exporter struct {
 	// export destined for another logger; set true for a full OpsLog→OpsLog
 	// round-trip that preserves everything.
 	IncludeAppFields bool
+
+	// Fields, when non-nil, restricts the export to exactly these ADIF tags
+	// (uppercase) — the "choose which fields to export" mode. nil = write every
+	// field (the standard/full behaviour above). When set it overrides
+	// IncludeAppFields: an APP_/vendor tag is written iff it's in the set.
+	Fields map[string]bool
 }
 
 // iterator streams QSOs through fn. The three concrete sources (all, filtered,
@@ -100,7 +106,7 @@ func (e *Exporter) writeDoc(ctx context.Context, w io.Writer, iter iterator) (in
 
 	count := 0
 	err := iter(ctx, func(q qso.QSO) error {
-		writeRecord(bw, q, e.IncludeAppFields)
+		writeRecord(bw, q, e.IncludeAppFields, e.Fields)
 		count++
 		return nil
 	})
@@ -115,7 +121,7 @@ func SingleRecordADIF(q qso.QSO) string {
 	var b strings.Builder
 	bw := bufio.NewWriter(&b)
 	// Uploads target other services — keep it standard (no app-specific tags).
-	writeRecord(bw, q, false)
+	writeRecord(bw, q, false, nil)
 	bw.Flush()
 	return b.String()
 }
@@ -127,7 +133,7 @@ func SingleRecordADIF(q qso.QSO) string {
 func FullRecordADIF(q qso.QSO) string {
 	var b strings.Builder
 	bw := bufio.NewWriter(&b)
-	writeRecord(bw, q, true)
+	writeRecord(bw, q, true, nil)
 	bw.Flush()
 	return b.String()
 }
@@ -155,161 +161,181 @@ func BatchRecordsADIF(records []string) string {
 // Empty fields are omitted. MODE/SUBMODE are massaged so a "promoted"
 // mode (e.g. FT4 stored without a parent) is exported as the canonical
 // pair MODE=MFSK SUBMODE=FT4 — round-trips cleanly with strict loggers.
-func writeRecord(bw *bufio.Writer, q qso.QSO, includeApp bool) {
+func writeRecord(bw *bufio.Writer, q qso.QSO, includeApp bool, allow map[string]bool) {
+	// allow == nil → write every promoted field (standard/full behaviour).
+	// Otherwise a promoted tag is written only when it's in the chosen set.
+	// w/wi/wf wrap the raw writers with that gate so the ~150 field lines below
+	// stay one-liners.
+	ok := func(tag string) bool { return allow == nil || allow[tag] }
+	w := func(tag, v string) {
+		if ok(tag) {
+			writeField(bw, tag, v)
+		}
+	}
+	wi := func(tag string, p *int) {
+		if ok(tag) {
+			writeIntPtr(bw, tag, p)
+		}
+	}
+	wf := func(tag string, p *float64, decimals int) {
+		if ok(tag) {
+			writeFloatPtr(bw, tag, p, decimals)
+		}
+	}
 	// --- Core ---
-	writeField(bw, "CALL", q.Callsign)
+	w("CALL", q.Callsign)
 
 	if !q.QSODate.IsZero() {
-		writeField(bw, "QSO_DATE", q.QSODate.UTC().Format("20060102"))
+		w("QSO_DATE", q.QSODate.UTC().Format("20060102"))
-		writeField(bw, "TIME_ON", q.QSODate.UTC().Format("150405"))
+		w("TIME_ON", q.QSODate.UTC().Format("150405"))
 	}
 	if !q.QSODateOff.IsZero() {
-		writeField(bw, "QSO_DATE_OFF", q.QSODateOff.UTC().Format("20060102"))
+		w("QSO_DATE_OFF", q.QSODateOff.UTC().Format("20060102"))
-		writeField(bw, "TIME_OFF", q.QSODateOff.UTC().Format("150405"))
+		w("TIME_OFF", q.QSODateOff.UTC().Format("150405"))
 	}
-	writeField(bw, "BAND", q.Band)
+	w("BAND", q.Band)
-	writeField(bw, "BAND_RX", q.BandRX)
+	w("BAND_RX", q.BandRX)
 
 	mode, submode := modeForExport(q.Mode, q.Submode)
-	writeField(bw, "MODE", mode)
+	w("MODE", mode)
-	writeField(bw, "SUBMODE", submode)
+	w("SUBMODE", submode)
 
 	if q.FreqHz != nil && *q.FreqHz > 0 {
-		writeField(bw, "FREQ", strconv.FormatFloat(float64(*q.FreqHz)/1_000_000, 'f', 6, 64))
+		w("FREQ", strconv.FormatFloat(float64(*q.FreqHz)/1_000_000, 'f', 6, 64))
 	}
 	if q.FreqRXHz != nil && *q.FreqRXHz > 0 {
-		writeField(bw, "FREQ_RX", strconv.FormatFloat(float64(*q.FreqRXHz)/1_000_000, 'f', 6, 64))
+		w("FREQ_RX", strconv.FormatFloat(float64(*q.FreqRXHz)/1_000_000, 'f', 6, 64))
 	}
 
-	writeField(bw, "RST_SENT", q.RSTSent)
+	w("RST_SENT", q.RSTSent)
-	writeField(bw, "RST_RCVD", q.RSTRcvd)
+	w("RST_RCVD", q.RSTRcvd)
 
 	// --- Contacted ---
-	writeField(bw, "NAME", q.Name)
+	w("NAME", q.Name)
-	writeField(bw, "QTH", q.QTH)
+	w("QTH", q.QTH)
-	writeField(bw, "ADDRESS", q.Address)
+	w("ADDRESS", q.Address)
-	writeField(bw, "EMAIL", q.Email)
+	w("EMAIL", q.Email)
-	writeField(bw, "WEB", q.Web)
+	w("WEB", q.Web)
-	writeField(bw, "GRIDSQUARE", q.Grid)
+	w("GRIDSQUARE", q.Grid)
-	writeField(bw, "GRIDSQUARE_EXT", q.GridExt)
+	w("GRIDSQUARE_EXT", q.GridExt)
-	writeField(bw, "VUCC_GRIDS", q.VUCCGrids)
+	w("VUCC_GRIDS", q.VUCCGrids)
-	writeField(bw, "COUNTRY", q.Country)
+	w("COUNTRY", q.Country)
-	writeField(bw, "STATE", q.State)
+	w("STATE", q.State)
-	writeField(bw, "CNTY", q.County)
+	w("CNTY", q.County)
-	writeIntPtr(bw, "DXCC", q.DXCC)
+	wi("DXCC", q.DXCC)
-	writeField(bw, "CONT", q.Continent)
+	w("CONT", q.Continent)
-	writeIntPtr(bw, "CQZ", q.CQZ)
+	wi("CQZ", q.CQZ)
-	writeIntPtr(bw, "ITUZ", q.ITUZ)
+	wi("ITUZ", q.ITUZ)
-	writeField(bw, "IOTA", q.IOTA)
+	w("IOTA", q.IOTA)
-	writeField(bw, "SOTA_REF", q.SOTARef)
+	w("SOTA_REF", q.SOTARef)
-	writeField(bw, "POTA_REF", q.POTARef)
+	w("POTA_REF", q.POTARef)
-	writeIntPtr(bw, "AGE", q.Age)
+	wi("AGE", q.Age)
-	writeFloatPtr(bw, "LAT", q.Lat, 6)
+	wf("LAT", q.Lat, 6)
-	writeFloatPtr(bw, "LON", q.Lon, 6)
+	wf("LON", q.Lon, 6)
-	writeField(bw, "RIG", q.Rig)
+	w("RIG", q.Rig)
-	writeField(bw, "ANT", q.Ant)
+	w("ANT", q.Ant)
 
 	// --- QSL / LoTW / eQSL / Clublog / HRDLog ---
-	writeField(bw, "QSL_SENT", q.QSLSent)
+	w("QSL_SENT", q.QSLSent)
-	writeField(bw, "QSL_RCVD", q.QSLRcvd)
+	w("QSL_RCVD", q.QSLRcvd)
-	writeField(bw, "QSLSDATE", q.QSLSentDate)
+	w("QSLSDATE", q.QSLSentDate)
-	writeField(bw, "QSLRDATE", q.QSLRcvdDate)
+	w("QSLRDATE", q.QSLRcvdDate)
-	writeField(bw, "QSL_VIA", q.QSLVia)
+	w("QSL_VIA", q.QSLVia)
-	writeField(bw, "QSLMSG", q.QSLMsg)
+	w("QSLMSG", q.QSLMsg)
-	writeField(bw, "QSLMSG_RCVD", q.QSLMsgRcvd)
+	w("QSLMSG_RCVD", q.QSLMsgRcvd)
-	writeField(bw, "LOTW_QSL_SENT", q.LOTWSent)
+	w("LOTW_QSL_SENT", q.LOTWSent)
-	writeField(bw, "LOTW_QSL_RCVD", q.LOTWRcvd)
+	w("LOTW_QSL_RCVD", q.LOTWRcvd)
-	writeField(bw, "LOTW_QSLSDATE", q.LOTWSentDate)
+	w("LOTW_QSLSDATE", q.LOTWSentDate)
-	writeField(bw, "LOTW_QSLRDATE", q.LOTWRcvdDate)
+	w("LOTW_QSLRDATE", q.LOTWRcvdDate)
-	writeField(bw, "EQSL_QSL_SENT", q.EQSLSent)
+	w("EQSL_QSL_SENT", q.EQSLSent)
-	writeField(bw, "EQSL_QSL_RCVD", q.EQSLRcvd)
+	w("EQSL_QSL_RCVD", q.EQSLRcvd)
-	writeField(bw, "EQSL_QSLSDATE", q.EQSLSentDate)
+	w("EQSL_QSLSDATE", q.EQSLSentDate)
-	writeField(bw, "EQSL_QSLRDATE", q.EQSLRcvdDate)
+	w("EQSL_QSLRDATE", q.EQSLRcvdDate)
-	writeField(bw, "CLUBLOG_QSO_UPLOAD_DATE", q.ClublogUploadDate)
+	w("CLUBLOG_QSO_UPLOAD_DATE", q.ClublogUploadDate)
-	writeField(bw, "CLUBLOG_QSO_UPLOAD_STATUS", q.ClublogUploadStatus)
+	w("CLUBLOG_QSO_UPLOAD_STATUS", q.ClublogUploadStatus)
-	writeField(bw, "HRDLOG_QSO_UPLOAD_DATE", q.HRDLogUploadDate)
+	w("HRDLOG_QSO_UPLOAD_DATE", q.HRDLogUploadDate)
-	writeField(bw, "HRDLOG_QSO_UPLOAD_STATUS", q.HRDLogUploadStatus)
+	w("HRDLOG_QSO_UPLOAD_STATUS", q.HRDLogUploadStatus)
-	writeField(bw, "QRZCOM_QSO_UPLOAD_DATE", q.QRZComUploadDate)
+	w("QRZCOM_QSO_UPLOAD_DATE", q.QRZComUploadDate)
-	writeField(bw, "QRZCOM_QSO_UPLOAD_STATUS", q.QRZComUploadStatus)
+	w("QRZCOM_QSO_UPLOAD_STATUS", q.QRZComUploadStatus)
-	writeField(bw, "QRZCOM_QSO_DOWNLOAD_DATE", q.QRZComDownloadDate)
+	w("QRZCOM_QSO_DOWNLOAD_DATE", q.QRZComDownloadDate)
-	writeField(bw, "QRZCOM_QSO_DOWNLOAD_STATUS", q.QRZComDownloadStatus)
+	w("QRZCOM_QSO_DOWNLOAD_STATUS", q.QRZComDownloadStatus)
 
 	// --- Contest ---
-	writeField(bw, "CONTEST_ID", q.ContestID)
+	w("CONTEST_ID", q.ContestID)
-	writeIntPtr(bw, "SRX", q.SRX)
+	wi("SRX", q.SRX)
-	writeIntPtr(bw, "STX", q.STX)
+	wi("STX", q.STX)
-	writeField(bw, "SRX_STRING", q.SRXString)
+	w("SRX_STRING", q.SRXString)
-	writeField(bw, "STX_STRING", q.STXString)
+	w("STX_STRING", q.STXString)
-	writeField(bw, "CHECK", q.Check)
+	w("CHECK", q.Check)
-	writeField(bw, "PRECEDENCE", q.Precedence)
+	w("PRECEDENCE", q.Precedence)
-	writeField(bw, "ARRL_SECT", q.ARRLSect)
+	w("ARRL_SECT", q.ARRLSect)
 
 	// --- Satellite / propagation ---
-	writeField(bw, "PROP_MODE", q.PropMode)
+	w("PROP_MODE", q.PropMode)
-	writeField(bw, "SAT_NAME", q.SatName)
+	w("SAT_NAME", q.SatName)
-	writeField(bw, "SAT_MODE", q.SatMode)
+	w("SAT_MODE", q.SatMode)
-	writeFloatPtr(bw, "ANT_AZ", q.AntAz, 1)
+	wf("ANT_AZ", q.AntAz, 1)
-	writeFloatPtr(bw, "ANT_EL", q.AntEl, 1)
+	wf("ANT_EL", q.AntEl, 1)
-	writeField(bw, "ANT_PATH", q.AntPath)
+	w("ANT_PATH", q.AntPath)
 
 	// --- My station / operator ---
-	writeField(bw, "STATION_CALLSIGN", q.StationCallsign)
+	w("STATION_CALLSIGN", q.StationCallsign)
-	writeField(bw, "OPERATOR", q.Operator)
+	w("OPERATOR", q.Operator)
-	writeField(bw, "MY_GRIDSQUARE", q.MyGrid)
+	w("MY_GRIDSQUARE", q.MyGrid)
-	writeField(bw, "MY_GRIDSQUARE_EXT", q.MyGridExt)
+	w("MY_GRIDSQUARE_EXT", q.MyGridExt)
-	writeField(bw, "MY_COUNTRY", q.MyCountry)
+	w("MY_COUNTRY", q.MyCountry)
-	writeField(bw, "MY_STATE", q.MyState)
+	w("MY_STATE", q.MyState)
-	writeField(bw, "MY_CNTY", q.MyCounty)
+	w("MY_CNTY", q.MyCounty)
-	writeField(bw, "MY_IOTA", q.MyIOTA)
+	w("MY_IOTA", q.MyIOTA)
-	writeField(bw, "MY_SOTA_REF", q.MySOTARef)
+	w("MY_SOTA_REF", q.MySOTARef)
-	writeField(bw, "MY_POTA_REF", q.MyPOTARef)
+	w("MY_POTA_REF", q.MyPOTARef)
-	writeIntPtr(bw, "MY_DXCC", q.MyDXCC)
+	wi("MY_DXCC", q.MyDXCC)
-	writeIntPtr(bw, "MY_CQ_ZONE", q.MyCQZone)
+	wi("MY_CQ_ZONE", q.MyCQZone)
-	writeIntPtr(bw, "MY_ITU_ZONE", q.MyITUZone)
+	wi("MY_ITU_ZONE", q.MyITUZone)
-	writeFloatPtr(bw, "MY_LAT", q.MyLat, 6)
+	wf("MY_LAT", q.MyLat, 6)
-	writeFloatPtr(bw, "MY_LON", q.MyLon, 6)
+	wf("MY_LON", q.MyLon, 6)
-	writeField(bw, "MY_STREET", q.MyStreet)
+	w("MY_STREET", q.MyStreet)
-	writeField(bw, "MY_CITY", q.MyCity)
+	w("MY_CITY", q.MyCity)
-	writeField(bw, "MY_POSTAL_CODE", q.MyPostalCode)
+	w("MY_POSTAL_CODE", q.MyPostalCode)
-	writeField(bw, "MY_RIG", q.MyRig)
+	w("MY_RIG", q.MyRig)
-	writeField(bw, "MY_ANTENNA", q.MyAntenna)
+	w("MY_ANTENNA", q.MyAntenna)
 
 	// --- Misc ---
-	writeFloatPtr(bw, "TX_PWR", q.TXPower, 1)
+	wf("TX_PWR", q.TXPower, 1)
-	writeField(bw, "COMMENT", q.Comment)
+	w("COMMENT", q.Comment)
-	writeField(bw, "NOTES", q.Notes)
+	w("NOTES", q.Notes)
 
 	// --- ADIF 3.1.7 additional promoted fields ---
-	writeField(bw, "SIG", q.SIG)
+	w("SIG", q.SIG)
-	writeField(bw, "SIG_INFO", q.SIGInfo)
+	w("SIG_INFO", q.SIGInfo)
-	writeField(bw, "MY_SIG", q.MySIG)
+	w("MY_SIG", q.MySIG)
-	writeField(bw, "MY_SIG_INFO", q.MySIGInfo)
+	w("MY_SIG_INFO", q.MySIGInfo)
-	writeField(bw, "WWFF_REF", q.WWFFRef)
+	w("WWFF_REF", q.WWFFRef)
-	writeField(bw, "MY_WWFF_REF", q.MyWWFFRef)
+	w("MY_WWFF_REF", q.MyWWFFRef)
-	writeFloatPtr(bw, "DISTANCE", q.Distance, 1)
+	wf("DISTANCE", q.Distance, 1)
-	writeFloatPtr(bw, "RX_PWR", q.RXPower, 1)
+	wf("RX_PWR", q.RXPower, 1)
-	writeFloatPtr(bw, "A_INDEX", q.AIndex, 0)
+	wf("A_INDEX", q.AIndex, 0)
-	writeFloatPtr(bw, "K_INDEX", q.KIndex, 0)
+	wf("K_INDEX", q.KIndex, 0)
-	writeFloatPtr(bw, "SFI", q.SFI, 0)
+	wf("SFI", q.SFI, 0)
-	writeField(bw, "SKCC", q.SKCC)
+	w("SKCC", q.SKCC)
-	writeField(bw, "FISTS", q.FISTS)
+	w("FISTS", q.FISTS)
-	writeField(bw, "TEN_TEN", q.TenTen)
+	w("TEN_TEN", q.TenTen)
-	writeField(bw, "CONTACTED_OP", q.ContactedOp)
+	w("CONTACTED_OP", q.ContactedOp)
-	writeField(bw, "EQ_CALL", q.EqCall)
+	w("EQ_CALL", q.EqCall)
-	writeField(bw, "PFX", q.PFX)
+	w("PFX", q.PFX)
-	writeField(bw, "MY_NAME", q.MyName)
+	w("MY_NAME", q.MyName)
-	writeField(bw, "CLASS", q.Class)
+	w("CLASS", q.Class)
-	writeField(bw, "DARC_DOK", q.DarcDOK)
+	w("DARC_DOK", q.DarcDOK)
-	writeField(bw, "MY_DARC_DOK", q.MyDarcDOK)
+	w("MY_DARC_DOK", q.MyDarcDOK)
-	writeField(bw, "REGION", q.Region)
+	w("REGION", q.Region)
-	writeField(bw, "SILENT_KEY", q.SilentKey)
+	w("SILENT_KEY", q.SilentKey)
-	writeField(bw, "SWL", q.SWL)
+	w("SWL", q.SWL)
-	writeField(bw, "QSO_COMPLETE", q.QSOComplete)
+	w("QSO_COMPLETE", q.QSOComplete)
-	writeField(bw, "QSO_RANDOM", q.QSORandom)
+	w("QSO_RANDOM", q.QSORandom)
-	writeField(bw, "CREDIT_GRANTED", q.CreditGranted)
+	w("CREDIT_GRANTED", q.CreditGranted)
-	writeField(bw, "CREDIT_SUBMITTED", q.CreditSubmitted)
+	w("CREDIT_SUBMITTED", q.CreditSubmitted)
-	writeField(bw, "MY_ARRL_SECT", q.MyARRLSect)
+	w("MY_ARRL_SECT", q.MyARRLSect)
-	writeField(bw, "MY_VUCC_GRIDS", q.MyVUCCGrids)
+	w("MY_VUCC_GRIDS", q.MyVUCCGrids)
 
 	// --- Extras (unpromoted ADIF fields preserved verbatim) ---
 	// Standard mode emits ONLY valid ADIF-spec fields, so it drops APP_*
@@ -318,7 +344,12 @@ func writeRecord(bw *bufio.Writer, q qso.QSO, includeApp bool) {
 	// extra for a lossless OpsLog round-trip.
 	for k, v := range q.Extras {
 		tag := strings.ToUpper(k)
-		if !includeApp && (strings.HasPrefix(tag, "APP_") || !IsStandardField(tag)) {
+		if allow != nil {
+			// Chosen-fields mode: the set alone decides (incl. APP_/vendor tags).
+			if !allow[tag] {
+				continue
+			}
+		} else if !includeApp && (strings.HasPrefix(tag, "APP_") || !IsStandardField(tag)) {
 			continue
 		}
 		writeField(bw, tag, v)

internal/adif/roundtrip_test.go

@@ -34,7 +34,7 @@ func TestPromotedFieldsRoundTrip(t *testing.T) {
 	var buf bytes.Buffer
 	bw := bufio.NewWriter(&buf)
 	bw.WriteString("<EOH>\n")
-	writeRecord(bw, in, true)
+	writeRecord(bw, in, true, nil)
 	bw.Flush()
 
 	var rec Record
@@ -115,7 +115,7 @@ func TestStandardExportDropsNonStandard(t *testing.T) {
 func renderRecord(q qso.QSO, includeApp bool) string {
 	var buf bytes.Buffer
 	bw := bufio.NewWriter(&buf)
-	writeRecord(bw, q, includeApp)
+	writeRecord(bw, q, includeApp, nil)
 	bw.Flush()
 	return buf.String()
 }

internal/award/catalog/h26.json

@@ -0,0 +1,260 @@
+{
+  "def": {
+    "code": "H26",
+    "name": "The Helvetia 26 Award HF",
+    "description": "26 Cantons of Switzerland",
+    "valid": true,
+    "url": "https://uska.ch/en/contest/uska-diplome/",
+    "ref_url": "https://uska.ch/en/contest/uska-diplome/",
+    "valid_from": "1980-01-01",
+    "valid_to": "9999-12-01",
+    "ref_display": "name",
+    "type": "QSOFIELDS",
+    "field": "address",
+    "match_by": "description",
+    "pattern": "",
+    "or_rules": [
+      {
+        "field": "qth",
+        "match_by": "description"
+      }
+    ],
+    "dxcc_filter": [
+      287
+    ],
+    "valid_bands": [
+      "2190m",
+      "630m",
+      "160m",
+      "80m",
+      "40m",
+      "30m",
+      "20m",
+      "17m",
+      "15m",
+      "12m",
+      "10m"
+    ],
+    "confirm": [
+      "lotw",
+      "qsl"
+    ],
+    "validate": [
+      "lotw",
+      "qsl"
+    ],
+    "total": 0,
+    "builtin": true,
+    "version": 1
+  },
+  "references": [
+    {
+      "code": "AG",
+      "name": "Aargau",
+      "dxcc": 287,
+      "group": "",
+      "subgrp": "",
+      "valid": true
+    },
+    {
+      "code": "AI",
+      "name": "Appenzell Innerrhoden",
+      "dxcc": 287,
+      "group": "",
+      "subgrp": "",
+      "valid": true
+    },
+    {
+      "code": "AR",
+      "name": "Appenzell Ausserrhoden",
+      "dxcc": 287,
+      "group": "",
+      "subgrp": "",
+      "valid": true
+    },
+    {
+      "code": "BE",
+      "name": "Bern",
+      "dxcc": 287,
+      "group": "",
+      "subgrp": "",
+      "valid": true
+    },
+    {
+      "code": "BL",
+      "name": "Basel-Landschaft",
+      "dxcc": 287,
+      "group": "",
+      "subgrp": "",
+      "valid": true
+    },
+    {
+      "code": "BS",
+      "name": "Basel-Stadt",
+      "dxcc": 287,
+      "group": "",
+      "subgrp": "",
+      "valid": true
+    },
+    {
+      "code": "FR",
+      "name": "Fribourg",
+      "dxcc": 287,
+      "group": "",
+      "subgrp": "",
+      "valid": true
+    },
+    {
+      "code": "GE",
+      "name": "Geneva",
+      "dxcc": 287,
+      "group": "",
+      "subgrp": "",
+      "valid": true
+    },
+    {
+      "code": "GL",
+      "name": "Glarus",
+      "dxcc": 287,
+      "group": "",
+      "subgrp": "",
+      "valid": true
+    },
+    {
+      "code": "GR",
+      "name": "Graubünden (Grisons)",
+      "dxcc": 287,
+      "group": "",
+      "subgrp": "",
+      "valid": true
+    },
+    {
+      "code": "JU",
+      "name": "Jura",
+      "dxcc": 287,
+      "group": "",
+      "subgrp": "",
+      "valid": true
+    },
+    {
+      "code": "LU",
+      "name": "Lucerne",
+      "dxcc": 287,
+      "group": "",
+      "subgrp": "",
+      "valid": true
+    },
+    {
+      "code": "NE",
+      "name": "Neuchâtel",
+      "dxcc": 287,
+      "group": "",
+      "subgrp": "",
+      "valid": true
+    },
+    {
+      "code": "NW",
+      "name": "Nidwalden",
+      "dxcc": 287,
+      "group": "",
+      "subgrp": "",
+      "valid": true
+    },
+    {
+      "code": "OW",
+      "name": "Obwalden",
+      "dxcc": 287,
+      "group": "",
+      "subgrp": "",
+      "valid": true
+    },
+    {
+      "code": "SG",
+      "name": "St. Gallen",
+      "dxcc": 287,
+      "group": "",
+      "subgrp": "",
+      "valid": true
+    },
+    {
+      "code": "SH",
+      "name": "Schaffhausen",
+      "dxcc": 287,
+      "group": "",
+      "subgrp": "",
+      "valid": true
+    },
+    {
+      "code": "SO",
+      "name": "Solothurn",
+      "dxcc": 287,
+      "group": "",
+      "subgrp": "",
+      "valid": true
+    },
+    {
+      "code": "SZ",
+      "name": "Schwyz",
+      "dxcc": 287,
+      "group": "",
+      "subgrp": "",
+      "valid": true
+    },
+    {
+      "code": "TG",
+      "name": "Thurgau",
+      "dxcc": 287,
+      "group": "",
+      "subgrp": "",
+      "valid": true
+    },
+    {
+      "code": "TI",
+      "name": "Ticino",
+      "dxcc": 287,
+      "group": "",
+      "subgrp": "",
+      "valid": true
+    },
+    {
+      "code": "UR",
+      "name": "Uri",
+      "dxcc": 287,
+      "group": "",
+      "subgrp": "",
+      "valid": true
+    },
+    {
+      "code": "VD",
+      "name": "Vaud",
+      "dxcc": 287,
+      "group": "",
+      "subgrp": "",
+      "valid": true
+    },
+    {
+      "code": "VS",
+      "name": "Valais",
+      "dxcc": 287,
+      "group": "",
+      "subgrp": "",
+      "valid": true
+    },
+    {
+      "code": "ZG",
+      "name": "Zug",
+      "dxcc": 287,
+      "group": "",
+      "subgrp": "",
+      "valid": true
+    },
+    {
+      "code": "ZH",
+      "name": "Zurich",
+      "dxcc": 287,
+      "group": "",
+      "subgrp": "",
+      "valid": true
+    }
+  ]
+}

internal/cat/flex.go

@@ -1889,15 +1889,11 @@ func (f *Flex) SetTune(on bool) error {
 // SmartSDR refuses to transmit while inhibit is set, so it holds even against a
 // footswitch or an external keyer, which a software PTT block could not.
 //
-// It also labels the interlock reason "OpsLog" so SmartSDR shows WHY TX is
+// `transmit set inhibit=` is the whole mechanism. We used to also send
-// blocked. The reason is best-effort (a separate interlock object); the inhibit
+// `interlock set reason=OpsLog` to label WHY TX was blocked, but `reason` is a
-// is what actually blocks TX, so a rig that ignores the reason still stays safe.
+// read-only status field on the interlock object — writing it is rejected
+// (cmd error 5000002D on SmartSDR v1.4/v3) and does nothing, so it's dropped.
 func (f *Flex) SetTXInhibit(on bool) error {
-	if on {
-		f.send("interlock set reason=OpsLog")
-	} else {
-		f.send("interlock set reason=")
-	}
 	return f.txSet("transmit set inhibit="+boolFlex(on), "inhibit", func(t *flexTX) { t.inhibit = on })
 }
 

internal/cat/icomserial.go

@@ -224,11 +224,14 @@ func (b *IcomSerial) Connect() error {
 			idAddr = f.Data[1]
 		}
 	}
-	// Dual-scope rigs (IC-7610/9700) prefix each waveform frame with a main/sub
+	// Whether the rig's scope protocol carries a leading main/sub SELECTOR byte on
-	// selector byte; single-scope rigs (IC-7300…) do not. Decide from the
+	// every 0x27 frame and command. The IC-7610/9700 (dual scope) do — and the logs
-	// IDENTIFIED model, NOT the configured address: an IC-7300 run at 0x98 must
+	// prove the IC-7300 does too (frames arrive as `27 00 00 <seq> <total> …` and a
-	// still parse single-scope frames (this was the "scope blank on the 7300" bug).
+	// mode read answers `27 14 00 <mode>`), even though it has a single scope. The
-	b.dualScope = idAddr == 0x98 || idAddr == 0xA2
+	// waveform parser auto-detects this per-frame regardless, so a 7300 at a
+	// non-default address still RENDERS; this flag only drives the SET/read commands
+	// (mode, span, edges), which need the 0x00 selector to be accepted on the 7300.
+	b.dualScope = idAddr == 0x98 || idAddr == 0xA2 || idAddr == 0x94
 	// Defer the DSP snapshot until the rig actually answers CI-V. Over the network
 	// the rig may still be booting (or off) at Connect, so an immediate readDSP
 	// would time out and leave every control at 0 / off with no retry. ReadState
@@ -603,12 +606,20 @@ func (b *IcomSerial) scopeLoop(spec chan civ.Decoded, done chan struct{}) {
 				rawN++
 				applog.Printf("icom scope raw #%d: len=%d data=[% X]", rawN, len(f.Data), f.Data)
 			}
+			// Frame layout after the 0x00 sub-command byte is one of:
+			//   [selector][seq][total][data…]  (IC-7610/9700 AND, as the logs prove,
+			//                                    the IC-7300 — selector 0x00 = main)
+			//   [seq][total][data…]             (a rig with no selector byte)
+			// The sequence starts at 1, so a 0x00 at Data[1] can only be the main-scope
+			// selector — never a valid sequence. Keying this off the rig ADDRESS was the
+			// long-standing "blank scope on the IC-7300" bug: the 7300 DOES send the
+			// selector, so idx stayed 1, seq was read as 0x00, and every frame was
+			// dropped. Detect it from the byte itself instead — address-independent.
 			idx := 1
-			if b.dualScope {
+			if len(f.Data) >= 2 && f.Data[1] == 0x00 {
-				if len(f.Data) < 2 || f.Data[1] != 0x00 {
+				idx = 2 // leading main-scope selector byte present
-					continue // only the MAIN scope
+			} else if b.dualScope {
-				}
+				continue // dual-scope rig SUB frame (selector != 0x00) — main only
-				idx = 2
 			}
 			if len(f.Data) < idx+2 {
 				continue
@@ -725,12 +736,19 @@ func (b *IcomSerial) SetScope(on bool) error {
 		// but nothing shows, compare its `icom scope raw` frames against this.
 		applog.Printf("icom scope: enable on rig=%q addr=0x%02X dualScope=%v (expect %s frame layout)",
 			b.model, b.rigAddr, b.dualScope, map[bool]string{true: "27 00 [MS] [seq] [total] …", false: "27 00 [seq] [total] …"}[b.dualScope])
+		// Turn the scope DISPLAY on — needed so the rig actually streams (esp. when
+		// remote and we can't touch the front panel). ONLY on enable: we must never
+		// switch the display OFF, because that is the operator's own scope on the
+		// radio, and closing OpsLog (SetScope(false)) blanking a local IC-7300's
+		// screen is exactly the regression this avoids. Some firmwares don't ack a
+		// 0x27 set; a timeout isn't fatal, so log and continue.
+		if err := b.exec(civ.CmdScope, civ.SubScopeOnOff, 0x01); err != nil {
+			applog.Printf("icom scope: display on ack: %v", err)
 		}
-	// Some firmwares don't ack 0x27 sets; a timeout here isn't fatal, so log and
-	// continue rather than abort the second command.
-	if err := b.exec(civ.CmdScope, civ.SubScopeOnOff, boolByte(on)); err != nil {
-		applog.Printf("icom scope: display on=%v ack: %v", on, err)
 	}
+	// Waveform data OUTPUT over CI-V: enabled with the scope, and — crucially —
+	// the ONLY thing we switch off on disable, so the radio's own scope display is
+	// left exactly as the operator had it.
 	if err := b.exec(civ.CmdScope, civ.SubScopeOn, boolByte(on)); err != nil {
 		applog.Printf("icom scope: output on=%v ack: %v", on, err)
 	}

internal/cat/omnirig.go

@@ -267,12 +267,23 @@ func (o *OmniRig) SetFrequency(hz int64) error {
 	// method (RX=TX=freq, simplex). It works on rigs — notably Icom (IC-9100) —
 	// where direct FreqA/FreqB writes are accepted but never move the radio.
 	// Clearing split is the right thing when tuning to a spot anyway.
+	simplexOK := false
 	if _, err := oleutil.CallMethod(o.rig, "SetSimplexMode", int32(hz32)); err == nil {
+		simplexOK = true
 		debugLog.Printf("OmniRig.SetFrequency: SetSimplexMode(%d) OK", hz32)
 	} else {
-		debugLog.Printf("OmniRig.SetFrequency: SetSimplexMode unavailable (%v) — using property writes", err)
+		debugLog.Printf("OmniRig.SetFrequency: SetSimplexMode unavailable (%v)", err)
-		// Fallback: write the active VFO's property AND the generic Freq
+	}
-		// (always — some .ini honour only one, and split here is often misread).
+
+	// On Yaesu / Kenwood (and anything non-Icom), SetSimplexMode frequently returns
+	// OK but is a SILENT NO-OP — the rig never moves. Confirmed on an FT-891 over
+	// OmniRig: every spot click logged "SetSimplexMode OK" yet FreqA stayed put,
+	// while SetMode on the same .ini worked fine (so the CAT link is healthy).
+	// Writing the VFO frequency PROPERTY directly DOES move them, so also do that
+	// here. It is skipped on Icom, where the direct write is the unreliable one and
+	// could nudge the wrong Main/Sub VFO — there SetSimplexMode is authoritative.
+	isIcom := strings.HasPrefix(strings.ToUpper(strings.TrimSpace(rigType)), "IC")
+	if !isIcom || !simplexOK {
 		prop := "FreqA"
 		switch vfo {
 		case "B", "BB", "BA":
@@ -287,7 +298,7 @@ func (o *OmniRig) SetFrequency(hz int64) error {
 				okAny = true
 			}
 		}
-		if !okAny {
+		if !simplexOK && !okAny {
 			return fmt.Errorf("OmniRig: no writable frequency property for this rig")
 		}
 	}

internal/clublog/mostwanted.go

@@ -0,0 +1,194 @@
+package clublog
+
+// mostwanted.go — the ClubLog "Most Wanted" DXCC ranking. ClubLog publishes, per
+// callsign, how wanted each DXCC entity is (rank 1 = the single most wanted, e.g.
+// P5 North Korea). We fetch it, invert it to a DXCC-number → rank map, cache it on
+// disk (personalised to the operator's callsign) and refresh daily. The rank is
+// surfaced next to the entity in the entry-strip band/slot matrix.
+//
+// Endpoint (same one DXHunter uses): mostwanted.php?api=1 returns JSON
+//   { "1": "344", "2": "123", ... }   rank → ADIF (DXCC) number
+// Passing &callsign=<CALL> personalises the ranking to that operator's log.
+// api=1 is just the "return JSON" flag — no API key is needed here.
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+)
+
+const mwURL = "https://clublog.org/mostwanted.php?api=1"
+const mwFile = "clublog_mostwanted.json"
+
+// mwUserAgent — ClubLog's nginx 403s the default Go user-agent, so set a real one.
+const mwUserAgent = "OpsLog (amateur radio logger)"
+
+// mwCache is the on-disk shape (ranks keyed by DXCC number as a string for JSON).
+type mwCache struct {
+	Callsign  string         `json:"callsign"`
+	FetchedAt time.Time      `json:"fetched_at"`
+	Ranks     map[string]int `json:"ranks"`
+}
+
+// MostWanted owns the on-disk cache and the parsed DXCC-number → rank map.
+type MostWanted struct {
+	dir string
+
+	mu      sync.RWMutex
+	ranks   map[int]int // dxcc number → rank (1 = most wanted)
+	call    string      // callsign the current ranks were fetched for
+	fetched time.Time
+}
+
+func NewMostWanted(dataDir string) *MostWanted {
+	return &MostWanted{dir: dataDir, ranks: map[int]int{}}
+}
+
+func (m *MostWanted) path() string { return filepath.Join(m.dir, mwFile) }
+
+// Rank returns the most-wanted rank for a DXCC number, or 0 if unknown/unloaded.
+func (m *MostWanted) Rank(dxcc int) int {
+	if dxcc <= 0 {
+		return 0
+	}
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	return m.ranks[dxcc]
+}
+
+// Ranks returns a copy of the whole DXCC-number → rank map.
+func (m *MostWanted) Ranks() map[int]int {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	out := make(map[int]int, len(m.ranks))
+	for k, v := range m.ranks {
+		out[k] = v
+	}
+	return out
+}
+
+// Info reports the callsign the list was fetched for, its date, and entity count.
+func (m *MostWanted) Info() (call, date string, count int) {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	d := ""
+	if !m.fetched.IsZero() {
+		d = m.fetched.Format("2006-01-02")
+	}
+	return m.call, d, len(m.ranks)
+}
+
+func (m *MostWanted) Loaded() bool {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	return len(m.ranks) > 0
+}
+
+// LoadFromDisk reads the cached JSON into memory. Does NOT download.
+func (m *MostWanted) LoadFromDisk() error {
+	b, err := os.ReadFile(m.path())
+	if err != nil {
+		return err
+	}
+	var c mwCache
+	if err := json.Unmarshal(b, &c); err != nil {
+		return err
+	}
+	ranks := make(map[int]int, len(c.Ranks))
+	for k, v := range c.Ranks {
+		if n, err := strconv.Atoi(k); err == nil && n > 0 && v > 0 {
+			ranks[n] = v
+		}
+	}
+	m.mu.Lock()
+	m.ranks = ranks
+	m.call = c.Callsign
+	m.fetched = c.FetchedAt
+	m.mu.Unlock()
+	return nil
+}
+
+// NeedsRefresh reports whether the list is empty, older than maxAge, or was
+// fetched for a DIFFERENT callsign (the ranking is personalised, so a profile
+// switch invalidates it).
+func (m *MostWanted) NeedsRefresh(callsign string, maxAge time.Duration) bool {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	if len(m.ranks) == 0 {
+		return true
+	}
+	if !strings.EqualFold(strings.TrimSpace(callsign), m.call) {
+		return true
+	}
+	return time.Since(m.fetched) > maxAge
+}
+
+// Download fetches the most-wanted list for callsign, writes it atomically, and
+// swaps it into memory.
+func (m *MostWanted) Download(ctx context.Context, callsign string) error {
+	if err := os.MkdirAll(m.dir, 0o755); err != nil {
+		return err
+	}
+	call := strings.ToUpper(strings.TrimSpace(callsign))
+	url := mwURL
+	if call != "" {
+		url += "&callsign=" + call
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
+	if err != nil {
+		return err
+	}
+	req.Header.Set("User-Agent", mwUserAgent)
+	client := &http.Client{Timeout: 30 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return fmt.Errorf("download: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("clublog mostwanted HTTP %d", resp.StatusCode)
+	}
+	body, err := io.ReadAll(io.LimitReader(resp.Body, 1<<20))
+	if err != nil {
+		return err
+	}
+	// { "1": "344", "2": "123", ... } — rank → ADIF (DXCC) number.
+	var raw map[string]string
+	if err := json.Unmarshal(body, &raw); err != nil {
+		return fmt.Errorf("clublog mostwanted parse: %w", err)
+	}
+	ranks := make(map[int]int, len(raw))
+	strRanks := make(map[string]int, len(raw))
+	for rankStr, adif := range raw {
+		rank, e1 := strconv.Atoi(strings.TrimSpace(rankStr))
+		dxcc, e2 := strconv.Atoi(strings.TrimSpace(adif))
+		if e1 == nil && e2 == nil && rank > 0 && dxcc > 0 {
+			ranks[dxcc] = rank
+			strRanks[adif] = rank
+		}
+	}
+	if len(ranks) == 0 {
+		return fmt.Errorf("clublog mostwanted: empty/invalid response")
+	}
+	now := time.Now()
+	if b, err := json.Marshal(mwCache{Callsign: call, FetchedAt: now, Ranks: strRanks}); err == nil {
+		tmp := m.path() + ".tmp"
+		if os.WriteFile(tmp, b, 0o644) == nil {
+			_ = os.Rename(tmp, m.path())
+		}
+	}
+	m.mu.Lock()
+	m.ranks = ranks
+	m.call = call
+	m.fetched = now
+	m.mu.Unlock()
+	return nil
+}

internal/cwdecode/cwdecode.go

@@ -0,0 +1,697 @@
+// Package cwdecode is a real-time CW (Morse) decoder: it turns a stream of
+// mono PCM samples into decoded text.
+//
+// This is the second generation of the decoder. The first one worked on clean
+// machine keying but fell apart on real signals; every stage below exists to
+// fix a specific failure of that version (and of naïve Goertzel decoders in
+// general):
+//
+//	audio ─ Hamming-windowed Goertzel bank ─ pitch lock ─ dB envelope with
+//	separate noise-floor / peak trackers ─ hysteresis slicer + SNR squelch ─
+//	DEBOUNCED mark/space stream ─ two-cluster dit/dah length tracking ─
+//	element / character / word segmentation ─ Morse table ─ text
+//
+// The fixes that matter, in order of impact:
+//
+//  1. Debounced transitions BOTH ways. The old decoder rejected too-short
+//     marks but not too-short SPACES, so a one-hop fade inside a dah (QSB,
+//     static crash) split it into two dits — the single biggest source of
+//     garbage on real signals. Here a state flip must persist for a glitch
+//     time (~0.3 dit) before it is committed; shorter flips are folded back
+//     into the surrounding element.
+//
+//  2. Two-cluster timing. Dit and dah lengths are tracked as two separate
+//     moving centres with the decision boundary at their geometric mean,
+//     instead of one EMA "dot length" that both classifies marks and is
+//     updated by that same classification (a feedback loop that spiralled to
+//     "all dits at 60 WPM" the moment it started mis-classifying). The
+//     inter-element gaps also feed the dit centre — spaces are timing
+//     evidence too, and hand keying is often more regular in its gaps than
+//     in its dits.
+//
+//  3. dB-domain envelope. Peak and noise floor are tracked in dB with
+//     asymmetric attack/decay, the slicer runs at 55%/38% of the span with
+//     hysteresis, and a minimum-span squelch (6 dB) keeps pure noise from
+//     keying at all. In the old linear-magnitude scheme weak signals lived
+//     in the bottom few percent of the scale and QSB swallowed them.
+//
+//  4. Windowed Goertzel. A Hamming window tames spectral leakage so a strong
+//     tone doesn't bleed across the whole bank and corrupt both the noise
+//     estimate and the lock choice.
+//
+// Kept from the first version because they were right: the pitch LOCK (decode
+// one tone, ignore QRM at other pitches), pitch targeting (follow the radio's
+// known CW pitch instead of searching — SetTarget), tiered acquisition
+// (strong signals lock on the first hop so their opening dit isn't eaten),
+// the floor frozen during key-down (a rising floor mid-dah fragments it), and
+// the end-of-over flush when the lock releases.
+//
+// Deliberately dependency-free and fed by plain []int16 so the whole pipeline
+// is unit-tested with synthetic signals (see cwdecode_test.go: clean keying at
+// several speeds, added noise, QSB fading, QRM on a nearby pitch, and a
+// noise-only squelch test).
+//
+// Honest expectations: on clean or moderately noisy signals this decodes
+// solidly; very weak signals in heavy QRM remain hard for any envelope
+// decoder — the tools that shine there (CW Skimmer, SDC) use probabilistic
+// sequence estimation on top. This stage is designed so such a layer could be
+// added later without touching the DSP.
+package cwdecode
+
+import (
+	"math"
+	"sort"
+	"sync/atomic"
+)
+
+// Status is a periodic snapshot for the UI (pitch lock, speed, signal).
+type Status struct {
+	WPM    int     `json:"wpm"`
+	Pitch  int     `json:"pitch"`  // Hz of the locked tone (0 = not locked)
+	Level  float64 `json:"level"`  // 0..1 input audio level (RMS) for the meter
+	Active bool    `json:"active"` // a tone is currently keyed down
+}
+
+// Decoder consumes PCM and emits decoded characters via onChar (one or more
+// characters at a time, including " " for word gaps) and periodic onStatus.
+// Process must be called from a single goroutine; SetTarget is safe to call
+// concurrently.
+type Decoder struct {
+	fs     int
+	hop    int     // samples between analyses (~6 ms)
+	win    int     // Goertzel window length (~20 ms)
+	hopMs  float64 // hop duration in ms
+	biasMs float64 // envelope widening caused by the analysis window (see below)
+
+	window []float64 // Hamming window, len win
+	ring   []float64 // circular raw-sample buffer, len win
+	rpos   int       // next write position in ring
+	filled int       // samples written so far (until >= win)
+	acc    int       // samples since last analysis
+
+	ws []float64 // scratch: windowed samples for this hop
+
+	// Search bank (only run while unlocked / untargeted).
+	freqs  []float64
+	coeffs []float64
+	mags   []float64 // dB per bin
+	nbuf   []float64 // scratch for the median
+
+	// Fixed-pitch target (Hz). 0 = auto-search; >0 = decode exactly this pitch
+	// and ignore everything else (e.g. follow the radio's CW pitch). Set live
+	// from another goroutine, so it's atomic.
+	targetHz    atomic.Int32
+	targetFor   float64 // freq the cached target coeff was computed for
+	targetCoeff float64
+
+	// Pitch lock.
+	lockIdx    int // bin index while auto-locked; -1 = unlocked
+	candIdx    int
+	candHops   int
+	quietHops  int // consecutive key-up hops while locked (drives release)
+	bankTick   int // hops since the bank last ran while locked
+	betterHops int // evidence that a different bin is the real signal
+
+	// Envelope (dB domain) on the locked/target tone.
+	floorDB, peakDB float64
+	bankNoiseDB     float64 // broadband reference: EMA of the bank median
+	haveBankNoise   bool
+	envSeeded       bool
+	rawKey          bool // slicer output this hop
+
+	// Debounced mark/space state machine.
+	key        bool // committed state (true = mark)
+	stableHops int  // hops in the committed state
+	pendHops   int  // consecutive hops the raw state has disagreed
+
+	// Two-cluster element timing (ms).
+	muDit, muDah float64
+	marksSeen    int
+
+	// Character assembly. Element DURATIONS are stored and only classified
+	// into dits/dahs when the character is flushed: by then the character's
+	// own marks are all known, and a bimodal batch carries its own dit/dah
+	// boundary — so even the very first character of an over decodes
+	// correctly at any speed, before the global clusters have converged.
+	elemMs      []float64
+	charEmitted bool
+	wordEmitted bool
+	textSince   bool // something was decoded since lock (guards leading spaces)
+
+	lastPitch float64
+	lastRMS   float64
+
+	statusEvery int
+	sinceStatus int
+
+	onChar   func(string)
+	onStatus func(Status)
+}
+
+var morse = map[string]byte{
+	".-": 'A', "-...": 'B', "-.-.": 'C', "-..": 'D', ".": 'E', "..-.": 'F',
+	"--.": 'G', "....": 'H', "..": 'I', ".---": 'J', "-.-": 'K', ".-..": 'L',
+	"--": 'M', "-.": 'N', "---": 'O', ".--.": 'P', "--.-": 'Q', ".-.": 'R',
+	"...": 'S', "-": 'T', "..-": 'U', "...-": 'V', ".--": 'W', "-..-": 'X',
+	"-.--": 'Y', "--..": 'Z',
+	"-----": '0', ".----": '1', "..---": '2', "...--": '3', "....-": '4',
+	".....": '5', "-....": '6', "--...": '7', "---..": '8', "----.": '9',
+	".-.-.-": '.', "--..--": ',', "..--..": '?', "-..-.": '/', "-...-": '=',
+	".-.-.": '+', "-.-.--": '!', "---...": ':', "-....-": '-', ".--.-.": '@',
+}
+
+// Tunables (hops are ~6 ms).
+const (
+	minDitMs = 20.0  // 60 WPM ceiling
+	maxDitMs = 240.0 // 5 WPM floor
+	seedDit  = 60.0  // 20 WPM seed before any marks are seen
+
+	acqStrongDB = 12.0 // lock on the FIRST hop above this SNR (don't eat the opening dit)
+	acqWeakDB   = 8.5  // lock after sustained hops above this SNR
+	// Successive analysis windows overlap ~70%, so consecutive hops are highly
+	// correlated — a noise spike easily "persists" 2–3 hops. Requiring ~2 full
+	// window lengths of persistence makes a false noise lock genuinely rare.
+	acqWeakHops = 6
+
+	squelchDB = 6.0 // minimum peak-floor span to key at all
+	// The span alone can't reject pure noise: a noise bin's dB level swings
+	// ±5–6 dB, which the peak/floor trackers happily turn into a keyable
+	// span. The second squelch is ABSOLUTE: the envelope peak must stand well
+	// above the broadband noise reference (the bank median) — a keyed tone
+	// does, noise never sustainably does.
+	snrSquelchDB = 9.5
+
+	// The slicer's span is CAPPED: with a very quiet background (high SNR, or
+	// digitally silent test signals) the raw floor sits so far below the peak
+	// that the off-threshold lands in the analysis window's skirts — every
+	// mark then stretches by almost a full window and every gap shrinks,
+	// until character gaps fall below the segmentation threshold and letters
+	// merge. Capping the usable span keeps the slicer crossing near the
+	// signal edges regardless of how quiet the background is.
+	spanCapDB = 30.0
+
+	onFrac  = 0.55 // slicer thresholds as a fraction of the (capped) span…
+	offFrac = 0.38 // …with hysteresis
+
+	charGapDits = 2.2 // gap > this ⇒ character boundary (geom. mean of 1 & 3 ≈ 1.7, plus margin for sloppy fists)
+	wordGapDits = 4.6 // gap > this ⇒ word boundary (geom. mean of 3 & 7)
+)
+
+// New builds a decoder for the given sample rate. onChar receives decoded text
+// incrementally; onStatus receives ~10 snapshots/second. Either may be nil.
+func New(sampleRate int, onChar func(string), onStatus func(Status)) *Decoder {
+	if sampleRate <= 0 {
+		sampleRate = 16000
+	}
+	d := &Decoder{
+		fs:       sampleRate,
+		hop:      sampleRate * 5 / 1000,  // 5 ms — resolves dits up to ~50 WPM
+		win:      sampleRate * 16 / 1000, // 16 ms window (≈80 Hz bandwidth with Hamming; a 20 ms window left 40 WPM inter-element gaps with almost no envelope dip)
+		lockIdx:  -1,
+		candIdx:  -1,
+		muDit:    seedDit,
+		muDah:    3 * seedDit,
+		onChar:   onChar,
+		onStatus: onStatus,
+	}
+	if d.hop < 1 {
+		d.hop = 1
+	}
+	if d.win < 4*d.hop {
+		d.win = 4 * d.hop
+	}
+	d.hopMs = float64(d.hop) / float64(d.fs) * 1000
+	// Even with the span cap, the analysis window widens every mark and
+	// narrows every gap by roughly half a window on each edge (the tone leaks
+	// into windows that straddle an edge). Durations are de-biased by this
+	// constant so the timing clusters and gap thresholds see true lengths.
+	d.biasMs = 0.6 * float64(d.win) / float64(d.fs) * 1000
+	d.statusEvery = int(math.Max(1, 100/d.hopMs)) // ~10 Hz
+	d.ring = make([]float64, d.win)
+	d.ws = make([]float64, d.win)
+	// Hamming window: −43 dB sidelobes keep a strong tone from bleeding across
+	// the bank (rectangular Goertzel leaks at −13 dB, enough to fool the lock).
+	d.window = make([]float64, d.win)
+	for i := range d.window {
+		d.window[i] = 0.54 - 0.46*math.Cos(2*math.Pi*float64(i)/float64(d.win-1))
+	}
+	// Candidate CW tones: 400–1000 Hz every 30 Hz. Deliberately NOT lower:
+	// low-frequency hum/rumble rises toward DC and would win the argmax.
+	for f := 400.0; f <= 1000.0; f += 30 {
+		d.freqs = append(d.freqs, f)
+		d.coeffs = append(d.coeffs, 2*math.Cos(2*math.Pi*f/float64(d.fs)))
+	}
+	d.mags = make([]float64, len(d.freqs))
+	d.nbuf = make([]float64, len(d.freqs))
+	return d
+}
+
+// SetTarget fixes the decode pitch to hz (an exact-frequency detector, not the
+// nearest search bin), or returns to auto-search when hz <= 0. Safe to call
+// concurrently.
+func (d *Decoder) SetTarget(hz int) { d.targetHz.Store(int32(hz)) }
+
+// Reset clears decode state (e.g. when the user re-arms the decoder).
+func (d *Decoder) Reset() {
+	d.rpos, d.filled, d.acc = 0, 0, 0
+	d.lockIdx, d.candIdx, d.candHops, d.quietHops = -1, -1, 0, 0
+	d.envSeeded, d.rawKey, d.key = false, false, false
+	d.haveBankNoise = false
+	d.stableHops, d.pendHops = 0, 0
+	d.bankTick, d.betterHops = 0, 0
+	d.muDit, d.muDah, d.marksSeen = seedDit, 3*seedDit, 0
+	d.elemMs = d.elemMs[:0]
+	d.charEmitted, d.wordEmitted, d.textSince = true, true, false
+}
+
+// Process feeds a block of mono samples through the decoder.
+func (d *Decoder) Process(samples []int16) {
+	for _, s := range samples {
+		d.ring[d.rpos] = float64(s)
+		d.rpos++
+		if d.rpos == d.win {
+			d.rpos = 0
+		}
+		if d.filled < d.win {
+			d.filled++
+		}
+		d.acc++
+		if d.acc >= d.hop && d.filled >= d.win {
+			d.acc = 0
+			d.hopStep()
+		}
+	}
+}
+
+// goertzelDB returns the tone power (dB, arbitrary reference) of the windowed
+// scratch buffer at the detector coefficient c.
+func (d *Decoder) goertzelDB(c float64) float64 {
+	var s1, s2 float64
+	for _, x := range d.ws {
+		s0 := x + c*s1 - s2
+		s2 = s1
+		s1 = s0
+	}
+	p := s1*s1 + s2*s2 - c*s1*s2
+	if p < 1e-12 {
+		p = 1e-12
+	}
+	return 10 * math.Log10(p)
+}
+
+// hopStep runs one analysis hop: tone detection, envelope, slicer, timing.
+func (d *Decoder) hopStep() {
+	// Materialize the window (oldest→newest; order is irrelevant for power)
+	// and the RMS level for the UI meter.
+	var sumSq float64
+	for i := 0; i < d.win; i++ {
+		x := d.ring[(d.rpos+i)%d.win]
+		d.ws[i] = x * d.window[i]
+		sumSq += x * x
+	}
+	d.lastRMS = math.Min(1, math.Sqrt(sumSq/float64(d.win))/32768*4)
+
+	toneDB, haveTone := 0.0, false
+
+	if th := float64(d.targetHz.Load()); th > 0 {
+		// Fixed pitch: one exact-frequency detector, like a skimmer channel.
+		if th != d.targetFor {
+			d.targetFor = th
+			d.targetCoeff = 2 * math.Cos(2*math.Pi*th/float64(d.fs))
+			d.envSeeded = false // re-seed the envelope for the new channel
+		}
+		toneDB = d.goertzelDB(d.targetCoeff)
+		d.lastPitch = th
+		d.lockIdx = -1 // targeting supersedes the auto lock
+		haveTone = true
+		// Refresh the broadband noise reference for the absolute squelch.
+		d.bankTick++
+		if d.bankTick >= 8 {
+			d.bankTick = 0
+			for i, c := range d.coeffs {
+				d.mags[i] = d.goertzelDB(c)
+			}
+			copy(d.nbuf, d.mags)
+			sort.Float64s(d.nbuf)
+			d.updateBankNoise(d.nbuf[len(d.nbuf)/2])
+		}
+	} else if d.lockIdx >= 0 {
+		// Auto-locked: only the locked bin is needed per hop.
+		toneDB = d.goertzelDB(d.coeffs[d.lockIdx])
+		d.lastPitch = d.freqs[d.lockIdx]
+		haveTone = true
+		// Supervised re-lock: periodically sweep the whole bank anyway. If a
+		// clearly stronger tone lives on a DIFFERENT pitch and keeps doing so,
+		// the current lock is wrong (locked onto noise, or the operator moved)
+		// — jump to the real signal instead of decoding garbage until the
+		// quiet-release finally fires.
+		d.bankTick++
+		if d.bankTick >= 8 {
+			d.bankTick = 0
+			bestIdx, bestDB := -1, math.Inf(-1)
+			for i, c := range d.coeffs {
+				m := d.goertzelDB(c)
+				d.mags[i] = m
+				if i >= d.lockIdx-1 && i <= d.lockIdx+1 {
+					continue
+				}
+				if m > bestDB {
+					bestDB, bestIdx = m, i
+				}
+			}
+			copy(d.nbuf, d.mags)
+			sort.Float64s(d.nbuf)
+			d.updateBankNoise(d.nbuf[len(d.nbuf)/2])
+			if bestIdx >= 0 && bestDB > toneDB+6 {
+				d.betterHops += 2
+			} else if d.betterHops > 0 {
+				d.betterHops--
+			}
+			if d.betterHops >= 24 && bestIdx >= 0 { // ~12 confirmations over ~1 s
+				d.flushPending()
+				copy(d.nbuf, d.mags)
+				sort.Float64s(d.nbuf)
+				d.lockIdx = bestIdx
+				// Seed the envelope honestly: floor from the bank median, NOT
+				// peak−cap — fabricating a full span would let a noise re-lock
+				// key freely until the trackers converged.
+				d.floorDB, d.peakDB = d.nbuf[len(d.nbuf)/2], bestDB
+				d.quietHops, d.bankTick, d.betterHops = 0, 0, 0
+				d.marksSeen = 0
+				d.elemMs = d.elemMs[:0]
+				d.charEmitted, d.wordEmitted, d.textSince = true, true, false
+				d.key, d.stableHops, d.pendHops = false, 0, 0
+				toneDB = d.goertzelDB(d.coeffs[d.lockIdx])
+				d.lastPitch = d.freqs[d.lockIdx]
+			}
+		}
+	} else {
+		// Unlocked: run the whole bank, estimate noise, hunt for a tone.
+		maxIdx, maxDB := 0, math.Inf(-1)
+		for i, c := range d.coeffs {
+			m := d.goertzelDB(c)
+			d.mags[i] = m
+			if m > maxDB {
+				maxDB, maxIdx = m, i
+			}
+		}
+		copy(d.nbuf, d.mags)
+		sort.Float64s(d.nbuf)
+		noise := d.nbuf[len(d.nbuf)/2] // median: robust to a few strong tones
+		d.updateBankNoise(noise)
+		snr := maxDB - noise
+
+		near := d.candIdx >= 0 && maxIdx >= d.candIdx-1 && maxIdx <= d.candIdx+1
+		if near {
+			d.candHops++
+		} else {
+			d.candIdx, d.candHops = maxIdx, 1
+		}
+		// Tiered acquisition: a clearly strong tone locks on the FIRST hop (so
+		// its opening dit isn't eaten), a marginal one must persist a few hops
+		// (so we don't lock onto a noise spike).
+		if snr > acqStrongDB || (d.candHops >= acqWeakHops && snr > acqWeakDB) {
+			d.lockIdx = maxIdx
+			d.floorDB, d.peakDB = noise, maxDB
+			d.envSeeded = true
+			d.quietHops = 0
+			d.bankTick, d.betterHops = 0, 0
+			d.marksSeen = 0 // relearn speed quickly for this signal (keep muDit as seed)
+			d.elemMs = d.elemMs[:0]
+			d.charEmitted, d.wordEmitted, d.textSince = true, true, false
+			d.key, d.stableHops, d.pendHops = false, 0, 0
+			toneDB = maxDB
+			d.lastPitch = d.freqs[maxIdx]
+			haveTone = true
+		} else {
+			d.lastPitch = 0
+		}
+	}
+
+	if !haveTone {
+		d.rawKey = false
+		d.emitStatus()
+		return
+	}
+	if !d.envSeeded {
+		// First hop on a targeted channel: seed from the current reading.
+		d.floorDB, d.peakDB = toneDB, toneDB+squelchDB
+		d.envSeeded = true
+	}
+
+	// ---- Envelope: separate floor / peak trackers, dB domain. ----
+	// Floor drops fast, but only RISES while keyed up: a floor creeping up
+	// under a long dah shrinks the span until the dah fragments into dits.
+	if toneDB < d.floorDB {
+		d.floorDB += (toneDB - d.floorDB) * 0.3
+	} else if !d.rawKey {
+		d.floorDB += (toneDB - d.floorDB) * 0.015
+	}
+	// Peak attacks fast and decays slowly toward current conditions (~1.5 s),
+	// so QSB is followed without collapsing across ordinary word gaps.
+	if toneDB > d.peakDB {
+		d.peakDB += (toneDB - d.peakDB) * 0.4
+	} else {
+		d.peakDB += (toneDB - d.peakDB) * 0.004
+	}
+	if d.peakDB < d.floorDB {
+		d.peakDB = d.floorDB
+	}
+
+	// ---- Slicer with hysteresis + SNR squelch. ----
+	if d.peakDB-d.floorDB < squelchDB ||
+		(d.haveBankNoise && d.peakDB < d.bankNoiseDB+snrSquelchDB) {
+		d.rawKey = false
+	} else {
+		// Cap the usable span so the slicer crossings stay near the keying
+		// edges even over a dead-quiet background (see spanCapDB).
+		effFloor := math.Max(d.floorDB, d.peakDB-spanCapDB)
+		span := d.peakDB - effFloor
+		if d.rawKey {
+			d.rawKey = toneDB > effFloor+offFrac*span
+		} else {
+			d.rawKey = toneDB > effFloor+onFrac*span
+		}
+	}
+
+	// ---- Auto-lock release after a long quiet spell. ----
+	if d.lockIdx >= 0 {
+		if d.rawKey {
+			d.quietHops = 0
+		} else {
+			d.quietHops++
+			// Long enough to survive slow-speed word gaps (7 dits), short
+			// enough to retune to a new signal within a few seconds.
+			release := int(math.Max(2000, 12*d.muDit) / d.hopMs)
+			if d.quietHops > release {
+				d.flushPending()
+				d.lockIdx, d.candIdx, d.candHops = -1, -1, 0
+				d.rawKey = false
+				d.lastPitch = 0
+			}
+		}
+	}
+
+	d.timing()
+	d.emitStatus()
+}
+
+// updateBankNoise folds a fresh bank-median reading into the broadband noise
+// reference used by the absolute squelch.
+func (d *Decoder) updateBankNoise(medianDB float64) {
+	if !d.haveBankNoise {
+		d.bankNoiseDB, d.haveBankNoise = medianDB, true
+		return
+	}
+	d.bankNoiseDB += (medianDB - d.bankNoiseDB) * 0.2
+}
+
+// glitchHops is the debounce time in hops: ~0.3 dit, clamped to 1..3 hops
+// (6–19 ms) so it neither swallows fast dits nor passes static crashes.
+func (d *Decoder) glitchHops() int {
+	g := int(math.Round(0.3 * d.muDit / d.hopMs))
+	if g < 1 {
+		g = 1
+	}
+	if g > 3 {
+		g = 3
+	}
+	return g
+}
+
+// timing runs the debounced mark/space state machine for one hop.
+func (d *Decoder) timing() {
+	if d.rawKey == d.key {
+		// Agreement folds any pending flip back into the committed state:
+		// a sub-glitch dropout inside a dah (or spike inside a gap) vanishes.
+		d.stableHops += 1 + d.pendHops
+		d.pendHops = 0
+	} else {
+		d.pendHops++
+		if d.pendHops > d.glitchHops() {
+			seg := d.stableHops
+			wasMark := d.key
+			d.key = d.rawKey
+			d.stableHops = d.pendHops
+			d.pendHops = 0
+			if wasMark {
+				d.endMark(seg)
+			} else {
+				d.endSpace(seg)
+			}
+			if d.key {
+				d.charEmitted, d.wordEmitted = false, false
+			}
+		}
+	}
+	if !d.key {
+		d.spaceProgress()
+	}
+}
+
+// endMark stores a finished key-down run for the character batch. Cluster
+// updates deliberately do NOT happen here: attributing a mark to the dit or
+// dah centre with the still-converging global boundary poisons the clusters
+// (a dah-led character at an unexpected speed lands its dahs in the dit
+// centre, which then oscillates). Both classification AND cluster updates
+// happen per character in flushChar, where the batch's own contrast makes
+// the attribution reliable.
+func (d *Decoder) endMark(hops int) {
+	ms := float64(hops)*d.hopMs - d.biasMs // de-bias the window widening
+	if ms < 0.5*minDitMs {
+		return // debounce residue — not a credible element
+	}
+	d.elemMs = append(d.elemMs, ms)
+	// Bootstrap: a first mark SHORTER than the seeded dit can only be a dit of
+	// a faster sender — jump the estimate straight there instead of easing in.
+	if d.marksSeen == 0 && ms < d.muDit {
+		d.muDit = math.Max(ms, minDitMs)
+	}
+	d.marksSeen++
+	if len(d.elemMs) > 8 {
+		d.elemMs = d.elemMs[:0] // no Morse character is that long — noise run
+	}
+}
+
+// endSpace runs when a mark begins: the finished gap, if it was clearly an
+// inter-element one, is extra evidence for the dit length (gaps are often
+// steadier than dits in hand keying).
+func (d *Decoder) endSpace(hops int) {
+	ms := float64(hops)*d.hopMs + d.biasMs // gaps shrink by what marks gained
+	if d.marksSeen < 1 || ms < 0.35*d.muDit || ms > 1.7*d.muDit {
+		return
+	}
+	// Early on, gaps are the FASTEST way to find the true dit length (the very
+	// first inter-element gap is one, whatever the first mark was); once the
+	// clusters have settled they are just a gentle refinement.
+	alpha := 0.08
+	if d.marksSeen < 8 {
+		alpha = 0.35
+	}
+	d.muDit += (ms - d.muDit) * alpha
+	d.muDit = math.Min(math.Max(d.muDit, minDitMs), maxDitMs)
+}
+
+// spaceProgress emits the pending character / word space LIVE once the current
+// gap crosses each boundary (instead of waiting for the next mark), so text
+// appears as it is sent.
+func (d *Decoder) spaceProgress() {
+	gapMs := float64(d.stableHops)*d.hopMs + d.biasMs
+	if !d.charEmitted && gapMs > charGapDits*d.muDit {
+		d.flushChar()
+		d.charEmitted = true
+	}
+	if !d.wordEmitted && gapMs > wordGapDits*d.muDit {
+		if d.textSince && d.onChar != nil {
+			d.onChar(" ")
+		}
+		d.wordEmitted = true
+	}
+}
+
+// flushChar classifies the accumulated mark durations into dits/dahs and
+// emits the character. Classification happens HERE, not as marks arrive: a
+// character whose own marks are clearly bimodal carries its own dit/dah
+// boundary (their geometric mean), which decodes correctly even before the
+// global clusters have converged — the first character of an over included.
+// Unimodal characters (EEE, TTT, 555…) fall back to the global boundary.
+func (d *Decoder) flushChar() {
+	if len(d.elemMs) == 0 {
+		return
+	}
+	lo, hi := d.elemMs[0], d.elemMs[0]
+	for _, v := range d.elemMs[1:] {
+		lo = math.Min(lo, v)
+		hi = math.Max(hi, v)
+	}
+	b := math.Sqrt(d.muDit * d.muDah)
+	if hi >= 2*lo {
+		b = math.Sqrt(lo * hi) // the batch is bimodal: trust its own contrast
+	}
+	alpha := 0.18
+	if d.marksSeen <= 8 {
+		alpha = 0.45 // converge fast on a new sender
+	}
+	pat := make([]byte, len(d.elemMs))
+	for i, v := range d.elemMs {
+		if v < b {
+			pat[i] = '.'
+			d.muDit += (v - d.muDit) * alpha
+		} else {
+			pat[i] = '-'
+			d.muDah += (v - d.muDah) * alpha
+		}
+	}
+	// Ratio guards: dah stays 2–4.8 dits; dit stays within speed limits.
+	d.muDit = math.Min(math.Max(d.muDit, minDitMs), maxDitMs)
+	if d.muDah < 2.0*d.muDit {
+		d.muDah = 2.0 * d.muDit
+	}
+	if d.muDah > 4.8*d.muDit {
+		d.muDah = 4.8 * d.muDit
+	}
+	d.elemMs = d.elemMs[:0]
+	if c, ok := morse[string(pat)]; ok {
+		if d.onChar != nil {
+			d.onChar(string(c))
+		}
+		d.textSince = true
+	} else if len(pat) <= 7 {
+		// Morse-shaped but unknown → flag it; longer runs are noise, drop.
+		if d.onChar != nil {
+			d.onChar("?")
+		}
+		d.textSince = true
+	}
+}
+
+// flushPending finishes the in-progress character and word at end-of-over
+// (lock release), so the last word isn't left hanging until the next signal.
+func (d *Decoder) flushPending() {
+	if !d.charEmitted {
+		d.flushChar()
+		d.charEmitted = true
+	}
+	if !d.wordEmitted && d.textSince && d.onChar != nil {
+		d.onChar(" ")
+		d.wordEmitted = true
+	}
+}
+
+func (d *Decoder) emitStatus() {
+	d.sinceStatus++
+	if d.sinceStatus < d.statusEvery || d.onStatus == nil {
+		return
+	}
+	d.sinceStatus = 0
+	wpm := 0
+	if d.muDit > 0 && (d.lockIdx >= 0 || d.targetHz.Load() > 0) {
+		wpm = int(math.Round(1200 / d.muDit))
+	}
+	d.onStatus(Status{
+		WPM:    wpm,
+		Pitch:  int(math.Round(d.lastPitch)),
+		Level:  d.lastRMS,
+		Active: d.rawKey,
+	})
+}

internal/cwdecode/cwdecode_test.go

@@ -0,0 +1,326 @@
+package cwdecode
+
+import (
+	"math"
+	"math/rand"
+	"strings"
+	"testing"
+)
+
+// ---- Synthesizer -----------------------------------------------------------
+
+func charToMorse() map[byte]string {
+	m := map[byte]string{}
+	for code, ch := range morse {
+		m[ch] = code
+	}
+	return m
+}
+
+// keyMessage synthesizes keyed CW for msg with raised-cosine edges (5 ms), so
+// the signal has realistic click-free envelopes rather than hard steps.
+func keyMessage(msg string, fs, wpm int, pitch, amp float64) []int16 {
+	dot := fs * 1200 / (wpm * 1000) // samples per dit
+	edge := fs * 5 / 1000           // 5 ms shaping
+	c2m := charToMorse()
+	var out []float64
+	phase := 0.0
+	dphi := 2 * math.Pi * pitch / float64(fs)
+
+	tone := func(n int) {
+		for i := 0; i < n; i++ {
+			g := 1.0
+			if i < edge {
+				g = 0.5 - 0.5*math.Cos(math.Pi*float64(i)/float64(edge))
+			} else if n-1-i < edge {
+				g = 0.5 - 0.5*math.Cos(math.Pi*float64(n-1-i)/float64(edge))
+			}
+			out = append(out, amp*g*math.Sin(phase))
+			phase += dphi
+		}
+	}
+	silence := func(n int) {
+		for i := 0; i < n; i++ {
+			out = append(out, 0)
+		}
+	}
+
+	silence(fs / 4) // lead-in for envelope warm-up
+	for i := 0; i < len(msg); i++ {
+		ch := msg[i]
+		if ch == ' ' {
+			silence(4 * dot) // + trailing 3 from the previous char = 7 total
+			continue
+		}
+		code := c2m[ch]
+		for j := 0; j < len(code); j++ {
+			if code[j] == '.' {
+				tone(dot)
+			} else {
+				tone(3 * dot)
+			}
+			silence(dot)
+		}
+		silence(2 * dot) // + trailing element gap = 3 total
+	}
+	silence(fs / 2)
+	return toInt16(out)
+}
+
+func toInt16(x []float64) []int16 {
+	out := make([]int16, len(x))
+	for i, v := range x {
+		if v > 32767 {
+			v = 32767
+		} else if v < -32768 {
+			v = -32768
+		}
+		out[i] = int16(v)
+	}
+	return out
+}
+
+func addNoise(s []int16, sigma float64, seed int64) []int16 {
+	r := rand.New(rand.NewSource(seed))
+	out := make([]int16, len(s))
+	for i, v := range s {
+		out[i] = int16(math.Max(-32768, math.Min(32767, float64(v)+r.NormFloat64()*sigma)))
+	}
+	return out
+}
+
+// applyQSB modulates the amplitude between lo..1.0 at rate Hz (slow fading).
+func applyQSB(s []int16, fs int, rate, lo float64) []int16 {
+	out := make([]int16, len(s))
+	for i, v := range s {
+		g := lo + (1-lo)*(0.5+0.5*math.Sin(2*math.Pi*rate*float64(i)/float64(fs)))
+		out[i] = int16(float64(v) * g)
+	}
+	return out
+}
+
+// applyDropouts blanks brief windows (ms long) every period ms — static-crash
+// style holes that land inside dahs and gaps alike.
+func applyDropouts(s []int16, fs int, everyMs, holeMs int) []int16 {
+	out := make([]int16, len(s))
+	copy(out, s)
+	every := fs * everyMs / 1000
+	hole := fs * holeMs / 1000
+	for start := every; start+hole < len(out); start += every {
+		for i := start; i < start+hole; i++ {
+			out[i] = 0
+		}
+	}
+	return out
+}
+
+func mix(a, b []int16) []int16 {
+	n := len(a)
+	if len(b) > n {
+		n = len(b)
+	}
+	out := make([]int16, n)
+	for i := 0; i < n; i++ {
+		var v int
+		if i < len(a) {
+			v += int(a[i])
+		}
+		if i < len(b) {
+			v += int(b[i])
+		}
+		if v > 32767 {
+			v = 32767
+		} else if v < -32768 {
+			v = -32768
+		}
+		out[i] = int16(v)
+	}
+	return out
+}
+
+// decode runs samples through a fresh decoder in live-sized chunks.
+func decode(t *testing.T, samples []int16, targetHz int) string {
+	t.Helper()
+	var sb strings.Builder
+	d := New(16000, func(s string) { sb.WriteString(s) }, nil)
+	if targetHz > 0 {
+		d.SetTarget(targetHz)
+	}
+	for i := 0; i < len(samples); i += 256 {
+		end := i + 256
+		if end > len(samples) {
+			end = len(samples)
+		}
+		d.Process(samples[i:end])
+	}
+	return strings.ToUpper(sb.String())
+}
+
+func wantContains(t *testing.T, got, want, label string) {
+	t.Helper()
+	if !strings.Contains(got, want) {
+		t.Fatalf("%s: decoded %q, want it to contain %q", label, got, want)
+	}
+}
+
+// ---- Tests -----------------------------------------------------------------
+
+func TestCleanSignalSpeeds(t *testing.T) {
+	const fs = 16000
+	for _, wpm := range []int{12, 18, 25, 32, 40} {
+		got := decode(t, keyMessage("CQ TEST DE F4BPO K", fs, wpm, 700, 9000), 0)
+		wantContains(t, got, "CQ TEST DE F4BPO K", "clean @"+itoa(wpm)+"wpm")
+	}
+}
+
+func TestOtherPitches(t *testing.T) {
+	const fs = 16000
+	for _, pitch := range []float64{450, 600, 850} {
+		got := decode(t, keyMessage("PARIS PARIS", fs, 22, pitch, 9000), 0)
+		wantContains(t, got, "PARIS PARIS", "pitch")
+	}
+}
+
+func TestWithNoise(t *testing.T) {
+	const fs = 16000
+	clean := keyMessage("CQ CQ DE HB9HBY", fs, 22, 700, 9000)
+	noisy := addNoise(clean, 2000, 1) // ≈13 dB tone/noise in the audio band
+	got := decode(t, noisy, 0)
+	wantContains(t, got, "CQ CQ DE HB9HBY", "noise")
+}
+
+// QSB fading between 35% and 100% amplitude — the adaptive dB envelope must
+// ride it. The old linear envelope lost the faded halves entirely.
+func TestQSBFading(t *testing.T) {
+	const fs = 16000
+	clean := keyMessage("CQ CQ CQ DE F4BPO F4BPO", fs, 20, 700, 12000)
+	faded := applyQSB(clean, fs, 0.4, 0.35)
+	got := decode(t, faded, 0)
+	wantContains(t, got, "DE F4BPO", "qsb")
+}
+
+// Brief 10 ms holes punched every 150 ms — they land inside dahs. Without the
+// two-sided debounce every hit dah shatters into dits (the old decoder's
+// single worst failure on real signals).
+func TestDropoutsInsideDahs(t *testing.T) {
+	const fs = 16000
+	clean := keyMessage("TEST TEST TEST", fs, 18, 700, 9000)
+	holed := applyDropouts(clean, fs, 150, 10)
+	got := decode(t, holed, 0)
+	wantContains(t, got, "TEST TEST", "dropouts")
+}
+
+// QRM: a second, slightly weaker keyed signal at 950 Hz. The pitch lock must
+// hold the 700 Hz target and ignore the interferer.
+func TestQRMAutoLock(t *testing.T) {
+	const fs = 16000
+	target := keyMessage("PARIS PARIS PARIS", fs, 20, 700, 9000)
+	qrm := keyMessage("QRZ QRZ QRZ QRZ QRZ", fs, 26, 950, 5000)
+	got := decode(t, mix(target, qrm), 0)
+	wantContains(t, got, "PARIS", "qrm-auto")
+}
+
+// Targeted mode: with two comparable signals, SetTarget must decode the chosen
+// one even though the other is as strong.
+func TestQRMTargeted(t *testing.T) {
+	const fs = 16000
+	want := keyMessage("SOS SOS SOS", fs, 20, 600, 8000)
+	other := keyMessage("QRL QRL QRL QRL", fs, 24, 900, 8000)
+	got := decode(t, mix(want, other), 600)
+	wantContains(t, got, "SOS SOS", "qrm-target")
+}
+
+// Pure noise must stay silent: the squelch keys nothing, so no text at all.
+func TestNoiseOnlySquelch(t *testing.T) {
+	const fs = 16000
+	noise := addNoise(make([]int16, fs*6), 3000, 7)
+	got := strings.TrimSpace(decode(t, noise, 0))
+	if len(got) > 2 { // tolerate at most a stray flagged char
+		t.Fatalf("squelch: decoded %q from pure noise, want (almost) nothing", got)
+	}
+}
+
+// keyMessageJitter synthesizes hand-sent CW: every element and gap duration
+// is jittered (elements ±je, gaps ±jg, uniform), like a human fist.
+func keyMessageJitter(msg string, fs, wpm int, pitch, amp, je, jg float64, seed int64) []int16 {
+	r := rand.New(rand.NewSource(seed))
+	dot := float64(fs) * 1200 / (float64(wpm) * 1000)
+	edge := fs * 5 / 1000
+	c2m := charToMorse()
+	var out []float64
+	phase := 0.0
+	dphi := 2 * math.Pi * pitch / float64(fs)
+	jit := func(n float64, j float64) int { return int(n * (1 + (r.Float64()*2-1)*j)) }
+	tone := func(n int) {
+		for i := 0; i < n; i++ {
+			g := 1.0
+			if i < edge {
+				g = 0.5 - 0.5*math.Cos(math.Pi*float64(i)/float64(edge))
+			} else if n-1-i < edge {
+				g = 0.5 - 0.5*math.Cos(math.Pi*float64(n-1-i)/float64(edge))
+			}
+			out = append(out, amp*g*math.Sin(phase))
+			phase += dphi
+		}
+	}
+	silence := func(n int) {
+		for i := 0; i < n; i++ {
+			out = append(out, 0)
+		}
+	}
+	silence(fs / 4)
+	for i := 0; i < len(msg); i++ {
+		ch := msg[i]
+		if ch == ' ' {
+			silence(jit(4*dot, jg))
+			continue
+		}
+		code := c2m[ch]
+		for j := 0; j < len(code); j++ {
+			if code[j] == '.' {
+				tone(jit(dot, je))
+			} else {
+				tone(jit(3*dot, je))
+			}
+			silence(jit(dot, jg))
+		}
+		silence(jit(2*dot, jg))
+	}
+	silence(fs / 2)
+	return toInt16(out)
+}
+
+// Hand keying: ±20% element jitter, ±25% gap jitter — a sloppy but readable
+// human fist. The batch classifier and the gap-fed dit tracking must ride it.
+func TestHandKeying(t *testing.T) {
+	const fs = 16000
+	for seed := int64(1); seed <= 3; seed++ {
+		s := keyMessageJitter("CQ CQ DE HB9HBY HB9HBY K", fs, 22, 700, 9000, 0.20, 0.25, seed)
+		got := decode(t, s, 0)
+		wantContains(t, got, "HB9HBY", "hand-keying")
+	}
+}
+
+// Speed change mid-over: the cluster tracker must follow 25 → 15 WPM.
+func TestSpeedChange(t *testing.T) {
+	const fs = 16000
+	fast := keyMessage("CQ CQ CQ DE F4BPO", fs, 25, 700, 9000)
+	slow := keyMessage("UR RST 599 599", fs, 15, 700, 9000)
+	got := decode(t, append(fast, slow...), 0)
+	wantContains(t, got, "F4BPO", "speed-fast-part")
+	wantContains(t, got, "599", "speed-slow-part")
+}
+
+func itoa(n int) string {
+	if n == 0 {
+		return "0"
+	}
+	var b [8]byte
+	i := len(b)
+	for n > 0 {
+		i--
+		b[i] = byte('0' + n%10)
+		n /= 10
+	}
+	return string(b[i:])
+}

internal/cwdecode/debug_test.go

@@ -0,0 +1,30 @@
+package cwdecode
+
+import (
+	"fmt"
+	"testing"
+)
+
+// TestDebugTrace prints the element stream for a chosen case — a development
+// aid, not an assertion test. Run with: go test -run TestDebugTrace -v
+func TestDebugTrace(t *testing.T) {
+	if testing.Short() {
+		t.Skip("debug aid")
+	}
+	const fs = 16000
+	samples := keyMessage("CQ TEST DE F4BPO K", fs, 40, 700, 9000)
+	var d *Decoder
+	d = New(fs, func(s string) { fmt.Printf("EMIT %q (muDit=%.0f muDah=%.0f)\n", s, d.muDit, d.muDah) }, nil)
+	lastMarks := 0
+	for i := 0; i < len(samples); i += 256 {
+		end := i + 256
+		if end > len(samples) {
+			end = len(samples)
+		}
+		d.Process(samples[i:end])
+		if d.marksSeen != lastMarks {
+			lastMarks = d.marksSeen
+			fmt.Printf("mark#%d elems=%v muDit=%.0f muDah=%.0f\n", d.marksSeen, d.elemMs, d.muDit, d.muDah)
+		}
+	}
+}

internal/db/mysql.go

@@ -207,9 +207,58 @@ func OpenMySQL(c MySQLConfig) (*sql.DB, error) {
 		Dialect = "sqlite" // migration failed; we'll fall back to SQLite
 		return nil, err
 	}
+	// Guarantee the schema can store non-Latin text (Cyrillic, Polish ł, …).
+	// Best-effort: never block access to the logbook over the charset probe.
+	if err := ensureMySQLUTF8MB4(conn, name); err != nil {
+		fmt.Printf("OpsLog: utf8mb4 conversion: %v\n", err)
+	}
 	return conn, nil
 }
 
+// ensureMySQLUTF8MB4 makes the database default and every OpsLog table utf8mb4,
+// converting any that isn't. It repairs databases pre-created as latin1 or
+// utf8mb3 by a hosting panel (cPanel/o2switch default), where OpsLog's
+// "CREATE DATABASE IF NOT EXISTS … utf8mb4" was a no-op and the tables inherited
+// a charset that can't store non-Latin callsigns/names/QTHs — the MySQL 1366
+// "Incorrect string value: '\xD0\xAF'" (Cyrillic Я) seen updating a QSO from QRZ.
+//
+// Idempotent and cheap on a healthy database: one information_schema probe finds
+// the tables with a non-utf8mb4 text column, and only those are converted (none
+// on an already-correct DB). Conversion is safe for the wide qso table because
+// the bulk of its columns are off-page TEXT (see the row-size note above); only
+// the ~20 indexed VARCHARs sit in-row, well under InnoDB's 65535-byte limit even
+// at 4 bytes/char.
+func ensureMySQLUTF8MB4(conn *sql.DB, dbName string) error {
+	// Fix the database default so any FUTURE table is utf8mb4 too.
+	_, _ = conn.Exec("ALTER DATABASE `" + dbName + "` CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci")
+
+	rows, err := conn.Query(`
+		SELECT DISTINCT TABLE_NAME
+		FROM information_schema.COLUMNS
+		WHERE TABLE_SCHEMA = ?
+		  AND CHARACTER_SET_NAME IS NOT NULL
+		  AND CHARACTER_SET_NAME <> 'utf8mb4'`, dbName)
+	if err != nil {
+		return fmt.Errorf("probe charsets: %w", err)
+	}
+	var tables []string
+	for rows.Next() {
+		var t string
+		if err := rows.Scan(&t); err == nil && validDBIdent(t) {
+			tables = append(tables, t)
+		}
+	}
+	rows.Close()
+
+	var firstErr error
+	for _, t := range tables {
+		if _, err := conn.Exec("ALTER TABLE `" + t + "` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci"); err != nil && firstErr == nil {
+			firstErr = fmt.Errorf("convert %s: %w", t, err)
+		}
+	}
+	return firstErr
+}
+
 // isFreshMySQL reports whether the database has no OpsLog schema yet (no qso
 // table), so the baseline fast-path applies. A partially-migrated database is
 // NOT fresh and goes through the incremental migrator.

internal/qso/qso.go

@@ -366,6 +366,42 @@ func decodeExtras(s string) map[string]string {
 	return m
 }
 
+// DistinctExtraKeys returns the set of keys present across stored QSO extras
+// (the non-promoted ADIF tags kept verbatim), scanning the most recent `sample`
+// rows that have any extras. Capped so it stays fast on a large remote logbook —
+// the extras vocabulary is small and stable, so a recent sample finds it all.
+func (r *Repo) DistinctExtraKeys(ctx context.Context, sample int) ([]string, error) {
+	if sample <= 0 {
+		sample = 5000
+	}
+	rows, err := r.db.QueryContext(ctx,
+		`SELECT extras_json FROM qso
+		 WHERE extras_json IS NOT NULL AND extras_json <> '' AND extras_json <> '{}'
+		 ORDER BY id DESC LIMIT ?`, sample)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	seen := map[string]bool{}
+	for rows.Next() {
+		var s sql.NullString
+		if err := rows.Scan(&s); err != nil {
+			return nil, err
+		}
+		for k := range decodeExtras(s.String) {
+			seen[k] = true
+		}
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	out := make([]string, 0, len(seen))
+	for k := range seen {
+		out = append(out, k)
+	}
+	return out, nil
+}
+
 // Add inserts a QSO and returns its ID.
 func (r *Repo) Add(ctx context.Context, q QSO) (int64, error) {
 	q.Callsign = strings.ToUpper(strings.TrimSpace(q.Callsign))
@@ -1370,6 +1406,10 @@ type WorkedBefore struct {
 	DXCCModes     []string   `json:"dxcc_modes"`
 	DXCCBandModes []BandMode `json:"dxcc_band_modes"`
 
+	// MWRank is the ClubLog "Most Wanted" rank for this entity (1 = most wanted),
+	// 0 when unknown or the feature is off. Populated by the app layer, not here.
+	MWRank int `json:"mw_rank,omitempty"`
+
 	// Status grid driving the band×class matrix in the UI. One entry per
 	// (band, class) where ANY QSO exists in this DXCC. Only the highest
 	// status for that cell is kept (call_c > call_w > dxcc_c > dxcc_w).

internal/steppir/steppir.go

@@ -23,6 +23,7 @@
 package steppir
 
 import (
+	"bytes"
 	"encoding/binary"
 	"fmt"
 	"io"
@@ -84,6 +85,12 @@ type Client struct {
 	lastStatus *Status
 	lastSetKHz int
 
+	// lastRaw holds the previous raw status frame so we only log a status line
+	// when the controller's reply actually changes — enough to diagnose a stuck
+	// "motors moving" read (which drives the app's TX-inhibit interlock) without
+	// spamming the log every 2 s poll.
+	lastRaw []byte
+
 	// A just-commanded direction is held until the controller's poll reports it —
 	// the motors take a second or two, and a stale poll would otherwise snap the
 	// UI back. Same trick as the Ultrabeam client.
@@ -242,7 +249,17 @@ func (c *Client) queryStatus() (*Status, error) {
 	if _, err := io.ReadFull(conn, buf); err != nil {
 		return nil, fmt.Errorf("read status: %w", err)
 	}
-	return parseStatus(buf)
+	st, err := parseStatus(buf)
+	// Log the raw frame + decode whenever it changes. The motor byte (buf[6]) is
+	// what decides st.MotorsMoving, and that in turn drives the app's "block TX
+	// while moving" interlock — so if a controller (e.g. with its INHIBIT engaged)
+	// reports a byte we misread as perpetual motion, this line makes it visible.
+	if err == nil && !bytes.Equal(buf, c.lastRaw) {
+		c.lastRaw = append(c.lastRaw[:0], buf...)
+		log.Printf("steppir: status ← % X  (freq=%d kHz dir=%d moving=%d motorByte=0x%02X dirByte=0x%02X)",
+			buf, st.Frequency, st.Direction, st.MotorsMoving, buf[6], buf[7])
+	}
+	return st, err
 }
 
 // parseStatus decodes an 11-byte status frame.

internal/winkeyer/linectl_other.go

@@ -0,0 +1,37 @@
+//go:build !windows
+
+package winkeyer
+
+// linectl_other.go — non-Windows DTR/RTS line control via go.bug.st/serial. On
+// Linux/macOS the SetDTR/SetRTS ioctls control the lines independently, so the
+// CP210x-on-Windows problem that motivated the native path (see linectl_windows.go)
+// doesn't apply. OpsLog ships on Windows; this keeps the package building elsewhere.
+
+import (
+	"fmt"
+	"strings"
+
+	"go.bug.st/serial"
+)
+
+type serialLineCtl struct {
+	port serial.Port
+}
+
+func openLineCtl(port string) (lineCtl, error) {
+	if strings.TrimSpace(port) == "" {
+		return nil, fmt.Errorf("no serial port")
+	}
+	p, err := serial.Open(port, &serial.Mode{BaudRate: 9600, DataBits: 8, Parity: serial.NoParity, StopBits: serial.OneStopBit})
+	if err != nil {
+		return nil, fmt.Errorf("open %s: %w", port, err)
+	}
+	c := &serialLineCtl{port: p}
+	_ = c.setDTR(false)
+	_ = c.setRTS(false)
+	return c, nil
+}
+
+func (c *serialLineCtl) setDTR(on bool) error { return c.port.SetDTR(on) }
+func (c *serialLineCtl) setRTS(on bool) error { return c.port.SetRTS(on) }
+func (c *serialLineCtl) close() error         { return c.port.Close() }

internal/winkeyer/linectl_windows.go

@@ -0,0 +1,81 @@
+//go:build windows
+
+package winkeyer
+
+// linectl_windows.go — DTR/RTS line control via EscapeCommFunction, the direct
+// Win32 method N1MM/WSJT/fldigi use. It sets ONE line at a time without a
+// GetCommState/SetCommState round-trip, so a held RTS (PTT) is NOT disturbed when
+// DTR (CW) is toggled. go.bug.st/serial drives the lines via SetCommState, which
+// on USB-serial adapters (the SCU-17's CP210x, FTDI) drops the held RTS the moment
+// DTR changes — the "rig drops to RX between words" bug this fixes.
+
+import (
+	"fmt"
+	"strings"
+
+	"golang.org/x/sys/windows"
+)
+
+type winLineCtl struct {
+	h windows.Handle
+}
+
+// openLineCtl opens a COM port for line control only (no data I/O).
+func openLineCtl(port string) (lineCtl, error) {
+	name := strings.TrimSpace(port)
+	if name == "" {
+		return nil, fmt.Errorf("no serial port")
+	}
+	// The \\.\ prefix is required for COM10+ and harmless for COM1-9.
+	if !strings.HasPrefix(name, `\\.\`) {
+		name = `\\.\` + name
+	}
+	p, err := windows.UTF16PtrFromString(name)
+	if err != nil {
+		return nil, err
+	}
+	h, err := windows.CreateFile(p,
+		windows.GENERIC_READ|windows.GENERIC_WRITE, 0, nil,
+		windows.OPEN_EXISTING, 0, 0)
+	if err != nil {
+		return nil, fmt.Errorf("open %s: %w", port, err)
+	}
+	// A minimal DCB so the driver is in a sane state. Baud is irrelevant for pure
+	// line control, but leaving fDtr/fRtsControl at DISABLE means only our explicit
+	// EscapeCommFunction calls drive the lines.
+	var dcb windows.DCB
+	if windows.GetCommState(h, &dcb) == nil {
+		dcb.BaudRate = 9600
+		dcb.ByteSize = 8
+		dcb.Parity = 0  // NOPARITY
+		dcb.StopBits = 0 // ONESTOPBIT
+		// Clear DTR (bits 4-5) and RTS (bits 12-13) control fields → DISABLE, so the
+		// lines idle low until we assert them, and no hardware flow control fights us.
+		dcb.Flags &^= 0x00000030
+		dcb.Flags &^= 0x00003000
+		_ = windows.SetCommState(h, &dcb)
+	}
+	c := &winLineCtl{h: h}
+	// Start both lines low (inactive) — the keyer's idle() will do this too.
+	_ = c.setDTR(false)
+	_ = c.setRTS(false)
+	return c, nil
+}
+
+func (c *winLineCtl) setDTR(on bool) error {
+	f := uint32(windows.CLRDTR)
+	if on {
+		f = windows.SETDTR
+	}
+	return windows.EscapeCommFunction(c.h, f)
+}
+
+func (c *winLineCtl) setRTS(on bool) error {
+	f := uint32(windows.CLRRTS)
+	if on {
+		f = windows.SETRTS
+	}
+	return windows.EscapeCommFunction(c.h, f)
+}
+
+func (c *winLineCtl) close() error { return windows.CloseHandle(c.h) }

internal/winkeyer/serialcw.go

@@ -0,0 +1,326 @@
+package winkeyer
+
+// serialcw.go — CW keying by toggling a serial control line, the "hardware CW
+// keying" method N1MM / WSJT / fldigi use with a Yaesu SCU-17 and similar
+// interfaces (DTR = CW key, RTS = PTT). No K1EL WinKeyer chip involved: the PC
+// bit-bangs the Morse itself on the DTR (or RTS) line at the configured WPM.
+//
+// A single worker goroutine consumes queued text and keys it element by element,
+// so Send returns immediately (like the WinKeyer's buffered send) and Stop can
+// abort mid-message. Speed changes apply live between characters. PTT (when
+// enabled) is asserted on the OTHER line for the whole transmission plus a
+// lead-in / tail, and held through a short hang so send-on-type doesn't chatter.
+
+import (
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"hamlog/internal/applog"
+)
+
+// lineCtl drives a serial port's DTR and RTS control lines. On Windows it uses
+// EscapeCommFunction (SETDTR/CLRDTR/SETRTS/CLRRTS) — the direct method N1MM/WSJT
+// use, reliable on USB-serial adapters (CP210x/FTDI). go.bug.st/serial drives the
+// lines via SetCommState instead, which on a CP210x drops the held RTS (PTT) as
+// soon as DTR (CW) is toggled — the "rig drops to RX between words" bug. See
+// linectl_windows.go / linectl_other.go.
+type lineCtl interface {
+	setDTR(on bool) error
+	setRTS(on bool) error
+	close() error
+}
+
+// morseTable maps a keyable character to its Morse element string (. = dit,
+// - = dah). Mirrors winkeyer.allowedCW.
+var morseTable = map[rune]string{
+	'A': ".-", 'B': "-...", 'C': "-.-.", 'D': "-..", 'E': ".", 'F': "..-.",
+	'G': "--.", 'H': "....", 'I': "..", 'J': ".---", 'K': "-.-", 'L': ".-..",
+	'M': "--", 'N': "-.", 'O': "---", 'P': ".--.", 'Q': "--.-", 'R': ".-.",
+	'S': "...", 'T': "-", 'U': "..-", 'V': "...-", 'W': ".--", 'X': "-..-",
+	'Y': "-.--", 'Z': "--..",
+	'0': "-----", '1': ".----", '2': "..---", '3': "...--", '4': "....-",
+	'5': ".....", '6': "-....", '7': "--...", '8': "---..", '9': "----.",
+	'.': ".-.-.-", ',': "--..--", '?': "..--..", '/': "-..-.", '=': "-...-",
+	'+': ".-.-.", '-': "-....-", ':': "---...", '(': "-.--.", ')': "-.--.-",
+	';': "-.-.-.", '"': ".-..-.", '\'': ".----.", '@': ".--.-.",
+}
+
+// serialKeyer bit-bangs CW on a serial control line. Owned by a winkeyer.Manager
+// while Type == "serial"; all keying happens in run(). The line-control options
+// (key line, invert, PTT, lead/tail) are atomic so ApplyConfig can update them
+// LIVE — e.g. ticking "Key PTT line" takes effect without reconnecting the keyer.
+type serialKeyer struct {
+	line   lineCtl
+	keyDTR atomic.Bool  // true: CW on DTR, PTT on RTS (N1MM default). false: swapped.
+	invert atomic.Bool  // true: active-LOW — asserting a line means driving it LOW
+	usePTT atomic.Bool  // hold the PTT line for the whole transmission
+	leadMs atomic.Int32 // PTT lead-in
+	tailMs atomic.Int32 // PTT hold (hang) after the last element
+	onBusy func(bool)
+
+	mu    sync.Mutex
+	wpm   int
+	farns int
+	abort chan struct{} // recreated by Stop; keying aborts when it closes
+
+	in   chan string
+	stop chan struct{}
+	done chan struct{}
+}
+
+func newSerialKeyer(line lineCtl, cfg Config, onBusy func(bool)) *serialKeyer {
+	k := &serialKeyer{
+		line:   line,
+		onBusy: onBusy,
+		wpm:    cfg.WPM,
+		farns:  cfg.Farnsworth,
+		abort:  make(chan struct{}),
+		in:     make(chan string, 256),
+		stop:   make(chan struct{}),
+		done:   make(chan struct{}),
+	}
+	k.keyDTR.Store(!strings.EqualFold(strings.TrimSpace(cfg.CWKeyLine), "rts")) // default DTR=CW
+	k.invert.Store(cfg.CWInvert)
+	k.usePTT.Store(cfg.UsePTT)
+	k.leadMs.Store(int32(cfg.LeadInMs))
+	k.tailMs.Store(int32(cfg.TailMs))
+	k.idle() // start inactive: key up, PTT off
+	go k.run()
+	return k
+}
+
+// ApplyConfig live-updates the line-control options (no port reopen), so a
+// settings change is felt from the next character without a reconnect. Speed and
+// Farnsworth are updated too. keyText re-reads these per element.
+func (k *serialKeyer) ApplyConfig(cfg Config) {
+	k.keyDTR.Store(!strings.EqualFold(strings.TrimSpace(cfg.CWKeyLine), "rts"))
+	k.invert.Store(cfg.CWInvert)
+	k.usePTT.Store(cfg.UsePTT)
+	k.leadMs.Store(int32(cfg.LeadInMs))
+	k.tailMs.Store(int32(cfg.TailMs))
+	k.mu.Lock()
+	k.wpm = cfg.WPM
+	k.farns = cfg.Farnsworth
+	k.mu.Unlock()
+	k.idle() // re-assert idle lines with any new polarity/key-line choice
+}
+
+// level maps a logical "active" state to the physical line level, honouring the
+// invert (active-LOW) option: normally active = HIGH, inverted active = LOW.
+func (k *serialKeyer) level(active bool) bool { return active != k.invert.Load() }
+
+// setKey raises/lowers the CW key line; setPTT the PTT line (only when enabled).
+func (k *serialKeyer) setKey(down bool) {
+	if k.keyDTR.Load() {
+		_ = k.line.setDTR(k.level(down))
+	} else {
+		_ = k.line.setRTS(k.level(down))
+	}
+}
+func (k *serialKeyer) setPTT(on bool) {
+	if !k.usePTT.Load() {
+		return
+	}
+	if k.keyDTR.Load() {
+		_ = k.line.setRTS(k.level(on))
+	} else {
+		_ = k.line.setDTR(k.level(on))
+	}
+}
+
+// idle drives BOTH lines to their inactive level (key up, PTT off), respecting
+// the invert option — so an active-LOW interface isn't left keyed at rest.
+func (k *serialKeyer) idle() {
+	_ = k.line.setDTR(k.level(false))
+	_ = k.line.setRTS(k.level(false))
+}
+
+// SetSpeed / Send / Stop mirror the WinKeyer manager's control surface.
+func (k *serialKeyer) SetSpeed(wpm int) {
+	k.mu.Lock()
+	k.wpm = wpm
+	k.mu.Unlock()
+}
+
+func (k *serialKeyer) Send(text string) {
+	select {
+	case k.in <- text:
+	default: // queue full (pathological) — drop rather than block the app binding
+	}
+}
+
+// Stop aborts the character being keyed and flushes anything queued.
+func (k *serialKeyer) Stop() {
+	k.mu.Lock()
+	close(k.abort)
+	k.abort = make(chan struct{})
+	k.mu.Unlock()
+	for drained := false; !drained; {
+		select {
+		case <-k.in:
+		default:
+			drained = true
+		}
+	}
+	k.setKey(false)
+}
+
+func (k *serialKeyer) Close() {
+	close(k.stop)
+	<-k.done
+	_ = k.line.close()
+}
+
+func (k *serialKeyer) run() {
+	defer close(k.done)
+	defer k.idle()
+	for {
+		select {
+		case <-k.stop:
+			return
+		case s := <-k.in:
+			k.onBusy(true)
+			// Diagnostic: confirms whether PTT is actually held for the whole macro
+			// (a rig dropping to RX between words = usePTT off, or the interface's
+			// PTT line isn't wired / honoured in CW).
+			applog.Printf("winkeyer serial: TX %.40q ptt=%v line=%s lead=%dms tail=%dms",
+				s, k.usePTT.Load(), map[bool]string{true: "DTR-CW/RTS-PTT", false: "RTS-CW/DTR-PTT"}[k.keyDTR.Load()],
+				k.leadMs.Load(), k.tailMs.Load())
+			k.setPTT(true)
+			k.sleep(time.Duration(k.leadMs.Load()) * time.Millisecond)
+			k.keyText(s)
+			hang := time.Duration(k.tailMs.Load()) * time.Millisecond
+			if hang <= 0 {
+				hang = 5 * time.Millisecond
+			}
+		hold: // hold PTT briefly so back-to-back sends (send-on-type) don't chatter
+			for {
+				select {
+				case <-k.stop:
+					k.idle()
+					k.onBusy(false)
+					return
+				case s2 := <-k.in:
+					k.keyText(s2)
+				case <-time.After(hang):
+					break hold
+				}
+			}
+			k.setPTT(false)
+			k.onBusy(false)
+		}
+	}
+}
+
+// keyText keys one string. Element gaps use the character speed (WPM); the
+// inter-character (3-unit) and inter-word (7-unit) gaps use the Farnsworth speed
+// when one is set, so slow-copy CW keeps full-speed characters with wider spacing.
+func (k *serialKeyer) keyText(s string) {
+	k.mu.Lock()
+	abort := k.abort
+	k.mu.Unlock()
+	for _, r := range strings.ToUpper(s) {
+		select {
+		case <-abort:
+			k.setKey(false)
+			return
+		case <-k.stop:
+			k.setKey(false)
+			return
+		default:
+		}
+		ditW, ditF := k.dits()
+		if r == ' ' {
+			// Word gap: 7 units total. A 3-unit inter-char gap was already emitted
+			// after the previous character, so add 4 more.
+			if !k.gap(4*ditF, abort) {
+				return
+			}
+			continue
+		}
+		code, ok := morseTable[r]
+		if !ok {
+			continue
+		}
+		for j, el := range code {
+			if el == '.' {
+				if !k.mark(ditW, abort) {
+					return
+				}
+			} else {
+				if !k.mark(3*ditW, abort) {
+					return
+				}
+			}
+			if j < len(code)-1 { // intra-character (element) gap: 1 unit
+				if !k.gap(ditW, abort) {
+					return
+				}
+			}
+		}
+		if !k.gap(3*ditF, abort) { // inter-character gap: 3 units
+			return
+		}
+	}
+}
+
+// mark holds the key down for d; gap holds it up for d. Both abort cleanly
+// (leaving the key UP) when Stop closes abort or the keyer shuts down.
+func (k *serialKeyer) mark(d time.Duration, abort chan struct{}) bool {
+	k.setKey(true)
+	ok := k.wait(d, abort)
+	k.setKey(false)
+	return ok
+}
+func (k *serialKeyer) gap(d time.Duration, abort chan struct{}) bool { return k.wait(d, abort) }
+
+func (k *serialKeyer) wait(d time.Duration, abort chan struct{}) bool {
+	if d <= 0 {
+		return true
+	}
+	t := time.NewTimer(d)
+	defer t.Stop()
+	select {
+	case <-t.C:
+		return true
+	case <-abort:
+		return false
+	case <-k.stop:
+		return false
+	}
+}
+
+// sleep is a non-abortable pause (used for the short PTT lead-in).
+func (k *serialKeyer) sleep(d time.Duration) {
+	if d <= 0 {
+		return
+	}
+	t := time.NewTimer(d)
+	defer t.Stop()
+	select {
+	case <-t.C:
+	case <-k.stop:
+	}
+}
+
+// dits returns the element (character-speed) dit and the spacing (Farnsworth)
+// dit as durations, read live so a speed change mid-message takes effect.
+func (k *serialKeyer) dits() (elem, space time.Duration) {
+	k.mu.Lock()
+	w, f := k.wpm, k.farns
+	k.mu.Unlock()
+	if w < 5 {
+		w = 5
+	}
+	if w > 99 {
+		w = 99
+	}
+	elem = time.Duration(float64(time.Millisecond) * 1200.0 / float64(w))
+	space = elem
+	if f > 0 && f < w {
+		space = time.Duration(float64(time.Millisecond) * 1200.0 / float64(f))
+	}
+	return elem, space
+}

internal/winkeyer/winkeyer.go

@@ -49,6 +49,16 @@ type Config struct {
 	AutoSpace  bool   `json:"autospace"`   // auto letter-space
 	UsePTT     bool   `json:"use_ptt"`     // key PTT (Key/PTT output)
 	SerialEcho bool   `json:"serial_echo"` // device echoes sent chars back to host
+
+	// Type selects the keyer engine on this serial port:
+	//   "" / "k1el" → a K1EL WinKeyer chip (the default, everything above applies)
+	//   "serial"    → the PC bit-bangs Morse on a control line (no WinKeyer chip):
+	//                 the "hardware CW keying" a Yaesu SCU-17 / generic interface
+	//                 uses. WPM / Weight / Farnsworth / LeadIn / Tail / UsePTT still
+	//                 apply; the paddle/sidetone/ratio fields are WinKeyer-only.
+	Type      string `json:"type"`
+	CWKeyLine string `json:"cw_key_line"` // serial: "dtr" (CW on DTR, PTT on RTS — default) | "rts"
+	CWInvert  bool   `json:"cw_invert"`   // serial: invert line polarity (active-LOW) for both key and PTT
 }
 
 func (c Config) normalised() Config {
@@ -93,6 +103,7 @@ type Manager struct {
 	status   Status
 	stopRead chan struct{}
 	doneRead chan struct{}
+	serial   *serialKeyer // non-nil when cfg.Type == "serial" (DTR/RTS line keying)
 
 	onStatus func(Status)
 	onEcho   func(string) // chars the device echoes back as it keys them
@@ -130,6 +141,9 @@ func (m *Manager) Connect(cfg Config) error {
 	if strings.TrimSpace(cfg.Port) == "" {
 		return fmt.Errorf("winkeyer: no serial port selected")
 	}
+	if cfg.Type == "serial" {
+		return m.connectSerial(cfg)
+	}
 	m.Disconnect() // drop any existing link first
 
 	p, err := serial.Open(cfg.Port, &serial.Mode{
@@ -175,6 +189,59 @@ func (m *Manager) Connect(cfg Config) error {
 	return nil
 }
 
+// ApplySerialConfig live-updates a running serial-line keyer's control options
+// (PTT keying, key line, invert, lead/tail, speed) WITHOUT reopening the port —
+// so ticking "Key PTT line" (or changing the key line) takes effect from the next
+// character, no reconnect needed. No-op unless a serial keyer is running.
+func (m *Manager) ApplySerialConfig(cfg Config) {
+	cfg = cfg.normalised()
+	m.mu.Lock()
+	sk := m.serial
+	m.cfg = cfg
+	m.mu.Unlock()
+	if sk != nil {
+		sk.ApplyConfig(cfg)
+	}
+}
+
+// connectSerial opens the port for line-keying (DTR=CW / RTS=PTT) — no K1EL
+// handshake, no read loop. The PC bit-bangs the Morse itself (see serialcw.go).
+func (m *Manager) connectSerial(cfg Config) error {
+	m.Disconnect() // drop any existing link first
+
+	// Open for line control only (DTR/RTS). On Windows this uses EscapeCommFunction
+	// so a held RTS (PTT) survives DTR (CW) toggling on USB adapters — see linectl_*.
+	line, err := openLineCtl(cfg.Port)
+	if err != nil {
+		return fmt.Errorf("winkeyer: open %s: %w", cfg.Port, err)
+	}
+	// The keyer updates busy state as it keys; mirror it into status + notify.
+	sk := newSerialKeyer(line, cfg, func(busy bool) {
+		m.mu.Lock()
+		changed := m.status.Busy != busy
+		m.status.Busy = busy
+		m.mu.Unlock()
+		if changed {
+			m.emit()
+		}
+	})
+
+	m.mu.Lock()
+	m.port = nil // serial keyer owns its own (line-only) port, not m.port
+	m.serial = sk
+	m.cfg = cfg
+	m.status = Status{Connected: true, WPM: cfg.WPM, Port: cfg.Port}
+	m.mu.Unlock()
+
+	lineDesc := "DTR (CW) / RTS (PTT)"
+	if strings.EqualFold(cfg.CWKeyLine, "rts") {
+		lineDesc = "RTS (CW) / DTR (PTT)"
+	}
+	applog.Printf("winkeyer: serial CW keyer on %s — %s, PTT=%v (EscapeCommFunction line ctl)", cfg.Port, lineDesc, cfg.UsePTT)
+	m.emit()
+	return nil
+}
+
 // applyConfig pushes the keying parameters to the device.
 func (m *Manager) applyConfig(c Config) error {
 	cmds := [][]byte{
@@ -256,7 +323,12 @@ func (m *Manager) SetSpeed(wpm int) error {
 	if wpm > 99 {
 		wpm = 99
 	}
-	if err := m.write([]byte{0x02, byte(wpm)}); err != nil {
+	m.mu.Lock()
+	sk := m.serial
+	m.mu.Unlock()
+	if sk != nil {
+		sk.SetSpeed(wpm)
+	} else if err := m.write([]byte{0x02, byte(wpm)}); err != nil {
 		return err
 	}
 	m.mu.Lock()
@@ -283,18 +355,39 @@ func (m *Manager) Send(text string) error {
 	if out == "" {
 		return nil
 	}
+	m.mu.Lock()
+	sk := m.serial
+	m.mu.Unlock()
+	if sk != nil {
+		sk.Send(out)
+		return nil
+	}
 	return m.write([]byte(out))
 }
 
 // Stop aborts the current message and clears the keyer buffer (command 0x0A).
 func (m *Manager) Stop() error {
+	m.mu.Lock()
+	sk := m.serial
+	m.mu.Unlock()
+	if sk != nil {
+		sk.Stop()
+		return nil
+	}
 	return m.write([]byte{0x0A})
 }
 
 // Backspace removes the most recent character from the keyer's send buffer,
 // IF it hasn't been keyed yet (command 0x08). Used by "send on typing" mode
-// so a fast typo can be corrected before it goes on the air.
+// so a fast typo can be corrected before it goes on the air. The serial line
+// keyer has no buffer to un-key from, so backspace is a no-op there.
 func (m *Manager) Backspace() error {
+	m.mu.Lock()
+	sk := m.serial
+	m.mu.Unlock()
+	if sk != nil {
+		return nil
+	}
 	return m.write([]byte{0x08})
 }
 
@@ -313,14 +406,29 @@ func (m *Manager) write(b []byte) error {
 func (m *Manager) Disconnect() {
 	m.mu.Lock()
 	p := m.port
+	sk := m.serial
 	stop, done := m.stopRead, m.doneRead
 	m.port = nil
+	m.serial = nil
 	m.stopRead = nil
 	m.doneRead = nil
 	connected := m.status.Connected
 	m.status = Status{Connected: false}
 	m.mu.Unlock()
 
+	if sk != nil {
+		// Serial line keyer: stop the worker (drops the key/PTT lines) then close.
+		sk.Close()
+		if p != nil {
+			_ = p.Close()
+		}
+		if connected {
+			applog.Printf("winkeyer: serial CW keyer disconnected")
+			m.emit()
+		}
+		return
+	}
+
 	if p != nil {
 		_, _ = p.Write([]byte{0x00, 0x03}) // Host Close
 		_ = p.Close()

telemetry.go

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

wiki/Awards.md

@@ -23,6 +23,17 @@ Plus a **leading/trailing** strip, a **prefix** prepended to found references, a
 **dynamic** mode (any value counts, like POTA), and the **fallback searches**
 described below.
 
+**One QSO can count for several references.** A contact always yields *every*
+reference its field holds — the value is split on commas and semicolons, so an
+n-fer POTA activation logged as `US-6544,US-0680` credits both parks, and a
+grid-line VUCC contact credits each grid. There is no "one reference per QSO"
+switch — it was never useful.
+
+**Match by `code`** looks up each token of the field in the reference list (so a
+partial or multi-value field still resolves), while **`exact match`** requires
+the whole field to equal the reference. Use exact match when a substring would
+cause false hits.
+
 ### The five rules to remember
 
 1. **Every regex is case-insensitive.** Award and per-reference patterns match
@@ -72,6 +83,42 @@ A custom province award where the log rarely spells the province out (it names a
 Now a QSO is resolved by the province **name** if present, else by a **city**
 regex — first in the QTH, then in the address. First hit wins.
 
+## Why doesn't a QSO count? — Test & Missing refs
+
+An award that matches nothing is the hardest thing to debug: the column is just
+empty, and you can't tell whether the QSO was out of scope, the field was empty,
+the rule looked in the wrong place, or the reference isn't on the list. Two tools
+answer that.
+
+### Test a callsign (award editor)
+
+In the **award editor** there's a **Test** box: type a callsign and OpsLog
+replays that award's rules against every QSO you have with that station and shows
+what happened, step by step — the exact same code path the real matcher uses, so
+what you see is what actually runs. For each contact it reports:
+
+- whether the QSO is **in scope** (and, if not, *why* — wrong DXCC, band, mode,
+  emission, or outside the valid-from/to dates);
+- each rule in turn (**primary**, then **Fallback 1, 2, …**), the **field value**
+  it scanned, the **candidates** it produced, which ones were **kept**, and which
+  were **rejected** (with the reason — e.g. "not on the reference list");
+- rules that were **skipped** because an earlier one already matched;
+- any **manual** reference you assigned by hand;
+- the final **result** — what the QSO counts for.
+
+This is the fastest way to fix a rule: if the primary scanned the wrong field, or
+a candidate was rejected as unlisted, the trace says so directly.
+
+### Missing refs (awards panel)
+
+For an award scoped to a DXCC entity (DDFM, WAS, RAC, WAJA…), the **Missing refs**
+view lists contacts that ARE in scope (right DXCC / band / mode / dates) **but
+where no reference was found** — so they don't count yet. Sort by a column, tick
+the matching contacts, and **assign the reference** to all of them at once (or
+click a row to open the QSO and fix the field). Recompute and the fixed contacts
+drop off the list. This is how you close the gaps a matcher can't fill on its own
+(a French QSO logged without its department, say).
+
 ## Live detection & manual refs
 
 - References are detected **live** as you enter a callsign.
@@ -89,6 +136,15 @@ regex — first in the QTH, then in the address. First hit wins.
   or **both**. Award columns are opt-in per the Columns picker
   ([[Recent QSOs and Filters]]).
 
+## Built-in updates vs your edits
+
+Built-in awards ship with the app, definition **and** reference list. When a
+newer version fixes a shipped award (a better fallback chain, a corrected
+reference list), OpsLog offers to apply that update — **unless you've edited that
+award yourself**, in which case your version is left alone (your work outranks
+ours). Awards you created are never touched by updates. So you can freely tune a
+built-in award without fear of a future release overwriting it.
+
 ## Rescan
 
 **Rescan** re-pulls the logbook and recomputes — it picks up fresh LoTW / QRZ /