chore: release v0.27.2

A connect that lasts 50 ms leaves nothing to say which answer the client
disliked — WSJT-X refusing to attach to the shared CAT was undiagnosable
without the full wire trace. The handshake is now always logged; steady-state
polling stays behind the trace switch.

app.go

@@ -74,6 +74,7 @@ import (
 	"hamlog/internal/tunergenius"
 	"hamlog/internal/uls"
 	"hamlog/internal/ultrabeam"
+	"hamlog/internal/watchlist"
 	"hamlog/internal/winkeyer"
 
 	wruntime "github.com/wailsapp/wails/v2/pkg/runtime"
@@ -97,6 +98,7 @@ const (
 
 	keyStationCallsign         = "station.callsign"
 	keyStationOperator         = "station.operator"
+	keyWatchlistContestPattern = "watchlist.contest_pattern" // auto-add contest calls containing this
 	keyStationMyGrid           = "station.my_grid"
 	keyStationCountry          = "station.my_country"
 	keyStationSOTA             = "station.my_sota_ref"
@@ -157,6 +159,7 @@ const (
 	keyCATIcomNetUser      = "cat.icom.net.user"       // Icom network: Network User1 ID
 	keyCATIcomNetPass      = "cat.icom.net.pass"       // Icom network: Network User1 password
 	keyCATIcomNetAudio     = "cat.icom.net.audio"      // Icom network: stream RX audio on 50003 (experimental)
+	keyAudioMonitorOn      = "audio.monitor.on"        // play the network RX audio through the Listening device (the stream itself stays open for the recorder either way)
 	keyCATTCIHost          = "cat.tci.host"            // TCI host (Expert Electronics SunSDR / ExpertSDR2)
 	keyCATTCIPort          = "cat.tci.port"            // TCI WebSocket port (default 40001)
 	keyCATTCISpots         = "cat.tci.spots"           // push cluster spots to the TCI panorama
@@ -402,6 +405,8 @@ const (
 
 	keyExtLoTWTQSLPath     = "extsvc.lotw.tqsl_path"
 	keyExtLoTWStationLoc   = "extsvc.lotw.station_location"
+	keyExtLoTWQSLDetail    = "extsvc.lotw.qsl_detail"             // ask LoTW for the QSL dates and station details (an order of magnitude slower)
+	keyExtLoTWAllCalls     = "extsvc.lotw.download_all_calls"     // download confirmations for EVERY call on the account, not just this profile's
 	keyExtLoTWForceCall    = "extsvc.lotw.force_station_callsign" // override STATION_CALLSIGN at sign time (e.g. F4BPO/P on the F4BPO cert)
 	keyExtLoTWKeyPassword  = "extsvc.lotw.key_password"
 	keyExtLoTWUploadFlag   = "extsvc.lotw.upload_flag"  // legacy single flag (migrated to upload_flags)
@@ -733,6 +738,15 @@ type App struct {
 	uls          *uls.Store // US callsign→county/grid (offline FCC ULS), lazily opened
 	awardRefs    *awardref.Repo
 	qslTemplates *qslcard.Repo
+	watchlist    *watchlist.Store     // Tools → Watchlist (global watchlist.json)
+	watchAlertMu sync.Mutex           // throttles watchlist alerts…
+	watchAlertAt map[string]time.Time // …per entry
+
+	// WSJT-X decode highlighting (message 13) — see app_wsjt_highlight.go.
+	wsjtHighlightOn atomic.Bool
+	wsjtHLMu        sync.Mutex
+	wsjtHLSent      map[string]string
+	watchPattern    atomic.Value // auto-contest pattern (string), loaded at startup
 	operating       *operating.Repo
 	udp             *udp.Manager
 	udpRepo         *udp.Repo
@@ -1013,6 +1027,13 @@ func (a *App) startup(ctx context.Context) {
 		return
 	}
 	a.dataDir = dataDir
+	// The watchlist needs nothing but its file, so it opens FIRST. It used to be
+	// created after the logbook connect, and a remote MySQL dial of 10-30 s left
+	// the tab saying "Watchlist: 0" until the next refresh tick — twenty seconds
+	// of an empty list for a JSON file that reads in a millisecond. (The
+	// auto-contest pattern still loads later, once the settings store is open.)
+	a.watchlist = watchlist.New(filepath.Join(dataDir, "watchlist.json"))
+	a.watchAlertAt = map[string]time.Time{}
 	// Settings/config database (settings + profiles). Fresh installs use
 	// settings.db; existing installs keep their opslog.db (which also held the
 	// QSOs before they were split into a dedicated logbook file — see below).
@@ -1189,6 +1210,11 @@ func (a *App) startup(ctx context.Context) {
 	a.operating = operating.NewRepo(conn)
 	a.udpRepo = udp.NewRepo(conn)
 	a.udp = udp.NewManager(a.udpRepo)
+	// A program heard for the first time is asked to replay the decodes already
+	// on its screen, so the FT decodes panel starts full instead of waiting a
+	// period. Replayed decodes arrive marked not-new and are shown but never
+	// auto-answered.
+	a.udp.SetOnNewInstance(func(id string) { _ = a.udp.SendReplay(id) })
 	go a.consumeUDPEvents()
 	a.cache = lookup.NewCache(conn, 30*24*time.Hour)
 	a.lookup = lookup.NewManager(a.cache)
@@ -1237,6 +1263,49 @@ func (a *App) startup(ctx context.Context) {
 			go a.applyRelayAuto(s.FreqHz, s.Band)
 		}
 	})
+	// Digital Voice Keyer + QSO recorder (WASAPI). Idle until used. Created
+	// BEFORE the CAT link comes up, and it matters: a network Icom with RX
+	// audio enabled builds its audio sink inside reloadCAT, gated on audioMgr —
+	// when the manager was created later, every fresh launch connected with
+	// audio silently off, and the operator had to untick/save/retick the option
+	// to hear anything.
+	a.audioMgr = audio.NewManager(func() {
+		st := a.dvkStatus()
+		// When a voice message finishes (or is stopped), drop the PTT we keyed
+		// for it — but tag the release with the current key generation so it
+		// can't cut a transmission a newer message already started.
+		if !st.Playing {
+			a.pttMu.Lock()
+			keyed := a.dvkPttKeyed
+			gen := a.pttGen
+			if keyed {
+				a.dvkPttKeyed = false
+			}
+			a.pttMu.Unlock()
+			if keyed {
+				go a.dvkUnkeyPTT(gen)
+			}
+			// And give the microphone back, if we took it (see raiseFlexDVKDax).
+			// Off the callback's goroutine: this talks to the radio, and the
+			// audio manager is reporting a state change, not waiting on us.
+			go a.lowerFlexDVKDax()
+		}
+		if a.ctx != nil {
+			wruntime.EventsEmit(a.ctx, "audio:status", st)
+		}
+	})
+	a.qsoRec = audio.NewRecorder()
+	if a.audioMgr != nil {
+		// A running monitor picks the new level up immediately: the operator is
+		// listening while they move the slider, and asking them to stop and
+		// restart it to hear the change is how a working control gets reported
+		// as broken.
+		if cfg, err := a.GetAudioSettings(); err == nil {
+			a.audioMgr.SetMonitorGain(cfg.FromGain)
+		}
+	}
+	a.startQSORecorderIfEnabled()
+
 	a.reloadCAT()
 
 	// The QSO logbook lives where the ACTIVE PROFILE points it: the local SQLite
@@ -1383,6 +1452,9 @@ func (a *App) startup(ctx context.Context) {
 	// 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...) })
+	a.startWatchlistClubLog()
+	a.watchPattern.Store(strings.ToUpper(strings.TrimSpace(a.settingOr(keyWatchlistContestPattern, ""))))
+	a.wsjtHighlightOn.Store(a.settingOr(keyWsjtHighlight, "0") == "1")
 	go a.pota.Run(a.ctx)
 
 	// DX Cluster (multi-server): the spot callback enriches each spot
@@ -1462,44 +1534,6 @@ func (a *App) startup(ctx context.Context) {
 	})
 	a.solar.Start()
 
-	// Digital Voice Keyer + QSO recorder (WASAPI). Idle until used.
-	a.audioMgr = audio.NewManager(func() {
-		st := a.dvkStatus()
-		// When a voice message finishes (or is stopped), drop the PTT we keyed
-		// for it — but tag the release with the current key generation so it
-		// can't cut a transmission a newer message already started.
-		if !st.Playing {
-			a.pttMu.Lock()
-			keyed := a.dvkPttKeyed
-			gen := a.pttGen
-			if keyed {
-				a.dvkPttKeyed = false
-			}
-			a.pttMu.Unlock()
-			if keyed {
-				go a.dvkUnkeyPTT(gen)
-			}
-			// And give the microphone back, if we took it (see raiseFlexDVKDax).
-			// Off the callback's goroutine: this talks to the radio, and the
-			// audio manager is reporting a state change, not waiting on us.
-			go a.lowerFlexDVKDax()
-		}
-		if a.ctx != nil {
-			wruntime.EventsEmit(a.ctx, "audio:status", st)
-		}
-	})
-	a.qsoRec = audio.NewRecorder()
-	if a.audioMgr != nil {
-		// A running monitor picks the new level up immediately: the operator is
-		// listening while they move the slider, and asking them to stop and
-		// restart it to hear the change is how a working control gets reported
-		// as broken.
-		if cfg, err := a.GetAudioSettings(); err == nil {
-			a.audioMgr.SetMonitorGain(cfg.FromGain)
-		}
-	}
-	a.startQSORecorderIfEnabled()
-
 	// NET Control store (global JSON, shared across logbooks).
 	if ns, err := netctl.Open(filepath.Join(a.dataDir, "nets.json")); err != nil {
 		applog.Printf("netctl: open failed: %v", err)
@@ -1794,6 +1828,9 @@ func (a *App) setSettingGlobal(key, val string) {
 }
 
 func (a *App) shutdown(ctx context.Context) {
+	if a.watchlist != nil {
+		a.watchlist.Flush() // the save debounce would lose the last edits
+	}
 	// If the user managed to skip beforeClose (force kill, OS shutdown,
 	// crash recovery) we still try the backup here as a best-effort
 	// safety net. HasBackupToday makes a double-run a no-op.
@@ -2122,6 +2159,21 @@ func (a *App) saveWindowState() {
 // position — which options can't express — remains, and it is set here while the
 // window is still hidden, so there is no visible jump. Nothing to do for a
 // maximised or first-run window.
+// moveWindowTo places the window at an ABSOLUTE desktop coordinate — the same
+// coordinate system WindowGetPosition reports and window.json stores.
+//
+// Wails' WindowSetPosition is relative to the current monitor's work area (see
+// windowpos_windows.go), so on a monitor left of the primary one it added that
+// monitor's negative origin to an already-absolute value and the window walked
+// one screen further off the desktop at every launch. Fall back to it only when
+// we cannot place the window ourselves — on the primary monitor the two agree.
+func (a *App) moveWindowTo(x, y int) {
+	if setWindowPosAbsolute(x, y) {
+		return
+	}
+	wruntime.WindowSetPosition(a.ctx, x, y)
+}
+
 func (a *App) restoreWindowPosition() {
 	if a.ctx == nil {
 		return
@@ -2149,7 +2201,7 @@ func (a *App) restoreWindowPosition() {
 			return
 		}
 		wruntime.WindowUnmaximise(a.ctx)
-		wruntime.WindowSetPosition(a.ctx, ws.X, ws.Y)
+		a.moveWindowTo(ws.X, ws.Y)
 		wruntime.WindowMaximise(a.ctx)
 		gx, gy := wruntime.WindowGetPosition(a.ctx)
 		applog.Printf("window: re-maximised at the saved corner — now at %d,%d", gx, gy)
@@ -2177,10 +2229,13 @@ func (a *App) restoreWindowPosition() {
 		}
 		applog.Printf("window: saved position %d,%d is off every monitor (%s) — moved to %d,%d",
 			ws.X, ws.Y, describeMonitors(monitorRects()), nx, ny)
-		wruntime.WindowSetPosition(a.ctx, nx, ny)
+		a.moveWindowTo(nx, ny)
 		return
 	}
-	wruntime.WindowSetPosition(a.ctx, ws.X, ws.Y)
+	a.moveWindowTo(ws.X, ws.Y)
+	if gx, gy := wruntime.WindowGetPosition(a.ctx); gx != ws.X || gy != ws.Y {
+		applog.Printf("window: asked for %d,%d and the window reports %d,%d", ws.X, ws.Y, gx, gy)
+	}
 }
 
 // onSomeMonitor reports whether a window at these coordinates would land on the
@@ -3338,6 +3393,10 @@ func (a *App) applyStationDefaults(q *qso.QSO, includeIdentity bool) {
 	// Per-band rig/antenna from Operating conditions (the antenna ticked as
 	// DEFAULT for this band) — the same auto-fill the entry strip does, applied
 	// here so imported QSOs get MY_RIG / MY_ANTENNA from the band defaults.
+	// The radio that is CONNECTED names itself first — see activeRadioMyRig.
+	if q.MyRig == "" {
+		q.MyRig = a.activeRadioMyRig()
+	}
 	if a.operating != nil && q.Band != "" && (q.MyRig == "" || q.MyAntenna == "") {
 		if d, ok, _ := a.operating.BandDefault(a.ctx, p.ID, q.Band); ok {
 			if q.MyRig == "" {
@@ -6914,6 +6973,28 @@ func (a *App) BulkUpdateField(ids []int64, field, value string) (int64, error) {
 	if field == "freq" {
 		return a.bulkSetFrequency(ids, value)
 	}
+	// The station-side numbers. Bounded so a slip cannot stamp CQ zone 400 on a
+	// thousand rows: DXCC entities stop short of 1000, CQ zones at 40, ITU at 90.
+	// Empty clears (NULL).
+	if field == "my_dxcc" || field == "my_cq_zone" || field == "my_itu_zone" {
+		var vp *int
+		if t := strings.TrimSpace(value); t != "" {
+			v, err := strconv.Atoi(t)
+			max := map[string]int{"my_dxcc": 999, "my_cq_zone": 40, "my_itu_zone": 90}[field]
+			if err != nil || v < 1 || v > max {
+				return 0, fmt.Errorf("%s must be a number between 1 and %d (empty to clear)", field, max)
+			}
+			vp = &v
+		}
+		n, err := a.qso.BulkSetIntField(a.ctx, ids, field, vp)
+		if err != nil {
+			return 0, err
+		}
+		if n > 0 {
+			a.invalidateAwardStats()
+		}
+		return n, nil
+	}
 	// Some ADIF fields have no promoted column and live in extras_json
 	// (OWNER_CALLSIGN) — those take the JSON path so the rest of the extras on
 	// each QSO survive the edit.
@@ -7228,7 +7309,9 @@ func (a *App) SetCompactMode(on bool) {
 		wruntime.WindowSetMinSize(a.ctx, normalMinW, normalMinH)
 		if a.preCompactValid {
 			wruntime.WindowSetSize(a.ctx, a.preCompactW, a.preCompactH)
-			wruntime.WindowSetPosition(a.ctx, a.preCompactX, a.preCompactY)
+			// Absolute, like the capture — see moveWindowTo. Leaving compact mode on a
+			// monitor left of the primary one moved the window a screen further out.
+			a.moveWindowTo(a.preCompactX, a.preCompactY)
 			if a.preCompactMax {
 				wruntime.WindowMaximise(a.ctx)
 			}
@@ -8369,7 +8452,7 @@ func (a *App) ListAudioInputDevices() ([]audio.Device, error) {
 		return devs, err
 	}
 	if a.tciAudioAvailable() {
-		devs = append([]audio.Device{{ID: audio.NetworkDeviceID, Name: "Radio (TCI network audio)"}}, devs...)
+		devs = append([]audio.Device{{ID: audio.NetworkDeviceID, Name: "Radio (network audio)"}}, devs...)
 	}
 	return devs, nil
 }
@@ -8396,7 +8479,7 @@ func (a *App) ListAudioOutputDevices() ([]audio.Device, error) {
 		return devs, err
 	}
 	if audio.NetworkPlayerReady() {
-		devs = append([]audio.Device{{ID: audio.NetworkDeviceID, Name: "Radio (TCI network audio)"}}, devs...)
+		devs = append([]audio.Device{{ID: audio.NetworkDeviceID, Name: "Radio (network audio)"}}, devs...)
 	}
 	return devs, nil
 }
@@ -8927,6 +9010,11 @@ func (a *App) clusterEventWorker() {
 				}
 			}
 		}
+		// SOTA: the summit is in the spot's own text — the SOTA feeds put it
+		// there — so it costs a regex rather than an API lookup.
+		if s.SOTARef == "" {
+			s.SOTARef = cluster.SOTARefFrom(s.Comment)
+		}
 		// POTA: tag the spot when the DX station is currently activating a park.
 		if a.pota != nil {
 			if info, ok := a.pota.Lookup(s.DXCall); ok {
@@ -8950,6 +9038,10 @@ func (a *App) clusterEventWorker() {
 		a.detectBandOpening(s)
 		// Fire any matching alert rules (sound / visual / e-mail).
 		a.evaluateAlerts(s)
+		// The watchlist sees the same live stream the alerts do — never the
+		// SH/DX replay above, which would mark forty stations "just seen" with
+		// spots from three hours ago.
+		a.watchSpot(s.DXCall, s.Band, alerts.InferMode(s.Comment, s.FreqHz), s.Country, s.Comment, s.FreqHz)
 		// Mirror the spot onto the FlexRadio panadapter when enabled. Infer the
 		// mode (from the comment, else the band plan) so clicking the spot on the
 		// panadapter tunes AND switches mode — a DX cluster line carries no mode,
@@ -9187,7 +9279,9 @@ func (a *App) QSOAudioManualReady() bool {
 		return false
 	}
 	cfg, _ := a.GetAudioSettings()
-	return !cfg.QSORecord && strings.TrimSpace(cfg.FromRadio) != ""
+	// Over the network the radio needs no sound card: the 50003 stream is the
+	// source, so the button is offered even with "From radio" empty.
+	return !cfg.QSORecord && (strings.TrimSpace(cfg.FromRadio) != "" || a.icomNetAudioActive())
 }
 
 // QSOAudioManualStart begins a recording when automatic recording is off.
@@ -9204,10 +9298,19 @@ func (a *App) QSOAudioManualStart() bool {
 	}
 	if !a.qsoRec.Running() {
 		cfg, _ := a.GetAudioSettings()
-		if strings.TrimSpace(cfg.FromRadio) == "" {
+		// Same source rule as the automatic recorder: when the RX audio arrives
+		// over the network, record THAT — not the "From radio" sound card, which
+		// on a mixed station is another radio entirely. A manual take on the
+		// network IC-7760 was capturing the Flex's DAX: technically a recording,
+		// just not of the QSO being made.
+		from := cfg.FromRadio
+		a.qsoRecPushed = a.icomNetAudioActive() || cfg.FromRadio == audio.NetworkDeviceID
+		if a.qsoRecPushed {
+			from = audio.PushedSource
+		} else if strings.TrimSpace(from) == "" {
 			return false
 		}
-		if err := a.qsoRec.Start(cfg.FromRadio, cfg.RecordingDevice, cfg.PrerollSeconds); err != nil {
+		if err := a.qsoRec.Start(from, cfg.RecordingDevice, cfg.PrerollSeconds); err != nil {
 			applog.Printf("qso-rec: manual start failed: %v", err)
 			return false
 		}
@@ -10589,6 +10692,26 @@ func (a *App) AudioStartMonitor() error {
 		return fmt.Errorf("audio not initialized")
 	}
 	cfg, _ := a.GetAudioSettings()
+	// Idempotent: asking to listen while a monitor is already running restarts
+	// it instead of refusing. The refusal surfaced as a checkbox that unticked
+	// itself the instant it was ticked, whenever the UI's idea of the state and
+	// the real monitor had drifted apart.
+	a.audioMgr.StopMonitor()
+	// When the rig's audio arrives over the NETWORK (Icom 50003), the monitor
+	// must be render-only: this button used to start a USB capture from the
+	// "From radio" device as well, and that second producer — often another
+	// radio's DAX — interleaved its chunks with the network stream's pushes.
+	// The result was audio chopped to pieces the moment the operator toggled
+	// Listening off and on while connected to a network Icom.
+	if cs, err := a.GetCATSettings(); err == nil && cs.Enabled && cs.Backend == "icom-net" && cs.IcomNetAudio {
+		a.setSetting(keyAudioMonitorOn, "1")
+		applog.Printf("audio: RX monitor start (network sink only → listen=%q)", cfg.ListeningDevice)
+		return a.audioMgr.StartMonitorSink(cfg.ListeningDevice)
+	}
+	// Only the USB path needs a capture device — checked AFTER the network
+	// branch, which needs none: with From-radio empty (the normal network
+	// setup) this refusal was un-ticking the speakers checkbox the instant it
+	// was ticked.
 	if strings.TrimSpace(cfg.FromRadio) == "" {
 		return fmt.Errorf(`no "From radio" capture device set — pick the rig's USB Audio CODEC in Settings → Audio`)
 	}
@@ -10599,6 +10722,7 @@ func (a *App) AudioStartMonitor() error {
 
 // AudioStopMonitor stops the RX monitor passthrough.
 func (a *App) AudioStopMonitor() {
+	a.setSetting(keyAudioMonitorOn, "0")
 	if a.audioMgr != nil {
 		a.audioMgr.StopMonitor()
 		applog.Printf("audio: RX monitor stopped")
@@ -10621,9 +10745,44 @@ func (a *App) AudioStartTX() error {
 	if strings.TrimSpace(cfg.ToRadio) == "" {
 		return fmt.Errorf(`no "To radio" device set — pick the rig's USB Audio CODEC output in Settings → Audio`)
 	}
+	// Live mic over the radio's own link: the To-radio "device" is the radio.
+	// Fetched before keying so a missing stream refuses cleanly with the PTT
+	// never touched.
+	var netSend func([]byte) error
+	if cfg.ToRadio == audio.NetworkDeviceID {
+		if strings.TrimSpace(cfg.RecordingDevice) == "" {
+			return fmt.Errorf("pick your microphone as the Recording mic in Settings → Audio")
+		}
+		type sender interface {
+			TXAudioSender() (func([]byte) error, error)
+		}
+		err := a.cat.IcomDo(func(ic cat.IcomController) error {
+			p, ok := ic.(sender)
+			if !ok {
+				return fmt.Errorf("this radio cannot take live microphone audio over its link yet")
+			}
+			fn, err := p.TXAudioSender()
+			if err != nil {
+				return err
+			}
+			netSend = fn
+			return nil
+		})
+		if err != nil {
+			return err
+		}
+	}
 	if err := a.pttKey(cfg); err != nil { // key first — no point streaming to a rig that isn't transmitting
 		return err
 	}
+	if netSend != nil {
+		if err := a.audioMgr.StartTXAudioNetwork(cfg.RecordingDevice, netSend); err != nil {
+			a.pttUnkey()
+			return err
+		}
+		applog.Printf("audio: TX start (mic=%q → the radio over the network, ptt=%q)", cfg.RecordingDevice, cfg.PTTMethod)
+		return nil
+	}
 	if err := a.audioMgr.StartTXAudio(cfg.RecordingDevice, cfg.ToRadio); err != nil {
 		a.pttUnkey()
 		return err
@@ -11295,11 +11454,19 @@ func (a *App) runManualUpload(svc extsvc.Service, ids []int64, cfg extsvc.Extern
 		}
 		res, err := extsvc.UploadLoTW(ctx, cfg.LoTW, "", strings.Join(recs, "\n"))
 		if err != nil || !res.OK {
-			msg := res.Message
+			// The DETAIL wins over the error string. UploadLoTW returns both: a
-			if err != nil {
+			// terse error ("no QSOs processed") and a Message carrying TQSL's own
+			// account of what happened to the contacts ("…already uploaded", "…out
+			// of date range"). Taking the error whenever there was one threw the
+			// answer away and showed the operator the half that explains nothing.
+			msg := strings.TrimSpace(res.Message)
+			if msg == "" && err != nil {
 				msg = err.Error()
+			} else if err != nil && !strings.Contains(msg, err.Error()) {
+				msg = msg + " (" + err.Error() + ")"
 			}
 			emit("LoTW upload failed: " + msg)
+			emit("  The station location OpsLog signs with must match the callsign on these contacts, and their dates must fall inside the certificate's validity — TQSL refuses the whole batch otherwise.")
 			// The qslmgr:log console is only visible in the QSL Manager — a failure
 			// triggered from the Recent QSOs right-click was completely silent, which
 			// read as "send to LoTW does nothing". Surface it as a toast too.
@@ -11537,6 +11704,10 @@ func (a *App) runManualUpload(svc extsvc.Service, ids []int64, cfg extsvc.Extern
 // with award-style NEW flags computed against the log's prior confirmations.
 type ConfirmationItem struct {
 	Callsign string `json:"callsign"`
+	// Station is the callsign the QSO was made UNDER, which the download can now
+	// span ("All my callsigns"): a list mixing F4BPO, F4BPO/P and TM2Q says
+	// nothing useful unless each line says which of them it belongs to.
+	Station string `json:"station"`
 	QSODate string `json:"qso_date"` // ISO UTC
 	Band    string `json:"band"`
 	Mode    string `json:"mode"`
@@ -12087,6 +12258,27 @@ func manualRefFor(existing, code string) string {
 	return ""
 }
 
+// GetLoTWQSLDetail reports whether the download asks LoTW for the QSL detail.
+func (a *App) GetLoTWQSLDetail() bool {
+	return a.settingOr(keyExtLoTWQSLDetail, "") == "1"
+}
+
+// SetLoTWQSLDetail stores that choice.
+func (a *App) SetLoTWQSLDetail(on bool) {
+	a.setSetting(keyExtLoTWQSLDetail, map[bool]string{true: "1", false: "0"}[on])
+}
+
+// GetLoTWDownloadAllCalls reports whether the LoTW download ignores the
+// profile's own call and pulls every callsign on the account.
+func (a *App) GetLoTWDownloadAllCalls() bool {
+	return a.settingOr(keyExtLoTWAllCalls, "") == "1"
+}
+
+// SetLoTWDownloadAllCalls stores that choice.
+func (a *App) SetLoTWDownloadAllCalls(on bool) {
+	a.setSetting(keyExtLoTWAllCalls, map[bool]string{true: "1", false: "0"}[on])
+}
+
 // DownloadConfirmations pulls confirmed QSOs from a service and updates the
 // matching local QSOs' received status. LoTW only for now (the canonical
 // confirmation system); runs in the background emitting the same
@@ -12158,7 +12350,30 @@ func (a *App) runDownloadConfirmations(ctx context.Context, svc extsvc.Service,
 	case extsvc.ServiceLoTW:
 		sinceDate := resolveSince(keyExtLoTWLastDownload)
 		ownCall := a.uploadOwnerCall(extsvc.ServiceLoTW)
+		// A LoTW account holds every call its owner operates — F4BPO, F4BPO/P,
+		// TM2Q — and the download is normally scoped to the profile's own call so
+		// one profile does not pull another's confirmations. That scope also
+		// silently hides them: a QSO made as F4BPO/P is confirmed at LoTW and can
+		// never be downloaded from the F4BPO profile, so it stays unconfirmed here
+		// for good while the ARRL counts it. Off by default, because the scope is
+		// right for anyone whose profiles are separate stations.
+		if a.settingOr(keyExtLoTWAllCalls, "") == "1" {
+			ownCall = ""
+		}
 		callLabel := ownCall
+		// Unscoped, the report carries every station on the account — including
+		// the ones belonging to ANOTHER profile's logbook (a Vietnam expedition,
+		// say). Those confirmations have nothing to match here, and with "add the
+		// ones not found" ticked they would pour a second log into this one. So
+		// the station callsigns this logbook actually holds become the filter:
+		// F4BPO/P is kept because it was worked here, XV9Q is skipped because it
+		// never was.
+		var ownStations map[string]bool
+		if ownCall == "" {
+			if st, e := a.qso.StationCallsigns(ctx); e == nil && len(st) > 0 {
+				ownStations = st
+			}
+		}
 		if callLabel == "" {
 			callLabel = "all callsigns"
 		}
@@ -12168,13 +12383,36 @@ func (a *App) runDownloadConfirmations(ctx context.Context, svc extsvc.Service,
 			emit(fmt.Sprintf("Downloading all LoTW confirmations for %s…", callLabel))
 		}
 		emit(fmt.Sprintf("Window: since=%q → resolved=%q (scope owncall=%q)", since, sinceDate, ownCall))
-		adifText, err := extsvc.DownloadLoTWConfirmations(ctx, nil, cfg.LoTW, sinceDate, ownCall)
+		// The report arrives over minutes, and a window that says nothing while it
+		// does is indistinguishable from one that has hung — which is what it was
+		// being reported as. Every half-megabyte, say how much has landed.
+		// Adding the QSOs LoTW knows and we do not is the one job that needs the
+		// slow report: without the detail those records would come in with no
+		// grid, state or county, and nothing else would ever fill them.
+		detail := addNotFound || a.settingOr(keyExtLoTWQSLDetail, "") == "1"
+		if detail {
+			emit("Asking for the QSL details too — LoTW takes considerably longer to build that report.")
+		}
+		adifText, err := extsvc.DownloadLoTWConfirmations(ctx, nil, cfg.LoTW, sinceDate, ownCall, detail, emit)
 		if err != nil {
 			emit("Download failed: " + err.Error())
 			done(matched, total)
 			return
 		}
 		emit(fmt.Sprintf("LoTW returned %d KB of ADIF", len(adifText)/1024))
+		// A report far smaller than the account justifies is the one failure that
+		// looks like success: LoTW answers 200 with a near-empty ADIF when it
+		// disagrees with the query (an unknown callsign in qso_owncall, a login
+		// that half-worked). Show its own header rather than leaving "matched 1 of
+		// 1" to be read as "you have one confirmation".
+		if len(adifText) < 4096 {
+			head := strings.TrimSpace(adifText)
+			if len(head) > 400 {
+				head = head[:400]
+			}
+			emit("The report is unexpectedly small — what LoTW actually sent:")
+			emit("  " + strings.Join(strings.Fields(head), " "))
+		}
 		keyIDs, kerr := a.qso.DedupeKeyIDs(ctx)
 		if kerr != nil {
 			emit("Error reading local log: " + kerr.Error())
@@ -12192,6 +12430,7 @@ func (a *App) runDownloadConfirmations(ctx context.Context, svc extsvc.Service,
 		sets, _ := a.qso.ConfirmedSlots(ctx, []string{"lotw_rcvd", "qsl_rcvd"})
 		var items []ConfirmationItem
 		var unmatched []string
+		skippedOtherStation := 0
 		perr := adif.Parse(strings.NewReader(adifText), func(rec adif.Record) error {
 			if ctx.Err() != nil {
 				return ctx.Err() // window closed / superseded
@@ -12200,6 +12439,16 @@ func (a *App) runDownloadConfirmations(ctx context.Context, svc extsvc.Service,
 			if !ok {
 				return nil
 			}
+			// Another station's confirmation — see ownStations above. Counted so
+			// the report says how many were left alone rather than silently
+			// dropping a third of the file.
+			if ownStations != nil {
+				st := strings.ToUpper(strings.TrimSpace(rec["station_callsign"]))
+				if st != "" && !ownStations[st] {
+					skippedOtherStation++
+					return nil
+				}
+			}
 			total++
 			date := rec["qslrdate"]
 			if date == "" {
@@ -12248,6 +12497,7 @@ func (a *App) runDownloadConfirmations(ctx context.Context, svc extsvc.Service,
 			}
 			it := ConfirmationItem{
 				Callsign: q.Callsign,
+				Station:  strings.ToUpper(strings.TrimSpace(rec["station_callsign"])),
 				QSODate:  q.QSODate.UTC().Format(time.RFC3339),
 				Band:     q.Band,
 				Mode:     q.Mode,
@@ -12280,6 +12530,9 @@ func (a *App) runDownloadConfirmations(ctx context.Context, svc extsvc.Service,
 		} else {
 			emit(fmt.Sprintf("Matched %d of %d confirmed QSO(s)", matched, total))
 		}
+		if skippedOtherStation > 0 {
+			emit(fmt.Sprintf("  (%d confirmation(s) skipped — made under a callsign this logbook has never used)", skippedOtherStation))
+		}
 		if byClass > 0 {
 			// Said out loud rather than folded silently into the total: these
 			// matched on the mode CLASS, not the mode. LoTW hands back "DATA" for
@@ -13401,7 +13654,12 @@ func (a *App) LogUDPLoggedADIF(adifText string) (int64, error) {
 
 	// ── Operating-conditions stamp ──
 	// Pre-fill MY_RIG / MY_ANTENNA / TX_PWR from the default antenna for
-	// this band (if the user has configured Operating conditions).
+	// this band (if the user has configured Operating conditions) — after the
+	// connected radio has had its say, since it knows which rig is keying and
+	// the band default only knows which one was planned.
+	if q.MyRig == "" {
+		q.MyRig = a.activeRadioMyRig()
+	}
 	if a.operating != nil && a.profiles != nil {
 		if p, err := a.profiles.Active(a.ctx); err == nil {
 			if d, ok2, _ := a.operating.BandDefault(a.ctx, p.ID, q.Band); ok2 {
@@ -13658,7 +13916,13 @@ func (a *App) consumeUDPEvents() {
 				"low_conf": ev.DecodeLowConf,
 				"mode_raw": ev.DecodeModeRaw,
 				"msg_raw":  ev.DecodeMsgRaw,
+				// false on a Replay's resent history — shown, never auto-answered.
+				"is_new": ev.DecodeIsNew,
 			})
+			// Log-aware colour in the decoder's own window (see
+			// app_wsjt_highlight.go). After the emit: painting must never delay
+			// the panel.
+			a.maybeHighlightDecode(ev.ProgramID, ev.DecodeCall, bandForHz(ev.DecodeFreqHz))
 			// A WSJT-X decode (heard station). Render it on the FlexRadio
 			// panadapter when the option is on; green + SNR comment, auto-expiring
 			// after the configured duration. De-duped per call in the Flex backend.
@@ -14286,6 +14550,23 @@ func (a *App) IcomSetSplit(on bool) error {
 	return a.cat.IcomDo(func(ic cat.IcomController) error { return ic.SetIcomSplit(on) })
 }
 
+// IcomSetATU puts the internal tuner in or out of line.
+func (a *App) IcomSetATU(on bool) error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	return a.cat.IcomDo(func(ic cat.IcomController) error { return ic.SetATU(on) })
+}
+
+// IcomSetSplitOffset turns split on with a chosen TX offset (Hz) — the
+// console's +1/+5/+10 kHz buttons.
+func (a *App) IcomSetSplitOffset(hz int64) error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	return a.cat.IcomDo(func(ic cat.IcomController) error { return ic.SetIcomSplitOffset(true, hz) })
+}
+
 func (a *App) IcomSetAntenna(n int) error {
 	if a.cat == nil {
 		return fmt.Errorf("cat not initialized")
@@ -14502,6 +14783,36 @@ func (a *App) FlexBackspaceCW(n int) error {
 	return a.cat.FlexDo(func(fc cat.FlexController) error { return fc.BackspaceCW(n) })
 }
 
+// TCISendCW keys a CW message through the SunSDR's own macro keyer, so a TCI
+// station needs no WinKeyer and no second serial port. Text is already
+// variable-resolved by the UI.
+func (a *App) TCISendCW(text string) error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	err := a.cat.TCICWDo(func(tc cat.TCICWController) error { return tc.SendCW(text) })
+	if err != nil {
+		applog.Printf("tci cw: TCISendCW(%q) failed: %v", text, err)
+	}
+	return err
+}
+
+// TCIStopCW aborts whatever the keyer is sending.
+func (a *App) TCIStopCW() error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	return a.cat.TCICWDo(func(tc cat.TCICWController) error { return tc.StopCW() })
+}
+
+// TCISetKeySpeed sets the macro keyer speed in WPM.
+func (a *App) TCISetKeySpeed(wpm int) error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	return a.cat.TCICWDo(func(tc cat.TCICWController) error { return tc.SetCWSpeed(wpm) })
+}
+
 // IcomStopCW aborts the CW message currently being sent.
 func (a *App) IcomStopCW() error {
 	if a.cat == nil {
@@ -15360,9 +15671,11 @@ func (a *App) reloadCAT() {
 			// verification (see icomaudio.go) — hence experimental + opt-in.
 			acfg, _ := a.GetAudioSettings()
 			a.audioMgr.StopMonitor() // clear any prior monitor/sink so a re-save restarts cleanly
-			if err := a.audioMgr.StartMonitorSink(acfg.ListeningDevice); err != nil {
+			// The SINK — decode + recorder feed — exists whenever the stream is
-				applog.Printf("icom-net audio: cannot start output sink: %v", err)
+			// on. It used to be built only when the speakers were also wanted,
-			} else {
+			// so "speakers off" (or a sink that failed to open) silently turned
+			// the whole stream off: audio=false on the wire, no recordings, no
+			// voice keyer, and a ticked RX-audio checkbox that did nothing.
 			codec := audio.NewPCM16Codec()
 			audioSink = func(payload []byte) {
 				pcm, err := codec.Decode(payload)
@@ -15377,10 +15690,23 @@ func (a *App) reloadCAT() {
 					a.qsoRec.PushRX(pcm)
 				}
 			}
+			// Listening is a CHOICE, remembered: an operator sitting next to the
+			// radio hears it in the room and wants the stream only for the
+			// recorder and the voice keyer. Stop listening turns this off, the
+			// Listen button turns it back on, and reconnects respect it instead
+			// of switching the speakers back on every time.
+			if a.settingOr(keyAudioMonitorOn, "1") != "1" {
+				applog.Printf("icom-net audio: stream on, speakers off (Listening was stopped by the operator)")
+			} else if err := a.audioMgr.StartMonitorSink(acfg.ListeningDevice); err != nil {
+				applog.Printf("icom-net audio: stream on, but the output sink failed: %v", err)
+			} else {
 				applog.Printf("icom-net audio: RX audio streaming ENABLED (experimental) → %q", acfg.ListeningDevice)
 			}
 		}
 		a.cat.Start(cat.NewIcomNet(s.IcomNetHost, s.IcomNetUser, s.IcomNetPass, s.IcomAddr, s.DigitalDefault, audioSink))
+		// With the audio session open the radio can also TAKE audio: offer it to
+		// the voice keyer, the way a TCI radio is offered.
+		a.installIcomTXPlayer(audioSink != nil)
 	case "tci":
 		// Expert Electronics TCI (WebSocket) — SunSDR / ExpertSDR2, or any
 		// TCI-compatible server. The receive audio rides the same socket, so
@@ -19524,7 +19850,8 @@ type SpotStatus struct {
 type clusterStatusCache struct {
 	entities           map[int]*qso.EntitySlot
 	workedCalls        map[string]struct{}
-	workedCallSlots map[string]struct{} // nil unless the "same slot" option is on
+	workedCallSlots    map[string]struct{}
+	workedCallSlotsDig map[string]struct{} // same set, digital modes folded to DIG // nil unless the "same slot" option is on
 	workedCounties     map[string]struct{}
 	// callCounties holds callsign → "STATE,County" for stations already logged
 	// with a county, so a spot shows the county the entry panel showed rather
@@ -19608,8 +19935,18 @@ func (a *App) clusterStatusMaps() *clusterStatusCache {
 	// "Already worked only on the same slot" option (Settings → DX Cluster): the
 	// WORKED-call flag then needs the SAME band and mode (digital-grouped through
 	// the same normMode when that option is on) rather than the call anywhere.
-	if sameSlot || slotHighlight {
+	// Built UNCONDITIONALLY since the watchlist arrived: its per-slot verdict
+	// needs this set whatever the cluster's own display options say, and the
+	// scan already runs at cache-rebuild cadence, not per batch.
 	c.workedCallSlots, _ = a.qso.WorkedCallSlotKeys(a.ctx, c.normMode)
+	// And once more at digital-CLASS grain, for the spots whose mode the band
+	// plan can only call "DATA": a generic mode cannot be matched exactly, so it
+	// is judged against "any digital mode of this call on this band". When the
+	// grouping option is on, workedCallSlots is already at that grain.
+	if c.normMode != nil {
+		c.workedCallSlotsDig = c.workedCallSlots
+	} else {
+		c.workedCallSlotsDig, _ = a.qso.WorkedCallSlotKeys(a.ctx, qso.GroupDigitalMode)
 	}
 	// Orthogonal dimensions: worked US counties (for the ULS callsign→county
 	// lookup) and worked POTA parks.
@@ -20837,3 +21174,30 @@ func (a *App) CheckHamlogKey(key string) (string, error) {
 	defer cancel()
 	return extsvc.CheckHamlogKey(ctx, nil, key)
 }
+
+// GetAudioMonitorPref says whether the network RX audio should be played
+// through the Listening device — the remembered speaker choice behind the
+// console's speaker button and the CAT panel's checkbox.
+func (a *App) GetAudioMonitorPref() bool {
+	return a.settingOr(keyAudioMonitorOn, "1") == "1"
+}
+
+// IcomConsolePTT is the console's PTT button. On a USB station it keys the
+// rig and nothing more — the operator talks into the radio's own microphone.
+// When the transmit audio goes over the NETWORK, keying alone transmits
+// silence: the PC microphone must be routed with it, exactly as the Talk
+// button does. One button, the right road picked here.
+func (a *App) IcomConsolePTT(on bool) error {
+	cfg, _ := a.GetAudioSettings()
+	if cfg.ToRadio == audio.NetworkDeviceID {
+		if on {
+			return a.AudioStartTX()
+		}
+		a.AudioStopTX()
+		return nil
+	}
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	return a.cat.SetPTT(on)
+}

app_icom_dvk.go

@@ -0,0 +1,49 @@
+package main
+
+// The voice keyer, through an Icom's network link — the Icom face of what
+// app_tci_dvk.go does for a SunSDR: selecting the radio as the "To radio"
+// output hands messages to the 50003 audio session instead of a sound card.
+// The same PTT before and after, the same gain, the same files.
+
+import (
+	"fmt"
+
+	"hamlog/internal/applog"
+	"hamlog/internal/audio"
+	"hamlog/internal/cat"
+)
+
+// icomTXPlayer hands one message to the radio. Fetched on the CAT goroutine,
+// played off it — a ten-second message must not freeze frequency, mode and
+// PTT handling for ten seconds (see tciTXPlayer, which set the pattern).
+func (a *App) icomTXPlayer(pcm []byte, rate, ch, bits int, stop <-chan struct{}) error {
+	if a.cat == nil {
+		return fmt.Errorf("CAT not initialized")
+	}
+	type txPlayer interface {
+		PlayTXAudio(pcm []byte, rate, ch, bits int, stop <-chan struct{}) error
+	}
+	var player txPlayer
+	err := a.cat.IcomDo(func(ic cat.IcomController) error {
+		p, ok := ic.(txPlayer)
+		if !ok {
+			return fmt.Errorf("this radio cannot take transmit audio over its CAT link")
+		}
+		player = p
+		return nil
+	})
+	if err != nil {
+		return err
+	}
+	return player.PlayTXAudio(pcm, rate, ch, bits, stop)
+}
+
+// installIcomTXPlayer offers the network Icom as an audio output, or withdraws
+// it. Withdrawing matters as much as offering — see installTCITXPlayer.
+func (a *App) installIcomTXPlayer(on bool) {
+	if !on {
+		return // the reloadCAT preamble already cleared the network player
+	}
+	audio.SetNetworkPlayer(a.icomTXPlayer)
+	applog.Printf("icom net: the radio is available as an audio output — the voice keyer can play to it without a cable")
+}

app_k3.go

@@ -24,6 +24,17 @@ func (a *App) GetKenwoodState() cat.KenwoodTXState {
 	return st
 }
 
+// SetKenwoodPanelMode sets the operating mode from the panel's mode row —
+// CW / USB / LSB / DATA (soundcard, DT0) / RTTY (FSK D, DT2).
+func (a *App) SetKenwoodPanelMode(mode string) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodPanelMode(mode) })
+}
+
+// SetKenwoodRITOffset sets the RIT/XIT offset to an absolute value in Hz.
+func (a *App) SetKenwoodRITOffset(hz int) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodRITOffset(hz) })
+}
+
 func (a *App) SetKenwoodPower(w int) error {
 	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodPower(w) })
 }

app_radios.go

@@ -43,6 +43,14 @@ type RadioConfig struct {
 	// the CAT panel has always edited, so a saved radio is exactly "what the
 	// settings said the day it was saved".
 	Settings CATSettings `json:"settings"`
+	// MyRig is what goes into MY_RIG on a QSO made with this radio.
+	//
+	// It belongs here rather than in Operating conditions once there is more
+	// than one rig: the operating conditions describe a PLAN — "on 20 m I use
+	// the beam and the 7300" — while this is the fact of which radio is keying.
+	// Left empty, nothing changes: the old chain (band default, then the
+	// profile's rig) answers exactly as it did.
+	MyRig string `json:"my_rig"`
 }
 
 // radioLabel is what the status bar shows when the operator never named one.
@@ -204,3 +212,35 @@ func (a *App) syncActiveRadio(s CATSettings) {
 		}
 	}
 }
+
+// activeRadioMyRig is the MY_RIG of the radio currently connected, or "".
+//
+// Consulted BEFORE the per-band default, and deliberately: the band default is
+// what the operator planned to use on that band, this is which radio is
+// actually on the air. When they disagree — a second rig borrowed for one
+// evening on 20 m — the one that is transmitting is the true answer.
+func (a *App) activeRadioMyRig() string {
+	if a.settings == nil || strings.TrimSpace(a.settingOr(keyRadiosList, "")) == "" {
+		return "" // no list was ever made: nothing to say, nothing changes
+	}
+	list, err := a.GetRadios()
+	if err != nil {
+		return ""
+	}
+	id := a.ActiveRadioID()
+	for _, r := range list {
+		if r.ID == id {
+			return strings.TrimSpace(r.MyRig)
+		}
+	}
+	return ""
+}
+
+// ActiveRadioMyRig exposes the connected radio's MY_RIG to the frontend, which
+// pre-fills the entry form's My-station fields on every band change. Without
+// this the per-band default landed in the field FIRST, and the log-time
+// priority (the radio that is keying beats the radio that was planned) never
+// ran — the field was no longer empty by the time the backend looked.
+func (a *App) ActiveRadioMyRig() string {
+	return a.activeRadioMyRig()
+}

app_watchlist.go

@@ -0,0 +1,293 @@
+package main
+
+// Watchlist bindings — the DXHunter watchlist concept as an OpsLog tab.
+// The store lives in internal/watchlist (global watchlist.json, DXHunter's own
+// schema); this file is the Wails boundary plus the two places the list meets
+// the rest of the app: the spot stream (MarkSeen + alert) and the logbook (the
+// worked-today answer contest entries are judged by).
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"hamlog/internal/applog"
+	"hamlog/internal/qso"
+	"hamlog/internal/watchlist"
+
+	wruntime "github.com/wailsapp/wails/v2/pkg/runtime"
+)
+
+// The auto-contest pattern, DXHunter's contest_prefix: while non-empty, any
+// spotted callsign CONTAINING it is added to the watchlist as a contest entry
+// by itself — a special-event fleet (HB9WWA, DL0WWA, F4WWA…) is collected as
+// it appears instead of typed in one by one. Held in an atomic so the spot
+// pipeline never touches the settings store per spot.
+func (a *App) GetWatchlistContestPattern() string {
+	if v := a.watchPattern.Load(); v != nil {
+		return v.(string)
+	}
+	return ""
+}
+
+// SetWatchlistContestPattern stores the pattern (global, like the list itself).
+// Emptying it stops the auto-add; entries already collected stay — deleting an
+// operator's list because a setting changed is DXHunter behaviour this port
+// deliberately drops.
+func (a *App) SetWatchlistContestPattern(p string) {
+	p = strings.ToUpper(strings.TrimSpace(p))
+	a.watchPattern.Store(p)
+	a.setSettingGlobal(keyWatchlistContestPattern, p)
+}
+
+// WatchlistEntries returns the list for the tab.
+func (a *App) WatchlistEntries() []watchlist.Entry {
+	if a.watchlist == nil {
+		return nil
+	}
+	return a.watchlist.Entries()
+}
+
+// WatchlistAdd adds a callsign or prefix; contest entries are judged per UTC day.
+func (a *App) WatchlistAdd(callsign string, contest bool) error {
+	if a.watchlist == nil {
+		return fmt.Errorf("watchlist not initialized")
+	}
+	return a.watchlist.Add(callsign, contest)
+}
+
+// WatchlistRemove deletes an entry.
+func (a *App) WatchlistRemove(callsign string) error {
+	if a.watchlist == nil {
+		return fmt.Errorf("watchlist not initialized")
+	}
+	return a.watchlist.Remove(callsign)
+}
+
+// WatchlistSetNotify arms the existing alert path (sound + toast) for an entry.
+func (a *App) WatchlistSetNotify(callsign string, on bool) error {
+	if a.watchlist == nil {
+		return fmt.Errorf("watchlist not initialized")
+	}
+	return a.watchlist.SetNotify(callsign, on)
+}
+
+// WatchlistSetContest flips the per-entry contest rule.
+func (a *App) WatchlistSetContest(callsign string, on bool) error {
+	if a.watchlist == nil {
+		return fmt.Errorf("watchlist not initialized")
+	}
+	return a.watchlist.SetContest(callsign, on)
+}
+
+// WatchlistSlotQuery asks whether one spot's slot is worked — against the whole
+// log for a normal entry, against TODAY (UTC) for a contest one.
+type WatchlistSlotQuery struct {
+	Call    string `json:"call"`
+	Band    string `json:"band"`
+	Mode    string `json:"mode"`
+	Contest bool   `json:"contest"`
+}
+
+// WatchlistWorkedSlots answers a batch of slot questions for the tab.
+//
+// Normal entries read the CLUSTER's own slot set — the same cached
+// WorkedCallSlotKeys index that colours the grid — so the watchlist can never
+// contradict the cluster about the same spot. That index normalises the mode
+// exactly as the operator configured (digital grouping on → FT4 counts as FT8's
+// class; off → exact mode), and the first version of this ignored that: it
+// asked the alerts' raw-mode index with a CLASS name, matched nothing, and
+// showed a fully-worked DXpedition as all Needed.
+//
+// Contest entries read TODAY's contacts instead — the midnight-UTC reset is
+// the query's date bound, nothing stored, nothing to reset — normalised through
+// the same function so the two answers use one grammar.
+func (a *App) WatchlistWorkedSlots(queries []WatchlistSlotQuery) []bool {
+	out := make([]bool, len(queries))
+	if a.qso == nil || len(queries) == 0 {
+		return out
+	}
+	idx := a.clusterStatusMaps()
+	norm := func(m string) string {
+		m = strings.ToUpper(strings.TrimSpace(m))
+		if idx.normMode != nil {
+			m = idx.normMode(m)
+		}
+		return m
+	}
+	slotKey := func(call, band, mode string) string {
+		up := strings.ToUpper(strings.TrimSpace(call))
+		b := strings.ToLower(strings.TrimSpace(band))
+		if m := norm(mode); m != "" {
+			return up + "|" + b + "|" + m
+		}
+		return up + "|" + b
+	}
+	// A spot whose mode the band plan could only call "DATA" (an F/H DXpedition
+	// off the standard dials, a comment with no mode) cannot be matched exactly:
+	// "DATA" is in nobody's log. Such a spot is judged at digital-CLASS grain —
+	// worked if ANY digital mode of that call is logged on that band. Claiming
+	// NEW MODE because the label differs from FT8 was the reported bug.
+	generic := func(m string) bool {
+		switch strings.ToUpper(strings.TrimSpace(m)) {
+		case "", "DATA", "DIG", "DIGI", "DIGITAL":
+			return true
+		}
+		return false
+	}
+	digKey := func(call, band string) string {
+		return strings.ToUpper(strings.TrimSpace(call)) + "|" + strings.ToLower(strings.TrimSpace(band)) + "|DIG"
+	}
+	needToday := false
+	for _, q := range queries {
+		if q.Contest {
+			needToday = true
+			break
+		}
+	}
+	today := map[string]bool{}
+	if needToday {
+		midnight := time.Now().UTC().Truncate(24 * time.Hour)
+		rows, err := a.qso.SlotsSince(a.ctx, midnight)
+		if err == nil {
+			for _, r := range rows {
+				today[slotKey(r.Callsign, r.Band, r.Mode)] = true
+				today[digKey(r.Callsign, r.Band)] = qso.ModeClass(r.Mode) == "DIG" || today[digKey(r.Callsign, r.Band)]
+			}
+		}
+	}
+	for i, q := range queries {
+		if q.Contest {
+			if generic(q.Mode) {
+				out[i] = today[digKey(q.Call, q.Band)]
+			} else {
+				out[i] = today[slotKey(q.Call, q.Band, q.Mode)]
+			}
+		} else if generic(q.Mode) {
+			if idx.workedCallSlotsDig != nil {
+				_, out[i] = idx.workedCallSlotsDig[digKey(q.Call, q.Band)]
+			}
+		} else if idx.workedCallSlots != nil {
+			_, out[i] = idx.workedCallSlots[slotKey(q.Call, q.Band, q.Mode)]
+		}
+	}
+	return out
+}
+
+// watchSpot runs one live spot through the watchlist: last-seen bookkeeping and
+// the alert, through the SAME event the alert rules fire — the frontend already
+// knows how to toast and sound it, and a second notification path would be a
+// second thing to misconfigure.
+func (a *App) watchSpot(dxCall, band, mode, country, comment string, freqHz int64) {
+	if a.watchlist == nil {
+		return
+	}
+	entry, notify, ok := a.watchlist.MarkSeen(dxCall)
+	if !ok {
+		// Not watched yet — the auto-contest pattern may claim it. Contains, not
+		// prefix: the event string sits anywhere in these calls (HB9WWA, F4WWA/P).
+		if p := a.GetWatchlistContestPattern(); p != "" &&
+			strings.Contains(strings.ToUpper(dxCall), p) {
+			if err := a.watchlist.Add(dxCall, true); err == nil {
+				applog.Printf("watchlist: auto-added %s (contest pattern %q)", dxCall, p)
+				entry, notify, ok = a.watchlist.MarkSeen(dxCall)
+				if a.ctx != nil {
+					wruntime.EventsEmit(a.ctx, "watchlist:changed")
+				}
+			}
+		}
+	}
+	if !ok || !notify || a.ctx == nil {
+		return
+	}
+	// Already worked? Then nothing to announce. Judged HERE, before the sound —
+	// the report was an alert ringing for a slot the tab showed as Worked a
+	// moment later, because the frontend's verdict arrives on a debounce while
+	// the alert used to fire on the raw spot. Same verdict as the tab: exact
+	// slot for named modes, digital class for a generic DATA spot, today-only
+	// for a contest entry.
+	if e, found := a.watchlist.Get(entry); found {
+		if a.WatchlistWorkedSlots([]WatchlistSlotQuery{{Call: dxCall, Band: band, Mode: mode, Contest: e.IsContest}})[0] {
+			return
+		}
+	}
+	// Throttled per entry: a DXpedition lights up every skimmer on the planet,
+	// and forty alerts a minute for one station is a alarm nobody keeps on.
+	a.watchAlertMu.Lock()
+	last := a.watchAlertAt[entry]
+	now := time.Now()
+	if now.Sub(last) < 2*time.Minute {
+		a.watchAlertMu.Unlock()
+		return
+	}
+	a.watchAlertAt[entry] = now
+	a.watchAlertMu.Unlock()
+	wruntime.EventsEmit(a.ctx, "alert:fired", map[string]any{
+		"rule":    "Watchlist " + entry,
+		"call":    strings.ToUpper(strings.TrimSpace(dxCall)),
+		"band":    band,
+		"mode":    mode,
+		"freq_hz": freqHz,
+		"country": country,
+		"comment": comment,
+		"sound":   true,
+		"visual":  true,
+	})
+}
+
+// startWatchlistClubLog begins the expedition enrichment: every entry's
+// ClubLog block (expedition flag, OQRS, LiveStream, QSO totals and 24 h rate)
+// is refreshed on a rolling schedule — hourly for expeditions, six-hourly for
+// the rest, DXHunter's own cadence. OpsLog's application API key is used, so
+// there is nothing to configure.
+//
+// Two at a time with a breath between requests: the key is shared by every
+// OpsLog install, and a hundred-entry watchlist must read as a trickle at
+// ClubLog's end, not a burst.
+func (a *App) startWatchlistClubLog() {
+	if a.watchlist == nil {
+		return
+	}
+	go func() {
+		client := &http.Client{Timeout: 30 * time.Second}
+		// Let the app finish starting before the first network pass.
+		time.Sleep(15 * time.Second)
+		for {
+			stale := a.watchlist.StaleEntries(1*time.Hour, 6*time.Hour)
+			changed := false
+			for _, call := range stale {
+				// The pattern's BASE is what ClubLog knows: VK9* has no log.
+				base := strings.TrimSuffix(call, "*")
+				if base == "" {
+					continue
+				}
+				ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+				d, err := watchlist.FetchWatch(ctx, client, clublogAppAPIKey, base)
+				cancel()
+				if err != nil {
+					applog.Printf("watchlist clublog: %s: %v", base, err)
+					continue
+				}
+				if a.watchlist.ApplyClubLog(call, d) {
+					changed = true
+					if d.IsExpedition {
+						applog.Printf("watchlist clublog: %s is a DXpedition (%d QSOs, %d/24h, OQRS=%v)",
+							base, func() int {
+								if d.ClubLogInfo != nil {
+									return d.ClubLogInfo.TotalQSOs
+								}
+								return 0
+							}(), d.QSOs24h(), d.HasOQRS)
+					}
+				}
+				time.Sleep(400 * time.Millisecond)
+			}
+			if changed && a.ctx != nil {
+				wruntime.EventsEmit(a.ctx, "watchlist:changed")
+			}
+			time.Sleep(10 * time.Minute)
+		}
+	}()
+}

app_wsjt_highlight.go

@@ -0,0 +1,155 @@
+package main
+
+// Log-aware colours in WSJT-X / JTDX's own Band Activity window (message 13),
+// the way JTAlert paints them: a decode of a watchlist member, a new DXCC or a
+// new band for its entity is highlighted where the operator is actually
+// looking. The verdicts come from the same cluster status cache that colours
+// the spot grid, so the two windows can never disagree.
+
+import (
+	"strings"
+
+	"hamlog/internal/applog"
+	"hamlog/internal/dxcc"
+	udp "hamlog/internal/integrations/udp"
+)
+
+const (
+	keyWsjtHighlight  = "udp.wsjt.highlight"
+	keyWsjtFollowMode = "udp.wsjt.followmode" // spot clicks switch the decoder's mode
+)
+
+// wsjtModes are the modes a Configure message can meaningfully ask for — the
+// decoder's own vocabulary. Anything else (CW, SSB, RTTY) is none of its
+// business and is not sent.
+var wsjtModes = map[string]bool{
+	"FT8": true, "FT4": true, "JT65": true, "JT9": true,
+	"MSK144": true, "Q65": true, "FST4": true, "JS8": false, // JS8Call speaks another protocol
+}
+
+// GetWsjtFollowMode reports whether spot clicks retune the decoder's mode.
+func (a *App) GetWsjtFollowMode() bool {
+	return a.settingOr(keyWsjtFollowMode, "1") == "1"
+}
+
+// SetWsjtFollowMode flips it.
+func (a *App) SetWsjtFollowMode(on bool) {
+	v := "0"
+	if on {
+		v = "1"
+	}
+	a.setSetting(keyWsjtFollowMode, v)
+}
+
+// ConfigureDecoderMode asks the connected decoders to switch mode — called by
+// the frontend after a spot click has tuned the radio. A no-op for modes the
+// decoder does not speak, and when the option is off or nothing is connected.
+func (a *App) ConfigureDecoderMode(mode string) {
+	mode = strings.ToUpper(strings.TrimSpace(mode))
+	if a.udp == nil || !wsjtModes[mode] || !a.GetWsjtFollowMode() {
+		return
+	}
+	a.udp.SendConfigureMode(mode)
+}
+
+// The palette. Fixed colours, not theme tokens — they are painted into another
+// application's window, which has no idea what theme OpsLog wears.
+var (
+	hlWatchlist = udp.RGB{R: 244, G: 114, B: 182} // the watchlist pink
+	hlNewDXCC   = udp.RGB{R: 22, G: 130, B: 60}   // green
+	hlNewBand   = udp.RGB{R: 226, G: 122, B: 24}  // orange
+	hlWhite     = udp.RGB{R: 255, G: 255, B: 255}
+	hlBlack     = udp.RGB{R: 20, G: 20, B: 20}
+)
+
+// GetWsjtHighlight reports whether decode highlighting is on.
+func (a *App) GetWsjtHighlight() bool {
+	return a.settingOr(keyWsjtHighlight, "0") == "1"
+}
+
+// SetWsjtHighlight turns decode highlighting on or off. Turning it OFF also
+// clears every instruction OpsLog installed in the running applications — a
+// disabled option that leaves stale colours behind looks broken, not disabled.
+func (a *App) SetWsjtHighlight(on bool) {
+	v := "0"
+	if on {
+		v = "1"
+	}
+	a.setSetting(keyWsjtHighlight, v)
+	a.wsjtHighlightOn.Store(on)
+	if !on && a.udp != nil {
+		for _, inst := range a.udp.Instances() {
+			_ = a.udp.SendClearHighlights(inst)
+		}
+		a.wsjtHLMu.Lock()
+		a.wsjtHLSent = map[string]string{}
+		a.wsjtHLMu.Unlock()
+		applog.Printf("wsjt highlight: off — cleared in every instance")
+	}
+}
+
+// maybeHighlightDecode paints one decoded callsign in the instance that heard
+// it, when the option is on and the verdict is worth a colour. De-duplicated
+// per instance+call+verdict: a station CQing all evening is decoded four times
+// a minute, and the instruction only needs to be said once.
+func (a *App) maybeHighlightDecode(instance, call, band string) {
+	if !a.wsjtHighlightOn.Load() || a.udp == nil || call == "" || instance == "" {
+		return
+	}
+	bg, fg, verdict := a.decodeHighlightVerdict(call, band)
+	key := instance + "|" + strings.ToUpper(call) + "|" + band
+	a.wsjtHLMu.Lock()
+	if a.wsjtHLSent == nil {
+		a.wsjtHLSent = map[string]string{}
+	}
+	if len(a.wsjtHLSent) > 4000 { // bounded; a long session just re-says a few
+		a.wsjtHLSent = map[string]string{}
+	}
+	prev, had := a.wsjtHLSent[key]
+	if had && prev == verdict {
+		a.wsjtHLMu.Unlock()
+		return
+	}
+	a.wsjtHLSent[key] = verdict
+	a.wsjtHLMu.Unlock()
+	if verdict == "" {
+		// Was highlighted under an earlier verdict and no longer deserves it
+		// (the operator just worked them): clear that one callsign.
+		if had && prev != "" {
+			_ = a.udp.SendHighlight(instance, call, nil, nil, false)
+		}
+		return
+	}
+	_ = a.udp.SendHighlight(instance, call, bg, fg, false)
+}
+
+// decodeHighlightVerdict ranks a callsign: watchlist beats new-DXCC beats
+// new-band; anything else is "no colour". The empty verdict doubles as the
+// clear signal in maybeHighlightDecode.
+func (a *App) decodeHighlightVerdict(call, band string) (bg, fg *udp.RGB, verdict string) {
+	if a.watchlist != nil {
+		if _, ok := a.watchlist.Match(call); ok {
+			c := hlWatchlist
+			f := hlBlack
+			return &c, &f, "watchlist"
+		}
+	}
+	c := a.clusterStatusMaps()
+	if a.dxcc != nil {
+		if m, ok := a.dxcc.Lookup(call); ok && m.Entity != nil {
+			num := dxcc.EntityDXCC(m.Entity.Name)
+			ent := c.entities[num]
+			if ent == nil {
+				bgc, fgc := hlNewDXCC, hlWhite
+				return &bgc, &fgc, "new-dxcc"
+			}
+			if band != "" {
+				if _, workedBand := ent.Bands[strings.ToLower(band)]; !workedBand {
+					bgc, fgc := hlNewBand, hlBlack
+					return &bgc, &fgc, "new-band"
+				}
+			}
+		}
+	}
+	return nil, nil, ""
+}

appearance.go

@@ -174,6 +174,11 @@ type MatrixColors struct {
 	EntityWorked    string `json:"entity_worked"`
 	NotWorked       string `json:"not_worked"`
 	CurrentEntry    string `json:"current_entry"`
+	// The dot marking a slot already worked with the callsign in hand. It is a
+	// mark rather than a background, so it needs its own two colours: it is
+	// drawn on top of all five of the above and must stay legible over each.
+	MarkWorked    string `json:"mark_worked"`
+	MarkConfirmed string `json:"mark_confirmed"`
 }
 
 // normMatrixColors keeps only plain hex values. Anything else becomes "" — i.e.
@@ -196,6 +201,8 @@ func normMatrixColors(c MatrixColors) MatrixColors {
 		EntityWorked:    clean(c.EntityWorked),
 		NotWorked:       clean(c.NotWorked),
 		CurrentEntry:    clean(c.CurrentEntry),
+		MarkWorked:      clean(c.MarkWorked),
+		MarkConfirmed:   clean(c.MarkConfirmed),
 	}
 }
 

changelog.json

@@ -1,4 +1,218 @@
 [
+  {
+    "version": "0.27.2",
+    "date": "",
+    "en": [
+      "Bulk operations work on any size of selection — setting a field, fixing frequencies, deleting, marking uploads and exporting the selection all failed with “too many SQL variables” past a few tens of thousands of QSOs. Statements are now issued in slices.",
+      "Elecraft console: the power meter reads in real watts. The K3’s bargraph is relative to a range that flips at 12 W — calibrated against a real radio’s full table, the PC setting picks the range and the bar converts to watts.",
+      "Watchlist: a visual pass toward DXHunter’s look — pink callsigns, counter pills, quieter cards with a hover, the ⚡ back on the DXpedition badge.",
+      "WSJT-X / JTDX: OpsLog can highlight decodes in the decoder’s own Band Activity window from your log — watchlist members pink, new DXCC green, new band orange (option in Settings → Connections). And a freshly-started decoder is asked to replay its on-screen decodes, so the FT decodes panel starts full.",
+      "WSJT-X / JTDX / MSHV: only a CHANGED DX Call updates the entry — the decoder re-broadcasts the same call endlessly, and it kept overwriting a spot clicked in OpsLog.",
+      "Map: Zoom DX toward a polar entity no longer frames a band of blank white above the top of the world — the camera stays within the map’s ±85°, the path still draws.",
+      "WSJT-X / JTDX / MSHV: clicking a spot in a digital mode the decoder speaks (FT8, FT4, JT65…) switches the decoder’s mode too — option in Settings → Connections, on by default."
+    ],
+    "fr": [
+      "Les opérations groupées fonctionnent quelle que soit la taille de la sélection — définir un champ, corriger des fréquences, supprimer, marquer les uploads et exporter la sélection échouaient avec « too many SQL variables » au-delà de quelques dizaines de milliers de QSO. Les requêtes sont désormais émises par tranches.",
+      "Console Elecraft : le wattmètre lit en vrais watts. Le bargraph du K3 est relatif à une gamme qui bascule à 12 W — calibré sur la table complète d’une vraie radio, le réglage PC choisit la gamme et la barre se convertit en watts.",
+      "Watchlist : une passe visuelle vers le look DXHunter — indicatifs roses, compteurs en pastilles, cartes plus feutrées avec survol, le ⚡ de retour sur le badge DXpedition.",
+      "WSJT-X / JTDX : OpsLog peut surligner les décodages dans la fenêtre Band Activity du décodeur selon votre log — watchlist en rose, nouveau DXCC en vert, nouvelle bande en orange (option dans Réglages → Connections). Et un décodeur fraîchement détecté rejoue ses décodages à l’écran, donc le panneau FT decodes démarre plein.",
+      "WSJT-X / JTDX / MSHV : seul un DX Call qui CHANGE met à jour la saisie — le décodeur rediffuse le même call sans fin, et il écrasait un spot cliqué dans OpsLog.",
+      "Carte : Zoom DX vers une entité polaire ne cadre plus une bande blanche au-dessus du haut du monde — la caméra reste dans les ±85° de la carte, le trajet se dessine toujours.",
+      "WSJT-X / JTDX / MSHV : cliquer un spot dans un mode numérique que le décodeur parle (FT8, FT4, JT65…) change aussi le mode du décodeur — option dans Réglages → Connections, activée par défaut."
+    ]
+  },
+  {
+    "version": "0.27.1",
+    "date": "",
+    "en": [
+      "Elecraft console: the S-meter is calibrated against a real K3 — S9 and the +dB readings now match the radio’s own display (they read about two S-units low).",
+      "Elecraft console: an SWR spike (the K3’s own blip at the end of an FT8 frame) no longer fades over twelve seconds — the peak shows briefly, then the meter returns straight to the live reading.",
+      "Icom: the IC-7760 joins the model list (CI-V address B2h).",
+      "Icom console: the IC-7760 gets its real attenuator steps — 6/12/18 dB.",
+      "Icom network audio: the RX stream is decoded correctly — mono is requested and the payload offset was confirmed on a real IC-7760, curing the garbled, clicking audio.",
+      "Icom: switching back from a data mode (USB-D1) to plain USB now sticks — if the rig ignores the data-flag command, it is repeated with the modern one-frame form (0x26). Seen on the IC-7760.",
+      "Icom console: a DATA mode button (USB-D, what FT8 wants), the PSK button drives the rigs that have a native PSK mode, and the power meter reads in real watts on the IC-7760’s 250 W scale.",
+      "Icom network audio: the right codec is requested (16-bit mono LPCM), settled by experiment on a real IC-7760.",
+      "CAT settings: reopening the panel now shows the radio that is actually selected — it always showed the first one, with the fields (MY_RIG included) silently editing the wrong entry.",
+      "IC-7760: the power meter is calibrated against the radio (100 W reads 100 W on the 250 W face) and the RF power setting reads in watts, not a percentage.",
+      "Icom network audio: toggling Listening off and on no longer chops the sound — the monitor restarts as network-fed instead of also opening a USB capture.",
+      "QSO recorder: starting a fresh manual take resets the counter for good — it used to flash 0 and jump back to the previous take’s elapsed time.",
+      "MY_RIG follows the radio actually connected: the entry form now asks the active radio first, before the per-band default — an IC-7760 on the air no longer logs as the Flex the band plan names.",
+      "QSO recorder: a manual take on a network Icom records the network RX stream, not the “From radio” sound card (which captured another radio’s DAX on a mixed station).",
+      "Icom network audio: duplicate and late-retransmitted packets no longer reach the recorder — recordings came out longer than the QSO, slowed and stuttering, while the speakers played fine.",
+      "Icom network audio: it now starts with the app — launching OpsLog connected with audio silently off, and the option had to be unticked and re-saved to hear anything.",
+      "Icom network: when the rig goes quiet on CI-V while the session stays up (seen on the IC-7760), the CI-V flow is re-opened on the spot — recovery in seconds instead of the 35-second full reconnect.",
+      "Icom network: after a session dies young, the redial waits 20 s so the rig can purge the old session first — stops the reconnect-die-reconnect spiral seen on the IC-7760, where each fresh session answered for a second and was then strangled by the previous one’s cleanup.",
+      "Icom network audio, phase 5: the radio can now TAKE audio — with RX audio enabled, pick “Radio (network audio)” as the To-radio device and the voice keyer plays straight to the rig over the LAN, no cable, no virtual sound card. First tested on the IC-7760.",
+      "Icom network audio: listening is now a remembered choice — Stop listening keeps the speakers off across reconnects and restarts, while the stream stays open for the QSO recorder and the voice keyer.",
+      "Icom console: a speaker button beside ON/OFF toggles listening to the network RX audio right from the console — no more trip through Settings → Audio; recordings and the voice keyer keep working either way, and the choice is remembered.",
+      "CAT settings: a “Play it through the speakers” checkbox sits under the Icom RX-audio option — the same remembered switch as the console’s speaker button, applied immediately.",
+      "Icom network audio: “Talk to radio” now works over the LAN too — live microphone straight to the rig, PTT included. With RX audio and a headset, OpsLog is a complete remote station: hear, talk, key CW and log over one network link.",
+      "Icom console: the SUB display shows the sub receiver’s frequency at all times (it was blank until split), and engaging split copies the mode to the TX VFO so it matches the main.",
+      "Icom network audio: the stream now opens regardless of the speaker choice — speakers-off (or a failed output device) was silently disabling the whole stream: no audio session, no recordings, no voice keyer, despite the RX-audio option being ticked.",
+      "Icom network: a radio in standby keeps its session and the console’s ON button — the quiet-CI-V recovery was tearing the session down every 15 s, so a radio that was off when OpsLog started could never be powered on.",
+      "Icom console: the MOX button carries your microphone on a network station, and engaging split aligns the TX VFO’s mode with the main.",
+      "Icom console: the spectrum scope is removed. Every model streams its waveform differently — and on the IC-7760 enabling it killed the whole CI-V link, audio included. The radio’s own scope does it better.",
+      "Icom: any leftover waveform stream is switched off at connect — the scope flag lives in the radio and survived sessions, and its flood is what was killing the IC-7760’s CI-V link.",
+      "Icom console: an ATU chip beside SPLIT engages or DISENGAGES the internal tuner — TUNE started a cycle but could never take the tuner back out of line.",
+      "Icom console: the TX meters get needle inertia — power holds its peak instead of flickering to 0 W between syllables, SWR shows the real peak then returns to the live value — and the wattage readout no longer wraps at three digits.",
+      "Icom console: the meters use the same LED bars as the Flex and Elecraft consoles, and the mode badge says USB or LSB instead of an ambiguous SSB.",
+      "Cluster: spots on the standard FT8/FT4 frequencies of every band now read FT8/FT4 when the comment names no mode — 30 m, 60 m, 80 m FT4, 17 m FT4 and 12 m were falling into the generic DATA bucket.",
+      "OmniRig (Yaesu): with split engaged, tuning to a spot moves BOTH VFOs — on an FT-2000 the write landed on the TX VFO only, so the transmitter QSYed and the receiver stayed behind.",
+      "Worked before: a slow lookup can no longer overwrite a newer one — typing a second callsign quickly could leave the previous call’s QSOs displayed under the new call’s name.",
+      "Icom network: OpsLog now sends its own pings every 500 ms on all three streams, as RS-BA1 and wfview do — a client that only ever replied was judged absent by the rig, which stopped serving CI-V data about a minute into every session: the recurring sound/CAT dropouts."
+    ],
+    "fr": [
+      "Console Elecraft : le S-mètre est calibré sur un vrai K3 — S9 et les +dB correspondent désormais à l’affichage de la radio (il lisait environ deux points S trop bas).",
+      "Console Elecraft : un pic de ROS (le sursaut du K3 en fin de trame FT8) ne s’estompe plus pendant douze secondes — le pic s’affiche brièvement, puis le ros-mètre revient directement à la valeur réelle.",
+      "Icom : l’IC-7760 rejoint la liste des modèles (adresse CI-V B2h).",
+      "Console Icom : l’IC-7760 reçoit ses vrais crans d’atténuateur — 6/12/18 dB.",
+      "Audio réseau Icom : le flux RX est décodé correctement — le mono est demandé et l’offset du payload a été confirmé sur un vrai IC-7760, ce qui guérit le son inaudible et les clics.",
+      "Icom : revenir d’un mode data (USB-D1) au USB simple tient désormais — si la radio ignore la commande du drapeau data, elle est répétée sous la forme moderne en une trame (0x26). Constaté sur l’IC-7760.",
+      "Console Icom : un bouton de mode DATA (USB-D, celui de FT8), le bouton PSK pilote les radios qui ont un vrai mode PSK, et le wattmètre lit en watts réels sur l’échelle 250 W de l’IC-7760.",
+      "Audio réseau Icom : le bon codec est demandé (LPCM mono 16 bits), déterminé par l’expérience sur un vrai IC-7760.",
+      "Réglages CAT : rouvrir le panneau montre désormais la radio réellement sélectionnée — il montrait toujours la première, et les champs (MY_RIG compris) modifiaient silencieusement la mauvaise entrée.",
+      "IC-7760 : le wattmètre est calibré sur la radio (100 W affiche 100 W sur l’échelle 250 W) et le réglage RF power se lit en watts, plus en pourcentage.",
+      "Audio réseau Icom : couper puis relancer Listening ne hache plus le son — le moniteur redémarre alimenté par le réseau au lieu d’ouvrir en plus une capture USB.",
+      "Enregistreur de QSO : démarrer une nouvelle prise manuelle remet le compteur à zéro pour de bon — il affichait 0 puis resautait au temps de la prise précédente.",
+      "MY_RIG suit la radio réellement connectée : le formulaire interroge d’abord la radio active, avant le défaut par bande — un IC-7760 à l’antenne ne se logue plus comme le Flex prévu par le plan de bande.",
+      "Enregistreur de QSO : une prise manuelle sur un Icom réseau enregistre le flux RX réseau, pas la carte son « From Radio » (qui capturait le DAX d’une autre radio sur une station mixte).",
+      "Audio réseau Icom : les paquets dupliqués ou retransmis en retard n’atteignent plus l’enregistreur — les enregistrements sortaient plus longs que le QSO, ralentis et hachés, alors que les haut-parleurs jouaient bien.",
+      "Audio réseau Icom : il démarre maintenant avec l’application — au lancement, la connexion se faisait audio coupé, et il fallait décocher/recocher l’option pour entendre quelque chose.",
+      "Réseau Icom : quand la radio se tait sur le CI-V alors que la session tient (constaté sur l’IC-7760), le flux CI-V est rouvert immédiatement — récupération en quelques secondes au lieu des 35 secondes de reconnexion complète.",
+      "Réseau Icom : après une session morte jeune, la renumérotation attend 20 s pour que la radio purge d’abord l’ancienne session — stoppe la spirale reconnexion-mort-reconnexion vue sur l’IC-7760, où chaque session neuve répondait une seconde avant d’être étranglée par le nettoyage de la précédente.",
+      "Audio réseau Icom, phase 5 : la radio peut maintenant RECEVOIR de l’audio — avec le RX audio activé, choisissez « Radio (network audio) » comme périphérique To Radio et le voice keyer joue directement vers la radio par le LAN, sans câble ni carte son virtuelle. Premier test sur l’IC-7760.",
+      "Audio réseau Icom : l’écoute est désormais un choix mémorisé — Stop listening garde les enceintes coupées à travers reconnexions et redémarrages, tandis que le flux reste ouvert pour l’enregistreur de QSO et le voice keyer.",
+      "Console Icom : un bouton haut-parleur à côté de ON/OFF bascule l’écoute du RX audio réseau depuis la console — fini l’aller-retour dans Réglages → Audio ; enregistrements et voice keyer continuent de fonctionner, et le choix est mémorisé.",
+      "Réglages CAT : une case « Écouter dans les enceintes » sous l’option RX audio Icom — le même interrupteur mémorisé que le bouton haut-parleur de la console, appliqué immédiatement.",
+      "Audio réseau Icom : « Talk to radio » fonctionne aussi par le LAN — micro en direct vers la radio, PTT compris. Avec le RX audio et un casque, OpsLog devient une station remote complète : écouter, parler, manipuler la CW et loguer sur un seul lien réseau.",
+      "Console Icom : l’affichage SUB montre la fréquence du sub receiver en permanence (il restait vide hors split), et activer le split copie le mode sur le VFO TX pour qu’il suive le main.",
+      "Audio réseau Icom : le flux s’ouvre désormais indépendamment du choix d’écoute — enceintes coupées (ou périphérique de sortie en échec) désactivait silencieusement tout le flux : pas de session audio, ni enregistrements, ni voice keyer, malgré la case RX audio cochée.",
+      "Réseau Icom : une radio en veille garde sa session et le bouton ON de la console — la récupération du CI-V muet détruisait la session toutes les 15 s, donc une radio éteinte au lancement d’OpsLog ne pouvait jamais être allumée.",
+      "Console Icom : le bouton MOX emporte votre micro sur une station réseau, et activer le split aligne le mode du VFO TX sur le main.",
+      "Console Icom : le scope spectral est retiré. Chaque modèle streame sa forme d’onde différemment — et sur l’IC-7760 son activation tuait tout le lien CI-V, audio compris. Le scope de la radio fait ça mieux.",
+      "Icom : tout flux waveform résiduel est coupé à la connexion — le drapeau scope vit dans la radio et survivait aux sessions, et son flot est ce qui tuait le lien CI-V de l’IC-7760.",
+      "Console Icom : une puce ATU à côté de SPLIT engage ou DÉSENGAGE le tuner interne — TUNE lançait un cycle mais ne pouvait jamais remettre le tuner hors ligne.",
+      "Console Icom : les mètres TX gagnent une inertie d’aiguille — la puissance tient sa crête au lieu de retomber à 0 W entre les syllabes, le ROS montre la vraie crête puis revient à la valeur vive — et l’affichage en watts ne passe plus à la ligne à trois chiffres.",
+      "Console Icom : les mètres utilisent les mêmes barres LED que les consoles Flex et Elecraft, et le badge de mode dit USB ou LSB au lieu d’un SSB ambigu.",
+      "Cluster : les spots sur les fréquences standard FT8/FT4 de chaque bande lisent désormais FT8/FT4 quand le commentaire ne nomme pas de mode — 30 m, 60 m, FT4 80 m, FT4 17 m et 12 m tombaient dans le bloc DATA générique.",
+      "OmniRig (Yaesu) : avec le split actif, se rendre sur un spot déplace LES DEUX VFO — sur un FT-2000 l’écriture n’atteignait que le VFO TX, donc l’émetteur QSYait et le récepteur restait derrière.",
+      "Déjà contacté : une recherche lente ne peut plus écraser une plus récente — taper un second indicatif rapidement pouvait laisser les QSO du call précédent affichés sous le nom du nouveau.",
+      "Réseau Icom : OpsLog envoie désormais ses propres pings toutes les 500 ms sur les trois flux, comme RS-BA1 et wfview — un client qui ne faisait que répondre était jugé absent par la radio, qui cessait de servir le CI-V au bout d’une minute : les coupures récurrentes de son/CAT."
+    ]
+  },
+  {
+    "version": "0.27.0",
+    "date": "",
+    "en": [
+      "⭐ NEW — Watchlist (Tools): the DXHunter watchlist as an OpsLog tab — callsigns you are hunting (exact, or a family with a trailing * — VK9* catches every VK9), the live cluster spots under each with the NEW badges and a Needed/Worked verdict per slot, an ON AIR badge, per-entry alerts through the normal alert path, and CONTEST entries judged per UTC day (at midnight everything is workable again).Each entry is enriched from ClubLog automatically: DXpedition badge, OQRS, LiveStream link, QSO total and 24-hour rate — nothing to configure. Reads and writes DXHunter’s own watchlist.json format — drop your existing file into the data folder to carry it over.",
+      "TCI (SunSDR): the meter subscription is renewed when the radio announces it is ready — sent only at connect, it could fall inside the initial state dump and be ignored, which left the transmit power and SWR empty. The log now also records the subscription and the first sensor frames, so a report can tell “the radio never sends them” from “they arrived and were dropped”.",
+      "Sending a spot while in split now pre-fills the RX frequency — where the station actually is — instead of the TX frequency, which spotted the pile-up five up from the DX.",
+      "Cluster: NEW SLOT gets its own colour — the sky cyan the panadapter palette already uses for it, clearly apart from POTA green and the yellows. The NEW SLOT and NEW COUNTY filter chips now wear the same colours as the badges they select, and the NEW CALL filter works even when the slot-highlight display option is off.",
+      "Elecraft console: a mode row — CW, USB, LSB, DATA and DATA RTTY. The two DATA buttons set the K3’s submode as well (DATA A for FT8/FT4, FSK D for RTTY): switching to DATA by mode alone kept whatever submode the last session left, which is how a K3 “in DATA” keys FT8 with no audio.",
+      "DX Cluster settings: “I chase POTA” and “I chase SOTA”, on by default. Unticked, the NEW POTA badge, colour and filter disappear — a new-band + new-POTA spot reads NEW BAND alone — and the reference columns stay empty.",
+      "Elecraft console: RIT and XIT use the same control as the Icom and TCI consoles — ± buttons, mouse wheel, typed value, Ctrl+←/→ — and the power slider moves in 1 W steps instead of 5.",
+      "Bulk edit: My DXCC, My CQ zone and My ITU zone join the My-station fields — numbers checked against their real ranges, empty clears.",
+      "Clicking a spot in the Chase new panel now applies the FlexRadio panadapter width/zoom, like every other spot click.",
+      "FlexRadio: the panadapter width/zoom now applies reliably when double-clicking a cluster spot — the zoom is sent after the tune settles, so SmartSDR’s own pan-follow on a band change no longer overrides it."
+    ],
+    "fr": [
+      "⭐ NOUVEAU — Watchlist (Outils) : la watchlist de DXHunter en onglet OpsLog — indicatifs chassés (exacts, ou une famille avec une * finale — VK9* attrape tous les VK9), les spots cluster en direct sous chaque entrée avec les badges NOUVEAU et un verdict Manquant/Contacté par créneau, un badge ON AIR, des alertes par entrée via le circuit d'alerte normal, et des entrées CONTEST jugées par jour UTC (à minuit tout redevient à faire).Chaque entrée est enrichie automatiquement depuis ClubLog : badge DXpedition, OQRS, lien LiveStream, total de QSO et rythme sur 24 h — rien à configurer. Lit et écrit le format watchlist.json de DXHunter — déposez votre fichier existant dans le dossier data pour le récupérer.",
+      "TCI (SunSDR) : l'abonnement aux mesures est renouvelé quand la radio annonce qu'elle est prête — envoyé seulement à la connexion, il pouvait tomber pendant l'envoi initial de l'état et être ignoré, laissant la puissance et le ROS vides en émission. Le journal enregistre aussi l'abonnement et les premières trames de mesure, pour distinguer « la radio ne les envoie jamais » de « elles arrivaient et étaient perdues ».",
+      "Envoyer un spot en split préremplit désormais la fréquence RX — là où la station se trouve réellement — au lieu de la fréquence TX, qui spottait le pile-up cinq au-dessus du DX.",
+      "Cluster : NOUVEAU SLOT reçoit sa propre couleur — le cyan ciel que la palette du panadapter lui donne déjà, bien distinct du vert POTA et des jaunes. Les puces de filtre NOUVEAU SLOT et NOUVEAU COMTÉ portent désormais les couleurs des badges qu'elles sélectionnent, et le filtre NOUVEAU CALL fonctionne même quand l'option de surlignage par slot est désactivée.",
+      "Console Elecraft : une rangée de modes — CW, USB, LSB, DATA et DATA RTTY. Les deux boutons DATA règlent aussi le sous-mode du K3 (DATA A pour FT8/FT4, FSK D pour le RTTY) : passer en DATA par le seul mode gardait le sous-mode de la session précédente, et un K3 « en DATA » manipulait le FT8 sans audio.",
+      "Réglages DX Cluster : « Je chasse le POTA » et « Je chasse le SOTA », cochés par défaut. Décochés, le badge, la couleur et le filtre NOUVEAU POTA disparaissent — un spot nouvelle bande + nouveau POTA affiche seulement NOUVELLE BANDE — et les colonnes de références restent vides.",
+      "Console Elecraft : le RIT et le XIT utilisent la même commande que les consoles Icom et TCI — boutons ±, molette, valeur tapée, Ctrl+←/→ — et le curseur de puissance avance par pas de 1 W au lieu de 5.",
+      "Édition groupée : My DXCC, My CQ zone et My ITU zone rejoignent les champs Ma station — valeurs vérifiées contre leurs bornes réelles, vide efface.",
+      "Cliquer un spot dans le panneau Chase new applique désormais la largeur/zoom du panadapter FlexRadio, comme tout autre clic de spot.",
+      "FlexRadio : la largeur/zoom du panadapter s’applique désormais de façon fiable au double-clic sur un spot du cluster — le zoom est envoyé après le tune, pour que le suivi du panadapter de SmartSDR lors d’un changement de bande ne l’écrase plus."
+    ]
+  },
+  {
+    "version": "0.26.23",
+    "date": "",
+    "en": [
+      "LoTW: the downloaded confirmations list gains a Station column, so a list spanning several callsigns says which one each confirmation belongs to. Shown only when the report actually carries more than the one station.",
+      "The band maps follow your IARU region (Settings → General): Region 2’s 40 m runs to 7300 kHz with phone from 7125 and its 80 m to 4000, Region 3’s 80 m to 3900 — the band edges and the CW/digital/phone shading all adjust."
+    ],
+    "fr": [
+      "LoTW : la liste des confirmations téléchargées gagne une colonne Station, pour savoir à quel indicatif appartient chaque confirmation quand le téléchargement en couvre plusieurs. Affichée seulement si le rapport en contient effectivement.",
+      "Les cartes de bande suivent votre région IARU (Réglages → Général) : le 40 m de la Région 2 va jusqu'à 7300 kHz avec la phonie dès 7125 et son 80 m jusqu'à 4000, le 80 m de la Région 3 jusqu'à 3900 — les limites de bande et les zones CW/numérique/phonie s'ajustent."
+    ]
+  },
+  {
+    "version": "0.26.22",
+    "date": "",
+    "en": [
+      "LoTW download: the QSL details (QSL date, grid, state, county) are now optional and off by default — LoTW takes about ten times longer to build that report, twenty minutes against two on the same account, and marking a confirmation needs none of it. Still asked for automatically when adding the QSOs not found in the log.",
+      "Band map: the tooltip now also names a new prefix or a new grid square. They stay off the 22-pixel colour strip, but leaving them out of the text made the two panels look as though they disagreed — the cluster said NEW PFX about a spot the map called Worked, and both were right. The map’s “Worked” also says whose: it is the ENTITY that was worked on that band and mode, not the callsign, which is what made the two readings look contradictory.",
+      "TCI (SunSDR): clicking a cluster spot no longer needs a second click to get the mode right — the sideband was chosen from the frequency the radio had last reported instead of the one just asked for. The log also names the ExpertSDR version now, and says so when it is older than the 1.5 that panorama spots need.",
+      "Two screens: OpsLog no longer walks off the desktop. On a monitor placed left of the primary one, the saved position was being added to that monitor’s own origin at every launch, so the window moved one screen further out each time until it was invisible.",
+      "CW over TCI: a SunSDR can now be keyed through its own macro keyer — pick TCI as the keyer engine (Settings → CW Keyer) and macros, auto-call and the speed control all work over the link already open, with no WinKeyer and no second serial port. NOT TESTED on the air yet.",
+      "LoTW upload: a refusal now shows TQSL’s own explanation — which contacts were already uploaded, which fell outside the certificate’s dates — instead of the bare “no QSOs processed”, and names the two settings that cause it.",
+      "Main tab: the docked cluster now has ONE header row — its title, live count and Filters button sit with Clear filters and Columns, as Recent QSOs beside it already did. The pane is titled DX Cluster.",
+      "A busy cluster no longer makes the rest of the interface sluggish: incoming spots are grouped into fewer, larger updates as the feed gets faster (up to half a second), instead of redrawing the window twenty times a second. A quiet cluster still shows each spot as it lands.",
+      "SunSDR console: the meters work. The S-meter, transmit power and SWR are pushed by the radio only to a client that subscribes, and OpsLog never did — it was reading commands ExpertSDR3 does not send.",
+      "Cluster: the “N new spots” counter no longer jumps to the whole buffer. It was looking for the row it had frozen on, and a station spotted again replaces its row — so the count fell through to “everything is new”.",
+      "E-mail: a refused SMTP login now says what to do about it — Microsoft 365 and outlook.com have switched off password-based SMTP, and an app password does not bring it back.",
+      "TCI panorama spots: the colour was sent as a negative number and ExpertSDR dropped every spot in silence. It now goes out as the unsigned ARGB integer the protocol document uses, and the first few spots are written to the log verbatim.",
+      "Cluster: “Group duplicates” was hiding the same station on OTHER bands and modes — a DXpedition spotted on five bands showed as one line and four slots disappeared. A duplicate is now what it should always have been: the same station on the same band and mode."
+    ],
+    "fr": [
+      "Téléchargement LoTW : les détails QSL (date du QSL, locator, état, comté) deviennent optionnels et désactivés par défaut — LoTW met environ dix fois plus longtemps à construire ce rapport, vingt minutes contre deux sur le même compte, et marquer une confirmation n'en a pas besoin. Toujours demandés automatiquement quand on ajoute les QSO absents du log.",
+      "Carte des bandes : l'infobulle indique aussi un nouveau préfixe ou un nouveau locator. Ils restent hors de la bande de couleur de 22 pixels, mais les omettre du texte donnait l'impression que les deux panneaux se contredisaient — le cluster annonçait NOUVEAU PFX pour un spot que la carte disait contacté, et les deux avaient raison. Le « Contacté » de la carte dit aussi de qui il parle : c'est l'ENTITÉ qui a été contactée sur cette bande et ce mode, pas l'indicatif — d'où l'impression de contradiction.",
+      "TCI (SunSDR) : cliquer un spot du cluster ne demande plus un second clic pour obtenir le bon mode — la bande latérale était choisie d'après la fréquence encore annoncée par la radio au lieu de celle qu'on venait de demander. Le journal indique aussi la version d'ExpertSDR, et signale si elle est antérieure à la 1.5 qu'exigent les spots sur le panorama.",
+      "Deux écrans : OpsLog ne s'échappe plus du bureau. Sur un écran placé à gauche de l'écran principal, la position enregistrée était ajoutée à l'origine de cet écran à chaque lancement, si bien que la fenêtre s'éloignait d'un écran à chaque fois jusqu'à devenir invisible.",
+      "CW en TCI : un SunSDR peut désormais être manipulé par son propre keyer à macros — choisissez TCI comme moteur (Réglages → Manipulateur CW) et les macros, l'appel automatique et le réglage de vitesse passent par la liaison déjà ouverte, sans WinKeyer ni second port série. PAS ENCORE TESTÉ sur l'air.",
+      "Envoi LoTW : un refus affiche désormais l'explication de TQSL — quels contacts étaient déjà envoyés, lesquels tombaient hors des dates du certificat — au lieu du seul « no QSOs processed », et nomme les deux réglages qui en sont la cause.",
+      "Onglet Main : le cluster ancré n'a plus qu'UNE ligne d'en-tête — son titre, le compteur live et le bouton Filtres rejoignent Effacer les filtres et Colonnes, comme le faisait déjà la liste des QSO récents à côté. Le panneau s'intitule DX Cluster.",
+      "Un cluster chargé ne ralentit plus le reste de l'interface : les spots entrants sont regroupés en mises à jour moins nombreuses à mesure que le flux s'accélère (jusqu'à une demi-seconde), au lieu de redessiner la fenêtre vingt fois par seconde. Sur un cluster calme, chaque spot s'affiche toujours dès son arrivée.",
+      "Console SunSDR : les mesures fonctionnent. Le S-mètre, la puissance et le ROS ne sont envoyés qu'à un client qui s'abonne, ce qu'OpsLog ne faisait pas — il lisait des commandes qu'ExpertSDR3 n'envoie pas.",
+      "Cluster : le compteur « N nouveaux spots » ne saute plus à la taille du tampon. Il cherchait la ligne sur laquelle il s'était figé, or une station re-spottée remplace sa ligne — le compte basculait donc sur « tout est nouveau ».",
+      "E-mail : un refus d'authentification SMTP explique désormais quoi faire — Microsoft 365 et outlook.com ont désactivé le SMTP par mot de passe, et un mot de passe d'application ne le rétablit pas.",
+      "Spots sur le panorama TCI : la couleur partait en nombre négatif et ExpertSDR écartait chaque spot en silence. Elle est désormais envoyée en entier ARGB non signé, comme dans la documentation du protocole, et les premiers spots sont écrits tels quels dans le journal.",
+      "Cluster : « Grouper les doublons » masquait la même station sur les AUTRES bandes et modes — une expédition spottée sur cinq bandes n'affichait qu'une ligne et quatre créneaux disparaissaient. Un doublon est désormais ce qu'il aurait toujours dû être : la même station sur la même bande et le même mode."
+    ]
+  },
+  {
+    "version": "0.26.21",
+    "date": "",
+    "en": [
+      "Distances can be shown in miles (Settings → General): the cluster and Recent QSOs columns, the map path box, the rotator buttons and the band-opening list all follow, and the column headers name the unit.",
+      "LoTW download: the report is now counted in megabytes as it arrives, LoTW’s \"busy\" answer (HTTP 503) is retried twice instead of failing, and a transfer that stops moving for two minutes says so rather than showing \"working\" indefinitely."
+    ],
+    "fr": [
+      "Les distances peuvent s'afficher en miles (Réglages → Général) : les colonnes du cluster et des QSO récents, l'encart du tracé sur la carte, les boutons du rotor et la liste des ouvertures suivent, et l'unité est indiquée dans les en-têtes de colonne.",
+      "Téléchargement LoTW : le rapport est compté en mégaoctets au fur et à mesure, la réponse « occupé » de LoTW (HTTP 503) est retentée deux fois au lieu d'échouer, et un transfert qui n'avance plus pendant deux minutes le dit au lieu d'afficher « en cours » indéfiniment."
+    ]
+  },
+  {
+    "version": "0.26.20",
+    "date": "",
+    "en": [
+      "Each radio carries its own MY_RIG (Settings → CAT), written on every QSO made with it — ahead of the per-band station in Operating conditions, which says what you planned to use rather than which radio is keying. Left empty, nothing changes.",
+      "Worked-before matrix: a dot in the corner of a cell now means the callsign you are working has already been worked on that slot, whatever colour the entity status gave the cell. Its two colours (worked / confirmed with this callsign) are in Appearance with the other matrix colours.",
+      "Icom spectrum scope: the command shape (with or without the main/sub selector) is now worked out from the radio’s own answers instead of a list of models. A radio that has scope control but no waveform stream over CI-V — the IC-7851 — says so in the panel rather than showing a black rectangle.",
+      "Elecraft KPA: the status-bar chip now shows the amplifier as connected and switches it between OPERATE and STANDBY like the other brands, and an offline KPA no longer calls itself an Acom.",
+      "Cluster: a SOTA column, read from the summit reference the SOTA feeds put in the spot comment. Clicking the spot fills the QSO’s SOTA award reference, as a POTA spot already did. Turn the column on in Columns. Add cluster.sota.org.uk:7300 as a server to receive the summit spots.",
+      "Awards: a \"Slots to confirm\" filter and a running count beside the reference total, so the gap between worked and confirmed band-slots — the Challenge difference — can be seen reference by reference instead of only as two numbers.",
+      "QSL Manager: a QRZ button next to the Paper QSL search, opening the callsign on QRZ.com.",
+      "LoTW: an \"All my callsigns\" option beside the download. The download is scoped to the profile’s own callsign, so a QSO made as a portable or contest call was confirmed at LoTW and never marked here. Confirmations made under a callsign this logbook has never used are skipped, and a suspiciously small report now shows what LoTW actually answered.",
+      "LoTW download: \"All\" really means all — without a date LoTW answered with a handful of recent confirmations, which looked like a successful download of an empty account. A full account also has time to arrive: the two-minute limit that ended in \"context deadline exceeded\" is now twenty."
+    ],
+    "fr": [
+      "Chaque radio porte son propre MY_RIG (Réglages → CAT), inscrit sur chaque QSO fait avec elle — avant la station par bande des Conditions de trafic, qui dit ce qui était prévu et non quelle radio émet. Laissé vide, rien ne change.",
+      "Matrice des contacts : un point dans le coin d'une case indique que l'indicatif en cours a déjà été contacté sur ce créneau, quelle que soit la couleur donnée par le statut de l'entité. Ses deux couleurs (contacté / confirmé avec cet indicatif) se règlent dans Apparence avec les autres couleurs de la matrice.",
+      "Scope Icom : la forme des commandes (avec ou sans le sélecteur main/sub) est déduite des réponses de la radio au lieu d'une liste de modèles. Une radio qui pilote son scope mais ne l'envoie pas en CI-V — l'IC-7851 — l'indique dans le panneau au lieu d'afficher un rectangle noir.",
+      "Elecraft KPA : la pastille de la barre d'état montre enfin l'amplificateur comme connecté et bascule OPERATE / STANDBY comme les autres marques, et un KPA hors ligne ne s'annonce plus comme un Acom.",
+      "Cluster : une colonne SOTA, lue dans la référence de sommet que les flux SOTA mettent dans le commentaire du spot. Cliquer le spot remplit la référence SOTA du QSO, comme le faisait déjà un spot POTA. Colonne à activer dans Colonnes. Ajoutez le serveur cluster.sota.org.uk:7300 pour recevoir les spots de sommets.",
+      "Awards : un filtre « Slots à confirmer » et un compteur à côté du total de références, pour voir l'écart entre créneaux contactés et confirmés — la différence du Challenge — référence par référence et non plus seulement en deux chiffres.",
+      "Gestionnaire QSL : un bouton QRZ à côté de la recherche QSL papier, qui ouvre l'indicatif sur QRZ.com.",
+      "LoTW : une option « Tous mes indicatifs » à côté du téléchargement. Celui-ci est limité à l'indicatif du profil, si bien qu'un QSO fait sous un indicatif portable ou de contest était confirmé chez LoTW sans jamais être marqué ici. Les confirmations faites sous un indicatif que ce carnet n'a jamais utilisé sont ignorées, et un rapport anormalement petit affiche désormais ce que LoTW a réellement répondu.",
+      "Téléchargement LoTW : « Tout » veut enfin dire tout — sans date, LoTW ne renvoyait qu'une poignée de confirmations récentes, ce qui ressemblait à un téléchargement réussi d'un compte vide. Un compte complet a aussi le temps d'arriver : la limite de deux minutes, qui finissait en « context deadline exceeded », passe à vingt."
+    ]
+  },
   {
     "version": "0.26.19",
     "date": "",

frontend/src/App.tsx

@@ -33,7 +33,7 @@ import {
   GetSolarData,
   GetQSORate,
   LoTWUserInfo,
-  OperatingDefaultForBand,
+  OperatingDefaultForBand, ActiveRadioMyRig, ConfigureDecoderMode,
   LogUDPLoggedADIF,
   ListCountries,
   GetWinkeyerSettings, SaveWinkeyerSettings, ListSerialPorts, GetWinkeyerStatus,
@@ -41,6 +41,7 @@ import {
   IcomSendCW, YaesuSendCW, YaesuStopCW, SetYaesuKeySpeed, IcomStopCW, IcomSetKeySpeed, IcomSetBreakIn, GetIcomState,
   KenwoodSendCW, KenwoodStopCW, SetKenwoodKeySpeed,
   FlexSendCW, FlexStopCW, FlexSetKeySpeed, FlexBackspaceCW,
+  TCISendCW, TCIStopCW, TCISetKeySpeed,
   GetDVKMessages, GetDVKStatus, DVKPlay, DVKStop,
   StartCWDecoder, StopCWDecoder, SetCWDecoderPitch,
   ChatAvailable, GetChatHistory, SendChatMessage, GetOnlineOperators,
@@ -57,6 +58,7 @@ import {
 import { Combobox } from '@/components/ui/combobox';
 import { applyAwardRefs, parseAwardRefs as parseManualRefs, spotRefList , withIOTARef, withRDARef } from '@/lib/awardRefs';
 import { ListRadios, SetActiveRadio } from '../wailsjs/go/main/App';
+import { formatDistance } from '@/lib/units';
 import { EventsOn, BrowserOpenURL, WindowMinimise, WindowToggleMaximise, WindowIsMaximised, Quit } from '../wailsjs/runtime/runtime';
 import type { adif as adifModels, lookup as lookupModels, cat as catModels } from '../wailsjs/go/models';
 import type { QSOForm, WorkedBeforeView, StationSettingsForm, ListsSettingsForm, ModePresetForm } from '@/types';
@@ -67,6 +69,7 @@ import {
 } from '@/components/ui/dropdown-menu';
 import { APP_VERSION, APP_AUTHOR } from '@/version';
 import { QSLManagerPanel } from '@/components/QSLManagerModal';
+import { WatchlistTab } from '@/components/WatchlistTab';
 import { QslDesignerModal } from '@/components/qsl/QslDesignerModal';
 import { SendEQSLModal } from '@/components/qsl/SendEQSLModal';
 import { AutoEQSL } from '@/components/qsl/AutoEQSL';
@@ -96,7 +99,7 @@ import { ExportFieldsDialog } from '@/components/ExportFieldsDialog';
 import { ShutdownProgress } from '@/components/ShutdownProgress';
 import { ClusterGrid } from '@/components/ClusterGrid';
 import { cleanSpotter, inferSpotMode, spotModeCategory, spotStatusKey } from '@/lib/spot';
-import { applySpotDisplay, readSpotDisplayOptions, spotIsWorked, SPOT_DISPLAY_OPTIONS_EXPOSED } from '@/lib/spotDisplay';
+import { applySpotDisplay, chasePota, readSpotDisplayOptions, spotIsWorked, SPOT_DISPLAY_OPTIONS_EXPOSED } from '@/lib/spotDisplay';
 import { AnswerDecode, HaltDecodeTx, LogUIError, FlexTXOnBand, GetMatrixColors, GetRotorPresets, GetRowColors, GetSpotTTLMinutes, GetSpotMax, IsNewUSCounty } from '../wailsjs/go/main/App';
 import { applyMatrixColors } from '@/lib/matrixColors';
 import { WorkedBeforeGrid } from '@/components/WorkedBeforeGrid';
@@ -931,11 +934,16 @@ export default function App() {
   useEffect(() => {
     if (!band) return;
     let cancelled = false;
-    OperatingDefaultForBand(band).then((d) => {
+    OperatingDefaultForBand(band).then(async (d) => {
+      if (cancelled) return;
+      // The radio actually CONNECTED names itself ahead of the per-band plan:
+      // an IC-7760 on the air must not log as the Flex the band default names.
+      let liveRig = '';
+      try { liveRig = (await ActiveRadioMyRig()) || ''; } catch {}
       if (cancelled) return;
       setDetails((cur) => ({
         ...cur,
-        my_rig: d?.station_name || '',
+        my_rig: liveRig || d?.station_name || '',
         my_antenna: d?.antenna_name || '',
         tx_pwr: d?.tx_pwr ?? cur.tx_pwr,
       }));
@@ -1048,6 +1056,13 @@ export default function App() {
       if (!active) setError(t('rec.manualFailed'));
     }).catch((e: any) => setError(String(e?.message ?? e)));
   };
+  // recTick means "a fresh take" — that is the only case where the clock returns
+  // to zero, as opposed to resuming after a stop. Declared BEFORE the ticking
+  // effect below and deliberately so: effects run in declaration order, and the
+  // other way round the ticker captured the PREVIOUS take's elapsed as its
+  // starting point — the counter showed 0 for one second, then jumped straight
+  // back to the old thirty minutes.
+  useEffect(() => { setRecSeconds(0); recSecondsRef.current = 0; setRecStopped(false); }, [recTick]);
   useEffect(() => {
     if (!recording) { setRecSeconds(0); return; }
     // A stopped take freezes the clock where it is: it must show the length of
@@ -1058,9 +1073,6 @@ export default function App() {
     const id = window.setInterval(() => setRecSeconds(from + Math.floor((Date.now() - start) / 1000)), 1000);
     return () => window.clearInterval(id);
   }, [recording, recTick, recStopped]);
-  // recTick means "a fresh take" — that is the only case where the clock returns
-  // to zero, as opposed to resuming after a stop.
-  useEffect(() => { setRecSeconds(0); recSecondsRef.current = 0; setRecStopped(false); }, [recTick]);
   // The callsign the in-progress recording belongs to (uppercased; '' = none).
   // Lets us restart from zero when the operator edits the call to a different
   // station mid-recording, instead of continuing the old take.
@@ -1489,7 +1501,7 @@ export default function App() {
   // CI-V 0x17 (no extra hardware — sends over the CAT connection). Macros,
   // auto-call and <LOGQSO> are shared; only the transport differs.
   const [wkEngine, setWkEngine] = useState<string>('winkeyer');
-  const cwSource: 'winkeyer' | 'icom' | 'flex' | 'yaesu' | 'kenwood' = wkEngine === 'icom' ? 'icom' : wkEngine === 'flex' ? 'flex' : wkEngine === 'yaesu' ? 'yaesu' : wkEngine === 'kenwood' ? 'kenwood' : 'winkeyer';
+  const cwSource: 'winkeyer' | 'icom' | 'flex' | 'yaesu' | 'kenwood' | 'tci' = wkEngine === 'icom' ? 'icom' : wkEngine === 'flex' ? 'flex' : wkEngine === 'yaesu' ? 'yaesu' : wkEngine === 'kenwood' ? 'kenwood' : wkEngine === 'tci' ? 'tci' : 'winkeyer';
   // Setting the CW speed has to reach the keyer that is ACTUALLY sending, and
   // both the CW panel and the Yaesu console can ask for it. With DTR/RTS line
   // keying the PC does the timing, so the rig's internal keyer speed changes
@@ -1503,6 +1515,7 @@ export default function App() {
     else if (src === 'flex') FlexSetKeySpeed(w).catch(() => {});
     else if (src === 'yaesu') SetYaesuKeySpeed(w).catch(() => {});
     else if (src === 'kenwood') SetKenwoodKeySpeed(w).catch(() => {});
+    else if (src === 'tci') TCISetKeySpeed(w).catch(() => {});
     else WinkeyerSetSpeed(w).catch(() => {});
     // The rig's own keyer follows too whenever a Yaesu is on CAT, even when it is
     // not the sending engine: its front panel and OpsLog then agree.
@@ -1519,7 +1532,7 @@ export default function App() {
   // Seed the current break-in from the rig when the CW panel becomes active in
   // Icom mode (so the control reflects the radio's real state).
   useEffect(() => {
-    if (cwSource !== 'icom' || !wkEnabled || !(catState.backend === 'icom' && catState.connected)) return;
+    if (cwSource !== 'icom' || !wkEnabled || !((catState.backend === 'icom' || catState.backend === 'icom-net') && catState.connected)) return;
     GetIcomState().then((s: any) => { if (s && typeof s.break_in === 'number') setIcomBreakIn(s.break_in); }).catch(() => {});
   }, [cwSource, wkEnabled, catState.backend, catState.connected]);
   // Auto-call: repeat the clicked macro (e.g. F1 CQ) every (message + N seconds)
@@ -1543,10 +1556,11 @@ export default function App() {
   // skips the log that hasn't happened yet.
   const wkSendGenRef = useRef(0);
   useEffect(() => {
-    const connected = cwSource === 'icom' ? (catState.backend === 'icom' && catState.connected)
+    const connected = cwSource === 'icom' ? ((catState.backend === 'icom' || catState.backend === 'icom-net') && catState.connected)
       : cwSource === 'flex' ? (catState.backend === 'flex' && catState.connected)
       : cwSource === 'yaesu' ? (catState.backend === 'yaesu' && catState.connected)
       : cwSource === 'kenwood' ? (catState.backend === 'kenwood' && catState.connected)
+      : cwSource === 'tci' ? (catState.backend === 'tci' && catState.connected)
       : wkStatus.connected;
     wkActiveRef.current = wkEnabled && connected;
   }, [wkEnabled, wkStatus.connected, cwSource, catState.backend, catState.connected]);
@@ -1680,6 +1694,9 @@ export default function App() {
   // NET Control tab — enabled from Tools (persisted; once on it's a tab like Cluster).
   const [netEnabled, setNetEnabled] = useState(() => localStorage.getItem('opslog.netEnabled') === '1');
   useEffect(() => { localStorage.setItem('opslog.netEnabled', netEnabled ? '1' : '0'); }, [netEnabled]);
+  // Watchlist tab — opt-in from Tools, persisted, closable like NET Control.
+  const [watchlistEnabled, setWatchlistEnabled] = useState(() => localStorage.getItem('opslog.watchlistEnabled') === '1');
+  useEffect(() => { localStorage.setItem('opslog.watchlistEnabled', watchlistEnabled ? '1' : '0'); }, [watchlistEnabled]);
   // Contest tab is hidden until enabled from Tools → Contest mode.
   const [contestTabEnabled, setContestTabEnabled] = useState(() => localStorage.getItem('opslog.contestTab') === '1');
   useEffect(() => { localStorage.setItem('opslog.contestTab', contestTabEnabled ? '1' : '0'); }, [contestTabEnabled]);
@@ -1729,15 +1746,29 @@ export default function App() {
     const gen = ++dvkAutoCqGenRef.current;
     dvkAutoCqSlotRef.current = slot;
     const sleep = (ms: number) => new Promise((r) => window.setTimeout(r, ms));
+    // Traced into the app log deliberately: the loop kept 'not repeating' on a
+    // network rig and every guess at which guard was tripping proved wrong.
+    const trace = (m: string) => UILog(`dvk auto-cq: ${m}`).catch(() => {});
+    trace(`start slot=${slot} gen=${gen}`);
+    let round = 0;
     while (dvkAutoCqSlotRef.current === slot && gen === dvkAutoCqGenRef.current && dvkActiveRef.current) {
-      if (!isPhoneMode(modeRef.current)) { stopDvkAutoCq(); break; }
+      // An EMPTY mode is not a mode change: over the network the rig's mode
-      await DVKPlay(slot).catch(() => {});
+      // read fails transiently and the CAT push blanks the field for a poll or
+      // two — killing the auto-CQ loop mid-run for nothing. Only a known
+      // non-phone mode stops the loop.
+      if (modeRef.current && !isPhoneMode(modeRef.current)) { trace(`stopped: mode ${modeRef.current} is not phone`); stopDvkAutoCq(); break; }
+      round++;
+      trace(`round ${round}: play`);
+      await DVKPlay(slot).catch((e: any) => trace(`play failed: ${e?.message ?? e}`));
       await sleep(300);                        // let playback flip "playing" true
+      trace(`round ${round}: playing=${dvkPlayingRef.current}`);
       let guard = 0;                           // then wait for it to finish (cap ~90 s)
       while (dvkPlayingRef.current && gen === dvkAutoCqGenRef.current && guard < 600) { await sleep(150); guard++; }
-      if (gen !== dvkAutoCqGenRef.current) break;
+      if (gen !== dvkAutoCqGenRef.current) { trace(`stopped mid-round: superseded (gen ${dvkAutoCqGenRef.current})`); break; }
+      trace(`round ${round}: message over after ~${(guard * 150 / 1000).toFixed(1)}s, gap ${dvkAutoCqSecsRef.current}s`);
       await sleep(Math.max(0, dvkAutoCqSecsRef.current) * 1000); // gap before the next CQ
     }
+    trace(`exit: slotRef=${dvkAutoCqSlotRef.current} gen=${gen}/${dvkAutoCqGenRef.current} active=${dvkActiveRef.current}`);
   }
   const dvkPlay = useCallback((slot: number) => {
     if (!isPhoneMode(modeRef.current)) { setError(t('dvkp.notPhone')); return; }
@@ -2010,7 +2041,7 @@ export default function App() {
   // so it's loaded async on mount and re-read on profile:changed below.
   // 'none' is only ever stored for the third and fourth panes: the first two are
   // the Main view, and a layout with no panes at all is not a layout.
-  type MainPaneKind = 'map1' | 'map2' | 'cluster' | 'worked' | 'flex' | 'recent' | 'icom' | 'yaesu' | 'elecraft' | 'tci' | 'netcontrol' | 'decodes' | 'none';
+  type MainPaneKind = 'map1' | 'map2' | 'cluster' | 'worked' | 'flex' | 'recent' | 'icom' | 'yaesu' | 'elecraft' | 'tci' | 'netcontrol' | 'decodes' | 'watchlist' | 'none';
   const [mapZoomSignal, setMapZoomSignal] = useState(0); // bump → world map auto-zooms now
   const [mainPaneLeft, setMainPaneLeft] = useState<MainPaneKind>('map1');
   const [mainPaneRight, setMainPaneRight] = useState<MainPaneKind>('map2');
@@ -2021,7 +2052,7 @@ export default function App() {
   // quarter-width map is unreadable.
   const [mainLayout4, setMainLayout4] = useState<'cols' | 'quad'>('quad');
   const loadMainPanes = useCallback(async () => {
-    const valid = (v: string): v is MainPaneKind => v === 'map1' || v === 'map2' || v === 'cluster' || v === 'worked' || v === 'flex' || v === 'recent' || v === 'icom' || v === 'yaesu' || v === 'elecraft' || v === 'tci' || v === 'netcontrol' || v === 'decodes';
+    const valid = (v: string): v is MainPaneKind => v === 'map1' || v === 'map2' || v === 'cluster' || v === 'worked' || v === 'flex' || v === 'recent' || v === 'icom' || v === 'yaesu' || v === 'elecraft' || v === 'tci' || v === 'netcontrol' || v === 'decodes' || v === 'watchlist';
     const [l, r, p3, p4, lay] = await Promise.all([
       GetUIPref('mainPaneLeft').catch(() => ''),
       GetUIPref('mainPaneRight').catch(() => ''),
@@ -2064,6 +2095,9 @@ export default function App() {
   useEffect(() => { spotStatusRef.current = spotStatus; }, [spotStatus]);
   // Mirror of spots so the log-triggered refresh reads the current list without
   // a stale closure.
+  // Arrival times of the last second's spots, for the adaptive batching window
+  // in the cluster:spot listener.
+  const spotRateRef = useRef<number[]>([]);
   const spotsRef = useRef(spots);
   useEffect(() => { spotsRef.current = spots; }, [spots]);
   // The decoded stations, for the same reason: the status refresh and the cache
@@ -2532,6 +2566,10 @@ export default function App() {
     for (const d of decodes) {
       const seenKey = `${d.call}|${d.ms ?? d.at}|${d.instance ?? ''}`;
       if (autoSeenRef.current.has(seenKey)) continue;
+      // A Replay's resent history is display-only: answering a line the far
+      // end already dropped would fail anyway, and doing it at startup — the
+      // moment replays arrive — would be a transmitter firing on old news.
+      if ((d as any).is_new === false) { autoSeenRef.current.add(seenKey); continue; }
       // Only decodes from the CURRENT period are worth answering: replying to a
       // slot that has closed asks the far end to match a decode it has dropped.
       if (now - Date.parse(d.at) > 30_000) { autoSeenRef.current.add(seenKey); continue; }
@@ -2629,6 +2667,11 @@ export default function App() {
   // "the field still shows the previous broadcast" (safe to update) from "the
   // user has typed a different call" (must not clobber).
   const lastUdpCallRef = useRef('');
+  // Edge detection for the DECODER'S stream: WSJT-X/JTDX/MSHV re-broadcast the
+  // same DX Call in every Status packet, seconds apart, forever. Applying each
+  // one meant a spot clicked in OpsLog was overwritten moments later by the
+  // decoder restating old news. Only a CHANGE in this stream is an event.
+  const lastWsjtEdgeRef = useRef('');
 
   // When the entered callsign turns out to be worked-before, jump to the
   // Worked-before tab so the history is front-and-centre. Only once per call,
@@ -3275,7 +3318,7 @@ export default function App() {
   function handleSpotSelect(s: any) {
     if (!s?.dx_call?.trim()) return;
     onCallsignInput(s.dx_call, { force: true });
-    applySpotPOTA((s as any).pota_ref);
+    applySpotRefs((s as any).pota_ref, (s as any).sota_ref);
   }
 
   function handleSpotClick(s: any) {
@@ -3293,14 +3336,23 @@ export default function App() {
       noteManualEdit();
     }
     if (s.band) setBand(s.band);
-    if (catState.connected) tuneRigCAT(s.freq_hz, m);
     // The panadapter width follows the MODE of the spot, when the option is on.
-    // AFTER the tune, deliberately: a view change must never delay the frequency
+    // A no-op on any backend but a Flex. Sequenced AFTER the tune settles, not
-    // change the operator is waiting for. A no-op on any backend but a Flex.
+    // fired alongside it: on a cross-band jump SmartSDR moves the panadapter
-    FlexZoomForSpot(m ?? '', s.freq_hz ?? 0).catch(() => {});
+    // itself to follow the slice, and that follow lands after — and overrides —
+    // a zoom sent in the same instant. (A spot clicked ON the panadapter never
+    // hit this: the radio had already tuned before our zoom arrived.)
+    const zoom = () => FlexZoomForSpot(m ?? '', s.freq_hz ?? 0).catch(() => {});
+    if (catState.connected) {
+      void tuneRigCAT(s.freq_hz, m).then(() => window.setTimeout(zoom, 300));
+    } else zoom();
     if (m) applyModeFromSpot(m);
+    // And the DECODER follows too: an FT4 spot clicked while WSJT-X sits in
+    // FT8 switches its mode (Configure, message 15). The backend filters —
+    // only modes the decoder speaks, only when the option is on.
+    if (m) ConfigureDecoderMode(m).catch(() => {});
     onCallsignInput(s.dx_call, { force: true });
-    applySpotPOTA((s as any).pota_ref);
+    applySpotRefs((s as any).pota_ref, (s as any).sota_ref);
     if (s.dx_call?.trim()) restartRecordingForNewTarget(s.dx_call);
   }
 
@@ -3591,11 +3643,24 @@ export default function App() {
     const unsubSpot = EventsOn('cluster:spot', (sp: ClusterSpot) => {
       // Stage the spot; a short timer resolves its status then commits it.
       pendingSpotsRef.current.push(sp);
-      // 50 ms is enough to coalesce an RBN burst into one status lookup (the
+      // The window WIDENS with the rate of the feed.
-      // worked-index is in memory, so resolving is near-instant) while staying
+      //
-      // imperceptible.
+      // Every flush commits state that the whole window re-renders on, so a
+      // fixed 50 ms means twenty full renders a second under an RBN firehose —
+      // and that is felt everywhere else: a dropdown highlighting its entries a
+      // beat late as the mouse moves down them, which is what was reported.
+      //
+      // A quiet cluster keeps the 50 ms: a handful of spots an hour should
+      // appear the moment they arrive. A busy one is coalesced instead, and half
+      // a second's delay on a line in a list that is already scrolling past is
+      // not something anyone can see.
+      const now = Date.now();
+      spotRateRef.current = spotRateRef.current.filter((t) => now - t < 1000);
+      spotRateRef.current.push(now);
+      const perSec = spotRateRef.current.length;
+      const window_ms = perSec > 20 ? 500 : perSec > 5 ? 200 : 50;
       if (pendingSpotTimer.current === undefined) {
-        pendingSpotTimer.current = window.setTimeout(flushPendingSpots, 50);
+        pendingSpotTimer.current = window.setTimeout(flushPendingSpots, window_ms);
       }
       // Self-spot: someone spotted OUR callsign — show it in the shared header
       // toast (same place as the other notifications), not a separate banner.
@@ -3740,6 +3805,13 @@ export default function App() {
       // Anything that isn't WSJT-X (N1MM, ADIF, a panadapter/cluster click relayed
       // over UDP…) is an explicit pick → force it over an existing call.
       const force = String(p?.service ?? '').toLowerCase() !== 'wsjt';
+      if (!force) {
+        // The decoder's stream: same value as last time = no edge = no update.
+        // Only a changed DX Call is the operator doing something over there.
+        const upper = String(p?.call ?? '').trim().toUpperCase();
+        if (upper && upper === lastWsjtEdgeRef.current) return;
+        lastWsjtEdgeRef.current = upper;
+      }
       // External app moved to a new station → fresh recording for the new target.
       if (applyUdpCall(p?.call, force)) restartRecordingForNewTarget(String(p?.call ?? ''));
     });
@@ -3750,6 +3822,9 @@ export default function App() {
     // Only when something is actually in the entry, so an idle digital app doesn't
     // wipe a call being typed by hand.
     const unsubClear = EventsOn('udp:clear_call', () => {
+      // The decoder cleared its DX Call: the next call it announces — even the
+      // same one re-selected — is a fresh edge.
+      lastWsjtEdgeRef.current = '';
       if (callsignRef.current?.value?.trim() || callsign.trim()) resetEntry();
     });
     // Clicked one of OpsLog's spots on the FlexRadio panadapter → fill the call
@@ -3761,14 +3836,14 @@ export default function App() {
       restartRecordingForNewTarget(call);
       // The park, like a click in the band map: the radio reports only a
       // callsign, so the backend looks it up again before sending the event.
-      applySpotPOTA(String(p?.pota_ref ?? ''));
+      applySpotRefs(String(p?.pota_ref ?? ''), String(p?.sota_ref ?? ''));
     });
     // Clicking a spot on the ExpertSDR (TCI) panorama fills the call, like Flex.
     const unsubTciSpot = EventsOn('tci:spot_clicked', (p: any) => {
       const call = String(p?.call ?? '');
       if (!applyUdpCall(call, true)) return;
       restartRecordingForNewTarget(call);
-      applySpotPOTA(String(p?.pota_ref ?? ''));
+      applySpotRefs(String(p?.pota_ref ?? ''), String(p?.sota_ref ?? ''));
     });
     const unsubBulk = EventsOn('bulkupdate:progress', (p: any) => {
       const total = Number(p?.total ?? 0);
@@ -3967,7 +4042,7 @@ export default function App() {
     // segment AFTER the <LOGQSO> (which logs and clears the form) still expands its
     // variables correctly.
     const parts = rawText.split(/<LOGQSO>/i).map((pt) => resolveCW(pt));
-    const isRig = cwSourceRef.current === 'icom' || cwSourceRef.current === 'flex' || cwSourceRef.current === 'yaesu' || cwSourceRef.current === 'kenwood';
+    const isRig = cwSourceRef.current === 'icom' || cwSourceRef.current === 'flex' || cwSourceRef.current === 'yaesu' || cwSourceRef.current === 'kenwood' || cwSourceRef.current === 'tci';
     for (let p = 0; p < parts.length; p++) {
       if (aborted()) return; // ESC / Stop before this segment → stop sending, don't log
       const resolved = parts[p];
@@ -3979,7 +4054,7 @@ export default function App() {
         // current WPM, so it scales automatically.
         const keyed = resolved + ' ';
         setWkSent(resolved);
-        const sendFn = cwSourceRef.current === 'flex' ? FlexSendCW : cwSourceRef.current === 'icom' ? IcomSendCW : cwSourceRef.current === 'yaesu' ? YaesuSendCW : cwSourceRef.current === 'kenwood' ? KenwoodSendCW : null;
+        const sendFn = cwSourceRef.current === 'flex' ? FlexSendCW : cwSourceRef.current === 'icom' ? IcomSendCW : cwSourceRef.current === 'yaesu' ? YaesuSendCW : cwSourceRef.current === 'kenwood' ? KenwoodSendCW : cwSourceRef.current === 'tci' ? TCISendCW : null;
         if (sendFn) await sendFn(keyed).catch((e) => setError(String(e?.message ?? e)));
         else await WinkeyerSend(keyed).catch((e) => setError(String(e?.message ?? e)));
         // WAIT for THIS segment's CW to finish before moving on — so a <LOGQSO>
@@ -4022,6 +4097,7 @@ export default function App() {
     else if (cwSourceRef.current === 'flex') FlexStopCW().catch(() => {});
     else if (cwSourceRef.current === 'yaesu') YaesuStopCW().catch(() => {});
     else if (cwSourceRef.current === 'kenwood') KenwoodStopCW().catch(() => {});
+    else if (cwSourceRef.current === 'tci') TCIStopCW().catch(() => {});
     else WinkeyerStop().catch(() => {});
   }
   // runAutoCall sends macro i, waits for the keyer to finish, waits the chosen
@@ -4070,6 +4146,10 @@ export default function App() {
   // send-on-type: key the typed chars verbatim (no variable substitution).
   function wkSendRaw(chars: string) {
     if (cwSourceRef.current === 'flex') { FlexSendCW(chars).catch(() => {}); return; }
+    // TCI keys the character as a macro of its own. There is no un-typing it
+    // afterwards — the radio can stop the message but not shorten it — so the
+    // backspace below leaves the TCI engine alone rather than pretending.
+    if (cwSourceRef.current === 'tci') { TCISendCW(chars).catch(() => {}); return; }
     WinkeyerSend(chars).catch(() => {});
   }
   function wkBackspace() {
@@ -4558,10 +4638,17 @@ export default function App() {
     return () => { dead = true; };
   }, [selQso, callsign]);
 
+  const wbTokenRef = useRef(0);
   async function runWorkedBefore(call: string, dxccHint: number = 0) {
+    // Latest-wins: two lookups race when the operator types a second call
+    // before the first answered, and the SLOW one used to land last — the
+    // grid then showed the previous call's QSOs under the new call's name
+    // (LU5AVM's contact filed under LW8ETV, screenshot in hand).
+    const token = ++wbTokenRef.current;
     setWbBusy(true);
     try {
       const w = await WorkedBefore(call, dxccHint);
+      if (token !== wbTokenRef.current) return; // a newer lookup owns the panel
       setWb(w);
       // Mirrored synchronously rather than through the effect above: a backfill
       // parked by the lookup has to read this on the very next line, not a
@@ -4576,10 +4663,11 @@ export default function App() {
         fillFromLastQso(p.r, call);
       }
     } catch {
+      if (token !== wbTokenRef.current) return;
       setWb(null);
       wbRef.current = null;
       wbCallRef.current = '';
-    } finally { setWbBusy(false); }
+    } finally { if (token === wbTokenRef.current) setWbBusy(false); }
   }
   // fillFromLastQso enriches the entry from the LAST QSO we logged with this call
   // when the live lookup came up short — the callsign isn't on QRZ/HamQTH, or no
@@ -4796,13 +4884,17 @@ export default function App() {
     }
     wbTimerRef.current = window.setTimeout(() => runWorkedBefore(call), 150);
   }
-  // applySpotPOTA sets the QSO's POTA award reference(s) from a clicked spot's
+  // Award references carried by the spot itself: the park a station is
-  // park ref ("US-4164" or n-fer "US-1,US-2"). Empty ref clears it (fresh
+  // activating, the summit it is on, or both. Written into award_refs the same
-  // target). Routed to the pota_ref column at save via applyAwardRefs.
+  // way for each, so logging the contact credits it without retyping a
-  function applySpotPOTA(potaRef?: string) {
+  // reference that was on screen.
-    const refs = String(potaRef || '')
+  function applySpotRefs(potaRef?: string, sotaRef?: string) {
-      .split(/[,;]/).map((x) => x.trim().toUpperCase()).filter(Boolean);
+    const split = (v?: string) => String(v || '').split(/[,;]/).map((x) => x.trim().toUpperCase()).filter(Boolean);
-    setDetails((d) => ({ ...d, award_refs: refs.map((r) => `POTA@${r}`).join(';') }));
+    const refs = [
+      ...split(potaRef).map((r) => `POTA@${r}`),
+      ...split(sotaRef).map((r) => `SOTA@${r}`),
+    ];
+    setDetails((d) => ({ ...d, award_refs: refs.join(';') }));
   }
   function onCallsignInput(v: string, opts?: { force?: boolean }) {
     // Programmatic call-sets (force: spot click, UDP, external app) count as
@@ -4975,6 +5067,7 @@ export default function App() {
       { 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: (watchlistEnabled ? '✓ ' : '') + t('tools.watchlist'), action: 'tools.watchlist' },
       { type: 'item', label: (contestTabEnabled ? '✓ ' : '') + t('tools.contest'), action: 'tools.contest' },
       { type: 'item', label: t('tools.alerts'), action: 'tools.alerts' },
       { type: 'separator' },
@@ -4998,7 +5091,7 @@ export default function App() {
       { type: 'separator' },
       { type: 'item', label: t('help.about'), action: 'help.about' },
     ]},
-  ], [total, selectedId, selectedIds, exporting, wkEnabled, dvkEnabled, cwEnabled, netEnabled, contestTabEnabled, smtpConfigured, sendingLog, t]);
+  ], [total, selectedId, selectedIds, exporting, wkEnabled, dvkEnabled, cwEnabled, netEnabled, watchlistEnabled, contestTabEnabled, smtpConfigured, sendingLog, t]);
 
   function handleMenu(action: string) {
     switch (action) {
@@ -5026,6 +5119,7 @@ export default function App() {
       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.watchlist':   setWatchlistEnabled((v) => { const nv = !v; if (nv) setActiveTab('watchlist'); 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;
       case 'tools.duplicates':  setShowDuplicates(true); break;
@@ -5841,6 +5935,13 @@ export default function App() {
         // worked call still matches its own entity status too (new-band/new-slot),
         // so it stays visible under those chips.
         const matches = (st !== 'worked' && clusterStatusFilter.has(st))
+          // NEW CALL is a FACT about the callsign (never worked on this band and
+          // mode), surfaced as a status only by the slot-highlight option. The
+          // chip filters on the fact itself, so it works whether or not that
+          // display option is on — worked_slot is computed whenever either
+          // slot option is enabled.
+          || (clusterStatusFilter.has('new-call') && e?.worked_slot === false
+            && (!e?.status || e?.status === 'worked' || e?.status === 'new-call'))
           || (!!e?.worked_call && clusterStatusFilter.has('worked'))
           || (!!e?.new_pota && clusterStatusFilter.has('new-pota'))
           || (!!e?.new_county && clusterStatusFilter.has('new-county'))
@@ -5897,11 +5998,17 @@ export default function App() {
     });
     let rendered = list as (ClusterSpot & { repeats?: number })[];
     if (clusterGroup) {
+      // A DUPLICATE is the same station on the same band AND mode — the dozen
+      // skimmers that all heard one CQ. The same station on another band is the
+      // opposite of a duplicate: it is the line a DX chaser is scanning for, and
+      // grouping on the callsign alone deleted it. RI1FJL spotted on five bands
+      // showed as one row, so four slots simply vanished from the list.
       const seen = new Map<string, ClusterSpot & { repeats: number }>();
       for (const s of list) {
-        const e = seen.get(s.dx_call);
+        const key = `${(s.dx_call ?? '').toUpperCase()}|${(s.band ?? '').toLowerCase()}|${inferSpotMode(s.comment ?? '', s.freq_hz)}`;
+        const e = seen.get(key);
         if (e) { e.repeats++; }
-        else seen.set(s.dx_call, { ...s, repeats: 1 });
+        else seen.set(key, { ...s, repeats: 1 });
       }
       rendered = Array.from(seen.values());
     }
@@ -5941,12 +6048,20 @@ export default function App() {
   );
 
   const F_CHIP = 'px-1.5 py-[3px] rounded-md border text-[10px] font-bold tracking-wider transition-opacity';
-  const fChip = (key: string, label: string, cls: string, on: boolean, toggle: () => void) => (
+  const fChip = (key: string, label: string, cls: string, on: boolean, toggle: () => void, style?: React.CSSProperties, title?: string) => (
-    <button key={key} type="button" onClick={toggle}
+    <button key={key} type="button" onClick={toggle} title={title}
-      className={cn(F_CHIP, on ? cls : `${cls} opacity-40 hover:opacity-80`)}>
+      className={cn(F_CHIP, on ? cls : `${cls} opacity-40 hover:opacity-80`)} style={style}>
       {label}
     </button>
   );
+  // chipStyle builds a filter chip in an arbitrary colour — for the statuses
+  // whose grid badge is not one of the semantic tokens the chip classes cover.
+  // A filter that does not look like what it selects has to be learned twice.
+  const chipStyle = (c: string): React.CSSProperties => ({
+    color: c,
+    borderColor: `color-mix(in srgb, ${c} 45%, transparent)`,
+    background: `color-mix(in srgb, ${c} 14%, transparent)`,
+  });
 
   const renderClusterFilters = () => (
     <div className="w-56 shrink-0 border-l border-border/60 flex flex-col min-h-0 bg-muted/10">
@@ -6062,14 +6177,14 @@ export default function App() {
               { k: 'new-band-mode' as SpotFilterKey, label: 'NEW B+M', cls: 'bg-danger-muted text-danger-muted-foreground border-danger-border' },
               { k: 'new-band' as SpotFilterKey, label: 'NEW BAND',  cls: 'bg-warning-muted text-warning-muted-foreground border-warning-border' },
               { k: 'new-mode' as SpotFilterKey, label: 'NEW MODE',  cls: 'bg-caution-muted text-caution-muted-foreground border-caution-border' },
-              { k: 'new-slot' as SpotFilterKey, label: 'NEW SLOT',  cls: 'bg-caution-muted text-caution-muted-foreground border-caution-border' },
+              { k: 'new-slot' as SpotFilterKey, label: 'NEW SLOT',  cls: 'border', style: chipStyle('#5AC8FA') },
               // NEW CALL is about the CALLSIGN, not the entity: never worked on this
               // band and mode. Only appears when the slot-highlight option is on.
               { k: 'new-call' as SpotFilterKey, label: 'NEW CALL',  cls: 'bg-caution-muted text-caution-muted-foreground border-caution-border' },
               // Same colours as the badges in the grid — a filter that does not
               // look like what it selects has to be learned twice.
               { k: 'new-pota'   as SpotFilterKey, label: 'NEW POTA',   cls: 'bg-success-muted text-success-muted-foreground border-success-border' },
-              { k: 'new-county' as SpotFilterKey, label: 'NEW COUNTY', cls: 'bg-success-muted text-success-muted-foreground border-success-border' },
+              { k: 'new-county' as SpotFilterKey, label: 'NEW COUNTY', cls: 'border', style: chipStyle('var(--chart-5)') },
               { k: 'new-pfx'    as SpotFilterKey, label: 'NEW PFX',    cls: 'bg-caution-muted text-caution-muted-foreground border-caution-border' },
               // Only ever set for a station this receiver decoded over the UDP link.
               { k: 'new-grid'   as SpotFilterKey, label: 'NEW GRID',   cls: 'bg-muted text-foreground border-border' },
@@ -6077,8 +6192,9 @@ export default function App() {
               // worked spots; the separate "Hide worked" checkbox drops them — they
               // are opposite controls, so don't use both at once.
               { k: 'worked'   as SpotFilterKey, label: 'WORKED',   cls: 'bg-info-muted text-info-muted-foreground border-info-border' },
-            ]).map((s) => fChip(s.k, s.label, s.cls, clusterStatusFilter.has(s.k),
+            ]).filter((s: any) => s.k !== 'new-pota' || chasePota())
-              () => setClusterStatusFilter((cur) => { const n = new Set(cur); if (n.has(s.k)) n.delete(s.k); else n.add(s.k); return n; })))}
+              .map((s: any) => fChip(s.k, s.label, s.cls, clusterStatusFilter.has(s.k),
+              () => setClusterStatusFilter((cur) => { const n = new Set(cur); if (n.has(s.k)) n.delete(s.k); else n.add(s.k); return n; }), s.style))}
           </div>,
           clusterStatusFilter.size > 0 ? (
             <button type="button" onClick={() => setClusterStatusFilter(new Set())}
@@ -6223,13 +6339,19 @@ export default function App() {
       case 'cluster':
         return (
           <div className="h-full w-full min-h-0 flex flex-col bg-card border border-border rounded-lg overflow-hidden">
-            <div className="flex items-center justify-between px-2 py-1 border-b border-border/60 shrink-0">
-              <span className="text-[11px] font-semibold uppercase tracking-wider text-muted-foreground">Cluster</span>
-              {clusterFiltersToggleBtn}
-            </div>
             <div className="flex-1 min-h-0 flex">
               <div className="flex-1 min-w-0 flex flex-col min-h-0">
-                <ClusterGrid key={`clg-${activeProfileId ?? 'x'}`} rows={clusterRenderedRows as any} spotStatus={spotStatus} onSpotClick={handleSpotClick} onSpotSelect={handleSpotSelect} />
+                {/* Title, count and Filters ride INSIDE the grid's toolbar: two
+                    header rows cost a pane that is often only a few spots tall
+                    one of the few lines it has. */}
+                <ClusterGrid key={`clg-${activeProfileId ?? 'x'}`} rows={clusterRenderedRows as any} spotStatus={spotStatus} onSpotClick={handleSpotClick} onSpotSelect={handleSpotSelect}
+                  headerLeft={(
+                    <>
+                      <span className="text-[11px] font-semibold uppercase tracking-wider text-muted-foreground shrink-0">DX Cluster</span>
+                      <Badge variant="secondary" className="text-[10px] shrink-0">{spots.length} live</Badge>
+                      {clusterFiltersToggleBtn}
+                    </>
+                  )} />
               </div>
               {clusterShowFilters && renderClusterFilters()}
             </div>
@@ -6276,6 +6398,13 @@ export default function App() {
             <IcomPanel isNetwork={catBackend === 'icom-net'} onReportRST={(r) => { setRstSent(r); rstUserEditedRef.current = true; }} />
           </div>
         );
+      case 'watchlist':
+        return (
+          <div className="h-full w-full min-h-0 flex flex-col bg-card border border-border rounded-lg overflow-hidden">
+            <WatchlistTab spots={spots} spotStatus={spotStatus}
+              onSpotSelect={handleSpotSelect} onSpotClick={handleSpotClick} />
+          </div>
+        );
       case 'netcontrol':
         return (
           <div className="h-full w-full min-h-0 flex flex-col rounded-lg overflow-hidden border border-border">
@@ -6415,7 +6544,7 @@ export default function App() {
                     disabled={disabled}
                     onClick={() => p && goto(p.bearingShort, 'SP')}
                     title={p
-                      ? `Rotate short-path · ${Math.round(p.distanceShort).toLocaleString()} km`
+                      ? `Rotate short-path · ${formatDistance(p.distanceShort)}`
                       : (station.my_grid ? 'No remote grid' : 'Set your station grid in Preferences')}
                     className={cn(
                       'inline-flex items-center gap-1 px-2 py-0.5 transition-colors',
@@ -6431,7 +6560,7 @@ export default function App() {
                     type="button"
                     disabled={disabled}
                     onClick={() => p && goto(p.bearingLong, 'LP')}
-                    title={p ? `Rotate long-path · ${Math.round(p.distanceLong).toLocaleString()} km` : ''}
+                    title={p ? `Rotate long-path · ${formatDistance(p.distanceLong)}` : ''}
                     className={cn(
                       'px-1.5 py-0.5 border-l border-info-border text-[10px] transition-colors',
                       disabled
@@ -7169,7 +7298,7 @@ export default function App() {
         // relative + absolute inner: the panel's content can't grow the row, so
         // the row height is set by the ENTRY STRIP. A taller tab (Awards/F3) then
         // scrolls inside this fixed height instead of pushing everything down.
-        <div className="w-[560px] shrink-0 min-h-0 relative">
+        <div className="w-[600px] shrink-0 min-h-0 relative">
           <div className="absolute inset-0 flex flex-col min-h-0">
           <DetailsPanel
             callsign={callsign}
@@ -7351,7 +7480,10 @@ export default function App() {
                   entry, and the rig onto the frequency it was decoded on. */}
               <ChaseNewPanel onPick={(sp) => {
                 onCallsignInput(sp.call, { force: true });
-                if (sp.freq_hz) void tuneRigCAT(sp.freq_hz, sp.mode);
+                // And the panadapter width too — after the tune settles, for the
+                // same SmartSDR pan-follow reason as handleSpotClick.
+                if (sp.freq_hz) void tuneRigCAT(sp.freq_hz, sp.mode).then(() =>
+                  window.setTimeout(() => FlexZoomForSpot(sp.mode ?? '', sp.freq_hz ?? 0).catch(() => {}), 300));
               }} onClose={() => { setShowChaseNew(false); writeUiPref('opslog.showChaseNew', '0'); }} />
             </div>
           )}
@@ -7544,6 +7676,21 @@ export default function App() {
                   </span>
                 </TabsTrigger>
               )}
+              {watchlistEnabled && (
+                <TabsTrigger value="watchlist" className="gap-1.5">
+                  {t('tab.watchlist')}
+                  <span
+                    role="button"
+                    aria-label="Close Watchlist"
+                    title="Close"
+                    className="inline-flex items-center justify-center size-4 rounded hover:bg-foreground/10 text-muted-foreground hover:text-foreground"
+                    onPointerDown={(e) => { e.stopPropagation(); }}
+                    onClick={(e) => { e.stopPropagation(); setWatchlistEnabled(false); setActiveTab((t) => (t === 'watchlist' ? 'recent' : t)); }}
+                  >
+                    <X className="size-3" />
+                  </span>
+                </TabsTrigger>
+              )}
               {catState.backend === 'flex' && <TabsTrigger value="flex">Flex Console</TabsTrigger>}
               {catState.backend === 'icom' && <TabsTrigger value="icom">Icom Console</TabsTrigger>}
               {catState.backend === 'yaesu' && <TabsTrigger value="yaesu">Yaesu Console</TabsTrigger>}
@@ -8255,6 +8402,12 @@ export default function App() {
             {/* Band Map: several bands shown side-by-side (panadapter-style
                 strips). Pick bands with the chips; each strip is clickable to
                 tune the rig. */}
+            {watchlistEnabled && (
+              <TabsContent value="watchlist" className="mt-0 flex flex-col min-h-0 flex-1">
+                <WatchlistTab spots={spots} spotStatus={spotStatus}
+                  onSpotSelect={handleSpotSelect} onSpotClick={handleSpotClick} />
+              </TabsContent>
+            )}
             {netEnabled && (
               <TabsContent value="net" className="mt-0 flex flex-col min-h-0 flex-1">
                 <NetControlPanel onLogged={refresh} countries={countries} bands={bands} modes={modes}
@@ -8423,9 +8576,13 @@ export default function App() {
                 STANDBY, red = offline. CLICK toggles OPERATE ↔ STANDBY (optimistic
                 flip, the 2s poll reconciles); offline → click opens the settings. */}
             {ampSts.map((a: any) => {
-              const isPGXL = !a.spe && !a.acom;
+              // Every brand must be listed here. A KPA was not, so its chip
+              // read the fallback — permanently red on a connected amplifier,
+              // and clicking it opened the settings instead of switching to
+              // STANDBY.
+              const isPGXL = !a.spe && !a.acom && !a.kpa;
               const viaFlex = isPGXL && !!flexAmp?.amp_available;
-              const raw = a.spe ?? a.acom ?? a.pgxl ?? { connected: false };
+              const raw = a.spe ?? a.acom ?? a.kpa ?? a.pgxl ?? { connected: false };
               const connected = !!raw.connected || viaFlex;
               const operate = viaFlex ? !!flexAmp.amp_operate : !!raw.operate;
               const dot = !connected ? 'bg-danger' : operate ? 'bg-success' : 'bg-warning';
@@ -8435,7 +8592,7 @@ export default function App() {
                 const want = !operate;
                 if (viaFlex) setFlexAmp((f: any) => ({ ...f, amp_operate: want }));
                 else setAmpSts((l) => l.map((x: any) => x.id === a.id
-                  ? { ...x, spe: x.spe && { ...x.spe, operate: want }, acom: x.acom && { ...x.acom, operate: want }, pgxl: x.pgxl && { ...x.pgxl, operate: want } }
+                  ? { ...x, spe: x.spe && { ...x.spe, operate: want }, acom: x.acom && { ...x.acom, operate: want }, kpa: x.kpa && { ...x.kpa, operate: want }, pgxl: x.pgxl && { ...x.pgxl, operate: want } }
                   : x));
                 (viaFlex ? FlexAmpOperate(want) : AmpOperate(a.id, want)).catch(() => {});
               };
@@ -8562,7 +8719,7 @@ export default function App() {
                     "1.5k" and then appended the unit, giving "1.5kkm" — and even
                     written correctly, "1.5k km" makes a reader do arithmetic to
                     recover a number that was four characters long to begin with. */}
-                <span className="font-mono opacity-80">{o.median_km} km</span>
+                <span className="font-mono opacity-80">{formatDistance(o.median_km)}</span>
                 {/* Out of season is the one an operator must not learn last, so it
                     earns a mark on the badge rather than a line in the tooltip. */}
                 {!o.in_season && <span className="opacity-90">!</span>}
@@ -8607,9 +8764,14 @@ export default function App() {
         // freqMhz display string, which the manual-edit freeze / field locks can
         // leave stale (that dropped the sub-kHz: on 14134.5 the frozen "14.134"
         // string spotted 14134). Fall back to the entry field, then the last QSO.
+        //
+        // The RX frequency when split, deliberately: a spot names where the
+        // STATION is, and in split that is where we listen — freq_hz is where
+        // we transmit, and spotting a 5-up pile-up's TX frequency sent the
+        // whole cluster five kHz above the DX.
         defaultFreqKHz={
-          catState.connected && (catState.freq_hz ?? 0) > 0
+          catState.connected && ((catState.split && (catState.freq_rx_hz ?? 0) > 0 ? catState.freq_rx_hz : catState.freq_hz) ?? 0) > 0
-            ? Math.round(((catState.freq_hz ?? 0) / 1000) * 10) / 10
+            ? Math.round((((catState.split && (catState.freq_rx_hz ?? 0) > 0 ? catState.freq_rx_hz : catState.freq_hz) ?? 0) / 1000) * 10) / 10
             : parseFloat(freqMhz) > 0
               ? Math.round(parseFloat(freqMhz) * 1000 * 10) / 10
               : (qsos[0]?.freq_hz ? Math.round((qsos[0].freq_hz / 1000) * 10) / 10 : 0)

frontend/src/components/AmpCard.tsx

@@ -194,7 +194,7 @@ export function AmpCard({ amp, flex, t }: { amp: Amp; flex: any; t: (k: string,
           </div>
           <span className={cn('inline-flex items-center gap-1.5 text-sm', kpa.connected ? 'text-muted-foreground' : 'text-danger')}>
             <span className={cn('size-2 rounded-full', kpa.connected ? 'bg-success' : 'bg-danger')} />
-            {kpa.connected ? (kpa.tuning ? t('flxp.kpaTuning') : (kpa.power_on ? 'ON' : 'OFF')) : t('flxp.acomOffline')}
+            {kpa.connected ? (kpa.tuning ? t('flxp.kpaTuning') : (kpa.power_on ? 'ON' : 'OFF')) : t('flxp.kpaOffline')}
           </span>
           {kpa.connected && (
             <span className="text-sm font-mono text-muted-foreground tabular-nums">

frontend/src/components/AppearancePanel.tsx

@@ -127,6 +127,12 @@ function MatrixColorsSection() {
             <span className="inline-block w-7 h-5 rounded bg-mx-dx-work" />
             <span className="inline-block w-7 h-5 rounded bg-mx-none" />
             <span className="inline-block w-7 h-5 rounded bg-mx-none ring-2 ring-mx-cur ring-inset" />
+            <span className="relative inline-block w-7 h-5 rounded bg-mx-dx-conf">
+              <span className="absolute top-[4px] right-[4px] size-[5px] rounded-full bg-mx-mark-work ring-1 ring-background" />
+            </span>
+            <span className="relative inline-block w-7 h-5 rounded bg-mx-dx-conf">
+              <span className="absolute top-[4px] right-[4px] size-[5px] rounded-full bg-mx-mark-conf ring-1 ring-background" />
+            </span>
           </div>
 
           <button type="button" onClick={reset}

frontend/src/components/AwardsPanel.tsx

@@ -65,6 +65,19 @@ function cellStatus(r: AwardRef, band: string): CellStatus {
   if (r.bands?.includes(band)) return 'worked';
   return 'none';
 }
+// slotsToConfirm counts the band-slots worked with this reference and not yet
+// confirmed on any of them — the QSLs still outstanding, one per cell showing W.
+//
+// It is the difference the Challenge line makes visible in the aggregate (1832
+// worked against 1554 confirmed) without saying WHERE it is. Counted over the
+// bands actually on screen, so it always adds up to the columns in front of the
+// operator rather than to a band set they filtered out.
+function slotsToConfirm(r: AwardRef, bands: string[]): number {
+  let n = 0;
+  for (const b of bands) if (cellStatus(r, b) === 'worked') n++;
+  return n;
+}
+
 const CELL_STYLE: Record<CellStatus, string> = {
   validated: 'bg-success text-success-foreground',
   confirmed: 'bg-warning text-warning-foreground',
@@ -112,7 +125,7 @@ export function AwardsPanel({ onEditQSO, onAwardsChanged, onPaperQSL }: {
   const [refSearch, setRefSearch] = useState('');
   const [editing, setEditing] = useState(false);
   const [view, setView] = useState<'grid' | 'list' | 'stats'>('grid');
-  const [refFilter, setRefFilter] = useState<'all' | 'worked' | 'notworked' | 'worked_notconf'>('all');
+  const [refFilter, setRefFilter] = useState<'all' | 'worked' | 'notworked' | 'worked_notconf' | 'slots_notconf'>('all');
   // Mode filter, stacked ON TOP of the status one. "Worked on CW but not
   // confirmed" is two questions at once, and answering only one of them is what
   // sends an operator to a spreadsheet.
@@ -304,6 +317,10 @@ export function AwardsPanel({ onEditQSO, onAwardsChanged, onPaperQSL }: {
       if (refFilter === 'worked' && !r.worked) return false;
       if (refFilter === 'notworked' && r.worked) return false;
       if (refFilter === 'worked_notconf' && !(r.worked && !r.confirmed)) return false;
+      // Worked-not-confirmed by SLOT, not by reference: an entity confirmed on
+      // 20 m still has a 15 m contact waiting for its card, and every filter
+      // above answers "no" for it because the entity itself is confirmed.
+      if (refFilter === 'slots_notconf' && slotsToConfirm(r, gridBands) === 0) return false;
       if (modeFilter !== 'all' && refFilter !== 'notworked') {
         // A reference never worked has no mode, so "not worked" plus a mode is
         // a contradiction: the mode filter stands aside rather than emptying
@@ -339,7 +356,14 @@ export function AwardsPanel({ onEditQSO, onAwardsChanged, onPaperQSL }: {
       }
       return a.ref.localeCompare(b.ref, undefined, { numeric: true }) * dir;
     });
-  }, [current, refSearch, refFilter, modeFilter, refSort, refSortDir]);
+  }, [current, refSearch, refFilter, modeFilter, refSort, refSortDir, gridBands]);
+
+  // The gap itself, over whatever the other filters left on screen: the number
+  // of cells an operator would have to turn green to close it.
+  const slotGap = useMemo(
+    () => filteredRefs.reduce((n, r) => n + slotsToConfirm(r, gridBands), 0),
+    [filteredRefs, gridBands],
+  );
 
   // The group column earns its width only when the list actually carries one
   // (DXCC prefixes, POTA locations); most custom lists have none. For DXCC the
@@ -468,7 +492,7 @@ export function AwardsPanel({ onEditQSO, onAwardsChanged, onPaperQSL }: {
                 <Input className="h-8 w-56 pl-7 text-sm" placeholder={t('awp.filterReferences')} value={refSearch} onChange={(e) => setRefSearch(e.target.value)} />
               </div>
               <div className="flex items-center rounded-md border border-border overflow-hidden text-sm">
-                {([['all', t('awp.filterAll')], ['worked', t('awp.filterWkd')], ['notworked', t('awp.filterNotWkd')], ['worked_notconf', t('awp.filterWkdNotCfmd')]] as const).map(([k, label]) => (
+                {([['all', t('awp.filterAll')], ['worked', t('awp.filterWkd')], ['notworked', t('awp.filterNotWkd')], ['worked_notconf', t('awp.filterWkdNotCfmd')], ['slots_notconf', t('awp.filterSlotsNotCfmd')]] as const).map(([k, label]) => (
                   <button key={k} onClick={() => setRefFilter(k)}
                     className={cn('px-2 py-1', refFilter === k ? 'bg-accent font-medium' : 'hover:bg-accent/50 text-muted-foreground')}>
                     {label}
@@ -484,6 +508,11 @@ export function AwardsPanel({ onEditQSO, onAwardsChanged, onPaperQSL }: {
                 ))}
               </div>
               <span className="text-xs text-muted-foreground">{filteredRefs.length} {t('awp.refs')}</span>
+              {slotGap > 0 && (
+                <span className="text-xs text-muted-foreground" title={t('awp.slotGapTip')}>
+                  · <span className="font-semibold text-foreground">{slotGap}</span> {t('awp.slotGap')}
+                </span>
+              )}
               {/* Only for an award scoped to a DXCC entity. "In this award's
                   scope but with no reference" needs a scope to be in: on a
                   worldwide reference award — POTA, SOTA, IOTA, WWFF — every
@@ -604,7 +633,14 @@ export function AwardsPanel({ onEditQSO, onAwardsChanged, onPaperQSL }: {
                             <td key={b} className="border-b border-l border-border/30 p-0 text-center">
                               {s === 'none' ? <span className="block w-11 h-7" /> : (
                                 <button
-                                  className={cn('block w-11 h-7 text-[11px] font-bold', CELL_STYLE[s], 'hover:brightness-110')}
+                                  className={cn('block w-11 h-7 text-[11px] font-bold', CELL_STYLE[s], 'hover:brightness-110',
+                                    // Chasing the slots still to confirm, the
+                                    // confirmed ones are context, not the answer:
+                                    // a row is kept for its W cells and its V
+                                    // cells would otherwise be the loudest thing
+                                    // on it. Faded rather than hidden — which
+                                    // band is already done is worth seeing.
+                                    refFilter === 'slots_notconf' && s !== 'worked' && 'opacity-25')}
                                   title={t('awp.cellTitle', { ref: r.ref, band: b })}
                                   onClick={() => setCell({ ref: r.ref, band: b, name: r.name })}
                                 >{CELL_LABEL[s]}</button>

frontend/src/components/BandMap.tsx

@@ -2,6 +2,7 @@ import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { Minus, Plus, Crosshair, X, PanelLeft, PanelRight } from 'lucide-react';
 import { cn } from '@/lib/utils';
 import { useI18n } from '@/lib/i18n';
+import { bandRange, bandSegments, subscribeIaruRegion, type SegMode } from '@/lib/bandplan';
 import { spotStatusKey, inferSpotMode, spotModeCategory } from '@/lib/spot';
 import { SPOT_MARKERS, activeMarkers } from '@/lib/spotMarkers';
 import { applySpotDisplay, readSpotDisplayOptions } from '@/lib/spotDisplay';
@@ -76,6 +77,13 @@ const BMP_MARKER_LABEL: Record<string, string> = {
   new_pota: 'bmp.legendNewPota',
   new_county: 'bmp.legendNewCounty',
   worked_call: 'bmp.legendWorkedCall',
+  // Not on the strip — the pill is 22 px and a fourth segment turns it into a
+  // colour code nobody reads — but the TOOLTIP has room, and leaving them out of
+  // it made the two panels contradict each other: the cluster said NEW PFX about
+  // a spot the map called "Worked". Both were true (the entity is worked on this
+  // slot, the WPX prefix never has been) and neither view said so.
+  new_pfx: 'clg2.newPfx',
+  new_grid: 'clg2.newGrid',
 };
 
 interface Props {
@@ -107,59 +115,26 @@ interface Props {
   keyNav?: boolean;
 }
 
-const BAND_RANGES: Record<string, [number, number]> = {
+// Band edges and mode segments come from lib/bandplan, which knows the
-  '160m': [1800, 2000],
+// operator's IARU region (Settings → General): a Region 2 operator's 40 m runs
-  '80m':  [3500, 3800],
+// to 7300 with phone from 7125, and drawing Region 1's plan under their spots
-  '60m':  [5350, 5450],
+// cut the top 100 kHz of the band off the map.
-  '40m':  [7000, 7200],
+//
-  '30m':  [10100, 10150],
+// Sub-band shading colours: these are IDENTITIES (which mode the segment is
-  '20m':  [14000, 14350],
+// for), not states, so they take categorical hues — never the status tokens.
-  '17m':  [18068, 18168],
+// All three are drawn from the cool end of the categorical order and laid down
-  '15m':  [21000, 21450],
+// at low opacity, so the band plan stays background context while the warm
-  '12m':  [24890, 24990],
+// spot pills keep the foreground. Checked with the palette validator in both
-  '10m':  [28000, 29700],
+// themes (violet failed the dark protan step; magenta clears every check).
-  '6m':   [50000, 50500],
+const SEG_COLOR: Record<SegMode, string> = {
-  '4m':   [70000, 70500],
+  cw: 'var(--chart-7)',    // magenta
-  '2m':   [144000, 146000],
+  digi: 'var(--chart-1)',  // blue
-  '70cm': [430000, 440000],
+  phone: 'var(--chart-2)', // aqua
 };
-
-// Sub-band shading: CW / digital / phone.
-//
-// These are IDENTITIES (which mode the segment is for), not states, so they take
-// categorical hues — never the status tokens. They used to use success / info /
-// warning, which collided head-on with the spot pills drawn ON TOP of them: amber
-// is "new band" in this very component's legend, so the whole SSB portion read as
-// a giant "new band" wash. Status colours are reserved for status.
-//
-// All three are drawn from the COOL end of the categorical order and laid down at
-// low opacity, so the band plan stays background context while the warm spot pills
-// keep the foreground to themselves.
-// Checked with the palette validator in BOTH themes. Violet was the first pick
-// for CW and failed on the dark steps — violet and blue land 1.9 ΔE apart for a
-// protan reader there, i.e. the same colour. Magenta clears every check on both
-// surfaces (worst adjacent pair 13.0 light / 15.9 dark).
-const SEG_CW = 'var(--chart-7)';    // magenta
-const SEG_DIGI = 'var(--chart-1)';  // blue
-const SEG_PHONE = 'var(--chart-2)'; // aqua
 // A band-plan wash is CONTEXT, not data: it must stay under the spot pills that
 // are read on top of it.
 const SEG_OPACITY = 0.13;
 
-const SEGMENT_COLORS: Record<string, [number, number, string][]> = {
-  '160m': [[1800, 1838, SEG_CW], [1838, 1840, SEG_DIGI], [1840, 2000, SEG_PHONE]],
-  '80m':  [[3500, 3580, SEG_CW], [3580, 3600, SEG_DIGI], [3600, 3800, SEG_PHONE]],
-  '60m':  [[5350, 5450, SEG_PHONE]],
-  '40m':  [[7000, 7040, SEG_CW], [7040, 7100, SEG_DIGI], [7100, 7200, SEG_PHONE]],
-  '30m':  [[10100, 10130, SEG_CW], [10130, 10150, SEG_DIGI]],
-  '20m':  [[14000, 14070, SEG_CW], [14070, 14100, SEG_DIGI], [14100, 14350, SEG_PHONE]],
-  '17m':  [[18068, 18095, SEG_CW], [18095, 18110, SEG_DIGI], [18110, 18168, SEG_PHONE]],
-  '15m':  [[21000, 21070, SEG_CW], [21070, 21150, SEG_DIGI], [21150, 21450, SEG_PHONE]],
-  '12m':  [[24890, 24915, SEG_CW], [24915, 24940, SEG_DIGI], [24940, 24990, SEG_PHONE]],
-  '10m':  [[28000, 28070, SEG_CW], [28070, 28300, SEG_DIGI], [28300, 29700, SEG_PHONE]],
-  '6m':   [[50000, 50100, SEG_CW], [50100, 50500, SEG_PHONE]],
-};
-
 // Small coloured dot + label used in the band-map legend strip.
 function LegendDot({ cls, colour, label }: { cls?: string; colour?: string; label: string }) {
   return (
@@ -297,13 +272,16 @@ export function BandMap({ band, spots, spotStatus: spotStatusRaw, currentFreqHz,
   // nothing until the next poll happened to hand over a fresh object.
   const dispOpts = readSpotDisplayOptions();
   const spotStatus = useMemo(() => {
-    if (!dispOpts.muteWorked && !dispOpts.slotHighlight) return spotStatusRaw;
+    if (!dispOpts.muteWorked && !dispOpts.slotHighlight && dispOpts.chasePota) return spotStatusRaw;
     const out: Record<string, SpotStatusEntry> = {};
     for (const k of Object.keys(spotStatusRaw)) out[k] = applySpotDisplay(spotStatusRaw[k], dispOpts) as SpotStatusEntry;
     return out;
-  }, [spotStatusRaw, dispOpts.muteWorked, dispOpts.slotHighlight]);
+  }, [spotStatusRaw, dispOpts.muteWorked, dispOpts.slotHighlight, dispOpts.chasePota]);
-  const range = BAND_RANGES[band];
+  // Re-render when the operator changes their IARU region in Settings.
-  const segments = SEGMENT_COLORS[band] ?? [];
+  const [, setRegionTick] = useState(0);
+  useEffect(() => subscribeIaruRegion(() => setRegionTick((n) => n + 1)), []);
+  const range = bandRange(band);
+  const segments = bandSegments(band).map(([a, b, m]) => [a, b, SEG_COLOR[m]] as [number, number, string]);
   const [zoomIdx, setZoomIdx] = useState(() => readZoom(band));
   // The docked map follows the rig, so a band change must bring up THAT band's
   // remembered zoom.
@@ -737,7 +715,7 @@ export function BandMap({ band, spots, spotStatus: spotStatusRaw, currentFreqHz,
                   'hover:translate-x-0.5 hover:shadow',
                   style.pill,
                 )}
-                title={`${p.spot.dx_call}${entry?.country ? ' · ' + entry.country : ''} · ${p.spot.freq_khz.toFixed(1)} kHz · ${statusLabel(st, t)}${markersFor(entry).map((m) => ' · ' + t(BMP_MARKER_LABEL[m.key])).join('')}${p.spot.comment ? ' · ' + p.spot.comment : ''}${p.spot.spotter ? ' · de ' + p.spot.spotter : ''}`}
+                title={`${p.spot.dx_call}${entry?.country ? ' · ' + entry.country : ''} · ${p.spot.freq_khz.toFixed(1)} kHz · ${statusLabel(st, t)}${activeMarkers(entry).map((m) => ' · ' + t(BMP_MARKER_LABEL[m.key])).join('')}${p.spot.comment ? ' · ' + p.spot.comment : ''}${p.spot.spotter ? ' · de ' + p.spot.spotter : ''}`}
               >
                 {/* Left accent strip. With no extra marker it repeats the status
                     colour, exactly as before; otherwise it splits into one
@@ -787,9 +765,9 @@ export function BandMap({ band, spots, spotStatus: spotStatusRaw, currentFreqHz,
         ))}
         {/* Sub-band shading, so the wash behind the pills is never colour-alone. */}
         <span className="mx-0.5 opacity-40">|</span>
-        <LegendDot colour={SEG_CW} label={t("bmp.legendCW")} />
+        <LegendDot colour={SEG_COLOR.cw} label={t("bmp.legendCW")} />
-        <LegendDot colour={SEG_DIGI} label={t("bmp.legendData")} />
+        <LegendDot colour={SEG_COLOR.digi} label={t("bmp.legendData")} />
-        <LegendDot colour={SEG_PHONE} label={t("bmp.legendPhone")} />
+        <LegendDot colour={SEG_COLOR.phone} label={t("bmp.legendPhone")} />
       </div>
       <div className="px-3 py-1 text-[9px] text-muted-foreground bg-muted/30 border-t border-border font-mono text-center shrink-0">
         {t('bmp.footerHint')}

frontend/src/components/BandSlotGrid.tsx

@@ -81,23 +81,44 @@ const STATUS_CLASSES: Record<string, string> = {
 // i18n keys the Appearance panel's colour pickers use, so the two can never
 // disagree about which green is which. swatch = the background class (or a
 // special ring marker for the current-entry cell).
-const LEGEND: { swatch: string; ring?: boolean; label: string }[] = [
+const LEGEND: { swatch: string; ring?: boolean; mark?: string; label: string }[] = [
   { swatch: 'bg-mx-call-conf', label: 'mx.callConf' },
   { swatch: 'bg-mx-call-work', label: 'mx.callWork' },
   { swatch: 'bg-mx-dx-conf', label: 'mx.dxConf' },
   { swatch: 'bg-mx-dx-work', label: 'mx.dxWork' },
   { swatch: 'bg-mx-none', label: 'mx.none' },
   { swatch: 'bg-mx-none', ring: true, label: 'mx.current' },
+  { swatch: 'bg-mx-none', mark: 'w', label: 'mx.markWork' },
+  { swatch: 'bg-mx-none', mark: 'c', label: 'mx.markConf' },
 ];
 
-function cellTitle(t: (k: string) => string, band: string, cls: string, status: string, current: boolean): string {
+// CallMark — "this callsign has already been worked on this slot".
+//
+// Drawn the same way on every cell, whatever colour the entity status gave it:
+// the operator learns one shape and reads it without first working out what the
+// background means. Only the fill changes, and only with the callsign's own
+// state (worked / confirmed) — never with the entity's. The ring is the theme
+// background, which is what keeps the dot legible over all five cell colours.
+function CallMark({ state = 'w' }: { state?: string }) {
+  return (
+    <span
+      className={cn(
+        'pointer-events-none absolute top-[4px] right-[4px] size-[5px] rounded-full ring-1 ring-background',
+        state === 'c' ? 'bg-mx-mark-conf' : 'bg-mx-mark-work',
+      )}
+    />
+  );
+}
+
+function cellTitle(t: (k: string) => string, band: string, cls: string, status: string, current: boolean, call = ''): string {
   const desc =
     status === 'call_c' ? t('mx.tipCallConf') :
     status === 'call_w' ? t('mx.tipCallWork') :
     status === 'dxcc_c' ? t('mx.tipDxConf') :
     status === 'dxcc_w' ? t('mx.tipDxWork') :
                           t('mx.tipNone');
-  return `${band} ${cls}: ${desc}${current ? ' — ' + t('mx.current') : ''}`;
+  const mine = call === 'c' ? t('mx.tipThisCallConf') : call === 'w' ? t('mx.tipThisCall') : '';
+  return `${band} ${cls}: ${desc}${mine ? ' — ' + mine : ''}${current ? ' — ' + t('mx.current') : ''}`;
 }
 
 export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, hasCall = true, lat, lon, forCall, onEditQso }: Props) {
@@ -126,6 +147,16 @@ export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, hasCal
     return m;
   }, [wb]);
 
+  // Worked-with-this-callsign, per cell — carried separately by the backend
+  // because collapsing it into the status is what hid it.
+  const callMap = useMemo(() => {
+    const m = new Map<string, string>();
+    for (const s of wb?.band_status ?? []) {
+      if ((s as any).call) m.set(`${s.band}|${s.class}`, (s as any).call);
+    }
+    return m;
+  }, [wb]);
+
   // "Newness" of the current band+mode entry, for the award/DX-chase badges.
   // Derived straight from the entity's real band_status (all bands it was
   // worked on — not just the operator's configured column list).
@@ -211,11 +242,11 @@ export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, hasCal
   return (
     <section
       className={cn(
-        'flex items-center gap-4 px-3 py-2 flex-wrap shrink-0',
+        'flex items-center gap-2 px-2 py-2 flex-wrap shrink-0',
         newOne && 'bg-gradient-to-br from-warning-muted to-warning-muted rounded-lg',
       )}
     >
-      <div className="flex items-center gap-2 min-w-[220px] flex-1">
+      <div className="flex items-center gap-2 min-w-0 flex-1">
         {newOne ? (
           <>
             <Badge className="bg-warning text-warning-foreground gap-1 px-3 py-1 text-[11px]">
@@ -238,7 +269,7 @@ export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, hasCal
                 {forCall}
               </Badge>
             )}
-            <Badge className="bg-primary text-primary-foreground px-3 py-1 text-xs normal-case font-semibold tracking-normal">
+            <Badge className="bg-primary text-primary-foreground px-2 py-0.5 text-xs normal-case font-semibold tracking-normal leading-tight">
               {dxccName || `DXCC #${dxcc}`}
             </Badge>
             {mwBadge}
@@ -308,21 +339,29 @@ export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, hasCal
                 </th>
                 {cols.map((b) => {
                   const st = statusMap.get(`${b.tag}|${cls}`) ?? '';
+                  // The same cell's other answer: worked with THIS callsign
+                  // here. The status above is the entity's, and a confirmed
+                  // entity outranks a worked call — so chasing a DXpedition,
+                  // the cell could say "confirmed" about a contact made years
+                  // ago and nothing about the one made this morning.
+                  const mine = callMap.get(`${b.tag}|${cls}`) ?? '';
                   const isCurrent = hasCall && b.tag === currentBand && classCurrent;
                   return (
                     <td
                       key={b.tag}
-                      title={cellTitle(t, b.tag, cls, st, isCurrent) + (st ? ' — ' + t('mx.tipClick') : '')}
+                      title={cellTitle(t, b.tag, cls, st, isCurrent, mine) + (st ? ' — ' + t('mx.tipClick') : '')}
                       onClick={st ? () => setSlot({ band: b.tag, cls }) : undefined}
                       className={cn(
-                        'w-[28px] h-[24px] rounded transition-colors p-0',
+                        'relative w-[28px] h-[24px] rounded transition-colors p-0',
                         st ? STATUS_CLASSES[st] : 'bg-mx-none',
                         // Only a filled cell has anything to show — an empty one
                         // stays inert rather than opening a "no QSOs" dialog.
                         st && 'cursor-pointer hover:brightness-110',
                         isCurrent && 'ring-2 ring-mx-cur ring-inset',
                       )}
-                    />
+                    >
+                      {mine ? <CallMark state={mine} /> : null}
+                    </td>
                   );
                 })}
               </tr>
@@ -337,11 +376,13 @@ export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, hasCal
           <span key={l.label} className="flex items-center gap-1.5 text-[10px] text-muted-foreground">
             <span
               className={cn(
-                'inline-block size-3 rounded shrink-0',
+                'relative inline-block size-3 rounded shrink-0',
                 l.swatch,
                 l.ring && 'ring-2 ring-mx-cur ring-inset',
               )}
-            />
+            >
+              {l.mark ? <CallMark state={l.mark} /> : null}
+            </span>
             {t(l.label)}
           </span>
         ))}

frontend/src/components/BulkEditModal.tsx

@@ -60,6 +60,9 @@ const FIELDS: FieldDef[] = [
   // No promoted column: written into extras_json (see qso.bulkEditableExtras).
   { id: 'owner_callsign',   label: 'bulk.fOwnerCallsign', group: 'My station', kind: 'text', upper: true },
   { id: 'my_grid',          label: 'bulk.fMyGrid',       group: 'My station', kind: 'text', upper: true },
+  { id: 'my_dxcc',          label: 'bulk.fMyDxcc',       group: 'My station', kind: 'text' },
+  { id: 'my_cq_zone',       label: 'bulk.fMyCqZone',     group: 'My station', kind: 'text' },
+  { id: 'my_itu_zone',      label: 'bulk.fMyItuZone',    group: 'My station', kind: 'text' },
   { id: 'my_antenna',       label: 'bulk.fMyAntenna',    group: 'My station', kind: 'text' },
   { id: 'my_rig',           label: 'bulk.fMyRig',        group: 'My station', kind: 'text' },
   { id: 'my_street',        label: 'bulk.fMyStreet',     group: 'My station', kind: 'text' },

frontend/src/components/ChaseNewPanel.tsx

@@ -10,6 +10,7 @@
 // new is being decoded on FT8/FT4/JS8 near here — not that the band is dead.
 import { useEffect, useMemo, useState } from 'react';
 import { Radar, Loader2, X } from 'lucide-react';
+import { formatDistance } from '@/lib/units';
 import { useI18n } from '@/lib/i18n';
 import { markerColour } from '@/lib/spotMarkers';
 import { cn } from '@/lib/utils';
@@ -186,7 +187,7 @@ export function ChaseNewPanel({ onPick, onClose }: Props) {
                   title={[
                     s.country,
                     s.grid,
-                    s.dist_km ? `${s.dist_km} km` : '',
+                    s.dist_km ? formatDistance(s.dist_km) : '',
                     s.freq_hz ? `${(s.freq_hz / 1000).toFixed(1)} kHz` : '',
                   ].filter(Boolean).join(' · ')}
                 >

frontend/src/components/ClusterGrid.tsx

@@ -13,8 +13,9 @@ import { Button } from '@/components/ui/button';
 import { Checkbox } from '@/components/ui/checkbox';
 import { cleanSpotter, inferSpotMode, spotStatusKey } from '@/lib/spot';
 import { markerColour } from '@/lib/spotMarkers';
-import { applySpotDisplay, readSpotDisplayOptions } from '@/lib/spotDisplay';
+import { applySpotDisplay, chasePota, chaseSota, readSpotDisplayOptions } from '@/lib/spotDisplay';
 import { loadLocal, loadRemote, saveState, seedLocal, whenGridPrefsReady } from '@/lib/gridPrefs';
+import { distanceUnit, distanceValue, subscribeDistanceUnit } from '@/lib/units';
 import { useI18n } from '@/lib/i18n';
 
 type TFn = (key: string, vars?: Record<string, string | number>) => string;
@@ -45,6 +46,7 @@ export type ClusterSpot = {
   raw: string;
   repeats?: number;
   pota_ref?: string;
+  sota_ref?: string;
   pota_name?: string;
 };
 
@@ -82,6 +84,11 @@ type Props = {
   // stray click while looking took the operator off the station they were
   // working. Looking and going are now two different gestures.
   onSpotSelect?: (s: ClusterSpot) => void;
+  // Anything the caller wants on the LEFT of the toolbar — the pane's title, its
+  // live count, its Filters button. Docked in a pane, the title used to sit on a
+  // row of its own above this one, so the cluster ate two lines of a short pane
+  // where Recent QSOs beside it ate one. Reported by VK4DX.
+  headerLeft?: React.ReactNode;
 };
 
 const COL_STATE_KEY = 'hamlog.clusterColState.v1';
@@ -141,6 +148,12 @@ function statusFor(p: any): SpotStatusEntry | undefined {
 //   filled pfx  → new prefix  filled POTA → new park    filled county → new county
 //   blue call   → already worked (not a novelty, so text only)
 const NEW = 'var(--warning)'; // yellow: something here is new
+// NEW SLOT gets its own hue. It shared the amber NEW family while the NEW PFX
+// marker sits in caution yellow — two different facts, two near-identical
+// colours in the same cell. Sky cyan, the exact colour the panadapter palette
+// ships for new-slot (#5AC8FA), so the two views tell one story — and clearly
+// apart from the POTA green the first attempt (aqua) sat next to.
+const NEWSLOT = '#5AC8FA';
 const WKD = 'var(--info)';    // blue: this callsign is already in the log
 
 // FILLING the cell that carries the fact, rather than only tinting its text.
@@ -183,9 +196,10 @@ function statusColor(s: SpotStatusEntry | undefined): string | null {
     case 'new-band-mode':
     case 'new-band':
     case 'new-mode':
-    case 'new-slot':
     case 'new-call':
       return NEW;
+    case 'new-slot':
+      return NEWSLOT;
     default:
       return s?.worked_call ? WKD : null;
   }
@@ -329,13 +343,26 @@ const makeColCatalog = (t: TFn): ColEntry[] => [
   },
   {
     group: 'Spot', label: t('clg2.c.pota'), colId: 'pota',
-    headerName: t('clg2.c.pota'), field: 'pota_ref' as any, width: 92, cellClass: 'font-mono',
+    headerName: t('clg2.c.pota'), width: 92, cellClass: 'font-mono',
+    // Through a valueGetter so the chase switch empties the column live.
+    valueGetter: (p: any) => (chasePota() ? p.data?.pota_ref ?? '' : ''),
     defaultVisible: true,
     cellStyle: (p: any) => (statusFor(p)?.new_pota
       ? fillStyle(markerColour('new_pota'))
       : { color: 'var(--success)' }) as any,
     tooltipValueGetter: (p: any) => (p.data?.pota_name ? t('clg2.tipPota', { name: p.data.pota_name }) : undefined),
   },
+  {
+    // SOTA sits next to POTA and reads the same way. The reference comes from the
+    // spot's comment, so it is present on the SOTA feeds and empty elsewhere —
+    // which is why the column is off by default rather than an empty column for
+    // everyone who does not watch summits.
+    group: 'Spot', label: t('clg2.c.sota'), colId: 'sota',
+    headerName: t('clg2.c.sota'), width: 100, cellClass: 'font-mono',
+    valueGetter: (p: any) => (chaseSota() ? p.data?.sota_ref ?? '' : ''),
+    defaultVisible: false,
+    cellStyle: () => ({ color: 'var(--success)' }) as any,
+  },
   {
     group: 'Spot', label: t('clg2.c.freq'), colId: 'freq',
     headerName: t('clg2.c.freq'), field: 'freq_khz' as any, width: 95, type: 'rightAligned', cellClass: 'font-mono',
@@ -432,8 +459,13 @@ const makeColCatalog = (t: TFn): ColEntry[] => [
   },
   {
     group: 'Geo', label: t('clg2.c.distance_km'), colId: 'distance_km',
-    headerName: t('clg2.h.distance_km'), field: 'distance_km' as any, width: 80, type: 'rightAligned', cellClass: 'font-mono',
+    // The header carries the unit, so the cells stay bare numbers and the
-    valueFormatter: (p) => p.value ? String(p.value) : '',
+    // column still sorts on the km the backend sent — converting the VALUE
+    // would sort miles as if they were kilometres either way, but it would
+    // also round twice.
+    headerName: t('clg2.h.distance_km') + ' (' + distanceUnit() + ')',
+    field: 'distance_km' as any, width: 90, type: 'rightAligned', cellClass: 'font-mono',
+    valueFormatter: (p) => p.value ? String(distanceValue(p.value)) : '',
     comparator: (a, b) => (a ?? 0) - (b ?? 0),
   },
   {
@@ -506,13 +538,15 @@ const GROUP_ORDER = ['Spot', 'Geo'];
 const CLG_GRP_KEYS: Record<string, string> = { Spot: 'clg2.grpSpot', Geo: 'clg2.grpGeo' };
 const groupLabel = (t: TFn, g: string): string => t(CLG_GRP_KEYS[g] ?? g);
 
-export function ClusterGrid({ rows, spotStatus, onSpotClick, onSpotSelect }: Props) {
+export function ClusterGrid({ rows, spotStatus, onSpotClick, onSpotSelect, headerLeft }: Props) {
   const { t } = useI18n();
   const gridRef = useRef<any>(null);
   const [pickerOpen, setPickerOpen] = useState(false);
 
   // Localized column catalog — rebuilt when the language changes.
-  const COL_CATALOG = useMemo(() => makeColCatalog(t), [t]);
+  const [distUnit, setDistUnit] = useState(distanceUnit);
+  useEffect(() => subscribeDistanceUnit(() => setDistUnit(distanceUnit())), []);
+  const COL_CATALOG = useMemo(() => makeColCatalog(t), [t, distUnit]);
 
   // A rebuild makes AG Grid re-apply every colDef hide/width DEFAULT and fire the
   // matching column events. Without this guard those events were persisted, so a
@@ -603,16 +637,27 @@ export function ClusterGrid({ rows, spotStatus, onSpotClick, onSpotSelect }: Pro
   const [held, setHeld] = useState<ClusterSpot[] | null>(null);
   const shown = held ?? rows;
 
-  // How many arrived since the freeze. Counted by finding the frozen top row in
+  // How many arrived since the freeze — counted by TIME, not by finding the
-  // the live list rather than by comparing lengths: the list is a ring buffer,
+  // frozen top row again.
-  // so once it is full the length stops growing and a length comparison would
+  //
-  // report nothing new for the rest of the evening.
+  // Looking for that row was wrong in the ordinary case: a station spotted again
-  const spotID = (r: ClusterSpot) => `${(r as any).received_at}-${r.dx_call}-${(r as any).source_id}`;
+  // REPLACES its row (that is the de-dupe), so the row we froze on disappears
+  // from the live list the moment somebody re-spots it — and the count fell
+  // through to "everything is new", jumping from 4 to the buffer cap. Reported
+  // as "it shows 4, 5 new spots and then 500 all at once".
+  //
+  // A timestamp survives both the replacement and the ring buffer, which was the
+  // reason the length was not used either.
+  const spotTime = (r: ClusterSpot) => Date.parse(String((r as any).received_at ?? '')) || 0;
   const waiting = useMemo(() => {
     if (!held || held.length === 0) return 0;
-    const top = spotID(held[0]);
+    const since = spotTime(held[0]);
-    const i = rows.findIndex((r) => spotID(r) === top);
+    if (!since) return 0; // no usable timestamp — say nothing rather than a number
-    return i < 0 ? rows.length : i; // fell out of the buffer: everything is new
+    let n = 0;
+    for (const r of rows) {
+      if (spotTime(r) > since) n++;
+    }
+    return n;
   }, [held, rows]);
 
   const onBodyScroll = (e: { top: number }) => {
@@ -670,7 +715,9 @@ export function ClusterGrid({ rows, spotStatus, onSpotClick, onSpotSelect }: Pro
 
   return (
     <>
-      <div className="flex items-center justify-end gap-2 px-2.5 py-1 border-b border-border/60 bg-muted/20">
+      <div className="flex items-center gap-2 px-2.5 py-1 border-b border-border/60 bg-muted/20">
+        {headerLeft}
+        <div className="flex-1" />
         <Button variant="ghost" size="sm" className="h-7 text-[11px]" onClick={() => gridRef.current?.api?.setFilterModel(null)}
           title={t('clg2.clearFiltersTitle')}>
           <FilterX className="size-3.5" /> {t('clg2.clearFilters')}

frontend/src/components/ElecraftPanel.tsx

@@ -4,20 +4,21 @@ import {
   GetKenwoodState, RefreshKenwood, SetKenwoodPower, SetKenwoodAFGain, SetKenwoodTX, TuneKenwoodATU,
   SetKenwoodRFGain, SetKenwoodMicGain, SetKenwoodSquelch, SetKenwoodPreamp, SetKenwoodAtt,
   SetKenwoodNB, SetKenwoodNR, SetKenwoodAGC, SetKenwoodFilter, SetKenwoodAntenna,
-  SetKenwoodRIT, SetKenwoodXIT, ClearKenwoodRIT, SetKenwoodKeySpeed, ToggleKenwoodATU, NudgeKenwoodRIT,
+  SetKenwoodRIT, SetKenwoodXIT, ClearKenwoodRIT, SetKenwoodKeySpeed, ToggleKenwoodATU, SetKenwoodRITOffset, SetKenwoodPanelMode,
   GetCATState,
 } from '../../wailsjs/go/main/App';
 import { cn } from '@/lib/utils';
 import { useI18n } from '@/lib/i18n';
 import { sMeterRST } from '@/lib/rst';
+import { ShiftRow } from '@/components/ShiftRow';
 import { MeterBar } from '@/components/MeterBar';
 import { WheelRange } from '@/components/WheelRange';
 
 type KenwoodState = {
-  available: boolean; model?: string; elecraft: boolean; mode?: string;
+  available: boolean; model?: string; elecraft: boolean; mode?: string; data_sub?: string;
   transmitting: boolean; split: boolean; split_tx_hz?: number;
   s_meter: number; s_meter_raw: number;
-  power_meter: number; swr: number; swr_raw: number;
+  power_meter: number; power_w?: number; swr: number; swr_raw: number;
   rf_power: number; af_gain: number; rf_gain: number; mic_gain: number; squelch: number;
   preamp: boolean; att: boolean; nb: boolean; nr: boolean; agc?: string;
   filter_hz: number; antenna: number; rit: boolean; xit: boolean; rit_offset: number; key_speed: number;
@@ -41,18 +42,22 @@ const ZERO: KenwoodState = {
 // nobody notices are missing.
 const FILTERS = [200, 400, 700, 1000, 1800, 2400, 2800, 4000];
 
-// Raw S-meter → S units. The K3 answers 0-21 across S0…S9+60; S9 is taken at
+// Raw S-meter → S units, CALIBRATED against a real K3 beside its own display
-// raw 9 and each step above it as 6 dB. PROVISIONAL, like the rest of the
+// (2026-08): raw 5 reads S7 on the radio, raw 9 reads S9+20. So S9 sits near
-// scaling: the raw value is on screen and in the log, so a real radio settles
+// raw 6.5 — not 9, which showed everything two S-units low — and each raw step
-// it rather than this comment.
+// above it is worth ~8 dB, shown in the 10 dB steps the K3's own meter uses.
-const S9_RAW = 9;
+// A Kenwood answers 0-30 on the same command and keeps the simple 1-per-raw
-const DB_PER_RAW = 6;
+// scale until someone calibrates one against a real radio too.
-function sParts(rawV: number): { s: number; over: number; label: string } {
+const K3_S9_RAW = 6.5;
-  if (rawV >= S9_RAW) {
+const K3_DB_PER_RAW = 8;
-    const over = Math.max(0, Math.round((rawV - S9_RAW) * DB_PER_RAW));
+function sParts(rawV: number, elecraft: boolean): { s: number; over: number; label: string } {
+  const s9raw = elecraft ? K3_S9_RAW : 9;
+  if (rawV >= s9raw) {
+    let over = Math.max(0, Math.round((rawV - s9raw) * (elecraft ? K3_DB_PER_RAW : 6)));
+    if (elecraft) over = Math.round(over / 10) * 10;
     return { s: 9, over, label: over > 0 ? `S9+${over}` : 'S9' };
   }
-  const s = Math.max(0, Math.min(9, rawV));
+  const s = Math.max(0, Math.min(9, Math.round(rawV * (elecraft ? 9 / K3_S9_RAW : 1))));
   return { s, over: 0, label: `S${s}` };
 }
 
@@ -89,9 +94,34 @@ function Toggle({ label, on, off, onClick }: { label: string; on: boolean; off:
   );
 }
 
+// isDataMode: what the rig reports for MD6 varies — "DATA", or the configured
+// digital default (FT8…) — so the DATA family is "not one of the native modes".
+function isDataMode(m?: string): boolean {
+  switch ((m ?? '').toUpperCase()) {
+    case '': case 'CW': case 'USB': case 'LSB': case 'SSB': case 'FM': case 'AM': case 'RTTY':
+      return false;
+  }
+  return true;
+}
+
 export function ElecraftPanel({ onReportRST }: { onReportRST?: (rst: string) => void }) {
   const { t } = useI18n();
   const [st, setSt] = useState<KenwoodState>(ZERO);
+  // Ctrl+Left/Right shifts the RIT by ±10 Hz while RIT is on — the same
+  // keyboard clarifier the Icom and TCI consoles have, for zero-beating a
+  // caller without touching the mouse.
+  const stRef = useRef(st); stRef.current = st;
+  useEffect(() => {
+    const onKey = (e: KeyboardEvent) => {
+      if (!e.ctrlKey || (e.key !== 'ArrowLeft' && e.key !== 'ArrowRight')) return;
+      const v = stRef.current;
+      if (!v.available || !v.rit) return;
+      e.preventDefault();
+      SetKenwoodRITOffset((v.rit_offset || 0) + (e.key === 'ArrowRight' ? 10 : -10)).catch(() => {});
+    };
+    window.addEventListener('keydown', onKey);
+    return () => window.removeEventListener('keydown', onKey);
+  }, []);
   const [freqHz, setFreqHz] = useState(0);
   const [err, setErr] = useState('');
   // Optimistic overlay: a slider must follow the finger, not the poll. Dropped
@@ -149,6 +179,28 @@ export function ElecraftPanel({ onReportRST }: { onReportRST?: (rst: string) =>
             {freqHz > 0 ? (freqHz / 1e6).toFixed(6) : '—'}
           </div>
         </div>
+        {/* Mode row. The two DATA buttons are why it exists: MD6 alone keeps
+            whatever submode the last session left, and a K3 "in DATA" with FSK D
+            still armed keys FT8 with no audio. DATA sends MD6+DT0 (DATA A, the
+            soundcard path), RTTY sends MD6+DT2 (FSK D). The active DATA button
+            follows the rig's own DT answer. */}
+        <div className="inline-flex rounded-md border border-border overflow-hidden">
+          {([
+            ['CW', 'CW', view.mode === 'CW'],
+            ['USB', 'USB', view.mode === 'USB'],
+            ['LSB', 'LSB', view.mode === 'LSB'],
+            ['DATA', t('k3.modeData'), isDataMode(view.mode) && view.data_sub !== 'FSK D' && view.data_sub !== 'PSK D'],
+            ['RTTY', t('k3.modeRtty'), (isDataMode(view.mode) && (view.data_sub === 'FSK D' || view.data_sub === 'PSK D')) || view.mode === 'RTTY'],
+          ] as [string, string, boolean][]).map(([cmd, label, on]) => (
+            <button key={cmd} type="button" disabled={off}
+              title={cmd === 'DATA' ? t('k3.modeDataHint') : cmd === 'RTTY' ? t('k3.modeRttyHint') : label}
+              onClick={() => SetKenwoodPanelMode(cmd).catch((e: any) => setErr(String(e?.message ?? e)))}
+              className={cn('px-2.5 py-1.5 text-xs font-bold border-l border-border first:border-l-0',
+                on ? 'bg-primary text-primary-foreground' : 'bg-card text-muted-foreground hover:bg-muted')}>
+              {label}
+            </button>
+          ))}
+        </div>
         <button type="button" className="text-[11px] text-muted-foreground hover:text-foreground flex items-center gap-1"
           onClick={() => RefreshKenwood().catch(() => {})} title={t('k3.refreshHint')}>
           <SlidersHorizontal className="size-3.5" />
@@ -163,14 +215,15 @@ export function ElecraftPanel({ onReportRST }: { onReportRST?: (rst: string) =>
       <div className="grid grid-cols-1 sm:grid-cols-3 gap-2">
         <MeterBar label="S-METER" value={view.transmitting ? 0 : view.s_meter} lo={0} hi={100}
           accent="#16a34a" segColor={sSegColor}
-          display={view.transmitting ? '—' : sParts(view.s_meter_raw).label}
+          display={view.transmitting ? '—' : sParts(view.s_meter_raw, view.elecraft).label}
           onClick={() => {
             if (view.transmitting || !onReportRST) return;
-            const sp = sParts(view.s_meter_raw);
+            const sp = sParts(view.s_meter_raw, view.elecraft);
             onReportRST(sMeterRST(sp.s, sp.over, view.mode));
           }}
           title={t('k3.sMeterHint', { raw: String(view.s_meter_raw) })} />
-        <MeterBar label="PWR" value={view.transmitting ? view.power_meter : 0} lo={0} hi={100} accent="#0ea5e9" />
+        <MeterBar label="PWR" value={view.transmitting ? view.power_meter : 0} lo={0} hi={100} accent="#0ea5e9"
+          display={view.transmitting && view.elecraft ? `${view.power_w ?? 0} W` : undefined} />
         {/* 0 means "not measured", and it must not render as a perfect 1.0:
             a match that looks ideal on an antenna nobody has measured is the one
             reading that can cost a radio. */}
@@ -216,7 +269,7 @@ export function ElecraftPanel({ onReportRST }: { onReportRST?: (rst: string) =>
       <div className="grid grid-cols-1 lg:grid-cols-2 gap-x-6 gap-y-2">
         <label className="flex items-center gap-2 text-xs">
           <span className="w-16 shrink-0 text-muted-foreground">{t('k3.power')}</span>
-          <WheelRange min={0} max={110} step={5} disabled={off}
+          <WheelRange min={0} max={110} step={1} disabled={off}
             value={view.rf_power ?? 0}
             onChange={(n) => put({ rf_power: n }, () => SetKenwoodPower(n))} />
           <span className="w-12 text-right font-mono tabular-nums">{view.rf_power ?? 0} W</span>
@@ -279,21 +332,18 @@ export function ElecraftPanel({ onReportRST }: { onReportRST?: (rst: string) =>
           ))}
         </div>
 
-        {/* RIT / XIT. Clear zeroes both offsets at once — the radio's own RC,
+        {/* RIT / XIT — the shared ShiftRow, exactly as the Icom and TCI consoles
-            and what an operator means by "clear it". */}
+            drive theirs: ± / wheel / type, Ctrl+←/→ while RIT is on. The K3 has
+            ONE offset for both, so both rows show it, like the Icom's. */}
+        <div className="space-y-1.5">
+          <ShiftRow label="RIT" accent="#8b5cf6" on={view.rit} hz={view.rit_offset || 0} disabled={off}
+            onToggle={() => SetKenwoodRIT(!view.rit).catch(setErrMsg)}
+            onSet={(hz) => SetKenwoodRITOffset(hz).catch(setErrMsg)} />
+          <ShiftRow label="XIT" accent="#f59e0b" on={view.xit} hz={view.rit_offset || 0} disabled={off}
+            onToggle={() => SetKenwoodXIT(!view.xit).catch(setErrMsg)}
+            onSet={(hz) => SetKenwoodRITOffset(hz).catch(setErrMsg)} />
+        </div>
         <div className="flex flex-wrap items-center gap-1.5">
-          <Toggle label="RIT" on={view.rit} off={off} onClick={() => SetKenwoodRIT(!view.rit).catch(setErrMsg)} />
-          <Toggle label="XIT" on={view.xit} off={off} onClick={() => SetKenwoodXIT(!view.xit).catch(setErrMsg)} />
-          {/* The offset itself. A lit RIT button says the feature is on and
-              nothing about where it has put the receiver. */}
-          {[-100, -10, 10, 100].map((d) => (
-            <Toggle key={d} label={(d > 0 ? '+' : '') + d} on={false} off={off}
-              onClick={() => NudgeKenwoodRIT(d).catch(setErrMsg)} />
-          ))}
-          <span className="text-[11px] font-mono tabular-nums text-muted-foreground w-16">
-            {view.rit_offset > 0 ? '+' : ''}{view.rit_offset || 0} Hz
-          </span>
-          <Toggle label={t('k3.clear')} on={false} off={off} onClick={() => ClearKenwoodRIT().catch(setErrMsg)} />
           {/* Antenna only when the radio answered AN — a K3 without the internal
               ATU has one socket and no switch to offer. */}
           {view.antenna > 0 && (<>

frontend/src/components/IcomPanel.tsx

@@ -1,11 +1,12 @@
 import { useEffect, useRef, useState } from 'react';
-import { Radio, AudioLines, Mic, Activity, SlidersHorizontal, Antenna, Filter, Power } from 'lucide-react';
+import { Radio, AudioLines, Mic, Activity, SlidersHorizontal, Antenna, Filter, Power, Volume2, VolumeX } from 'lucide-react';
 import {
   GetIcomState, IcomRefresh,
   IcomSetAFGain, IcomSetRFGain, IcomSetNB, IcomSetNBLevel, IcomSetNR, IcomSetNRLevel,
   IcomSetANF, IcomSetAPF, IcomSetAGC, IcomSetPreamp, IcomSetAtt, IcomSetFilter,
-  IcomSetRFPower, IcomSetMicGain, IcomSetSplit, IcomTune, IcomSetPTT,
+  AudioMonitorActive, AudioStartMonitor, AudioStopMonitor,
-  IcomSetScope, IcomScopeData, IcomSetScopeMode, IcomSetScopeEdges, GetCATState, SetCATFrequency, SetCATMode,
+  IcomSetRFPower, IcomSetMicGain, IcomSetSplit, IcomTune, IcomSetATU, IcomConsolePTT,
+  GetCATState, SetCATFrequency, SetCATMode,
   IcomSetRIT, IcomSetRITOn, IcomSetXITOn,
   IcomSetAntenna, IcomSetPBTInner, IcomSetPBTOuter, IcomSetManualNotch, IcomSetNotchPos,
   IcomSetSquelch, IcomSetComp, IcomSetCompLevel, IcomSetMonitor, IcomSetMonLevel,
@@ -19,7 +20,7 @@ import { ShiftRow } from '@/components/ShiftRow';
 
 type IcomState = {
   available: boolean; model?: string; mode?: string;
-  transmitting: boolean; split: boolean;
+  transmitting: boolean; split: boolean; sub_hz?: number; atu_on?: boolean;
   s_meter: number; power_meter: number; swr_meter: number;
   rf_power: number; mic_gain: number;
   af_gain: number; rf_gain: number;
@@ -79,17 +80,18 @@ function bandsFor(model?: string): Band[] {
 
 // Mode buttons for the console (like RS-BA1's row). SetCATMode picks USB/LSB for
 // SSB by frequency and the rig's data variant for digital modes.
-const MODES = ['SSB', 'CW', 'RTTY', 'PSK', 'AM', 'FM'];
+const MODES = ['SSB', 'CW', 'RTTY', 'PSK', 'AM', 'FM', 'DATA'];
 
 // Attenuator steps are MODEL-dependent even though the CI-V command (0x11) is the
 // same: the value byte is the dB. The IC-7610 (and 7700/7800/7851) have a 6/12/18
-// dB stepped attenuator; the IC-7300/705/7100 have a single 20 dB attenuator; the
+// dB stepped attenuator, and the IC-7760 the same (confirmed on a real one); the
+// IC-7300/705/7100 have a single 20 dB attenuator; the
 // IC-9700 a single 10 dB. Offering the wrong steps = a dead button (the rig NAKs
 // e.g. 6 dB on a 7300). Default to the common single 20 dB for unknown models.
 function attOptions(model?: string): { v: string; l: string }[] {
   const m = (model ?? '').toUpperCase();
   const OFF = { v: '0', l: 'OFF' };
-  if (/(7610|7700|7800|7850|7851)/.test(m)) {
+  if (/(7610|7700|7760|7800|7850|7851)/.test(m)) {
     return [OFF, { v: '6', l: '6dB' }, { v: '12', l: '12dB' }, { v: '18', l: '18dB' }];
   }
   if (m.includes('9700')) return [OFF, { v: '10', l: '10dB' }];
@@ -128,9 +130,38 @@ function fmtVFO(hz?: number): string {
 }
 
 // modeMatches marks a mode button active, folding the rig's USB/LSB into SSB.
+// icomWatts turns the backend's 0-100 meter percentage back into watts on the
+// IC-7760's own meter face. The backend value is linear in the RAW meter byte
+// (0-255 → 0-100), but Icom's calibration is not: raw 143 is half deflection
+// and raw 213 is full scale. On a real 7760 a measured 100 W sits at half
+// deflection of the 250 W face — the linear ×2.5 first tried showed 140 W for
+// it. Below half scale watts run 0→100, above it 100→250.
+// The anchors are MEASURED on the real radio, not derived: a known 50 W read
+// raw ≈89 and a known 100 W read raw 143 (Icom's documented half-deflection),
+// with raw 213 = full scale = 250 W. The face is not linear in watts at the
+// bottom — a two-segment guess showed 50 W as 62 — so watts interpolate
+// between the measured anchors, and a new measurement just adds a row.
+// Third measured anchor (2026-08-30): a real 200 W read full deflection —
+// raw 213 is 200 W on this rig, not the 250 the printed face suggests.
+const ICOM_7760_PO: [number, number][] = [[0, 0], [89, 50], [143, 100], [213, 200]];
+function icomWatts(pct: number): { w: number; defl: number } {
+  const raw = Math.max(0, pct * 2.55);
+  const defl = raw <= 143 ? (raw / 143) * 50 : Math.min(100, 50 + ((raw - 143) / 70) * 50);
+  let w = 200;
+  for (let i = 1; i < ICOM_7760_PO.length; i++) {
+    const [r0, w0] = ICOM_7760_PO[i - 1], [r1, w1] = ICOM_7760_PO[i];
+    if (raw <= r1) { w = w0 + ((raw - r0) / (r1 - r0)) * (w1 - w0); break; }
+  }
+  return { w: Math.round(w), defl };
+}
+
 function modeMatches(btn: string, cur?: string): boolean {
   if (!cur) return false;
   if (btn === 'SSB') return cur === 'SSB' || cur === 'USB' || cur === 'LSB';
+  // The backend surfaces USB-D as the operator's digital default (FT8…), or as
+  // plain DATA — either way it is the DATA button that should light.
+  if (btn === 'DATA') return ['DATA', 'FT8', 'FT4', 'JS8', 'JT65', 'JT9', 'MFSK', 'OLIVIA'].includes(cur);
+  if (btn === 'PSK') return cur === 'PSK' || cur === 'PSK31';
   return btn === cur;
 }
 
@@ -241,11 +272,11 @@ function Meter({ label, value, accent, scale, onClick, title }: { label: string;
       <div className="flex-1 h-2.5 rounded-full bg-muted/60 overflow-hidden">
         <div className="h-full rounded-full transition-[width] duration-150" style={{ width: `${v}%`, background: accent }} />
       </div>
-      <span className="w-10 text-right text-[11px] font-mono tabular-nums text-muted-foreground">{scale ?? v}</span>
+      <span className="w-14 shrink-0 whitespace-nowrap text-right text-[11px] font-mono tabular-nums text-muted-foreground">{scale ?? v}</span>
     </>
   );
   if (onClick) {
-    return <button type="button" onClick={onClick} title={title} className="flex items-center gap-2 w-full rounded hover:bg-muted/50 -mx-1 px-1 py-0.5">{body}</button>;
+    return <button type="button" onClick={onClick} title={title} className="flex items-center gap-2 w-full rounded cursor-pointer hover:bg-muted/50 -mx-1 px-1 py-0.5">{body}</button>;
   }
   return <div className="flex items-center gap-2">{body}</div>;
 }
@@ -253,6 +284,13 @@ function Meter({ label, value, accent, scale, onClick, title }: { label: string;
 // sParts turns the raw 0-100 S-meter into S-unit + dB-over-S9 (S9 ≈ 47% on the
 // CI-V 0-255 scale, +60 dB near full scale). Used for both the display label and
 // the RST-tx value on click.
+// Green to S9, amber through +20, red above — the Elecraft console's scale.
+function sSegColor(frac: number) {
+  if (frac > 0.78) return '#dc2626';
+  if (frac > 0.55) return '#f59e0b';
+  return '#16a34a';
+}
+
 function sParts(v: number): { s: number; over: number; label: string } {
   if (v >= 47) {
     const over = Math.max(0, Math.round((v - 47) * 60 / 47));
@@ -280,287 +318,31 @@ function wfColor(v: number): [number, number, number] {
   return WF_STOPS[WF_STOPS.length - 1][1];
 }
 
-// ScopePanadapter — enables the rig's spectrum-scope stream and draws the
+// The spectrum scope is GONE, deliberately. Every Icom streams its waveform
-// reassembled sweep as a modern SDR panadapter: a glowing filled spectrum trace
+// differently — the IC-7851 controls a scope it never streams, and a real
-// on top and a scrolling colour waterfall below. Amplitudes are raw rig scale
+// IC-7760 stops answering CI-V altogether a few frames in, taking CAT and
-// (~0-160), normalised to the tallest recent peak so the trace fills the height.
+// audio down with it — and chasing a per-model frame layout for a decoration
-function ScopePanadapter() {
+// is not worth a console that drops the link. The radio has a better scope
-  const { t } = useI18n();
+// on its own front panel.
-  const [on, setOn] = useState(false);
-  const [fixed, setFixed] = useState(true);
-  const canvasRef = useRef<HTMLCanvasElement>(null);
-  const wfRef = useRef<HTMLCanvasElement>(null); // waterfall
-  const peakRef = useRef(160); // running amplitude ceiling for auto-scale
-  const holdRef = useRef<number[]>([]); // per-bin peak-hold line
-  const spanRef = useRef({ low: 0, high: 0 }); // latest sweep edges, for click-to-tune
-  const vfoRef = useRef(0);    // latest VFO frequency, for wheel-tune
-  const centerRef = useRef(0); // scope centre we last set (for pan ◀/▶)
 
-  const toggle = () => {
-    const next = !on;
-    setOn(next);
-    IcomSetScope(next).catch(() => {});
-  };
-
-  // Centre/pan the FIXED scope: set the edges to centre ±50 kHz (a 100 kHz
-  // window). "Centre" uses the live VFO; ◀/▶ shift the window by 50 kHz. This
-  // just writes the rig's fixed edges — simple and independent of the waveform
-  // decode.
-  const SCOPE_HALF = 50_000;
-  const applyEdges = (center: number) => {
-    if (center <= 0) return;
-    centerRef.current = center;
-    setFixed(true);
-    IcomSetScopeEdges(center - SCOPE_HALF, center + SCOPE_HALF).catch(() => {});
-  };
-  const centerOnVfo = async () => {
-    let c = vfoRef.current;
-    if (c <= 0) { try { const cs = await GetCATState(); c = cs?.freq_hz || 0; } catch {} }
-    applyEdges(c);
-  };
-  const pan = (dir: number) => applyEdges((centerRef.current || vfoRef.current) + dir * SCOPE_HALF);
-  const setMode = (nextFixed: boolean) => {
-    setFixed(nextFixed);
-    IcomSetScopeMode(nextFixed).catch(() => {});
-  };
-  // Stop the stream when the panel unmounts.
-  useEffect(() => () => { IcomSetScope(false).catch(() => {}); }, []);
-
-  useEffect(() => {
-    if (!on) return;
-    let raf = 0, lastSeq = -1, alive = true;
-    const tick = async () => {
-      if (!alive) return;
-      try {
-        const sw = await IcomScopeData();
-        if (sw && sw.seq !== lastSeq && sw.amp && sw.amp.length) {
-          lastSeq = sw.seq;
-          setFixed(sw.fixed);
-          spanRef.current = { low: sw.low_hz, high: sw.high_hz };
-          let vfo = 0;
-          try {
-            const cs = await GetCATState();
-            vfo = cs?.split && cs.freq_rx_hz ? cs.freq_rx_hz : (cs?.freq_hz || 0);
-          } catch {}
-          if (vfo > 0) vfoRef.current = vfo;
-          draw(sw.amp, sw.low_hz, sw.high_hz, vfoRef.current, sw.fixed);
-        }
-      } catch {}
-      if (alive) raf = window.setTimeout(() => { raf = requestAnimationFrame(tick); }, 40) as unknown as number;
-    };
-    raf = requestAnimationFrame(tick);
-    return () => { alive = false; cancelAnimationFrame(raf); window.clearTimeout(raf); };
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [on]);
-
-  // Double-click tunes the rig to the clicked frequency.
-  const onDblClick = (e: React.MouseEvent<HTMLCanvasElement>) => {
-    const cv = canvasRef.current;
-    const { low, high } = spanRef.current;
-    if (!cv || !(low > 0 && high > low)) return;
-    const rect = cv.getBoundingClientRect();
-    const frac = Math.max(0, Math.min(1, (e.clientX - rect.left) / rect.width));
-    const hz = Math.round((low + frac * (high - low)) / 100) * 100; // nearest 100 Hz
-    SetCATFrequency(hz).catch(() => {});
-  };
-
-  // Mouse-wheel over the scope QSYs ±100 Hz. Non-passive listener so we can
-  // preventDefault (else the page scrolls); optimistic vfoRef so quick spins
-  // accumulate before the poll reconciles.
-  useEffect(() => {
-    const el = canvasRef.current;
-    if (!el || !on) return;
-    const onWheel = (e: WheelEvent) => {
-      if (!vfoRef.current) return;
-      e.preventDefault();
-      const next = vfoRef.current + (e.deltaY < 0 ? 100 : -100);
-      vfoRef.current = next;
-      SetCATFrequency(next).catch(() => {});
-    };
-    el.addEventListener('wheel', onWheel, { passive: false });
-    return () => el.removeEventListener('wheel', onWheel);
-  }, [on]);
-
-  const draw = (amp: number[], lowHz: number, highHz: number, vfoHz: number, fixedMode: boolean) => {
-    const cv = canvasRef.current;
-    if (!cv) return;
-    const dpr = window.devicePixelRatio || 1;
-    const w = cv.clientWidth, h = cv.clientHeight;
-    if (cv.width !== w * dpr || cv.height !== h * dpr) { cv.width = w * dpr; cv.height = h * dpr; }
-    const ctx = cv.getContext('2d');
-    if (!ctx) return;
-    ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
-
-    // Auto-scale: track the peak, decaying slowly so the floor doesn't jump.
-    const peak = Math.max(...amp);
-    peakRef.current = Math.max(peak, peakRef.current * 0.95, 40);
-    const scale = peakRef.current;
-    const n = amp.length;
-
-    // Background — deep navy vertical gradient.
-    const bg = ctx.createLinearGradient(0, 0, 0, h);
-    bg.addColorStop(0, '#0b1220'); bg.addColorStop(1, '#05070e');
-    ctx.fillStyle = bg; ctx.fillRect(0, 0, w, h);
-
-    // Grid.
-    ctx.strokeStyle = 'rgba(120,150,200,0.08)';
-    ctx.lineWidth = 1;
-    for (let i = 1; i < 4; i++) { const y = (h * i) / 4; ctx.beginPath(); ctx.moveTo(0, y); ctx.lineTo(w, y); ctx.stroke(); }
-    for (let i = 1; i < 8; i++) { const x = (w * i) / 8; ctx.beginPath(); ctx.moveTo(x, 0); ctx.lineTo(x, h); ctx.stroke(); }
-
-    const xOf = (i: number) => (i / (n - 1)) * w;
-    const yOf = (v: number) => h - Math.min(1, v / scale) * h;
-
-    // Peak-hold line (slow decay) — a faint ghost of recent maxima.
-    const hold = holdRef.current;
-    if (hold.length !== n) hold.length = n, hold.fill(0);
-    for (let i = 0; i < n; i++) hold[i] = Math.max(amp[i], hold[i] * 0.92);
-
-    // Filled spectrum area.
-    ctx.beginPath();
-    ctx.moveTo(0, h);
-    for (let i = 0; i < n; i++) ctx.lineTo(xOf(i), yOf(amp[i]));
-    ctx.lineTo(w, h); ctx.closePath();
-    const grad = ctx.createLinearGradient(0, 0, 0, h);
-    grad.addColorStop(0, 'rgba(56,189,248,0.40)');
-    grad.addColorStop(1, 'rgba(56,189,248,0.02)');
-    ctx.fillStyle = grad; ctx.fill();
-
-    // Peak-hold trace (thin, faint).
-    ctx.beginPath();
-    for (let i = 0; i < n; i++) { const x = xOf(i), y = yOf(hold[i]); i === 0 ? ctx.moveTo(x, y) : ctx.lineTo(x, y); }
-    ctx.strokeStyle = 'rgba(148,197,255,0.35)'; ctx.lineWidth = 1; ctx.stroke();
-
-    // Live spectrum trace with a soft glow.
-    ctx.save();
-    ctx.shadowColor = 'rgba(56,189,248,0.7)'; ctx.shadowBlur = 6;
-    ctx.beginPath();
-    for (let i = 0; i < n; i++) { const x = xOf(i), y = yOf(amp[i]); i === 0 ? ctx.moveTo(x, y) : ctx.lineTo(x, y); }
-    ctx.strokeStyle = '#7dd3fc'; ctx.lineWidth = 1.5; ctx.lineJoin = 'round'; ctx.stroke();
-    ctx.restore();
-
-    // VFO marker: you should ALWAYS see where you are. Exact position when the VFO
-    // is inside the span; the centre in CTR mode; clamped to the nearest edge with
-    // a sideways arrow in FIX mode when the fixed scope doesn't cover the VFO (so
-    // you can tell which way to tune to get it back on-screen).
-    const haveVfo = vfoHz > 0 && lowHz > 0 && highHz > lowHz;
-    const inSpan = haveVfo && vfoHz >= lowHz && vfoHz <= highHz;
-    let markerX = -1;
-    let offEdge = 0; // -1 = VFO off the left edge, +1 = off the right
-    if (inSpan) markerX = ((vfoHz - lowHz) / (highHz - lowHz)) * w;
-    else if (!fixedMode) markerX = w / 2;
-    else if (haveVfo) { offEdge = vfoHz < lowHz ? -1 : 1; markerX = offEdge < 0 ? 1 : w - 1; }
-    if (markerX >= 0) {
-      const x = markerX;
-      ctx.fillStyle = 'rgba(244,63,94,0.10)'; ctx.fillRect(x - 5, 0, 10, h);
-      ctx.strokeStyle = 'rgba(244,63,94,0.9)'; ctx.lineWidth = 1.25;
-      ctx.beginPath(); ctx.moveTo(x, 0); ctx.lineTo(x, h); ctx.stroke();
-      ctx.fillStyle = 'rgba(244,63,94,0.95)';
-      if (offEdge === 0) {
-        ctx.beginPath(); ctx.moveTo(x - 4, 0); ctx.lineTo(x + 4, 0); ctx.lineTo(x, 6); ctx.closePath(); ctx.fill();
-      } else {
-        const yh = 8; ctx.beginPath(); ctx.moveTo(x, yh - 5); ctx.lineTo(x + offEdge * 7, yh); ctx.lineTo(x, yh + 5); ctx.closePath(); ctx.fill();
-      }
-    }
-
-    // Frequency scale. In fixed mode the rig reports usable edge frequencies, so
-    // we label low/centre/high from them. In centre mode the header frame's edge
-    // pair isn't a usable low..high range, but the scope is centred on the VFO —
-    // so we always label the centre with the live VFO frequency (which we fetch
-    // each sweep), and only add edge labels when the reported edges genuinely
-    // bracket the VFO. That guarantees you always see your frequency in CTR.
-    const mhz = (hz: number) => (hz / 1e6).toFixed(3);
-    ctx.font = '10px ui-monospace, monospace';
-    ctx.textBaseline = 'bottom';
-    ctx.shadowColor = 'rgba(0,0,0,0.8)'; ctx.shadowBlur = 3;
-    ctx.fillStyle = 'rgba(226,232,240,0.85)';
-    const label = (txt: string, x: number, align: CanvasTextAlign) => { ctx.textAlign = align; ctx.fillText(txt, x, h - 3); };
-    const validEdges = lowHz > 0 && highHz > lowHz;
-    if (fixedMode) {
-      if (validEdges) {
-        label(mhz(lowHz), 4, 'left');
-        label(mhz((lowHz + highHz) / 2), w / 2, 'center');
-        label(mhz(highHz), w - 4, 'right');
-      }
-    } else {
-      if (validEdges && vfoHz >= lowHz && vfoHz <= highHz) {
-        label(mhz(lowHz), 4, 'left');
-        label(mhz(highHz), w - 4, 'right');
-      }
-      if (vfoHz > 0) label(mhz(vfoHz), w / 2, 'center');
-    }
-    ctx.shadowBlur = 0;
-
-    drawWaterfall(amp, scale);
-  };
-
-  // drawWaterfall scrolls the history down one row and paints the newest sweep
-  // as a colour-mapped line at the top.
-  const drawWaterfall = (amp: number[], scale: number) => {
-    const cv = wfRef.current;
-    if (!cv) return;
-    const w = Math.max(1, cv.clientWidth), h = Math.max(1, cv.clientHeight);
-    if (cv.width !== w || cv.height !== h) { cv.width = w; cv.height = h; }
-    const ctx = cv.getContext('2d');
-    if (!ctx) return;
-    // Scroll everything down by one pixel row.
-    ctx.drawImage(cv, 0, 0, w, h - 1, 0, 1, w, h - 1);
-    // Paint the new top row.
-    const row = ctx.createImageData(w, 1);
-    const n = amp.length;
-    for (let x = 0; x < w; x++) {
-      const i = Math.min(n - 1, Math.round((x / (w - 1)) * (n - 1)));
-      const [r, g, b] = wfColor(amp[i] / scale);
-      const o = x * 4;
-      row.data[o] = r; row.data[o + 1] = g; row.data[o + 2] = b; row.data[o + 3] = 255;
-    }
-    ctx.putImageData(row, 0, 0);
-  };
-
-  // Collapsible card: when the scope is off, only the header band shows (the
-  // canvas is hidden entirely) so it doesn't waste vertical space. The CTR/FIX
-  // and ON/OFF controls live in the header itself.
-  return (
-    <div className="rounded-xl border border-border bg-card shadow-sm overflow-hidden">
-      <div className="flex items-center gap-2 px-3 py-2 border-b border-border/60 bg-muted/30">
-        <Activity className="size-4" style={{ color: '#38bdf8' }} />
-        <span className="text-xs font-bold uppercase tracking-wider text-foreground/80">{t('icmp.spectrum')}</span>
-        <div className="ml-auto flex items-center gap-2 shrink-0">
-          {on && (
-            <div className="inline-flex rounded-md border border-border overflow-hidden">
-              <button type="button" onClick={() => pan(-1)} title={t('icmp.scopePanDown')}
-                className="px-2 py-1 text-xs font-bold bg-card text-muted-foreground hover:bg-muted border-r border-border">◀</button>
-              <button type="button" onClick={centerOnVfo} title={t('icmp.scopeCenterVfo')}
-                className="px-2 py-1 text-[11px] font-bold bg-card text-muted-foreground hover:bg-muted border-r border-border">⊙</button>
-              <button type="button" onClick={() => pan(1)} title={t('icmp.scopePanUp')}
-                className="px-2 py-1 text-xs font-bold bg-card text-muted-foreground hover:bg-muted">▶</button>
-            </div>
-          )}
-          {on && (
-            <Segmented value={fixed ? 'FIX' : 'CTR'} options={[{ v: 'CTR', l: 'CTR' }, { v: 'FIX', l: 'FIX' }]}
-              onChange={(v) => setMode(v === 'FIX')} />
-          )}
-          <Chip label={on ? 'ON' : 'OFF'} on={on} onClick={toggle} />
-        </div>
-      </div>
-      {on && (
-        <div className="p-3">
-          <div className="rounded-xl overflow-hidden ring-1 ring-info/20 shadow-lg shadow-sky-500/5 bg-[#05070e]">
-            <canvas ref={canvasRef} onDoubleClick={onDblClick}
-              className="w-full block cursor-crosshair" style={{ height: 140 }} />
-            <canvas ref={wfRef} className="w-full block" style={{ height: 96 }} />
-          </div>
-        </div>
-      )}
-    </div>
-  );
-}
-
-// IcomPanel — full control surface (RX DSP + TX) for an Icom on the CI-V backend.
-// Unlike the Flex (which pushes state), the Icom is polled: meters/TX state are
-// read every cache cycle; DSP set-controls are optimistic and reconcile on the
-// next poll. Front-panel knob changes for DSP show after ↻ Refresh.
 export function IcomPanel({ onReportRST, isNetwork = false }: { onReportRST?: (rst: string) => void; isNetwork?: boolean } = {}) {
+  // The speaker toggle lives HERE, next to ON/OFF, because that is where the
+  // operator is looking — burying "stop listening" behind Settings → Audio
+  // meant a trip through two panels to mute a radio sitting in the same room.
+  const [listening, setListening] = useState(false);
+  useEffect(() => {
+    if (!isNetwork) return;
+    let alive = true;
+    const ask = () => AudioMonitorActive().then((v) => { if (alive) setListening(!!v); }).catch(() => {});
+    ask();
+    const id = window.setInterval(ask, 2000);
+    return () => { alive = false; window.clearInterval(id); };
+  }, [isNetwork]);
+  const toggleListening = () => {
+    const next = !listening;
+    setListening(next);
+    (next ? AudioStartMonitor() : Promise.resolve(AudioStopMonitor())).catch(() => setListening(!next));
+  };
   const { t } = useI18n();
   const [st, setSt] = useState<IcomState>(ZERO);
   const [cat, setCat] = useState<any>(null); // RigState (freq/mode/split) for the VFO display
@@ -596,7 +378,9 @@ export function IcomPanel({ onReportRST, isNetwork = false }: { onReportRST?: (r
   const toggleMox = () => {
     const next = !txRef.current;
     txRef.current = next;
-    set({ transmitting: next }, () => IcomSetPTT(next));
+    // Through the console binding: on a network station the PC microphone
+    // rides with the PTT (silence otherwise); on USB it keys and nothing more.
+    set({ transmitting: next }, () => IcomConsolePTT(next));
   };
 
   const tune = async () => {
@@ -639,8 +423,13 @@ export function IcomPanel({ onReportRST, isNetwork = false }: { onReportRST?: (r
   // other is TX (freq_hz); otherwise there's a single VFO (freq_hz).
   const split = !!cat?.split;
   const mainHz: number = split ? (cat?.freq_rx_hz || 0) : (cat?.freq_hz || 0);
-  const subHz: number = split ? (cat?.freq_hz || 0) : 0;
+  // The sub receiver's dial is worth seeing whether or not split is on —
-  const curMode: string = cat?.mode || st.mode || '';
+  // in split the CAT state's TX freq is the authority, otherwise the panel's
+  // own sub_hz read.
+  const subHz: number = split ? (cat?.freq_hz || 0) : (st.sub_hz || 0);
+  // The panel's own mode first: it carries the sideband (USB/LSB) where the
+  // CAT state folds both into ADIF's SSB.
+  const curMode: string = st.mode || cat?.mode || '';
   // Mode-dependent controls: VOX / speech-comp / mic are voice-only (hidden on
   // CW and data); APF (audio peak filter) is CW-only. Fold USB/LSB into phone.
   const um = curMode.toUpperCase();
@@ -669,6 +458,14 @@ export function IcomPanel({ onReportRST, isNetwork = false }: { onReportRST?: (r
               rig's LAN server stays alive in standby, so both work. */}
           {isNetwork && (
             <>
+              <button type="button" onClick={toggleListening}
+                title={listening ? t('icmp.speakerOffHint') : t('icmp.speakerOnHint')}
+                className={cn('inline-flex items-center gap-1 rounded-md border px-2 py-1 text-xs font-bold',
+                  listening
+                    ? 'border-primary/60 bg-primary/10 text-primary hover:bg-primary/20'
+                    : 'border-border bg-card text-muted-foreground hover:bg-muted')}>
+                {listening ? <Volume2 className="size-3.5" /> : <VolumeX className="size-3.5" />}
+              </button>
               <button type="button" onClick={() => IcomSetPower(true).catch(() => {})} title={t('icmp.powerOnHint')}
                 className="inline-flex items-center gap-1 rounded-md border border-success/60 bg-success/10 px-2 py-1 text-xs font-bold text-success hover:bg-success/20">
                 <Power className="size-3.5" /> ON
@@ -710,7 +507,7 @@ export function IcomPanel({ onReportRST, isNetwork = false }: { onReportRST?: (r
           </div>
         </div>
         {/* Mode selector row (RS-BA1's SSB/CW/RTTY/PSK/AM/FM). */}
-        <div className="grid grid-cols-6 border-t border-border/60 divide-x divide-border/60">
+        <div className="grid grid-cols-7 border-t border-border/60 divide-x divide-border/60">
           {MODES.map((m) => {
             const on = modeMatches(m, curMode);
             return (
@@ -724,20 +521,28 @@ export function IcomPanel({ onReportRST, isNetwork = false }: { onReportRST?: (r
         </div>
       </div>
 
-      {/* Live meters — always visible: S (RX, click → RST), Po in watts, SWR. */}
+      {/* Live meters — the SAME LED MeterBar every other console uses (Flex,
-      <div className="rounded-xl border border-border bg-card px-3 py-2.5 shadow-sm grid grid-cols-1 sm:grid-cols-3 gap-x-5 gap-y-2">
+          Elecraft, the amp cards): one instrument look across the app, per the
+          operator's "les consoles doivent se ressembler". S is clickable → RST. */}
+      <div className="grid grid-cols-1 sm:grid-cols-3 gap-2">
         {(() => { const sp = sParts(st.s_meter); return (
-          <Meter label="S" value={st.s_meter} accent="#22c55e" scale={sp.label}
+          <MeterBar label="S-METER" value={st.transmitting ? 0 : st.s_meter} lo={0} hi={100}
+            accent="#16a34a" segColor={sSegColor}
+            display={st.transmitting ? '—' : sp.label}
             title={onReportRST ? t('rst.clickToFill') : undefined}
-            onClick={onReportRST ? () => onReportRST(sMeterRST(sp.s, sp.over, st.mode)) : undefined} />
+            onClick={onReportRST ? () => { if (!st.transmitting) onReportRST(sMeterRST(sp.s, sp.over, st.mode)); } : undefined} />
         ); })()}
-        <Meter label="Po" value={st.power_meter} accent="#ef4444" scale={`${st.power_meter} W`} />
+        {(() => {
-        <Meter label="SWR" value={st.swr_meter} accent="#f59e0b" scale={st.swr_meter > 0 ? `${(1 + st.swr_meter / 33.3).toFixed(1)}` : '1.0'} />
+          if ((st.model ?? '').includes('7760')) {
+            const { w, defl } = icomWatts(st.power_meter);
+            return <MeterBar label="PWR" value={defl} lo={0} hi={100} accent="#0ea5e9" display={`${w} W`} />;
+          }
+          return <MeterBar label="PWR" value={st.power_meter} lo={0} hi={100} accent="#0ea5e9" display={`${st.power_meter} W`} />;
+        })()}
+        <MeterBar label="SWR" value={st.swr_meter > 0 ? 1 + st.swr_meter / 33.3 : 0} lo={1} hi={4} accent="#f59e0b"
+          display={st.swr_meter > 0 ? (1 + st.swr_meter / 33.3).toFixed(1) : '—'} />
       </div>
 
-      {/* Spectrum panadapter (full width). */}
-      <ScopePanadapter />
-
       <div className="grid grid-cols-1 lg:grid-cols-2 gap-3">
       {/* Band buttons + antenna selection. */}
       <Card icon={Antenna} title={t('icmp.bandsAntenna')} accent="#0891b2">
@@ -777,7 +582,11 @@ export function IcomPanel({ onReportRST, isNetwork = false }: { onReportRST?: (r
       <Card icon={Mic} title={t('icmp.transmit')} accent="#ef4444">
         <Row label={t('icmp.power')}>
           <Slider value={st.rf_power} accent="#ef4444" onChange={(v) => set({ rf_power: v }, () => IcomSetRFPower(v))} />
-          <span className="w-8 text-right text-xs font-mono tabular-nums text-muted-foreground">{st.rf_power}</span>
+          {/* PC is a percentage of the rig's rated power; on a 200 W rig the
+              operator thinks in watts, so say it in watts there. */}
+          <span className="w-12 text-right text-xs font-mono tabular-nums text-muted-foreground">
+            {(st.model ?? '').includes('7760') ? `${st.rf_power * 2} W` : st.rf_power}
+          </span>
         </Row>
         {isPhone && (
           <Row label={t('icmp.mic')}>
@@ -792,6 +601,9 @@ export function IcomPanel({ onReportRST, isNetwork = false }: { onReportRST?: (r
             {tx ? 'TX ON' : 'MOX'}
           </button>
           <Chip label="SPLIT" on={st.split} onClick={() => set({ split: !st.split }, () => IcomSetSplit(!st.split))} />
+          {/* Tuner IN/OUT — TUNE below starts a cycle but could never take the
+              tuner back out of line. */}
+          <Chip label="ATU" on={!!st.atu_on} onClick={() => set({ atu_on: !st.atu_on } as any, () => IcomSetATU(!st.atu_on))} />
           <button type="button" onClick={tune} disabled={tuning}
             className={cn('w-14 shrink-0 px-2 py-1.5 rounded-md text-[11px] font-bold border transition-colors',
               tuning ? 'bg-warning border-warning text-warning-foreground animate-pulse' : 'bg-card text-foreground border-border hover:bg-muted')}>

frontend/src/components/MainMap.tsx

@@ -4,6 +4,7 @@ import 'leaflet/dist/leaflet.css';
 import { nightPolygon } from '../lib/greyline';
 import { gridToLatLon, gridSquareBounds, greatCirclePoints, pathBetween, destinationPoint } from '@/lib/maidenhead';
 import { writeUiPref } from '@/lib/uiPref';
+import { formatDistance } from '@/lib/units';
 
 // Persisted free-pan view of the world map (when auto-zoom is off).
 function loadMapView(): { lat: number; lon: number; zoom: number } | null {
@@ -369,8 +370,14 @@ export function WorldMap({ fromGrid, toGrid, fromLabel, toLabel, beamAzimuths, b
 
     if (autoZoom) {
       if (from && to && arcPts) {
-        const bounds = L.latLngBounds([[from.lat, from.lon], [to.lat, to.lon]]);
+        // Latitudes clamped to Mercator's edge (±85°): the arc to a polar
-        arcPts.forEach((p) => bounds.extend(p as L.LatLngExpression));
+        // entity (Franz Josef Land) peaks near 88°N, and fitting the raw
+        // points framed a band of tile-less white above the top of the world.
+        // The line itself still draws to wherever it goes — only the CAMERA
+        // stays where there is a map to show.
+        const clamp = (lat: number) => Math.max(-85, Math.min(85, lat));
+        const bounds = L.latLngBounds([[clamp(from.lat), from.lon], [clamp(to.lat), to.lon]]);
+        arcPts.forEach((p) => bounds.extend([clamp(p[0]), p[1]] as L.LatLngExpression));
         wm.fitBounds(bounds, { padding: [30, 30], maxZoom: 6 });
       } else if (to) {
         wm.setView([to.lat, to.lon], 3);
@@ -446,8 +453,8 @@ export function WorldMap({ fromGrid, toGrid, fromLabel, toLabel, beamAzimuths, b
       </button>
       {path && (
         <div className="absolute bottom-1 left-1 z-[500] rounded-md bg-card/90 backdrop-blur px-2 py-1 text-[11px] font-mono shadow border border-border pointer-events-none">
-          <div><span className="text-muted-foreground">Dist</span> {Math.round(path.distanceShort).toLocaleString()} km
+          <div><span className="text-muted-foreground">Dist</span> {formatDistance(path.distanceShort)}
-            <span className="text-muted-foreground"> · LP</span> {Math.round(path.distanceLong).toLocaleString()} km</div>
+            <span className="text-muted-foreground"> · LP</span> {formatDistance(path.distanceLong)}</div>
           <div><span className="text-muted-foreground">Az SP</span> {Math.round(path.bearingShort)}°
             <span className="text-muted-foreground"> · LP</span> {Math.round(path.bearingLong)}°</div>
         </div>

frontend/src/components/QSLManagerModal.tsx

@@ -8,7 +8,7 @@ import {
   Select, SelectTrigger, SelectValue, SelectContent, SelectItem,
 } from '@/components/ui/select';
 import { cn } from '@/lib/utils';
-import { FindQSOsForUpload, UploadQSOsManual, DownloadConfirmations, CancelConfirmations, ImportHamlogConfirmations, ExportHamlogUnmatched, OpenADIFFile, SaveADIFFile, SyncPOTAHunterLog, ListQSO, BulkUpdateQSL, UploadCallsign, GetSlotStats } from '../../wailsjs/go/main/App';
+import { GetLoTWQSLDetail, SetLoTWQSLDetail, GetLoTWDownloadAllCalls, SetLoTWDownloadAllCalls, OpenExternalURL, FindQSOsForUpload, UploadQSOsManual, DownloadConfirmations, CancelConfirmations, ImportHamlogConfirmations, ExportHamlogUnmatched, OpenADIFFile, SaveADIFFile, SyncPOTAHunterLog, ListQSO, BulkUpdateQSL, UploadCallsign, GetSlotStats } from '../../wailsjs/go/main/App';
 import { Input } from '@/components/ui/input';
 import { RecentQSOsGrid } from '@/components/RecentQSOsGrid';
 import { EventsOn } from '../../wailsjs/runtime/runtime';
@@ -31,7 +31,7 @@ const UPLOAD_COLS: ColDef<UploadRow>[] = [
 ];
 
 type Confirmation = {
-  callsign: string; qso_date: string; band: string; mode: string; country: string;
+  callsign: string; station?: string; qso_date: string; band: string; mode: string; country: string;
   new_dxcc: boolean; new_band: boolean; new_mode: boolean; new_slot: boolean;
 };
 
@@ -255,6 +255,15 @@ export function QSLManagerPanel({ onEditQSO, actions, paperRequest }: {
   const [searching, setSearching] = useState(false);
   const [error, setError] = useState('');
   const [addNotFound, setAddNotFound] = useState(false);
+  // LoTW only: pull the whole account rather than this profile's callsign.
+  const [lotwAllCalls, setLotwAllCalls] = useState(false);
+  // LoTW only: ask for the QSL dates and station details. Ten times slower to
+  // build, so it is a choice rather than the default it used to be.
+  const [lotwDetail, setLotwDetail] = useState(false);
+  useEffect(() => {
+    GetLoTWDownloadAllCalls().then((v: boolean) => setLotwAllCalls(!!v)).catch(() => {});
+    GetLoTWQSLDetail().then((v: boolean) => setLotwDetail(!!v)).catch(() => {});
+  }, []);
   // Download date window: 'last' = incremental since last pull, 'date' = from a
   // chosen date, 'all' = everything.
   const [sinceMode, setSinceMode] = useState<'last' | 'date' | 'all'>('last');
@@ -434,6 +443,18 @@ export function QSLManagerPanel({ onEditQSO, actions, paperRequest }: {
               {paperBusy ? <Loader2 className="size-3.5 animate-spin" /> : <Search className="size-3.5" />}
               {t('qslm.search')}
             </Button>
+            {/* The station's QRZ page, one click away: writing a card means
+                reading the address, the manager and whether they even want
+                paper, and all three are on that page. */}
+            <Button size="sm" variant="outline" className="h-8" disabled={!paperCall.trim()}
+              title={t('qslm.qrzTitle')}
+              onClick={() => {
+                const c = paperCall.trim().toUpperCase();
+                if (c) OpenExternalURL(`https://www.qrz.com/db/${c}`).catch(() => {});
+              }}>
+              <ExternalLink className="size-3.5" />
+              QRZ
+            </Button>
             <span className="text-[11px] text-muted-foreground self-center">{t('qslm.paperHint')}</span>
           </>
         ) : (
@@ -598,6 +619,10 @@ export function QSLManagerPanel({ onEditQSO, actions, paperRequest }: {
               <thead className="sticky top-0 bg-card">
                 <tr className="text-left text-muted-foreground border-b border-border">
                   <th className="py-1.5 px-2">{t('qslm.thDateUtc')}</th><th className="py-1.5 px-2">{t('qslm.thCallsign')}</th>
+                  {/* Which of the operator's callsigns the contact was made
+                      under. Only worth a column when the list can hold more than
+                      one — see "All my callsigns" on the download. */}
+                  {shownConfs.some((c) => c.station) && <th className="py-1.5 px-2">{t('qslm.thStation')}</th>}
                   <th className="py-1.5 px-2">{t('qslm.thBand')}</th><th className="py-1.5 px-2">{t('qslm.thMode')}</th>
                   <th className="py-1.5 px-2">{t('qslm.thCountry')}</th><th className="py-1.5 px-2">{t('qslm.thNew')}</th>
                 </tr>
@@ -607,6 +632,9 @@ export function QSLManagerPanel({ onEditQSO, actions, paperRequest }: {
                   <tr key={i} className="border-b border-border/40">
                     <td className="py-1 px-2 font-mono">{fmtDate(c.qso_date)}</td>
                     <td className="py-1 px-2 font-mono font-bold">{c.callsign}</td>
+                    {shownConfs.some((x) => x.station) && (
+                      <td className="py-1 px-2 font-mono text-muted-foreground">{c.station ?? ''}</td>
+                    )}
                     <td className="py-1 px-2">{c.band}</td>
                     <td className="py-1 px-2">{c.mode}</td>
                     <td className="py-1 px-2 text-muted-foreground">{c.country}</td>
@@ -736,6 +764,19 @@ export function QSLManagerPanel({ onEditQSO, actions, paperRequest }: {
             <Checkbox checked={addNotFound} onCheckedChange={(c) => setAddNotFound(!!c)} />
             {t('qslm.addNotFound')}
           </label>
+          {service === 'lotw' && (
+            <label className="flex items-center gap-1.5 text-[11px] text-muted-foreground cursor-pointer" title={t('qslm.lotwDetailTitle')}>
+              <Checkbox checked={lotwDetail || addNotFound} disabled={addNotFound}
+                onCheckedChange={(c) => { setLotwDetail(!!c); SetLoTWQSLDetail(!!c); }} />
+              {t('qslm.lotwDetail')}
+            </label>
+          )}
+          {service === 'lotw' && (
+            <label className="flex items-center gap-1.5 text-[11px] text-muted-foreground cursor-pointer" title={t('qslm.lotwAllCallsTitle')}>
+              <Checkbox checked={lotwAllCalls} onCheckedChange={(c) => { setLotwAllCalls(!!c); SetLoTWDownloadAllCalls(!!c); }} />
+              {t('qslm.lotwAllCalls')}
+            </label>
+          )}
           </>)}
         </div>
         <Button size="sm" onClick={upload} disabled={selectedCount === 0 || busy}>

frontend/src/components/RecentQSOsGrid.tsx

@@ -9,6 +9,7 @@ import { formatDateTimeUTC, formatDateOnly, getDateFormat, subscribeDateFormat }
 import { AgGridReact } from 'ag-grid-react';
 import { Columns3, FilterX, ListChecks } from 'lucide-react';
 import type { QSOForm } from '@/types';
+import { distanceUnit, distanceValue, subscribeDistanceUnit } from '@/lib/units';
 import { QSOContextMenu, type QSOMenuState } from './QSOContextMenu';
 import {
   Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter, DialogDescription,
@@ -177,8 +178,9 @@ export const makeColCatalog = (t: TFn, myGrid?: string): ColEntry[] => [
   { group: 'Contacted', label: t('rqg.c.lon'),      colId: 'lon',      headerName: t('rqg.c.lon'),      field: 'lon' as any,      width: 90, type: 'rightAligned', cellClass: 'font-mono' },
   // Derived, not stored: computed from the two locations at display time, like
   // the cluster grid's own distance column.
-  { group: 'Contacted', label: t('rqg.c.distance_km'), colId: 'distance_km', headerName: t('rqg.h.distance_km'), width: 90, type: 'rightAligned', cellClass: 'font-mono',
+  { group: 'Contacted', label: t('rqg.c.distance_km'), colId: 'distance_km',
-    valueGetter: (p) => qsoDistanceKm(p.data, myGrid),
+    headerName: t('rqg.h.distance_km') + ' (' + distanceUnit() + ')', width: 95, type: 'rightAligned', cellClass: 'font-mono',
+    valueGetter: (p) => { const km = qsoDistanceKm(p.data, myGrid); return km ? distanceValue(km) : km; },
     comparator: (a, b) => (a ?? 0) - (b ?? 0), defaultVisible: true },
   { group: 'Contacted', label: t('rqg.c.email'),    colId: 'email',    headerName: t('rqg.c.email'),    field: 'email' as any,    width: 180 },
   { group: 'Contacted', label: t('rqg.c.web'),      colId: 'web',      headerName: t('rqg.c.web'),      field: 'web' as any,      width: 180 },
@@ -335,7 +337,9 @@ export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal,
   // inside the column definitions, so nothing else would notice.
   const [dateFmt, setDateFmt] = useState(getDateFormat);
   useEffect(() => subscribeDateFormat(() => setDateFmt(getDateFormat())), []);
-  const COL_CATALOG = useMemo(() => makeColCatalog(t, myGrid), [t, myGrid, dateFmt]);
+  const [distUnit, setDistUnit] = useState(distanceUnit);
+  useEffect(() => subscribeDistanceUnit(() => setDistUnit(distanceUnit())), []);
+  const COL_CATALOG = useMemo(() => makeColCatalog(t, myGrid), [t, myGrid, dateFmt, distUnit]);
 
   // Right-click: if the clicked row isn't already part of the selection,
   // select just it; then open the bulk-action menu on the whole selection.

frontend/src/components/SettingsModal.tsx

@@ -9,7 +9,8 @@ import {
 import {
   GetLookupSettings, SaveLookupSettings, ClearLookupCache, TestLookupProvider,
   GetListsSettings, SaveListsSettings,
-  GetCATSettings, SaveCATSettings, GetRadios, SaveRadios, SetActiveRadio, DiscoverFlexRadios,
+  GetCATSettings, SaveCATSettings, GetRadios, SaveRadios, SetActiveRadio, ActiveRadioID, DiscoverFlexRadios,
+  GetAudioMonitorPref,
   ListProfiles, GetActiveProfile, SaveProfile, DeleteProfile, ActivateProfile, DuplicateProfile,
   GetRotators, SaveRotators, TestRotatorDevice, RotatorPark, RotatorStop,
   GetRotorPresets, SaveRotorPresets, ResetRotorPresets,
@@ -80,6 +81,8 @@ import {
 } from '@/components/ui/select';
 import { cn } from '@/lib/utils';
 import { writeUiPref } from '@/lib/uiPref';
+import { setUseMiles } from '@/lib/units';
+import { iaruRegion, setIaruRegion, type IaruRegion } from '@/lib/bandplan';
 import { getDateFormat, setDateFormat, type DateFormat } from '@/lib/dateFormat';
 import { useI18n, FlagGB, FlagFR, type Lang } from '@/lib/i18n';
 import { useTheme, CONCRETE_THEMES, type ThemeChoice } from '@/lib/theme';
@@ -688,8 +691,7 @@ function TelemetryToggle() {
     <label className="flex items-center gap-2 text-sm cursor-pointer">
       <Checkbox checked={on} disabled={!loaded}
         onCheckedChange={(c) => { const v = !!c; setOn(v); SetTelemetryEnabled(v).catch(() => {}); }} />
-      {t('settings.telemetry')}
+      <span title={t('settings.telemetryHint')}>{t('settings.telemetry')}</span>
-      <span className="text-xs text-muted-foreground">({t('settings.telemetryHint')})</span>
     </label>
   );
 }
@@ -1085,7 +1087,7 @@ function RelayAutoPanel() {
 // panes. The first two are the view; the third and fourth can be left empty, and
 // an empty one is not drawn at all. Per-profile (stored via SetUIPref, which is
 // profile-prefixed). Self-contained so it owns its async-loaded state.
-const MAIN_PANE_VALUES = ['map1', 'map2', 'cluster', 'worked', 'recent', 'netcontrol', 'decodes'];
+const MAIN_PANE_VALUES = ['map1', 'map2', 'cluster', 'worked', 'recent', 'netcontrol', 'decodes', 'watchlist'];
 const PANE_NONE = 'none';
 function MainViewPanes({ onChanged, flexAvailable, icomAvailable, yaesuAvailable, elecraftAvailable, tciAvailable }: { onChanged?: (side: 'left' | 'right' | 'p3' | 'p4' | 'layout', value: string) => void; flexAvailable?: boolean; icomAvailable?: boolean; yaesuAvailable?: boolean; elecraftAvailable?: boolean; tciAvailable?: boolean }) {
   const { t } = useI18n();
@@ -1502,6 +1504,7 @@ const ICOM_MODELS: { name: string; addr: number }[] = [
   { name: 'IC-7600', addr: 0x7A },
   { name: 'IC-7610', addr: 0x98 },
   { name: 'IC-7700', addr: 0x74 },
+  { name: 'IC-7760', addr: 0xB2 },
   { name: 'IC-7800', addr: 0x6A },
   { name: 'IC-7851', addr: 0x8E },
   { name: 'IC-9100', addr: 0x7C },
@@ -1599,6 +1602,7 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
   // The saved radios. The CAT panel edits ONE of them — whichever is on the air
   // — and the list is what makes switching possible without touching profiles.
   const [radios, setRadios] = useState<any[]>([]);
+  const [listenPref, setListenPref] = useState(true);
   const [activeRadio, setActiveRadioId] = useState('');
   const [radioBusy, setRadioBusy] = useState(false);
   const [catCfg, setCatCfg] = useState<CATSettings>({
@@ -1747,6 +1751,8 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
   const [startEqEnd, setStartEqEnd] = useState(() => localStorage.getItem('opslog.startEqualsEnd') === '1');
   const [lookupOnBlur, setLookupOnBlur] = useState(() => localStorage.getItem('opslog.lookupOnBlur') === '1');
   const [groupDigital, setGroupDigital] = useState(() => localStorage.getItem('opslog.groupDigitalSlots') === '1');
+  const [milesUnit, setMilesUnit] = useState(() => localStorage.getItem('opslog.distanceMiles') === '1');
+  const [region, setRegion] = useState<IaruRegion>(() => iaruRegion());
   const [clusterWorkedSameSlot, setClusterWorkedSameSlot] = useState(() => localStorage.getItem('opslog.clusterWorkedSameSlot') === '1');
   // Declared HERE and not in ClusterPanel: that renderer is called as a plain
   // function by the PANELS map, so it must stay hooks-free.
@@ -2065,6 +2071,8 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
     try { await SaveGridScopeSettings(next); } catch { /* the panel keeps the choice either way */ }
   };
   const [chaseGrids, setChaseGrids] = useState(false);
+  const [chasePotaOn, setChasePotaOn] = useState(() => localStorage.getItem('opslog.chasePota') !== '0');
+  const [chaseSotaOn, setChaseSotaOn] = useState(() => localStorage.getItem('opslog.chaseSota') !== '0');
   const [chaseNew, setChaseNew] = useState(false);
   const [spotTTL, setSpotTTL] = useState(0);
   const [spotTTLText, setSpotTTLText] = useState('0');
@@ -2198,10 +2206,17 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
         // buttons. See rotorPresetsLoaded for the belt to this brace.
         try { setRotorPresets((((await GetRotorPresets()) ?? []) as any)); setRotorPresetsLoaded(true); } catch {}
         try {
+          try { setListenPref(!!(await GetAudioMonitorPref())); } catch {}
           const rl: any = await GetRadios();
           setRadios(rl ?? []);
-          const act = (rl ?? []).find((r: any) => r.active) ?? (rl ?? [])[0];
+          // The backend is the only one who knows which radio is on the air —
-          setActiveRadioId(act?.id ?? '');
+          // the list entries carry no 'active' flag, and guessing the first
+          // meant reopening the panel showed Radio 1's name over the settings
+          // of whichever radio was actually selected.
+          let actId = '';
+          try { actId = (await ActiveRadioID()) ?? ''; } catch {}
+          if (!actId || !(rl ?? []).some((r: any) => r.id === actId)) actId = (rl ?? [])[0]?.id ?? '';
+          setActiveRadioId(actId);
         } catch { /* one radio, never listed — the panel works as it always did */ }
         try { setUltrabeam(await GetUltrabeamSettings() as any); } catch {}
         try { setAntgenius(await GetAntGeniusSettings() as any); } catch {}
@@ -3266,7 +3281,19 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
                 <Trash2 className="size-3.5" />
               </Button>
             </div>
+            {/* MY_RIG follows the radio, not the profile.
+                Operating conditions describe a PLAN — "on 20 m I use the beam
+                and the 7300" — while this is the fact of which rig is keying.
+                Empty leaves the old chain alone. */}
+            <div className="flex items-center gap-2">
+              <Label className="shrink-0 w-24">{t('cat.radioMyRig')}</Label>
+              <Input className="h-9 flex-1" placeholder={t('cat.radioMyRigPh')}
+                value={(radios.find((r: any) => r.id === activeRadio)?.my_rig) ?? ''}
+                onChange={(e) => setRadios((l) => l.map((r: any) => r.id === activeRadio ? { ...r, my_rig: e.target.value } : r))}
+                onBlur={() => { SaveRadios(radios as any).catch(() => {}); }} />
+            </div>
             <p className="text-[11px] text-muted-foreground">{t('cat.radioHint')}</p>
+            <p className="text-[11px] text-muted-foreground">{t('cat.radioMyRigHint')}</p>
           </div>
 
           <label className="flex items-center gap-2 text-sm cursor-pointer">
@@ -3602,6 +3629,22 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
                   <span className="block text-[11px] text-muted-foreground">{t('cat.icomNetAudioHint')}</span>
                 </span>
               </label>
+              {!!(catCfg as any).icom_net_audio && (
+                <label className="col-span-2 flex items-start gap-2 text-sm cursor-pointer pl-6">
+                  {/* The speaker choice, right where the stream is enabled. Same
+                      remembered preference as the console's speaker button —
+                      applied immediately, no save needed. */}
+                  <Checkbox checked={listenPref}
+                    onCheckedChange={(c) => {
+                      setListenPref(!!c);
+                      (c ? AudioStartMonitor() : Promise.resolve(AudioStopMonitor())).catch(() => setListenPref(!c));
+                    }} />
+                  <span>
+                    {t('cat.icomNetListen')}
+                    <span className="block text-[11px] text-muted-foreground">{t('cat.icomNetListenHint')}</span>
+                  </span>
+                </label>
+              )}
             </>
             )}
             {catCfg.backend === 'tci' && (
@@ -4853,7 +4896,7 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
                   <SelectItem value="yaesu">{t('wk.engYaesu')}</SelectItem>
                   <SelectItem value="kenwood">{t('wk.engKenwood')}</SelectItem>
                   <SelectItem value="flex">{t('wk.engFlex')}</SelectItem>
-                  <SelectItem value="tci" disabled>{t('wk.engTci')}</SelectItem>
+                  <SelectItem value="tci">{t('wk.engTci')}</SelectItem>
                 </SelectContent>
               </Select>
             </div>
@@ -4869,7 +4912,7 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
 
           {wk.engine === 'icom' ? (
             <>
-              {(!catCfg.enabled || catCfg.backend !== 'icom') && (
+              {(!catCfg.enabled || (catCfg.backend !== 'icom' && catCfg.backend !== 'icom-net')) && (
                 <p className="text-xs font-medium text-warning -mt-1 flex items-start gap-1.5">
                   <span aria-hidden>⚠</span>
                   <span>{t('wk.catWarnIcom', { backend: catCfg.enabled ? (catCfg.backend || 'none') : 'disabled' })}</span>
@@ -4914,6 +4957,22 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
                 </div>
               </div>
             </>
+          ) : wk.engine === 'tci' ? (
+            <>
+              {(!catCfg.enabled || catCfg.backend !== 'tci') && (
+                <p className="text-xs font-medium text-warning -mt-1 flex items-start gap-1.5">
+                  <span aria-hidden>⚠</span>
+                  <span>{t('wk.catWarnTci', { backend: catCfg.enabled ? (catCfg.backend || 'none') : 'disabled' })}</span>
+                </p>
+              )}
+              <p className="text-xs text-muted-foreground -mt-1">{t('wk.tciHint')}</p>
+              <div className="grid grid-cols-4 gap-3">
+                <div className="space-y-1">
+                  <Label>{t('wk.speed')}</Label>
+                  <Input type="number" min={5} max={60} value={wk.wpm} onChange={(e) => setWkField({ wpm: num(e.target.value, 25) })} className="font-mono" />
+                </div>
+              </div>
+            </>
           ) : wk.engine === 'flex' ? (
             <>
               {(!catCfg.enabled || catCfg.backend !== 'flex') && (
@@ -5283,11 +5342,6 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
               ))}
             </div>
           </div>
-          <p className="text-xs text-muted-foreground">
-            {t('clu.freeNodes')} <span className="font-mono">dxc.k0xm.net:7300</span>,{' '}
-            <span className="font-mono">dx.maritimecontestclub.net:7300</span>,{' '}
-            <span className="font-mono">w8avi.net:7300</span>.
-          </p>
           <label className="flex items-start gap-2 text-sm cursor-pointer border-t border-border/60 pt-3">
             <Checkbox checked={clusterWorkedSameSlot} className="mt-0.5"
               onCheckedChange={(c) => { const v = !!c; setClusterWorkedSameSlot(v); writeUiPref('opslog.clusterWorkedSameSlot', v ? '1' : '0'); }} />
@@ -5349,11 +5403,24 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
                   const n = parseInt(raw, 10);
                   if (Number.isFinite(n) && n > 0) SetSpotMax(Math.min(10000, n)).catch(() => {});
                 }} />
-              <span className="text-xs text-muted-foreground">{t('clu.spotMaxHint')}</span>
+
             </div>
           </div>
 
           <div className="border-t border-border/60 pt-3 space-y-2">
+            {/* Chase switches: off, the marker stops being TOLD, everywhere at
+                once — badge, colour, filter chip, reference column. A "new band
+                + new POTA" spot then reads NEW BAND alone. */}
+            <label className="flex items-center gap-2 text-sm cursor-pointer" title={t('clu.chasePotaHint')}>
+              <Checkbox checked={chasePotaOn}
+                onCheckedChange={(c) => { const v = !!c; setChasePotaOn(v); writeUiPref('opslog.chasePota', v ? '1' : '0'); }} />
+              {t('clu.chasePota')}
+            </label>
+            <label className="flex items-center gap-2 text-sm cursor-pointer" title={t('clu.chaseSotaHint')}>
+              <Checkbox checked={chaseSotaOn}
+                onCheckedChange={(c) => { const v = !!c; setChaseSotaOn(v); writeUiPref('opslog.chaseSota', v ? '1' : '0'); }} />
+              {t('clu.chaseSota')}
+            </label>
             <label className="flex items-start gap-2 text-sm cursor-pointer">
               <Checkbox checked={chaseGrids} className="mt-0.5"
                 onCheckedChange={(c) => { setChaseGrids(!!c); SetChaseNewGrids(!!c).catch(() => {}); }} />
@@ -5649,10 +5716,7 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
   function UDPIntegrationsPanelWrapper() {
     return (
       <>
-        <SectionHeader
+        <SectionHeader title={t('sec.udp')} />
-          title={t('sec.udp')}
-          hint={t('udp.hint')}
-        />
         <UDPIntegrationsPanel onError={(m) => setErr(m)} />
       </>
     );
@@ -6747,7 +6811,7 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
               useLocalLogbook(); // SQLite → default logbook file (clears any per-profile path)
             }}
           >
-            <SelectTrigger className="h-8 w-72"><SelectValue /></SelectTrigger>
+            <SelectTrigger className="h-8 w-72" title={t('gen.iaruHint')}><SelectValue /></SelectTrigger>
             <SelectContent>
               <SelectItem value="sqlite">{t('db.optSqlite')}</SelectItem>
               <SelectItem value="mysql">{t('db.optMysql')}</SelectItem>
@@ -6921,7 +6985,8 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
               size="sm"
               className="h-8"
               onClick={toggleMonitor}
-              disabled={!monitorOn && (!audioCfg.from_radio || fromRadioIsNetwork)}
+              disabled={!monitorOn && (!audioCfg.from_radio || fromRadioIsNetwork)
+                && !(catCfg.backend === 'icom-net' && (catCfg as any).icom_net_audio)}
               title={fromRadioIsNetwork ? t('aud.monitorNoTci') : t('aud.monitorTitle')}
             >
               {monitorOn ? t('aud.stopListening') : t('aud.listenRadio')}
@@ -7117,7 +7182,7 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
     const { lang, setLang, t } = useI18n();
     return (
       <>
-        <SectionHeader title={t('sec.general')} hint={t('gen.hint')} />
+        <SectionHeader title={t('sec.general')} />
         <div className="space-y-3 max-w-3xl">
           <div className="flex items-center gap-3">
             <Label className="text-sm w-40">{t('settings.language')}</Label>
@@ -7145,15 +7210,32 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
                  ['us', t('gen.dateUS'), '07-30-2026 14:25']] as [DateFormat, string, string][]).map(([code, label, sample]) => (
                 <button key={code} type="button" title={sample}
                   onClick={() => { setDateFormat(code); setDateFmtSel(code); }}
-                  className={cn('flex flex-col items-start px-3 py-1 text-sm font-medium border-l border-border first:border-l-0',
+                  className={cn('px-3 py-1.5 text-sm font-medium border-l border-border first:border-l-0',
                     dateFmtSel === code ? 'bg-primary text-primary-foreground' : 'bg-card text-muted-foreground hover:bg-muted')}>
                   {label}
-                  <span className="text-[10px] font-mono opacity-70">{sample}</span>
                 </button>
               ))}
             </div>
           </div>
 
+          <div className="flex items-center gap-2 text-sm">
+            {/* The IARU region drives the band edges and mode segments the band
+                maps draw — Region 2's 40 m runs to 7300, Region 1's stops at
+                7200 — and nothing else: spots and logging are region-blind. */}
+            <Label className="text-sm w-40 shrink-0">{t('gen.iaruRegion')}</Label>
+            <Select value={String(region)} onValueChange={(v) => {
+              const r = (v === '2' ? 2 : v === '3' ? 3 : 1) as IaruRegion;
+              setRegion(r); setIaruRegion(r);
+            }}>
+              <SelectTrigger className="h-8 w-72"><SelectValue /></SelectTrigger>
+              <SelectContent>
+                <SelectItem value="1">{t('gen.iaruR1')}</SelectItem>
+                <SelectItem value="2">{t('gen.iaruR2')}</SelectItem>
+                <SelectItem value="3">{t('gen.iaruR3')}</SelectItem>
+              </SelectContent>
+            </Select>
+          </div>
+
           <ThemeSelector />
 
           <label className="flex items-center gap-2 text-sm cursor-pointer">
@@ -7175,11 +7257,10 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
           {/* Super Check Partial / N+1 — downloads the community MASTER.SCP list and
               shows a two-column callsign helper (partial matches + one-edit calls). */}
           <div className="border-t border-border/60 pt-3 space-y-2">
-            <label className="flex items-center gap-2 text-sm cursor-pointer">
+            <label className="flex items-center gap-2 text-sm cursor-pointer" title={t('scp.settingsHint')}>
               <Checkbox checked={scp.enabled} disabled={scpBusy} onCheckedChange={(c) => toggleScp(!!c)} />
               {t('scp.enable')}
             </label>
-            <p className="text-[11px] text-muted-foreground">{t('scp.settingsHint')}</p>
             {scp.enabled && (
               <div className="flex items-center gap-3">
                 <Button variant="outline" size="sm" onClick={downloadScp} disabled={scpBusy}>
@@ -7207,11 +7288,18 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
           </label>
           <label className="flex items-center gap-2 text-sm cursor-pointer">
             <Checkbox checked={groupDigital} onCheckedChange={(c) => { const v = !!c; setGroupDigital(v); writeUiPref('opslog.groupDigitalSlots', v ? '1' : '0'); }} />
-            {t('gen.groupDigital')} <span className="text-xs text-muted-foreground">{t('gen.groupDigitalHint')}</span>
+            <span title={t('gen.groupDigitalHint')}>{t('gen.groupDigital')}</span>
+          </label>
+          <label className="flex items-center gap-2 text-sm cursor-pointer">
+            {/* Distances are computed in km everywhere and converted at display
+                time — see lib/units. Changing this repaints the columns that
+                already carry a distance; nothing stored moves. */}
+            <Checkbox checked={milesUnit} onCheckedChange={(c) => { const v = !!c; setMilesUnit(v); setUseMiles(v); }} />
+            {t('gen.miles')}
           </label>
           <label className="flex items-center gap-2 text-sm cursor-pointer">
             <Checkbox checked={checkUpdates} onCheckedChange={(c) => { const v = !!c; setCheckUpdates(v); writeUiPref('opslog.checkUpdates', v ? '1' : '0'); }} />
-            {t('gen.checkUpdates')} <span className="text-xs text-muted-foreground">{t('gen.checkUpdatesHint')}</span>
+            {t('gen.checkUpdates')}
           </label>
           <TelemetryToggle />
 
@@ -7274,12 +7362,7 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
                 }}
                 className="mt-0.5"
               />
-              <span>
+              <span title={t('gen.clubDesc')}>{t('gen.clubUse')}</span>
-                {t('gen.clubUse')}
-                <span className="block text-xs text-muted-foreground mt-0.5">
-                  {t('gen.clubDesc')}
-                </span>
-              </span>
             </label>
             <div className="flex items-center gap-3 pl-6">
               <Button variant="outline" size="sm" className="h-8" disabled={clubBusy}

frontend/src/components/UDPIntegrationsPanel.tsx

@@ -2,6 +2,7 @@ import React, { useCallback, useEffect, useState } from 'react';
 import { Plus, Trash2, Edit2, RefreshCcw, ArrowDownToLine, ArrowUpFromLine } from 'lucide-react';
 import {
   ListUDPIntegrations, SaveUDPIntegration, DeleteUDPIntegration, ReloadUDPIntegrations,
+  GetWsjtHighlight, SetWsjtHighlight, GetWsjtFollowMode, SetWsjtFollowMode,
 } from '../../wailsjs/go/main/App';
 import { Button } from '@/components/ui/button';
 import { Input } from '@/components/ui/input';
@@ -158,6 +159,12 @@ const TRIGGERS = [
 type Props = { onError: (msg: string) => void };
 
 export function UDPIntegrationsPanel({ onError }: Props) {
+  const [highlightOn, setHighlightOn] = useState(false);
+  const [followMode, setFollowMode] = useState(true);
+  useEffect(() => {
+    GetWsjtHighlight().then((v) => setHighlightOn(!!v)).catch(() => {});
+    GetWsjtFollowMode().then((v) => setFollowMode(!!v)).catch(() => {});
+  }, []);
   const { t } = useI18n();
   const [items, setItems] = useState<UDPConfig[]>([]);
   const [loading, setLoading] = useState(true);
@@ -229,10 +236,24 @@ export function UDPIntegrationsPanel({ onError }: Props) {
 
   return (
     <div className="space-y-4">
-      <div className="text-[11px] text-muted-foreground max-w-2xl leading-relaxed">
+      {/* Log-aware colours in WSJT-X / JTDX's own window — lives HERE because
-        {t('udpp.intro')}
+          this panel is where the WSJT-X link is configured. */}
-      </div>
+      <label className="flex items-start gap-2 text-sm cursor-pointer max-w-2xl">
-
+        <Checkbox checked={highlightOn}
+          onCheckedChange={(c) => { setHighlightOn(!!c); void SetWsjtHighlight(!!c); }} />
+        <span>
+          {t('udpp.highlight')}
+          <span className="block text-[11px] text-muted-foreground">{t('udpp.highlightHint')}</span>
+        </span>
+      </label>
+      <label className="flex items-start gap-2 text-sm cursor-pointer max-w-2xl">
+        <Checkbox checked={followMode}
+          onCheckedChange={(c) => { setFollowMode(!!c); void SetWsjtFollowMode(!!c); }} />
+        <span>
+          {t('udpp.followMode')}
+          <span className="block text-[11px] text-muted-foreground">{t('udpp.followModeHint')}</span>
+        </span>
+      </label>
       <Section
         title={t('udpp.inboundTitle')}
         icon={<ArrowDownToLine className="size-4" />}

frontend/src/components/WatchlistTab.tsx

@@ -0,0 +1,420 @@
+// Watchlist — the DXHunter concept as an OpsLog tab.
+//
+// One card per watched callsign (or prefix), the live spots that match it
+// underneath, and the two questions an operator actually asks answered on every
+// line: is this slot still NEEDED, and what would it be worth (the same NEW
+// DXCC / band / mode / slot badges the cluster shows, resolved from the same
+// index). A CONTEST entry is judged against the current UTC day — at midnight
+// everything reads "work today" again; the boundary lives in the backend query,
+// so there is nothing to reset.
+//
+// The design is DXHunter's — the layout, the badges, the wording — repainted in
+// the app's theme tokens rather than its hard-coded slate/pink.
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { Eye, Plus, Trash2, Bell, BellOff, Trophy, Search } from 'lucide-react';
+import { Button } from '@/components/ui/button';
+import { Input } from '@/components/ui/input';
+import { Checkbox } from '@/components/ui/checkbox';
+import { cn } from '@/lib/utils';
+import { useI18n } from '@/lib/i18n';
+import {
+  WatchlistEntries, WatchlistAdd, WatchlistRemove, WatchlistSetNotify,
+  WatchlistSetContest, WatchlistWorkedSlots,
+  GetWatchlistContestPattern, SetWatchlistContestPattern, OpenExternalURL,
+} from '../../wailsjs/go/main/App';
+import { EventsOn } from '../../wailsjs/runtime/runtime';
+import type { ClusterSpot, SpotStatusEntry } from '@/components/ClusterGrid';
+import { inferSpotMode, spotStatusKey } from '@/lib/spot';
+
+interface WLEntry {
+  callsign: string; lastSeenStr: string; addedAt: string; spotCount: number;
+  isContest: boolean; notify: boolean;
+  isExpedition: boolean; clubLogQSOs24h: number; clubLogTotalQSOs: number;
+  clubLogHasOQRS: boolean; clubLogLiveStream: boolean;
+}
+
+interface Props {
+  spots: ClusterSpot[];
+  spotStatus: Record<string, SpotStatusEntry>;
+  onSpotSelect?: (s: ClusterSpot) => void;
+  onSpotClick?: (s: ClusterSpot) => void;
+}
+
+// A spot is ON AIR for the badge while its last sighting is this fresh.
+const ON_AIR_MS = 10 * 60 * 1000;
+
+// Exact unless the entry carries a trailing * — the same rule the backend's
+// Match applies to the live stream, mirrored so the tab and the alerts can
+// never disagree about what an entry covers.
+function matchesEntry(call: string, pattern: string): boolean {
+  const c = call.toUpperCase();
+  if (pattern.endsWith('*')) {
+    const p = pattern.slice(0, -1);
+    return p !== '' && c.startsWith(p);
+  }
+  return c === pattern;
+}
+
+export function WatchlistTab({ spots, spotStatus, onSpotSelect, onSpotClick }: Props) {
+  const { t } = useI18n();
+  const [entries, setEntries] = useState<WLEntry[]>([]);
+  const [addCall, setAddCall] = useState('');
+  const [addContest, setAddContest] = useState(false);
+  const [search, setSearch] = useState('');
+  // The filters survive leaving the tab: the component unmounts on every tab
+  // switch, and filters that reset each time are filters nobody trusts.
+  const [neededOnly, setNeededOnlyRaw] = useState(() => localStorage.getItem('opslog.wlNeededOnly') === '1');
+  const [activeOnly, setActiveOnlyRaw] = useState(() => localStorage.getItem('opslog.wlActiveOnly') === '1');
+  const [family, setFamilyRaw] = useState<'all' | 'normal' | 'contest'>(() => {
+    const v = localStorage.getItem('opslog.wlFamily');
+    return v === 'normal' || v === 'contest' ? v : 'all';
+  });
+  const setNeededOnly = (f: (v: boolean) => boolean) => setNeededOnlyRaw((v) => { const nv = f(v); try { localStorage.setItem('opslog.wlNeededOnly', nv ? '1' : '0'); } catch {} return nv; });
+  const setActiveOnly = (f: (v: boolean) => boolean) => setActiveOnlyRaw((v) => { const nv = f(v); try { localStorage.setItem('opslog.wlActiveOnly', nv ? '1' : '0'); } catch {} return nv; });
+  const setFamily = (v: 'all' | 'normal' | 'contest') => { setFamilyRaw(v); try { localStorage.setItem('opslog.wlFamily', v); } catch {} };
+  // Mode filter — DXHunter's "All Modes" select. DIGI matches the digital class
+  // (FT8, FT4, a generic DATA spot…), the named modes match exactly.
+  const [modeFilter, setModeFilterRaw] = useState(() => localStorage.getItem('opslog.wlMode') || 'ALL');
+  const setModeFilter = (v: string) => { setModeFilterRaw(v); try { localStorage.setItem('opslog.wlMode', v); } catch {} };
+  const modeMatches = (s2: ClusterSpot): boolean => {
+    if (modeFilter === 'ALL') return true;
+    const m = (inferSpotMode(s2.comment ?? '', s2.freq_hz) || '').toUpperCase();
+    if (modeFilter === 'DIGI') return !['', 'CW', 'SSB', 'USB', 'LSB', 'FM', 'AM'].includes(m);
+    if (modeFilter === 'SSB') return m === 'SSB' || m === 'USB' || m === 'LSB';
+    return m === modeFilter;
+  };
+  const [error, setError] = useState('');
+  // A quiet confirmation under the toolbar; both messages clear themselves —
+  // a stale "added" from ten minutes ago reads as a fresh one.
+  const [notice, setNotice] = useState('');
+  const noticeTimer = useRef<number | undefined>(undefined);
+  const flash = (msg: string, isError: boolean) => {
+    if (noticeTimer.current) window.clearTimeout(noticeTimer.current);
+    setError(isError ? msg : '');
+    setNotice(isError ? '' : msg);
+    noticeTimer.current = window.setTimeout(() => { setError(''); setNotice(''); }, 4000) as unknown as number;
+  };
+
+  // worked answer per "call|band|modeclass|contest" key.
+  const [worked, setWorked] = useState<Record<string, boolean>>({});
+
+  const refresh = useCallback(async () => {
+    try { setEntries(((await WatchlistEntries()) ?? []) as any as WLEntry[]); }
+    catch (e: any) { setError(String(e?.message ?? e)); }
+  }, []);
+  // Refreshed on mount, when the backend auto-adds (event), and on a slow tick
+  // so last-seen and the spot counters stay honest while the tab sits open.
+  useEffect(() => {
+    void refresh();
+    const off = EventsOn('watchlist:changed', () => { void refresh(); });
+    const id = window.setInterval(() => { void refresh(); }, 30_000);
+    return () => { off(); window.clearInterval(id); };
+  }, [refresh]);
+  // The auto-contest pattern (DXHunter's contest_prefix): spots whose call
+  // contains it are added as contest entries by the backend.
+  const [pattern, setPattern] = useState('');
+  useEffect(() => { GetWatchlistContestPattern().then((p: string) => setPattern(p ?? '')).catch(() => {}); }, []);
+
+  // Live spots per entry — prefix-matched, newest first, deduped per band+mode
+  // (one line per slot; the freshest spot represents it).
+  const spotsFor = useMemo(() => {
+    const map = new Map<string, ClusterSpot[]>();
+    for (const e of entries) map.set(e.callsign, []);
+    for (const s of spots) {
+      for (const e of entries) {
+        if (matchesEntry(s.dx_call ?? '', e.callsign)) { map.get(e.callsign)!.push(s); break; }
+      }
+    }
+    for (const [k, list] of map) {
+      const seen = new Set<string>();
+      map.set(k, list.filter((s) => {
+        const key = `${(s.band ?? '')}|${inferSpotMode(s.comment ?? '', s.freq_hz)}|${s.dx_call}`;
+        if (seen.has(key)) return false;
+        seen.add(key);
+        return true;
+      }));
+    }
+    return map;
+  }, [spots, entries]);
+
+  // The worked answers, refreshed when the visible slots change. Debounced: a
+  // spot burst must cost one round trip, not one per spot.
+  const queryTimer = useRef<number | undefined>(undefined);
+  useEffect(() => {
+    if (queryTimer.current) window.clearTimeout(queryTimer.current);
+    queryTimer.current = window.setTimeout(async () => {
+      const queries: { call: string; band: string; mode: string; contest: boolean }[] = [];
+      const keys: string[] = [];
+      for (const e of entries) {
+        for (const s of spotsFor.get(e.callsign) ?? []) {
+          const mode = inferSpotMode(s.comment ?? '', s.freq_hz) || '';
+          queries.push({ call: s.dx_call, band: s.band ?? '', mode, contest: e.isContest });
+          keys.push(`${s.dx_call}|${s.band ?? ''}|${mode}|${e.isContest ? 1 : 0}`);
+        }
+      }
+      if (queries.length === 0) { setWorked({}); return; }
+      try {
+        const res: boolean[] = (await WatchlistWorkedSlots(queries as any)) ?? [];
+        // MERGED, not replaced: replacing made every already-answered key
+        // momentarily unknown on each refresh, which re-hid settled lines.
+        setWorked((prev) => {
+          const next = { ...prev };
+          keys.forEach((k, i) => { next[k] = !!res[i]; });
+          return next;
+        });
+      } catch { /* the badges just stay conservative */ }
+    }, 150) as unknown as number;
+    return () => { if (queryTimer.current) window.clearTimeout(queryTimer.current); };
+  }, [spotsFor, entries]);
+
+  const wkey = (e: WLEntry, s: ClusterSpot) =>
+    `${s.dx_call}|${s.band ?? ''}|${inferSpotMode(s.comment ?? '', s.freq_hz) || ''}|${e.isContest ? 1 : 0}`;
+  const workedFor = (e: WLEntry, s: ClusterSpot): boolean => worked[wkey(e, s)] ?? false;
+  // A spot whose verdict has not come back yet is NOT drawn. Showing it as
+  // Needed and withdrawing it half a second later made the list twitch on
+  // every burst — and nobody needs a spot 400 ms early, they need it settled.
+  const settled = (e: WLEntry, s: ClusterSpot): boolean => wkey(e, s) in worked;
+
+  const add = async () => {
+    const c = addCall.trim().toUpperCase();
+    if (!c) return;
+    try {
+      await WatchlistAdd(c, addContest);
+      setAddCall('');
+      flash(t(addContest ? 'wl.addedContest' : 'wl.added', { call: c }), false);
+      await refresh();
+    } catch (e: any) { flash(String(e?.message ?? e), true); }
+  };
+
+  // One click, like the bell and the trophy beside it: removing a watchlist
+  // entry is cheap to undo (type it again), so it does not earn a confirmation
+  // the other two buttons do not have.
+  const remove = async (call: string) => {
+    try { await WatchlistRemove(call); flash(t('wl.removed', { call }), false); await refresh(); }
+    catch (e: any) { flash(String(e?.message ?? e), true); }
+  };
+
+  const isOnAir = (e: WLEntry): boolean =>
+    (spotsFor.get(e.callsign) ?? []).some((s) => {
+      const ts = Date.parse(String((s as any).received_at ?? ''));
+      return ts > 0 && Date.now() - ts < ON_AIR_MS;
+    });
+
+  const shown = entries.filter((e) => {
+    if (family === 'normal' && e.isContest) return false;
+    if (family === 'contest' && !e.isContest) return false;
+    if (search && !e.callsign.includes(search.trim().toUpperCase())) return false;
+    const list = (spotsFor.get(e.callsign) ?? []).filter(modeMatches).filter((s2) => settled(e, s2));
+    if (activeOnly && list.length === 0) return false;
+    if (neededOnly && !list.some((s2) => !workedFor(e, s2))) return false;
+    return true;
+  });
+
+  const counters = useMemo(() => {
+    let active = 0, needed = 0;
+    for (const e of entries) {
+      const list = (spotsFor.get(e.callsign) ?? []).filter(modeMatches).filter((s2) => settled(e, s2));
+      if (list.length > 0) active++;
+      if (list.some((s2) => !workedFor(e, s2))) needed++;
+    }
+    return { total: entries.length, active, needed };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [entries, spotsFor, worked, modeFilter]);
+
+  // The cluster's own badge for a spot, read from the shared status index.
+  const dxccBadge = (s: ClusterSpot): { label: string; color: string } | null => {
+    const st = spotStatus[spotStatusKey(s.dx_call, s.band ?? '', s.comment ?? '', s.freq_hz)];
+    switch (st?.status) {
+      case 'new': return { label: t('wl.newDxcc'), color: 'var(--danger)' };
+      case 'new-band-mode': return { label: t('clg2.newBandMode'), color: 'var(--danger)' };
+      case 'new-band': return { label: t('clg2.newBand'), color: 'var(--warning)' };
+      case 'new-mode': return { label: t('clg2.newMode'), color: 'var(--caution)' };
+      case 'new-slot': return { label: t('clg2.newSlot'), color: '#5AC8FA' };
+      default: return null;
+    }
+  };
+
+  const chip = (color: string, text: string, extra?: string) => (
+    <span className={cn('px-1.5 py-0.5 rounded text-[10px] font-bold border', extra)}
+      style={{ color, borderColor: `color-mix(in srgb, ${color} 40%, transparent)`, background: `color-mix(in srgb, ${color} 12%, transparent)` }}>
+      {text}
+    </span>
+  );
+
+  return (
+    // Capped and centred: a card is a reading surface, and callsign-to-badge
+    // lines stretched across a 34-inch window are not readable, they are long.
+    <div className="flex flex-col min-h-0 flex-1 gap-2 p-2 w-full max-w-5xl mx-auto">
+      {/* Header: the counters alone, centred — they are the tab's headline.
+          Everything one INTERACTS with lives on the second row. */}
+      <div className="flex items-center justify-center gap-2.5 text-xs text-muted-foreground">
+        <Eye className="size-4 text-primary shrink-0" />
+        <span className="flex items-center gap-1.5">{t('wl.cTotal')}
+          <b className="px-2 py-0.5 rounded bg-muted text-foreground">{counters.total}</b></span>
+        <span className="opacity-40">|</span>
+        <span className="flex items-center gap-1.5">{t('wl.cActive')}
+          <b className="px-2 py-0.5 rounded text-info border border-info/30 bg-info/10">{counters.active}</b></span>
+        <span className="opacity-40">|</span>
+        <span className="flex items-center gap-1.5">{t('wl.cNeeded')}
+          <b className={cn('px-2 py-0.5 rounded border', counters.needed > 0
+            ? 'text-warning border-warning/40 bg-warning/10'
+            : 'text-muted-foreground border-border bg-muted/40')}>{counters.needed}</b></span>
+      </div>
+      {/* toolbar */}
+      <div className="flex items-start justify-between gap-x-3 gap-y-1.5 flex-wrap">
+        <div className="flex items-center gap-2 shrink-0">
+        <Input className="h-8 w-40 font-mono placeholder:font-sans placeholder:normal-case" placeholder={t('wl.addPh')} value={addCall}
+          onChange={(e) => setAddCall(e.target.value.toUpperCase())}
+          onKeyDown={(e) => { if (e.key === 'Enter') void add(); }} />
+        <label className="flex items-center gap-1.5 text-xs cursor-pointer" title={t('wl.contestHint')}>
+          <Checkbox checked={addContest} onCheckedChange={(c) => setAddContest(!!c)} />
+          <Trophy className="size-3.5 text-warning" /> {t('wl.addAsContest')}
+        </label>
+        <Button size="sm" className="h-8" onClick={() => void add()} disabled={!addCall.trim()}>
+          <Plus className="size-3.5" /> {t('wl.add')}
+        </Button>
+        <Input className="h-8 w-28 font-mono placeholder:font-sans placeholder:normal-case" placeholder={t('wl.patternPh')}
+          title={t('wl.patternHint')}
+          value={pattern}
+          onChange={(e) => setPattern(e.target.value.toUpperCase())}
+          onBlur={() => { void SetWatchlistContestPattern(pattern.trim()); }} />
+        </div>
+        <div className="flex items-center gap-2 shrink-0">
+        <div className="relative">
+          <Search className="size-3.5 absolute left-2 top-1/2 -translate-y-1/2 text-muted-foreground" />
+          <Input className="h-8 w-28 pl-7 text-sm" placeholder={t('wl.searchPh')} value={search}
+            onChange={(e) => setSearch(e.target.value)} />
+        </div>
+        {/* families kept together, told apart — per review of the DXHunter port,
+            no global contest mode: each entry carries its own rule. */}
+        <div className="inline-flex rounded-md border border-border overflow-hidden text-xs">
+          {([['all', t('wl.famAll')], ['normal', t('wl.famNormal')], ['contest', t('wl.famContest')]] as const).map(([k, label]) => (
+            <button key={k} type="button" onClick={() => setFamily(k)}
+              className={cn('px-2 py-1 border-l border-border first:border-l-0',
+                family === k ? 'bg-accent font-medium' : 'text-muted-foreground hover:bg-accent/50')}>
+              {label}
+            </button>
+          ))}
+        </div>
+        <select value={modeFilter} onChange={(e) => setModeFilter(e.target.value)}
+          title={t('wl.modeFilter')}
+          className="h-7 px-1.5 rounded-md border border-border bg-background text-xs text-foreground">
+          {['ALL', 'CW', 'SSB', 'FT8', 'FT4', 'RTTY', 'DIGI'].map((m) => (
+            <option key={m} value={m}>{m === 'ALL' ? t('wl.allModes') : m}</option>
+          ))}
+        </select>
+        <button type="button" onClick={() => setActiveOnly((v) => !v)}
+          className={cn('px-2 py-1 rounded-md border text-xs', activeOnly ? 'bg-accent border-border font-medium' : 'border-border text-muted-foreground hover:bg-accent/50')}>
+          {t('wl.activeOnly')}
+        </button>
+        <button type="button" onClick={() => setNeededOnly((v) => !v)}
+          className={cn('px-2 py-1 rounded-md border text-xs', neededOnly ? 'bg-accent border-border font-medium' : 'border-border text-muted-foreground hover:bg-accent/50')}>
+          {t('wl.neededOnly')}
+        </button>
+        </div>
+      </div>
+      {error && <div className="text-xs text-danger px-1">{error}</div>}
+      {notice && <div className="text-xs text-success px-1">{notice}</div>}
+
+      {/* cards */}
+      <div className="flex-1 min-h-0 overflow-y-auto space-y-2 pr-1">
+        {shown.length === 0 ? (
+          <div className="text-sm text-muted-foreground text-center pt-16 max-w-md mx-auto leading-relaxed">
+            {entries.length === 0 ? t('wl.empty') : t('wl.noneMatch')}
+          </div>
+        ) : shown.map((e) => {
+          const all = (spotsFor.get(e.callsign) ?? []).filter(modeMatches).filter((s2) => settled(e, s2));
+          const needed = all.filter((s) => !workedFor(e, s)).length;
+          // Needed-only hides the worked LINES as well as the all-worked cards:
+          // a filter that says needed and still lists five green Worked rows is
+          // answering a different question than the one asked.
+          const list = neededOnly ? all.filter((s) => !workedFor(e, s)) : all;
+          return (
+            <div key={e.callsign}
+              className={cn('rounded-lg border bg-card/70 p-3 transition-colors hover:bg-accent/20',
+                needed > 0 ? 'border-warning/40' : 'border-border/70',
+                e.isContest && 'border-l-4 border-l-warning')}>
+              <div className="flex items-center gap-2 flex-wrap">
+                <span className="text-lg font-bold font-mono" style={{ color: '#f472b6' }}>{e.callsign}</span>
+                {isOnAir(e) && chip('var(--danger)', t('wl.onAir'), 'animate-pulse')}
+                {e.isContest && (
+                  <span className="inline-flex items-center gap-1 px-1.5 py-0.5 rounded text-[10px] font-bold bg-warning-muted text-warning-muted-foreground border border-warning-border"
+                    title={t('wl.contestHint')}>
+                    <Trophy className="size-3" /> {t('wl.contest')}
+                  </span>
+                )}
+                {e.isExpedition && chip('var(--chart-5)', '⚡ ' + t('wl.expedition'))}
+                {e.clubLogTotalQSOs > 0 && <span className="text-[11px] text-muted-foreground">{e.clubLogTotalQSOs.toLocaleString()} QSOs{e.clubLogQSOs24h > 0 ? ` · ${e.clubLogQSOs24h}/24h` : ''}</span>}
+                {e.clubLogHasOQRS && chip('var(--success)', 'OQRS')}
+                {e.clubLogLiveStream && (
+                  <a href="#" onClick={(ev) => { ev.preventDefault(); void OpenExternalURL(`https://clublog.org/livestream/${e.callsign.replace('*', '')}`); }}
+                    className="px-1.5 py-0.5 rounded text-[10px] font-bold border text-info border-info/40 bg-info/10 hover:bg-info/20">Live</a>
+                )}
+                {list.length > 0 && (needed > 0
+                  ? chip('var(--warning)', e.isContest ? t('wl.nToday', { n: needed }) : t('wl.nNeeded', { n: needed }))
+                  : chip('var(--success)', e.isContest ? t('wl.workedToday') : t('wl.allWorked')))}
+                {e.lastSeenStr && e.lastSeenStr !== 'Never' && (
+                  <span className="text-[11px] text-muted-foreground">· {e.lastSeenStr}</span>
+                )}
+                {e.spotCount > 0 && (
+                  <span className="text-[11px] text-muted-foreground/70">· {t('wl.totalSpots', { n: e.spotCount })}</span>
+                )}
+                <div className="flex-1" />
+                <button type="button" title={t('wl.toggleContest')}
+                  onClick={() => void WatchlistSetContest(e.callsign, !e.isContest).then(refresh)}
+                  className={cn('p-1 rounded hover:bg-muted', e.isContest ? 'text-warning' : 'text-muted-foreground/40')}>
+                  <Trophy className="size-3.5" />
+                </button>
+                <button type="button" title={e.notify ? t('wl.notifyOff') : t('wl.notifyOn')}
+                  onClick={() => void WatchlistSetNotify(e.callsign, !e.notify).then(refresh)}
+                  className={cn('p-1 rounded hover:bg-muted', e.notify ? 'text-warning' : 'text-muted-foreground/40')}>
+                  {e.notify ? <Bell className="size-3.5" /> : <BellOff className="size-3.5" />}
+                </button>
+                <button type="button" title={t('wl.remove')}
+                  onClick={() => void remove(e.callsign)}
+                  className="p-1 rounded hover:bg-muted text-muted-foreground/40 hover:text-danger">
+                  <Trash2 className="size-3.5" />
+                </button>
+              </div>
+
+              {list.length > 0 ? (
+                <div className="mt-2 space-y-1 max-h-52 overflow-y-auto">
+                  {list.slice(0, 12).map((s, i) => {
+                    const done = workedFor(e, s);
+                    const badge = dxccBadge(s);
+                    const mode = inferSpotMode(s.comment ?? '', s.freq_hz);
+                    return (
+                      <button key={i} type="button"
+                        onClick={() => onSpotSelect?.(s)}
+                        onDoubleClick={() => onSpotClick?.(s)}
+                        title={t('wl.spotTip')}
+                        className={cn('w-full flex items-center gap-2 px-2 py-1.5 rounded text-[11px] bg-muted/25 hover:bg-muted/70 transition-colors text-left',
+                          !done && 'border-l-[3px] border-warning')}>
+                        {done && <span className='font-bold shrink-0 text-success'>✓</span>}
+                        <span className="font-mono font-bold text-info shrink-0">{s.dx_call}</span>
+                        <span className="text-muted-foreground truncate flex-1 min-w-0 max-w-56">{(s as any).country ?? ''}</span>
+                        <span className="px-1.5 rounded bg-muted shrink-0">{s.band}</span>
+                        {mode && <span className="px-1.5 rounded shrink-0" style={{ color: 'var(--chart-5)', background: 'color-mix(in srgb, var(--chart-5) 12%, transparent)' }}>{mode}</span>}
+                        <span className="font-mono text-muted-foreground shrink-0">{(s.freq_hz / 1e6).toFixed(4)}</span>
+                        {badge && chip(badge.color, badge.label)}
+                        <div className="flex-1" />
+                        {done
+                          ? chip('var(--success)', e.isContest ? t('wl.todayOk') : t('wl.worked'))
+                          : chip('var(--warning)', e.isContest ? t('wl.workToday') : t('wl.needed'))}
+                        <span className="text-muted-foreground/70 shrink-0">{s.time_utc ?? ''}</span>
+                      </button>
+                    );
+                  })}
+                </div>
+              ) : (
+                <div className="mt-2 text-[11px] text-muted-foreground text-center py-1.5 bg-muted/30 rounded">
+                  {t('wl.noSpots')}
+                </div>
+              )}
+            </div>
+          );
+        })}
+      </div>
+    </div>
+  );
+}

frontend/src/components/WinkeyerPanel.tsx

@@ -26,7 +26,7 @@ interface Props {
   wpm: number;
   macros: WKMacro[];
   sent: string; // text echoed back by the keyer as it transmits
-  source: 'winkeyer' | 'icom' | 'flex' | 'yaesu' | 'kenwood'; // CW output engine (chosen in Settings → CW Keyer)
+  source: 'winkeyer' | 'icom' | 'flex' | 'yaesu' | 'kenwood' | 'tci'; // CW output engine (chosen in Settings → CW Keyer)
   breakIn?: number;                          // Icom CW break-in: 0=OFF, 1=SEMI, 2=FULL
   onSetBreakIn?: (mode: number) => void;
   onSelectPort: (p: string) => void;
@@ -109,16 +109,16 @@ export function WinkeyerPanel({
         <Radio className="size-4 text-primary shrink-0" />
         {/* CW output engine (chosen in Settings → CW Keyer). */}
         <span className="text-xs font-semibold uppercase tracking-wider text-muted-foreground shrink-0">
-          {source === 'icom' ? 'Icom CW' : source === 'flex' ? 'Flex CWX' : source === 'yaesu' ? 'Yaesu CW' : source === 'kenwood' ? 'Kenwood CW' : 'WinKeyer'}
+          {source === 'icom' ? 'Icom CW' : source === 'flex' ? 'Flex CWX' : source === 'yaesu' ? 'Yaesu CW' : source === 'kenwood' ? 'Kenwood CW' : source === 'tci' ? 'TCI CW' : 'WinKeyer'}
         </span>
         <span className={cn('size-2 rounded-full', connected ? (status.busy ? 'bg-warning animate-pulse' : 'bg-success') : 'bg-muted-foreground/40')}
           title={connected ? (status.busy ? t('wkp.sending') : t('wkp.connectedV', { version: status.version })) : t('wkp.disconnected')} />
         <div className="flex-1" />
-        {source === 'icom' || source === 'flex' || source === 'yaesu' || source === 'kenwood' ? (
+        {source === 'icom' || source === 'flex' || source === 'yaesu' || source === 'kenwood' || source === 'tci' ? (
           <span className="text-[11px] font-medium text-muted-foreground">
             {source === 'flex'
               ? (connected ? t('wkp.cwxReady') : t('wkp.cwxOffline'))
-              : source === 'yaesu' || source === 'kenwood'
+              : source === 'yaesu' || source === 'kenwood' || source === 'tci'
                 ? (connected ? t('wkp.rigReady') : t('wkp.rigOffline'))
                 : (connected ? t('wkp.civReady') : t('wkp.civOffline'))}
           </span>

frontend/src/lib/bandplan.ts

@@ -0,0 +1,113 @@
+// IARU band plans, by region.
+//
+// The band maps used to carry one hard-coded table — Region 1's — so a US or
+// Australian operator saw 40 m stop at 7200 while stations sat spotted at 7250,
+// and the SSB wash started 25 kHz early. The region is a station-level fact the
+// operator states once (Settings → General); everything drawing a band edge or
+// a mode segment reads it from here.
+//
+// The tables are deliberately coarse: a band map's wash is CONTEXT, not a
+// regulatory chart. Only the segments that differ between regions in ways an
+// operator notices are split out; national fine print (US licence classes,
+// beacon slots) does not belong in a background tint.
+import { writeUiPref } from '@/lib/uiPref';
+
+export type IaruRegion = 1 | 2 | 3;
+export const KEY_IARU_REGION = 'opslog.iaruRegion';
+
+export function iaruRegion(): IaruRegion {
+  try {
+    const v = localStorage.getItem(KEY_IARU_REGION);
+    return v === '2' ? 2 : v === '3' ? 3 : 1;
+  } catch { return 1; }
+}
+
+export function setIaruRegion(r: IaruRegion): void {
+  writeUiPref(KEY_IARU_REGION, String(r));
+  listeners.forEach((l) => l());
+}
+
+// The band maps capture the plan inside their render, so a change must reach
+// them the way the distance unit reaches the grids.
+const listeners = new Set<() => void>();
+export function subscribeIaruRegion(fn: () => void): () => void {
+  listeners.add(fn);
+  return () => { listeners.delete(fn); };
+}
+
+export type SegMode = 'cw' | 'digi' | 'phone';
+type Seg = [number, number, SegMode];
+
+interface Plan {
+  ranges: Record<string, [number, number]>;
+  segments: Record<string, Seg[]>;
+}
+
+// Region 1 — Europe / Africa / Middle East / northern Asia. The baseline the
+// other two override.
+const R1: Plan = {
+  ranges: {
+    '160m': [1800, 2000], '80m': [3500, 3800], '60m': [5350, 5450],
+    '40m': [7000, 7200], '30m': [10100, 10150], '20m': [14000, 14350],
+    '17m': [18068, 18168], '15m': [21000, 21450], '12m': [24890, 24990],
+    '10m': [28000, 29700], '6m': [50000, 50500], '4m': [70000, 70500],
+    '2m': [144000, 146000], '70cm': [430000, 440000],
+  },
+  segments: {
+    '160m': [[1800, 1838, 'cw'], [1838, 1840, 'digi'], [1840, 2000, 'phone']],
+    '80m': [[3500, 3580, 'cw'], [3580, 3600, 'digi'], [3600, 3800, 'phone']],
+    '60m': [[5350, 5450, 'phone']],
+    '40m': [[7000, 7040, 'cw'], [7040, 7100, 'digi'], [7100, 7200, 'phone']],
+    '30m': [[10100, 10130, 'cw'], [10130, 10150, 'digi']],
+    '20m': [[14000, 14070, 'cw'], [14070, 14100, 'digi'], [14100, 14350, 'phone']],
+    '17m': [[18068, 18095, 'cw'], [18095, 18110, 'digi'], [18110, 18168, 'phone']],
+    '15m': [[21000, 21070, 'cw'], [21070, 21150, 'digi'], [21150, 21450, 'phone']],
+    '12m': [[24890, 24915, 'cw'], [24915, 24940, 'digi'], [24940, 24990, 'phone']],
+    '10m': [[28000, 28070, 'cw'], [28070, 28300, 'digi'], [28300, 29700, 'phone']],
+    '6m': [[50000, 50100, 'cw'], [50100, 50500, 'phone']],
+  },
+};
+
+// Region 2 — the Americas. 80 m runs to 4000 and 40 m to 7300, with phone from
+// 7125 (the whole point of asking the region: a KP4 ragchew on 7250 must not
+// hang past the top of the map).
+const R2: Plan = {
+  ranges: {
+    ...R1.ranges,
+    '80m': [3500, 4000], '40m': [7000, 7300],
+    '6m': [50000, 54000], '2m': [144000, 148000], '70cm': [420000, 450000],
+  },
+  segments: {
+    ...R1.segments,
+    '80m': [[3500, 3570, 'cw'], [3570, 3600, 'digi'], [3600, 4000, 'phone']],
+    '40m': [[7000, 7040, 'cw'], [7040, 7125, 'digi'], [7125, 7300, 'phone']],
+    '6m': [[50000, 50100, 'cw'], [50100, 54000, 'phone']],
+  },
+};
+
+// Region 3 — Asia-Pacific. 80 m to 3900; 40 m as Region 1's shape.
+const R3: Plan = {
+  ranges: {
+    ...R1.ranges,
+    '80m': [3500, 3900],
+    '6m': [50000, 54000], '2m': [144000, 148000], '70cm': [430000, 450000],
+  },
+  segments: {
+    ...R1.segments,
+    '80m': [[3500, 3535, 'cw'], [3535, 3600, 'digi'], [3600, 3900, 'phone']],
+    '6m': [[50000, 50100, 'cw'], [50100, 54000, 'phone']],
+  },
+};
+
+function plan(): Plan {
+  const r = iaruRegion();
+  return r === 2 ? R2 : r === 3 ? R3 : R1;
+}
+
+export function bandRange(band: string): [number, number] | undefined {
+  return plan().ranges[band];
+}
+
+export function bandSegments(band: string): Seg[] {
+  return plan().segments[band] ?? [];
+}

frontend/src/lib/matrixColors.ts

@@ -14,9 +14,11 @@ export type MatrixColors = {
   entity_worked: string;
   not_worked: string;
   current_entry: string;
+  mark_worked: string;
+  mark_confirmed: string;
 };
 
-// The six settings fields and the CSS custom property each one drives. Also the
+// The settings fields and the CSS custom property each one drives. Also the
 // display order — the same order the legend under the matrix reads in, so the
 // settings panel and the grid can never disagree about which green is which.
 export const MATRIX_VARS: { key: keyof Omit<MatrixColors, 'enabled'>; cssVar: string; label: string }[] = [
@@ -26,12 +28,15 @@ export const MATRIX_VARS: { key: keyof Omit<MatrixColors, 'enabled'>; cssVar: st
   { key: 'entity_worked',    cssVar: '--mx-dx-work',   label: 'mx.dxWork' },
   { key: 'not_worked',       cssVar: '--mx-none',      label: 'mx.none' },
   { key: 'current_entry',    cssVar: '--mx-cur',       label: 'mx.current' },
+  { key: 'mark_worked',      cssVar: '--mx-mark-work', label: 'mx.markWork' },
+  { key: 'mark_confirmed',   cssVar: '--mx-mark-conf', label: 'mx.markConf' },
 ];
 
 export const emptyMatrixColors = (): MatrixColors => ({
   enabled: false,
   call_confirmed: '', call_worked: '', entity_confirmed: '',
   entity_worked: '', not_worked: '', current_entry: '',
+  mark_worked: '', mark_confirmed: '',
 });
 
 // applyMatrixColors stamps (or clears) the overrides on <html>. Safe to call as

frontend/src/lib/spot.ts

@@ -36,17 +36,17 @@ export function inferSpotMode(comment: string, freqHz: number): string {
   type Seg = [number, number, string];
   const segs: Seg[] = [
     [1.8, 1.838, 'CW'], [1.838, 1.84, 'FT8'], [1.84, 2.0, 'SSB'],
-    [3.5, 3.58, 'CW'], [3.573, 3.576, 'FT8'], [3.58, 3.6, 'DATA'], [3.6, 4.0, 'SSB'],
+    [3.573, 3.575, 'FT8'], [3.575, 3.578, 'FT4'], [3.5, 3.58, 'CW'], [3.58, 3.6, 'DATA'], [3.6, 4.0, 'SSB'],
-    [5.3, 5.5, 'SSB'],
+    [5.357, 5.36, 'FT8'], [5.3, 5.5, 'SSB'],
     [7.0, 7.04, 'CW'], [7.074, 7.077, 'FT8'], [7.0475, 7.0485, 'FT4'],
     [7.04, 7.1, 'DATA'], [7.1, 7.3, 'SSB'],
-    [10.1, 10.13, 'CW'], [10.13, 10.15, 'DATA'],
+    [10.136, 10.139, 'FT8'], [10.14, 10.143, 'FT4'], [10.1, 10.13, 'CW'], [10.13, 10.15, 'DATA'],
     [14.0, 14.07, 'CW'], [14.074, 14.077, 'FT8'], [14.08, 14.0815, 'FT4'],
     [14.07, 14.1, 'DATA'], [14.1, 14.35, 'SSB'],
-    [18.068, 18.095, 'CW'], [18.1, 18.103, 'FT8'], [18.095, 18.11, 'DATA'], [18.11, 18.168, 'SSB'],
+    [18.1, 18.103, 'FT8'], [18.104, 18.107, 'FT4'], [18.068, 18.095, 'CW'], [18.095, 18.11, 'DATA'], [18.11, 18.168, 'SSB'],
     [21.0, 21.07, 'CW'], [21.074, 21.077, 'FT8'], [21.14, 21.143, 'FT4'],
     [21.07, 21.15, 'DATA'], [21.15, 21.45, 'SSB'],
-    [24.89, 24.915, 'CW'], [24.915, 24.917, 'FT8'], [24.915, 24.94, 'DATA'], [24.94, 24.99, 'SSB'],
+    [24.915, 24.918, 'FT8'], [24.919, 24.922, 'FT4'], [24.89, 24.915, 'CW'], [24.915, 24.94, 'DATA'], [24.94, 24.99, 'SSB'],
     [28.0, 28.07, 'CW'], [28.074, 28.077, 'FT8'], [28.18, 28.183, 'FT4'],
     [28.07, 28.3, 'DATA'], [28.3, 29.7, 'SSB'],
     [50.0, 50.1, 'CW'], [50.313, 50.316, 'FT8'], [50.318, 50.321, 'FT4'],

frontend/src/lib/spotDisplay.ts

@@ -11,7 +11,25 @@
 //
 // They compose deliberately: mute what is done, light up what is not.
 
-export type SpotDisplayOptions = { muteWorked: boolean; slotHighlight: boolean };
+export type SpotDisplayOptions = {
+  muteWorked: boolean; slotHighlight: boolean;
+  // Chase switches (Settings → DX Cluster), ON by default. An operator who does
+  // not chase parks does not want NEW POTA shouting from every activator spot:
+  // off, the marker is withdrawn at the display layer — a "new band + new POTA"
+  // spot simply reads NEW BAND — and the reference column goes quiet. The facts
+  // keep being computed; only the telling stops, so ticking the box back on
+  // needs no rescan.
+  chasePota: boolean; chaseSota: boolean;
+};
+
+// chasePota/chaseSota read the switches directly — for the places that show a
+// REFERENCE rather than a status (the POTA and SOTA columns).
+export function chasePota(): boolean {
+  try { return localStorage.getItem('opslog.chasePota') !== '0'; } catch { return true; }
+}
+export function chaseSota(): boolean {
+  try { return localStorage.getItem('opslog.chaseSota') !== '0'; } catch { return true; }
+}
 
 // Both options are withdrawn from the filter panel for now. The machinery below
 // is deliberately kept whole — it is correct and hard-won — so putting the two
@@ -23,14 +41,19 @@ export type SpotDisplayOptions = { muteWorked: boolean; slotHighlight: boolean }
 export const SPOT_DISPLAY_OPTIONS_EXPOSED = false;
 
 export function readSpotDisplayOptions(): SpotDisplayOptions {
-  if (!SPOT_DISPLAY_OPTIONS_EXPOSED) return { muteWorked: false, slotHighlight: false };
+  // The EXPOSED flag only withdraws the two original switches; the chase
+  // switches are live regardless.
+  if (!SPOT_DISPLAY_OPTIONS_EXPOSED) {
+    return { muteWorked: false, slotHighlight: false, chasePota: chasePota(), chaseSota: chaseSota() };
+  }
   try {
     return {
       muteWorked: localStorage.getItem('opslog.clusterMuteWorked') === '1',
       slotHighlight: localStorage.getItem('opslog.clusterSlotHighlight') === '1',
+      chasePota: chasePota(), chaseSota: chaseSota(),
     };
   } catch {
-    return { muteWorked: false, slotHighlight: false };
+    return { muteWorked: false, slotHighlight: false, chasePota: true, chaseSota: true };
   }
 }
 
@@ -72,6 +95,9 @@ export function applySpotDisplay<T extends Entry>(s: T, o: SpotDisplayOptions):
   if (o.muteWorked) {
     e = { ...e, worked_call: false } as NonNullable<T>;
   }
+  if (!o.chasePota && e.new_pota) {
+    e = { ...e, new_pota: false } as NonNullable<T>;
+  }
   return e;
 }
 

frontend/src/lib/uiPref.ts

@@ -40,6 +40,10 @@ const PORTABLE_KEYS = [
   'opslog.clusterFilterSource', 'opslog.clusterGroup', 'opslog.clusterBands',
   'opslog.clusterLockBand', 'opslog.clusterLockMode', 'opslog.clusterStatusFilter',
   'opslog.clusterModeFilter', 'opslog.clusterSearch', 'opslog.clusterHideWorked',
+  'opslog.distanceMiles', // distances shown in statute miles rather than km
+  'opslog.iaruRegion',    // IARU region (1/2/3) — band edges and segments on the band maps
+  'opslog.chasePota',     // show POTA references and the NEW POTA marker on spots
+  'opslog.chaseSota',     // show SOTA references on spots
   'opslog.activeTab',     // last selected tab
   'opslog.mainSplit',    // Main tab: width share of the left pane (percent) — legacy, read once to seed mainShares
   'opslog.mainShares',   // Main tab: column shares per column count, as {2:[..],3:[..],4:[..]}

frontend/src/lib/units.ts

@@ -0,0 +1,49 @@
+// Distance units.
+//
+// Everything is COMPUTED in kilometres — the great-circle maths, the backend's
+// distance_km on a spot, the map's path lengths — and converted once, here, at
+// display time. Storing miles anywhere would mean two sources of truth for the
+// same number and a rounding error that grows with every hop.
+//
+// The preference is portable (see lib/uiPref): an operator who works in miles
+// works in miles on every machine they copy their folder to.
+import { writeUiPref } from '@/lib/uiPref';
+
+export const KEY_MILES = 'opslog.distanceMiles';
+const KM_PER_MILE = 1.609344; // statute miles, the ones a US licence is used in
+
+export function useMiles(): boolean {
+  try { return localStorage.getItem(KEY_MILES) === '1'; } catch { return false; }
+}
+
+export function setUseMiles(on: boolean): void {
+  writeUiPref(KEY_MILES, on ? '1' : '0');
+  listeners.forEach((l) => l());
+}
+
+// subscribeDistanceUnit notifies on a change. The grids capture the unit inside
+// their column definitions (header text and formatter both), so without this a
+// toggle would only show up on the next language change or restart.
+const listeners = new Set<() => void>();
+export function subscribeDistanceUnit(fn: () => void): () => void {
+  listeners.add(fn);
+  return () => { listeners.delete(fn); };
+}
+
+// distanceValue converts a distance in km to the operator's unit, rounded to a
+// whole unit — the precision the inputs actually justify (a 4-character grid is
+// a square tens of kilometres wide).
+export function distanceValue(km: number): number {
+  if (!isFinite(km)) return 0;
+  return Math.round(useMiles() ? km / KM_PER_MILE : km);
+}
+
+// distanceUnit is the short label: "km" or "mi".
+export function distanceUnit(): string {
+  return useMiles() ? 'mi' : 'km';
+}
+
+// formatDistance is value + unit, thousands-separated: "12 345 km".
+export function formatDistance(km: number): string {
+  return `${distanceValue(km).toLocaleString()} ${distanceUnit()}`;
+}

frontend/src/style.css

@@ -91,6 +91,11 @@
      be recoloured on its own without dragging every other warning in the app
      with it (Appearance → matrix colours). */
   --mx-cur: var(--warning);
+  /* The "worked with this callsign" dot. Declared ONCE, like --mx-cur: it is
+     drawn over every one of the five cell colours, so it follows the theme's own
+     foreground/background pair rather than a per-theme colour of its own. */
+  --mx-mark-work: var(--foreground);
+  --mx-mark-conf: var(--foreground);
 
   --scrollbar-thumb: #b8a880;
   --scrollbar-thumb-hover: #968455;
@@ -981,6 +986,8 @@
   --color-mx-dx-work: var(--mx-dx-work);
   --color-mx-none: var(--mx-none);
   --color-mx-cur: var(--mx-cur);
+  --color-mx-mark-work: var(--mx-mark-work);
+  --color-mx-mark-conf: var(--mx-mark-conf);
 
   --radius: 0.5rem;
 

frontend/src/version.ts

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

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

@@ -30,6 +30,7 @@ import {lotwusers} from '../models';
 import {lookup} from '../models';
 import {netctl} from '../models';
 import {scp} from '../models';
+import {watchlist} from '../models';
 
 export function ACOMSetOperate(arg1:boolean):Promise<void>;
 
@@ -45,6 +46,8 @@ export function ActivateProfile(arg1:number):Promise<void>;
 
 export function ActiveRadioID():Promise<string>;
 
+export function ActiveRadioMyRig():Promise<string>;
+
 export function AddQSO(arg1:qso.QSO):Promise<number>;
 
 export function AmpFanMode(arg1:string,arg2:string):Promise<void>;
@@ -139,6 +142,8 @@ export function ComputeQSOAwardRefs(arg1:qso.QSO):Promise<Array<main.QSOAwardRef
 
 export function ComputeStationInfo(arg1:string,arg2:string):Promise<main.StationInfoComputed>;
 
+export function ConfigureDecoderMode(arg1:string):Promise<void>;
+
 export function ConnectAllClusters():Promise<void>;
 
 export function ConnectClusterServer(arg1:number):Promise<void>;
@@ -403,6 +408,8 @@ export function GetAntGeniusSettings():Promise<main.AntGeniusSettings>;
 
 export function GetAntGeniusStatus():Promise<antgenius.Status>;
 
+export function GetAudioMonitorPref():Promise<boolean>;
+
 export function GetAudioSettings():Promise<main.AudioSettings>;
 
 export function GetAutostartPrograms():Promise<Array<main.AutostartProgram>>;
@@ -503,6 +510,10 @@ export function GetLiveOpenings():Promise<Array<bandopen.Opening>>;
 
 export function GetLiveStations():Promise<Array<main.LiveStation>>;
 
+export function GetLoTWDownloadAllCalls():Promise<boolean>;
+
+export function GetLoTWQSLDetail():Promise<boolean>;
+
 export function GetLoTWUsersStatus():Promise<main.LoTWUsersStatus>;
 
 export function GetLogFilePath():Promise<string>;
@@ -597,6 +608,8 @@ export function GetUltrabeamSettings():Promise<main.UltrabeamSettings>;
 
 export function GetUltrabeamStatus():Promise<main.UltrabeamStatusInfo>;
 
+export function GetWatchlistContestPattern():Promise<string>;
+
 export function GetWebPublishConfig():Promise<webpub.Config>;
 
 export function GetWebPublishStatus():Promise<main.WebPublishStatus>;
@@ -609,6 +622,10 @@ export function GetWinkeyerStatus():Promise<winkeyer.Status>;
 
 export function GetWorkedCallVariants():Promise<boolean>;
 
+export function GetWsjtFollowMode():Promise<boolean>;
+
+export function GetWsjtHighlight():Promise<boolean>;
+
 export function GetYaesuBandAntennas():Promise<Record<string, number>>;
 
 export function GetYaesuState():Promise<cat.YaesuTXState>;
@@ -619,6 +636,8 @@ export function HaltDecodeTx(arg1:string,arg2:boolean):Promise<void>;
 
 export function HasBuiltinReferences(arg1:string):Promise<boolean>;
 
+export function IcomConsolePTT(arg1:boolean):Promise<void>;
+
 export function IcomRefresh():Promise<void>;
 
 export function IcomScopeData():Promise<cat.ScopeSweep>;
@@ -633,6 +652,8 @@ export function IcomSetANF(arg1:boolean):Promise<void>;
 
 export function IcomSetAPF(arg1:boolean):Promise<void>;
 
+export function IcomSetATU(arg1:boolean):Promise<void>;
+
 export function IcomSetAntenna(arg1:number):Promise<void>;
 
 export function IcomSetAntiVOX(arg1:number):Promise<void>;
@@ -693,6 +714,8 @@ export function IcomSetScopeMode(arg1:boolean):Promise<void>;
 
 export function IcomSetSplit(arg1:boolean):Promise<void>;
 
+export function IcomSetSplitOffset(arg1:number):Promise<void>;
+
 export function IcomSetSquelch(arg1:number):Promise<void>;
 
 export function IcomSetVOX(arg1:boolean):Promise<void>;
@@ -1141,6 +1164,8 @@ export function SetKenwoodNB(arg1:boolean):Promise<void>;
 
 export function SetKenwoodNR(arg1:boolean):Promise<void>;
 
+export function SetKenwoodPanelMode(arg1:string):Promise<void>;
+
 export function SetKenwoodPower(arg1:number):Promise<void>;
 
 export function SetKenwoodPreamp(arg1:boolean):Promise<void>;
@@ -1149,6 +1174,8 @@ export function SetKenwoodRFGain(arg1:number):Promise<void>;
 
 export function SetKenwoodRIT(arg1:boolean):Promise<void>;
 
+export function SetKenwoodRITOffset(arg1:number):Promise<void>;
+
 export function SetKenwoodSquelch(arg1:number):Promise<void>;
 
 export function SetKenwoodTX(arg1:boolean):Promise<void>;
@@ -1157,6 +1184,10 @@ export function SetKenwoodXIT(arg1:boolean):Promise<void>;
 
 export function SetLinkedAmps(arg1:Array<string>):Promise<void>;
 
+export function SetLoTWDownloadAllCalls(arg1:boolean):Promise<void>;
+
+export function SetLoTWQSLDetail(arg1:boolean):Promise<void>;
+
 export function SetMotorFollow(arg1:boolean,arg2:number,arg3:string):Promise<void>;
 
 export function SetOpsLogQSLReceived(arg1:number,arg2:boolean):Promise<void>;
@@ -1215,10 +1246,16 @@ export function SetUIPref(arg1:string,arg2:string):Promise<void>;
 
 export function SetUltrabeamDirection(arg1:number):Promise<void>;
 
+export function SetWatchlistContestPattern(arg1:string):Promise<void>;
+
 export function SetWinkeyerTrace(arg1:boolean):Promise<void>;
 
 export function SetWorkedCallVariants(arg1:boolean):Promise<void>;
 
+export function SetWsjtFollowMode(arg1:boolean):Promise<void>;
+
+export function SetWsjtHighlight(arg1:boolean):Promise<void>;
+
 export function SetYaesuAFGain(arg1:number):Promise<void>;
 
 export function SetYaesuAGC(arg1:string):Promise<void>;
@@ -1271,6 +1308,12 @@ export function SyncFolderNow():Promise<number>;
 
 export function SyncPOTAHunterLog(arg1:boolean,arg2:boolean):Promise<main.POTASyncResult>;
 
+export function TCISendCW(arg1:string):Promise<void>;
+
+export function TCISetKeySpeed(arg1:number):Promise<void>;
+
+export function TCIStopCW():Promise<void>;
+
 export function TailLogFile(arg1:number):Promise<string>;
 
 export function TestCloudlogUpload():Promise<string>;
@@ -1339,6 +1382,18 @@ export function UploadCallsign(arg1:string):Promise<string>;
 
 export function UploadQSOsManual(arg1:string,arg2:Array<number>):Promise<void>;
 
+export function WatchlistAdd(arg1:string,arg2:boolean):Promise<void>;
+
+export function WatchlistEntries():Promise<Array<watchlist.Entry>>;
+
+export function WatchlistRemove(arg1:string):Promise<void>;
+
+export function WatchlistSetContest(arg1:string,arg2:boolean):Promise<void>;
+
+export function WatchlistSetNotify(arg1:string,arg2:boolean):Promise<void>;
+
+export function WatchlistWorkedSlots(arg1:Array<main.WatchlistSlotQuery>):Promise<Array<boolean>>;
+
 export function WebPublishColumns():Promise<Array<Record<string, string>>>;
 
 export function WinkeyerBackspace():Promise<void>;

frontend/wailsjs/go/main/App.js

@@ -30,6 +30,10 @@ export function ActiveRadioID() {
   return window['go']['main']['App']['ActiveRadioID']();
 }
 
+export function ActiveRadioMyRig() {
+  return window['go']['main']['App']['ActiveRadioMyRig']();
+}
+
 export function AddQSO(arg1) {
   return window['go']['main']['App']['AddQSO'](arg1);
 }
@@ -218,6 +222,10 @@ export function ComputeStationInfo(arg1, arg2) {
   return window['go']['main']['App']['ComputeStationInfo'](arg1, arg2);
 }
 
+export function ConfigureDecoderMode(arg1) {
+  return window['go']['main']['App']['ConfigureDecoderMode'](arg1);
+}
+
 export function ConnectAllClusters() {
   return window['go']['main']['App']['ConnectAllClusters']();
 }
@@ -746,6 +754,10 @@ export function GetAntGeniusStatus() {
   return window['go']['main']['App']['GetAntGeniusStatus']();
 }
 
+export function GetAudioMonitorPref() {
+  return window['go']['main']['App']['GetAudioMonitorPref']();
+}
+
 export function GetAudioSettings() {
   return window['go']['main']['App']['GetAudioSettings']();
 }
@@ -946,6 +958,14 @@ export function GetLiveStations() {
   return window['go']['main']['App']['GetLiveStations']();
 }
 
+export function GetLoTWDownloadAllCalls() {
+  return window['go']['main']['App']['GetLoTWDownloadAllCalls']();
+}
+
+export function GetLoTWQSLDetail() {
+  return window['go']['main']['App']['GetLoTWQSLDetail']();
+}
+
 export function GetLoTWUsersStatus() {
   return window['go']['main']['App']['GetLoTWUsersStatus']();
 }
@@ -1134,6 +1154,10 @@ export function GetUltrabeamStatus() {
   return window['go']['main']['App']['GetUltrabeamStatus']();
 }
 
+export function GetWatchlistContestPattern() {
+  return window['go']['main']['App']['GetWatchlistContestPattern']();
+}
+
 export function GetWebPublishConfig() {
   return window['go']['main']['App']['GetWebPublishConfig']();
 }
@@ -1158,6 +1182,14 @@ export function GetWorkedCallVariants() {
   return window['go']['main']['App']['GetWorkedCallVariants']();
 }
 
+export function GetWsjtFollowMode() {
+  return window['go']['main']['App']['GetWsjtFollowMode']();
+}
+
+export function GetWsjtHighlight() {
+  return window['go']['main']['App']['GetWsjtHighlight']();
+}
+
 export function GetYaesuBandAntennas() {
   return window['go']['main']['App']['GetYaesuBandAntennas']();
 }
@@ -1178,6 +1210,10 @@ export function HasBuiltinReferences(arg1) {
   return window['go']['main']['App']['HasBuiltinReferences'](arg1);
 }
 
+export function IcomConsolePTT(arg1) {
+  return window['go']['main']['App']['IcomConsolePTT'](arg1);
+}
+
 export function IcomRefresh() {
   return window['go']['main']['App']['IcomRefresh']();
 }
@@ -1206,6 +1242,10 @@ export function IcomSetAPF(arg1) {
   return window['go']['main']['App']['IcomSetAPF'](arg1);
 }
 
+export function IcomSetATU(arg1) {
+  return window['go']['main']['App']['IcomSetATU'](arg1);
+}
+
 export function IcomSetAntenna(arg1) {
   return window['go']['main']['App']['IcomSetAntenna'](arg1);
 }
@@ -1326,6 +1366,10 @@ export function IcomSetSplit(arg1) {
   return window['go']['main']['App']['IcomSetSplit'](arg1);
 }
 
+export function IcomSetSplitOffset(arg1) {
+  return window['go']['main']['App']['IcomSetSplitOffset'](arg1);
+}
+
 export function IcomSetSquelch(arg1) {
   return window['go']['main']['App']['IcomSetSquelch'](arg1);
 }
@@ -2222,6 +2266,10 @@ export function SetKenwoodNR(arg1) {
   return window['go']['main']['App']['SetKenwoodNR'](arg1);
 }
 
+export function SetKenwoodPanelMode(arg1) {
+  return window['go']['main']['App']['SetKenwoodPanelMode'](arg1);
+}
+
 export function SetKenwoodPower(arg1) {
   return window['go']['main']['App']['SetKenwoodPower'](arg1);
 }
@@ -2238,6 +2286,10 @@ export function SetKenwoodRIT(arg1) {
   return window['go']['main']['App']['SetKenwoodRIT'](arg1);
 }
 
+export function SetKenwoodRITOffset(arg1) {
+  return window['go']['main']['App']['SetKenwoodRITOffset'](arg1);
+}
+
 export function SetKenwoodSquelch(arg1) {
   return window['go']['main']['App']['SetKenwoodSquelch'](arg1);
 }
@@ -2254,6 +2306,14 @@ export function SetLinkedAmps(arg1) {
   return window['go']['main']['App']['SetLinkedAmps'](arg1);
 }
 
+export function SetLoTWDownloadAllCalls(arg1) {
+  return window['go']['main']['App']['SetLoTWDownloadAllCalls'](arg1);
+}
+
+export function SetLoTWQSLDetail(arg1) {
+  return window['go']['main']['App']['SetLoTWQSLDetail'](arg1);
+}
+
 export function SetMotorFollow(arg1, arg2, arg3) {
   return window['go']['main']['App']['SetMotorFollow'](arg1, arg2, arg3);
 }
@@ -2370,6 +2430,10 @@ export function SetUltrabeamDirection(arg1) {
   return window['go']['main']['App']['SetUltrabeamDirection'](arg1);
 }
 
+export function SetWatchlistContestPattern(arg1) {
+  return window['go']['main']['App']['SetWatchlistContestPattern'](arg1);
+}
+
 export function SetWinkeyerTrace(arg1) {
   return window['go']['main']['App']['SetWinkeyerTrace'](arg1);
 }
@@ -2378,6 +2442,14 @@ export function SetWorkedCallVariants(arg1) {
   return window['go']['main']['App']['SetWorkedCallVariants'](arg1);
 }
 
+export function SetWsjtFollowMode(arg1) {
+  return window['go']['main']['App']['SetWsjtFollowMode'](arg1);
+}
+
+export function SetWsjtHighlight(arg1) {
+  return window['go']['main']['App']['SetWsjtHighlight'](arg1);
+}
+
 export function SetYaesuAFGain(arg1) {
   return window['go']['main']['App']['SetYaesuAFGain'](arg1);
 }
@@ -2482,6 +2554,18 @@ export function SyncPOTAHunterLog(arg1, arg2) {
   return window['go']['main']['App']['SyncPOTAHunterLog'](arg1, arg2);
 }
 
+export function TCISendCW(arg1) {
+  return window['go']['main']['App']['TCISendCW'](arg1);
+}
+
+export function TCISetKeySpeed(arg1) {
+  return window['go']['main']['App']['TCISetKeySpeed'](arg1);
+}
+
+export function TCIStopCW() {
+  return window['go']['main']['App']['TCIStopCW']();
+}
+
 export function TailLogFile(arg1) {
   return window['go']['main']['App']['TailLogFile'](arg1);
 }
@@ -2618,6 +2702,30 @@ export function UploadQSOsManual(arg1, arg2) {
   return window['go']['main']['App']['UploadQSOsManual'](arg1, arg2);
 }
 
+export function WatchlistAdd(arg1, arg2) {
+  return window['go']['main']['App']['WatchlistAdd'](arg1, arg2);
+}
+
+export function WatchlistEntries() {
+  return window['go']['main']['App']['WatchlistEntries']();
+}
+
+export function WatchlistRemove(arg1) {
+  return window['go']['main']['App']['WatchlistRemove'](arg1);
+}
+
+export function WatchlistSetContest(arg1, arg2) {
+  return window['go']['main']['App']['WatchlistSetContest'](arg1, arg2);
+}
+
+export function WatchlistSetNotify(arg1, arg2) {
+  return window['go']['main']['App']['WatchlistSetNotify'](arg1, arg2);
+}
+
+export function WatchlistWorkedSlots(arg1) {
+  return window['go']['main']['App']['WatchlistWorkedSlots'](arg1);
+}
+
 export function WebPublishColumns() {
   return window['go']['main']['App']['WebPublishColumns']();
 }

frontend/wailsjs/go/models.ts

@@ -983,6 +983,7 @@ export namespace cat {
 	    mode?: string;
 	    transmitting: boolean;
 	    split: boolean;
+	    sub_hz: number;
 	    s_meter: number;
 	    power_meter: number;
 	    swr_meter: number;
@@ -1006,6 +1007,7 @@ export namespace cat {
 	    att: number;
 	    filter: number;
 	    antenna: number;
+	    atu_on: boolean;
 	    pbt_inner: number;
 	    pbt_outer: number;
 	    manual_notch: boolean;
@@ -1030,6 +1032,7 @@ export namespace cat {
 	        this.mode = source["mode"];
 	        this.transmitting = source["transmitting"];
 	        this.split = source["split"];
+	        this.sub_hz = source["sub_hz"];
 	        this.s_meter = source["s_meter"];
 	        this.power_meter = source["power_meter"];
 	        this.swr_meter = source["swr_meter"];
@@ -1053,6 +1056,7 @@ export namespace cat {
 	        this.att = source["att"];
 	        this.filter = source["filter"];
 	        this.antenna = source["antenna"];
+	        this.atu_on = source["atu_on"];
 	        this.pbt_inner = source["pbt_inner"];
 	        this.pbt_outer = source["pbt_outer"];
 	        this.manual_notch = source["manual_notch"];
@@ -1072,12 +1076,14 @@ export namespace cat {
 	    model?: string;
 	    elecraft: boolean;
 	    mode?: string;
+	    data_sub?: string;
 	    transmitting: boolean;
 	    split: boolean;
 	    split_tx_hz: number;
 	    s_meter: number;
 	    s_meter_raw: number;
 	    power_meter: number;
+	    power_w: number;
 	    swr: number;
 	    swr_raw: number;
 	    rf_power: number;
@@ -1108,12 +1114,14 @@ export namespace cat {
 	        this.model = source["model"];
 	        this.elecraft = source["elecraft"];
 	        this.mode = source["mode"];
+	        this.data_sub = source["data_sub"];
 	        this.transmitting = source["transmitting"];
 	        this.split = source["split"];
 	        this.split_tx_hz = source["split_tx_hz"];
 	        this.s_meter = source["s_meter"];
 	        this.s_meter_raw = source["s_meter_raw"];
 	        this.power_meter = source["power_meter"];
+	        this.power_w = source["power_w"];
 	        this.swr = source["swr"];
 	        this.swr_raw = source["swr_raw"];
 	        this.rf_power = source["rf_power"];
@@ -1196,6 +1204,7 @@ export namespace cat {
 	    low_hz: number;
 	    high_hz: number;
 	    fixed: boolean;
+	    unsupported: boolean;
 	
 	    static createFrom(source: any = {}) {
 	        return new ScopeSweep(source);
@@ -1208,6 +1217,7 @@ export namespace cat {
 	        this.low_hz = source["low_hz"];
 	        this.high_hz = source["high_hz"];
 	        this.fixed = source["fixed"];
+	        this.unsupported = source["unsupported"];
 	    }
 	}
 	export class TCIPanelState {
@@ -3066,6 +3076,8 @@ export namespace main {
 	    entity_worked: string;
 	    not_worked: string;
 	    current_entry: string;
+	    mark_worked: string;
+	    mark_confirmed: string;
 	
 	    static createFrom(source: any = {}) {
 	        return new MatrixColors(source);
@@ -3080,6 +3092,8 @@ export namespace main {
 	        this.entity_worked = source["entity_worked"];
 	        this.not_worked = source["not_worked"];
 	        this.current_entry = source["current_entry"];
+	        this.mark_worked = source["mark_worked"];
+	        this.mark_confirmed = source["mark_confirmed"];
 	    }
 	}
 	
@@ -3573,6 +3587,7 @@ export namespace main {
 	    id: string;
 	    name: string;
 	    settings: CATSettings;
+	    my_rig: string;
 	
 	    static createFrom(source: any = {}) {
 	        return new RadioConfig(source);
@@ -3583,6 +3598,7 @@ export namespace main {
 	        this.id = source["id"];
 	        this.name = source["name"];
 	        this.settings = this.convertValues(source["settings"], CATSettings);
+	        this.my_rig = source["my_rig"];
 	    }
 	
 		convertValues(a: any, classs: any, asMap: boolean = false): any {
@@ -4291,6 +4307,24 @@ export namespace main {
 	        this.text = source["text"];
 	    }
 	}
+	export class WatchlistSlotQuery {
+	    call: string;
+	    band: string;
+	    mode: string;
+	    contest: boolean;
+	
+	    static createFrom(source: any = {}) {
+	        return new WatchlistSlotQuery(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.call = source["call"];
+	        this.band = source["band"];
+	        this.mode = source["mode"];
+	        this.contest = source["contest"];
+	    }
+	}
 	export class WebPublishStatus {
 	    last_run: string;
 	    last_err: string;
@@ -5025,6 +5059,7 @@ export namespace qso {
 	    band: string;
 	    class: string;
 	    status: string;
+	    call?: string;
 	
 	    static createFrom(source: any = {}) {
 	        return new BandStatus(source);
@@ -5035,6 +5070,7 @@ export namespace qso {
 	        this.band = source["band"];
 	        this.class = source["class"];
 	        this.status = source["status"];
+	        this.call = source["call"];
 	    }
 	}
 	export class Bucket {
@@ -5978,6 +6014,68 @@ export namespace udp {
 
 }
 
+export namespace watchlist {
+	
+	export class Entry {
+	    callsign: string;
+	    // Go type: time
+	    lastSeen: any;
+	    lastSeenStr: string;
+	    // Go type: time
+	    addedAt: any;
+	    spotCount: number;
+	    isContest: boolean;
+	    notify: boolean;
+	    isExpedition: boolean;
+	    clubLogQSOs24h: number;
+	    clubLogTotalQSOs: number;
+	    clubLogHasOQRS: boolean;
+	    clubLogLiveStream: boolean;
+	    // Go type: time
+	    clubLogUpdatedAt?: any;
+	
+	    static createFrom(source: any = {}) {
+	        return new Entry(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.callsign = source["callsign"];
+	        this.lastSeen = this.convertValues(source["lastSeen"], null);
+	        this.lastSeenStr = source["lastSeenStr"];
+	        this.addedAt = this.convertValues(source["addedAt"], null);
+	        this.spotCount = source["spotCount"];
+	        this.isContest = source["isContest"];
+	        this.notify = source["notify"];
+	        this.isExpedition = source["isExpedition"];
+	        this.clubLogQSOs24h = source["clubLogQSOs24h"];
+	        this.clubLogTotalQSOs = source["clubLogTotalQSOs"];
+	        this.clubLogHasOQRS = source["clubLogHasOQRS"];
+	        this.clubLogLiveStream = source["clubLogLiveStream"];
+	        this.clubLogUpdatedAt = this.convertValues(source["clubLogUpdatedAt"], null);
+	    }
+	
+		convertValues(a: any, classs: any, asMap: boolean = false): any {
+		    if (!a) {
+		        return a;
+		    }
+		    if (a.slice && a.map) {
+		        return (a as any[]).map(elem => this.convertValues(elem, classs));
+		    } else if ("object" === typeof a) {
+		        if (asMap) {
+		            for (const key of Object.keys(a)) {
+		                a[key] = new classs(a[key]);
+		            }
+		            return a;
+		        }
+		        return new classs(a);
+		    }
+		    return a;
+		}
+	}
+
+}
+
 export namespace webpub {
 	
 	export class Config {

internal/alerts/bandplan.go

@@ -27,27 +27,31 @@ type modeSeg struct {
 var bandPlan = []modeSeg{
 	{1_800_000, 1_838_000, "CW"}, {1_838_000, 1_840_000, "FT8"}, {1_840_000, 2_000_000, "SSB"},
 
-	{3_573_000, 3_576_000, "FT8"}, {3_500_000, 3_580_000, "CW"},
+	{3_573_000, 3_575_000, "FT8"}, {3_575_000, 3_578_000, "FT4"}, {3_500_000, 3_580_000, "CW"},
 	{3_580_000, 3_600_000, "DATA"}, {3_600_000, 4_000_000, "SSB"},
 
-	{5_300_000, 5_500_000, "SSB"},
+	{5_357_000, 5_360_000, "FT8"}, {5_300_000, 5_500_000, "SSB"},
 
 	{7_074_000, 7_077_000, "FT8"}, {7_047_500, 7_048_500, "FT4"},
 	{7_000_000, 7_040_000, "CW"}, {7_040_000, 7_100_000, "DATA"}, {7_100_000, 7_300_000, "SSB"},
 
 	// 30 m: CW to 10.130, data above it — and nothing else. No SSB on this band.
+	// The FT8/FT4 watering holes come first, or a 10.136 spot with a bare
+	// comment reads as generic DATA — which is what every skimmerless spot of a
+	// DXpedition's 30 m FT8 slot did.
+	{10_136_000, 10_139_000, "FT8"}, {10_140_000, 10_143_000, "FT4"},
 	{10_100_000, 10_130_000, "CW"}, {10_130_000, 10_150_000, "DATA"},
 
 	{14_074_000, 14_077_000, "FT8"}, {14_080_000, 14_081_500, "FT4"},
 	{14_000_000, 14_070_000, "CW"}, {14_070_000, 14_100_000, "DATA"}, {14_100_000, 14_350_000, "SSB"},
 
-	{18_100_000, 18_103_000, "FT8"},
+	{18_100_000, 18_103_000, "FT8"}, {18_104_000, 18_107_000, "FT4"},
 	{18_068_000, 18_095_000, "CW"}, {18_095_000, 18_110_000, "DATA"}, {18_110_000, 18_168_000, "SSB"},
 
 	{21_074_000, 21_077_000, "FT8"}, {21_140_000, 21_143_000, "FT4"},
 	{21_000_000, 21_070_000, "CW"}, {21_070_000, 21_150_000, "DATA"}, {21_150_000, 21_450_000, "SSB"},
 
-	{24_915_000, 24_917_000, "FT8"},
+	{24_915_000, 24_918_000, "FT8"}, {24_919_000, 24_922_000, "FT4"},
 	{24_890_000, 24_915_000, "CW"}, {24_915_000, 24_940_000, "DATA"}, {24_940_000, 24_990_000, "SSB"},
 
 	{28_074_000, 28_077_000, "FT8"}, {28_180_000, 28_183_000, "FT4"},

internal/audio/manager.go

@@ -356,6 +356,29 @@ func (m *Manager) StartTXAudio(micDev, toRadioDev string) error {
 	return nil
 }
 
+// StartTXAudioNetwork pipes the live microphone into a SEND function instead
+// of a render device — the talk button when the radio is reached over its own
+// link. No ring and no pacing goroutine: the microphone delivers in real time,
+// and the sender re-frames to the rig's cadence, so the capture callback IS
+// the clock.
+func (m *Manager) StartTXAudioNetwork(micDev string, send func([]byte) error) error {
+	m.mu.Lock()
+	if m.txStop != nil {
+		m.mu.Unlock()
+		return fmt.Errorf("TX audio already running")
+	}
+	stop := make(chan struct{})
+	m.txStop = stop
+	m.mu.Unlock()
+	go func() {
+		if err := captureStream(micDev, stop, func(chunk []byte) { _ = send(chunk) }); err != nil {
+			LogSink("audio: network TX capture from %q failed: %v", DeviceName(micDev), err)
+		}
+	}()
+	m.notify()
+	return nil
+}
+
 // StopTXAudio stops the TX mic→rig passthrough.
 func (m *Manager) StopTXAudio() {
 	m.mu.Lock()

internal/audio/network.go

@@ -64,4 +64,4 @@ func NetworkPlayerReady() bool { return networkPlayer() != nil }
 // comes back with. Named, because "the device could not be opened" would send
 // an operator hunting through Windows sound settings for a device that never
 // existed.
-var errNoNetworkRadio = errors.New("no radio is connected to take the audio — check the CAT link (the radio output only works with a TCI radio)")
+var errNoNetworkRadio = errors.New("no radio is connected to take the audio — check the CAT link (a TCI radio, or a network Icom with RX audio enabled)")

internal/cat/cat.go

@@ -572,6 +572,10 @@ type IcomTXState struct {
 	// Transmit + live status (polled).
 	Transmitting bool `json:"transmitting"`
 	Split        bool `json:"split"`
+	// SubHz is the unselected VFO / sub receiver's frequency — shown on the
+	// console's SUB display whether or not split is on: a dual-receiver rig
+	// (IC-7610/7760) has a second dial worth seeing at all times.
+	SubHz      int64 `json:"sub_hz"`
 	SMeter     int   `json:"s_meter"`     // 0-100 (raw 0-255; S9≈120)
 	PowerMeter int   `json:"power_meter"` // 0-100 (TX Po)
 	SWRMeter   int   `json:"swr_meter"`   // 0-100 (TX SWR)
@@ -599,6 +603,7 @@ type IcomTXState struct {
 	Filter  int    `json:"filter"`        // 1 | 2 | 3 (FIL1/2/3)
 	// Antenna (IC-7610 = ANT1/ANT2).
 	Antenna int  `json:"antenna"` // 1 | 2 (0 = unknown)
+	ATUOn   bool `json:"atu_on"`  // internal tuner engaged
 	// Filter fine controls: Twin PBT + manual notch (0-100, 50 = centre).
 	PBTInner    int  `json:"pbt_inner"`
 	PBTOuter    int  `json:"pbt_outer"`
@@ -636,6 +641,8 @@ type IcomController interface {
 	SetRFPower(int) error
 	SetMicGain(int) error
 	SetIcomSplit(bool) error
+	SetIcomSplitOffset(bool, int64) error
+	SetATU(bool) error
 	TuneATU() error
 	SetScope(bool) error              // enable/disable the spectrum-scope waveform stream
 	SetScopeMode(bool) error          // true = fixed span, false = center-on-VFO
@@ -674,6 +681,12 @@ type ScopeSweep struct {
 	LowHz  int64 `json:"low_hz"`  // left edge frequency (0 when unknown)
 	HighHz int64 `json:"high_hz"` // right edge frequency (0 when unknown)
 	Fixed  bool  `json:"fixed"`   // true = fixed-span mode, false = center-on-VFO
+	// Unsupported: this radio refuses the waveform-output command, so there will
+	// never be a sweep. The IC-7851 does — its last firmware is from 2016, older
+	// than the CI-V waveform stream — while still answering the scope's other
+	// commands. Reported so the panadapter can say so instead of showing a black
+	// rectangle that looks like a bug in OpsLog.
+	Unsupported bool `json:"unsupported"`
 }
 
 // IcomState returns the current Icom DSP state, or (zero, false) when the active

internal/cat/civ/civ.go

@@ -36,6 +36,7 @@ const (
 	CmdVfoFreq        = 0x25 // read a specific VFO's freq (sub 0x00 selected, 0x01 unselected)
 	CmdPTT            = 0x1C // sub 0x00 = PTT
 	CmdExtra          = 0x1A // sub 0x06 = data mode on modern Icoms
+	CmdModeDataFil    = 0x26 // sub 0x00 = selected VFO: mode + data flag + filter in one frame
 	CmdReadID         = 0x19 // sub 0x00 = rig's own CI-V address (identifies model)
 	CmdPower          = 0x18 // power on/off (sub 0x01 = on, 0x00 = off; on needs an FE wake preamble)
 
@@ -130,6 +131,8 @@ const (
 	ModeFM    = 0x05
 	ModeCWR   = 0x07
 	ModeRTTYR = 0x08
+	ModePSK   = 0x12 // native PSK (IC-7610/7760/7851 class; older rigs NAK it)
+	ModePSKR  = 0x13
 )
 
 // Frame builds a complete CI-V frame (preamble … end) for payload, which is the
@@ -305,6 +308,8 @@ func ModeToADIF(m byte, data bool) string {
 		return "CW"
 	case ModeRTTY, ModeRTTYR:
 		return "RTTY"
+	case ModePSK, ModePSKR:
+		return "PSK31"
 	case ModeAM:
 		return "AM"
 	case ModeFM:
@@ -357,6 +362,8 @@ func ModelName(addr byte) string {
 		return "IC-9700"
 	case 0xA4:
 		return "IC-705"
+	case 0xB2:
+		return "IC-7760"
 	case 0xB6:
 		return "IC-7300MKII"
 	}

internal/cat/icomaudio.go

@@ -22,17 +22,20 @@ package cat
 // audio stream is opt-in and entirely separate from control/CI-V.
 
 import (
+	"fmt"
 	"net"
 	"sync"
 	"sync/atomic"
 	"time"
 )
 
-// icaAudioOffset is where the PCM payload begins inside an audio data packet
+// icaAudioOffset is where the PCM payload begins inside an audio data packet.
-// (wfview audio_packet: 16-byte common header + ident@0x10 + datalen@0x12 +
+// CONFIRMED on a real IC-7760 (2026-08-29): 16-byte common header, ident@0x10,
-// sendseq@0x14 → audio@0x16). Isolated as a const so a capture-confirmed change
+// send seq (BE) @0x12, payload length (BE uint32) @0x14 — 0x500 observed on
-// is a one-line edit.
+// every packet — and the PCM starts at 0x18. The 0x16 first guessed from
-const icaAudioOffset = 0x16
+// wfview's struct swallowed two header bytes into the audio, one broken sample
+// per packet: a 50 Hz click track under everything.
+const icaAudioOffset = 0x18
 
 // icaDumpFirst is how many initial audio packets to hex-dump to the debug log for
 // offset verification. After the layout is confirmed on a real rig this can go to
@@ -55,6 +58,14 @@ type icomAudio struct {
 	rxMissing map[uint16]int
 
 	dumped  int    // packets hex-dumped so far (≤ icaDumpFirst)
+	pingSeq uint16 // client-ping counter — the rig wants OUR pings too (see icnPing)
+	started time.Time
+
+	// Live-TX state — see SendTXChunk.
+	txMu    sync.Mutex
+	txRem   []byte
+	txOuter uint16
+	txSend  uint16
 	lastRx  atomic.Int64 // UnixNano of last packet (liveness)
 
 	done      chan struct{}
@@ -100,6 +111,7 @@ func dialIcomAudio(host string, sink func([]byte), cancel <-chan struct{}) (*ico
 	_ = conn.SetReadBuffer(1 << 20)
 	a := &icomAudio{
 		conn: conn, aID: aID, aRemote: aRemote,
+		started:   time.Now(),
 		sink:      sink,
 		rxMissing: make(map[uint16]int),
 		done:      make(chan struct{}),
@@ -115,6 +127,7 @@ func dialIcomAudio(host string, sink func([]byte), cancel <-chan struct{}) (*ico
 func (a *icomAudio) audioPump() {
 	buf := make([]byte, 8192)
 	lastIdle := time.Now()
+	lastPing := time.Now()
 	lastReq := time.Now()
 	for {
 		select {
@@ -132,12 +145,19 @@ func (a *icomAudio) audioPump() {
 			case typ == 0x05: // rig-initiated disconnect
 				debugLog.Printf("icom audio: rig sent DISCONNECT — audio stream dropped by the rig")
 			case typ == 0x00 && k > icaAudioOffset: // audio data packet
-				a.trackRxSeq(icnLE.Uint16(buf[6:]))
+				fresh := a.trackRxSeq(icnLE.Uint16(buf[6:]))
 				if a.dumped < icaDumpFirst {
 					a.dumped++
 					debugLog.Printf("icom audio raw #%d: len=%d head=% X", a.dumped, k, buf[:min(icaAudioOffset+8, k)])
 				}
-				if a.sink != nil {
+				// Only a packet that ADVANCES the sequence reaches the sink. A
+				// duplicate or a late retransmit used to be delivered as if it
+				// were the next 20 ms of audio: the monitor's capped ring threw
+				// the surplus away (the speakers stayed clean), but the recorder
+				// keeps every sample it is given — the file grew longer than the
+				// QSO and played back slowed and stuttering, each lost-then-
+				// resent packet heard twice.
+				if fresh && a.sink != nil {
 					payload := append([]byte(nil), buf[icaAudioOffset:k]...)
 					a.sink(payload)
 				}
@@ -147,6 +167,11 @@ func (a *icomAudio) audioPump() {
 			_, _ = a.conn.Write(icnCtrl(0x00, 0, a.aID, a.aRemote))
 			lastIdle = time.Now()
 		}
+		if time.Since(lastPing) > 500*time.Millisecond {
+			a.pingSeq++
+			_, _ = a.conn.Write(icnPing(a.pingSeq, a.aID, a.aRemote, uint32(time.Since(a.started).Milliseconds())))
+			lastPing = time.Now()
+		}
 		if time.Since(lastReq) > 100*time.Millisecond {
 			a.sendRetransmitReq()
 			lastReq = time.Now()
@@ -157,26 +182,36 @@ func (a *icomAudio) audioPump() {
 // trackRxSeq / sendRetransmitReq mirror icomNet's receive-side retransmit exactly
 // (audio is as loss-sensitive as the scope stream). Duplicated deliberately so
 // the audio stream owns its own seq state with no shared locking.
-func (a *icomAudio) trackRxSeq(seq uint16) {
+//
+// The return value says whether this packet moves the stream FORWARD — the
+// only kind the sink may hear. A duplicate is the same 20 ms again; a late
+// retransmit would play old audio in the middle of new. Both are accounted
+// for here and dropped by the caller.
+func (a *icomAudio) trackRxSeq(seq uint16) bool {
 	if !a.rxHaveSeq {
 		a.rxHaveSeq = true
 		a.rxLastSeq = seq
-		return
+		return true
 	}
 	switch d := int16(seq - a.rxLastSeq); {
 	case d == 0:
+		return false
 	case d < 0:
 		delete(a.rxMissing, seq)
+		return false
 	case d == 1:
 		a.rxLastSeq = seq
+		return true
 	case int(d) <= icnMaxMissing:
 		for f := a.rxLastSeq + 1; f != seq; f++ {
 			a.rxMissing[f] = 0
 		}
 		a.rxLastSeq = seq
+		return true
 	default:
 		a.rxMissing = make(map[uint16]int)
 		a.rxLastSeq = seq
+		return true
 	}
 }
 
@@ -217,3 +252,89 @@ func (a *icomAudio) sendRetransmitReq() {
 		_, _ = a.conn.Write(b)
 	}
 }
+
+// PlayTX sends one already-decoded message out over the audio session, paced
+// at the stream's own 20 ms / 320-sample cadence, and returns when the last
+// packet has gone or stop is closed.
+//
+// The frame mirrors what the rig itself sends on this socket byte for byte —
+// ident 0x81 0x01 (LPCM mono 16-bit), a big-endian send sequence at 0x12, the
+// payload length at 0x14, PCM from 0x18 — with the IDs swapped for direction.
+// PTT is the caller's business, exactly as on the TCI and sound-card paths.
+func (a *icomAudio) PlayTX(pcm []byte, rate, ch, bits int, stop <-chan struct{}) error {
+	mono := decodeToMono(pcm, ch, bits)
+	if len(mono) == 0 {
+		return fmt.Errorf("the message is empty")
+	}
+	if rate > 0 && rate != 16000 {
+		mono = resampleLinear(mono, rate, 16000)
+	}
+	// Through the SAME framer and counters as the live microphone. Each of the
+	// two used to number its own packets from 1, and a voice-keyer message sent
+	// after a talk session re-used sequence numbers the rig had already seen —
+	// it keyed for the full length of the message and modulated none of it.
+	const frame = 320 // samples per packet: 20 ms at 16 kHz, the rig's own cadence
+	tick := time.NewTicker(20 * time.Millisecond)
+	defer tick.Stop()
+	buf := make([]byte, frame*2)
+	for pos := 0; pos < len(mono); pos += frame {
+		select {
+		case <-stop:
+			return nil
+		case <-a.done:
+			return fmt.Errorf("the audio stream closed mid-message")
+		case <-tick.C:
+		}
+		for i := 0; i < frame; i++ {
+			var v float32
+			if pos+i < len(mono) {
+				v = mono[pos+i] * 32767
+			}
+			if v > 32767 {
+				v = 32767
+			} else if v < -32768 {
+				v = -32768
+			}
+			icnLE.PutUint16(buf[i*2:], uint16(int16(v)))
+		}
+		if err := a.SendTXChunk(buf); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Live TX — the microphone, not a recorded message. Chunks arrive at the
+// microphone's own real-time pace (16 kHz mono 16-bit, whatever length the
+// capture delivers) and are re-framed into the rig's 320-sample packets; the
+// remainder waits for the next chunk. Counters and remainder live on the
+// stream so a talk session survives across calls.
+func (a *icomAudio) SendTXChunk(pcm []byte) error {
+	a.txMu.Lock()
+	defer a.txMu.Unlock()
+	a.txRem = append(a.txRem, pcm...)
+	const frameBytes = 640
+	for len(a.txRem) >= frameBytes {
+		select {
+		case <-a.done:
+			return fmt.Errorf("the audio stream closed")
+		default:
+		}
+		pkt := make([]byte, 0x18+frameBytes)
+		icnLE.PutUint32(pkt[0:], uint32(len(pkt)))
+		a.txOuter++
+		icnLE.PutUint16(pkt[6:], a.txOuter)
+		icnLE.PutUint32(pkt[8:], a.aID)
+		icnLE.PutUint32(pkt[12:], a.aRemote)
+		pkt[0x10], pkt[0x11] = 0x81, 0x01
+		icnBE.PutUint16(pkt[0x12:], a.txSend)
+		a.txSend++
+		icnBE.PutUint32(pkt[0x14:], frameBytes)
+		copy(pkt[0x18:], a.txRem[:frameBytes])
+		a.txRem = a.txRem[frameBytes:]
+		if _, err := a.conn.Write(pkt); err != nil {
+			return fmt.Errorf("sending mic audio to the rig: %w", err)
+		}
+	}
+	return nil
+}

internal/cat/icomnet.go

@@ -56,6 +56,15 @@ func NewIcomNet(host, user, pass string, civAddr int, digitalDefault string, aud
 		model:      "Icom",
 		scopeFixed: true,
 	}
+	// lastNetConnect is when the previous session came up, and it drives a
+	// deliberate pause: on a real IC-7760 a session sometimes goes deaf on CI-V
+	// while the rig still holds it half-open, and a session dialled straight
+	// back in answers for a second and is then strangled when the rig finally
+	// purges the old one — reconnect, die, reconnect, die, twenty seconds a
+	// lap and no audio the whole time. When the last session died YOUNG, wait
+	// out the rig's cleanup before dialling again; a session that lived long
+	// reconnects immediately, as ever.
+	var lastNetConnect time.Time
 	b.open = func() (civTransport, error) {
 		if strings.TrimSpace(host) == "" {
 			return nil, fmt.Errorf("no rig host configured")
@@ -63,7 +72,20 @@ func NewIcomNet(host, user, pass string, civAddr int, digitalDefault string, aud
 		b.dialMu.Lock()
 		cancel := b.dialCancel
 		b.dialMu.Unlock()
-		return dialIcomNet(host, user, pass, "OpsLog", b.rigAddr, cancel, audioSink)
+		if !lastNetConnect.IsZero() && time.Since(lastNetConnect) < 90*time.Second {
+			debugLog.Printf("icom net: the last session died young — pausing 20 s before redialling so the rig can purge it first")
+			for i := 0; i < 40; i++ {
+				if icnCanceled(cancel) {
+					return nil, errDialCanceled
+				}
+				time.Sleep(500 * time.Millisecond)
+			}
+		}
+		tr, err := dialIcomNet(host, user, pass, "OpsLog", b.rigAddr, cancel, audioSink)
+		if err == nil {
+			lastNetConnect = time.Now()
+		}
+		return tr, err
 	}
 	return b
 }
@@ -97,6 +119,19 @@ type icomNet struct {
 	// CAT goroutine) and during dial — never by the pump — so no lock is needed.
 	vTracked uint16
 	vCivSeq  uint16
+	seqMu    sync.Mutex // guards vTracked/vCivSeq: the command loop AND the pump's quiet-recovery both send
+	// Client-ping sequence counters, one per stream, and the connection's epoch
+	// for the ping timestamps. Owned by their pump goroutines — no locking.
+	civPingSeq  uint16
+	ctrlPingSeq uint16
+	started     time.Time
+	// txCiv counts CI-V command packets sent, and txAtData snapshots it at the
+	// last received CI-V data. Their difference during a silence answers the
+	// question the reconnects cannot: were we still ASKING when the answers
+	// stopped? Zero writes-since-data would mean the fault is our own poll
+	// loop, not the rig — and RS-BA1 showing no such dropouts points that way.
+	txCiv    atomic.Uint32
+	txAtData atomic.Uint32
 
 	rx      chan []byte // CI-V byte chunks from civPump → Read (control replies)
 	scopeRx chan []byte // scope (0x27) frames, kept off rx so the panadapter
@@ -227,10 +262,13 @@ func (n *icomNet) Write(p []byte) (int, error) {
 	if icnTrace {
 		debugLog.Printf("icom net TX: % X", p)
 	}
-	seq := n.vTracked
+	n.seqMu.Lock()
-	pkt := icnCivData(seq, n.vID, n.vRemote, n.vCivSeq, p)
+	seq, civSeq := n.vTracked, n.vCivSeq
 	n.vTracked++
 	n.vCivSeq++
+	n.seqMu.Unlock()
+	n.txCiv.Add(1)
+	pkt := icnCivData(seq, n.vID, n.vRemote, civSeq, p)
 	n.sentMu.Lock()
 	n.sentBuf[seq] = pkt
 	delete(n.sentBuf, seq-1024) // keep the buffer bounded (~last 1024 packets) so
@@ -281,6 +319,7 @@ func (n *icomNet) Close() error {
 func (n *icomNet) ctrlPump() {
 	buf := make([]byte, 4096)
 	lastIdle := time.Now()
+	lastCtrlPing := time.Now()
 	lastToken := time.Now() // token was just granted during dial
 	for {
 		select {
@@ -321,6 +360,11 @@ func (n *icomNet) ctrlPump() {
 		}
 		// Renew well inside the rig's ~2-min token timeout. 30 s (was 45) leaves room
 		// for one lost renewal + its retransmit before the token would lapse.
+		if time.Since(lastCtrlPing) > 500*time.Millisecond {
+			n.ctrlPingSeq++
+			_, _ = n.ctrl.Write(icnPing(n.ctrlPingSeq, n.cID, n.cRemote, uint32(time.Since(n.started).Milliseconds())))
+			lastCtrlPing = time.Now()
+		}
 		if time.Since(lastToken) > 30*time.Second {
 			n.renewToken()
 			lastToken = time.Now()
@@ -359,6 +403,25 @@ func (n *icomNet) civPump() {
 	buf := make([]byte, 8192)
 	lastIdle := time.Now()
 	lastReq := time.Now()
+	// Diagnosis for the recurring 2-3-minute silence a real IC-7760 shows on
+	// this stream while the control link stays alive: when the stream has been
+	// quiet for 10 s, say so ONCE, with the last read error — a socket error
+	// and a rig that stopped talking are different repairs, and the 30 s
+	// watchdog that follows cannot tell them apart from where it sits.
+	debugLog.Printf("icom net: client pings armed on the CI-V stream (every 500 ms)")
+	lastPkt := time.Now()
+	lastPing := time.Now()
+	lastData := time.Now()   // CI-V payload packets (replies + transceive)
+	lastScope := time.Time{} // scope frames within those
+	var lastErr error
+	quietSaid := false
+	gaveUp := false
+	// sawData: this session has heard at least one CI-V payload. A radio in
+	// STANDBY is silent on CI-V by design — only the transport chats — and the
+	// quiet-recovery below must not treat that as a fault: it was tearing the
+	// session down every 15 s, and with it the console and its ON button, so a
+	// radio that was off when OpsLog started could never be turned on at all.
+	sawData := false
 	for {
 		select {
 		case <-n.done:
@@ -366,7 +429,14 @@ func (n *icomNet) civPump() {
 		default:
 		}
 		_ = n.civ.SetReadDeadline(time.Now().Add(100 * time.Millisecond))
-		if k, err := n.civ.Read(buf); err == nil && k >= 16 {
+		k, err := n.civ.Read(buf)
+		if err != nil {
+			if e, ok := err.(net.Error); !ok || !e.Timeout() {
+				lastErr = err // a REAL socket error, not the read deadline
+			}
+		}
+		if err == nil && k >= 16 {
+			lastPkt = time.Now()
 			n.markRx()
 			switch typ := icnLE.Uint16(buf[4:]); {
 			case typ == 0x07: // ping
@@ -379,6 +449,13 @@ func (n *icomNet) civPump() {
 				n.dead.Store(true) // make Alive() fail now → prompt clean reconnect
 				debugLog.Printf("icom net: rig sent DISCONNECT on CI-V stream — session dropped by the rig")
 			case typ == 0x00 && k > 0x15 && buf[0x10] == 0xc1: // CI-V data
+				if quietSaid {
+					debugLog.Printf("icom net: CI-V replies are back after %s", time.Since(lastData).Round(time.Second))
+					quietSaid, gaveUp = false, false
+				}
+				sawData = true
+				lastData = time.Now()
+				n.txAtData.Store(n.txCiv.Load())
 				n.trackRxSeq(icnLE.Uint16(buf[6:])) // note gaps for retransmit
 				civBytes := buf[0x15:k]
 				cp := append([]byte(nil), civBytes...)
@@ -388,6 +465,7 @@ func (n *icomNet) civPump() {
 				// feeder in IcomSerial picks them up. Everything else is a control
 				// reply → rx → Read.
 				if len(civBytes) >= 5 && civBytes[4] == 0x27 {
+					lastScope = time.Now()
 					icnEnqueueDrop(n.scopeRx, cp)
 					break
 				}
@@ -410,14 +488,69 @@ func (n *icomNet) civPump() {
 				}
 			}
 		}
+		if !quietSaid && sawData && time.Since(lastData) > 10*time.Second {
+			quietSaid = true
+			scopeAge := "never"
+			if !lastScope.IsZero() {
+				scopeAge = time.Since(lastScope).Round(time.Second).String()
+			}
+			debugLog.Printf("icom net: no CI-V DATA for 10 s (transport last heard %s ago; last scope frame %s ago; last socket error: %v; missing-seq backlog: %d; CI-V commands SENT since the last answer: %d)",
+				time.Since(lastPkt).Round(time.Second), scopeAge, lastErr, len(n.rxMissing), n.txCiv.Load()-n.txAtData.Load())
+			// And try the gentle repair before the 30 s watchdog tears the whole
+			// session down: if the rig quietly closed the CI-V data flow (the
+			// transport is still chatting, so the session itself stands), saying
+			// "open" again on the same stream is all it should take. Harmless
+			// when the cause is elsewhere — the watchdog still fires at 30 s.
+			n.seqMu.Lock()
+			seq, civSeq := n.vTracked, n.vCivSeq
+			n.vTracked++
+			n.vCivSeq++
+			n.seqMu.Unlock()
+			ocPkt := icnOpenClose(seq, n.vID, n.vRemote, civSeq, 0x04)
+			n.sentMu.Lock()
+			n.sentBuf[seq] = ocPkt
+			n.sentMu.Unlock()
+			_, _ = n.civ.Write(ocPkt)
+			debugLog.Printf("icom net: re-sent the CI-V open on the existing stream")
+		}
+		// The reopen was given five seconds. On a real IC-7760 it never works —
+		// the rig ignores it and only a fresh session brings CI-V back — so
+		// rather than sit out the 30 s watchdog, fail the link NOW and let the
+		// manager rebuild it: the outage drops from ~35 s to ~15.
+		if quietSaid && !gaveUp && time.Since(lastData) > 15*time.Second {
+			gaveUp = true
+			n.dead.Store(true)
+			debugLog.Printf("icom net: the reopen did not bring CI-V back — forcing a fresh session")
+		}
 		if time.Since(lastIdle) > 150*time.Millisecond {
-			_, _ = n.civ.Write(icnCtrl(0x00, 0, n.vID, n.vRemote))
+			// Idles carry a REAL sequence number, drawn from the same counter as
+			// the data packets, and sit in the retransmit buffer like them —
+			// which is how RS-BA1 and wfview number theirs. Ours used seq 0 on
+			// every idle, seven a second, interleaved with properly-numbered
+			// data; a rig that follows the sequence tolerates that for a minute
+			// or so and then stops serving CI-V data on the stream — which is
+			// the shape of every dropout this loaner IC-7760 has shown, with
+			// the scope and the TX path both since eliminated.
+			n.seqMu.Lock()
+			iseq := n.vTracked
+			n.vTracked++
+			n.seqMu.Unlock()
+			ipkt := icnCtrl(0x00, iseq, n.vID, n.vRemote)
+			n.sentMu.Lock()
+			n.sentBuf[iseq] = ipkt
+			n.sentMu.Unlock()
+			_, _ = n.civ.Write(ipkt)
 			lastIdle = time.Now()
 		}
 		if time.Since(lastReq) > 100*time.Millisecond {
 			n.sendRetransmitReq()
 			lastReq = time.Now()
 		}
+		if time.Since(lastPing) > 500*time.Millisecond {
+			n.civPingSeq++
+			_, _ = n.civ.Write(icnPing(n.civPingSeq, n.vID, n.vRemote, uint32(time.Since(n.started).Milliseconds())))
+			lastPing = time.Now()
+		}
 	}
 }
 
@@ -661,6 +794,7 @@ func dialIcomNet(host, user, pass, compName string, rigAddr byte, cancel <-chan
 		cTracked: cTracked, cAuthSeq: cInner,
 		cToken: token, cTokReq: tokReq,
 		cSentBuf: make(map[uint16][]byte),
+		started:  time.Now(),
 	}
 	n.markRx() // the successful handshake counts as initial rig activity
 	// openClose(open) starts the CI-V data flow. We intentionally DO NOT power the
@@ -712,6 +846,11 @@ func icnHandshake(c *net.UDPConn, myID uint32, cancel <-chan struct{}) (uint32,
 		}
 		typ := icnLE.Uint16(p[4:])
 		sentid := icnLE.Uint32(p[8:])
+		// Every packet the rig sends during the handshake, verbatim. A radio that
+		// answers SOMETHING unrecognised (a newer model, a different firmware) and
+		// a radio that answers nothing are different faults, and a silent timeout
+		// hides which one this is.
+		icnHandshakeProbe(p)
 		switch typ {
 		case 0x04: // iAmHere
 			remoteID = sentid
@@ -843,11 +982,20 @@ func icnConnInfo(seq, innerSeq, tokReq uint16, sentid, rcvdid, token uint32, use
 	copy(b[0x40:0x60], []byte("IC-7610"))
 	copy(b[0x60:0x70], icnPasscode(user))
 	b[0x70] = rxEnable // rxenable: 1 opens the 50003 RX audio stream, 0 = CI-V only
-	b[0x71] = 0x00     // txenable (Phase 5)
+	// TX rides the same audio session: whenever the operator wants RX audio the
-	b[0x72] = 0x10     // rxcodec
+	// TX side is opened with it, so the voice keyer can play to the radio with
+	// no cable. Costs nothing when unused — no packets flow until a message is
+	// actually played.
+	b[0x71] = rxEnable // txenable
+	// rxcodec 0x04 = LPCM, ONE channel, 16-BIT — settled by experiment on a
+	// real IC-7760, one wrong guess at a time: 0x10 produced 1280-byte payloads
+	// of interleaved 16-bit stereo, 0x02 produced 320-byte payloads of 8-bit
+	// mono (samples hugging 0x80). 0x04 sits between them in the codec table
+	// (as in wfview): 16-bit mono, the format the 16 kHz playback path plays.
+	b[0x72] = 0x04 // rxcodec
 	b[0x73] = 0x04 // txcodec
 	icnBE.PutUint32(b[0x74:], 16000)
-	icnBE.PutUint32(b[0x78:], 8000)
+	icnBE.PutUint32(b[0x78:], 16000) // TX sample rate — the same 16 kHz everything else here runs at
 	icnBE.PutUint32(b[0x7c:], uint32(civPort))
 	icnBE.PutUint32(b[0x80:], uint32(audioPort))
 	icnBE.PutUint32(b[0x84:], 100)
@@ -855,6 +1003,26 @@ func icnConnInfo(seq, innerSeq, tokReq uint16, sentid, rcvdid, token uint32, use
 	return b
 }
 
+// PlayTXAudio plays one voice-keyer message through the 50003 audio session.
+// On the transport because the transport owns the session; the IcomSerial
+// controller forwards here after a type assertion, exactly as the TCI path
+// reaches its radio.
+func (n *icomNet) PlayTXAudio(pcm []byte, rate, ch, bits int, stop <-chan struct{}) error {
+	if n.audio == nil {
+		return fmt.Errorf("the radio's audio stream is not open — enable RX audio in Settings → CAT first")
+	}
+	return n.audio.PlayTX(pcm, rate, ch, bits, stop)
+}
+
+// TXAudioSender returns a function that streams live microphone chunks to the
+// rig — the talk button's road, where PlayTXAudio is the voice keyer's.
+func (n *icomNet) TXAudioSender() (func([]byte) error, error) {
+	if n.audio == nil {
+		return nil, fmt.Errorf("the radio's audio stream is not open — enable RX audio in Settings → CAT first")
+	}
+	return n.audio.SendTXChunk, nil
+}
+
 func icnOpenClose(seq uint16, sentid, rcvdid uint32, civSeq uint16, magic byte) []byte {
 	b := make([]byte, 0x16)
 	icnLE.PutUint32(b[0:], 0x16)
@@ -903,3 +1071,38 @@ func icnPasscode(s string) []byte {
 	}
 	return out
 }
+
+// icnHandshakeProbe logs the first packets seen during a control handshake —
+// capped hard, because a working handshake would log for ever.
+var icnProbeCount int
+
+func icnHandshakeProbe(p []byte) {
+	if icnProbeCount >= 12 {
+		return
+	}
+	icnProbeCount++
+	n := len(p)
+	if n > 32 {
+		n = 32
+	}
+	debugLog.Printf("icom net: handshake rx %d bytes: % X", len(p), p[:n])
+}
+
+// icnPing builds a CLIENT ping request (wfview's ping_packet: 0x15 bytes,
+// type 0x07, reply=0, a monotonic time at 0x11). The rig answers each one —
+// and, decisively, treats them as the client's sign of life: wfview sends one
+// every 500 ms on every stream, and OpsLog, which only ever REPLIED to the
+// rig's pings, watched the IC-7760 stop serving CI-V data about a minute into
+// every session. Same socket answered, same transport alive: the rig had
+// simply concluded nobody was listening.
+func icnPing(seq uint16, sentid, rcvdid uint32, ms uint32) []byte {
+	b := make([]byte, 0x15)
+	icnLE.PutUint32(b[0:], 0x15)
+	icnLE.PutUint16(b[4:], 0x07)
+	icnLE.PutUint16(b[6:], seq)
+	icnLE.PutUint32(b[8:], sentid)
+	icnLE.PutUint32(b[12:], rcvdid)
+	b[0x10] = 0x00
+	icnLE.PutUint32(b[0x11:], ms)
+	return b
+}

internal/cat/icomserial.go

@@ -94,6 +94,9 @@ type IcomSerial struct {
 	// reassembled sweep; scopeMu guards it (written by the scope goroutine, read
 	// via ScopeData from the binding goroutine).
 	dualScope bool
+	// Set when the rig rejects the waveform-output command in both shapes: it has
+	// no stream to give, and asking again on every enable is noise.
+	scopeUnsupported bool
 	scopeMu          sync.Mutex
 	scopeAmp         []byte
 	scopeLow         int64 // spectrum left-edge frequency (from the sweep's header frame)
@@ -113,6 +116,12 @@ type IcomSerial struct {
 	//                       "alive but silent" tolerance below, which used to be
 	//                       unbounded and left the display frozen for ever
 	silentGrace time.Duration // current width of that tolerance (backs off, see ReadState)
+	// Needle inertia for the TX meters — the CI-V meters are point samples, and
+	// between two SSB syllables a poll lands on 0 W and a perfect SWR. See
+	// meterPeak (yaesu_panel.go): power decays like a needle, SWR holds then
+	// snaps back to the live truth.
+	powerPeak meterPeak
+	swrPeak   meterPeak
 	dspLoaded bool // readDSP has run since the rig became responsive (loads all
 	//                     the panel's set-once controls once the rig actually answers)
 	// When the console last asked for the DSP snapshot. The meters and the
@@ -259,6 +268,21 @@ func (b *IcomSerial) Connect() error {
 	// 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
+	// Silence any LEFTOVER waveform stream, BLIND, before anything else. The
+	// 0x27 output flag lives in the RADIO and survives sessions; its flood is
+	// what makes the IC-7760 stop answering CI-V — so waiting for CI-V to
+	// answer before sending this (the first attempt did) was the egg asking
+	// the chicken to hatch it. Fire-and-forget: an unanswered set costs one
+	// frame, and the rig acts on what it decodes whether or not we hear the
+	// acknowledgement. The front-panel display is deliberately untouched.
+	// Synchronously: Connect already runs on the CAT goroutine, and a stray
+	// goroutine writing to the shared link would interleave with the command
+	// loop. Two forms, because the selector byte differs by model and a NAK
+	// costs one frame — and the results are LOGGED, because a kill that quietly
+	// fails leaves the flood running and the next dropout unexplained.
+	err1 := b.execScope("waveform output off (leftover)", civ.SubScopeOn, 0)
+	err2 := b.exec(civ.CmdScope, civ.SubScopeOn, 0x00, 0x00) // main-selector form
+	applog.Printf("icom: waveform-off sent at connect (plain: %v, with selector: %v)", err1, err2)
 	// 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
@@ -344,7 +368,12 @@ func (b *IcomSerial) ReadState() (RigState, error) {
 			case readerGone:
 				debugLog.Printf("icom net: the CI-V reader has exited — the connection is dead however alive the control link looks → reconnecting")
 			case at.Alive():
-				debugLog.Printf("icom net: control link answers but no CI-V reply for %s → reconnecting. Another program (WSJT-X/OmniRig, the Remote Utility) has most likely taken the CI-V session.", silentFor.Round(time.Second))
+				// No verdict on WHY: this fires for a session taken by another
+				// program (WSJT-X, the Remote Utility) AND for a rig that simply
+				// stopped answering — a real IC-7760 did exactly that once with
+				// nothing else on the network. Blaming a hijacker sent that
+				// operator hunting software that was not installed.
+				debugLog.Printf("icom net: control link answers but no CI-V reply for %s → reconnecting. Either another program took the CI-V session (WSJT-X/OmniRig/Remote Utility), or the rig stopped answering on its own.", silentFor.Round(time.Second))
 			default:
 				debugLog.Printf("icom net: control link went quiet (no rig packets for >6 s) → reconnecting. If this recurs every ~2-3 min, the rig is invalidating the session (token renewal rejected).")
 			}
@@ -393,6 +422,19 @@ func (b *IcomSerial) ReadState() (RigState, error) {
 		}
 		b.dspMu.Lock()
 		b.dsp.Mode = s.Mode
+		// The console says which SIDEBAND, not the ADIF family: "SSB" on 40 m
+		// leaves the operator guessing whether the rig is where convention puts
+		// it. The log keeps SSB; the panel shows what the radio is actually doing.
+		switch b.curModeByte {
+		case civ.ModeUSB:
+			if s.Mode == "SSB" {
+				b.dsp.Mode = "USB"
+			}
+		case civ.ModeLSB:
+			if s.Mode == "SSB" {
+				b.dsp.Mode = "LSB"
+			}
+		}
 		b.dspMu.Unlock()
 	}
 
@@ -406,8 +448,13 @@ func (b *IcomSerial) ReadState() (RigState, error) {
 	// all, for the user's Set* commands.
 	if b.pollN%4 == 1 {
 		b.splitOn, b.splitTXFreq = false, 0
-		if on, ok := b.readSplit(); ok && on {
+		on, okSplit := b.readSplit()
+		// The unselected VFO is read split or NOT: on a dual-receiver rig it is
+		// the sub receiver's dial, and the console showed it blank until split
+		// was engaged.
 		if txHz, ok2 := b.readTXFreq(); ok2 && txHz > 0 {
+			b.setCache(func(st *IcomTXState) { st.SubHz = txHz })
+			if okSplit && on {
 				b.splitOn, b.splitTXFreq = true, txHz
 			}
 		}
@@ -432,12 +479,16 @@ func (b *IcomSerial) ReadState() (RigState, error) {
 		sm, _ = b.readMeter(civ.SubMeterS)
 		po, swr = 0, 0
 		if tx {
+			now := time.Now()
 			if v, ok := b.readMeter(civ.SubMeterPo); ok {
-				po = v
+				po = b.powerPeak.update(v, now)
 			}
 			if v, ok := b.readMeter(civ.SubMeterSWR); ok {
-				swr = v
+				swr = b.swrPeak.updateSnap(v, now)
 			}
+		} else {
+			// Cleared with the carrier, so the next transmission starts fresh.
+			b.powerPeak, b.swrPeak = meterPeak{}, meterPeak{}
 		}
 	}
 	b.dspMu.Lock()
@@ -506,6 +557,13 @@ func (b *IcomSerial) refreshFrontPanel() {
 			b.dsp.Filter = int(f)
 			b.dspMu.Unlock()
 		}
+	case 2:
+		// Tuner in/out — the radio's own TUNER button changes it mid-session.
+		if v, ok := b.readSwitchSub(civ.CmdATU, civ.SubATU); ok {
+			b.dspMu.Lock()
+			b.dsp.ATUOn = v == 1
+			b.dspMu.Unlock()
+		}
 	}
 }
 
@@ -556,6 +614,18 @@ func (b *IcomSerial) SetMode(mode string) error {
 	}
 	// Filter 0x01 (FIL1) is the conventional default for the data-mode set.
 	_ = b.execIdempotent("set data mode", civ.CmdExtra, civ.SubDataMode, dataByte, 0x01)
+	// Trust, then verify: the IC-7760 acknowledges 1A 06 and stays in USB-D
+	// anyway, which left an operator unable to get back to plain USB at all.
+	// When the readback disagrees, say it again with 0x26 — mode, data flag and
+	// filter in one frame, the command the newer rigs actually honour. Only on
+	// a mismatch, so rigs that predate 0x26 never see it.
+	if got := b.readDataMode(); got != data {
+		if err := b.execIdempotent("set mode+data (0x26)", civ.CmdModeDataFil, 0x00, code, dataByte, 0x01); err != nil {
+			applog.Printf("icom: data flag stuck at %v after mode %s, and 0x26 failed too: %v", got, mode, err)
+		} else {
+			applog.Printf("icom: data flag stuck after 1A06, corrected via 0x26 (mode %s)", mode)
+		}
+	}
 	return nil
 }
 
@@ -848,6 +918,19 @@ func (b *IcomSerial) scopeLoop(spec chan civ.Decoded, done chan struct{}) {
 					loggedCfg[f.Data[0]] = true
 					applog.Printf("icom scope cfg 0x%02X: data=[% X]", f.Data[0], f.Data)
 				}
+				// The rig just told us its own layout: a mode/span/edge answer of
+				// three bytes or more carries the main/sub selector, one of two
+				// bytes does not. Worth reading, because the SET commands take the
+				// same shape and several firmwares answer a wrong-shaped set with
+				// silence rather than a rejection — which is not something the
+				// retry in execScope can act on.
+				if f.Data[0] == civ.SubScopeMode && len(f.Data) >= 2 {
+					if sel := len(f.Data) >= 3; sel != b.dualScope {
+						applog.Printf("icom scope: the rig answers 0x%02X with %d bytes — using the %s form",
+							f.Data[0], len(f.Data)-1, map[bool]string{true: "27 xx 00 …", false: "27 xx …"}[sel])
+						b.dualScope = sel
+					}
+				}
 				continue
 			}
 			if rawN < 24 {
@@ -982,6 +1065,43 @@ func (b *IcomSerial) assembleSweep(regions map[byte][]byte, total byte) {
 	}
 }
 
+// execScope sends a 0x27 SET and, if the rig rejects it, sends it once more in
+// the other shape — with or without the leading main/sub selector byte — and
+// remembers which one this rig speaks.
+//
+// The shape used to be decided from the CI-V address, which meant every new
+// model was a blank scope until someone reported it: the IC-7851 (0x8E) rejects
+// "27 11 01" outright and wants "27 11 00 01", exactly as the IC-7610 does not.
+// A rejection is a cheap and unambiguous answer, so ask the rig instead of
+// keeping a list. Only the SET commands need this — the waveform parser already
+// detects the selector per frame.
+func (b *IcomSerial) execScope(what string, sub byte, args ...byte) error {
+	try := func(sel bool) error {
+		p := []byte{civ.CmdScope, sub}
+		if sel {
+			p = append(p, 0x00) // main scope
+		}
+		return b.exec(append(p, args...)...)
+	}
+	err := try(b.dualScope)
+	// Only a REJECTION means "wrong shape". A timeout says nothing (several
+	// firmwares simply don't ack a 0x27 set), and retrying it in the other shape
+	// would flip a working rig onto the wrong one.
+	if err == nil || !strings.Contains(err.Error(), "rejected") {
+		return err
+	}
+	err2 := try(!b.dualScope)
+	applog.Printf("icom scope: %s rejected in the %s form — the other form gave: %v",
+		what, map[bool]string{true: "27 xx 00 …", false: "27 xx …"}[b.dualScope], err2)
+	if err2 == nil {
+		b.dualScope = !b.dualScope
+		applog.Printf("icom scope: %s rejected — this rig wants the %s form (selector=%v)",
+			what, map[bool]string{true: "27 xx 00 …", false: "27 xx …"}[b.dualScope], b.dualScope)
+		return nil
+	}
+	return err
+}
+
 // SetScope enables or disables the spectrum scope. Two commands are needed and
 // RS-BA1 sends both: 0x27 0x10 turns the scope DISPLAY on (without it the rig
 // streams nothing — the case when we're remote and can't touch the front panel),
@@ -1000,15 +1120,25 @@ func (b *IcomSerial) SetScope(on bool) error {
 		// 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 {
+		if err := b.execScope("display on", civ.SubScopeOnOff, 0x01); err != nil {
 			applog.Printf("icom scope: display on ack: %v", 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 {
+	if err := b.execScope("data output", civ.SubScopeOn, boolByte(on)); err != nil {
 		applog.Printf("icom scope: output on=%v ack: %v", on, err)
+		// Rejected in both shapes = the command does not exist on this rig, which
+		// is a permanent answer and not a bad guess on our part. Remember it: the
+		// panel can then say so, and we stop asking a radio that has already
+		// said no.
+		if strings.Contains(err.Error(), "rejected") {
+			applog.Printf("icom scope: %s does not stream its scope over CI-V — control commands only", b.model)
+			b.scopeMu.Lock()
+			b.scopeUnsupported = true
+			b.scopeMu.Unlock()
+		}
 	}
 	b.scopeMu.Lock()
 	b.scopeOn = on
@@ -1041,13 +1171,7 @@ func (b *IcomSerial) scopeReadCfg() {
 // makes the scope follow the VFO, so tuning pans the view left/right.
 func (b *IcomSerial) SetScopeMode(fixed bool) error {
 	mode := boolByte(fixed) // 0 = center, 1 = fixed (verify on rig via the cfg log)
-	var payload []byte
+	if err := b.execScope("set mode", civ.SubScopeMode, mode); err != nil {
-	if b.dualScope {
-		payload = []byte{civ.CmdScope, civ.SubScopeMode, 0x00, mode}
-	} else {
-		payload = []byte{civ.CmdScope, civ.SubScopeMode, mode}
-	}
-	if err := b.exec(payload...); err != nil {
 		applog.Printf("icom scope: set mode fixed=%v ack: %v", fixed, err)
 	}
 	b.scopeMu.Lock()
@@ -1093,13 +1217,8 @@ func (b *IcomSerial) SetScopeEdges(low, high int64) error {
 	if rangeID == 0 {
 		return fmt.Errorf("icom scope: freq out of range")
 	}
-	if b.dualScope {
+	_ = b.execScope("fixed mode", civ.SubScopeMode, 0x01)
-		_ = b.exec(civ.CmdScope, civ.SubScopeMode, 0x00, 0x01) // fixed mode (main)
+	_ = b.execScope("edge set 1", civ.SubScopeEdge, 0x01)
-		_ = b.exec(civ.CmdScope, civ.SubScopeEdge, 0x00, 0x01) // activate edge set 1
-	} else {
-		_ = b.exec(civ.CmdScope, civ.SubScopeMode, 0x01)
-		_ = b.exec(civ.CmdScope, civ.SubScopeEdge, 0x01)
-	}
 	payload := append([]byte{civ.CmdScope, civ.SubScopeFixEdge, rangeID, 0x01}, civ.FreqToBCD(low)...)
 	payload = append(payload, civ.FreqToBCD(high)...)
 	b.scopeMu.Lock()
@@ -1263,7 +1382,8 @@ func (b *IcomSerial) ScopeData() ScopeSweep {
 	for i, v := range b.scopeAmp {
 		amp[i] = int(v)
 	}
-	return ScopeSweep{Amp: amp, Seq: b.scopeSeq, LowHz: b.scopeLow, HighHz: b.scopeHigh, Fixed: b.scopeFixed}
+	return ScopeSweep{Amp: amp, Seq: b.scopeSeq, LowHz: b.scopeLow, HighHz: b.scopeHigh, Fixed: b.scopeFixed,
+		Unsupported: b.scopeUnsupported}
 }
 
 // exec sends a set command and waits for the rig's OK (FB) / NG (FA) ack.
@@ -1429,6 +1549,12 @@ func (b *IcomSerial) modeCode(mode string) (code byte, data bool, err error) {
 		return civ.ModeFM, false, nil
 	case "RTTY", "FSK":
 		return civ.ModeRTTY, false, nil
+	case "PSK":
+		// The console button, not the ADIF mode: the rigs that HAVE a native PSK
+		// mode (7610/7760/7851 class) get it; a 7300 NAKs 0x12 and the button
+		// stays dead there, exactly as RS-BA1's does. Soundcard PSK31 stays on
+		// USB-D below, where every rig can do it.
+		return civ.ModePSK, false, nil
 	case "FT8", "FT4", "PSK31", "MFSK", "JS8", "JT65", "JT9", "OLIVIA", "DATA", "DIGITALVOICE":
 		// Digital data modes ride on USB with the data flag set (FT8 etc.).
 		return civ.ModeUSB, true, nil
@@ -1779,10 +1905,16 @@ func (b *IcomSerial) SetMicGain(p int) error {
 }
 
 func (b *IcomSerial) SetIcomSplit(on bool) error {
+	return b.SetIcomSplitOffset(on, 0)
+}
+
+// SetIcomSplitOffset enables split with a CHOSEN TX offset in Hz (0 = the
+// usual convention: +1 kHz on CW, +5 kHz otherwise). The console offers
+// +1/+5/+10 directly, DXpedition style.
+func (b *IcomSerial) SetIcomSplitOffset(on bool, offsetHz int64) error {
 	if on {
-		// Enable split with the usual "work him up" TX offset: +1 kHz on CW,
+		// Set the unselected (TX) VFO to RX+offset first, then turn split on.
-		// +5 kHz otherwise (SSB). Set the unselected (TX) VFO to RX+offset first,
+		// 0x25 0x01 + BCD sets the unselected VFO's frequency.
-		// then turn split on. 0x25 0x01 + BCD sets the unselected VFO's frequency.
 		rx := b.curFreq
 		if rx <= 0 {
 			if hz, err := b.readFreq(); err == nil {
@@ -1790,12 +1922,39 @@ func (b *IcomSerial) SetIcomSplit(on bool) error {
 			}
 		}
 		if rx > 0 {
-			offset := int64(5000)
+			offset := offsetHz
+			if offset <= 0 {
+				offset = 5000
 				if b.curModeByte == civ.ModeCW || b.curModeByte == civ.ModeCWR {
 					offset = 1000
 				}
+			}
 			_ = b.exec(append([]byte{civ.CmdVfoFreq, civ.SubVfoUnselected}, civ.FreqToBCD(rx+offset)...)...)
 		}
+		// And the MODE crosses with it: a split where the TX VFO is still on
+		// yesterday's mode transmits FM into a CW pileup. 0x26 0x01 sets the
+		// unselected VFO's mode + data flag in one frame; rigs that predate
+		// 0x26 NAK it harmlessly and behave as they always did.
+		if b.curModeByte == 0 {
+			// A fresh session may not have read the mode yet — ask, or the copy
+			// below would send mode 0 (LSB) whatever the main is on.
+			if m, ok := b.readMode(); ok {
+				b.curModeByte = m
+			}
+		}
+		if b.curModeByte != 0 {
+			dataByte := byte(0)
+			if got := b.readDataMode(); got {
+				dataByte = 1
+			}
+			// Logged, not discarded: the first version swallowed the error and a
+			// real 7760's sub VFO kept yesterday's mode with nothing to show why.
+			if err := b.exec(civ.CmdModeDataFil, 0x01, b.curModeByte, dataByte, 0x01); err != nil {
+				applog.Printf("icom: split mode-align (26 01 %02X %d) refused: %v", b.curModeByte, dataByte, err)
+			} else {
+				applog.Printf("icom: split mode-align OK (26 01 %02X %d)", b.curModeByte, dataByte)
+			}
+		}
 	}
 	if err := b.exec(civ.CmdSplit, boolByte(on)); err != nil {
 		return err
@@ -1929,6 +2088,17 @@ func (b *IcomSerial) TuneATU() error {
 	return b.exec(civ.CmdATU, civ.SubATU, 0x02)
 }
 
+// SetATU engages or DISENGAGES the internal tuner (0x1C 0x01: 1 = in line,
+// 0 = through). Tune existed without this, which meant a tuner once engaged
+// could not be taken out of line again from the console.
+func (b *IcomSerial) SetATU(on bool) error {
+	if err := b.exec(civ.CmdATU, civ.SubATU, boolByte(on)); err != nil {
+		return err
+	}
+	b.setCache(func(s *IcomTXState) { s.ATUOn = on })
+	return nil
+}
+
 func (b *IcomSerial) setCache(fn func(*IcomTXState)) {
 	b.dspMu.Lock()
 	fn(&b.dsp)
@@ -1971,3 +2141,42 @@ func agcValue(name string) byte {
 	}
 	return 0
 }
+
+// PlayTXAudio hands a voice-keyer message to the network audio session, when
+// this rig is reached over one. A USB-connected Icom takes its audio through
+// its own sound card instead, and says so.
+func (b *IcomSerial) PlayTXAudio(pcm []byte, rate, ch, bits int, stop <-chan struct{}) error {
+	// port is written once per Connect, on the CAT goroutine this is fetched
+	// from (IcomDo); at worst a reconnect leaves this one connection stale, and
+	// a stale transport fails fast on its closed done channel.
+	port := b.port
+	// A nil port fails the assertions below too — and used to fail them with
+	// the sound-card message, sending an operator whose radio was simply OFF
+	// hunting through their audio devices.
+	if port == nil {
+		return fmt.Errorf("not connected to the radio — check the CAT link")
+	}
+	type txPlayer interface {
+		PlayTXAudio(pcm []byte, rate, ch, bits int, stop <-chan struct{}) error
+	}
+	if p, ok := port.(txPlayer); ok {
+		return p.PlayTXAudio(pcm, rate, ch, bits, stop)
+	}
+	return fmt.Errorf("this rig takes transmit audio through its USB sound card, not the CAT link")
+}
+
+// TXAudioSender hands back the network transport's live-mic sender, when this
+// rig is reached over one.
+func (b *IcomSerial) TXAudioSender() (func([]byte) error, error) {
+	port := b.port
+	if port == nil {
+		return nil, fmt.Errorf("not connected to the radio — check the CAT link")
+	}
+	type sender interface {
+		TXAudioSender() (func([]byte) error, error)
+	}
+	if p, ok := port.(sender); ok {
+		return p.TXAudioSender()
+	}
+	return nil, fmt.Errorf("this rig takes transmit audio through its USB sound card, not the CAT link")
+}

internal/cat/kenwood_panel.go

@@ -35,6 +35,11 @@ type KenwoodTXState struct {
 	Model     string `json:"model,omitempty"`
 	Elecraft  bool   `json:"elecraft"` // a K3/K4 rather than a Kenwood
 	Mode      string `json:"mode,omitempty"`
+	// DataSub is the K3/K4 DATA submode while in DATA mode (DT): "DATA A",
+	// "AFSK A", "FSK D" or "PSK D". Empty on a Kenwood, and outside DATA. The
+	// panel's two DATA buttons need it to show WHICH data mode the rig is in —
+	// FT8 wants DATA A, RTTY wants FSK D, and MD6 alone cannot say which.
+	DataSub string `json:"data_sub,omitempty"`
 
 	Transmitting bool  `json:"transmitting"`
 	Split        bool  `json:"split"`
@@ -48,6 +53,12 @@ type KenwoodTXState struct {
 	// PowerMeter is 0-100 while transmitting. SWR is the ratio; 0 means "not
 	// measured", NOT a perfect match.
 	PowerMeter int `json:"power_meter"`
+	// PowerW is the transmit power in WATTS, derived from the bargraph and the
+	// meter's RANGE. The K3's bar is relative to a range that flips at 12 W —
+	// calibrated against a real one: 10 W showed 83 (10/12), 100 W showed 83
+	// too (100/120). The bar alone never was watts; with the PC setting to
+	// pick the range, it converts. 0 while receiving.
+	PowerW int     `json:"power_w"`
 	SWR    float64 `json:"swr"`
 	SWRRaw int     `json:"swr_raw"`
 
@@ -107,10 +118,12 @@ type KenwoodPanelController interface {
 	SetKenwoodRIT(bool) error
 	SetKenwoodXIT(bool) error
 	NudgeKenwoodRIT(int) error
+	SetKenwoodRITOffset(int) error
 	ClearKenwoodRIT() error
 	SetKenwoodTX(bool) error
 	TuneKenwoodATU() error
 	ToggleKenwoodATU() error
+	SetKenwoodPanelMode(string) error
 }
 
 // kenwoodPanelSlowBeat is how many polls pass between full re-reads of the
@@ -155,6 +168,7 @@ func (k *Kenwood) readPanel(mode string, split bool, txHz int64, txNow bool) {
 		// Cleared, not frozen: a power bar left standing after the carrier drops
 		// reads as a live transmission.
 		k.panel.PowerMeter = 0
+		k.panel.PowerW = 0
 		k.panel.SWR, k.panel.SWRRaw = 0, 0
 		k.powerPeak, k.swrPeak = meterPeak{}, meterPeak{}
 		// The S-meter only means anything while receiving.
@@ -212,6 +226,14 @@ func (k *Kenwood) readPanelSettings() {
 	if v, ok := k.askNum("NR;", "NR", 1); ok {
 		k.panel.NR = v != 0
 	}
+	// The DATA submode, Elecraft only (a plain Kenwood has no DT and would "?;"
+	// it). Read every settings beat: the operator changes it from the rig's own
+	// front panel mid-session, and the two DATA buttons must follow.
+	if k.elecraft {
+		if v, ok := k.askNum("DT;", "DT", 1); ok {
+			k.panel.DataSub = kenwoodDataSubName(v)
+		}
+	}
 	if v, ok := k.askNum("GT;", "GT", 3); ok {
 		k.panel.AGC = kenwoodAGCName(v)
 	}
@@ -326,6 +348,13 @@ func (k *Kenwood) readTXMeters() {
 	defer func() { k.noLatch = false }()
 	if v, ok := k.askNum("BG;", "BG", 2); ok {
 		k.panel.PowerMeter = k.powerPeak.update(kenwoodBargraphPercent(v), now)
+		if k.elecraft {
+			scale := 120
+			if k.panel.RFPower > 0 && k.panel.RFPower <= 12 {
+				scale = 12 // the K3's QRP range
+			}
+			k.panel.PowerW = k.panel.PowerMeter * scale / 100
+		}
 	}
 	// SW; — SETTLED, from Elecraft's own release note: three digits, tenths of a
 	// ratio. "SW023;" is 2.3:1, and "SW999;" is the 99.9:1 it reports instead of
@@ -334,7 +363,7 @@ func (k *Kenwood) readTXMeters() {
 	if v, ok := k.askNum("SW;", "SW", 3); ok {
 		k.panel.SWRRaw = v
 		if v > 0 {
-			k.panel.SWR = float64(k.swrPeak.update(v, now)) / 10
+			k.panel.SWR = float64(k.swrPeak.updateSnap(v, now)) / 10
 		}
 	}
 	if k.metersLogged >= 20 {
@@ -564,6 +593,16 @@ func (k *Kenwood) SetKenwoodXIT(on bool) error {
 
 // ClearKenwoodRIT zeroes the RIT/XIT offset, both at once — which is what RC
 // does and what the operator means by "clear it".
+// SetKenwoodRITOffset writes the offset as an ABSOLUTE value — what the shared
+// ShiftRow control speaks. Nudge stays for the keyboard clarifier; both funnel
+// into the same RO write.
+func (k *Kenwood) SetKenwoodRITOffset(hz int) error {
+	k.mu.Lock()
+	cur := k.panel.RITOffset
+	k.mu.Unlock()
+	return k.NudgeKenwoodRIT(hz - cur)
+}
+
 func (k *Kenwood) ClearKenwoodRIT() error {
 	return k.setPanel("RC;")
 }
@@ -650,3 +689,58 @@ func (k *Kenwood) askNum(cmd, prefix string, digits int) (int, bool) {
 	}
 	return n, true
 }
+
+// kenwoodDataSubName decodes DT (K3/K4 programmer's reference).
+func kenwoodDataSubName(v int) string {
+	switch v {
+	case 0:
+		return "DATA A"
+	case 1:
+		return "AFSK A"
+	case 2:
+		return "FSK D"
+	case 3:
+		return "PSK D"
+	}
+	return ""
+}
+
+// SetKenwoodPanelMode is the panel's mode row: CW / USB / LSB / DATA / RTTY.
+//
+// It exists because SetMode is the LOGGER's path — it maps an ADIF mode and
+// honours the data-mode preference — while a panel button is the operator
+// saying exactly what the rig should do. The two DATA cases are the point:
+// "DATA" is MD6 + DT0 (DATA A, the soundcard submode FT8/FT4 modulate through)
+// and "RTTY" is MD6 + DT2 (FSK D, the K3's direct-keyed RTTY). MD6 alone keeps
+// whatever submode a prior session left, which is how a K3 "in DATA" transmits
+// FT8 with no audio — the report behind this row.
+func (k *Kenwood) SetKenwoodPanelMode(mode string) error {
+	k.mu.Lock()
+	defer k.mu.Unlock()
+	if k.port == nil {
+		return fmt.Errorf("kenwood: not connected")
+	}
+	var cmds []string
+	switch strings.ToUpper(strings.TrimSpace(mode)) {
+	case "CW":
+		cmds = []string{"MD3;"}
+	case "USB":
+		cmds = []string{"MD2;"}
+	case "LSB":
+		cmds = []string{"MD1;"}
+	case "DATA":
+		cmds = []string{"MD6;", "DT0;"}
+	case "RTTY":
+		cmds = []string{"MD6;", "DT2;"}
+	default:
+		return fmt.Errorf("kenwood panel: unknown mode %q", mode)
+	}
+	for _, c := range cmds {
+		if err := k.write(c); err != nil {
+			return err
+		}
+	}
+	// Re-read the settings on the next poll so Mode and DataSub confirm at once.
+	k.panelCycle = kenwoodPanelSlowBeat
+	return nil
+}

internal/cat/omnirig.go

@@ -553,6 +553,13 @@ func (o *OmniRig) SetFrequency(hz int64) error {
 		props := []string{prop, "Freq"}
 		if onSubVFO {
 			props = []string{prop}
+		} else if isYaesu && split&pmSplitOn != 0 && split&pmSplitOff == 0 {
+			// Yaesu with SPLIT engaged: the generic Freq write lands on the TX
+			// VFO — an FT-2000 moved B and left A (the receiver) behind, so a
+			// spot click QSYed the transmitter and nothing audible changed.
+			// Both VFOs are written: the radio arrives on the spot RX and TX
+			// together, split left as the operator had it.
+			props = []string{"FreqA", "FreqB", "Freq"}
 		}
 		for _, p := range props {
 			if _, e := oleutil.PutProperty(o.rig, p, hz32); e != nil {

internal/cat/tci.go

@@ -27,6 +27,14 @@ type TCI struct {
 
 	digitalDefault string // surfaced when the rig reports a digital mode (FT8/…)
 	spotsEnabled   bool   // mirror cluster spots onto the TCI panorama
+	// wantFreq is the frequency last COMMANDED and not yet echoed back, used to
+	// pick the sideband before the radio has confirmed the move.
+	wantFreq int64
+	// What the server said it is, from its "protocol:" announcement.
+	serverName    string
+	serverVersion string
+	// How many spots have been logged verbatim (the first few only).
+	spotsSent int
 
 	// OnSpotClick is called when the user clicks one of our spots on the TCI
 	// panorama (callsign + freq), so the host can fill the entry form. Set before
@@ -149,6 +157,15 @@ func (t *TCI) Connect() error {
 	t.mu.Unlock()
 	debugLog.Printf("TCI: connected to %s", url)
 	go t.reader(conn)
+	// Ask for the meters. Nothing measures anything until this goes out: the
+	// S-meter, the transmit power and the SWR are all pushed by the radio, and
+	// only to a client that has subscribed. 200 ms is the rate the protocol's own
+	// examples use — fast enough for a needle, slow enough not to flood a socket
+	// that also carries audio.
+	if t.spotsEnabled {
+		debugLog.Printf("TCI: panorama spots are ON — spots will be sent to the radio")
+	}
+	t.subscribeSensors("connect")
 	if t.spotsEnabled {
 		// Forget what we thought was on the panorama at the same moment the radio
 		// is told to drop it. Kept, the memory would suppress the next spot for
@@ -228,11 +245,19 @@ func (t *TCI) SendSpot(s SpotInfo) error {
 		// other two matching what already works here.
 		_ = t.send(fmt.Sprintf("spot_delete:%s;", call))
 	}
-	// TCI's SPOT command wants the colour as a signed 32-bit DECIMAL integer in
+	// The colour is a DECIMAL ARGB integer, and an UNSIGNED one.
-	// 0xAARRGGBB order — NOT a "0x…" hex string (e.g. "spot:UN7GK,cw,14025000,
+	//
-	// -16776961,test;"). ExpertSDR silently drops a spot whose colour field it
+	// Expert Electronics' own protocol document gives the whole command:
-	// can't parse as a number, which is why spots never showed on the panorama
+	//
-	// while tuning (a separate command) still worked.
+	//	SPOT:RN6LHF,CW,7100000,16711680,ANY_TEXT;
+	//
+	// 16711680 is 0x00FF0000 — positive, alpha zero. This backend was sending
+	// the same number as a SIGNED 32-bit value, taken from a third-party
+	// example: with the alpha byte set to FF for opacity, 0xFFFFA500 becomes
+	// -22336, and a spot whose colour field ExpertSDR cannot read is dropped in
+	// silence. Reported on ExpertSDR3 1.3 (which speaks TCI 2.x, so the version
+	// was never the problem): everything else worked and the panorama stayed
+	// empty.
 	hex := strings.TrimPrefix(strings.TrimPrefix(strings.TrimSpace(s.Color), "#"), "0x")
 	if hex == "" {
 		hex = "FFFFA500" // opaque orange default
@@ -253,7 +278,15 @@ func (t *TCI) SendSpot(s SpotInfo) error {
 	}
 	// Commas/semicolons would break TCI's comma-separated argument parsing.
 	text := strings.NewReplacer(",", " ", ";", " ").Replace(s.Comment)
-	return t.send(fmt.Sprintf("spot:%s,%s,%d,%d,%s;", call, mode, s.FreqHz, int32(argb), text))
+	cmd := fmt.Sprintf("spot:%s,%s,%d,%d,%s;", call, mode, s.FreqHz, argb, text)
+	// The first few, verbatim. A spot that the radio ignores leaves no trace at
+	// all — no reply, no error — so the only evidence that OpsLog sent one, and
+	// in what shape, is this line.
+	if n := t.spotsSent; n < 3 {
+		t.spotsSent = n + 1
+		debugLog.Printf("TCI: sending spot #%d: %s", n+1, strings.TrimSuffix(cmd, ";"))
+	}
+	return t.send(cmd)
 }
 
 // Disconnect closes the WebSocket; the reader goroutine then exits.
@@ -334,6 +367,11 @@ func (t *TCI) ReadState() (RigState, error) {
 
 // SetFrequency tunes VFO A (the main/RX VFO).
 func (t *TCI) SetFrequency(hz int64) error {
+	// Remember what we ASKED for. SetMode reads it to choose the sideband, and
+	// the radio's own echo can be a moment behind — see SetMode.
+	t.mu.Lock()
+	t.wantFreq = hz
+	t.mu.Unlock()
 	return t.send(fmt.Sprintf("vfo:0,0,%d;", hz))
 }
 
@@ -342,6 +380,17 @@ func (t *TCI) SetFrequency(hz int64) error {
 func (t *TCI) SetMode(mode string) error {
 	t.mu.Lock()
 	freq := t.freqA
+	// Prefer the frequency we just COMMANDED over the one the radio has echoed.
+	//
+	// Clicking a spot sets the frequency and then the mode, and the sideband is
+	// chosen from the frequency (below 10 MHz → LSB). Read from the echo, that
+	// is the frequency we were on BEFORE the click whenever the echo has not
+	// landed yet: a 14 MHz spot clicked from 7 MHz got LSB, and clicking the same
+	// spot again — now that the echo has arrived — got USB. Reported from a
+	// SunSDR as "the frequency is right, the mode is wrong until I click twice".
+	if t.wantFreq > 0 {
+		freq = t.wantFreq
+	}
 	t.mu.Unlock()
 	m := adifToTCIMode(mode, freq)
 	if m == "" {
@@ -411,6 +460,24 @@ func (t *TCI) SetTXAudioSource(src string) {
 }
 
 // send writes a command to the WebSocket (one writer at a time).
+// subscribeSensors asks the radio to push its meters. Nothing measures anything
+// until this goes out — the S-meter, the transmit power and the SWR are all
+// subscription-only (TCI §4.4) — and it is sent at connect AND again at every
+// "ready", because a subscription sent during the server's initial dump can be
+// dropped. 200 ms is the rate the protocol's own examples use.
+func (t *TCI) subscribeSensors(when string) {
+	// Both cases, deliberately. Every other command this backend sends works in
+	// lower case, but the meters stayed silent on a real SunSDR through two
+	// rounds of fixes — and the protocol document's own examples are upper case
+	// (TX_SENSORS_ENABLE:true,200;). A server that is case-insensitive ignores
+	// the duplicate; one that is not finally hears the subscription.
+	e1 := t.send("rx_sensors_enable:true,200;")
+	e2 := t.send("tx_sensors_enable:true,200;")
+	_ = t.send("RX_SENSORS_ENABLE:true,200;")
+	_ = t.send("TX_SENSORS_ENABLE:true,200;")
+	debugLog.Printf("TCI: sensor subscription sent (%s, both cases): rx=%v tx=%v", when, e1, e2)
+}
+
 func (t *TCI) send(cmd string) error {
 	t.mu.Lock()
 	c := t.conn
@@ -493,6 +560,18 @@ func (t *TCI) handle(msg string) {
 	switch lower {
 	case "device":
 		t.device = strings.TrimSpace(args)
+	// The server's own announcement: "protocol:ExpertSDR3,1.9;" — its name and
+	// the TCI version it speaks. Worth keeping rather than filing under
+	// "unhandled": panorama spots need a version that HAS the spot command, and
+	// without this an operator on an older ExpertSDR sees nothing on the
+	// waterfall and nothing anywhere saying why.
+	case "protocol":
+		t.serverName, t.serverVersion = get(0), get(1)
+		debugLog.Printf("TCI: server is %s, TCI %s", t.serverName, t.serverVersion)
+		if t.spotsEnabled && tciSpotsUnsupported(t.serverVersion) {
+			debugLog.Printf("TCI: this server speaks TCI %s — panorama spots need 1.5 or later, so they will not appear",
+				t.serverVersion)
+		}
 	// The radio ANNOUNCES its audio format at connect —
 	// "audio_stream_sample_type:float32" and "audio_stream_channels:2" — which
 	// is better evidence than anything derived from a frame, and it arrives
@@ -505,6 +584,13 @@ func (t *TCI) handle(msg string) {
 		}
 	case "ready", "start":
 		t.ready = true
+		// (Re)subscribe to the meters HERE, not only at connect. ExpertSDR3
+		// dumps its whole state and then says "ready"; a unidirectional control
+		// command sent while that dump is still in flight can be ignored, and
+		// the report from a real SunSDR — transmit meters still empty after the
+		// connect-time subscription — has exactly that shape. From a goroutine:
+		// send takes t.mu, which this handler holds.
+		go t.subscribeSensors("ready")
 	case "stop":
 		t.ready = false
 	case "vfo":
@@ -516,6 +602,10 @@ func (t *TCI) handle(msg string) {
 				switch get(1) {
 				case "0":
 					t.freqA = hz
+					// The radio has caught up: from here the echo IS the truth.
+					if t.wantFreq != 0 && absInt64(hz-t.wantFreq) < 100 {
+						t.wantFreq = 0
+					}
 				case "1":
 					t.freqB = hz
 				}
@@ -651,3 +741,18 @@ func adifToTCIMode(mode string, freqHz int64) string {
 		return "digu"
 	}
 }
+
+// tciSpotsUnsupported reports whether a TCI version predates the spot commands.
+//
+// SPOT / SPOT_DELETE / SPOT_CLEAR arrived in TCI 1.5. An older ExpertSDR accepts
+// the connection, answers frequency and mode perfectly, and silently ignores
+// every spot — which is indistinguishable from a bug in the logger unless
+// somebody says so. Anything unparseable is treated as supported: refusing to
+// draw on a doubt would be the worse mistake.
+func tciSpotsUnsupported(version string) bool {
+	var maj, min int
+	if n, err := fmt.Sscanf(strings.TrimSpace(version), "%d.%d", &maj, &min); n < 2 || err != nil {
+		return false
+	}
+	return maj < 1 || (maj == 1 && min < 5)
+}

internal/cat/tci_cw.go

@@ -0,0 +1,72 @@
+package cat
+
+import (
+	"fmt"
+	"strings"
+)
+
+// CW keying over TCI — a sixth CW engine, so a SunSDR needs no WinKeyer and no
+// second serial port: the radio's own macro keyer is driven over the WebSocket
+// that already carries the CAT.
+//
+// The commands, from the TCI command table (confirmed against ars-ka0s/eesdr-tci,
+// the same source that settled SPOT):
+//
+//	CW_MACROS:<trx>,<text>;   send text through the radio's keyer
+//	CW_MACROS_SPEED:<wpm>;    the speed those macros are keyed at
+//	CW_MACROS_STOP;           abort what is being keyed
+//	CW_MACROS_EMPTY;          the radio saying the buffer has run dry
+//
+// CW_MSG (TCI 2.0) does the same with separate before/after callsign fields.
+// CW_MACROS is used instead because it exists from 1.6 and OpsLog resolves the
+// variables itself — the text handed here is already what should go on the air.
+//
+// Notably absent: there is no backspace. The FlexRadio CWX keyer can un-type
+// what has not been sent yet; TCI can only stop. So the type-ahead correction
+// the Flex engine offers is not offered here rather than faked.
+
+// tciCWTextLimit caps one macro. A runaway paste down a WebSocket that also
+// carries audio is worth refusing, and no real CW message is this long.
+const tciCWTextLimit = 512
+
+// SendCW keys a message through the radio's macro keyer.
+func (t *TCI) SendCW(text string) error {
+	msg := sanitiseTCICW(text)
+	if msg == "" {
+		return nil
+	}
+	return t.send(fmt.Sprintf("cw_macros:0,%s;", msg))
+}
+
+// StopCW aborts the message being keyed.
+func (t *TCI) StopCW() error { return t.send("cw_macros_stop;") }
+
+// SetCWSpeed sets the macro keyer speed in words per minute.
+//
+// Only the MACRO speed: the paddle keyer has its own (CW_KEYER_SPEED) and an
+// operator who has set their paddle to 28 wpm did not ask the logger to change
+// it because a macro went out at 25.
+func (t *TCI) SetCWSpeed(wpm int) error {
+	if wpm < 5 {
+		wpm = 5
+	}
+	if wpm > 60 {
+		wpm = 60
+	}
+	return t.send(fmt.Sprintf("cw_macros_speed:%d;", wpm))
+}
+
+// sanitiseTCICW makes a message safe to put in a TCI command.
+//
+// Commas and semicolons are the protocol's own separators — a comma inside the
+// text would be read as another argument and a semicolon would end the command
+// early, keying half a message and leaving the rest to be parsed as a command of
+// its own. Neither belongs in Morse anyway.
+func sanitiseTCICW(text string) string {
+	s := strings.ToUpper(strings.TrimSpace(text))
+	s = strings.NewReplacer(",", " ", ";", " ", "\r", " ", "\n", " ").Replace(s)
+	if len(s) > tciCWTextLimit {
+		s = s[:tciCWTextLimit]
+	}
+	return strings.TrimSpace(s)
+}

internal/cat/tci_manager.go

@@ -96,3 +96,26 @@ func (m *Manager) TCIPanelDo(fn func(TCIPanelController) error) error {
 		return fn(tc)
 	})
 }
+
+// TCICWController is the radio's CW keyer, as the CW engine uses it.
+//
+// Three methods, and no backspace: TCI can stop a message but cannot un-type one
+// (see tci_cw.go). Kept as its own interface rather than folded into the console
+// one so a CW engine does not have to depend on forty panel setters to key a
+// message.
+type TCICWController interface {
+	SendCW(text string) error
+	StopCW() error
+	SetCWSpeed(wpm int) error
+}
+
+// TCICWDo dispatches one keyer command onto the CAT goroutine.
+func (m *Manager) TCICWDo(fn func(TCICWController) error) error {
+	return m.exec(func(b Backend) error {
+		tc, ok := b.(TCICWController)
+		if !ok {
+			return fmt.Errorf("the active CAT backend is not a TCI radio")
+		}
+		return fn(tc)
+	})
+}

internal/cat/tci_panel.go

@@ -113,7 +113,8 @@ func (t *TCI) handlePanel(name string, get func(int) string, args string) bool {
 	// it. What the radio actually announces after the command settles whether
 	// this is our reading or its doing, and no amount of reasoning will.
 	switch name {
-	case "mute", "sql_enable", "sql_level", "tx_power", "tx_swr", "tune":
+	case "mute", "sql_enable", "sql_level", "tx_power", "tx_swr", "tune",
+		"tx_sensors", "rx_sensors", "rx_channel_sensors":
 		// Logged on arrival so an ANSWER can be told from a SILENCE: the log
 		// showed the transmit meters being asked for and nothing coming back,
 		// which on its own proves nothing — a reply that arrived and failed to
@@ -233,6 +234,42 @@ func (t *TCI) handlePanel(name string, get func(int) string, args string) bool {
 		if n, ok := num(get(1)); ok && forRX0() {
 			p.SMeter = n
 		}
+	// The meters of ExpertSDR3. The S-meter used to be read only from RX_SMETER
+	// and the transmit ones from TX_POWER / TX_SWR — commands this radio simply
+	// never sends, which is why the console's meters sat empty on a SunSDR in
+	// both RX and TX while everything else worked.
+	//
+	// The protocol's own answer (TCI Protocol.pdf, §4.4) is a SUBSCRIPTION:
+	//
+	//	RX_SENSORS:<rx>,<dBm>;                       (deprecated in 2.0)
+	//	RX_CHANNEL_SENSORS:<rx>,<channel>,<dBm>;     (its replacement)
+	//	TX_SENSORS:<trx>,<mic dBm>,<power W>,<peak W>,<SWR>;
+	//
+	// none of which arrives until the client asks with RX_SENSORS_ENABLE and
+	// TX_SENSORS_ENABLE — see Connect.
+	case "rx_sensors":
+		if v, err := strconv.ParseFloat(strings.TrimSpace(get(1)), 64); err == nil && forRX0() {
+			p.SMeter = int(v)
+		}
+	case "rx_channel_sensors":
+		// Main channel (A) of receiver 0: the one the console is showing.
+		if v, err := strconv.ParseFloat(strings.TrimSpace(get(2)), 64); err == nil &&
+			get(0) == "0" && get(1) == "0" {
+			p.SMeter = int(v)
+		}
+	case "tx_sensors":
+		if get(0) != "0" {
+			break
+		}
+		// arg3 is RMS power, arg4 the peak. The peak is what a power meter's
+		// needle does on speech; the RMS is what the operator is asked to keep
+		// under the amplifier's limit — so RMS is the number, as elsewhere.
+		if v, err := strconv.ParseFloat(strings.TrimSpace(get(2)), 64); err == nil {
+			p.TXPowerW = v
+		}
+		if v, err := strconv.ParseFloat(strings.TrimSpace(get(4)), 64); err == nil {
+			p.TXSWR = v
+		}
 	case "tune":
 		if forRX0() {
 			p.Tuning = yes(get(1))

internal/cat/tci_test.go

@@ -0,0 +1,41 @@
+package cat
+
+import "testing"
+
+func TestTCISpotsUnsupported(t *testing.T) {
+	// SPOT arrived in TCI 1.5. The SunSDR2 PRO report that prompted this was an
+	// ExpertSDR announcing 1.3 — spots accepted and silently dropped.
+	for _, c := range []struct {
+		version string
+		old     bool
+	}{
+		{"1.3", true},
+		{"1.4", true},
+		{"1.5", false},
+		{"1.9", false},
+		{"2.0", false},
+		{"", false},      // unparseable → assume it works
+		{"weird", false}, // refusing to draw on a doubt is the worse mistake
+	} {
+		if got := tciSpotsUnsupported(c.version); got != c.old {
+			t.Errorf("tciSpotsUnsupported(%q) = %v, want %v", c.version, got, c.old)
+		}
+	}
+}
+
+func TestSanitiseTCICW(t *testing.T) {
+	// The separators must never survive: a comma would become another argument
+	// and a semicolon would end the command with the message half sent.
+	for _, c := range []struct{ in, want string }{
+		{"cq cq de f4bpo", "CQ CQ DE F4BPO"},
+		{" tu 599 ", "TU 599"},
+		{"73, gl", "73  GL"},
+		{"test;cw_macros_stop", "TEST CW_MACROS_STOP"},
+		{"line\r\nbreak", "LINE  BREAK"},
+		{"   ", ""},
+	} {
+		if got := sanitiseTCICW(c.in); got != c.want {
+			t.Errorf("sanitiseTCICW(%q) = %q, want %q", c.in, got, c.want)
+		}
+	}
+}

internal/cat/yaesu_panel.go

@@ -905,3 +905,22 @@ func yaesuSplitCommand(cmd, vfo string, on bool) string {
 	}
 	return cmd + "0;"
 }
+
+// updateSnap is update for a meter where lingering is misinformation: the peak
+// stands for the hold, then the display returns to the live sample AT ONCE.
+// Made for the K3's SWR — the radio throws a brief SWR spike as an FT8 frame
+// ends, and the quarter-of-the-gap decay above turned that one bad sample into
+// twelve seconds of alarming red on the next transmission. A needle's inertia
+// suits a power meter; an SWR reading is a warning light, and a warning that
+// fades slowly reads as a fault that is slowly getting better.
+func (m *meterPeak) updateSnap(sample int, now time.Time) int {
+	if sample >= m.val {
+		m.val, m.at = sample, now
+		return m.val
+	}
+	if now.Sub(m.at) < meterHold {
+		return m.val
+	}
+	m.val, m.at = sample, now
+	return m.val
+}

internal/cluster/cluster.go

@@ -75,6 +75,10 @@ type Spot struct {
 	Historical bool   `json:"historical,omitempty"`
 	POTARef    string `json:"pota_ref,omitempty"`  // park id if this station is activating (api.pota.app)
 	POTAName   string `json:"pota_name,omitempty"` // park name
+	// SOTARef comes from the COMMENT, not from an API: the SOTA clusters put the
+	// summit in the text of the spot they send ("W9/WI-001"), and there is no
+	// per-callsign endpoint to ask the way POTA has one.
+	SOTARef string `json:"sota_ref,omitempty"`
 }
 
 // State enumerates the per-server lifecycle.

internal/cluster/sotaref.go

@@ -0,0 +1,21 @@
+package cluster
+
+import "regexp"
+
+// sotaRefRe matches a SOTA summit reference inside a spot comment.
+//
+// The shape is association/region-NNN — "W9/WI-001", "DM/BM-063", "VK3/VC-014",
+// "F/AM-123" — and the association may carry digits. Anchored on both sides so
+// a callsign like DL/SP9DPM/P can never be read as one, and deliberately
+// narrower than "anything with a slash and a dash": POTA (US-4475) and WWFF
+// (DLFF-0001) refs share the comment field and must not be caught here.
+var sotaRefRe = regexp.MustCompile(`\b([A-Z0-9]{1,4}(?:/[A-Z0-9]{1,4})?/[A-Z]{2}-[0-9]{3})\b`)
+
+// SOTARefFrom returns the first SOTA reference in a spot comment, or "".
+func SOTARefFrom(comment string) string {
+	m := sotaRefRe.FindStringSubmatch(comment)
+	if m == nil {
+		return ""
+	}
+	return m[1]
+}

internal/cluster/sotaref_test.go

@@ -0,0 +1,25 @@
+package cluster
+
+import "testing"
+
+func TestSOTARefFrom(t *testing.T) {
+	// Left column: real comments seen on the SOTA cluster feed.
+	cases := []struct{ in, want string }{
+		{"W9/WI-001", "W9/WI-001"},
+		{"DM/BM-063", "DM/BM-063"},
+		{"W7Y/TT-122", "W7Y/TT-122"},
+		{"VK3/VC-014 s2s", "VK3/VC-014"},
+		{"[SOTA] F/AM-123 cq", "F/AM-123"},
+		{"", ""},
+		// The other reference schemes that share this field.
+		{"POTA US-4475", ""},
+		{"WWFF DLFF-0001", ""},
+		// A portable callsign is not a summit.
+		{"DL/SP9DPM/P calling", ""},
+	}
+	for _, c := range cases {
+		if got := SOTARefFrom(c.in); got != c.want {
+			t.Errorf("SOTARefFrom(%q) = %q, want %q", c.in, got, c.want)
+		}
+	}
+}

internal/email/email.go

@@ -5,6 +5,7 @@ package email
 import (
 	"fmt"
 	"os"
+	"strings"
 	"time"
 
 	"github.com/wneessen/go-mail"
@@ -86,12 +87,42 @@ func SendFiles(cfg Config, to, subject, body string, attachPaths []string) error
 		return fmt.Errorf("smtp client: %w", err)
 	}
 	if err := client.DialAndSend(m); err != nil {
-		return fmt.Errorf("send via %s:%d (%s, %s): %w",
+		return fmt.Errorf("send via %s:%d (%s, %s): %w%s",
-			cfg.Host, cfg.Port, cfg.Encryption, describeSize(attachPaths), err)
+			cfg.Host, cfg.Port, cfg.Encryption, describeSize(attachPaths), err, explainSMTP(err))
 	}
 	return nil
 }
 
+// explainSMTP turns a server's refusal into the thing to go and do.
+//
+// A rejection is quoted verbatim above it — the server's own words are the
+// evidence — but several of them name a policy rather than a mistake, and no
+// amount of re-checking the password will fix those. Microsoft's is the one
+// operators keep hitting: basic authentication for SMTP is switched off across
+// Microsoft 365 and outlook.com, and an app password does not bring it back.
+func explainSMTP(err error) string {
+	msg := strings.ToLower(err.Error())
+	switch {
+	case strings.Contains(msg, "basic authentication is disabled"),
+		strings.Contains(msg, "5.7.139"):
+		return "\n\nMicrosoft has switched off password-based SMTP for this account. " +
+			"An app password does not restore it — the server refuses the password itself, not the one you typed. " +
+			"On a Microsoft 365 tenant an administrator can re-enable it for this mailbox " +
+			"(Set-CASMailbox -SmtpClientAuthenticationDisabled $false, plus the tenant-wide setting); " +
+			"otherwise use another provider for alerts (a Gmail account with an app password works, so does any ordinary IMAP/SMTP host)."
+	case strings.Contains(msg, "application-specific password"),
+		strings.Contains(msg, "5.7.9"):
+		return "\n\nThis account needs an APP PASSWORD rather than the one you sign in with " +
+			"(Google, Yahoo and others require it once two-factor authentication is on)."
+	case strings.Contains(msg, "5.7.8"), strings.Contains(msg, "authentication failed"),
+		strings.Contains(msg, "535"):
+		return "\n\nThe server rejected the username or the password."
+	case strings.Contains(msg, "must issue a starttls"):
+		return "\n\nThe server requires encryption: set STARTTLS (usually port 587) or SSL (465)."
+	}
+	return ""
+}
+
 // describeSize reports what was attached, in bytes.
 //
 // "An existing connection was forcibly closed" during DATA is the same message

internal/email/email_explain_test.go

@@ -0,0 +1,29 @@
+package email
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestExplainSMTP(t *testing.T) {
+	// The real refusal, from an operator's Outlook account.
+	outlook := errors.New("SMTP AUTH failed: 535 5.7.139 Authentication unsuccessful, basic authentication is disabled.")
+	if got := explainSMTP(outlook); !strings.Contains(got, "Microsoft has switched off") {
+		t.Errorf("the Microsoft policy refusal is not explained: %q", got)
+	}
+	// A plain wrong password must NOT claim a policy: the advice would send the
+	// operator to an administrator over a typo.
+	wrong := errors.New("535 5.7.8 authentication failed")
+	got := explainSMTP(wrong)
+	if strings.Contains(got, "Microsoft") {
+		t.Errorf("a wrong password was explained as a Microsoft policy: %q", got)
+	}
+	if !strings.Contains(got, "rejected the username") {
+		t.Errorf("a wrong password is not explained: %q", got)
+	}
+	// Anything else is left to speak for itself.
+	if got := explainSMTP(errors.New("dial tcp: i/o timeout")); got != "" {
+		t.Errorf("an unrelated error got an explanation: %q", got)
+	}
+}

internal/extsvc/lotw.go

@@ -12,6 +12,7 @@ import (
 	"os/exec"
 	"path/filepath"
 	"strings"
+	"sync"
 	"syscall"
 	"time"
 )
@@ -20,6 +21,67 @@ import (
 // document of the user's QSOs (optionally only confirmed ones).
 const lotwReportURL = "https://lotw.arrl.org/lotwuser/lotwreport.adi"
 
+const (
+	// How long LoTW may take to START answering. It builds the whole report
+	// before sending anything, so this is the slow part of a big account.
+	lotwHeaderTimeout = 10 * time.Minute
+	// How long the transfer may stall once it HAS started. A download that has
+	// not moved in this long is not slow, it is dead — and saying so beats a
+	// progress window that sits at "working" until someone gives up.
+	lotwIdleTimeout = 2 * time.Minute
+	lotwMaxBytes    = 256 * 1024 * 1024
+)
+
+// readWithProgress reads the body in chunks, reporting the running total and
+// failing fast on a stall.
+//
+// Reported as it arrives rather than at the end: an 18 MB report over a slow
+// link is minutes of silence otherwise, which is indistinguishable from a hang —
+// and that is exactly what operators were reporting.
+func say(note func(string), msg string) {
+	if note != nil {
+		note(msg)
+	}
+	LogSink("%s", msg)
+}
+
+func readWithProgress(ctx context.Context, r io.Reader, note func(string)) ([]byte, error) {
+	var (
+		out   []byte
+		total int64
+		last  = time.Now()
+		buf   = make([]byte, 64*1024)
+		next  = int64(256 * 1024) // first report early — proof it is moving
+	)
+	for {
+		if err := ctx.Err(); err != nil {
+			return nil, err
+		}
+		n, err := r.Read(buf)
+		if n > 0 {
+			out = append(out, buf[:n]...)
+			total += int64(n)
+			last = time.Now()
+			if total >= next {
+				say(note, fmt.Sprintf("  … %.1f MB received", float64(total)/(1024*1024)))
+				next = total + 512*1024
+			}
+			if total >= lotwMaxBytes {
+				return out, nil
+			}
+		}
+		if err == io.EOF {
+			return out, nil
+		}
+		if err != nil {
+			return nil, err
+		}
+		if time.Since(last) > lotwIdleTimeout {
+			return nil, fmt.Errorf("the transfer stalled after %d KB — LoTW stopped sending", total/1024)
+		}
+	}
+}
+
 // DownloadLoTWConfirmations fetches confirmed QSOs from LoTW as ADIF text.
 // Uses the LoTW *website* login (Username/Password), not the TQSL cert. When
 // since is non-empty (YYYY-MM-DD) only confirmations received since then are
@@ -27,7 +89,7 @@ const lotwReportURL = "https://lotw.arrl.org/lotwuser/lotwreport.adi"
 // non-empty, only confirmations for that station callsign are returned (an
 // LoTW account holds every call you operate — F4BPO, F4BPO/P, TM2Q — so this
 // scopes the pull to the active profile's call).
-func DownloadLoTWConfirmations(ctx context.Context, client *http.Client, cfg ServiceConfig, since, ownCall string) (string, error) {
+func DownloadLoTWConfirmations(ctx context.Context, client *http.Client, cfg ServiceConfig, since, ownCall string, detail bool, note func(string)) (string, error) {
 	user := strings.TrimSpace(cfg.Username)
 	if user == "" || cfg.Password == "" {
 		return "", fmt.Errorf("lotw: website login (username/password) not set")
@@ -37,27 +99,118 @@ func DownloadLoTWConfirmations(ctx context.Context, client *http.Client, cfg Ser
 	q.Set("password", cfg.Password)
 	q.Set("qso_query", "1")
 	q.Set("qso_qsl", "yes") // only QSLed (confirmed) records
-	q.Set("qso_qsldetail", "yes") // include QSL_RCVD / QSLRDATE detail
+	// qso_qsldetail is what LoTW charges for: it adds the QSL date and the
+	// station's own DXCC / grid / state / county to every record, and takes an
+	// order of magnitude longer to build — a report that arrives in two minutes
+	// without it takes twenty with it, measured on the same account.
+	//
+	// What we actually need to mark a confirmation is call, date, band and mode.
+	// The rest is worth its price only when the download is also ADDING the QSOs
+	// it cannot find, which is the one case where the extra fields are the only
+	// source for them.
+	if detail {
+		q.Set("qso_qsldetail", "yes")
+	}
 	if c := strings.TrimSpace(ownCall); c != "" {
 		q.Set("qso_owncall", c) // restrict to this station callsign
 	}
-	if s := strings.TrimSpace(since); s != "" {
+	// qso_qslsince is ALWAYS sent, even for "everything".
-		q.Set("qso_qslsince", s)
+	//
+	// Left out, LoTW does not answer "all confirmations" — it answers with a
+	// handful of recent ones, which arrives as a 200 and a valid ADIF and reads
+	// as a successful download of a nearly empty account. Asking from a date
+	// older than the service itself is the only way to mean "all".
+	sinceDate := strings.TrimSpace(since)
+	if sinceDate == "" {
+		sinceDate = "1945-11-15" // older than any QSO LoTW will accept
 	}
+	q.Set("qso_qslsince", sinceDate)
 
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, lotwReportURL+"?"+q.Encode(), nil)
 	if err != nil {
 		return "", fmt.Errorf("lotw: build request: %w", err)
 	}
+	// Named, because LoTW's front end throttles unidentified clients harder than
+	// it throttles known ones, and an operator reporting a 503 deserves a request
+	// that says who is asking.
+	req.Header.Set("User-Agent", "OpsLog")
 	if client == nil {
-		client = &http.Client{Timeout: 120 * time.Second}
+		// NO overall deadline. A full account is tens of megabytes and LoTW spends
+		// minutes building it before the first byte; a total timeout turns a slow
+		// but healthy download into "context deadline exceeded", and a longer one
+		// turns a dead connection into a window that says "working" for twenty
+		// minutes. What matters is not how long it takes but whether it is still
+		// moving — see the idle watchdog below.
+		client = &http.Client{
+			Transport: &http.Transport{
+				Proxy:                 http.ProxyFromEnvironment,
+				ResponseHeaderTimeout: lotwHeaderTimeout,
+				TLSHandshakeTimeout:   30 * time.Second,
+			},
+		}
+	}
+	// LoTW answers 503 when it is busy, which for a report covering more than a
+	// few days is often — other loggers get the same answer and simply ask
+	// again. Three tries, spaced, and each one said out loud: an operator whose
+	// download takes four minutes because the ARRL is loaded should be able to
+	// see that rather than guess it.
+	// LoTW sends nothing at all until the whole report is built — minutes for a
+	// large account. That silence was the entire complaint: a window saying
+	// "working" with no way to tell a busy server from a dead one. Count it out
+	// loud until the first byte.
+	beat := make(chan struct{})
+	go func() {
+		start := time.Now()
+		tick := time.NewTicker(15 * time.Second)
+		defer tick.Stop()
+		for {
+			select {
+			case <-beat:
+				return
+			case <-ctx.Done():
+				return
+			case <-tick.C:
+				say(note, fmt.Sprintf("  … still waiting for LoTW to build the report (%.0f s)", time.Since(start).Seconds()))
+			}
+		}
+	}()
+	// Stopped where the WAIT ends, not where the function does: deferred, the
+	// heartbeat went on counting between the megabyte lines and read as if the
+	// report were still being built while it was already arriving.
+	stopBeat := sync.OnceFunc(func() { close(beat) })
+	defer stopBeat()
+
+	var resp *http.Response
+	for attempt := 1; ; attempt++ {
+		resp, err = client.Do(req) //nolint:bodyclose // closed below or in the retry
+		if err == nil && resp.StatusCode != http.StatusServiceUnavailable &&
+			resp.StatusCode != http.StatusBadGateway && resp.StatusCode != http.StatusGatewayTimeout {
+			break
+		}
+		if attempt >= 3 {
+			break
+		}
+		wait := time.Duration(attempt*20) * time.Second
+		if resp != nil {
+			say(note, fmt.Sprintf("LoTW is busy (HTTP %d) — asking again in %s…", resp.StatusCode, wait))
+			resp.Body.Close()
+		} else {
+			say(note, fmt.Sprintf("LoTW did not answer (%v) — asking again in %s…", err, wait))
+		}
+		select {
+		case <-ctx.Done():
+			return "", ctx.Err()
+		case <-time.After(wait):
+		}
+		req = req.Clone(ctx)
 	}
-	resp, err := client.Do(req)
 	if err != nil {
 		return "", fmt.Errorf("lotw: request failed: %w", err)
 	}
 	defer resp.Body.Close()
-	body, err := io.ReadAll(io.LimitReader(resp.Body, 32*1024*1024))
+	stopBeat()
+	say(note, fmt.Sprintf("LoTW answered (HTTP %d) — receiving…", resp.StatusCode))
+	body, err := readWithProgress(ctx, resp.Body, note)
 	if err != nil {
 		return "", fmt.Errorf("lotw: read response: %w", err)
 	}
@@ -365,7 +518,7 @@ func TestLoTW(cfg ServiceConfig, stationDataPath string) (string, error) {
 	}
 	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
 	defer cancel()
-	if _, err := DownloadLoTWConfirmations(ctx, nil, cfg, "2099-01-01", ""); err != nil {
+	if _, err := DownloadLoTWConfirmations(ctx, nil, cfg, "2099-01-01", "", false, nil); err != nil {
 		return "", fmt.Errorf("%s — but the DOWNLOAD login failed: %w", up, err)
 	}
 	return up + ". Download login accepted.", nil

internal/integrations/udp/server.go

@@ -156,6 +156,8 @@ type Event struct {
 	DecodeModeRaw string
 	// DecodeMsgRaw is the message as sent, untrimmed — see DecodeModeRaw.
 	DecodeMsgRaw string
+	// DecodeIsNew is false on the history a Replay resends: display-only lines.
+	DecodeIsNew bool
 	// ProgramID is the sending application's own id ("WSJT-X", "MSHV", or
 	// "WSJT-X - 2" for a second instance started with --rig-name). It is what
 	// tells two receivers apart on one multicast group — and it is the address a
@@ -212,6 +214,9 @@ type Server struct {
 	// lastFrom is the address each program's packets arrive from — where a Reply
 	// has to be sent. See SendReply.
 	lastFrom map[string]*net.UDPAddr
+	// onNewInstance fires (off the read loop) the first time a program id is
+	// heard on this listener — the hook the startup replay hangs from.
+	onNewInstance func(programID string)
 	// instLabel names each running application, keyed by id AND sending address.
 	//
 	// WSJT-X requires --rig-name for a second instance, so its ids differ. MSHV
@@ -288,6 +293,7 @@ func newServer(cfg Config, out chan<- Event, mgr *Manager) *Server {
 		cfg:           cfg,
 		out:           out,
 		mgr:           mgr,
+		onNewInstance: mgr.onNewInstance,
 		stop:          make(chan struct{}),
 		done:          make(chan struct{}),
 	}
@@ -515,13 +521,23 @@ func (s *Server) handle(pkt []byte, remote *net.UDPAddr) {
 		// must go to the sender's own address, never to the group.
 		s.mu.Lock()
 		inst := s.instanceLabel(w.ProgramID, remote)
+		newInstance := false
 		if inst != "" && remote != nil {
 			if s.lastFrom == nil {
 				s.lastFrom = map[string]*net.UDPAddr{}
 			}
+			if _, known := s.lastFrom[inst]; !known {
+				newInstance = true
+			}
 			s.lastFrom[inst] = remote
 		}
+		onNew := s.onNewInstance
 		s.mu.Unlock()
+		// A program just heard for the first time this session: tell the app, so
+		// it can ask for a replay of the decodes already on that program's screen.
+		if newInstance && onNew != nil {
+			go onNew(inst)
+		}
 		// Status carries the current dial frequency; remember it so Decode audio
 		// offsets can be turned into RF frequencies for the panadapter.
 		if w.FreqHz > 0 && !w.IsDecode {
@@ -580,6 +596,7 @@ func (s *Server) handle(pkt []byte, remote *net.UDPAddr) {
 			ev.DecodeModeRaw = w.Mode
 			ev.DecodeMsg = w.DecodeMsg
 			ev.DecodeMsgRaw = w.DecodeMsgRaw
+			ev.DecodeIsNew = w.DecodeIsNew
 			ev.DecodeAt = decodeTime(w.DecodeMsSinceMidnight)
 			ev.DecodeTRPeriod = tr
 			ev.DecodeDial = dial
@@ -803,6 +820,10 @@ type Manager struct {
 	repo *Repo
 	out  chan Event
 
+	// onNewInstance is copied onto every inbound listener as it starts; see
+	// Server.onNewInstance.
+	onNewInstance func(programID string)
+
 	// noADIFOnce keeps the "nothing to forward to" note to one line a session
 	// rather than one per QSO logged.
 	noADIFOnce sync.Once
@@ -940,3 +961,11 @@ func (m *Manager) StopAll() {
 		s.close()
 	}
 }
+
+// SetOnNewInstance installs the first-sighting hook. Call before Reload so
+// listeners are born with it.
+func (m *Manager) SetOnNewInstance(fn func(programID string)) {
+	m.mu.Lock()
+	m.onNewInstance = fn
+	m.mu.Unlock()
+}

internal/integrations/udp/wsjtconfigure.go

@@ -0,0 +1,47 @@
+package udp
+
+import (
+	"bytes"
+	"encoding/binary"
+
+	"hamlog/internal/applog"
+)
+
+// WSJT-X Configure (message 15) — change the decoder's settings remotely. Used
+// for ONE thing here: clicking an FT4 spot while the decoder sits in FT8
+// switches its mode too, so the operator lands ready to decode instead of
+// staring at a band of gibberish. Every other field is sent as "no change"
+// (empty strings, max-quint32), per the protocol.
+const wsjtMsgConfigure = 15
+
+// EncodeConfigureMode builds a Configure datagram that changes only the mode.
+func EncodeConfigureMode(programID, mode string) []byte {
+	const noChange32 = ^uint32(0)
+	var b bytes.Buffer
+	_ = binary.Write(&b, binary.BigEndian, uint32(wsjtMagic))
+	_ = binary.Write(&b, binary.BigEndian, uint32(2))
+	_ = binary.Write(&b, binary.BigEndian, uint32(wsjtMsgConfigure))
+	writeQString(&b, programID)
+	writeQString(&b, mode)                             // Mode
+	_ = binary.Write(&b, binary.BigEndian, noChange32) // Frequency Tolerance — no change
+	writeQString(&b, "")                               // Submode — no change
+	_ = binary.Write(&b, binary.BigEndian, uint8(0))   // Fast Mode — off (right for every HF mode)
+	_ = binary.Write(&b, binary.BigEndian, noChange32) // T/R Period — no change
+	_ = binary.Write(&b, binary.BigEndian, noChange32) // Rx DF — no change
+	writeQString(&b, "")                               // DX Call — no change
+	writeQString(&b, "")                               // DX Grid — no change
+	_ = binary.Write(&b, binary.BigEndian, uint8(0))   // Generate Messages — no
+	return b.Bytes()
+}
+
+// SendConfigureMode asks every decoder heard this session to switch mode.
+// Sent to all instances rather than one: the spot click does not say which
+// decoder the operator is looking at, and a second instance already in the
+// right mode treats the message as a no-op.
+func (m *Manager) SendConfigureMode(mode string) {
+	for _, inst := range m.Instances() {
+		if err := m.sendToInstance(inst, EncodeConfigureMode(inst, mode), "configure-mode"); err == nil {
+			applog.Printf("udp: asked %q to switch to %s", inst, mode)
+		}
+	}
+}

internal/integrations/udp/wsjthighlight.go

@@ -0,0 +1,146 @@
+package udp
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"strings"
+
+	"hamlog/internal/applog"
+)
+
+// WSJT-X Highlight Callsign (13) and Replay (7) — the two halves of making the
+// Band Activity window log-aware.
+//
+// Highlight paints a callsign in the decoding application's own window with the
+// colours OpsLog chooses — new DXCC, new band, a watchlist member — the way
+// JTAlert does. Replay asks a freshly-discovered instance to resend the decodes
+// it already has on screen, so the FT decodes panel starts full instead of
+// empty until the next period.
+
+const (
+	wsjtMsgReplay    = 7
+	wsjtMsgHighlight = 13
+)
+
+// RGB is one highlight colour. A nil *RGB means "invalid QColor", which is the
+// protocol's way of saying "remove the highlight".
+type RGB struct{ R, G, B uint8 }
+
+// writeQColor serializes a QColor as QDataStream does: a spec byte (1 = RGB,
+// 0 = invalid) followed by five 16-bit channels (alpha, red, green, blue, pad),
+// each 8-bit value doubled into 16 bits the way Qt stores them.
+func writeQColor(b *bytes.Buffer, c *RGB) {
+	if c == nil {
+		b.WriteByte(0) // invalid — clears the highlight
+		for i := 0; i < 5; i++ {
+			_ = binary.Write(b, binary.BigEndian, uint16(0))
+		}
+		return
+	}
+	b.WriteByte(1) // spec = RGB
+	wide := func(v uint8) uint16 { return uint16(v) * 0x101 }
+	_ = binary.Write(b, binary.BigEndian, uint16(0xFFFF)) // alpha, opaque
+	_ = binary.Write(b, binary.BigEndian, wide(c.R))
+	_ = binary.Write(b, binary.BigEndian, wide(c.G))
+	_ = binary.Write(b, binary.BigEndian, wide(c.B))
+	_ = binary.Write(b, binary.BigEndian, uint16(0)) // pad
+}
+
+// EncodeHighlight builds a Highlight Callsign datagram. bg/fg nil = invalid
+// colour; both nil clears the callsign's highlight.
+func EncodeHighlight(programID, callsign string, bg, fg *RGB, lastPeriodOnly bool) []byte {
+	var b bytes.Buffer
+	_ = binary.Write(&b, binary.BigEndian, uint32(wsjtMagic))
+	_ = binary.Write(&b, binary.BigEndian, uint32(2))
+	_ = binary.Write(&b, binary.BigEndian, uint32(wsjtMsgHighlight))
+	writeQString(&b, programID)
+	writeQString(&b, callsign)
+	writeQColor(&b, bg)
+	writeQColor(&b, fg)
+	var last uint8
+	if lastPeriodOnly {
+		last = 1
+	}
+	_ = binary.Write(&b, binary.BigEndian, last)
+	return b.Bytes()
+}
+
+// EncodeReplay builds a Replay datagram — "resend what your window holds".
+func EncodeReplay(programID string) []byte {
+	var b bytes.Buffer
+	_ = binary.Write(&b, binary.BigEndian, uint32(wsjtMagic))
+	_ = binary.Write(&b, binary.BigEndian, uint32(2))
+	_ = binary.Write(&b, binary.BigEndian, uint32(wsjtMsgReplay))
+	writeQString(&b, programID)
+	return b.Bytes()
+}
+
+// sendToInstance routes a raw datagram to the application that owns programID,
+// the same way SendReply does: to the address its packets actually arrive from.
+func (m *Manager) sendToInstance(programID string, pkt []byte, what string) error {
+	if strings.TrimSpace(programID) == "" {
+		return fmt.Errorf("no application id")
+	}
+	m.mu.Lock()
+	servers := make([]*Server, 0, len(m.inbound))
+	for _, s := range m.inbound {
+		servers = append(servers, s)
+	}
+	m.mu.Unlock()
+	for _, s := range servers {
+		conn, addr := s.replyTarget(programID)
+		if conn == nil || addr == nil {
+			continue
+		}
+		if _, err := conn.WriteToUDP(pkt, addr); err != nil {
+			return fmt.Errorf("send %s to %s at %s: %w", what, programID, addr, err)
+		}
+		return nil
+	}
+	return fmt.Errorf("no packet has arrived from %q yet", programID)
+}
+
+// SendHighlight paints (or clears) one callsign in the given instance.
+func (m *Manager) SendHighlight(programID, callsign string, bg, fg *RGB, lastPeriodOnly bool) error {
+	return m.sendToInstance(programID, EncodeHighlight(programID, callsign, bg, fg, lastPeriodOnly), "highlight")
+}
+
+// SendClearHighlights removes every highlighting instruction OpsLog installed
+// in the instance. "CLEARALL!" is the protocol's own magic callsign for it.
+func (m *Manager) SendClearHighlights(programID string) error {
+	return m.sendToInstance(programID, EncodeHighlight(programID, "CLEARALL!", nil, nil, false), "clear-highlights")
+}
+
+// SendReplay asks the instance to resend its on-screen decodes.
+func (m *Manager) SendReplay(programID string) error {
+	err := m.sendToInstance(programID, EncodeReplay(programID), "replay")
+	if err == nil {
+		applog.Printf("udp: replay requested from %q — its existing decodes will arrive marked not-new", programID)
+	}
+	return err
+}
+
+// Instances lists every program id a packet has arrived from, for "clear the
+// highlights everywhere" and the startup replay.
+func (m *Manager) Instances() []string {
+	m.mu.Lock()
+	servers := make([]*Server, 0, len(m.inbound))
+	for _, s := range m.inbound {
+		servers = append(servers, s)
+	}
+	m.mu.Unlock()
+	seen := map[string]struct{}{}
+	var out []string
+	for _, s := range servers {
+		s.mu.Lock()
+		for id := range s.lastFrom {
+			if _, dup := seen[id]; !dup {
+				seen[id] = struct{}{}
+				out = append(out, id)
+			}
+		}
+		s.mu.Unlock()
+	}
+	return out
+}

internal/qso/qso.go

@@ -722,15 +722,14 @@ func (r *Repo) MarkUploadedBatch(ctx context.Context, statusCol, dateCol, date s
 	if len(ids) == 0 {
 		return nil
 	}
-	ph := strings.TrimSuffix(strings.Repeat("?,", len(ids)), ",")
+	now := db.NowISO()
-	args := make([]any, 0, len(ids)+2)
+	_, err := bulkByIDChunks(ctx, ids, func(ph string, idArgs []any) (int64, error) {
-	args = append(args, date, db.NowISO())
+		args := append([]any{date, now}, idArgs...)
-	for _, id := range ids {
-		args = append(args, id)
-	}
 		_, err := r.db.ExecContext(ctx,
 			`UPDATE qso SET `+statusCol+` = 'Y', `+dateCol+` = ?, updated_at = ? WHERE id IN (`+ph+`)`,
 			args...)
+		return 0, err
+	})
 	if err != nil {
 		return fmt.Errorf("mark uploaded batch (%d): %w", len(ids), err)
 	}
@@ -868,6 +867,73 @@ var bulkEditableCols = map[string]bool{
 
 // BulkSetField sets one whitelisted column to value on every listed QSO in a
 // single statement. value "" clears the field. Returns rows affected.
+// bulkEditableIntCols are the NUMERIC columns the bulk editor may touch. Their
+// own path, not the text one: the columns are nullable integers, and while
+// SQLite would coerce "14" quietly, a shared MySQL logbook would not — and an
+// empty string is NULL here, never "".
+// bulkByIDChunks runs one UPDATE per slice of ids, small enough for SQLite's
+// bound-variable cap: the single IN (…) with one placeholder per id worked at
+// 10 000 QSOs and failed at 168 000 with "too many SQL variables". Each call
+// gets the placeholder string and the id arguments for its slice; affected
+// rows are summed. 500 per statement keeps every backend far from any limit
+// while costing a few hundred statements on the largest logs.
+func bulkByIDChunks(ctx context.Context, ids []int64, run func(ph string, idArgs []any) (int64, error)) (int64, error) {
+	const chunk = 500
+	var total int64
+	for start := 0; start < len(ids); start += chunk {
+		end := start + chunk
+		if end > len(ids) {
+			end = len(ids)
+		}
+		part := ids[start:end]
+		ph := strings.Repeat("?,", len(part)-1) + "?"
+		args := make([]any, len(part))
+		for i, id := range part {
+			args[i] = id
+		}
+		n, err := run(ph, args)
+		if err != nil {
+			return total, err
+		}
+		total += n
+	}
+	return total, nil
+}
+
+var bulkEditableIntCols = map[string]bool{
+	"my_dxcc":     true,
+	"my_cq_zone":  true,
+	"my_itu_zone": true,
+}
+
+// BulkSetIntField sets one integer column across the ids; v nil clears it.
+func (r *Repo) BulkSetIntField(ctx context.Context, ids []int64, column string, v *int) (int64, error) {
+	if !bulkEditableIntCols[column] {
+		return 0, fmt.Errorf("field %q is not bulk-editable", column)
+	}
+	if len(ids) == 0 {
+		return 0, nil
+	}
+	var val any
+	if v != nil {
+		val = *v
+	}
+	now := db.NowISO()
+	n, err := bulkByIDChunks(ctx, ids, func(ph string, idArgs []any) (int64, error) {
+		args := append([]any{val, now}, idArgs...)
+		res, err := r.db.ExecContext(ctx,
+			"UPDATE qso SET "+column+" = ?, updated_at = ? WHERE id IN ("+ph+")", args...)
+		if err != nil {
+			return 0, err
+		}
+		return res.RowsAffected()
+	})
+	if err != nil {
+		return n, fmt.Errorf("bulk set %s: %w", column, err)
+	}
+	return n, nil
+}
+
 func (r *Repo) BulkSetField(ctx context.Context, ids []int64, column, value string) (int64, error) {
 	if !bulkEditableCols[column] {
 		return 0, fmt.Errorf("field %q is not bulk-editable", column)
@@ -875,13 +941,6 @@ func (r *Repo) BulkSetField(ctx context.Context, ids []int64, column, value stri
 	if len(ids) == 0 {
 		return 0, nil
 	}
-	ph := make([]string, len(ids))
-	args := make([]any, 0, len(ids)+2)
-	args = append(args, value, db.NowISO())
-	for i, id := range ids {
-		ph[i] = "?"
-		args = append(args, id)
-	}
 	set := column + " = ?, updated_at = ?"
 	if column == "mode" {
 		// A submode belongs to the mode it was recorded under. Left behind, it
@@ -890,13 +949,19 @@ func (r *Repo) BulkSetField(ctx context.Context, ids []int64, column, value stri
 		// only outcome that leaves the row meaning what the operator asked for.
 		set += ", submode = ''"
 	}
+	now := db.NowISO()
+	n, err := bulkByIDChunks(ctx, ids, func(ph string, idArgs []any) (int64, error) {
+		args := append([]any{value, now}, idArgs...)
 		res, err := r.db.ExecContext(ctx,
-		`UPDATE qso SET `+set+` WHERE id IN (`+strings.Join(ph, ",")+`)`,
+			`UPDATE qso SET `+set+` WHERE id IN (`+ph+`)`, args...)
-		args...)
 		if err != nil {
-		return 0, fmt.Errorf("bulk set %s: %w", column, err)
+			return 0, err
+		}
+		return res.RowsAffected()
+	})
+	if err != nil {
+		return n, fmt.Errorf("bulk set %s: %w", column, err)
 	}
-	n, _ := res.RowsAffected()
 	return n, nil
 }
 
@@ -957,26 +1022,26 @@ func (r *Repo) BulkSetExtra(ctx context.Context, ids []int64, adifKey, value str
 	if len(ids) == 0 {
 		return 0, nil
 	}
-	ph := make([]string, len(ids))
+	head := []any{}
-	args := make([]any, 0, len(ids)+2)
 	expr := `json_set(COALESCE(extras_json, '{}'), '$.` + adifKey + `', ?)`
 	if value == "" {
 		expr = `json_remove(COALESCE(extras_json, '{}'), '$.` + adifKey + `')`
 	} else {
-		args = append(args, value)
+		head = append(head, value)
-	}
-	args = append(args, db.NowISO())
-	for i, id := range ids {
-		ph[i] = "?"
-		args = append(args, id)
 	}
+	head = append(head, db.NowISO())
+	n, err := bulkByIDChunks(ctx, ids, func(ph string, idArgs []any) (int64, error) {
+		args := append(append([]any{}, head...), idArgs...)
 		res, err := r.db.ExecContext(ctx,
-		`UPDATE qso SET extras_json = `+expr+`, updated_at = ? WHERE id IN (`+strings.Join(ph, ",")+`)`,
+			`UPDATE qso SET extras_json = `+expr+`, updated_at = ? WHERE id IN (`+ph+`)`, args...)
-		args...)
 		if err != nil {
-		return 0, fmt.Errorf("bulk set extra %s: %w", adifKey, err)
+			return 0, err
+		}
+		return res.RowsAffected()
+	})
+	if err != nil {
+		return n, fmt.Errorf("bulk set extra %s: %w", adifKey, err)
 	}
-	n, _ := res.RowsAffected()
 	return n, nil
 }
 
@@ -988,20 +1053,19 @@ func (r *Repo) BulkSetFrequency(ctx context.Context, ids []int64, freqHz int64,
 	if len(ids) == 0 {
 		return 0, nil
 	}
-	ph := make([]string, len(ids))
+	now := db.NowISO()
-	args := make([]any, 0, len(ids)+3)
+	n, err := bulkByIDChunks(ctx, ids, func(ph string, idArgs []any) (int64, error) {
-	args = append(args, freqHz, band, db.NowISO())
+		args := append([]any{freqHz, band, now}, idArgs...)
-	for i, id := range ids {
-		ph[i] = "?"
-		args = append(args, id)
-	}
 		res, err := r.db.ExecContext(ctx,
-		`UPDATE qso SET freq_hz = ?, band = ?, updated_at = ? WHERE id IN (`+strings.Join(ph, ",")+`)`,
+			`UPDATE qso SET freq_hz = ?, band = ?, updated_at = ? WHERE id IN (`+ph+`)`, args...)
-		args...)
 		if err != nil {
-		return 0, fmt.Errorf("bulk set frequency: %w", err)
+			return 0, err
+		}
+		return res.RowsAffected()
+	})
+	if err != nil {
+		return n, fmt.Errorf("bulk set frequency: %w", err)
 	}
-	n, _ := res.RowsAffected()
 	return n, nil
 }
 
@@ -1163,17 +1227,16 @@ func (r *Repo) DeleteMany(ctx context.Context, ids []int64) (int64, error) {
 	if len(ids) == 0 {
 		return 0, nil
 	}
-	ph := make([]string, len(ids))
+	n, err := bulkByIDChunks(ctx, ids, func(ph string, idArgs []any) (int64, error) {
-	args := make([]any, len(ids))
+		res, err := r.db.ExecContext(ctx, `DELETE FROM qso WHERE id IN (`+ph+`)`, idArgs...)
-	for i, id := range ids {
-		ph[i] = "?"
-		args[i] = id
-	}
-	res, err := r.db.ExecContext(ctx, `DELETE FROM qso WHERE id IN (`+strings.Join(ph, ",")+`)`, args...)
 		if err != nil {
-		return 0, fmt.Errorf("delete qsos: %w", err)
+			return 0, err
+		}
+		return res.RowsAffected()
+	})
+	if err != nil {
+		return n, fmt.Errorf("delete qsos: %w", err)
 	}
-	n, _ := res.RowsAffected()
 	return n, nil
 }
 
@@ -1663,27 +1726,42 @@ func (r *Repo) IterateByIDs(ctx context.Context, ids []int64, fn func(QSO) error
 	if len(ids) == 0 {
 		return nil
 	}
-	ph := strings.TrimSuffix(strings.Repeat("?,", len(ids)), ",")
+	// Chunked like every other by-ids statement (the one-placeholder-per-id IN
-	args := make([]any, len(ids))
+	// died at 168k with "too many SQL variables") — and because each chunk is
-	for i, id := range ids {
+	// only locally ordered, the rows are collected and sorted once at the end
-		args[i] = id
+	// so the chronological contract holds across chunks.
-	}
+	var all []QSO
+	_, err := bulkByIDChunks(ctx, ids, func(ph string, idArgs []any) (int64, error) {
 		rows, err := r.db.QueryContext(ctx,
-		`SELECT `+selectCols+` FROM qso WHERE id IN (`+ph+`) ORDER BY qso_date ASC, id ASC`, args...)
+			`SELECT `+selectCols+` FROM qso WHERE id IN (`+ph+`)`, idArgs...)
 		if err != nil {
-		return fmt.Errorf("query qso: %w", err)
+			return 0, err
 		}
 		defer rows.Close()
 		for rows.Next() {
 			q, err := scanQSO(rows)
 			if err != nil {
-			return err
+				return 0, err
 			}
+			all = append(all, q)
+		}
+		return 0, rows.Err()
+	})
+	if err != nil {
+		return fmt.Errorf("query qso: %w", err)
+	}
+	sort.Slice(all, func(i, j int) bool {
+		if !all[i].QSODate.Equal(all[j].QSODate) {
+			return all[i].QSODate.Before(all[j].QSODate)
+		}
+		return all[i].ID < all[j].ID
+	})
+	for _, q := range all {
 		if err := fn(q); err != nil {
 			return err
 		}
 	}
-	return rows.Err()
+	return nil
 }
 
 // GridKey builds the lookup key for the worked-grid index.
@@ -1901,10 +1979,24 @@ type WorkedBefore struct {
 }
 
 // BandStatus is one cell in the worked-before grid.
+//
+// Status is the single highest thing true of the cell, which is what colours
+// it. Call is the SAME cell's answer to a different question — "have I worked
+// THIS callsign here" — kept separately because the two are asked at the same
+// moment and one was hiding the other.
+//
+// Chasing an expedition, an operator needs both: whether the slot is still
+// missing for the entity (does this fill a DXCC hole) and whether this
+// expedition has already been worked on it (would this be a dupe). A confirmed
+// entity outranks a worked callsign in Status — correctly, for awards — so a
+// slot worked with the DX yesterday can read "entity confirmed" and say nothing
+// at all about yesterday.
 type BandStatus struct {
 	Band   string `json:"band"`   // ADIF lowercase band, e.g. "20m"
 	Class  string `json:"class"`  // "PH" | "CW" | "DIG"
 	Status string `json:"status"` // "call_c" | "call_w" | "dxcc_c" | "dxcc_w"
+	// Call is "", "w" (worked with this callsign) or "c" (confirmed with it).
+	Call string `json:"call,omitempty"`
 }
 
 // Band-status codes, lowest first. The ORDER is the rule: a cell shows the
@@ -1951,6 +2043,39 @@ func bandStatusCode(callWorked, callConfirmed, entityConfirmed bool) int {
 
 // modeClass collapses ADIF modes into the three buckets DXers care about.
 // Anything not voice and not CW is treated as digital.
+// ModeClass is modeClass for callers outside the package — the watchlist
+// judges slots at the same grain the cluster does.
+func ModeClass(mode string) string { return modeClass(mode) }
+
+// SlotRow is one (callsign, band, mode) triple from SlotsSince.
+type SlotRow struct {
+	Callsign string
+	Band     string
+	Mode     string
+}
+
+// SlotsSince lists the slots of every contact made since the given instant —
+// the contest watchlist's "worked today", where the day boundary lives in this
+// query's bound and nowhere else.
+func (r *Repo) SlotsSince(ctx context.Context, since time.Time) ([]SlotRow, error) {
+	rows, err := r.db.QueryContext(ctx,
+		"SELECT callsign, band, mode FROM qso WHERE qso_date >= ?",
+		since.UTC().Format(isoMillis))
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var out []SlotRow
+	for rows.Next() {
+		var sr SlotRow
+		if err := rows.Scan(&sr.Callsign, &sr.Band, &sr.Mode); err != nil {
+			return nil, err
+		}
+		out = append(out, sr)
+	}
+	return out, rows.Err()
+}
+
 func modeClass(mode string) string {
 	switch strings.ToUpper(mode) {
 	case "SSB", "USB", "LSB", "AM", "FM", "DIGITALVOICE", "PHONE":
@@ -2222,13 +2347,17 @@ func (r *Repo) WorkedBefore(ctx context.Context, callsign string, dxccHint int,
 	// The grid answers "what do I still need on this band and mode", and for
 	// that question confirmation is the axis that matters: a confirmed entity
 	// needs nothing, whoever else was worked afterwards.
+	// The two per-callsign columns use the SAME predicate as the callsign count
+	// above, portable variants included: a cell that counts RI1FJL/1 in "worked
+	// with this call" and a header that does not would be two answers to one
+	// question.
 	// Filter NULL/empty band+mode rows — they'd create a NULL group key
 	// that Scan into *string can't handle and would error out the whole
 	// WorkedBefore call, blanking the matrix in the UI.
 	statusRows, err := r.db.QueryContext(ctx, `
         SELECT band, mode,
-               MAX(CASE WHEN callsign = ? THEN 1 ELSE 0 END),
+               MAX(CASE WHEN `+pred+` THEN 1 ELSE 0 END),
-               MAX(CASE WHEN callsign = ?
+               MAX(CASE WHEN `+pred+`
                          AND (lotw_rcvd IN `+ConfirmedValues+` OR qsl_rcvd IN `+ConfirmedValues+` OR eqsl_rcvd IN `+ConfirmedValues+`)
                         THEN 1 ELSE 0 END),
                MAX(CASE WHEN lotw_rcvd IN `+ConfirmedValues+` OR qsl_rcvd IN `+ConfirmedValues+` OR eqsl_rcvd IN `+ConfirmedValues+`
@@ -2237,12 +2366,14 @@ func (r *Repo) WorkedBefore(ctx context.Context, callsign string, dxccHint int,
         WHERE dxcc = ?
           AND band IS NOT NULL AND band != ''
           AND mode IS NOT NULL AND mode != ''
-        GROUP BY band, mode`, wb.Callsign, wb.Callsign, dxcc)
+        GROUP BY band, mode`, append(append(append([]any{}, predArgs...), predArgs...), dxcc)...)
 	if err != nil {
 		return wb, fmt.Errorf("band status: %w", err)
 	}
 	type cellKey struct{ band, class string }
 	best := map[cellKey]int{}
+	// The call's own answer per cell, independent of the ladder above.
+	callByCell := map[cellKey]string{}
 	for statusRows.Next() {
 		var band, mode string
 		var callW, callC, dxccConfirmed int
@@ -2255,12 +2386,21 @@ func (r *Repo) WorkedBefore(ctx context.Context, callsign string, dxccHint int,
 		if cur, ok := best[k]; !ok || code > cur {
 			best[k] = code
 		}
+		// Confirmed beats worked here too, and neither is ever erased by the
+		// entity: this is only ever about the callsign.
+		switch {
+		case callC == 1:
+			callByCell[k] = "c"
+		case callW == 1 && callByCell[k] == "":
+			callByCell[k] = "w"
+		}
 	}
 	statusRows.Close()
 	codeStr := bandStatusNames
 	for k, code := range best {
 		wb.BandStatus = append(wb.BandStatus, BandStatus{
 			Band: k.band, Class: k.class, Status: codeStr[code],
+			Call: callByCell[k],
 		})
 	}
 	return wb, nil
@@ -2955,6 +3095,33 @@ func DedupeKey(callsign, qsoDateMinute, band, mode string) string {
 	return strings.ToUpper(callsign) + "|" + qsoDateMinute + "|" + strings.ToLower(band) + "|" + strings.ToUpper(mode)
 }
 
+// StationCallsigns lists the distinct station callsigns the logbook was worked
+// under, upper-cased and without the blanks.
+//
+// Used to decide whether a downloaded confirmation belongs to THIS log at all:
+// one LoTW account can hold several stations (a home call, a portable, an
+// expedition), and a confirmation for a station this logbook has never used is
+// somebody else's log — here, another profile's.
+func (r *Repo) StationCallsigns(ctx context.Context) (map[string]bool, error) {
+	rows, err := r.db.QueryContext(ctx,
+		`SELECT DISTINCT COALESCE(station_callsign,'') FROM qso`)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	out := map[string]bool{}
+	for rows.Next() {
+		var c string
+		if err := rows.Scan(&c); err != nil {
+			return nil, err
+		}
+		if c = strings.ToUpper(strings.TrimSpace(c)); c != "" {
+			out[c] = true
+		}
+	}
+	return out, rows.Err()
+}
+
 // DedupeKeyIDs returns a map of dedupe key → QSO id, for matching downloaded
 // confirmations back to local QSOs.
 func (r *Repo) DedupeKeyIDs(ctx context.Context) (map[string]int64, error) {

internal/rigctld/rigctld.go

@@ -246,6 +246,11 @@ func (s *Server) serve(c net.Conn) {
 		s.releasePTT(fmt.Sprintf("client %s left", c.RemoteAddr()))
 	}()
 	s.log("rigctld: client connected from %s", c.RemoteAddr())
+	// The HANDSHAKE is always traced — the first few commands are where a
+	// client decides to stay or hang up, and a connect that lasted 50 ms left
+	// nothing in the log to say which answer it disliked. Steady-state polling
+	// stays behind the CAT trace switch.
+	traced := 0
 	r := bufio.NewReader(c)
 	w := bufio.NewWriter(c)
 	for {
@@ -265,7 +270,8 @@ func (s *Server) serve(c net.Conn) {
 		// that preceded it — the one thing needed to tell whether OpsLog answered
 		// something the client could not accept. Behind the same switch as the CAT
 		// wire trace: this is one line per poll and would drown an ordinary log.
-		if req != "" && cat.CIVTraceEnabled() {
+		if req != "" && (traced < 6 || cat.CIVTraceEnabled()) {
+			traced++
 			s.log("rigctld: %s → %q ⇒ %q", c.RemoteAddr(), req, strings.TrimRight(resp, "\r\n"))
 		}
 		if resp != "" {

internal/watchlist/clublog.go

@@ -0,0 +1,131 @@
+package watchlist
+
+// ClubLog enrichment — phase 2 of the DXHunter port. clublog.org/watch.php
+// answers, per callsign: is this an expedition, does it run OQRS, is there a
+// LiveStream, the log's QSO total and the last 24 hours' rate. That block has
+// been in the Entry schema since phase 1 (the file round-trips DXHunter's);
+// this file finally fills it.
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+)
+
+// WatchData is clublog.org/watch.php's answer, reduced to what the tab shows.
+type WatchData struct {
+	IsExpedition bool `json:"is_expedition"`
+	HasOQRS      bool `json:"has_oqrs"`
+	LiveStream   bool `json:"livestream"`
+	ClubLogInfo  *struct {
+		TotalQSOs int `json:"total_qsos"`
+	} `json:"clublog_info"`
+	// {} when populated, [] when empty — RawMessage swallows both shapes.
+	QSOsPerBand json.RawMessage `json:"24h_qsos_per_band_mode"`
+}
+
+// QSOs24h sums the per-band/per-mode counts.
+func (d *WatchData) QSOs24h() int {
+	if len(d.QSOsPerBand) == 0 {
+		return 0
+	}
+	var parsed map[string]map[string]int
+	if err := json.Unmarshal(d.QSOsPerBand, &parsed); err != nil {
+		return 0 // "[]" for an empty answer lands here, which is the right zero
+	}
+	n := 0
+	for _, modes := range parsed {
+		for _, c := range modes {
+			n += c
+		}
+	}
+	return n
+}
+
+// FetchWatch asks ClubLog about one callsign. A 404 is "ClubLog has no log for
+// this call" — an ordinary answer, not an error.
+func FetchWatch(ctx context.Context, client *http.Client, apiKey, callsign string) (*WatchData, error) {
+	url := fmt.Sprintf("https://clublog.org/watch.php?call=%s&api=%s",
+		strings.ToUpper(strings.TrimSpace(callsign)), apiKey)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("User-Agent", "OpsLog")
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode == http.StatusNotFound {
+		return &WatchData{}, nil
+	}
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("clublog watch %s: HTTP %d", callsign, resp.StatusCode)
+	}
+	body, err := io.ReadAll(io.LimitReader(resp.Body, 1<<20))
+	if err != nil {
+		return nil, err
+	}
+	if len(strings.TrimSpace(string(body))) == 0 {
+		return &WatchData{}, nil
+	}
+	var data WatchData
+	if err := json.Unmarshal(body, &data); err != nil {
+		return nil, fmt.Errorf("clublog watch %s: %w", callsign, err)
+	}
+	return &data, nil
+}
+
+// ApplyClubLog writes one answer into the entry and reports whether anything
+// the tab shows actually changed — the caller only broadcasts on true.
+func (s *Store) ApplyClubLog(callsign string, d *WatchData) bool {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	e, ok := s.entries[strings.ToUpper(strings.TrimSpace(callsign))]
+	if !ok {
+		return false
+	}
+	total := e.ClubLogTotalQSOs
+	if d.ClubLogInfo != nil {
+		total = d.ClubLogInfo.TotalQSOs
+	}
+	q24 := d.QSOs24h()
+	changed := e.IsExpedition != d.IsExpedition || e.ClubLogHasOQRS != d.HasOQRS ||
+		e.ClubLogLiveStream != d.LiveStream || e.ClubLogTotalQSOs != total ||
+		e.ClubLogQSOs24h != q24
+	e.IsExpedition = d.IsExpedition
+	e.ClubLogHasOQRS = d.HasOQRS
+	e.ClubLogLiveStream = d.LiveStream
+	e.ClubLogTotalQSOs = total
+	e.ClubLogQSOs24h = q24
+	e.ClubLogUpdatedAt = time.Now()
+	s.scheduleSave()
+	return changed
+}
+
+// StaleEntries lists the callsigns whose ClubLog block is due a refresh.
+// Expeditions age faster — their totals are the interesting number and move by
+// the hour; a quiet call is asked about four times a day at most.
+func (s *Store) StaleEntries(expTTL, otherTTL time.Duration) []string {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	now := time.Now()
+	var out []string
+	for call, e := range s.entries {
+		// A starred pattern is a family, not a station — ClubLog has no log
+		// for "VK9*". The base (star stripped) is what gets asked about.
+		ttl := otherTTL
+		if e.IsExpedition {
+			ttl = expTTL
+		}
+		if now.Sub(e.ClubLogUpdatedAt) >= ttl {
+			out = append(out, call)
+		}
+	}
+	return out
+}

internal/watchlist/watchlist.go

@@ -0,0 +1,268 @@
+// Package watchlist is the DXHunter watchlist, transplanted: a list of
+// callsigns (or prefixes) the operator is hunting, matched against the live
+// spot stream, with per-entry state that survives restarts.
+//
+// The JSON file is DXHunter's OWN schema, field for field — including the
+// ClubLog expedition block this phase does not fill yet. Deliberate: the
+// operator asked to carry their watchlist.json across, and a file that
+// round-trips unchanged is the whole of "same format". The file is GLOBAL
+// (dataDir, beside nets.json), not per profile: a DXpedition worth hunting is
+// worth hunting whichever station is on.
+//
+// The CONTEST idea is per entry, not a global mode as in DXHunter: an entry
+// marked contest is judged against the CURRENT UTC DAY — at midnight UTC
+// yesterday's contacts stop counting and every slot reads "work today" again.
+// Nothing resets and nothing is stored for it: the day boundary lives in the
+// query, which is why it cannot drift or need a timer.
+package watchlist
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"sort"
+	"strings"
+	"sync"
+	"time"
+)
+
+// Entry is one watched callsign. JSON tags match DXHunter's watchlist.json
+// exactly — see the package comment before renaming anything.
+type Entry struct {
+	Callsign    string    `json:"callsign"`
+	LastSeen    time.Time `json:"lastSeen"`
+	LastSeenStr string    `json:"lastSeenStr"`
+	AddedAt     time.Time `json:"addedAt"`
+	SpotCount   int       `json:"spotCount"`
+	IsContest   bool      `json:"isContest"`
+	Notify      bool      `json:"notify"`
+	// ClubLog expedition enrichment — phase 2. Carried so a DXHunter file
+	// round-trips; not filled by OpsLog yet.
+	IsExpedition      bool      `json:"isExpedition"`
+	ClubLogQSOs24h    int       `json:"clubLogQSOs24h"`
+	ClubLogTotalQSOs  int       `json:"clubLogTotalQSOs"`
+	ClubLogHasOQRS    bool      `json:"clubLogHasOQRS"`
+	ClubLogLiveStream bool      `json:"clubLogLiveStream"`
+	ClubLogUpdatedAt  time.Time `json:"clubLogUpdatedAt,omitempty"`
+}
+
+// Store owns the file. All methods are safe for concurrent use; writes are
+// debounced so a burst of MarkSeen calls costs one disk write.
+type Store struct {
+	mu      sync.RWMutex
+	entries map[string]*Entry
+	path    string
+
+	saveMu    sync.Mutex
+	saveTimer *time.Timer
+	ioMu      sync.Mutex
+}
+
+func New(path string) *Store {
+	s := &Store{entries: map[string]*Entry{}, path: path}
+	s.load()
+	return s
+}
+
+func (s *Store) load() {
+	data, err := os.ReadFile(s.path)
+	if err != nil {
+		return // absent on first run — created on first save
+	}
+	var list []Entry
+	if err := json.Unmarshal(data, &list); err != nil {
+		return // a corrupt file must not take the app down; it is left for repair
+	}
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	for i := range list {
+		e := list[i]
+		e.Callsign = strings.ToUpper(strings.TrimSpace(e.Callsign))
+		if e.Callsign == "" {
+			continue
+		}
+		s.entries[e.Callsign] = &e
+	}
+}
+
+// Entries returns a snapshot, watched-first ordering left to the UI.
+func (s *Store) Entries() []Entry {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	out := make([]Entry, 0, len(s.entries))
+	for _, e := range s.entries {
+		c := *e
+		c.LastSeenStr = lastSeenLabel(c.LastSeen)
+		out = append(out, c)
+	}
+	sort.Slice(out, func(i, j int) bool { return out[i].Callsign < out[j].Callsign })
+	return out
+}
+
+// Add creates an entry; contest marks it as re-workable every UTC day. A
+// trailing * makes the entry a prefix (VK9* catches every VK9…); anywhere else
+// the star is refused rather than silently matching nothing.
+func (s *Store) Add(callsign string, contest bool) error {
+	call := strings.ToUpper(strings.TrimSpace(callsign))
+	if call == "" {
+		return fmt.Errorf("callsign required")
+	}
+	if i := strings.Index(call, "*"); i >= 0 && i != len(call)-1 {
+		return fmt.Errorf("* is only allowed at the end (VK9*)")
+	}
+	if call == "*" {
+		return fmt.Errorf("a bare * would match every spot")
+	}
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if _, ok := s.entries[call]; ok {
+		return fmt.Errorf("%s is already on the watchlist", call)
+	}
+	s.entries[call] = &Entry{Callsign: call, AddedAt: time.Now(), IsContest: contest}
+	s.scheduleSave()
+	return nil
+}
+
+// Remove deletes an entry.
+func (s *Store) Remove(callsign string) error {
+	call := strings.ToUpper(strings.TrimSpace(callsign))
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if _, ok := s.entries[call]; !ok {
+		return fmt.Errorf("%s is not on the watchlist", call)
+	}
+	delete(s.entries, call)
+	s.scheduleSave()
+	return nil
+}
+
+// SetNotify arms or disarms the alert for one entry.
+func (s *Store) SetNotify(callsign string, on bool) error {
+	return s.patch(callsign, func(e *Entry) { e.Notify = on })
+}
+
+// SetContest flips the per-entry contest rule.
+func (s *Store) SetContest(callsign string, on bool) error {
+	return s.patch(callsign, func(e *Entry) { e.IsContest = on })
+}
+
+func (s *Store) patch(callsign string, fn func(*Entry)) error {
+	call := strings.ToUpper(strings.TrimSpace(callsign))
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	e, ok := s.entries[call]
+	if !ok {
+		return fmt.Errorf("%s is not on the watchlist", call)
+	}
+	fn(e)
+	s.scheduleSave()
+	return nil
+}
+
+// Match returns the entry a spotted callsign belongs to, or "".
+//
+// EXACT unless the entry says otherwise: N8W matches only N8W, and it takes
+// N8W* to catch N8WCR. The first version prefix-matched everything, DXHunter
+// style, and a three-letter special-event call swallowed every longer call
+// sharing its start — N8W lit up for N8WCR, which is a different station
+// entirely. The operator writes the star when they MEAN a family (VK9*, an
+// expedition's portable forms via RI0SP*); a bare entry means that call.
+func (s *Store) Match(callsign string) (string, bool) {
+	call := strings.ToUpper(strings.TrimSpace(callsign))
+	if call == "" {
+		return "", false
+	}
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	for pattern := range s.entries {
+		if PatternMatches(pattern, call) {
+			return pattern, true
+		}
+	}
+	return "", false
+}
+
+// PatternMatches reports whether one watchlist pattern covers a callsign:
+// exact equality, or — with a trailing * — a prefix.
+func PatternMatches(pattern, call string) bool {
+	if p, ok := strings.CutSuffix(pattern, "*"); ok {
+		return p != "" && strings.HasPrefix(call, p)
+	}
+	return call == pattern
+}
+
+// MarkSeen records a spot against the matching entry and reports whether the
+// entry wants an alert.
+func (s *Store) MarkSeen(callsign string) (entry string, notify bool, ok bool) {
+	pattern, found := s.Match(callsign)
+	if !found {
+		return "", false, false
+	}
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	e := s.entries[pattern]
+	if e == nil {
+		return "", false, false
+	}
+	e.LastSeen = time.Now()
+	e.SpotCount++
+	s.scheduleSave()
+	return e.Callsign, e.Notify, true
+}
+
+// scheduleSave debounces the write: a burst of spots costs one file write two
+// seconds after the last of them. Callers hold s.mu.
+func (s *Store) scheduleSave() {
+	s.saveMu.Lock()
+	defer s.saveMu.Unlock()
+	if s.saveTimer != nil {
+		s.saveTimer.Stop()
+	}
+	s.saveTimer = time.AfterFunc(2*time.Second, func() { s.persist() })
+}
+
+func (s *Store) persist() {
+	list := s.Entries()
+	data, err := json.MarshalIndent(list, "", "  ")
+	if err != nil {
+		return
+	}
+	s.ioMu.Lock()
+	defer s.ioMu.Unlock()
+	_ = os.WriteFile(s.path, data, 0o644)
+}
+
+// Flush writes now — for shutdown, where the two-second debounce would lose
+// the last edits.
+func (s *Store) Flush() { s.persist() }
+
+// lastSeenLabel is DXHunter's "Just now / 5m ago / 3h ago / 2d ago" string,
+// computed at read time so it never goes stale in the file.
+func lastSeenLabel(t time.Time) string {
+	if t.IsZero() {
+		return "Never"
+	}
+	d := time.Since(t)
+	switch {
+	case d < time.Minute:
+		return "Just now"
+	case d < time.Hour:
+		return fmt.Sprintf("%dm ago", int(d.Minutes()))
+	case d < 24*time.Hour:
+		return fmt.Sprintf("%dh ago", int(d.Hours()))
+	default:
+		return fmt.Sprintf("%dd ago", int(d.Hours()/24))
+	}
+}
+
+// Get returns one entry by its exact name — the alert path needs its contest
+// flag after MarkSeen named it.
+func (s *Store) Get(callsign string) (Entry, bool) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	e, ok := s.entries[strings.ToUpper(strings.TrimSpace(callsign))]
+	if !ok {
+		return Entry{}, false
+	}
+	return *e, true
+}

internal/watchlist/watchlist_test.go

@@ -0,0 +1,92 @@
+package watchlist
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestGlobMatch(t *testing.T) {
+	s := New(filepath.Join(t.TempDir(), "watchlist.json"))
+	if err := s.Add("RI0SP*", false); err != nil {
+		t.Fatal(err)
+	}
+	if err := s.Add("N8W", false); err != nil {
+		t.Fatal(err)
+	}
+	// A starred entry is a family: the expedition's portable forms.
+	for _, call := range []string{"RI0SP", "RI0SP/MM", "RI0SP/P"} {
+		if _, ok := s.Match(call); !ok {
+			t.Errorf("Match(%q) = false, want true", call)
+		}
+	}
+	// A bare entry is THAT call — the reported bug was N8W lighting up for
+	// N8WCR, a different station entirely.
+	if _, ok := s.Match("N8W"); !ok {
+		t.Error("exact entry must match its own call")
+	}
+	if _, ok := s.Match("N8WCR"); ok {
+		t.Error("exact entry must NOT match a longer call")
+	}
+	if _, ok := s.Match("RI0S"); ok {
+		t.Error("a SHORTER call must not match a starred entry")
+	}
+	if err := s.Add("VK*9", false); err == nil {
+		t.Error("a mid-string star must be refused")
+	}
+	if err := s.Add("*", false); err == nil {
+		t.Error("a bare star must be refused")
+	}
+}
+
+func TestDXHunterFileRoundTrips(t *testing.T) {
+	// A real DXHunter entry, ClubLog block included. It must survive
+	// load → save byte-meaningfully: same keys, values preserved.
+	src := `[{"callsign":"C5SP","lastSeen":"0001-01-01T00:00:00Z","lastSeenStr":"Never",
+	  "addedAt":"2026-01-17T00:18:43.89Z","spotCount":7,"isContest":true,"notify":true,
+	  "isExpedition":true,"clubLogQSOs24h":120,"clubLogTotalQSOs":30500,
+	  "clubLogHasOQRS":true,"clubLogLiveStream":true,"clubLogUpdatedAt":"2026-08-28T22:32:18Z"}]`
+	dir := t.TempDir()
+	path := filepath.Join(dir, "watchlist.json")
+	if err := os.WriteFile(path, []byte(src), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	s := New(path)
+	s.Flush()
+	out, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var list []map[string]any
+	if err := json.Unmarshal(out, &list); err != nil {
+		t.Fatal(err)
+	}
+	if len(list) != 1 {
+		t.Fatalf("got %d entries", len(list))
+	}
+	e := list[0]
+	for k, want := range map[string]any{
+		"callsign": "C5SP", "isContest": true, "notify": true,
+		"isExpedition": true, "clubLogQSOs24h": float64(120),
+		"clubLogTotalQSOs": float64(30500), "clubLogHasOQRS": true,
+	} {
+		if e[k] != want {
+			t.Errorf("%s = %v, want %v", k, e[k], want)
+		}
+	}
+}
+
+func TestMarkSeenAndNotify(t *testing.T) {
+	s := New(filepath.Join(t.TempDir(), "watchlist.json"))
+	_ = s.Add("HB040A", false)
+	_ = s.SetNotify("HB040A", true)
+	entry, notify, ok := s.MarkSeen("HB040A")
+	if !ok || !notify || entry != "HB040A" {
+		t.Fatalf("MarkSeen = %q %v %v", entry, notify, ok)
+	}
+	list := s.Entries()
+	if list[0].SpotCount != 1 || list[0].LastSeenStr != "Just now" {
+		t.Errorf("entry after MarkSeen: %+v", list[0])
+	}
+}

telemetry.go

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

windowpos_other.go

@@ -0,0 +1,7 @@
+//go:build !windows
+
+package main
+
+// Placing a window at an absolute desktop coordinate is Windows-specific; every
+// caller falls back to the toolkit's own call when this says no.
+func setWindowPosAbsolute(x, y int) bool { return false }

windowpos_windows.go

@@ -0,0 +1,93 @@
+//go:build windows
+
+package main
+
+import (
+	"syscall"
+	"unsafe"
+
+	"hamlog/internal/applog"
+)
+
+// Moving the window to an ABSOLUTE virtual-desktop position.
+//
+// Wails' own WindowSetPosition cannot do it. Its Windows implementation reads:
+//
+//	func (cba *ControlBase) SetPos(x, y int) {
+//	    info := getMonitorInfo(cba.hwnd)
+//	    w32.SetWindowPos(cba.hwnd, HWND_TOP, int(info.RcWork.Left)+x, int(info.RcWork.Top)+y, ...)
+//	}
+//
+// — the coordinates are relative to the CURRENT monitor's work area, while
+// WindowGetPosition returns GetWindowRect, which is absolute. Saving one and
+// restoring the other is only harmless on the primary monitor, where the work
+// area starts at 0.
+//
+// On a second monitor to the LEFT it compounds at every launch. Reported from a
+// two-screen station with the left monitor at x = -3840: OpsLog saved -3844,
+// reopened on that monitor, added the monitor's own origin, and stored -7684 —
+// then -11524, each launch one screen further into nowhere.
+//
+// So we place the window ourselves. Same call the toolkit makes, without the
+// offset.
+const (
+	swpNoSize     = 0x0001
+	swpNoZOrder   = 0x0004
+	swpNoActivate = 0x0010
+)
+
+var (
+	procSetWindowPos              = user32Dll.NewProc("SetWindowPos")
+	procEnumWindows               = user32Dll.NewProc("EnumWindows")
+	procGetWindowThreadProcessID  = user32Dll.NewProc("GetWindowThreadProcessId")
+	procGetWindowTextLengthW      = user32Dll.NewProc("GetWindowTextLengthW")
+	procGetWindow                 = user32Dll.NewProc("GetWindow")
+	kernel32Dll                   = syscall.NewLazyDLL("kernel32.dll")
+	procGetCurrentProcessIDWinPos = kernel32Dll.NewProc("GetCurrentProcessId")
+)
+
+// mainWindowHandle finds this process's own top-level window.
+//
+// Wails does not expose the handle, so it is looked up: the first top-level
+// window belonging to this process id that has no owner and a title. The window
+// is created hidden (StartHidden), and EnumWindows lists hidden windows too,
+// which is what makes this usable before the window is shown.
+func mainWindowHandle() uintptr {
+	self, _, _ := procGetCurrentProcessIDWinPos.Call()
+	var found uintptr
+	cb := syscall.NewCallback(func(hwnd uintptr, _ uintptr) uintptr {
+		var pid uint32
+		procGetWindowThreadProcessID.Call(hwnd, uintptr(unsafe.Pointer(&pid)))
+		if uintptr(pid) != self {
+			return 1 // keep going
+		}
+		// GW_OWNER = 4: skip tool windows and dialogs owned by the main one.
+		if owner, _, _ := procGetWindow.Call(hwnd, 4); owner != 0 {
+			return 1
+		}
+		if n, _, _ := procGetWindowTextLengthW.Call(hwnd); n == 0 {
+			return 1
+		}
+		found = hwnd
+		return 0 // stop
+	})
+	procEnumWindows.Call(cb, 0)
+	return found
+}
+
+// setWindowPosAbsolute moves the window to a virtual-desktop coordinate.
+// Reports whether it could; the caller falls back to the toolkit's own call.
+func setWindowPosAbsolute(x, y int) bool {
+	hwnd := mainWindowHandle()
+	if hwnd == 0 {
+		applog.Printf("window: could not find our own window handle — falling back to the toolkit's placement")
+		return false
+	}
+	r, _, err := procSetWindowPos.Call(hwnd, 0, uintptr(int32(x)), uintptr(int32(y)), 0, 0,
+		swpNoSize|swpNoZOrder|swpNoActivate)
+	if r == 0 {
+		applog.Printf("window: SetWindowPos(%d,%d) failed: %v", x, y, err)
+		return false
+	}
+	return true
+}