chore: release v0.24.7

docs(changelog): cut the 0.24.7 entries to one line each
Entries had grown to 250-450 characters, carrying the symptom, the mechanism and the reassurance about existing setups. The panel is read top to bottom; that belongs in the commit message, which has no length limit and is not competing for the reader's attention.
2026-08-12 14:45:19 +02:00 · 2026-08-12 11:10:48 +02:00 · 2026-08-12 11:08:45 +02:00 · 2026-08-12 10:57:04 +02:00 · 2026-08-12 10:51:12 +02:00 · 2026-08-12 10:43:23 +02:00
26 changed files with 1120 additions and 101 deletions
@@ -233,6 +233,8 @@ const (
 	keyUltrabeamPort    = "ultrabeam.port"
 	keyUltrabeamFollow  = "ultrabeam.follow"     // "1" → re-tune to the rig frequency
 	keyUltrabeamStep    = "ultrabeam.step_khz"   // re-tune hysteresis: 25 | 50 | 100 kHz
+	keyMotorTrackMode   = "motor.track_mode"     // "always" | "step" | "band"
+	keyMotorBandFreqs   = "motor.band_freqs"     // per-band tune frequency: "40m=7100,20m=14150"
 	keyMotorType        = "ultrabeam.type"       // "ultrabeam" | "steppir" (default ultrabeam)
 	keyMotorTransport   = "ultrabeam.transport"  // "tcp" | "serial" (default tcp)
 	keyMotorCOM         = "ultrabeam.com"        // serial device name (COM3, /dev/ttyUSB0)
@@ -2721,6 +2723,15 @@ func (a *App) applySolar(q *qso.QSO) {
 	if a.solar == nil {
 		return
 	}
+	// Today's space weather belongs on today's QSO. The ADIF monitor and the UDP
+	// path both feed contacts that are normally seconds old, but neither promises
+	// it: a logger re-broadcasting its backlog, or an operator typing in last
+	// month's contact by hand, would otherwise be given this morning's SFI as if
+	// it had been measured at the time. A wrong number is worse than none — it
+	// cannot be told from a real reading afterwards.
+	if !q.QSODate.IsZero() && time.Since(q.QSODate) > 24*time.Hour {
+		return
+	}
 	d := a.solar.Get()
 	if !d.OK {
 		return
@@ -4475,6 +4486,7 @@ func (a *App) awardRefMetas(defs []award.Def) map[string][]award.RefMeta {
 			metas = append(metas, award.RefMeta{
 				Code: rf.Code, Name: rf.Name, Group: rf.Group, SubGrp: rf.SubGrp,
 				DXCCList: dxccList, Pattern: rf.Pattern, Valid: rf.Valid,
+				ValidFrom: rf.ValidFrom, ValidTo: rf.ValidTo,
 			})
 		}
 		out[code] = metas
@@ -11823,6 +11835,16 @@ func (a *App) LogUDPLoggedADIF(adifText string) (int64, error) {
 	a.refineDistrictZones(&q)          // W6 → CQ3/ITU6 for zone-split countries
 	a.applyQSLDefaults(&q)

+	// ── Space weather and path length ──
+	// Also "same as the manual path", and they were missed when that comment was
+	// written. A QSO auto-logged from WSJT-X went in with no SFI, no A, no K and
+	// no distance, so an operator running digital — which is most of the traffic
+	// on most stations — had those fields empty across the whole log while a
+	// hand-logged contact carried them. Both are stamped only where the record
+	// left them empty, so an ADIF that supplied its own still wins.
+	a.applySolar(&q)
+	fillDistance(&q)
+
 	// ── Dedup (serialised) ──
 	// Match by call + band + mode within a ±2-minute window: a QSO logged
 	// manually in OpsLog and re-broadcast by Log4OM over UDP often differs by
@@ -12346,13 +12368,25 @@ func (a *App) ultrabeamFollowNow(freqHz int64) {
 	if ref <= 0 {
 		ref = c.LastSetKHz()
 	}
-	diff := khz - ref
-	if diff < 0 {
-		diff = -diff
-	}
-	if ref > 0 && diff < step {
-		applog.Printf("ultrabeam: followNow within deadband (%d kHz vs ref %d, step %d) — no move", khz, ref, step)
-		return // within the deadband — don't chase a tiny QSY
+	switch normMotorTrackMode(s.TrackMode) {
+	case motorTrackAlways:
+		// Every frequency change means every frequency change, including this one.
+	case motorTrackBand:
+		// The antenna is already resonant somewhere in this band — that is all the
+		// operator asked for in band mode, so a spot click inside it moves nothing.
+		if ref > 0 && bandForHz(int64(ref)*1000) == bandForHz(freqHz) {
+			applog.Printf("ultrabeam: followNow stays in band %q (antenna at %d kHz) — no move", bandForHz(freqHz), ref)
+			return
+		}
+	default:
+		diff := khz - ref
+		if diff < 0 {
+			diff = -diff
+		}
+		if ref > 0 && diff < step {
+			applog.Printf("ultrabeam: followNow within deadband (%d kHz vs ref %d, step %d) — no move", khz, ref, step)
+			return // within the deadband — don't chase a tiny QSY
+		}
 	}
 	a.noteMotorMoveCommanded()
 	if err := c.SetFrequency(khz, st.Direction); err != nil {
@@ -14634,6 +14668,17 @@ type UltrabeamSettings struct {
 	Baud      int    `json:"baud"`       // serial baud
 	Follow    bool   `json:"follow"`     // re-tune the antenna to the rig's frequency
 	StepKHz   int    `json:"step_khz"`   // re-tune only when the freq moved this far (25/50/100)
+	// When the follow loop is allowed to move the motors. The three choices the
+	// SteppIR's own controller software offers, because operators arrive with
+	// that mental model:
+	//   "always" — every frequency change. Resonance is always right, at the cost
+	//              of motors running constantly; on a SteppIR every move also
+	//              inhibits transmit while the elements travel.
+	//   "step"   — only past a threshold (StepKHz). The default, and the sane
+	//              middle: the antenna follows a QSY but ignores tuning around.
+	//   "band"   — only when the band changes. Motors move a handful of times a
+	//              day; resonance is whatever the band-entry frequency gave.
+	TrackMode string `json:"track_mode"`
 	TXInhibit bool   `json:"tx_inhibit"` // block Flex transmission while the elements are moving
 	// Bands the antenna covers — the follow filter. The follow loop only re-tunes
 	// (and only lets TX-inhibit trigger) on a band in this set; on any other band
@@ -14641,6 +14686,11 @@ type UltrabeamSettings struct {
 	// range so a single band can be dropped (e.g. 30 m without its extension) while
 	// its neighbours stay. Applies to BOTH the Ultrabeam and the SteppIR.
 	Bands []string `json:"bands"`
+	// Per-band tune frequency (kHz) — where a band button in Station Control
+	// sends the antenna. Sparse: a band with no entry uses its default, so an
+	// operator sets only the bands he cares about and an existing config needs no
+	// migration.
+	BandFreqs map[string]int `json:"band_freqs"`
 	// Legacy tunable range (MHz). Superseded by Bands; kept so an older config
 	// migrates cleanly (the range is converted to a band set on load) and so the
 	// value round-trips. Not used by the follow filter once Bands is set.
@@ -14648,16 +14698,39 @@ type UltrabeamSettings struct {
 	FreqMaxMHz int `json:"freq_max_mhz"`
 }

+// Tracking modes. Stored as strings rather than an int so a settings row stays
+// readable when diagnosing an antenna that moves too much or not at all.
+const (
+	motorTrackAlways = "always"
+	motorTrackStep   = "step"
+	motorTrackBand   = "band"
+)
+
+// normMotorTrackMode keeps an unknown or empty value on the threshold mode
+// instead of guessing — a config written before this option existed then
+// behaves exactly as it did.
+func normMotorTrackMode(m string) string {
+	switch strings.ToLower(strings.TrimSpace(m)) {
+	case motorTrackAlways:
+		return motorTrackAlways
+	case motorTrackBand:
+		return motorTrackBand
+	default:
+		return motorTrackStep
+	}
+}
+
 // GetUltrabeamSettings returns the persisted motorized-antenna config, defaulting
 // to the pre-SteppIR behaviour (Ultrabeam over TCP) so an existing install is
 // unchanged.
 func (a *App) GetUltrabeamSettings() (UltrabeamSettings, error) {
-	out := UltrabeamSettings{Type: "ultrabeam", Transport: "tcp", Port: 23, Baud: 9600, StepKHz: 50}
+	out := UltrabeamSettings{Type: "ultrabeam", Transport: "tcp", Port: 23, Baud: 9600, StepKHz: 50, TrackMode: motorTrackStep}
 	if a.settings == nil {
 		return out, fmt.Errorf("db not initialized")
 	}
 	m, err := a.settings.GetMany(a.ctx, keyUltrabeamEnabled, keyUltrabeamHost, keyUltrabeamPort, keyUltrabeamFollow, keyUltrabeamStep,
-		keyMotorType, keyMotorTransport, keyMotorCOM, keyMotorBaud, keyMotorTXInhibit, keyMotorFreqMin, keyMotorFreqMax, keyMotorBands)
+		keyMotorType, keyMotorTransport, keyMotorCOM, keyMotorBaud, keyMotorTXInhibit, keyMotorFreqMin, keyMotorFreqMax, keyMotorBands,
+		keyMotorTrackMode, keyMotorBandFreqs)
 	if err != nil {
 		return out, err
 	}
@@ -14681,6 +14754,8 @@ func (a *App) GetUltrabeamSettings() (UltrabeamSettings, error) {
 	if st, _ := strconv.Atoi(m[keyUltrabeamStep]); st == 25 || st == 50 || st == 100 {
 		out.StepKHz = st
 	}
+	out.TrackMode = normMotorTrackMode(m[keyMotorTrackMode])
+	out.BandFreqs = decodeMotorBandFreqs(m[keyMotorBandFreqs])
 	out.FreqMinMHz, _ = strconv.Atoi(m[keyMotorFreqMin])
 	out.FreqMaxMHz, _ = strconv.Atoi(m[keyMotorFreqMax])
 	// Bands is the follow filter. If it was saved, use it verbatim. Otherwise this
@@ -14746,6 +14821,8 @@ func (a *App) SaveUltrabeamSettings(s UltrabeamSettings) error {
 		keyUltrabeamPort:    strconv.Itoa(s.Port),
 		keyUltrabeamFollow:  boolStr(s.Follow),
 		keyUltrabeamStep:    strconv.Itoa(s.StepKHz),
+		keyMotorTrackMode:   normMotorTrackMode(s.TrackMode),
+		keyMotorBandFreqs:   encodeMotorBandFreqs(normMotorBandFreqs(s.BandFreqs)),
 		keyMotorType:        s.Type,
 		keyMotorTransport:   s.Transport,
 		keyMotorCOM:         strings.TrimSpace(s.COM),
@@ -14831,12 +14908,91 @@ func (a *App) startUltrabeam() {
 // fitted) while keeping its neighbours — something a contiguous min/max range
 // can't express. nomMHz is a representative in-band frequency, used only to
 // migrate a legacy FreqMin/FreqMax range into a band set.
+// defKHz is where a band button tunes the antenna when the operator has not
+// chosen a frequency for that band — roughly mid-band, where a beam's pattern is
+// usable across the whole allocation. It is only a default: an operator who
+// lives in the CW segment sets his own, exactly as the SteppIR controller's own
+// "Frequency (KHz)" column does.
 var motorBands = []struct {
 	name   string
 	nomMHz int
+	defKHz int
 }{
-	{"40m", 7}, {"30m", 10}, {"20m", 14}, {"17m", 18},
-	{"15m", 21}, {"12m", 24}, {"10m", 28}, {"6m", 50},
+	{"40m", 7, 7100}, {"30m", 10, 10125}, {"20m", 14, 14150}, {"17m", 18, 18110},
+	{"15m", 21, 21150}, {"12m", 24, 24930}, {"10m", 28, 28400}, {"6m", 50, 50150},
+}
+
+// motorBandDefaultKHz is the fallback tune frequency for a band, 0 if unknown.
+func motorBandDefaultKHz(band string) int {
+	band = strings.ToLower(strings.TrimSpace(band))
+	for _, b := range motorBands {
+		if b.name == band {
+			return b.defKHz
+		}
+	}
+	return 0
+}
+
+// normMotorBandFreqs keeps only entries that name a real motor band AND whose
+// frequency actually falls in that band.
+//
+// The check matters: this value is fed straight to the antenna as a tune
+// command. A slip of one digit — 1450 for 20 m, or kHz typed as MHz — would send
+// the elements travelling to a length that is wrong for the band the operator is
+// on, and on a SteppIR that is a long, transmit-inhibited journey to a position
+// nobody asked for. An entry that fails the check is dropped, so the band falls
+// back to its default rather than to nonsense.
+func normMotorBandFreqs(in map[string]int) map[string]int {
+	out := map[string]int{}
+	for _, b := range motorBands {
+		khz, ok := in[b.name]
+		if !ok || khz <= 0 {
+			continue
+		}
+		if bandForHz(int64(khz)*1000) != b.name {
+			applog.Printf("motor-antenna: ignoring %d kHz for %s — not in that band", khz, b.name)
+			continue
+		}
+		out[b.name] = khz
+	}
+	return out
+}
+
+// encodeMotorBandFreqs / decodeMotorBandFreqs store the map as "40m=7100,20m=14150".
+// A flat string rather than JSON so the settings row stays readable, and so a
+// value corrupted by hand degrades one band instead of the whole set.
+func encodeMotorBandFreqs(m map[string]int) string {
+	parts := []string{}
+	for _, b := range motorBands { // canonical order, not map order
+		if khz := m[b.name]; khz > 0 {
+			parts = append(parts, fmt.Sprintf("%s=%d", b.name, khz))
+		}
+	}
+	return strings.Join(parts, ",")
+}
+
+func decodeMotorBandFreqs(s string) map[string]int {
+	out := map[string]int{}
+	for _, kv := range strings.Split(s, ",") {
+		name, val, ok := strings.Cut(strings.TrimSpace(kv), "=")
+		if !ok {
+			continue
+		}
+		if khz, err := strconv.Atoi(strings.TrimSpace(val)); err == nil && khz > 0 {
+			out[strings.ToLower(strings.TrimSpace(name))] = khz
+		}
+	}
+	return normMotorBandFreqs(out)
+}
+
+// motorTuneKHzForBand is the frequency a band button commands: the operator's
+// choice when set, the default otherwise.
+func motorTuneKHzForBand(m map[string]int, band string) int {
+	band = strings.ToLower(strings.TrimSpace(band))
+	if khz := m[band]; khz > 0 {
+		return khz
+	}
+	return motorBandDefaultKHz(band)
 }

 // motorBandNames is the full ordered set (all bands enabled).
@@ -14985,10 +15141,21 @@ func (a *App) motorTXInhibitLoop(c motorAntenna, bands []string, stop <-chan str
 	}
 }

-func (a *App) ultrabeamFollowLoop(c motorAntenna, stepKHz int, bands []string, stop <-chan struct{}) {
+func (a *App) ultrabeamFollowLoop(c motorAntenna, mode string, stepKHz int, bands []string, stop <-chan struct{}) {
 	if stepKHz <= 0 {
 		stepKHz = 50
 	}
+	mode = normMotorTrackMode(mode)
+	// "Every time the frequency changes" is the threshold mode with the smallest
+	// threshold there is: the loop already re-tunes when the rig has moved at
+	// least stepKHz from the last commanded frequency, and 1 kHz makes that
+	// "moved at all". Expressing it this way keeps ONE decision path, so the
+	// deadband reference — which is the rig, not the antenna's own flaky reported
+	// frequency — cannot drift out of step between modes.
+	if mode == motorTrackAlways {
+		stepKHz = 1
+	}
+	lastCmdBand := "" // band of the last commanded move — the reference in band mode
 	ticker := time.NewTicker(1500 * time.Millisecond)
 	defer ticker.Stop()
 	lastRigKHz := 0 // only log when the followed rig frequency actually changes
@@ -15046,19 +15213,35 @@ func (a *App) ultrabeamFollowLoop(c motorAntenna, stepKHz int, bands []string, s
 					ref = c.LastSetKHz()
 				}
 			}
-			diff := rigKHz - ref
-			if diff < 0 {
-				diff = -diff
-			}
-			if ref > 0 && diff < stepKHz {
-				continue // within the deadband — leave the motors alone
+			// Band mode ignores the threshold entirely: the antenna is re-tuned once
+			// on entering a band and then left alone however far the rig roams
+			// inside it. The reference is the band we last COMMANDED for, not the
+			// rig's previous band — otherwise a first move after startup, or any
+			// move the operator made by hand, would never be reconciled.
+			if mode == motorTrackBand {
+				b := bandForHz(rs.FreqHz)
+				if b == lastCmdBand {
+					continue
+				}
+				if newFreq {
+					applog.Printf("ultrabeam: band changed %q → %q — re-tuning to %d kHz", lastCmdBand, b, rigKHz)
+				}
+			} else {
+				diff := rigKHz - ref
+				if diff < 0 {
+					diff = -diff
+				}
+				if ref > 0 && diff < stepKHz {
+					continue // within the deadband — leave the motors alone
+				}
 			}
 			a.noteMotorMoveCommanded()
 			if err := c.SetFrequency(rigKHz, st.Direction); err != nil {
 				applog.Printf("ultrabeam: follow re-tune to %d kHz failed: %v", rigKHz, err)
 			} else {
 				lastCmdKHz = rigKHz
-				applog.Printf("ultrabeam: followed rig → %d kHz (dir %d, was ref %d kHz, step %d)", rigKHz, st.Direction, ref, stepKHz)
+				lastCmdBand = bandForHz(rs.FreqHz)
+				applog.Printf("ultrabeam: followed rig → %d kHz (dir %d, was ref %d kHz, mode %s, step %d)", rigKHz, st.Direction, ref, mode, stepKHz)
 			}
 		}
 	}
@@ -15078,12 +15261,17 @@ type UltrabeamStatusInfo struct {
 	Elements  []int  `json:"elements"` // per-element lengths (mm); empty when unsupported
 	// Follow and StepKHz are mirrored here so the Station Control widget can show
 	// and change tracking without loading the whole settings block for a poll.
-	Follow  bool `json:"follow"`
-	StepKHz int  `json:"step_khz"`
+	Follow    bool   `json:"follow"`
+	StepKHz   int    `json:"step_khz"`
+	TrackMode string `json:"track_mode"`
 	// Bands the antenna is configured to cover — the widget offers exactly these
 	// as buttons rather than inventing its own list, so a band dropped in Settings
 	// cannot be clicked here.
 	Bands []string `json:"bands"`
+	// Where each band button tunes. Resolved here — operator's choice or the
+	// default — so the widget never has to carry its own copy of the band table
+	// and cannot drift from what Settings shows.
+	BandFreqs map[string]int `json:"band_freqs"`
 }

 // GetUltrabeamStatus returns the antenna's current state for the UI poll.
@@ -15094,6 +15282,13 @@ func (a *App) GetUltrabeamStatus() UltrabeamStatusInfo {
 	out.Type = s.Type
 	out.Follow = s.Follow
 	out.StepKHz = s.StepKHz
+	out.TrackMode = normMotorTrackMode(s.TrackMode)
+	out.BandFreqs = map[string]int{}
+	for _, b := range s.Bands {
+		if khz := motorTuneKHzForBand(s.BandFreqs, b); khz > 0 {
+			out.BandFreqs[b] = khz
+		}
+	}
 	out.Bands = append(out.Bands, s.Bands...)
 	if a.motorAnt == nil {
 		return out
@@ -15199,7 +15394,7 @@ func (a *App) MotorNudgeKHz(deltaKHz int) error {
 // opening Settings. Both are ordinary operating decisions — an operator turns
 // tracking off to park the antenna and back on to resume — and a preferences
 // dialog is the wrong place for something changed that often.
-func (a *App) SetMotorFollow(on bool, stepKHz int) error {
+func (a *App) SetMotorFollow(on bool, stepKHz int, mode string) error {
 	s, err := a.GetUltrabeamSettings()
 	if err != nil {
 		return err
@@ -15211,6 +15406,11 @@ func (a *App) SetMotorFollow(on bool, stepKHz int) error {
 	default:
 		return fmt.Errorf("step must be 25, 50 or 100 kHz")
 	}
+	// An empty mode leaves it alone, so the caller toggling tracking on and off
+	// does not have to know or resend it.
+	if strings.TrimSpace(mode) != "" {
+		s.TrackMode = normMotorTrackMode(mode)
+	}
 	s.Follow = on

 	// Persist WITHOUT the restart. SaveUltrabeamSettings tears the client down and
@@ -15232,6 +15432,9 @@ func (a *App) SetMotorFollow(on bool, stepKHz int) error {
 	if err := a.settings.Set(a.ctx, keyUltrabeamStep, strconv.Itoa(s.StepKHz)); err != nil {
 		return err
 	}
+	if err := a.settings.Set(a.ctx, keyMotorTrackMode, normMotorTrackMode(s.TrackMode)); err != nil {
+		return err
+	}
 	a.restartMotorFollow(s)
 	return nil
 }
@@ -15249,8 +15452,8 @@ func (a *App) restartMotorFollow(s UltrabeamSettings) {
 	}
 	stop := make(chan struct{})
 	a.ubFollowStop = stop
-	applog.Printf("ultrabeam: follow loop restarting — covered bands %v, step %d kHz", s.Bands, s.StepKHz)
-	go a.ultrabeamFollowLoop(a.motorAnt, s.StepKHz, s.Bands, stop)
+	applog.Printf("ultrabeam: follow loop restarting — covered bands %v, mode %s, step %d kHz", s.Bands, normMotorTrackMode(s.TrackMode), s.StepKHz)
+	go a.ultrabeamFollowLoop(a.motorAnt, s.TrackMode, s.StepKHz, s.Bands, stop)
 }

 // UltrabeamRetract retracts all elements (storage / safe position).
@@ -126,7 +126,13 @@ func (a *App) startBandOpenFeed() {
 		a.pskr = nil
 	}
 	s := a.GetBandOpenSettings()
+	a.bandOpen.on.Store(s.Enabled)
 	if !s.Enabled {
+		// Put out whatever is currently lit. Leaving the badges up would keep
+		// announcing an opening from a watch that is now off, and they only fade
+		// on a timer fed by spots this path no longer looks at — so they would
+		// hang there until the app restarted.
+		a.clearBandOpenings()
 		return
 	}
 	// Every spot is measured from the operator's position. Without one there is
@@ -11,6 +11,7 @@ import (
 	"fmt"
 	"strings"
 	"sync"
+	"sync/atomic"
 	"time"

 	"hamlog/internal/applog"
@@ -21,6 +22,13 @@ import (
 )

 type bandOpenState struct {
+	// on mirrors the "Watch for band openings" setting.
+	//
+	// Cached rather than read per spot: this is the cluster hot path, where a
+	// settings query per spot is exactly what the rest of this file avoids.
+	// startBandOpenFeed owns it — it runs at startup and again on every save, so
+	// the switch takes effect without a restart.
+	on   atomic.Bool
 	mu   sync.Mutex
 	det  *bandopen.Detector
 	last []bandopen.Opening // most recent first, for the UI
@@ -45,6 +53,16 @@ const maxRememberedOpenings = 20

 // detectBandOpening feeds one spot to the detector and announces a hit.
 func (a *App) detectBandOpening(s cluster.Spot) {
+	// The watch has to be switched on.
+	//
+	// It was not checked here at all: the setting only ever governed the extra
+	// DATA SOURCES (the RBN nodes and the PSK Reporter feed), while the detector
+	// itself ran on every ordinary cluster spot. So an operator who had never
+	// enabled the watch still got opening banners, from a feature they had
+	// deliberately left off.
+	if !a.bandOpen.on.Load() {
+		return
+	}
 	// No operator grid = no distance and no bearing on the spot, and the whole
 	// detection rests on those two. Say nothing rather than guess.
 	if !a.opSet || s.DistanceKm <= 0 || !bandopen.Watched(s.Band) {
@@ -122,6 +140,21 @@ func (a *App) GetLiveOpenings() []bandopen.Opening {
 	return out
 }

+// clearBandOpenings puts out every lit badge and forgets the detector's window.
+// Called when the watch is switched off: the badges fade on a timer fed by
+// spots the detector no longer looks at, so without this they would stay up
+// until the next restart. The remembered list is left alone — those openings
+// really did happen, and the operator may still want to see what he missed.
+func (a *App) clearBandOpenings() {
+	a.bandOpen.mu.Lock()
+	defer a.bandOpen.mu.Unlock()
+	a.bandOpen.live = nil
+	a.bandOpen.aliveUntil = nil
+	// Drop the accumulated spot window too, so switching the watch back on starts
+	// from what is on the air now rather than from an hour-old burst.
+	a.bandOpen.det = nil
+}
+
 // announceOpening logs and pushes one detection. Shared by both feeds — the
 // cluster path here and the PSK Reporter path in bandopen_sources.go — so an
 // opening reads the same however it was noticed.
@@ -0,0 +1,65 @@
+package main
+
+import (
+	"testing"
+	"time"
+
+	"hamlog/internal/bandopen"
+	"hamlog/internal/cluster"
+)
+
+// The "Watch for band openings" switch has to gate the DETECTOR, not just the
+// extra data sources.
+//
+// It originally governed only the RBN nodes and the PSK Reporter feed, while
+// the detector itself ran on every ordinary cluster spot — so an operator who
+// had never enabled the watch still got opening banners for a feature he had
+// deliberately left off. That is what this pins.
+func TestBandOpenWatchGatesTheDetector(t *testing.T) {
+	spot := func() cluster.Spot {
+		return cluster.Spot{
+			DXCall: "EA1ABC", Band: "6m", DistanceKm: 1400, ShortPath: 210,
+			ReceivedAt: time.Now(),
+		}
+	}
+
+	// Switched off: the spot must not even reach the detector.
+	off := &App{opSet: true, opLat: 48.0, opLon: 2.0}
+	off.detectBandOpening(spot())
+	if off.bandOpen.det != nil {
+		t.Error("the detector ran with the watch switched off")
+	}
+
+	// Switched on: the same spot is accepted (one spot is not an opening, so
+	// nothing is announced — but the detector now exists and is collecting).
+	on := &App{opSet: true, opLat: 48.0, opLon: 2.0}
+	on.bandOpen.on.Store(true)
+	on.detectBandOpening(spot())
+	if on.bandOpen.det == nil {
+		t.Error("the detector did not run with the watch switched on")
+	}
+}
+
+// Switching the watch off must put the badges out. They fade on a timer fed by
+// spots the detector no longer looks at, so left alone they would stay lit
+// until the next restart.
+func TestClearBandOpeningsPutsTheBadgesOut(t *testing.T) {
+	a := &App{}
+	a.bandOpen.live = map[string]bandopen.Opening{"6m": {Band: "6m", Calls: 9}}
+	a.bandOpen.aliveUntil = map[string]time.Time{"6m": time.Now().Add(time.Hour)}
+	a.bandOpen.det = bandopen.New(bandopen.DefaultConfig())
+	a.bandOpen.last = []bandopen.Opening{{Band: "6m", Calls: 9}}
+
+	a.clearBandOpenings()
+
+	if got := a.GetLiveOpenings(); len(got) != 0 {
+		t.Errorf("a badge stayed lit after the watch was switched off: %v", got)
+	}
+	if a.bandOpen.det != nil {
+		t.Error("the accumulated spot window survived — switching back on would start from a stale burst")
+	}
+	// The history is NOT cleared: those openings really happened.
+	if len(a.GetBandOpenings()) != 1 {
+		t.Error("the remembered openings were thrown away")
+	}
+}
@@ -1,4 +1,30 @@
 [
+  {
+    "version": "0.24.7",
+    "date": "",
+    "en": [
+      "QSOs logged from WSJT-X now carry the space weather and the distance, like hand-logged ones.",
+      "Band openings: EME contacts are no longer mistaken for an opening. Each band now has the longest path the atmosphere can carry.",
+      "Kenwood: WSJT-X \"Fake It\" no longer leaves the dial on the transmit frequency.",
+      "PowerGenius XL: the Station Control card now shows power, current, SWR and temperature without a FlexRadio.",
+      "Motorized antennas: tracking now offers three modes — every frequency change, past a step, or band change only.",
+      "Motorized antennas: each covered band now has its own tune frequency, set in Settings.",
+      "Awards: a single award can now be exported on its own.",
+      "Awards: each reference now has its own validity window, so a reference that ceased to exist stops counting for later QSOs.",
+      "Band openings: the watch switch now governs the detection itself, not just the extra data sources."
+    ],
+    "fr": [
+      "Les QSO enregistrés depuis WSJT-X portent désormais la météo spatiale et la distance, comme ceux saisis à la main.",
+      "Ouvertures de bande : les contacts EME ne sont plus pris pour une ouverture. Chaque bande a désormais la distance maximale que l atmosphère peut porter.",
+      "Kenwood : le « Fake It » de WSJT-X ne laisse plus le VFO sur la fréquence d émission.",
+      "PowerGenius XL : la carte du Contrôle station affiche puissance, courant, ROS et température sans FlexRadio.",
+      "Antennes motorisées : le suivi propose trois modes — à chaque changement de fréquence, au-delà d un pas, ou au changement de bande.",
+      "Antennes motorisées : chaque bande couverte a désormais sa propre fréquence d accord, réglable dans les Réglages.",
+      "Diplômes : un diplôme peut désormais être exporté seul.",
+      "Diplômes : chaque référence a désormais sa fenêtre de validité, une référence disparue cesse donc de compter pour les QSO suivants.",
+      "Ouvertures de bande : l interrupteur de la veille gouverne désormais la détection elle-même, plus seulement les sources de données."
+    ]
+  },
  {
    "version": "0.24.6",
    "date": "",
@@ -90,7 +90,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 } from '@/lib/spotDisplay';
+import { applySpotDisplay, readSpotDisplayOptions, SPOT_DISPLAY_OPTIONS_EXPOSED } from '@/lib/spotDisplay';
 import { WorkedBeforeGrid } from '@/components/WorkedBeforeGrid';
 import { NetControlPanel } from '@/components/NetControlPanel';
 import { ContestPanel, CONTEST_DEFAULT, type ContestSession } from '@/components/ContestPanel';
@@ -1497,8 +1497,11 @@ export default function App() {
  // beside Hide worked and not among the status chips.
  const [clusterLotwOnly, setClusterLotwOnly] = useState(() => localStorage.getItem('opslog.clusterLotwOnly') === '1');
  const [clusterSpotterConts, setClusterSpotterConts] = useState<Set<string>>(() => lsSet<string>('opslog.clusterSpotterCont'));
-  const [clusterMuteWorked, setClusterMuteWorked] = useState(() => localStorage.getItem('opslog.clusterMuteWorked') === '1');
-  const [clusterSlotHighlight, setClusterSlotHighlight] = useState(() => localStorage.getItem('opslog.clusterSlotHighlight') === '1');
+  // Read through lib/spotDisplay, not straight from localStorage: while the two
+  // options are withdrawn it answers false, so the cluster list cannot end up
+  // applying an option the operator can no longer see or switch off.
+  const [clusterMuteWorked, setClusterMuteWorked] = useState(() => readSpotDisplayOptions().muteWorked);
+  const [clusterSlotHighlight, setClusterSlotHighlight] = useState(() => readSpotDisplayOptions().slotHighlight);
  const [clusterStatusFilter, setClusterStatusFilter] = useState<Set<SpotFilterKey>>(() => lsSet<SpotFilterKey>('opslog.clusterStatusFilter'));
  // Mode filter chips. Empty set = show every mode. Categories map the
  // inferred per-spot mode onto SSB (phone) / CW / DATA (digital).
@@ -4843,8 +4846,11 @@ export default function App() {
        <div className="space-y-0.5">
          {fSwitch(t('clu.hideWorked'), clusterHideWorked, setClusterHideWorked)}
          {fSwitch(t('clu.groupDup'), clusterGroup, setClusterGroup)}
-          {fSwitch(t('clu.muteWorkedShort'), clusterMuteWorked, (v) => { setClusterMuteWorked(v); writeUiPref('opslog.clusterMuteWorked', v ? '1' : '0'); })}
-          {fSwitch(t('clu.slotHighlightShort'), clusterSlotHighlight, (v) => { setClusterSlotHighlight(v); writeUiPref('opslog.clusterSlotHighlight', v ? '1' : '0'); })}
+          {/* The two display options are withdrawn for now — the flag is in
+              lib/spotDisplay, and it also forces them off for the band map, so
+              there is one place to flip when they come back. */}
+          {SPOT_DISPLAY_OPTIONS_EXPOSED && fSwitch(t('clu.muteWorkedShort'), clusterMuteWorked, (v) => { setClusterMuteWorked(v); writeUiPref('opslog.clusterMuteWorked', v ? '1' : '0'); })}
+          {SPOT_DISPLAY_OPTIONS_EXPOSED && fSwitch(t('clu.slotHighlightShort'), clusterSlotHighlight, (v) => { setClusterSlotHighlight(v); writeUiPref('opslog.clusterSlotHighlight', v ? '1' : '0'); })}
          {fSwitch(t('clu.lotwOnly'), clusterLotwOnly, (v) => { setClusterLotwOnly(v); writeUiPref('opslog.clusterLotwOnly', v ? '1' : '0'); })}
        </div>

@@ -174,6 +174,45 @@ export function AmpCard({ amp, flex, t }: { amp: Amp; flex: any; t: (k: string,
  const operate = viaFlex ? !!flex?.amp_operate : !!pg.operate;
  const connected = !!pg.connected || viaFlex;
  const fault = flex?.amp_fault;
+
+  // Meters built from the amplifier's own GSCP status frame, for when the radio
+  // is not feeding a meter stream.
+  //
+  // Whether there is power is the amp's state field; how much is the plain
+  // forward figure. NOT "peakfwd" — that is a latched maximum which is never
+  // reset and survives in the last-known status after the amp disconnects, so it
+  // once claimed 1350 W from an old transmission while 10 W was going out. Same
+  // reason peak_id is left alone. Both readings are gated on transmit so they
+  // fall back to zero between overs instead of freezing on the last one.
+  const pgxlMeters = () => {
+    if (!pg.connected) return null;
+    const txing = typeof flex?.transmitting === 'boolean' ? flex.transmitting : /TRANSMIT/i.test(pg.state || '');
+    const fwdW = peakHold('pgfwd', txing ? Number(pg.fwd_w) || 0 : 0);
+    const idA = peakHold('pgid', txing ? Number(pg.id) || 0 : 0);
+    const swr = peakHold('pgswr', txing ? Number(pg.vswr) || 0 : 0);
+    const tempC = Number(pg.temperature) || 0;
+    // Two columns, not four. The card sits beside a tall neighbour in Station
+    // Control, so a single row of four leaves the height empty and squeezes each
+    // bar into a quarter width — two rows of two use the room that is already
+    // there and give every bar twice the resolution.
+    return (
+      <div className="grid grid-cols-2 gap-2 mt-2 pt-2 border-t border-border/50">
+        <MeterBar label={t('flxp.outputPower')} value={fwdW} unit="W" lo={0} hi={2000}
+          display={`${Math.round(fwdW)} W`}
+          segColor={(f) => (f > 0.9 ? '#dc2626' : f > 0.75 ? '#f59e0b' : '#ea580c')} />
+        <MeterBar label={t('ampw.id')} value={idA} lo={0} hi={25} display={`${idA.toFixed(1)} A`} accent="#16a34a" />
+        {/* Below 1:1 the reading is meaningless, so an idle amp shows a flat bar
+            rather than a zero that looks like a perfect match. */}
+        <MeterBar label={t('ampw.swr')} value={swr >= 1 ? swr : 1} lo={1} hi={3}
+          display={swr >= 1 ? swr.toFixed(1) : '—'}
+          segColor={(f) => (f > 0.75 ? '#dc2626' : f > 0.4 ? '#f59e0b' : '#16a34a')} />
+        <MeterBar label={t('ampw.temp')} value={tempC} unit="°C" lo={0} hi={100}
+          display={tempC > 0 ? `${Math.round(tempC)} °C` : '—'}
+          segColor={(f) => (f > 0.8 ? '#dc2626' : f > 0.6 ? '#f59e0b' : '#ea580c')} />
+      </div>
+    );
+  };
+
  return (
    <Card icon={Flame} ckey="amplifier" title={`${t('flxp.amplifier')}${flex?.amp_model ? ' · ' + flex.amp_model : (pg.model ? ' · ' + pg.model : '')} · ${amp.name}`} accent="#ea580c">
      <div className="flex items-center gap-3 flex-wrap">
@@ -204,13 +243,20 @@ export function AmpCard({ amp, flex, t }: { amp: Amp; flex: any; t: (k: string,
          <span className="px-2 py-1 rounded bg-danger-muted text-danger-muted-foreground text-xs font-bold">{t('flxp.fault')}: {fault}</span>
        )}
      </div>
-      {/* Amplifier meters (FWD / ID / TEMP …) from the FlexRadio UDP stream. */}
-      {viaFlex && (() => {
+      {/* Amplifier meters (FWD / ID / TEMP …).
+          The FlexRadio UDP stream is the preferred source — it is fast and reads
+          the same as SmartSDR. When there is no Flex, or it is not streaming,
+          the amplifier's OWN link carries the same figures; falling back to them
+          is what the docked widget already does. Without that fallback this card
+          showed an operator on a Kenwood nothing but OPERATE and the fan mode,
+          while the amplifier was reporting power, current and temperature all
+          along. */}
+      {(() => {
        const meters = (flex?.meters as any[]) || [];
        const dbmToW = (d: number) => Math.pow(10, (d - 30) / 10);
        const amps = meters.filter((m) => (m.src || '').toUpperCase().includes('AMP')
          && !/^(RL|DRV)$/i.test((m.name || '').trim()));
-        if (amps.length === 0) return null;
+        if (!viaFlex || amps.length === 0) return pgxlMeters();
        // Power comes from the radio's meter stream and nothing else. The
        // amplifier also reports a "peakfwd", and using it was a mistake twice
        // over: it is a latched maximum that is never reset, and it survives in
@@ -1,5 +1,5 @@
 import { useCallback, useEffect, useMemo, useState } from 'react';
-import { Plus, Trash2, RotateCcw, Save, Download, Upload, Loader2, Search, FolderOpen, ArrowUpCircle } from 'lucide-react';
+import { Plus, Trash2, RotateCcw, Save, Download, Upload, Loader2, Search, FolderOpen, ArrowUpCircle, Share2 } from 'lucide-react';
 import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter } from '@/components/ui/dialog';
 import { Button } from '@/components/ui/button';
 import { Input } from '@/components/ui/input';
@@ -19,7 +19,7 @@ import {
  ListCountries, DXCCForCountry, DXCCName,
  PopulateBuiltinReferences, HasBuiltinReferences,
  ExportAwards, ImportAwards, InspectAwardImport, ApplyAwardImport, GetCatalogCodes, OpenAwardsFolder,
-  ExportAwardForCatalog,
+  ExportAwardForCatalog, ExportAward,
  GetAwardUpdates, ApplyAwardUpdate, DismissAwardUpdate, ExplainAward,
 } from '../../wailsjs/go/main/App';

@@ -97,6 +97,13 @@ function Chips({ all, value, onToggle }: { all: string[]; value: string[]; onTog
  );
 }

+// Awards use a far-future date as "no end" (RDA carries 9999-12-31). Printing it
+// back at the operator reads like a real deadline, so show it as open-ended.
+function openEnded(d?: string): string {
+  if (!d) return '—';
+  return /^9\d{3}-/.test(d) ? '—' : d;
+}
+
 function Field2({ label, children }: { label: string; children: React.ReactNode }) {
  return (
    <div className="grid grid-cols-[120px_1fr] items-center gap-2">
@@ -307,6 +314,23 @@ export function AwardEditor({ open, onClose, onSaved }: Props) {
      if (p) setErr(t('awed.exportedTo', { path: p }));
    } catch (e: any) { setErr(String(e?.message ?? e)); }
  }
+  // Export the SELECTED award on its own — the unit you actually share. The
+  // bundle above is a backup: sending it to someone hands over your whole
+  // catalogue when they asked for one award.
+  //
+  // Distinct from the catalog publish below, which is for shipping an award INTO
+  // OpsLog: that one stamps a version and clears user_edited. This one is a plain
+  // share and leaves both alone, so the recipient's copy is correctly marked as
+  // someone else's work rather than as a pristine built-in.
+  async function exportOne() {
+    setErr('');
+    if (!cur) return;
+    try {
+      const code = cur.code.trim().toUpperCase();
+      const p = await ExportAward(code);
+      if (p) setErr(t('awed.exportedOneTo', { code, path: p }));
+    } catch (e: any) { setErr(String(e?.message ?? e)); }
+  }
  // Export the SELECTED award as a catalog-ready JSON, stamped with a version, to
  // paste over internal/award/catalog/<code>.json. A new release then ships it to
  // the whole team (unedited copies auto-upgrade; edited ones are offered it).
@@ -761,6 +785,7 @@ export function AwardEditor({ open, onClose, onSaved }: Props) {
                  <TabsContent value="refs" className="mt-0">
                    <ReferencesPanel
                      code={cur.code.trim().toUpperCase()} presets={presets} meta={meta[cur.code.toUpperCase()]}
+                      awardValidFrom={cur.valid_from} awardValidTo={cur.valid_to}
                      onUpdateOnline={() => updateList(cur.code.toUpperCase())} updating={updating === cur.code.toUpperCase()}
                      onChanged={loadMeta} setErr={setErr}
                    />
@@ -780,6 +805,14 @@ export function AwardEditor({ open, onClose, onSaved }: Props) {
          <Button variant="outline" onClick={exportAwards} title={t('awed.exportTitle')}>
            <Download className="size-3.5 mr-1" /> {t('awed.export')}
          </Button>
+          {/* Share just the selected one. Sitting next to the whole-catalogue
+              export because that is where an operator looks for it, and labelled
+              with the code so the two are never confused at a glance. */}
+          {cur && (
+            <Button variant="outline" onClick={exportOne} title={t('awed.exportOneTitle')}>
+              <Share2 className="size-3.5 mr-1" /> {t('awed.exportOne', { code: cur.code.trim().toUpperCase() })}
+            </Button>
+          )}
          <Button variant="outline" onClick={importAwards} title={t('awed.importTitle')}>
            <Upload className="size-3.5 mr-1" /> {t('awed.import')}
          </Button>
@@ -874,8 +907,8 @@ export function AwardEditor({ open, onClose, onSaved }: Props) {
 // ReferencesPanel — manage the reference list of one award: search/list on the
 // left, a per-reference editor on the right, plus bulk paste/CSV, presets and
 // the online updater (POTA/SOTA/WWFF).
-function ReferencesPanel({ code, presets, meta, onUpdateOnline, updating, onChanged, setErr }: {
-  code: string; presets: Preset[]; meta?: RefMeta;
+function ReferencesPanel({ code, presets, meta, awardValidFrom, awardValidTo, onUpdateOnline, updating, onChanged, setErr }: {
+  code: string; presets: Preset[]; meta?: RefMeta; awardValidFrom?: string; awardValidTo?: string;
  onUpdateOnline: () => void; updating: boolean; onChanged: () => void; setErr: (s: string) => void;
 }) {
  const { t } = useI18n();
@@ -1031,6 +1064,26 @@ function ReferencesPanel({ code, presets, meta, onUpdateOnline, updating, onChan
                  third-party list may carry the values — but they are not offered
                  for editing until something actually reads them. */}
              <Field2 label={t('awed.grid')}><Input className="h-8 font-mono" value={sel.gridsquare ?? ''} onChange={(e) => patchSel({ gridsquare: e.target.value })} /></Field2>
+              {/* This reference's own validity window. A reference is not forever:
+                  a park is delisted, a district merged. A QSO made while it
+                  existed still counts — it was a valid contact on the day — and
+                  one made afterwards does not.
+                  Left empty the award's own dates govern, which is why they show
+                  as the placeholder: the operator can see what "empty" inherits
+                  instead of having to remember. */}
+              <Field2 label={t('awed.refValidFrom')}>
+                <Input type="date" className="h-8 w-44" value={sel.valid_from ?? ''}
+                  onChange={(e) => patchSel({ valid_from: e.target.value })} />
+              </Field2>
+              <Field2 label={t('awed.refValidTo')}>
+                <Input type="date" className="h-8 w-44" value={sel.valid_to ?? ''}
+                  onChange={(e) => patchSel({ valid_to: e.target.value })} />
+              </Field2>
+              <p className="text-xs text-muted-foreground">
+                {(awardValidFrom || awardValidTo)
+                  ? t('awed.refValidHintAward', { from: openEnded(awardValidFrom), to: openEnded(awardValidTo) })
+                  : t('awed.refValidHint')}
+              </p>
              <div className="flex justify-end pt-1"><Button size="sm" className="h-7" onClick={() => sel && saveRef(sel)}><Save className="size-3.5 mr-1" /> {t('awed.saveReference')}</Button></div>
            </div>
          )}
@@ -373,12 +373,16 @@ export function DetailsPanel({ callsign, prefix, operatorGrid, remoteGrid, qth,
              <Input value={details.address} onChange={(e) => onChange({ address: e.target.value })} />
            </Field>
          </div>
-          <Field label={t('detp.qslMessage')} span={7}>
-            <Input value={details.qsl_msg} onChange={(e) => onChange({ qsl_msg: e.target.value })} />
-          </Field>
-          <Field label={t('detp.qslVia')} span={5}>
+          {/* QSL via gets the room, not the message. Width should follow use, and
+              these two are nowhere near equal: a manager's callsign is filled in
+              constantly and a QSL message almost never. The message had 7 columns
+              of 12 for text most operators never type. */}
+          <Field label={t('detp.qslVia')} span={7}>
            <Input value={details.qsl_via} onChange={(e) => onChange({ qsl_via: e.target.value })} />
          </Field>
+          <Field label={t('detp.qslMessage')} span={5}>
+            <Input value={details.qsl_msg} onChange={(e) => onChange({ qsl_msg: e.target.value })} />
+          </Field>
        </div>
      )}

@@ -689,6 +689,13 @@ const RELAY_BANDS = ['160m', '80m', '60m', '40m', '30m', '20m', '17m', '15m', '1
 // Bands a motorized HF/6 m antenna (Ultrabeam / SteppIR) can cover — the follow
 // filter is a subset of these. Must match motorBands in app.go, low → high.
 const MOTOR_BANDS = ['40m', '30m', '20m', '17m', '15m', '12m', '10m', '6m'];
+// Shown as placeholders only — the backend owns these values (motorBands in
+// app.go) and resolves what a band button actually commands. Duplicated here
+// purely so an empty box can say what leaving it empty will do.
+const MOTOR_BAND_DEFAULT_KHZ: Record<string, number> = {
+  '40m': 7100, '30m': 10125, '20m': 14150, '17m': 18110,
+  '15m': 21150, '12m': 24930, '10m': 28400, '6m': 50150,
+};
 const relayCountUI = (type: string) => (type === 'kmtronic' || type === 'denkovi' ? 8 : 5);

 // Live status + OPERATE/STANDBY toggle for ONE configured amplifier (by config
@@ -1250,8 +1257,8 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
  const [rotatorTest, setRotatorTest] = useState<{ ok: boolean; msg: string } | null>(null);

  // Motorized antenna (Ultrabeam TCP or SteppIR TCP/serial) settings.
-  const [ultrabeam, setUltrabeam] = useState<{ enabled: boolean; type: string; transport: string; host: string; port: number; com: string; baud: number; follow: boolean; step_khz: number; tx_inhibit: boolean; bands: string[]; freq_min_mhz: number; freq_max_mhz: number }>({
-    enabled: false, type: 'ultrabeam', transport: 'tcp', host: '', port: 23, com: '', baud: 9600, follow: false, step_khz: 50, tx_inhibit: false, bands: [], freq_min_mhz: 13, freq_max_mhz: 54,
+  const [ultrabeam, setUltrabeam] = useState<{ enabled: boolean; type: string; transport: string; host: string; port: number; com: string; baud: number; follow: boolean; step_khz: number; track_mode: string; band_freqs: Record<string, number>; tx_inhibit: boolean; bands: string[]; freq_min_mhz: number; freq_max_mhz: number }>({
+    enabled: false, type: 'ultrabeam', transport: 'tcp', host: '', port: 23, com: '', baud: 9600, follow: false, step_khz: 50, track_mode: 'step', band_freqs: {}, tx_inhibit: false, bands: [], freq_min_mhz: 13, freq_max_mhz: 54,
  });
  const [ubTesting, setUbTesting] = useState(false);
  const [ubTest, setUbTest] = useState<{ ok: boolean; msg: string } | null>(null);
@@ -3140,45 +3147,96 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
          <div className="border-t border-border/60 pt-3 space-y-2">
            <label className="flex items-center gap-2 text-sm cursor-pointer">
              <Checkbox checked={ultrabeam.follow} onCheckedChange={(c) => setUltrabeam((s) => ({ ...s, follow: !!c }))} />
-              Follow rig frequency (auto-tune the antenna)
+              {t('hw.motorFollow')}
            </label>
            {ultrabeam.follow && (
-              <div className="flex items-center gap-3 pl-6">
-                <Label className="text-sm">Re-tune step</Label>
-                <Select value={String(ultrabeam.step_khz)} onValueChange={(v) => setUltrabeam((s) => ({ ...s, step_khz: parseInt(v, 10) || 50 }))}>
-                  <SelectTrigger className="h-8 w-32"><SelectValue /></SelectTrigger>
-                  <SelectContent>
-                    <SelectItem value="25">25 kHz</SelectItem>
-                    <SelectItem value="50">50 kHz</SelectItem>
-                    <SelectItem value="100">100 kHz</SelectItem>
-                  </SelectContent>
-                </Select>
-                <span className="text-xs text-muted-foreground">re-tune only when the frequency moves this far</span>
+              <div className="space-y-2 pl-6">
+                <div className="flex items-center gap-3">
+                  <Label className="text-sm">{t('station.trackModeTip')}</Label>
+                  <Select value={ultrabeam.track_mode || 'step'} onValueChange={(v) => setUltrabeam((s) => ({ ...s, track_mode: v }))}>
+                    <SelectTrigger className="h-8 w-52"><SelectValue /></SelectTrigger>
+                    <SelectContent>
+                      <SelectItem value="always">{t('station.trackAlways')}</SelectItem>
+                      <SelectItem value="step">{t('station.trackStep')}</SelectItem>
+                      <SelectItem value="band">{t('station.trackBand')}</SelectItem>
+                    </SelectContent>
+                  </Select>
+                </div>
+                {/* The step is only a question in step mode — the other two modes
+                    have nothing to threshold. */}
+                {(ultrabeam.track_mode || 'step') === 'step' && (
+                  <div className="flex items-center gap-3">
+                    <Label className="text-sm">{t('hw.motorStep')}</Label>
+                    <Select value={String(ultrabeam.step_khz)} onValueChange={(v) => setUltrabeam((s) => ({ ...s, step_khz: parseInt(v, 10) || 50 }))}>
+                      <SelectTrigger className="h-8 w-32"><SelectValue /></SelectTrigger>
+                      <SelectContent>
+                        <SelectItem value="25">25 kHz</SelectItem>
+                        <SelectItem value="50">50 kHz</SelectItem>
+                        <SelectItem value="100">100 kHz</SelectItem>
+                      </SelectContent>
+                    </Select>
+                  </div>
+                )}
+                <p className="text-xs text-muted-foreground">
+                  {(ultrabeam.track_mode || 'step') === 'always' ? t('station.trackAlwaysTip')
+                    : (ultrabeam.track_mode || 'step') === 'band' ? t('station.trackBandTip')
+                      : t('station.trackStepTipMode')}
+                </p>
              </div>
            )}
          </div>
          {(isSteppir || ultrabeam.type === 'ultrabeam') && (
            <div className="border-t border-border/60 pt-3 space-y-2">
              <Label className="text-sm">{t('hw.motorBands')}</Label>
-              <div className="flex items-center gap-1.5 flex-wrap">
+              {/* Band, and under it the frequency its button tunes to — the
+                  layout of the SteppIR controller's own Bands and Frequencies
+                  table, which is where operators expect to find this. The box
+                  only appears on a selected band: a tune frequency for a band the
+                  antenna is not allowed on is a setting with no effect. Left
+                  empty it shows the default as placeholder, so the field is
+                  self-documenting and clearing it is how you go back. */}
+              <div className="flex items-start gap-1.5 flex-wrap">
                {MOTOR_BANDS.map((b) => {
                  const on = ultrabeam.bands.includes(b);
                  return (
-                    <button key={b} type="button"
-                      onClick={() => setUltrabeam((s) => ({
-                        ...s,
-                        bands: on ? s.bands.filter((x) => x !== b) : [...s.bands, b],
-                      }))}
-                      className={`h-8 min-w-[3rem] rounded-md border px-2 text-sm font-medium transition-colors ${
-                        on
-                          ? 'border-primary bg-primary/15 text-primary'
-                          : 'border-input bg-background text-muted-foreground hover:bg-muted'
-                      }`}>
-                      {b}
-                    </button>
+                    <div key={b} className="flex flex-col gap-1">
+                      <button type="button"
+                        onClick={() => setUltrabeam((s) => ({
+                          ...s,
+                          bands: on ? s.bands.filter((x) => x !== b) : [...s.bands, b],
+                        }))}
+                        className={`h-8 w-[4.5rem] rounded-md border px-2 text-sm font-medium transition-colors ${
+                          on
+                            ? 'border-primary bg-primary/15 text-primary'
+                            : 'border-input bg-background text-muted-foreground hover:bg-muted'
+                        }`}>
+                        {b}
+                      </button>
+                      {on && (
+                        <input
+                          type="text" inputMode="numeric"
+                          value={ultrabeam.band_freqs?.[b] ? String(ultrabeam.band_freqs[b]) : ''}
+                          placeholder={String(MOTOR_BAND_DEFAULT_KHZ[b] ?? '')}
+                          title={t('hw.motorBandFreqHint')}
+                          onChange={(e) => {
+                            // Keep only digits, and store nothing for an empty box
+                            // so it round-trips to "use the default" rather than
+                            // to a zero the backend would have to interpret.
+                            const digits = e.target.value.replace(/[^0-9]/g, '');
+                            setUltrabeam((s) => {
+                              const next = { ...(s.band_freqs || {}) };
+                              if (digits === '') delete next[b]; else next[b] = parseInt(digits, 10);
+                              return { ...s, band_freqs: next };
+                            });
+                          }}
+                          className="h-7 w-[4.5rem] rounded-md border border-input bg-background px-1.5 text-center text-xs font-mono outline-none focus:border-primary"
+                        />
+                      )}
+                    </div>
                  );
                })}
              </div>
+              <p className="text-xs text-muted-foreground">{t('hw.motorBandFreqHint')}</p>
            </div>
          )}
          <div className="border-t border-border/60 pt-3 space-y-1">
@@ -116,7 +116,7 @@ function RotatorWidget({ hd, refetch, centerLat, centerLon, bearing, t }: Rotato
  );
 }

-type AntStatus = { enabled: boolean; type: string; connected: boolean; direction: number; frequency: number; moving: boolean; elements: number[]; follow?: boolean; step_khz?: number; bands?: string[] };
+type AntStatus = { enabled: boolean; type: string; connected: boolean; direction: number; frequency: number; moving: boolean; elements: number[]; follow?: boolean; step_khz?: number; track_mode?: string; bands?: string[]; band_freqs?: Record<string, number> };

 // Where each band button points the antenna.
 //
@@ -241,7 +241,10 @@ function MotorAntennaWidget({ ant, refetch, t }: { ant: AntStatus; refetch: () =
          <div className="text-[10px] font-semibold uppercase tracking-wider text-muted-foreground mb-1">{t('station.bands')}</div>
          <div className="grid grid-cols-5 gap-1">
            {(ant.bands ?? []).map((b: string) => {
-              const khz = ANT_BAND_KHZ[b];
+              // Where this band tunes is resolved by the backend — the operator's
+              // per-band choice from Settings, or the default. ANT_BAND_KHZ is only
+              // the floor for a status poll that hasn't landed yet.
+              const khz = ant.band_freqs?.[b] || ANT_BAND_KHZ[b];
              if (!khz) return null;
              // "On this band" from the antenna's own frequency, not the rig's:
              // the widget must show where the ANTENNA is, which is the whole
@@ -277,23 +280,38 @@ function MotorAntennaWidget({ ant, refetch, t }: { ant: AntStatus; refetch: () =

        {/* Tracking. Here rather than only in Settings because it is an operating
            decision — off to park the antenna, on to resume — not something set
-            up once. The step only shows when tracking is on: a threshold for
-            something switched off is a question the operator cannot act on. */}
-        <div className="flex items-center gap-2">
-          <button type="button"
-            onClick={() => run(SetMotorFollow(!ant.follow, 0))}
-            className={cn('flex-1 rounded-md border py-1.5 text-xs font-semibold transition-colors',
-              ant.follow ? 'bg-success-muted text-success-muted-foreground border-success-border' : 'border-border hover:bg-muted')}>
-            {ant.follow ? t('station.trackOn') : t('station.trackOff')}
-          </button>
+            up once. Mode and step only show when tracking is on: settings for
+            something switched off are questions the operator cannot act on. And
+            the step only shows in step mode, where it is the one thing it means. */}
+        <div className="space-y-1.5">
+          <div className="flex items-center gap-2">
+            <button type="button"
+              onClick={() => run(SetMotorFollow(!ant.follow, 0, ''))}
+              className={cn('flex-1 rounded-md border py-1.5 text-xs font-semibold transition-colors',
+                ant.follow ? 'bg-success-muted text-success-muted-foreground border-success-border' : 'border-border hover:bg-muted')}>
+              {ant.follow ? t('station.trackOn') : t('station.trackOff')}
+            </button>
+            {ant.follow && (ant.track_mode || 'step') === 'step' && (
+              <select
+                value={String(ant.step_khz || 50)}
+                onChange={(e) => run(SetMotorFollow(true, parseInt(e.target.value, 10), ''))}
+                className="h-[30px] rounded-md border border-border bg-background px-1 text-xs font-mono"
+                title={t('station.trackStepTip')}
+              >
+                {[25, 50, 100].map((s) => <option key={s} value={s}>{s} kHz</option>)}
+              </select>
+            )}
+          </div>
          {ant.follow && (
            <select
-              value={String(ant.step_khz || 50)}
-              onChange={(e) => run(SetMotorFollow(true, parseInt(e.target.value, 10)))}
-              className="h-[30px] rounded-md border border-border bg-background px-1 text-xs font-mono"
-              title={t('station.trackStepTip')}
+              value={ant.track_mode || 'step'}
+              onChange={(e) => run(SetMotorFollow(true, 0, e.target.value))}
+              className="w-full h-[30px] rounded-md border border-border bg-background px-1.5 text-xs"
+              title={t('station.trackModeTip')}
            >
-              {[25, 50, 100].map((s) => <option key={s} value={s}>{s} kHz</option>)}
+              <option value="always" title={t('station.trackAlwaysTip')}>{t('station.trackAlways')}</option>
+              <option value="step" title={t('station.trackStepTipMode')}>{t('station.trackStep')}</option>
+              <option value="band" title={t('station.trackBandTip')}>{t('station.trackBand')}</option>
            </select>
          )}
        </div>
@@ -13,7 +13,17 @@

 export type SpotDisplayOptions = { muteWorked: boolean; slotHighlight: boolean };

+// 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
+// switches back is this one flag and the block they came from in App.tsx.
+//
+// The saved preferences are left untouched in localStorage rather than cleared:
+// an operator who had either turned on gets them back exactly as they were the
+// day the options return, instead of silently starting from off.
+export const SPOT_DISPLAY_OPTIONS_EXPOSED = false;
+
 export function readSpotDisplayOptions(): SpotDisplayOptions {
+  if (!SPOT_DISPLAY_OPTIONS_EXPOSED) return { muteWorked: false, slotHighlight: false };
  try {
    return {
      muteWorked: localStorage.getItem('opslog.clusterMuteWorked') === '1',
@@ -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.24.6';
+export const APP_VERSION = '0.24.7';

 // Author / credits, shown in Help -> About.
 export const APP_AUTHOR = 'F4BPO';
@@ -982,7 +982,7 @@ export function SetDVKLabel(arg1:number,arg2:string):Promise<void>;

 export function SetKenwoodKeySpeed(arg1:number):Promise<void>;

-export function SetMotorFollow(arg1:boolean,arg2:number):Promise<void>;
+export function SetMotorFollow(arg1:boolean,arg2:number,arg3:string):Promise<void>;

 export function SetOpsLogQSLReceived(arg1:number,arg2:boolean):Promise<void>;

@@ -1906,8 +1906,8 @@ export function SetKenwoodKeySpeed(arg1) {
  return window['go']['main']['App']['SetKenwoodKeySpeed'](arg1);
 }

-export function SetMotorFollow(arg1, arg2) {
-  return window['go']['main']['App']['SetMotorFollow'](arg1, arg2);
+export function SetMotorFollow(arg1, arg2, arg3) {
+  return window['go']['main']['App']['SetMotorFollow'](arg1, arg2, arg3);
 }

 export function SetOpsLogQSLReceived(arg1, arg2) {
@@ -3283,8 +3283,10 @@ export namespace main {
 	    baud: number;
 	    follow: boolean;
 	    step_khz: number;
+	    track_mode: string;
 	    tx_inhibit: boolean;
 	    bands: string[];
+	    band_freqs: Record<string, number>;
 	    freq_min_mhz: number;
 	    freq_max_mhz: number;
 	
@@ -3303,8 +3305,10 @@ export namespace main {
 	        this.baud = source["baud"];
 	        this.follow = source["follow"];
 	        this.step_khz = source["step_khz"];
+	        this.track_mode = source["track_mode"];
 	        this.tx_inhibit = source["tx_inhibit"];
 	        this.bands = source["bands"];
+	        this.band_freqs = source["band_freqs"];
 	        this.freq_min_mhz = source["freq_min_mhz"];
 	        this.freq_max_mhz = source["freq_max_mhz"];
 	    }
@@ -3320,7 +3324,9 @@ export namespace main {
 	    elements: number[];
 	    follow: boolean;
 	    step_khz: number;
+	    track_mode: string;
 	    bands: string[];
+	    band_freqs: Record<string, number>;
 	
 	    static createFrom(source: any = {}) {
 	        return new UltrabeamStatusInfo(source);
@@ -3338,7 +3344,9 @@ export namespace main {
 	        this.elements = source["elements"];
 	        this.follow = source["follow"];
 	        this.step_khz = source["step_khz"];
+	        this.track_mode = source["track_mode"];
 	        this.bands = source["bands"];
+	        this.band_freqs = source["band_freqs"];
 	    }
 	}
 	export class UpdateInfo {
@@ -449,6 +449,34 @@ type RefMeta struct {
 	Pattern  string
 	re       *regexp.Regexp
 	Valid    bool
+	// Per-reference validity window, ISO "2006-01-02". A reference is not
+	// forever: a park is delisted, a county is merged, a castle loses its
+	// reference number. A QSO made while it existed still counts — it was a valid
+	// contact on the day — and one made after it stopped existing does not.
+	//
+	// Empty means "no window of its own", and the award's own ValidFrom/ValidTo
+	// then govern, as they already do for every QSO in the award (see inScope).
+	// That fallback is deliberately NOT duplicated here: two places enforcing the
+	// same dates is two places for them to disagree.
+	ValidFrom string
+	ValidTo   string
+}
+
+// activeOn reports whether the reference existed on the day of the QSO.
+//
+// Compared as ISO date strings rather than parsed times on purpose: the stored
+// values are "2025-08-01"-shaped and lexical order on that shape IS
+// chronological order, so this cannot fail on a malformed date the way a parse
+// can — a reference with a typo in its window keeps counting instead of silently
+// vanishing from an operator's totals.
+func (m RefMeta) activeOn(day string) bool {
+	if m.ValidFrom != "" && day < m.ValidFrom {
+		return false
+	}
+	if m.ValidTo != "" && day > m.ValidTo {
+		return false
+	}
+	return true
 }

 // NewRefList builds the engine's reference view from (code, meta) pairs.
@@ -956,11 +984,13 @@ func candidates(d *Def, re *regexp.Regexp, q *qso.QSO, rl refList, hasList bool)
 // describes is worse than no trace, because it is believed.
 func candidatesTrace(d *Def, re *regexp.Regexp, q *qso.QSO, rl refList, hasList bool, ex *Explanation) []string {
 	predefined := hasList && !d.Dynamic
+	// The day of the contact, for per-reference validity windows.
+	day := q.QSODate.Format("2006-01-02")

 	// run executes one rule and, when tracing, records it.
 	run := func(label, field, matchBy, pattern string, rex *regexp.Regexp, exact bool, leading, trailing, prefix string) []string {
 		raw := searchOne(field, matchBy, rex, exact, leading, trailing, prefix, q, rl, predefined)
-		kept := keepRefs(predefined, rl, raw)
+		kept := keepRefs(predefined, rl, raw, day)
 		if ex != nil {
 			s := Step{Rule: label, Field: field, MatchBy: matchBy, Exact: exact, Pattern: pattern,
 				FieldValue: strings.TrimSpace(stripAffix(fieldRaw(field, q), leading, trailing)),
@@ -974,7 +1004,7 @@ func candidatesTrace(d *Def, re *regexp.Regexp, q *qso.QSO, rl refList, hasList
 				if _, ok := keptSet[n]; ok {
 					continue
 				}
-				s.Rejected = append(s.Rejected, rejection(predefined, rl, n))
+				s.Rejected = append(s.Rejected, rejection(predefined, rl, n, day))
 			}
 			ex.Steps = append(ex.Steps, s)
 		}
@@ -1026,7 +1056,7 @@ func candidatesTrace(d *Def, re *regexp.Regexp, q *qso.QSO, rl refList, hasList
 	// hand. Applied HERE (not just in MatchQSO) so Compute — which powers the
 	// awards panel and the per-QSO refs editor — honours overrides too. For a
 	// predefined award the ref is still validated against the list below.
-	manual := keepRefs(predefined, rl, manualRefs(q, d.Code))
+	manual := keepRefs(predefined, rl, manualRefs(q, d.Code), day)
 	if ex != nil {
 		ex.Manual = manual
 	}
@@ -1065,7 +1095,7 @@ func candidatesTrace(d *Def, re *regexp.Regexp, q *qso.QSO, rl refList, hasList
 // become a reference. "Nothing matched" is the least useful thing a matcher can
 // say; every one of this week's award bugs was a rejection with a plain reason
 // that nothing was printing.
-func rejection(predefined bool, rl refList, code string) Rejected {
+func rejection(predefined bool, rl refList, code, day string) Rejected {
 	switch {
 	case code == "":
 		return Rejected{Candidate: code, Reason: "empty"}
@@ -1076,6 +1106,17 @@ func rejection(predefined bool, rl refList, code string) Rejected {
 	if !ok {
 		return Rejected{Candidate: code, Reason: "not in the award's reference list"}
 	}
+	// Spell the dates out. "Did not count" on a contact the operator remembers
+	// making is exactly the moment they need to be told it is the REFERENCE that
+	// has a window, not their log that is wrong.
+	if !m.activeOn(day) {
+		switch {
+		case m.ValidTo != "" && day > m.ValidTo:
+			return Rejected{Candidate: code, Reason: fmt.Sprintf("the reference ceased to exist on %s, after this QSO of %s", m.ValidTo, day)}
+		default:
+			return Rejected{Candidate: code, Reason: fmt.Sprintf("the reference did not exist until %s, after this QSO of %s", m.ValidFrom, day)}
+		}
+	}
 	if !m.Valid {
 		return Rejected{Candidate: code, Reason: "listed but disabled"}
 	}
@@ -1088,7 +1129,7 @@ func rejection(predefined bool, rl refList, code string) Rejected {
 // so we do NOT additionally require the QSO's entity to match the reference's own
 // DXCC — that wrongly excluded e.g. WAS Alaska (state AK is DXCC entity 6, not
 // 291). Per-reference DXCC stays metadata for the picker.
-func keepRefs(predefined bool, rl refList, found []string) []string {
+func keepRefs(predefined bool, rl refList, found []string, day string) []string {
 	if !predefined {
 		out := make([]string, 0, len(found))
 		for _, c := range found {
@@ -1106,6 +1147,10 @@ func keepRefs(predefined bool, rl refList, found []string) []string {
 		if !ok || !m.Valid {
 			continue
 		}
+		// The reference has to have existed on the day of the contact.
+		if !m.activeOn(day) {
+			continue
+		}
 		if _, dup := seen[c]; dup {
 			continue
 		}
@@ -0,0 +1,109 @@
+package award
+
+import (
+	"testing"
+	"time"
+
+	"hamlog/internal/qso"
+)
+
+func day(s string) time.Time {
+	t, err := time.Parse("2006-01-02", s)
+	if err != nil {
+		panic(err)
+	}
+	return t
+}
+
+// A reference is not forever. A park is delisted, a district is merged, a castle
+// loses its number. A contact made while it existed still counts — it was a
+// valid contact on the day — and one made after it stopped existing does not.
+func TestRefValidityWindow(t *testing.T) {
+	m := RefMeta{Code: "KL-01", Valid: true, ValidTo: "2025-08-31"}
+	for _, tc := range []struct {
+		day  string
+		want bool
+	}{
+		{"2019-01-01", true},
+		{"2025-08-31", true}, // the last day it existed still counts
+		{"2025-09-01", false},
+		{"2026-08-12", false},
+	} {
+		if got := m.activeOn(tc.day); got != tc.want {
+			t.Errorf("KL-01 on %s: active=%v, want %v", tc.day, got, tc.want)
+		}
+	}
+
+	// A reference that only came into being partway through.
+	n := RefMeta{Code: "KL-99", Valid: true, ValidFrom: "2025-01-15"}
+	if n.activeOn("2025-01-14") {
+		t.Error("counted a QSO from before the reference existed")
+	}
+	if !n.activeOn("2025-01-15") {
+		t.Error("the first day it existed must count")
+	}
+
+	// No window of its own: the award's own dates govern, as they already do for
+	// every QSO in the award. Nothing here may narrow that.
+	if !(RefMeta{Code: "X", Valid: true}).activeOn("1970-01-01") {
+		t.Error("a reference with no window must count on any date")
+	}
+}
+
+// The whole point: the same QSO counts before the cutoff and does not after.
+func TestExpiredRefStopsCountingForLaterQSOs(t *testing.T) {
+	d := &Def{
+		Code: "RDA", Name: "Russian District Award", Valid: true,
+		Type: TypeQSOFields, Field: "note", MatchBy: "code",
+		Confirm: []string{"lotw"},
+	}
+	metas := []RefMeta{
+		{Code: "KL-01", Name: "Petrozavodsk", Valid: true, ValidTo: "2025-08-31"},
+		{Code: "KL-04", Name: "Kostomuksha", Valid: true},
+	}
+
+	q := func(ref, on string) *qso.QSO {
+		return &qso.QSO{Callsign: "RA1ABC", Band: "20m", Notes: ref, QSODate: day(on)}
+	}
+
+	if got := MatchQSO(*d, metas, q("KL-01", "2025-06-01")); len(got) != 1 || got[0] != "KL-01" {
+		t.Errorf("a QSO made while KL-01 existed must count: got %v", got)
+	}
+	if got := MatchQSO(*d, metas, q("KL-01", "2025-09-15")); len(got) != 0 {
+		t.Errorf("a QSO made after KL-01 ceased to exist must not count: got %v", got)
+	}
+	if got := MatchQSO(*d, metas, q("KL-04", "2025-09-15")); len(got) != 1 || got[0] != "KL-04" {
+		t.Errorf("a reference with no window is unaffected: got %v", got)
+	}
+}
+
+// The claim that an empty per-reference window "inherits the award's" has to be
+// a fact about the code, not a comment. Compute and MatchQSO both gate on
+// inScope, which enforces the award's own dates — so a reference with no window
+// of its own is already bounded by them, and duplicating the check per reference
+// would only create a second place for the same dates to disagree.
+func TestEmptyRefWindowInheritsTheAward(t *testing.T) {
+	d := Def{
+		Code: "RDA", Name: "Russian District Award", Valid: true,
+		Type: TypeQSOFields, Field: "note", MatchBy: "code",
+		Confirm:   []string{"lotw"},
+		ValidFrom: "1991-06-12", // the award itself starts here
+	}
+	metas := []RefMeta{{Code: "KL-04", Name: "Kostomuksha", Valid: true}} // no window of its own
+
+	q := func(on string) *qso.QSO {
+		return &qso.QSO{Callsign: "RA1ABC", Band: "20m", Notes: "KL-04", QSODate: day(on)}
+	}
+	if got := MatchQSO(d, metas, q("1991-06-11")); len(got) != 0 {
+		t.Errorf("a QSO before the AWARD's start counted for a reference with no window of its own: %v", got)
+	}
+	if got := MatchQSO(d, metas, q("1991-06-12")); len(got) != 1 {
+		t.Errorf("a QSO on the award's first day must count: %v", got)
+	}
+
+	// And a reference window NARROWER than the award's still applies on top.
+	metas[0].ValidTo = "2025-08-31"
+	if got := MatchQSO(d, metas, q("2025-09-01")); len(got) != 0 {
+		t.Errorf("the reference's own end date was ignored: %v", got)
+	}
+}
@@ -81,6 +81,28 @@ var watched = map[string]bool{"10m": true, "6m": true, "4m": true, "2m": true}
 // Watched reports whether a band is one the detector looks at.
 func Watched(band string) bool { return watched[strings.ToLower(strings.TrimSpace(band))] }

+// maxTerrestrialKm is the longest path a band can carry through the atmosphere.
+// Zero means no limit.
+//
+// The flat 2400 km ceiling was removed because it threw away real multi-hop Es
+// on 6 m, and that was right — but "no limit anywhere" then let something else
+// through. A 2 m opening was announced at 9650 km towards Japan, on stations
+// that were unmistakably working EME: the moon is not an opening, and pointing
+// an antenna at that bearing would find nothing.
+//
+// So the limit is per band, and it is physics rather than a threshold. Two
+// metres reaches a few thousand kilometres by tropospheric duct or a chain of Es
+// clouds and no further; beyond that the path went via the moon or a satellite,
+// neither of which says anything about the band. Six and ten metres have no
+// ceiling at all — multi-hop Es and F2 genuinely go round the world.
+var maxTerrestrialKm = map[string]int{
+	"2m": 3500,
+	"4m": 4000,
+}
+
+// MaxKmFor returns the plausibility ceiling for a band, 0 for none.
+func MaxKmFor(band string) int { return maxTerrestrialKm[strings.ToLower(strings.TrimSpace(band))] }
+
 // Opening is a detected opening, ready to be announced.
 type Opening struct {
 	Band       string `json:"band"`
@@ -130,6 +152,12 @@ func (d *Detector) Add(s Spot, lat float64) *Opening {
 	if s.DistKm < d.cfg.MinKm || (d.cfg.MaxKm > 0 && s.DistKm > d.cfg.MaxKm) {
 		return nil
 	}
+	// Past what the atmosphere can carry on this band, the path went via the moon
+	// or a satellite. Those are real contacts and real reports; they are simply
+	// not evidence about the band.
+	if m := MaxKmFor(band); m > 0 && s.DistKm > m {
+		return nil
+	}
 	d.recent = append(d.recent, s)
 	d.prune(s.At)

@@ -0,0 +1,51 @@
+package bandopen
+
+import (
+	"testing"
+	"time"
+)
+
+// A 2 m "opening" was announced at 9650 km towards Japan on stations that were
+// plainly working EME. The moon is not an opening: an operator pointing an
+// antenna at that bearing finds nothing.
+func TestEMEIsNotAnOpeningOnTwoMetres(t *testing.T) {
+	d := New(DefaultConfig())
+	base := time.Date(2026, 8, 12, 6, 0, 0, 0, time.UTC)
+	for i, call := range []string{"7M4RRM", "JA7RPC", "JF1AWC", "JK1TPA", "JH1JCQ"} {
+		if op := d.Add(Spot{
+			Call: call, Band: "2m", DistKm: 9650, Bearing: 40 + i*3,
+			At: base.Add(time.Duration(i) * time.Minute),
+		}, 47.0); op != nil {
+			t.Fatalf("a 9650 km 2 m path was announced as an opening: %+v", op)
+		}
+	}
+}
+
+// But a real 2 m opening — an Es chain at a plausible distance — must survive.
+func TestLongButPlausibleTwoMetresStillCounts(t *testing.T) {
+	d := New(DefaultConfig())
+	base := time.Date(2026, 6, 20, 18, 0, 0, 0, time.UTC)
+	var got *Opening
+	for i, call := range []string{"EA1AA", "CT1BB", "EA7CC", "CT7DD"} {
+		if op := d.Add(Spot{
+			Call: call, Band: "2m", DistKm: 2000 + i*30, Bearing: 200 + i*4,
+			At: base.Add(time.Duration(i) * time.Minute),
+		}, 47.0); op != nil {
+			got = op
+		}
+	}
+	if got == nil {
+		t.Fatal("a 2000 km 2 m burst in one sector was not reported")
+	}
+}
+
+// Six metres keeps no ceiling: multi-hop Es genuinely goes that far, which is
+// why the flat limit was removed in the first place.
+func TestSixMetresHasNoCeiling(t *testing.T) {
+	if MaxKmFor("6m") != 0 || MaxKmFor("10m") != 0 {
+		t.Error("6 m and 10 m must have no distance ceiling")
+	}
+	if MaxKmFor("2m") == 0 {
+		t.Error("2 m must have one")
+	}
+}
@@ -440,7 +440,31 @@ func (k *Kenwood) SetFrequency(hz int64) error {
 	if k.curVFO == "B" {
 		cmd = "FB"
 	}
-	return k.write(fmt.Sprintf("%s%011d;", cmd, hz))
+	if err := k.write(fmt.Sprintf("%s%011d;", cmd, hz)); err != nil {
+		return err
+	}
+	// Remember what we just commanded.
+	//
+	// While PTT is held the poll is skipped and State() hands back lastState — the
+	// rig answers "?;" to IF; mid-transmission, and reading that as a fault used
+	// to drop the whole link. But a frequency SET during that window then went
+	// unrecorded, so the cache kept describing the dial as it was before.
+	//
+	// WSJT-X's "Fake It" is exactly that sequence: move the dial, key, transmit,
+	// and afterwards put it back. Polling during the over, it was told the rig was
+	// still on the receive frequency — so there was nothing to put back, and the
+	// dial stayed on the transmit frequency for good. Every following over
+	// started from there, which is the drift that was reported.
+	//
+	// Only simplex is updated here. Under split, FreqHz means the transmit
+	// frequency while this write lands on whichever VFO the operator is on, and
+	// guessing which side moved would be worse than a stale value the next poll
+	// corrects on its own.
+	if !k.lastState.Split {
+		k.curFreq = hz
+		k.lastState.FreqHz = hz
+	}
+	return nil
 }

 func (k *Kenwood) SetMode(mode string) error {
@@ -0,0 +1,100 @@
+package cat
+
+import "testing"
+
+// WSJT-X "Fake It" against the transmit-window cache.
+//
+// Fake It keeps the radio on one dial frequency and shifts it only for the
+// duration of each over: set the transmit frequency, key, transmit, unkey, set
+// it back. The restore is not unconditional — WSJT-X reads the frequency back
+// and puts the dial where it believes it should be.
+//
+// That read lands inside the window where this backend deliberately stops
+// polling, because a Kenwood answers "?;" to IF; while it is transmitting and
+// treating that as a fault used to drop the whole shared link. The cache
+// answers instead. So the cache has to account for frequency SETS made during
+// the window, or it describes the dial as it was before the over — and WSJT-X,
+// told the radio is already on the receive frequency, has nothing to restore.
+//
+// This reproduces the sequence from a reported session: the dial stayed on the
+// transmit frequency after the first over and every later one started there.
+func TestKenwoodFakeItRestoresAfterTransmit(t *testing.T) {
+	const (
+		rxHz = 7074000 // where the operator is listening
+		txHz = 7075500 // where Fake It moves the dial to transmit
+	)
+
+	rig := &ts2000{vfoA: rxHz, mode: '2'}
+	k := NewKenwood("COM-TEST", 9600, "FT8")
+	k.dialPort = dialTo(rig)
+	if err := k.Connect(); err != nil {
+		t.Fatalf("connect: %v", err)
+	}
+	defer k.Disconnect()
+
+	if s, err := k.ReadState(); err != nil || s.FreqHz != rxHz {
+		t.Fatalf("before the over: %d (err %v) — want %d", s.FreqHz, err, rxHz)
+	}
+
+	// The over: shift the dial, then key.
+	if err := k.SetFrequency(txHz); err != nil {
+		t.Fatalf("set transmit frequency: %v", err)
+	}
+	if err := k.SetPTT(true); err != nil {
+		t.Fatalf("ptt on: %v", err)
+	}
+
+	// WSJT-X reads back mid-over. The wire is not polled here — this is the
+	// cache talking, and it must not still be saying rxHz.
+	s, err := k.ReadState()
+	if err != nil {
+		t.Fatalf("read during the over: %v", err)
+	}
+	if s.FreqHz != txHz {
+		t.Errorf("during the over the backend reported %d, want %d — "+
+			"reporting the pre-over frequency is what stops Fake It restoring the dial", s.FreqHz, txHz)
+	}
+
+	if err := k.SetPTT(false); err != nil {
+		t.Fatalf("ptt off: %v", err)
+	}
+
+	// The restore, once the over is done.
+	if err := k.SetFrequency(rxHz); err != nil {
+		t.Fatalf("restore: %v", err)
+	}
+	if rig.vfoA != rxHz {
+		t.Errorf("dial left on %d after the over, want %d", rig.vfoA, rxHz)
+	}
+	if s, err := k.ReadState(); err != nil || s.FreqHz != rxHz {
+		t.Errorf("after the over: %d (err %v) — want %d", s.FreqHz, err, rxHz)
+	}
+}
+
+// Under split the same write must NOT touch the cache: FreqHz means the
+// transmit frequency while the write lands on whichever VFO the operator is on,
+// so guessing which side moved would put a wrong number in front of the
+// operator. A stale one survives only until the next poll.
+func TestKenwoodSplitCacheLeftToThePoll(t *testing.T) {
+	rig := &ts2000{vfoA: 14025000, vfoB: 14030000, mode: '3', split: true}
+	k := NewKenwood("COM-TEST", 9600, "CW")
+	k.dialPort = dialTo(rig)
+	if err := k.Connect(); err != nil {
+		t.Fatalf("connect: %v", err)
+	}
+	defer k.Disconnect()
+
+	s, err := k.ReadState()
+	if err != nil || !s.Split {
+		t.Fatalf("split not seen: %+v (err %v)", s, err)
+	}
+	before := s.FreqHz
+
+	if err := k.SetFrequency(14026000); err != nil {
+		t.Fatalf("set: %v", err)
+	}
+	if k.lastState.FreqHz != before {
+		t.Errorf("split cache moved to %d on a VFO write, want it left at %d for the poll",
+			k.lastState.FreqHz, before)
+	}
+}
@@ -0,0 +1,78 @@
+package main
+
+import "testing"
+
+// A per-band tune frequency goes straight to the antenna as a command, so a
+// value that is not actually in that band has to be refused rather than obeyed.
+// One wrong digit sends the elements travelling to a length that is wrong for
+// the band the operator is on — and on a SteppIR that journey inhibits transmit
+// the whole way.
+func TestNormMotorBandFreqsRefusesOutOfBand(t *testing.T) {
+	in := map[string]int{
+		"20m":   14050,    // fine, CW end
+		"40m":   7005,     // fine
+		"6m":    50313,    // fine, FT8
+		"15m":   1450,     // a digit lost — lands in the broadcast band
+		"10m":   28400000, // Hz typed where kHz was asked
+		"17m":   14100,    // right number, wrong band
+		"30m":   0,        // not set
+		"80m":   3750,     // not a band this antenna covers at all
+		"bogus": 14100,    // not a band
+	}
+	got := normMotorBandFreqs(in)
+	want := map[string]int{"40m": 7005, "20m": 14050, "6m": 50313}
+	if len(got) != len(want) {
+		t.Fatalf("kept %v, want %v", got, want)
+	}
+	for k, v := range want {
+		if got[k] != v {
+			t.Errorf("%s = %d, want %d", k, got[k], v)
+		}
+	}
+}
+
+// The stored form round-trips, in canonical band order rather than map order so
+// the settings row does not churn between saves.
+func TestMotorBandFreqsRoundTrip(t *testing.T) {
+	m := map[string]int{"20m": 14050, "40m": 7005, "6m": 50313}
+	enc := encodeMotorBandFreqs(m)
+	if enc != "40m=7005,20m=14050,6m=50313" {
+		t.Errorf("encoded %q — want canonical low→high order", enc)
+	}
+	back := decodeMotorBandFreqs(enc)
+	for k, v := range m {
+		if back[k] != v {
+			t.Errorf("round trip lost %s: %d → %d", k, v, back[k])
+		}
+	}
+	// Garbage in one entry must cost only that entry.
+	part := decodeMotorBandFreqs("40m=7005,20m=oops,6m=50313")
+	if part["40m"] != 7005 || part["6m"] != 50313 {
+		t.Errorf("one bad entry took the others down: %v", part)
+	}
+	if _, ok := part["20m"]; ok {
+		t.Errorf("kept an unparseable entry: %v", part)
+	}
+}
+
+// An unset band falls back to its default, which is what makes the Settings box
+// safe to leave empty.
+func TestMotorTuneKHzForBandFallsBack(t *testing.T) {
+	m := map[string]int{"20m": 14050}
+	if got := motorTuneKHzForBand(m, "20m"); got != 14050 {
+		t.Errorf("chosen frequency ignored: %d", got)
+	}
+	if got := motorTuneKHzForBand(m, "15m"); got != 21150 {
+		t.Errorf("15m = %d, want the 21150 default", got)
+	}
+	if got := motorTuneKHzForBand(m, "80m"); got != 0 {
+		t.Errorf("80m = %d, want 0 — not a motor band", got)
+	}
+	// Every default must itself be in its band, or the fallback ships the very
+	// fault normMotorBandFreqs exists to catch.
+	for _, b := range motorBands {
+		if got := bandForHz(int64(b.defKHz) * 1000); got != b.name {
+			t.Errorf("default %d kHz for %s reads as %q", b.defKHz, b.name, got)
+		}
+	}
+}
@@ -0,0 +1,48 @@
+package main
+
+import "testing"
+
+// The tracking mode decides how often a motorized antenna's elements run, so a
+// value that fails to parse must not silently become the most aggressive
+// setting. Anything unrecognised — including the empty string every config
+// written before this option existed contains — has to land on the threshold
+// mode, which is exactly what those configs already did.
+func TestNormMotorTrackMode(t *testing.T) {
+	for _, tc := range []struct{ in, want string }{
+		{"always", motorTrackAlways},
+		{"ALWAYS", motorTrackAlways},
+		{"  band  ", motorTrackBand},
+		{"step", motorTrackStep},
+		{"", motorTrackStep},          // never configured — behaves as before
+		{"everytime", motorTrackStep}, // near-miss, not "always"
+		{"per-band", motorTrackStep},  // near-miss, not "band"
+		{"25", motorTrackStep},        // a step value fed in by mistake
+	} {
+		if got := normMotorTrackMode(tc.in); got != tc.want {
+			t.Errorf("normMotorTrackMode(%q) = %q, want %q", tc.in, got, tc.want)
+		}
+	}
+}
+
+// Band mode compares the band the rig is on against the band the antenna was
+// last commanded for. That comparison is bandForHz, and the property it has to
+// have is that two frequencies far apart within one band agree while two
+// frequencies close together across a band edge do not — otherwise the antenna
+// either never moves or moves on every QSY.
+func TestBandForHzDrivesBandTracking(t *testing.T) {
+	same := [][2]int64{
+		{14000000, 14350000}, // both ends of 20 m — one band, no move
+		{7000000, 7200000},   // 40 m
+		{50000000, 52000000}, // 6 m, a wide one
+	}
+	for _, p := range same {
+		if a, b := bandForHz(p[0]), bandForHz(p[1]); a != b || a == "" {
+			t.Errorf("%.3f MHz is %q but %.3f MHz is %q — band mode would re-tune inside one band",
+				float64(p[0])/1e6, a, float64(p[1])/1e6, b)
+		}
+	}
+	// A small QSY that crosses from 30 m into 20 m has to read as a band change.
+	if a, b := bandForHz(10150000), bandForHz(14000000); a == b {
+		t.Errorf("30 m and 20 m both read %q — band mode would never re-tune between them", a)
+	}
+}
@@ -21,7 +21,7 @@ import (

 const (
 	// appVersion is stamped on every heartbeat (and could feed the About box).
-	appVersion = "0.24.6"
+	appVersion = "0.24.7"

 	// posthogHost is the PostHog ingestion endpoint. EU cloud by default; change
 	// to https://us.i.posthog.com for a US project.
Author	SHA1	Message	Date
rouggy	bbddba6e74	chore: release v0.24.7	2026-08-12 14:45:19 +02:00
rouggy	b659f6f16d	docs(changelog): cut the 0.24.7 entries to one line each Entries had grown to 250-450 characters, carrying the symptom, the mechanism and the reassurance about existing setups. The panel is read top to bottom; that belongs in the commit message, which has no length limit and is not competing for the reader's attention.	2026-08-12 11:10:48 +02:00
rouggy	b4ad12bdc6	fix(bandopen): the watch switch now gates the detector "Watch for band openings" only ever governed the extra DATA SOURCES — the RBN nodes and the PSK Reporter feed. The detector itself ran on every ordinary cluster spot regardless, so an operator who had never enabled the watch still got 10 m and 6 m opening banners from a feature he had deliberately left off. The flag is cached on bandOpenState rather than read per spot: this is the cluster hot path, where a settings query per spot is exactly what the rest of this file avoids. startBandOpenFeed owns it, and it already runs at startup and on every save, so the switch takes effect without a restart. Switching it off also clears the live badges and the accumulated spot window. The badges only fade on a timer fed by spots the detector no longer looks at, so they would otherwise hang there until the next restart; and dropping the window means switching back on starts from what is on the air rather than from an hour-old burst. The remembered openings are kept — those really happened.	2026-08-12 11:08:45 +02:00
rouggy	5dd3532074	feat(cluster): withdraw the two spot display options Hidden from the filter panel and forced off, without touching the machinery behind them — it is correct and took several rounds to get right, so it stays whole. One flag in lib/spotDisplay does both jobs: readSpotDisplayOptions answers false while it is down, which covers the band map, and App.tsx seeds its two states from that same call instead of reading localStorage directly. Without that second half an operator who already had "No colour on worked" saved would have kept it applied with no switch left to turn it off. The saved preferences are deliberately left in localStorage rather than cleared, so whoever had either option on gets their choice back the day the switches return instead of silently starting from off.	2026-08-12 10:57:04 +02:00
rouggy	dd7b63c059	fix(awards): stack the reference validity dates, and prove the award fallback Two dates side by side put each one in a half-width Field2, which spends 120px on its label column — the second label overlapped the first input and the row ran off the panel. The comment ten lines above says exactly this about the group/subgroup fields; one per row, as everything else in this editor. Also shows a far-future end date as open-ended. RDA carries 9999-12-31 as "no end" and printing it back reads like a real deadline. The claim that an empty per-reference window inherits the award's is now a test rather than a comment: a QSO before the award's own ValidFrom does not count for a reference that has no window of its own, and a narrower reference window still applies on top.	2026-08-12 10:51:12 +02:00
rouggy	8fc6673611	fix(awards): apply the per-reference validity window References are not forever: a park is delisted, a district merged, a castle loses its number. A QSO made while the reference existed is a valid contact and must keep counting; one made afterwards must not. The JSON format did not need to change — ValidFrom/ValidTo were already on awardref.Ref, already columns in award_references, already round-tripping through export and import. They were simply never read: awardRefMetas dropped them on the way into the engine, so nothing downstream could enforce them. This carries them through and checks them in keepRefs. Empty means the award's own window governs, which inScope already enforces for every QSO in the award. That fallback is deliberately NOT duplicated per reference — two places enforcing the same dates is two places for them to disagree. The editor shows the award's dates as the hint under the boxes so the operator can see what empty inherits. Dates are compared as ISO strings rather than parsed times: the stored shape is "2006-01-02", lexical order on it IS chronological, and this cannot fail on a malformed value the way a parse can — a reference with a typo in its window keeps counting instead of silently vanishing from an operator's totals. The Explain trace names the date and the cutoff, because "did not count" on a contact the operator remembers making is exactly when they need to be told it is the reference that has a window, not their log that is wrong.	2026-08-12 10:43:23 +02:00
rouggy	d33291b521	feat(awards): wire up the single-award export Only the whole-catalogue bundle was reachable from the UI, so sharing one award meant handing over every award you have — including the ones you edited for yourself. Nothing new was needed underneath: ExportAward(code) already existed and already reads the definition AND its references from the database rather than from the embedded catalog, which is the point (a WAPC is only worth sharing because of the province list and city regexes the operator added). The English and French strings existed too. Only the button was missing. Kept distinct from the catalog publish next to it: that one stamps a version and clears user_edited to seed a release, this one is a plain share and leaves both alone, so the recipient's copy is correctly marked as someone else's work instead of a pristine built-in that future catalog updates would overwrite.	2026-08-12 10:23:55 +02:00
rouggy	1b32b1ddec	feat(antenna): per-band tune frequency for Ultrabeam and SteppIR The band buttons in Station Control tuned to a fixed mid-band frequency baked into the frontend. An operator who lives in the CW segment, or in the FT8 window, got the antenna resonant somewhere he never operates and had to nudge it every time. The SteppIR's own controller has a Frequency (KHz) column per band for exactly this; this is that column. Stored sparsely: a band with no entry uses its default, so nothing migrates and an operator sets only the bands he cares about. Left empty the Settings box shows the default as its placeholder, which makes clearing it the obvious way back. The value is checked against the band plan before it is kept, because it goes to the antenna as a tune command — a lost digit (1450 for 20 m) or kHz typed as MHz would send the elements travelling to a length wrong for the band the operator is on, and on a SteppIR that journey inhibits transmit the whole way. A rejected entry is logged and the band falls back to its default. Resolution happens in the backend and rides on the existing status poll, so the widget no longer decides where a band button goes and cannot drift from what Settings shows. Its own table stays only as a floor for the first poll.	2026-08-12 08:58:01 +02:00
rouggy	65bbaa85f3	feat(antenna): three tracking modes for Ultrabeam and SteppIR The follow loop only ever had one behaviour — re-tune once the rig moved further than a fixed step. The SteppIR's own controller software offers three, and operators arrive with that mental model: every frequency change, past a threshold, or only on a band change. They are real operating trade-offs, not preferences: "always" keeps resonance perfect at the cost of motors running constantly (and on a SteppIR every move inhibits transmit while the elements travel), "band" moves them a handful of times a day. "Always" is implemented as the threshold mode with a 1 kHz threshold rather than as a separate branch, so all modes keep the one deadband reference that matters: the rig frequency last commanded for, NOT the antenna's own reported frequency — a SteppIR flips its reported frequency between the commanded value and its home value, which would re-issue a SET on nearly every poll and leave the operator permanently unable to transmit. Band mode compares against the band last COMMANDED for, not the rig's previous band, so the first move after startup and any move made by hand still get reconciled. It applies to the immediate spot-click path too: a click inside the band the antenna is already resonant in moves nothing. An unset or unrecognised mode resolves to the step mode, so every config written before this option behaves exactly as it did. Also routes the antenna settings block through t() — it was hardcoded English.	2026-08-12 08:31:44 +02:00
rouggy	99d903eb44	fix(pgxl): stack the amplifier meters two by two The card is two grid columns wide and sits beside a tall neighbour in Station Control, so a single row of four bars left the height unused and squeezed each bar into a quarter of the width. Two rows of two fill the room already there and double the resolution of every bar.	2026-08-12 07:50:11 +02:00
rouggy	13515c58c0	fix(pgxl): draw the amplifier card's meters from the amp when there is no Flex The PowerGenius XL card gated its whole meter row on flex.amp_available, so on any station without a FlexRadio it rendered OPERATE and the fan selector over an otherwise empty two-column card — reported from a TS-590 station. Nothing was missing from the backend. internal/powergenius already parses forward power, drain current, VSWR and temperature out of the GSCP status frame, and the docked AmpWidget already prefers the radio's meter stream and falls back to those. Only the full card never learnt the fallback. Same source preference as the widget, and the same two exclusions: peakfwd and peakid are latched maxima that are never reset and survive in the last-known status after the amp disconnects, so the plain readings are used and gated on the transmit state instead of freezing on the last over.	2026-08-12 07:40:45 +02:00
rouggy	e4014e11d2	fix(kenwood): record a frequency set made while transmitting WSJT-X "Fake It" shifts the dial for the duration of each over and puts it back afterwards, but the restore is conditional: it reads the frequency back and only moves the dial if it disagrees with where it believes the radio should be. That read lands inside the window where this backend stops polling on purpose. A Kenwood answers "?;" to IF; while it is transmitting, and treating that as a fault used to drop the shared CAT link entirely, so the cached state answers instead. SetFrequency wrote the command to the rig without touching that cache — so mid-over the cache still described the pre-over dial, WSJT-X read its own receive frequency back, concluded there was nothing to restore, and the radio stayed on the transmit frequency. Every later over started from there. Reported from a session where the dial stuck at 7075500 after a full FT8 over while a bare TUNE, which never sets a frequency, worked fine. Only simplex updates the cache. Under split, FreqHz is the transmit frequency while the write lands on whichever VFO the operator is on, and guessing which side moved would put a wrong number in front of the operator — a stale one survives until the next poll. The test reproduces the reported sequence and fails without the fix with the same frequency the log shows.	2026-08-12 07:34:21 +02:00
rouggy	025472820b	fix(bandopen): the moon is not a band opening A 2 m opening was announced at 9650 km towards Japan. The callsigns gave it away — 7M4RRM, JA7RPC, JF1AWC — all working EME, which is routine on 2 m and reported to PSK Reporter like anything else. Real contacts, real grids, and no evidence whatsoever about the band: an operator turning a beam on that bearing would hear nothing. Removing the flat 2400 km ceiling was right; it threw away genuine multi-hop Es on 6 m. "No limit anywhere" was the overcorrection. The limit is per band now, and it is physics rather than a threshold: 2 m reaches a few thousand kilometres by tropospheric duct or a chain of Es clouds and no further, so 3500 km, and 4 m 4000. Six and ten metres keep no ceiling — multi-hop Es and F2 genuinely do go round the world, which is the case that started all this. Pinned from both sides: the 9650 km Japanese burst produces nothing, and a 2000 km 2 m burst in one sector still counts.	2026-08-12 07:00:59 +02:00
rouggy	8b66030c89	fix(udp): WSJT-X QSOs were missing the solar data and the distance The UDP path applies the station profile, the DXCC number, the Club Log exceptions, the zone refinement and the QSL defaults — and its comment says "same as the manual AddQSO path", which it was not. applySolar and fillDistance were never called there. For an operator running digital, and that is most of the traffic on most stations, it meant SFI, A, K and distance were empty across the whole log while a hand-logged contact carried all four. It also quietly undermines the history-based propagation work, which needs those numbers to be there. applySolar now refuses a QSO more than a day old, whichever path it arrives by. The UDP feed and the ADIF monitor normally carry contacts seconds old but neither promises it — a logger re-broadcasting its backlog, or an operator typing last month's contact by hand, would be handed this morning's SFI as though it had been measured at the time. A wrong reading is worse than a missing one: afterwards nothing tells it apart from a real one.	2026-08-11 22:11:29 +02:00
rouggy	d4f23a52af	fix(details): QSL via gets the width, QSL message gives it up Width should follow use, and these two are nowhere near equal: a manager's callsign is typed constantly, a QSL message almost never. The message held 7 columns of 12 for text most operators never write, while the field beside it — often a long "via" instruction — was the one running out of room. Swapped, so QSL via takes 7 and the message 5. Also puts them in the order they are reached for.	2026-08-11 21:35:41 +02:00
rouggy	b4b9674d8c	chore: open 0.24.7 Empty block at the top so the next change has somewhere to go. 0.24.6 keeps its six entries; the release script stamps the version constants.	2026-08-11 21:15:52 +02:00