chore: release v0.27.17

Typing a cluster macro cost two things per character. The state lived on
SettingsModal, so every keystroke in one of those twenty-four boxes
re-rendered the WHOLE preferences dialog — every list, every form, every
panel. And the save wrote through to Go and into the database on each
one: a round trip per character.

The editor is now its own module-scoped component with its own state, so
a keystroke re-renders twelve rows. And writeUiPrefDebounced holds the
database write until the typing stops, while the local cache — which is
what everything reads back — is still written at once. Pending values are
flushed when the page goes away, so typing and immediately closing does
not lose the last word.

The behaviour is unchanged: still saved as you type, still no Save
button, because a text box whose contents only take effect on some other
button is how work gets lost.

Also folds the satellite changelog into one [NEW] entry. Satellites are
new in this version — nobody reading the notes has seen any of it — so a
running account of how it was built, tab then tracking then rotator then
where the settings moved to, is the wrong shape. One entry saying what it
does.

app.go

@@ -67,6 +67,7 @@ import (
 	"hamlog/internal/rotator/pst"
 	"hamlog/internal/rotator/spid"
 	"hamlog/internal/rotgenius"
+	"hamlog/internal/sat"
 	"hamlog/internal/scp"
 	"hamlog/internal/settings"
 	"hamlog/internal/solar"
@@ -157,6 +158,7 @@ const (
 	// the rule since is that nothing a backend does may be steered by another
 	// backend's setting.
 	keyCATYaesuLowLines    = "cat.yaesu.low_dtr_rts"   // deassert DTR/RTS on connect
+	keyCATYaesuRTTYUSB     = "cat.yaesu.rtty_usb"      // set RTTY on USB rather than the older LSB
 	keyCATKenwoodLowLines  = "cat.kenwood.low_dtr_rts" // deassert DTR/RTS on connect
 	keyCATKenwoodDataMode  = "cat.kenwood.data_mode"   // data modes → "usb" | "data" (MD6) | "keep"
 	keyCATIcomPort         = "cat.icom.port"           // Icom USB CI-V serial port (e.g. COM5)
@@ -510,7 +512,11 @@ type CATSettings struct {
 	// Per-backend: deassert DTR and RTS after opening the CAT port, for
 	// interfaces that read either line as PTT. Off by default: lowering them
 	// stops some USB-serial interfaces transmitting at all.
-	YaesuLowLines   bool   `json:"yaesu_low_lines"`
+	YaesuLowLines bool `json:"yaesu_low_lines"`
+	// YaesuRTTYUSB: ADIF says "RTTY" and Yaesu has both sidebands, so the rig
+	// cannot be driven from the logged mode alone. Off = RTTY-L, the older
+	// convention.
+	YaesuRTTYUSB    bool   `json:"yaesu_rtty_usb"`
 	KenwoodLowLines bool   `json:"kenwood_low_lines"`
 	IcomPort        string `json:"icom_port"`      // Icom USB CI-V serial port (e.g. COM5)
 	IcomBaud        int    `json:"icom_baud"`      // Icom CI-V baud (default 115200)
@@ -753,6 +759,9 @@ type App struct {
 	// is consulted once per message.
 	chaseBandsMu sync.RWMutex
 	chaseBands   map[string]bool
+	// The Chase new panel's OWN band filter, as the set switched off. Read per
+	// message like the list above, so an atomic rather than a settings lookup.
+	chaseNewBandsOff atomic.Value // map[string]bool
 	// pskr is the PSK Reporter MQTT feed, up only while the opening watch is on.
 	// It is the source that makes VHF detection work at all: the cluster and RBN
 	// carry a handful of 6 m spots where PSK Reporter carries hundreds.
@@ -773,8 +782,12 @@ type App struct {
 	// FT8 window and an FT4 one do not even share a period length — and one
 	// buffer for both cut every slot into fragments, each judged as a period of
 	// its own. The engine then counted a missed period several times a slot.
-	acPeriod    map[string]string
+	acPeriod map[string]string
-	acAt        map[string]time.Time
+	acAt     map[string]time.Time
+	// acFed is when the last decode of the open period ARRIVED, wall clock. The
+	// period's own timestamp cannot answer "has it gone quiet" — it is the start
+	// of the slot, thirteen seconds before its decodes exist.
+	acFed       map[string]time.Time
 	acTR        map[string]int
 	acBuf       map[string][]acDecode
 	acTX        autocall.TXState
@@ -782,6 +795,15 @@ type App struct {
 	acLastJudge time.Time
 	// acTXPeriod is the last transmit period already counted — see autoCallNoteTX.
 	acTXPeriod string
+	// acJudged is the last period key each receiver has been judged on, and
+	// acDirty says decodes have arrived for it since. Together they let a period
+	// be judged AGAIN when a straggler turns up, with the whole period in hand.
+	acJudged map[string]string
+	acDirty  map[string]bool
+	// What the decodes panel is SHOWING, and whether it is publishing at all.
+	// The panel owns the filters; this is its answer, not a second copy of them.
+	acVisible   map[string]bool
+	acVisibleOn bool
 	// Self-spot throttle: when and on what frequency we last announced ourselves.
 	// Held in memory only — a restart legitimately re-announces the station.
 	selfSpotMu   sync.Mutex
@@ -863,6 +885,23 @@ type App struct {
 
 	alertStore *alerts.Store // DX-cluster spot alert rules (global JSON)
 
+	// udpFocus arbitrates the entry field between several decoders running at
+	// once — see app_udp_focus.go.
+	udpFocus udpFocus
+
+	// Satellites. The elements (where the birds are) and the frequency plan
+	// (what to do with the radio) are held apart because they come from
+	// different places and change for different reasons — a feed every few
+	// days, an operator's correction when a transponder is switched.
+	satMu    sync.Mutex
+	satStore *sat.Store   // orbital elements, by satellite name
+	satBirds *sat.Birds   // uplink/downlink plan
+	satFetch *sat.Fetcher // element feeds + the on-disk cache
+	// satTrack is the live tracker: the goroutine that walks the radio through a
+	// pass. nil when nothing is being tracked.
+	satTrackMu sync.Mutex
+	satTrack   *satTracker
+
 	cwMu      sync.Mutex        // guards the CW decoder lifecycle
 	cwStop    chan struct{}     // stops the CW decoder capture loop; nil when off
 	cwDecoder *cwdecode.Decoder // live decoder (for retargeting the pitch)
@@ -1172,6 +1211,7 @@ func (a *App) startup(ctx context.Context) {
 	audio.AlertSink = func(format string, args ...any) { a.toast(fmt.Sprintf(format, args...)) }
 	extsvc.LogSink = applog.Printf // log raw QRZ (and other) service responses for diagnosis
 	lookup.LogSink = applog.Printf // which call was queried, and why a portable lookup fell back
+	audio.Logf = applog.Printf     // why the Listening device stayed silent, above all
 	db.LogSink = applog.Printf     // which schema migrations ran, and how long they took
 	// Version and executable FIRST, before anything else can fail. Diagnosing a
 	// report means knowing which build produced the log, and that was previously
@@ -1621,6 +1661,10 @@ func (a *App) startup(ctx context.Context) {
 		a.alertStore = as
 	}
 
+	// Satellites: the cached elements and the frequency plan. Local files only —
+	// any element fetch it decides to make goes to the network on its own.
+	a.startSatellites()
+
 	// Ultrabeam antenna: connect in the background if enabled.
 	a.startUltrabeam()
 	// Antenna Genius switch: connect in the background if enabled.
@@ -1653,6 +1697,7 @@ func (a *App) startup(ctx context.Context) {
 	a.startGridCache()
 	a.chaseNew = newChaseNewStore()
 	a.refreshChaseNew()
+	a.refreshChaseNewBands()
 	// PSK Reporter. After the operator's grid is known: without it there is no
 	// distance to measure and no receiver squares to filter on, so it stays down.
 	a.startBandOpenFeed()
@@ -1923,6 +1968,10 @@ func (a *App) shutdown(ctx context.Context) {
 	applog.Printf("shutdown: closing autostart programs")
 	a.CloseAutostartPrograms()
 	a.stopPSKTarget() // one TLS socket to a public broker; nothing to flush
+	// Before CAT goes down: disarming satellite mode takes the radio out of full
+	// duplex and puts the transmitter back where the operator is listening, and
+	// that has to happen while the link is still up.
+	a.StopSatelliteTracking()
 	applog.Printf("shutdown: stopping UDP")
 	if a.udp != nil {
 		a.udp.StopAll()
@@ -2591,7 +2640,20 @@ func (a *App) switchLogbook(p profile.Profile) error {
 		_ = old.Close()
 	}
 	applog.Printf("logbook switched to %s for profile %q", backend, p.Name)
+	// EVERY worked/new verdict belonged to the OLD logbook.
+	//
+	// The award matrices above are only half of it: the in-memory worked-index
+	// the alert engine reads, the chase-new list, and the frontend's own cache of
+	// resolved spot verdicts all still hold the previous log's answers. An
+	// operator switching to an empty profile and back found every decode on the
+	// screen badged NEW — the empty log's verdicts, cached under the full one,
+	// and nothing short of a restart cleared them.
+	if a.chaseNew != nil {
+		a.chaseNew.clear()
+	}
+	go a.rebuildWorkedIndex()
 	if a.ctx != nil {
+		wruntime.EventsEmit(a.ctx, "spotstatus:invalidate")
 		wruntime.EventsEmit(a.ctx, "logbook:changed")
 	}
 	return nil
@@ -3036,6 +3098,10 @@ func (a *App) AddQSO(q qso.QSO) (id int64, err error) {
 		}
 	}()
 	a.applyStationDefaults(&q, true)
+	// Before fillRXDefaults, which copies the transmit frequency into the receive
+	// one: on a satellite the two are on different bands, and letting that copy
+	// happen first would bury the downlink under the uplink.
+	a.applySatellite(&q)
 	fillRXDefaults(&q)
 	fillDistance(&q)
 	a.applyDXCCNumber(&q)
@@ -3070,6 +3136,9 @@ func (a *App) AddQSO(q qso.QSO) (id int64, err error) {
 	}
 	if err == nil {
 		q.ID = id
+		// The contact is over, so no decoder holds the entry field any more: the
+		// next station may come from whichever one hears it first.
+		a.udpFocus.release("QSO logged")
 		a.noteWorked(q.Callsign, q.Band, q.Mode) // keep the alert worked-index fresh (in-memory)
 		a.noteLiveQSO()                          // multi-op: flip this operator back "online" (publishes async)
 		// Snapshot the QSO recording SYNCHRONOUSLY, BEFORE announcing the log: the
@@ -3124,7 +3193,7 @@ func (a *App) AddQSO(q qso.QSO) (id int64, err error) {
 			// a few lines above and is not on the copy taken at insert time.
 			a.syncPublishAsync(syncfolder.OpAdd, id, nil)
 			if a.udp != nil {
-				rec := adif.SingleRecordADIF(qc)
+				rec := adif.ForwardRecordADIF(qc)
 				a.udp.EmitLoggedADIF(rec)
 				a.udp.EmitLoggedQSOWSJT(wsjtLoggedQSO(qc), rec)
 				a.udpTriggerQSOLogged(qc)
@@ -8286,7 +8355,7 @@ func (a *App) GetCATSettings() (CATSettings, error) {
 	if a.settings == nil {
 		return CATSettings{Backend: "omnirig", OmniRigNum: 1, PollMs: 250}, fmt.Errorf("db not initialized")
 	}
-	m, err := a.settings.GetMany(a.ctx, keyCATEnabled, keyCATBackend, keyCATOmniRigNum, keyCATOmniRigVFO, keyCATFlexHost, keyCATFlexPort, keyCATFlexSpots, keyCATFlexDVKDax, keyCATFlexDecodeSpots, keyCATFlexDecodeSecs, keyCATXieguPort, keyCATXieguBaud, keyCATXieguAddr, keyCATXieguPTTLine, keyCATYaesuPort, keyCATYaesuBaud, keyCATKenwoodPort, keyCATKenwoodBaud, keyCATKenwoodHost, keyCATKenwoodLink, keyCATYaesuLowLines, keyCATKenwoodLowLines, keyCATKenwoodDataMode, keyCATIcomPort, keyCATIcomBaud, keyCATIcomAddr, keyCATIcomNetHost, keyCATIcomNetUser, keyCATIcomNetPass, keyCATIcomNetAudio, keyCATTCIHost, keyCATTCIPort, keyCATTCISpots, keyCATPttHotkeyEnabled, keyCATPttHotkey, keyCATPttHotkeyToggle, keyCATPollMs, keyCATDelayMs, keyCATOffsetOn, keyCATOffsetHz, keyCATDigitalDefault, keyCATShareEnabled, keyCATSharePort, keyCATShareProto, keyCATShareTCIPort, keyCATDigiUSB)
+	m, err := a.settings.GetMany(a.ctx, keyCATEnabled, keyCATBackend, keyCATOmniRigNum, keyCATOmniRigVFO, keyCATFlexHost, keyCATFlexPort, keyCATFlexSpots, keyCATFlexDVKDax, keyCATFlexDecodeSpots, keyCATFlexDecodeSecs, keyCATXieguPort, keyCATXieguBaud, keyCATXieguAddr, keyCATXieguPTTLine, keyCATYaesuPort, keyCATYaesuBaud, keyCATYaesuRTTYUSB, keyCATKenwoodPort, keyCATKenwoodBaud, keyCATKenwoodHost, keyCATKenwoodLink, keyCATYaesuLowLines, keyCATKenwoodLowLines, keyCATKenwoodDataMode, keyCATIcomPort, keyCATIcomBaud, keyCATIcomAddr, keyCATIcomNetHost, keyCATIcomNetUser, keyCATIcomNetPass, keyCATIcomNetAudio, keyCATTCIHost, keyCATTCIPort, keyCATTCISpots, keyCATPttHotkeyEnabled, keyCATPttHotkey, keyCATPttHotkeyToggle, keyCATPollMs, keyCATDelayMs, keyCATOffsetOn, keyCATOffsetHz, keyCATDigitalDefault, keyCATShareEnabled, keyCATSharePort, keyCATShareProto, keyCATShareTCIPort, keyCATDigiUSB)
 	if err != nil {
 		return CATSettings{}, err
 	}
@@ -8312,6 +8381,7 @@ func (a *App) GetCATSettings() (CATSettings, error) {
 		KenwoodLink:      kenwoodLinkOr(m[keyCATKenwoodLink], m[keyCATKenwoodHost]),
 		KenwoodBaud:      9600,
 		YaesuLowLines:    m[keyCATYaesuLowLines] == "1",
+		YaesuRTTYUSB:     m[keyCATYaesuRTTYUSB] == "1",
 		KenwoodLowLines:  m[keyCATKenwoodLowLines] == "1",
 		KenwoodDataMode:  m[keyCATKenwoodDataMode],
 		IcomPort:         m[keyCATIcomPort],
@@ -8445,7 +8515,11 @@ func (a *App) SaveCATSettings(s CATSettings) error {
 	if s.IcomBaud <= 0 {
 		s.IcomBaud = 115200
 	}
-	if s.IcomAddr <= 0 || s.IcomAddr > 0xFF {
+	// 0x00 IS an address. Rejecting it as "unset" is what sent an operator's
+	// custom-address rig straight back to the IC-7610's 0x98 every time the
+	// settings were saved — the model dropdown snapping back with it, since it
+	// reads the address rather than a stored model.
+	if s.IcomAddr < 0 || s.IcomAddr > 0xFF {
 		s.IcomAddr = 0x98
 	}
 	if s.PollMs < 50 || s.PollMs > 2000 {
@@ -8521,6 +8595,7 @@ func (a *App) SaveCATSettings(s CATSettings) error {
 		keyCATKenwoodLink:      kenwoodLinkOr(s.KenwoodLink, s.KenwoodHost),
 		keyCATKenwoodBaud:      strconv.Itoa(s.KenwoodBaud),
 		keyCATYaesuLowLines:    b01(s.YaesuLowLines),
+		keyCATYaesuRTTYUSB:     b01(s.YaesuRTTYUSB),
 		keyCATKenwoodLowLines:  b01(s.KenwoodLowLines),
 		keyCATKenwoodDataMode:  strings.ToLower(strings.TrimSpace(s.KenwoodDataMode)),
 		keyCATIcomPort:         strings.TrimSpace(s.IcomPort),
@@ -11786,10 +11861,34 @@ func (a *App) UploadQSOsManual(service string, ids []int64) error {
 		return fmt.Errorf("unknown service %q", service)
 	}
 	cfg := a.loadExternalServices()
+	// NOT CONFIGURED IS AN ANSWER, AND IT BELONGS HERE.
+	//
+	// The upload runs on its own goroutine and reports through the QSL Manager's
+	// console, which is not open when the command was given from a right-click in
+	// the QSO list: an upload to a service with no credentials looked exactly
+	// like one that worked. Refused synchronously instead, where the caller can
+	// show it.
+	if err := uploadConfigured(svc, cfg); err != nil {
+		return err
+	}
 	go a.runManualUpload(svc, ids, cfg)
 	return nil
 }
 
+// uploadConfigured reports whether a service can be uploaded to at all.
+//
+// The rules live in internal/extsvc, beside the uploaders that enforce them.
+// Written here instead they drifted at once: Club Log was refused for a missing
+// API key that nobody has ever set — OpsLog carries its own application key —
+// and an operator whose live upload had worked for months was told his service
+// was not configured.
+func uploadConfigured(svc extsvc.Service, cfg extsvc.ExternalServices) error {
+	if err := extsvc.Configured(svc, cfg); err != nil {
+		return fmt.Errorf("%w (Settings → External services)", err)
+	}
+	return nil
+}
+
 func (a *App) runManualUpload(svc extsvc.Service, ids []int64, cfg extsvc.ExternalServices) {
 	emit := func(line string) {
 		if a.ctx != nil {
@@ -14289,7 +14388,7 @@ func (a *App) LogUDPLoggedADIF(adifText string) (int64, error) {
 		// path — otherwise a QSO logged FROM WSJT-X/JTDX/MSHV was never re-emitted
 		// to the outbound ADIF listeners (Log4OM, N1MM, gridtracker…).
 		if a.udp != nil {
-			rec := adif.SingleRecordADIF(qc)
+			rec := adif.ForwardRecordADIF(qc)
 			a.udp.EmitLoggedADIF(rec)
 			a.udp.EmitLoggedQSOWSJT(wsjtLoggedQSO(qc), rec)
 			a.udpTriggerQSOLogged(qc)
@@ -14524,6 +14623,13 @@ func (a *App) consumeUDPEvents() {
 				"adif":      ev.LoggedADIF,
 			})
 		case ev.ClearCall:
+			// Only from the program the entry field belongs to. An idle decoder
+			// alongside the one being worked clears its own DX Call for reasons
+			// of its own, and that must not empty a field somebody else filled.
+			if !a.udpFocus.holds(ev.ProgramID) {
+				break
+			}
+			a.udpFocus.release("DX Call cleared")
 			applog.Printf("udp: emit udp:clear_call (DX Call cleared in the digital app)\n")
 			wruntime.EventsEmit(a.ctx, "udp:clear_call", map[string]any{
 				"service": string(ev.Service),
@@ -14548,6 +14654,12 @@ func (a *App) consumeUDPEvents() {
 				wruntime.EventsEmit(a.ctx, "udp:remote_call", ev.DXCall)
 			}
 		case ev.DXCall != "":
+			// With two or three decoders running, the one announcing a station
+			// takes the entry field and keeps it until it lets go. See udpFocus.
+			if !a.udpFocus.claim(ev.ProgramID) {
+				a.udpFocus.noteIgnored(ev.ProgramID, ev.DXCall)
+				break
+			}
 			applog.Printf("udp: emit udp:dx_call %q (mode=%s freq=%d)\n", ev.DXCall, ev.Mode, ev.FreqHz)
 			wruntime.EventsEmit(a.ctx, "udp:dx_call", map[string]any{
 				"call":    ev.DXCall,
@@ -16164,6 +16276,14 @@ func (a *App) reloadCAT() {
 		go a.startQSORecorderIfEnabled()
 	}
 	a.reloadCATShare(s)
+	// Preferences that the LINK does not depend on, pushed to the rig that is
+	// already connected. They are deliberately absent from catLinkSig — none of
+	// them is worth dropping the CAT link (and with it WSJT-X's rigctl session)
+	// to apply — so without this they waited for the next launch, and the
+	// operator ticking "RTTY on USB" watched the rig go on choosing LSB.
+	if s.Enabled && s.Backend == "yaesu" && a.cat != nil {
+		_ = a.cat.YaesuDo(func(y cat.YaesuController) error { y.SetRTTYUpper(s.YaesuRTTYUSB); return nil })
+	}
 	// Nothing about the link changed → leave it connected. See catLinkSig.
 	if sig := catLinkSig(s); sig == a.catSig {
 		applog.Printf("cat: settings saved, link unchanged — staying connected")
@@ -16224,6 +16344,7 @@ func (a *App) reloadCAT() {
 		// (a rig file that hides the VFO, a Freq property meaning A on one model
 		// and B on another); talking to the radio directly removes it.
 		yz := cat.NewYaesu(s.YaesuPort, s.YaesuBaud, s.DigitalDefault)
+		yz.SetRTTYUpper(s.YaesuRTTYUSB)
 		yz.SetLowerLines(s.YaesuLowLines)
 		a.cat.Start(yz)
 	case "kenwood", "elecraft":
@@ -16692,11 +16813,17 @@ func (a *App) reloadAfterProfileSwitch() {
 	// Auto-call is per profile — attempts, the "call only" callsign, whether it
 	// is on at all — and it TRANSMITS. A switch that left the previous profile's
 	// settings running would have the wrong station calling on the wrong log.
+	//
+	// Off, exactly as at launch: a switch changes the callsign, the log and
+	// usually the antenna, and none of that is a state in which a transmitter
+	// should resume by itself because this profile's stored setting said on.
 	// Re-applied rather than restarted: the loop is one goroutine for the life
-	// of the process, and applyAutoCall clears the target when the feature is
+	// of the process.
-	// off in the profile just activated.
+	a.disarmAutoCall("profile switch")
-	a.applyAutoCall()
 	a.autoCallEngine().Reset()
+	// Same reasoning for the satellite tracker: it transmits, and the new profile
+	// may be a different station on a different antenna.
+	a.StopSatelliteTracking()
 }
 
 // DuplicateProfile clones an existing profile under newName. Useful when
@@ -18251,7 +18378,22 @@ func motorBandAllowed(bands []string, hz int64) bool {
 // refreshed every couple of seconds — so a fresh command opens a short grace
 // window during which TX stays inhibited even before the poll confirms motion,
 // closing the gap at the start of a move.
-func (a *App) noteMotorMoveCommanded() { a.motorMoveCmdNs.Store(time.Now().UnixNano()) }
+// noteMotorMoveCommanded records — and ANNOUNCES — that the antenna has just
+// been told to move.
+//
+// The transmit gag already started here; the screen did not. It waited for a
+// status poll to come round and say the elements were travelling, so the
+// indicator turned orange a second or more after the button was pressed, and on
+// an automatic follow (band change with tracking on) the operator had no warning
+// at all until the poll landed. The event lets the interface show it at the
+// instant the order goes out, which is also when the transmitter is gagged —
+// one moment, one appearance.
+func (a *App) noteMotorMoveCommanded() {
+	a.motorMoveCmdNs.Store(time.Now().UnixNano())
+	if a.ctx != nil {
+		wruntime.EventsEmit(a.ctx, "motorant:move")
+	}
+}
 
 // applyMotorInhibit sets or clears the Flex transmit inhibit, but only when the
 // active CAT backend IS a FlexRadio — the inhibit is a Flex-API feature; with any
@@ -18280,7 +18422,13 @@ func (a *App) applyMotorInhibit(on bool) {
 // OR within a grace window after a commanded move — and always releases the
 // inhibit when it stops (so a settings change / shutdown never leaves TX blocked).
 func (a *App) motorTXInhibitLoop(c motorAntenna, bands []string, stop <-chan struct{}) {
-	const grace = 3 * time.Second // cover the poll latency at the very start of a move
+	// Just long enough to bridge ONE fast poll at the start of a move, when the
+	// antenna has been told to go but has not yet said it is going. It was three
+	// seconds, from when the status poll ran every two: a move that took a second
+	// left the transmitter gagged for two more, with the elements already in
+	// place. The antenna is now polled four times a second while it travels, so
+	// this only has to cover the command itself.
+	const grace = 900 * time.Millisecond
 	ticker := time.NewTicker(300 * time.Millisecond)
 	defer ticker.Stop()
 	defer a.applyMotorInhibit(false) // never leave TX blocked when the loop ends
@@ -20578,6 +20726,15 @@ func (a *App) SaveChaseSettings(cs ChaseSettings) error {
 	a.clusterStatusMu.Lock()
 	a.clusterStatusIdx = nil
 	a.clusterStatusMu.Unlock()
+	// Chase new judges each decode AS IT ARRIVES and keeps only what was new at
+	// that moment, so its list is a set of verdicts reached under the old rule —
+	// and nothing in it would ever be re-judged. Switching to "new only" left
+	// rows listed that are merely unconfirmed; switching the other way could not
+	// bring back what had already been refused. Emptied, it refills from the
+	// live feed within a period or two, under the rule now in force.
+	if a.chaseNew != nil {
+		a.chaseNew.clear()
+	}
 	// The frontend caches resolved verdicts and only asks about unknown keys —
 	// without this it kept judging half the screen under the OLD rules until a
 	// restart, which read as the new mode simply not working.

app_gate.go

@@ -20,6 +20,7 @@ var deniedCallHashes = map[string]struct{}{
 	"0741c9e394b42f43191899105553b47155ddc3026da12b5360701f9c181ff123": {},
 	"ab4926a3a0ab76d41b5b99cd3ad0683584970c341c29427c1dfa4b3c329ce415": {},
 	"9d17c9c213a6cc89c12d7520bcf21c86a0cf43d17e82e74f33f3a77cb865d28a": {},
+	"94ee059335e587e501cc4bf90613e0814f00a7b08bc7c648fd865a2af6a22cc2": {},
 }
 
 // callDenied reports whether a callsign is on deniedCallHashes. The call is

app_sat.go

@@ -0,0 +1,980 @@
+package main
+
+// Satellites — the wiring around internal/sat.
+//
+// The package knows orbits and frequency plans; this file is what the station
+// knows: where the antenna is, which birds the operator cares about, and where
+// the elements are kept. Nothing here talks to a radio or a rotator yet — that
+// is the next layer, and it is deliberately built on top of GetSatelliteTuning
+// rather than beside it, so what the operator reads on screen and what gets
+// sent to the rig can never disagree.
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	wruntime "github.com/wailsapp/wails/v2/pkg/runtime"
+
+	"hamlog/internal/applog"
+	"hamlog/internal/sat"
+)
+
+const (
+	keySatFavorites = "sat.favorites" // comma-separated satellite names
+	keySatMinEl     = "sat.min_el"    // degrees; passes lower than this are not listed
+	keySatWindowH   = "sat.window_h"  // hours of pass predictions
+	keySatAutoTLE   = "sat.auto_tle"  // fetch elements at startup when the set is stale
+	keySatGrid      = "sat.grid"      // locator override ("" = the station's own)
+	keySatAltM      = "sat.alt_m"     // antenna height above sea level, metres
+
+	// The az/el rotator. Its own settings rather than the HF rotator's: a
+	// satellite station's elevation rotator is a different machine on a
+	// different port, and an operator who has both must not have to choose.
+	keySatRotOn = "sat.rot_enabled"
+	// Which program drives the mast: OpsLog itself over EasyComm, or PstRotator,
+	// which many stations already run in front of their controller. Its own port
+	// key because it is a different program on a different port from an EasyComm
+	// controller, and an operator who tries both must not lose the first setting
+	// to the second.
+	keySatRotType      = "sat.rot_type"      // "easycomm" | "pstrotator"
+	keySatRotPstPort   = "sat.rot_pst_port"  // PstRotator's UDP command port
+	keySatRotTransport = "sat.rot_transport" // "serial" | "tcp"
+	keySatRotHost      = "sat.rot_host"
+	keySatRotPort      = "sat.rot_port"
+	keySatRotCOM       = "sat.rot_com"
+	keySatRotBaud      = "sat.rot_baud"
+	keySatRotMaxAz     = "sat.rot_max_az" // 360 or 450
+	keySatRotMinEl     = "sat.rot_min_el" // don't drive the rotator below this elevation
+	keySatRotStep      = "sat.rot_step"   // degrees of change worth a command
+	keySatRotPark      = "sat.rot_park"   // park at az 0 / el 0 when tracking stops
+)
+
+// customTLEName holds elements the operator pasted in by hand.
+//
+// Kept apart from the feed cache because the cache is REPLACED wholesale on
+// every refresh: a freshly launched satellite, whose elements arrive on a
+// mailing list days before any feed carries it, would be wiped by the first
+// automatic update — which is precisely the week everybody wants to hear it.
+const customTLEName = "satellites.custom.tle"
+
+// SatSettings is the station's side of satellite work.
+type SatSettings struct {
+	Favorites []string `json:"favorites"`
+	MinEl     int      `json:"min_el"`
+	WindowH   int      `json:"window_h"`
+	AutoTLE   bool     `json:"auto_tle"`
+	Grid      string   `json:"grid"`
+	AltM      int      `json:"alt_m"`
+
+	// The az/el rotator.
+	RotOn        bool   `json:"rot_on"`
+	RotType      string `json:"rot_type"`
+	RotPstPort   int    `json:"rot_pst_port"`
+	RotTransport string `json:"rot_transport"`
+	RotHost      string `json:"rot_host"`
+	RotPort      int    `json:"rot_port"`
+	RotCOM       string `json:"rot_com"`
+	RotBaud      int    `json:"rot_baud"`
+	RotMaxAz     int    `json:"rot_max_az"`
+	RotMinEl     int    `json:"rot_min_el"`
+	RotStep      int    `json:"rot_step"`
+	RotPark      bool   `json:"rot_park"`
+}
+
+// SatTransponder is one path through a satellite, as the UI needs it.
+type SatTransponder struct {
+	Label     string  `json:"label"`
+	Mode      string  `json:"mode"`
+	DownLo    int64   `json:"down_lo"`
+	DownHi    int64   `json:"down_hi"`
+	UpLo      int64   `json:"up_lo"`
+	UpHi      int64   `json:"up_hi"`
+	Inverting bool    `json:"inverting"`
+	CTCSS     float64 `json:"ctcss"`
+	Linear    bool    `json:"linear"`
+}
+
+// SatBird is a satellite as the operator sees it: the frequency plan joined to
+// whatever elements we hold for it.
+type SatBird struct {
+	Name          string           `json:"name"`
+	NORAD         int              `json:"norad"`
+	Geostationary bool             `json:"geostationary"`
+	Favorite      bool             `json:"favorite"`
+	HasElements   bool             `json:"has_elements"`
+	ElementName   string           `json:"element_name"` // the feed's spelling, when it differs
+	EpochAgeH     float64          `json:"epoch_age_h"`
+	Transponders  []SatTransponder `json:"transponders"`
+}
+
+// SatTLEInfo describes the element set the station is working from.
+type SatTLEInfo struct {
+	Count     int       `json:"count"`
+	FetchedAt time.Time `json:"fetched_at"`
+	AgeH      float64   `json:"age_h"`
+	Stale     bool      `json:"stale"`
+	Custom    int       `json:"custom"` // hand-entered satellites among the count
+}
+
+// SatTuning is where to listen and where to transmit, right now.
+//
+// Both the nominal and the corrected pair are returned on purpose: the nominal
+// is what goes in the log (see the ADIF note on SAT_NAME) and the corrected is
+// what goes to the radio. An operator staring at a display that shows only one
+// of them cannot tell a Doppler correction from a mistuned transponder.
+type SatTuning struct {
+	Name        string  `json:"name"`
+	Transponder string  `json:"transponder"`
+	Mode        string  `json:"mode"`
+	NominalDown int64   `json:"nominal_down"`
+	NominalUp   int64   `json:"nominal_up"`
+	DownHz      int64   `json:"down_hz"`
+	UpHz        int64   `json:"up_hz"`
+	CTCSS       float64 `json:"ctcss"`
+	Inverting   bool    `json:"inverting"`
+
+	Az        float64   `json:"az"`
+	El        float64   `json:"el"`
+	RangeKm   float64   `json:"range_km"`
+	RangeRate float64   `json:"range_rate"`
+	Visible   bool      `json:"visible"`
+	At        time.Time `json:"at"`
+
+	// Where the satellite is over the earth. Carried with the tuning because
+	// they are read together and change together — the panel would otherwise ask
+	// twice a second for two halves of one instant.
+	Lat       float64 `json:"lat"`
+	Lon       float64 `json:"lon"`
+	AltKm     float64 `json:"alt_km"`
+	Footprint float64 `json:"footprint_km"`
+}
+
+// SatPassInfo is the pass in progress, or the next one.
+//
+// Separate from the tuning and polled far more slowly: predicting a pass steps
+// the orbit thirty seconds at a time across hours, which is not something to do
+// once a second for a countdown a browser can run itself from two timestamps.
+type SatPassInfo struct {
+	Name    string `json:"name"`
+	HasPass bool   `json:"has_pass"`
+	// InPass distinguishes "it is up now" from "it rises at". The pass in
+	// progress is reported whatever its maximum elevation: an operator watching
+	// a satellite go over does not want it hidden because it fell below the
+	// threshold that filters the TABLE of what is worth waiting for.
+	InPass   bool      `json:"in_pass"`
+	AOS      time.Time `json:"aos"`
+	LOS      time.Time `json:"los"`
+	AOSAz    float64   `json:"aos_az"`
+	LOSAz    float64   `json:"los_az"`
+	MaxEl    float64   `json:"max_el"`
+	MaxElAz  float64   `json:"max_el_az"`
+	MaxElAt  time.Time `json:"max_el_at"`
+	Duration float64   `json:"duration_s"`
+}
+
+// ── Lifecycle ───────────────────────────────────────────────────────────────
+
+// startSatellites loads what is already on disk and, only if asked, goes to the
+// network.
+//
+// Cache first and synchronously: it is one file and a few hundred parses, and
+// it means the satellite tab is populated the instant it is opened, on a shack
+// PC with no internet as much as on one with. The fetch is the slow, optional
+// half and never blocks a launch.
+func (a *App) startSatellites() {
+	dir := a.dataDir
+	birds, err := sat.LoadBirds(dir)
+	if err != nil {
+		// LoadBirds always returns a usable list; the error says the operator's
+		// own file was refused, which they need to be told about.
+		applog.Printf("sat: %v", err)
+	}
+	store := sat.NewStore()
+	fetch := sat.NewFetcher(dir)
+	fetch.Logf = applog.Printf
+
+	if els, at, err := fetch.LoadCache(); err == nil {
+		store.Replace(els, at)
+		applog.Printf("sat: %d satellites from the cached element set (%s old)", len(els), time.Since(at).Round(time.Minute))
+	} else if !os.IsNotExist(err) {
+		applog.Printf("sat: the cached element set could not be read: %v", err)
+	}
+	a.satMu.Lock()
+	a.satStore, a.satBirds, a.satFetch = store, birds, fetch
+	a.satMu.Unlock()
+	a.loadCustomElements()
+
+	set := a.satSettings()
+	if set.AutoTLE && a.satTLEInfo().Stale {
+		go func() {
+			if _, err := a.RefreshSatelliteTLE(); err != nil {
+				applog.Printf("sat: %v", err)
+			}
+		}()
+	}
+}
+
+// satParts hands back the three pieces under the lock, building them if the
+// startup path has not run — a binding called from a tab the operator opened
+// before startup finished must not answer "no satellites".
+func (a *App) satParts() (*sat.Store, *sat.Birds, *sat.Fetcher) {
+	a.satMu.Lock()
+	if a.satStore == nil {
+		a.satMu.Unlock()
+		a.startSatellites()
+		a.satMu.Lock()
+	}
+	s, b, f := a.satStore, a.satBirds, a.satFetch
+	a.satMu.Unlock()
+	return s, b, f
+}
+
+// ── Settings ────────────────────────────────────────────────────────────────
+
+func (a *App) satSettings() SatSettings {
+	// The rotator defaults are the common case, not a blank form: EasyComm over
+	// a serial port at 9600, a 360° machine, and a five-degree step — which on a
+	// beam with any gain at all is well inside the beamwidth and keeps a pass
+	// from being a command a second.
+	out := SatSettings{
+		MinEl: 10, WindowH: 24, AutoTLE: true,
+		RotType: satRotEasycomm, RotPstPort: 12000,
+		RotTransport: "serial", RotPort: 4533, RotBaud: 9600,
+		RotMaxAz: 360, RotMinEl: 0, RotStep: 5,
+	}
+	if a.settings == nil {
+		return out
+	}
+	m, err := a.settings.GetMany(a.ctx,
+		keySatFavorites, keySatMinEl, keySatWindowH, keySatAutoTLE, keySatGrid, keySatAltM,
+		keySatRotOn, keySatRotType, keySatRotPstPort, keySatRotTransport, keySatRotHost, keySatRotPort, keySatRotCOM,
+		keySatRotBaud, keySatRotMaxAz, keySatRotMinEl, keySatRotStep, keySatRotPark)
+	if err != nil {
+		return out
+	}
+	out.RotOn = m[keySatRotOn] == "1"
+	if ty := m[keySatRotType]; ty == satRotPst || ty == satRotEasycomm {
+		out.RotType = ty
+	}
+	if v, err := strconv.Atoi(m[keySatRotPstPort]); err == nil && v > 0 && v <= 65535 {
+		out.RotPstPort = v
+	}
+	if tr := m[keySatRotTransport]; tr == "tcp" || tr == "serial" {
+		out.RotTransport = tr
+	}
+	out.RotHost = strings.TrimSpace(m[keySatRotHost])
+	if v, err := strconv.Atoi(m[keySatRotPort]); err == nil && v > 0 && v <= 65535 {
+		out.RotPort = v
+	}
+	out.RotCOM = strings.TrimSpace(m[keySatRotCOM])
+	if v, err := strconv.Atoi(m[keySatRotBaud]); err == nil && v >= 1200 && v <= 115200 {
+		out.RotBaud = v
+	}
+	if v, err := strconv.Atoi(m[keySatRotMaxAz]); err == nil && v == 450 {
+		out.RotMaxAz = 450
+	}
+	if v, err := strconv.Atoi(m[keySatRotMinEl]); err == nil && v >= -10 && v <= 30 {
+		out.RotMinEl = v
+	}
+	if v, err := strconv.Atoi(m[keySatRotStep]); err == nil && v >= 1 && v <= 30 {
+		out.RotStep = v
+	}
+	out.RotPark = m[keySatRotPark] == "1"
+	for _, n := range strings.Split(m[keySatFavorites], ",") {
+		if n = strings.TrimSpace(n); n != "" {
+			out.Favorites = append(out.Favorites, n)
+		}
+	}
+	if v, err := strconv.Atoi(m[keySatMinEl]); err == nil && v >= 0 && v <= 60 {
+		out.MinEl = v
+	}
+	if v, err := strconv.Atoi(m[keySatWindowH]); err == nil && v >= 1 && v <= 168 {
+		out.WindowH = v
+	}
+	if v, ok := m[keySatAutoTLE]; ok && v != "" {
+		out.AutoTLE = v == "1"
+	}
+	out.Grid = strings.TrimSpace(m[keySatGrid])
+	if v, err := strconv.Atoi(m[keySatAltM]); err == nil && v > -500 && v < 9000 {
+		out.AltM = v
+	}
+	return out
+}
+
+// GetSatSettings returns the satellite preferences.
+func (a *App) GetSatSettings() (SatSettings, error) {
+	if a.settings == nil {
+		return SatSettings{}, fmt.Errorf("db not initialized")
+	}
+	return a.satSettings(), nil
+}
+
+// SaveSatSettings stores them.
+func (a *App) SaveSatSettings(s SatSettings) error {
+	if a.settings == nil {
+		return fmt.Errorf("db not initialized")
+	}
+	if s.MinEl < 0 || s.MinEl > 60 {
+		s.MinEl = 10
+	}
+	if s.WindowH < 1 || s.WindowH > 168 {
+		s.WindowH = 24
+	}
+	var favs []string
+	seen := map[string]bool{}
+	for _, n := range s.Favorites {
+		n = strings.TrimSpace(n)
+		if n == "" || seen[strings.ToUpper(n)] {
+			continue
+		}
+		seen[strings.ToUpper(n)] = true
+		favs = append(favs, n)
+	}
+	if s.RotType != satRotPst {
+		s.RotType = satRotEasycomm
+	}
+	if s.RotPstPort <= 0 || s.RotPstPort > 65535 {
+		s.RotPstPort = 12000
+	}
+	if s.RotTransport != "tcp" {
+		s.RotTransport = "serial"
+	}
+	if s.RotMaxAz != 450 {
+		s.RotMaxAz = 360
+	}
+	if s.RotStep < 1 || s.RotStep > 30 {
+		s.RotStep = 5
+	}
+	if s.RotPort <= 0 || s.RotPort > 65535 {
+		s.RotPort = 4533
+	}
+	if s.RotBaud < 1200 || s.RotBaud > 115200 {
+		s.RotBaud = 9600
+	}
+	for k, v := range map[string]string{
+		keySatFavorites:    strings.Join(favs, ","),
+		keySatMinEl:        strconv.Itoa(s.MinEl),
+		keySatWindowH:      strconv.Itoa(s.WindowH),
+		keySatAutoTLE:      boolStr(s.AutoTLE),
+		keySatGrid:         strings.ToUpper(strings.TrimSpace(s.Grid)),
+		keySatAltM:         strconv.Itoa(s.AltM),
+		keySatRotOn:        boolStr(s.RotOn),
+		keySatRotType:      s.RotType,
+		keySatRotPstPort:   strconv.Itoa(s.RotPstPort),
+		keySatRotTransport: s.RotTransport,
+		keySatRotHost:      strings.TrimSpace(s.RotHost),
+		keySatRotPort:      strconv.Itoa(s.RotPort),
+		keySatRotCOM:       strings.TrimSpace(s.RotCOM),
+		keySatRotBaud:      strconv.Itoa(s.RotBaud),
+		keySatRotMaxAz:     strconv.Itoa(s.RotMaxAz),
+		keySatRotMinEl:     strconv.Itoa(s.RotMinEl),
+		keySatRotStep:      strconv.Itoa(s.RotStep),
+		keySatRotPark:      boolStr(s.RotPark),
+	} {
+		if err := a.settings.Set(a.ctx, k, v); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// satObserver is the ground station: the satellite grid if the operator set one,
+// otherwise the station's own.
+//
+// A locator, not a latitude and longitude: it is what every logbook already
+// holds, and its six-character precision is a couple of kilometres — three
+// hundredths of a degree of azimuth at the worst possible geometry, far below
+// any rotator's backlash.
+func (a *App) satObserver() (sat.Observer, error) {
+	set := a.satSettings()
+	grid := set.Grid
+	if grid == "" && a.profiles != nil {
+		// The station locator lives on the ACTIVE PROFILE, not in a settings key.
+		// keyStationMyGrid is a legacy key that EnsureDefault migrated into the
+		// profile years ago and nothing writes any more — reading it told an
+		// operator with a perfectly good locator on screen that he had not set
+		// one.
+		if p, err := a.profiles.Active(a.ctx); err == nil {
+			grid = p.MyGrid
+		}
+	}
+	grid = strings.TrimSpace(grid)
+	lat, lon, ok := gridToLatLon(grid)
+	if !ok {
+		return sat.Observer{}, fmt.Errorf("your locator is not set — Settings ▸ Station, or Settings ▸ Satellites for a different site")
+	}
+	return sat.Observer{Lat: lat, Lon: lon, AltM: float64(set.AltM)}, nil
+}
+
+// GetSatelliteObserver reports the ground station the predictions are made for,
+// so the UI can show it — and say plainly when there is none.
+func (a *App) GetSatelliteObserver() (map[string]any, error) {
+	obs, err := a.satObserver()
+	if err != nil {
+		return nil, err
+	}
+	return map[string]any{"lat": obs.Lat, "lon": obs.Lon, "alt_m": obs.AltM}, nil
+}
+
+// ── Elements ────────────────────────────────────────────────────────────────
+
+func (a *App) customTLEPath() string { return filepath.Join(a.dataDir, customTLEName) }
+
+// loadCustomElements merges the hand-entered file over the feed's set. Last
+// writer wins in the store, so an operator's own elements for a satellite
+// override the feed's — which is the whole point of having typed them.
+func (a *App) loadCustomElements() int {
+	f, err := os.Open(a.customTLEPath())
+	if err != nil {
+		return 0
+	}
+	defer f.Close()
+	els, skipped, err := sat.ParseTLESet(f)
+	if err != nil {
+		applog.Printf("sat: %s could not be read: %v", customTLEName, err)
+		return 0
+	}
+	if skipped > 0 {
+		applog.Printf("sat: %d entries in %s were unusable", skipped, customTLEName)
+	}
+	store, _, _ := a.satParts()
+	for _, e := range els {
+		store.Put(e)
+	}
+	return len(els)
+}
+
+func (a *App) customElementCount() int {
+	f, err := os.Open(a.customTLEPath())
+	if err != nil {
+		return 0
+	}
+	defer f.Close()
+	els, _, err := sat.ParseTLESet(f)
+	if err != nil {
+		return 0
+	}
+	return len(els)
+}
+
+func (a *App) satTLEInfo() SatTLEInfo {
+	store, _, _ := a.satParts()
+	at := store.FetchedAt()
+	info := SatTLEInfo{Count: store.Len(), FetchedAt: at, Custom: a.customElementCount()}
+	if !at.IsZero() {
+		info.AgeH = time.Since(at).Hours()
+		info.Stale = time.Since(at) > sat.StaleAfter
+	} else {
+		info.Stale = true // nothing on disk yet: the operator has to be told to fetch
+	}
+	return info
+}
+
+// GetSatelliteTLEInfo describes the element set, including how old it is.
+func (a *App) GetSatelliteTLEInfo() SatTLEInfo { return a.satTLEInfo() }
+
+// RefreshSatelliteTLE downloads a fresh element set.
+func (a *App) RefreshSatelliteTLE() (SatTLEInfo, error) {
+	store, _, fetch := a.satParts()
+	ctx := a.ctx
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	els, err := fetch.Fetch(ctx)
+	if err != nil {
+		return a.satTLEInfo(), err
+	}
+	store.Replace(els, time.Now())
+	a.loadCustomElements() // the operator's own elements go back on top
+	info := a.satTLEInfo()
+	if a.ctx != nil {
+		wruntime.EventsEmit(a.ctx, "sat:tle", info)
+	}
+	return info, nil
+}
+
+// AddSatelliteElements takes elements pasted in by hand — two or three lines
+// per satellite — and keeps them across feed refreshes.
+func (a *App) AddSatelliteElements(text string) (int, error) {
+	els, skipped, err := sat.ParseTLESet(strings.NewReader(text))
+	if err != nil {
+		return 0, fmt.Errorf("those are not usable elements: %w", err)
+	}
+	existing := map[string]bool{}
+	var keep []sat.Element
+	if f, ferr := os.Open(a.customTLEPath()); ferr == nil {
+		old, _, _ := sat.ParseTLESet(f)
+		f.Close()
+		keep = old
+	}
+	// The new set wins for a satellite already in the file: pasting elements is
+	// how an operator UPDATES a bird the feeds do not carry.
+	for _, e := range els {
+		existing[strings.ToUpper(e.Name)] = true
+	}
+	var out []sat.Element
+	for _, e := range keep {
+		if !existing[strings.ToUpper(e.Name)] {
+			out = append(out, e)
+		}
+	}
+	out = append(out, els...)
+
+	var b strings.Builder
+	for _, e := range out {
+		if e.Name != "" {
+			b.WriteString(e.Name + "\n")
+		}
+		b.WriteString(e.Line1 + "\n" + e.Line2 + "\n")
+	}
+	if err := os.WriteFile(a.customTLEPath(), []byte(b.String()), 0o644); err != nil {
+		return 0, err
+	}
+	n := a.loadCustomElements()
+	if a.ctx != nil {
+		wruntime.EventsEmit(a.ctx, "sat:tle", a.satTLEInfo())
+	}
+	if skipped > 0 {
+		applog.Printf("sat: %d pasted entries were unusable and were skipped", skipped)
+	}
+	return n, nil
+}
+
+// ── The list ────────────────────────────────────────────────────────────────
+
+// GetSatelliteBirds joins the frequency plan to the elements.
+//
+// Both halves are listed, not just their intersection: a bird with elements and
+// no plan is one the operator can still track and add frequencies for, and a
+// bird with a plan and no elements is the one visible symptom of an element set
+// that is too old or too narrow — silently dropping either turns a fixable
+// configuration problem into a satellite that "does not exist".
+func (a *App) GetSatelliteBirds() []SatBird {
+	store, birds, _ := a.satParts()
+	set := a.satSettings()
+	fav := map[string]bool{}
+	for _, n := range set.Favorites {
+		fav[strings.ToUpper(n)] = true
+	}
+
+	out := make([]SatBird, 0, birds.Len())
+	planned := map[string]bool{}
+	for _, b := range birds.All() {
+		item := SatBird{Name: b.Name, Geostationary: b.Geostationary, Favorite: fav[strings.ToUpper(b.Name)]}
+		for _, t := range b.Transponders {
+			item.Transponders = append(item.Transponders, SatTransponder{
+				Label: t.Label, Mode: t.Mode,
+				DownLo: t.DownLo, DownHi: t.DownHi, UpLo: t.UpLo, UpHi: t.UpHi,
+				Inverting: t.Inverting, CTCSS: t.CTCSS, Linear: t.Linear(),
+			})
+		}
+		if e, ok := satElement(store, b); ok {
+			item.HasElements = true
+			item.NORAD = e.NORAD
+			item.EpochAgeH = e.Age().Hours()
+			planned[strings.ToUpper(e.Name)] = true
+			if !strings.EqualFold(e.Name, b.Name) {
+				item.ElementName = e.Name
+			}
+		}
+		out = append(out, item)
+	}
+	// The rest of the element set, so nothing the station holds is invisible.
+	for _, n := range store.Names() {
+		if planned[strings.ToUpper(n)] {
+			continue
+		}
+		e, ok := store.Get(n)
+		if !ok {
+			continue
+		}
+		out = append(out, SatBird{
+			Name: e.Name, NORAD: e.NORAD, HasElements: true,
+			EpochAgeH: e.Age().Hours(), Favorite: fav[strings.ToUpper(e.Name)],
+		})
+	}
+	sort.Slice(out, func(i, j int) bool {
+		// Favourites first, then the birds we can actually use, then by name.
+		if out[i].Favorite != out[j].Favorite {
+			return out[i].Favorite
+		}
+		iu := len(out[i].Transponders) > 0 && out[i].HasElements
+		ju := len(out[j].Transponders) > 0 && out[j].HasElements
+		if iu != ju {
+			return iu
+		}
+		return out[i].Name < out[j].Name
+	})
+	return out
+}
+
+// GetSatelliteNames is the list behind the entry form's SAT_NAME box.
+//
+// One list, not two. It used to be a text box in Settings ▸ Lists that an
+// operator typed their birds into by hand, which then had nothing to do with
+// the satellites the tracker knew — the same station kept two lists of the same
+// satellites and they drifted apart. This is the followed set (or every
+// satellite with a frequency plan, when none is followed), plus anything the
+// old hand-kept list still holds so nobody's typing is thrown away.
+//
+// SAT_NAME is compared character for character by the awards and by LoTW, so
+// offering the spelling already used beats inventing a new one every pass.
+func (a *App) GetSatelliteNames() []string {
+	seen := map[string]bool{}
+	var out []string
+	add := func(n string) {
+		n = strings.ToUpper(strings.TrimSpace(n))
+		if n == "" || seen[n] {
+			return
+		}
+		seen[n] = true
+		out = append(out, n)
+	}
+	for _, n := range a.satNames(nil) {
+		add(n)
+	}
+	// The legacy list. Read, never written: the panel that edited it is gone,
+	// and what it holds is somebody's past work.
+	if a.settings != nil {
+		if raw, _ := a.settings.Get(a.ctx, keyListsSatellites); raw != "" {
+			var legacy []string
+			if json.Unmarshal([]byte(raw), &legacy) == nil {
+				for _, n := range legacy {
+					add(n)
+				}
+			}
+		}
+	}
+	sort.Strings(out)
+	return out
+}
+
+// satElement finds the elements for a bird, trying its aliases.
+//
+// The feed's name and the operator's name for the same satellite are routinely
+// different, and the element set is keyed by the feed's.
+func satElement(store *sat.Store, b sat.Bird) (sat.Element, bool) {
+	if e, ok := store.Get(b.Name); ok {
+		return e, true
+	}
+	for _, alias := range b.Aliases {
+		if e, ok := store.Get(alias); ok {
+			return e, true
+		}
+	}
+	// Last resort: scan, matching on letters and digits alone — that is how
+	// "RADFXSAT (FOX-1B)" and "AO-91" meet.
+	for _, n := range store.Names() {
+		if b.Matches(n) {
+			if e, ok := store.Get(n); ok {
+				return e, true
+			}
+		}
+	}
+	return sat.Element{}, false
+}
+
+// ── Tracking ────────────────────────────────────────────────────────────────
+
+// satNames resolves the names the UI asked for, falling back to the favourites
+// and then to every planned bird we hold elements for.
+func (a *App) satNames(names []string) []string {
+	if len(names) > 0 {
+		return names
+	}
+	set := a.satSettings()
+	if len(set.Favorites) > 0 {
+		return set.Favorites
+	}
+	var out []string
+	for _, b := range a.GetSatelliteBirds() {
+		if b.HasElements && len(b.Transponders) > 0 {
+			out = append(out, b.Name)
+		}
+	}
+	return out
+}
+
+// satResolve maps an operator-facing name onto the element set's own spelling.
+func (a *App) satResolve(name string) (string, bool) {
+	store, birds, _ := a.satParts()
+	if _, ok := store.Get(name); ok {
+		return name, true
+	}
+	if b, ok := birds.Find(name); ok {
+		if e, ok2 := satElement(store, b); ok2 {
+			return e.Name, true
+		}
+	}
+	return "", false
+}
+
+// GetSatellitePositions is where the given satellites are right now — the map's
+// question, and the rotator's.
+func (a *App) GetSatellitePositions(names []string) ([]sat.Position, error) {
+	obs, err := a.satObserver()
+	if err != nil {
+		return nil, err
+	}
+	store, _, _ := a.satParts()
+	now := time.Now().UTC()
+	var out []sat.Position
+	for _, n := range a.satNames(names) {
+		real, ok := a.satResolve(n)
+		if !ok {
+			continue
+		}
+		p, err := store.Track(real, obs, now)
+		if err != nil {
+			continue
+		}
+		p.Name = n // answer in the operator's vocabulary, not the feed's
+		out = append(out, p)
+	}
+	return out, nil
+}
+
+// GetSatelliteGroundTrack is the path a satellite draws over the ground, for
+// the map: one point a minute, forward from now.
+func (a *App) GetSatelliteGroundTrack(name string, minutes int) ([]sat.Position, error) {
+	if minutes <= 0 || minutes > 360 {
+		minutes = 120
+	}
+	obs, err := a.satObserver()
+	if err != nil {
+		return nil, err
+	}
+	real, ok := a.satResolve(name)
+	if !ok {
+		return nil, fmt.Errorf("%s is not in the element set", name)
+	}
+	store, _, _ := a.satParts()
+	now := time.Now().UTC()
+	out := make([]sat.Position, 0, minutes+1)
+	for i := 0; i <= minutes; i++ {
+		p, err := store.Track(real, obs, now.Add(time.Duration(i)*time.Minute))
+		if err != nil {
+			return nil, err
+		}
+		p.Name = name
+		out = append(out, p)
+	}
+	return out, nil
+}
+
+// GetSatellitePasses lists what is coming, in time order.
+func (a *App) GetSatellitePasses(names []string, hours int) ([]sat.Pass, error) {
+	obs, err := a.satObserver()
+	if err != nil {
+		return nil, err
+	}
+	set := a.satSettings()
+	if hours <= 0 {
+		hours = set.WindowH
+	}
+	if hours > 168 {
+		hours = 168
+	}
+	store, _, _ := a.satParts()
+	want := a.satNames(names)
+	// The store is keyed by the feed's names; remember which operator name each
+	// answer belongs to so the table reads the way the operator thinks.
+	real := make([]string, 0, len(want))
+	back := map[string]string{}
+	for _, n := range want {
+		r, ok := a.satResolve(n)
+		if !ok {
+			continue
+		}
+		real = append(real, r)
+		back[r] = n
+	}
+	passes := store.NextPasses(real, obs, time.Now().UTC(), time.Duration(hours)*time.Hour, set.MinEl)
+	for i := range passes {
+		if n, ok := back[passes[i].Name]; ok {
+			passes[i].Name = n
+		}
+	}
+	return passes, nil
+}
+
+// SatSkyPoint is one moment of a pass as the antenna sees it.
+type SatSkyPoint struct {
+	At time.Time `json:"at"`
+	Az float64   `json:"az"`
+	El float64   `json:"el"`
+}
+
+// GetSatelliteSkyTrack is the pass drawn as a path across the sky.
+//
+// The map answers "where is it over the earth"; this answers "where do I look",
+// which on a pass is the question that matters. An operator reading a polar
+// plot knows in one glance whether the bird comes over the top or clips the
+// horizon behind the house — something no amount of azimuth and elevation
+// digits conveys.
+func (a *App) GetSatelliteSkyTrack(name string, points int) ([]SatSkyPoint, error) {
+	if points < 8 || points > 400 {
+		points = 120
+	}
+	p, err := a.GetSatelliteNextPass(name)
+	if err != nil {
+		return nil, err
+	}
+	if !p.HasPass {
+		return nil, nil
+	}
+	obs, err := a.satObserver()
+	if err != nil {
+		return nil, err
+	}
+	real, ok := a.satResolve(name)
+	if !ok {
+		return nil, fmt.Errorf("%s is not in the element set", name)
+	}
+	store, _, _ := a.satParts()
+	span := p.LOS.Sub(p.AOS)
+	if span <= 0 {
+		return nil, nil
+	}
+	out := make([]SatSkyPoint, 0, points+1)
+	for i := 0; i <= points; i++ {
+		at := p.AOS.Add(time.Duration(float64(span) * float64(i) / float64(points)))
+		pos, err := store.Track(real, obs, at)
+		if err != nil {
+			return nil, err
+		}
+		// Below the horizon at the very ends, by a fraction of a degree, because
+		// the pass boundaries come from a coarser search than this sampling. A
+		// negative elevation would draw the track outside the horizon circle.
+		if pos.El < 0 {
+			pos.El = 0
+		}
+		out = append(out, SatSkyPoint{At: at.UTC(), Az: pos.Az, El: pos.El})
+	}
+	return out, nil
+}
+
+// GetSatelliteNextPass is the pass in progress, or the next one to come.
+//
+// The one question that decides whether an operator sits down at the radio, and
+// the reason a satellite tab is worth having at all: how long have I got, and
+// how high does it get.
+func (a *App) GetSatelliteNextPass(name string) (SatPassInfo, error) {
+	out := SatPassInfo{Name: name}
+	obs, err := a.satObserver()
+	if err != nil {
+		return out, err
+	}
+	real, ok := a.satResolve(name)
+	if !ok {
+		return out, fmt.Errorf("%s is not in the element set", name)
+	}
+	store, _, _ := a.satParts()
+	now := time.Now().UTC()
+	// From a little before now: a pass that started two minutes ago is the one
+	// the operator is in, and asking from this instant would skip it and report
+	// the next orbit instead — an hour and a half away, while the satellite is
+	// overhead.
+	from := now.Add(-30 * time.Minute)
+	// Elevation zero, not the operator's minimum. That threshold filters the
+	// table of passes worth waiting for; it must not hide the pass they are
+	// actually working.
+	passes, err := store.Passes(real, obs, from, now.Add(26*time.Hour), 0)
+	if err != nil {
+		return out, err
+	}
+	for _, p := range passes {
+		if p.LOS.Before(now) {
+			continue // already over
+		}
+		out.HasPass = true
+		out.InPass = !p.AOS.After(now)
+		out.AOS, out.LOS = p.AOS, p.LOS
+		out.AOSAz, out.LOSAz = p.AOSAz, p.LOSAz
+		out.MaxEl, out.MaxElAz, out.MaxElAt = p.MaxEl, p.MaxElAz, p.MaxElAt
+		out.Duration = p.Duration
+		return out, nil
+	}
+	return out, nil
+}
+
+// GetSatelliteTuning is the working answer: where to listen, where to transmit,
+// and where the bird is, for one satellite and one transponder.
+//
+// downHz is where the operator has tuned inside the passband, in NOMINAL terms
+// — 0 means the middle of it. Keeping the operator's frequency nominal, and
+// applying Doppler only on the way out to the radio, is what makes a linear
+// pass workable: the station being answered stays put on the dial while both
+// radios chase the shift.
+func (a *App) GetSatelliteTuning(name string, transponder int, downHz int64) (SatTuning, error) {
+	_, birds, _ := a.satParts()
+	b, ok := birds.Find(name)
+	if !ok {
+		return SatTuning{}, fmt.Errorf("%s has no frequency plan — add one in %s", name, sat.BirdsName)
+	}
+	if transponder < 0 || transponder >= len(b.Transponders) {
+		transponder = 0
+	}
+	if len(b.Transponders) == 0 {
+		return SatTuning{}, fmt.Errorf("%s has no transponder listed", b.Name)
+	}
+	t := b.Transponders[transponder]
+	if downHz <= 0 {
+		// While the tracker is running it owns the nominal frequency — it moves
+		// as the operator tunes. Reading the centre of the passband instead would
+		// show a frequency nobody is on the moment they hunt for a station.
+		downHz = a.satTrackedNominal(b.Name, transponder)
+	}
+	if downHz <= 0 {
+		downHz = t.Centre()
+	}
+	out := SatTuning{
+		Name:        b.Name,
+		Transponder: t.Label,
+		Mode:        t.Mode,
+		NominalDown: downHz,
+		NominalUp:   t.UplinkFor(downHz),
+		CTCSS:       t.CTCSS,
+		Inverting:   t.Inverting,
+		At:          time.Now().UTC(),
+	}
+	// Geostationary: it does not move, so there is nothing to correct and no
+	// look angle worth recomputing every second. QO-100 is simply pointed at
+	// once and left alone.
+	if b.Geostationary {
+		out.DownHz, out.UpHz = out.NominalDown, out.NominalUp
+		out.Visible = true
+		return out, nil
+	}
+
+	obs, err := a.satObserver()
+	if err != nil {
+		// No locator: the frequencies are still worth having, uncorrected.
+		out.DownHz, out.UpHz = out.NominalDown, out.NominalUp
+		return out, nil
+	}
+	real, ok := a.satResolve(name)
+	if !ok {
+		out.DownHz, out.UpHz = out.NominalDown, out.NominalUp
+		return out, fmt.Errorf("%s is not in the element set — refresh the elements", b.Name)
+	}
+	store, _, _ := a.satParts()
+	p, err := store.Track(real, obs, out.At)
+	if err != nil {
+		out.DownHz, out.UpHz = out.NominalDown, out.NominalUp
+		return out, err
+	}
+	sh := sat.Doppler(p, out.NominalDown, out.NominalUp)
+	out.DownHz, out.UpHz = sh.DownHz, sh.UpHz
+	out.Az, out.El, out.RangeKm, out.RangeRate = p.Az, p.El, p.RangeKm, p.RangeRate
+	out.Lat, out.Lon, out.AltKm, out.Footprint = p.Lat, p.Lon, p.AltKm, p.Footprint
+	out.Visible = p.Visible()
+	return out, nil
+}

app_sat_rotator.go

@@ -0,0 +1,140 @@
+package main
+
+// The two ways a satellite station points its antenna.
+//
+// Some operators drive their az/el rotator directly — EasyComm II, what
+// SatPC32 and Gpredict speak. Others already run PstRotator, which sits between
+// them and a dozen different controllers and handles az AND el; for those,
+// OpsLog talking to the controller itself would be a second program fighting
+// PstRotator over the same cable.
+//
+// So both, behind one small interface, chosen in Settings. Neither is more
+// "correct" than the other: the right one is whichever the station already has
+// working.
+
+import (
+	"fmt"
+	"math"
+	"strings"
+	"sync"
+
+	"hamlog/internal/rotator/easycomm"
+	"hamlog/internal/rotator/pst"
+)
+
+// satRotator is what the tracker needs of an antenna: point it, ask where it
+// is, and let go of it at the end of the pass.
+type satRotator interface {
+	Point(az, el float64) error
+	// Heading reports where the antenna is. live is false when the answer is
+	// the last commanded position rather than a reading — a stuck rotator must
+	// not be able to hide behind an order it never carried out.
+	Heading() (az, el float64, live bool, err error)
+	Close()
+}
+
+// The rotator kinds, as stored.
+const (
+	satRotEasycomm = "easycomm"
+	satRotPst      = "pstrotator"
+)
+
+// newSatRotator builds the configured controller.
+func newSatRotator(s SatSettings) (satRotator, error) {
+	switch s.RotType {
+	case satRotPst:
+		if strings.TrimSpace(s.RotHost) == "" && s.RotPort <= 0 {
+			return nil, fmt.Errorf("no address for PstRotator")
+		}
+		return &pstSatRotator{c: pst.New(s.RotHost, s.RotPstPort), maxAz: s.RotMaxAz}, nil
+	default:
+		if s.RotTransport == "tcp" {
+			if strings.TrimSpace(s.RotHost) == "" {
+				return nil, fmt.Errorf("no address for the rotator")
+			}
+			return easycomm.New(s.RotHost, s.RotPort, s.RotMaxAz), nil
+		}
+		if strings.TrimSpace(s.RotCOM) == "" {
+			return nil, fmt.Errorf("no COM port for the rotator")
+		}
+		return easycomm.NewSerial(s.RotCOM, s.RotBaud, s.RotMaxAz), nil
+	}
+}
+
+// pstSatRotator points the antenna through PstRotator.
+//
+// PstRotator takes whole degrees and does its own overlap handling for a 450°
+// rotator — it knows which controller is on the other end, and OpsLog does not.
+// So the azimuth is sent plainly, and the 450° logic that EasyComm needs is
+// deliberately NOT applied here: two programs each deciding to go the long way
+// round is how an antenna ends up unwinding in the middle of a pass.
+type pstSatRotator struct {
+	c     *pst.Client
+	maxAz int
+
+	mu sync.Mutex
+	// lastAz/lastEl are what was commanded, for the display when PstRotator
+	// does not answer a position query — which is the usual case for the many
+	// setups whose controller reports nothing back to it either.
+	lastAz, lastEl float64
+	commanded      bool
+	azSilent       bool // the azimuth query went unanswered; stop asking
+	elSilent       bool // likewise for elevation, and far more common
+}
+
+func (p *pstSatRotator) Point(az, el float64) error {
+	a := math.Mod(az, 360)
+	if a < 0 {
+		a += 360
+	}
+	if el < 0 {
+		el = 0
+	}
+	if el > 180 {
+		el = 180
+	}
+	if err := p.c.GoTo(int(math.Round(a)), true, int(math.Round(el))); err != nil {
+		return err
+	}
+	p.mu.Lock()
+	p.lastAz, p.lastEl, p.commanded = a, el, true
+	p.mu.Unlock()
+	return nil
+}
+
+func (p *pstSatRotator) Heading() (float64, float64, bool, error) {
+	p.mu.Lock()
+	azSilent, elSilent, la, le, commanded := p.azSilent, p.elSilent, p.lastAz, p.lastEl, p.commanded
+	p.mu.Unlock()
+
+	az, el, live := la, le, false
+	if !azSilent {
+		if v, _, err := p.c.Heading(); err == nil {
+			az, live = float64(v), true
+		} else {
+			// One silence is enough. Each query binds a socket and waits a second
+			// and a half; repeating that every few seconds for a setup that will
+			// never answer is a stall per poll for nothing.
+			p.mu.Lock()
+			p.azSilent = true
+			p.mu.Unlock()
+		}
+	}
+	if !elSilent {
+		if v, _, err := p.c.Elevation(); err == nil {
+			el = float64(v)
+		} else {
+			p.mu.Lock()
+			p.elSilent = true
+			p.mu.Unlock()
+		}
+	}
+	if !live && !commanded {
+		return 0, 0, false, fmt.Errorf("PstRotator does not report the antenna position")
+	}
+	return az, el, live, nil
+}
+
+// Close: nothing to release. Every PstRotator command is one datagram, and the
+// socket lives for the length of a single write.
+func (p *pstSatRotator) Close() {}

app_sat_track.go

@@ -0,0 +1,622 @@
+package main
+
+// Doppler tracking — walking the radio through a pass.
+//
+// The hard part of satellite tuning is not the arithmetic, it is deciding who
+// owns the dial. A tracker that simply forces both frequencies fights the
+// operator every time they turn the knob to follow a station across a linear
+// transponder, and one that never touches the receiver leaves them chasing a
+// signal that slides 9 kHz across a 70 cm pass.
+//
+// So: the operator owns the receiver, and the tracker follows them. Every tick
+// it asks the radio where the receiver actually is. If that is where the tracker
+// put it, nothing has changed and it keeps correcting from the same NOMINAL
+// frequency. If it has moved further than a dial-turn's tolerance, the operator
+// has chosen a new station: the tracker converts what they landed on back into a
+// nominal frequency and carries on from there. The transmitter is derived from
+// the nominal and never argued with — which is exactly the division of labour on
+// a linear bird, where the operator listens and the radio does the sums.
+
+import (
+	"fmt"
+	"math"
+	"strings"
+	"sync"
+	"time"
+
+	wruntime "github.com/wailsapp/wails/v2/pkg/runtime"
+
+	"hamlog/internal/applog"
+	"hamlog/internal/cat"
+	"hamlog/internal/qso"
+	"hamlog/internal/sat"
+)
+
+// satTickEvery is how often the radio is re-pointed. One second: at the middle
+// of a 70 cm pass the downlink moves about 60 Hz a second, which is audible on
+// SSB within two or three of them and inaudible within one.
+const satTickEvery = time.Second
+
+// satDialTolerance is how far the receiver may differ from where the tracker put
+// it before that difference is read as the operator tuning.
+//
+// 200 Hz is comfortably more than the rounding and the round-trip lag between
+// setting a frequency and reading it back, and comfortably less than the
+// smallest deliberate move anybody makes hunting a station on a transponder.
+const satDialTolerance = 200
+
+// satLightKmS is the speed of light in km/s, for turning a heard frequency back
+// into a nominal one. The same constant internal/sat corrects with.
+const satLightKmS = 299792.458
+
+type satTracker struct {
+	name string
+	tp   int
+
+	mu sync.Mutex
+	// nominalDown is where the operator is, expressed as if the satellite were
+	// standing still. Everything else is derived from it, and it is the only
+	// thing a dial movement changes.
+	nominalDown int64
+	lastDown    int64 // what was last sent to the radio
+	lastUp      int64
+	status      SatTrackStatus
+	fails       int
+
+	// The az/el rotator, built once at the start of the pass so a serial port is
+	// opened once rather than on every command. nil when none is configured.
+	rot       satRotator
+	rotStep   float64
+	rotMinE   float64
+	rotPark   bool
+	rotAz     float64 // last commanded, so a step smaller than the beamwidth costs nothing
+	rotEl     float64
+	rotSent   bool
+	rotReadAt time.Time // when the controller was last asked where it is
+
+	stop chan struct{}
+	done chan struct{}
+}
+
+// SatTrackStatus is what the tracker is doing, for the panel.
+type SatTrackStatus struct {
+	On          bool    `json:"on"`
+	Name        string  `json:"name"`
+	Transponder string  `json:"transponder"`
+	Mode        string  `json:"mode"`
+	NominalDown int64   `json:"nominal_down"`
+	NominalUp   int64   `json:"nominal_up"`
+	DownHz      int64   `json:"down_hz"`
+	UpHz        int64   `json:"up_hz"`
+	Az          float64 `json:"az"`
+	El          float64 `json:"el"`
+	Visible     bool    `json:"visible"`
+	Radio       string  `json:"radio"` // what the rig is doing: "sat", "downlink-only", ""
+	Error       string  `json:"error"`
+
+	// Where the antenna is. RotLive distinguishes a reading from the controller
+	// from the last position it was TOLD to go to — a stuck rotator must not be
+	// able to hide behind a command it never carried out.
+	RotOn   bool    `json:"rot_on"`
+	RotAz   float64 `json:"rot_az"`
+	RotEl   float64 `json:"rot_el"`
+	RotLive bool    `json:"rot_live"`
+}
+
+// StartSatelliteTracking arms the radio and starts following the satellite.
+func (a *App) StartSatelliteTracking(name string, transponder int) error {
+	if a.cat == nil {
+		return fmt.Errorf("CAT is not running")
+	}
+	_, birds, _ := a.satParts()
+	b, ok := birds.Find(name)
+	if !ok || len(b.Transponders) == 0 {
+		return fmt.Errorf("%s has no frequency plan to tune to", name)
+	}
+	if transponder < 0 || transponder >= len(b.Transponders) {
+		transponder = 0
+	}
+	a.StopSatelliteTracking()
+
+	t := &satTracker{
+		name:        b.Name,
+		tp:          transponder,
+		nominalDown: b.Transponders[transponder].Centre(),
+		stop:        make(chan struct{}),
+		done:        make(chan struct{}),
+	}
+	t.status = SatTrackStatus{On: true, Name: b.Name, Transponder: b.Transponders[transponder].Label, Mode: b.Transponders[transponder].Mode}
+
+	// The rotator, if there is one. A geostationary bird is pointed at once and
+	// left alone, so it gets one command rather than a loop.
+	set := a.satSettings()
+	if set.RotOn {
+		r, rerr := newSatRotator(set)
+		if rerr != nil {
+			applog.Printf("sat: no rotator: %v", rerr)
+			t.status.Error = rerr.Error()
+		} else {
+			t.rot = r
+			t.rotStep, t.rotMinE, t.rotPark = float64(set.RotStep), float64(set.RotMinEl), set.RotPark
+		}
+	}
+
+	// Arm the radio for the pair. A rig that cannot hold one is NOT a failure:
+	// it can still be tuned to the downlink, which is most of a receive-heavy
+	// pass, and saying so beats refusing to track at all.
+	radio := "downlink-only"
+	if a.cat.SatCapable() {
+		if err := a.cat.SatDo(func(st cat.SatTuner) error { return st.SetSatellite(true) }); err != nil {
+			applog.Printf("sat: could not arm satellite mode: %v", err)
+			t.status.Error = err.Error()
+		} else {
+			radio = "sat"
+		}
+	}
+	t.status.Radio = radio
+
+	a.satTrackMu.Lock()
+	a.satTrack = t
+	a.satTrackMu.Unlock()
+	go a.satTrackLoop(t)
+	applog.Printf("sat: tracking %s (%s), radio %s", t.name, t.status.Transponder, radio)
+	return nil
+}
+
+// StopSatelliteTracking hands the radio back.
+func (a *App) StopSatelliteTracking() {
+	a.satTrackMu.Lock()
+	t := a.satTrack
+	a.satTrack = nil
+	a.satTrackMu.Unlock()
+	if t == nil {
+		return
+	}
+	close(t.stop)
+	<-t.done
+	if a.cat != nil && a.cat.SatCapable() {
+		if err := a.cat.SatDo(func(st cat.SatTuner) error { return st.SetSatellite(false) }); err != nil {
+			applog.Printf("sat: could not disarm satellite mode: %v", err)
+		}
+	}
+	applog.Printf("sat: tracking stopped (%s)", t.name)
+	a.emitSatTrack(SatTrackStatus{})
+}
+
+// TestSatelliteRotator opens the configured controller and asks it where it is.
+//
+// The one question worth asking before a pass: is this port the rotator, and
+// does it talk back? A controller that accepts commands silently is a normal,
+// working one — so that answer is a success with a caveat, not a failure.
+func (a *App) TestSatelliteRotator() (string, error) {
+	set := a.satSettings()
+	if !set.RotOn {
+		return "", fmt.Errorf("the satellite rotator is switched off")
+	}
+	c, err := newSatRotator(set)
+	if err != nil {
+		return "", err
+	}
+	defer c.Close()
+	az, el, live, err := c.Heading()
+	if err != nil {
+		return "", err
+	}
+	if !live {
+		return "The controller accepted the command but does not report its position — normal for many controllers. It will still be driven.", nil
+	}
+	return fmt.Sprintf("The rotator is at %.1f° azimuth, %.1f° elevation.", az, el), nil
+}
+
+// GetSatelliteTracking reports what the tracker is doing.
+func (a *App) GetSatelliteTracking() SatTrackStatus {
+	a.satTrackMu.Lock()
+	t := a.satTrack
+	a.satTrackMu.Unlock()
+	if t == nil {
+		return SatTrackStatus{}
+	}
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	return t.status
+}
+
+// satTrackedNominal is the nominal downlink the tracker is currently working
+// from, or 0 when it is not tracking this satellite and transponder.
+func (a *App) satTrackedNominal(name string, transponder int) int64 {
+	a.satTrackMu.Lock()
+	t := a.satTrack
+	a.satTrackMu.Unlock()
+	if t == nil || t.tp != transponder || !strings.EqualFold(t.name, name) {
+		return 0
+	}
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	return t.nominalDown
+}
+
+func (a *App) emitSatTrack(s SatTrackStatus) {
+	if a.ctx != nil {
+		wruntime.EventsEmit(a.ctx, "sat:track", s)
+	}
+}
+
+func (a *App) satTrackLoop(t *satTracker) {
+	defer close(t.done)
+	defer t.releaseRotator()
+	tick := time.NewTicker(satTickEvery)
+	defer tick.Stop()
+	for {
+		a.satTrackStep(t)
+		select {
+		case <-t.stop:
+			return
+		case <-tick.C:
+		}
+	}
+}
+
+// satTrackStep is one pass of the loop: read the dial, work out the pair, send
+// what changed.
+func (a *App) satTrackStep(t *satTracker) {
+	_, birds, _ := a.satParts()
+	b, ok := birds.Find(t.name)
+	if !ok || t.tp >= len(b.Transponders) {
+		return
+	}
+	tp := b.Transponders[t.tp]
+
+	t.mu.Lock()
+	nominal := t.nominalDown
+	lastDown, lastUp := t.lastDown, t.lastUp
+	t.mu.Unlock()
+
+	// Where the satellite is, and how fast it is running away. A geostationary
+	// bird is neither: its range rate is zero, so the zero position below gives
+	// a zero shift without a special case, and asking for a look angle we do not
+	// need would only fail on a station with no locator.
+	var pos sat.Position
+	visible := true
+	if !b.Geostationary {
+		obs, err := a.satObserver()
+		if err != nil {
+			t.setError(err.Error())
+			return
+		}
+		real, ok := a.satResolve(t.name)
+		if !ok {
+			t.setError(fmt.Sprintf("%s is not in the element set", t.name))
+			return
+		}
+		store, _, _ := a.satParts()
+		p, err := store.Track(real, obs, time.Now().UTC())
+		if err != nil {
+			t.setError(err.Error())
+			return
+		}
+		pos = p
+		visible = p.Visible()
+	}
+	// The fractional shift, positive when the satellite is approaching. Only the
+	// dial arithmetic below needs it as a number; the pair itself comes from
+	// sat.Doppler, so there is exactly one place where the sign of a correction
+	// is decided.
+	factor := -pos.RangeRate / satLightKmS
+
+	// Where did the operator leave the receiver? If it is not where the tracker
+	// put it, they have moved to another station and that is the new nominal.
+	if lastDown > 0 && tp.Linear() {
+		if actual, err := a.satReceiveHz(); err == nil && actual > 0 {
+			if abs64i(actual-lastDown) > satDialTolerance {
+				moved := satNominalFromDial(actual, factor)
+				if moved >= tp.DownLo && moved <= tp.DownHi {
+					nominal = moved
+					t.mu.Lock()
+					t.nominalDown = moved
+					t.mu.Unlock()
+				}
+			}
+		}
+	}
+
+	nomUp := tp.UplinkFor(nominal)
+	sh := sat.Doppler(pos, nominal, nomUp)
+	down, up := sh.DownHz, sh.UpHz
+
+	t.mu.Lock()
+	t.status = SatTrackStatus{
+		On: true, Name: b.Name, Transponder: tp.Label, Mode: tp.Mode,
+		NominalDown: nominal, NominalUp: nomUp,
+		DownHz: down, UpHz: up,
+		Az: pos.Az, El: pos.El, Visible: visible,
+		Radio: t.status.Radio, Error: t.status.Error,
+	}
+	t.mu.Unlock()
+
+	t.pointRotator(pos, b.Geostationary)
+	t.readRotator()
+
+	t.mu.Lock()
+	st := t.status
+	t.mu.Unlock()
+	a.emitSatTrack(st)
+
+	// Only send what has actually moved. The step is the smallest change worth a
+	// command: on SSB a listener hears twenty hertz, on an FM channel nothing
+	// under a couple of hundred matters at all.
+	step := int64(20)
+	if strings.EqualFold(tp.Mode, "FM") {
+		step = 200
+	}
+	if abs64i(down-lastDown) < step && abs64i(up-lastUp) < step {
+		return
+	}
+
+	mode := tp.Mode
+	if lastDown != 0 {
+		mode = "" // set once, at the start of the pass — see satMode/satSetMode
+	}
+	err := a.satTune(down, up, mode, mode)
+	t.mu.Lock()
+	if err == nil {
+		t.lastDown, t.lastUp, t.fails = down, up, 0
+		t.status.Error = ""
+	} else {
+		t.fails++
+		t.status.Error = err.Error()
+	}
+	fails := t.fails
+	t.mu.Unlock()
+	if err != nil && (fails == 1 || fails%30 == 0) {
+		// Once, then once every half minute: a radio that has gone away must be
+		// visible in the log without filling it.
+		applog.Printf("sat: tuning %s failed (%d in a row): %v", t.name, fails, err)
+	}
+}
+
+// satNominalFromDial turns a frequency the operator tuned to into the nominal
+// one it corresponds to.
+//
+// The inverse of the downlink correction: what comes out of the transponder at
+// nominal arrives at heard = nominal × (1 + f). Doing this is what lets the
+// operator hunt across a linear passband without the tracker dragging them back
+// — where they land becomes the new truth, and the uplink follows it.
+func satNominalFromDial(heardHz int64, factor float64) int64 {
+	if heardHz <= 0 || factor <= -1 {
+		return heardHz
+	}
+	return int64(math.Round(float64(heardHz) / (1 + factor)))
+}
+
+// pointRotator keeps the antenna on the satellite.
+//
+// Below the configured elevation the rotator is left alone. Not because the
+// numbers stop being right — they are right all the way round the orbit — but
+// because a rotator that chases a satellite through the far side of the earth
+// spends the whole night turning, and a mast is a mechanical thing with a
+// finite number of turns in it.
+func (t *satTracker) pointRotator(pos sat.Position, geostationary bool) {
+	if t.rot == nil {
+		return
+	}
+	if !geostationary && pos.El < t.rotMinE {
+		return
+	}
+	// A step below the beamwidth is a command for nothing. Compared against what
+	// was last COMMANDED rather than where the rotator says it is: a rotator in
+	// motion is always somewhere between the two, and comparing against that
+	// would order a fresh move on every tick of a slew.
+	az, el := pos.Az, pos.El
+	if geostationary {
+		// A satellite that does not move needs pointing once. Its own az/el were
+		// not computed (there is nothing to compute), so leave the rotator where
+		// the operator put it.
+		if t.rotSent {
+			return
+		}
+	}
+	if t.rotSent && math.Abs(az-t.rotAz) < t.rotStep && math.Abs(el-t.rotEl) < t.rotStep {
+		return
+	}
+	if err := t.rot.Point(az, el); err != nil {
+		t.setError(err.Error())
+		return
+	}
+	t.rotAz, t.rotEl, t.rotSent = az, el, true
+}
+
+// readRotator asks the controller where it actually is, for the display.
+//
+// Separate from the pointing, and it runs on every tick rather than only when a
+// command was sent: watching the antenna crawl towards the bearing is how an
+// operator sees a rotator that is slow, stalled, or turning the wrong way. A
+// controller that does not answer says so once and is not asked again.
+func (t *satTracker) readRotator() {
+	if t.rot == nil {
+		return
+	}
+	// Not on every tick. A PstRotator query binds a socket and waits up to a
+	// second and a half for an answer, and a held serial port still costs a
+	// round trip; three seconds is often enough to watch an antenna slew and
+	// rare enough not to sit in the way of the tuning.
+	if time.Since(t.rotReadAt) < 3*time.Second {
+		return
+	}
+	t.rotReadAt = time.Now()
+	az, el, live, err := t.rot.Heading()
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	if err != nil {
+		t.status.RotOn = true
+		return
+	}
+	t.status.RotOn, t.status.RotAz, t.status.RotEl, t.status.RotLive = true, az, el, live
+}
+
+// releaseRotator hands the mast back at the end of a pass.
+func (t *satTracker) releaseRotator() {
+	if t.rot == nil {
+		return
+	}
+	if t.rotPark && t.rotSent {
+		// Elevation down first and azimuth to north: a dish or a pair of yagis
+		// left pointing at the sky is what a gale takes away.
+		if err := t.rot.Point(0, 0); err != nil {
+			applog.Printf("sat: could not park the rotator: %v", err)
+		}
+	}
+	t.rot.Close()
+	t.rot = nil
+}
+
+func (t *satTracker) setError(msg string) {
+	t.mu.Lock()
+	t.status.Error = msg
+	t.mu.Unlock()
+}
+
+// satTune sends the pair to whichever radio is connected.
+func (a *App) satTune(downHz, upHz int64, downMode, upMode string) error {
+	if a.cat == nil {
+		return fmt.Errorf("CAT is not running")
+	}
+	if a.cat.SatCapable() {
+		return a.cat.SatDo(func(st cat.SatTuner) error {
+			return st.TuneSatellite(downHz, upHz, downMode, upMode)
+		})
+	}
+	// No satellite pair on this backend: the downlink is what it can do, and the
+	// operator was told so when tracking started (Radio = "downlink-only").
+	if err := a.cat.SetFrequency(downHz); err != nil {
+		return err
+	}
+	if downMode != "" {
+		return a.cat.SetMode(downMode)
+	}
+	return nil
+}
+
+// satReceiveHz is where the receiver is, asked of the backend that knows.
+func (a *App) satReceiveHz() (int64, error) {
+	if a.cat == nil {
+		return 0, fmt.Errorf("CAT is not running")
+	}
+	if a.cat.SatCapable() {
+		var hz int64
+		err := a.cat.SatDo(func(st cat.SatTuner) error {
+			v, e := st.SatReceiveHz()
+			hz = v
+			return e
+		})
+		return hz, err
+	}
+	st := a.cat.State()
+	if st.RxFreqHz > 0 {
+		return st.RxFreqHz, nil
+	}
+	return st.FreqHz, nil
+}
+
+func abs64i(v int64) int64 {
+	if v < 0 {
+		return -v
+	}
+	return v
+}
+
+// ── What goes in the log ────────────────────────────────────────────────────
+
+// applySatellite stamps a QSO made through a satellite.
+//
+// The NOMINAL frequencies are logged, never the Doppler-corrected ones. Two
+// stations working each other through a transponder read different numbers off
+// their dials at the same instant — that is what Doppler means — and the only
+// figure they can both agree on, and the only one that means anything to
+// somebody reading the log later, is the transponder's own. LoTW matches on the
+// band, so nothing is lost; a log full of 435.847 231 would simply be a record
+// of where one radio happened to be.
+func (a *App) applySatellite(q *qso.QSO) {
+	a.satTrackMu.Lock()
+	t := a.satTrack
+	a.satTrackMu.Unlock()
+	if t == nil {
+		return
+	}
+	t.mu.Lock()
+	name, down, up := t.status.Name, t.status.NominalDown, t.status.NominalUp
+	az, el := t.status.Az, t.status.El
+	t.mu.Unlock()
+	if name == "" || down <= 0 {
+		return
+	}
+	// Nothing the operator filled in is overwritten. A QSO edited by hand, or
+	// imported, or logged from a second radio while the tracker happened to be
+	// running, keeps what it was given.
+	if strings.TrimSpace(q.PropMode) == "" {
+		q.PropMode = "SAT"
+	}
+	if q.PropMode != "SAT" {
+		return // they said it was something else — meteor scatter, EME
+	}
+	if strings.TrimSpace(q.SatName) == "" {
+		q.SatName = name
+	}
+	if strings.TrimSpace(q.SatMode) == "" {
+		q.SatMode = satModeLetters(up, down)
+	}
+	// The transmit frequency is the uplink and the receive frequency the
+	// downlink — which is the one place a satellite QSO differs from every other
+	// kind, and the reason FREQ alone cannot describe one.
+	if up > 0 {
+		q.FreqHz = &up
+		if b := bandForHz(up); b != "" {
+			q.Band = b
+		}
+	}
+	d := down
+	q.FreqRXHz = &d
+	if b := bandForHz(down); b != "" {
+		q.BandRX = b
+	}
+	if q.AntAz == nil && (az != 0 || el != 0) {
+		v := az
+		q.AntAz = &v
+	}
+	if q.AntEl == nil && el != 0 {
+		v := el
+		q.AntEl = &v
+	}
+}
+
+// satModeLetters is the ADIF SAT_MODE: the uplink band's letter, then the
+// downlink's — "U/V" for 435 up, 145 down. The letters are AMSAT's, and they
+// are what every satellite operator writes on a QSL card.
+func satModeLetters(upHz, downHz int64) string {
+	u, d := satBandLetter(upHz), satBandLetter(downHz)
+	if u == "" || d == "" {
+		return ""
+	}
+	return u + "/" + d
+}
+
+func satBandLetter(hz int64) string {
+	switch {
+	case hz <= 0:
+		return ""
+	case hz < 30_000_000:
+		return "A" // 10 m — mode A's downlink
+	case hz < 148_000_000:
+		return "V" // 2 m
+	case hz < 450_000_000:
+		return "U" // 70 cm
+	case hz < 1_300_000_000:
+		return "L" // 23 cm
+	case hz < 2_500_000_000:
+		return "S" // 13 cm
+	case hz < 6_000_000_000:
+		return "C" // 6 cm
+	case hz < 11_000_000_000:
+		return "X" // 3 cm
+	}
+	return "K" // 24 GHz and above
+}

app_sat_track_test.go

@@ -0,0 +1,47 @@
+package main
+
+import (
+	"testing"
+
+	"hamlog/internal/sat"
+)
+
+// The dial arithmetic has to be the exact inverse of the correction, or every
+// touch of the knob would nudge the nominal frequency a little further off and
+// the uplink would walk across the passband over a pass.
+func TestSatNominalFromDialRoundTrip(t *testing.T) {
+	// A range of range rates: hard approach, drifting, hard recession. ±8 km/s
+	// covers a low orbit overhead.
+	for _, rate := range []float64{-8, -3.2, -0.4, 0, 0.4, 3.2, 8} {
+		p := sat.Position{RangeRate: rate}
+		for _, nominal := range []int64{29_450_000, 145_900_000, 435_850_000, 10_489_675_000} {
+			sh := sat.Doppler(p, nominal, 0)
+			factor := -rate / satLightKmS
+			got := satNominalFromDial(sh.DownHz, factor)
+			if diff := got - nominal; diff > 1 || diff < -1 {
+				t.Errorf("rate %.1f km/s, %d Hz: heard %d, came back as %d (%+d)",
+					rate, nominal, sh.DownHz, got, diff)
+			}
+		}
+	}
+}
+
+// SAT_MODE is what goes on a QSL card, and the letters are the uplink's then
+// the downlink's — the order operators write and the order ADIF wants.
+func TestSatModeLetters(t *testing.T) {
+	for _, tc := range []struct {
+		name     string
+		up, down int64
+		want     string
+	}{
+		{"FO-29: 2 m up, 70 cm down", 145_950_000, 435_850_000, "V/U"},
+		{"AO-91: 70 cm up, 2 m down", 435_250_000, 145_960_000, "U/V"},
+		{"AO-7 mode A: 2 m up, 10 m down", 145_900_000, 29_450_000, "V/A"},
+		{"QO-100: 13 cm up, 3 cm down", 2_400_175_000, 10_489_675_000, "S/X"},
+		{"receive only", 0, 145_800_000, ""},
+	} {
+		if got := satModeLetters(tc.up, tc.down); got != tc.want {
+			t.Errorf("%s: got %q, wanted %q", tc.name, got, tc.want)
+		}
+	}
+}

app_udp_focus.go

@@ -0,0 +1,108 @@
+package main
+
+// Which decoder the entry field belongs to, when several are running.
+//
+// A station running WSJT-X, JTDX and MSHV at once has three programs sending
+// Status once a second each. Click a call in one of them and only that one has
+// a DX Call; the other two are idle and say so. Both statements are true, and
+// both arrive — so the entry field is filled by the program the operator is
+// working and emptied by the two that are not, once a second, and the map
+// zooms in and out with it.
+//
+// So the first program to announce a station is FOCUSED, and until it lets go
+// the others cannot touch the entry field. That is the operator's own answer:
+// "if I call on one program, keep that one's UDP for the duration of the QSO".
+//
+// Focus is released when the focused program clears its own DX Call, when it
+// stops sending altogether (it was closed), or when a QSO is logged — never on
+// a timer that could hand the field to another program mid-over.
+
+import (
+	"strings"
+	"sync"
+	"time"
+
+	"hamlog/internal/applog"
+)
+
+// udpFocusIdle is how long a focused program may go silent before the focus is
+// given up.
+//
+// Generous on purpose: a decoder sends Status every second, so anything above a
+// few seconds means it has been closed or has lost its network. Thirty is long
+// enough to survive a machine that stutters and short enough that a program
+// closed mid-QSO does not lock the entry field for the rest of the evening.
+const udpFocusIdle = 30 * time.Second
+
+type udpFocus struct {
+	mu   sync.Mutex
+	inst string
+	at   time.Time
+	// told marks that the log already carries the line explaining why another
+	// program's callsign is being ignored. Once per focus, not once a second.
+	told map[string]bool
+}
+
+// claim records that inst is announcing a station, and reports whether inst is
+// the program the entry field currently belongs to.
+func (f *udpFocus) claim(inst string) bool {
+	if inst == "" {
+		return true // a sender with no id: nothing to arbitrate between
+	}
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	if f.inst == "" || f.inst == inst || time.Since(f.at) > udpFocusIdle {
+		if f.inst != inst {
+			applog.Printf("udp: the entry field follows %s while it is calling", inst)
+			f.told = nil
+		}
+		f.inst, f.at = inst, time.Now()
+		return true
+	}
+	return false
+}
+
+// holds reports whether inst may act on the entry field, without claiming it.
+// Used for the clear: a program that is not focused clearing its own DX Call
+// says nothing about the QSO in progress somewhere else.
+func (f *udpFocus) holds(inst string) bool {
+	if inst == "" {
+		return true
+	}
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	if f.inst == "" || time.Since(f.at) > udpFocusIdle {
+		return true
+	}
+	return f.inst == inst
+}
+
+// release gives the field up — the focused program cleared its call, or a QSO
+// was logged and the next station may come from anywhere.
+func (f *udpFocus) release(why string) {
+	f.mu.Lock()
+	had := f.inst
+	f.inst, f.at, f.told = "", time.Time{}, nil
+	f.mu.Unlock()
+	if had != "" {
+		applog.Printf("udp: the entry field is free again (%s let go: %s)", had, why)
+	}
+}
+
+// noteIgnored logs, once per focused program, that another one's callsign was
+// not applied. Without it the behaviour is invisible: an operator whose second
+// decoder "stopped filling the call" has nothing to read.
+func (f *udpFocus) noteIgnored(inst, call string) {
+	f.mu.Lock()
+	if f.told == nil {
+		f.told = map[string]bool{}
+	}
+	first := !f.told[inst]
+	f.told[inst] = true
+	holder := f.inst
+	f.mu.Unlock()
+	if first {
+		applog.Printf("udp: [%s] %q not applied — %s has the entry field while it is calling",
+			inst, strings.ToUpper(call), holder)
+	}
+}

app_udp_focus_test.go

@@ -0,0 +1,76 @@
+package main
+
+import (
+	"testing"
+	"time"
+)
+
+// The reported failure, in order: MSHV is called on, WSJT-X and JTDX sit idle
+// beside it, and every one of their Status packets used to empty the entry
+// field that MSHV had just filled — once a second, with the map zooming in and
+// out to match.
+func TestUdpFocusKeepsTheFieldWithTheCallingProgram(t *testing.T) {
+	var f udpFocus
+
+	if !f.claim("MSHV") {
+		t.Fatal("the first program to announce a station must take the field")
+	}
+	// The other two, announcing stations of their own, are refused.
+	if f.claim("WSJT-X") {
+		t.Error("WSJT-X took the field while MSHV was calling")
+	}
+	if f.claim("JTDX") {
+		t.Error("JTDX took the field while MSHV was calling")
+	}
+	// And their clears do not empty it — this is the half that caused the flicker.
+	if f.holds("WSJT-X") {
+		t.Error("an idle WSJT-X was allowed to clear MSHV's callsign")
+	}
+	if !f.holds("MSHV") {
+		t.Error("MSHV lost the right to clear its own callsign")
+	}
+	// MSHV moving to the next station keeps the field.
+	if !f.claim("MSHV") {
+		t.Error("the focused program must keep the field across stations")
+	}
+}
+
+// Letting go, three ways.
+func TestUdpFocusRelease(t *testing.T) {
+	var f udpFocus
+
+	// The focused program clears its own call.
+	f.claim("MSHV")
+	f.release("DX Call cleared")
+	if !f.claim("WSJT-X") {
+		t.Error("after a release the next program should be able to take the field")
+	}
+
+	// A QSO is logged.
+	f.release("QSO logged")
+	if !f.claim("JTDX") {
+		t.Error("logging a QSO must free the field for whichever program hears the next station")
+	}
+
+	// The focused program is closed and stops sending. Its hold lapses rather
+	// than locking the entry field for the rest of the evening.
+	f.mu.Lock()
+	f.at = time.Now().Add(-udpFocusIdle - time.Second)
+	f.mu.Unlock()
+	if !f.claim("MSHV") {
+		t.Error("a silent program must not hold the field for ever")
+	}
+}
+
+// A sender with no program id — an ADIF relay, a remote "set call" — is not
+// something to arbitrate between, and must never be locked out.
+func TestUdpFocusIgnoresUnnamedSenders(t *testing.T) {
+	var f udpFocus
+	f.claim("MSHV")
+	if !f.claim("") {
+		t.Error("an unnamed sender was refused the entry field")
+	}
+	if !f.holds("") {
+		t.Error("an unnamed sender was refused a clear")
+	}
+}

app_wsjt_highlight.go

@@ -7,6 +7,8 @@ package main
 // the spot grid, so the two windows can never disagree.
 
 import (
+	"fmt"
+	"strconv"
 	"strings"
 
 	"hamlog/internal/applog"
@@ -18,6 +20,13 @@ const (
 	keyWsjtHighlight  = "udp.wsjt.highlight"
 	keyWsjtFollowMode = "udp.wsjt.followmode" // spot clicks switch the decoder's mode
 	keyWsjtHLWorked   = "udp.wsjt.highlight_worked"
+	// One key per verdict, holding "#RRGGBB". Only the BACKGROUND is stored: the
+	// text colour is computed from it, so a chosen colour can never come out
+	// unreadable in somebody else's window.
+	keyWsjtColWatchlist = "udp.wsjt.colour.watchlist"
+	keyWsjtColNewDXCC   = "udp.wsjt.colour.new_dxcc"
+	keyWsjtColNewBand   = "udp.wsjt.colour.new_band"
+	keyWsjtColWorked    = "udp.wsjt.colour.worked"
 )
 
 // wsjtModes are the modes a Configure message can meaningfully ask for — the
@@ -53,8 +62,9 @@ func (a *App) ConfigureDecoderMode(mode string) {
 	a.udp.SendConfigureMode(mode)
 }
 
-// The palette. Fixed colours, not theme tokens — they are painted into another
+// The DEFAULT palette. Fixed colours, not theme tokens — they are painted into
-// application's window, which has no idea what theme OpsLog wears.
+// another application's window, which has no idea what theme OpsLog wears, and
+// the operator can change each of them (see WsjtHighlightColours).
 var (
 	hlWatchlist = udp.RGB{R: 244, G: 114, B: 182} // the watchlist pink
 	hlNewDXCC   = udp.RGB{R: 22, G: 130, B: 60}   // green
@@ -64,10 +74,82 @@ var (
 	// Worked already, on this band and in this mode. Grey on purpose, and the
 	// only DIM colour of the four: the others say "look at this", and this one
 	// says the opposite — it has to recede, not compete with them.
-	hlWorked   = udp.RGB{R: 75, G: 85, B: 99}
+	hlWorked = udp.RGB{R: 75, G: 85, B: 99}
-	hlWorkedFg = udp.RGB{R: 203, G: 213, B: 225}
 )
 
+// WsjtHighlightColours is the operator's palette, one background per verdict.
+type WsjtHighlightColours struct {
+	Watchlist string `json:"watchlist"`
+	NewDXCC   string `json:"new_dxcc"`
+	NewBand   string `json:"new_band"`
+	Worked    string `json:"worked"`
+}
+
+// GetWsjtHighlightColours returns the palette in "#RRGGBB", defaults included.
+func (a *App) GetWsjtHighlightColours() WsjtHighlightColours {
+	return WsjtHighlightColours{
+		Watchlist: a.settingOr(keyWsjtColWatchlist, hexOfRGB(hlWatchlist)),
+		NewDXCC:   a.settingOr(keyWsjtColNewDXCC, hexOfRGB(hlNewDXCC)),
+		NewBand:   a.settingOr(keyWsjtColNewBand, hexOfRGB(hlNewBand)),
+		Worked:    a.settingOr(keyWsjtColWorked, hexOfRGB(hlWorked)),
+	}
+}
+
+// SetWsjtHighlightColours stores the palette and repaints.
+//
+// The repaint is the whole point of clearing: the de-duplication remembers what
+// it has already told each decoder, so without this a callsign keeps yesterday's
+// colour until it changes verdict — and the operator, having just picked a new
+// one, sees nothing happen.
+func (a *App) SetWsjtHighlightColours(c WsjtHighlightColours) {
+	set := func(key, v, def string) {
+		if _, ok := parseHexRGB(v); !ok {
+			v = def
+		}
+		a.setSetting(key, strings.ToUpper(strings.TrimSpace(v)))
+	}
+	set(keyWsjtColWatchlist, c.Watchlist, hexOfRGB(hlWatchlist))
+	set(keyWsjtColNewDXCC, c.NewDXCC, hexOfRGB(hlNewDXCC))
+	set(keyWsjtColNewBand, c.NewBand, hexOfRGB(hlNewBand))
+	set(keyWsjtColWorked, c.Worked, hexOfRGB(hlWorked))
+	a.clearWsjtHighlights()
+	applog.Printf("wsjt highlight: palette changed — repainting")
+}
+
+// colourFor reads one verdict's background and picks a legible foreground.
+//
+// The text colour is DERIVED, never stored: an operator choosing a dark blue
+// would otherwise get black text on it in somebody else's window and conclude
+// the feature is broken. Rec. 601 luma, the same rule a browser's contrast
+// checker uses, with the threshold where black stops being readable.
+func (a *App) colourFor(key, def string) (udp.RGB, udp.RGB) {
+	bg, ok := parseHexRGB(a.settingOr(key, def))
+	if !ok {
+		bg, _ = parseHexRGB(def)
+	}
+	luma := (299*int(bg.R) + 587*int(bg.G) + 114*int(bg.B)) / 1000
+	if luma < 140 {
+		return bg, hlWhite
+	}
+	return bg, hlBlack
+}
+
+func hexOfRGB(c udp.RGB) string { return fmt.Sprintf("#%02X%02X%02X", c.R, c.G, c.B) }
+
+// parseHexRGB reads "#RRGGBB" (or "RRGGBB"). Anything else is refused rather
+// than half-read: a colour that silently becomes black is worse than a default.
+func parseHexRGB(s string) (udp.RGB, bool) {
+	s = strings.TrimPrefix(strings.TrimSpace(s), "#")
+	if len(s) != 6 {
+		return udp.RGB{}, false
+	}
+	v, err := strconv.ParseUint(s, 16, 32)
+	if err != nil {
+		return udp.RGB{}, false
+	}
+	return udp.RGB{R: byte(v >> 16), G: byte(v >> 8), B: byte(v)}, true
+}
+
 // GetWsjtHighlightWorked reports whether stations already worked on this band
 // and mode are greyed out as well.
 //
@@ -174,42 +256,52 @@ func (a *App) maybeHighlightDecode(instance, call, band, mode string) {
 // Anything else is "no colour", and the empty verdict doubles as the clear
 // signal in maybeHighlightDecode.
 func (a *App) decodeHighlightVerdict(call, band, mode string) (bg, fg *udp.RGB, verdict string) {
-	if a.watchlist != nil {
+	c := a.clusterStatusMaps()
+	// ALREADY WORKED HERE, whatever else the station is.
+	//
+	// Settled first because it is the one fact that cancels the others. A watch
+	// list entry worked on this band and mode stayed pink for the rest of the
+	// session — the list is a statement of intent, not of what is left to do, and
+	// the colour that means "call this one" was being shown for a station already
+	// in the log. From the operator's side there was no way to tell the two
+	// apart, which is the only thing the colours are for.
+	workedHere := false
+	if band != "" && mode != "" && c.workedCallSlots != nil {
+		m := strings.ToUpper(strings.TrimSpace(mode))
+		if c.normMode != nil {
+			m = c.normMode(m)
+		}
+		_, workedHere = c.workedCallSlots[strings.ToUpper(call)+"|"+strings.ToLower(band)+"|"+m]
+	}
+	if a.watchlist != nil && !workedHere {
 		if _, ok := a.watchlist.Match(call); ok {
-			c := hlWatchlist
+			bgc, fgc := a.colourFor(keyWsjtColWatchlist, hexOfRGB(hlWatchlist))
-			f := hlBlack
+			return &bgc, &fgc, "watchlist"
-			return &c, &f, "watchlist"
 		}
 	}
-	c := a.clusterStatusMaps()
 	if a.dxcc != nil {
 		if m, ok := a.dxcc.Lookup(call); ok && m.Entity != nil {
 			num := dxcc.EntityDXCC(m.Entity.Name)
 			ent := c.entities[num]
 			if ent == nil {
-				bgc, fgc := hlNewDXCC, hlWhite
+				bgc, fgc := a.colourFor(keyWsjtColNewDXCC, hexOfRGB(hlNewDXCC))
 				return &bgc, &fgc, "new-dxcc"
 			}
 			if band != "" {
 				if _, workedBand := ent.Bands[strings.ToLower(band)]; !workedBand {
-					bgc, fgc := hlNewBand, hlBlack
+					bgc, fgc := a.colourFor(keyWsjtColNewBand, hexOfRGB(hlNewBand))
 					return &bgc, &fgc, "new-band"
 				}
 			}
 		}
 	}
-	// Worked already, this exact callsign on this band in this mode — a dupe,
+	// A dupe, judged by the same ledger and the same digital-mode grouping the
-	// judged by the same ledger and the same digital-mode grouping the cluster
+	// cluster uses, so the two windows cannot disagree about what "worked" means.
-	// uses, so the two windows cannot disagree about what "worked" means.
+	// Its own option: on a well-filled log this matches most of a period, and a
-	if a.wsjtHLWorkedOn.Load() && band != "" && mode != "" {
+	// screen where nearly every line is coloured has stopped saying anything.
-		m := strings.ToUpper(strings.TrimSpace(mode))
+	if workedHere && a.wsjtHLWorkedOn.Load() {
-		if c.normMode != nil {
+		bgc, fgc := a.colourFor(keyWsjtColWorked, hexOfRGB(hlWorked))
-			m = c.normMode(m)
+		return &bgc, &fgc, "worked"
-		}
-		if _, ok := c.workedCallSlots[strings.ToUpper(call)+"|"+strings.ToLower(band)+"|"+m]; ok {
-			bgc, fgc := hlWorked, hlWorkedFg
-			return &bgc, &fgc, "worked"
-		}
 	}
 	return nil, nil, ""
 }

autocall.go

@@ -30,7 +30,12 @@ const (
 	keyAutoCallWatched  = "autocall.watched_attempts"
 	keyAutoCallMisses   = "autocall.misses"
 	keyAutoCallRounds   = "autocall.max_rounds"
-	keyAutoCallRestMin  = "autocall.rest_min"
+	// Periods, not minutes — see autocall.Settings.RestPeriods. A new key rather
+	// than a reinterpreted one: the old value was in minutes, and reading "2" as
+	// two periods or as two minutes are eight periods apart.
+	keyAutoCallRest     = "autocall.rest_periods"
+	keyAutoCallOnScreen = "autocall.on_screen_only"
+	keyAutoCallTrace    = "autocall.trace"
 )
 
 // AutoCallSettings is the panel's shape. Durations are in minutes because that
@@ -46,9 +51,28 @@ type AutoCallSettings struct {
 	// it, before it is given up on.
 	Misses int `json:"misses"`
 	// MaxRounds: how many series of calls one station gets in a session, and
-	// RestMin the pause between two of them.
+	// RestPeriods the pause between two of them, counted in the station's own
-	MaxRounds int `json:"max_rounds"`
+	// transmit periods.
-	RestMin   int `json:"rest_min"`
+	MaxRounds   int `json:"max_rounds"`
+	RestPeriods int `json:"rest_periods"`
+	// OnScreenOnly: call only what the decodes panel is showing, so its filters
+	// steer the transmitter as well as the eye.
+	OnScreenOnly bool `json:"on_screen_only"`
+	// Trace writes one line per period to the log: what was on the air, why
+	// each station was refused, and what was decided. For diagnosing "it is not
+	// calling anything" — and it is a line every fifteen seconds, so it is off
+	// unless asked for.
+	Trace bool `json:"trace"`
+}
+
+// intOr reads a stored integer, keeping a stored ZERO — which num() cannot,
+// since it treats zero as "nothing set".
+func intOr(v string, def int) int {
+	n, err := strconv.Atoi(strings.TrimSpace(v))
+	if err != nil || n < 0 {
+		return def
+	}
+	return n
 }
 
 func (a *App) GetAutoCallSettings() AutoCallSettings {
@@ -66,24 +90,36 @@ func (a *App) GetAutoCallSettings() AutoCallSettings {
 		Only:            strings.ToUpper(strings.TrimSpace(a.settingOr(keyAutoCallOnly, ""))),
 		Attempts:        num(keyAutoCallAttempts, d.Attempts),
 		WatchedAttempts: num(keyAutoCallWatched, d.WatchedAttempts),
-		Misses:          num(keyAutoCallMisses, d.Misses),
+		// On by default: the filters are in front of the operator, and a station
-		MaxRounds:       num(keyAutoCallRounds, d.MaxRounds),
+		// they have hidden is one they have said they do not want.
-		RestMin:         num(keyAutoCallRestMin, int(d.Rest/time.Minute)),
+		OnScreenOnly: a.settingOr(keyAutoCallOnScreen, "1") == "1",
+		Trace:        a.settingOr(keyAutoCallTrace, "0") == "1",
+		Misses:       num(keyAutoCallMisses, d.Misses),
+		MaxRounds:    num(keyAutoCallRounds, d.MaxRounds),
+		// Zero is meaningful (call it again next period), so it is read directly
+		// rather than through num(), which treats zero as "unset".
+		RestPeriods: intOr(a.settingOr(keyAutoCallRest, ""), d.RestPeriods),
 	}
 }
 
 func (a *App) SaveAutoCallSettings(s AutoCallSettings) error {
 	a.setSetting(keyAutoCallOn, map[bool]string{true: "1", false: "0"}[s.Enabled])
 	a.setSetting(keyAutoCallOnly, strings.ToUpper(strings.TrimSpace(s.Only)))
+	a.setSetting(keyAutoCallOnScreen, map[bool]string{true: "1", false: "0"}[s.OnScreenOnly])
+	a.setSetting(keyAutoCallTrace, map[bool]string{true: "1", false: "0"}[s.Trace])
 	for key, v := range map[string]int{
 		keyAutoCallAttempts: s.Attempts, keyAutoCallWatched: s.WatchedAttempts,
 		keyAutoCallMisses: s.Misses, keyAutoCallRounds: s.MaxRounds,
-		keyAutoCallRestMin: s.RestMin,
 	} {
 		if v > 0 {
 			a.setSetting(key, strconv.Itoa(v))
 		}
 	}
+	// Stored even at zero, unlike the counters above: no rest at all is a
+	// setting, not an empty field.
+	if s.RestPeriods >= 0 {
+		a.setSetting(keyAutoCallRest, strconv.Itoa(s.RestPeriods))
+	}
 	a.applyAutoCall()
 	applog.Printf("autocall: %v (only=%q, %d/%d calls, %d misses, %d rounds)",
 		s.Enabled, s.Only, s.Attempts, s.WatchedAttempts, s.Misses, s.MaxRounds)
@@ -121,10 +157,10 @@ func (a *App) autoCallEngine() *autocall.Engine {
 func (a *App) autoCallSettings() autocall.Settings {
 	s := a.GetAutoCallSettings()
 	return autocall.Settings{
-		Enabled: s.Enabled, Only: s.Only,
+		Enabled: s.Enabled, Only: s.Only, OnScreenOnly: s.OnScreenOnly,
 		Attempts: s.Attempts, WatchedAttempts: s.WatchedAttempts,
 		Misses: s.Misses, MaxRounds: s.MaxRounds,
-		Rest: time.Duration(s.RestMin) * time.Minute,
+		RestPeriods: s.RestPeriods,
 	}
 }
 
@@ -135,35 +171,63 @@ func (a *App) applyAutoCall() {
 	e := a.autoCallEngine()
 	s := a.autoCallSettings()
 	e.SetSettings(s)
+	if a.GetAutoCallSettings().Trace {
+		e.SetTrace(func(f string, args ...any) { applog.Printf("autocall: "+f, args...) })
+	} else {
+		e.SetTrace(nil)
+	}
 	if !s.Enabled {
 		e.Reset()
 		a.acMu.Lock()
 		a.acPeriod, a.acBuf = nil, nil
+		a.acJudged, a.acDirty = nil, nil
 		a.acMu.Unlock()
 	}
 	a.emitAutoCall()
 }
 
-// ResetAutoCall is the operator's restart after it gave up — and what Halt
+// ResetAutoCall is the operator's restart after the engine gave up on an
-// does, since halting means "not this station".
+// explicit target: it clears every verdict, including the grey list.
 func (a *App) ResetAutoCall() {
 	a.autoCallEngine().Reset()
 	a.emitAutoCall()
 }
 
+// HaltAutoCall is the Halt button while a call is in progress.
+//
+// It does NOT clear the engine's state, which is what Halt used to do: that
+// wiped the rests and the rounds along with everything else, so the station the
+// operator had just stopped was eligible again in the same second and the next
+// period called it straight back.
+func (a *App) HaltAutoCall() {
+	call := a.autoCallEngine().Halt()
+	if call != "" {
+		a.acMu.Lock()
+		a.acReason = fmt.Sprintf("%s stopped by the operator — set aside until auto-call is switched off and on", call)
+		a.acMu.Unlock()
+		applog.Printf("autocall: %s", a.acReason)
+	}
+	a.emitAutoCall()
+}
+
 // AutoCallStatus is what the toolbar shows.
 type AutoCallStatus struct {
 	Enabled bool `json:"enabled"`
 	// Only is the chase list, carried in the status so the field in the decodes
 	// toolbar and the one in Preferences are never two versions of the truth:
 	// whichever is typed into, both show it.
-	Only    string `json:"only"`
+	Only   string `json:"only"`
-	Target  string `json:"target"`
+	Target string `json:"target"`
+	// Waiting: what it would call if that station were not in a QSO.
+	Waiting string `json:"waiting"`
 	Calls   int    `json:"calls"`
 	Max     int    `json:"max"`
 	Misses  int    `json:"misses"`
 	MaxMiss int    `json:"max_miss"`
 	Stopped bool   `json:"stopped"`
+	// Greylisted counts the stations the operator has stopped this session, so
+	// the toolbar can say why a station on the air is never called.
+	Greylisted int `json:"greylisted"`
 	// Reason is the last decision in plain words. An auto-call that is doing
 	// nothing on purpose looks exactly like one that is broken.
 	Reason string `json:"reason"`
@@ -177,9 +241,10 @@ func (a *App) GetAutoCallStatus() AutoCallStatus {
 	set := a.GetAutoCallSettings()
 	return AutoCallStatus{
 		Enabled: set.Enabled, Only: set.Only,
-		Target: st.Target, Calls: st.Attempts, Max: st.Max,
+		Target: st.Target, Waiting: st.Waiting, Calls: st.Attempts, Max: st.Max,
 		Misses: st.Misses, MaxMiss: st.MaxMiss, Stopped: st.Stopped,
-		Reason: reason,
+		Greylisted: a.autoCallEngine().Greylisted(),
+		Reason:     reason,
 	}
 }
 
@@ -234,20 +299,60 @@ func (a *App) autoCallFeed(d autocall.Decode) {
 	a.acMu.Lock()
 	if a.acPeriod == nil {
 		a.acPeriod, a.acAt, a.acTR, a.acBuf = map[string]string{}, map[string]time.Time{}, map[string]int{}, map[string][]acDecode{}
+		a.acFed = map[string]time.Time{}
+		a.acJudged, a.acDirty = map[string]string{}, map[string]bool{}
 	}
 	if prev := a.acPeriod[inst]; prev != "" && prev != key {
 		prevAt, prevTR, buf := a.acAt[inst], a.acTR[inst], a.acBuf[inst]
+		// Only if something in it has NOT been judged. The buffer now outlives
+		// the judgement (see below), so without this the arrival of the next
+		// period would judge the previous one a second time on the very same
+		// decodes — and act on them, a slot late.
+		pending := a.acDirty[inst] || a.acJudged[inst] != prev
 		a.acPeriod[inst], a.acAt[inst], a.acTR[inst] = key, d.At, d.TRPeriod
 		a.acBuf[inst] = []acDecode{{d: d}}
+		a.acFed[inst], a.acDirty[inst] = time.Now(), true
 		a.acMu.Unlock()
-		a.autoCallJudge(inst, prev, prevAt, prevTR, buf)
+		// The previous period ends here whatever the sweeper was going to do: a
+		// decode stamped with the next slot is proof the old one is over.
+		if pending {
+			a.autoCallJudge(inst, prev, prevAt, prevTR, buf)
+		}
 		return
 	}
+	// APPENDED, never restarted. The buffer survives the period being judged,
+	// so a decode that arrives after the others belongs to the same period and
+	// is weighed against all of them.
+	//
+	// It used to be dropped and then judged on its own: the sweeper cleared the
+	// buffer, a straggler opened a "new" one under the same key, and the ladder
+	// was applied to whatever handful had come late — with the other thirty
+	// stations of that period nowhere in sight. A deep decode arriving a second
+	// after the burst is exactly the station worth calling.
 	a.acPeriod[inst], a.acAt[inst], a.acTR[inst] = key, d.At, d.TRPeriod
+	a.acFed[inst], a.acDirty[inst] = time.Now(), true
 	a.acBuf[inst] = append(a.acBuf[inst], acDecode{d: d})
 	a.acMu.Unlock()
 }
 
+// acQuiet is how long a period is left open after its LAST decode arrives.
+//
+// This is the whole timing budget of the feature. A decoder finishes a period
+// and sends its decodes about a second before the next slot opens, so the
+// answer has to be back before that boundary — a reply that arrives after it
+// makes the decoder start its call several seconds into the slot, which is what
+// an operator sees as "it calls late" and what a station on the other end sees
+// as a message it cannot decode.
+//
+// It was a whole slot plus four seconds, measured from the DECODE'S OWN
+// TIMESTAMP — the start of the period, not the moment it arrived — so the
+// answer left about four seconds INTO the next slot, every time.
+//
+// 800 ms: long enough for a busy period's decodes to arrive together (measured
+// in bursts of a few hundred milliseconds), short enough to answer inside the
+// same second they landed.
+const acQuiet = 800 * time.Millisecond
+
 // autoCallSweep closes the periods nothing has closed for us. Called on a timer.
 //
 // Per receiver, because with two decoders one may fall silent while the other
@@ -273,15 +378,21 @@ func (a *App) autoCallSweep() {
 		if tr <= 0 {
 			tr = 15
 		}
-		// One slot plus a margin: decodes for a period keep arriving for a
+		// Measured from when the last decode ARRIVED, not from the period it
-		// second or two after it ends, and judging early would count a station
+		// belongs to: a decode is stamped with the start of its own slot, so
-		// as missing that is about to be listed.
+		// waiting "a slot plus four seconds" from that stamp is waiting until
-		if time.Since(a.acAt[inst]) < time.Duration(tr)*time.Second+4*time.Second {
+		// the middle of the NEXT slot. See acQuiet.
+		if time.Since(a.acFed[inst]) < acQuiet {
+			continue
+		}
+		// Judged once per period, and again only when something new has come in
+		// for it. The period itself is kept open until a decode from the NEXT one
+		// arrives, so a straggler is judged with the whole period behind it.
+		if a.acJudged[inst] == key && !a.acDirty[inst] {
 			continue
 		}
 		ready = append(ready, due{inst, key, a.acAt[inst], tr, a.acBuf[inst]})
-		delete(a.acPeriod, inst)
+		a.acJudged[inst], a.acDirty[inst] = key, false
-		delete(a.acBuf, inst)
 	}
 	a.acMu.Unlock()
 	for _, d := range ready {
@@ -304,7 +415,9 @@ func (a *App) autoCallSilence() {
 		return
 	}
 	a.acMu.Lock()
-	quiet := a.acPeriod[inst] == "" && time.Since(a.acLastJudge) > 20*time.Second
+	// Nothing pending for this receiver, and nothing judged for a while: the
+	// band has gone quiet under it.
+	quiet := !a.acDirty[inst] && time.Since(a.acLastJudge) > 20*time.Second
 	tr := a.acTR[inst]
 	a.acMu.Unlock()
 	if !quiet {
@@ -351,18 +464,18 @@ func (a *App) autoCallJudge(inst, key string, at time.Time, tr int, buf []acDeco
 		status[st.Call+"|"+st.Band+"|"+st.Mode] = st
 	}
 
+	chase := a.autoCallChase()
 	cands := make([]autocall.Candidate, 0, len(uniq))
 	for _, dd := range uniq {
 		st := status[dd.d.Call+"|"+dd.d.Band+"|"+dd.d.Mode]
-		cands = append(cands, autocall.Candidate{
+		c := candidateOf(dd.d, st, chase)
-			Decode:  dd.d,
+		c.Watched = a.autoCallWatched(dd.d.Call)
-			Need:    autoCallNeedOf(st.Status),
+		c.Hidden = a.autoCallHidden(dd.d.Call)
-			Watched: a.autoCallWatched(dd.d.Call),
+		cands = append(cands, c)
-			Worked:  st.Status == "worked",
-		})
 	}
 
 	tx := a.autoCallTX()
+
 	act := a.autoCallEngine().OnPeriod(autocall.Period{
 		Instance: inst, Key: key, At: at, TRPeriod: tr, Decodes: cands, TX: tx,
 		MyCall: a.opCall,
@@ -370,6 +483,81 @@ func (a *App) autoCallJudge(inst, key string, at time.Time, tr int, buf []acDeco
 	a.autoCallDo(act)
 }
 
+// candidateOf turns one decode and the log's verdict on it into a candidate.
+//
+// Split out and kept pure because ONE line of it was wrong for weeks and
+// nothing could catch it: the entity's verdict was read as the station's.
+// chaseExtras is what the operator hunts BESIDES entities — the cluster's
+// orthogonal markers, from the same switches that decide whether the badges are
+// shown at all (Settings → DX Cluster). One answer for the eye and the
+// transmitter: a marker withdrawn from the screen is not one to call for.
+type chaseExtras struct{ pota, grid, pfx, county, state bool }
+
+func candidateOf(d autocall.Decode, st SpotStatus, ch chaseExtras) autocall.Candidate {
+	c := autocall.Candidate{
+		Decode: d,
+		// The ENTITY's verdict decides what is still needed…
+		Need: autoCallNeedOf(st.Status),
+		// …and THIS CALLSIGN on this band and mode decides whether calling it
+		// would be a duplicate.
+		//
+		// Status was used for both. "worked" there means the COUNTRY is in the
+		// log on this band and mode, so on a band where the operator has most of
+		// them, nearly every station on the air was refused as already worked —
+		// a trace of one evening shows twenty decodes out of twenty-one turned
+		// away that way, the watched DXpedition among them.
+		Worked: st.WorkedSlot,
+		// The need exists only because a QSL never came: worth chasing, and worth
+		// less than the same need never worked at all.
+		Unconfirmed: st.UnconfStatus,
+	}
+	// NOTHING LEFT ON THE ENTITY, AND STILL WORTH A CALL.
+	//
+	// A prefix, a square, a county, a state, a park: never worked, orthogonal to
+	// the entity's verdict, and exactly what the operator ticked in the chase
+	// settings. They ranked at nothing-needed, so auto-call sat through a
+	// never-worked WPX prefix calling CQ and did not answer it.
+	//
+	// Only when the entity has nothing to add — a new band that is ALSO a new
+	// prefix is a new band, and says so.
+	if c.Need == autocall.NeedNone {
+		switch {
+		case ch.pfx && st.NewPfx:
+			c.Need, c.Extra, c.Unconfirmed = autocall.NeedExtra, "prefix", st.UnconfPfx
+		case ch.county && st.NewCounty:
+			c.Need, c.Extra, c.Unconfirmed = autocall.NeedExtra, "county", st.UnconfCty
+		case ch.state && st.NewState:
+			c.Need, c.Extra, c.Unconfirmed = autocall.NeedExtra, "state", st.UnconfState
+		case ch.grid && st.NewGrid:
+			c.Need, c.Extra, c.Unconfirmed = autocall.NeedExtra, "square", st.GridState == "unconf"
+		case ch.pota && st.NewPOTA:
+			c.Need, c.Extra = autocall.NeedExtra, "park"
+		}
+	}
+	return c
+}
+
+// autoCallChase reads the chase switches the cluster and the decode list use.
+//
+// Read once per period rather than per decode: they are settings-store reads,
+// and the period loop runs over every station on the band.
+func (a *App) autoCallChase() chaseExtras {
+	on := func(key string) bool {
+		if a.settings == nil {
+			return true
+		}
+		v, _ := a.settings.Get(a.ctx, "ui.opslog."+key)
+		return v != "0" // unset means on, as it does on the screen
+	}
+	return chaseExtras{
+		pota:   on("chasePota"),
+		grid:   on("chaseGrids"),
+		pfx:    on("chasePfx"),
+		county: on("chaseCounty"),
+		state:  on("chaseState"),
+	}
+}
+
 // autoCallDo carries out a decision and records it.
 func (a *App) autoCallDo(act autocall.Action) {
 	if act.Reason != "" {
@@ -385,9 +573,9 @@ func (a *App) autoCallDo(act autocall.Action) {
 			applog.Printf("autocall: the call to %s could not be sent: %v", d.Call, err)
 		}
 	case autocall.DoHalt:
-		// autoTxOnly=false: stop now. The whole point of a brake is that it does
+		// Soft: let the over finish, then stop transmitting. Hard: stop now.
-		// not wait for the over in progress to finish.
+		// The engine decides — see Action.Soft.
-		if err := a.HaltDecodeTx("", false); err != nil {
+		if err := a.HaltDecodeTx("", act.Soft); err != nil {
 			applog.Printf("autocall: halt failed: %v", err)
 		}
 	}
@@ -433,6 +621,38 @@ func (a *App) autoCallSetTX(tx autocall.TXState) {
 	a.acMu.Unlock()
 }
 
+// SetAutoCallVisible is the decodes panel saying what it is SHOWING.
+//
+// The panel owns the filters and therefore owns the answer: reimplementing them
+// here would give the screen and the transmitter two definitions of the same
+// word, which is how they end up disagreeing. It sends the callsigns that
+// survive its filters, and the engine calls nothing else.
+//
+// An empty list with active=false means "no filtering in force" — the panel was
+// closed, or has never been opened this session — and the ladder decides alone.
+func (a *App) SetAutoCallVisible(calls []string, active bool) {
+	set := make(map[string]bool, len(calls))
+	for _, c := range calls {
+		if c = strings.ToUpper(strings.TrimSpace(c)); c != "" {
+			set[c] = true
+		}
+	}
+	a.acMu.Lock()
+	a.acVisible, a.acVisibleOn = set, active
+	a.acMu.Unlock()
+}
+
+// autoCallHidden reports whether the panel's filters are keeping a station off
+// the screen. Unknown when nothing is being published: not hidden.
+func (a *App) autoCallHidden(call string) bool {
+	a.acMu.Lock()
+	defer a.acMu.Unlock()
+	if !a.acVisibleOn {
+		return false
+	}
+	return !a.acVisible[strings.ToUpper(strings.TrimSpace(call))]
+}
+
 // autoCallNeedOf maps the cluster's own status vocabulary onto the ladder. One
 // vocabulary for both, so a station that reads NEW BAND in the decodes list is
 // the same NEW BAND the auto-call ranks — two answers to one question is how
@@ -471,18 +691,40 @@ func (a *App) autoCallWatched(call string) bool {
 	return ok
 }
 
-// startAutoCall arms the engine at launch.
+// startAutoCall starts the engine's loop, with auto-call OFF.
 //
-// The stored "on" is honoured, and the engine starts with NO target: a program
+// It is never on from a stored value. This is the one setting in the program
-// that came up already calling a station chosen before the last shutdown is not
+// that puts the station on the air by itself, and the operator who left it on
-// something an operator can be expected to anticipate.
+// last night is not necessarily the one at the desk now — nor necessarily at
+// the desk at all: OpsLog starts with Windows, and a rig that powers up with it
+// would begin calling into an empty shack, on whatever band the radio happens
+// to be on, hours after anybody decided that was a good idea.
+//
+// Arming it is one click, and it is a click somebody has to make.
 func (a *App) startAutoCall() {
-	a.applyAutoCall()
+	a.disarmAutoCall("launch")
 	go a.autoCallLoop()
 }
 
+// disarmAutoCall switches auto-call off and writes that down.
+//
+// The setting is what the toolbar and the settings panel both read, so turning
+// the engine off without storing it would show a lit switch over a silent
+// transmitter — and the operator's next click, meaning "on", would send "off".
+func (a *App) disarmAutoCall(why string) {
+	if a.settingOr(keyAutoCallOn, "0") == "1" {
+		applog.Printf("autocall: off at %s — it is never armed from a stored setting", why)
+	}
+	a.setSetting(keyAutoCallOn, "0")
+	a.applyAutoCall()
+}
+
 func (a *App) autoCallLoop() {
-	t := time.NewTicker(2 * time.Second)
+	// A quarter of a second. The sweeper is what closes a period, so its tick is
+	// part of the same budget as acQuiet: a two-second tick added up to two
+	// seconds of its own to every answer, which is most of the margin there is.
+	// The work per tick is a map read.
+	t := time.NewTicker(250 * time.Millisecond)
 	defer t.Stop()
 	for range t.C {
 		if a.ctx == nil {

autocall_wiring_test.go

@@ -0,0 +1,81 @@
+package main
+
+import (
+	"testing"
+
+	"hamlog/internal/autocall"
+)
+
+// The entity's verdict is not the station's.
+//
+// From the air: on 10 m, where most countries are already in the log, the
+// engine refused twenty decodes out of twenty-one as "worked" — a watched
+// DXpedition calling CQ among them — because the ENTITY's status was read as
+// the station's.
+// allChased is the default: every orthogonal marker ticked.
+var allChased = chaseExtras{pota: true, grid: true, pfx: true, county: true, state: true}
+
+func TestCandidateWorkedIsTheCallsignNotTheEntity(t *testing.T) {
+	d := autocall.Decode{Call: "J38DX", Band: "10m", Mode: "FT8", IsNew: true}
+
+	// Grenada worked on 10 m FT8, this callsign never worked: nothing is needed
+	// from it, and calling it is NOT a duplicate.
+	c := candidateOf(d, SpotStatus{Status: "worked", WorkedSlot: false}, allChased)
+	if c.Worked {
+		t.Error("a station never worked was refused because its entity was")
+	}
+	if c.Need != autocall.NeedNone {
+		t.Errorf("need = %v on a worked entity, want none", c.Need)
+	}
+
+	// The same callsign already in the log on this band and mode IS a duplicate.
+	if c := candidateOf(d, SpotStatus{Status: "worked", WorkedSlot: true}, allChased); !c.Worked {
+		t.Error("a callsign already worked on this band and mode was not flagged")
+	}
+
+	// And a real need still carries through, with the unconfirmed distinction.
+	c = candidateOf(d, SpotStatus{Status: "new-band", UnconfStatus: true}, allChased)
+	if c.Need != autocall.NeedBand || !c.Unconfirmed {
+		t.Errorf("new-band unconfirmed came through as %v (unconf=%v)", c.Need, c.Unconfirmed)
+	}
+}
+
+// A station whose ENTITY has nothing left to give can still be the reason the
+// operator is on the band: a WPX prefix, a county, a square, a park that has
+// never been worked. Reported from the air — auto-call sat through a
+// never-worked prefix calling CQ and did nothing.
+func TestOrthogonalMarkersAreWorthACall(t *testing.T) {
+	d := autocall.Decode{Call: "BH2SWB", Band: "10m", Mode: "FT8", IsNew: true}
+	worked := SpotStatus{Status: "worked"}
+
+	for _, tc := range []struct {
+		what string
+		st   SpotStatus
+		want string
+	}{
+		{"prefix", SpotStatus{Status: "worked", NewPfx: true}, "prefix"},
+		{"county", SpotStatus{Status: "worked", NewCounty: true}, "county"},
+		{"state", SpotStatus{Status: "worked", NewState: true}, "state"},
+		{"square", SpotStatus{Status: "worked", NewGrid: true}, "square"},
+		{"park", SpotStatus{Status: "worked", NewPOTA: true}, "park"},
+	} {
+		c := candidateOf(d, tc.st, allChased)
+		if c.Need != autocall.NeedExtra || c.Extra != tc.want {
+			t.Errorf("%s: need=%v extra=%q, want extra %q", tc.what, c.Need, c.Extra, tc.want)
+		}
+		// And not when the operator does not chase that kind of thing: the
+		// switch that withdraws the badge withdraws the call with it.
+		if c := candidateOf(d, tc.st, chaseExtras{}); c.Need != autocall.NeedNone {
+			t.Errorf("%s: called for a marker the operator does not chase", tc.what)
+		}
+	}
+
+	// It is the LOWEST rung: a real need on the entity still says what it is.
+	if c := candidateOf(d, SpotStatus{Status: "new-band", NewPfx: true}, allChased); c.Need != autocall.NeedBand {
+		t.Errorf("need = %v — a new band that is also a new prefix is a new band", c.Need)
+	}
+	// Nothing anywhere is still nothing.
+	if c := candidateOf(d, worked, allChased); c.Need != autocall.NeedNone {
+		t.Errorf("need = %v on a station with nothing to gain", c.Need)
+	}
+}

changelog.json

@@ -1,4 +1,164 @@
 [
+  {
+    "version": "0.27.17",
+    "date": "",
+    "en": [
+      "[NEW] Satellites. A new tab (Tools → Satellites) works the amateur birds from end to end. A map with each satellite's footprint and the selected one's path over the ground; a sky plot the way every tracker draws one, centre straight up and rim at the horizon, with the whole pass and where the bird is on it; a countdown to AOS — or to LOS once it is up — with rise, peak and set, their compass directions, distance, altitude and footprint; and a pass table for everything you follow.\n\nTrack puts the radio on the satellite and keeps it there, once a second: an IC-9700 or IC-9100 in its own satellite mode, a FlexRadio on two slices (A the downlink, B the uplink, created if missing, full duplex on) — and any other rig on the downlink, which it says plainly rather than half-doing the job. Tune the receiver where you like: the tracker reads the dial, takes it as the station you have chosen, and moves the transmitter to match. An az/el rotator follows along, either driven directly over EasyComm II or handed to PstRotator if you already run it; a 450° rotator is used as one, so a pass crossing north continues instead of unwinding.\n\nQSOs made while tracking are logged with the NOMINAL frequencies, SAT_NAME, SAT_MODE and PROP_MODE=SAT — the transponder's own numbers, which both stations can agree on, rather than where one radio happened to be.\n\nOrbital elements come from Celestrak with a mirror behind it and are kept on disk, so the tab is full the moment it opens even with no internet; elements for a bird no feed carries yet can be pasted in and survive every refresh. Twenty-five satellites ship with a frequency plan — the FM and linear birds, GreenCube, QO-100 narrow and wide — in a file you can correct yourself when a transponder is switched. Everything about setting it up lives in Settings → Satellites, including which satellites you follow, chosen the way you choose awards.",
+      "Each map keeps its own imagery. The world map and the grid-square map shared one setting, so choosing satellite imagery to look at grids repainted the main map as well, and there was no way to have terrain on one and plain streets on the other. All four — world, grid squares, FT map, satellites — now remember their own choice, and it travels with the data folder like the remembered views. A choice already made for the grid map is carried over, not reset.",
+      "Two or three FT8 programs at once no longer fight over the callsign field. Click a station in MSHV and only MSHV has a DX Call; WSJT-X and JTDX beside it are idle and say so once a second each — and OpsLog was reading those as MSHV abandoning the station, so the entry emptied and refilled at 1 Hz and the map zoomed in and out with it. A cleared DX Call is now read per program, never across the listener; and the program that announces a station keeps the entry field until it clears its own call, is closed, or the QSO is logged.",
+      "The FT decodes table sorts on SNR, frequency, distance, country and status — click the heading. Within each slot and never across them: the periods are what the panel is, and a list sorted end to end would mix three minutes of decodes into one column with no way to tell which window any of them came from. One click sorts the way that column is worth reading (strongest signal, furthest DX, lowest frequency, A to Z, most wanted first), the second reverses it, the third gives back the order the decoder heard them in. Stations with no grid, or no country resolved yet, sort to the end either way rather than pretending to a distance of zero.",
+      "The cluster editor offers a list of known nodes. Setting up a telnet cluster is the step operators get stuck on: the address and the port are two pieces of information nobody has to hand, and a typo in either looks exactly like a node that is down. Pick one and the fields fill in — F4BPO, DXFun, F5LEN, F5MZN, KM3T, SOTA, POTA, and the two Reverse Beacon feeds, which are one network on two ports where 7000 carries CW and RTTY and 7001 carries FT8 and FT4. Everything stays editable, and a node typed in by hand works exactly the same. More will be added.",
+      "Preferences no longer lag behind the keyboard. Typing a cluster macro re-rendered the whole dialog on every keystroke and wrote a row into the database per character; the twenty-four boxes now stand on their own and the database write waits for the typing to stop."
+    ],
+    "fr": [
+      "[NOUVEAU] Satellites. Un nouvel onglet (Outils → Satellites) permet de travailler les satellites amateurs de bout en bout. Une carte avec l'empreinte de chacun et la trace au sol du satellite sélectionné ; une vue du ciel comme la dessine n'importe quel tracker, centre à la verticale et bord à l'horizon, avec le passage entier et la position du satellite dessus ; un compte à rebours jusqu'à l'AOS — ou jusqu'au LOS une fois levé — avec lever, culmination et coucher, leurs directions à la boussole, distance, altitude et empreinte ; et un tableau des passages de tout ce que vous suivez.\n\n« Suivre » met la radio sur le satellite et l'y maintient, chaque seconde : un IC-9700 ou IC-9100 dans son propre mode satellite, un FlexRadio sur deux slices (A la descente, B la montée, créées si elles manquent, full duplex activé) — et n'importe quel autre poste sur la descente seule, ce qu'il annonce clairement plutôt que de faire le travail à moitié. Accordez le récepteur où vous voulez : le suivi lit le VFO, y voit la station que vous avez choisie, et déplace l'émetteur en conséquence. Un rotor az/él suit aussi, piloté directement en EasyComm II ou confié à PstRotator si vous le faites déjà tourner ; un rotor 450° est utilisé comme tel, et un passage qui traverse le nord continue au lieu de se dérouler.\n\nLes QSO faits pendant le suivi sont enregistrés avec les fréquences NOMINALES, SAT_NAME, SAT_MODE et PROP_MODE=SAT — les chiffres du transpondeur, sur lesquels les deux stations peuvent s'accorder, plutôt que l'endroit où une radio se trouvait.\n\nLes éléments orbitaux viennent de Celestrak, avec un miroir derrière, et sont conservés sur disque : l'onglet est rempli dès son ouverture, même sans internet. Les éléments d'un satellite qu'aucun flux ne diffuse encore peuvent être collés à la main et survivent à chaque mise à jour. Vingt-cinq satellites sont livrés avec un plan de fréquences — les FM et les linéaires, GreenCube, QO-100 bande étroite et large — dans un fichier que vous pouvez corriger vous-même quand un transpondeur change de mode. Toute la configuration est dans Réglages → Satellites, y compris le choix des satellites suivis, sélectionnés comme on choisit ses diplômes.",
+      "Chaque carte garde son propre fond. La carte principale et celle des carrés partageaient un seul réglage : choisir la vue satellite pour regarder les carrés repeignait aussi la carte principale, et il n'y avait aucun moyen d'avoir le relief sur l'une et les rues sur l'autre. Les quatre — principale, carrés, FT map, satellites — retiennent désormais leur propre choix, qui suit le dossier de données comme les positions mémorisées. Un choix déjà fait pour la carte des carrés est repris, pas réinitialisé.",
+      "Deux ou trois logiciels FT8 en même temps ne se disputent plus le champ indicatif. Cliquez une station dans MSHV et lui seul a un DX Call ; WSJT-X et JTDX à côté sont au repos et le disent une fois par seconde chacun — et OpsLog y lisait MSHV abandonnant la station : le champ se vidait et se remplissait à 1 Hz, la carte zoomant au même rythme. Un DX Call effacé est désormais lu par programme, jamais à l'échelle du port ; et le logiciel qui annonce une station garde le champ jusqu'à ce qu'il efface son propre indicatif, soit fermé, ou que le QSO soit enregistré.",
+      "Le tableau des décodages FT se trie sur SNR, fréquence, distance, pays et statut — cliquez l'en-tête. À l'intérieur de chaque créneau et jamais au travers : les périodes sont la raison d'être du panneau, et un tri de bout en bout mélangerait trois minutes de décodages en une colonne sans plus savoir de quelle fenêtre chacun vient. Un clic trie dans le sens où la colonne se lit (signal le plus fort, DX le plus lointain, fréquence la plus basse, de A à Z, le plus recherché d'abord), un second inverse, un troisième rend l'ordre dans lequel le décodeur les a entendus. Les stations sans locator, ou dont le pays n'est pas encore résolu, se rangent à la fin dans les deux sens plutôt que de se faire passer pour une distance nulle.",
+      "L'éditeur de cluster propose une liste de nœuds connus. La configuration d'un cluster telnet est l'étape où l'on se bloque : l'adresse et le port sont deux informations que personne n'a sous la main, et une faute de frappe dans l'une ou l'autre ressemble exactement à un nœud en panne. On en choisit un et les champs se remplissent — F4BPO, DXFun, F5LEN, F5MZN, KM3T, SOTA, POTA, et les deux flux Reverse Beacon, qui sont un même réseau sur deux ports où 7000 porte la CW et le RTTY et 7001 le FT8 et le FT4. Tout reste modifiable, et un nœud saisi à la main fonctionne exactement pareil. D'autres seront ajoutés.",
+      "Les Préférences ne traînent plus derrière le clavier. Saisir une macro de cluster redessinait tout le dialogue à chaque frappe et écrivait une ligne en base par caractère ; les vingt-quatre champs sont désormais indépendants et l'écriture en base attend la fin de la saisie."
+    ]
+  },
+  {
+    "version": "0.27.16",
+    "date": "",
+    "en": [
+      "[NEW] Typing a digital watering hole sets the mode with it. A spot click has always carried one; a frequency typed by hand carried none, so the rig stayed in SSB on 28.074 while the operator waited for decodes. Same table and same tolerance as a spot (±3 kHz of a known FT8/FT4/JS8 frequency), only towards the digital modes: tuning away from one leaves the mode alone, because there the frequency says nothing about what you mean to do.",
+      "Yaesu CAT now drives the older radios. The FTDX10, FT-991A, FT-891 and FT-710 write a frequency in nine digits; everything before them — FTDX3000, FTDX5000, FTDX1200, FT-2000, FT-950, FT-450 — writes eight and answers a nine-digit command with a rejection, which is what an FTDX3000 owner saw: every FA refused and a radio that would not follow. The width is taken from the rig’s own reply rather than from a table of models, so a set is in the format that radio speaks — including models this backend has never heard of.",
+      "Yaesu: RTTY can be set on USB (Settings → CAT). ADIF records only “RTTY” and the rig has both sidebands, so the log cannot answer for it — the older RTTY-L stays the default, and a station whose FSK controller wants the upper one says so once. The choice reaches the radio already connected: it is not part of what defines the link, so the link is not rebuilt for it — and until now that meant it waited for the next launch while the rig went on choosing LSB.",
+      "The update no longer relaunches OpsLog through a hidden PowerShell. An unsigned program that replaces itself on disk, clears the mark-of-the-web and then spawns a windowless PowerShell to start another executable is — byte for byte — the shape of a dropper, and Windows Defender’s machine-learning model reads the shape, not the intention: 0.27.14 was removed from a station under Trojan:Script/Wacatac.H!ml. The new version simply starts itself and waits its turn on the single-instance lock, which it already knew how to do. Only the rare fallback path, when the running file cannot even be renamed, still needs a helper that outlives the process.",
+      "Rotor widget: with more than one rotor the panel no longer runs off the bottom. The selector row appears above the dial, and the widget’s height is not its own to take — it sits in a strip sized by the entry form beside it — so the SP/LP pair and half the Stop button were cut off. The dial, the button rows and the padding now give that row back between them, in proportion, and nothing is dropped."
+    ],
+    "fr": [
+      "[NEW] Taper une fréquence d’appel numérique règle le mode avec elle. Un clic sur un spot en portait un depuis toujours ; une fréquence tapée à la main n’en portait aucun, si bien que le poste restait en SSB sur 28.074 pendant qu’on attendait les décodages. Même table et même tolérance qu’un spot (±3 kHz d’une fréquence FT8/FT4/JS8 connue), et seulement vers les modes numériques : en s’en éloignant le mode n’est pas touché, car là la fréquence ne dit rien de ce qu’on veut faire.",
+      "Le CAT Yaesu pilote désormais les postes plus anciens. FTDX10, FT-991A, FT-891 et FT-710 écrivent une fréquence sur neuf chiffres ; tout ce qui précède — FTDX3000, FTDX5000, FTDX1200, FT-2000, FT-950, FT-450 — l’écrit sur huit et rejette une commande à neuf chiffres. C’est ce que voyait un possesseur de FTDX3000 : chaque FA refusée et une radio qui ne suivait pas. Le format est pris dans la réponse du poste plutôt que dans une table de modèles : l’envoi part donc dans la langue de cette radio-là, y compris pour des modèles que ce backend ne connaît pas.",
+      "Yaesu : le RTTY peut être placé en USB (Réglages → CAT). L’ADIF n’enregistre que « RTTY » et le poste a les deux bandes latérales : le log ne peut pas répondre à sa place. Le RTTY-L ancien reste par défaut, et une station dont l’interface FSK veut la supérieure le dit une fois. Le choix atteint le poste déjà connecté : il ne fait pas partie de ce qui définit la liaison, donc celle-ci n’est pas reconstruite pour lui — et jusqu’ici cela voulait dire qu’il attendait le prochain lancement pendant que le poste continuait de choisir la LSB.",
+      "La mise à jour ne relance plus OpsLog par un PowerShell caché. Un programme non signé qui se remplace sur le disque, efface la marque « téléchargé depuis Internet » puis lance un PowerShell sans fenêtre pour démarrer un autre exécutable a — à l’octet près — la forme d’un dropper, et le modèle d’apprentissage de Windows Defender lit la forme, pas l’intention : la 0.27.14 a été supprimée chez un OM sous Trojan:Script/Wacatac.H!ml. La nouvelle version se lance elle-même et attend son tour sur le verrou d’instance unique, ce qu’elle savait déjà faire. Seul le repli rare, quand le fichier en cours d’exécution ne peut même pas être renommé, garde un assistant qui survit au processus.",
+      "Widget rotor : avec plusieurs rotors, le panneau ne déborde plus par le bas. La rangée de sélection apparaît au-dessus du cadran, et la hauteur du widget ne lui appartient pas — il occupe une bande dont la hauteur est fixée par la saisie à côté — si bien que la paire SP/LP et la moitié du bouton Stop se retrouvaient coupées. Le cadran, les rangées de boutons et les marges rendent désormais cette hauteur entre eux, chacun pour sa part, sans rien supprimer."
+    ]
+  },
+  {
+    "version": "0.27.15",
+    "date": "",
+    "en": [
+      "[NEW] The WSJT-X / JTDX highlight colours are yours to choose (Settings → UDP), one per verdict — watch list, new DXCC, new band, worked. Only the background is set: the text colour is worked out from it, so a chosen colour cannot come back unreadable in the decoder’s window. The “grey out stations already worked” switch keeps its purpose — it decides WHETHER dupes are marked, not what colour they are — and is now called “Mark stations already worked”.",
+      "[NEW] Rotor dial: a circular scale and a beam instead of an arrow. The square ring made a marker at 45° sit further from the centre than one at north — a dial is read by angle, so the ring it is read against is now the same distance away all the way round. The antenna is drawn as a sector that fades outwards, which is the shape of the thing it stands for; where the mouse would send it appears in the same shape in orange, and its azimuth in place of the current heading while you aim. Green for where the antenna is, orange for where it would go, yellow for what was ordered — the second lobe of a bidirectional Ultrabeam and the dashed boom are unchanged. Design from EC1KD again.",
+      "WSJT-X highlighting: a watch-list station already worked on this band and mode is no longer painted as one to call. The list is a statement of intent, not of what is left to do, and its pink outranked everything — including the log — so a station already worked stayed pink for the session with no way to tell it from one still needed.",
+      "Motorised antenna: the transmitter is released as soon as the elements stop. Three delays were stacked between the antenna finishing and the operator being allowed to call — the antenna polled every two seconds, the transmit gag held for three after the command whatever the antenna said, and the screen refreshed every three. Both the Ultrabeam and the SteppIR are now polled four times a second WHILE IT MOVES (and left at two seconds when it is still, where nothing changes), the gag only bridges the command itself, and the widget follows at half a second. The SteppIR also reports a commanded move at once, as the Ultrabeam already did: it says nothing until its own poll comes round, so the shortened gag would otherwise have released the transmitter in the middle of a move.",
+      "Motorised antenna: the indicator turns amber the instant the move is ORDERED, from a button or from an automatic band change with tracking on, instead of waiting for the antenna to say it is moving. The transmit gag already started there; the screen did not, so the two disagreed by a second or more — and on a follow there was no warning at all until a poll landed.",
+      "Icom network audio starts at once instead of half a minute later. The message that authorises the stream is sent during the login, before the audio socket exists — so the rig was told to send audio to a port nothing was bound to, got a port-unreachable back, and only resumed when its own retry timer came round. It is sent once more as soon as the port is listening.",
+      "Icom over the network: when CI-V goes quiet while the experimental RX audio stream is still delivering, the log now says so and names the switch to try. The two share the rig’s session, and the shape in the field is exactly that — hundreds of audio packets arriving, not one CI-V reply, the watchdog tearing the session down, and the whole thing starting again. The silence report also lists the last eight CI-V commands sent: a rig that answers at connect and then never again has usually been sent something it does not like, and a count of unanswered commands never said which one.",
+      "Icom over the network: a rig left in standby no longer sits in a dial-and-drop loop. The clock that bounds “the control link answers but no CI-V comes back” belongs to a session and was never cleared when a new one opened, so every fresh session started already past its grace — torn down at once, redialled twenty seconds later, and torn down again for as long as the radio was asleep. Silent since connect is now read as what it is: a rig in standby, with the session kept so it can be woken.",
+      "The Icom console appears whenever the configured radio is an Icom, not only once the rig is talking — the console is where the power-ON button lives, so it used to be missing at the one moment it was needed. The console’s configured backend also follows a radio switched from the status bar, instead of waiting for a trip through Settings and a Save that changed nothing.",
+      "Audio: the Listening device now says when it cannot be opened. A device unplugged, renamed by Windows or unable to run at 16 kHz failed silently while everything upstream reported success — the stream up, the packets arriving, the monitor started — which is the whole of “I turned the sound on and nothing comes out”. The log also says, once, whether the network RX audio is reaching the speakers or arriving with nobody listening.",
+      "ADIF export: a record is written on one line again. ADDRESS is a multi-line field by the standard and callbooks and other loggers fill it that way — “Kabul”, four blank lines, “Afghanistan” — and OpsLog wrote it out as it was, so a record ran down a dozen lines with the next apparently starting in the middle of the page. Line breaks inside a value are now joined with a comma, which is how an address reads on one line anyway. The files were always valid (ADIF counts bytes); they were unreadable.",
+      "Club Log uploads are no longer refused as “not configured”. The check added for services with no credentials demanded a Club Log API key, which nobody has ever set — OpsLog carries its own application key — so an operator whose live upload had worked for months was turned away when sending QSOs by hand. Each service’s requirements now live beside the uploader that enforces them, and the message names the fields that are actually missing.",
+      "FT map: the callsign, square and report show on hover again. The invisible circle that catches the clicks sits on top of the dot, so it takes the hover too — and the label was bound only to the dot underneath, which left the map silent from the moment the stations became clickable."
+    ],
+    "fr": [
+      "[NEW] Les couleurs de mise en évidence WSJT-X / JTDX sont au choix (Réglages → UDP), une par verdict — watchlist, nouveau DXCC, nouvelle bande, contactée. Seul le fond se règle : la couleur du texte en est déduite, pour qu’une couleur choisie ne revienne jamais illisible dans la fenêtre du décodeur. L’option « griser les stations déjà contactées » garde sa raison d’être — elle décide SI les doublons sont marqués, pas de quelle couleur — et s’appelle désormais « Marquer les stations déjà contactées ».",
+      "[NEW] Cadran rotor : échelle circulaire et faisceau au lieu d’une flèche. L’anneau carré plaçait un repère à 45° plus loin du centre qu’un repère au nord — un cadran se lit par l’angle, donc l’anneau qui sert de référence est désormais à la même distance tout autour. L’antenne est dessinée comme un secteur qui s’estompe vers l’extérieur, ce qui est la forme de ce qu’il représente ; là où la souris l’enverrait apparaît dans la même forme en orange, et son azimut à la place du cap courant pendant qu’on vise. Vert pour où l’antenne est, orange pour où elle irait, jaune pour ce qui a été demandé — le deuxième lobe d’un Ultrabeam bidirectionnel et le boom en pointillés sont inchangés. Design d’EC1KD, encore.",
+      "Mise en évidence WSJT-X : une station de la watchlist déjà contactée sur cette bande et ce mode n’est plus peinte comme une station à appeler. La liste dit une intention, pas ce qu’il reste à faire, et son rose passait devant tout — y compris le carnet — si bien qu’une station déjà faite restait rose toute la session, sans moyen de la distinguer d’une station encore à faire.",
+      "Antenne motorisée : l’émission est rendue dès que les éléments s’arrêtent. Trois délais s’ajoutaient entre la fin du mouvement et le droit d’appeler — l’antenne interrogée toutes les deux secondes, le blocage d’émission maintenu trois secondes après la commande quoi qu’en dise l’antenne, et l’écran rafraîchi toutes les trois. L’Ultrabeam comme la SteppIR sont désormais interrogées quatre fois par seconde PENDANT qu’elle bouge (et laissée à deux secondes à l’arrêt, où rien ne change), le blocage ne couvre plus que la commande elle-même, et le widget suit à la demi-seconde. La SteppIR signale aussi un mouvement dès qu’il est commandé, comme le faisait déjà l’Ultrabeam : elle ne dit rien avant sa propre lecture, et le blocage raccourci aurait sinon rendu l’émission en plein mouvement.",
+      "Antenne motorisée : l’indicateur passe à l’ambre à l’instant où le mouvement est COMMANDÉ, par un bouton comme par un changement de bande automatique quand le suivi est actif, au lieu d’attendre que l’antenne dise qu’elle bouge. Le blocage d’émission démarrait déjà là ; l’écran non, et les deux se contredisaient d’une seconde ou plus — sur un suivi, il n’y avait aucun signe avant l’arrivée d’une lecture.",
+      "L’audio réseau Icom démarre tout de suite au lieu d’une demi-minute plus tard. Le message qui autorise le flux part pendant la connexion, avant que la prise audio n’existe : le poste se voyait donc demander d’émettre vers un port où personne n’écoutait, recevait un « port injoignable » en retour, et ne reprenait qu’au tour suivant de son propre minuteur. Il est renvoyé dès que le port écoute.",
+      "Icom en réseau : quand le CI-V devient muet alors que le flux audio expérimental continue d’arriver, le journal le dit et nomme l’option à essayer. Les deux partagent la session du poste, et c’est exactement la forme observée en vrai — des centaines de paquets audio, pas une réponse CI-V, le chien de garde qui coupe la session, et tout qui recommence. Le rapport de silence liste aussi les huit dernières commandes CI-V envoyées : un poste qui répond à la connexion puis plus jamais s’est en général vu envoyer quelque chose qu’il n’aime pas, et un compteur de commandes sans réponse n’a jamais dit laquelle.",
+      "Icom en réseau : un poste laissé en veille ne tourne plus en boucle connexion/déconnexion. L’horloge qui borne « la liaison de contrôle répond mais aucun CI-V ne revient » appartient à une session et n’était jamais remise à zéro à l’ouverture de la suivante : chaque nouvelle session démarrait déjà au-delà de son délai de grâce — coupée aussitôt, rappelée vingt secondes plus tard, recoupée, aussi longtemps que la radio dormait. « Silencieux depuis la connexion » se lit désormais pour ce que c’est : un poste en veille, dont on garde la session pour pouvoir le réveiller.",
+      "La console Icom s’affiche dès que la radio configurée est un Icom, et pas seulement quand le poste parle — c’est là que se trouve le bouton d’allumage, il manquait donc au seul moment où il servait. Le backend configuré suit aussi un changement de radio fait depuis la barre d’état, au lieu d’attendre un passage dans les réglages et un « Enregistrer » qui ne changeait rien.",
+      "Audio : le périphérique d’écoute signale désormais quand il ne peut pas s’ouvrir. Un périphérique débranché, renommé par Windows ou incapable de fonctionner en 16 kHz échouait en silence pendant que tout en amont annonçait le succès — flux ouvert, paquets reçus, moniteur démarré — ce qui est exactement le « j’ai remis le son et rien ne sort ». Le journal dit aussi, une fois, si l’audio réseau atteint les haut-parleurs ou arrive sans que personne n’écoute.",
+      "Export ADIF : un enregistrement tient de nouveau sur une ligne. ADDRESS est un champ multiligne selon la norme, et les callbooks comme les autres logiciels le remplissent ainsi — « Kabul », quatre lignes vides, « Afghanistan » — qu’OpsLog recopiait tel quel : un enregistrement s’étalait sur une douzaine de lignes, le suivant semblant commencer au milieu de la page. Les retours à la ligne dans une valeur sont désormais réunis par une virgule, ce qui est de toute façon la façon de lire une adresse sur une ligne. Les fichiers étaient valides (l’ADIF compte les octets) ; ils étaient illisibles.",
+      "Les envois vers Club Log ne sont plus refusés comme « non configuré ». Le contrôle ajouté pour les services sans identifiants réclamait une clé API Club Log que personne n’a jamais saisie — OpsLog embarque la sienne — et un opérateur dont l’envoi automatique fonctionnait depuis des mois se voyait éconduit au moment d’envoyer des QSO à la main. Les exigences de chaque service vivent désormais à côté du code qui les applique, et le message nomme les champs réellement manquants.",
+      "Carte FTx : l’indicatif, le locator et le report réapparaissent au survol. Le cercle invisible qui capte les clics est au-dessus du point, donc il capte aussi le survol — et l’étiquette n’était liée qu’au point du dessous, ce qui rendait la carte muette dès que les stations sont devenues cliquables."
+    ]
+  },
+  {
+    "version": "0.27.14",
+    "date": "",
+    "en": [
+      "[NEW] The mouse wheel steps the RST fields, in the entry strip and in the QSO editor. It counts the way an operator does — 57, 58, 59, 59+5, 59+10, 59+15, 59+20 — one S-unit up to nine and then five decibels at a time, and one decibel on a digital report. R and T do not move. The dropdown beside them lists the reports worth having to hand, not every legal one, so the wheel works on the value rather than walking the list.",
+      "[NEW] The world map opens centred on YOUR square, not on Greenwich. Centred on 0° it left an Australian looking at their own country in the bottom-right corner with every path running off both edges; centred on their own longitude the same map reads the way their antenna does — the Americas to the east, Europe and Africa to the west. The latitude leans towards your hemisphere without following you to the pole, and a view you have panned to yourself still wins.",
+      "The world map now waits for the station’s square before painting. It used to draw the world at 0° and then move to your longitude, fetching a screenful of tiles and discarding it on every first run; it is built once, knowing where it is looking. A profile with no locator still gets the default view after a moment rather than a blank panel.",
+      "[NEW] The FT decodes map and the grid-square map remember where you left them — centre and zoom, portable with the data folder like the world map’s own view. Panning a map is the operator saying which part of the world they are working, and it was being thrown away on every tab switch.",
+      "[NEW] FT map: the station dots answer the same two gestures as the decodes list — one click takes the callsign into the entry, two answer it. The hit area is wider than the dot, and a double click no longer zooms the map on its way through.",
+      "The auto-call readout moved out of the Auto button and beside it: the station being called is the biggest thing on the row, the calls and the missed periods each carry a label instead of reading as one number, and a station being waited for shows with an hourglass. The button had been changing width every period.",
+      "Auto-call: the rest between two series is counted in the station’s own overs, not in minutes, and is ONE by default. Two minutes is four overs on FT8 — by then the DX has worked four other callers and half the time it has gone. Seven calls, one over listened through, and it goes again if the station is still there (Settings → DXHunter, “Rest (overs)”).",
+      "Auto-call sees a decode that arrives after the others. A decoder sends a period in a burst and stragglers follow — a deep decode a second behind the rest — and the straggler was judged on its own, with the thirty stations of its own period nowhere in sight. The period now stays open until the next one starts, and a late arrival is weighed against all of it.",
+      "Auto-call: a period the station was decoded in is never counted as a miss. A period is judged more than once — the decodes arrive in a burst and stragglers follow — and a later judgement holds a partial view of it, not evidence of absence: a station answering in that very period showed “1/3 missed” against it.",
+      "Auto-call never parks a watched callsign. After a few series of unanswered calls a station is set aside for the session — the right answer for one the LOG picked out, the wrong one for a station YOU named: a DXpedition running a pileup takes more than two series to get through to, which is exactly why it is on the list. The rest between series still applies.",
+      "PSK Reporter panel: with the whole-band scope, clicking a decode no longer resets the report count to zero. The window there belongs to the BAND — every FTx report on it, filtered by target only when the analysis is drawn — and it was being emptied on every target change, throwing away an hour of evidence at the exact moment it was worth something. The narrow scope still clears it, because there the window is one station’s.",
+      "Changing mode with a callsign in the field now fixes the report. The “the operator chose this report” flag was holding across a change of mode, where it means nothing — “+00” is not a weak SSB report, it is not a report at all — and anything that fills the field from the rig (the S-meter readouts in the rig consoles) sets that flag too, so it could stay in the wrong notation for the whole QSO. A judgement that can be carried across is carried (57 → 579, 599 → 59); otherwise the mode’s preset answers.",
+      "Icom CI-V: address 00 can be set, and “Other (custom address)” stays chosen. Zero was treated as “not configured” and every save put the rig back to the IC-7610’s 98 — the model list following it, since it is derived from the address rather than stored.",
+      "Cloudlog / Wavelog upload: a simplex contact is no longer uploaded as split. Every QSO carried a receive band and frequency equal to the transmit side, and Wavelog draws both — an ordinary FT8 contact read “17m/17m”. In ADIF an absent BAND_RX means “same as transmit”, so they are now written only when they differ. The record forwarded to another logger on the UDP link still carries them in full (Log4OM reads BAND_RX).",
+      "Right-click → Send to: an upload to a service with no credentials is refused, and says which ones are missing and where. It used to run on its own and report into the QSL Manager’s console, which is not open when the command came from the QSO list — so it looked exactly like an upload that worked. Cloudlog / Wavelog and HamQTH also name themselves properly in the toast.",
+      "Cluster: “S/F” in a spot comment is read as FT8, alongside “superfox”, “sfox” and “F/H”. They are all the same DXpedition transmit mode, and the comment was falling through to the band plan and coming out DATA."
+    ],
+    "fr": [
+      "[NEW] La molette fait défiler les champs RST, dans la barre de saisie comme dans l’éditeur de QSO. Elle compte comme un opérateur — 57, 58, 59, 59+5, 59+10, 59+15, 59+20 — un point S jusqu’à neuf puis cinq décibels à la fois, et un décibel sur un report numérique. R et T ne bougent pas. La liste déroulante à côté contient les reports qu’on veut sous la main, pas tous les reports légaux : la molette agit donc sur la valeur plutôt que de parcourir la liste.",
+      "[NEW] La carte du monde s’ouvre centrée sur VOTRE locator, plus sur Greenwich. Centrée sur 0°, elle laissait un Australien avec son pays dans le coin en bas à droite et tous les trajets qui sortaient des deux bords ; centrée sur sa longitude, la même carte se lit comme son antenne travaille — les Amériques à l’est, l’Europe et l’Afrique à l’ouest. La latitude penche vers votre hémisphère sans vous suivre jusqu’au pôle, et une vue que vous avez déplacée vous-même reste prioritaire.",
+      "La carte du monde attend désormais le locator de la station avant de peindre. Elle dessinait le monde à 0° puis se déplaçait sur votre longitude, chargeant un écran de tuiles jeté aussitôt à chaque premier lancement ; elle est construite une fois, en sachant où elle regarde. Un profil sans locator obtient toujours la vue par défaut après un instant, pas un panneau vide.",
+      "[NEW] La carte des décodages FTx et la carte des locators retiennent où vous les avez laissées — centre et zoom, portables avec le dossier de données comme la vue de la carte du monde. Déplacer une carte, c’est dire quelle partie du monde on travaille, et c’était jeté à chaque changement d’onglet.",
+      "[NEW] Carte FTx : les points des stations répondent aux mêmes deux gestes que la liste des décodages — un clic met l’indicatif dans la saisie, deux l’appellent. La zone cliquable est plus large que le point, et un double clic ne zoome plus la carte au passage.",
+      "L’affichage de l’auto-call sort du bouton Auto pour se placer à côté : la station appelée est l’élément le plus lisible de la ligne, les appels et les périodes ratées portent chacun leur étiquette au lieu de se lire comme un seul nombre, et une station attendue s’affiche avec un sablier. Le bouton changeait de largeur à chaque période.",
+      "Auto-call : le repos entre deux séries se compte en tours de la station, plus en minutes, et vaut UN par défaut. Deux minutes, c’est quatre tours en FT8 — le DX a travaillé quatre autres appelants entre-temps, et la moitié du temps il est parti. Sept appels, un tour écouté, et ça repart si la station est toujours là (Réglages → DXHunter, « Repos (tours) »).",
+      "L’auto-call voit un décodage qui arrive après les autres. Un décodeur envoie une période en rafale, puis les retardataires — un décodage « deep » une seconde plus tard — et le retardataire était jugé tout seul, sans les trente stations de sa propre période. La période reste maintenant ouverte jusqu’au début de la suivante, et un arrivant tardif est pesé face à l’ensemble.",
+      "Auto-call : une période où la station a été décodée n’est plus comptée comme un raté. Une période est jugée plusieurs fois — les décodages arrivent en rafale puis les retardataires — et un jugement tardif n’en donne qu’une vue partielle, pas la preuve d’une absence : une station qui répondait dans cette période exacte se voyait compter « 1/3 raté ».",
+      "L’auto-call ne met jamais de côté un indicatif de la watchlist. Après quelques séries d’appels sans réponse, une station est écartée pour la session — la bonne réponse pour une station choisie par le CARNET, la mauvaise pour une station que VOUS avez nommée : un DX en pile-up demande plus de deux séries pour passer, et c’est précisément pour ça qu’il est sur la liste. Le repos entre séries s’applique toujours.",
+      "Panneau PSK Reporter : en portée « toute la bande », cliquer sur un décodage ne remet plus le nombre de reports à zéro. La fenêtre appartient là à la BANDE — tous les reports FTx qui y circulent, filtrés par cible seulement à l’affichage — et elle était vidée à chaque changement de cible, jetant une heure d’observations au moment précis où elles servent. La portée étroite continue de la vider : là, la fenêtre est celle d’une seule station.",
+      "Changer de mode avec un indicatif dans le champ corrige désormais le report. Le drapeau « l’opérateur a choisi ce report » tenait au travers d’un changement de mode, où il ne veut rien dire — « +00 » n’est pas un report SSB faible, ce n’est pas un report du tout — et tout ce qui remplit le champ depuis le poste (les lectures S-mètre des consoles) lève ce drapeau aussi : la notation pouvait rester fausse pour tout le QSO. Un jugement transposable l’est (57 → 579, 599 → 59) ; sinon le préréglage du mode répond.",
+      "Icom CI-V : l’adresse 00 peut être saisie, et « Other (custom address) » reste sélectionné. Le zéro était pris pour « non configuré » et chaque enregistrement remettait le poste sur le 98 de l’IC-7610 — la liste des modèles suivant, puisqu’elle est déduite de l’adresse et non enregistrée.",
+      "Upload Cloudlog / Wavelog : un contact simplex n’est plus envoyé comme un split. Chaque QSO portait une bande et une fréquence de réception égales à l’émission, et Wavelog affiche les deux — un FT8 ordinaire se lisait « 17m/17m ». En ADIF, un BAND_RX absent signifie « identique à l’émission » : ils ne sont donc écrits que s’ils diffèrent. L’enregistrement transmis à un autre logiciel par UDP les porte toujours en entier (Log4OM lit BAND_RX).",
+      "Clic droit → Envoyer vers : un envoi vers un service non configuré est refusé, en disant ce qui manque et où. Il partait tout seul et rendait compte dans la console du gestionnaire QSL, qui n’est pas ouverte quand la commande vient de la liste des QSO — ça ressemblait donc exactement à un envoi réussi. Cloudlog / Wavelog et HamQTH s’annoncent aussi sous leur nom dans le message.",
+      "Cluster : « S/F » dans un commentaire de spot est lu comme du FT8, au même titre que « superfox », « sfox » et « F/H ». C’est le même mode d’émission DXpédition, et le commentaire retombait sur le plan de bande pour ressortir en DATA."
+    ]
+  },
+  {
+    "version": "0.27.13",
+    "date": "",
+    "en": [
+      "[NEW] Rotor widget redrawn: a night world map behind a square azimuth scale, an orange pointer following the mouse so a click lands where it is aimed, a yellow marker on the azimuth ordered until the antenna gets there, and quick turns in columns of six. The Ultrabeam boom and its second lobe are still drawn, and Station Control keeps the plain dial — dial only, since anything under it is pushed off the bottom of the row. Design contributed by EC1KD — thank you.",
+      "[NEW] Settings → Rotator now chooses the dial: the new world-map compass or the classic one. Both are kept — one reads across the shack, the other is the compact dial that was there before — and the choice applies to the docked widget and to Station Control at once.",
+      "Rotor widget: the Stop button no longer flickers on a rotor standing still. Movement was inferred from a one-degree change, which is less than the jitter a controller reports at rest.",
+      "[NEW] A docked watch-list panel, showing only what is ON THE AIR and still needed — one line per band and mode — callsign, band, mode, what it is worth, how long ago — freshest first, click to tune, with the cluster’s own NEW DXCC / NEW BAND / NEW SLOT badge on each row. The Watchlist tab is a tab, and an operator working FT8 lives on the decodes one: a station you asked to be told about was appearing on a screen you were not looking at. Turn it on with the bell in the toolbar.",
+      "[NEW] FT decodes: a distance column, next to the square it is computed from and in your own unit (km or miles). Rounded to whole units — a four-character grid is a square tens of kilometres wide and nothing finer is honest.",
+      "[NEW] The PSK Reporter panel switches to the station auto-call is WAITING for (the hourglass), while nothing is being called. Its analysis takes a history query and a period or two of live reports to fill, so starting it when the DX finally comes free is starting it too late — the wait is exactly what it should be spent on.",
+      "[NEW] Chase new: a band selection of its own, under the option (160 m to 70 cm). The station’s band list still applies underneath — this one says what is worth WATCHING tonight.",
+      "Chase new: the panel says what the feed is doing — up or down, how many reports it has taken, how many receiver squares it is subscribed to. An empty list said nothing about whether anything was arriving at all.",
+      "FT decodes: a receiver column appears when more than one decoder feeds the merged list, and the list empties for a receiver that changes band — half a screen of stations no longer reachable is worse than an empty one.",
+      "FT decodes: a pink WL badge marks a station on your watch list, and the period clock turns red while transmitting. It is the one thing on the screen that moves, so “am I on the air” is readable from across the room.",
+      "FT decodes: a message addressed to YOU is set in green, whole and bold, with a green edge on the row — read from the far side of the shack. The station you are calling keeps a light tint and its callsign picked out in red: most of what it sends goes to other people, and colouring those lines the same way said you were in a QSO you were not in.",
+      "Cluster: “superfox”, “super fox”, “fox/hound” and “F/H” in a spot comment are read as FT8. They are WSJT-X’s DXpedition transmit modes, not modes of their own, and the comment fell through to the band’s default.",
+      "Auto-call: what it calls, and in what order. It answers only what the decodes list is SHOWING — the filters above it (CQ only, LoTW only, the category chips, continents, minimum report, search) now steer the transmitter as well as the eye, and the separate “LoTW users only” option is gone. A new prefix, county, state, square or park is worth a call too, at the foot of the ladder and only for the kinds you chase (Settings → DX Cluster). A watched callsign outranks everything not on the list, a real need beats an unconfirmed one at the same level, and a better station may take over from one that has not answered yet — never from a QSO in progress.",
+      "Auto-call: it calls THROUGH a pileup. It used to give up the moment the station it was calling answered somebody else — which is precisely how a DX with a queue behaves, and the only way to be the next one is to keep calling while it works the others. Still bounded by the call and miss counters, and a station in mid-exchange is still never CHOSEN as a new target.",
+      "Auto-call: safety and control. It is always OFF at launch and after a profile switch, never armed from a stored setting — it is the one feature that puts the station on the air by itself, and OpsLog starts with Windows. Halt is now a verdict: the station is set aside for the session and never called again until auto-call is switched off and on. It says what it is waiting for, showing a wanted station that is working somebody else next to the Auto button. And it can log every decision (Settings → DXHunter): one line per period saying what was on the air and why each station was refused.",
+      "Auto-call: a round of fixes from on-air use. It no longer cuts your own 73 short, calls four to six seconds late, starts a call and drops it a second later, ignores a station calling you, misreads MSHV’s two-answers-in-one-line, refuses nearly everything on the air because it read the entity’s “worked” as the station’s, or opens with two misses already counted against a station it has only just picked.",
+      "Switching profile no longer leaves the previous logbook’s verdicts on the screen. Coming back from a profile with an empty log, every decode and spot stayed badged NEW until a restart: the worked-index, the chase-new list and the cached verdicts are now all dropped when the logbook changes.",
+      "Chase new fixes: the header counts both what the filters show and what the panel holds (“3 of 12 heard”), a stored filter set that hides everything is ignored, and switching between “new” and “new + unconfirmed” re-reads the list instead of leaving old verdicts on screen.",
+      "PSK Reporter panel fixes: the history is asked for in both feed scopes and refreshed every five minutes, so a target picked shortly after start-up no longer shows an empty page; the suggested transmit offset always has an answer when there is data; and the texts say ten minutes, which is the window actually used.",
+      "Callbook lookup: a compound callsign with a page of its OWN keeps that page’s location. HP/WE9G is filed on QRZ under exactly that form, with the Panama address and square the station is operating from, and OpsLog was throwing it away — the rule that drops a home address from a portable call was applying to pages that describe the operation itself. The record’s own country tells the two apart. Cached lookups heal on the next read; QSOs already logged without a grid keep it empty."
+    ],
+    "fr": [
+      "[NEW] Widget rotor redessiné : carte du monde nocturne derrière une échelle d’azimut carrée, aiguille orange qui suit la souris pour qu’un clic parte où on vise, repère jaune sur l’azimut demandé jusqu’à l’arrivée de l’antenne, et directions rapides en colonnes de six. Le boom Ultrabeam et son deuxième lobe sont toujours tracés, et Station Control garde le cadran seul — rien en dessous, ce qui y était se retrouvait coupé en bas de la rangée. Design proposé par EC1KD — merci à lui.",
+      "[NEW] Réglages → Rotator permet de choisir le cadran : la nouvelle boussole carte du monde ou le cadran classique. Les deux sont conservés — l’un se lit de loin, l’autre est le cadran compact d’avant — et le choix s’applique aussitôt au widget docké comme à Station Control.",
+      "Widget rotor : le bouton Stop ne clignote plus sur un rotor à l’arrêt. Le mouvement était déduit d’un changement d’un degré, soit moins que le tremblement de lecture d’un contrôleur au repos.",
+      "[NEW] Un panneau watchlist docké, qui ne montre que ce qui est EN L’AIR et manque encore — une ligne par bande et mode — indicatif, bande, mode, ce que ça vaut, il y a combien de temps — le plus frais en haut, clic pour s’y caler, avec le badge NEW DXCC / NEW BAND / NEW SLOT du cluster sur chaque ligne. L’onglet Watchlist est un onglet, et en FT8 on vit sur celui des décodes : une station qu’on avait demandé à surveiller apparaissait sur un écran qu’on ne regardait pas. À activer avec la cloche dans la barre d’outils.",
+      "[NEW] FT decodes : une colonne distance, à côté du locator dont elle est calculée et dans votre unité (km ou miles). Arrondie à l’unité — un locator à quatre caractères est un carré de plusieurs dizaines de kilomètres, rien de plus fin ne serait honnête.",
+      "[NEW] Le panneau PSK Reporter bascule sur la station que l’auto-call ATTEND (le sablier), tant que rien n’est appelé. Son analyse met une requête d’historique et une période ou deux à se remplir : la lancer quand le DX se libère enfin, c’est la lancer trop tard — l’attente sert précisément à ça.",
+      "[NEW] Chase new : sélection de bandes propre au panneau, sous l’option (160 m à 70 cm). La liste de bandes de la station s’applique toujours en dessous — celle-ci dit ce qu’on veut SURVEILLER ce soir.",
+      "Chase new : le panneau indique l’état du flux — connecté ou non, nombre de rapports reçus, nombre de carrés de réception souscrits. Une liste vide ne disait rien sur ce qui arrivait vraiment.",
+      "FT decodes : une colonne récepteur apparaît quand plusieurs décodeurs alimentent la liste fusionnée, et la liste se vide pour un récepteur qui change de bande — un demi-écran de stations devenues inaccessibles est pire qu’un écran vide.",
+      "FT decodes : un badge WL rose marque une station de votre watchlist, et l’horloge de période passe au rouge en émission. C’est le seul élément qui bouge à l’écran, donc « suis-je en émission » se lit de loin.",
+      "FT decodes : un message qui VOUS est adressé s’affiche en vert, en entier et en gras, avec un liseré vert sur la ligne — lisible de l’autre bout du shack. La station que vous appelez garde une teinte légère et son indicatif en rouge : l’essentiel de ce qu’elle émet s’adresse à d’autres, et colorer ces lignes pareil laissait croire à un QSO en cours.",
+      "Cluster : « superfox », « super fox », « fox/hound » et « F/H » dans un commentaire de spot sont lus comme du FT8. Ce sont les modes d’émission DXpédition de WSJT-X, pas des modes en soi, et le commentaire retombait sur le mode par défaut de la bande.",
+      "Auto-call : ce qu’il appelle, et dans quel ordre. Il ne répond qu’à ce que la liste des décodes AFFICHE — les filtres du dessus (CQ seul, LoTW seul, les pastilles de catégorie, les continents, le rapport minimum, la recherche) pilotent désormais l’émission autant que l’œil, et l’option distincte « utilisateurs LoTW uniquement » disparaît. Un nouveau préfixe, comté, état, locator ou parc vaut aussi un appel, au dernier barreau de l’échelle et seulement pour ce que vous chassez (Réglages → DX Cluster). Un indicatif en watchlist passe devant tout ce qui n’y est pas, un vrai besoin devant un besoin non confirmé de même niveau, et une meilleure station peut prendre la place d’une autre qui n’a pas encore répondu — jamais celle d’un QSO en cours.",
+      "Auto-call : il appelle À TRAVERS un pile-up. Il abandonnait dès que la station appelée répondait à quelqu’un d’autre — or c’est exactement ce que fait un DX avec une file, et le seul moyen d’être le suivant est de continuer à appeler pendant qu’il travaille les autres. Toujours borné par les compteurs d’appels et de ratés, et une station en plein échange n’est toujours jamais CHOISIE comme nouvelle cible.",
+      "Auto-call : sécurité et contrôle. Il est toujours ARRÊTÉ au lancement et après un changement de profil, jamais armé depuis un réglage enregistré — c’est la seule fonction qui met la station en émission toute seule, et OpsLog démarre avec Windows. Halt devient un verdict : la station est mise de côté pour la session et n’est plus appelée jusqu’à ce que l’auto-call soit désactivé puis réactivé. Il dit ce qu’il attend, en affichant à côté du bouton Auto la station voulue qui travaille quelqu’un d’autre. Et il peut journaliser chaque décision (Réglages → DXHunter) : une ligne par période disant ce qui était sur l’air et pourquoi chaque station a été refusée.",
+      "Auto-call : série de corrections issues du trafic. Il ne coupe plus votre 73, n’appelle plus avec quatre à six secondes de retard, ne lance plus un appel pour le couper une seconde après, ne laisse plus sans réponse une station qui vous appelle, lit correctement les doubles réponses MSHV sur une même ligne, ne refuse plus presque tout ce qui passe parce qu’il prenait le « worked » de l’entité pour celui de la station, et ne démarre plus avec deux ratés au compteur sur une station tout juste choisie.",
+      "Changer de profil ne laisse plus les verdicts du carnet précédent à l’écran. En revenant d’un profil au log vide, tous les décodes et spots restaient marqués NEW jusqu’au redémarrage : l’index des contacts, la liste chase new et les verdicts en cache sont désormais vidés au changement de carnet.",
+      "Chase new, corrections : l’en-tête compte à la fois ce que les filtres montrent et ce que le panneau contient (« 3 sur 12 entendues »), un jeu de filtres enregistré qui cache tout est ignoré, et le passage entre « new » et « new + non confirmés » relit la liste au lieu de laisser d’anciens verdicts à l’écran.",
+      "Panneau PSK Reporter, corrections : l’historique est demandé dans les deux portées du flux et rafraîchi toutes les cinq minutes, donc une cible choisie peu après le démarrage n’affiche plus une page vide ; l’offset d’émission suggéré donne toujours une réponse quand il y a des données ; et les textes annoncent dix minutes, la fenêtre réellement utilisée.",
+      "Recherche callbook : un indicatif composé qui a sa PROPRE fiche garde la position de cette fiche. HP/WE9G est déposé sur QRZ sous cette forme exacte, avec l’adresse et le locator du Panama d’où la station émet, et OpsLog les jetait — la règle qui écarte l’adresse personnelle d’un indicatif portable s’appliquait aussi aux fiches qui décrivent l’opération elle-même. C’est le pays de la fiche qui les distingue. Les fiches en cache se corrigent à la lecture suivante ; les QSO déjà enregistrés sans locator le restent."
+    ]
+  },
   {
     "version": "0.27.12",
     "date": "",

frontend/src/App.tsx

@@ -12,7 +12,7 @@ import {
   ContestDupe,
   GetQSO, UpdateQSO, DeleteQSO, DeleteQSOs, DeleteAllQSO,
   UpdateQSOsFromCty, UpdateQSOsFromQRZ, UpdateQSOsFromClublog, UpdateQSOsCountyFromULS, ULSStatus, UploadQSOsManual, SendQSORecordingEmail,
-  LookupCallsign, GetStationSettings, GetListsSettings,
+  LookupCallsign, GetStationSettings, GetListsSettings, GetSatelliteNames,
   GetStartupStatus, CheckForUpdate, DownloadAndApplyUpdate, GetLiveStations, GetWhatsNew, GetChangelog,
   SMTPConfigured, SendLogToDeveloper,
   WorkedBefore,
@@ -54,7 +54,7 @@ import {
   GetFlexState, FlexAmpOperate,
   GetPSKReporterStatus, GetLiveOpenings, GetChaseNew,
   QSLViaRepairStatus, RepairQSLVia, DismissQSLViaRepair,
-  GetAutoCallStatus, SetAutoCall, SetAutoCallOnly, TakeAutoCallTarget, ResetAutoCall,
+  GetAutoCallStatus, SetAutoCall, SetAutoCallOnly, TakeAutoCallTarget, HaltAutoCall, WatchlistEntries,
 } from '../wailsjs/go/main/App';
 import { Combobox } from '@/components/ui/combobox';
 import { applyAwardRefs, parseAwardRefs as parseManualRefs, spotRefList , withIOTARef, withRDARef } from '@/lib/awardRefs';
@@ -80,6 +80,7 @@ import { ConfirmDialog } from '@/components/ConfirmDialog';
 import { SettingsModal } from '@/components/SettingsModal';
 import { FTMapPanel } from '@/components/FTMapPanel';
 import { DXpeditionsPanel } from '@/components/DXpeditionsPanel';
+import { SatellitePanel } from '@/components/SatellitePanel';
 import { FirstRunModal } from '@/components/FirstRunModal';
 import { QSOEditModal } from '@/components/QSOEditModal';
 import { BandMap } from '@/components/BandMap';
@@ -119,10 +120,14 @@ import { DetailsPanel, type DetailsState } from '@/components/DetailsPanel';
 import { SendSpotModal, type RecentSpotQSO } from '@/components/SendSpotModal';
 import { WinkeyerPanel, type WKStatus, type WKMacro } from '@/components/WinkeyerPanel';
 import { RotorCompass } from '@/components/RotorCompass';
+import { RotorCompassClassic } from '@/components/RotorCompassClassic';
+import { WatchlistWidget } from '@/components/WatchlistWidget';
+import { rotorStyle, subscribeRotorStyle } from '@/lib/rotorStyle';
 import { GridSquareMap } from '@/components/GridSquareMap';
 import { loadClusterMacros, visibleClusterMacros } from '@/lib/clusterMacros';
 import { DecodesPanel, type Decode as DecodeRow, type TxMsg as TxMsgRow } from '@/components/DecodesPanel';
 import { PSKReporterPanel } from '@/components/PSKReporterPanel';
+import { decoderName } from '@/lib/decoderName';
 import { subscribeRotorHeading, pokeRotorHeading } from '@/lib/rotorHeading';
 import { writeUiPref } from '@/lib/uiPref';
 import { formatDateTimeUTC } from '@/lib/dateFormat';
@@ -146,6 +151,7 @@ import { cn } from '@/lib/utils';
 import { pathBetween, pathBetweenLatLon, gridToLatLon, latLonToGrid } from '@/lib/maidenhead';
 import { flagURL } from '@/lib/flags';
 import { LogViewer } from '@/components/LogViewer';
+import { convertRST, rstFitsMode, stepRST } from '@/lib/rst';
 
 type QSO = QSOForm;
 type ImportResult = adifModels.ImportResult;
@@ -300,8 +306,12 @@ function FreqWheelDisplay({ mhz, onNudge, className, placeholder = '—.——
 // pill. The full message stays in the tooltip. Recognises the common cases
 // (OmniRig not installed, not registered) and otherwise truncates.
 // RadioChip — the CAT status chip, and the radio picker behind it.
-function RadioChip({ catUp, catState, onOpenSettings }: {
+function RadioChip({ catUp, catState, onOpenSettings, onRadioSwitched }: {
   catUp: boolean; catState: any; onOpenSettings: () => void;
+  // Switching radio here IS a settings change — the chosen entry becomes the CAT
+  // settings — so whatever reads those has to be told. Two Icoms swapped for one
+  // another never change the live backend name, and nothing else would notice.
+  onRadioSwitched?: () => void;
 }) {
   const [radios, setRadios] = useState<any[]>([]);
   const [open, setOpen] = useState(false);
@@ -366,7 +376,7 @@ function RadioChip({ catUp, catState, onOpenSettings }: {
               onClick={() => {
                 setOpen(false);
                 if (r.active) return;
-                SetActiveRadio(r.id).then(load).catch(() => {});
+                SetActiveRadio(r.id).then(() => { load(); onRadioSwitched?.(); }).catch(() => {});
               }}
               className={cn('flex w-full items-center gap-2 px-2.5 py-1 text-left text-xs hover:bg-muted',
                 r.active && 'font-semibold text-primary')}
@@ -653,6 +663,11 @@ export default function App() {
   useEffect(() => { rstListsRef.current = rstLists; }, [rstLists]);
   const [rstSent, setRstSent] = useState('59');
   const [rstRcvd, setRstRcvd] = useState('59');
+  // Read by applyModePreset, which runs from those same long-lived closures.
+  const rstSentRef = useRef(rstSent);
+  const rstRcvdRef = useRef(rstRcvd);
+  useEffect(() => { rstSentRef.current = rstSent; }, [rstSent]);
+  useEffect(() => { rstRcvdRef.current = rstRcvd; }, [rstRcvd]);
   const [grid, setGrid] = useState('');
   const [name, setName] = useState('');
   const [qth, setQth] = useState('');
@@ -707,6 +722,15 @@ export default function App() {
   // hide the rig ON/OFF buttons on USB, where the interface is unpowered when the
   // rig is off so power-ON can't work).
   const [catBackend, setCatBackend] = useState('');
+  // icomConfigured is "this station's radio IS an Icom", from the settings
+  // rather than from the link.
+  //
+  // The console used to appear only once the rig was talking. Switching to an
+  // Icom that was switched OFF therefore showed no console at all — and the
+  // console is where the ON button lives, so the one moment the button exists
+  // for was the one moment it could not be reached.
+  const icomConfigured = catBackend === 'icom' || catBackend === 'icom-net';
+  const icomShown = catState.backend === 'icom' || icomConfigured;
   // Live space-weather (solar flux / sunspots / A / K) for the header strip.
   // Loaded on mount, refreshed on the backend 'solar:update' event, plus a slow
   // fallback poll. These same numbers are stamped onto each logged QSO.
@@ -1331,6 +1355,17 @@ export default function App() {
   }
   const [ftmapTabOpen, setFtmapTabOpen] = useState(() => localStorage.getItem('opslog.ftmapTab') === '1');
   const [dxpedTabOpen, setDxpedTabOpen] = useState(() => localStorage.getItem('opslog.dxpedTab') === '1');
+  const [satTabOpen, setSatTabOpen] = useState(() => localStorage.getItem('opslog.satTab') === '1');
+  function openSatTab() {
+    setSatTabOpen(true);
+    writeUiPref('opslog.satTab', '1');
+    setActiveTab('sat');
+  }
+  function closeSatTab() {
+    setSatTabOpen(false);
+    writeUiPref('opslog.satTab', '0');
+    setActiveTab((t) => (t === 'sat' ? 'recent' : t));
+  }
   function openDxpedTab() {
     setDxpedTabOpen(true);
     writeUiPref('opslog.dxpedTab', '1');
@@ -2406,6 +2441,17 @@ export default function App() {
   // the watchlist panel: a call can be added from the cluster or the
   // DXpeditions tab, and the old inline message lived on a page nobody was
   // looking at.
+  // The watch list as patterns, for the decodes badge. Loaded once and kept in
+  // step with the same event the notice below listens to — a call added from
+  // the cluster has to light up in the decodes list too.
+  const [watchPatterns, setWatchPatterns] = useState<string[]>([]);
+  const loadWatchPatterns = useCallback(() => {
+    WatchlistEntries()
+      .then((es: any[]) => setWatchPatterns((es ?? []).map((e: any) => String(e?.callsign ?? '')).filter(Boolean)))
+      .catch(() => {});
+  }, []);
+  useEffect(() => { loadWatchPatterns(); }, [loadWatchPatterns]);
+  useEffect(() => EventsOn('watchlist:changed', () => loadWatchPatterns()), [loadWatchPatterns]);
   const [wlNotice, setWlNotice] = useState<{ call: string; added: boolean } | null>(null);
   const wlNoticeTimer = useRef<number | undefined>(undefined);
   useEffect(() => EventsOn('watchlist:changed', (e: any) => {
@@ -2597,6 +2643,33 @@ export default function App() {
   // Staged like the cluster's, so a period arriving as one burst of fifty
   // packets costs one status lookup and one render, not fifty of each.
   const pendingDecodesRef = useRef<DecodeRow[]>([]);
+  // The band each receiver was last decoding on. A band change empties that
+  // receiver's list — see the flush below.
+  const decoderBandRef = useRef<Map<string, string>>(new Map());
+
+  // The RIG changing band empties the list too, without waiting for the
+  // decoder to catch up.
+  //
+  // Clicking a watchlist row or a spot tunes the radio; the decoder follows on
+  // its own clock and its first decode on the new band is up to a period away.
+  // Until then the operator reads a screen of stations from a band they have
+  // left — which is the moment the list is most misleading, because it looks
+  // current. Only the receivers that were on the band we came FROM are
+  // cleared: a second decoder parked on another band has not moved.
+  const rigBandRef = useRef<string>('');
+  useEffect(() => {
+    const band = (catState.band ?? '').toLowerCase();
+    const was = rigBandRef.current;
+    rigBandRef.current = band;
+    if (!band || !was || was === band) return;
+    const stale = new Set<string>();
+    decoderBandRef.current.forEach((b2, inst) => { if (b2 === was) stale.add(inst); });
+    if (stale.size === 0) return;
+    stale.forEach((inst) => decoderBandRef.current.delete(inst));
+    pendingDecodesRef.current = pendingDecodesRef.current.filter((d) => !stale.has(d.instance ?? ''));
+    setDecodes((arr) => arr.filter((d) => !stale.has(d.instance ?? '')));
+    setTxMsgs((arr) => arr.filter((m) => !stale.has(m.instance ?? '')));
+  }, [catState.band]);
   const pendingDecodeTimer = useRef<number | undefined>(undefined);
 
   // Rotor quick-turn buttons (Settings → Rotator). Same reload trigger as the
@@ -2733,6 +2806,9 @@ export default function App() {
 
   // Portable UI toggles (mirrored to the DB via writeUiPref / syncPortablePrefs).
   const [showRotor, setShowRotor] = useState(() => localStorage.getItem('opslog.showRotor') !== '0');
+  // Off by default: it is an alerting panel, and one that appears uninvited on
+  // an operator who does not keep a watch list is just a box saying "empty".
+  const [showWatchWidget, setShowWatchWidget] = useState(() => localStorage.getItem('opslog.showWatchWidget') === '1');
   const [showAntGenius, setShowAntGenius] = useState(() => localStorage.getItem('opslog.showAntGenius') !== '0');
   const [showTuner, setShowTuner] = useState(() => localStorage.getItem('opslog.showTuner') !== '0');
   const [showScp, setShowScp] = useState(() => localStorage.getItem('opslog.showScp') !== '0');
@@ -2759,6 +2835,11 @@ export default function App() {
   // withholding them IS the compact mode, so there is no second layout to keep
   // in step with the first.
   const [rotorCompact, setRotorCompact] = useState(() => localStorage.getItem('opslog.rotorCompact') === '1');
+  // Which dial (Settings → Rotator). Subscribed rather than re-read on close, so
+  // the choice shows the moment it is made — it is picked by looking at it.
+  const [rotorDial, setRotorDial] = useState(() => rotorStyle());
+  useEffect(() => subscribeRotorStyle(() => setRotorDial(rotorStyle())), []);
+  const Compass2 = rotorDial === 'classic' ? RotorCompassClassic : RotorCompass;
 
   // Award code → scanned field (e.g. POTA→pota_ref, WWFF→wwff). Used to route
   // picked award references to the QSO field/extras each award actually reads.
@@ -3031,15 +3112,43 @@ export default function App() {
   const pokeUbStatus = useCallback(async () => {
     try { const s: any = await GetUltrabeamStatus(); if (s) setUbStatus(s); } catch { /* transient */ }
   }, []);
+  // A move was just ORDERED — from a button here or by the follow loop on a
+  // band change. Held for as long as it takes the antenna to answer, and no
+  // longer: the real status takes over the moment it arrives.
+  const [motorCmdAt, setMotorCmdAt] = useState(0);
+  const motorMoving = !!ubStatus.moving || (motorCmdAt > 0 && Date.now() - motorCmdAt < 2500);
+
+  // Three seconds while it sits still, half a second while it moves.
+  //
+  // The moving flag gags the transmitter, and this poll is the last of three
+  // delays between the elements stopping and the operator being allowed to call
+  // again — the antenna's own poll and the inhibit loop are the other two. At
+  // three seconds it was the largest of them: the antenna had finished, the
+  // radio was free, and the screen still said orange.
   useEffect(() => {
     let alive = true;
     const tick = async () => {
       try { const s: any = await GetUltrabeamStatus(); if (alive) setUbStatus(s); } catch {}
     };
     tick();
-    const id = window.setInterval(tick, 3000);
+    const id = window.setInterval(tick, motorMoving ? 400 : 3000);
     return () => { alive = false; window.clearInterval(id); };
-  }, []);
+  }, [motorMoving]);
+
+  // The backend says it at the instant the order goes out — see
+  // noteMotorMoveCommanded. Read at once as well, so the antenna's own answer
+  // replaces the assumption as soon as there is one.
+  useEffect(() => {
+    const off = EventsOn('motorant:move', () => {
+      setMotorCmdAt(Date.now());
+      pokeUbStatus();
+      window.setTimeout(pokeUbStatus, 350);
+      // And once the window is over, so "assumed moving" stops being assumed
+      // even if nothing else re-renders.
+      window.setTimeout(() => setMotorCmdAt((v) => (Date.now() - v >= 2500 ? 0 : v)), 2600);
+    });
+    return () => { off?.(); };
+  }, [pokeUbStatus]);
 
   // Poll the Antenna Genius switch for active antenna per port + the list.
   // Re-read the enabled flag each tick so toggling it in Settings makes the
@@ -3209,12 +3318,25 @@ export default function App() {
       setCatBackend(c.backend ?? '');
     } catch {}
   }, []);
+  // The configured backend follows every way the radio can change: the CAT
+  // panel's Save, a switch from the status bar's radio list, and the link
+  // itself reporting a different backend. It was read once at launch and after
+  // a Settings save only — so switching radio from the status bar left the
+  // console configured for the previous rig, and the Icom power buttons stayed
+  // hidden until the operator went into Settings and pressed Save for no
+  // reason.
+  useEffect(() => { loadCATCfg(); }, [catState.backend, loadCATCfg]);
+
   const loadLists = useCallback(async () => {
     try {
       const l: ListsSettings = await GetListsSettings();
       setRstLists({ phone: (l as any).rst_phone ?? [], cw: (l as any).rst_cw ?? [], digital: (l as any).rst_digital ?? [] });
       if (l.bands && l.bands.length) setBands(l.bands);
-      setSatellites([...(((l as any).satellites ?? []) as string[])].filter(Boolean).sort());
+      // The satellites come from the satellite side now, not from a list typed
+      // by hand in Settings: one station kept two lists of the same birds and
+      // they drifted apart. Go merges the followed set with whatever the old
+      // hand-kept list still holds, so nobody's typing is lost.
+      GetSatelliteNames().then((s) => setSatellites((s ?? []) as string[])).catch(() => {});
       if (l.modes && l.modes.length) {
         setModePresets(l.modes);
         const names = l.modes.map((m) => m.name);
@@ -3290,15 +3412,31 @@ export default function App() {
     return m;
   }
   function applyModePreset(m: string) {
-    if (rstUserEditedRef.current) return;
+    // AN EDIT IS ABOUT A SIGNAL, NOT ABOUT A NOTATION.
+    //
+    // The edited flag protects a report the operator chose — 57 rather than 59 —
+    // and it used to protect it across a change of mode as well, where it means
+    // nothing: "+00" is not a weak SSB report, it is not a report at all. An
+    // operator with a callsign in the field, switching from FT8 to SSB, was left
+    // with a decibel figure to log, and anything that fills the report from the
+    // rig (the S-meter readouts in the rig consoles) sets that flag too — so the
+    // field could be stuck in the wrong notation for the rest of the QSO.
+    //
+    // So the flag holds only while the report still belongs to the mode. When it
+    // does not, the judgement is carried across where it can be (57 → 579,
+    // 599 → 59) and the preset answers where it cannot.
+    const fits = rstFitsMode(rstSentRef.current, m) && rstFitsMode(rstRcvdRef.current, m);
+    if (rstUserEditedRef.current && fits) return;
     // Prefer the user's configured preset RST; otherwise fall back to the mode
     // category default (CW/RTTY/PSK → 599, phone → 59, digital → first option)
     // so switching SSB→CW flips 59→599 even without a configured preset.
     // Read through the refs, never the state: see their declaration.
     const p = modePresetsRef.current.find((x) => x.name === m);
     const fallback = rstOptions(m, rstListsRef.current)[0] || '';
-    setRstSent(p?.default_rst_sent || fallback);
+    const keep = (cur: string, preset: string) =>
-    setRstRcvd(p?.default_rst_rcvd || fallback);
+      (rstUserEditedRef.current && convertRST(cur, m)) || preset || fallback;
+    setRstSent(keep(rstSentRef.current, p?.default_rst_sent || ''));
+    setRstRcvd(keep(rstRcvdRef.current, p?.default_rst_rcvd || ''));
   }
   // Clicking a spot (cluster grid or any band map): tune the rig, set the mode,
   // fill the call, pre-fill POTA, (re)start the recording. Shared so every spot
@@ -3718,9 +3856,42 @@ export default function App() {
           });
         }
       } catch { /* status unresolved — the decode still shows, just unflagged */ }
+      // A BAND CHANGE empties that receiver's list.
+      //
+      // What is on 20 m says nothing about 40 m, and half a screen of stations
+      // that are no longer reachable is worse than an empty one: the period
+      // headings still march on, the rows still carry status badges, and the
+      // operator reads a band they have left. Per receiver — in a split view
+      // the other one has not moved — and only when the new band is known.
+      const moved = new Map<string, string>();
+      for (const d of batch) {
+        const inst = d.instance ?? '';
+        const band = (d.band ?? '').toLowerCase();
+        if (!band) continue;
+        const was = decoderBandRef.current.get(inst);
+        decoderBandRef.current.set(inst, band);
+        if (was && was !== band) moved.set(inst, band);
+      }
+      if (moved.size > 0) {
+        for (const [inst, band] of moved) {
+          LogUIError('decodes', `${decoderName(inst) || 'decoder'} moved to ${band.toUpperCase()} — its earlier decodes cleared`, '');
+        }
+        setTxMsgs((arr) => arr.filter((m) => !moved.has(m.instance ?? '')));
+      }
       setDecodes((arr) => {
         const cutoff = Date.now() - DECODE_KEEP_MS;
-        const next = [...arr, ...batch].filter((d) => Date.parse(d.at) >= cutoff);
+        // Rows from a receiver that has just changed band go with it — the
+        // batch itself is already on the new band.
+        const kept = moved.size === 0 ? arr : arr.filter((d) => !moved.has(d.instance ?? ''));
+        // The batch can straddle the change — a 300 ms flush can hold the last
+        // decodes of the old band and the first of the new. Only the new band
+        // survives for a receiver that moved.
+        const fresh = moved.size === 0 ? batch
+          : batch.filter((d) => {
+            const b2 = moved.get(d.instance ?? '');
+            return !b2 || (d.band ?? '').toLowerCase() === b2;
+          });
+        const next = [...kept, ...fresh].filter((d) => Date.parse(d.at) >= cutoff);
         return next;
       });
     };
@@ -4476,11 +4647,16 @@ export default function App() {
     const LABELS: Record<string, string> = {
       qrz: 'QRZ.com', clublog: 'Club Log', lotw: 'LoTW',
       hrdlog: 'HRDLog.net', eqsl: 'eQSL.cc', hamlog: 'HAMLOG.online',
+      hamqth: 'HamQTH', cloudlog: 'Cloudlog / Wavelog',
     };
     const label = LABELS[service] ?? service;
-    showToast(`Uploading ${ids.length} QSO${ids.length > 1 ? 's' : ''} to ${label}…`);
+    try {
-    try { await UploadQSOsManual(service, ids as any); }
+      // Awaited BEFORE the toast: the backend refuses a service with no
-    catch (e: any) { setError(String(e?.message ?? e)); }
+      // credentials, and announcing an upload that was never started is how an
+      // operator concludes their QSOs are on a site they never signed up to.
+      await UploadQSOsManual(service, ids as any);
+      showToast(`Uploading ${ids.length} QSO${ids.length > 1 ? 's' : ''} to ${label}…`);
+    } catch (e: any) { setError(String(e?.message ?? e)); }
   }
   // Right-click "Export filtered to ADIF (no limit)": exports every QSO that
   // matches the current filter, bypassing the on-screen row threshold.
@@ -5050,6 +5226,7 @@ export default function App() {
     { name: 'tools', label: t('menu.tools'), items: [
       { type: 'item', label: t('tools.qslManager'), action: 'tools.qslmanager' },
       { type: 'item', label: t('dxp.tab'), action: 'tools.dxped' },
+      { type: 'item', label: t('sat.tab'), action: 'tools.sat' },
       { type: 'item', label: t('stats.tab'), action: 'tools.stats' },
       { type: 'item', label: t('station.title'), action: 'tools.station' },
       { type: 'item', label: t('tools.qslDesigner'), action: 'tools.qsldesigner' },
@@ -5107,6 +5284,7 @@ export default function App() {
       case 'tools.stats':       setStatsTabOpen(true); setActiveTab('stats'); break;
       case 'tools.station':     setStationTabOpen(true); setActiveTab('station'); break;
       case 'tools.dxped':       openDxpedTab(); break;
+      case 'tools.sat':         openSatTab(); break;
       case 'tools.decodes':     openDecodesTab(); break;
       case 'tools.ftmap':       openFtmapTab(); break;
       case 'tools.grids':       openGridsTab(); break;
@@ -5392,12 +5570,19 @@ export default function App() {
   );
   const rstTxBlock = (
     <div className="flex flex-col w-20" data-esm="rsttx"><Label className="mb-1 h-3.5">{t('field.rstTx')}</Label>
-      <Combobox value={rstSent} options={rstOptions(mode, rstLists)} commitOnType onChange={(v) => { setRstSent(v); rstUserEditedRef.current = true; }} />
+      {/* The wheel steps the report — an S-unit on RST, a decibel on a digital
+          one. Wheeling is the same gesture as saying "he is a bit stronger than
+          that", and it beats retyping three characters between overs. */}
+      <Combobox value={rstSent} options={rstOptions(mode, rstLists)} commitOnType
+        onChange={(v) => { setRstSent(v); rstUserEditedRef.current = true; }}
+        onWheelStep={(d) => { setRstSent((v) => stepRST(v, d, mode)); rstUserEditedRef.current = true; }} />
     </div>
   );
   const rstRxBlock = (
     <div className="flex flex-col w-20" data-esm="rstrx"><Label className="mb-1 h-3.5">{t('field.rstRx')}</Label>
-      <Combobox value={rstRcvd} options={rstOptions(mode, rstLists)} commitOnType onChange={(v) => { setRstRcvd(v); rstUserEditedRef.current = true; }} />
+      <Combobox value={rstRcvd} options={rstOptions(mode, rstLists)} commitOnType
+        onChange={(v) => { setRstRcvd(v); rstUserEditedRef.current = true; }}
+        onWheelStep={(d) => { setRstRcvd((v) => stepRST(v, d, mode)); rstUserEditedRef.current = true; }} />
     </div>
   );
   // DX country flag, shown large next to RST (moved here from the Country field).
@@ -5759,7 +5944,29 @@ export default function App() {
     const mhz = parseFloat(mhzStr);
     if (!Number.isFinite(mhz) || mhz < 0.1 || mhz > 3000) return;
     noteManualEdit();
-    SetCATFrequency(Math.round(mhz * 1_000_000)).catch(() => {});
+    const hz = Math.round(mhz * 1_000_000);
+    SetCATFrequency(hz).catch(() => {});
+    tuneModeForWateringHole(hz);
+  };
+
+  // 28.074 IS FT8, and typing it says so.
+  //
+  // A spot click has always carried a mode; a frequency typed by hand carried
+  // none, so the rig stayed in whatever it was — an FTDX3000 landing on 28.074
+  // in USB while the operator waited for decodes. Nobody tunes a watering hole
+  // to listen to it in SSB, and this is the same table and the same tolerance a
+  // spot click is judged with (±3 kHz of a known digital frequency).
+  //
+  // Only when it actually changes something, and only towards the digital
+  // modes: tuning away from 28.074 leaves the mode alone, because there the
+  // frequency says nothing about what the operator means to do.
+  const tuneModeForWateringHole = (hz: number) => {
+    const m = inferDigitalMode(hz);
+    if (!m || m === mode) return;
+    setMode(m);
+    applyModePreset(m);
+    if (catState.enabled && catState.connected && !locks.mode) SetCATMode(m).catch(() => {});
+    ConfigureDecoderMode(m).catch(() => {});
   };
   // Carry out what was typed in the call field. Bands go through the ordinary
   // band change, so the antennas, the power table and the outbound integrations
@@ -5777,6 +5984,7 @@ export default function App() {
     const b = bandForMHz(hz / 1_000_000);
     if (b) setBand(b);
     if (catState.enabled && catState.connected) SetCATFrequency(hz).catch(() => {});
+    tuneModeForWateringHole(hz);
     showToast((hz / 1_000_000).toFixed(3) + ' MHz');
   };
 
@@ -6278,13 +6486,41 @@ export default function App() {
   // Follow the station the digital application says it is calling. A decode
   // clicked here sets the target directly (see onCall); this covers the QSO
   // started from the other side — WSJT-X's own double-click, or auto-call.
+  //
+  // On the EDGE — when the decoder's DX call actually changes — and not by
+  // comparing it with the panel's current target: the auto-call effect below
+  // sets that target too, and two effects each restoring "their" value from the
+  // other's write is a loop, not a preference.
+  const pskDxRef = useRef('');
   useEffect(() => {
     const dx = (txState?.dx_call ?? '').toUpperCase().trim();
-    if (dx && dx !== pskTarget) {
+    if (!dx || dx === pskDxRef.current) return;
-      setPskTarget(dx);
+    pskDxRef.current = dx;
-      setPskTargetMode(txState?.mode ?? '');
+    setPskTarget(dx);
-    }
+    setPskTargetMode(txState?.mode ?? '');
-  }, [txState?.dx_call, txState?.mode, pskTarget]);
+  }, [txState?.dx_call, txState?.mode]);
+
+  // WAITING FOR A STATION IS ALREADY A REASON TO ANALYSE IT.
+  //
+  // Auto-call shows an hourglass for a station it wants and cannot call yet
+  // because that station is working somebody else. The analysis takes a moment
+  // to fill — the history query, then a period or two of live reports — so
+  // starting it at the instant the DX becomes free is starting it too late.
+  // The wait is dead time, and this is exactly what it is worth spending on.
+  //
+  // Only while nothing is actually being called: a real target is the panel's
+  // subject, and it arrives here through the decoder's DX call above.
+  const pskWaitRef = useRef('');
+  useEffect(() => {
+    const w = String(autoCallStatus?.waiting ?? '').toUpperCase().trim();
+    if (!w) { pskWaitRef.current = ''; return; }
+    if (autoCallStatus?.target) return;
+    if (w === pskWaitRef.current) return;
+    pskWaitRef.current = w;
+    setPskTarget(w);
+    setPskTargetMode(txState?.mode ?? mode ?? '');
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [autoCallStatus?.waiting, autoCallStatus?.target]);
 
   const renderDecodesPanel = () => (
     <div className="flex h-full min-h-0">
@@ -6314,6 +6550,37 @@ export default function App() {
     </div>
   );
 
+  // ONE CLICK TAKES THE STATION, TWO ANSWER IT — and the FT map means the same
+  // by them as the list does. They were written inline on the list, so the map
+  // had no way to offer the same gestures without a second copy of them.
+  function selectDecode(d: any) {
+    setPskTarget((d.call ?? '').toUpperCase());
+    setPskTargetMode(d.mode ?? '');
+    onCallsignInput(d.call, { force: true });
+  }
+  function callDecode(d: any) {
+    // The station being answered is also the one worth analysing: the PSK
+    // Reporter panel follows the click rather than asking for a second one.
+    setPskTarget((d.call ?? '').toUpperCase());
+    setPskTargetMode(d.mode ?? '');
+    // Auto-call adopts the station: the click chooses WHO, the watchdogs still
+    // decide how long it is called for.
+    TakeAutoCallTarget(d.call ?? '', d.band ?? '', d.mode ?? '').catch(() => {});
+    onCallsignInput(d.call, { force: true });
+    // With two slices on two bands, the Reply reaches the right INSTANCE but the
+    // radio still transmits on whichever slice holds the TX flag. Move it to the
+    // decode's band first, or an 80 m answer goes out on 20 m. A no-op on any
+    // backend without slices.
+    FlexTXOnBand(d.band ?? '').catch(() => { /* not a Flex, or no such slice */ });
+    AnswerDecode(
+      d.instance ?? '', d.ms ?? 0, d.snr, d.dt ?? 0,
+      // The RAW mode marker, not the resolved name: the receiving application
+      // matches the Reply against its decode list field for field, and JTDX
+      // drops one that says "FT8" where it decoded "~".
+      d.audio_hz ?? 0, d.mode_raw || d.mode || '', d.msg_raw ?? d.msg ?? '', !!d.low_conf,
+    ).catch((e: any) => setError(String(e?.message ?? e)));
+  }
+
   const renderDecodesList = () => (
     <DecodesPanel
       decodes={decodes}
@@ -6325,6 +6592,7 @@ export default function App() {
       // compare with", never "the rig is on no band".
       rigBand={catState.connected ? (catState.band || '') : ''}
       myCall={station.callsign}
+      myGrid={station.my_grid}
       // A DOUBLE click answers the station: it hands the decode back to
       // WSJT-X/MSHV as a Reply, the same thing as double-clicking the line in
       // their own window. A single click only selects it — see onSelect below,
@@ -6337,33 +6605,8 @@ export default function App() {
       // One click: take the station, transmit nothing. The entry is filled and
       // the panels follow it, exactly as clicking a cluster spot does — so a
       // row can be inspected, looked up and read about without keying up.
-      onSelect={(d) => {
+      onSelect={selectDecode}
-        setPskTarget((d.call ?? '').toUpperCase());
+      onCall={callDecode}
-        setPskTargetMode(d.mode ?? '');
-        onCallsignInput(d.call, { force: true });
-      }}
-      onCall={(d) => {
-        // The station being answered is also the one worth analysing: the PSK
-        // Reporter panel follows the click rather than asking for a second one.
-        setPskTarget((d.call ?? '').toUpperCase());
-        setPskTargetMode(d.mode ?? '');
-        // Auto-call adopts the station: the click chooses WHO, the watchdogs
-        // still decide how long it is called for.
-        TakeAutoCallTarget(d.call ?? '', d.band ?? '', d.mode ?? '').catch(() => {});
-        onCallsignInput(d.call, { force: true });
-        // With two slices on two bands, the Reply reaches the right INSTANCE but
-        // the radio still transmits on whichever slice holds the TX flag. Move
-        // it to the decode's band first, or an 80 m answer goes out on 20 m.
-        // A no-op on any backend without slices.
-        FlexTXOnBand(d.band ?? '').catch(() => { /* not a Flex, or no such slice */ });
-        AnswerDecode(
-          d.instance ?? '', d.ms ?? 0, d.snr, d.dt ?? 0,
-          // The RAW mode marker, not the resolved name: the receiving
-          // application matches the Reply against its decode list field for
-          // field, and JTDX drops one that says "FT8" where it decoded "~".
-          d.audio_hz ?? 0, d.mode_raw || d.mode || '', d.msg_raw ?? d.msg ?? '', !!d.low_conf,
-        ).catch((e: any) => setError(String(e?.message ?? e)));
-      }}
       // Wipes the live view only — nothing here is stored, and the staging
       // buffer goes too or the next flush would put back what was just cleared.
       onClear={(instance) => {
@@ -6385,15 +6628,16 @@ export default function App() {
       // An empty instance lets the backend fall back to whichever application
       // last reported its status — the normal single-receiver case.
       onHalt={(instance) => {
-        // Halt means stop, including whatever auto-call had started — and it
+        // Halt is a verdict on the station being called: it is set aside for
-        // clears the engine's state, so a target it had given up on is not
+        // the session rather than released, or the next period would call it
-        // still sitting there when the operator switches it back on.
+        // straight back — which is exactly what the operator just stopped.
-        ResetAutoCall().catch(() => {});
+        HaltAutoCall().catch(() => {});
         HaltDecodeTx(instance, false).catch((e: any) => setError(String(e?.message ?? e)));
       }}
       autoCallOn={!!autoCallStatus?.enabled}
       onToggleAutoCall={toggleAutoCall}
       autoCall={autoCallStatus}
+      watchlist={watchPatterns}
       autoCallOnly={autoCallStatus?.only ?? ''}
       onSetAutoCallOnly={(list) => {
         setAutoCallStatus((st: any) => ({ ...st, only: list.toUpperCase() }));
@@ -6677,9 +6921,9 @@ export default function App() {
             {/* Motorized-antenna pattern (Normal / 180° reverse / Bidirectional), next to the azimuth. */}
             {ubStatus.enabled && (
               <div className="inline-flex items-center rounded-full border border-success-border bg-success-muted overflow-hidden text-[10px] font-semibold ml-1"
-                title={ubStatus.connected ? (ubStatus.moving ? 'Antenna: moving…' : 'Antenna pattern') : 'Antenna: connecting…'}>
+                title={ubStatus.connected ? (motorMoving ? 'Antenna: moving…' : 'Antenna pattern') : 'Antenna: connecting…'}>
                 <button type="button" className="pl-1.5 pr-0.5 flex items-center" onClick={() => { setSettingsSection('antenna'); setShowSettings(true); }} title="Antenna settings">
-                  <span className={cn('size-2 rounded-full', ubStatus.connected ? (ubStatus.moving ? 'bg-warning' : 'bg-success') : 'bg-muted-foreground/40')} />
+                  <span className={cn('size-2 rounded-full', ubStatus.connected ? (motorMoving ? 'bg-warning' : 'bg-success') : 'bg-muted-foreground/40')} />
                 </button>
                 {([{ d: 0, l: 'N', t: 'Normal' }, { d: 1, l: '180°', t: 'Reverse (180°)' }, { d: 2, l: 'Bi', t: 'Bidirectional' }]).map((o) => (
                   <button key={o.d} type="button" disabled={!ubStatus.connected} title={o.t}
@@ -6737,6 +6981,18 @@ export default function App() {
               <Ear className="size-4" />
               {cwOn && cwStatus.active && <span className="absolute -top-0.5 -right-0.5 size-2 rounded-full bg-success animate-pulse" />}
             </button>
+            <button
+              type="button"
+              onClick={() => { const v = !showWatchWidget; setShowWatchWidget(v); writeUiPref('opslog.showWatchWidget', v ? '1' : '0'); }}
+              title={showWatchWidget ? t('wlw.hide') : t('wlw.show')}
+              className={cn(
+                'relative inline-flex items-center justify-center size-7 rounded-md border transition-colors',
+                showWatchWidget ? 'border-success-border bg-success-muted text-success-muted-foreground hover:bg-success-muted'
+                  : 'border-border text-muted-foreground hover:bg-muted',
+              )}
+            >
+              <Bell className="size-4" />
+            </button>
             <button
               type="button"
               onClick={() => { const v = !showRotor; setShowRotor(v); writeUiPref('opslog.showRotor', v ? '1' : '0'); }}
@@ -6764,8 +7020,8 @@ export default function App() {
                 {/* Amber while the elements travel: on a SteppIR that is also
                     when transmitting is a bad idea, so it is worth seeing from
                     the icon without opening the widget. */}
-                {ubStatus.moving && <span className="absolute -top-0.5 -right-0.5 size-2 rounded-full bg-warning animate-pulse" />}
+                {motorMoving && <span className="absolute -top-0.5 -right-0.5 size-2 rounded-full bg-warning animate-pulse" />}
-                {!ubStatus.moving && showMotorAnt && ubStatus.connected && <span className="absolute -top-0.5 -right-0.5 size-2 rounded-full bg-success" />}
+                {!motorMoving && showMotorAnt && ubStatus.connected && <span className="absolute -top-0.5 -right-0.5 size-2 rounded-full bg-success" />}
               </button>
             )}
             {agEnabled && (
@@ -7219,12 +7475,30 @@ export default function App() {
                     {e.date && <span className="text-[11px] text-muted-foreground">{e.date}</span>}
                   </div>
                   <ul className="space-y-1.5 text-sm">
-                    {(clLang === 'fr' ? e.fr : e.en).map((line, i) => (
+                    {(clLang === 'fr' ? e.fr : e.en).map((line, i) => {
-                      <li key={i} className="flex gap-2">
+                      // "[NEW] " at the head of an entry marks a new FEATURE, as
-                        <span className="text-primary mt-1.5 size-1.5 rounded-full bg-primary shrink-0" />
+                      // opposed to a fix to one. The marker is written in the
-                        <span>{line}</span>
+                      // changelog file itself and is the same in both languages,
-                      </li>
+                      // so one convention covers EN and FR; it is stripped here
-                    ))}
+                      // and drawn as a pill. A release is mostly fixes, and the
+                      // two or three things that are actually new should not have
+                      // to be found by reading all of it.
+                      const isNew = line.startsWith('[NEW] ');
+                      const text = isNew ? line.slice(6) : line;
+                      return (
+                        <li key={i} className="flex gap-2">
+                          <span className={cn('mt-1.5 size-1.5 rounded-full shrink-0', isNew ? 'bg-success' : 'bg-primary')} />
+                          <span>
+                            {isNew && (
+                              <span className="mr-1.5 align-[1px] rounded px-1 py-px text-[10px] font-bold uppercase tracking-wide bg-success text-success-foreground">
+                                {t('whatsnew.newTag')}
+                              </span>
+                            )}
+                            {text}
+                          </span>
+                        </li>
+                      );
+                    })}
                   </ul>
                 </div>
               ))}
@@ -7446,7 +7720,7 @@ export default function App() {
       {/* Reserved free space to the right. The WinKeyer CW keyer and/or the
           Digital Voice Keyer take this slot when enabled (Log4OM-style);
           otherwise it shows the QRZ profile photo. */}
-      {!compact && (chatShown || wkEnabled || dvkEnabled || lookupResult?.image_url || (showRotor && (rotatorHeading.enabled || dxPath)) || (showMotorAnt && ubStatus.enabled) || (showAntGenius && agEnabled) || (showTuner && tgEnabled) || (showAmpWidget && ampSts.length > 0) || (showScp && scpEnabled) || (chaseNewOn && showChaseNew) || (showLiveStations && dbConn?.backend === 'mysql')) && (
+      {!compact && (chatShown || wkEnabled || dvkEnabled || lookupResult?.image_url || (showRotor && (rotatorHeading.enabled || dxPath)) || (showMotorAnt && ubStatus.enabled) || (showAntGenius && agEnabled) || (showTuner && tgEnabled) || (showAmpWidget && ampSts.length > 0) || (showScp && scpEnabled) || (chaseNewOn && showChaseNew) || showWatchWidget || (showLiveStations && dbConn?.backend === 'mysql')) && (
         // relative + absolute inner (like the F1-F5 panel): a taller widget (e.g.
         // the DVK with Auto CQ) can't grow the row — the row height stays set by
         // the entry strip and each widget fills that height, scrolling inside.
@@ -7509,10 +7783,27 @@ export default function App() {
           {/* Rotor compass: azimuth dial + needles + click-to-turn. Shows when a
               rotator is configured or a DX bearing exists. Compact mode drops the
               controls column, so the widget is just the dial and needs only its
-              width. */}
+              width. The classic dial sizes itself from the inside and expects a fixed
+              column; the current one asks for the width it needs. */}
+          {showWatchWidget && (
+            <div className="w-[290px] shrink-0 min-h-0" style={{ order: wOrder('watchlist') }}>
+              {/* Same handler as a cluster row, for the same reason as Chase
+                  new: a row here IS a spot, and half the reflex — the call
+                  without the frequency, or the frequency without the mode — is
+                  what makes a shortcut not worth using. */}
+              <WatchlistWidget
+                spots={spots}
+                spotStatus={spotStatus as any}
+                onPick={(s) => handleSpotClick(s as any)}
+                onClose={() => { setShowWatchWidget(false); writeUiPref('opslog.showWatchWidget', '0'); }}
+              />
+            </div>
+          )}
           {showRotor && (rotatorHeading.enabled || dxPath) && (
-            <div className={cn('shrink-0 min-h-0', rotorCompact ? 'w-[196px]' : 'w-[320px]')} style={{ order: wOrder('rotor') }}>
+            <div className={cn('shrink-0 min-h-0',
-              <RotorCompass
+              rotorCompact ? 'w-[196px]' : rotorDial === 'classic' ? 'w-[320px]' : 'w-auto')}
+              style={{ order: wOrder('rotor') }}>
+              <Compass2
                 presets={rotorCompact ? undefined : rotorPresets}
                 onStop={rotorCompact ? undefined : () => { RotatorStop().then(pokeRotorHeading).catch((err) => setError(String(err?.message ?? err))); }}
                 bearing={dxPath?.bearingShort ?? null}
@@ -7533,7 +7824,7 @@ export default function App() {
           {showMotorAnt && ubStatus.enabled && (
             <div className="w-[230px] shrink-0 min-h-0" style={{ order: wOrder('motorant') }}>
               <MotorAntennaWidget
-                ant={ubStatus}
+                ant={{ ...ubStatus, moving: motorMoving }}
                 refetch={pokeUbStatus}
                 t={t}
                 essentialsOnly
@@ -7820,7 +8111,7 @@ export default function App() {
                 </TabsTrigger>
               )}
               {catState.backend === 'flex' && <TabsTrigger value="flex">Flex Console</TabsTrigger>}
-              {catState.backend === 'icom' && <TabsTrigger value="icom">Icom Console</TabsTrigger>}
+              {icomShown && <TabsTrigger value="icom">Icom Console</TabsTrigger>}
               {catState.backend === 'yaesu' && <TabsTrigger value="yaesu">Yaesu Console</TabsTrigger>}
             {(catState.backend === 'elecraft' || catState.backend === 'kenwood') && <TabsTrigger value="elecraft">{t('k3.console')}</TabsTrigger>}
             {catState.backend === 'tci' && <TabsTrigger value="tci">{t('tcip.console')}</TabsTrigger>}
@@ -7887,6 +8178,21 @@ export default function App() {
                   </span>
                 </TabsTrigger>
               )}
+              {satTabOpen && (
+                <TabsTrigger value="sat" className="gap-1.5">
+                  {t('sat.tab')}
+                  <span
+                    role="button"
+                    aria-label="Close Satellites"
+                    title="Close"
+                    className="inline-flex items-center justify-center size-4 rounded hover:bg-foreground/10 text-muted-foreground hover:text-foreground"
+                    onPointerDown={(e) => { e.stopPropagation(); }}
+                    onClick={(e) => { e.stopPropagation(); closeSatTab(); }}
+                  >
+                    <X className="size-3" />
+                  </span>
+                </TabsTrigger>
+              )}
               {ftmapTabOpen && (
                 <TabsTrigger value="ftmap" className="gap-1.5">
                   {t('ftmap.tab')}
@@ -8535,11 +8841,24 @@ export default function App() {
                 )}
               </TabsContent>
             )}
+            {satTabOpen && (
+              <TabsContent value="sat" className="mt-0 flex flex-col min-h-0 flex-1 data-[state=inactive]:hidden">
+                {/* Mounted only while it is the visible tab: the panel polls the
+                    tuning once a second, and there is no reason to compute an
+                    orbit for a tab nobody is looking at. */}
+                {activeTab === 'sat' && (
+                  <div className="h-full w-full min-h-0">
+                    <SatellitePanel myGrid={station.my_grid} />
+                  </div>
+                )}
+              </TabsContent>
+            )}
             {ftmapTabOpen && (
               <TabsContent value="ftmap" className="mt-0 flex flex-col min-h-0 flex-1 data-[state=inactive]:hidden">
                 {activeTab === 'ftmap' && (
                   <div className="h-full w-full min-h-0 bg-card border border-border rounded-lg overflow-hidden">
-                    <FTMapPanel decodes={decodes as any} myGrid={station.my_grid} />
+                    <FTMapPanel decodes={decodes as any} myGrid={station.my_grid}
+                      onSelect={selectDecode} onCall={callDecode} />
                   </div>
                 )}
               </TabsContent>
@@ -8595,7 +8914,7 @@ export default function App() {
               </TabsContent>
             )}
 
-            {catState.backend === 'icom' && (
+            {icomShown && (
               <TabsContent value="icom" className="flex-1 min-h-0 p-0">
                 <IcomPanel isNetwork={catBackend === 'icom-net'} onReportRST={(r) => { setRstSent(r); rstUserEditedRef.current = true; }} />
               </TabsContent>
@@ -8766,6 +9085,7 @@ export default function App() {
               catUp={catUp}
               catState={catState}
               onOpenSettings={() => { setSettingsSection('cat'); setShowSettings(true); }}
+              onRadioSwitched={loadCATCfg}
             />
             <Chip
               on={rotatorHeading.enabled && rotatorHeading.ok}
@@ -9011,7 +9331,7 @@ export default function App() {
           onSaved={onSettingsSaved}
           onMainPaneChanged={onSettingsPaneChanged}
           flexAvailable={catState.backend === 'flex'}
-          icomAvailable={catState.backend === 'icom'}
+          icomAvailable={icomShown}
           yaesuAvailable={catState.backend === 'yaesu'}
           elecraftAvailable={catState.backend === 'elecraft' || catState.backend === 'kenwood'}
           tciAvailable={catState.backend === 'tci'}

frontend/src/components/AppearancePanel.tsx

@@ -304,13 +304,13 @@ export function AppearancePanel() {
 // place here: it comes back where the operator left it rather than at the end.
 export const WIDGET_KEYS = [
   'livestations', 'chat', 'rotor', 'motorant', 'antgenius',
-  'amp', 'tuner', 'scp', 'chasenew', 'dvk', 'winkeyer', 'photo',
+  'amp', 'tuner', 'scp', 'chasenew', 'watchlist', 'dvk', 'winkeyer', 'photo',
 ] as const;
 
 const WIDGET_LABELS: Record<string, string> = {
   livestations: 'wo.livestations', chat: 'wo.chat', rotor: 'wo.rotor',
   motorant: 'wo.motorant', antgenius: 'wo.antgenius', amp: 'wo.amp',
-  tuner: 'wo.tuner', scp: 'wo.scp', chasenew: 'wo.chasenew',
+  tuner: 'wo.tuner', scp: 'wo.scp', chasenew: 'wo.chasenew', watchlist: 'wo.watchlist',
   dvk: 'wo.dvk', winkeyer: 'wo.winkeyer', photo: 'wo.photo',
 };
 

frontend/src/components/ChaseNewPanel.tsx

@@ -15,7 +15,7 @@ import { useI18n } from '@/lib/i18n';
 import { chaseAllows } from '@/lib/spotDisplay';
 import { markerColour } from '@/lib/spotMarkers';
 import { cn } from '@/lib/utils';
-import { GetChaseNewSpots } from '../../wailsjs/go/main/App';
+import { GetChaseNewSpots, GetPSKReporterStatus } from '../../wailsjs/go/main/App';
 
 export interface ChaseNewSpot {
   call: string;
@@ -80,15 +80,25 @@ function categoryOf(s: ChaseNewSpot): Category | null {
 
 const FILTER_KEY = 'opslog.chaseNewFilters';
 
+function allowedCategories(): Category[] {
+  return CATEGORIES.filter((c) => chaseAllows(c.key)).map((c) => c.key);
+}
+
 function loadFilters(): Set<Category> {
+  const allowed = allowedCategories();
   try {
     const raw = localStorage.getItem(FILTER_KEY);
     if (raw) {
       const list = JSON.parse(raw) as Category[];
-      if (Array.isArray(list)) return new Set(list);
+      // A stored set holding NONE of the categories on offer hides the whole
+      // panel, for ever, with nothing to say why — and that is exactly what a
+      // preference written by an older build does once a category is renamed.
+      // Treated as "no preference": a panel that shows nothing at every launch
+      // is never what was meant, and the chips are one click away.
+      if (Array.isArray(list) && list.some((k) => allowed.includes(k))) return new Set(list);
     }
   } catch { /* a corrupt preference is not worth a broken panel */ }
-  return new Set(CATEGORIES.filter((c) => chaseAllows(c.key)).map((c) => c.key));
+  return new Set(allowed);
 }
 
 export function ChaseNewPanel({ onPick, onClose }: Props) {
@@ -96,6 +106,10 @@ export function ChaseNewPanel({ onPick, onClose }: Props) {
   const [spots, setSpots] = useState<ChaseNewSpot[]>([]);
   const [loaded, setLoaded] = useState(false);
   const [on, setOn] = useState<Set<Category>>(loadFilters);
+  // The FEED, not the list: connected or not, how many reports it has taken,
+  // and what it is filtered on. Without it an empty panel says nothing about
+  // whether anything is arriving at all — which is the first question.
+  const [feed, setFeed] = useState<any>(null);
 
   // Polled rather than pushed: the feed can deliver several a second under an
   // opening, and an event per row would be a redraw per row for a list nobody
@@ -106,6 +120,8 @@ export function ChaseNewPanel({ onPick, onClose }: Props) {
       try {
         const r = ((await GetChaseNewSpots()) ?? []) as ChaseNewSpot[];
         if (alive) { setSpots(r); setLoaded(true); }
+        const st = await GetPSKReporterStatus();
+        if (alive) setFeed(st);
       } catch { /* the feed may not be up yet */ }
     };
     tick();
@@ -154,8 +170,13 @@ export function ChaseNewPanel({ onPick, onClose }: Props) {
           ))}
         </div>
 
+        {/* Both numbers: what is on screen, and what was heard. They differ
+            exactly when a category is switched off, which is the one case an
+            operator reads this panel as broken. */}
         <span className="shrink-0 text-[10px] text-muted-foreground">
-          {loaded ? t('chn.count', { n: shown.length }) : ''}
+          {loaded ? (shown.length === spots.length
+            ? t('chn.count', { n: spots.length })
+            : t('chn.countOf', { n: shown.length, total: spots.length })) : ''}
         </span>
         {onClose && (
           <button
@@ -218,7 +239,16 @@ export function ChaseNewPanel({ onPick, onClose }: Props) {
         )}
       </div>
 
-      <p className="border-t border-border px-2 py-1 text-[10px] text-muted-foreground">{t('chn.digitalOnly')}</p>
+      {/* The radius comes from the FEED, not from a sentence: it was written
+          into this line as "~300 km" and stayed 300 while the setting said
+          1000, which is the panel telling the operator their change did not
+          take when it had. */}
+      <p className="border-t border-border px-2 py-1 text-[10px] text-muted-foreground">
+        {t('chn.heardWithin', { km: feed?.near_km || 300 })}
+        {feed && (feed.running
+          ? <span className="text-success"> · {t('chn.feedOn', { n: feed.received ?? 0, sq: feed.squares ?? 0 })}</span>
+          : <span className="text-warning"> · {feed.last_err ? t('chn.feedErr', { e: feed.last_err }) : t('chn.feedOff')}</span>)}
+      </p>
     </div>
   );
 }

frontend/src/components/DecodesPanel.tsx

@@ -12,13 +12,16 @@
 // Status flags (new entity / band / mode / slot / grid / prefix / POTA / county)
 // come from the same resolver the cluster uses, so a call means the same thing in
 // both panels rather than being judged twice by two rules.
-import { useEffect, useMemo, useState } from 'react';
+import { useCallback, useEffect, useMemo, useState } from 'react';
 import { AlertTriangle, Radio, Search, X, Signal, ArrowUpRight, Timer, Trash2, Ban, Columns2, Bot } from 'lucide-react';
 import { cn } from '@/lib/utils';
 import { useI18n } from '@/lib/i18n';
 import { chaseAllows } from '@/lib/spotDisplay';
+import { pathBetween } from '@/lib/maidenhead';
+import { distanceValue, distanceUnit, subscribeDistanceUnit } from '@/lib/units';
 import { markerColour, type SpotMarkerKey } from '@/lib/spotMarkers';
 import { writeUiPref } from '@/lib/uiPref';
+import { SetAutoCallVisible } from '../../wailsjs/go/main/App';
 import { decoderName } from '@/lib/decoderName';
 
 export type Decode = {
@@ -104,6 +107,9 @@ interface Props {
   // point the panels at it. Absent, a click falls back to onCall.
   onSelect?: (d: Decode) => void;
   myCall?: string;
+  // The station's own square: distance is measured from it, and without one the
+  // column stays empty rather than guessing.
+  myGrid?: string;
   // Drop every decode and transmit message held for this panel. The list is a
   // live view, not data — clearing it costs nothing but the seconds until the
   // next period lands.
@@ -120,11 +126,14 @@ interface Props {
   autoCallOn?: boolean;
   onToggleAutoCall?: () => void;
   // The engine's own account of what it is doing, straight from the backend.
-  autoCall?: { target: string; calls: number; max: number; misses: number; max_miss: number; stopped: boolean; reason: string };
+  autoCall?: { target: string; waiting: string; calls: number; max: number; misses: number; max_miss: number; stopped: boolean; reason: string };
   // The chase list, here as well as in Preferences: naming the station you are
   // waiting for is done WHILE watching the band, not in a settings tree.
   autoCallOnly?: string;
   onSetAutoCallOnly?: (list: string) => void;
+  // The watch list, as PATTERNS (VK9*, 3Y0J). A decode of one is worth saying
+  // so where the operator is reading the band, not only in the watchlist tab.
+  watchlist?: string[];
 }
 
 // The "new" categories, as toggle badges — the same idea and the same colours as
@@ -171,6 +180,21 @@ function catsOf(e: StatusEntry | undefined): Set<NewCat> {
   return out;
 }
 
+// isWatched applies the watch list's own rule — a trailing "*" is a prefix,
+// anything else is the whole callsign — so a decode is judged here exactly as
+// the backend judges a spot. Two rules for one list is how a badge and an alert
+// start disagreeing about the same station.
+function isWatched(call: string, patterns: string[] | undefined): boolean {
+  if (!patterns || patterns.length === 0 || !call) return false;
+  const c = call.toUpperCase();
+  for (const raw of patterns) {
+    const p = (raw ?? '').toUpperCase().trim();
+    if (!p) continue;
+    if (p.endsWith('*') ? c.startsWith(p.slice(0, -1)) : c === p) return true;
+  }
+  return false;
+}
+
 const CAT_KEY = 'opslog.decodeCats';
 const SPLIT_KEY = 'opslog.decodeSplit';
 const FILTER_KEY = 'opslog.decodeFilters';
@@ -252,9 +276,14 @@ const CELL_LAST = 'flex items-center min-w-0 px-2 gap-1 overflow-hidden';
 // One declaration per column, in display order: the header, the widths and the
 // resize handles all read from this, so a column cannot be resized in the header
 // and stay the old width in the body.
-type ColKey = 'time' | 'snr' | 'dt' | 'freq' | 'band' | 'mode' | 'msg' | 'grid' | 'state' | 'country' | 'status';
+type ColKey = 'time' | 'rx' | 'snr' | 'dt' | 'freq' | 'band' | 'mode' | 'msg' | 'grid' | 'dist' | 'state' | 'country' | 'status';
 const COLS: { key: ColKey; tkey: string; def: number; min: number }[] = [
   { key: 'time',    tkey: 'dec.colTime',    def: 64,  min: 44 },
+  // WHICH RECEIVER heard it. Shown only while more than one is feeding, and
+  // that is the case it exists for: two decoders on one band send the same
+  // stations twice, each with its own SNR and DT, and a merged list gave no way
+  // at all to tell a second receiver from a duplicate.
+  { key: 'rx',      tkey: 'dec.colRx',      def: 74,  min: 44 },
   { key: 'snr',     tkey: 'dec.colSnr',     def: 50,  min: 36 },
   { key: 'dt',      tkey: 'dec.colDt',      def: 44,  min: 32 },
   { key: 'freq',    tkey: 'dec.colFreq',    def: 56,  min: 40 },
@@ -268,6 +297,11 @@ const COLS: { key: ColKey; tkey: string; def: number; min: number }[] = [
   { key: 'grid',    tkey: 'dec.colGrid',    def: 62,  min: 46 },
   // For the WAS chasers: the badge carries the two letters, the name spells
   // them out — "SD" alone is a quiz for a European.
+  // Next to the square it is computed from. A four-character grid is a square
+  // tens of kilometres wide, so this is rounded to whole units and never
+  // pretends to more: it answers "is that station across the pond or across the
+  // valley", which is what decides whether the report is worth anything.
+  { key: 'dist',    tkey: 'dec.colDist',    def: 70,  min: 46 },
   { key: 'state',   tkey: 'dec.colState',   def: 120, min: 56 },
   { key: 'country', tkey: 'dec.colCountry', def: 140, min: 70 },
   { key: 'status',  tkey: 'dec.colStatus',  def: 186, min: 80 },
@@ -286,6 +320,39 @@ const US_STATES: Record<string, string> = {
   WV: 'West Virginia', WI: 'Wisconsin', WY: 'Wyoming', DC: 'District of Columbia',
 };
 
+// The columns worth sorting on. Not every column: time is what the periods
+// already are, and sorting a slot by callsign or message answers no question an
+// operator has.
+type SortKey = 'snr' | 'freq' | 'dist' | 'country' | 'status';
+const SORTABLE: SortKey[] = ['snr', 'freq', 'dist', 'country', 'status'];
+
+// Which way each column is worth reading FIRST — strongest signal, lowest
+// frequency, furthest DX, A to Z, most wanted. Clicking again reverses it.
+const SORT_FIRST: Record<SortKey, 'asc' | 'desc'> = {
+  snr: 'desc', freq: 'asc', dist: 'desc', country: 'asc', status: 'desc',
+};
+
+// How wanted a station is, as a number to sort by. The cluster's own order,
+// most wanted first — a new entity above a new band above a new slot — so the
+// two views rank the same things the same way.
+const STATUS_RANK: Record<string, number> = {
+  'new': 100, 'new-band-mode': 90, 'new-band': 80, 'new-mode': 70, 'new-slot': 60,
+  'new-call': 30, 'worked': 10,
+};
+function statusRank(e?: StatusEntry): number {
+  if (!e) return 0;
+  let r = STATUS_RANK[e.status ?? ''] ?? 0;
+  // The markers that are orthogonal to the entity: a new county on a worked
+  // country is still something to chase, and should not sort with the plain
+  // duplicates.
+  if (e.new_pota) r = Math.max(r, 50);
+  if (e.new_county) r = Math.max(r, 45);
+  if (e.new_grid) r = Math.max(r, 44);
+  if (e.new_state) r = Math.max(r, 43);
+  if (e.new_pfx) r = Math.max(r, 42);
+  return r;
+}
+
 const COL_MAX = 600;
 const COLW_KEY = 'opslog.decodeColWidths';
 
@@ -422,16 +489,31 @@ function periodLabel(ms: number, trSec: number): string {
 // read "CQ CQ PE1NAO JO32" — the badge and the message's own first word saying
 // the same thing twice. Highlighting the word already in the line keeps the
 // scannability and drops the stutter.
-function renderMsg(msg: string, me: string, calling: string) {
+function renderMsg(msg: string, me: string, calling: string, toMe: boolean) {
   if (!msg) return null;
+  // THE WHOLE LINE, when it is addressed to YOU.
+  //
+  // Token colouring is for reading the band — it picks your call out of a wall
+  // of other people's traffic. A message sent TO you is a different question:
+  // not "is my call in there somewhere" but "what did he just send me", read
+  // from the far side of the shack, so the whole line carries the colour.
+  //
+  // Only that case. The station you are calling also transmits to everybody
+  // else — "LA8WRA LA1RAU/P +00" is your target reporting to another caller —
+  // and setting those lines in the same strong colour said you were in a QSO
+  // you were not in. Its callsign is picked out by the token pass below, which
+  // is what "he is on the air, working somebody else" should look like.
+  if (toMe) {
+    return <span className="font-bold text-success">{msg}</span>;
+  }
   // Split on whitespace and colour the tokens that matter, rather than the
   // whole line: an operator scanning a slot is looking for their own call in
   // the first position (someone answering) and for the station being called.
-  const parts = msg.split(/(s+)/);
+  const parts = msg.split(/(\s+)/);
   return (
     <>
       {parts.map((tok, i) => {
-        if (/^s+$/.test(tok)) return tok;
+        if (/^\s+$/.test(tok)) return tok;
         const bare = tok.replace(/[<>]/g, '').toUpperCase();
         if (i === 0 && /^CQ$/i.test(tok)) return <span key={i} className="font-bold text-success">{tok.toUpperCase()}</span>;
         if (me && bare === me) return <span key={i} className="font-bold text-success">{tok}</span>;
@@ -450,7 +532,7 @@ function renderMsg(msg: string, me: string, calling: string) {
 //
 // It is the one moving thing on the panel, and it answers the question an
 // operator actually has between overs: how long until the next batch.
-function PeriodClock({ trSec, mode }: { trSec: number; mode?: string }) {
+function PeriodClock({ trSec, mode, tx }: { trSec: number; mode?: string; tx?: boolean }) {
   const [now, setNow] = useState(() => Date.now());
   useEffect(() => {
     // 100 ms: smooth enough for a bar that fills in three and three quarter
@@ -466,19 +548,26 @@ function PeriodClock({ trSec, mode }: { trSec: number; mode?: string }) {
   // The last fifth of a slot is when a decode is imminent and an operator
   // deciding whether to answer has run out of time to think.
   const closing = left <= trSec / 5;
+  // TRANSMITTING outranks both. The bar is the one thing on this screen that
+  // moves continuously, so it is what the eye is already on — and "am I on the
+  // air" is the state worth reading from across the room. Red, and it stays red
+  // for the whole over rather than turning amber near the end of it.
+  const tone = tx ? 'danger' : closing ? 'warning' : '';
 
   return (
     <span className="flex items-center gap-2 shrink-0" title={mode ? `${mode} · ${trSec}s` : `${trSec}s`}>
-      <Timer className={cn('size-4', closing ? 'text-warning' : 'text-muted-foreground')} />
+      <Timer className={cn('size-4',
+        tone === 'danger' ? 'text-danger' : tone === 'warning' ? 'text-warning' : 'text-muted-foreground')} />
       <span className="relative h-1.5 w-24 rounded-full bg-muted overflow-hidden">
         <span
           className={cn('absolute inset-y-0 left-0 rounded-full transition-[width] duration-100 ease-linear',
-            closing ? 'bg-warning' : 'bg-primary')}
+            tone === 'danger' ? 'bg-danger' : tone === 'warning' ? 'bg-warning' : 'bg-primary')}
           style={{ width: `${pct}%` }}
         />
       </span>
       <span className={cn('font-mono text-sm tabular-nums w-10 text-right',
-        closing ? 'text-warning font-semibold' : 'text-muted-foreground')}>
+        tone === 'danger' ? 'text-danger font-semibold'
+          : tone === 'warning' ? 'text-warning font-semibold' : 'text-muted-foreground')}>
         {left.toFixed(1)}
       </span>
       <span className="text-xs text-muted-foreground">
@@ -552,7 +641,7 @@ function buildPeriods(filtered: Decode[], txMsgs: TxMsg[]) {
     }));
 }
 
-export function DecodesPanel({ decodes, txMsgs, txState, txStates, spotStatus, rigBand, onCall, onSelect, myCall, onClear, onHalt, autoCallOn, onToggleAutoCall, autoCall, autoCallOnly, onSetAutoCallOnly }: Props) {
+export function DecodesPanel({ decodes, txMsgs, txState, txStates, spotStatus, rigBand, onCall, onSelect, myCall, myGrid, onClear, onHalt, autoCallOn, onToggleAutoCall, autoCall, autoCallOnly, onSetAutoCallOnly, watchlist }: Props) {
   const { t } = useI18n();
   // Column widths, dragged in the header and shared by every row. Persisted
   // through writeUiPref (not raw localStorage) so the layout travels with data/
@@ -567,8 +656,6 @@ export function DecodesPanel({ decodes, txMsgs, txState, txStates, spotStatus, r
     if (el && el.tagName === 'INPUT' && el.getAttribute('placeholder') === t('dec.chasePh')) return;
     setOnlyText(autoCallOnly ?? '');
   }, [autoCallOnly, t]);
-  const template = useMemo(() => COLS.map((c) => `${colw[c.key]}px`).join(' '), [colw]);
-  const tableW = useMemo(() => COLS.reduce((s, c) => s + colw[c.key], 0), [colw]);
   const setColWidth = (key: ColKey, px: number) => {
     const col = COLS.find((c) => c.key === key)!;
     const w = Math.min(COL_MAX, Math.max(col.min, Math.round(px)));
@@ -617,6 +704,68 @@ export function DecodesPanel({ decodes, txMsgs, txState, txStates, spotStatus, r
   const statusOf = (d: Decode): StatusEntry | undefined =>
     spotStatus[`${d.call}|${d.band ?? ''}|${(d.mode ?? '').toUpperCase()}`];
 
+  // ── Sorting, inside a period ──────────────────────────────────────────
+  //
+  // WITHIN each slot and never across them. The periods are the point of this
+  // panel — what was on the air in one fifteen-second window — and a list
+  // sorted end to end by signal would mix three minutes of decodes into one
+  // column of numbers with no way to tell which slot any of them came from.
+  //
+  // Arrival order stays the default and stays one click away, because it
+  // mirrors the decoder's own window line for line, which is what makes the
+  // two screens comparable at a glance.
+  const [sortSpec, setSortSpec] = usePersisted('sort', '');
+  const [sortKey, sortDir] = useMemo(() => {
+    const [k, d] = String(sortSpec || '').split(':');
+    return [SORTABLE.includes(k as SortKey) ? (k as SortKey) : '', d === 'asc' ? 'asc' : 'desc'] as const;
+  }, [sortSpec]);
+
+  // One click sorts the way that column is worth reading — strongest signal,
+  // furthest DX, lowest frequency, A to Z, most wanted. The second reverses it,
+  // the third gives arrival order back.
+  const toggleSort = (k: SortKey) => {
+    if (sortKey !== k) { setSortSpec(`${k}:${SORT_FIRST[k]}`); return; }
+    if (sortDir === SORT_FIRST[k]) { setSortSpec(`${k}:${SORT_FIRST[k] === 'asc' ? 'desc' : 'asc'}`); return; }
+    setSortSpec('');
+  };
+
+  const sortValue = useCallback((d: Decode, k: SortKey): number | string => {
+    const e = statusOf(d);
+    switch (k) {
+      case 'snr': return d.snr;
+      case 'freq': return d.freq_hz ?? 0;
+      case 'dist': {
+        const g = d.grid || e?.grid || '';
+        const path = myGrid && g ? pathBetween(myGrid, g) : null;
+        // A station that never sent a grid cannot be placed. Sorted to the end
+        // whichever way round the column goes, rather than pretending to a
+        // distance of zero and sitting at the top of "nearest first".
+        return path ? path.distanceShort : Number.NaN;
+      }
+      case 'country': return (e?.country ?? '').toUpperCase();
+      case 'status': return statusRank(e);
+    }
+  }, [spotStatus, myGrid]);
+
+  const sortDecodes = useCallback((list: Decode[]): Decode[] => {
+    if (!sortKey) return list;
+    const sign = sortDir === 'asc' ? 1 : -1;
+    return [...list].sort((a, b) => {
+      const va = sortValue(a, sortKey), vb = sortValue(b, sortKey);
+      const na = typeof va === 'number' && Number.isNaN(va);
+      const nb = typeof vb === 'number' && Number.isNaN(vb);
+      if (na !== nb) return na ? 1 : -1;   // unknowns last, both ways
+      if (na && nb) return 0;
+      if (typeof va === 'string' || typeof vb === 'string') {
+        const sa = String(va), sb = String(vb);
+        // An empty country is an unknown too, not a name that sorts first.
+        if (!sa !== !sb) return sa ? -1 : 1;
+        return sign * sa.localeCompare(sb);
+      }
+      return sign * ((va as number) - (vb as number));
+    });
+  }, [sortKey, sortDir, sortValue]);
+
   // The mode currently on the air, for the slot clock. The newest decode knows
   // best; between overs the transmit state still does.
   // A decoder that has lost its CAT link keeps announcing the last dial
@@ -645,6 +794,8 @@ export function DecodesPanel({ decodes, txMsgs, txState, txStates, spotStatus, r
   // opens with our callsign, sometimes bracketed when the sender compressed a
   // non-standard call.
   const me = (myCall ?? '').toUpperCase();
+  const [, bumpUnit] = useState(0);
+  useEffect(() => subscribeDistanceUnit(() => bumpUnit((n) => n + 1)), []);
   const calling = (txState?.dx_call ?? '').toUpperCase();
   const answersMe = (msg?: string): boolean => {
     if (!me || !msg) return false;
@@ -681,6 +832,12 @@ export function DecodesPanel({ decodes, txMsgs, txState, txStates, spotStatus, r
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [decodes, spotStatus]);
 
+  // The receiver column is dead weight with one decoder — which is nearly
+  // everybody — so it is not there at all until a second one starts feeding.
+  const cols = useMemo(() => COLS.filter((c) => c.key !== 'rx' || (instances.length > 1 && !splitByInstance)),
+    [instances.length, splitByInstance]);
+  const template = useMemo(() => cols.map((c) => `${colw[c.key]}px`).join(' '), [cols, colw]);
+  const tableW = useMemo(() => cols.reduce((s, c) => s + colw[c.key], 0), [cols, colw]);
   // All seven, always, in their usual order.
   //
   // The chips used to be built from the continents ON the feed, which read as a
@@ -714,6 +871,22 @@ export function DecodesPanel({ decodes, txMsgs, txState, txStates, spotStatus, r
     });
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [decodes, spotStatus, cqOnly, lotwOnly, cats, bandSel, modeSel, contSel, minSnr, search]);
+  // What this panel is SHOWING, published to the auto-call engine.
+  //
+  // The filters are the operator's control over the transmitter as well as
+  // over the list: a station filtered off the screen is not called. The panel
+  // sends the callsigns rather than the filter settings, so there is one
+  // definition of "shown" and not two — the engine cannot disagree with what
+  // is in front of the operator.
+  useEffect(() => {
+    const calls = [...new Set(filtered.map((d) => (d.call ?? '').toUpperCase()).filter(Boolean))];
+    SetAutoCallVisible(calls, true).catch(() => {});
+  }, [filtered]);
+  // Closed, it publishes nothing: filters that are not on the screen cannot
+  // silence the engine behind the operator's back.
+  useEffect(() => () => { SetAutoCallVisible([], false).catch(() => {}); }, []);
+
+
 
   // Group into periods, newest first, and drop the operator's transmissions into
   // the slot they went out in.
@@ -724,20 +897,24 @@ export function DecodesPanel({ decodes, txMsgs, txState, txStates, spotStatus, r
   // Each pane cuts its own periods: the bands differ, so the slot boundaries and
   // the transmit messages belong to one receiver and not the other.
   const panes = useMemo(() => {
+    // The sort is applied to each period's decodes, never to the periods
+    // themselves: the slots stay newest-first, which is what the panel is.
+    const sorted = (ps: ReturnType<typeof buildPeriods>) =>
+      sortKey ? ps.map((p) => ({ ...p, decodes: sortDecodes(p.decodes) })) : ps;
     if (!splitByInstance || instances.length < 2) {
-      return [{ key: '', label: '', tx: txState ?? undefined, periods: buildPeriods(filtered, txMsgs) }];
+      return [{ key: '', label: '', tx: txState ?? undefined, periods: sorted(buildPeriods(filtered, txMsgs)) }];
     }
     return instances.map((inst) => ({
       key: inst,
       // What the program is called, not the id it announces — see decoderName.
       label: decoderName(inst),
       tx: txStates?.[inst],
-      periods: buildPeriods(
+      periods: sorted(buildPeriods(
         filtered.filter((d) => (d.instance ?? '') === inst),
         txMsgs.filter((m) => (m.instance ?? '') === inst),
-      ),
+      )),
     }));
-  }, [filtered, txMsgs, splitByInstance, instances, txState, txStates]);
+  }, [filtered, txMsgs, splitByInstance, instances, txState, txStates, sortKey, sortDecodes]);
 
 
   const resetFilters = () => {
@@ -770,7 +947,11 @@ export function DecodesPanel({ decodes, txMsgs, txState, txStates, spotStatus, r
         {/* The slot clock. Taken from the newest decode's mode, falling back to
             what the transmit state reports, so it is right the moment anything
             is heard and keeps running when the band goes quiet. */}
-        <PeriodClock trSec={liveTr} mode={liveMode} />
+        {/* Any receiver on the air colours it: with two decoders the shared
+            txState is whichever reported last, and "somebody here is
+            transmitting" is what the bar has to say. */}
+        <PeriodClock trSec={liveTr} mode={liveMode}
+          tx={!!txState?.transmitting || Object.values(txStates ?? {}).some((s) => s?.transmitting)} />
         {bandDrift && (
           <span
             title={t('dec.bandDriftTip')}
@@ -927,13 +1108,47 @@ export function DecodesPanel({ decodes, txMsgs, txState, txStates, spotStatus, r
           >
             <Bot className="size-3.5" />
             {t('dec.autoCall')}
-            {autoCallOn && autoCall?.target && (
+          </button>
-              <span className="font-mono text-xs">
+        )}
-                {autoCall.target} {autoCall.calls}/{autoCall.max}
+        {/* WHAT IT IS DOING, BESIDE THE SWITCH RATHER THAN ON IT.
-                {autoCall.misses > 0 ? ` ·${autoCall.misses}/${autoCall.max_miss}` : ''}
+            A thing that keys the transmitter must never be a switch with no
+            readout — but the readout was crammed inside the button as
+            "Auto D2ACE 1/7 ·1/3", where the two counters read as one number and
+            the whole control changed width every period. Out here each figure
+            gets a label, and the station being called is the biggest thing on
+            the row. */}
+        {autoCallOn && autoCall?.target && (
+          <span className="h-8 inline-flex items-center gap-2 rounded-lg border border-success/50 bg-success/10 px-2"
+            title={t('dec.autoTargetTip', { call: autoCall.target })}>
+            <span className="font-mono text-sm font-bold text-success">{autoCall.target}</span>
+            <span className="inline-flex items-center gap-1 text-[11px] text-muted-foreground">
+              <span className="uppercase tracking-wide">{t('dec.autoCalls')}</span>
+              <span className="font-mono tabular-nums text-foreground">{autoCall.calls}/{autoCall.max}</span>
+            </span>
+            {/* Only once there is one to report: a zero that is always there is
+                a figure nobody reads, and it was the half of the pair that got
+                mistaken for the call count. */}
+            {autoCall.misses > 0 && (
+              <span className="inline-flex items-center gap-1 text-[11px] text-muted-foreground">
+                <span className="uppercase tracking-wide">{t('dec.autoMisses')}</span>
+                <span className={cn('font-mono tabular-nums',
+                  autoCall.misses + 1 >= autoCall.max_miss ? 'text-warning' : 'text-foreground')}>
+                  {autoCall.misses}/{autoCall.max_miss}
+                </span>
               </span>
             )}
-          </button>
+          </span>
+        )}
+        {/* Wanted, decoded, and in a QSO with somebody else. Holding fire looks
+            exactly like having nothing to do, and the operator had no way to
+            tell them apart. */}
+        {autoCallOn && !autoCall?.target && autoCall?.waiting && (
+          <span className="h-8 inline-flex items-center gap-1.5 rounded-lg border border-warning/50 bg-warning/10 px-2 animate-pulse"
+            title={t('dec.autoWaitTip', { call: autoCall.waiting })}>
+            <span className="text-sm">⏳</span>
+            <span className="font-mono text-sm font-bold text-warning">{autoCall.waiting}</span>
+            <span className="text-[11px] uppercase tracking-wide text-muted-foreground">{t('dec.autoWaiting')}</span>
+          </span>
         )}
         {/* The chase list. Raw text while typing, committed on blur or Enter:
             the stored value is upper-cased and trimmed, and binding the box to
@@ -1082,23 +1297,33 @@ export function DecodesPanel({ decodes, txMsgs, txState, txStates, spotStatus, r
       <div className="shrink-0 border-b border-border bg-background overflow-hidden">
         <div className={cn(ROW, 'h-7 text-[10px] font-semibold uppercase tracking-wider text-muted-foreground')}
           style={{ gridTemplateColumns: template, width: tableW }}>
-          {COLS.map((c, i) => (
+          {cols.map((c, i) => {
-            <span key={c.key}
+            const sortable = SORTABLE.includes(c.key as SortKey);
-              // Not CELL_LAST for the final column: its overflow-hidden would
+            const active = sortable && sortKey === c.key;
-              // clip that column's own resize handle.
+            return (
-              className={cn('relative flex items-center min-w-0 px-2',
+              <span key={c.key}
-                i < COLS.length - 1 && 'border-r border-border/30',
+                // Not CELL_LAST for the final column: its overflow-hidden would
-                // The three numeric columns label their own right edge, where the
+                // clip that column's own resize handle.
-                // figures are.
+                className={cn('relative flex items-center min-w-0 px-2',
-                (c.key === 'snr' || c.key === 'dt' || c.key === 'freq') && 'justify-end')}
+                  i < cols.length - 1 && 'border-r border-border/30',
-              title={c.key === 'dt' ? t('dec.colDtTitle') : c.key === 'freq' ? t('dec.colFreqTitle') : undefined}>
+                  // The three numeric columns label their own right edge, where the
-              <span className="truncate">{t(c.tkey)}</span>
+                  // figures are.
-              <ColResizer
+                  (c.key === 'snr' || c.key === 'dt' || c.key === 'freq' || c.key === 'dist') && 'justify-end',
-                onResize={(dx) => setColWidth(c.key, colw[c.key] + dx)}
+                  sortable && 'cursor-pointer select-none hover:text-foreground',
-                onReset={() => setColWidth(c.key, c.def)}
+                  active && 'text-primary')}
-              />
+                onClick={sortable ? () => toggleSort(c.key as SortKey) : undefined}
-            </span>
+                title={sortable ? t('dec.sortTip')
-          ))}
+                  : c.key === 'dt' ? t('dec.colDtTitle')
+                  : c.key === 'freq' ? t('dec.colFreqTitle') : undefined}>
+                <span className="truncate">{c.key === 'dist' ? `${t(c.tkey)} (${distanceUnit()})` : t(c.tkey)}</span>
+                {active && <span className="ml-0.5 shrink-0">{sortDir === 'asc' ? '▲' : '▼'}</span>}
+                <ColResizer
+                  onResize={(dx) => setColWidth(c.key, colw[c.key] + dx)}
+                  onReset={() => setColWidth(c.key, c.def)}
+                />
+              </span>
+            );
+          })}
         </div>
       </div>
 
@@ -1172,7 +1397,10 @@ export function DecodesPanel({ decodes, txMsgs, txState, txStates, spotStatus, r
                   title={t('dec.callTitle', { call: d.call })}
                   style={{ gridTemplateColumns: template, width: tableW }}
                   className={cn(ROW, 'text-left border-b border-border/20 transition-colors',
-                    replying ? 'bg-success/20 hover:bg-success/25'
+                    replying ? 'bg-success/25 hover:bg-success/30 border-l-2 border-l-success'
+                      // The station being called: a tint saying "he is on the
+                      // air", not the QSO treatment above — most of what he
+                      // sends is to other people.
                       : worked ? 'bg-danger/15 hover:bg-danger/20'
                       : mine ? 'bg-info/10'
                       : 'hover:bg-muted/50')}
@@ -1185,6 +1413,15 @@ export function DecodesPanel({ decodes, txMsgs, txState, txStates, spotStatus, r
                     {hhmmssCompact(d.at)}
                   </span>
 
+                  {/* Which receiver heard it — present only while more than one
+                      is feeding a merged list. */}
+                  {cols.some((c) => c.key === 'rx') && (
+                    <span className={cn(CELL, 'text-[11px] text-muted-foreground truncate')}
+                      title={d.instance ?? ''}>
+                      {decoderName(d.instance)}
+                    </span>
+                  )}
+
                   <span className={cn(CELL, 'justify-end font-mono text-[13px] font-semibold tabular-nums', snrTone(d.snr))}>
                     {d.snr > 0 ? `+${d.snr}` : d.snr}
                   </span>
@@ -1218,7 +1455,7 @@ export function DecodesPanel({ decodes, txMsgs, txState, txStates, spotStatus, r
                   {/* The message carries the callsign already — which is why
                       there is no column repeating it. */}
                   <span className={cn(CELL, 'font-mono text-[13px]')}>
-                    <span className="truncate">{renderMsg(d.msg ?? '', me, calling)}</span>
+                    <span className="truncate">{renderMsg(d.msg ?? '', me, calling, replying)}</span>
                   </span>
 
                   {/* The decode's own grid first, the remembered one as the
@@ -1231,6 +1468,14 @@ export function DecodesPanel({ decodes, txMsgs, txState, txStates, spotStatus, r
                     <span className="truncate">{d.grid || e?.grid || ''}</span>
                   </span>
 
+                  <span className={cn(CELL, 'justify-end font-mono text-[11px] tabular-nums text-muted-foreground/80')}>
+                    {(() => {
+                      const g = d.grid || e?.grid || '';
+                      const path = myGrid && g ? pathBetween(myGrid, g) : null;
+                      return path ? distanceValue(path.distanceShort).toLocaleString() : '';
+                    })()}
+                  </span>
+
                   <span className={cn(CELL, 'gap-1.5')}>
                     {e?.state && (
                       <>
@@ -1256,6 +1501,15 @@ export function DecodesPanel({ decodes, txMsgs, txState, txStates, spotStatus, r
                         {t('dec.wkd')}
                       </span>
                     )}
+                    {/* Plainest first: the LoTW letter, the worked note, then
+                        the coloured badges — the watch list leading them, being
+                        the operator's own answer rather than the log's. */}
+                    {isWatched(d.call, watchlist) && (
+                      <span className="rounded px-1 py-px text-[10px] font-bold uppercase tracking-wide shrink-0 text-white"
+                        style={{ background: '#f472b6' }} title={t('dec.wlTip')}>
+                        {t('dec.wl')}
+                      </span>
+                    )}
                     {entities.map((b) => (
                       <span key={b.label}
                         title={e?.unconf_status ? t('dec.unconfTip') : undefined}

frontend/src/components/FTMapPanel.tsx

@@ -5,6 +5,8 @@ import { gridToLatLon, greatCirclePoints, splitAtAntimeridian } from '@/lib/maid
 import { BASEMAPS, type BasemapKey } from '@/components/MainMap';
 import { cn } from '@/lib/utils';
 import { useI18n } from '@/lib/i18n';
+import { loadMapView, saveMapView, MAP_VIEW_FT } from '@/lib/mapView';
+import { loadMapBase, saveMapBase, MAP_BASE_FT } from '@/lib/mapBase';
 
 // FT Map — the live decode feed as geography: every station decoded in the
 // last half hour, an arc from the operator's own square to theirs, coloured by
@@ -18,12 +20,16 @@ import { useI18n } from '@/lib/i18n';
 // capped, and redraws happen when the DECODE LIST changes — every 15 s in FT8,
 // not per frame.
 
+// The map is handed the SAME decode objects the list works from — it only reads
+// a few of the fields. The rest travel with them so a click here can answer the
+// station exactly as a double-click in the list does.
 export type FTMapDecode = {
   call: string;
   grid?: string;
   band?: string;
   snr: number;
   at: string;
+  [k: string]: unknown;
 };
 
 // The band palette every PSK Reporter user already knows, near enough.
@@ -38,7 +44,26 @@ const bandColour = (b?: string) => BAND_COLOURS[(b ?? '').toLowerCase()] || '#9c
 const MAX_ARCS = 300;
 const MAX_AGE_MS = 30 * 60_000;
 
-export function FTMapPanel({ decodes, myGrid }: { decodes: FTMapDecode[]; myGrid: string }) {
+export function FTMapPanel({ decodes, myGrid, onSelect, onCall }: {
+  decodes: FTMapDecode[];
+  myGrid: string;
+  // One click takes the station, two answer it — the list's own gestures.
+  onSelect?: (d: FTMapDecode) => void;
+  onCall?: (d: FTMapDecode) => void;
+}) {
+  // Held in refs so the redraw below does not have to list them as dependencies
+  // and rebuild every arc whenever the parent re-renders.
+  const selectRef = useRef(onSelect);
+  const callRef = useRef(onCall);
+  useEffect(() => { selectRef.current = onSelect; callRef.current = onCall; }, [onSelect, onCall]);
+  // Distinguishing the two gestures is ours to do: Leaflet fires click before
+  // dblclick and leaves the telling apart to the handler.
+  const clickTimer = useRef<number | undefined>(undefined);
+  useEffect(() => () => window.clearTimeout(clickTimer.current), []);
+  // Where this map was left. Panning and zooming it is the operator saying which
+  // part of the world they are working; throwing that away on every tab switch
+  // made it something to set up again rather than something to glance at.
+  const saved = useRef(loadMapView(MAP_VIEW_FT));
   const { t } = useI18n();
   const divRef = useRef<HTMLDivElement>(null);
   const mapRef = useRef<L.Map | null>(null);
@@ -58,7 +83,15 @@ export function FTMapPanel({ decodes, myGrid }: { decodes: FTMapDecode[]; myGrid
       // No maxBounds: with the world smaller than the window the clamp
       // dragged every zoom into a corner. noWrap tiles alone keep one world.
       worldCopyJump: false, preferCanvas: true,
-      center: [25, 0], zoom: 2, minZoom: 2,
+      center: saved.current ? [saved.current.lat, saved.current.lon] : [25, 0],
+      zoom: saved.current ? saved.current.zoom : 2,
+      minZoom: 2,
+    });
+    // Every move, not just the deliberate ones: a zoom is as much a choice as a
+    // pan, and there is no moment afterwards at which to ask.
+    m.on('moveend', () => {
+      const c = m.getCenter();
+      saveMapView(MAP_VIEW_FT, c.lat, c.lng, m.getZoom());
     });
     mapRef.current = m;
     layerRef.current = L.layerGroup().addTo(m);
@@ -96,7 +129,7 @@ export function FTMapPanel({ decodes, myGrid }: { decodes: FTMapDecode[]; myGrid
     };
     baseRef.current = L.tileLayer(bm.url, { ...opts, attribution: bm.attr, subdomains: bm.subdomains ?? 'abc' }).addTo(m);
     if (bm.labelsUrl) labelsRef.current = L.tileLayer(bm.labelsUrl, opts).addTo(m);
-    localStorage.setItem('opslog.ftmapBase', basemap);
+    saveMapBase(MAP_BASE_FT, basemap);
   }, [basemap]);
 
   // The arcs, redrawn when the decode list changes. Newest last so they paint
@@ -132,10 +165,36 @@ export function FTMapPanel({ decodes, myGrid }: { decodes: FTMapDecode[]; myGrid
       L.polyline(pts as L.LatLngExpression[][], {
         color: colour, weight: 1.3, opacity: 0.65 * fade, smoothFactor: 0,
       }).addTo(layer);
-      L.circleMarker([to.lat, to.lon], {
+      const label = `${d.call} · ${d.grid} · ${d.snr > 0 ? '+' : ''}${d.snr} dB`;
+      const mk = L.circleMarker([to.lat, to.lon], {
+        // A three-pixel dot is a fine mark and a poor target, so the visible
+        // radius stays and an invisible one three times the size takes the
+        // clicks.
         radius: 3, color: colour, weight: 1, fillColor: colour, fillOpacity: 0.9 * fade,
-      }).bindTooltip(`${d.call} · ${d.grid} · ${d.snr > 0 ? '+' : ''}${d.snr} dB`, { direction: 'top' })
+      }).bindTooltip(label, { direction: 'top' }).addTo(layer);
-        .addTo(layer);
+      // The tooltip goes on the HIT circle too, and it is the one that matters:
+      // being on top, it takes the hover as well as the click, and binding it
+      // only to the dot underneath left the map silent from the moment the dots
+      // became clickable — the callsign and report an operator reads by pointing
+      // at a station had simply gone.
+      const hit = L.circleMarker([to.lat, to.lon], {
+        radius: 9, opacity: 0, fillOpacity: 0, interactive: true,
+      }).bindTooltip(label, { direction: 'top' }).addTo(layer);
+      for (const target of [mk, hit]) {
+        target.on('click', (e) => {
+          // Not to the map: a click on a station is not a click on the water.
+          L.DomEvent.stopPropagation(e as unknown as Event);
+          window.clearTimeout(clickTimer.current);
+          clickTimer.current = window.setTimeout(() => selectRef.current?.(d), 250);
+        });
+        target.on('dblclick', (e) => {
+          // stop(), not stopPropagation(): the map zooms on a double click, and
+          // answering a station is not a request to zoom in on it.
+          L.DomEvent.stop(e as unknown as Event);
+          window.clearTimeout(clickTimer.current);
+          callRef.current?.(d);
+        });
+      }
     }
   }, [decodes, myGrid]);
 

frontend/src/components/GridSquareMap.tsx

@@ -6,8 +6,10 @@ import { GridSquares } from '../../wailsjs/go/main/App';
 import { gridSquareBounds, gridToLatLon } from '@/lib/maidenhead';
 import { useI18n } from '@/lib/i18n';
 import { cn } from '@/lib/utils';
-import { BASEMAPS, addBasemap, loadBasemap, type BasemapKey } from '@/components/MainMap';
+import { BASEMAPS, addBasemap, type BasemapKey } from '@/components/MainMap';
+import { loadMapBase, saveMapBase, MAP_BASE_GRIDS, MAP_BASE_WORLD } from '@/lib/mapBase';
 import { writeUiPref } from '@/lib/uiPref';
+import { loadMapView, saveMapView, MAP_VIEW_GRIDS } from '@/lib/mapView';
 
 // GridSquareMap — every Maidenhead square in the log, drawn on a world map.
 //
@@ -85,7 +87,9 @@ export function GridSquareMap({ myGrid, className }: { myGrid?: string; classNam
     () => (SCOPES.some((s) => s.key === localStorage.getItem(SCOPE_KEY))
       ? (localStorage.getItem(SCOPE_KEY) as ScopeKey) : 'DIGI'));
 
-  const [basemap, setBasemap] = useState<BasemapKey>(loadBasemap);
+  // This map's own imagery. It shared the world map's key until they were
+  // separated, so a choice made back then is inherited rather than reset.
+  const [basemap, setBasemap] = useState<BasemapKey>(() => loadMapBase(MAP_BASE_GRIDS, 'light', MAP_BASE_WORLD));
   const [confColour, setConfColour] = useState(() => localStorage.getItem(COL_CONFIRMED_KEY) ?? '');
   const [workedColour, setWorkedColour] = useState(() => localStorage.getItem(COL_WORKED_KEY) ?? '');
   // Repaint the squares when the THEME changes, not the basemap: the fills come
@@ -131,8 +135,16 @@ export function GridSquareMap({ myGrid, className }: { myGrid?: string; classNam
 
     }).setView([20, 0], 2);
     // The whole world, once, whatever the window is shaped like — computed by
-    // Leaflet from the container rather than guessed with a zoom number.
+    // Leaflet from the container rather than guessed with a zoom number. Unless
-    m.fitWorld({ animate: false });
+    // the operator has already chosen a view: theirs is the answer, and fitting
+    // the world over it would undo the choice on every tab switch.
+    const saved = loadMapView(MAP_VIEW_GRIDS);
+    if (saved) m.setView([saved.lat, saved.lon], saved.zoom);
+    else m.fitWorld({ animate: false });
+    m.on('moveend', () => {
+      const c = m.getCenter();
+      saveMapView(MAP_VIEW_GRIDS, c.lat, c.lng, m.getZoom());
+    });
     mapRef.current = m;
     layerRef.current = L.layerGroup().addTo(m);
     // Leaflet measures its container ONCE, when the map is created, and never
@@ -144,7 +156,7 @@ export function GridSquareMap({ myGrid, className }: { myGrid?: string; classNam
     // fitWorld above ran against a container that may still have had no size —
     // the tab is mounted hidden. Fit ONCE more the first time it really has one,
     // and never again: after that the view belongs to the operator.
-    let fitted = false;
+    let fitted = !!saved; // a remembered view is already the right size
     const ro = new ResizeObserver(() => {
       m.invalidateSize({ animate: false });
       const el = hostRef.current;
@@ -244,7 +256,7 @@ export function GridSquareMap({ myGrid, className }: { myGrid?: string; classNam
         </span>
         <select
           value={basemap}
-          onChange={(e) => { const v = e.target.value as BasemapKey; setBasemap(v); writeUiPref('opslog.mapBasemap', v); }}
+          onChange={(e) => { const v = e.target.value as BasemapKey; setBasemap(v); saveMapBase(MAP_BASE_GRIDS, v); }}
           title={t('gsm.basemap')}
           className="h-6 rounded border border-border bg-background px-1 text-[11px]"
         >

frontend/src/components/MainMap.tsx

@@ -3,17 +3,16 @@ import L from 'leaflet';
 import 'leaflet/dist/leaflet.css';
 import { nightPolygon } from '../lib/greyline';
 import { gridToLatLon, gridSquareBounds, greatCirclePoints, pathBetween, destinationPoint } from '@/lib/maidenhead';
+import { loadMapBase, saveMapBase, MAP_BASE_WORLD } from '@/lib/mapBase';
 import { writeUiPref } from '@/lib/uiPref';
 import { formatDistance } from '@/lib/units';
+import { loadMapView, saveMapView, MAP_VIEW_WORLD } from '@/lib/mapView';
 
 // Persisted free-pan view of the world map (when auto-zoom is off).
-function loadMapView(): { lat: number; lon: number; zoom: number } | null {
+const loadWorldView = () => loadMapView(MAP_VIEW_WORLD);
-  try { const v = JSON.parse(localStorage.getItem('opslog.mapView') || 'null'); return v && typeof v.zoom === 'number' ? v : null; }
+function saveWorldView(m: L.Map) {
-  catch { return null; }
-}
-function saveMapView(m: L.Map) {
   const c = m.getCenter();
-  writeUiPref('opslog.mapView', JSON.stringify({ lat: c.lat, lon: c.lng, zoom: m.getZoom() }));
+  saveMapView(MAP_VIEW_WORLD, c.lat, c.lng, m.getZoom());
 }
 
 // The Main tab is built from two independent map panes that the operator can
@@ -28,6 +27,26 @@ function saveMapView(m: L.Map) {
 // unwrapLon makes a lat/lon ring continuous in longitude (each point within
 // 180° of the previous) so a polygon crossing the antimeridian doesn't snap
 // across the whole map. Coords may exceed ±180; Leaflet (worldCopyJump) is fine.
+// homeView is where a world map should open for THIS station.
+//
+// Centred on 0° a world map puts Europe in the middle and leaves an Australian
+// looking at their own country in the bottom-right corner, with the paths to
+// everywhere they work running off both edges. Centred on their own longitude
+// the same map reads the way their antenna does: the Americas to the east,
+// Europe and Africa to the west. Leaflet repeats the world horizontally
+// (worldCopyJump), so this is a choice of viewpoint and costs nothing — the
+// tiles either side are the same world, and the great-circle code already draws
+// across the seam (see unwrapLon).
+//
+// The latitude is damped, not followed: a station at 69° north centred on itself
+// would spend half the map on the Arctic. It leans towards the operator's
+// hemisphere and stops well short of the pole.
+function homeView(grid: string): [number, number] {
+  const home = gridToLatLon(grid);
+  if (!home) return [20, 0];
+  return [Math.max(-35, Math.min(45, home.lat * 0.6 + 8)), home.lon];
+}
+
 function unwrapLon(ring: [number, number][]): [number, number][] {
   const out: [number, number][] = [];
   let prev = NaN;
@@ -98,9 +117,10 @@ export const BASEMAPS: Record<BasemapKey, { label: string; url: string; attr: st
                attr: 'Tiles &copy; Esri — Source: Esri, Maxar, Earthstar Geographics',
                labelsUrl: 'https://server.arcgisonline.com/ArcGIS/rest/services/Reference/World_Boundaries_and_Places/MapServer/tile/{z}/{y}/{x}' },
 };
+// loadBasemap is the WORLD map's imagery. Each map keeps its own — see
+// lib/mapBase, which is where the keys live.
 export function loadBasemap(): BasemapKey {
-  const v = localStorage.getItem('opslog.mapBasemap');
+  return loadMapBase(MAP_BASE_WORLD, 'light');
-  return v === 'voyager' || v === 'street' || v === 'satellite' ? v : 'light';
 }
 
 // addBasemap (re)installs the imagery layer and, for satellite, its transparent
@@ -178,31 +198,50 @@ export function WorldMap({ fromGrid, toGrid, fromLabel, toLabel, beamAzimuths, b
   const autoZoomRef = useRef(autoZoom);
   useEffect(() => { autoZoomRef.current = autoZoom; }, [autoZoom]);
 
+  // WAIT FOR THE SQUARE BEFORE PAINTING.
+  //
+  // The station's own locator arrives from the profile a moment after this
+  // component mounts. Building the map immediately meant painting the world at
+  // 0°, then moving it to the operator's longitude — a screenful of tiles
+  // fetched from Esri and thrown away on every first run. The map is built once,
+  // when it knows where it is looking.
+  //
+  // Not for ever, though: an operator with no locator set (or a profile still
+  // loading after two seconds) gets the default view rather than a blank panel.
+  const [mapReady, setMapReady] = useState(() => !!gridToLatLon(fromGrid) || !!loadWorldView());
+  useEffect(() => {
+    if (mapReady) return;
+    if (gridToLatLon(fromGrid)) { setMapReady(true); return; }
+    const t = window.setTimeout(() => setMapReady(true), 2000);
+    return () => window.clearTimeout(t);
+  }, [fromGrid, mapReady]);
+
   // One-time map creation.
   useEffect(() => {
-    if (worldRef.current && !worldMap.current) {
+    if (worldRef.current && !worldMap.current && mapReady) {
       // preferCanvas: the beam lobe is a dense FAN of translucent radials — up to
       // ~120 thick strokes with a bidirectional Ultrabeam. As SVG that is ~120
       // composited paths re-rasterised on every pan, zoom and redraw, which is
       // enough to blow WebView2's raster budget and leave the window painting in
       // patches. On canvas it is a single layer.
       const m = L.map(worldRef.current, { zoomControl: true, attributionControl: true, worldCopyJump: true, preferCanvas: true })
-        .setView([20, 0], 1);
+        .setView(homeView(fromGrid), 1);
       addBasemap(m, basemap, baseLayer, labelsLayer);
       worldOverlay.current = L.layerGroup().addTo(m);
       worldMap.current = m;
-      const sv = loadMapView();
+      const sv = loadWorldView();
       if (!autoZoomRef.current && sv) m.setView([sv.lat, sv.lon], sv.zoom);
-      m.on('moveend', () => { if (!autoZoomRef.current) saveMapView(m); });
+      m.on('moveend', () => { if (!autoZoomRef.current) saveWorldView(m); });
     }
     const t = window.setTimeout(() => { worldMap.current?.invalidateSize(); }, 80);
+
     // Resizing the pane is the ONLY thing that needs invalidateSize. Calling it on
     // every overlay redraw (as before) forced a full repaint of the map each time
     // the rotor moved a degree.
     const ro = new ResizeObserver(() => worldMap.current?.invalidateSize());
     if (worldRef.current) ro.observe(worldRef.current);
     return () => { window.clearTimeout(t); ro.disconnect(); };
-  }, []);
+  }, [mapReady]);
 
   // Swap the basemap (and its optional place-name overlay) when the operator
   // picks a different one. Vector overlays (path/beam) live in Leaflet's
@@ -408,7 +447,7 @@ export function WorldMap({ fromGrid, toGrid, fromLabel, toLabel, beamAzimuths, b
           <button
             key={k}
             type="button"
-            onClick={() => { setBasemap(k); writeUiPref('opslog.mapBasemap', k); }}
+            onClick={() => { setBasemap(k); saveMapBase(MAP_BASE_WORLD, k); }}
             title={`Basemap: ${BASEMAPS[k].label}`}
             className={`px-2 py-1 text-[11px] font-medium transition-colors ${
               basemap === k ? 'bg-primary text-primary-foreground' : 'bg-card/90 text-muted-foreground hover:bg-card'
@@ -427,7 +466,7 @@ export function WorldMap({ fromGrid, toGrid, fromLabel, toLabel, beamAzimuths, b
           setAutoZoom(v);
           writeUiPref('opslog.mapAutoZoomDX', v ? '1' : '0');
           const m = worldMap.current;
-          if (!v && m) saveMapView(m);
+          if (!v && m) saveWorldView(m);
         }}
         title={autoZoom ? 'Auto-zoom to DX is ON — click for free pan/zoom (remembered)' : 'Free pan/zoom — click to auto-zoom to the DX'}
         className={`absolute top-1 right-1 z-[500] rounded-md px-2 py-1 text-[11px] font-medium shadow border backdrop-blur transition-colors ${

frontend/src/components/QSOEditModal.tsx

@@ -1,7 +1,7 @@
 import { useEffect, useMemo, useRef, useState } from 'react';
 import { Trash2, Search, Loader2, CalendarDays } from 'lucide-react';
 import { LookupCallsign, LookupCallsignFresh, DXCCForCountry, GetAwardDefs, ComputeQSOAwardRefs, GetListsSettings, OpenExternalURL, SetOpsLogQSLReceived } from '../../wailsjs/go/main/App';
-import { rstOptions, type RSTLists } from '@/lib/rst';
+import { rstOptions, stepRST, type RSTLists } from '@/lib/rst';
 import { AwardRefSelector } from '@/components/AwardRefSelector';
 import { AdifExtrasEditor } from '@/components/AdifExtrasEditor';
 import { applyAwardRefs } from '@/lib/awardRefs';
@@ -598,9 +598,13 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
                     value={draft.callsign ?? ''} onChange={(e) => set('callsign', e.target.value)} />
                 </div>
                 <div className="flex flex-col w-20"><Label>S</Label>
-                  <Combobox value={draft.rst_sent ?? ''} options={rstOptions(draft.mode ?? '', rstLists)} commitOnType onChange={(v) => set('rst_sent', v)} /></div>
+                  <Combobox value={draft.rst_sent ?? ''} options={rstOptions(draft.mode ?? '', rstLists)} commitOnType
+                    onChange={(v) => set('rst_sent', v)}
+                    onWheelStep={(d) => set('rst_sent', stepRST(draft.rst_sent ?? '', d, draft.mode ?? ''))} /></div>
                 <div className="flex flex-col w-20"><Label>R</Label>
-                  <Combobox value={draft.rst_rcvd ?? ''} options={rstOptions(draft.mode ?? '', rstLists)} commitOnType onChange={(v) => set('rst_rcvd', v)} /></div>
+                  <Combobox value={draft.rst_rcvd ?? ''} options={rstOptions(draft.mode ?? '', rstLists)} commitOnType
+                    onChange={(v) => set('rst_rcvd', v)}
+                    onWheelStep={(d) => set('rst_rcvd', stepRST(draft.rst_rcvd ?? '', d, draft.mode ?? ''))} /></div>
                 <Button type="button" variant="outline" className="h-10" onClick={fetchLookup} disabled={looking}
                   title={t('qedit.fetchTitle')}>
                   {looking ? <Loader2 className="size-4 animate-spin" /> : <Search className="size-4" />} {t('qedit.fetch')}

frontend/src/components/RotorCompassClassic.tsx

@@ -0,0 +1,381 @@
+// RotorCompassClassic — the original rotor dial, kept as an option.
+//
+// Settings → Rotator chooses between this and the current compass. It was
+// replaced rather than removed because the two answer the same question in
+// different ways: this one is a small light-map dial with the quick turns in a
+// column beside it, and an operator used to it should not have to relearn a
+// panel to keep working.
+//
+// An azimuthal-equidistant rotor display (à la 4O3A RotorGenius).
+//
+// A world map centred on the operator's QTH (north up) fills the dial, ringed by
+// a green azimuth bezel. A green needle shows the antenna heading (two needles
+// when an Ultrabeam is bidirectional, the opposite one when reversed); a small
+// red marker on the bezel shows the short-path bearing to the DX. Click the dial
+// to turn the antenna there.
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { geoAzimuthalEquidistant, geoPath, geoGraticule10 } from 'd3-geo';
+import { feature } from 'topojson-client';
+import landTopo from 'world-atlas/land-110m.json';
+import { Compass, X, Play, Square } from 'lucide-react';
+import { cn } from '@/lib/utils';
+import { useI18n } from '@/lib/i18n';
+
+// Decode the coastline outline once (≈110 m simplified land polygons).
+const LAND = feature(landTopo as any, (landTopo as any).objects.land);
+const GRATICULE = geoGraticule10();
+
+interface Props {
+  bearing?: number | null;       // short-path azimuth to DX (deg)
+  headings: number[];            // radiating heading(s) — rotor + Ultrabeam pattern
+  boomHeading?: number | null;   // mechanical boom (rotor) azimuth, shown grey when it differs
+  pattern?: 'normal' | 'reverse' | 'bi' | null; // Ultrabeam pattern (for the badge)
+  centerLat?: number | null;     // operator latitude (projection centre)
+  centerLon?: number | null;     // operator longitude
+  rotorEnabled?: boolean;
+  rotors?: string[];             // logical rotor names; >1 → show a selector
+  activeRotor?: number;          // index of the selected rotor (0-based)
+  onSelectRotor?: (i: number) => void; // switch the active rotor
+  onGoto?: (az: number) => void; // click-to-turn
+  onClose?: () => void;
+  // Quick-turn buttons and the azimuth box, shown only where the caller wants
+  // them: Station Control draws its own GoTo/Stop around this compass, and two
+  // sets of the same controls side by side would be nothing but confusing.
+  presets?: { label: string; azimuth: number }[];
+  onStop?: () => void;
+}
+
+const SIZE = 168;
+const C = SIZE / 2;
+const R = C - 6;          // outer bezel radius
+const MAP_R = R - 6;      // map/clip radius (inside the bezel)
+
+function pt(az: number, radius: number): [number, number] {
+  const a = ((az - 90) * Math.PI) / 180;
+  return [C + radius * Math.cos(a), C + radius * Math.sin(a)];
+}
+
+export function RotorCompassClassic({ bearing, headings, boomHeading, pattern, centerLat, centerLon, rotorEnabled, rotors, activeRotor, onSelectRotor, onGoto, onClose, presets, onStop }: Props) {
+  const { t } = useI18n();
+  // Raw text, not a number: binding the input to a normalised value makes
+  // Backspace fight the operator on the way from "230" to "23". It is parsed
+  // when it is sent, and only then.
+  const [azText, setAzText] = useState('');
+  const showControls = !!(presets || onStop);
+
+  // Which preset was just pressed, so it can light up for a moment.
+  //
+  // A rotor takes seconds to start moving and the needle barely twitches at
+  // first, so without this the only answer to "did that register?" is to press
+  // it again — which is how an antenna ends up ordered somewhere twice. The
+  // acknowledgement has to come from the button itself, at once.
+  const [flashIdx, setFlashIdx] = useState<number | null>(null);
+  const flashTimer = useRef<number | undefined>(undefined);
+  useEffect(() => () => window.clearTimeout(flashTimer.current), []);
+  const pressPreset = (i: number, az: number) => {
+    if (!onGoto) return;
+    setFlashIdx(i);
+    window.clearTimeout(flashTimer.current);
+    flashTimer.current = window.setTimeout(() => setFlashIdx(null), 450);
+    onGoto(az);
+  };
+
+  // Stop needs the same acknowledgement, for the same reason and one more: it
+  // is pressed when something is already wrong, and a button that stays inert
+  // gets hit again and again. Its own flag, so stopping does not blank a preset
+  // that is still lit.
+  const [stopFlash, setStopFlash] = useState(false);
+  const stopTimer = useRef<number | undefined>(undefined);
+  useEffect(() => () => window.clearTimeout(stopTimer.current), []);
+  const pressStop = () => {
+    if (!onStop) return;
+    setStopFlash(true);
+    window.clearTimeout(stopTimer.current);
+    stopTimer.current = window.setTimeout(() => setStopFlash(false), 450);
+    onStop();
+  };
+
+  // 0-359 and nothing else. 360 is refused rather than folded to 0 — it is
+  // almost always a typo for 36 or 306, and a rotor swinging through north on a
+  // slip of the finger is worth one rejected keypress.
+  const sendAz = () => {
+    const s = azText.trim();
+    if (s === '' || !onGoto) return;
+    const n = Number(s);
+    if (!Number.isFinite(n) || !Number.isInteger(n) || n < 0 || n > 359) return;
+    onGoto(n);
+    setAzText('');
+  };
+
+  const cardinals = useMemo(
+    () => [ { d: 0, l: 'N' }, { d: 45, l: 'NE' }, { d: 90, l: 'E' }, { d: 135, l: 'SE' },
+            { d: 180, l: 'S' }, { d: 225, l: 'SW' }, { d: 270, l: 'W' }, { d: 315, l: 'NW' } ],
+    [],
+  );
+
+  // Project the world centred on the QTH (north up; antipode at the bezel).
+  const { land, grat } = useMemo(() => {
+    if (centerLat == null || centerLon == null) return { land: '', grat: '' };
+    const proj = geoAzimuthalEquidistant()
+      .rotate([-centerLon, -centerLat])
+      .clipAngle(179.9)
+      .scale(MAP_R / Math.PI)
+      .translate([C, C]);
+    const path = geoPath(proj as any);
+    return { land: path(LAND as any) || '', grat: path(GRATICULE as any) || '' };
+  }, [centerLat, centerLon]);
+
+  function handleClick(e: React.MouseEvent<SVGSVGElement>) {
+    if (!onGoto) return;
+    const rect = e.currentTarget.getBoundingClientRect();
+    const x = ((e.clientX - rect.left) / rect.width) * SIZE - C;
+    const y = ((e.clientY - rect.top) / rect.height) * SIZE - C;
+    let az = (Math.atan2(y, x) * 180) / Math.PI + 90;
+    az = ((az % 360) + 360) % 360;
+    onGoto(Math.round(az));
+  }
+
+  const headLabel = headings.length ? headings[0] : null;
+
+  // Short and long path to the DX, in figures.
+  //
+  // The bezel already carries the short path as a red marker, but a marker is a
+  // direction, not a number — the same pair sits in the status bar at 10px and
+  // operators reported not being able to read it. It lives here because it
+  // belongs to the compass: every place that draws one gets the readout, instead
+  // of each caller inventing its own. Clickable when the caller can turn, like
+  // the status bar's. Built as a value because it is placed in one of two
+  // columns depending on whether the controls are shown.
+  const pathReadout = (
+    <div className="flex gap-1.5 mt-2 font-mono w-full">
+      {([['SP', bearing ?? null], ['LP', bearing == null ? null : (bearing + 180) % 360]] as const).map(([lbl, az]) => (
+        <button key={lbl} type="button" disabled={az == null || !onGoto}
+          onClick={() => { if (az != null && onGoto) onGoto(Math.round(az)); }}
+          title={az == null ? '' : `${lbl} ${Math.round(az)}°`}
+          className={
+            'flex-1 rounded-md border py-1 text-xs font-semibold tabular-nums transition-colors active:scale-95 ' +
+            (az == null
+              ? 'border-border text-muted-foreground/50 cursor-not-allowed'
+              : onGoto
+                ? 'border-info-border text-info-muted-foreground hover:bg-info-muted cursor-pointer'
+                : 'border-border text-muted-foreground cursor-default')
+          }>
+          {lbl} {az == null ? '—' : `${Math.round(az)}°`}
+        </button>
+      ))}
+    </div>
+  );
+
+  return (
+    <section className="flex flex-col h-full min-h-0 rounded-lg border border-border bg-card overflow-hidden">
+      {/* Header — matches the WinKeyer / Voice keyer panels. */}
+      <div className="flex items-center gap-2 px-3 py-1.5 bg-muted/40 border-b border-border shrink-0">
+        <Compass className="size-4 text-primary shrink-0" />
+        <span className="text-xs font-semibold uppercase tracking-wider text-muted-foreground">Rotor</span>
+        <span className={cn('size-2 rounded-full', rotorEnabled ? 'bg-success' : 'bg-muted-foreground/40')}
+          title={rotorEnabled ? 'Rotator connected' : 'Rotator disabled'} />
+        <div className="flex-1" />
+        {pattern && (
+          <span
+            className={cn('px-1 py-px rounded text-[9px] font-bold tracking-wide',
+              pattern === 'reverse' ? 'bg-warning-muted text-warning-muted-foreground'
+                : pattern === 'bi' ? 'bg-info-muted text-info-muted-foreground'
+                : 'bg-success-muted text-success-muted-foreground')}
+            title={pattern === 'reverse' ? 'Ultrabeam reversed — radiates opposite the boom'
+              : pattern === 'bi' ? 'Ultrabeam bidirectional — radiates both ways'
+              : 'Ultrabeam normal'}>
+            {pattern === 'reverse' ? 'REV' : pattern === 'bi' ? 'BI' : 'NORM'}
+          </span>
+        )}
+        <span className="font-mono text-sm font-bold text-success tabular-nums">
+          {headLabel != null ? `${Math.round(headLabel).toString().padStart(3, '0')}°` : '—'}
+        </span>
+        {onClose && (
+          <button className="text-muted-foreground hover:text-foreground" title="Hide rotor" onClick={onClose}>
+            <X className="size-3.5" />
+          </button>
+        )}
+      </div>
+
+      {/* Multiple rotors — pick which one the dial shows and turns. */}
+      {rotors && rotors.length > 1 && (
+        <div className="flex flex-wrap gap-1 px-2 pt-1.5">
+          {rotors.map((nm, i) => {
+            const active = (activeRotor ?? 0) === i;
+            const label = nm?.trim() || `Rotor ${i + 1}`;
+            return (
+              <button
+                key={i}
+                onClick={() => onSelectRotor?.(i)}
+                className={cn(
+                  'flex-1 min-w-[48px] px-1.5 py-0.5 rounded text-[10px] font-semibold truncate transition-colors',
+                  active
+                    ? 'bg-success text-success-foreground'
+                    : 'bg-muted text-muted-foreground hover:bg-muted/70',
+                )}
+                title={label}
+              >
+                {label}
+              </button>
+            );
+          })}
+        </div>
+      )}
+
+      {/* Dial on the left, controls on the right. The controls column is sized to
+          fit WITHIN the dial's height: the widget sits in a row whose height is
+          set by the entry strip, so it may grow sideways but never downwards. */}
+      <div className="flex items-start gap-2 p-2 min-h-0">
+      {/* flex-col: the readout goes BELOW the dial. This wrapper was a row, so a
+          sibling of the <svg> landed beside it. */}
+      <div className="flex flex-col items-center justify-center min-h-0 shrink-0">
+        <svg
+          viewBox={`0 0 ${SIZE} ${SIZE}`}
+          className={onGoto ? 'cursor-pointer select-none' : 'select-none'}
+          style={{ width: SIZE, height: SIZE }}
+          onClick={handleClick}
+        >
+          <defs>
+            <clipPath id="rotorDial"><circle cx={C} cy={C} r={MAP_R} /></clipPath>
+          </defs>
+          {/* water + world map, clipped to the dial */}
+          <circle cx={C} cy={C} r={MAP_R} fill="#d3e7f1" />
+          <g clipPath="url(#rotorDial)">
+            {grat && <path d={grat} fill="none" stroke="#9cc0d6" strokeWidth={0.4} opacity={0.7} />}
+            {land && <path d={land} fill="#dfe2cf" stroke="#9aa589" strokeWidth={0.4} />}
+          </g>
+          {/* green azimuth bezel */}
+          <circle cx={C} cy={C} r={R} fill="none" stroke="#16a34a" strokeWidth={5} />
+
+          {/* ticks every 10°, longer at 30° */}
+          {Array.from({ length: 36 }, (_, i) => i * 10).map((d) => {
+            const major = d % 30 === 0;
+            const [x1, y1] = pt(d, MAP_R);
+            const [x2, y2] = pt(d, MAP_R - (major ? 7 : 4));
+            return <line key={d} x1={x1} y1={y1} x2={x2} y2={y2} stroke="#475569" strokeWidth={major ? 1 : 0.6} opacity={0.7} />;
+          })}
+          {/* cardinal labels + degree numbers at 45° */}
+          {cardinals.map(({ d, l }) => {
+            const [x, y] = pt(d, MAP_R - 13);
+            return <text key={l} x={x} y={y} textAnchor="middle" dominantBaseline="central" className="fill-slate-700" style={{ fontSize: l.length > 1 ? 7 : 9, fontWeight: 700 }}>{l}</text>;
+          })}
+
+          {/* DX short-path bearing → small red marker on the bezel */}
+          {bearing != null && (() => { const [x, y] = pt(bearing, MAP_R); return (
+            <circle cx={x} cy={y} r={3} fill="#dc2626" stroke="#fff" strokeWidth={1} />
+          ); })()}
+
+          {/* mechanical boom (rotor) heading — grey dashed needle, shown when the
+              Ultrabeam radiates somewhere other than the boom (reverse/bi) so the
+              operator sees where the antenna physically points vs where it boom-sits */}
+          {boomHeading != null && pattern && pattern !== 'normal' && (() => {
+            const [x, y] = pt(boomHeading, MAP_R - 2);
+            return (
+              <g>
+                <title>Boom (rotor) {Math.round(boomHeading)}°</title>
+                <line x1={C} y1={C} x2={x} y2={y} stroke="#64748b" strokeWidth={2} strokeDasharray="3 3" strokeLinecap="round" />
+                <circle cx={x} cy={y} r={3} fill="#64748b" stroke="#fff" strokeWidth={1} />
+              </g>
+            );
+          })()}
+
+          {/* radiating heading needle(s) — green; two when bidirectional */}
+          {headings.map((h, i) => { const [x, y] = pt(h, MAP_R - 2); return (
+            <g key={i}>
+              <line x1={C} y1={C} x2={x} y2={y} stroke="#15803d" strokeWidth={3} strokeLinecap="round" opacity={i === 0 ? 1 : 0.55} />
+              <polygon points={`${x},${y} ${pt(h - 5, MAP_R - 12).join(',')} ${pt(h + 5, MAP_R - 12).join(',')}`} fill="#15803d" opacity={i === 0 ? 1 : 0.55} />
+            </g>
+          ); })}
+          <circle cx={C} cy={C} r={3.5} fill="#15803d" stroke="#fff" strokeWidth={1} />
+        </svg>
+
+        {/* With the controls column present the readout goes at the FOOT OF IT
+            instead: the dial sets the widget's height, the controls are shorter
+            than the dial, and that leftover space is exactly the right size for
+            the pair. Under the dial it would push the whole widget taller. */}
+        {!showControls && pathReadout}
+      </div>
+
+      {/* Quick turns + free azimuth + Stop. */}
+      {showControls && (
+        <div className="flex flex-col gap-1.5 flex-1 min-w-0">
+          {/* Two columns so six regions fit beside the dial rather than under
+              it. An operator with fewer keeps the same compact block. */}
+          {!!presets?.length && (
+            <div className="grid grid-cols-2 gap-1">
+              {presets.map((p, i) => (
+                <button
+                  key={`${p.label}-${i}`}
+                  type="button"
+                  disabled={!onGoto}
+                  onClick={() => pressPreset(i, p.azimuth)}
+                  title={`${p.label} — ${p.azimuth}°`}
+                  className={cn(
+                    'rounded-md border py-1 text-xs font-semibold truncate transition-all duration-150 active:scale-95',
+                    flashIdx === i
+                      // Lit, and showing the azimuth it just sent: the label alone
+                      // would only say the press landed, not what was ordered.
+                      ? 'border-success bg-success text-success-foreground scale-95'
+                      : 'border-border bg-muted/40',
+                    onGoto && flashIdx !== i ? 'hover:bg-muted' : '',
+                    !onGoto ? 'opacity-50 cursor-not-allowed' : '',
+                  )}
+                >
+                  {flashIdx === i ? `${p.azimuth}°` : p.label}
+                </button>
+              ))}
+            </div>
+          )}
+
+          {/* Free azimuth: Enter sends, so the whole thing is type-three-digits
+              -and-go without reaching for the mouse. */}
+          <div className="flex gap-1">
+            <input
+              type="text"
+              inputMode="numeric"
+              value={azText}
+              onChange={(e) => setAzText(e.target.value.replace(/[^0-9]/g, '').slice(0, 3))}
+              onKeyDown={(e) => { if (e.key === 'Enter') { e.preventDefault(); sendAz(); } }}
+              placeholder={t('rotor.azPh')}
+              title={t('rotor.azTitle')}
+              disabled={!onGoto}
+              className="min-w-0 flex-1 rounded-md border border-border bg-background px-2 py-1 text-xs font-mono tabular-nums text-center disabled:opacity-50"
+            />
+            <button
+              type="button"
+              onClick={sendAz}
+              disabled={!onGoto || azText.trim() === ''}
+              title={t('rotor.go')}
+              className="flex items-center gap-1 rounded-md border border-success/60 bg-success-muted px-2 py-1 text-xs font-bold text-success-muted-foreground transition-transform hover:bg-success/25 active:scale-95 disabled:opacity-40 disabled:cursor-not-allowed"
+            >
+              <Play className="size-3" /> {t('rotor.go')}
+            </button>
+          </div>
+
+          {onStop && (
+            <button
+              type="button"
+              onClick={pressStop}
+              title={t('rotor.stop')}
+              className={cn(
+                'flex items-center justify-center gap-1.5 rounded-md border py-1 text-xs font-bold transition-all duration-150 active:scale-95',
+                stopFlash
+                  // Solid, not a tint: STOP reads the same in both languages, so
+                  // the fill is the whole acknowledgement.
+                  ? 'border-destructive bg-destructive text-destructive-foreground scale-95'
+                  : 'border-destructive/60 bg-destructive/15 text-destructive hover:bg-destructive/25',
+              )}
+            >
+              <Square className="size-3 fill-current" /> {t('rotor.stop')}
+            </button>
+          )}
+
+          {/* mt-auto: the readout sits at the FOOT of the column, level with the
+              bottom of the dial, instead of floating under the Stop button. */}
+          <div className="mt-auto">{pathReadout}</div>
+        </div>
+      )}
+      </div>
+    </section>
+  );
+}

frontend/src/components/SatellitePanel.tsx

@@ -0,0 +1,791 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import L from 'leaflet';
+import 'leaflet/dist/leaflet.css';
+import { Satellite as SatIcon, Radio, ArrowUp, ArrowDown, PanelRightClose, PanelRightOpen, Radar } from 'lucide-react';
+import {
+  GetSatelliteBirds, GetSatellitePositions, GetSatellitePasses, GetSatelliteTuning,
+  GetSatelliteGroundTrack, GetSatelliteTLEInfo, GetSatelliteNextPass, GetSatelliteSkyTrack,
+  StartSatelliteTracking, StopSatelliteTracking, GetSatelliteTracking,
+} from '../../wailsjs/go/main/App';
+import { EventsOn } from '../../wailsjs/runtime/runtime';
+import { Button } from '@/components/ui/button';
+import { gridToLatLon, splitAtAntimeridian } from '@/lib/maidenhead';
+import { BASEMAPS, type BasemapKey } from '@/components/MainMap';
+import { loadMapView, saveMapView } from '@/lib/mapView';
+import { loadMapBase, saveMapBase, MAP_BASE_SAT } from '@/lib/mapBase';
+import { writeUiPref } from '@/lib/uiPref';
+import { SkyPlot, type SkyPoint } from '@/components/SkyPlot';
+import { cn } from '@/lib/utils';
+import { useI18n } from '@/lib/i18n';
+
+// Satellites — where the birds are, and what to do with the radio.
+//
+// The tab answers the three questions a pass poses, and answers them where they
+// are asked: how long have I got (the countdown), where is it (the map), what
+// do I tune (the readout). Everything else — which satellites to follow, where
+// the elements come from, the rotator — is maintenance and lives in Settings.
+// During a pass there is no time to configure anything.
+
+type Bird = {
+  name: string; norad: number; geostationary: boolean; favorite: boolean;
+  has_elements: boolean; element_name: string; epoch_age_h: number;
+  transponders?: {
+    label: string; mode: string; down_lo: number; down_hi: number;
+    up_lo: number; up_hi: number; inverting: boolean; ctcss: number; linear: boolean;
+  }[];
+};
+type Position = {
+  name: string; lat: number; lon: number; alt_km: number; footprint_km: number;
+  az: number; el: number; range_km: number; range_rate: number;
+};
+type Pass = {
+  name: string; aos: string; los: string; aos_az: number; los_az: number;
+  max_el: number; max_el_az: number; max_el_at: string; duration_s: number;
+};
+type PassInfo = {
+  name: string; has_pass: boolean; in_pass: boolean;
+  aos: string; los: string; aos_az: number; los_az: number;
+  max_el: number; max_el_az: number; max_el_at: string; duration_s: number;
+};
+type Tuning = {
+  name: string; transponder: string; mode: string;
+  nominal_down: number; nominal_up: number; down_hz: number; up_hz: number;
+  ctcss: number; inverting: boolean;
+  az: number; el: number; range_km: number; range_rate: number; visible: boolean;
+  lat: number; lon: number; alt_km: number; footprint_km: number;
+};
+type Track = {
+  on: boolean; name: string; transponder: string; mode: string;
+  nominal_down: number; nominal_up: number; down_hz: number; up_hz: number;
+  az: number; el: number; visible: boolean;
+  radio: string; // "sat" | "downlink-only" | ""
+  error: string;
+  rot_on: boolean; rot_az: number; rot_el: number; rot_live: boolean;
+};
+
+const MAP_VIEW_SAT = 'opslog.satMapView';
+
+// The readout column. Wide enough by default to hold a frequency to the hertz
+// without wrapping, and adjustable because how much map an operator wants
+// against how much detail is theirs to decide — a station watching a footprint
+// cross an ocean wants the map, one working a pass wants the numbers.
+const SIDE_W_KEY = 'opslog.satSideWidth';
+const SIDE_SHOWN_KEY = 'opslog.satSideShown';
+const SIDE_W_DEFAULT = 336, SIDE_W_MIN = 240, SIDE_W_MAX = 720;
+const SKY_SHOWN_KEY = 'opslog.satSkyShown';
+
+const fmtHz = (hz: number) => {
+  if (!hz) return '—';
+  // Six decimals: a linear transponder is tuned to the hundred hertz, and the
+  // Doppler correction moves the last three digits every second.
+  return (hz / 1e6).toFixed(6).replace(/(\d)(?=(\d{3})+\.)/g, '$1 ');
+};
+const fmtDeg = (d: number) => `${d.toFixed(1)}°`;
+const fmtKm = (km: number) => `${Math.round(km).toLocaleString()} km`;
+const hhmm = (iso: string) => {
+  const d = new Date(iso);
+  return Number.isNaN(d.getTime()) ? '—' : d.toISOString().slice(11, 16);
+};
+const hhmmss = (iso: string) => {
+  const d = new Date(iso);
+  return Number.isNaN(d.getTime()) ? '—' : d.toISOString().slice(11, 19);
+};
+const inMin = (iso: string) => Math.round((Date.parse(iso) - Date.now()) / 60000);
+
+// A countdown an operator can act on. Seconds while they matter, then minutes,
+// then hours — nobody needs "1h 04m 37s", and nobody wants "0m" for the last
+// fifty seconds before a satellite rises.
+function fmtCountdown(ms: number): string {
+  const s = Math.max(0, Math.round(ms / 1000));
+  if (s < 60) return `${s}s`;
+  if (s < 3600) return `${Math.floor(s / 60)}m ${String(s % 60).padStart(2, '0')}s`;
+  const h = Math.floor(s / 3600);
+  return `${h}h ${String(Math.floor((s % 3600) / 60)).padStart(2, '0')}m`;
+}
+
+// The eight points of the compass, for an azimuth an operator reads rather than
+// computes. "rises at 213°" is a number; "rises SW" is a direction to look in.
+const COMPASS = ['N', 'NE', 'E', 'SE', 'S', 'SW', 'W', 'NW'];
+const compass = (deg: number) => COMPASS[Math.round(((deg % 360) + 360) % 360 / 45) % 8];
+
+// How good a pass is, as a colour. A bird 70° overhead and one scraping 12°
+// along the horizon are not the same evening, and the table should say so
+// without the operator reading every number.
+function elClass(el: number): string {
+  if (el >= 50) return 'text-success';
+  if (el >= 25) return 'text-foreground';
+  if (el >= 15) return 'text-caution';
+  return 'text-muted-foreground';
+}
+
+// The mode a satellite is worked in, as a dot: FM and SSB call for a completely
+// different set-up, and which of the two the next pass is decides whether the
+// operator reaches for a handheld or the whole station.
+const MODE_COLOUR: Record<string, string> = {
+  FM: 'var(--info)',
+  SSB: 'var(--success)',
+  CW: 'var(--caution)',
+  DATA: 'var(--warning)',
+};
+
+function ModeDot({ mode }: { mode: string }) {
+  const colour = MODE_COLOUR[mode];
+  if (!colour) return null;
+  return (
+    <span
+      title={mode}
+      className="ml-1.5 inline-block size-1.5 rounded-full align-middle"
+      style={{ backgroundColor: colour }}
+    />
+  );
+}
+
+export function SatellitePanel({ myGrid }: { myGrid: string }) {
+  const { t } = useI18n();
+  const [birds, setBirds] = useState<Bird[]>([]);
+  const [sel, setSel] = useState<string>(() => localStorage.getItem('opslog.satSelected') || '');
+  const [tpIdx, setTpIdx] = useState(0);
+  const [positions, setPositions] = useState<Position[]>([]);
+  const [passes, setPasses] = useState<Pass[]>([]);
+  const [tuning, setTuning] = useState<Tuning | null>(null);
+  const [pass, setPass] = useState<PassInfo | null>(null);
+  const [tle, setTle] = useState<{ count: number; age_h: number; stale: boolean; custom: number } | null>(null);
+  const [tracking, setTracking] = useState<Track | null>(null);
+  const [sky, setSky] = useState<SkyPoint[]>([]);
+  const [skyShown, setSkyShown] = useState(() => localStorage.getItem(SKY_SHOWN_KEY) !== '0');
+  const [err, setErr] = useState('');
+  // A clock of its own, so every countdown on the panel ticks from one instant
+  // and none of them needs a round trip to Go to lose a second.
+  const [now, setNow] = useState(() => Date.now());
+  useEffect(() => {
+    const id = window.setInterval(() => setNow(Date.now()), 1000);
+    return () => window.clearInterval(id);
+  }, []);
+
+  // What the operator follows. Chosen in Settings; following nothing means
+  // every satellite we can both find and tune, which is what somebody who has
+  // not chosen yet should see.
+  const shown = useMemo(() => {
+    const favs = birds.filter((b) => b.favorite);
+    if (favs.length > 0) return favs;
+    return birds.filter((b) => b.has_elements && (b.transponders?.length ?? 0) > 0);
+  }, [birds]);
+  const bird = useMemo(() => birds.find((b) => b.name === sel) ?? null, [birds, sel]);
+  const tp = bird?.transponders?.[tpIdx] ?? null;
+  // The mode each satellite is worked in, for the pass table's dot. Its first
+  // transponder: on a bird that has two, the first is the one it is known for.
+  const modeOf = useMemo(() => {
+    const m = new Map(birds.map((b) => [b.name, b.transponders?.[0]?.mode ?? ''] as const));
+    return (name: string) => m.get(name) ?? '';
+  }, [birds]);
+
+  // ── Data ─────────────────────────────────────────────────────────────────
+
+  const loadBirds = useCallback(async () => {
+    try {
+      const list: Bird[] = (await GetSatelliteBirds()) as any;
+      setBirds(list ?? []);
+    } catch (e: any) { setErr(String(e?.message ?? e)); }
+  }, []);
+
+  const loadTle = useCallback(async () => {
+    try { setTle((await GetSatelliteTLEInfo()) as any); } catch { /* shown as unknown */ }
+  }, []);
+
+  const loadPasses = useCallback(async () => {
+    try {
+      setPasses(((await GetSatellitePasses([], 0)) as any) ?? []);
+      setErr('');
+    } catch (e: any) { setErr(String(e?.message ?? e)); }
+  }, []);
+
+  useEffect(() => { loadBirds(); loadTle(); loadPasses(); }, [loadBirds, loadTle, loadPasses]);
+  useEffect(() => EventsOn('sat:tle', () => { loadTle(); loadBirds(); loadPasses(); }), [loadTle, loadBirds, loadPasses]);
+  useEffect(() => { if (sel) localStorage.setItem('opslog.satSelected', sel); }, [sel]);
+  useEffect(() => { setTpIdx(0); }, [sel]);
+
+  // Keep the selection inside what is followed: an operator who narrows the list
+  // in Settings must not be left looking at a satellite that is no longer there.
+  useEffect(() => {
+    if (shown.length === 0) return;
+    if (!sel || !shown.some((b) => b.name === sel)) setSel(shown[0].name);
+  }, [shown, sel]);
+
+  // The map's satellites, every five seconds: a low orbit moves about a third of
+  // a degree of longitude in that time, which is a pixel or two at this zoom.
+  useEffect(() => {
+    let live = true;
+    const tick = async () => {
+      try {
+        const p: Position[] = ((await GetSatellitePositions([])) as any) ?? [];
+        if (live) setPositions(p);
+      } catch { /* a missing locator is already reported by the passes call */ }
+    };
+    tick();
+    const id = window.setInterval(tick, 5000);
+    return () => { live = false; window.clearInterval(id); };
+  }, []);
+
+  // The readout, every second: this is the number an operator types into a
+  // radio, and a Doppler correction on 70 cm moves by a few tens of hertz a
+  // second at the middle of a pass.
+  useEffect(() => {
+    if (!sel) { setTuning(null); return; }
+    let live = true;
+    const tick = async () => {
+      try {
+        const tn: Tuning = (await GetSatelliteTuning(sel, tpIdx, 0)) as any;
+        if (live) setTuning(tn);
+      } catch { if (live) setTuning(null); }
+    };
+    tick();
+    const id = window.setInterval(tick, 1000);
+    return () => { live = false; window.clearInterval(id); };
+  }, [sel, tpIdx]);
+
+  // The pass, every twenty seconds. Predicting one steps the orbit across hours;
+  // the countdown itself is two timestamps and a clock, which the browser runs.
+  useEffect(() => {
+    if (!sel) { setPass(null); return; }
+    let live = true;
+    const tick = async () => {
+      try {
+        const p: PassInfo = (await GetSatelliteNextPass(sel)) as any;
+        if (live) setPass(p);
+      } catch { if (live) setPass(null); }
+    };
+    tick();
+    const id = window.setInterval(tick, 20_000);
+    return () => { live = false; window.clearInterval(id); };
+  }, [sel]);
+
+  // The pass drawn across the sky. Once a minute is plenty: the SHAPE of a
+  // pass does not change while it happens — only the marker on it moves, and
+  // that comes from the tuning poll a second at a time.
+  useEffect(() => {
+    if (!sel || !skyShown) { setSky([]); return; }
+    let live = true;
+    const load = async () => {
+      try {
+        const pts: SkyPoint[] = ((await GetSatelliteSkyTrack(sel, 120)) as any) ?? [];
+        if (live) setSky(pts);
+      } catch { if (live) setSky([]); }
+    };
+    load();
+    const id = window.setInterval(load, 60_000);
+    return () => { live = false; window.clearInterval(id); };
+  }, [sel, skyShown]);
+  useEffect(() => { writeUiPref(SKY_SHOWN_KEY, skyShown ? '1' : '0'); }, [skyShown]);
+
+  // Passes are cheap but not free, and they change slowly.
+  useEffect(() => {
+    const id = window.setInterval(loadPasses, 5 * 60_000);
+    return () => window.clearInterval(id);
+  }, [loadPasses]);
+
+  // The tracker's own state, pushed as it moves. Polled as well, at a lazy
+  // rate, so a panel opened while tracking is already running is not blank
+  // until the next tick.
+  useEffect(() => {
+    const read = async () => {
+      try { setTracking((await GetSatelliteTracking()) as any); } catch { /* not tracking */ }
+    };
+    read();
+    const off = EventsOn('sat:track', (s: any) => setTracking(s ?? null));
+    const id = window.setInterval(read, 10_000);
+    return () => { off(); window.clearInterval(id); };
+  }, []);
+
+  const toggleTracking = async () => {
+    setErr('');
+    try {
+      if (tracking?.on) {
+        await StopSatelliteTracking();
+        setTracking(null);
+      } else {
+        await StartSatelliteTracking(sel, tpIdx);
+        setTracking((await GetSatelliteTracking()) as any);
+      }
+    } catch (e: any) { setErr(String(e?.message ?? e)); }
+  };
+
+  // ── Map ──────────────────────────────────────────────────────────────────
+
+  const divRef = useRef<HTMLDivElement>(null);
+  const mapRef = useRef<L.Map | null>(null);
+  const layerRef = useRef<L.LayerGroup | null>(null);
+  const baseRef = useRef<L.TileLayer | null>(null);
+  const labelsRef = useRef<L.TileLayer | null>(null);
+  const [basemap, setBasemap] = useState<BasemapKey>(() => loadMapBase(MAP_BASE_SAT, 'light'));
+  const saved = useRef(loadMapView(MAP_VIEW_SAT));
+  const [track, setTrack] = useState<Position[]>([]);
+
+  const home = useMemo(() => gridToLatLon(myGrid), [myGrid]);
+
+  // ── The readout column ───────────────────────────────────────────────────
+
+  const [sideW, setSideW] = useState<number>(() => {
+    const n = parseFloat(localStorage.getItem(SIDE_W_KEY) || '');
+    return Number.isFinite(n) && n >= SIDE_W_MIN && n <= SIDE_W_MAX ? n : SIDE_W_DEFAULT;
+  });
+  const [sideShown, setSideShown] = useState(() => localStorage.getItem(SIDE_SHOWN_KEY) !== '0');
+  useEffect(() => { writeUiPref(SIDE_W_KEY, String(Math.round(sideW))); }, [sideW]);
+  useEffect(() => { writeUiPref(SIDE_SHOWN_KEY, sideShown ? '1' : '0'); }, [sideShown]);
+
+  // Dragging the grip. Measured from where the pointer STARTED rather than from
+  // the container, and with the pointer captured — without the capture the map
+  // underneath swallows the moves the instant the cursor crosses it.
+  const startSideDrag = (e: React.PointerEvent) => {
+    e.preventDefault();
+    (e.currentTarget as HTMLElement).setPointerCapture(e.pointerId);
+    const x0 = e.clientX;
+    const w0 = sideW;
+    const onMove = (ev: PointerEvent) => {
+      setSideW(Math.min(SIDE_W_MAX, Math.max(SIDE_W_MIN, Math.round(w0 + (x0 - ev.clientX)))));
+    };
+    const onUp = () => {
+      window.removeEventListener('pointermove', onMove);
+      window.removeEventListener('pointerup', onUp);
+    };
+    window.addEventListener('pointermove', onMove);
+    window.addEventListener('pointerup', onUp);
+  };
+
+  useEffect(() => {
+    if (!divRef.current || mapRef.current) return;
+    const m = L.map(divRef.current, {
+      zoomControl: true, attributionControl: true,
+      worldCopyJump: false, preferCanvas: true,
+      // Opened on the station, not on the Atlantic: the passes that matter are
+      // the ones over the operator's own head.
+      center: saved.current ? [saved.current.lat, saved.current.lon] : [home?.lat ?? 25, home?.lon ?? 0],
+      zoom: saved.current ? saved.current.zoom : 3,
+      minZoom: 2,
+    });
+    m.on('moveend', () => {
+      const c = m.getCenter();
+      saveMapView(MAP_VIEW_SAT, c.lat, c.lng, m.getZoom());
+    });
+    mapRef.current = m;
+    layerRef.current = L.layerGroup().addTo(m);
+    const ro = new ResizeObserver(() => m.invalidateSize({ animate: false }));
+    ro.observe(divRef.current);
+    const settle = window.setTimeout(() => m.invalidateSize({ animate: false }), 100);
+    return () => {
+      window.clearTimeout(settle);
+      ro.disconnect();
+      m.remove();
+      mapRef.current = null;
+      layerRef.current = null;
+    };
+  }, [home?.lat, home?.lon]);
+
+  useEffect(() => {
+    const m = mapRef.current;
+    if (!m) return;
+    baseRef.current?.remove(); labelsRef.current?.remove();
+    const bm = BASEMAPS[basemap];
+    const opts: L.TileLayerOptions = {
+      maxNativeZoom: bm.maxNativeZoom, noWrap: true,
+      bounds: L.latLngBounds(L.latLng(-85.0511, -180), L.latLng(85.0511, 180)),
+    };
+    baseRef.current = L.tileLayer(bm.url, { ...opts, attribution: bm.attr, subdomains: bm.subdomains ?? 'abc' }).addTo(m);
+    if (bm.labelsUrl) labelsRef.current = L.tileLayer(bm.labelsUrl, opts).addTo(m);
+    saveMapBase(MAP_BASE_SAT, basemap);
+  }, [basemap]);
+
+  // The selected bird's path over the ground, redrawn when the selection
+  // changes and every couple of minutes as it walks off the front of it.
+  useEffect(() => {
+    if (!sel) { setTrack([]); return; }
+    let live = true;
+    const load = async () => {
+      try {
+        const pts: Position[] = ((await GetSatelliteGroundTrack(sel, 100)) as any) ?? [];
+        if (live) setTrack(pts);
+      } catch { if (live) setTrack([]); }
+    };
+    load();
+    const id = window.setInterval(load, 120_000);
+    return () => { live = false; window.clearInterval(id); };
+  }, [sel]);
+
+  useEffect(() => {
+    const layer = layerRef.current;
+    if (!layer) return;
+    layer.clearLayers();
+    if (home) {
+      L.circleMarker([home.lat, home.lon], {
+        radius: 5, color: '#fff', weight: 2, fillColor: '#e11d48', fillOpacity: 1,
+      }).bindTooltip(myGrid, { direction: 'top' }).addTo(layer);
+    }
+    if (track.length > 1) {
+      const pts = splitAtAntimeridian(track.map((p) => [p.lat, p.lon] as [number, number]));
+      L.polyline(pts as L.LatLngExpression[][], {
+        color: 'var(--info)', weight: 1.2, opacity: 0.7, dashArray: '4 4', smoothFactor: 0,
+      }).addTo(layer);
+    }
+    const wanted = new Set(shown.map((b) => b.name));
+    for (const p of positions) {
+      if (!wanted.has(p.name) && p.name !== sel) continue;
+      const chosen = p.name === sel;
+      const up = p.el > 0;
+      const colour = chosen ? '#22c55e' : up ? '#f59e0b' : '#9ca3af';
+      // The footprint is the honest answer to "can I hear it": everything inside
+      // the circle has the satellite above its horizon.
+      L.circle([p.lat, p.lon], {
+        radius: p.footprint_km * 1000,
+        color: colour, weight: chosen ? 1.2 : 0.8, opacity: chosen ? 0.7 : 0.35,
+        fillColor: colour, fillOpacity: chosen ? 0.1 : 0.05,
+      }).addTo(layer);
+      L.circleMarker([p.lat, p.lon], {
+        radius: chosen ? 6 : 4, color: '#fff', weight: 1,
+        fillColor: colour, fillOpacity: 1,
+      })
+        .bindTooltip(`${p.name} · ${fmtDeg(p.el)} · ${Math.round(p.alt_km)} km`, { direction: 'top' })
+        .on('click', () => setSel(p.name))
+        .addTo(layer);
+    }
+  }, [positions, track, home?.lat, home?.lon, myGrid, sel, shown]);
+
+  // ── Render ───────────────────────────────────────────────────────────────
+
+  // The pass, as a countdown and a bar. Both derived here from two timestamps,
+  // so they move every second without asking Go anything.
+  const aosMs = pass?.has_pass ? Date.parse(pass.aos) : 0;
+  const losMs = pass?.has_pass ? Date.parse(pass.los) : 0;
+  const inPass = !!pass?.has_pass && now >= aosMs && now < losMs;
+  const progress = inPass && losMs > aosMs ? (now - aosMs) / (losMs - aosMs) : 0;
+
+  return (
+    <div className="flex flex-col h-full min-h-0 gap-1 p-1">
+      {/* Header: what to work, and the one button that touches the radio.
+          Everything else about satellites — which ones, where the elements come
+          from, the rotator — is in Settings, because none of it is something to
+          do while a bird is going over. */}
+      <div className="flex items-center gap-2 flex-wrap px-1 shrink-0">
+        <SatIcon className="size-4 text-muted-foreground" />
+        <select
+          className="h-7 rounded-md border border-border bg-background px-2 text-xs min-w-[12rem]"
+          value={sel}
+          onChange={(e) => setSel(e.target.value)}
+        >
+          {shown.length === 0 && <option value="">{t('sat.noneFollowed')}</option>}
+          {shown.map((b) => (
+            <option key={b.name} value={b.name} disabled={!b.has_elements && !b.geostationary}>
+              {b.name}{b.has_elements || b.geostationary ? '' : ` — ${t('sat.noElements')}`}
+            </option>
+          ))}
+        </select>
+        {(bird?.transponders?.length ?? 0) > 1 && (
+          <select
+            className="h-7 rounded-md border border-border bg-background px-2 text-xs"
+            value={tpIdx}
+            onChange={(e) => setTpIdx(Number(e.target.value))}
+          >
+            {bird!.transponders!.map((x, i) => (
+              <option key={i} value={i}>{x.label}</option>
+            ))}
+          </select>
+        )}
+        <Button
+          size="sm"
+          variant={tracking?.on ? 'default' : 'outline'}
+          className={cn('h-7 px-2 gap-1.5', tracking?.on && 'bg-success text-background hover:bg-success/90')}
+          onClick={toggleTracking}
+          disabled={!bird?.transponders?.length}
+          title={tracking?.on
+            ? (tracking.radio === 'sat' ? t('sat.trackingFull') : t('sat.trackingDown'))
+            : t('sat.trackTip')}
+        >
+          <Radio className="size-3.5" />
+          {tracking?.on ? t('sat.tracking') : t('sat.track')}
+        </Button>
+        {tracking?.on && tracking.radio === 'downlink-only' && (
+          <span className="text-[11px] text-warning">{t('sat.downlinkOnly')}</span>
+        )}
+        <div className="flex-1" />
+        {/* Elements are maintenance, so only their AGE is here — and only when
+            it has become a reason the panel might be wrong. */}
+        {tle?.stale && <span className="text-[11px] text-warning">{t('sat.tleStale')}</span>}
+        <select
+          className="h-7 rounded-md border border-border bg-background px-2 text-xs"
+          value={basemap}
+          onChange={(e) => setBasemap(e.target.value as BasemapKey)}
+        >
+          {Object.entries(BASEMAPS).map(([k, v]) => <option key={k} value={k}>{v.label}</option>)}
+        </select>
+        <Button
+          variant="ghost" size="sm"
+          className={cn('h-7 px-1.5', skyShown && 'text-success')}
+          onClick={() => setSkyShown((v) => !v)}
+          title={skyShown ? t('sat.hideSky') : t('sat.showSky')}
+        >
+          <Radar className="size-3.5" />
+        </Button>
+        {/* Put the whole window on the map. On a laptop the readout takes a
+            third of the screen, and there are moments — watching a footprint
+            cross an ocean — when the map IS the answer. */}
+        <Button
+          variant="ghost" size="sm" className="h-7 px-1.5"
+          onClick={() => setSideShown((v) => !v)}
+          title={sideShown ? t('sat.hideSide') : t('sat.showSide')}
+        >
+          {sideShown ? <PanelRightClose className="size-3.5" /> : <PanelRightOpen className="size-3.5" />}
+        </Button>
+      </div>
+
+      {err && <div className="px-2 text-[11px] text-danger shrink-0">{err}</div>}
+
+      <div className="flex gap-1 flex-1 min-h-0">
+        {/* The map. isolate is load-bearing, not tidiness: Leaflet stacks its
+            own panes and controls up to z-index 1000, which without a stacking
+            context of their own float over Preferences and every dialog in the
+            app — the map ends up on top of the very buttons that would close
+            it. */}
+        <div className="relative isolate z-0 flex-1 min-w-0 rounded-lg overflow-hidden border border-border">
+          <div ref={divRef} className="h-full w-full" />
+        </div>
+
+        {sideShown && (
+          <div
+            role="separator"
+            aria-orientation="vertical"
+            title={t('sat.sideWidthTip')}
+            onPointerDown={startSideDrag}
+            onDoubleClick={() => setSideW(SIDE_W_DEFAULT)}
+            className="group relative shrink-0 w-2 cursor-col-resize flex items-center justify-center"
+          >
+            <span className="h-10 w-[3px] rounded-full bg-border group-hover:bg-primary transition-colors" />
+          </div>
+        )}
+
+        <div className={cn('shrink-0 flex flex-col gap-1 min-h-0', !sideShown && 'hidden')}
+          style={{ width: sideW }}>
+          {/* The pass. The first thing an operator looks at and the reason they
+              sit down: how long have I got, and how high does it get. */}
+          <div className={cn('rounded-lg border bg-card p-2',
+            inPass ? 'border-success/60' : 'border-border')}>
+            <div className="flex items-baseline justify-between gap-2">
+              <span className="font-medium text-sm truncate">{bird?.name ?? '—'}</span>
+              <span className="text-[11px] text-muted-foreground truncate">{tp?.label ?? ''}</span>
+            </div>
+
+            {bird?.geostationary ? (
+              <div className="mt-1 text-[11px] text-muted-foreground">{t('sat.geoHint')}</div>
+            ) : !pass?.has_pass ? (
+              <div className="mt-1 text-[11px] text-muted-foreground">{t('sat.noPassSoon')}</div>
+            ) : (
+              <>
+                <div className="mt-1 flex items-baseline gap-2">
+                  <span className={cn('text-[10px] uppercase tracking-wide',
+                    inPass ? 'text-success' : 'text-muted-foreground')}>
+                    {inPass ? t('sat.los') : t('sat.aos')}
+                  </span>
+                  <span className={cn('text-xl font-semibold tabular-nums leading-none',
+                    inPass && 'text-success')}>
+                    {fmtCountdown((inPass ? losMs : aosMs) - now)}
+                  </span>
+                  <span className="text-[11px] text-muted-foreground tabular-nums ml-auto">
+                    {hhmmss(inPass ? pass.los : pass.aos)}Z
+                  </span>
+                </div>
+
+                {/* Where in the pass we are. A bar because the useful question
+                    mid-pass is not the clock but "am I past the peak". */}
+                <div className="mt-1.5 h-1 rounded-full bg-muted overflow-hidden">
+                  <div className="h-full bg-success transition-[width] duration-1000 ease-linear"
+                    style={{ width: `${Math.round(progress * 100)}%` }} />
+                </div>
+
+                <div className="mt-1.5 grid grid-cols-3 gap-1 text-[11px] tabular-nums">
+                  <PassBit label={t('sat.rise')} value={`${hhmm(pass.aos)} ${compass(pass.aos_az)}`} />
+                  <PassBit label={t('sat.peak')} value={`${Math.round(pass.max_el)}° ${compass(pass.max_el_az)}`}
+                    strong={pass.max_el >= 30} />
+                  <PassBit label={t('sat.set')} value={`${hhmm(pass.los)} ${compass(pass.los_az)}`} />
+                </div>
+              </>
+            )}
+          </div>
+
+          {/* The sky, seen from underneath it: the centre is straight up, the
+              rim is the horizon, north is at the top. One glance says whether
+              the pass comes over the roof or along the treeline. */}
+          {skyShown && (
+            <div className="rounded-lg border border-border bg-card p-2">
+              <SkyPlot
+                track={sky}
+                az={tuning?.az ?? null}
+                el={tuning?.el ?? null}
+                name={bird?.name}
+                visible={!!tuning?.visible}
+              />
+            </div>
+          )}
+
+          {/* Where it is, right now. */}
+          <div className="rounded-lg border border-border bg-card p-2">
+            <div className="grid grid-cols-2 gap-2">
+              <Readout label={t('sat.az')} value={tuning ? fmtDeg(tuning.az) : '—'}
+                sub={tuning ? compass(tuning.az) : ''} />
+              <Readout label={t('sat.el')} value={tuning ? fmtDeg(tuning.el) : '—'}
+                colour={tuning?.visible ? 'var(--success)' : 'var(--muted-foreground)'}
+                sub={tuning ? (tuning.visible ? t('sat.up') : t('sat.below')) : ''} />
+            </div>
+
+            <div className="mt-2 grid grid-cols-3 gap-1 text-[11px] tabular-nums">
+              <PassBit label={t('sat.range')} value={tuning?.range_km ? fmtKm(tuning.range_km) : '—'} />
+              <PassBit label={t('sat.altitude')} value={tuning?.alt_km ? fmtKm(tuning.alt_km) : '—'} />
+              <PassBit label={t('sat.footprint')} value={tuning?.footprint_km ? fmtKm(tuning.footprint_km) : '—'} />
+            </div>
+
+            {/* Approaching or receding, which is the sign of the whole Doppler
+                correction and the one number that explains why the frequencies
+                are moving the way they are. */}
+            {!!tuning && !bird?.geostationary && (
+              <div className="mt-1.5 flex items-center gap-1.5 text-[11px] text-muted-foreground tabular-nums">
+                {tuning.range_rate < 0
+                  ? <ArrowUp className="size-3 text-success" />
+                  : <ArrowDown className="size-3 text-warning" />}
+                <span>{tuning.range_rate < 0 ? t('sat.approaching') : t('sat.receding')}</span>
+                <span>{Math.abs(tuning.range_rate).toFixed(2)} km/s</span>
+              </div>
+            )}
+
+            {/* Where the antenna is, beside where the satellite is. The two
+                differing is a rotator still slewing; the two differing for a
+                long time is a rotator that is stuck, and that is worth being
+                able to see without walking outside. */}
+            {tracking?.rot_on && (
+              <div className="mt-1.5 pt-1.5 border-t border-border/60 flex items-baseline gap-2 text-[11px] tabular-nums">
+                <span className="text-muted-foreground uppercase tracking-wide text-[10px]">{t('sat.antenna')}</span>
+                <span className="font-medium">{fmtDeg(tracking.rot_az)} / {fmtDeg(tracking.rot_el)}</span>
+                {!tracking.rot_live && <span className="text-muted-foreground">{t('sat.rotCommanded')}</span>}
+              </div>
+            )}
+          </div>
+
+          {/* What to tune. */}
+          <div className="rounded-lg border border-border bg-card p-2">
+            <div className="space-y-1">
+              <FreqRow label={t('sat.down')} hz={tuning?.down_hz ?? 0} nominal={tuning?.nominal_down ?? 0} />
+              <FreqRow label={t('sat.up')} hz={tuning?.up_hz ?? 0} nominal={tuning?.nominal_up ?? 0} />
+            </div>
+            <div className="mt-1.5 flex flex-wrap gap-x-3 gap-y-0.5 text-[11px] text-muted-foreground">
+              {!!tp?.mode && <span>{tp.mode}</span>}
+              {!!tp?.ctcss && <span>CTCSS {tp.ctcss.toFixed(1)}</span>}
+              {tp?.inverting && <span>{t('sat.inverting')}</span>}
+              {tp?.linear && <span>{Math.round((tp.down_hi - tp.down_lo) / 1000)} kHz</span>}
+              {bird?.geostationary && <span>{t('sat.geo')}</span>}
+            </div>
+          </div>
+
+          {/* What is coming. */}
+          <div className="rounded-lg border border-border bg-card flex-1 min-h-0 flex flex-col">
+            <div className="px-2 py-1 text-[11px] font-medium text-muted-foreground border-b border-border shrink-0">
+              {t('sat.nextPasses')}
+            </div>
+            <div className="flex-1 min-h-0 overflow-auto">
+              {passes.length === 0 && (
+                <div className="p-2 text-[11px] text-muted-foreground">{t('sat.noPasses')}</div>
+              )}
+              {passes.length > 0 && (
+                // A real table, so the name column takes the width the longest
+                // name needs — "ZHUHAI-1 OVS-1A" was cut to eight characters in
+                // a fixed one — and the rest keeps its columns lined up under
+                // headings that say what the numbers are.
+                <table className="w-full text-[11px] tabular-nums">
+                  <thead className="sticky top-0 z-10 bg-card">
+                    <tr className="text-[10px] uppercase tracking-wide text-muted-foreground">
+                      <th className="text-left font-medium px-2 py-1">{t('sat.thSat')}</th>
+                      <th className="text-left font-medium py-1">{t('sat.thAos')}</th>
+                      <th className="text-left font-medium py-1">{t('sat.thLos')}</th>
+                      <th className="text-right font-medium py-1">{t('sat.thMaxEl')}</th>
+                      <th className="text-right font-medium px-2 py-1">{t('sat.thIn')}</th>
+                    </tr>
+                  </thead>
+                  <tbody>
+                    {passes.map((p, i) => {
+                      const aos = Date.parse(p.aos);
+                      const running = aos <= now && Date.parse(p.los) > now;
+                      const soon = !running && aos - now < 5 * 60_000;
+                      return (
+                        <tr
+                          key={`${p.name}-${p.aos}-${i}`}
+                          onClick={() => setSel(p.name)}
+                          className={cn(
+                            'cursor-pointer hover:bg-accent/50 border-t border-border/40',
+                            p.name === sel && 'bg-accent/40',
+                            running && 'bg-success/10',
+                          )}
+                        >
+                          <td className="px-2 py-1 whitespace-nowrap">
+                            <span className={cn('font-medium', running && 'text-success')}>{p.name}</span>
+                            <ModeDot mode={modeOf(p.name)} />
+                          </td>
+                          <td className="py-1 whitespace-nowrap">{hhmm(p.aos)}</td>
+                          <td className="py-1 whitespace-nowrap text-muted-foreground">{hhmm(p.los)}</td>
+                          {/* The elevation is the quality of the pass, so it is
+                              coloured like one: a 70° pass overhead and a 12°
+                              scrape along the horizon are not the same evening. */}
+                          <td className={cn('py-1 text-right font-medium', elClass(p.max_el))}>
+                            {Math.round(p.max_el)}°
+                          </td>
+                          <td className={cn('px-2 py-1 text-right whitespace-nowrap',
+                            running ? 'text-success font-medium' : soon ? 'text-warning' : 'text-muted-foreground')}>
+                            {running ? t('sat.now') : fmtCountdown(aos - now)}
+                          </td>
+                        </tr>
+                      );
+                    })}
+                  </tbody>
+                </table>
+              )}
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+}
+
+function Readout({ label, value, colour, sub }: { label: string; value: string; colour?: string; sub?: string }) {
+  return (
+    <div className="rounded-md bg-muted/40 px-2 py-1">
+      <div className="text-[10px] uppercase tracking-wide text-muted-foreground">{label}</div>
+      <div className="flex items-baseline gap-1.5">
+        <span className="text-lg font-semibold tabular-nums leading-tight" style={colour ? { color: colour } : undefined}>
+          {value}
+        </span>
+        {!!sub && <span className="text-[10px] text-muted-foreground">{sub}</span>}
+      </div>
+    </div>
+  );
+}
+
+function PassBit({ label, value, strong }: { label: string; value: string; strong?: boolean }) {
+  return (
+    <div className="min-w-0">
+      <div className="text-[10px] uppercase tracking-wide text-muted-foreground truncate">{label}</div>
+      <div className={cn('truncate', strong && 'font-semibold text-foreground')}>{value}</div>
+    </div>
+  );
+}
+
+// The corrected frequency large, the nominal one small beside it. Showing only
+// one of them leaves an operator unable to tell a Doppler correction from a
+// mistuned transponder.
+function FreqRow({ label, hz, nominal }: { label: string; hz: number; nominal: number }) {
+  const shift = hz && nominal ? hz - nominal : 0;
+  return (
+    <div className="flex items-baseline gap-2">
+      <span className="w-10 text-[10px] uppercase tracking-wide text-muted-foreground">{label}</span>
+      <span className="text-base font-semibold tabular-nums">{fmtHz(hz)}</span>
+      {!!shift && (
+        <span className="text-[10px] tabular-nums text-muted-foreground">
+          {shift > 0 ? '+' : '−'}{Math.abs(Math.round(shift))} Hz
+        </span>
+      )}
+    </div>
+  );
+}

frontend/src/components/SettingsModal.tsx

@@ -19,6 +19,8 @@ import {
   GetAntGeniusSettings, SaveAntGeniusSettings,
   GetTunerGeniusSettings, SaveTunerGeniusSettings,
   GetPSUSettings, SavePSUSettings,
+  GetSatSettings, SaveSatSettings, TestSatelliteRotator,
+  GetSatelliteTLEInfo, RefreshSatelliteTLE, AddSatelliteElements, GetSatelliteBirds,
   GetAmplifiers, SaveAmplifiers, GetAmpStatuses, AmpOperate,
   GetWinkeyerSettings, SaveWinkeyerSettings, ListSerialPorts,
   GetAudioSettings, SaveAudioSettings, AudioApplyLevels, ListAudioInputDevices, ListAudioOutputDevices, PickAudioFolder, TestPTT,
@@ -60,7 +62,7 @@ import {
   GetFolderSync, SaveFolderSync, PickFolderSyncFolder, GetFolderSyncStatus, SyncFolderNow,
   GetRelayAuto, SaveRelayAuto, GetStationDevices,
   GetAwardDefs, GetTrackedAwards, SaveTrackedAwards,
-  GetBandOpenSettings, SaveBandOpenSettings, GetGridScopeSettings, SaveGridScopeSettings, GetPSKReporterStatus, GetChaseNewGrids, SetChaseNewGrids, GetChaseNew, SetChaseNew, GetPSKTargetSettings, SavePSKTargetSettings, GetAutoCallSettings, SaveAutoCallSettings, GetWatchlistContestCalls, SetWatchlistContestCalls, GetWatchlistContestPattern, SetWatchlistContestPattern, GetGridCacheStatus, GetLinkedAmps, SetLinkedAmps, GetSpotTTLMinutes, SetSpotTTLMinutes, GetSpotMax, SetSpotMax, 
+  GetBandOpenSettings, SaveBandOpenSettings, GetGridScopeSettings, SaveGridScopeSettings, GetPSKReporterStatus, GetChaseNewGrids, SetChaseNewGrids, GetChaseNew, SetChaseNew, GetPSKTargetSettings, SavePSKTargetSettings, GetAutoCallSettings, SaveAutoCallSettings, GetChaseNewBands, SetChaseNewBands, GetWatchlistContestCalls, SetWatchlistContestCalls, GetWatchlistContestPattern, SetWatchlistContestPattern, GetGridCacheStatus, GetLinkedAmps, SetLinkedAmps, GetSpotTTLMinutes, SetSpotTTLMinutes, GetSpotMax, SetSpotMax, 
 } from '../../wailsjs/go/main/App';
 import type { profile as profileModels } from '../../wailsjs/go/models';
 import type { LookupSettingsForm, StationSettingsForm, ListsSettingsForm, ModePresetForm } from '@/types';
@@ -83,6 +85,7 @@ import {
 import { cn } from '@/lib/utils';
 import { writeUiPref } from '@/lib/uiPref';
 import { setUseMiles } from '@/lib/units';
+import { rotorStyle, setRotorStyle, type RotorStyle } from '@/lib/rotorStyle';
 import { iaruRegion, setIaruRegion, type IaruRegion } from '@/lib/bandplan';
 import { getDateFormat, setDateFormat, type DateFormat } from '@/lib/dateFormat';
 import { useI18n, FlagGB, FlagFR, type Lang } from '@/lib/i18n';
@@ -91,6 +94,7 @@ import { OperatingPanel } from '@/components/OperatingPanel';
 import { AppearancePanel } from '@/components/AppearancePanel';
 import { UDPIntegrationsPanel } from '@/components/UDPIntegrationsPanel';
 import { loadClusterMacros, saveClusterMacros, type ClusterMacro } from '@/lib/clusterMacros';
+import { CLUSTER_PRESETS } from '@/lib/clusterPresets';
 
 type LookupSettings = LookupSettingsForm;
 type StationSettings = StationSettingsForm;
@@ -211,7 +215,6 @@ type SectionId =
   | 'lookup'
   | 'lists-bands'
   | 'lists-modes'
-  | 'lists-satellites'
   | 'cluster'
   | 'dxhunter'
   | 'backup'
@@ -227,6 +230,7 @@ type SectionId =
   | 'antgenius'
   | 'tunergenius'
   | 'psu'
+  | 'satellite'
   | 'pgxl'
   | 'flex'
   | 'relayauto'
@@ -309,6 +313,10 @@ function buildTree(flexAvailable: boolean, t: (k: string) => string): TreeNode[]
       { kind: 'item', label: t('sec.station'), id: 'station' },
       { kind: 'item', label: t('sec.profiles'), id: 'profiles' },
       { kind: 'item', label: t('sec.operating'), id: 'operating' },
+      // Not hardware, whatever the rotator block inside it suggests: which
+      // satellites you chase, where your antenna stands and how old your
+      // elements are is operating, and it sits with the rest of it.
+      { kind: 'item', label: t('sec.satellite'),    id: 'satellite' },
       { kind: 'item', label: t('sec.confirmations'), id: 'confirmations' },
       { kind: 'item', label: t('sec.awards'), id: 'awards' },
       { kind: 'item', label: t('sec.external'), id: 'external-services' },
@@ -323,7 +331,6 @@ function buildTree(flexAvailable: boolean, t: (k: string) => string): TreeNode[]
       { kind: 'group', label: t('nav.lists'), icon: Database, defaultOpen: true, children: [
         { kind: 'item', label: t('sec.bands'),      id: 'lists-bands' },
         { kind: 'item', label: t('sec.modes'), id: 'lists-modes' },
-        { kind: 'item', label: t('sec.satellites'), id: 'lists-satellites' },
       ]},
       { kind: 'item', label: t('sec.cluster'),     id: 'cluster' },
       { kind: 'item', label: t('sec.dxhunter'),    id: 'dxhunter' },
@@ -354,7 +361,7 @@ function buildTree(flexAvailable: boolean, t: (k: string) => string): TreeNode[]
 // Map section id → i18n key (breadcrumb / placeholders).
 const SECTION_KEY: Partial<Record<SectionId, string>> = {
   station: 'sec.station', profiles: 'sec.profiles', operating: 'sec.operating', confirmations: 'sec.confirmations',
-  'external-services': 'sec.external', appearance: 'sec.appearance', lookup: 'sec.lookup', 'lists-bands': 'sec.bands', 'lists-modes': 'sec.modes', 'lists-satellites': 'sec.satellites',
+  'external-services': 'sec.external', appearance: 'sec.appearance', lookup: 'sec.lookup', 'lists-bands': 'sec.bands', 'lists-modes': 'sec.modes',
   cluster: 'sec.cluster', backup: 'sec.backup', database: 'sec.database', autostart: 'sec.autostart', udp: 'sec.udp',
   adifmon: 'sec.adifmon',
   foldersync: 'sec.foldersync',
@@ -376,7 +383,6 @@ const SECTION_LABELS: Partial<Record<SectionId, string>> = {
   lookup: 'Callsign Lookup',
   'lists-bands': 'Bands',
   'lists-modes': 'Modes & default RST',
-  'lists-satellites': 'Satellites',
   cluster: 'DX Cluster',
   backup: 'Database backup',
   database: 'Database',
@@ -405,16 +411,21 @@ interface TreeProps {
   flexAvailable?: boolean;
 }
 
-function Tree({ selected, onSelect, flexAvailable }: TreeProps) {
+// The sidebar. Memoised and its tree built once per (language, radio): it is
+// sixty-odd items that depend on nothing an operator types, and it was rebuilt
+// and re-rendered on every keystroke in every field of every panel — the whole
+// dialog holds its state in one component, so one character redraws all of it.
+const Tree = memo(function Tree({ selected, onSelect, flexAvailable }: TreeProps) {
   const { t } = useI18n();
+  const nodes = useMemo(() => buildTree(!!flexAvailable, t), [flexAvailable, t]);
   return (
     <nav className="text-sm">
-      {buildTree(!!flexAvailable, t).map((node, i) => (
+      {nodes.map((node, i) => (
         <TreeNodeView key={i} node={node} depth={0} selected={selected} onSelect={onSelect} />
       ))}
     </nav>
   );
-}
+});
 
 function TreeNodeView({
   node, depth, selected, onSelect,
@@ -472,6 +483,11 @@ function TreeNodeView({
 // identity is STABLE across SettingsModal re-renders; defining them inside the
 // component would give each render a fresh function, remounting the Radix
 // Select and slamming the open dropdown shut on any ambient re-render.
+// The bands the Chase new filter offers, in band-plan order. Mirrors
+// ChaseNewBands in pskchase.go, which is what actually filters the feed —
+// a band added there and not here is simply one nobody can switch off.
+const CHASE_BANDS = ['160m', '80m', '60m', '40m', '30m', '20m', '17m', '15m', '12m', '10m', '6m', '4m', '2m', '70cm'];
+
 const THEME_SWATCH: Record<Exclude<ThemeChoice, 'auto'>, { bg: string; card: string; accent: string }> = {
   'light-warm':    { bg: '#e8dfc9', card: '#faf6ea', accent: '#b8410c' },
   'light-cool':    { bg: '#f4f6f8', card: '#ffffff', accent: '#2563eb' },
@@ -900,6 +916,66 @@ const MOTOR_BAND_DEFAULT_KHZ: Record<string, number> = {
 const relayCountUI = (type: string) =>
   type === 'kmtronic' || type === 'denkovi' ? 8 : type === 'httpgen' ? 4 : 5;
 
+// The twelve cluster command macros.
+//
+// Module-scoped, with its own state, and that is the point rather than tidiness:
+// nested inside SettingsModal every keystroke in one of these twenty-four boxes
+// re-rendered the WHOLE preferences dialog — every list, every form, every
+// panel — and the letters arrived visibly after the finger had left the key.
+// Here a keystroke re-renders twelve rows.
+//
+// Written on every keystroke as before. This panel has no Save button, and a
+// text box whose contents only take effect on some other button is how work
+// gets lost; the database write is what waits (see saveClusterMacros).
+function ClusterMacroEditor() {
+  const { t } = useI18n();
+  const [macros, setMacros] = useState<ClusterMacro[]>(loadClusterMacros);
+  const setMacro = (i: number, patch: Partial<ClusterMacro>) => {
+    setMacros((cur) => {
+      const next = cur.map((m, j) => (j === i ? { ...m, ...patch } : m));
+      saveClusterMacros(next);
+      return next;
+    });
+  };
+  return (
+    <div className="border-t border-border/60 pt-3 space-y-2">
+      <div>
+        <span className="text-sm font-medium">{t('clu.macros')}</span>
+      </div>
+      {/* Two columns of six: twelve rows stacked would push everything else
+          in this panel off the screen. */}
+      <div className="grid grid-cols-1 md:grid-cols-2 gap-x-4 gap-y-1.5">
+        {macros.map((m, i) => (
+          <div key={i} className="flex items-center gap-1.5">
+            <span className="text-[10px] text-muted-foreground tabular-nums w-4 text-right shrink-0">{i + 1}</span>
+            <Input
+              className="h-8 w-28 shrink-0 text-xs"
+              placeholder={t('clu.macroLabel')}
+              value={m.label}
+              maxLength={24}
+              onChange={(e) => setMacro(i, { label: e.target.value })}
+            />
+            {/* 500, not 120. A DXSpider filter is a list of prefixes and an
+                operator's own list of wanted countries runs past a hundred
+                characters easily — the field simply stopped accepting
+                keystrokes, with nothing to say why, and the command was saved
+                truncated. The title shows the whole thing, since the box
+                cannot. */}
+            <Input
+              className="h-8 flex-1 min-w-0 font-mono text-xs"
+              placeholder={t('clu.macroCmd')}
+              value={m.cmd}
+              title={m.cmd}
+              maxLength={500}
+              onChange={(e) => setMacro(i, { cmd: e.target.value })}
+            />
+          </div>
+        ))}
+      </div>
+    </div>
+  );
+}
+
 // Live status + OPERATE/STANDBY toggle for ONE configured amplifier (by config
 // id) — SPE / ACOM / PGXL alike. Module-scoped (not a nested component) so it
 // isn't remounted on every parent render. Polls once a second while shown.
@@ -1309,6 +1385,168 @@ function AwardsSelectionPanel({ profile }: { profile?: { name?: string; callsign
   );
 }
 
+// SatelliteElementsBlock is where the orbital elements are kept up to date.
+//
+// In Settings rather than in the tab because it is maintenance, not operating:
+// during a pass an operator wants the frequencies and the countdown, not a
+// download button. Module-scope so it may hold its own hooks (see PanelHost).
+function SatelliteElementsBlock({ autoTle, onAutoTle }: { autoTle: boolean; onAutoTle: (v: boolean) => void }) {
+  const { t } = useI18n();
+  const [info, setInfo] = useState<{ count: number; age_h: number; stale: boolean; custom: number } | null>(null);
+  const [busy, setBusy] = useState(false);
+  const [msg, setMsg] = useState('');
+  const [paste, setPaste] = useState('');
+  const [showPaste, setShowPaste] = useState(false);
+
+  const read = async () => { try { setInfo(await GetSatelliteTLEInfo() as any); } catch { /* shown as unknown */ } };
+  useEffect(() => { read(); }, []);
+
+  const refresh = async () => {
+    setBusy(true); setMsg('');
+    try {
+      const i: any = await RefreshSatelliteTLE();
+      setInfo(i);
+      setMsg(t('satset.tleFetched', { n: i?.count ?? 0 }));
+    } catch (e: any) { setMsg(String(e?.message ?? e)); }
+    setBusy(false);
+  };
+
+  const addPasted = async () => {
+    setMsg('');
+    try {
+      const n: number = (await AddSatelliteElements(paste)) as any;
+      setPaste(''); setShowPaste(false);
+      await read();
+      setMsg(t('satset.tleAdded', { n }));
+    } catch (e: any) { setMsg(String(e?.message ?? e)); }
+  };
+
+  const age = !info ? '—'
+    : info.count === 0 ? t('satset.tleNone')
+    : t('satset.tleAge', { n: info.count, h: Math.round(info.age_h) });
+
+  return (
+    <div className="space-y-3">
+      <h4 className="text-sm font-semibold text-foreground">{t('satset.elements')}</h4>
+      <div className="flex items-center gap-3 flex-wrap">
+        <span className={cn('text-sm tabular-nums', info?.stale ? 'text-warning' : 'text-muted-foreground')}>{age}</span>
+        {!!info?.custom && <span className="text-xs text-muted-foreground">{t('satset.tleCustom', { n: info.custom })}</span>}
+        <Button size="sm" variant="outline" onClick={refresh} disabled={busy}>
+          {busy ? t('satset.tleFetching') : t('satset.tleFetch')}
+        </Button>
+        <Button size="sm" variant="ghost" onClick={() => setShowPaste((v) => !v)}>{t('satset.tlePaste')}</Button>
+      </div>
+      <label className="flex items-center gap-2 text-sm cursor-pointer">
+        <Checkbox checked={autoTle} onCheckedChange={(c) => onAutoTle(!!c)} />
+        {t('satset.autoTle')}
+      </label>
+      <p className="text-xs text-muted-foreground">{t('satset.tleHint')}</p>
+      {showPaste && (
+        <div className="space-y-2">
+          <Textarea rows={5} className="font-mono text-xs" placeholder={t('satset.tlePastePlaceholder')}
+            value={paste} onChange={(e) => setPaste(e.target.value)} />
+          <div className="flex items-center gap-2">
+            <Button size="sm" onClick={addPasted} disabled={!paste.trim()}>{t('satset.tlePasteAdd')}</Button>
+            <span className="text-xs text-muted-foreground">{t('satset.tlePasteHint')}</span>
+          </div>
+        </div>
+      )}
+      {msg && <div className="text-xs text-muted-foreground">{msg}</div>}
+    </div>
+  );
+}
+
+// SatelliteFollowList chooses which satellites the tab shows and the tracker
+// offers — the same two-column shape as the awards, for the same reason: a feed
+// carries a couple of hundred birds and an operator works six.
+//
+// Following none means following every satellite that has both elements and a
+// frequency plan, which is the sensible thing for somebody who has not chosen
+// yet and the reason the list does not start out empty-handed.
+function SatelliteFollowList({ followed, onChange }: { followed: string[]; onChange: (next: string[]) => void }) {
+  const { t } = useI18n();
+  const [all, setAll] = useState<any[]>([]);
+  const [q, setQ] = useState('');
+  const [withPlanOnly, setWithPlanOnly] = useState(true);
+
+  useEffect(() => {
+    (async () => {
+      try { setAll(((await GetSatelliteBirds()) ?? []) as any[]); } catch { /* an empty list says it itself */ }
+    })();
+  }, []);
+
+  const followedSet = new Set(followed.map((s) => s.toUpperCase()));
+  const byName = new Map(all.map((b) => [b.name as string, b] as const));
+  const needle = q.trim().toLowerCase();
+  const available = all.filter((b) => !followedSet.has(String(b.name).toUpperCase())
+    && (!withPlanOnly || (b.transponders?.length ?? 0) > 0)
+    && (needle === '' || String(b.name).toLowerCase().includes(needle)));
+  const chosen = followed.map((n) => byName.get(n) ?? { name: n, has_elements: false, transponders: [] });
+
+  const label = (b: any) => {
+    const bits: string[] = [];
+    if ((b.transponders?.length ?? 0) > 0) bits.push(b.transponders.map((x: any) => x.mode).filter((m: string, i: number, a: string[]) => a.indexOf(m) === i).join('/'));
+    if (b.geostationary) bits.push(t('sat.geo'));
+    if (!b.has_elements) bits.push(t('sat.noElements'));
+    return bits.join(' · ');
+  };
+
+  return (
+    <div className="space-y-2">
+      <h4 className="text-sm font-semibold text-foreground">{t('satset.follow')}</h4>
+      <p className="text-xs text-muted-foreground">{t('satset.followHint')}</p>
+      <div className="grid grid-cols-2 gap-3">
+        <div className="rounded-lg border border-border bg-card/40 flex flex-col">
+          <div className="flex items-center justify-between px-3 py-2 border-b border-border/60">
+            <span className="text-sm font-medium">{t('satset.available')} <span className="text-muted-foreground">({available.length})</span></span>
+            <button type="button" className="text-xs text-primary hover:underline disabled:opacity-40"
+              disabled={available.length === 0}
+              onClick={() => onChange([...followed, ...available.map((b) => b.name as string)])}>
+              {t('awards.addAll')}
+            </button>
+          </div>
+          <div className="p-2 border-b border-border/60 space-y-2">
+            <Input value={q} onChange={(e) => setQ(e.target.value)} placeholder={t('satset.search')} className="h-8" />
+            <label className="flex items-center gap-2 text-xs cursor-pointer text-muted-foreground">
+              <Checkbox checked={withPlanOnly} onCheckedChange={(c) => setWithPlanOnly(!!c)} />
+              {t('satset.withPlanOnly')}
+            </label>
+          </div>
+          <div className="max-h-[300px] overflow-y-auto p-1.5 space-y-0.5">
+            {available.map((b) => (
+              <button key={b.name} type="button" onClick={() => onChange([...followed, b.name])}
+                className="group w-full flex items-center gap-2 rounded-md px-2 py-1 text-left hover:bg-primary/10">
+                <span className="font-mono text-xs shrink-0">{b.name}</span>
+                <span className="text-[11px] text-muted-foreground truncate flex-1">{label(b)}</span>
+                <span className="text-primary opacity-0 group-hover:opacity-100">→</span>
+              </button>
+            ))}
+            {available.length === 0 && <div className="p-2 text-xs text-muted-foreground">{t('satset.allFollowed')}</div>}
+          </div>
+        </div>
+        <div className="rounded-lg border border-primary/40 bg-primary/5 flex flex-col">
+          <div className="flex items-center justify-between px-3 py-2 border-b border-border/60">
+            <span className="text-sm font-medium">{t('satset.followed')} <span className="text-muted-foreground">({followed.length})</span></span>
+            <button type="button" className="text-xs text-primary hover:underline disabled:opacity-40"
+              disabled={followed.length === 0} onClick={() => onChange([])}>{t('awards.clear')}</button>
+          </div>
+          <div className="max-h-[352px] overflow-y-auto p-1.5 space-y-0.5">
+            {chosen.map((b: any) => (
+              <button key={b.name} type="button" onClick={() => onChange(followed.filter((n) => n !== b.name))}
+                className="group w-full flex items-center gap-2 rounded-md px-2 py-1 text-left hover:bg-primary/10">
+                <span className="text-muted-foreground opacity-0 group-hover:opacity-100">←</span>
+                <span className="font-mono text-xs shrink-0">{b.name}</span>
+                <span className="text-[11px] text-muted-foreground truncate flex-1">{label(b)}</span>
+              </button>
+            ))}
+            {followed.length === 0 && <div className="p-2 text-xs text-muted-foreground">{t('satset.noneFollowed')}</div>}
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+}
+
 function ComingSoon({ id, icon: Icon }: { id: SectionId; icon?: any }) {
   const label = SECTION_LABELS[id] ?? id;
   const IconCmp = Icon ?? Construction;
@@ -1610,9 +1848,14 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
   const [listenPref, setListenPref] = useState(true);
   const [activeRadio, setActiveRadioId] = useState('');
   const [radioBusy, setRadioBusy] = useState(false);
+  // "Other (custom address)" has to STAY chosen. The dropdown is derived from
+  // the address, so picking Other while the address still matched a listed rig
+  // put the list straight back on that rig — the operator saw it jump back to
+  // IC-7610 the moment they chose Other.
+  const [icomCustom, setIcomCustom] = useState(false);
   const [catCfg, setCatCfg] = useState<CATSettings>({
     enabled: false, backend: 'omnirig', omnirig_rig: 1, omnirig_vfo: '', flex_host: '', flex_port: 4992, flex_spots: false, flex_decode_spots: false, flex_decode_secs: 120, flex_dvk_dax: false,
-    yaesu_port: '', yaesu_baud: 38400, yaesu_low_lines: false, kenwood_low_lines: false, kenwood_port: '', kenwood_baud: 9600, kenwood_host: '', kenwood_link: 'usb', kenwood_data_mode: 'usb', xiegu_port: '', xiegu_baud: 19200, xiegu_addr: 0x70, xiegu_ptt_line: '',
+    yaesu_port: '', yaesu_baud: 38400, yaesu_low_lines: false, yaesu_rtty_usb: false, kenwood_low_lines: false, kenwood_port: '', kenwood_baud: 9600, kenwood_host: '', kenwood_link: 'usb', kenwood_data_mode: 'usb', xiegu_port: '', xiegu_baud: 19200, xiegu_addr: 0x70, xiegu_ptt_line: '',
     icom_port: '', icom_baud: 115200, icom_addr: 0x98, icom_net_host: '', icom_net_user: '', icom_net_pass: '', icom_net_audio: false,
     tci_host: '', tci_port: 40001, tci_spots: false, poll_ms: 250, delay_ms: 0, offset_on: false, offset_hz: 0,
     digital_default: 'FT8', share_enabled: false, share_port: 4532, share_proto: 'rigctl', share_tci_port: 40001,
@@ -1663,6 +1906,11 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
   const [antgenius, setAntgenius] = useState<{ enabled: boolean; host: string; password: string; use_for_my_antenna?: boolean; ant1_port?: number }>({ enabled: false, host: '', password: '', use_for_my_antenna: false, ant1_port: 1 });
   const [tunergenius, setTunergenius] = useState<{ enabled: boolean; host: string; password: string }>({ enabled: false, host: '', password: '' });
   const [psuCfg, setPsuCfg] = useState<{ enabled: boolean; com_port: string; baud: number; address: number }>({ enabled: false, com_port: '', baud: 9600, address: 1 });
+  // Satellites: the observer and the az/el rotator. The rest of the satellite
+  // settings (favourites, the pass window) are set in the tab itself, where
+  // they are used.
+  const [satCfg, setSatCfg] = useState<any>({ min_el: 10, window_h: 24, auto_tle: true, grid: '', alt_m: 0, rot_on: false, rot_type: 'easycomm', rot_pst_port: 12000, rot_transport: 'serial', rot_host: '', rot_port: 4533, rot_com: '', rot_baud: 9600, rot_max_az: 360, rot_min_el: 0, rot_step: 5, rot_park: false });
+  const [satTest, setSatTest] = useState('');
 
   // Amplifier list — operators can run SEVERAL amps (even two SPEs combined),
   // each with its own connection. Saved as a whole via SaveAmplifiers.
@@ -1755,15 +2003,13 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
   // the full widget is what the operator has today, and a setting that changes
   // a panel the moment you upgrade is a setting that gets blamed for it.
   const [rotorCompact, setRotorCompact] = useState(() => localStorage.getItem('opslog.rotorCompact') === '1');
+  const [rotorDial, setRotorDial] = useState<RotorStyle>(() => rotorStyle());
   const [startEqEnd, setStartEqEnd] = useState(() => localStorage.getItem('opslog.startEqualsEnd') === '1');
   const [lookupOnBlur, setLookupOnBlur] = useState(() => localStorage.getItem('opslog.lookupOnBlur') === '1');
   const [groupDigital, setGroupDigital] = useState(() => localStorage.getItem('opslog.groupDigitalSlots') === '1');
   const [milesUnit, setMilesUnit] = useState(() => localStorage.getItem('opslog.distanceMiles') === '1');
   const [region, setRegion] = useState<IaruRegion>(() => iaruRegion());
   const [clusterWorkedSameSlot, setClusterWorkedSameSlot] = useState(() => localStorage.getItem('opslog.clusterWorkedSameSlot') === '1');
-  // Declared HERE and not in ClusterPanel: that renderer is called as a plain
-  // function by the PANELS map, so it must stay hooks-free.
-  const [clusterMacros, setClusterMacros] = useState<ClusterMacro[]>(loadClusterMacros);
   const [showQsoRate, setShowQsoRate] = useState(() => localStorage.getItem('opslog.showQsoRate') === '1');
   const [catModeBeforeFreq, setCatModeBeforeFreq] = useState(() => localStorage.getItem('opslog.catModeBeforeFreq') === '1');
   // Password-encryption (secret vault) state.
@@ -2089,11 +2335,18 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
   const [chaseSotaOn, setChaseSotaOn] = useState(() => localStorage.getItem('opslog.chaseSota') !== '0');
   const [chaseNew, setChaseNew] = useState(false);
   const [pskTgt, setPskTgt] = useState<any>({ enabled: false, scope: 'target' });
-  const [ac, setAc] = useState<any>({ enabled: false, only: '', attempts: 7, watched_attempts: 15, misses: 3, max_rounds: 3, rest_min: 2 });
+  const [ac, setAc] = useState<any>({ enabled: false, only: '', attempts: 7, watched_attempts: 15, misses: 3, max_rounds: 3, rest_periods: 1, on_screen_only: true });
   // The named contest callsigns. Raw text in state, written on blur: it is a
   // multi-line list, and normalising it on every keystroke would fight the
   // Return key — the one key this box is built around.
   const [contestCalls, setContestCalls] = useState('');
+  // Which bands the Chase new panel shows. The station's own band list still
+  // applies underneath — this one is "what am I watching tonight".
+  const [chaseBands, setChaseBands] = useState<string[]>([]);
+  const saveChaseBands = (next: string[]) => {
+    setChaseBands(next);
+    void SetChaseNewBands(next);
+  };
   const [contestPattern, setContestPattern] = useState('');
   const saveAC = async (next: any) => {
     setAc(next);
@@ -2132,6 +2385,7 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
       try { setChaseNew(await GetChaseNew()); } catch { /* defaults stand */ }
       try { setPskTgt(await GetPSKTargetSettings()); } catch { /* defaults stand */ }
       try { setAc(await GetAutoCallSettings()); } catch { /* defaults stand */ }
+      try { setChaseBands((await GetChaseNewBands()) ?? []); } catch { /* defaults stand */ }
       try { setContestCalls(await GetWatchlistContestCalls()); } catch { /* defaults stand */ }
       try { setContestPattern(await GetWatchlistContestPattern()); } catch { /* defaults stand */ }
       try { setLinkedAmps((await GetLinkedAmps()) ?? []); } catch { /* defaults stand */ }
@@ -2261,6 +2515,7 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
         try { setAntgenius(await GetAntGeniusSettings() as any); } catch {}
         try { setTunergenius(await GetTunerGeniusSettings() as any); } catch {}
         try { setPsuCfg(await GetPSUSettings() as any); } catch {}
+        try { setSatCfg(await GetSatSettings() as any); } catch {}
         try { setAmps(((await GetAmplifiers()) ?? []) as AmpUI[]); } catch {}
         setBackupCfg(b as any);
         setQslDefaults(qd as any);
@@ -2305,6 +2560,7 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
         try { setAntgenius(await GetAntGeniusSettings() as any); } catch {}
         try { setTunergenius(await GetTunerGeniusSettings() as any); } catch {}
         try { setPsuCfg(await GetPSUSettings() as any); } catch {}
+        try { setSatCfg(await GetSatSettings() as any); } catch {}
         try { setAmps(((await GetAmplifiers()) ?? []) as AmpUI[]); } catch {}
         try { setBackupCfg(await GetBackupSettings() as any); } catch {}
         try { setQslDefaults(await GetQSLDefaults() as any); } catch {}
@@ -2506,6 +2762,7 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
       await SaveAntGeniusSettings(antgenius as any);
       await SaveTunerGeniusSettings(tunergenius as any);
       await SavePSUSettings(psuCfg as any);
+      await SaveSatSettings(satCfg as any);
       await SaveAmplifiers(amps as any);
       await SaveWinkeyerSettings(wk as any);
       await SaveAudioSettings(audioCfg as any);
@@ -3078,39 +3335,6 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
     );
   }
 
-  function SatellitesPanel() {
-    const sats = lists.satellites ?? [];
-    return (
-      <>
-        <SectionHeader title={t('sec.satellites')} hint={t('sat.hint')} />
-        <div className="space-y-3 max-w-xl">
-          <div className="space-y-1">
-            <Label>{t('sat.listLabel')}</Label>
-            {/* Raw text, one per line, parsed on change — not a row-per-entry
-                editor with add and delete buttons. The list is short, edited
-                twice a year, and usually arrives pasted from a satellite
-                tracker; a textarea takes that paste in one gesture. */}
-            <textarea
-              className="w-full h-56 rounded-md border border-input bg-background p-2 font-mono text-xs"
-              value={sats.join('\n')}
-              placeholder={'AO-7\nAO-91\nRS-44\nSO-50'}
-              onChange={(e) => {
-                const next = e.target.value.split('\n').map((v) => v.trim());
-                setLists((s) => ({ ...s, satellites: next }));
-              }}
-              onBlur={() => setLists((s) => ({
-                // Tidied when the field is LEFT, never while typing: dropping an
-                // empty line as it is typed makes the Enter key look broken.
-                ...s,
-                satellites: Array.from(new Set((s.satellites ?? []).map((v) => v.trim().toUpperCase()).filter(Boolean))).sort(),
-              }))}
-            />
-            <p className="text-xs text-muted-foreground">{t('sat.listHint')}</p>
-          </div>
-        </div>
-      </>
-    );
-  }
 
   function ModesPanel() {
     const selected = lists.modes ?? [];
@@ -3507,6 +3731,17 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
                 </label>
                 <span className="text-xs text-muted-foreground">{t('cat.lowerLinesHint')}</span>
               </div>
+              {/* ADIF records "RTTY" and nothing more, and the rig has two
+                  sidebands to put it on — so this is the operator's answer, not
+                  something the log can supply. */}
+              <div className="col-span-2 space-y-1">
+                <label className="flex items-center gap-2 text-xs cursor-pointer">
+                  <Checkbox checked={!!(catCfg as any).yaesu_rtty_usb}
+                    onCheckedChange={(c) => setCatCfg((s) => ({ ...s, yaesu_rtty_usb: !!c } as any))} />
+                  {t('cat.yaesuRttyUsb')}
+                </label>
+                <span className="text-xs text-muted-foreground">{t('cat.yaesuRttyUsbHint')}</span>
+              </div>
             </>
             )}
             {['icom', 'xiegu', 'kenwood', 'elecraft'].includes(catCfg.backend) && (
@@ -3608,8 +3843,12 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
               <div className="space-y-1">
                 <Label>{t('cat.icomModel')}</Label>
                 <Select
-                  value={ICOM_MODELS.find((m) => m.addr === (catCfg.icom_addr ?? 0x98))?.name ?? '_custom'}
+                  value={icomCustom ? '_custom' : (ICOM_MODELS.find((m) => m.addr === (catCfg.icom_addr ?? 0x98))?.name ?? '_custom')}
-                  onValueChange={(v) => { const m = ICOM_MODELS.find((x) => x.name === v); if (m) setCatCfg((s) => ({ ...s, icom_addr: m.addr })); }}>
+                  onValueChange={(v) => {
+                    const m = ICOM_MODELS.find((x) => x.name === v);
+                    setIcomCustom(!m);
+                    if (m) setCatCfg((s) => ({ ...s, icom_addr: m.addr }));
+                  }}>
                   <SelectTrigger><SelectValue /></SelectTrigger>
                   <SelectContent>
                     {ICOM_MODELS.map((m) => <SelectItem key={m.name} value={m.name}>{m.name}</SelectItem>)}
@@ -3635,8 +3874,12 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
               <div className="space-y-1">
                 <Label>{t('cat.icomModel')}</Label>
                 <Select
-                  value={ICOM_MODELS.find((m) => m.addr === (catCfg.icom_addr ?? 0x98))?.name ?? '_custom'}
+                  value={icomCustom ? '_custom' : (ICOM_MODELS.find((m) => m.addr === (catCfg.icom_addr ?? 0x98))?.name ?? '_custom')}
-                  onValueChange={(v) => { const m = ICOM_MODELS.find((x) => x.name === v); if (m) setCatCfg((s) => ({ ...s, icom_addr: m.addr })); }}>
+                  onValueChange={(v) => {
+                    const m = ICOM_MODELS.find((x) => x.name === v);
+                    setIcomCustom(!m);
+                    if (m) setCatCfg((s) => ({ ...s, icom_addr: m.addr }));
+                  }}>
                   <SelectTrigger><SelectValue /></SelectTrigger>
                   <SelectContent>
                     {ICOM_MODELS.map((m) => <SelectItem key={m.name} value={m.name}>{m.name}</SelectItem>)}
@@ -4321,6 +4564,223 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
     );
   }
 
+  // Satellites: where the antenna is, and the machine that points it.
+  //
+  // The observer belongs here rather than in the tab because it is a property
+  // of the station, and the rotator because it is a second machine on a second
+  // port — a station with an HF rotator and an az/el pair must be able to have
+  // both, and choosing between them in one panel would be the wrong question.
+  function SatellitePanelSettings() {
+    const ports = wkPorts;
+    const setPorts = setWkPorts;
+    const set = (k: string, v: any) => setSatCfg((s: any) => ({ ...s, [k]: v }));
+    const num = (v: string) => parseInt(v.replace(/[^0-9-]/g, ''), 10) || 0;
+    return (
+      <>
+        <SectionHeader title={t('sec.satellite')} hint={t('satset.hint')} />
+        <div className="space-y-5 max-w-xl mb-5">
+          <SatelliteElementsBlock autoTle={!!satCfg.auto_tle} onAutoTle={(v) => set('auto_tle', v)} />
+        </div>
+        <div className="max-w-3xl mb-5">
+          <SatelliteFollowList
+            followed={satCfg.favorites ?? []}
+            onChange={(next) => set('favorites', next)}
+          />
+        </div>
+        <div className="space-y-5 max-w-xl">
+          <div className="grid grid-cols-3 gap-3">
+            <div className="space-y-1">
+              <Label>{t('satset.altM')}</Label>
+              <Input className="font-mono" value={String(satCfg.alt_m ?? 0)}
+                onChange={(e) => set('alt_m', num(e.target.value))} />
+            </div>
+            <div className="space-y-1">
+              <Label>{t('satset.minEl')}</Label>
+              <Input className="font-mono" value={String(satCfg.min_el ?? 10)}
+                onChange={(e) => set('min_el', num(e.target.value))} />
+            </div>
+            <div className="space-y-1">
+              <Label>{t('satset.windowH')}</Label>
+              <Input className="font-mono" value={String(satCfg.window_h ?? 24)}
+                onChange={(e) => set('window_h', num(e.target.value))} />
+            </div>
+          </div>
+          <p className="text-xs text-muted-foreground">{t('satset.altHint')}</p>
+
+          {/* The locator is NOT repeated here: it is the station's, set once in
+              Station information, and the passes are predicted from it. This is
+              the exception — an antenna at another site — and it says so, so
+              nobody has to wonder which of two locators is in use. */}
+          <details className="text-sm">
+            <summary className="cursor-pointer text-muted-foreground hover:text-foreground">
+              {t('satset.otherSite')}
+            </summary>
+            <div className="mt-2 flex items-center gap-3">
+              <Input className="font-mono w-40" placeholder={t('satset.gridPlaceholder')}
+                value={satCfg.grid ?? ''} onChange={(e) => set('grid', e.target.value.toUpperCase())} />
+              <span className="text-xs text-muted-foreground">{t('satset.otherSiteHint')}</span>
+            </div>
+          </details>
+
+          <div className="border-t border-border/60 pt-4 space-y-3">
+            <h4 className="text-sm font-semibold text-foreground">{t('satset.rotor')}</h4>
+            <label className="flex items-center gap-2 text-sm cursor-pointer">
+              <Checkbox checked={!!satCfg.rot_on} onCheckedChange={(c) => set('rot_on', !!c)} />
+              {t('satset.rotEnable')}
+            </label>
+            <p className="text-xs text-muted-foreground">{t('satset.rotHint')}</p>
+
+            {!!satCfg.rot_on && (
+              <>
+                {/* Who drives the mast. Not a detail: a station already running
+                    PstRotator must NOT have OpsLog on the same cable as well. */}
+                <div className="grid grid-cols-4 gap-3">
+                  {/* Two columns wide: "OpsLog (EasyComm II)" does not fit in a
+                      third of the row, and a truncated choice is a choice an
+                      operator cannot read. */}
+                  <div className="space-y-1 col-span-2">
+                    <Label>{t('satset.rotType')}</Label>
+                    <Select value={satCfg.rot_type || 'easycomm'} onValueChange={(v) => set('rot_type', v)}>
+                      <SelectTrigger className="h-9"><SelectValue /></SelectTrigger>
+                      <SelectContent>
+                        <SelectItem value="easycomm">{t('satset.rotEasycomm')}</SelectItem>
+                        <SelectItem value="pstrotator">{t('satset.rotPst')}</SelectItem>
+                      </SelectContent>
+                    </Select>
+                  </div>
+                  {satCfg.rot_type === 'pstrotator' && (
+                    <>
+                      <div className="space-y-1">
+                        <Label>{t('satset.rotHost')}</Label>
+                        <Input className="font-mono" placeholder="127.0.0.1"
+                          value={satCfg.rot_host ?? ''} onChange={(e) => set('rot_host', e.target.value)} />
+                      </div>
+                      <div className="space-y-1">
+                        <Label>{t('satset.rotPstPort')}</Label>
+                        <Input className="font-mono" value={String(satCfg.rot_pst_port ?? 12000)}
+                          onChange={(e) => set('rot_pst_port', num(e.target.value))} />
+                      </div>
+                    </>
+                  )}
+                </div>
+                {satCfg.rot_type === 'pstrotator' && (
+                  <p className="text-xs text-muted-foreground">{t('satset.rotPstHint')}</p>
+                )}
+                <div className={cn('grid grid-cols-3 gap-3', satCfg.rot_type === 'pstrotator' && 'hidden')}>
+                  <div className="space-y-1">
+                    <Label>{t('satset.rotLink')}</Label>
+                    <Select value={satCfg.rot_transport || 'serial'} onValueChange={(v) => set('rot_transport', v)}>
+                      <SelectTrigger className="h-9"><SelectValue /></SelectTrigger>
+                      <SelectContent>
+                        <SelectItem value="serial">{t('satset.rotSerial')}</SelectItem>
+                        <SelectItem value="tcp">{t('satset.rotTcp')}</SelectItem>
+                      </SelectContent>
+                    </Select>
+                  </div>
+                  {satCfg.rot_transport === 'tcp' ? (
+                    <>
+                      <div className="space-y-1">
+                        <Label>{t('satset.rotHost')}</Label>
+                        <Input className="font-mono" placeholder="127.0.0.1"
+                          value={satCfg.rot_host ?? ''} onChange={(e) => set('rot_host', e.target.value)} />
+                      </div>
+                      <div className="space-y-1">
+                        <Label>{t('satset.rotPort')}</Label>
+                        <Input className="font-mono" value={String(satCfg.rot_port ?? 4533)}
+                          onChange={(e) => set('rot_port', num(e.target.value))} />
+                      </div>
+                    </>
+                  ) : (
+                    <>
+                      <div className="space-y-1">
+                        <Label>{t('satset.rotCom')}</Label>
+                        <div className="flex items-center gap-2">
+                          <Select value={satCfg.rot_com || '_'} onValueChange={(v) => set('rot_com', v === '_' ? '' : v)}>
+                            <SelectTrigger className="h-9 flex-1"><SelectValue placeholder="— COM —" /></SelectTrigger>
+                            <SelectContent>
+                              {ports.length === 0 && <SelectItem value="_" disabled>{t('station.noPorts')}</SelectItem>}
+                              {ports.map((p) => <SelectItem key={p} value={p}>{p}</SelectItem>)}
+                            </SelectContent>
+                          </Select>
+                          <Button size="sm" variant="outline" onClick={() => ListSerialPorts().then((p) => setPorts((p ?? []) as string[])).catch(() => {})}>
+                            ↻
+                          </Button>
+                        </div>
+                      </div>
+                      <div className="space-y-1">
+                        <Label>{t('satset.rotBaud')}</Label>
+                        <Select value={String(satCfg.rot_baud || 9600)} onValueChange={(v) => set('rot_baud', parseInt(v, 10) || 9600)}>
+                          <SelectTrigger className="h-9"><SelectValue /></SelectTrigger>
+                          <SelectContent>
+                            {[1200, 2400, 4800, 9600, 19200, 38400, 57600, 115200].map((b) => (
+                              <SelectItem key={b} value={String(b)}>{b}</SelectItem>
+                            ))}
+                          </SelectContent>
+                        </Select>
+                      </div>
+                    </>
+                  )}
+                </div>
+
+                <div className="grid grid-cols-3 gap-3">
+                  {/* The rotator's range is ours to know only when we drive the
+                      controller. PstRotator knows which machine is on the other
+                      end and does its own overlap; two programs each deciding to
+                      go the long way round is how an antenna unwinds mid-pass. */}
+                  {satCfg.rot_type !== 'pstrotator' && (
+                    <div className="space-y-1">
+                      <Label>{t('satset.rotRange')}</Label>
+                      <Select value={String(satCfg.rot_max_az ?? 360)} onValueChange={(v) => set('rot_max_az', parseInt(v, 10))}>
+                        <SelectTrigger className="h-9"><SelectValue /></SelectTrigger>
+                        <SelectContent>
+                          <SelectItem value="360">360°</SelectItem>
+                          <SelectItem value="450">450°</SelectItem>
+                        </SelectContent>
+                      </Select>
+                    </div>
+                  )}
+                  <div className="space-y-1">
+                    <Label>{t('satset.rotMinEl')}</Label>
+                    <Input className="font-mono" value={String(satCfg.rot_min_el ?? 0)}
+                      onChange={(e) => set('rot_min_el', num(e.target.value))} />
+                  </div>
+                  <div className="space-y-1">
+                    <Label>{t('satset.rotStep')}</Label>
+                    <Input className="font-mono" value={String(satCfg.rot_step ?? 5)}
+                      onChange={(e) => set('rot_step', num(e.target.value))} />
+                  </div>
+                </div>
+                <p className="text-xs text-muted-foreground">{t('satset.rotRangeHint')}</p>
+
+                <label className="flex items-center gap-2 text-sm cursor-pointer">
+                  <Checkbox checked={!!satCfg.rot_park} onCheckedChange={(c) => set('rot_park', !!c)} />
+                  {t('satset.rotPark')}
+                </label>
+
+                <div className="flex items-center gap-2">
+                  <Button size="sm" variant="outline" onClick={async () => {
+                    setSatTest(t('satset.rotTesting'));
+                    try {
+                      // Saved first: the test opens the port from the STORED
+                      // settings, and testing what is on screen rather than what
+                      // is stored is the classic way to prove a COM port that is
+                      // not the one about to be used.
+                      await SaveSatSettings(satCfg as any);
+                      setSatTest(String(await TestSatelliteRotator()));
+                    } catch (e: any) { setSatTest(String(e?.message ?? e)); }
+                  }}>
+                    {t('satset.rotTest')}
+                  </Button>
+                  {satTest && <span className="text-xs text-muted-foreground">{satTest}</span>}
+                </div>
+              </>
+            )}
+          </div>
+        </div>
+      </>
+    );
+  }
+
   function PGXLPanelSettings() {
     // The stored `type` stays a flat value ("spe13", "acom700", "pgxl"); the UI
     // presents it as brand + model.
@@ -4855,6 +5315,20 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
               dial to take a column, not a panel. */}
           <div className="border-t border-border/60 pt-3 space-y-2">
             <div className="text-sm font-semibold">{t('rot.widget')}</div>
+            {/* Which dial. Both are kept: the new one reads at a glance across
+                the shack, the old one is the compact dial operators learned
+                first, and neither is wrong. */}
+            <div className="flex items-center gap-2 text-sm">
+              <span className="text-muted-foreground">{t('rot.dial')}</span>
+              <select
+                value={rotorDial}
+                onChange={(e) => { const v = e.target.value as RotorStyle; setRotorDial(v); setRotorStyle(v); }}
+                className="h-8 rounded-md border border-border bg-background px-2 text-sm"
+              >
+                <option value="modern">{t('rot.dialModern')}</option>
+                <option value="classic">{t('rot.dialClassic')}</option>
+              </select>
+            </div>
             <label className="flex items-center gap-2 text-sm">
               <Checkbox checked={rotorCompact}
                 onCheckedChange={(c) => { const v = !!c; setRotorCompact(v); writeUiPref('opslog.rotorCompact', v ? '1' : '0'); }} />
@@ -5402,6 +5876,34 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
                 <span className="text-xs text-muted-foreground">{t('chn.nearKmHint')}</span>
               </div>
             )}
+            {/* Which bands the panel lists. Not the station's band list — that
+                one says what this station can work at all and still applies
+                underneath. This says what is worth watching tonight, which is
+                a different question and changes far more often. */}
+            {chaseNew && (
+              <div className="pl-6 space-y-1">
+                <span className="text-xs text-muted-foreground">{t('chn.bands')}</span>
+                <div className="flex flex-wrap items-center gap-1">
+                  {CHASE_BANDS.map((b) => {
+                    const on = chaseBands.includes(b);
+                    return (
+                      <button key={b} type="button"
+                        onClick={() => saveChaseBands(on ? chaseBands.filter((x) => x !== b) : [...chaseBands, b])}
+                        className={cn('h-6 px-2 rounded-full border text-[11px] font-medium transition-colors',
+                          on ? 'border-primary bg-primary text-primary-foreground'
+                             : 'border-border text-muted-foreground hover:bg-muted')}>
+                        {b}
+                      </button>
+                    );
+                  })}
+                  <button type="button" onClick={() => saveChaseBands([...CHASE_BANDS])}
+                    className="h-6 px-2 rounded-full border border-border text-[11px] text-muted-foreground hover:bg-muted">
+                    {t('chn.bandsAll')}
+                  </button>
+                </div>
+                <p className="text-xs text-muted-foreground">{t('chn.bandsHint')}</p>
+              </div>
+            )}
           </div>
 
           {/* PSK Reporter analysis of the station being called. Same service as
@@ -5491,7 +5993,7 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
                     ['watched_attempts', t('ac.watchedAttempts'), 1, 60],
                     ['misses', t('ac.misses'), 1, 10],
                     ['max_rounds', t('ac.rounds'), 1, 10],
-                    ['rest_min', t('ac.rest'), 1, 60],
+                    ['rest_periods', t('ac.rest'), 1, 20],
                   ] as [string, string, number, number][]).map(([k, label, min, max]) => (
                     <span key={k} className="inline-flex items-center gap-1.5">
                       <span className="text-xs text-muted-foreground">{label}</span>
@@ -5505,6 +6007,20 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
                     </span>
                   ))}
                 </div>
+                {/* A rule about what the transmitter may call, stated once. The
+                    decodes panel has a LoTW chip too, but that one is a way of
+                    READING the band — it is flicked on and off while looking
+                    around, and the panel can be closed. */}
+                <label className="flex items-center gap-2 text-xs cursor-pointer">
+                  <Checkbox checked={ac.on_screen_only !== false}
+                    onCheckedChange={(c) => saveAC({ ...ac, on_screen_only: !!c })} />
+                  <span>{t('ac.onScreen')} <span className="text-muted-foreground">{t('ac.onScreenHint')}</span></span>
+                </label>
+                <label className="flex items-center gap-2 text-xs cursor-pointer">
+                  <Checkbox checked={!!ac.trace}
+                    onCheckedChange={(c) => saveAC({ ...ac, trace: !!c })} />
+                  <span>{t('ac.trace')} <span className="text-muted-foreground">{t('ac.traceHint')}</span></span>
+                </label>
               </div>
             )}
           </div>
@@ -5516,14 +6032,6 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
 
   function ClusterPanel() {
     const sorted = [...clusterServers].sort((a, b) => (a.sort_order ?? 0) - (b.sort_order ?? 0));
-    // Written on every keystroke. This panel has no Save button, and a pair of
-    // text boxes whose contents only take effect on some other button is how
-    // work gets lost.
-    const setMacro = (i: number, patch: Partial<ClusterMacro>) => {
-      const next = clusterMacros.map((m, j) => (j === i ? { ...m, ...patch } : m));
-      setClusterMacros(next);
-      saveClusterMacros(next);
-    };
     return (
       <>
         <SectionHeader
@@ -5616,41 +6124,7 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
               {t('clu.autoConnect')}
             </label>
           </div>
-          <div className="border-t border-border/60 pt-3 space-y-2">
+          <ClusterMacroEditor />
-            <div>
-              <span className="text-sm font-medium">{t('clu.macros')}</span>
-            </div>
-            {/* Two columns of six: twelve rows stacked would push everything else
-                in this panel off the screen. */}
-            <div className="grid grid-cols-1 md:grid-cols-2 gap-x-4 gap-y-1.5">
-              {clusterMacros.map((m, i) => (
-                <div key={i} className="flex items-center gap-1.5">
-                  <span className="text-[10px] text-muted-foreground tabular-nums w-4 text-right shrink-0">{i + 1}</span>
-                  <Input
-                    className="h-8 w-28 shrink-0 text-xs"
-                    placeholder={t('clu.macroLabel')}
-                    value={m.label}
-                    maxLength={24}
-                    onChange={(e) => setMacro(i, { label: e.target.value })}
-                  />
-                  {/* 500, not 120. A DXSpider filter is a list of prefixes and
-                      an operator's own list of wanted countries runs past a
-                      hundred characters easily — the field simply stopped
-                      accepting keystrokes, with nothing to say why, and the
-                      command was saved truncated. The title shows the whole
-                      thing, since the box cannot. */}
-                  <Input
-                    className="h-8 flex-1 min-w-0 font-mono text-xs"
-                    placeholder={t('clu.macroCmd')}
-                    value={m.cmd}
-                    title={m.cmd}
-                    maxLength={500}
-                    onChange={(e) => setMacro(i, { cmd: e.target.value })}
-                  />
-                </div>
-              ))}
-            </div>
-          </div>
           <label className="flex items-start gap-2 text-sm cursor-pointer border-t border-border/60 pt-3">
             <Checkbox checked={clusterWorkedSameSlot} className="mt-0.5"
               onCheckedChange={(c) => { const v = !!c; setClusterWorkedSameSlot(v); writeUiPref('opslog.clusterWorkedSameSlot', v ? '1' : '0'); }} />
@@ -8237,7 +8711,6 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
     lookup:         LookupPanel,
     'lists-bands':  BandsPanel,
     'lists-modes':  ModesPanel,
-    'lists-satellites': SatellitesPanel,
     cluster:        ClusterPanel,
     dxhunter:       DXHunterPanel,
     udp:            UDPIntegrationsPanelWrapper,
@@ -8270,6 +8743,7 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
     antgenius:      AntGeniusPanelSettings,
     tunergenius:    TunerGeniusPanelSettings,
     psu:            PSUPanelSettings,
+    satellite:      SatellitePanelSettings,
     pgxl:           PGXLPanelSettings,
     flex:           () => (
       <div className="space-y-6">
@@ -8488,8 +8962,13 @@ interface ClusterEditorProps {
 }
 
 function ClusterServerEditor({ value, onCancel, onSave }: ClusterEditorProps) {
+  const { t } = useI18n();
   const [s, setS] = useState(value);
   const update = (patch: Partial<typeof s>) => setS((cur) => ({ ...cur, ...patch }));
+  // Which preset the fields currently match, so reopening a node created from
+  // one shows it selected rather than blank.
+  const presetIdx = CLUSTER_PRESETS.findIndex(
+    (p) => p.host.toLowerCase() === (s.host ?? '').trim().toLowerCase() && p.port === s.port);
   return (
     <Dialog open onOpenChange={(o) => { if (!o) onCancel(); }}>
       <DialogContent className="max-w-[640px] px-6">
@@ -8500,6 +8979,39 @@ function ClusterServerEditor({ value, onCancel, onSave }: ClusterEditorProps) {
           </DialogDescription>
         </DialogHeader>
         <div className="grid grid-cols-2 gap-3 py-2 px-2">
+          {/* Start from a node that is known to work. The host and the port are
+              two pieces of information nobody has to hand, and a typo in either
+              looks exactly like a node that is down. Everything stays editable
+              afterwards. */}
+          <div className="space-y-1 col-span-2">
+            <Label>{t('clu.preset')}</Label>
+            <Select
+              value={presetIdx >= 0 ? String(presetIdx) : '_'}
+              onValueChange={(v) => {
+                const p = CLUSTER_PRESETS[Number(v)];
+                if (!p) return;
+                update({
+                  host: p.host, port: p.port,
+                  // The name is only filled when the operator has not chosen one
+                  // of their own: renaming a node is the first thing anybody with
+                  // two of them does.
+                  name: s.name.trim() ? s.name : p.name,
+                  init_commands: s.init_commands?.trim() ? s.init_commands : (p.init ?? ''),
+                });
+              }}
+            >
+              <SelectTrigger className="h-9"><SelectValue placeholder={t('clu.presetPick')} /></SelectTrigger>
+              <SelectContent>
+                <SelectItem value="_" disabled>{t('clu.presetPick')}</SelectItem>
+                {CLUSTER_PRESETS.map((p, i) => (
+                  <SelectItem key={`${p.host}:${p.port}`} value={String(i)}>
+                    {p.name} — {p.about}
+                  </SelectItem>
+                ))}
+              </SelectContent>
+            </Select>
+            <p className="text-[11px] text-muted-foreground">{t('clu.presetHint')}</p>
+          </div>
           <div className="space-y-1 col-span-2">
             <Label>Display name</Label>
             <Input autoFocus value={s.name} onChange={(e) => update({ name: e.target.value })} placeholder="VE7CC, F4BPO home…" />

frontend/src/components/SkyPlot.tsx

@@ -0,0 +1,142 @@
+import { useI18n } from '@/lib/i18n';
+
+// The sky, seen from underneath it.
+//
+// The map answers "where is the satellite over the earth". This answers "where
+// do I look", which during a pass is the question that matters: whether the
+// bird comes over the top or clips the horizon behind the house is something no
+// amount of azimuth and elevation digits conveys, and one glance at a polar
+// plot settles it.
+//
+// The projection is the one every satellite tracker uses and every operator
+// already reads: the centre is the zenith, the outer circle is the horizon, and
+// north is up. So the radius is (90 − elevation), NOT the elevation — a
+// satellite overhead is a dot in the middle, and a pass that stays near the rim
+// is one that never rises.
+
+export type SkyPoint = { at: string; az: number; el: number };
+
+export function SkyPlot({ track, az, el, name, visible, size = 300 }: {
+  // The pass, sampled from rise to set. Empty draws the dial alone, which is
+  // still worth showing: it says where the antenna is pointing now.
+  track: SkyPoint[];
+  // Where the satellite is at this instant, or null when it is not up.
+  az?: number | null;
+  el?: number | null;
+  name?: string;
+  visible?: boolean;
+  size?: number;
+}) {
+  const { t } = useI18n();
+  const R = size / 2 - 14;      // the horizon circle
+  const cx = size / 2, cy = size / 2;
+
+  // Where a bearing and an elevation land on the dial.
+  const pt = (azDeg: number, elDeg: number): [number, number] => {
+    const r = R * (90 - Math.max(0, Math.min(90, elDeg))) / 90;
+    const a = (azDeg * Math.PI) / 180;
+    return [cx + r * Math.sin(a), cy - r * Math.cos(a)];
+  };
+
+  const rings = [15, 30, 45, 60, 75];
+  const path = track.length > 1
+    ? track.map((p, i) => `${i === 0 ? 'M' : 'L'}${pt(p.az, p.el).map((v) => v.toFixed(1)).join(' ')}`).join(' ')
+    : '';
+
+  // Ticks every 10°, longer every 30°, so the rim reads as a compass rather
+  // than a plain circle.
+  const ticks = [];
+  for (let a = 0; a < 360; a += 10) {
+    const long = a % 30 === 0;
+    const rad = (a * Math.PI) / 180;
+    const r1 = R, r2 = R - (long ? 7 : 4);
+    ticks.push(
+      <line key={a}
+        x1={cx + r1 * Math.sin(rad)} y1={cy - r1 * Math.cos(rad)}
+        x2={cx + r2 * Math.sin(rad)} y2={cy - r2 * Math.cos(rad)}
+        stroke="var(--border)" strokeWidth={long ? 1.4 : 0.8} />,
+    );
+  }
+
+  const here = az != null && el != null ? pt(az, el) : null;
+  const start = track.length > 1 ? pt(track[0].az, track[0].el) : null;
+  const end = track.length > 1 ? pt(track[track.length - 1].az, track[track.length - 1].el) : null;
+
+  return (
+    <svg viewBox={`0 0 ${size} ${size}`} className="w-full h-auto select-none" role="img"
+      aria-label={t('sat.skyPlot')}>
+      <defs>
+        {/* An arrowhead on the track: a pass has a direction, and which way the
+            satellite is travelling decides where to point the antenna next. */}
+        <marker id="skyArrow" viewBox="0 0 10 10" refX="6" refY="5"
+          markerWidth="5" markerHeight="5" orient="auto-start-reverse">
+          <path d="M 0 0 L 10 5 L 0 10 z" fill="var(--success)" />
+        </marker>
+      </defs>
+
+      <circle cx={cx} cy={cy} r={R} fill="var(--muted)" fillOpacity={0.25}
+        stroke="var(--border)" strokeWidth={1.5} />
+      {rings.map((e) => (
+        <circle key={e} cx={cx} cy={cy} r={R * (90 - e) / 90}
+          fill="none" stroke="var(--border)" strokeWidth={0.6} strokeDasharray="3 4" />
+      ))}
+      {ticks}
+
+      {/* The cardinal cross. */}
+      <line x1={cx} y1={cy - R} x2={cx} y2={cy + R} stroke="var(--border)" strokeWidth={0.6} />
+      <line x1={cx - R} y1={cy} x2={cx + R} y2={cy} stroke="var(--border)" strokeWidth={0.6} />
+
+      {([
+        { lbl: 'N', x: cx, y: cy - R - 3, anchor: 'middle' },
+        { lbl: 'S', x: cx, y: cy + R + 11, anchor: 'middle' },
+        { lbl: 'E', x: cx + R + 4, y: cy + 4, anchor: 'start' },
+        { lbl: 'W', x: cx - R - 4, y: cy + 4, anchor: 'end' },
+      ] as const).map((c) => (
+        <text key={c.lbl} x={c.x} y={c.y} textAnchor={c.anchor}
+          fontSize={11} fontWeight={600} fill="var(--muted-foreground)">{c.lbl}</text>
+      ))}
+
+      {/* Elevation labels along the west arm, the way a tracker draws them. */}
+      {[0, 30, 60].map((e) => (
+        <text key={e} x={cx - R * (90 - e) / 90 + 2} y={cy + 10} fontSize={8}
+          fill="var(--muted-foreground)" opacity={0.8}>{e}°</text>
+      ))}
+
+      {/* The pass. */}
+      {path && (
+        <path d={path} fill="none" stroke="var(--success)" strokeWidth={1.6}
+          strokeDasharray="5 3" markerMid="url(#skyArrow)" markerEnd="url(#skyArrow)"
+          opacity={0.85} />
+      )}
+      {start && <circle cx={start[0]} cy={start[1]} r={3} fill="none" stroke="var(--success)" strokeWidth={1.4} />}
+      {end && <circle cx={end[0]} cy={end[1]} r={3} fill="var(--success)" opacity={0.6} />}
+
+      {/* Where it is now. Hollow and grey below the horizon: the numbers are
+          still right, but nothing can be worked through the earth. */}
+      {here && (
+        <g>
+          <line x1={here[0] - 6} y1={here[1]} x2={here[0] + 6} y2={here[1]}
+            stroke={visible ? 'var(--success)' : 'var(--muted-foreground)'} strokeWidth={1.4} />
+          <line x1={here[0]} y1={here[1] - 6} x2={here[0]} y2={here[1] + 6}
+            stroke={visible ? 'var(--success)' : 'var(--muted-foreground)'} strokeWidth={1.4} />
+          <circle cx={here[0]} cy={here[1]} r={4}
+            fill={visible ? 'var(--success)' : 'none'}
+            stroke={visible ? 'var(--background)' : 'var(--muted-foreground)'} strokeWidth={1.2} />
+        </g>
+      )}
+
+      {/* The name and the look angles, in the middle, where a tracker puts them
+          — big enough to read from the other side of the shack. */}
+      {!!name && (
+        <text x={cx} y={cy - R * 0.42} textAnchor="middle" fontSize={18} fontWeight={600}
+          fill="var(--foreground)" opacity={0.85}>{name}</text>
+      )}
+      {az != null && el != null && (
+        <text x={cx} y={cy - R * 0.22} textAnchor="middle" fontSize={12}
+          fill="var(--muted-foreground)" className="tabular-nums">
+          AZ {az.toFixed(1)}°  EL {el.toFixed(1)}°
+        </text>
+      )}
+    </svg>
+  );
+}

frontend/src/components/StationControlPanel.tsx

@@ -11,6 +11,8 @@ import { useI18n } from '@/lib/i18n';
 import { writeUiPref } from '@/lib/uiPref';
 import { subscribeRotorHeading, pokeRotorHeading } from '@/lib/rotorHeading';
 import { RotorCompass } from '@/components/RotorCompass';
+import { RotorCompassClassic } from '@/components/RotorCompassClassic';
+import { rotorStyle, subscribeRotorStyle } from '@/lib/rotorStyle';
 import { AmpCard } from '@/components/AmpCard';
 import { TunerCard } from '@/components/TunerCard';
 import type { TGStatus } from '@/components/TunerGeniusPanel';
@@ -128,6 +130,11 @@ function RotatorWidget({ hd, refetch, centerLat, centerLon, bearing, t }: Rotato
 }) {
   const [goto, setGoto] = useState('');
   const [err, setErr] = useState('');
+  // Both compasses in the app follow the same preference (Settings → Rotator):
+  // one operator's choice of dial, not one per panel.
+  const [dial, setDial] = useState(() => rotorStyle());
+  useEffect(() => subscribeRotorStyle(() => setDial(rotorStyle())), []);
+  const Dial = dial === 'classic' ? RotorCompassClassic : RotorCompass;
 
   const turn = (az: number) => {
     const a = ((Math.round(az) % 360) + 360) % 360;
@@ -145,9 +152,12 @@ function RotatorWidget({ hd, refetch, centerLat, centerLon, bearing, t }: Rotato
           title={hd.ok ? t('station.online') : t('station.rotatorNoRead')} />
       </div>
       <div className="p-3 flex gap-4 items-start">
-        {/* The SP/LP readout lives INSIDE RotorCompass, so every compass in the
+        {/* The compact compass is the dial alone — short and long path are the
-            app carries it rather than each caller drawing its own. */}
+            two coloured dots on it. The figures are in the status bar. */}
-        <RotorCompass
+        {/* The dial-only form is square and fills the box it is given, so its
+            size is set here rather than baked into the component. */}
+        <div className={dial === 'classic' ? 'shrink-0' : 'w-[210px] shrink-0'}>
+        <Dial
           bearing={bearing ?? null}
           headings={hd.ok ? [hd.azimuth] : []}
           centerLat={centerLat ?? null}
@@ -158,6 +168,7 @@ function RotatorWidget({ hd, refetch, centerLat, centerLon, bearing, t }: Rotato
           onSelectRotor={(i) => { SetActiveRotor(i).then(refetch).catch((e) => setErr(String(e?.message ?? e))); }}
           onGoto={(az) => turn(az)}
         />
+        </div>
         <div className="flex-1 min-w-0 space-y-2">
           <div className="font-mono">
             <span className="text-2xl font-bold tabular-nums">{hd.ok ? `${hd.azimuth}°` : '—'}</span>

frontend/src/components/UDPIntegrationsPanel.tsx

@@ -3,6 +3,7 @@ import { Plus, Trash2, Edit2, RefreshCcw, ArrowDownToLine, ArrowUpFromLine } fro
 import {
   ListUDPIntegrations, SaveUDPIntegration, DeleteUDPIntegration, ReloadUDPIntegrations,
   GetWsjtHighlight, SetWsjtHighlight, GetWsjtHighlightWorked, SetWsjtHighlightWorked, GetWsjtFollowMode, SetWsjtFollowMode,
+  GetWsjtHighlightColours, SetWsjtHighlightColours,
 } from '../../wailsjs/go/main/App';
 import { Button } from '@/components/ui/button';
 import { Input } from '@/components/ui/input';
@@ -161,9 +162,13 @@ type Props = { onError: (msg: string) => void };
 export function UDPIntegrationsPanel({ onError }: Props) {
   const [highlightOn, setHighlightOn] = useState(false);
   const [hlWorked, setHlWorked] = useState(false);
+  // The palette, as chosen. Background per verdict; the text colour is the
+  // backend’s business (see colourFor).
+  const [colours, setColours] = useState({ watchlist: '#F472B6', new_dxcc: '#16823C', new_band: '#E27A18', worked: '#4B5563' });
   const [followMode, setFollowMode] = useState(true);
   useEffect(() => {
     GetWsjtHighlight().then((v) => setHighlightOn(!!v)).catch(() => {});
+    GetWsjtHighlightColours().then((c: any) => { if (c) setColours(c); }).catch(() => {});
     GetWsjtHighlightWorked().then((v) => setHlWorked(!!v)).catch(() => {});
     GetWsjtHighlightWorked().then((v) => setHlWorked(!!v)).catch(() => {});
     GetWsjtFollowMode().then((v) => setFollowMode(!!v)).catch(() => {});
@@ -249,16 +254,52 @@ export function UDPIntegrationsPanel({ onError }: Props) {
           <span className="block text-[11px] text-muted-foreground">{t('udpp.highlightHint')}</span>
         </span>
       </label>
+      {/* The palette, nested under the switch for the same reason as the box
+          below it. One colour per verdict, and the background only: the text
+          colour is worked out from it, so a chosen colour cannot come back
+          unreadable in the decoder's window. */}
+      {highlightOn && (
+        <div className="pl-6 max-w-2xl space-y-1.5">
+          <div className="text-[11px] text-muted-foreground">{t('udpp.hlColours')}</div>
+          <div className="flex flex-wrap gap-3">
+            {([
+              ['watchlist', t('udpp.hlWatchlist')],
+              ['new_dxcc', t('udpp.hlNewDxcc')],
+              ['new_band', t('udpp.hlNewBand')],
+              ['worked', t('udpp.hlWorkedC')],
+            ] as const).map(([k, label]) => (
+              <label key={k} className="inline-flex items-center gap-1.5 text-xs">
+                <input
+                  type="color"
+                  value={(colours as any)[k] || '#000000'}
+                  onChange={(e) => {
+                    const next = { ...colours, [k]: e.target.value.toUpperCase() };
+                    setColours(next);
+                    void SetWsjtHighlightColours(next as any);
+                  }}
+                  className="h-6 w-8 rounded border border-border bg-background p-0.5 cursor-pointer"
+                />
+                {label}
+              </label>
+            ))}
+            <button type="button" className="text-xs text-muted-foreground underline hover:text-foreground"
+              onClick={() => {
+                const def = { watchlist: '#F472B6', new_dxcc: '#16823C', new_band: '#E27A18', worked: '#4B5563' };
+                setColours(def as any);
+                void SetWsjtHighlightColours(def as any);
+              }}>
+              {t('udpp.hlReset')}
+            </button>
+          </div>
+        </div>
+      )}
       {/* Nested under the switch above: the same feature, and meaningless
           while that one is off. */}
       {highlightOn && (
         <label className="flex items-start gap-2 text-sm cursor-pointer max-w-2xl pl-6">
           <Checkbox checked={hlWorked}
             onCheckedChange={(c) => { setHlWorked(!!c); void SetWsjtHighlightWorked(!!c); }} />
-          <span>
+          <span>{t('udpp.hlWorked')}</span>
-            {t('udpp.hlWorked')}
-            <span className="block text-[11px] text-muted-foreground">{t('udpp.hlWorkedHint')}</span>
-          </span>
         </label>
       )}
       <label className="flex items-start gap-2 text-sm cursor-pointer max-w-2xl">

frontend/src/components/WatchlistTab.tsx

@@ -25,13 +25,7 @@ import {
 import { EventsOn } from '../../wailsjs/runtime/runtime';
 import type { ClusterSpot, SpotStatusEntry } from '@/components/ClusterGrid';
 import { inferSpotMode, spotStatusKey } from '@/lib/spot';
-
+import { useWatchlistSpots, matchesEntry, newBadge, type WLEntry } from '@/lib/watchlistSpots';
-interface WLEntry {
-  callsign: string; lastSeenStr: string; addedAt: string; spotCount: number;
-  isContest: boolean; notify: boolean;
-  isExpedition: boolean; clubLogQSOs24h: number; clubLogTotalQSOs: number;
-  clubLogHasOQRS: boolean; clubLogLiveStream: boolean;
-}
 
 interface Props {
   spots: ClusterSpot[];
@@ -40,21 +34,6 @@ interface Props {
   onSpotClick?: (s: ClusterSpot) => void;
 }
 
-// A spot is ON AIR for the badge while its last sighting is this fresh.
-const ON_AIR_MS = 10 * 60 * 1000;
-
-// Exact unless the entry carries a trailing * — the same rule the backend's
-// Match applies to the live stream, mirrored so the tab and the alerts can
-// never disagree about what an entry covers.
-function matchesEntry(call: string, pattern: string): boolean {
-  const c = call.toUpperCase();
-  if (pattern.endsWith('*')) {
-    const p = pattern.slice(0, -1);
-    return p !== '' && c.startsWith(p);
-  }
-  return c === pattern;
-}
-
 export function WatchlistTab({ spots, spotStatus, onSpotSelect, onSpotClick }: Props) {
   const { t } = useI18n();
   const [entries, setEntries] = useState<WLEntry[]>([]);
@@ -95,8 +74,6 @@ export function WatchlistTab({ spots, spotStatus, onSpotSelect, onSpotClick }: P
     noticeTimer.current = window.setTimeout(() => { setError(''); setNotice(''); }, 4000) as unknown as number;
   };
 
-  // worked answer per "call|band|modeclass|contest" key.
-  const [worked, setWorked] = useState<Record<string, boolean>>({});
 
   const refresh = useCallback(async () => {
     try { setEntries(((await WatchlistEntries()) ?? []) as any as WLEntry[]); }
@@ -117,63 +94,11 @@ export function WatchlistTab({ spots, spotStatus, onSpotSelect, onSpotClick }: P
 
   // Live spots per entry — prefix-matched, newest first, deduped per band+mode
   // (one line per slot; the freshest spot represents it).
-  const spotsFor = useMemo(() => {
+  // Which entries are on the air, and which of their slots are still needed.
-    const map = new Map<string, ClusterSpot[]>();
+  // One definition, shared with the docked watch-list widget — the answer
-    for (const e of entries) map.set(e.callsign, []);
+  // involves a debounced query per visible slot, and two copies of it would be
-    for (const s of spots) {
+  // two bursts of the same question and two ideas of what "needed" means.
-      for (const e of entries) {
+  const { spotsFor, workedFor, settled, onAir, worked } = useWatchlistSpots(entries, spots);
-        if (matchesEntry(s.dx_call ?? '', e.callsign)) { map.get(e.callsign)!.push(s); break; }
-      }
-    }
-    for (const [k, list] of map) {
-      const seen = new Set<string>();
-      map.set(k, list.filter((s) => {
-        const key = `${(s.band ?? '')}|${inferSpotMode(s.comment ?? '', s.freq_hz)}|${s.dx_call}`;
-        if (seen.has(key)) return false;
-        seen.add(key);
-        return true;
-      }));
-    }
-    return map;
-  }, [spots, entries]);
-
-  // The worked answers, refreshed when the visible slots change. Debounced: a
-  // spot burst must cost one round trip, not one per spot.
-  const queryTimer = useRef<number | undefined>(undefined);
-  useEffect(() => {
-    if (queryTimer.current) window.clearTimeout(queryTimer.current);
-    queryTimer.current = window.setTimeout(async () => {
-      const queries: { call: string; band: string; mode: string; contest: boolean }[] = [];
-      const keys: string[] = [];
-      for (const e of entries) {
-        for (const s of spotsFor.get(e.callsign) ?? []) {
-          const mode = inferSpotMode(s.comment ?? '', s.freq_hz) || '';
-          queries.push({ call: s.dx_call, band: s.band ?? '', mode, contest: e.isContest });
-          keys.push(`${s.dx_call}|${s.band ?? ''}|${mode}|${e.isContest ? 1 : 0}`);
-        }
-      }
-      if (queries.length === 0) { setWorked({}); return; }
-      try {
-        const res: boolean[] = (await WatchlistWorkedSlots(queries as any)) ?? [];
-        // MERGED, not replaced: replacing made every already-answered key
-        // momentarily unknown on each refresh, which re-hid settled lines.
-        setWorked((prev) => {
-          const next = { ...prev };
-          keys.forEach((k, i) => { next[k] = !!res[i]; });
-          return next;
-        });
-      } catch { /* the badges just stay conservative */ }
-    }, 150) as unknown as number;
-    return () => { if (queryTimer.current) window.clearTimeout(queryTimer.current); };
-  }, [spotsFor, entries]);
-
-  const wkey = (e: WLEntry, s: ClusterSpot) =>
-    `${s.dx_call}|${s.band ?? ''}|${inferSpotMode(s.comment ?? '', s.freq_hz) || ''}|${e.isContest ? 1 : 0}`;
-  const workedFor = (e: WLEntry, s: ClusterSpot): boolean => worked[wkey(e, s)] ?? false;
-  // A spot whose verdict has not come back yet is NOT drawn. Showing it as
-  // Needed and withdrawing it half a second later made the list twitch on
-  // every burst — and nobody needs a spot 400 ms early, they need it settled.
-  const settled = (e: WLEntry, s: ClusterSpot): boolean => wkey(e, s) in worked;
 
   const add = async () => {
     const c = addCall.trim().toUpperCase();
@@ -195,11 +120,7 @@ export function WatchlistTab({ spots, spotStatus, onSpotSelect, onSpotClick }: P
     catch (e: any) { flash(String(e?.message ?? e), true); }
   };
 
-  const isOnAir = (e: WLEntry): boolean =>
+  const isOnAir = onAir;
-    (spotsFor.get(e.callsign) ?? []).some((s) => {
-      const ts = Date.parse(String((s as any).received_at ?? ''));
-      return ts > 0 && Date.now() - ts < ON_AIR_MS;
-    });
 
   const shown = entries.filter((e) => {
     if (family === 'normal' && e.isContest) return false;
@@ -225,14 +146,8 @@ export function WatchlistTab({ spots, spotStatus, onSpotSelect, onSpotClick }: P
   // The cluster's own badge for a spot, read from the shared status index.
   const dxccBadge = (s: ClusterSpot): { label: string; color: string } | null => {
     const st = spotStatus[spotStatusKey(s.dx_call, s.band ?? '', s.comment ?? '', s.freq_hz)];
-    switch (st?.status) {
+    const b = newBadge(st?.status);
-      case 'new': return { label: t('wl.newDxcc'), color: 'var(--danger)' };
+    return b ? { label: t(b.key), color: b.colour } : null;
-      case 'new-band-mode': return { label: t('clg2.newBandMode'), color: 'var(--danger)' };
-      case 'new-band': return { label: t('clg2.newBand'), color: 'var(--warning)' };
-      case 'new-mode': return { label: t('clg2.newMode'), color: 'var(--caution)' };
-      case 'new-slot': return { label: t('clg2.newSlot'), color: '#5AC8FA' };
-      default: return null;
-    }
   };
 
   // Three decimals, and no trailing zeros beyond them: 7.056 rather than

frontend/src/components/WatchlistWidget.tsx

@@ -0,0 +1,147 @@
+// WatchlistWidget — the watch list reduced to what is worth acting on RIGHT
+// NOW: entries that are on the air and still needed.
+//
+// The Watchlist tab is a tab, and an operator working FT8 lives on the decodes
+// one. A station they asked to be told about would appear on a screen they are
+// not looking at — so the same answer is docked in the widget strip, which sits
+// above the tabs and is therefore always in view. Only active AND needed: a
+// list of everything watched is the tab's job, and it would not fit here.
+import { useEffect, useMemo, useState } from 'react';
+import { Bell, X } from 'lucide-react';
+import { useI18n } from '@/lib/i18n';
+import { cn } from '@/lib/utils';
+import { inferSpotMode, spotStatusKey } from '@/lib/spot';
+import { useWatchlistSpots, newBadge, type WLEntry } from '@/lib/watchlistSpots';
+import type { ClusterSpot, SpotStatusEntry } from '@/components/ClusterGrid';
+import { WatchlistEntries } from '../../wailsjs/go/main/App';
+import { EventsOn } from '../../wailsjs/runtime/runtime';
+
+interface Props {
+  spots: ClusterSpot[];
+  // The cluster's own verdicts. WHAT a station is worth is the reason to leave
+  // what you are doing for it — "on the air and not worked" says nothing about
+  // whether it is a new entity or a fifth band on one worked in 1998.
+  spotStatus: Record<string, SpotStatusEntry>;
+  // A row is a spot: clicking it does what clicking one in the cluster does.
+  onPick?: (s: ClusterSpot) => void;
+  onClose?: () => void;
+}
+
+function age(s: ClusterSpot): string {
+  const ts = Date.parse(String((s as any).received_at ?? ''));
+  if (!(ts > 0)) return '';
+  const m = Math.floor((Date.now() - ts) / 60000);
+  if (m < 1) return 'now';
+  return `${m}m`;
+}
+
+export function WatchlistWidget({ spots, spotStatus, onPick, onClose }: Props) {
+  const { t } = useI18n();
+  const [entries, setEntries] = useState<WLEntry[]>([]);
+
+  const load = () => { WatchlistEntries().then((e: any) => setEntries((e ?? []) as WLEntry[])).catch(() => {}); };
+  useEffect(() => {
+    load();
+    // The list changes from four places (the tab, the cluster's star, the
+    // contest auto-add, an import), and a widget that only reads it at mount
+    // would quietly watch the wrong set for the rest of the session.
+    const off = EventsOn('watchlist:changed', load);
+    return () => { off?.(); };
+  }, []);
+
+  const { spotsFor, workedFor, settled } = useWatchlistSpots(entries, spots);
+
+  // Ticking, because every row carries an age and the freshest thing here is
+  // the reason to look at it at all.
+  const [, tick] = useState(0);
+  useEffect(() => {
+    const id = window.setInterval(() => tick((n) => n + 1), 30000);
+    return () => window.clearInterval(id);
+  }, []);
+
+  // One row per (entry, needed slot): the same station on two bands is two
+  // chances to work it, and collapsing them would hide the one that is open.
+  const rows = useMemo(() => {
+    const out: { e: WLEntry; s: ClusterSpot }[] = [];
+    for (const e of entries) {
+      for (const s of spotsFor.get(e.callsign) ?? []) {
+        if (!settled(e, s) || workedFor(e, s)) continue;
+        out.push({ e, s });
+      }
+    }
+    // Freshest first: a spot from twenty minutes ago is history, and this
+    // panel is short.
+    return out.sort((a, b) =>
+      Date.parse(String((b.s as any).received_at ?? '')) - Date.parse(String((a.s as any).received_at ?? '')));
+  }, [entries, spotsFor, workedFor, settled]);
+
+  return (
+    <section className="flex flex-col h-full min-h-0 rounded-lg border border-border bg-card overflow-hidden">
+      <div className="flex items-center gap-2 px-3 py-1.5 bg-muted/40 border-b border-border shrink-0">
+        <Bell className="size-4 text-primary shrink-0" />
+        <span className="text-xs font-semibold uppercase tracking-wider text-muted-foreground">
+          {t('wlw.title')}
+        </span>
+        <span className={cn('rounded px-1.5 py-px text-[10px] font-bold',
+          rows.length > 0 ? 'bg-warning text-warning-foreground' : 'bg-muted text-muted-foreground')}>
+          {rows.length}
+        </span>
+        <div className="flex-1" />
+        {onClose && (
+          <button type="button" onClick={onClose} title={t('wlw.hide')}
+            className="text-muted-foreground hover:text-foreground transition-colors">
+            <X className="size-3.5" />
+          </button>
+        )}
+      </div>
+
+      <div className="flex-1 min-h-0 overflow-y-auto">
+        {rows.length === 0 ? (
+          // Empty is the normal state, and it means something precise — say it,
+          // rather than leaving a blank box that reads as broken.
+          <div className="px-3 py-3 text-xs text-muted-foreground">
+            {entries.length === 0 ? t('wlw.emptyList') : t('wlw.emptyNone')}
+          </div>
+        ) : rows.map(({ e, s }, i) => {
+          const mode = inferSpotMode(s.comment ?? '', s.freq_hz) || '';
+          const badge = newBadge(spotStatus[spotStatusKey(s.dx_call, s.band ?? '', s.comment ?? '', s.freq_hz)]?.status);
+          return (
+            <button
+              key={`${e.callsign}-${s.dx_call}-${s.band}-${mode}-${i}`}
+              type="button"
+              onClick={() => onPick?.(s)}
+              title={e.callsign === s.dx_call
+                ? t('wlw.pick', { call: s.dx_call })
+                : `${t('wlw.pick', { call: s.dx_call })} — ${e.callsign}`}
+              className="w-full text-left px-2 py-1 border-b border-border/20 hover:bg-muted/50 transition-colors flex items-center gap-1.5"
+            >
+              {/* One line, in reading order: who, where, what it is worth, how
+                  long ago. The callsign is the only part allowed to give way —
+                  everything else is short and fixed, and a row that wraps is a
+                  row an operator has to parse instead of scan. */}
+              <span className="font-mono text-[13px] font-bold text-warning truncate">{s.dx_call}</span>
+              {s.band && (
+                <span className="rounded px-1 py-px text-[10px] font-bold uppercase bg-info-muted text-info-muted-foreground shrink-0">
+                  {s.band}
+                </span>
+              )}
+              {mode && <span className="font-mono text-[10px] text-muted-foreground shrink-0">{mode}</span>}
+              <div className="flex-1" />
+              {/* Why it is worth interrupting a QSO for — or not. */}
+              {badge && (
+                <span className="rounded px-1 py-px text-[10px] font-bold uppercase tracking-wide border shrink-0"
+                  style={{ color: badge.colour, borderColor: `color-mix(in srgb, ${badge.colour} 45%, transparent)`,
+                    background: `color-mix(in srgb, ${badge.colour} 12%, transparent)` }}>
+                  {t(badge.key)}
+                </span>
+              )}
+              <span className="font-mono text-[10px] text-muted-foreground/70 tabular-nums shrink-0 w-7 text-right">
+                {age(s)}
+              </span>
+            </button>
+          );
+        })}
+      </div>
+    </section>
+  );
+}

frontend/src/components/ui/combobox.tsx

@@ -9,7 +9,7 @@ import { cn } from '@/lib/utils';
 // can't hold a typo'd value that isn't in the list.
 export function Combobox({
   value, onChange, options, placeholder, className, allowFreeText = false, commitOnType = false,
-  showToggle = false,
+  showToggle = false, onWheelStep,
 }: {
   value: string;
   onChange: (v: string) => void;
@@ -21,6 +21,10 @@ export function Combobox({
   // fields read live by other actions — e.g. RST, so a CW macro sent without
   // leaving the field uses the value just typed.
   commitOnType?: boolean;
+  // Wheel over the field steps the value. The control cannot know what a step
+  // means — a decibel here, an S-unit there — so it reports the direction and
+  // the owner decides.
+  onWheelStep?: (dir: 1 | -1) => void;
   // Draw a chevron that opens the full list on click.
   //
   // Without it this control is indistinguishable from a plain text box: it opens
@@ -42,6 +46,21 @@ export function Combobox({
   // leave the list floating over the wrong row.
   const [menuPos, setMenuPos] = useState({ top: 0, left: 0, width: 0 });
 
+  // A NATIVE, non-passive listener: React attaches onWheel passively, where
+  // preventDefault does nothing at all and the panel scrolls away under the
+  // field being adjusted.
+  useEffect(() => {
+    const el = ref.current;
+    if (!el || !onWheelStep) return;
+    const onWheel = (e: WheelEvent) => {
+      if (e.deltaY === 0) return;
+      e.preventDefault();
+      onWheelStep(e.deltaY < 0 ? 1 : -1); // up is a better report
+    };
+    el.addEventListener('wheel', onWheel, { passive: false });
+    return () => el.removeEventListener('wheel', onWheel);
+  }, [onWheelStep]);
+
   useEffect(() => {
     function onDoc(e: MouseEvent) {
       if (ref.current && !ref.current.contains(e.target as Node)) setOpen(false);

frontend/src/lib/clusterMacros.ts

@@ -10,7 +10,7 @@
 // Stored through writeUiPref like every other portable preference, so the
 // buttons travel with data/ rather than living in one browser profile.
 
-import { writeUiPref } from '@/lib/uiPref';
+import { writeUiPrefDebounced } from '@/lib/uiPref';
 
 export type ClusterMacro = {
   label: string; // what the button says
@@ -43,8 +43,12 @@ export function loadClusterMacros(): ClusterMacro[] {
   return out;
 }
 
+// Debounced, because this is called on every keystroke in twenty-four text
+// boxes. The local cache is written at once — it is what everything reads back
+// — and only the database write waits for the typing to stop. A round trip into
+// Go per character is what "the letters appear after I have moved on" was.
 export function saveClusterMacros(macros: ClusterMacro[]): void {
-  writeUiPref(clusterMacrosKey, JSON.stringify(macros));
+  writeUiPrefDebounced(clusterMacrosKey, JSON.stringify(macros));
 }
 
 // visibleClusterMacros drops the slots that would send nothing. The COMMAND is

frontend/src/lib/clusterPresets.ts

@@ -0,0 +1,50 @@
+// Cluster nodes worth starting from.
+//
+// Setting up a telnet cluster is the step operators get stuck on: the host and
+// the port are two pieces of information nobody has to hand, a typo produces a
+// silent failure to connect, and the ports are not guessable — a Reverse Beacon
+// feed on 7000 carries CW and RTTY while 7001 carries FT8 and FT4, which no
+// amount of trying will tell you.
+//
+// So the editor offers a list. It fills the fields and then gets out of the
+// way: everything stays editable, because a node moves or an operator wants a
+// different name for it, and a preset that could not be corrected would be
+// worse than none.
+//
+// The list is meant to grow. One entry per node, and nothing here is special —
+// a node added by hand behaves exactly the same.
+
+export type ClusterPreset = {
+  name: string;
+  host: string;
+  port: number;
+  // What it carries, in a few words: the dropdown is chosen from, not read, and
+  // "SOTA" means nothing to somebody who has never chased a summit.
+  about: string;
+  // Sent one per line after login. Empty for the nodes that need nothing.
+  init?: string;
+};
+
+export const CLUSTER_PRESETS: ClusterPreset[] = [
+  { name: 'F4BPO', host: 'cluster.f4bpo.com', port: 7300,
+    about: 'General DX cluster (OpsLog author’s node)' },
+  { name: 'DXFun', host: 'dxfun.com', port: 8000,
+    about: 'General DX cluster, worldwide' },
+  { name: 'F5LEN', host: 'dxcluster.f5len.org', port: 7373,
+    about: 'General DX cluster' },
+  { name: 'F5MZN', host: 'f5mzn.org', port: 9000,
+    about: 'General DX cluster' },
+  { name: 'KM3T', host: 'dxcc.km3t.net', port: 7373,
+    about: 'General DX cluster' },
+  { name: 'SOTA', host: 'cluster.sota.org.uk', port: 7300,
+    about: 'Summits On The Air spots' },
+  { name: 'POTA', host: 'pota-cluster.iz2lsc.eu', port: 7373,
+    about: 'Parks On The Air spots' },
+  // The two Reverse Beacon feeds are one network on two ports, and which port
+  // decides which modes arrive. Getting that wrong looks exactly like a dead
+  // node, so they are listed separately and named for what they carry.
+  { name: 'RBN CW', host: 'telnet.reversebeacon.net', port: 7000,
+    about: 'Reverse Beacon Network — CW and RTTY skimmers' },
+  { name: 'RBN FTx', host: 'telnet.reversebeacon.net', port: 7001,
+    about: 'Reverse Beacon Network — FT8 and FT4 skimmers' },
+];

frontend/src/lib/mapBase.ts

@@ -0,0 +1,38 @@
+// Which imagery each map draws on — one choice per map.
+//
+// The world map and the grid-square map used to share a single key, so picking
+// satellite imagery to look at grids also repainted the main map, and there was
+// no way to have terrain on one and plain streets on the other. They are
+// different maps answering different questions, and the imagery that suits one
+// is not the imagery that suits the next.
+//
+// Portable (see lib/uiPref) like the remembered views in lib/mapView: a copied
+// data folder brings the choices with it.
+import { writeUiPref } from '@/lib/uiPref';
+import type { BasemapKey } from '@/components/MainMap';
+
+// The keys in use. Named here rather than typed at each call site so a rename
+// cannot silently orphan somebody's choice.
+export const MAP_BASE_WORLD = 'opslog.mapBasemap';
+export const MAP_BASE_GRIDS = 'opslog.gridMapBase';
+export const MAP_BASE_FT = 'opslog.ftmapBase';
+export const MAP_BASE_SAT = 'opslog.satMapBase';
+
+const VALID = ['light', 'voyager', 'street', 'satellite'];
+
+// loadMapBase reads one map's choice.
+//
+// inheritFrom exists for the split: the grid map's choice lived under the world
+// map's key until they were separated, so an operator who had chosen imagery
+// there keeps it instead of being silently reset to the default.
+export function loadMapBase(key: string, fallback: BasemapKey, inheritFrom?: string): BasemapKey {
+  const read = (k: string) => {
+    const v = localStorage.getItem(k);
+    return v && VALID.includes(v) ? (v as BasemapKey) : null;
+  };
+  return read(key) ?? (inheritFrom ? read(inheritFrom) : null) ?? fallback;
+}
+
+export function saveMapBase(key: string, v: BasemapKey): void {
+  writeUiPref(key, v);
+}

frontend/src/lib/mapView.ts

@@ -0,0 +1,31 @@
+// Remembered map views — where each map was left, per map.
+//
+// Panning and zooming a map is an operator saying "this is the part of the world
+// I work". Throwing that away on every tab switch made the maps something to
+// set up again each time rather than something to glance at, and the world map
+// was the only one that remembered anything.
+//
+// One key per map, and portable (see lib/uiPref) like the world map's own: a
+// copied data folder brings the views with it.
+import { writeUiPref } from '@/lib/uiPref';
+
+export type MapView = { lat: number; lon: number; zoom: number };
+
+// The keys in use. Named here rather than typed at each call site so a rename
+// cannot silently orphan somebody's saved view.
+export const MAP_VIEW_WORLD = 'opslog.mapView';
+export const MAP_VIEW_FT = 'opslog.ftMapView';
+export const MAP_VIEW_GRIDS = 'opslog.gridMapView';
+
+export function loadMapView(key: string): MapView | null {
+  try {
+    const v = JSON.parse(localStorage.getItem(key) || 'null');
+    return v && typeof v.zoom === 'number' && typeof v.lat === 'number' && typeof v.lon === 'number' ? v : null;
+  } catch {
+    return null; // corrupt or unreadable → open where the map would by default
+  }
+}
+
+export function saveMapView(key: string, lat: number, lon: number, zoom: number): void {
+  writeUiPref(key, JSON.stringify({ lat, lon, zoom }));
+}

frontend/src/lib/rotorStyle.ts

@@ -0,0 +1,39 @@
+// Which rotor dial to draw.
+//
+// Two compasses ship: the current one (night map, square scale, mouse pointer,
+// target marker) and the original small light-map dial. Neither is more correct
+// than the other — one operator reads the big map at a glance, another wants the
+// compact dial that was there before — so it is a preference, not a migration.
+//
+// A UI preference rather than a settings-database key: it decides what a widget
+// looks like, nothing is transmitted from it, and it belongs to the screen it is
+// read on. It is portable all the same (see lib/uiPref), so a copied folder
+// keeps the dial its owner chose.
+import { writeUiPref } from '@/lib/uiPref';
+
+export const KEY_ROTOR_STYLE = 'opslog.rotorStyle';
+
+export type RotorStyle = 'modern' | 'classic';
+
+export function rotorStyle(): RotorStyle {
+  try {
+    return localStorage.getItem(KEY_ROTOR_STYLE) === 'classic' ? 'classic' : 'modern';
+  } catch {
+    return 'modern';
+  }
+}
+
+// Same shape as the distance unit: the compasses are rendered from two call
+// sites, and a preference changed in Settings has to reach both without either
+// of them polling for it.
+const listeners = new Set<() => void>();
+
+export function setRotorStyle(style: RotorStyle): void {
+  writeUiPref(KEY_ROTOR_STYLE, style);
+  listeners.forEach((l) => l());
+}
+
+export function subscribeRotorStyle(fn: () => void): () => void {
+  listeners.add(fn);
+  return () => { listeners.delete(fn); };
+}

frontend/src/lib/rst.ts

@@ -36,3 +36,85 @@ export function rstOptions(mode: string, lists: RSTLists): string[] {
   if (l && l.length) return l;
   return cat === 'phone' ? ['59', '58', '57'] : cat === 'cw' ? ['599', '589', '579'] : ['+00', '-10', '-20'];
 }
+
+// stepRST moves a report one step up or down, the way an operator would say it.
+//
+// The dropdown beside these fields is a list of the values worth having to hand,
+// not of every legal report: nobody keeps 41 dB figures in it. So the wheel
+// works on the VALUE, not on the list — a digital report moves by a decibel and
+// an RST by one S-unit, which is what the hand on the wheel is asking for.
+//
+// dir is +1 for wheel up (a better report) and -1 for down.
+export function stepRST(value: string, dir: number, mode: string): string {
+  const v = (value || '').trim();
+  if (v === '') return v;
+  if (rstCategory(mode) === 'digital') {
+    // A dB report: "-12", "+05", "0". Kept in its own shape — signed and two
+    // digits — because that is how every decoder writes it and how the operator
+    // reads it back off the screen.
+    const n = parseInt(v, 10);
+    if (!Number.isFinite(n)) return v;
+    // The range WSJT-X itself reports in, with room either side. Beyond it the
+    // number stops meaning anything.
+    const next = Math.max(-30, Math.min(35, n + dir));
+    return (next < 0 ? '-' : '+') + String(Math.abs(next)).padStart(2, '0');
+  }
+  // RST/RS, and the S9+ ladder above it. What an operator counts through is
+  //
+  //   … 57  58  59  59+5  59+10  59+15  59+20 …
+  //
+  // — one S-unit up to nine, then five decibels at a time, because that is how
+  // a strong signal is reported and how the S-meter is read (see sMeterRST).
+  // Stepping the S digit and leaving the "+20" where it was would have gone
+  // from 59+20 to 58+20, which nobody has ever said on the air.
+  //
+  // R and T do not move: they are judgements about readability and tone, and a
+  // wheel has no business changing them.
+  const m = /^(\d)(\d)(\d?)(?:\+(\d+))?$/.exec(v);
+  if (!m) return v;
+  const head = m[1];
+  const tone = m[3];
+  let sUnit = parseInt(m[2], 10);
+  let over = m[4] === undefined ? 0 : parseInt(m[4], 10);
+  if (over > 0) {
+    // Above S9: five at a time, and back down through +5 to a plain 59.
+    over = Math.max(0, Math.min(60, over + dir * 5));
+  } else if (sUnit >= 9 && dir > 0) {
+    over = 5; // 59 → 59+5
+  } else {
+    sUnit = Math.max(1, Math.min(9, sUnit + dir));
+  }
+  return head + String(sUnit) + tone + (over > 0 ? '+' + over : '');
+}
+
+// rstFitsMode says whether a report belongs to the family a mode reports in.
+//
+// The three families are written differently and are not interchangeable: a
+// signed decibel figure ("+00"), a three-figure RST ("599"), a two-figure RS
+// ("59", with an optional "+20" above S9). "+00" on SSB is not a weak report,
+// it is not a report at all.
+export function rstFitsMode(value: string, mode: string): boolean {
+  const v = (value || '').trim();
+  if (v === '') return false;
+  switch (rstCategory(mode)) {
+    case 'digital': return /^[+-]\d{1,2}$/.test(v);
+    case 'cw': return /^\d{3}(\+\d+)?$/.test(v);
+    default: return /^\d{2}(\+\d+)?$/.test(v);
+  }
+}
+
+// convertRST carries a report across the CW/phone divide, keeping the operator's
+// own judgement of the signal: 57 becomes 579, 599 becomes 59.
+//
+// Only between those two — a decibel figure says nothing about readability and
+// an RST says nothing in decibels, so there the preset is the honest answer.
+// Returns '' when it cannot be done.
+export function convertRST(value: string, toMode: string): string {
+  const v = (value || '').trim();
+  const to = rstCategory(toMode);
+  if (to === 'digital') return '';
+  const m = /^(\d)(\d)(\d?)((?:\+\d+)?)$/.exec(v);
+  if (!m) return '';
+  if (to === 'cw') return m[1] + m[2] + '9' + m[4];  // RS → RST, tone 9
+  return m[1] + m[2] + m[4];                        // RST → RS, tone dropped
+}

frontend/src/lib/spot.ts

@@ -15,6 +15,15 @@ export function cleanSpotter(s: string): string {
 // alone instead of guessing wrong.
 export function inferSpotMode(comment: string, freqHz: number): string {
   const c = (comment || '').toUpperCase();
+  // SuperFox and Fox/Hound are FT8 — they are WSJT-X's DXpedition transmit modes,
+  // not modes of their own, and they turn up in a comment written every way an
+  // operator can shorten them: "super fox", SFOX, S/F, F/H.
+  //
+  // A spot commented "super fox" fell through to the band plan and came out
+  // DATA, and that verdict is not cosmetic: the
+  // band+mode status is computed from this answer, so a ZD8 on 21.071 read as a
+  // new DATA slot rather than the new FT8 one it is.
+  if (/\bSUPER\s*FOX\b|\bSFOX\b|\bS\/F\b|\bFOX\s*\/?\s*HOUND\b|\bF\/H\b/.test(c)) return 'FT8';
   if (/\bFT8\b/.test(c))   return 'FT8';
   if (/\bFT4\b/.test(c))   return 'FT4';
   if (/\bJS8\b/.test(c))   return 'JS8';

frontend/src/lib/uiPref.ts

@@ -29,10 +29,14 @@ const PORTABLE_KEYS = [
   'opslog.bandMapBands',  // bands shown side-by-side in the Band Map tab
   'opslog.mapAutoZoomDX', // Main map: auto-zoom to the DX (vs free pan/zoom)
   'opslog.mapView',       // Main map: remembered free-pan view (lat/lon/zoom)
+  // The same, for the FT decodes map and the grid-square map: a view an
+  // operator set up is theirs, and it should follow the folder like the rest.
+  'opslog.ftMapView', 'opslog.gridMapView', 'opslog.satMapView',
   'opslog.lookupOnBlur',  // run the callsign lookup on blur instead of while typing
   'opslog.groupDigitalSlots', // matrix + cluster: all digital modes count as ONE (DXCC-style) instead of per-mode slots
   'opslog.clusterShowFilters', // cluster filter sidebar shown (tab + Main pane)
-  'opslog.mapBasemap',    // world map basemap (light / street / satellite)
+  // One imagery choice per map — world, grid squares, FT map, satellites.
+  'opslog.mapBasemap', 'opslog.gridMapBase', 'opslog.ftmapBase', 'opslog.satMapBase',
   'opslog.dateFormat',    // how dates are DISPLAYED (iso / fr / us); storage stays ISO
   'opslog.mapGreyline',   // world map: grey line (day/night terminator) shown
   'opslog.awardRefSort', 'opslog.awardRefSortDir', // award reference table: sort column and direction
@@ -44,6 +48,10 @@ const PORTABLE_KEYS = [
   'opslog.iaruRegion',    // IARU region (1/2/3) — band edges and segments on the band maps
   'opslog.chasePota',     // show POTA references and the NEW POTA marker on spots
   'opslog.chaseSota',     // show SOTA references on spots
+  // The other chase switches. In the DB as well as locally because AUTO-CALL
+  // reads them: what the operator does not hunt is not something to transmit
+  // for, and the backend cannot see localStorage.
+  'opslog.chasePfx', 'opslog.chaseCounty', 'opslog.chaseState', 'opslog.chaseGrids',
   'opslog.activeTab',     // last selected tab
   'opslog.mainSplit',    // Main tab: width share of the left pane (percent) — legacy, read once to seed mainShares
   'opslog.mainShares',   // Main tab: column shares per column count, as {2:[..],3:[..],4:[..]}
@@ -51,6 +59,8 @@ const PORTABLE_KEYS = [
   'opslog.clusterMuteWorked',    // cluster/band map: no colour or badge on worked spots
   'opslog.clusterSlotHighlight', // cluster/band map: colour calls not worked on this band+mode
   'opslog.bandMapWidth',    // docked band map: column width (px)
+  'opslog.satSideWidth', 'opslog.satSideShown', // Satellites tab: readout column width, and whether it is shown
+  'opslog.satSkyShown',  // Satellites tab: the polar sky plot
   'opslog.bandMapTabWidth', // Band map tab: shared card width (px)
   'opslog.bandMapZoom',     // band map zoom (px/kHz step) remembered per band, as one {band: index} map
   'opslog.decodeColWidths', // FT decodes table: per-column widths (px), as one {col: px} map
@@ -83,6 +93,50 @@ export async function syncPortablePrefs(): Promise<void> {
   }));
 }
 
+// writeUiPrefDebounced is writeUiPref for a value that changes AS SOMEBODY
+// TYPES.
+//
+// The local cache is written at once, because that is what the interface reads
+// back and it costs nothing. The DATABASE write is held until the typing stops:
+// writeUiPref crosses into Go and writes a row, and doing that per character in
+// a text box is a round trip per keystroke — twenty-four boxes of cluster
+// macros was exactly that, and it showed as characters appearing after the
+// finger had left the key.
+//
+// Pending writes are flushed when the page goes away, so a value typed and
+// immediately followed by a close is not lost.
+const pendingPrefs = new Map<string, { value: string; timer: number }>();
+
+export function writeUiPrefDebounced(key: string, value: string, ms = 400): void {
+  try { localStorage.setItem(key, value); } catch { /* quota / private mode */ }
+  const prev = pendingPrefs.get(key);
+  if (prev) window.clearTimeout(prev.timer);
+  const timer = window.setTimeout(() => {
+    pendingPrefs.delete(key);
+    SetUIPref(key, value).catch((e: any) => {
+      try { LogUIError('ui pref', 'could not store ' + key + ': ' + String(e?.message ?? e), ''); } catch { /* nothing left to try */ }
+    });
+  }, ms);
+  pendingPrefs.set(key, { value, timer });
+}
+
+// flushUiPrefs writes every pending value immediately.
+export function flushUiPrefs(): void {
+  for (const [key, p] of pendingPrefs) {
+    window.clearTimeout(p.timer);
+    SetUIPref(key, p.value).catch(() => { /* the local cache still holds it */ });
+  }
+  pendingPrefs.clear();
+}
+if (typeof window !== 'undefined') {
+  window.addEventListener('beforeunload', flushUiPrefs);
+  // Closing the app does not always fire beforeunload in a WebView; a hidden
+  // page is the earlier and more reliable signal.
+  document.addEventListener('visibilitychange', () => {
+    if (document.visibilityState === 'hidden') flushUiPrefs();
+  });
+}
+
 // writeUiPref write-throughs a value to the local cache AND the portable DB.
 // Use it everywhere these keys are written instead of localStorage.setItem.
 export function writeUiPref(key: string, value: string): void {

frontend/src/lib/watchlistSpots.ts

@@ -0,0 +1,133 @@
+// What the watch list is HEARING, and what of it is still needed.
+//
+// Two places ask the same question — the Watchlist tab and the docked widget —
+// and the answer involves a debounced round trip to the logbook per visible
+// slot. Written twice it would be two definitions of "needed" drifting apart,
+// and two bursts of the same query on every spot; written here it is one.
+import { useEffect, useMemo, useRef, useState } from 'react';
+import type { ClusterSpot } from '@/components/ClusterGrid';
+import { inferSpotMode } from '@/lib/spot';
+import { WatchlistWorkedSlots } from '../../wailsjs/go/main/App';
+
+export interface WLEntry {
+  callsign: string; lastSeenStr: string; addedAt: string; spotCount: number;
+  isContest: boolean; notify: boolean;
+  isExpedition: boolean; clubLogQSOs24h: number; clubLogTotalQSOs: number;
+  clubLogHasOQRS: boolean; clubLogLiveStream: boolean;
+}
+
+// A spot is ON AIR while its last sighting is this fresh.
+export const ON_AIR_MS = 10 * 60 * 1000;
+
+// Exact unless the entry carries a trailing * — the same rule the backend's
+// Match applies to the live stream, mirrored so the list and the alerts can
+// never disagree about what an entry covers.
+export function matchesEntry(call: string, pattern: string): boolean {
+  const c = call.toUpperCase();
+  if (pattern.endsWith('*')) {
+    const p = pattern.slice(0, -1);
+    return p !== '' && c.startsWith(p);
+  }
+  return c === pattern;
+}
+
+// What the cluster's verdict is worth saying, and in what colour.
+//
+// The order of severity is the one the band map and Chase new use: a new entity
+// first, then the band and mode inside it. Shared because the tab and the docked
+// widget must not label the same spot differently — an operator reads one of
+// them to decide whether to leave what they are doing.
+export const NEW_BADGES: Record<string, { key: string; colour: string }> = {
+  'new': { key: 'wl.newDxcc', colour: 'var(--danger)' },
+  'new-band-mode': { key: 'clg2.newBandMode', colour: 'var(--danger)' },
+  'new-band': { key: 'clg2.newBand', colour: 'var(--warning)' },
+  'new-mode': { key: 'clg2.newMode', colour: 'var(--caution)' },
+  'new-slot': { key: 'clg2.newSlot', colour: '#5AC8FA' },
+};
+
+export function newBadge(status?: string): { key: string; colour: string } | null {
+  return (status && NEW_BADGES[status]) || null;
+}
+
+export interface WatchlistSpots {
+  // The raw verdicts, exposed for dependency arrays: it changes only when an
+  // answer arrives, where the closures below are new on every render.
+  worked: Record<string, boolean>;
+  // The spots each entry covers, deduplicated by band+mode.
+  spotsFor: Map<string, ClusterSpot[]>;
+  // Worked on this exact slot (and, for a contest entry, today).
+  workedFor: (e: WLEntry, s: ClusterSpot) => boolean;
+  // Whether the logbook has actually answered for this pair yet. A spot whose
+  // verdict has not come back is NOT drawn: showing it as needed and
+  // withdrawing it half a second later made the list twitch on every burst,
+  // and nobody needs a spot 400 ms early — they need it settled.
+  settled: (e: WLEntry, s: ClusterSpot) => boolean;
+  onAir: (e: WLEntry) => boolean;
+}
+
+export function useWatchlistSpots(entries: WLEntry[], spots: ClusterSpot[]): WatchlistSpots {
+  const [worked, setWorked] = useState<Record<string, boolean>>({});
+
+  const spotsFor = useMemo(() => {
+    const map = new Map<string, ClusterSpot[]>();
+    for (const e of entries) map.set(e.callsign, []);
+    for (const s of spots) {
+      for (const e of entries) {
+        if (matchesEntry(s.dx_call ?? '', e.callsign)) { map.get(e.callsign)!.push(s); break; }
+      }
+    }
+    for (const [k, list] of map) {
+      const seen = new Set<string>();
+      map.set(k, list.filter((s) => {
+        const key = `${(s.band ?? '')}|${inferSpotMode(s.comment ?? '', s.freq_hz)}|${s.dx_call}`;
+        if (seen.has(key)) return false;
+        seen.add(key);
+        return true;
+      }));
+    }
+    return map;
+  }, [spots, entries]);
+
+  // Debounced: a spot burst must cost one round trip, not one per spot.
+  const queryTimer = useRef<number | undefined>(undefined);
+  useEffect(() => {
+    if (queryTimer.current) window.clearTimeout(queryTimer.current);
+    queryTimer.current = window.setTimeout(async () => {
+      const queries: { call: string; band: string; mode: string; contest: boolean }[] = [];
+      const keys: string[] = [];
+      for (const e of entries) {
+        for (const s of spotsFor.get(e.callsign) ?? []) {
+          const mode = inferSpotMode(s.comment ?? '', s.freq_hz) || '';
+          queries.push({ call: s.dx_call, band: s.band ?? '', mode, contest: e.isContest });
+          keys.push(`${s.dx_call}|${s.band ?? ''}|${mode}|${e.isContest ? 1 : 0}`);
+        }
+      }
+      if (queries.length === 0) { setWorked({}); return; }
+      try {
+        const res: boolean[] = (await WatchlistWorkedSlots(queries as any)) ?? [];
+        // MERGED, not replaced: replacing made every already-answered key
+        // momentarily unknown on each refresh, which re-hid settled lines.
+        setWorked((prev) => {
+          const next = { ...prev };
+          keys.forEach((k, i) => { next[k] = !!res[i]; });
+          return next;
+        });
+      } catch { /* the badges just stay conservative */ }
+    }, 150) as unknown as number;
+    return () => { if (queryTimer.current) window.clearTimeout(queryTimer.current); };
+  }, [spotsFor, entries]);
+
+  const wkey = (e: WLEntry, s: ClusterSpot) =>
+    `${s.dx_call}|${s.band ?? ''}|${inferSpotMode(s.comment ?? '', s.freq_hz) || ''}|${e.isContest ? 1 : 0}`;
+
+  return {
+    worked,
+    spotsFor,
+    workedFor: (e, s) => worked[wkey(e, s)] ?? false,
+    settled: (e, s) => wkey(e, s) in worked,
+    onAir: (e) => (spotsFor.get(e.callsign) ?? []).some((s) => {
+      const ts = Date.parse(String((s as any).received_at ?? ''));
+      return ts > 0 && Date.now() - ts < ON_AIR_MS;
+    }),
+  };
+}

frontend/src/version.ts

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

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

@@ -19,6 +19,7 @@ import {pskrtgt} from '../models';
 import {pskr} from '../models';
 import {psu} from '../models';
 import {spe} from '../models';
+import {sat} from '../models';
 import {solar} from '../models';
 import {tunergenius} from '../models';
 import {webpub} from '../models';
@@ -52,6 +53,8 @@ export function ActiveRadioMyRig():Promise<string>;
 
 export function AddQSO(arg1:qso.QSO):Promise<number>;
 
+export function AddSatelliteElements(arg1:string):Promise<number>;
+
 export function AmpFanMode(arg1:string,arg2:string):Promise<void>;
 
 export function AmpOperate(arg1:string,arg2:boolean):Promise<void>;
@@ -454,6 +457,8 @@ export function GetChangelog():Promise<Array<main.ChangelogEntry>>;
 
 export function GetChaseNew():Promise<boolean>;
 
+export function GetChaseNewBands():Promise<Array<string>>;
+
 export function GetChaseNewGrids():Promise<boolean>;
 
 export function GetChaseNewSpots():Promise<Array<main.ChaseNewSpot>>;
@@ -586,6 +591,30 @@ export function GetRowColors():Promise<main.RowColorSettings>;
 
 export function GetSPEStatus():Promise<spe.Status>;
 
+export function GetSatSettings():Promise<main.SatSettings>;
+
+export function GetSatelliteBirds():Promise<Array<main.SatBird>>;
+
+export function GetSatelliteGroundTrack(arg1:string,arg2:number):Promise<Array<sat.Position>>;
+
+export function GetSatelliteNames():Promise<Array<string>>;
+
+export function GetSatelliteNextPass(arg1:string):Promise<main.SatPassInfo>;
+
+export function GetSatelliteObserver():Promise<Record<string, any>>;
+
+export function GetSatellitePasses(arg1:Array<string>,arg2:number):Promise<Array<sat.Pass>>;
+
+export function GetSatellitePositions(arg1:Array<string>):Promise<Array<sat.Position>>;
+
+export function GetSatelliteSkyTrack(arg1:string,arg2:number):Promise<Array<main.SatSkyPoint>>;
+
+export function GetSatelliteTLEInfo():Promise<main.SatTLEInfo>;
+
+export function GetSatelliteTracking():Promise<main.SatTrackStatus>;
+
+export function GetSatelliteTuning(arg1:string,arg2:number,arg3:number):Promise<main.SatTuning>;
+
 export function GetScpStatus():Promise<main.ScpStatus>;
 
 export function GetSecretStatus():Promise<main.SecretStatus>;
@@ -646,6 +675,8 @@ export function GetWsjtFollowMode():Promise<boolean>;
 
 export function GetWsjtHighlight():Promise<boolean>;
 
+export function GetWsjtHighlightColours():Promise<main.WsjtHighlightColours>;
+
 export function GetWsjtHighlightWorked():Promise<boolean>;
 
 export function GetYaesuBandAntennas():Promise<Record<string, number>>;
@@ -654,6 +685,8 @@ export function GetYaesuState():Promise<cat.YaesuTXState>;
 
 export function GridSquares(arg1:string):Promise<Array<qso.GridSquare>>;
 
+export function HaltAutoCall():Promise<void>;
+
 export function HaltDecodeTx(arg1:string,arg2:boolean):Promise<void>;
 
 export function HasBuiltinReferences(arg1:string):Promise<boolean>;
@@ -968,6 +1001,8 @@ export function RefreshDXpeditions():Promise<void>;
 
 export function RefreshKenwood():Promise<void>;
 
+export function RefreshSatelliteTLE():Promise<main.SatTLEInfo>;
+
 export function RefreshSolar():Promise<void>;
 
 export function RefreshYaesuPanel():Promise<void>;
@@ -1110,6 +1145,8 @@ export function SaveRotorPresets(arg1:Array<main.RotorPreset>):Promise<void>;
 
 export function SaveRowColors(arg1:main.RowColorSettings):Promise<void>;
 
+export function SaveSatSettings(arg1:main.SatSettings):Promise<void>;
+
 export function SaveSelfSpotSettings(arg1:main.SelfSpotSettings):Promise<void>;
 
 export function SaveSpotColors(arg1:main.SpotColors):Promise<void>;
@@ -1158,6 +1195,8 @@ export function SetAutoCall(arg1:boolean):Promise<void>;
 
 export function SetAutoCallOnly(arg1:string):Promise<void>;
 
+export function SetAutoCallVisible(arg1:Array<string>,arg2:boolean):Promise<void>;
+
 export function SetCATFrequency(arg1:number):Promise<void>;
 
 export function SetCATMode(arg1:string):Promise<void>;
@@ -1168,6 +1207,8 @@ export function SetCWDecoderPitch(arg1:number):Promise<void>;
 
 export function SetChaseNew(arg1:boolean):Promise<void>;
 
+export function SetChaseNewBands(arg1:Array<string>):Promise<void>;
+
 export function SetChaseNewGrids(arg1:boolean):Promise<void>;
 
 export function SetClublogCtyEnabled(arg1:boolean):Promise<void>;
@@ -1300,6 +1341,8 @@ export function SetWsjtFollowMode(arg1:boolean):Promise<void>;
 
 export function SetWsjtHighlight(arg1:boolean):Promise<void>;
 
+export function SetWsjtHighlightColours(arg1:main.WsjtHighlightColours):Promise<void>;
+
 export function SetWsjtHighlightWorked(arg1:boolean):Promise<void>;
 
 export function SetYaesuAFGain(arg1:number):Promise<void>;
@@ -1344,10 +1387,14 @@ export function SetYaesuVOX(arg1:boolean):Promise<void>;
 
 export function StartCWDecoder():Promise<void>;
 
+export function StartSatelliteTracking(arg1:string,arg2:number):Promise<void>;
+
 export function StationSetRelay(arg1:string,arg2:number,arg3:boolean):Promise<void>;
 
 export function StopCWDecoder():Promise<void>;
 
+export function StopSatelliteTracking():Promise<void>;
+
 export function SwitchCATRig(arg1:number):Promise<void>;
 
 export function SyncFolderNow():Promise<number>;
@@ -1388,6 +1435,8 @@ export function TestQRZUpload():Promise<string>;
 
 export function TestRotatorDevice(arg1:main.RotatorDevice,arg2:number):Promise<void>;
 
+export function TestSatelliteRotator():Promise<string>;
+
 export function TestStationDevice(arg1:main.StationDevice):Promise<main.StationTestResult>;
 
 export function TestUltrabeam(arg1:main.UltrabeamSettings):Promise<void>;

frontend/wailsjs/go/main/App.js

@@ -38,6 +38,10 @@ export function AddQSO(arg1) {
   return window['go']['main']['App']['AddQSO'](arg1);
 }
 
+export function AddSatelliteElements(arg1) {
+  return window['go']['main']['App']['AddSatelliteElements'](arg1);
+}
+
 export function AmpFanMode(arg1, arg2) {
   return window['go']['main']['App']['AmpFanMode'](arg1, arg2);
 }
@@ -842,6 +846,10 @@ export function GetChaseNew() {
   return window['go']['main']['App']['GetChaseNew']();
 }
 
+export function GetChaseNewBands() {
+  return window['go']['main']['App']['GetChaseNewBands']();
+}
+
 export function GetChaseNewGrids() {
   return window['go']['main']['App']['GetChaseNewGrids']();
 }
@@ -1106,6 +1114,54 @@ export function GetSPEStatus() {
   return window['go']['main']['App']['GetSPEStatus']();
 }
 
+export function GetSatSettings() {
+  return window['go']['main']['App']['GetSatSettings']();
+}
+
+export function GetSatelliteBirds() {
+  return window['go']['main']['App']['GetSatelliteBirds']();
+}
+
+export function GetSatelliteGroundTrack(arg1, arg2) {
+  return window['go']['main']['App']['GetSatelliteGroundTrack'](arg1, arg2);
+}
+
+export function GetSatelliteNames() {
+  return window['go']['main']['App']['GetSatelliteNames']();
+}
+
+export function GetSatelliteNextPass(arg1) {
+  return window['go']['main']['App']['GetSatelliteNextPass'](arg1);
+}
+
+export function GetSatelliteObserver() {
+  return window['go']['main']['App']['GetSatelliteObserver']();
+}
+
+export function GetSatellitePasses(arg1, arg2) {
+  return window['go']['main']['App']['GetSatellitePasses'](arg1, arg2);
+}
+
+export function GetSatellitePositions(arg1) {
+  return window['go']['main']['App']['GetSatellitePositions'](arg1);
+}
+
+export function GetSatelliteSkyTrack(arg1, arg2) {
+  return window['go']['main']['App']['GetSatelliteSkyTrack'](arg1, arg2);
+}
+
+export function GetSatelliteTLEInfo() {
+  return window['go']['main']['App']['GetSatelliteTLEInfo']();
+}
+
+export function GetSatelliteTracking() {
+  return window['go']['main']['App']['GetSatelliteTracking']();
+}
+
+export function GetSatelliteTuning(arg1, arg2, arg3) {
+  return window['go']['main']['App']['GetSatelliteTuning'](arg1, arg2, arg3);
+}
+
 export function GetScpStatus() {
   return window['go']['main']['App']['GetScpStatus']();
 }
@@ -1226,6 +1282,10 @@ export function GetWsjtHighlight() {
   return window['go']['main']['App']['GetWsjtHighlight']();
 }
 
+export function GetWsjtHighlightColours() {
+  return window['go']['main']['App']['GetWsjtHighlightColours']();
+}
+
 export function GetWsjtHighlightWorked() {
   return window['go']['main']['App']['GetWsjtHighlightWorked']();
 }
@@ -1242,6 +1302,10 @@ export function GridSquares(arg1) {
   return window['go']['main']['App']['GridSquares'](arg1);
 }
 
+export function HaltAutoCall() {
+  return window['go']['main']['App']['HaltAutoCall']();
+}
+
 export function HaltDecodeTx(arg1, arg2) {
   return window['go']['main']['App']['HaltDecodeTx'](arg1, arg2);
 }
@@ -1870,6 +1934,10 @@ export function RefreshKenwood() {
   return window['go']['main']['App']['RefreshKenwood']();
 }
 
+export function RefreshSatelliteTLE() {
+  return window['go']['main']['App']['RefreshSatelliteTLE']();
+}
+
 export function RefreshSolar() {
   return window['go']['main']['App']['RefreshSolar']();
 }
@@ -2154,6 +2222,10 @@ export function SaveRowColors(arg1) {
   return window['go']['main']['App']['SaveRowColors'](arg1);
 }
 
+export function SaveSatSettings(arg1) {
+  return window['go']['main']['App']['SaveSatSettings'](arg1);
+}
+
 export function SaveSelfSpotSettings(arg1) {
   return window['go']['main']['App']['SaveSelfSpotSettings'](arg1);
 }
@@ -2250,6 +2322,10 @@ export function SetAutoCallOnly(arg1) {
   return window['go']['main']['App']['SetAutoCallOnly'](arg1);
 }
 
+export function SetAutoCallVisible(arg1, arg2) {
+  return window['go']['main']['App']['SetAutoCallVisible'](arg1, arg2);
+}
+
 export function SetCATFrequency(arg1) {
   return window['go']['main']['App']['SetCATFrequency'](arg1);
 }
@@ -2270,6 +2346,10 @@ export function SetChaseNew(arg1) {
   return window['go']['main']['App']['SetChaseNew'](arg1);
 }
 
+export function SetChaseNewBands(arg1) {
+  return window['go']['main']['App']['SetChaseNewBands'](arg1);
+}
+
 export function SetChaseNewGrids(arg1) {
   return window['go']['main']['App']['SetChaseNewGrids'](arg1);
 }
@@ -2534,6 +2614,10 @@ export function SetWsjtHighlight(arg1) {
   return window['go']['main']['App']['SetWsjtHighlight'](arg1);
 }
 
+export function SetWsjtHighlightColours(arg1) {
+  return window['go']['main']['App']['SetWsjtHighlightColours'](arg1);
+}
+
 export function SetWsjtHighlightWorked(arg1) {
   return window['go']['main']['App']['SetWsjtHighlightWorked'](arg1);
 }
@@ -2622,6 +2706,10 @@ export function StartCWDecoder() {
   return window['go']['main']['App']['StartCWDecoder']();
 }
 
+export function StartSatelliteTracking(arg1, arg2) {
+  return window['go']['main']['App']['StartSatelliteTracking'](arg1, arg2);
+}
+
 export function StationSetRelay(arg1, arg2, arg3) {
   return window['go']['main']['App']['StationSetRelay'](arg1, arg2, arg3);
 }
@@ -2630,6 +2718,10 @@ export function StopCWDecoder() {
   return window['go']['main']['App']['StopCWDecoder']();
 }
 
+export function StopSatelliteTracking() {
+  return window['go']['main']['App']['StopSatelliteTracking']();
+}
+
 export function SwitchCATRig(arg1) {
   return window['go']['main']['App']['SwitchCATRig'](arg1);
 }
@@ -2710,6 +2802,10 @@ export function TestRotatorDevice(arg1, arg2) {
   return window['go']['main']['App']['TestRotatorDevice'](arg1, arg2);
 }
 
+export function TestSatelliteRotator() {
+  return window['go']['main']['App']['TestSatelliteRotator']();
+}
+
 export function TestStationDevice(arg1) {
   return window['go']['main']['App']['TestStationDevice'](arg1);
 }

frontend/wailsjs/go/models.ts

@@ -1961,7 +1961,9 @@ export namespace main {
 	    watched_attempts: number;
 	    misses: number;
 	    max_rounds: number;
-	    rest_min: number;
+	    rest_periods: number;
+	    on_screen_only: boolean;
+	    trace: boolean;
 	
 	    static createFrom(source: any = {}) {
 	        return new AutoCallSettings(source);
@@ -1975,18 +1977,22 @@ export namespace main {
 	        this.watched_attempts = source["watched_attempts"];
 	        this.misses = source["misses"];
 	        this.max_rounds = source["max_rounds"];
-	        this.rest_min = source["rest_min"];
+	        this.rest_periods = source["rest_periods"];
+	        this.on_screen_only = source["on_screen_only"];
+	        this.trace = source["trace"];
 	    }
 	}
 	export class AutoCallStatus {
 	    enabled: boolean;
 	    only: string;
 	    target: string;
+	    waiting: string;
 	    calls: number;
 	    max: number;
 	    misses: number;
 	    max_miss: number;
 	    stopped: boolean;
+	    greylisted: number;
 	    reason: string;
 	
 	    static createFrom(source: any = {}) {
@@ -1998,11 +2004,13 @@ export namespace main {
 	        this.enabled = source["enabled"];
 	        this.only = source["only"];
 	        this.target = source["target"];
+	        this.waiting = source["waiting"];
 	        this.calls = source["calls"];
 	        this.max = source["max"];
 	        this.misses = source["misses"];
 	        this.max_miss = source["max_miss"];
 	        this.stopped = source["stopped"];
+	        this.greylisted = source["greylisted"];
 	        this.reason = source["reason"];
 	    }
 	}
@@ -2371,6 +2379,7 @@ export namespace main {
 	    kenwood_baud: number;
 	    kenwood_data_mode: string;
 	    yaesu_low_lines: boolean;
+	    yaesu_rtty_usb: boolean;
 	    kenwood_low_lines: boolean;
 	    icom_port: string;
 	    icom_baud: number;
@@ -2424,6 +2433,7 @@ export namespace main {
 	        this.kenwood_baud = source["kenwood_baud"];
 	        this.kenwood_data_mode = source["kenwood_data_mode"];
 	        this.yaesu_low_lines = source["yaesu_low_lines"];
+	        this.yaesu_rtty_usb = source["yaesu_rtty_usb"];
 	        this.kenwood_low_lines = source["kenwood_low_lines"];
 	        this.icom_port = source["icom_port"];
 	        this.icom_baud = source["icom_baud"];
@@ -3993,6 +4003,363 @@ export namespace main {
 		    return a;
 		}
 	}
+	export class SatTransponder {
+	    label: string;
+	    mode: string;
+	    down_lo: number;
+	    down_hi: number;
+	    up_lo: number;
+	    up_hi: number;
+	    inverting: boolean;
+	    ctcss: number;
+	    linear: boolean;
+	
+	    static createFrom(source: any = {}) {
+	        return new SatTransponder(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.label = source["label"];
+	        this.mode = source["mode"];
+	        this.down_lo = source["down_lo"];
+	        this.down_hi = source["down_hi"];
+	        this.up_lo = source["up_lo"];
+	        this.up_hi = source["up_hi"];
+	        this.inverting = source["inverting"];
+	        this.ctcss = source["ctcss"];
+	        this.linear = source["linear"];
+	    }
+	}
+	export class SatBird {
+	    name: string;
+	    norad: number;
+	    geostationary: boolean;
+	    favorite: boolean;
+	    has_elements: boolean;
+	    element_name: string;
+	    epoch_age_h: number;
+	    transponders: SatTransponder[];
+	
+	    static createFrom(source: any = {}) {
+	        return new SatBird(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.name = source["name"];
+	        this.norad = source["norad"];
+	        this.geostationary = source["geostationary"];
+	        this.favorite = source["favorite"];
+	        this.has_elements = source["has_elements"];
+	        this.element_name = source["element_name"];
+	        this.epoch_age_h = source["epoch_age_h"];
+	        this.transponders = this.convertValues(source["transponders"], SatTransponder);
+	    }
+	
+		convertValues(a: any, classs: any, asMap: boolean = false): any {
+		    if (!a) {
+		        return a;
+		    }
+		    if (a.slice && a.map) {
+		        return (a as any[]).map(elem => this.convertValues(elem, classs));
+		    } else if ("object" === typeof a) {
+		        if (asMap) {
+		            for (const key of Object.keys(a)) {
+		                a[key] = new classs(a[key]);
+		            }
+		            return a;
+		        }
+		        return new classs(a);
+		    }
+		    return a;
+		}
+	}
+	export class SatPassInfo {
+	    name: string;
+	    has_pass: boolean;
+	    in_pass: boolean;
+	    // Go type: time
+	    aos: any;
+	    // Go type: time
+	    los: any;
+	    aos_az: number;
+	    los_az: number;
+	    max_el: number;
+	    max_el_az: number;
+	    // Go type: time
+	    max_el_at: any;
+	    duration_s: number;
+	
+	    static createFrom(source: any = {}) {
+	        return new SatPassInfo(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.name = source["name"];
+	        this.has_pass = source["has_pass"];
+	        this.in_pass = source["in_pass"];
+	        this.aos = this.convertValues(source["aos"], null);
+	        this.los = this.convertValues(source["los"], null);
+	        this.aos_az = source["aos_az"];
+	        this.los_az = source["los_az"];
+	        this.max_el = source["max_el"];
+	        this.max_el_az = source["max_el_az"];
+	        this.max_el_at = this.convertValues(source["max_el_at"], null);
+	        this.duration_s = source["duration_s"];
+	    }
+	
+		convertValues(a: any, classs: any, asMap: boolean = false): any {
+		    if (!a) {
+		        return a;
+		    }
+		    if (a.slice && a.map) {
+		        return (a as any[]).map(elem => this.convertValues(elem, classs));
+		    } else if ("object" === typeof a) {
+		        if (asMap) {
+		            for (const key of Object.keys(a)) {
+		                a[key] = new classs(a[key]);
+		            }
+		            return a;
+		        }
+		        return new classs(a);
+		    }
+		    return a;
+		}
+	}
+	export class SatSettings {
+	    favorites: string[];
+	    min_el: number;
+	    window_h: number;
+	    auto_tle: boolean;
+	    grid: string;
+	    alt_m: number;
+	    rot_on: boolean;
+	    rot_type: string;
+	    rot_pst_port: number;
+	    rot_transport: string;
+	    rot_host: string;
+	    rot_port: number;
+	    rot_com: string;
+	    rot_baud: number;
+	    rot_max_az: number;
+	    rot_min_el: number;
+	    rot_step: number;
+	    rot_park: boolean;
+	
+	    static createFrom(source: any = {}) {
+	        return new SatSettings(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.favorites = source["favorites"];
+	        this.min_el = source["min_el"];
+	        this.window_h = source["window_h"];
+	        this.auto_tle = source["auto_tle"];
+	        this.grid = source["grid"];
+	        this.alt_m = source["alt_m"];
+	        this.rot_on = source["rot_on"];
+	        this.rot_type = source["rot_type"];
+	        this.rot_pst_port = source["rot_pst_port"];
+	        this.rot_transport = source["rot_transport"];
+	        this.rot_host = source["rot_host"];
+	        this.rot_port = source["rot_port"];
+	        this.rot_com = source["rot_com"];
+	        this.rot_baud = source["rot_baud"];
+	        this.rot_max_az = source["rot_max_az"];
+	        this.rot_min_el = source["rot_min_el"];
+	        this.rot_step = source["rot_step"];
+	        this.rot_park = source["rot_park"];
+	    }
+	}
+	export class SatSkyPoint {
+	    // Go type: time
+	    at: any;
+	    az: number;
+	    el: number;
+	
+	    static createFrom(source: any = {}) {
+	        return new SatSkyPoint(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.at = this.convertValues(source["at"], null);
+	        this.az = source["az"];
+	        this.el = source["el"];
+	    }
+	
+		convertValues(a: any, classs: any, asMap: boolean = false): any {
+		    if (!a) {
+		        return a;
+		    }
+		    if (a.slice && a.map) {
+		        return (a as any[]).map(elem => this.convertValues(elem, classs));
+		    } else if ("object" === typeof a) {
+		        if (asMap) {
+		            for (const key of Object.keys(a)) {
+		                a[key] = new classs(a[key]);
+		            }
+		            return a;
+		        }
+		        return new classs(a);
+		    }
+		    return a;
+		}
+	}
+	export class SatTLEInfo {
+	    count: number;
+	    // Go type: time
+	    fetched_at: any;
+	    age_h: number;
+	    stale: boolean;
+	    custom: number;
+	
+	    static createFrom(source: any = {}) {
+	        return new SatTLEInfo(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.count = source["count"];
+	        this.fetched_at = this.convertValues(source["fetched_at"], null);
+	        this.age_h = source["age_h"];
+	        this.stale = source["stale"];
+	        this.custom = source["custom"];
+	    }
+	
+		convertValues(a: any, classs: any, asMap: boolean = false): any {
+		    if (!a) {
+		        return a;
+		    }
+		    if (a.slice && a.map) {
+		        return (a as any[]).map(elem => this.convertValues(elem, classs));
+		    } else if ("object" === typeof a) {
+		        if (asMap) {
+		            for (const key of Object.keys(a)) {
+		                a[key] = new classs(a[key]);
+		            }
+		            return a;
+		        }
+		        return new classs(a);
+		    }
+		    return a;
+		}
+	}
+	export class SatTrackStatus {
+	    on: boolean;
+	    name: string;
+	    transponder: string;
+	    mode: string;
+	    nominal_down: number;
+	    nominal_up: number;
+	    down_hz: number;
+	    up_hz: number;
+	    az: number;
+	    el: number;
+	    visible: boolean;
+	    radio: string;
+	    error: string;
+	    rot_on: boolean;
+	    rot_az: number;
+	    rot_el: number;
+	    rot_live: boolean;
+	
+	    static createFrom(source: any = {}) {
+	        return new SatTrackStatus(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.on = source["on"];
+	        this.name = source["name"];
+	        this.transponder = source["transponder"];
+	        this.mode = source["mode"];
+	        this.nominal_down = source["nominal_down"];
+	        this.nominal_up = source["nominal_up"];
+	        this.down_hz = source["down_hz"];
+	        this.up_hz = source["up_hz"];
+	        this.az = source["az"];
+	        this.el = source["el"];
+	        this.visible = source["visible"];
+	        this.radio = source["radio"];
+	        this.error = source["error"];
+	        this.rot_on = source["rot_on"];
+	        this.rot_az = source["rot_az"];
+	        this.rot_el = source["rot_el"];
+	        this.rot_live = source["rot_live"];
+	    }
+	}
+	
+	export class SatTuning {
+	    name: string;
+	    transponder: string;
+	    mode: string;
+	    nominal_down: number;
+	    nominal_up: number;
+	    down_hz: number;
+	    up_hz: number;
+	    ctcss: number;
+	    inverting: boolean;
+	    az: number;
+	    el: number;
+	    range_km: number;
+	    range_rate: number;
+	    visible: boolean;
+	    // Go type: time
+	    at: any;
+	    lat: number;
+	    lon: number;
+	    alt_km: number;
+	    footprint_km: number;
+	
+	    static createFrom(source: any = {}) {
+	        return new SatTuning(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.name = source["name"];
+	        this.transponder = source["transponder"];
+	        this.mode = source["mode"];
+	        this.nominal_down = source["nominal_down"];
+	        this.nominal_up = source["nominal_up"];
+	        this.down_hz = source["down_hz"];
+	        this.up_hz = source["up_hz"];
+	        this.ctcss = source["ctcss"];
+	        this.inverting = source["inverting"];
+	        this.az = source["az"];
+	        this.el = source["el"];
+	        this.range_km = source["range_km"];
+	        this.range_rate = source["range_rate"];
+	        this.visible = source["visible"];
+	        this.at = this.convertValues(source["at"], null);
+	        this.lat = source["lat"];
+	        this.lon = source["lon"];
+	        this.alt_km = source["alt_km"];
+	        this.footprint_km = source["footprint_km"];
+	    }
+	
+		convertValues(a: any, classs: any, asMap: boolean = false): any {
+		    if (!a) {
+		        return a;
+		    }
+		    if (a.slice && a.map) {
+		        return (a as any[]).map(elem => this.convertValues(elem, classs));
+		    } else if ("object" === typeof a) {
+		        if (asMap) {
+		            for (const key of Object.keys(a)) {
+		                a[key] = new classs(a[key]);
+		            }
+		            return a;
+		        }
+		        return new classs(a);
+		    }
+		    return a;
+		}
+	}
 	export class ScpStatus {
 	    enabled: boolean;
 	    count: number;
@@ -4584,6 +4951,24 @@ export namespace main {
 		    return a;
 		}
 	}
+	export class WsjtHighlightColours {
+	    watchlist: string;
+	    new_dxcc: string;
+	    new_band: string;
+	    worked: string;
+	
+	    static createFrom(source: any = {}) {
+	        return new WsjtHighlightColours(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.watchlist = source["watchlist"];
+	        this.new_dxcc = source["new_dxcc"];
+	        this.new_band = source["new_band"];
+	        this.worked = source["worked"];
+	    }
+	}
 
 }
 
@@ -4962,6 +5347,8 @@ export namespace pskr {
 	    last_err?: string;
 	    broker: string;
 	    bands: string[];
+	    near_km: number;
+	    squares: number;
 	
 	    static createFrom(source: any = {}) {
 	        return new Status(source);
@@ -4975,6 +5362,8 @@ export namespace pskr {
 	        this.last_err = source["last_err"];
 	        this.broker = source["broker"];
 	        this.bands = source["bands"];
+	        this.near_km = source["near_km"];
+	        this.squares = source["squares"];
 	    }
 	
 		convertValues(a: any, classs: any, asMap: boolean = false): any {
@@ -6041,6 +6430,109 @@ export namespace qso {
 
 }
 
+export namespace sat {
+	
+	export class Pass {
+	    name: string;
+	    // Go type: time
+	    aos: any;
+	    // Go type: time
+	    los: any;
+	    aos_az: number;
+	    los_az: number;
+	    max_el: number;
+	    max_el_az: number;
+	    // Go type: time
+	    max_el_at: any;
+	    duration_s: number;
+	
+	    static createFrom(source: any = {}) {
+	        return new Pass(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.name = source["name"];
+	        this.aos = this.convertValues(source["aos"], null);
+	        this.los = this.convertValues(source["los"], null);
+	        this.aos_az = source["aos_az"];
+	        this.los_az = source["los_az"];
+	        this.max_el = source["max_el"];
+	        this.max_el_az = source["max_el_az"];
+	        this.max_el_at = this.convertValues(source["max_el_at"], null);
+	        this.duration_s = source["duration_s"];
+	    }
+	
+		convertValues(a: any, classs: any, asMap: boolean = false): any {
+		    if (!a) {
+		        return a;
+		    }
+		    if (a.slice && a.map) {
+		        return (a as any[]).map(elem => this.convertValues(elem, classs));
+		    } else if ("object" === typeof a) {
+		        if (asMap) {
+		            for (const key of Object.keys(a)) {
+		                a[key] = new classs(a[key]);
+		            }
+		            return a;
+		        }
+		        return new classs(a);
+		    }
+		    return a;
+		}
+	}
+	export class Position {
+	    name: string;
+	    // Go type: time
+	    at: any;
+	    lat: number;
+	    lon: number;
+	    alt_km: number;
+	    footprint_km: number;
+	    az: number;
+	    el: number;
+	    range_km: number;
+	    range_rate: number;
+	
+	    static createFrom(source: any = {}) {
+	        return new Position(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.name = source["name"];
+	        this.at = this.convertValues(source["at"], null);
+	        this.lat = source["lat"];
+	        this.lon = source["lon"];
+	        this.alt_km = source["alt_km"];
+	        this.footprint_km = source["footprint_km"];
+	        this.az = source["az"];
+	        this.el = source["el"];
+	        this.range_km = source["range_km"];
+	        this.range_rate = source["range_rate"];
+	    }
+	
+		convertValues(a: any, classs: any, asMap: boolean = false): any {
+		    if (!a) {
+		        return a;
+		    }
+		    if (a.slice && a.map) {
+		        return (a as any[]).map(elem => this.convertValues(elem, classs));
+		    } else if ("object" === typeof a) {
+		        if (asMap) {
+		            for (const key of Object.keys(a)) {
+		                a[key] = new classs(a[key]);
+		            }
+		            return a;
+		        }
+		        return new classs(a);
+		    }
+		    return a;
+		}
+	}
+
+}
+
 export namespace scp {
 	
 	export class Result {

go.mod

@@ -3,6 +3,7 @@ module hamlog
 go 1.25.0
 
 require (
+	github.com/akhenakh/sgp4 v0.0.0-20260314155803-8ee03fc877eb
 	github.com/braheezy/shine-mp3 v0.1.0
 	github.com/eclipse/paho.mqtt.golang v1.5.1
 	github.com/go-ole/go-ole v1.3.0

go.sum

@@ -1,5 +1,7 @@
 filippo.io/edwards25519 v1.2.0 h1:crnVqOiS4jqYleHd9vaKZ+HKtHfllngJIiOpNpoJsjo=
 filippo.io/edwards25519 v1.2.0/go.mod h1:xzAOLCNug/yB62zG1bQ8uziwrIqIuxhctzJT18Q77mc=
+github.com/akhenakh/sgp4 v0.0.0-20260314155803-8ee03fc877eb h1:d9tZ7tJrssgs7Va9j8iu9vl7BlK2rmIs5RiOU7WQJrs=
+github.com/akhenakh/sgp4 v0.0.0-20260314155803-8ee03fc877eb/go.mod h1:JfAepWD223Cel6uRpzYdip/xijWZ2FT457YFLWy8Md4=
 github.com/bep/debounce v1.2.1 h1:v67fRdBA9UQu2NhLFXrSg0Brw7CexQekrBwDMM8bzeY=
 github.com/bep/debounce v1.2.1/go.mod h1:H8yggRPQKLUhUoqrJC1bO2xNya7vanpDl7xR3ISbCJ0=
 github.com/braheezy/shine-mp3 v0.1.0 h1:N2wZhv6ipCFduTSftaPNdDgZ5xFmQAPvB7JcqA4sSi8=

internal/adif/export.go

@@ -120,12 +120,36 @@ func (e *Exporter) writeDoc(ctx context.Context, w io.Writer, iter iterator) (in
 func SingleRecordADIF(q qso.QSO) string {
 	var b strings.Builder
 	bw := bufio.NewWriter(&b)
-	// Uploads target other services — keep it standard (no app-specific tags).
+	// Uploads target other services — keep it standard (no app-specific tags),
+	// and say nothing about the receive side when there is nothing to say: in
+	// ADIF an absent BAND_RX/FREQ_RX means "same as transmit", and a logger
+	// given both draws both. Wavelog reads a simplex FT8 contact uploaded with
+	// BAND_RX filled in as split and shows it as "17m/17m".
 	writeRecord(bw, q, false, nil)
 	bw.Flush()
 	return b.String()
 }
 
+// ForwardRecordADIF is the record sent to ANOTHER LOGGER on the UDP link.
+//
+// The receive side is written even when it repeats the transmit side, which is
+// the opposite of the upload rule above and is deliberate: Log4OM reads BAND_RX
+// and found nothing there for contacts logged by a path that left it blank. A
+// logger on the same desk is being handed a copy of our record, not published
+// to a service that will draw conclusions from every tag present.
+func ForwardRecordADIF(q qso.QSO) string {
+	var b strings.Builder
+	bw := bufio.NewWriter(&b)
+	writeRecord(bw, q, false, nil, keepRX)
+	bw.Flush()
+	return b.String()
+}
+
+// keepRX marks a record whose receive side must be written out in full.
+type rxMode int
+
+const keepRX rxMode = 1
+
 // FullRecordADIF serialises one QSO LOSSLESSLY — including the APP_* extras —
 // so it can be written out and read back with nothing dropped. Used by the
 // offline queue: a QSO parked in the safety file must come back identical
@@ -161,7 +185,18 @@ func BatchRecordsADIF(records []string) string {
 // Empty fields are omitted. MODE/SUBMODE are massaged so a "promoted"
 // mode (e.g. FT4 stored without a parent) is exported as the canonical
 // pair MODE=MFSK SUBMODE=FT4 — round-trips cleanly with strict loggers.
-func writeRecord(bw *bufio.Writer, q qso.QSO, includeApp bool, allow map[string]bool) {
+func writeRecord(bw *bufio.Writer, q qso.QSO, includeApp bool, allow map[string]bool, rx ...rxMode) {
+	// The receive side, unless it merely repeats the transmit side. See
+	// SingleRecordADIF and ForwardRecordADIF.
+	bandRX, freqRX := q.BandRX, q.FreqRXHz
+	if len(rx) == 0 || rx[0] != keepRX {
+		if strings.EqualFold(strings.TrimSpace(bandRX), strings.TrimSpace(q.Band)) {
+			bandRX = ""
+		}
+		if freqRX != nil && q.FreqHz != nil && *freqRX == *q.FreqHz {
+			freqRX = nil
+		}
+	}
 	// allow == nil → write every promoted field (standard/full behaviour).
 	// Otherwise a promoted tag is written only when it's in the chosen set.
 	// w/wi/wf wrap the raw writers with that gate so the ~150 field lines below
@@ -194,7 +229,7 @@ func writeRecord(bw *bufio.Writer, q qso.QSO, includeApp bool, allow map[string]
 		w("TIME_OFF", q.QSODateOff.UTC().Format("150405"))
 	}
 	w("BAND", q.Band)
-	w("BAND_RX", q.BandRX)
+	w("BAND_RX", bandRX)
 
 	mode, submode := modeForExport(q.Mode, q.Submode)
 	w("MODE", mode)
@@ -203,8 +238,8 @@ func writeRecord(bw *bufio.Writer, q qso.QSO, includeApp bool, allow map[string]
 	if q.FreqHz != nil && *q.FreqHz > 0 {
 		w("FREQ", strconv.FormatFloat(float64(*q.FreqHz)/1_000_000, 'f', 6, 64))
 	}
-	if q.FreqRXHz != nil && *q.FreqRXHz > 0 {
+	if freqRX != nil && *freqRX > 0 {
-		w("FREQ_RX", strconv.FormatFloat(float64(*q.FreqRXHz)/1_000_000, 'f', 6, 64))
+		w("FREQ_RX", strconv.FormatFloat(float64(*freqRX)/1_000_000, 'f', 6, 64))
 	}
 
 	w("RST_SENT", q.RSTSent)
@@ -372,12 +407,41 @@ func writeRecord(bw *bufio.Writer, q qso.QSO, includeApp bool, allow map[string]
 // length is the byte count (ADIF spec), which matches len(v) in Go since v is
 // already a UTF-8 byte string.
 func writeField(bw *bufio.Writer, tag, v string) {
+	v = oneLine(v)
 	if v == "" {
 		return
 	}
 	fmt.Fprintf(bw, "<%s:%d>%s ", tag, len(v), v)
 }
 
+// oneLine flattens a value onto a single line.
+//
+// ADIF counts bytes, so a value carrying line breaks is still read correctly —
+// and it turns the file into something nobody can read. ADDRESS is a multi-line
+// field by the standard, and callbooks and other loggers fill it that way: a
+// value of "Kabul" followed by four blank lines and "Afghanistan" came out of
+// OpsLog as one record spread down a dozen lines, with the next record
+// apparently starting in the middle of the page.
+//
+// The breaks are dropped rather than escaped: the parts are trimmed and joined
+// with a comma, which is how an address reads on one line anyway, and empty
+// fragments go. The length prefix is computed after this, so the record stays
+// exact.
+func oneLine(v string) string {
+	if !strings.ContainsAny(v, "\r\n\t") {
+		return v
+	}
+	parts := strings.FieldsFunc(v, func(r rune) bool { return r == '\r' || r == '\n' })
+	out := make([]string, 0, len(parts))
+	for _, part := range parts {
+		part = strings.TrimSpace(strings.ReplaceAll(part, "\t", " "))
+		if part != "" {
+			out = append(out, part)
+		}
+	}
+	return strings.Join(out, ", ")
+}
+
 func writeIntPtr(bw *bufio.Writer, tag string, p *int) {
 	if p == nil {
 		return

internal/adif/oneline_test.go

@@ -0,0 +1,46 @@
+package adif
+
+import (
+	"bufio"
+	"strings"
+	"testing"
+
+	"hamlog/internal/qso"
+)
+
+// An exported record has to fit on its own line. ADDRESS is a multi-line field
+// by the standard and callbooks fill it that way, so an OpsLog export was one
+// record spread down a dozen lines with the next apparently starting in the
+// middle of the page.
+func TestAMultiLineValueIsWrittenOnOneLine(t *testing.T) {
+	var b strings.Builder
+	bw := bufio.NewWriter(&b)
+	writeField(bw, "ADDRESS", "Kabul\r\n\r\n\r\n\r\nAfghanistan\r\n")
+	bw.Flush()
+
+	got := b.String()
+	if strings.ContainsAny(got, "\r\n") {
+		t.Fatalf("the record still breaks across lines: %q", got)
+	}
+	if want := "<ADDRESS:18>Kabul, Afghanistan "; got != want {
+		t.Errorf("got %q, want %q", got, want)
+	}
+}
+
+// And the whole record, the way an operator reads the file.
+func TestARecordIsOneLine(t *testing.T) {
+	hz := int64(28555000)
+	rec := SingleRecordADIF(qso.QSO{
+		Callsign: "T6T", Band: "10m", Mode: "SSB", FreqHz: &hz,
+		Address: "Kabul\n\n\nAfghanistan", Name: "Shuravi\t(Vyacheslav)",
+	})
+	if n := strings.Count(strings.TrimRight(rec, "\r\n"), "\n"); n != 0 {
+		t.Errorf("the record spans %d extra lines:\n%s", n, rec)
+	}
+	if !strings.Contains(rec, "Kabul, Afghanistan") {
+		t.Errorf("the address lost its parts:\n%s", rec)
+	}
+	if !strings.Contains(rec, "Shuravi (Vyacheslav)") {
+		t.Errorf("a tab was left in the value:\n%s", rec)
+	}
+}

internal/audio/manager.go

@@ -15,6 +15,12 @@ type Manager struct {
 	mu      sync.Mutex
 	recStop chan struct{}
 	recDone chan recResult
+	// Said once each: "the audio is reaching the speakers" and "it is arriving
+	// with nobody listening". Both are answers to the same evening — sound
+	// switched on, nothing out of the speakers — and neither is worth a line per
+	// packet at fifty packets a second.
+	gotAudioOnce sync.Once
+	noSinkOnce   sync.Once
 	// monGainPct scales what the RX monitor plays, 100 = as captured.
 	//
 	// The "From radio" slider used to reach only the QSO recorder, so an
@@ -224,6 +230,10 @@ func (m *Manager) StartMonitor(inputDev, outputDev string) error {
 	return m.startMonitor(inputDev, outputDev, true)
 }
 
+// Logf receives this package's diagnostic lines. Set to applog.Printf by the
+// app; a no-op in tests and for anything that vendors the package alone.
+var Logf = func(string, ...any) {}
+
 // StartMonitorSink starts ONLY the render side (no USB capture) so an external
 // producer — the network 50003 stream — can feed decoded RX PCM via
 // PushMonitorAudio. Same output path as StartMonitor, minus the capture goroutine.
@@ -255,8 +265,17 @@ func (m *Manager) startMonitor(inputDev, outputDev string, capture bool) error {
 		}()
 	}
 	// Consumer: render the ring to the output device at the internal 16 kHz mono.
+	//
+	// The error was thrown away, and that is the whole of "I turned the sound on
+	// and nothing comes out": a Listening device that has been unplugged, renamed
+	// by Windows or cannot open at 16 kHz fails here, silently, while everything
+	// upstream reports success — the stream is up, the packets arrive, the
+	// monitor says it started. Said out loud, the operator knows to look at the
+	// device rather than at the radio.
 	go func() {
-		_ = renderStream(outputDev, sampleRate, channels, bitsPerSample, stop, ring)
+		if err := renderStream(outputDev, sampleRate, channels, bitsPerSample, stop, ring); err != nil {
+			Logf("audio: the Listening device could not be opened (%q): %v", outputDev, err)
+		}
 	}()
 	m.notify()
 	return nil
@@ -321,9 +340,19 @@ func (m *Manager) PushMonitorAudio(pcm []byte) {
 	m.mu.Lock()
 	ring := m.monRing
 	m.mu.Unlock()
-	if ring != nil {
+	if ring == nil {
-		ring.Push(pcm)
+		// Nothing is listening: the stream is feeding the recorder and the voice
+		// keyer only. Said ONCE, because the alternative — silence in the log for
+		// silence in the speakers — is what makes this take an evening to find.
+		m.noSinkOnce.Do(func() {
+			Logf("audio: network RX audio is arriving but no monitor is running — the speakers are off (Listening)")
+		})
+		return
 	}
+	m.gotAudioOnce.Do(func() {
+		Logf("audio: network RX audio reaching the Listening device (%d-byte chunks)", len(pcm))
+	})
+	ring.Push(pcm)
 }
 
 // ---- TX audio passthrough (Phase 3: live mic → rig over USB) --------------

internal/autocall/autocall.go

@@ -47,6 +47,7 @@ package autocall
 import (
 	"fmt"
 	"regexp"
+	"sort"
 	"strings"
 	"time"
 	"unicode"
@@ -57,10 +58,20 @@ type Need int
 
 const (
 	NeedNone Need = iota
-	NeedSlot      // entity worked on this band and in this mode, never together
+	// NeedExtra: the ENTITY has nothing left to give on this band and mode, but
-	NeedMode      // entity never worked in this mode
+	// the station carries something else that has never been worked — a WPX
-	NeedBand      // entity never worked on this band
+	// prefix, a square, a US county or state, a park. Those are what the cluster
-	NeedDXCC      // entity never worked at all
+	// calls the orthogonal markers, and an operator who ticked them in the chase
+	// settings is hunting them: leaving them at nothing-needed meant auto-call
+	// watched a never-worked prefix call CQ and did nothing.
+	//
+	// The lowest rung, deliberately. It is worth calling when nothing better is
+	// on the air, and never worth leaving a new band for.
+	NeedExtra
+	NeedSlot // entity worked on this band and in this mode, never together
+	NeedMode // entity never worked in this mode
+	NeedBand // entity never worked on this band
+	NeedDXCC // entity never worked at all
 )
 
 func (n Need) String() string {
@@ -73,6 +84,8 @@ func (n Need) String() string {
 		return "mode"
 	case NeedSlot:
 		return "slot"
+	case NeedExtra:
+		return "extra"
 	}
 	return "-"
 }
@@ -109,6 +122,17 @@ type Candidate struct {
 	Decode
 	Need    Need
 	Watched bool
+	// Extra names what NeedExtra is about — "prefix", "county", "square" — so the
+	// decision line says why the station was worth a call. Empty otherwise.
+	Extra string
+	// Unconfirmed says the need above exists ONLY because a contact was never
+	// confirmed — the operator hunts "new + unconfirmed", the band is in the log
+	// and the QSL is not. A real need outranks it; see rank.
+	Unconfirmed bool
+	// Hidden is true when the decodes panel's own filters are keeping this
+	// station off the screen. The operator's filters are the control: what is
+	// not shown is not called — see Settings.OnScreenOnly.
+	Hidden bool
 	// Worked is "already in the log on this band AND mode". Nothing is gained
 	// by calling it again — and while chasing confirmations it is the trap that
 	// makes the same station be called all evening, because an unconfirmed QSO
@@ -145,20 +169,39 @@ type Settings struct {
 	// Misses is how many of the station's OWN transmit periods may pass with no
 	// decode of it before it is given up on.
 	Misses int
-	// Rest is how long a released callsign waits before it can be picked again,
+	// RestPeriods is how many of the station's OWN OVERS a released callsign sits
-	// and MaxRounds how many such series it gets before being parked for the
+	// out before it can be picked again, and MaxRounds how many such series it
-	// session.
+	// gets before being parked for the session.
-	Rest      time.Duration
+	//
-	MaxRounds int
+	// Counted in overs, not in minutes, because that is the unit the thing is
+	// happening in: an operator who has called a DX seven times without an answer
+	// listens through one of its transmissions and calls again if it is still
+	// there. Two minutes is four overs on FT8 — the DX has worked four other
+	// callers by then, and half the time it has gone.
+	RestPeriods int
+	MaxRounds   int
 	// MaxHold is the wall-clock backstop on one target.
 	MaxHold time.Duration
+	// OnScreenOnly restricts the calling to what the decodes panel is actually
+	// showing.
+	//
+	// The filters an operator sets while reading the band — CQ only, LoTW only,
+	// the new-category chips, continents, a minimum report, the search box — now
+	// bind the transmitter too: a station filtered off the screen is not called.
+	// It replaces a separate "LoTW users only" setting, which said one thing
+	// while the chip above the list said another.
+	//
+	// The panel publishes what it is showing; when it is publishing nothing —
+	// the tab was never opened this session — there is nothing to restrict and
+	// the ladder decides alone.
+	OnScreenOnly bool
 }
 
 // Defaults are what the operator gets before touching anything.
 func Defaults() Settings {
 	return Settings{
 		Attempts: 7, WatchedAttempts: 15, Misses: 3,
-		Rest: 2 * time.Minute, MaxRounds: 3, MaxHold: 4 * time.Minute,
+		RestPeriods: 1, MaxRounds: 3, MaxHold: 4 * time.Minute,
 	}
 }
 
@@ -173,8 +216,8 @@ func (s Settings) withDefaults() Settings {
 	if s.Misses <= 0 {
 		s.Misses = d.Misses
 	}
-	if s.Rest <= 0 {
+	if s.RestPeriods <= 0 {
-		s.Rest = d.Rest
+		s.RestPeriods = d.RestPeriods
 	}
 	if s.MaxRounds <= 0 {
 		s.MaxRounds = d.MaxRounds
@@ -201,6 +244,19 @@ type Action struct {
 	Kind   ActionKind
 	Decode Decode
 	Reason string
+	// Soft asks the decoder to finish the over it is sending and only then stop
+	// transmitting, rather than cutting the carrier where it stands.
+	//
+	// It matters for exactly one brake. The attempts cap trips WHILE the seventh
+	// call is going out — that is what counts it — so a hard halt cuts that
+	// transmission a second in, which on the air is a half-sent call and on the
+	// screen is an auto-call that "starts and stops". Nothing is saved by
+	// stopping it: the frame is already half gone.
+	//
+	// Every other brake fires on a station that is not being transmitted to (it
+	// has vanished, or the clock ran out between overs), and there a hard halt
+	// is right: it is the one that also clears the decoder's own auto-sequence.
+	Soft bool
 }
 
 // Engine holds the state between periods. Not safe for concurrent use; the
@@ -214,6 +270,19 @@ type Engine struct {
 	// targetInst is the receiver the target was picked on, so the brakes are
 	// counted against ITS periods and its transmissions.
 	targetInst string
+	// now is the time of the last period seen. Every deadline in here is measured
+	// against it rather than against the wall clock: the periods ARE the clock —
+	// they arrive stamped — and mixing the two gave a rest that expired against
+	// one reading and a hold that ran against another.
+	now time.Time
+	// waiting is the station the engine WOULD call and cannot, because it is in
+	// a QSO with somebody else. Kept so the toolbar can say so: an auto-call
+	// deliberately holding its fire looks exactly like one with nothing to do,
+	// and from the outside there was no way to tell them apart.
+	waiting string
+	// answered says the target has replied to us at least once — the exchange is
+	// under way and nothing may take its place.
+	answered bool
 	// heldSince is when this station BECAME the target, and is never refreshed
 	// while it stays one. It was, and that quietly disabled the clock backstop:
 	// a station decoded every period for ever kept pushing its own deadline
@@ -221,6 +290,12 @@ type Engine struct {
 	heldSince time.Time
 	attempts  int
 	misses    int
+	// seenKey is the period in which the target was last DECODED. A period is
+	// judged more than once — the decodes arrive in bursts and stragglers follow —
+	// and a later judgement holds a partial view of it, not evidence of absence:
+	// the station answered in that very period and the counter still read one
+	// miss out of three.
+	seenKey   string
 	lastMiss  string // period already counted, so one period counts once
 	txSlot    int    // which of the two slots the target transmits in; -1 unknown
 	stopped   bool   // an explicit "Only" target gave up: needs a restart
@@ -230,6 +305,20 @@ type Engine struct {
 	// how many series it has already had this session.
 	rested map[string]time.Time
 	rounds map[string]int
+	// trace, when set, receives one line per period: what was on the air, why
+	// each station was refused, and what was decided. Off unless the operator
+	// asks for it — a line per period is a line every fifteen seconds, all
+	// night.
+	trace func(string, ...any)
+	// greyed is every station the OPERATOR stopped a call to.
+	//
+	// Halt is a verdict, not a pause: the operator watched the engine call this
+	// station and said no. Answering that by releasing the target and picking
+	// the same station again the next period — which is what clearing the state
+	// did — is the machine overruling them, and it is what Halt exists to
+	// prevent. It holds until auto-call is switched off and on again, which is
+	// the one gesture that plainly means "start over".
+	greyed map[string]bool
 	// done is every station the exchange was completed with this session.
 	//
 	// The log is the authority on what is worked, and it is SLOW: the QSO is
@@ -242,7 +331,8 @@ type Engine struct {
 
 func New(s Settings) *Engine {
 	return &Engine{set: s.withDefaults(), txSlot: -1,
-		rested: map[string]time.Time{}, rounds: map[string]int{}, done: map[string]bool{}}
+		rested: map[string]time.Time{}, rounds: map[string]int{}, done: map[string]bool{},
+		greyed: map[string]bool{}}
 }
 
 // SetSettings swaps the settings in place. A target already being called is
@@ -261,7 +351,9 @@ func (e *Engine) Target() string {
 // Status is what the panel shows: who, how far into the brakes, and whether
 // the engine has given up and is waiting for the operator.
 type Status struct {
-	Target    string `json:"target"`
+	Target string `json:"target"`
+	// Waiting: wanted, decoded, and in a QSO with somebody else.
+	Waiting   string `json:"waiting"`
 	Attempts  int    `json:"attempts"`
 	Max       int    `json:"max"`
 	Misses    int    `json:"misses"`
@@ -271,7 +363,8 @@ type Status struct {
 }
 
 func (e *Engine) Status() Status {
-	st := Status{Misses: e.misses, MaxMiss: e.set.Misses, Stopped: e.stopped, StoppedOn: e.stoppedOn}
+	st := Status{Misses: e.misses, MaxMiss: e.set.Misses, Stopped: e.stopped, StoppedOn: e.stoppedOn,
+		Waiting: e.waiting}
 	if e.target != nil {
 		st.Target = e.target.Call
 		st.Attempts = e.attempts
@@ -287,9 +380,38 @@ func (e *Engine) Reset() {
 	e.targetInst = ""
 	e.lastMiss, e.stopped, e.stoppedOn = "", false, ""
 	e.rested, e.rounds = map[string]time.Time{}, map[string]int{}
-	e.done = map[string]bool{}
+	e.done, e.greyed = map[string]bool{}, map[string]bool{}
 }
 
+// Halt is the operator stopping the call in progress.
+//
+// The station is set aside for the session — see greyed — and the target is
+// released. Returns the callsign so the caller can say what happened; empty
+// when nothing was being called, where Halt is just a halt.
+func (e *Engine) Halt() string {
+	if e.target == nil {
+		return ""
+	}
+	call := strings.ToUpper(e.target.Call)
+	e.greyed[call] = true
+	e.release(call, true)
+	// Not counted as a series: the brakes are about a station that will not
+	// answer, and this one was never given the chance. It will not be called
+	// again anyway.
+	e.rounds[call]--
+	if e.rounds[call] < 0 {
+		e.rounds[call] = 0
+	}
+	delete(e.rested, call)
+	return call
+}
+
+// SetTrace turns the per-period trace on (a non-nil function) or off (nil).
+func (e *Engine) SetTrace(fn func(string, ...any)) { e.trace = fn }
+
+// Greylisted reports how many stations the operator has stopped this session.
+func (e *Engine) Greylisted() int { return len(e.greyed) }
+
 // Take hands the operator's own click to the engine: the station they picked
 // becomes the target, with the counters restarted. Everything after it — the
 // brakes, the hand-off at the end of the QSO — then applies as usual.
@@ -309,23 +431,47 @@ func (e *Engine) maxAttempts(c Candidate) int {
 	return e.set.Attempts
 }
 
-// rank is the ladder, as one number. Watched lifts a station by one rung, and
+// rank is the ladder, as one number.
-// a watched station with nothing needed sits at the bottom rather than being
-// ineligible: the operator asked for that callsign.
 //
-//	9 WL DXCC   8 DXCC   7 WL band   6 band
+// A WATCHED callsign outranks everything that is not watched. That is what a
-//	5 WL mode   4 mode   3 WL slot   2 slot   1 watched, nothing needed
+// watch list means: the operator has named this station, and the machine's
-//	0 nothing to call for
+// opinion of what the log needs does not get to overrule it.
+//
+// It did before, one rung at a time — watched new band above plain new band,
+// but a watched station with nothing needed at the very bottom. On a band full
+// of stations that ARE needed, that station was never reached: a watched
+// DXpedition sat there all evening while the engine worked Brazilians. The
+// list is not a tie-breaker, it is the answer.
+//
+// Below that line the old order stands, and for the same reasons: what is
+// needed first, and a real need above one that exists only because a QSL never
+// came — an unconfirmed new BAND still outranks a real new SLOT, because the
+// band is the bigger prize whatever state it is in.
+//
+//	100+  every watched callsign, ordered among themselves by the same rule
+//	 18   DXCC        16 DXCC unconf
+//	 14   band        12 band unconf
+//	 10   mode         8 mode unconf
+//	  6   slot         4 slot unconf
+//	  0   nothing to call for
+//
+// needLabel is what the candidate is worth, in words: the rung, or the name of
+// the orthogonal marker when that is the whole reason for the call.
+func needLabel(c Candidate) string {
+	if c.Need == NeedExtra && c.Extra != "" {
+		return "new " + c.Extra
+	}
+	return c.Need.String()
+}
+
 func rank(c Candidate) int {
-	if c.Need == NeedNone {
+	r := int(c.Need) * 4 // slot 4, mode 8, band 12, DXCC 16
-		if c.Watched {
+	if c.Need != NeedNone && !c.Unconfirmed {
-			return 1
+		r += 2
-		}
-		return 0
 	}
-	r := int(c.Need) * 2 // slot 2, mode 4, band 6, DXCC 8
 	if c.Watched {
-		r++
+		// Above every unwatched station, whatever the log makes of either.
+		return 100 + r
 	}
 	return r
 }
@@ -371,6 +517,40 @@ func isGrid(tok string) bool {
 	return gridRe.MatchString(tok)
 }
 
+// messages splits a decoded line into the messages it carries.
+//
+// One transmission can hold two. MSHV answers several callers at once — its
+// own multi-answer transmission, not SuperFox — and the decoder prints them as
+// one line:
+//
+//	YV5ALI RR73; F4BPO <HK0/PY8WW> -08
+//
+// The second half is a report to F4BPO. Reading only the start of the line, the
+// engine saw a station working YV5ALI, decided it could not answer us, and
+// dropped the target — at the exact moment the DX was answering. Each segment
+// is its own message and names its own recipient first.
+func messages(msg string) []string {
+	return strings.Split(strings.ToUpper(strings.TrimSpace(msg)), ";")
+}
+
+// bare strips the angle brackets a decoder puts round a compressed callsign,
+// and upper-cases what is left. "<HP/WE9G>" and "HP/WE9G" are one station, and
+// every comparison in here has to agree about that.
+func bare(call string) string {
+	return strings.Trim(strings.ToUpper(strings.TrimSpace(call)), "<>")
+}
+
+// addressedTo reports whether one message segment is addressed to a callsign.
+// The recipient is the first token, sometimes bracketed when the sender has
+// compressed a non-standard call.
+func addressedTo(part, call string) bool {
+	toks := strings.Fields(part)
+	if len(toks) == 0 || call == "" {
+		return false
+	}
+	return bare(toks[0]) == bare(call)
+}
+
 // callable reports whether a station can be answered RIGHT NOW.
 //
 // A station in mid-exchange is committed to somebody else: it will not answer,
@@ -383,16 +563,22 @@ func callable(c Candidate, myCall string) bool {
 	if c.CQ {
 		return true
 	}
-	toks := strings.Fields(strings.ToUpper(strings.TrimSpace(c.Msg)))
+	parts := messages(c.Msg)
-	if len(toks) == 0 {
+	if len(parts) == 0 {
 		return false // nothing to read: assume it is busy rather than call blind
 	}
-	if myCall != "" && toks[0] == strings.ToUpper(myCall) {
+	for _, part := range parts {
-		return true // it is calling us
+		toks := strings.Fields(part)
-	}
+		if len(toks) == 0 {
-	switch toks[len(toks)-1] {
+			continue
-	case "RR73", "RRR", "73":
+		}
-		return true
+		if addressedTo(part, myCall) {
+			return true // it is calling us
+		}
+		switch toks[len(toks)-1] {
+		case "RR73", "RRR", "73":
+			return true
+		}
 	}
 	return false
 }
@@ -403,8 +589,12 @@ func callingUs(c Candidate, myCall string) bool {
 	if myCall == "" || c.CQ {
 		return false
 	}
-	toks := strings.Fields(strings.ToUpper(strings.TrimSpace(c.Msg)))
+	for _, part := range messages(c.Msg) {
-	return len(toks) > 0 && toks[0] == strings.ToUpper(myCall)
+		if addressedTo(part, myCall) {
+			return true
+		}
+	}
+	return false
 }
 
 // finished reports that the exchange with this station is over: it sent us the
@@ -420,13 +610,17 @@ func finished(decodes []Candidate, call, myCall string) bool {
 		if strings.ToUpper(c.Call) != call {
 			continue
 		}
-		toks := strings.Fields(strings.ToUpper(strings.TrimSpace(c.Msg)))
+		// Every segment: a fox says goodbye to one caller and hello to the next
-		if len(toks) < 2 || toks[0] != me {
+		// in the same transmission.
-			continue
+		for _, part := range messages(c.Msg) {
-		}
+			toks := strings.Fields(part)
-		switch toks[len(toks)-1] {
+			if len(toks) < 2 || !addressedTo(part, me) {
-		case "RR73", "RRR", "73":
+				continue
-			return true
+			}
+			switch toks[len(toks)-1] {
+			case "RR73", "RRR", "73":
+				return true
+			}
 		}
 	}
 	return false
@@ -466,6 +660,9 @@ func (e *Engine) OnPeriod(p Period) Action {
 	if !e.set.Enabled {
 		return Action{}
 	}
+	if !p.At.IsZero() {
+		e.now = p.At
+	}
 	// ONE station at a time, on the receiver it is being called on.
 	//
 	// This is the guarantee with two decoders running: while a target is held,
@@ -482,16 +679,38 @@ func (e *Engine) OnPeriod(p Period) Action {
 		t := *e.target
 		tc := strings.ToUpper(t.Call)
 
+		// HAS IT ANSWERED US? Settled first, before any of the checks below can
+		// decide to leave it.
+		//
+		// The reply lands in the same period the ladder is re-read, and that
+		// period used to be judged with answered still false — so a station
+		// answering our CQ-call was dropped for a better-ranked one in the exact
+		// period it came back to us. Watched from the shack: mid-exchange with
+		// V31MA, report sent, and OpsLog switched to a station calling on the
+		// other side of the screen. A QSO in progress outranks the ladder.
+		if seen := bestOf(p.Decodes, tc); seen != nil && callingUs(*seen, p.MyCall) {
+			e.answered = true
+		}
+
 		// The exchange is over — either the station sent us its last frame, or
 		// the log now holds it. Hand straight on to the next station in the same
 		// period rather than waiting for the next one: the slot is the resource.
 		if finished(p.Decodes, tc, p.MyCall) || workedNow(p.Decodes, tc) {
 			e.release(tc, false)
-			// Straight on to the next station, list or no list: pick() is what
+			// AND NOTHING ELSE THIS PERIOD. The next station is picked on the next
-			// knows the chase list, and with one on it the answer is simply the
+			// one, fifteen seconds later, and it is still there.
-			// next callsign there — a list of two DXpeditions must not stop
+			//
-			// after the first.
+			// His RR73 is decoded while we are between overs, so the decoder is
-			return e.pick(p, fmt.Sprintf("QSO with %s finished", tc))
+			// about to send our own 73 in the slot that is opening. Answering
+			// somebody else now takes that slot: the reply switches the DX call
+			// mid-sequence and the 73 never goes out whole — an operator watching
+			// saw both transmissions in one period, and the station at the other
+			// end never got the frame that closes the contact.
+			//
+			// This used to hand straight on "because the slot is the resource".
+			// The slot is worth less than the QSO it would spoil.
+			return Action{Kind: DoNothing,
+				Reason: fmt.Sprintf("QSO with %s finished — leaving the next slot for our 73", tc)}
 		}
 
 		// The clock backstop. Every counter below depends on decodes arriving in
@@ -501,22 +720,82 @@ func (e *Engine) OnPeriod(p Period) Action {
 			return Action{Kind: DoHalt, Reason: fmt.Sprintf("%s held for %s with nothing to show for it", tc, e.set.MaxHold)}
 		}
 
+		if e.trace != nil {
+			e.trace("period %s holding %s calls=%d/%d misses=%d/%d%s",
+				p.Key, tc, e.attempts, e.maxAttempts(t), e.misses, e.set.Misses,
+				map[bool]string{true: " (transmitting)", false: ""}[p.TX.Transmitting])
+		}
+		// SOMETHING BETTER HAS COME ON THE AIR.
+		//
+		// A target is held until it answers or a brake releases it, and that is
+		// right once an exchange has started — but before it has, holding means
+		// spending the next two minutes on a new slot while the watched
+		// DXpedition calls CQ three rows above it. Which is what an operator
+		// sees: the first CQ ignored, then the second one answered because the
+		// other call had run its course.
+		//
+		// So while the target has NOT answered us, a strictly better station
+		// takes its place. "Better" is the ladder, which does not flicker: a
+		// station's need does not change from period to period, so this cannot
+		// oscillate between two of them — only a genuinely higher rung wins.
+		if !e.answered {
+			if a, ok := e.preempt(p); ok {
+				return a
+			}
+		}
 		if seen := bestOf(p.Decodes, tc); seen != nil {
 			// The decode is refreshed so a reply carries a current timestamp; the
 			// hold clock is NOT — see heldSince.
 			e.target = seen
-			e.misses, e.lastMiss = 0, ""
+			e.misses, e.lastMiss, e.seenKey = 0, "", p.Key
 			e.txSlot = slotOf(p.At, periodSecs(p, *seen))
 			// In QSO: the decoder is sequencing the exchange on its own and the
 			// attempt counter has done its job. Interrupting it with another
 			// reply is how two transmissions land in one slot.
 			if callingUs(*seen, p.MyCall) {
 				e.attempts = 0
+				e.answered = true
+				// The exchange is under way, so the hold clock starts again from
+				// here: it exists to end a call nobody answers, and this one has
+				// been answered. Without this a QSO that began at the end of a
+				// long wait could be halted mid-exchange by a backstop that was
+				// counting the wait.
+				e.heldSince = p.At
+				return Action{}
+			}
+			// IT IS WORKING SOMEBODY ELSE, AND WE GO ON CALLING.
+			//
+			// This used to stop, on the reasoning that a station in a QSO cannot
+			// hear the call. That is how a pileup is NOT worked: a DX with a
+			// queue answers one caller per period, and the only way to be the
+			// next one is to keep calling while it works the others. An operator
+			// watched exactly that — D44TWO finishing a contact, the call
+			// started, the DX coming back to somebody else, and the engine
+			// giving up on a station that was about to be free.
+			//
+			// The effort is already bounded: seven calls, fifteen for a watched
+			// station, and the miss counter for one that goes off the air. And
+			// nothing is wasted while it is busy — a better station may still
+			// take the slot, because it has not answered us (see preempt).
+			//
+			// The callable test still governs the CHOICE of a target, where it
+			// belongs: a reply to a decode in mid-exchange is one WSJT-X and
+			// JTDX may refuse outright.
+			if e.trace != nil && !callable(*seen, p.MyCall) {
+				e.trace("period %s %s is working %s — carrying on calling", p.Key, tc, addressee(seen.Msg))
 			}
 			return Action{}
 		}
 
-		// Absent. Only its OWN transmit periods count against it.
+		// Absent. Only its OWN transmit periods count against it — and never one
+		// of ours: our transmission is the reason it is not there.
+		if p.TX.Transmitting {
+			return Action{}
+		}
+		// Nor a period it was already decoded in: see seenKey.
+		if e.seenKey == p.Key {
+			return Action{}
+		}
 		if e.txSlot >= 0 && slotOf(p.At, periodSecs(p, t)) != e.txSlot {
 			return Action{}
 		}
@@ -536,65 +815,132 @@ func (e *Engine) OnPeriod(p Period) Action {
 	if e.stopped {
 		return Action{} // an explicit target gave up; the operator restarts it
 	}
-	// Never start a call over a transmission in progress: the reply would land
-	// in a slot the decoder is already using.
-	if p.TX.Transmitting {
-		return Action{}
-	}
 	return e.pick(p, "")
 }
 
 // pick chooses the best station on the air and answers it.
+//
+// NEVER over a transmission in progress, and that guard belongs HERE because
+// there are two ways in. A reply is not a request the decoder queues: WSJT-X
+// acts on it at once, drops the exchange it is in and starts calling the new
+// station — so a reply sent while our own 73 was going out cut that 73 about a
+// second in, and the station we had just worked never got it. Reported from the
+// air, and the sequence is exactly this one: his RRR is decoded, the QSO reads
+// as finished, and the next station is picked in the same instant.
+//
+// The slot is worth having, but not at the price of the QSO in hand. The next
+// period is a fifteen-second wait and everything worth calling is still there.
 func (e *Engine) pick(p Period, why string) Action {
+	if e.trace != nil {
+		e.tracePick(p)
+	}
+	if p.TX.Transmitting {
+		if why != "" {
+			return Action{Kind: DoNothing, Reason: why + " — holding until the transmission ends"}
+		}
+		return Action{}
+	}
 	only := onlyList(e.set.Only)
 	var best *Candidate
 	var bestRank int
-	// bestRank of everything eligible, rested or not: a station that is resting
+	// The best station that is wanted, decoded, and working somebody else. It
-	// may only be re-picked while nothing better is on the air, and that is the
+	// is not a candidate — it cannot answer — but it is the reason the engine
-	// comparison.
+	// is silent, and the operator is entitled to know that.
-	topRank := 0
+	waiting, waitingRank := "", 0
 	for i := range p.Decodes {
 		c := p.Decodes[i]
-		if !e.eligible(c, p, only) {
+		if ok, why := e.judge(c, p, only); !ok {
-			continue
+			if why == "busy" {
-		}
+				if r := rank(c); r > waitingRank {
-		if r := rank(c); r > topRank {
+					waiting, waitingRank = strings.ToUpper(c.Call), r
-			topRank = r
+				}
-		}
+			}
-	}
-	for i := range p.Decodes {
-		c := p.Decodes[i]
-		if !e.eligible(c, p, only) {
 			continue
 		}
 		r := rank(c)
-		if resting, ok := e.rested[strings.ToUpper(c.Call)]; ok && p.At.Before(resting) {
-			// Rested: allowed back only when it is the best thing there is.
-			// Anything of higher rank takes the slot instead.
-			if r < topRank {
-				continue
-			}
-		}
 		if best == nil || better(c, r, *best, bestRank, p.MyCall) {
 			cc := c
 			best, bestRank = &cc, r
 		}
 	}
+	e.waiting = waiting
 	if best == nil {
+		if waiting != "" {
+			return Action{Kind: DoNothing,
+				Reason: fmt.Sprintf("waiting for %s — it is working somebody else", waiting)}
+		}
 		if why != "" {
 			return Action{Kind: DoNothing, Reason: why + " — nothing else worth calling"}
 		}
 		return Action{}
 	}
+	e.waiting = ""
 	e.target, e.heldSince, e.targetInst = best, p.At, best.Instance
-	e.attempts, e.misses, e.txSlot, e.lastMiss = 0, 0, -1, ""
+	// ITS SLOT IS KNOWN FROM THE DECODE THAT MADE IT A CANDIDATE.
-	reason := fmt.Sprintf("calling %s (%s%s)", best.Call, watchedTag(*best), best.Need)
+	//
+	// This used to start at -1, meaning "parity unknown", and with parity
+	// unknown the miss counter has nothing to filter on: every period without
+	// the station counted, INCLUDING the one we spend transmitting to it, where
+	// it cannot be decoded by definition. An operator answering a CQ saw the
+	// counter at two misses out of three before the station had had a single
+	// chance to come back — one bad period from being given up on.
+	e.attempts, e.misses, e.lastMiss = 0, 0, ""
+	e.txSlot = slotOf(p.At, periodSecs(p, *best))
+	e.answered = false
+	e.waiting = ""
+	reason := fmt.Sprintf("calling %s (%s%s)", best.Call, watchedTag(*best), needLabel(*best))
 	if why != "" {
 		reason = why + " — " + reason
 	}
 	return Action{Kind: DoReply, Decode: best.Decode, Reason: reason}
 }
 
+// tracePick writes the one line that says what this period held and what it
+// was worth. Counts by refusal, then the best few candidates in rank order —
+// enough to see WHY a station on the screen was not the one called.
+func (e *Engine) tracePick(p Period) {
+	only := onlyList(e.set.Only)
+	refused := map[string]int{}
+	// The callsigns too, not only the counts. "worked=2" answers "how many" and
+	// leaves "which" — and which is the whole question when an operator is
+	// looking at one station on the screen and asking why it was passed over.
+	who := map[string][]string{}
+	type scored struct {
+		c Candidate
+		r int
+	}
+	var ok []scored
+	for i := range p.Decodes {
+		if good, why := e.judge(p.Decodes[i], p, only); good {
+			ok = append(ok, scored{p.Decodes[i], rank(p.Decodes[i])})
+		} else {
+			refused[why]++
+			if len(who[why]) < 4 {
+				who[why] = append(who[why], p.Decodes[i].Call)
+			}
+		}
+	}
+	sort.Slice(ok, func(i, j int) bool { return ok[i].r > ok[j].r })
+	best := make([]string, 0, 3)
+	for i := 0; i < len(ok) && i < 3; i++ {
+		best = append(best, fmt.Sprintf("%s(%s%s,%d dB,r%d)",
+			ok[i].c.Call, watchedTag(ok[i].c), needLabel(ok[i].c), ok[i].c.SNR, ok[i].r))
+	}
+	why := make([]string, 0, len(refused))
+	for _, k := range []string{"worked", "nothing-needed", "busy", "resting", "halted", "parked", "hidden", "not-chased", "replay", "self"} {
+		if n := refused[k]; n > 0 {
+			names := strings.Join(who[k], ",")
+			if n > len(who[k]) {
+				names += ",…"
+			}
+			why = append(why, fmt.Sprintf("%s=%d(%s)", k, n, names))
+		}
+	}
+	e.trace("period %s rx=%q decodes=%d callable=%d [%s] refused[%s]%s",
+		p.Key, p.Instance, len(p.Decodes), len(ok), strings.Join(best, " "),
+		strings.Join(why, " "),
+		map[bool]string{true: " (transmitting)", false: ""}[p.TX.Transmitting])
+}
 func watchedTag(c Candidate) string {
 	if c.Watched {
 		return "watched "
@@ -604,30 +950,100 @@ func watchedTag(c Candidate) string {
 
 // eligible is every refusal that applies before a station is even ranked.
 func (e *Engine) eligible(c Candidate, p Period, only []string) bool {
+	ok, _ := e.judge(c, p, only)
+	return ok
+}
+
+// judge is eligible() with the reason attached, in one word.
+//
+// The reason exists for the log. An auto-call that calls nobody is the hardest
+// thing to argue with — the band is full, the panel shows a dozen stations
+// wanted, and nothing goes out — and "twenty-three decodes, nineteen already
+// worked, three greyed, one resting" answers it in a line where a boolean
+// cannot.
+func (e *Engine) judge(c Candidate, p Period, only []string) (bool, string) {
 	call := strings.ToUpper(strings.TrimSpace(c.Call))
 	if call == "" || call == strings.ToUpper(p.MyCall) {
-		return false
+		return false, "self"
 	}
 	if !c.IsNew {
-		return false // replayed history: the station may be hours gone
+		return false, "replay" // the station may be hours gone
 	}
 	if len(only) > 0 {
 		// The named stations, and each only until the QSO with it is made: an
 		// explicit request is not a standing order to work the same station all
 		// evening. The others on the list stay callable.
-		return inList(only, call) && !e.done[call] && !c.Worked
+		switch {
+		case !inList(only, call):
+			return false, "not-chased"
+		case e.greyed[call]:
+			return false, "halted"
+		case e.done[call] || c.Worked:
+			return false, "worked"
+		}
+		return true, ""
 	}
 	if c.Worked || e.done[call] {
-		return false
+		return false, "worked"
+	}
+	if e.greyed[call] {
+		return false, "halted"
+	}
+	// A STATION CALLING US is answered, needed or not.
+	//
+	// It has heard us, it is waiting, and the QSO is one over away — refusing it
+	// because the log has nothing to gain is how an operator finishes a contact,
+	// sees two stations calling them on the next sequence, and watches the
+	// machine ignore both. Everything below this point is about choosing whom to
+	// CALL; a caller is not chosen, it is already there.
+	//
+	// The refusals above still apply — worked on this band and mode, the QSO
+	// already made, a station the operator stopped. Those are answers about this
+	// station, not about the log's appetite.
+	if callingUs(c, p.MyCall) {
+		return true, ""
+	}
+	// "LoTW users only" is a rule about STRANGERS. It cannot overrule the watch
+	// list: naming a callsign is the operator saying they want that station, and
+	// a DXpedition that uploads nowhere is exactly the kind of station one puts
+	// on the list. Reported from the air — a watched J38DX, plainly calling CQ,
+	// never called all evening because it is not in the LoTW user file.
+	// FILTERED OFF THE SCREEN. The operator's own filters, applied to the
+	// transmitter: what is not shown is not called.
+	if e.set.OnScreenOnly && c.Hidden {
+		return false, "hidden"
 	}
 	if rank(c) == 0 {
-		return false
+		return false, "nothing-needed"
 	}
-	if e.rounds[call] >= e.set.MaxRounds {
+	// A WATCHED callsign is never parked.
-		return false // parked for the session
+	//
+	// Parking is the answer to "it will not answer, stop wasting the evening on
+	// it" — a fair verdict about a station the LOG picked out, and the wrong one
+	// about a station the OPERATOR did. A DXpedition running a pileup takes more
+	// than two series of calls to get through to, which is precisely why it was
+	// put on the list; watched ZD8GB was refused for the rest of the session
+	// after fourteen unanswered calls, while it went on transmitting six streams
+	// a period.
+	//
+	// The rest between series still applies, so it does not monopolise the
+	// transmitter — it simply never becomes ineligible.
+	if e.rounds[call] >= e.set.MaxRounds && !c.Watched {
+		return false, "parked" // its series are spent for the session
+	}
+	// RESTING. A series that ended in a brake is followed by a real pause,
+	// whatever else is on the air — the exception used to be "unless nothing
+	// better is decoding", and for the station everybody is chasing that is
+	// every period: seven calls, a halt, and the same station called again four
+	// seconds later. From the outside that is not a rest, it is a stutter.
+	if until, ok := e.rested[call]; ok && p.At.Before(until) {
+		return false, "resting"
 	}
 	// Mid-exchange with somebody else: it cannot answer us — see callable.
-	return callable(c, p.MyCall)
+	if !callable(c, p.MyCall) {
+		return false, "busy"
+	}
+	return true, ""
 }
 
 // better orders two eligible stations: the need first, then the one already
@@ -645,11 +1061,78 @@ func better(a Candidate, ra int, b Candidate, rb int, myCall string) bool {
 	return a.SNR > b.SNR
 }
 
+// preempt hands the slot to a better station, if one is on the air.
+func (e *Engine) preempt(p Period) (Action, bool) {
+	if e.target == nil || p.TX.Transmitting {
+		// Mid-over: the reply would switch the decoder's call in the middle of
+		// a transmission. It waits for the gap, like every other call.
+		return Action{}, false
+	}
+	held := rank(*e.target)
+	heldSeen := bestOf(p.Decodes, strings.ToUpper(e.target.Call)) != nil
+	only := onlyList(e.set.Only)
+	best, bestRank := (*Candidate)(nil), held
+	for i := range p.Decodes {
+		c := p.Decodes[i]
+		if strings.EqualFold(c.Call, e.target.Call) || !e.eligible(c, p, only) {
+			continue
+		}
+		// Strictly better takes over. So does an EQUAL rung when the station we
+		// are calling is not even on the air this period: the seven calls are
+		// going into the void while a station of the same value is calling CQ
+		// three rows above it, which is what an operator sees and cannot explain.
+		r := rank(c)
+		switch {
+		case r > bestRank:
+		case r == bestRank && !heldSeen && best == nil:
+		case best != nil && r == bestRank && better(c, r, *best, bestRank, p.MyCall):
+		default:
+			continue
+		}
+		{
+			cc := c
+			best, bestRank = &cc, r
+		}
+	}
+	if best == nil {
+		return Action{}, false
+	}
+	was := strings.ToUpper(e.target.Call)
+	e.drop()
+	e.target, e.heldSince, e.targetInst = best, p.At, best.Instance
+	return Action{Kind: DoReply, Decode: best.Decode,
+		Reason: fmt.Sprintf("%s (%s%s) takes over from %s — nothing had been answered yet",
+			best.Call, watchedTag(*best), needLabel(*best), was)}, true
+}
+
+// drop lets the target go with no verdict attached: not worked, not given up
+// on, not rested. It is simply not the station to be calling right now, and it
+// is picked again like any other the moment it is.
+func (e *Engine) drop() {
+	e.target, e.attempts, e.misses, e.txSlot, e.lastMiss = nil, 0, 0, -1, ""
+	e.targetInst, e.answered, e.seenKey = "", false, ""
+}
+
+// addressee is who a message is being sent to — the first token, which is the
+// callsign being answered — the first segment of a multi-answer line, which is
+// the QSO it is finishing.
+func addressee(msg string) string {
+	parts := messages(msg)
+	if len(parts) == 0 {
+		return "someone else"
+	}
+	toks := strings.Fields(parts[0])
+	if len(toks) == 0 {
+		return "someone else"
+	}
+	return bare(toks[0])
+}
+
 // release clears the target. gaveUp marks it as a series that ended in a brake
 // rather than in a QSO.
 func (e *Engine) release(call string, gaveUp bool) {
 	e.target, e.attempts, e.misses, e.txSlot, e.lastMiss = nil, 0, 0, -1, ""
-	e.targetInst = ""
+	e.targetInst, e.answered = "", false
 	if !gaveUp {
 		// A finished QSO is not a failed series — the callsign keeps its rounds —
 		// but it IS finished: nothing more is wanted from this station today,
@@ -662,7 +1145,11 @@ func (e *Engine) release(call string, gaveUp bool) {
 func (e *Engine) giveUp(call string, t Candidate) {
 	e.release(call, true)
 	e.rounds[call]++
-	e.rested[call] = time.Now().Add(e.set.Rest)
+	at := e.now
+	if at.IsZero() {
+		at = time.Now()
+	}
+	e.rested[call] = at.Add(restFor(e.set.RestPeriods, candidateSecs(t)))
 	// An explicit "call this station" that runs out of attempts stops the
 	// feature instead of moving on. There is nothing else it was asked to do.
 	if strings.TrimSpace(e.set.Only) != "" {
@@ -693,19 +1180,32 @@ func (e *Engine) NoteTX(tx TXState) Action {
 		return Action{}
 	}
 	t := *e.target
-	tc := strings.ToUpper(t.Call)
+	tc := bare(t.Call)
 	msg := strings.ToUpper(strings.TrimSpace(tx.Msg))
 	switch {
 	case msg != "":
 		toks := strings.Fields(msg)
-		if len(toks) < 3 || toks[0] != tc || !isGrid(toks[2]) {
+		// bare(): a decoder compresses a non-standard callsign into angle
+		// brackets — "<HP/WE9G> F4BPO JN36" is a call to HP/WE9G — and comparing
+		// the raw token left the counter at 0/15 while the operator watched call
+		// after call go out. Every brake downstream of it was dead too.
+		if len(toks) < 3 || bare(toks[0]) != tc {
+			return Action{}
+		}
+		if !isGrid(toks[2]) {
+			// A report, an R-report, RR73: we are INSIDE the exchange, not
+			// opening it. It does not count as a call — and it settles that
+			// nothing may take this station's place, which matters when the
+			// decoder is answering somebody the engine never picked (the
+			// operator double-clicked a row) and no reply has been decoded yet.
+			e.answered = true
 			return Action{}
 		}
 	default:
 		// JTDX reports no transmit message. The DX call is all there is, so
 		// every transmit period aimed at the target counts — more generous, and
 		// far better than a counter frozen at zero for ever.
-		if strings.ToUpper(strings.TrimSpace(tx.DXCall)) != tc {
+		if bare(tx.DXCall) != tc {
 			return Action{}
 		}
 	}
@@ -715,7 +1215,8 @@ func (e *Engine) NoteTX(tx TXState) Action {
 	}
 	max := e.maxAttempts(t)
 	e.giveUp(tc, t)
-	return Action{Kind: DoHalt, Reason: fmt.Sprintf("%s called %d times without an answer", tc, max)}
+	return Action{Kind: DoHalt, Soft: true,
+		Reason: fmt.Sprintf("%s called %d times without an answer — stopping after this over", tc, max)}
 }
 
 // bestOf returns the most callable decode of one station in a period.
@@ -750,6 +1251,28 @@ func workedNow(decodes []Candidate, call string) bool {
 	return false
 }
 
+// restFor turns a number of the station's own overs into a deadline.
+//
+// A station transmits every OTHER slot, so one of its overs is two T/R periods —
+// and the extra half-cycle is what makes the answer stable: without it the
+// deadline lands exactly on the station's next transmission, where a
+// millisecond of clock skew decides whether it is called or passed over. Landing
+// it mid-cycle makes "sit out one over" mean one over, every time.
+func restFor(overs, trSec int) time.Duration {
+	if overs <= 0 {
+		return time.Duration(trSec) * time.Second // no rest: its next over will do
+	}
+	return time.Duration(overs*2*trSec+trSec) * time.Second
+}
+
+// candidateSecs is the station's own T/R period in seconds, defaulting to FT8's.
+func candidateSecs(c Candidate) int {
+	if c.TRPeriod > 0 {
+		return c.TRPeriod
+	}
+	return 15
+}
+
 func periodSecs(p Period, c Candidate) int {
 	if c.TRPeriod > 0 {
 		return c.TRPeriod

internal/autocall/autocall_test.go

@@ -2,6 +2,7 @@ package autocall
 
 import (
 	"fmt"
+	"strings"
 	"testing"
 	"time"
 )
@@ -56,13 +57,17 @@ func on() *Engine { return New(Settings{Enabled: true}) }
 // ── The ladder ────────────────────────────────────────────────────────────
 
 func TestLadderOrder(t *testing.T) {
-	// Every rung, in the order the operator asked for.
+	// Every rung. The watched ones come FIRST, ordered among themselves by what
+	// is needed — the list is the operator's answer, not a tie-breaker.
 	order := []Candidate{
-		cq("A", NeedDXCC, 0, watched), cq("B", NeedDXCC, 0),
+		cq("A", NeedDXCC, 0, watched), cq("C", NeedBand, 0, watched),
-		cq("C", NeedBand, 0, watched), cq("D", NeedBand, 0),
+		cq("E", NeedMode, 0, watched), cq("G", NeedSlot, 0, watched),
-		cq("E", NeedMode, 0, watched), cq("F", NeedMode, 0),
-		cq("G", NeedSlot, 0, watched), cq("H", NeedSlot, 0),
 		cq("I", NeedNone, 0, watched),
+		cq("B", NeedDXCC, 0), cq("D", NeedBand, 0),
+		cq("F", NeedMode, 0), cq("H", NeedSlot, 0),
+		// The orthogonal markers sit at the foot of the ladder: worth a call
+		// when nothing better is on the air, never worth leaving a band for.
+		cq("J", NeedExtra, 0),
 	}
 	for i := 1; i < len(order); i++ {
 		if rank(order[i-1]) <= rank(order[i]) {
@@ -76,10 +81,17 @@ func TestLadderOrder(t *testing.T) {
 	}
 	// And the pick agrees with the ladder, whatever order the period lists them.
 	e := on()
-	a := e.OnPeriod(period(0, order[7], order[3], order[0], order[5]))
+	a := e.OnPeriod(period(0, order[8], order[5], order[0], order[6]))
 	if a.Kind != DoReply || a.Decode.Call != "A" {
 		t.Fatalf("picked %+v, want the watched new entity", a)
 	}
+	// A watched station with NOTHING needed still beats a new entity that is not
+	// watched — the case that sent an operator hunting: a watched DXpedition sat
+	// on the band all evening while the engine worked what the log wanted.
+	e = on()
+	if a := e.OnPeriod(period(2, cq("RARE", NeedDXCC, 0), cq("WATCHED", NeedNone, -20, watched))); a.Decode.Call != "WATCHED" {
+		t.Errorf("picked %q, want the watched callsign", a.Decode.Call)
+	}
 }
 
 func TestStrongestWinsBetweenEquals(t *testing.T) {
@@ -232,24 +244,56 @@ func TestAReleasedStationYieldsToAnythingBetter(t *testing.T) {
 	}
 }
 
-func TestAReleasedStationIsCalledAgainWhenNothingBetterIsOnTheAir(t *testing.T) {
+// A series that ended in a brake is followed by ONE of the station's own overs
+// passed over — long enough to be a pause, short enough that the DX everybody
+// is chasing is still there when the calling resumes. It used to be two
+// minutes, which on FT8 is four overs: by then the DX has worked four other
+// callers, and half the time it has gone.
+func TestAReleasedStationSitsOutOneOfItsOvers(t *testing.T) {
 	e := on()
 	e.OnPeriod(period(0, cq("DX", NeedBand, -5)))
 	tx := TXState{Transmitting: true, Msg: "DX " + me + " JN36"}
 	for i := 0; i < 7; i++ {
 		e.NoteTX(tx)
 	}
-	a := e.OnPeriod(period(2, cq("DX", NeedBand, -5)))
+	// Its very next over is passed over, whatever else is on the air: seven
-	if a.Kind != DoReply || a.Decode.Call != "DX" {
+	// calls, a halt, and the same station called again four seconds later is not
-		t.Errorf("nothing better on the air and the station was not called again: %+v", a)
+	// a rest, it is a stutter.
+	if a := e.OnPeriod(period(2, cq("DX", NeedBand, -5))); a.Kind != DoNothing {
+		t.Fatalf("called again during the rest: %+v", a)
+	}
+	// And the one after that goes: still there, still wanted, and the operator
+	// has listened through an over.
+	if a := e.OnPeriod(period(4, cq("DX", NeedBand, -5))); a.Kind != DoReply {
+		t.Errorf("after one over: %+v, want the station called again", a)
+	}
+}
+
+func TestTheAttemptsCapLetsTheOverFinish(t *testing.T) {
+	e := on()
+	e.OnPeriod(period(0, cq("DX", NeedDXCC, -5)))
+	tx := TXState{Transmitting: true, Msg: "DX " + me + " JN36"}
+	var a Action
+	for i := 0; i < 7; i++ {
+		a = e.NoteTX(tx)
+	}
+	if a.Kind != DoHalt {
+		t.Fatalf("no halt after seven calls: %+v", a)
+	}
+	// The cap trips WHILE the seventh call is going out — cutting the carrier
+	// there sends half a call. It asks the decoder to finish the over first.
+	if !a.Soft {
+		t.Error("the attempts cap cut the transmission that counted it")
 	}
 }
 
 func TestAStationIsParkedAfterItsRounds(t *testing.T) {
 	e := on()
 	tx := TXState{Transmitting: true, Msg: "DX " + me + " JN36"}
+	// Rounds are spaced past the rest (2 min = 8 periods) or the station would
+	// simply be resting rather than parked.
 	for round := 1; round <= 3; round++ {
-		a := e.OnPeriod(period(round*2, cq("DX", NeedBand, -5)))
+		a := e.OnPeriod(period(round*10, cq("DX", NeedBand, -5)))
 		if a.Kind != DoReply {
 			t.Fatalf("round %d: not called (%+v)", round, a)
 		}
@@ -259,7 +303,7 @@ func TestAStationIsParkedAfterItsRounds(t *testing.T) {
 	}
 	// Three series of seven is twenty-one calls. That is the end of it for this
 	// session — the whole point of the exercise is that it cannot reach fifty.
-	if a := e.OnPeriod(period(20, cq("DX", NeedBand, -5))); a.Kind != DoNothing {
+	if a := e.OnPeriod(period(60, cq("DX", NeedBand, -5))); a.Kind != DoNothing {
 		t.Errorf("a fourth series was started: %+v", a)
 	}
 }
@@ -271,9 +315,13 @@ func TestFinishedQSOMovesToTheNextPriority(t *testing.T) {
 	e.OnPeriod(period(0, cq("DX", NeedDXCC, -5)))
 	done := callsMe("DX", NeedDXCC, -5)
 	done.Msg = me + " DX RR73"
-	a := e.OnPeriod(period(2, done, cq("NEXT", NeedBand, -10)))
+	// The period the QSO ends in belongs to our own 73 — nothing else is called.
+	if a := e.OnPeriod(period(2, done, cq("NEXT", NeedBand, -10))); a.Kind != DoNothing {
+		t.Fatalf("took the slot our 73 goes out in: %+v", a)
+	}
+	a := e.OnPeriod(period(4, cq("NEXT", NeedBand, -10)))
 	if a.Kind != DoReply || a.Decode.Call != "NEXT" {
-		t.Errorf("after the QSO ended: %+v, want the next priority in the same period", a)
+		t.Errorf("next period: %+v, want the next priority", a)
 	}
 }
 
@@ -282,12 +330,14 @@ func TestFinishedQSOWithNoPriorityAnswersWhoeverIsCallingUs(t *testing.T) {
 	e.OnPeriod(period(0, cq("DX", NeedDXCC, -5)))
 	done := callsMe("DX", NeedDXCC, -5)
 	done.Msg = me + " DX RR73"
-	// Two stations calling us, nothing needed from either: the strongest wins.
+	// Two stations calling us, nothing needed from either: the strongest wins —
+	// on the period after the one our 73 goes out in.
 	weak := callsMe("WEAK", NeedNone, -18)
 	weak.Watched = true
 	loud := callsMe("LOUD", NeedNone, -4)
 	loud.Watched = true
-	a := e.OnPeriod(period(2, done, weak, loud))
+	e.OnPeriod(period(2, done))
+	a := e.OnPeriod(period(4, weak, loud))
 	if a.Kind != DoReply || a.Decode.Call != "LOUD" {
 		t.Errorf("answered %+v, want the strongest of the stations calling us", a)
 	}
@@ -403,7 +453,8 @@ func TestChaseListTakesSeveralCallsigns(t *testing.T) {
 	// single request.
 	done := callsMe("VP6D", NeedDXCC, -22)
 	done.Msg = me + " VP6D RR73"
-	a = e.OnPeriod(period(4, done, cq("3Y0J", NeedSlot, -1)))
+	e.OnPeriod(period(4, done, cq("3Y0J", NeedSlot, -1)))
+	a = e.OnPeriod(period(6, cq("3Y0J", NeedSlot, -1)))
 	if a.Kind != DoReply || a.Decode.Call != "3Y0J" {
 		t.Errorf("after working VP6D: %+v, want the other station on the list", a)
 	}
@@ -460,3 +511,468 @@ func TestTheOtherReceiverCannotBreakTheQSOInProgress(t *testing.T) {
 		t.Errorf("after the QSO ended, the other receiver was still locked out: %+v", a)
 	}
 }
+
+// The one reported from the air: his RRR arrives, we are sending our 73, and
+// the engine picked the next station in the same instant. WSJT-X acts on a
+// reply at once — it dropped the exchange and started calling the new station,
+// cutting the 73 a second in.
+func TestNothingIsCalledOverOurOwnTransmission(t *testing.T) {
+	e := on()
+	e.OnPeriod(period(0, cq("DX", NeedDXCC, -5)))
+	done := callsMe("DX", NeedDXCC, -5)
+	done.Msg = me + " DX RRR"
+	p := period(2, done, cq("NEXT", NeedBand, -10))
+	p.TX = TXState{Transmitting: true, Msg: "DX " + me + " 73"}
+	if a := e.OnPeriod(p); a.Kind != DoNothing {
+		t.Fatalf("called %+v while our own over was still going out", a)
+	}
+	// The QSO is still released — only the next call waits.
+	if e.Target() != "" {
+		t.Errorf("target = %q after the QSO finished, want none", e.Target())
+	}
+	// Next period, carrier down: now it may take the next station.
+	if a := e.OnPeriod(period(4, cq("NEXT", NeedBand, -10))); a.Kind != DoReply || a.Decode.Call != "NEXT" {
+		t.Errorf("once the transmission ended: %+v, want the next station called", a)
+	}
+}
+
+func TestTheHoldClockRestartsWhenTheStationAnswers(t *testing.T) {
+	e := on()
+	e.OnPeriod(period(0, cq("DX", NeedDXCC, -5)))
+	// Called for a long time — nearly the backstop — and then he answers.
+	for p := 2; p <= 14; p += 2 {
+		e.OnPeriod(period(p, cq("DX", NeedDXCC, -5)))
+	}
+	e.OnPeriod(period(16, callsMe("DX", NeedDXCC, -5)))
+	// The exchange must not be halted by a backstop that was counting the wait.
+	for _, p := range []int{18, 20} {
+		if a := e.OnPeriod(period(p, callsMe("DX", NeedDXCC, -5))); a.Kind == DoHalt {
+			t.Fatalf("period %d: halted an exchange in progress (%s)", p, a.Reason)
+		}
+	}
+}
+
+func TestARealNeedOutranksAnUnconfirmedOne(t *testing.T) {
+	real := cq("REAL", NeedBand, -20)
+	unconf := cq("UNCONF", NeedBand, -2)
+	unconf.Unconfirmed = true
+	// Same need, and the unconfirmed one is 18 dB louder. The band never worked
+	// is still the catch: the other is a QSL to chase, not a QSO to make.
+	e := on()
+	if a := e.OnPeriod(period(0, unconf, real)); a.Decode.Call != "REAL" {
+		t.Errorf("picked %q, want the band never worked", a.Decode.Call)
+	}
+	// Watched changes that, and is meant to: the list is the operator's answer.
+	unconf.Watched = true
+	e = on()
+	if a := e.OnPeriod(period(0, unconf, real)); a.Decode.Call != "UNCONF" {
+		t.Errorf("picked %q, want the watched station", a.Decode.Call)
+	}
+	unconf.Watched = false
+	// Between two unwatched stations, an unconfirmed BAND still beats a real
+	// SLOT: the band is the bigger prize whatever state it is in.
+	slot := cq("SLOT", NeedSlot, 0)
+	e = on()
+	if a := e.OnPeriod(period(0, slot, unconf)); a.Decode.Call != "UNCONF" {
+		t.Errorf("picked %q, want the unconfirmed band over a real slot", a.Decode.Call)
+	}
+}
+
+// ── The operator's Halt ───────────────────────────────────────────────────
+
+func TestHaltSetsTheStationAsideForTheSession(t *testing.T) {
+	e := on()
+	if a := e.OnPeriod(period(0, cq("DX", NeedDXCC, -5))); a.Decode.Call != "DX" {
+		t.Fatalf("not called: %+v", a)
+	}
+	// The operator stops it mid-call.
+	if got := e.Halt(); got != "DX" {
+		t.Fatalf("Halt returned %q, want the station being called", got)
+	}
+	if e.Target() != "" {
+		t.Error("the target survived a halt")
+	}
+	// Still the loudest new entity on the air, period after period. It is the
+	// operator's verdict, so it is not called again — not next period, not in
+	// ten minutes.
+	for _, n := range []int{2, 4, 40} {
+		if a := e.OnPeriod(period(n, cq("DX", NeedDXCC, -5))); a.Kind != DoNothing {
+			t.Errorf("period %d: called a station the operator had stopped: %+v", n, a)
+		}
+	}
+	// Naming it explicitly does not override the operator either.
+	e.SetSettings(Settings{Enabled: true, Only: "DX"})
+	if a := e.OnPeriod(period(42, cq("DX", NeedDXCC, -5))); a.Kind != DoNothing {
+		t.Errorf("the chase list overrode a halt: %+v", a)
+	}
+	// Switching auto-call off and on is what starts over.
+	e.Reset()
+	e.SetSettings(Settings{Enabled: true})
+	if a := e.OnPeriod(period(44, cq("DX", NeedDXCC, -5))); a.Kind != DoReply {
+		t.Errorf("after a restart the station is fair game again: %+v", a)
+	}
+}
+
+func TestHaltWithNothingBeingCalledIsJustAHalt(t *testing.T) {
+	e := on()
+	if got := e.Halt(); got != "" {
+		t.Errorf("Halt returned %q with no target", got)
+	}
+	if e.Greylisted() != 0 {
+		t.Errorf("greylisted %d stations from an idle halt", e.Greylisted())
+	}
+}
+
+func TestTraceSaysWhyNobodyWasCalled(t *testing.T) {
+	var lines []string
+	e := on()
+	e.SetTrace(func(f string, args ...any) { lines = append(lines, fmt.Sprintf(f, args...)) })
+
+	worked := cq("A", NeedDXCC, -5, worked)
+	nothing := cq("B", NeedNone, -5)
+	busyOne := busy("C", NeedBand, -5)
+	e.Halt() // nothing held: no-op, keeps the set empty
+	e.OnPeriod(period(0, worked, nothing, busyOne))
+
+	if len(lines) == 0 {
+		t.Fatal("tracing on and nothing was written")
+	}
+	got := lines[len(lines)-1]
+	for _, want := range []string{"decodes=3", "callable=0", "worked=1", "nothing-needed=1", "busy=1"} {
+		if !strings.Contains(got, want) {
+			t.Errorf("trace %q does not say %q", got, want)
+		}
+	}
+
+	// And when it DOES call, the line names the candidates it ranked.
+	lines = nil
+	e.OnPeriod(period(2, cq("DX", NeedBand, -9, watched)))
+	if len(lines) == 0 || !strings.Contains(lines[0], "DX(watched band,-9 dB,r118)") {
+		t.Errorf("trace %v does not describe the station it called", lines)
+	}
+}
+
+func TestAStationCallingUsIsAnsweredEvenWithNothingToGain(t *testing.T) {
+	e := on()
+	// A QSO has just ended and two stations are calling us. Neither is worth
+	// anything to the log — and both are worth answering: they have heard us,
+	// they are waiting, and the contact is one over away.
+	weak := callsMe("WEAK", NeedNone, -18)
+	loud := callsMe("LOUD", NeedNone, -3)
+	a := e.OnPeriod(period(0, weak, loud))
+	if a.Kind != DoReply || a.Decode.Call != "LOUD" {
+		t.Fatalf("answered %+v, want the strongest of the stations calling us", a)
+	}
+	// A caller already worked on this band and mode is a duplicate, not a QSO.
+	e = on()
+	done := callsMe("DUPE", NeedNone, -1)
+	done.Worked = true
+	if a := e.OnPeriod(period(2, done)); a.Kind != DoNothing {
+		t.Errorf("answered a station already in the log on this band and mode: %+v", a)
+	}
+	// And one the operator halted stays halted, however politely it calls.
+	e = on()
+	e.OnPeriod(period(4, cq("STOP", NeedDXCC, -5)))
+	e.Halt()
+	if a := e.OnPeriod(period(6, callsMe("STOP", NeedDXCC, -5))); a.Kind != DoNothing {
+		t.Errorf("answered a station the operator had stopped: %+v", a)
+	}
+	// A needed station still comes first: a caller with nothing to gain is
+	// answered when nothing better is on the air, which is what was asked for.
+	e = on()
+	if a := e.OnPeriod(period(8, callsMe("CALLER", NeedNone, 0), cq("RARE", NeedDXCC, -20))); a.Decode.Call != "RARE" {
+		t.Errorf("picked %q, want the new entity ahead of a caller with nothing needed", a.Decode.Call)
+	}
+}
+
+// TestAStationWorkingSomebodyElseIsNotCHOSEN — the test above is about a target
+// already being called; this is about picking one. A reply to a decode in
+// mid-exchange is a reply WSJT-X and JTDX may refuse outright, so it never
+// starts a call there.
+func TestAStationWorkingSomebodyElseIsNotCHOSEN(t *testing.T) {
+	e := on()
+	busyNow := busy("ON7GB", NeedSlot, +5)
+	busyNow.Msg = "PY2SAD ON7GB JO21"
+	if a := e.OnPeriod(period(0, busyNow)); a.Kind == DoReply {
+		t.Fatalf("called %+v — it is in a QSO with PY2SAD", a)
+	}
+	if e.Target() != "" {
+		t.Errorf("target is %q", e.Target())
+	}
+	// Its final frame is different: one period from free is the best moment
+	// there is to be calling it.
+	last := busy("ON7GB", NeedSlot, +5)
+	last.Msg = "PY2SAD ON7GB RR73"
+	if a := e.OnPeriod(period(2, last)); a.Kind != DoReply {
+		t.Errorf("%+v — a station on its last frame was not called", a)
+	}
+}
+
+func TestAFinalFrameToSomebodyElseIsNotABusyTarget(t *testing.T) {
+	e := on()
+	e.OnPeriod(period(0, cq("DX", NeedSlot, 0)))
+	// Sending RR73 to another station: one period from being free, and the best
+	// moment there is to be calling it.
+	wrap := busy("DX", NeedSlot, 0)
+	wrap.Msg = "PY2SAD DX RR73"
+	if a := e.OnPeriod(period(2, wrap)); a.Kind != DoNothing || e.Target() != "DX" {
+		t.Errorf("dropped a station that was finishing: %+v (target %q)", a, e.Target())
+	}
+}
+
+func TestNothingHiddenByThePanelIsCalled(t *testing.T) {
+	e := New(Settings{Enabled: true, OnScreenOnly: true})
+	// The operator has filtered the list down to CQs: what is not on the screen
+	// is not called, whatever the log makes of it.
+	hidden := cq("RARE", NeedDXCC, 0)
+	hidden.Hidden = true
+	shown := cq("PLAIN", NeedSlot, -20)
+	if a := e.OnPeriod(period(0, hidden, shown)); a.Decode.Call != "PLAIN" {
+		t.Errorf("picked %q, want the station the panel is showing", a.Decode.Call)
+	}
+	// With the panel publishing nothing, nothing is hidden and the ladder
+	// decides alone.
+	e = New(Settings{Enabled: true, OnScreenOnly: true})
+	free := cq("RARE", NeedDXCC, 0)
+	if a := e.OnPeriod(period(2, free, shown)); a.Decode.Call != "RARE" {
+		t.Errorf("picked %q with no filtering in force, want the new entity", a.Decode.Call)
+	}
+}
+
+// MSHV answers two stations in one transmission and the decoder prints them as
+// one line. Reported from the air: the DX was answering us in the second half
+// and the engine, reading only the first, dropped it as busy.
+func TestAMultiAnswerLineIsReadWhole(t *testing.T) {
+	fox := cq("HK0/PY8WW", NeedDXCC, -17, watched)
+	fox.CQ = false
+	fox.Msg = "YV5ALI RR73; " + me + " <HK0/PY8WW> -08"
+
+	if !callingUs(fox, me) {
+		t.Error("the second half is a report to us and was not read as one")
+	}
+	if !callable(fox, me) {
+		t.Error("a station answering us was judged uncallable")
+	}
+	// Held as the target, that line must not release it — it is the answer we
+	// were waiting for, not a station working somebody else.
+	e := on()
+	e.OnPeriod(period(0, cq("HK0/PY8WW", NeedDXCC, -17, watched)))
+	if a := e.OnPeriod(period(2, fox)); a.Kind != DoNothing || e.Target() != "HK0/PY8WW" {
+		t.Errorf("dropped the DX as it answered us: %+v (target %q)", a, e.Target())
+	}
+	// The exchange is under way, so the attempt counter has done its job.
+	if e.Status().Attempts != 0 {
+		t.Errorf("attempts = %d while in QSO, want 0", e.Status().Attempts)
+	}
+	// And its final frame to us, in the same shape, ends the QSO.
+	done := fox
+	done.Msg = "IK2ABC RR73; " + me + " <HK0/PY8WW> RR73"
+	if !finished([]Candidate{done}, "HK0/PY8WW", me) {
+		t.Error("a 73 to us inside a multi-answer line did not end the QSO")
+	}
+}
+
+// Reported from the air twice: the DX sends RR73, our own 73 is about to go
+// out, and the engine answered somebody else in that very slot — two
+// transmissions in one period, and the station at the other end never got the
+// frame that closes the contact.
+func TestTheSlotAfterAQSOBelongsToOur73(t *testing.T) {
+	e := on()
+	e.OnPeriod(period(0, cq("HP/WE9G", NeedDXCC, -6)))
+	bye := callsMe("HP/WE9G", NeedDXCC, -6)
+	bye.Msg = "<" + me + "> HP/WE9G RR73"
+	// A new band is decoding in the same period and is not called.
+	a := e.OnPeriod(period(2, bye, cq("GW8DX", NeedBand, +2)))
+	if a.Kind != DoNothing {
+		t.Fatalf("called %+v in the slot our 73 goes out in", a)
+	}
+	if !strings.Contains(a.Reason, "73") {
+		t.Errorf("reason %q does not say why the slot was left alone", a.Reason)
+	}
+	// It is still there fifteen seconds later, which is the whole cost.
+	if a := e.OnPeriod(period(4, cq("GW8DX", NeedBand, +2))); a.Kind != DoReply || a.Decode.Call != "GW8DX" {
+		t.Errorf("next period: %+v, want the new band called", a)
+	}
+}
+
+func TestABetterStationTakesOverBeforeAnybodyHasAnswered(t *testing.T) {
+	e := on()
+	e.OnPeriod(period(0, cq("PLAIN", NeedSlot, +10)))
+	// A watched station comes on the air: nothing has answered us yet, so the
+	// call in progress is worth less than the one now possible.
+	a := e.OnPeriod(period(2, cq("PLAIN", NeedSlot, +10), cq("WATCHED", NeedNone, -15, watched)))
+	if a.Kind != DoReply || a.Decode.Call != "WATCHED" {
+		t.Fatalf("%+v — a better station did not take over", a)
+	}
+
+	// Equal rungs do NOT take over while the station being called is on the air.
+	e = on()
+	e.OnPeriod(period(4, cq("A", NeedBand, 0)))
+	if a := e.OnPeriod(period(6, cq("A", NeedBand, 0), cq("B", NeedBand, +20))); a.Kind != DoNothing {
+		t.Errorf("%+v — swapped between two stations of equal value", a)
+	}
+	// But they do when it is absent: seven calls into the void while a station
+	// of the same value is calling CQ is what the operator was watching.
+	if a := e.OnPeriod(period(8, cq("B", NeedBand, +20))); a.Kind != DoReply || a.Decode.Call != "B" {
+		t.Errorf("%+v — kept calling a station that was not on the air", a)
+	}
+
+	// Once the station has answered, nothing takes its place.
+	e = on()
+	e.OnPeriod(period(10, cq("DX", NeedSlot, 0)))
+	e.OnPeriod(period(12, callsMe("DX", NeedSlot, 0)))
+	if a := e.OnPeriod(period(14, callsMe("DX", NeedSlot, 0), cq("RARE", NeedDXCC, 0, watched))); a.Kind != DoNothing {
+		t.Errorf("%+v — abandoned an exchange in progress", a)
+	}
+}
+
+// TestAnExchangeInProgressIsNeverAbandoned is the shack report: mid-QSO with
+// V31MA — its report decoded, our RR73 going out — and a station of a higher
+// rung called us from the other side of the screen. The engine switched.
+func TestAnExchangeInProgressIsNeverAbandoned(t *testing.T) {
+	e := on()
+	// V31MA is worth nothing on the ladder: worked before, nothing needed.
+	if a := e.OnPeriod(period(0, callsMe("V31MA", NeedNone, -12))); a.Kind != DoReply {
+		t.Fatalf("%+v — a station calling us was not answered", a)
+	}
+	// Its report arrives in the same period a better station calls us. That
+	// period used to be judged before the reply was taken into account.
+	a := e.OnPeriod(period(2,
+		callsMe("V31MA", NeedNone, -12),
+		callsMe("F5NNN", NeedSlot, -10)))
+	if a.Kind != DoNothing {
+		t.Fatalf("%+v — left V31MA mid-exchange", a)
+	}
+	if e.target == nil || e.target.Call != "V31MA" {
+		t.Fatalf("target is %v — the QSO in progress lost its place", e.target)
+	}
+
+	// Our own transmission settles it too: a report is not an opening call, so
+	// even a QSO the operator started by hand is protected.
+	e = on()
+	e.OnPeriod(period(4, cq("V31MA", NeedNone, -12, watched)))
+	e.NoteTX(TXState{Transmitting: true, Msg: "V31MA F4BPO RR73"})
+	if !e.answered {
+		t.Error("sending a report did not count as being inside the exchange")
+	}
+	if a := e.OnPeriod(period(6, cq("V31MA", NeedNone, -12, watched), callsMe("F5NNN", NeedDXCC, -10))); a.Kind != DoNothing {
+		t.Errorf("%+v — abandoned a QSO we were in the middle of", a)
+	}
+	if e.attempts != 0 {
+		t.Errorf("attempts=%d — an exchange frame was counted as a call", e.attempts)
+	}
+}
+
+// TestAPileupIsWorkedByCallingThroughIt is the shack report: D44TWO finishing a
+// contact, the call started, the DX coming back to somebody else — and the
+// engine giving up on a station that was one period from being free.
+func TestAPileupIsWorkedByCallingThroughIt(t *testing.T) {
+	e := on()
+	if a := e.OnPeriod(period(0, cq("D44TWO", NeedDXCC, -7))); a.Kind != DoReply {
+		t.Fatalf("%+v", a)
+	}
+	// It answers three other callers in a row — which is what a DX with a queue
+	// does, and calling through it is how the queue is joined.
+	does := func(n int) Action { return e.OnPeriod(period(n, busy("D44TWO", NeedDXCC, -7))) }
+	for _, n := range []int{2, 4, 6} {
+		if a := does(n); a.Kind != DoNothing {
+			t.Fatalf("%+v — stopped calling a station working the pileup", a)
+		}
+		if e.Target() != "D44TWO" {
+			t.Fatalf("target is %q — the station was released while it worked others", e.Target())
+		}
+	}
+	// And when it comes to us, the exchange starts as usual.
+	if a := e.OnPeriod(period(8, callsMe("D44TWO", NeedDXCC, -7))); a.Kind != DoNothing {
+		t.Errorf("%+v", a)
+	}
+	if !e.answered {
+		t.Error("the reply was not taken as the start of the exchange")
+	}
+
+	// A BETTER station may still take the slot while it is busy: nothing has
+	// been answered, so nothing is lost by moving.
+	e = on()
+	e.OnPeriod(period(10, cq("D44TWO", NeedSlot, -7)))
+	if a := e.OnPeriod(period(12, busy("D44TWO", NeedSlot, -7), cq("RARE", NeedDXCC, -20, watched))); a.Kind != DoReply || a.Decode.Call != "RARE" {
+		t.Errorf("%+v — a watched new one did not take the slot from a busy station", a)
+	}
+}
+
+// TestTheFirstCallStartsWithNoMisses is the shack report: a CQ answered for the
+// first time, and the toolbar already reading two misses out of three.
+func TestTheFirstCallStartsWithNoMisses(t *testing.T) {
+	e := on()
+	// It calls CQ on an odd slot; we answer.
+	if a := e.OnPeriod(period(1, cq("ER1CW", NeedBand, -2))); a.Kind != DoReply {
+		t.Fatalf("%+v", a)
+	}
+	// The next period is OURS: we are transmitting to it, and of course it is
+	// not decoded. That is not a miss.
+	pp := period(2)
+	pp.TX = TXState{Transmitting: true}
+	e.OnPeriod(pp)
+	if e.misses != 0 {
+		t.Fatalf("misses=%d after our own transmit period", e.misses)
+	}
+	// Nor is a period of the wrong parity with nothing in it.
+	e.OnPeriod(period(4))
+	if e.misses != 0 {
+		t.Fatalf("misses=%d — counted a period the station never transmits in", e.misses)
+	}
+	// ITS period, and it is not there: that is a miss.
+	e.OnPeriod(period(3))
+	if e.misses != 1 {
+		t.Fatalf("misses=%d — the station's own silent period was not counted", e.misses)
+	}
+}
+
+// Parking answers "it will not answer, stop wasting the evening on it" — which
+// is a verdict about a station the LOG picked out, not about one the OPERATOR
+// did. From the air: a watched ZD8GB, six streams a period, refused for the
+// rest of the session after two series of unanswered calls.
+func TestAWatchedCallsignIsNeverParked(t *testing.T) {
+	spent := func(c Candidate) *Engine {
+		e := New(Settings{Enabled: true, MaxRounds: 2})
+		e.OnPeriod(period(0)) // the engine's clock, so the rest below is period time
+		for i := 0; i < 2; i++ {
+			e.giveUp(strings.ToUpper(c.Call), c) // a series ended by a brake
+		}
+		return e
+	}
+
+	// Period 8, well past the rest that follows a series: what is left is the
+	// parking, and only the parking.
+	plain := cq("PLAIN", NeedDXCC, 0)
+	if a := spent(plain).OnPeriod(period(8, plain)); a.Kind == DoReply {
+		t.Errorf("%+v — a station whose series are spent was called again", a)
+	}
+
+	dx := cq("ZD8GB", NeedDXCC, 0, watched)
+	if a := spent(dx).OnPeriod(period(8, dx)); a.Kind != DoReply {
+		t.Errorf("%+v — a watched DXpedition was parked for the session", a)
+	}
+}
+
+// A period is judged more than once — the decodes arrive in a burst and
+// stragglers follow — and a later judgement of it holds a partial view, not
+// evidence that the station has gone. From the air: D2ACE answered in the very
+// period the counter then read as a miss.
+func TestAPeriodTheTargetWasSeenInIsNeverAMiss(t *testing.T) {
+	e := on()
+	if a := e.OnPeriod(period(1, cq("D2ACE", NeedBand, 13))); a.Kind != DoReply {
+		t.Fatalf("%+v", a)
+	}
+	// Its own next period: decoded, so the exchange is under way.
+	p := period(3, callsMe("D2ACE", NeedBand, 13))
+	e.OnPeriod(p)
+	if e.Status().Misses != 0 {
+		t.Fatalf("misses=%d after being decoded", e.Status().Misses)
+	}
+	// The same period again, this time from a flush that carries only the
+	// stragglers — the target is not among them.
+	e.OnPeriod(period(3))
+	if got := e.Status().Misses; got != 0 {
+		t.Errorf("misses=%d — a second flush of a period it was seen in counted against it", got)
+	}
+}

internal/cat/cat.go

@@ -832,6 +832,50 @@ func (m *Manager) IcomDo(fn func(IcomController) error) error {
 	})
 }
 
+// SatTuner is a backend that can be put on a satellite: a receiver on one band
+// and a transmitter on another, both moving under Doppler, at the same time.
+//
+// It is a separate interface from the per-manufacturer ones because what a
+// satellite needs is not a manufacturer's feature — it is a shape of operating
+// that a FlexRadio and an IC-9700 both provide and reach in completely
+// different ways. A backend that cannot do it simply does not implement this,
+// and the caller falls back to tuning the downlink alone rather than pretending.
+type SatTuner interface {
+	// SetSatellite arms or disarms satellite operation: the rig's own satellite
+	// mode where it has one, two slices where it has those. Disarming must leave
+	// the radio somewhere an operator can work from, not half-configured.
+	SetSatellite(on bool) error
+	// TuneSatellite points the receiver at downHz and the transmitter at upHz,
+	// both already Doppler-corrected. Modes are ADIF names ("SSB", "FM", "CW");
+	// an empty one leaves that side's mode alone.
+	TuneSatellite(downHz, upHz int64, downMode, upMode string) error
+	// SatReceiveHz is where the receiver actually is. The operator tunes it to
+	// follow a station across a linear transponder, and that dial movement is
+	// the input the whole tracker works from — without reading it back, a
+	// tracker fights the operator instead of helping them.
+	SatReceiveHz() (int64, error)
+}
+
+// SatCapable reports whether the active backend can hold a satellite pair.
+func (m *Manager) SatCapable() bool {
+	m.mu.RLock()
+	b := m.backend
+	m.mu.RUnlock()
+	_, ok := b.(SatTuner)
+	return ok
+}
+
+// SatDo dispatches a satellite control onto the CAT goroutine.
+func (m *Manager) SatDo(fn func(SatTuner) error) error {
+	return m.exec(func(b Backend) error {
+		st, ok := b.(SatTuner)
+		if !ok {
+			return fmt.Errorf("this radio cannot hold a satellite pair from OpsLog")
+		}
+		return fn(st)
+	})
+}
+
 // exec marshals a backend operation onto the CAT goroutine. Returns the
 // operation's error or a "busy"/"not running" error if dispatch failed.
 func (m *Manager) exec(fn func(Backend) error) error {

internal/cat/civ/civ.go

@@ -49,6 +49,11 @@ const (
 	CmdScope  = 0x27 // spectrum-scope waveform stream (sub 0x00 = data, 0x11 = on/off)
 	CmdRIT    = 0x21 // RIT/ΔTX: sub 0x00 offset freq, 0x01 RIT on/off, 0x02 ΔTX(XIT) on/off
 	CmdSendCW = 0x17 // send a CW message (ASCII, ≤30 chars) via the rig's keyer; data 0xFF = stop
+	// CmdVFO selects which receiver subsequent commands address. On the two-band
+	// satellite rigs (IC-9700, IC-9100) the MAIN band is the downlink and the SUB
+	// band the uplink, so every satellite frequency set is "point at a band, then
+	// tune it".
+	CmdVFO = 0x07
 
 	SubLevelKeySpeed = 0x0C // CmdLevel: CW keying speed (0-255 → KeyMinWPM..KeyMaxWPM)
 
@@ -112,6 +117,17 @@ const (
 	SubSwBreakIn = 0x47 // CW break-in: 0=OFF, 1=SEMI, 2=FULL (needed so 0x17 CW keys TX)
 	SubSwMN      = 0x48 // manual notch on/off
 	SubSwAPF     = 0x32 // audio peak filter on/off (CW only)
+	// Satellite mode (IC-9700 / IC-9100). The rig's OWN satellite mode, not an
+	// imitation of one: it pairs main and sub, gives full duplex, and keeps the
+	// two dials linked the way the radio's designers meant. Asking it to do that
+	// is always better than building the same thing out of split.
+	SubSwSatellite = 0x5A
+
+	// CmdVFO sub-commands: which of a two-receiver rig's bands the next command
+	// addresses.
+	SubVFOMain     = 0xD0 // MAIN band — the downlink in satellite mode
+	SubVFOSub      = 0xD1 // SUB band — the uplink
+	SubVFOExchange = 0xB0 // swap main and sub
 )
 
 // CW break-in modes (CmdSwitch 0x47).

internal/cat/flex.go

@@ -67,6 +67,14 @@ type Flex struct {
 	pendingSpot     map[int]string // seq → callsign, awaiting the spot index in the R response
 	pendingSpotMode map[int]string // seq → ADIF mode, paired with pendingSpot
 	pendingSplit    map[int]bool   // seq → awaiting the new TX slice's index (split create)
+	pendingSat      map[int]string // seq → "rx"/"tx", awaiting a satellite slice's index
+	// Satellite pair: slice A is the downlink, slice B the uplink. -1 when not
+	// armed. satCreatedTX marks an uplink slice OpsLog opened, and is the only
+	// one it will close again.
+	satOn        bool
+	satRX        int
+	satTX        int
+	satCreatedTX bool
 	spotCall        map[int]string // spot index → callsign (to fill the call on a panadapter click)
 	spotMode        map[int]string // spot index → ADIF mode, so a click can also set the slice mode (SmartSDR tunes the spot's freq but not its mode)
 	spotFreq        map[int]int64  // spot index → Hz, so a click can report where it was (the trigger message carries only the index)
@@ -227,7 +235,7 @@ func NewFlex(host string, port int, spotsEnabled bool) *Flex {
 	return &Flex{
 		host: strings.TrimSpace(host), port: port,
 		slices: map[int]*flexSlice{}, spotsEnabled: spotsEnabled,
-		spotIdx: map[int]bool{}, pendingSpot: map[int]string{}, pendingSpotMode: map[int]string{}, spotCall: map[int]string{}, spotMode: map[int]string{}, spotFreq: map[int]int64{}, pendingSpotFreq: map[int]int64{}, panWindow: map[string]panView{}, spotSig: map[string]string{}, spotSent: map[string]time.Time{}, spotByCall: map[string]int{}, pendingSplit: map[int]bool{},
+		spotIdx: map[int]bool{}, pendingSpot: map[int]string{}, pendingSpotMode: map[int]string{}, spotCall: map[int]string{}, spotMode: map[int]string{}, spotFreq: map[int]int64{}, pendingSpotFreq: map[int]int64{}, panWindow: map[string]panView{}, spotSig: map[string]string{}, spotSent: map[string]time.Time{}, spotByCall: map[string]int{}, pendingSplit: map[int]bool{}, pendingSat: map[int]string{}, satRX: -1, satTX: -1,
 		meterMeta: map[int]meterInfo{}, meterVal: map[int]float64{}, meterSub: map[int]bool{},
 		sentCmds: map[int]string{}, txSetAt: map[string]time.Time{},
 		pinnedSlice: -1,
@@ -458,12 +466,23 @@ func (f *Flex) reader(conn net.Conn) {
 			if splitSeq {
 				delete(f.pendingSplit, seq)
 			}
+			// The same reply carries the index of a slice created for a satellite
+			// pair; which of the two it is was recorded when it was asked for.
+			satRole := f.pendingSat[seq]
+			if satRole != "" {
+				delete(f.pendingSat, seq)
+			}
 			f.mu.Unlock()
 			if splitSeq && ok && len(parts) >= 3 {
 				if idx, e := strconv.Atoi(strings.TrimSpace(parts[2])); e == nil {
 					f.send(fmt.Sprintf("slice s %d tx=1", idx))
 				}
 			}
+			if satRole != "" && ok && len(parts) >= 3 {
+				if idx, e := strconv.Atoi(strings.TrimSpace(parts[2])); e == nil {
+					f.adoptSatSlice(satRole, idx)
+				}
+			}
 		}
 	}
 	// Connection ended.

internal/cat/flexsat.go

@@ -0,0 +1,202 @@
+package cat
+
+import (
+	"fmt"
+	"strings"
+
+	"hamlog/internal/applog"
+)
+
+// Satellite operation on a FlexRadio.
+//
+// A Flex has no satellite mode, and does not need one: it has slices. Slice A
+// is the downlink and slice B the uplink — the arrangement every Flex satellite
+// operator already uses by hand — with the transmitter on B and full duplex on,
+// so the operator hears their own signal come back through the transponder.
+// The transverters that put 145 and 435 MHz within the radio's reach are
+// configured in SmartSDR, and their offsets are the radio's business: OpsLog
+// sends the real satellite frequency and SmartSDR does the arithmetic.
+//
+// The two slices are CREATED when they are missing, because "slice B does not
+// exist" is not a thing to make the operator fix at the start of a ten-minute
+// pass. Only what OpsLog created is taken away again on disarming: a slice the
+// operator opened is theirs.
+
+// SetSatellite arranges (or unwinds) the two-slice satellite pair.
+func (f *Flex) SetSatellite(on bool) error {
+	f.mu.Lock()
+	connected := f.conn != nil
+	f.mu.Unlock()
+	if !connected {
+		return fmt.Errorf("flex: not connected")
+	}
+	if !on {
+		return f.satDisarm()
+	}
+
+	// The downlink slice is the one the operator is already on: taking the
+	// active slice rather than insisting on index 0 means arming the satellite
+	// does not move them off the receiver they were listening to.
+	f.mu.Lock()
+	rxIdx, _ := f.mainSliceLocked()
+	var txIdx = -1
+	for _, idx := range f.sortedSliceIdxLocked() {
+		if s := f.slices[idx]; s != nil && s.inUse && idx != rxIdx {
+			txIdx = idx
+			break
+		}
+	}
+	f.satRX, f.satTX = rxIdx, txIdx
+	f.satOn = true
+	f.mu.Unlock()
+
+	// Full duplex before anything else: without it the radio mutes the receiver
+	// on transmit, and an operator who cannot hear their own downlink has no way
+	// to know they are in the passband at all.
+	f.send("radio set full_duplex_enabled=1")
+
+	if rxIdx < 0 {
+		// A radio with no slice at all. One is created; the status that comes
+		// back adopts it as the downlink.
+		f.satCreate("rx", 145.900, "USB")
+	}
+	if txIdx < 0 {
+		f.satCreate("tx", 435.100, "USB")
+	} else {
+		f.send(fmt.Sprintf("slice s %d tx=1", txIdx))
+	}
+	applog.Printf("flex: satellite armed (rx slice %d, tx slice %d)", rxIdx, txIdx)
+	return nil
+}
+
+func (f *Flex) satDisarm() error {
+	f.mu.Lock()
+	rx, tx, created := f.satRX, f.satTX, f.satCreatedTX
+	f.satOn, f.satRX, f.satTX, f.satCreatedTX = false, -1, -1, false
+	f.mu.Unlock()
+
+	f.send("radio set full_duplex_enabled=0")
+	if created && tx >= 0 {
+		f.send(fmt.Sprintf("slice remove %d", tx))
+	}
+	// Transmit goes back where the operator is listening. A radio left
+	// transmitting on a slice that no longer exists — or on the uplink band with
+	// the satellite gone — is not somewhere anyone should be handed back.
+	if rx >= 0 {
+		f.send(fmt.Sprintf("slice s %d tx=1", rx))
+	}
+	applog.Printf("flex: satellite disarmed")
+	return nil
+}
+
+// satCreate asks for a slice and remembers what it is for; the index arrives in
+// the reply (see the R-line handler), which is where the role is applied.
+func (f *Flex) satCreate(role string, freqMHz float64, mode string) {
+	seq := f.send(fmt.Sprintf("slice create freq=%.6f mode=%s", freqMHz, mode))
+	if seq <= 0 {
+		return
+	}
+	f.mu.Lock()
+	if f.pendingSat == nil {
+		f.pendingSat = map[int]string{}
+	}
+	f.pendingSat[seq] = role
+	f.mu.Unlock()
+}
+
+// adoptSatSlice records a freshly created slice in its role. Called from the
+// reply handler with the index the radio assigned.
+func (f *Flex) adoptSatSlice(role string, idx int) {
+	f.mu.Lock()
+	switch role {
+	case "rx":
+		f.satRX = idx
+	case "tx":
+		f.satTX = idx
+		f.satCreatedTX = true
+	}
+	f.mu.Unlock()
+	if role == "tx" {
+		f.send(fmt.Sprintf("slice s %d tx=1", idx))
+	}
+	applog.Printf("flex: satellite %s slice is %d", role, idx)
+}
+
+// TuneSatellite moves the two slices.
+func (f *Flex) TuneSatellite(downHz, upHz int64, downMode, upMode string) error {
+	f.mu.Lock()
+	rx, tx := f.satRX, f.satTX
+	connected := f.conn != nil
+	if rx >= 0 && f.slices[rx] != nil && downHz > 0 {
+		f.slices[rx].freqHz = downHz // optimistic, as SetFrequency is
+	}
+	if tx >= 0 && f.slices[tx] != nil && upHz > 0 {
+		f.slices[tx].freqHz = upHz
+	}
+	f.mu.Unlock()
+	if !connected {
+		return fmt.Errorf("flex: not connected")
+	}
+	if rx < 0 {
+		// The slice was asked for and its index has not come back yet. Nothing is
+		// wrong — the next Doppler step, a second later, will find it.
+		return nil
+	}
+	if downHz > 0 {
+		f.send(fmt.Sprintf("slice t %d %.6f", rx, float64(downHz)/1e6))
+		f.satMode(rx, downMode, downHz)
+	}
+	if tx >= 0 && upHz > 0 {
+		f.send(fmt.Sprintf("slice t %d %.6f", tx, float64(upHz)/1e6))
+		f.satMode(tx, upMode, upHz)
+	}
+	return nil
+}
+
+// satMode sets a slice's mode only when it is not already there. A mode command
+// on every Doppler step is a command a second per slice for a whole pass, and
+// SmartSDR redraws the filter each time.
+func (f *Flex) satMode(idx int, mode string, freqHz int64) {
+	mode = strings.TrimSpace(mode)
+	if mode == "" {
+		return
+	}
+	// USB on both sides above 30 MHz, which is every satellite worth the name —
+	// including the parts of a passband that would be an LSB band down on HF.
+	if strings.EqualFold(mode, "SSB") && freqHz > 30_000_000 {
+		mode = "USB"
+	}
+	fm := adifModeToFlex(mode, freqHz)
+	if fm == "" {
+		return
+	}
+	f.mu.Lock()
+	s := f.slices[idx]
+	same := s != nil && strings.EqualFold(s.mode, fm)
+	if s != nil {
+		s.mode = fm
+	}
+	f.mu.Unlock()
+	if same {
+		return
+	}
+	f.send(fmt.Sprintf("slice s %d mode=%s", idx, fm))
+}
+
+// SatReceiveHz is where the downlink slice sits.
+//
+// From the cache, not from a read: SmartSDR pushes every slice change as it
+// happens, so the cached value is what the radio said, and there is no round
+// trip to pay for once a second.
+func (f *Flex) SatReceiveHz() (int64, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	if f.satRX < 0 {
+		return 0, fmt.Errorf("flex: no downlink slice")
+	}
+	s := f.slices[f.satRX]
+	if s == nil || !s.inUse {
+		return 0, fmt.Errorf("flex: the downlink slice has gone")
+	}
+	return s.freqHz, nil
+}

internal/cat/icom_silence_test.go

@@ -60,3 +60,33 @@ func TestIcomSilenceBackoff(t *testing.T) {
 		t.Errorf("backoff overshot the ceiling: %s", g)
 	}
 }
+
+// A new session must not be judged on the previous one's silence.
+//
+// From an operator's log: a rig switched to standby, then a dial-and-drop loop
+// every forty seconds for as long as it was left there. lastGoodAt bounds "the
+// link answers but no CI-V comes back"; it belongs to a session, and it was
+// never cleared when a new one opened, so every fresh session started already
+// past the grace — and the Icom console, where the power-ON button lives,
+// blinked away on every pass.
+func TestAFreshSessionStartsWithACleanSilenceClock(t *testing.T) {
+	b := &IcomSerial{
+		lastGoodAt:  time.Now().Add(-30 * time.Minute), // a session from before standby
+		readFails:   9,
+		silentGrace: icomSilentGraceMax,
+	}
+	// What Connect does once the transport is open, before anything is sent.
+	b.lastGoodAt = time.Time{}
+	b.readFails = 0
+	b.silentGrace = icomSilentGrace
+
+	if !b.lastGoodAt.IsZero() {
+		t.Fatal("the previous session's last good read survived into this one")
+	}
+	tolerate := func(lastGood time.Time, silentFor, grace time.Duration) bool {
+		return lastGood.IsZero() || silentFor < grace
+	}
+	if !tolerate(b.lastGoodAt, time.Hour, b.silentGrace) {
+		t.Error("a session silent since connect was torn down — that is a rig in standby, and where the ON button has to work")
+	}
+}

internal/cat/icomaudio.go

@@ -67,12 +67,26 @@ type icomAudio struct {
 	txOuter uint16
 	txSend  uint16
 	lastRx  atomic.Int64 // UnixNano of last packet (liveness)
+	rxCount atomic.Int64 // packets delivered on this stream
 
 	done      chan struct{}
 	closeOnce sync.Once
 }
 
-func (a *icomAudio) markRx() { a.lastRx.Store(time.Now().UnixNano()) }
+func (a *icomAudio) markRx() {
+	a.lastRx.Store(time.Now().UnixNano())
+	a.rxCount.Add(1)
+}
+
+// packets reports whether the stream is actually delivering — the difference
+// between "audio is on" and "audio is arriving", which is what makes it worth
+// naming as a suspect when CI-V has gone quiet on the same session.
+func (a *icomAudio) packets() int64 {
+	if a == nil {
+		return 0
+	}
+	return a.rxCount.Load()
+}
 
 // Close tears the audio stream down (disconnect a few times; UDP is lossy).
 func (a *icomAudio) Close() {

internal/cat/icomnet.go

@@ -43,7 +43,7 @@ var icnBE = binary.BigEndian
 // = CI-V only (the proven default). The audio stream is fully separate from CAT,
 // so enabling it can't affect freq/mode/DSP control.
 func NewIcomNet(host, user, pass string, civAddr int, digitalDefault string, audioSink func([]byte)) *IcomSerial {
-	if civAddr <= 0 || civAddr > 0xFF {
+	if civAddr < 0 || civAddr > 0xFF {
 		civAddr = 0x98 // IC-7610
 	}
 	if digitalDefault == "" {
@@ -132,6 +132,13 @@ type icomNet struct {
 	// loop, not the rig — and RS-BA1 showing no such dropouts points that way.
 	txCiv    atomic.Uint32
 	txAtData atomic.Uint32
+	// WHAT was asked, not just how much. A rig that answers at connect and then
+	// never again has usually been sent something it does not like, and counting
+	// the unanswered commands says nothing about which one that was. The last few
+	// command headers are kept so the silence report can name them — the only way
+	// to find a poison command on a radio nobody here has.
+	cmdMu   sync.Mutex
+	lastCmd []string
 
 	rx      chan []byte // CI-V byte chunks from civPump → Read (control replies)
 	scopeRx chan []byte // scope (0x27) frames, kept off rx so the panadapter
@@ -268,6 +275,7 @@ func (n *icomNet) Write(p []byte) (int, error) {
 	n.vCivSeq++
 	n.seqMu.Unlock()
 	n.txCiv.Add(1)
+	n.noteCmd(p)
 	pkt := icnCivData(seq, n.vID, n.vRemote, civSeq, p)
 	n.sentMu.Lock()
 	n.sentBuf[seq] = pkt
@@ -280,6 +288,35 @@ func (n *icomNet) Write(p []byte) (int, error) {
 	return len(p), nil
 }
 
+// noteCmd remembers the command bytes of a CI-V frame — everything after the
+// preamble and the two addresses, up to four bytes, which is command,
+// sub-command and the first of the data.
+func (n *icomNet) noteCmd(p []byte) {
+	if len(p) < 5 {
+		return
+	}
+	body := p[4:]
+	if len(body) > 4 {
+		body = body[:4]
+	}
+	n.cmdMu.Lock()
+	n.lastCmd = append(n.lastCmd, fmt.Sprintf("% X", body))
+	if len(n.lastCmd) > 8 {
+		n.lastCmd = n.lastCmd[len(n.lastCmd)-8:]
+	}
+	n.cmdMu.Unlock()
+}
+
+// recentCmds is what noteCmd collected, oldest first.
+func (n *icomNet) recentCmds() string {
+	n.cmdMu.Lock()
+	defer n.cmdMu.Unlock()
+	if len(n.lastCmd) == 0 {
+		return "none"
+	}
+	return strings.Join(n.lastCmd, " | ")
+}
+
 // icnTrace toggles verbose per-frame CI-V request/reply logging for diagnosing
 // the network transport. Off by default (the connect-step logs stay); flip to
 // true to trace every TX/RX again.
@@ -496,6 +533,18 @@ func (n *icomNet) civPump() {
 			}
 			debugLog.Printf("icom net: no CI-V DATA for 10 s (transport last heard %s ago; last scope frame %s ago; last socket error: %v; missing-seq backlog: %d; CI-V commands SENT since the last answer: %d)",
 				time.Since(lastPkt).Round(time.Second), scopeAge, lastErr, len(n.rxMissing), n.txCiv.Load()-n.txAtData.Load())
+			debugLog.Printf("icom net: the last CI-V commands sent, oldest first: %s", n.recentCmds())
+			// THE AUDIO STREAM IS THE FIRST SUSPECT, AND ONLY THE LOG CAN SAY SO.
+			//
+			// The RX audio stream is experimental and shares the rig's session with
+			// CI-V. The shape seen in the field is exactly this one: audio packets
+			// arriving by the hundred while not one CI-V reply comes back, the
+			// watchdog tearing the session down, and the whole thing beginning
+			// again — a loop an operator reads as "the Icom keeps disconnecting",
+			// with nothing pointing at the switch that would end it.
+			if n.audio != nil && n.audio.packets() > 0 {
+				debugLog.Printf("icom net: the RX audio stream is running and still delivering while CI-V has gone quiet — that option is experimental and shares this session. If the drops continue, turn OFF \"Stream RX audio over the network\" in Settings → CAT and see whether control steadies.")
+			}
 			// And try the gentle repair before the 30 s watchdog tears the whole
 			// session down: if the rig quietly closed the CI-V data flow (the
 			// transport is still chatting, so the session itself stands), saying
@@ -808,20 +857,46 @@ func dialIcomNet(host, user, pass, compName string, rigAddr byte, cancel <-chan
 	n.vTracked++
 	n.vCivSeq++
 
-	go n.ctrlPump()
-	go n.civPump()
-
 	// Optional RX audio stream (50003). The rig was told (conninfo rxEnable=1) to
 	// stream audio; open the socket + handshake now. A failure here is NON-fatal:
 	// CAT works without audio, so we log and continue rather than tear down a
 	// perfectly good control/CI-V session.
+	//
+	// BEFORE the pumps start, because the conninfo below touches the control-
+	// stream auth state, and after ctrlPump is running that state belongs to it.
 	if wantAudio {
 		if a, err := dialIcomAudio(host, audioSink, cancel); err != nil {
 			debugLog.Printf("icom net: audio stream FAILED (CAT unaffected): %v", err)
 		} else {
 			n.audio = a
+			// AND THE CONNINFO AGAIN, NOW THAT SOMEBODY IS LISTENING ON 50003.
+			//
+			// The first one goes out during the login, before this socket exists —
+			// it has to, since it is what authorises the stream. So the rig is told
+			// to send audio to a port nothing is bound to yet, and what comes back
+			// is an ICMP port-unreachable; it then backs off, and the audio appears
+			// only when its own retry timer comes round. An operator timed that at
+			// twenty to thirty seconds of silence after switching the speakers on,
+			// and one log here shows a minute and a half.
+			//
+			// Re-sent once the port is open, so the rig starts streaming into a
+			// socket that is ready for it. Idempotent — the same message the session
+			// already carries, which is why RS-BA1 repeats it too.
+			pkt := icnConnInfo(n.cTracked, n.cAuthSeq, n.cTokReq, n.cID, n.cRemote, n.cToken, user, rigMAC, 50002, 50003, 0x01)
+			n.cSentBuf[n.cTracked] = pkt
+			n.cTracked++
+			n.cAuthSeq++
+			if _, err := ctrl.Write(pkt); err != nil {
+				debugLog.Printf("icom net: could not re-send the conninfo after opening the audio port: %v", err)
+			} else {
+				debugLog.Printf("icom net: conninfo re-sent now that :50003 is listening — the rig can start the audio at once")
+			}
 		}
 	}
+
+	go n.ctrlPump()
+	go n.civPump()
+
 	return n, nil
 }
 

internal/cat/icomsat.go

@@ -0,0 +1,181 @@
+package cat
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+
+	"hamlog/internal/applog"
+	"hamlog/internal/cat/civ"
+)
+
+// Satellite operation on an Icom.
+//
+// Two rigs in the range have a satellite mode of their own — the IC-9700 and
+// the IC-9100 — and on those the right thing to do is ask the radio for it
+// rather than build an imitation out of split. Their satellite mode pairs the
+// MAIN band (the downlink) with the SUB band (the uplink), gives full duplex,
+// and keeps the two dials linked the way the designers meant. Every other Icom
+// has one receiver on one band: it can be tuned to the downlink, and that is
+// the whole truth about what it can do on a cross-band satellite.
+//
+// UNTESTED ON HARDWARE. Built from the IC-9700 CI-V reference: 0x16 0x5A arms
+// satellite mode, 0x07 0xD0 / 0xD1 select MAIN and SUB, and once a band is
+// selected the ordinary 0x05 / 0x06 tune it. If an IC-9700 owner reports it
+// misbehaving, the log lines below name every frame sent.
+
+// ErrSatUplinkUnreachable says the downlink was tuned and the uplink was not,
+// because the radio has no second receiver and the two are on different bands.
+//
+// A distinct error rather than a silent half-success: a tracker that quietly
+// stops transmitting where the operator expects it to is worse than one that
+// says it cannot. The caller reports it once, not once per Doppler step.
+var ErrSatUplinkUnreachable = errors.New("cat: this radio has one receiver — the uplink is on another band and cannot be set")
+
+// SetSatellite arms the rig's own satellite mode.
+func (b *IcomSerial) SetSatellite(on bool) error {
+	if !b.satNative {
+		// Nothing to arm and nothing to break: the tuning path below does what
+		// this radio can do without any mode change. Refusing here would deny an
+		// operator the downlink, which is most of the value on a receive-heavy
+		// pass.
+		b.satOn = on
+		return nil
+	}
+	if err := b.exec(civ.CmdSwitch, civ.SubSwSatellite, boolByte(on)); err != nil {
+		return fmt.Errorf("icom: satellite mode %v refused: %w", on, err)
+	}
+	b.satOn = on
+	applog.Printf("icom: satellite mode %v (%s)", on, b.model)
+	if on {
+		// Leave the radio pointing at MAIN. Everything else in OpsLog — the poll
+		// loop, the logged frequency, the operator's dial — reads the selected
+		// band, and on a satellite the band worth reading is the one carrying the
+		// downlink.
+		_ = b.exec(civ.CmdVFO, civ.SubVFOMain)
+	}
+	return nil
+}
+
+// TuneSatellite puts the receiver on downHz and the transmitter on upHz.
+func (b *IcomSerial) TuneSatellite(downHz, upHz int64, downMode, upMode string) error {
+	if downHz <= 0 {
+		return fmt.Errorf("icom: no downlink frequency")
+	}
+	if !b.satNative {
+		return b.tuneSatSingleBand(downHz, upHz, downMode, upMode)
+	}
+	// MAIN — the downlink.
+	if err := b.exec(civ.CmdVFO, civ.SubVFOMain); err != nil {
+		return fmt.Errorf("icom: could not select the main band: %w", err)
+	}
+	if err := b.SetFrequency(downHz); err != nil {
+		return err
+	}
+	if err := b.satSetMode(downMode, downHz); err != nil {
+		return err
+	}
+	// SUB — the uplink.
+	if upHz > 0 {
+		if err := b.exec(civ.CmdVFO, civ.SubVFOSub); err != nil {
+			return fmt.Errorf("icom: could not select the sub band: %w", err)
+		}
+		uerr := b.execIdempotent(fmt.Sprintf("set uplink %d Hz", upHz),
+			append([]byte{civ.CmdSetFreq}, civ.FreqToBCD(upHz)...)...)
+		merr := b.satSetMode(upMode, upHz)
+		// Back to MAIN whatever happened. A rig left pointing at SUB reports the
+		// uplink as its frequency, and every band-dependent thing in OpsLog —
+		// the log, the antenna, the amplifier — would follow the transmitter
+		// onto the wrong band.
+		if err := b.exec(civ.CmdVFO, civ.SubVFOMain); err != nil {
+			applog.Printf("icom: could not return to the main band: %v", err)
+		}
+		if uerr != nil {
+			return uerr
+		}
+		if merr != nil {
+			return merr
+		}
+	}
+	return nil
+}
+
+// satSetMode sets the mode of whichever band is currently selected. An empty
+// mode leaves it alone — a linear transponder is worked in one mode for a whole
+// pass, and re-sending it every second is traffic for nothing.
+func (b *IcomSerial) satSetMode(mode string, freqHz int64) error {
+	mode = strings.TrimSpace(mode)
+	if mode == "" {
+		return nil
+	}
+	// modeCode resolves "SSB" against the CURRENT dial to pick a sideband, which
+	// is wrong here twice over: the dial may still be on the other band, and on
+	// satellites USB is the convention on both sides whatever the frequency.
+	code, data, err := b.modeCode(satSideband(mode))
+	if err != nil {
+		return err
+	}
+	return b.setModeBytes(mode, code, data)
+}
+
+// satSideband is the sideband convention above 30 MHz: USB, on both the uplink
+// and the downlink, including the parts of a linear transponder that fall in
+// what would be an LSB band on HF. The exceptions — AO-7's mode A downlink on
+// 29 MHz among them — are still USB by convention, so there is no exception to
+// make.
+func satSideband(mode string) string {
+	if strings.EqualFold(strings.TrimSpace(mode), "SSB") {
+		return "USB"
+	}
+	return mode
+}
+
+// SatReceiveHz is where the receiver is now.
+func (b *IcomSerial) SatReceiveHz() (int64, error) {
+	if b.satNative {
+		// The selected band is MAIN — see TuneSatellite, which always returns to
+		// it — so the ordinary frequency read is the downlink.
+		if err := b.exec(civ.CmdVFO, civ.SubVFOMain); err != nil {
+			applog.Printf("icom: sat readback could not select main: %v", err)
+		}
+	}
+	return b.readFreq()
+}
+
+// tuneSatSingleBand is every other Icom: one receiver, one band.
+//
+// The downlink is set, because that is what the operator is listening to. The
+// uplink is set through split only when it is close enough to be on the same
+// band — QO-100 behind transverters, AO-7's mode A — and otherwise reported as
+// out of reach rather than quietly skipped.
+func (b *IcomSerial) tuneSatSingleBand(downHz, upHz int64, downMode, _ string) error {
+	if err := b.SetFrequency(downHz); err != nil {
+		return err
+	}
+	if err := b.satSetMode(downMode, downHz); err != nil {
+		return err
+	}
+	if upHz <= 0 {
+		return nil
+	}
+	// One megahertz apart is the working definition of "the same band" here: it
+	// covers a transponder's own passband and any sensible transverter pairing,
+	// and excludes every real cross-band satellite (145 / 435 MHz).
+	if abs64(upHz-downHz) > 1_000_000 {
+		return ErrSatUplinkUnreachable
+	}
+	if err := b.exec(append([]byte{civ.CmdVfoFreq, civ.SubVfoUnselected}, civ.FreqToBCD(upHz)...)...); err != nil {
+		return err
+	}
+	if !b.satOn {
+		return nil
+	}
+	return b.exec(civ.CmdSplit, boolByte(true))
+}
+
+func abs64(v int64) int64 {
+	if v < 0 {
+		return -v
+	}
+	return v
+}

internal/cat/icomserial.go

@@ -94,6 +94,13 @@ type IcomSerial struct {
 	// reassembled sweep; scopeMu guards it (written by the scope goroutine, read
 	// via ScopeData from the binding goroutine).
 	dualScope bool
+	// satNative marks the two-band satellite rigs — the IC-9700 and the IC-9100 —
+	// which have a real satellite mode of their own. Everything else gets the
+	// downlink and, where the uplink is reachable, split.
+	satNative bool
+	// satOn tracks what we last told the rig, so TuneSatellite can arm the mode
+	// once rather than on every Doppler step.
+	satOn bool
 	// Set when the rig rejects the waveform-output command in both shapes: it has
 	// no stream to give, and asking again on every enable is noise.
 	scopeUnsupported bool
@@ -172,12 +179,13 @@ const (
 )
 
 // NewIcomSerial builds an (unconnected) Icom serial backend. baud defaults to
-// 115200, rig address to the IC-7610's 0x98 when out of range.
+// 115200, rig address to the IC-7610's 0x98 when out of range — and 0x00 is in
+// range: it is a valid CI-V address that some rigs and interfaces are set to.
 func NewIcomSerial(portName string, baud, civAddr int, digitalDefault string) *IcomSerial {
 	if baud <= 0 {
 		baud = 115200
 	}
-	if civAddr <= 0 || civAddr > 0xFF {
+	if civAddr < 0 || civAddr > 0xFF {
 		civAddr = 0x98 // IC-7610
 	}
 	if digitalDefault == "" {
@@ -231,6 +239,21 @@ func (b *IcomSerial) Connect() error {
 	_ = port.SetRTS(false)
 	b.port = port
 	b.model = civ.ModelName(b.rigAddr)
+	// A NEW SESSION IS NOT JUDGED ON THE OLD ONE'S SILENCE.
+	//
+	// lastGoodAt bounds "the control link answers but no CI-V comes back". It
+	// belongs to a session, and it was never cleared when a new one opened —
+	// so a rig that went to standby half an hour ago handed every fresh session
+	// a half-hour-old "last good read", which is past the grace before the first
+	// command is even sent. The session was torn down at once, redialled twenty
+	// seconds later, and torn down again: a loop with no way out, and the Icom
+	// console (with its power-ON button) blinking away on every pass.
+	//
+	// Cleared, the rule reads as it was written: silent since connect is a rig in
+	// standby, and the session is kept so the operator can wake it.
+	b.lastGoodAt = time.Time{}
+	b.readFails = 0
+	b.silentGrace = icomSilentGrace
 
 	// Start the reader before any request: recv() now waits on respCh, which only
 	// the reader feeds. respCh is buffered so a burst (or the scope stream) never
@@ -268,6 +291,10 @@ func (b *IcomSerial) Connect() error {
 	// non-default address still RENDERS; this flag only drives the SET/read commands
 	// (mode, span, edges), which need the 0x00 selector to be accepted on the 7300.
 	b.dualScope = idAddr == 0x98 || idAddr == 0xA2 || idAddr == 0x94
+	// The satellite rigs: IC-9700 and IC-9100. Both carry two receivers on two
+	// bands and a satellite mode that pairs them; no other Icom in this table
+	// does, and asking one that does not is a rejected frame per Doppler step.
+	b.satNative = idAddr == 0xA2 || idAddr == 0x7C
 	// Silence any LEFTOVER waveform stream, BLIND, before anything else. The
 	// 0x27 output flag lives in the RADIO and survives sessions; its flood is
 	// what makes the IC-7760 stop answering CI-V — so waiting for CI-V to

internal/cat/yaesu.go

@@ -59,6 +59,13 @@ var yaesuModels = map[string]string{
 	"0650": "FT-891",
 	"0670": "FT-DX3000",
 	"0460": "FT-450D",
+	// The eight-digit family. Named for the console; the frequency format is
+	// learned from the rig either way (see learnFreqWidth).
+	"0251": "FT-2000",
+	"0310": "FT-950",
+	"0583": "FTDX1200",
+	"0462": "FTDX3000",
+	"0101": "FTDX5000",
 }
 
 // yaesuModeToADIF maps the MD digit to an ADIF mode. The DATA and RTTY variants
@@ -100,6 +107,11 @@ type Yaesu struct {
 	// rxVFOCmd is "FR" when the rig reports its receive VFO that way, else empty
 	// and VS is used — see ReadState.
 	rxVFOCmd string
+	// freqDigits is how many digits this rig writes a frequency in, LEARNED from
+	// its own replies. See learnFreqWidth.
+	freqDigits int
+	// rttyUpper picks RTTY-U over RTTY-L — see SetRTTYUpper.
+	rttyUpper bool
 
 	curFreq   int64
 	curRXFreq int64
@@ -130,6 +142,18 @@ func NewYaesu(portName string, baud int, digital string) *Yaesu {
 	return &Yaesu{portName: strings.TrimSpace(portName), baud: baud, digital: digital, curVFO: "A"}
 }
 
+// SetRTTYUpper chooses which sideband RTTY is set on.
+//
+// Yaesu has both — MD06 is RTTY-L, MD09 is RTTY-U — and ADIF has neither: it
+// says "RTTY" and stops there, so the rig cannot be driven from the logged mode
+// alone. LSB is the older convention and stays the default; an operator whose
+// FSK controller or decoder wants the other one says so once here.
+func (y *Yaesu) SetRTTYUpper(v bool) {
+	y.mu.Lock()
+	defer y.mu.Unlock()
+	y.rttyUpper = v
+}
+
 // SetLowerLines chooses whether DTR and RTS are deasserted on connect. Set
 // before Connect.
 func (y *Yaesu) SetLowerLines(v bool) {
@@ -275,6 +299,7 @@ func (y *Yaesu) ReadState() (RigState, error) {
 	if err != nil {
 		return RigState{}, err // the rig stopped answering — let the Manager reconnect
 	}
+	y.learnFreqWidth(faRaw, "FA")
 	freqA, ok := parseYaesuFreq(faRaw, "FA")
 	if !ok {
 		return RigState{}, fmt.Errorf("yaesu: unparsable FA reply %q", faRaw)
@@ -355,7 +380,7 @@ func (y *Yaesu) SetFrequency(hz int64) error {
 	if y.curVFO == "B" {
 		cmd = "FB"
 	}
-	return y.write(fmt.Sprintf("%s%09d;", cmd, hz))
+	return y.write(fmt.Sprintf("%s%0*d;", cmd, y.freqWidth(), hz))
 }
 
 func (y *Yaesu) SetMode(mode string) error {
@@ -364,7 +389,7 @@ func (y *Yaesu) SetMode(mode string) error {
 	if y.port == nil {
 		return fmt.Errorf("yaesu: not connected")
 	}
-	d := yaesuModeDigit(mode, y.curFreq)
+	d := yaesuModeDigit(mode, y.curFreq, y.rttyUpper)
 	if d == 0 {
 		return fmt.Errorf("yaesu: no CAT mode for %q", mode)
 	}
@@ -481,7 +506,53 @@ func cmdPrefix(cmd string) string {
 	return c
 }
 
-// parseYaesuFreq reads "FA014074000;" into Hz.
+// EIGHT DIGITS OR NINE — the rig says which, and it is not a matter of taste.
+//
+// The FTDX10, FT-991A, FT-891 and FT-710 write a frequency in nine digits;
+// everything before them — FTDX3000, FTDX5000, FTDX1200, FT-2000, FT-950,
+// FT-450 — writes eight, and answers a nine-digit SET with "?;". An operator
+// with an FTDX3000 saw exactly that: every FA command rejected, a radio that
+// would not follow, and nothing to say why.
+//
+// The width is LEARNED rather than tabulated: the rig announces it in every
+// reply to "FA;", so the answer comes from the radio in front of the operator
+// instead of from a list of models that will always be one release behind. Nine
+// until the first reply lands, which is what the modern rigs use and what this
+// backend was written against.
+const yaesuFreqDigitsDefault = 9
+
+func (y *Yaesu) freqWidth() int {
+	if y.freqDigits >= 8 && y.freqDigits <= 11 {
+		return y.freqDigits
+	}
+	return yaesuFreqDigitsDefault
+}
+
+// learnFreqWidth takes the width from a frequency reply. Only a reply that
+// parses as a frequency teaches anything — a "?;" or a stray frame says nothing
+// about the format, and a width learned from one would be worse than the
+// default.
+func (y *Yaesu) learnFreqWidth(reply, prefix string) {
+	r := strings.TrimSpace(reply)
+	if !strings.HasPrefix(r, prefix) {
+		return
+	}
+	digits := strings.TrimSuffix(strings.TrimPrefix(r, prefix), ";")
+	if len(digits) < 8 || len(digits) > 11 {
+		return
+	}
+	for _, c := range digits {
+		if c < '0' || c > '9' {
+			return
+		}
+	}
+	if y.freqDigits != len(digits) {
+		debugLog.Printf("yaesu: this rig writes frequencies in %d digits — commands will match", len(digits))
+		y.freqDigits = len(digits)
+	}
+}
+
+// parseYaesuFreq reads "FA014074000;" (or "FA14074000;") into Hz.
 func parseYaesuFreq(reply, prefix string) (int64, bool) {
 	r := strings.TrimSpace(reply)
 	if !strings.HasPrefix(r, prefix) {
@@ -551,7 +622,7 @@ func resolveYaesuVFOs(freqA, freqB int64, vfo string, split bool) (tx, rx int64,
 // yaesuModeDigit maps an ADIF mode to the MD digit. SSB has no single digit —
 // the sideband follows the worldwide convention (LSB below 10 MHz, USB above),
 // which is why the current frequency is part of the decision.
-func yaesuModeDigit(mode string, freqHz int64) byte {
+func yaesuModeDigit(mode string, freqHz int64, rttyUpper bool) byte {
 	switch strings.ToUpper(strings.TrimSpace(mode)) {
 	case "SSB":
 		if freqHz > 0 && freqHz < 10_000_000 {
@@ -569,7 +640,10 @@ func yaesuModeDigit(mode string, freqHz int64) byte {
 	case "AM":
 		return '5'
 	case "RTTY":
-		return '6'
+		if rttyUpper {
+			return '9' // RTTY-U
+		}
+		return '6' // RTTY-L, the older convention
 	case "":
 		return 0
 	default:

internal/cat/yaesu_freqwidth_test.go

@@ -0,0 +1,38 @@
+package cat
+
+import "testing"
+
+// The FTDX10 family writes a frequency in nine digits; everything before it —
+// FTDX3000, FTDX5000, FTDX1200, FT-2000, FT-950, FT-450 — writes eight and
+// answers a nine-digit SET with "?;". Reported from an FTDX3000: every FA
+// command rejected, a radio that would not follow.
+//
+// The width is taken from the rig's own reply, so a model this backend has
+// never heard of is right on the first read.
+func TestYaesuFrequencyWidthIsLearnedFromTheRig(t *testing.T) {
+	y := &Yaesu{}
+	if got := y.freqWidth(); got != 9 {
+		t.Errorf("before any reply the width is %d, want the modern 9", got)
+	}
+
+	y.learnFreqWidth("FA14074000;", "FA") // an FTDX3000
+	if got := y.freqWidth(); got != 8 {
+		t.Errorf("width %d after an eight-digit reply, want 8", got)
+	}
+
+	y.learnFreqWidth("FA014074000;", "FA") // and an FTDX10 on the next session
+	if got := y.freqWidth(); got != 9 {
+		t.Errorf("width %d after a nine-digit reply, want 9", got)
+	}
+
+	// Nothing that is not a frequency teaches anything: a rejection, a stray
+	// frame or a reply from another command would otherwise set the format for
+	// every command that follows.
+	for _, junk := range []string{"?;", "FA;", "FB014074000;", "FA1407400X;", "FA1234567;", "FA123456789012;"} {
+		before := y.freqWidth()
+		y.learnFreqWidth(junk, "FA")
+		if after := y.freqWidth(); after != before {
+			t.Errorf("%q changed the width from %d to %d", junk, before, after)
+		}
+	}
+}

internal/cat/yaesu_panel.go

@@ -84,6 +84,11 @@ type YaesuTXState struct {
 // same shape as FlexController and IcomController.
 type YaesuController interface {
 	YaesuState() YaesuTXState
+	// SetRTTYUpper is a preference, not a command — see Yaesu.SetRTTYUpper. It
+	// belongs here so a change of mind reaches the RUNNING rig: the link is not
+	// rebuilt for it, and until it was reachable this way the setting only took
+	// effect on the next launch.
+	SetRTTYUpper(bool)
 	RefreshYaesu() error
 	SetYaesuPower(int) error
 	SetYaesuMicGain(int) error

internal/cat/yaesu_test.go

@@ -123,7 +123,7 @@ func TestYaesuModeDigit(t *testing.T) {
 		{"", 14074000, 0},      // nothing to set
 	}
 	for _, c := range cases {
-		if got := yaesuModeDigit(c.mode, c.hz); got != c.want {
+		if got := yaesuModeDigit(c.mode, c.hz, false); got != c.want {
 			t.Errorf("yaesuModeDigit(%q, %d) = %q, want %q", c.mode, c.hz, got, c.want)
 		}
 	}
@@ -406,3 +406,38 @@ func TestYaesuAntennaCommand(t *testing.T) {
 		}
 	}
 }
+
+// ADIF says "RTTY" and stops there, but Yaesu has both sidebands and the rig
+// has to be told one. LSB is the older convention and the default; the other is
+// a station's own choice, made once.
+func TestYaesuRTTYSideband(t *testing.T) {
+	if got := yaesuModeDigit("RTTY", 14_080_000, false); got != '6' {
+		t.Errorf("RTTY = %q, want RTTY-L", got)
+	}
+	if got := yaesuModeDigit("RTTY", 14_080_000, true); got != '9' {
+		t.Errorf("RTTY (upper) = %q, want RTTY-U", got)
+	}
+	// The switch is about RTTY and nothing else.
+	if got := yaesuModeDigit("FT8", 28_074_000, true); got != 'C' {
+		t.Errorf("FT8 = %q, want DATA-U", got)
+	}
+	if got := yaesuModeDigit("CW", 14_030_000, true); got != '3' {
+		t.Errorf("CW = %q, want CW-U", got)
+	}
+}
+
+// The RTTY sideband is a preference the LINK does not depend on, so it is not
+// in catLinkSig and the link is not rebuilt for it — which means the running
+// client has to accept it. It did not, and the setting waited for the next
+// launch while the rig went on choosing LSB.
+func TestYaesuAcceptsTheRTTYSidebandWhileConnected(t *testing.T) {
+	var y YaesuController = &Yaesu{}
+	y.SetRTTYUpper(true)
+	if got := y.(*Yaesu).rttyUpper; !got {
+		t.Error("a running Yaesu ignored the RTTY sideband")
+	}
+	y.SetRTTYUpper(false)
+	if got := y.(*Yaesu).rttyUpper; got {
+		t.Error("it could not be turned back")
+	}
+}

internal/extsvc/configured.go

@@ -0,0 +1,79 @@
+package extsvc
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Configured reports what a service still needs before it can be uploaded to.
+//
+// It exists so the answer lives NEXT TO THE UPLOADERS that enforce it. Written
+// once in the app instead, it drifted immediately: Club Log was refused for a
+// missing API key, which nobody has ever set — OpsLog carries its own
+// application key (see clublogAppAPIKey) and the account is an email, a password
+// and the logbook callsign. An operator whose live upload had been working for
+// months was told his service was not configured.
+//
+// Each case mirrors the guard at the top of the matching Upload* function. It
+// answers "can this be attempted", not "are these credentials right": only the
+// service can say that, and it says it by refusing the upload.
+func Configured(svc Service, cfg ExternalServices) error {
+	missing := func(service string, fields ...string) error {
+		return fmt.Errorf("%s is not configured — %s", service, strings.Join(fields, ", "))
+	}
+	set := func(v string) bool { return strings.TrimSpace(v) != "" }
+	var need []string
+	add := func(ok bool, what string) {
+		if !ok {
+			need = append(need, what)
+		}
+	}
+
+	switch svc {
+	case ServiceQRZ:
+		add(set(cfg.QRZ.APIKey), "the logbook API key")
+		if len(need) > 0 {
+			return missing("QRZ.com", need...)
+		}
+	case ServiceClublog:
+		// No API key: OpsLog's own application key is embedded.
+		add(set(cfg.Clublog.Email), "the account email")
+		add(set(cfg.Clublog.Password), "the password")
+		add(set(cfg.Clublog.Callsign), "the logbook callsign")
+		if len(need) > 0 {
+			return missing("Club Log", need...)
+		}
+	case ServiceHRDLog:
+		add(set(cfg.HRDLog.Callsign), "the station callsign")
+		add(set(cfg.HRDLog.Code), "the upload code")
+		if len(need) > 0 {
+			return missing("HRDLog.net", need...)
+		}
+	case ServiceEQSL:
+		add(set(cfg.EQSL.Username), "the username (callsign)")
+		add(set(cfg.EQSL.Password), "the password")
+		if len(need) > 0 {
+			return missing("eQSL.cc", need...)
+		}
+	case ServiceHamQTH:
+		add(set(cfg.HamQTH.Username), "the username")
+		add(set(cfg.HamQTH.Password), "the password")
+		if len(need) > 0 {
+			return missing("HamQTH", need...)
+		}
+	case ServiceCloudlog:
+		add(set(cfg.Cloudlog.URL), "the instance URL")
+		add(set(cfg.Cloudlog.APIKey), "the API key")
+		add(set(cfg.Cloudlog.StationID), "the station profile")
+		if len(need) > 0 {
+			return missing("Cloudlog / Wavelog", need...)
+		}
+	case ServiceLoTW:
+		add(set(cfg.LoTW.TQSLPath), "the path to tqsl.exe")
+		add(set(cfg.LoTW.StationLocation), "the TQSL station location")
+		if len(need) > 0 {
+			return missing("LoTW", need...)
+		}
+	}
+	return nil
+}

internal/integrations/udp/dxclear_test.go

@@ -0,0 +1,54 @@
+package udp
+
+import "testing"
+
+// Three decoders on one multicast group, which is the ordinary setup. MSHV is
+// working a station; WSJT-X and JTDX are idle and say so once a second each.
+//
+// Read across the listener rather than per program, every one of those idle
+// Status packets was a "the operator cleared the DX Call" — so OpsLog emptied
+// the entry field, MSHV's next Status refilled it, and the entry blinked and
+// the map zoomed at 1 Hz for as long as all three were running.
+func TestDXClearIsPerProgram(t *testing.T) {
+	s := &Server{}
+
+	if s.noteDXCall("MSHV", "F5NNN") {
+		t.Fatal("taking up a station is not a clear")
+	}
+	// The idle ones, interleaved, as they arrive on the wire.
+	for i := 0; i < 3; i++ {
+		if s.noteDXCall("WSJT-X", "") {
+			t.Fatal("an idle WSJT-X was read as MSHV clearing its call")
+		}
+		if s.noteDXCall("JTDX", "") {
+			t.Fatal("an idle JTDX was read as MSHV clearing its call")
+		}
+		if s.noteDXCall("MSHV", "F5NNN") {
+			t.Fatal("MSHV repeating the same station is not a clear")
+		}
+	}
+
+	// MSHV's own clear is still an edge, and only once: the Status that follows
+	// is just as empty and must not re-clear a field the operator may have
+	// typed into since.
+	if !s.noteDXCall("MSHV", "") {
+		t.Error("MSHV clearing its own DX Call was not reported")
+	}
+	if s.noteDXCall("MSHV", "") {
+		t.Error("the clear repeated on the next identical Status")
+	}
+}
+
+// Each program's edge is its own: WSJT-X letting go says nothing about MSHV.
+func TestDXClearOfOneProgramLeavesTheOthers(t *testing.T) {
+	s := &Server{}
+	s.noteDXCall("MSHV", "F5NNN")
+	s.noteDXCall("WSJT-X", "DL1ABC")
+
+	if !s.noteDXCall("WSJT-X", "") {
+		t.Error("WSJT-X clearing its own call should be reported")
+	}
+	if s.noteDXCall("MSHV", "F5NNN") {
+		t.Error("MSHV's unchanged call was disturbed by WSJT-X's clear")
+	}
+}

internal/integrations/udp/server.go

@@ -235,7 +235,16 @@ type Server struct {
 	// lastMode is the mode NAME from each program's last Status, used to resolve
 	// a Decode's one-character mode marker.
 	lastMode map[string]string
-	lastDX   string // WSJT: last non-empty DX Call seen, to detect a clear
+	// lastDX is each program's last DX Call, to spot the moment it is cleared.
+	//
+	// PER PROGRAM, and that is the whole point of the map. Two or three decoders
+	// commonly share one listener — the multicast group on 2237 is the usual
+	// setup — and a single value meant WSJT-X's empty DX Call was read as MSHV
+	// clearing the station it was calling. One "cleared" per second, alternating
+	// with MSHV re-announcing the call: the entry field emptied and refilled at
+	// 1 Hz and the map zoomed in and out with it. "The operator cleared the DX
+	// call" is a statement about ONE program, never about a socket.
+	lastDX map[string]string
 
 	// badPkts counts datagrams this listener could not parse, so the diagnostic
 	// dump below stays bounded. A misconfigured port is not a one-off: the
@@ -403,6 +412,25 @@ func (s *Server) run() {
 // radios on different bands. The port is included — a program keeps its socket
 // for as long as it runs, which is exactly the lifetime this has to be stable
 // over.
+// noteDXCall records a program's current DX Call and reports whether THIS
+// program has just cleared one.
+//
+// A decoder sends Status every second whether anything changed or not, so the
+// clear is an edge — a call, then none — and it is an edge in ONE program's
+// stream. Several decoders commonly share a listener, and reading the edge
+// across all of them made an idle WSJT-X look like MSHV abandoning the station
+// it was calling, once a second, for as long as both were running.
+func (s *Server) noteDXCall(inst, dx string) (cleared bool) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if s.lastDX == nil {
+		s.lastDX = map[string]string{}
+	}
+	prev := s.lastDX[inst]
+	s.lastDX[inst] = dx
+	return dx == "" && prev != ""
+}
+
 func (s *Server) instanceLabel(id string, remote *net.UDPAddr) string {
 	if id == "" {
 		return ""
@@ -623,12 +651,9 @@ func (s *Server) handle(pkt []byte, remote *net.UDPAddr) {
 		// operator cleared it in WSJT-X / JTDX / MSHV. Fire ONE clear (tracked per
 		// server) — an idle app sends empty Status every second, and we must not
 		// re-clear (which would fight a manual entry) on each of those.
-		s.mu.Lock()
+		if s.noteDXCall(inst, w.DXCall) {
-		prev := s.lastDX
-		s.lastDX = w.DXCall
-		s.mu.Unlock()
-		if w.DXCall == "" && prev != "" {
 			ev.ClearCall = true
+			ev.ProgramID = inst // whose clear it is — the app filters on it
 		}
 	case ServiceADIF:
 		// JTAlert / GridTracker forward a text ADIF record after a QSO is

internal/lookup/lookup.go

@@ -395,6 +395,47 @@ func titleCase(s string) string {
 // lives, and keeps the ones that say WHO they are — name, address, QSL route.
 // A portable operator's cards still go to the home address, so that address is
 // not wrong; their county is.
+// sameEntityName reports whether two country names denote the same entity.
+//
+// The two come from different vocabularies — the callbook writes "Germany"
+// where cty.dat writes "Fed. Rep. of Germany", "United States" where the ADIF
+// list says "United States of America" — so they are compared on their
+// significant words with the boilerplate of officialdom removed, and one
+// containing the other counts as a match.
+//
+// Deliberately generous. Getting it wrong in the strict direction discards a
+// correct grid, which is the fault this exists to fix; getting it wrong in the
+// generous direction keeps a location from a neighbouring entity, which is the
+// state of every callbook record that has no page for the portable call anyway.
+func sameEntityName(a, b string) bool {
+	na, nb := entityKey(a), entityKey(b)
+	if na == "" || nb == "" {
+		return false
+	}
+	return na == nb || strings.Contains(na, nb) || strings.Contains(nb, na)
+}
+
+var entityNoise = map[string]bool{
+	"THE": true, "OF": true, "FED": true, "REP": true, "REPUBLIC": true,
+	"FEDERAL": true, "FEDERATION": true, "DEM": true, "DEMOCRATIC": true,
+	"STATE": true, "KINGDOM": true, "AMERICA": true,
+}
+
+// entityKey reduces a country name to its significant letters.
+func entityKey(s string) string {
+	s = strings.ToUpper(strings.TrimSpace(s))
+	var b strings.Builder
+	for _, tok := range strings.FieldsFunc(s, func(r rune) bool {
+		return r == ' ' || r == '.' || r == ',' || r == '-'
+	}) {
+		if entityNoise[tok] {
+			continue
+		}
+		b.WriteString(tok)
+	}
+	return b.String()
+}
+
 func clearHomeLocation(r *Result) {
 	r.Country, r.Continent = "", ""
 	r.CQZ, r.ITUZ, r.DXCC = 0, 0, 0
@@ -430,11 +471,23 @@ func fillFromDXCC(r *Result, dxcc DXCCResolver) bool {
 	//
 	// Same-entity portables (F4BPO/P, W2RE/2) are untouched: the entities match,
 	// and there the home details ARE where the operator is.
+	// UNLESS THE RECORD IS ABOUT THE OPERATION ITSELF.
+	//
+	// Some compound calls have a callbook page of their own, filed under the
+	// slashed form and describing where the station actually is: QRZ's HP/WE9G
+	// carries Altos del Maria, Panama, square EJ98xq. Clearing that threw away
+	// the one field the lookup existed to find, and the QSO was logged with no
+	// grid at all while the page plainly showed one.
+	//
+	// The record's OWN country is what tells the two apart: a page for the
+	// operation names the entity being operated from, a home page names home.
 	if dxccNum != 0 && strings.ContainsRune(r.Callsign, '/') && !saysNothingAboutLocation(r.Callsign) {
 		if home := homeCall(r.Callsign); home != "" && home != r.Callsign {
 			if homeNum, _, _, _, _, _, _, homeOK := dxcc.Resolve(home); homeOK && homeNum != 0 && homeNum != dxccNum {
-				clearHomeLocation(r)
+				if !sameEntityName(r.Country, country) {
-				filled = true
+					clearHomeLocation(r)
+					filled = true
+				}
 			}
 		}
 	}

internal/lookup/portable_location_test.go

@@ -91,3 +91,60 @@ func TestSameEntityPortableKeepsItsLocation(t *testing.T) {
 		t.Errorf("lat/lon = %v/%v — the precise home position was replaced by the entity centroid", r.Lat, r.Lon)
 	}
 }
+
+// The other half again, and the one an operator reported: a compound call with
+// a callbook page OF ITS OWN. QRZ files HP/WE9G under that exact form, with the
+// Panama address and square the station is actually operating from — and the
+// QSO was being logged with no grid at all while the page plainly showed one.
+func TestACompoundCallWithItsOwnPageKeepsThatPagesLocation(t *testing.T) {
+	dxcc := testDXCC()
+	dxcc["HP/WE9G"] = struct {
+		num       int
+		country   string
+		cont      string
+		cqz, ituz int
+		lat, lon  float64
+	}{num: 88, country: "Panama", cont: "NA", cqz: 7, ituz: 11, lat: 8.5, lon: -80.0}
+	dxcc["WE9G"] = struct {
+		num       int
+		country   string
+		cont      string
+		cqz, ituz int
+		lat, lon  float64
+	}{num: 291, country: "United States", cont: "NA", cqz: 5, ituz: 8, lat: 39.8, lon: -98.5}
+
+	r := Result{
+		Callsign: "HP/WE9G",
+		Name:     "Richard B",
+		Country:  "Panama", // the RECORD's own country: this page is the operation
+		Grid:     "EJ98xq",
+		Lat:      8.686667, Lon: -80.043333,
+	}
+	fillFromDXCC(&r, dxcc)
+
+	if r.Grid != "EJ98xq" {
+		t.Errorf("grid = %q, want EJ98xq — the page describes the operation, not a home address", r.Grid)
+	}
+	if r.Lat != 8.686667 || r.Lon != -80.043333 {
+		t.Errorf("lat/lon = %v/%v — the station's own position was replaced by the entity centroid", r.Lat, r.Lon)
+	}
+}
+
+func TestSameEntityNameAcrossVocabularies(t *testing.T) {
+	same := [][2]string{
+		{"Germany", "Fed. Rep. of Germany"},
+		{"United States", "United States of America"},
+		{"Panama", "Panama"},
+		{"Kosovo", "Republic of Kosovo"},
+	}
+	for _, p := range same {
+		if !sameEntityName(p[0], p[1]) {
+			t.Errorf("%q and %q read as different entities", p[0], p[1])
+		}
+	}
+	for _, p := range [][2]string{{"Costa Rica", "United States"}, {"France", "Belgium"}, {"", "Panama"}} {
+		if sameEntityName(p[0], p[1]) {
+			t.Errorf("%q and %q read as the same entity", p[0], p[1])
+		}
+	}
+}

internal/pskr/pskr.go

@@ -319,6 +319,12 @@ type Status struct {
 	LastErr  string    `json:"last_err,omitempty"`
 	Broker   string    `json:"broker"`
 	Bands    []string  `json:"bands"`
+	// What the feed is actually filtered on, so a panel showing nothing can say
+	// WHY instead of leaving the operator to guess: the radius in force, and how
+	// many receiver squares it came to. A radius raised in Preferences that
+	// never reached the subscription is invisible without these two.
+	NearKm  int `json:"near_km"`
+	Squares int `json:"squares"`
 }
 
 func (w *Watcher) Status() Status {
@@ -327,6 +333,7 @@ func (w *Watcher) Status() Status {
 	st := Status{
 		Running: w.running, Received: w.received, LastAt: w.lastAt,
 		LastErr: w.lastErr, Broker: w.cfg.Broker,
+		NearKm: w.cfg.NearKm, Squares: len(w.cfg.RxGrids),
 	}
 	st.Bands = append(st.Bands, w.cfg.Bands...)
 	return st

internal/pskrtgt/pskrtgt.go

@@ -62,6 +62,12 @@ const (
 	// whether it is worth calling at all.
 	pileupWindow = 2 * time.Minute
 
+	// backfillEvery is how often the history query is asked again for a target
+	// that is still being watched. Five minutes is PSK Reporter's own courtesy
+	// interval for repeating a query, and it happens to be the period most
+	// uploaders batch on.
+	backfillEvery = 5 * time.Minute
+
 	// The passband histogram: 60 Hz bins from 200 Hz to 4000 Hz. Above 4 kHz
 	// there is essentially no FT8, and drawing the empty space made the strip
 	// look broken rather than empty.
@@ -202,10 +208,12 @@ type Watcher struct {
 	subs  []string
 	spots []spot
 
-	// backfilled remembers the target the REST history was fetched for, so the
+	// backfilled remembers the target the REST history was fetched for and when,
-	// panel's polling cannot re-fetch it every second. PSK Reporter's query API
+	// so the panel's polling cannot re-fetch it every second — PSK Reporter's
-	// answers that with a rate limit, and rightly.
+	// query API answers that with a rate limit, and rightly — while a target
-	backfilled string
+	// held for a while still gets a fresh look every few minutes.
+	backfilled   string
+	backfilledAt time.Time
 }
 
 func New(cfg Config) *Watcher {
@@ -271,27 +279,46 @@ func (w *Watcher) Watch(target, mode string, dialHz int64) error {
 		return nil
 	}
 
-	w.mu.Lock()
-	// The window belongs to the target it was collected for. Keeping it across a
-	// change would answer the new question with the old station's evidence.
 	if changed {
-		w.spots = w.spots[:0]
+		w.dropWindowOfPreviousTarget()
 	}
-	w.mu.Unlock()
 
 	if err := w.resubscribe(client); err != nil {
 		return err
 	}
-	if changed && w.cfg.Scope == ScopeTarget {
+	if changed {
-		// Under the band-wide subscription the window is already full of the new
+		// In BOTH scopes. The band-wide subscription was assumed to arrive with
-		// target's reports; under the narrow one it is empty, and the REST query
+		// the target's reports already in the window — true only once it has been
-		// is what makes the panel useful in the first fifteen seconds instead of
+		// running a while, and false in the case that matters: the operator picks
-		// after five minutes.
+		// a station a minute after opening the panel and sees one decode where
+		// another program, running for an hour, shows four.
 		go w.backfill(target, mode)
 	}
 	return nil
 }
 
+// dropWindowOfPreviousTarget empties the collected window when it belonged to
+// the station being left behind.
+//
+// WHOSE WINDOW IS IT? Under the narrow scope the subscription IS the target —
+// three filters about one station — so the window is his, and keeping it across
+// a change would answer the new question with the old station's evidence.
+//
+// Under the band-wide scope it is the BAND's: every FTx report on it, filtered
+// by target only when the analysis is drawn. Clearing it there threw away an
+// hour of accumulated evidence on every click, and a panel that had been showing
+// hundreds of reports read zero — the operator clicking a decode to ask "can he
+// hear me" is the very moment that history is worth something, and it was being
+// deleted in order to answer the question.
+func (w *Watcher) dropWindowOfPreviousTarget() {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	if w.cfg.Scope == ScopeBand {
+		return
+	}
+	w.spots = w.spots[:0]
+}
+
 // resubscribe replaces every filter with the ones the current target and scope
 // want. Takes the old ones down first: a target change that only ADDED filters
 // would leave the previous station's reports arriving for ever.
@@ -377,7 +404,7 @@ func (w *Watcher) connect() (mqtt.Client, error) {
 		if err := w.resubscribe(c); err != nil {
 			w.cfg.Logf("pskr target: %v", err)
 		}
-		if target != "" && w.cfg.Scope == ScopeTarget {
+		if target != "" {
 			go w.backfill(target, mode)
 		}
 	}
@@ -449,7 +476,15 @@ func (w *Watcher) SetOperator(call, grid string) {
 
 // Snapshot recomputes the analysis from the window.
 func (w *Watcher) Snapshot() Analysis {
+	// Due another look at the history? Checked here because this is what the
+	// panel calls every second; the query itself is rate-limited inside
+	// backfill, so this cannot turn into a request per poll.
 	w.mu.Lock()
+	if t, m := w.target, w.mode; t != "" && time.Since(w.backfilledAt) >= backfillEvery {
+		w.mu.Unlock()
+		go w.backfill(t, m)
+		w.mu.Lock()
+	}
 	defer w.mu.Unlock()
 
 	now := time.Now()
@@ -633,34 +668,42 @@ func top(m map[string]Entry, limit int) []Entry {
 	return out
 }
 
-// suggestOffset picks an audio slot to call on: the middle of the widest run of
+// suggestOffset picks an audio slot to call on.
-// empty bins below the ceiling.
 //
 // Below the CEILING, not below 4000 Hz. The ceiling is the highest offset he
 // has actually decoded, and it is the only evidence available about how wide
 // his receiver is set — plenty of stations run 2500 Hz. Suggesting 3400 Hz to
 // somebody whose passband stops at 2700 is advice to transmit into a filter.
+//
+// Two passes, and the second is the one that matters on a busy DX. Looking for
+// an empty run alone answered "nowhere" exactly when the answer was most
+// wanted: a hundred decodes across a 2800 Hz passband leave no run of clear
+// bins at all, and the panel drew a full histogram with no advice under it.
+// Failing a real gap, the quietest slot is still better than the one the
+// operator would have picked by eye.
 func suggestOffset(bins []Bin, ceiling int) int {
 	if ceiling < 1000 {
 		return 0
 	}
-	used := map[int]bool{}
+	count := make(map[int]int, len(bins))
+	busy := make(map[int]bool, len(bins)*3)
 	for _, b := range bins {
+		count[b.OffsetHz] = b.Count
 		if b.Count > 0 {
-			used[b.OffsetHz] = true
 			// The neighbours too: FT8 is 50 Hz wide and the bins are 60, so a
 			// signal on a bin edge covers the next one as surely as its own.
-			used[b.OffsetHz-binHz] = true
+			busy[b.OffsetHz], busy[b.OffsetHz-binHz], busy[b.OffsetHz+binHz] = true, true, true
-			used[b.OffsetHz+binHz] = true
 		}
 	}
-	bestStart, bestLen := -1, 0
-	start, run := -1, 0
 	// From 1000 Hz up: below that is where every default transmit offset sits,
-	// so it is the most crowded part of the passband and the least useful
+	// so it is the most crowded part of the passband and the least useful advice.
-	// advice.
+	const low = 1020
-	for edge := 1020; edge+binHz <= ceiling; edge += binHz {
+	high := (ceiling / binHz) * binHz
-		if used[edge] {
+
+	// Pass 1 — the widest clear run, and call from its middle.
+	bestStart, bestLen, start, run := -1, 0, -1, 0
+	for edge := low; edge <= high; edge += binHz {
+		if busy[edge] {
 			start, run = -1, 0
 			continue
 		}
@@ -672,10 +715,32 @@ func suggestOffset(bins []Bin, ceiling int) int {
 			bestStart, bestLen = start, run
 		}
 	}
-	if bestStart < 0 || bestLen < 2 {
+	if bestStart >= 0 && bestLen >= 2 {
+		return bestStart + bestLen*binHz/2
+	}
+
+	// Pass 2 — no clear run: the least busy slot. Walked from the top down, so
+	// a tie goes to the higher offset, which is the less crowded half of any
+	// passband and the half a pile-up leaves alone.
+	quietest, fewest := -1, 1<<30
+	for edge := high; edge >= low; edge -= binHz {
+		if c := count[edge]; c < fewest {
+			quietest, fewest = edge, c
+		}
+	}
+	if quietest < 0 {
 		return 0
 	}
-	return bestStart + bestLen*binHz/2
+	// Never past the ceiling: the top bin CONTAINS it, so its middle can sit
+	// beyond the highest offset he has been shown to decode — which is the one
+	// thing this function exists to avoid.
+	if quietest+binHz/2 > ceiling {
+		quietest -= binHz
+	}
+	if quietest < low {
+		return 0
+	}
+	return quietest + binHz/2
 }
 
 // bandTag names the band a dial frequency is on, in PSK Reporter's own
@@ -755,11 +820,19 @@ type pskrReports struct {
 // is what gets an application rate-limited off the service for everyone.
 func (w *Watcher) backfill(target, mode string) {
 	w.mu.Lock()
-	if w.backfilled == target {
+	// Once per target, then no more often than the refresh interval.
+	//
+	// The live feed alone lags by design: PSK Reporter's uploaders batch their
+	// reports, most of them every five minutes, so between two batches the
+	// window only holds what happened to have been sent. Asking the history
+	// again at that same cadence keeps it as full as a program that has been
+	// subscribed for an hour — which is the whole of the difference an operator
+	// sees when comparing the two side by side.
+	if w.backfilled == target && time.Since(w.backfilledAt) < backfillEvery {
 		w.mu.Unlock()
 		return
 	}
-	w.backfilled = target
+	w.backfilled, w.backfilledAt = target, time.Now()
 	w.mu.Unlock()
 
 	got := 0

internal/pskrtgt/pskrtgt_test.go

@@ -99,10 +99,12 @@ func TestSuggestOffsetAvoidsTheOccupiedBinsAndTheCeiling(t *testing.T) {
 	if got < 1620 || got > 2340 {
 		t.Errorf("suggested %d Hz, want somewhere in the empty 1560-2400 run", got)
 	}
-	// A passband that stops low must not produce advice above it: transmitting
+	// A passband with no gap at all still gets an answer — the quietest slot,
-	// past the DX's filter is the one outcome worse than picking a busy slot.
+	// which is what an operator would look for by eye. What it must never do is
-	if got := suggestOffset(bins, 1500); got != 0 {
+	// advise ABOVE the ceiling: transmitting past the DX's filter is the one
-		t.Errorf("suggested %d Hz with a 1500 Hz ceiling and no room, want none", got)
+	// outcome worse than picking a busy slot.
+	if got := suggestOffset(bins, 1500); got <= 1000 || got > 1500 {
+		t.Errorf("suggested %d Hz with a full 1500 Hz passband, want a slot inside it", got)
 	}
 	if got := suggestOffset(nil, 0); got != 0 {
 		t.Errorf("suggested %d Hz with no data at all, want none", got)
@@ -132,3 +134,48 @@ func TestTopicsFollowTheScope(t *testing.T) {
 		t.Errorf("band scope = %v, want the one band-wide filter", got)
 	}
 }
+
+// The case reported from the air: a busy DX, 103 decodes across a 2805 Hz
+// passband, and the panel drew the whole histogram with no advice under it.
+func TestACrowdedPassbandStillGetsAnAnswer(t *testing.T) {
+	// Every bin from 1020 to 2800 occupied — no clear run anywhere, and the
+	// quietest slot is the answer.
+	bins := []Bin{}
+	for hz := 1020; hz <= 2760; hz += binHz {
+		n := 5
+		if hz == 2400 { // one slot noticeably quieter than the rest
+			n = 1
+		}
+		bins = append(bins, Bin{OffsetHz: hz, Count: n})
+	}
+	got := suggestOffset(bins, 2805)
+	if got == 0 {
+		t.Fatal("no advice on a full passband — this is exactly when it is wanted")
+	}
+	if got < 2400 || got > 2460 {
+		t.Errorf("suggested %d Hz, want the quietest slot around 2400", got)
+	}
+}
+
+// Under the band-wide scope the window is the BAND's, not the target's: it is
+// every FTx report on it, filtered by target only when the analysis is drawn.
+// Clearing it on a target change threw away an hour of accumulated evidence at
+// the exact moment it was worth something — the operator clicking a decode to
+// ask "can he hear me" saw the report count drop to zero.
+func TestBandScopeKeepsItsWindowAcrossATargetChange(t *testing.T) {
+	for _, tc := range []struct {
+		scope Scope
+		keep  bool
+	}{{ScopeBand, true}, {ScopeTarget, false}} {
+		w := &Watcher{cfg: Config{Scope: tc.scope, Logf: func(string, ...any) {}}}
+		w.target, w.mode = "OLD", "FT8"
+		w.spots = []spot{{TxCall: "OLD", RxCall: "F4BPO", at: time.Now()}}
+
+		w.dropWindowOfPreviousTarget()
+		w.target = "NEW"
+
+		if got := len(w.spots) > 0; got != tc.keep {
+			t.Errorf("%s scope: window kept = %v, want %v", tc.scope, got, tc.keep)
+		}
+	}
+}

internal/rotator/easycomm/easycomm.go

@@ -0,0 +1,369 @@
+// Package easycomm drives azimuth/elevation rotator controllers that speak
+// EasyComm II, over a raw TCP socket or a serial port.
+//
+// EasyComm is what satellite rotator controllers agreed on: SatPC32, Gpredict
+// and Hamlib all speak it, so a controller that works with any of those works
+// here. The dialect matters less than it looks — every command is a two-letter
+// name with a number stuck to it, on one line, and a controller that does not
+// recognise one ignores it.
+//
+// The subset used:
+//
+//	AZ123.4 EL45.0<LF>  point there
+//	AZ EL<LF>           ask where it is — the reply is the same shape
+//	SA SE<LF>           stop both axes
+//
+// Not every controller ANSWERS. A great many EasyComm boxes — the Arduino
+// trackers above all — accept commands and never say a word back, which is
+// perfectly legal in EasyComm I and common in II. So a silent controller is not
+// treated as a broken one: the last commanded position is reported instead, and
+// the rotator keeps being driven. Refusing to work with a write-only controller
+// would rule out half the satellite stations in the hobby.
+package easycomm
+
+import (
+	"fmt"
+	"io"
+	"math"
+	"net"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"go.bug.st/serial"
+)
+
+const (
+	dialTimeout = 3 * time.Second
+	ioTimeout   = 1500 * time.Millisecond
+	// replyWait is how long a query waits before deciding the controller is one
+	// of the silent ones. Short: this runs once a second inside a pass, and a
+	// controller that is going to answer answers in milliseconds.
+	replyWait = 400 * time.Millisecond
+)
+
+// Client is one rotator controller. Exactly one of (Host, Port) or ComPort is
+// used.
+type Client struct {
+	Host    string
+	Port    int
+	ComPort string
+	Baud    int
+	// MaxAz is how far the rotator turns: 360 or 450. A 450° rotator can follow
+	// a pass straight through north without unwinding, which is the difference
+	// between hearing the whole of an overhead pass and losing the middle of it.
+	MaxAz int
+
+	mu sync.Mutex
+	// lastAz/lastEl are what was last commanded — the answer for a controller
+	// that does not talk back.
+	lastAz, lastEl float64
+	commanded      bool
+	// silent latches once a query has gone unanswered. Without it, a write-only
+	// controller costs a 400 ms wait on every single poll of a pass.
+	silent bool
+}
+
+// New builds a TCP client. There is no standard port; 4533 is Hamlib's rotctld
+// convention and the usual default in the controllers' own setup screens.
+func New(host string, port int, maxAz int) *Client {
+	if strings.TrimSpace(host) == "" {
+		host = "127.0.0.1"
+	}
+	if port <= 0 || port > 65535 {
+		port = 4533
+	}
+	return &Client{Host: host, Port: port, MaxAz: normMaxAz(maxAz)}
+}
+
+// NewSerial builds a serial client.
+func NewSerial(comPort string, baud int, maxAz int) *Client {
+	if baud <= 0 {
+		baud = 9600
+	}
+	return &Client{ComPort: comPort, Baud: baud, MaxAz: normMaxAz(maxAz)}
+}
+
+func normMaxAz(v int) int {
+	if v == 450 {
+		return 450
+	}
+	return 360
+}
+
+// Point commands the rotator to an azimuth and elevation.
+//
+// The azimuth is given in the rotator's own terms: on a 450° machine an
+// azimuth past 360 is a real, reachable position, and asking for 010 when the
+// rotator is sitting at 370 would send it the long way round through the whole
+// scale — three quarters of a turn, in the middle of a pass, with the antenna
+// pointing at the ground for most of it.
+func (c *Client) Point(az, el float64) error {
+	az = c.wrapAz(az)
+	el = clamp(el, 0, 180)
+	if err := c.send(fmt.Sprintf("AZ%.1f EL%.1f", az, el), false); err != nil {
+		return err
+	}
+	c.mu.Lock()
+	c.lastAz, c.lastEl, c.commanded = az, el, true
+	c.mu.Unlock()
+	return nil
+}
+
+// Stop halts both axes.
+func (c *Client) Stop() error { return c.send("SA SE", false) }
+
+// Heading is where the rotator says it is.
+//
+// live is false when the answer is the last commanded position rather than a
+// reading — the caller shows that differently, because "where I told it to go"
+// and "where it is" are not the same claim and a stuck rotator must not be able
+// to hide behind the first.
+func (c *Client) Heading() (az, el float64, live bool, err error) {
+	c.mu.Lock()
+	silent, la, le, commanded := c.silent, c.lastAz, c.lastEl, c.commanded
+	c.mu.Unlock()
+	if silent {
+		if !commanded {
+			return 0, 0, false, fmt.Errorf("easycomm: the controller does not report its position")
+		}
+		return la, le, false, nil
+	}
+	line, err := c.query("AZ EL")
+	if err != nil {
+		// One silence is enough: a controller either answers or it does not, and
+		// this runs every second for the length of a pass.
+		c.mu.Lock()
+		c.silent = true
+		c.mu.Unlock()
+		if commanded {
+			return la, le, false, nil
+		}
+		return 0, 0, false, err
+	}
+	a, e, ok := parseHeading(line)
+	if !ok {
+		c.mu.Lock()
+		c.silent = true
+		c.mu.Unlock()
+		if commanded {
+			return la, le, false, nil
+		}
+		return 0, 0, false, fmt.Errorf("easycomm: could not read %q", line)
+	}
+	return a, e, true, nil
+}
+
+// wrapAz brings an azimuth into what this rotator can reach.
+//
+// On a 360° machine that is a plain modulo. On a 450° one the extra 90° is an
+// OVERLAP — 370 and 10 are the same direction — and which of the two to use is
+// decided by whichever is nearer where the rotator already is, so a pass
+// crossing north continues instead of unwinding.
+func (c *Client) wrapAz(az float64) float64 {
+	az = math.Mod(az, 360)
+	if az < 0 {
+		az += 360
+	}
+	if c.MaxAz != 450 {
+		return az
+	}
+	c.mu.Lock()
+	cur, known := c.lastAz, c.commanded
+	c.mu.Unlock()
+	if !known {
+		return az
+	}
+	alt := az + 360
+	if alt > 450 {
+		return az
+	}
+	if math.Abs(alt-cur) < math.Abs(az-cur) {
+		return alt
+	}
+	return az
+}
+
+// ── Transport ───────────────────────────────────────────────────────────────
+
+type heldPort struct {
+	p        serial.Port
+	openedAt time.Time
+}
+
+var (
+	portsMu   sync.Mutex
+	openPorts = map[string]*heldPort{}
+)
+
+// bootSettle: an Arduino-based controller resets when its serial port is
+// opened, and its bootloader then holds the processor for a second or more. A
+// command sent into that window is simply lost — which is how a controller that
+// answers a terminal perfectly reports nothing here.
+const bootSettle = 2 * time.Second
+
+func acquire(com string, baud int) (*heldPort, error) {
+	portsMu.Lock()
+	defer portsMu.Unlock()
+	if h, ok := openPorts[com]; ok && h.p != nil {
+		return h, nil
+	}
+	if baud <= 0 {
+		baud = 9600
+	}
+	sp, err := serial.Open(com, &serial.Mode{BaudRate: baud})
+	if err != nil {
+		return nil, fmt.Errorf("open rotator %s @ %d baud: %w", com, baud, err)
+	}
+	_ = sp.SetReadTimeout(150 * time.Millisecond)
+	h := &heldPort{p: sp, openedAt: time.Now()}
+	openPorts[com] = h
+	return h, nil
+}
+
+func drop(com string) {
+	portsMu.Lock()
+	defer portsMu.Unlock()
+	if h, ok := openPorts[com]; ok {
+		if h.p != nil {
+			_ = h.p.Close()
+		}
+		delete(openPorts, com)
+	}
+}
+
+// Close releases the serial port. TCP dials per command and holds nothing.
+func (c *Client) Close() {
+	if c.ComPort != "" {
+		drop(c.ComPort)
+	}
+}
+
+func (c *Client) send(cmd string, wantReply bool) error {
+	_, err := c.exchange(cmd, wantReply)
+	return err
+}
+
+func (c *Client) query(cmd string) (string, error) { return c.exchange(cmd, true) }
+
+func (c *Client) exchange(cmd string, wantReply bool) (string, error) {
+	var conn io.ReadWriteCloser
+	if c.ComPort != "" {
+		h, err := acquire(c.ComPort, c.Baud)
+		if err != nil {
+			return "", err
+		}
+		if wait := bootSettle - time.Since(h.openedAt); wait > 0 {
+			time.Sleep(wait)
+		}
+		conn = h.p
+		drain(h.p)
+	} else {
+		nc, err := net.DialTimeout("tcp", net.JoinHostPort(c.Host, strconv.Itoa(c.Port)), dialTimeout)
+		if err != nil {
+			return "", fmt.Errorf("connect rotator %s:%d: %w", c.Host, c.Port, err)
+		}
+		_ = nc.SetDeadline(time.Now().Add(ioTimeout))
+		defer nc.Close()
+		conn = nc
+	}
+	// LF, not CR: EasyComm's own documents use a line feed, and the controllers
+	// that want CR accept either. The reverse is not true of every Arduino
+	// sketch out there.
+	if _, err := conn.Write([]byte(cmd + "\n")); err != nil {
+		if c.ComPort != "" {
+			drop(c.ComPort)
+		}
+		return "", fmt.Errorf("send %q: %w", cmd, err)
+	}
+	if !wantReply {
+		return "", nil
+	}
+	buf := make([]byte, 128)
+	var sb strings.Builder
+	deadline := time.Now().Add(replyWait)
+	for time.Now().Before(deadline) {
+		n, err := conn.Read(buf)
+		if n > 0 {
+			sb.Write(buf[:n])
+			if strings.ContainsAny(sb.String(), "\r\n") {
+				break
+			}
+		}
+		if err != nil {
+			break
+		}
+	}
+	line := strings.TrimSpace(sb.String())
+	if line == "" {
+		return "", fmt.Errorf("no reply to %q", cmd)
+	}
+	return line, nil
+}
+
+func drain(sp serial.Port) {
+	buf := make([]byte, 256)
+	for {
+		n, err := sp.Read(buf)
+		if n == 0 || err != nil {
+			return
+		}
+	}
+}
+
+// parseHeading reads a controller's answer.
+//
+// The shapes in the wild differ more than the specification suggests —
+// "AZ123.4 EL45.0", "AZ=123.4 EL=45.0", "+123.4+045.0", lower case, tabs — so
+// this looks for the two labels and takes the number attached to each rather
+// than trying to match a whole line.
+func parseHeading(line string) (az, el float64, ok bool) {
+	up := strings.ToUpper(line)
+	az, aok := numberAfter(up, "AZ")
+	el, eok := numberAfter(up, "EL")
+	if !aok {
+		return 0, 0, false
+	}
+	// Elevation missing is not a broken reply: an azimuth-only controller
+	// answering an AZ EL query says what it has.
+	if !eok {
+		el = 0
+	}
+	return az, el, true
+}
+
+func numberAfter(s, label string) (float64, bool) {
+	i := strings.Index(s, label)
+	if i < 0 {
+		return 0, false
+	}
+	rest := strings.TrimLeft(s[i+len(label):], " \t=:")
+	end := 0
+	for end < len(rest) {
+		ch := rest[end]
+		if (ch >= '0' && ch <= '9') || ch == '.' || ((ch == '-' || ch == '+') && end == 0) {
+			end++
+			continue
+		}
+		break
+	}
+	if end == 0 {
+		return 0, false
+	}
+	v, err := strconv.ParseFloat(strings.TrimSuffix(rest[:end], "."), 64)
+	if err != nil {
+		return 0, false
+	}
+	return v, true
+}
+
+func clamp(v, lo, hi float64) float64 {
+	if v < lo {
+		return lo
+	}
+	if v > hi {
+		return hi
+	}
+	return v
+}

internal/rotator/easycomm/easycomm_test.go

@@ -0,0 +1,92 @@
+package easycomm
+
+import "testing"
+
+// Every one of these is a shape a real controller has been seen to answer with.
+// The point of the parser is that none of them is special-cased.
+func TestParseHeading(t *testing.T) {
+	for _, tc := range []struct {
+		line   string
+		az, el float64
+		ok     bool
+	}{
+		{"AZ123.4 EL45.0", 123.4, 45, true},
+		{"AZ=123.4 EL=45.0", 123.4, 45, true},
+		{"az 123.4 el 45.0", 123.4, 45, true},
+		{"AZ123.4\tEL45.0\r\n", 123.4, 45, true},
+		{"AZ012.0 EL000.0", 12, 0, true},
+		{"AZ370.5 EL05.5", 370.5, 5.5, true},
+		{"AZ123.4", 123.4, 0, true}, // azimuth-only controller
+		{"RPRT 0", 0, 0, false},
+		{"", 0, 0, false},
+	} {
+		az, el, ok := parseHeading(tc.line)
+		if ok != tc.ok {
+			t.Errorf("%q: ok=%v, wanted %v", tc.line, ok, tc.ok)
+			continue
+		}
+		if ok && (az != tc.az || el != tc.el) {
+			t.Errorf("%q: got %.1f/%.1f, wanted %.1f/%.1f", tc.line, az, el, tc.az, tc.el)
+		}
+	}
+}
+
+// The 450° overlap is the whole reason a satellite rotator is worth having: a
+// pass crossing north must continue past 360 instead of unwinding through the
+// entire scale with the antenna sweeping the ground.
+func TestWrapAz450(t *testing.T) {
+	c := &Client{MaxAz: 450}
+	// Nothing commanded yet: no history to be near, so the plain bearing.
+	if got := c.wrapAz(10); got != 10 {
+		t.Errorf("first move: got %.1f, wanted 10", got)
+	}
+	c.lastAz, c.commanded = 350, true
+	// Crossing north: 370 is 20° away, 10 is 340° away.
+	if got := c.wrapAz(10); got != 370 {
+		t.Errorf("crossing north from 350: got %.1f, wanted 370", got)
+	}
+	// Coming back down the same way, the overlap stays the near answer.
+	c.lastAz = 370
+	if got := c.wrapAz(350); got != 350 {
+		t.Errorf("back from 370: got %.1f, wanted 350", got)
+	}
+	// Beyond the rotator's reach there is no overlap to use.
+	c.lastAz = 440
+	if got := c.wrapAz(100); got != 100 {
+		t.Errorf("past the end of the scale: got %.1f, wanted 100", got)
+	}
+}
+
+func TestWrapAz360(t *testing.T) {
+	c := &Client{MaxAz: 360}
+	c.lastAz, c.commanded = 350, true
+	if got := c.wrapAz(10); got != 10 {
+		t.Errorf("a 360 rotator has no overlap: got %.1f, wanted 10", got)
+	}
+	if got := c.wrapAz(-10); got != 350 {
+		t.Errorf("negative bearing: got %.1f, wanted 350", got)
+	}
+	if got := c.wrapAz(725); got != 5 {
+		t.Errorf("two turns and five degrees: got %.1f, wanted 5", got)
+	}
+}
+
+// A controller that never answers must not be treated as a broken one: the last
+// commanded position is reported, marked as not live.
+func TestSilentControllerReportsCommanded(t *testing.T) {
+	c := &Client{MaxAz: 360, silent: true}
+	if _, _, _, err := c.Heading(); err == nil {
+		t.Error("a silent controller with nothing commanded should say it cannot report")
+	}
+	c.lastAz, c.lastEl, c.commanded = 120, 30, true
+	az, el, live, err := c.Heading()
+	if err != nil {
+		t.Fatalf("after a command: %v", err)
+	}
+	if live {
+		t.Error("a commanded position must not be reported as a live reading")
+	}
+	if az != 120 || el != 30 {
+		t.Errorf("got %.1f/%.1f, wanted 120/30", az, el)
+	}
+}

internal/rotator/pst/pst.go

@@ -11,6 +11,7 @@ import (
 	"fmt"
 	"net"
 	"strconv"
+	"strings"
 	"time"
 )
 
@@ -85,6 +86,76 @@ func (c *Client) Heading() (az int, raw string, err error) {
 	return a, raw, nil
 }
 
+// Elevation queries PstRotator for the current elevation.
+//
+// Same shape as Heading, and the same port+1 listener — but a great many
+// PstRotator setups drive an azimuth-only rotator and answer nothing at all,
+// which is why the caller is expected to ask once and stop rather than wait a
+// second and a half per poll for a reply that is never coming.
+//
+// The reply is matched on its LABEL and not on "the first number in it": AZ?
+// and EL? both report on the same port, so taking the first integer of whatever
+// arrives would happily read an azimuth as an elevation.
+func (c *Client) Elevation() (el int, raw string, err error) {
+	pc, err := net.ListenPacket("udp4", fmt.Sprintf(":%d", c.Port+1))
+	if err != nil {
+		return 0, "", fmt.Errorf("listen :%d for PstRotator reply: %w", c.Port+1, err)
+	}
+	defer pc.Close()
+
+	if err := c.send("<PST>EL?</PST>"); err != nil {
+		return 0, "", fmt.Errorf("query PstRotator: %w", err)
+	}
+	_ = pc.SetReadDeadline(time.Now().Add(1500 * time.Millisecond))
+	buf := make([]byte, 512)
+	n, _, rerr := pc.ReadFrom(buf)
+	if rerr != nil {
+		return 0, "", fmt.Errorf("no reply on :%d: %w", c.Port+1, rerr)
+	}
+	raw = string(buf[:n])
+	v, ok := parseLabelled(raw, "EL", "AZ")
+	if !ok {
+		return 0, raw, fmt.Errorf("no elevation in reply %q", raw)
+	}
+	return v, raw, nil
+}
+
+// parseLabelled reads the number attached to a label — "EL:45", "EL 45",
+// "<PST><ELEVATION>45</ELEVATION></PST>".
+//
+// The number is the first one AFTER the label, and false is returned when the
+// label is absent — which is how an answer to the other question gets refused
+// rather than read as this one.
+func parseLabelled(s, label, other string) (int, bool) {
+	up := strings.ToUpper(s)
+	i := strings.Index(up, label)
+	if i < 0 {
+		return 0, false
+	}
+	// A reply carrying BOTH labels is answering the other question first; only
+	// what follows our own label counts.
+	rest := up[i+len(label):]
+	if j := strings.Index(rest, other); j >= 0 {
+		rest = rest[:j]
+	}
+	j := 0
+	for j < len(rest) && (rest[j] < '0' || rest[j] > '9') {
+		j++
+	}
+	k := j
+	for k < len(rest) && rest[k] >= '0' && rest[k] <= '9' {
+		k++
+	}
+	if k == j {
+		return 0, false
+	}
+	n, err := strconv.Atoi(rest[j:k])
+	if err != nil {
+		return 0, false
+	}
+	return n, true
+}
+
 // parseAzimuth extracts the first integer found in a PstRotator reply
 // ("AZ:123", "123", "<PST><AZIMUTH>123</AZIMUTH></PST>", …) and normalises
 // it to [0,360).

internal/sat/birds.go

@@ -0,0 +1,285 @@
+package sat
+
+import (
+	_ "embed"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"sync"
+)
+
+// The frequency side of a satellite: what to listen on, what to transmit on,
+// and how the two are tied together.
+//
+// The elements say where a bird is; this says what to do with the radio when it
+// is there. They are separate on purpose — the elements change every few days
+// and come from a feed, while a transponder plan changes when a satellite is
+// commanded into another mode, which is a matter for the operator and AMSAT's
+// published chart.
+//
+// The shipped list is a STARTING POINT, not an authority: satellites are
+// switched between modes, transponders are turned off for a season, and new
+// ones fly. It is copied to the data directory on first use and read from there
+// afterwards, so an operator can correct a frequency without waiting for a
+// release — and keep the correction across updates.
+
+//go:embed birds.json
+var shippedBirds []byte
+
+// BirdsName is the editable copy in the data directory.
+const BirdsName = "satellites.json"
+
+// Transponder is one usable path through a satellite.
+type Transponder struct {
+	Label string `json:"label"`
+	Mode  string `json:"mode"` // ADIF: FM, SSB, CW, DATA
+
+	// The downlink and uplink passbands, in Hz. A single frequency (an FM
+	// repeater, a beacon) sets only the "lo" of each side.
+	DownLo int64 `json:"down_lo"`
+	DownHi int64 `json:"down_hi,omitempty"`
+	UpLo   int64 `json:"up_lo,omitempty"`
+	UpHi   int64 `json:"up_hi,omitempty"`
+
+	// Inverting: the transponder turns the passband over, so tuning UP the
+	// downlink means going DOWN the uplink. Getting this backwards puts the
+	// operator's transmission at the far end of the passband from the station
+	// they can hear — which is the classic first evening on a linear bird.
+	Inverting bool `json:"inverting,omitempty"`
+
+	// CTCSS is the subaudible tone an FM uplink needs, in Hz. Zero = none.
+	CTCSS float64 `json:"ctcss,omitempty"`
+}
+
+// Linear reports a transponder with a passband rather than a single channel.
+func (t Transponder) Linear() bool { return t.DownHi > t.DownLo && t.UpHi > t.UpLo }
+
+// UplinkFor is where to transmit in order to be heard at downHz on the
+// downlink.
+//
+// On a channel (FM) the answer is the uplink frequency, whatever the operator
+// is tuned to. On a linear transponder it is a position in the passband — the
+// same distance in from the edge, and from the OTHER edge when the transponder
+// inverts.
+func (t Transponder) UplinkFor(downHz int64) int64 {
+	if t.UpLo <= 0 {
+		return 0 // receive-only: a beacon, or a downlink we have no way to answer
+	}
+	if !t.Linear() {
+		return t.UpLo
+	}
+	if downHz < t.DownLo {
+		downHz = t.DownLo
+	}
+	if downHz > t.DownHi {
+		downHz = t.DownHi
+	}
+	offset := downHz - t.DownLo
+	if t.Inverting {
+		return t.UpHi - offset
+	}
+	return t.UpLo + offset
+}
+
+// DownlinkFor is the inverse: where a station transmitting at upHz comes out.
+// It exists for the operator who tunes the uplink first — rarer, but the split
+// has to be consistent whichever end they take hold of.
+func (t Transponder) DownlinkFor(upHz int64) int64 {
+	if !t.Linear() {
+		return t.DownLo
+	}
+	if upHz < t.UpLo {
+		upHz = t.UpLo
+	}
+	if upHz > t.UpHi {
+		upHz = t.UpHi
+	}
+	if t.Inverting {
+		return t.DownLo + (t.UpHi - upHz)
+	}
+	return t.DownLo + (upHz - t.UpLo)
+}
+
+// Centre is the middle of the downlink passband — where to park when the
+// operator picks a satellite and has not yet chosen a frequency in it.
+func (t Transponder) Centre() int64 {
+	if !t.Linear() {
+		return t.DownLo
+	}
+	return t.DownLo + (t.DownHi-t.DownLo)/2
+}
+
+// Bird is one satellite's frequency plan.
+type Bird struct {
+	Name    string   `json:"name"`
+	Aliases []string `json:"aliases,omitempty"`
+	// Geostationary: no pass, no Doppler worth correcting, a fixed look angle.
+	// QO-100 is the reason the flag exists, and it changes what the whole
+	// tracking side does — there is nothing to predict and nothing to follow.
+	Geostationary bool          `json:"geostationary,omitempty"`
+	Transponders  []Transponder `json:"transponders"`
+}
+
+// Matches reports whether a name from an element feed is this satellite.
+//
+// The same rules Find uses, exposed for the other direction: the caller holds a
+// bird and is scanning an element set spelled by somebody else.
+func (b Bird) Matches(feedName string) bool {
+	cands := []string{feedName}
+	if i := strings.IndexByte(feedName, '('); i > 0 {
+		cands = append(cands, feedName[:i], strings.Trim(feedName[i:], "()"))
+	}
+	names := append([]string{b.Name}, b.Aliases...)
+	if i := strings.IndexByte(b.Name, '('); i > 0 {
+		names = append(names, b.Name[:i], strings.Trim(b.Name[i:], "()"))
+	}
+	for _, n := range names {
+		ln := loose(n)
+		if ln == "" {
+			continue
+		}
+		for _, c := range cands {
+			if ln == loose(c) {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// Birds is the frequency plan for every satellite the station knows.
+type Birds struct {
+	mu    sync.RWMutex
+	list  []Bird
+	byKey map[string]int // name and aliases, loosely normalised → index in list
+}
+
+// loose is the matching form of a satellite name: upper case, letters and
+// digits only.
+//
+// Feeds, AMSAT and operators all spell the same bird differently — "ES'HAIL 2",
+// "ESHAIL-2", "Es'hail 2" — and none of them is wrong. Comparing the letters and
+// digits alone is what lets the frequency plan meet the element set without a
+// dozen aliases per satellite.
+func loose(name string) string {
+	var b strings.Builder
+	for _, r := range strings.ToUpper(name) {
+		if (r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9') {
+			b.WriteRune(r)
+		}
+	}
+	return b.String()
+}
+
+// LoadBirds reads the plan from the data directory, writing the shipped copy
+// there first if there is none.
+//
+// A file the operator has broken is NOT overwritten: it is reported and the
+// shipped list is used for this session, so a stray comma costs a correction
+// rather than the corrections of the last two years.
+func LoadBirds(dir string) (*Birds, error) {
+	b := &Birds{}
+	path := filepath.Join(dir, BirdsName)
+	data, err := os.ReadFile(path)
+	switch {
+	case err == nil:
+		if perr := b.parse(data); perr != nil {
+			_ = b.parse(shippedBirds)
+			return b, fmt.Errorf("sat: %s could not be read (%w) — the shipped list is in use for this session, and your file has been left alone", BirdsName, perr)
+		}
+		return b, nil
+	case os.IsNotExist(err):
+		if perr := b.parse(shippedBirds); perr != nil {
+			return nil, perr
+		}
+		if werr := os.MkdirAll(dir, 0o755); werr == nil {
+			_ = os.WriteFile(path, shippedBirds, 0o644)
+		}
+		return b, nil
+	default:
+		_ = b.parse(shippedBirds)
+		return b, err
+	}
+}
+
+func (b *Birds) parse(data []byte) error {
+	var list []Bird
+	if err := json.Unmarshal(data, &list); err != nil {
+		return err
+	}
+	byKey := make(map[string]int, len(list)*3)
+	put := func(name string, i int) {
+		if k := loose(name); k != "" {
+			// First writer wins: a satellite's own name must never be displaced by
+			// another bird's alias.
+			if _, seen := byKey[k]; !seen {
+				byKey[k] = i
+			}
+		}
+	}
+	for i, bird := range list {
+		put(bird.Name, i)
+	}
+	for i, bird := range list {
+		for _, a := range bird.Aliases {
+			put(a, i)
+		}
+		// "RADFXSAT (FOX-1B)" is one string in the feed and two names to an
+		// operator; index both halves so either spelling finds the bird.
+		if j := strings.IndexByte(bird.Name, '('); j > 0 {
+			put(bird.Name[:j], i)
+			put(strings.Trim(bird.Name[j:], "()"), i)
+		}
+	}
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	b.list, b.byKey = list, byKey
+	return nil
+}
+
+// Find looks a satellite up by name or alias.
+//
+// Celestrak says "RADFXSAT (FOX-1B)" where every operator says AO-91, so the
+// bracketed halves are tried on their own before giving up — that is how most
+// feed names differ from the name on the chart.
+func (b *Birds) Find(name string) (Bird, bool) {
+	b.mu.RLock()
+	defer b.mu.RUnlock()
+	try := func(s string) (Bird, bool) {
+		if i, ok := b.byKey[loose(s)]; ok {
+			return b.list[i], true
+		}
+		return Bird{}, false
+	}
+	if bird, ok := try(name); ok {
+		return bird, true
+	}
+	if i := strings.IndexByte(name, '('); i > 0 {
+		if bird, ok := try(name[:i]); ok {
+			return bird, true
+		}
+		if bird, ok := try(strings.Trim(name[i:], "()")); ok {
+			return bird, true
+		}
+	}
+	return Bird{}, false
+}
+
+// All lists the plan, in name order.
+func (b *Birds) All() []Bird {
+	b.mu.RLock()
+	defer b.mu.RUnlock()
+	out := append([]Bird(nil), b.list...)
+	sort.Slice(out, func(i, j int) bool { return out[i].Name < out[j].Name })
+	return out
+}
+
+// Len is how many satellites carry a frequency plan.
+func (b *Birds) Len() int {
+	b.mu.RLock()
+	defer b.mu.RUnlock()
+	return len(b.list)
+}

internal/sat/birds.json

@@ -0,0 +1,444 @@
+[
+  {
+    "name": "ISS (ZARYA)",
+    "aliases": [
+      "ISS",
+      "ZARYA",
+      "ARISS"
+    ],
+    "transponders": [
+      {
+        "label": "FM voice repeater",
+        "mode": "FM",
+        "down_lo": 437800000,
+        "up_lo": 145990000,
+        "ctcss": 67
+      },
+      {
+        "label": "APRS digipeater",
+        "mode": "DATA",
+        "down_lo": 145825000,
+        "up_lo": 145825000
+      },
+      {
+        "label": "SSTV",
+        "mode": "FM",
+        "down_lo": 145800000
+      }
+    ]
+  },
+  {
+    "name": "SO-50",
+    "aliases": [
+      "SAUDISAT 1C",
+      "SAUDISAT 1C (SO-50)"
+    ],
+    "transponders": [
+      {
+        "label": "FM voice repeater",
+        "mode": "FM",
+        "down_lo": 436795000,
+        "up_lo": 145850000,
+        "ctcss": 67
+      }
+    ]
+  },
+  {
+    "name": "AO-91",
+    "aliases": [
+      "RADFXSAT",
+      "FOX-1B",
+      "RADFXSAT (FOX-1B)"
+    ],
+    "transponders": [
+      {
+        "label": "FM voice repeater",
+        "mode": "FM",
+        "down_lo": 145960000,
+        "up_lo": 435250000,
+        "ctcss": 67
+      }
+    ]
+  },
+  {
+    "name": "IO-86",
+    "aliases": [
+      "LAPAN-A2",
+      "LAPAN-ORARI"
+    ],
+    "transponders": [
+      {
+        "label": "FM voice repeater",
+        "mode": "FM",
+        "down_lo": 435880000,
+        "up_lo": 145880000,
+        "ctcss": 88.5
+      }
+    ]
+  },
+  {
+    "name": "PO-101",
+    "aliases": [
+      "DIWATA-2",
+      "DIWATA-2B"
+    ],
+    "transponders": [
+      {
+        "label": "FM voice repeater (scheduled)",
+        "mode": "FM",
+        "down_lo": 145900000,
+        "up_lo": 437500000,
+        "ctcss": 141.3
+      }
+    ]
+  },
+  {
+    "name": "AO-7",
+    "aliases": [
+      "AMSAT-OSCAR 7",
+      "OSCAR 7"
+    ],
+    "transponders": [
+      {
+        "label": "Mode B linear (inverting)",
+        "mode": "SSB",
+        "down_lo": 145925000,
+        "down_hi": 145975000,
+        "up_lo": 432125000,
+        "up_hi": 432175000,
+        "inverting": true
+      },
+      {
+        "label": "Mode A linear",
+        "mode": "SSB",
+        "down_lo": 29400000,
+        "down_hi": 29500000,
+        "up_lo": 145850000,
+        "up_hi": 145950000
+      }
+    ]
+  },
+  {
+    "name": "FO-29",
+    "aliases": [
+      "JAS-2",
+      "FUJI-OSCAR 29"
+    ],
+    "transponders": [
+      {
+        "label": "Linear (inverting)",
+        "mode": "SSB",
+        "down_lo": 435800000,
+        "down_hi": 435900000,
+        "up_lo": 145900000,
+        "up_hi": 146000000,
+        "inverting": true
+      }
+    ]
+  },
+  {
+    "name": "AO-73",
+    "aliases": [
+      "FUNCUBE-1",
+      "FUNCUBE 1"
+    ],
+    "transponders": [
+      {
+        "label": "Linear (inverting)",
+        "mode": "SSB",
+        "down_lo": 145950000,
+        "down_hi": 145970000,
+        "up_lo": 435130000,
+        "up_hi": 435150000,
+        "inverting": true
+      }
+    ]
+  },
+  {
+    "name": "JO-97",
+    "aliases": [
+      "JY1SAT",
+      "JY1-SAT"
+    ],
+    "transponders": [
+      {
+        "label": "Linear (inverting)",
+        "mode": "SSB",
+        "down_lo": 145855000,
+        "down_hi": 145875000,
+        "up_lo": 435100000,
+        "up_hi": 435120000,
+        "inverting": true
+      }
+    ]
+  },
+  {
+    "name": "RS-44",
+    "aliases": [
+      "DOSAAF-85"
+    ],
+    "transponders": [
+      {
+        "label": "Linear (inverting)",
+        "mode": "SSB",
+        "down_lo": 435640000,
+        "down_hi": 435680000,
+        "up_lo": 145965000,
+        "up_hi": 146005000,
+        "inverting": true
+      }
+    ]
+  },
+  {
+    "name": "QO-100",
+    "aliases": [
+      "ES'HAIL 2",
+      "ESHAIL 2",
+      "ES'HAIL-2"
+    ],
+    "geostationary": true,
+    "transponders": [
+      {
+        "label": "Narrowband linear",
+        "mode": "SSB",
+        "down_lo": 10489550000,
+        "down_hi": 10489800000,
+        "up_lo": 2400050000,
+        "up_hi": 2400300000
+      },
+      {
+        "label": "Wideband (DATV)",
+        "mode": "DATA",
+        "down_lo": 10491000000,
+        "down_hi": 10499000000,
+        "up_lo": 2401500000,
+        "up_hi": 2409500000
+      }
+    ]
+  },
+  {
+    "name": "TEVEL-1",
+    "aliases": [
+      "TEVEL 1"
+    ],
+    "transponders": [
+      {
+        "label": "FM voice repeater",
+        "mode": "FM",
+        "down_lo": 436400000,
+        "up_lo": 145970000,
+        "ctcss": 67
+      }
+    ]
+  },
+  {
+    "name": "TEVEL-2",
+    "aliases": [
+      "TEVEL 2"
+    ],
+    "transponders": [
+      {
+        "label": "FM voice repeater",
+        "mode": "FM",
+        "down_lo": 436400000,
+        "up_lo": 145970000,
+        "ctcss": 67
+      }
+    ]
+  },
+  {
+    "name": "TEVEL-3",
+    "aliases": [
+      "TEVEL 3"
+    ],
+    "transponders": [
+      {
+        "label": "FM voice repeater",
+        "mode": "FM",
+        "down_lo": 436400000,
+        "up_lo": 145970000,
+        "ctcss": 67
+      }
+    ]
+  },
+  {
+    "name": "TEVEL-4",
+    "aliases": [
+      "TEVEL 4"
+    ],
+    "transponders": [
+      {
+        "label": "FM voice repeater",
+        "mode": "FM",
+        "down_lo": 436400000,
+        "up_lo": 145970000,
+        "ctcss": 67
+      }
+    ]
+  },
+  {
+    "name": "TEVEL-5",
+    "aliases": [
+      "TEVEL 5"
+    ],
+    "transponders": [
+      {
+        "label": "FM voice repeater",
+        "mode": "FM",
+        "down_lo": 436400000,
+        "up_lo": 145970000,
+        "ctcss": 67
+      }
+    ]
+  },
+  {
+    "name": "TEVEL-6",
+    "aliases": [
+      "TEVEL 6"
+    ],
+    "transponders": [
+      {
+        "label": "FM voice repeater",
+        "mode": "FM",
+        "down_lo": 436400000,
+        "up_lo": 145970000,
+        "ctcss": 67
+      }
+    ]
+  },
+  {
+    "name": "TEVEL-7",
+    "aliases": [
+      "TEVEL 7"
+    ],
+    "transponders": [
+      {
+        "label": "FM voice repeater",
+        "mode": "FM",
+        "down_lo": 436400000,
+        "up_lo": 145970000,
+        "ctcss": 67
+      }
+    ]
+  },
+  {
+    "name": "TEVEL-8",
+    "aliases": [
+      "TEVEL 8"
+    ],
+    "transponders": [
+      {
+        "label": "FM voice repeater",
+        "mode": "FM",
+        "down_lo": 436400000,
+        "up_lo": 145970000,
+        "ctcss": 67
+      }
+    ]
+  },
+  {
+    "name": "EO-88",
+    "aliases": [
+      "NAYIF-1",
+      "FUNCUBE-5"
+    ],
+    "transponders": [
+      {
+        "label": "Linear (inverting)",
+        "mode": "SSB",
+        "down_lo": 145960000,
+        "down_hi": 145990000,
+        "up_lo": 435015000,
+        "up_hi": 435045000,
+        "inverting": true
+      }
+    ]
+  },
+  {
+    "name": "AO-109",
+    "aliases": [
+      "RADFXSAT-2",
+      "FOX-1E"
+    ],
+    "transponders": [
+      {
+        "label": "Linear (inverting)",
+        "mode": "SSB",
+        "down_lo": 145860000,
+        "down_hi": 145880000,
+        "up_lo": 435750000,
+        "up_hi": 435770000,
+        "inverting": true
+      }
+    ]
+  },
+  {
+    "name": "CAS-4A",
+    "aliases": [
+      "ZHUHAI-1 OVS-1A",
+      "OVS-1A"
+    ],
+    "transponders": [
+      {
+        "label": "Linear (inverting)",
+        "mode": "SSB",
+        "down_lo": 145860000,
+        "down_hi": 145880000,
+        "up_lo": 435210000,
+        "up_hi": 435230000,
+        "inverting": true
+      }
+    ]
+  },
+  {
+    "name": "CAS-4B",
+    "aliases": [
+      "ZHUHAI-1 OVS-1B",
+      "OVS-1B"
+    ],
+    "transponders": [
+      {
+        "label": "Linear (inverting)",
+        "mode": "SSB",
+        "down_lo": 145905000,
+        "down_hi": 145925000,
+        "up_lo": 435270000,
+        "up_hi": 435290000,
+        "inverting": true
+      }
+    ]
+  },
+  {
+    "name": "TO-108",
+    "aliases": [
+      "CAS-6",
+      "TIANQIN-1"
+    ],
+    "transponders": [
+      {
+        "label": "Linear (inverting)",
+        "mode": "SSB",
+        "down_lo": 145915000,
+        "down_hi": 145935000,
+        "up_lo": 435270000,
+        "up_hi": 435290000,
+        "inverting": true
+      }
+    ]
+  },
+  {
+    "name": "IO-117",
+    "aliases": [
+      "GREENCUBE",
+      "MEZTLI"
+    ],
+    "transponders": [
+      {
+        "label": "Digipeater (1200 bd GMSK)",
+        "mode": "DATA",
+        "down_lo": 435310000,
+        "up_lo": 435310000
+      }
+    ]
+  }
+]

internal/sat/birds_test.go

@@ -0,0 +1,188 @@
+package sat
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// The shipped list has to be readable and consistent — it is embedded, so a
+// mistake in it is a mistake in every build.
+func TestShippedBirds(t *testing.T) {
+	b := &Birds{}
+	if err := b.parse(shippedBirds); err != nil {
+		t.Fatalf("birds.json does not parse: %v", err)
+	}
+	if b.Len() < 5 {
+		t.Fatalf("only %d satellites shipped", b.Len())
+	}
+	for _, bird := range b.All() {
+		if len(bird.Transponders) == 0 {
+			t.Errorf("%s has no transponder", bird.Name)
+		}
+		for _, tr := range bird.Transponders {
+			if tr.DownLo <= 0 {
+				t.Errorf("%s / %s: no downlink", bird.Name, tr.Label)
+			}
+			if tr.DownHi != 0 && tr.DownHi <= tr.DownLo {
+				t.Errorf("%s / %s: downlink passband runs backwards", bird.Name, tr.Label)
+			}
+			if tr.UpHi != 0 && tr.UpHi <= tr.UpLo {
+				t.Errorf("%s / %s: uplink passband runs backwards", bird.Name, tr.Label)
+			}
+			// A linear transponder whose two passbands are different widths cannot
+			// map one onto the other, and the split would drift across the pass.
+			if tr.Linear() && (tr.DownHi-tr.DownLo) != (tr.UpHi-tr.UpLo) {
+				t.Errorf("%s / %s: passbands are %d and %d Hz wide",
+					bird.Name, tr.Label, tr.DownHi-tr.DownLo, tr.UpHi-tr.UpLo)
+			}
+		}
+	}
+}
+
+func TestFindByAlias(t *testing.T) {
+	b := &Birds{}
+	if err := b.parse(shippedBirds); err != nil {
+		t.Fatal(err)
+	}
+	// Every spelling on the left is one an operator or a feed actually uses.
+	for _, tc := range []struct{ query, want string }{
+		{"AO-91", "AO-91"},
+		{"RADFXSAT (FOX-1B)", "AO-91"},
+		{"radfxsat", "AO-91"},
+		{"ISS (ZARYA)", "ISS (ZARYA)"},
+		{"ISS", "ISS (ZARYA)"},
+		{"SAUDISAT 1C (SO-50)", "SO-50"},
+		{"so 50", "SO-50"},
+		{"QO-100", "QO-100"},
+		{"ESHAIL-2", "QO-100"},
+		{"Es'hail 2", "QO-100"},
+	} {
+		got, ok := b.Find(tc.query)
+		if !ok {
+			t.Errorf("%q was not found", tc.query)
+			continue
+		}
+		if got.Name != tc.want {
+			t.Errorf("%q found %q, wanted %q", tc.query, got.Name, tc.want)
+		}
+	}
+	if _, ok := b.Find("NOAA 15"); ok {
+		t.Error("a weather satellite should not carry an amateur frequency plan")
+	}
+}
+
+// Matches is the other direction: a bird in hand, scanning a feed's names.
+func TestBirdMatches(t *testing.T) {
+	b := Bird{Name: "AO-91", Aliases: []string{"RADFXSAT", "FOX-1B"}}
+	for _, feed := range []string{"AO-91", "RADFXSAT (FOX-1B)", "radfxsat", "FOX 1B"} {
+		if !b.Matches(feed) {
+			t.Errorf("%q was not recognised as AO-91", feed)
+		}
+	}
+	for _, feed := range []string{"AO-92", "NOAA 15", "FOX-1A"} {
+		if b.Matches(feed) {
+			t.Errorf("%q was wrongly taken for AO-91", feed)
+		}
+	}
+	// A bracketed catalogue name matched from the other side.
+	iss := Bird{Name: "ISS (ZARYA)"}
+	if !iss.Matches("ISS") || !iss.Matches("ZARYA") {
+		t.Error("the ISS was not recognised by either half of its catalogue name")
+	}
+}
+
+// The uplink maths is the part that matters on the air: a station worked at one
+// end of an inverting transponder has to be answered at the other.
+func TestUplinkFor(t *testing.T) {
+	inv := Transponder{
+		DownLo: 435800000, DownHi: 435900000,
+		UpLo: 145900000, UpHi: 146000000,
+		Inverting: true,
+	}
+	straight := Transponder{
+		DownLo: 29400000, DownHi: 29500000,
+		UpLo: 145850000, UpHi: 145950000,
+	}
+	fm := Transponder{DownLo: 436795000, UpLo: 145850000}
+
+	for _, tc := range []struct {
+		name string
+		tr   Transponder
+		down int64
+		want int64
+	}{
+		{"inverting, bottom of the downlink", inv, 435800000, 146000000},
+		{"inverting, top of the downlink", inv, 435900000, 145900000},
+		{"inverting, 30 kHz up", inv, 435830000, 145970000},
+		{"straight, bottom", straight, 29400000, 145850000},
+		{"straight, 25 kHz up", straight, 29425000, 145875000},
+		{"FM channel ignores the tuned downlink", fm, 436798000, 145850000},
+		{"below the passband is clamped", inv, 435700000, 146000000},
+		{"above the passband is clamped", inv, 436000000, 145900000},
+	} {
+		if got := tc.tr.UplinkFor(tc.down); got != tc.want {
+			t.Errorf("%s: got %d, wanted %d", tc.name, got, tc.want)
+		}
+	}
+
+	// Receive-only: a beacon has nothing to answer on.
+	if got := (Transponder{DownLo: 145800000}).UplinkFor(145800000); got != 0 {
+		t.Errorf("a receive-only transponder gave an uplink of %d", got)
+	}
+}
+
+// Whichever end the operator takes hold of, the pair has to agree.
+func TestDownlinkForRoundTrip(t *testing.T) {
+	for _, tr := range []Transponder{
+		{DownLo: 435800000, DownHi: 435900000, UpLo: 145900000, UpHi: 146000000, Inverting: true},
+		{DownLo: 29400000, DownHi: 29500000, UpLo: 145850000, UpHi: 145950000},
+	} {
+		for _, down := range []int64{tr.DownLo, tr.Centre(), tr.DownHi} {
+			if got := tr.DownlinkFor(tr.UplinkFor(down)); got != down {
+				t.Errorf("inverting=%v: %d → uplink → %d", tr.Inverting, down, got)
+			}
+		}
+	}
+}
+
+func TestLoadBirdsWritesTheEditableCopy(t *testing.T) {
+	dir := t.TempDir()
+	b, err := LoadBirds(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	shipped := b.Len()
+	path := filepath.Join(dir, BirdsName)
+	if _, err := os.Stat(path); err != nil {
+		t.Fatalf("the editable copy was not written: %v", err)
+	}
+
+	// An operator's own list is what gets used from then on.
+	mine := `[{"name":"MY-SAT","transponders":[{"label":"FM","mode":"FM","down_lo":1,"up_lo":2}]}]`
+	if err := os.WriteFile(path, []byte(mine), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	b, err = LoadBirds(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if b.Len() != 1 {
+		t.Fatalf("the operator's list was not used: %d satellites", b.Len())
+	}
+
+	// And a broken one falls back without destroying what they wrote.
+	if err := os.WriteFile(path, []byte("[{oops"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	b, err = LoadBirds(dir)
+	if err == nil {
+		t.Error("a broken list was accepted silently")
+	}
+	if b.Len() != shipped {
+		t.Errorf("the shipped list did not take over: %d satellites", b.Len())
+	}
+	if data, _ := os.ReadFile(path); string(data) != "[{oops" {
+		t.Error("the operator's broken file was overwritten")
+	}
+}

internal/sat/sat.go

@@ -0,0 +1,372 @@
+// Package sat is where a satellite is, where it will be, and what that does to
+// a frequency.
+//
+// Three things live here and nothing else: the orbital elements a station keeps
+// (Store), the sky as seen from that station (Track, Passes), and the Doppler
+// shift the motion imposes (Shift). The radio, the rotator and the screen are
+// all somebody else's business — they are handed numbers by the app layer.
+//
+// The propagation itself is SGP4 from github.com/akhenakh/sgp4 (Apache-2.0,
+// pure Go): the model everyone in this hobby uses, and the one the TLEs are
+// built for. Writing it again would be writing it worse.
+package sat
+
+import (
+	"fmt"
+	"math"
+	"sort"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/akhenakh/sgp4"
+)
+
+// speedOfLightKmS is the constant every Doppler correction here is built on.
+const speedOfLightKmS = 299792.458
+
+// Observer is the ground station: where the antenna is, in degrees and metres.
+type Observer struct {
+	Lat, Lon float64
+	AltM     float64
+}
+
+// Position is a satellite seen from the ground at one instant.
+//
+// The two halves answer different questions and both are wanted: where the
+// thing IS (for the map) and where to POINT (for the rotator and the Doppler).
+type Position struct {
+	Name string    `json:"name"`
+	At   time.Time `json:"at"`
+
+	// Sub-satellite point and height — the map's half.
+	Lat       float64 `json:"lat"`
+	Lon       float64 `json:"lon"`
+	AltKm     float64 `json:"alt_km"`
+	Footprint float64 `json:"footprint_km"` // radius of the visibility circle
+
+	// Look angles — the station's half.
+	Az        float64 `json:"az"`
+	El        float64 `json:"el"`
+	RangeKm   float64 `json:"range_km"`
+	RangeRate float64 `json:"range_rate"` // km/s, positive = receding
+}
+
+// Visible reports whether the satellite is above the horizon.
+//
+// Zero degrees, not a courtesy margin: an operator with a clear take-off works
+// a pass from the moment it rises, and a station in a valley knows its own
+// horizon better than this package ever will.
+func (p Position) Visible() bool { return p.El > 0 }
+
+// Pass is one crossing of the sky, from rise to set.
+type Pass struct {
+	Name     string    `json:"name"`
+	AOS      time.Time `json:"aos"`
+	LOS      time.Time `json:"los"`
+	AOSAz    float64   `json:"aos_az"`
+	LOSAz    float64   `json:"los_az"`
+	MaxEl    float64   `json:"max_el"`
+	MaxElAz  float64   `json:"max_el_az"`
+	MaxElAt  time.Time `json:"max_el_at"`
+	Duration float64   `json:"duration_s"`
+}
+
+// Element is one satellite's orbital elements, as they were published.
+//
+// The raw lines are kept beside the parsed form because they are what gets
+// written to the cache and what an operator pastes in by hand for a bird that
+// is not in any feed yet — a freshly launched one, above all, which is exactly
+// when everybody wants to hear it.
+type Element struct {
+	Name  string `json:"name"`
+	NORAD int    `json:"norad"`
+	Line1 string `json:"line1"`
+	Line2 string `json:"line2"`
+	// Epoch is when these elements were computed. Their accuracy falls away
+	// from it, which is why the store knows how old they are.
+	Epoch time.Time `json:"epoch"`
+
+	tle *sgp4.TLE
+}
+
+// Age is how long ago these elements were computed.
+func (e Element) Age() time.Duration {
+	if e.Epoch.IsZero() {
+		return 0
+	}
+	return time.Since(e.Epoch)
+}
+
+// ParseElement reads one satellite from its two or three TLE lines.
+func ParseElement(name, line1, line2 string) (Element, error) {
+	name = strings.TrimSpace(name)
+	line1 = strings.TrimSpace(line1)
+	line2 = strings.TrimSpace(line2)
+	if line1 == "" || line2 == "" {
+		return Element{}, fmt.Errorf("sat: %q has no orbital elements", name)
+	}
+	raw := line1 + "\n" + line2
+	if name != "" {
+		raw = name + "\n" + raw
+	}
+	t, err := sgp4.ParseTLE(raw)
+	if err != nil {
+		return Element{}, fmt.Errorf("sat: %q: %w", name, err)
+	}
+	if name == "" {
+		name = strings.TrimSpace(t.Name)
+	}
+	return Element{
+		Name:  name,
+		NORAD: t.SatelliteNumber,
+		Line1: line1,
+		Line2: line2,
+		Epoch: tleEpoch(t),
+		tle:   t,
+	}, nil
+}
+
+// tleEpoch turns the two-digit year and fractional day of a TLE into a time.
+//
+// The pivot is the one the format itself defines: 57 and above is the twentieth
+// century, below it the twenty-first. It matters for the AGE of the elements,
+// which is how an operator knows whether to trust a prediction.
+func tleEpoch(t *sgp4.TLE) time.Time {
+	if t == nil || t.EpochDay <= 0 {
+		return time.Time{}
+	}
+	year := t.EpochYear
+	switch {
+	case year >= 57 && year <= 99:
+		year += 1900
+	case year < 57:
+		year += 2000
+	}
+	start := time.Date(year, 1, 1, 0, 0, 0, 0, time.UTC)
+	return start.Add(time.Duration((t.EpochDay - 1) * float64(24*time.Hour)))
+}
+
+// Store holds the elements a station tracks. Safe for concurrent use: the app
+// refreshes it from a feed while the tracking loop reads it several times a
+// second.
+type Store struct {
+	mu    sync.RWMutex
+	byKey map[string]Element
+	order []string // insertion order, so a listing reads like the feed
+	fetch time.Time
+}
+
+func NewStore() *Store { return &Store{byKey: map[string]Element{}} }
+
+// key is how a satellite is addressed. Case and spacing vary between feeds and
+// between the operator's typing; the NORAD number would be exact but is not
+// what anybody says out loud.
+func key(name string) string { return strings.ToUpper(strings.TrimSpace(name)) }
+
+// Put adds or replaces one satellite's elements.
+func (s *Store) Put(e Element) {
+	if e.tle == nil || e.Name == "" {
+		return
+	}
+	k := key(e.Name)
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if _, had := s.byKey[k]; !had {
+		s.order = append(s.order, k)
+	}
+	s.byKey[k] = e
+}
+
+// Get returns one satellite's elements.
+func (s *Store) Get(name string) (Element, bool) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	e, ok := s.byKey[key(name)]
+	return e, ok
+}
+
+// Names lists what the store holds, in the order it arrived.
+func (s *Store) Names() []string {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	out := make([]string, 0, len(s.order))
+	for _, k := range s.order {
+		out = append(out, s.byKey[k].Name)
+	}
+	return out
+}
+
+// Len is how many satellites are known.
+func (s *Store) Len() int {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	return len(s.byKey)
+}
+
+// FetchedAt is when the elements were last loaded from a feed, zero if never.
+func (s *Store) FetchedAt() time.Time {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	return s.fetch
+}
+
+// Replace swaps the whole set — what a feed refresh does. The order of the new
+// set is kept, and the fetch time is stamped.
+func (s *Store) Replace(els []Element, at time.Time) {
+	byKey := make(map[string]Element, len(els))
+	order := make([]string, 0, len(els))
+	for _, e := range els {
+		if e.tle == nil || e.Name == "" {
+			continue
+		}
+		k := key(e.Name)
+		if _, had := byKey[k]; !had {
+			order = append(order, k)
+		}
+		byKey[k] = e
+	}
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.byKey, s.order, s.fetch = byKey, order, at
+}
+
+// Track is where one satellite is, seen from one station, at one instant.
+func (s *Store) Track(name string, obs Observer, at time.Time) (Position, error) {
+	e, ok := s.Get(name)
+	if !ok {
+		return Position{}, fmt.Errorf("sat: %q is not in the element set", name)
+	}
+	return e.Track(obs, at)
+}
+
+// Track is the same for elements already in hand.
+func (e Element) Track(obs Observer, at time.Time) (Position, error) {
+	if e.tle == nil {
+		return Position{}, fmt.Errorf("sat: %q has no usable elements", e.Name)
+	}
+	loc := &sgp4.Location{Latitude: obs.Lat, Longitude: obs.Lon, Altitude: obs.AltM}
+	eci, err := e.tle.FindPositionAtTime(at.UTC())
+	if err != nil {
+		return Position{}, fmt.Errorf("sat: %q: %w", e.Name, err)
+	}
+	// The state vector carries the position AND the velocity, which is what the
+	// look angle needs for the range rate — and the range rate is the whole of
+	// the Doppler shift.
+	sv := &sgp4.StateVector{
+		X: eci.Position.X, Y: eci.Position.Y, Z: eci.Position.Z,
+		VX: eci.Velocity.X, VY: eci.Velocity.Y, VZ: eci.Velocity.Z,
+	}
+	o, err := sv.GetLookAngle(loc, at.UTC())
+	if err != nil {
+		return Position{}, fmt.Errorf("sat: %q look angle: %w", e.Name, err)
+	}
+	return Position{
+		Name:      e.Name,
+		At:        at.UTC(),
+		Lat:       o.SatellitePos.Latitude,
+		Lon:       o.SatellitePos.Longitude,
+		AltKm:     o.SatellitePos.Altitude,
+		Footprint: footprintKm(o.SatellitePos.Altitude),
+		Az:        o.LookAngles.Azimuth,
+		El:        o.LookAngles.Elevation,
+		RangeKm:   o.LookAngles.Range,
+		RangeRate: o.LookAngles.RangeRate,
+	}, nil
+}
+
+// earthRadiusKm is the mean radius — the footprint is a circle drawn on a
+// sphere, and a metre of flattening does not show at that scale.
+const earthRadiusKm = 6371.0
+
+// footprintKm is the radius of the circle from which the satellite is above the
+// horizon: the ground distance to where it sits exactly on it.
+func footprintKm(altKm float64) float64 {
+	if altKm <= 0 {
+		return 0
+	}
+	return earthRadiusKm * math.Acos(earthRadiusKm/(earthRadiusKm+altKm))
+}
+
+// Passes lists the crossings of the sky between two instants.
+//
+// minEl drops the passes not worth waiting for: a bird that scrapes three
+// degrees over the horizon is a line in a table that will never be a QSO, and
+// on a busy evening those are most of the list.
+func (s *Store) Passes(name string, obs Observer, from, to time.Time, minEl float64) ([]Pass, error) {
+	e, ok := s.Get(name)
+	if !ok {
+		return nil, fmt.Errorf("sat: %q is not in the element set", name)
+	}
+	if !to.After(from) {
+		return nil, fmt.Errorf("sat: the window ends before it starts")
+	}
+	// Thirty seconds: fine enough that the rise and set times are right to a few
+	// seconds, coarse enough that a day of predictions for a dozen satellites
+	// stays instant.
+	details, err := e.tle.GeneratePasses(obs.Lat, obs.Lon, obs.AltM, from.UTC(), to.UTC(), 30)
+	if err != nil {
+		return nil, fmt.Errorf("sat: %q passes: %w", e.Name, err)
+	}
+	out := make([]Pass, 0, len(details))
+	for _, d := range details {
+		if d.MaxElevation < minEl {
+			continue
+		}
+		out = append(out, Pass{
+			Name:     e.Name,
+			AOS:      d.AOS.UTC(),
+			LOS:      d.LOS.UTC(),
+			AOSAz:    d.AOSAzimuth,
+			LOSAz:    d.LOSAzimuth,
+			MaxEl:    d.MaxElevation,
+			MaxElAz:  d.MaxElevationAz,
+			MaxElAt:  d.MaxElevationTime.UTC(),
+			Duration: d.Duration.Seconds(),
+		})
+	}
+	return out, nil
+}
+
+// NextPasses is Passes over several satellites at once, in time order — the
+// question an operator actually asks: what is coming, and when.
+func (s *Store) NextPasses(names []string, obs Observer, from time.Time, window time.Duration, minEl int) []Pass {
+	var all []Pass
+	for _, n := range names {
+		ps, err := s.Passes(n, obs, from, from.Add(window), float64(minEl))
+		if err != nil {
+			continue // a satellite whose elements are missing is simply not listed
+		}
+		all = append(all, ps...)
+	}
+	sort.Slice(all, func(i, j int) bool { return all[i].AOS.Before(all[j].AOS) })
+	return all
+}
+
+// Shift is the Doppler-corrected pair for one moment.
+type Shift struct {
+	DownHz int64 `json:"down_hz"` // where to LISTEN for a nominal downlink
+	UpHz   int64 `json:"up_hz"`   // where to TRANSMIT for a nominal uplink
+}
+
+// Doppler corrects a nominal uplink/downlink pair for the satellite's motion.
+//
+// Two corrections, opposite in sign, and that is the part worth being careful
+// about: the DOWNLINK is what we receive, so it arrives shifted and we tune to
+// meet it — approaching (negative range rate) means a higher frequency. The
+// UPLINK is what the satellite receives, so we must transmit shifted the other
+// way for it to land on the transponder's nominal input.
+//
+// Zero in, zero out: a satellite with no uplink (a beacon) is not given an
+// invented one.
+func Doppler(p Position, downHz, upHz int64) Shift {
+	f := -p.RangeRate / speedOfLightKmS // fraction, positive when approaching
+	var s Shift
+	if downHz > 0 {
+		s.DownHz = downHz + int64(math.Round(float64(downHz)*f))
+	}
+	if upHz > 0 {
+		s.UpHz = upHz - int64(math.Round(float64(upHz)*f))
+	}
+	return s
+}

internal/sat/sat_test.go

@@ -0,0 +1,172 @@
+package sat
+
+import (
+	"math"
+	"testing"
+	"time"
+)
+
+// A real ISS element set, and the answers a second tracker agrees with. The
+// point is not the third decimal — it is that the observer, the epoch and the
+// look angle are wired the right way round, which is exactly what silently
+// comes out mirrored or an hour late.
+const (
+	issName  = "ISS (ZARYA)"
+	issLine1 = "1 25544U 98067A   24298.54791435  .00016717  00000+0  30074-3 0  9991"
+	issLine2 = "2 25544  51.6392 121.4587 0007976  86.1587  27.9639 15.50126585478227"
+)
+
+func issElement(t *testing.T) Element {
+	t.Helper()
+	e, err := ParseElement(issName, issLine1, issLine2)
+	if err != nil {
+		t.Fatalf("parse: %v", err)
+	}
+	return e
+}
+
+func TestElementCarriesItsIdentityAndEpoch(t *testing.T) {
+	e := issElement(t)
+	if e.NORAD != 25544 {
+		t.Errorf("NORAD = %d, want 25544", e.NORAD)
+	}
+	// Day 298.548 of 2024 — the day the elements were computed.
+	want := time.Date(2024, 10, 24, 13, 9, 0, 0, time.UTC)
+	if d := e.Epoch.Sub(want); d > time.Minute || d < -time.Minute {
+		t.Errorf("epoch = %s, want about %s", e.Epoch.Format(time.RFC3339), want.Format(time.RFC3339))
+	}
+}
+
+// The satellite is somewhere, that somewhere is on Earth's scale, and the look
+// angles are self-consistent: a bird below the horizon is further away than one
+// overhead, and the footprint is a plausible circle.
+func TestTrackIsSaneFromAKnownStation(t *testing.T) {
+	e := issElement(t)
+	obs := Observer{Lat: 48.85, Lon: 2.35, AltM: 35} // JN18, Paris
+	at := time.Date(2024, 10, 24, 14, 0, 0, 0, time.UTC)
+
+	p, err := e.Track(obs, at)
+	if err != nil {
+		t.Fatalf("track: %v", err)
+	}
+	if p.Lat < -90 || p.Lat > 90 || p.Lon < -180 || p.Lon > 180 {
+		t.Errorf("sub-satellite point off the planet: %.3f %.3f", p.Lat, p.Lon)
+	}
+	if p.AltKm < 300 || p.AltKm > 500 {
+		t.Errorf("altitude %.1f km — the ISS is not there", p.AltKm)
+	}
+	if p.Az < 0 || p.Az >= 360 || p.El < -90 || p.El > 90 {
+		t.Errorf("look angles out of range: az %.1f el %.1f", p.Az, p.El)
+	}
+	// A satellite on the FAR side of the planet is still at a distance — up to
+	// two Earth radii plus its height — so the useful invariant is the one that
+	// holds when it is actually up: above the horizon it cannot be further away
+	// than the slant range to its own footprint edge.
+	if p.RangeKm < 300 || p.RangeKm > 13200 {
+		t.Errorf("range %.0f km is not this orbit seen from the ground", p.RangeKm)
+	}
+	if p.El > 0 && p.RangeKm > 2600 {
+		t.Errorf("visible at %.1f° yet %.0f km away", p.El, p.RangeKm)
+	}
+	// ~2000 km of visibility circle at 420 km up.
+	if p.Footprint < 1500 || p.Footprint > 2600 {
+		t.Errorf("footprint %.0f km", p.Footprint)
+	}
+}
+
+// Twelve hours of ISS passes over a European station: there are always several,
+// they rise before they set, and the filter keeps its promise.
+func TestPassesRiseBeforeTheySetAndRespectTheFloor(t *testing.T) {
+	s := NewStore()
+	s.Put(issElement(t))
+	obs := Observer{Lat: 48.85, Lon: 2.35, AltM: 35}
+	from := time.Date(2024, 10, 24, 12, 0, 0, 0, time.UTC)
+
+	all, err := s.Passes(issName, obs, from, from.Add(12*time.Hour), 0)
+	if err != nil {
+		t.Fatalf("passes: %v", err)
+	}
+	if len(all) == 0 {
+		t.Fatal("no ISS pass in twelve hours over Paris")
+	}
+	for _, p := range all {
+		if !p.LOS.After(p.AOS) {
+			t.Errorf("%s: sets (%s) before it rises (%s)", p.Name, p.LOS, p.AOS)
+		}
+		if p.MaxEl <= 0 || p.MaxEl > 90 {
+			t.Errorf("max elevation %.1f", p.MaxEl)
+		}
+		if p.MaxElAt.Before(p.AOS) || p.MaxElAt.After(p.LOS) {
+			t.Errorf("the highest point falls outside the pass")
+		}
+	}
+	high, err := s.Passes(issName, obs, from, from.Add(12*time.Hour), 30)
+	if err != nil {
+		t.Fatalf("passes: %v", err)
+	}
+	if len(high) > len(all) {
+		t.Error("the elevation floor let MORE passes through")
+	}
+	for _, p := range high {
+		if p.MaxEl < 30 {
+			t.Errorf("a %.1f° pass survived a 30° floor", p.MaxEl)
+		}
+	}
+}
+
+// The two corrections go in OPPOSITE directions, and that is the whole of it:
+// the downlink arrives shifted so we tune to meet it, while the uplink has to
+// leave shifted the other way to land on the transponder's nominal input.
+func TestDopplerCorrectsBothWaysRoundTheRightWay(t *testing.T) {
+	const down, up = 145_950_000, 435_250_000
+
+	approaching := Position{RangeRate: -7.0} // km/s, coming towards us
+	receding := Position{RangeRate: +7.0}
+
+	a := Doppler(approaching, down, up)
+	if a.DownHz <= down {
+		t.Errorf("approaching: listen at %d, expected above %d", a.DownHz, down)
+	}
+	if a.UpHz >= up {
+		t.Errorf("approaching: transmit at %d, expected below %d", a.UpHz, up)
+	}
+
+	r := Doppler(receding, down, up)
+	if r.DownHz >= down {
+		t.Errorf("receding: listen at %d, expected below %d", r.DownHz, down)
+	}
+	if r.UpHz <= up {
+		t.Errorf("receding: transmit at %d, expected above %d", r.UpHz, up)
+	}
+
+	// Size, not just sign: 7 km/s on 145.950 MHz is about 3.4 kHz.
+	if d := math.Abs(float64(a.DownHz - down)); d < 3000 || d > 3800 {
+		t.Errorf("shift of %.0f Hz on 2 m at 7 km/s", d)
+	}
+	// Stationary is untouched, and an absent uplink is not invented.
+	if s := Doppler(Position{}, down, 0); s.DownHz != down || s.UpHz != 0 {
+		t.Errorf("a still satellite was corrected: %+v", s)
+	}
+}
+
+func TestStoreReplaceKeepsOrderAndStampsTheFetch(t *testing.T) {
+	s := NewStore()
+	e := issElement(t)
+	at := time.Date(2026, 9, 7, 10, 0, 0, 0, time.UTC)
+	s.Replace([]Element{e}, at)
+
+	if s.Len() != 1 || s.Names()[0] != issName {
+		t.Errorf("store holds %v", s.Names())
+	}
+	if !s.FetchedAt().Equal(at) {
+		t.Errorf("fetched at %s", s.FetchedAt())
+	}
+	// Case and spacing vary between feeds and typists; the name is not a
+	// password.
+	if _, ok := s.Get("iss (zarya)"); !ok {
+		t.Error("a satellite could not be found under its own name in another case")
+	}
+	if _, err := s.Track("NOTHING", Observer{}, at); err == nil {
+		t.Error("an unknown satellite was tracked anyway")
+	}
+}

internal/sat/tle.go

@@ -0,0 +1,230 @@
+package sat
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+// Where the elements come from, and where they are kept.
+//
+// Celestrak's amateur group is the list every tracker in this hobby uses; the
+// PE0SAT mirror is there for the day Celestrak is down or rate-limiting, which
+// it does when a hundred trackers all wake up at the top of the hour.
+const (
+	FeedCelestrak = "https://celestrak.org/NORAD/elements/gp.php?GROUP=amateur&FORMAT=tle"
+	FeedPE0SAT    = "http://tle.pe0sat.nl/kepler/amateur.txt"
+	// CacheName is the file kept in the data directory. Plain TLE text, so an
+	// operator can open it, read it, and paste a line into a tracker that is not
+	// this one.
+	CacheName = "satellites.tle"
+	// StaleAfter is when elements stop being worth trusting silently. SGP4 drifts
+	// a few hundred metres a day for a low orbit, which is nothing for a pass
+	// prediction and everything for a rotator at high elevation — so the age is
+	// SHOWN rather than enforced, and this is only the point at which OpsLog
+	// offers to fetch again.
+	StaleAfter = 3 * 24 * time.Hour
+)
+
+// ParseTLESet reads a whole feed or cache file: three lines per satellite —
+// name, then the two element lines — or two where the name is absent.
+//
+// A malformed satellite is SKIPPED, not fatal. A feed of two hundred birds with
+// one bad checksum must still give the operator the other hundred and
+// ninety-nine, and the count of what was dropped is returned so the app can say
+// so instead of quietly holding a shorter list.
+func ParseTLESet(r io.Reader) (els []Element, skipped int, err error) {
+	sc := bufio.NewScanner(r)
+	sc.Buffer(make([]byte, 0, 64*1024), 1<<20)
+	var pending []string
+	flush := func() {
+		defer func() { pending = nil }()
+		var name, l1, l2 string
+		switch len(pending) {
+		case 3:
+			name, l1, l2 = pending[0], pending[1], pending[2]
+		case 2:
+			l1, l2 = pending[0], pending[1]
+		default:
+			if len(pending) > 0 {
+				skipped++
+			}
+			return
+		}
+		e, perr := ParseElement(name, l1, l2)
+		if perr != nil {
+			skipped++
+			return
+		}
+		els = append(els, e)
+	}
+	for sc.Scan() {
+		line := strings.TrimRight(sc.Text(), " \t\r")
+		if strings.TrimSpace(line) == "" {
+			flush()
+			continue
+		}
+		// A "1 " or "2 " line is an element line; anything else starts a new
+		// satellite. That rule reads both the three-line and the two-line form
+		// without the file having to say which it is.
+		isElement := len(line) > 2 && (line[0] == '1' || line[0] == '2') && line[1] == ' '
+		if !isElement && len(pending) > 0 {
+			flush()
+		}
+		pending = append(pending, line)
+		if len(pending) == 3 || (len(pending) == 2 && strings.HasPrefix(pending[0], "1 ")) {
+			flush()
+		}
+	}
+	flush()
+	if err := sc.Err(); err != nil {
+		return els, skipped, fmt.Errorf("sat: reading the element set: %w", err)
+	}
+	if len(els) == 0 {
+		return nil, skipped, fmt.Errorf("sat: no usable elements in that set (%d entries refused)", skipped)
+	}
+	return els, skipped, nil
+}
+
+// Fetcher loads element sets from the feeds and keeps a copy on disk.
+type Fetcher struct {
+	Dir     string        // where the cache file lives — the app's data directory
+	Feeds   []string      // tried in order; the first that answers wins
+	Timeout time.Duration // per feed
+	Logf    func(string, ...any)
+}
+
+// NewFetcher builds one with the usual feeds.
+func NewFetcher(dir string) *Fetcher {
+	return &Fetcher{
+		Dir:     dir,
+		Feeds:   []string{FeedCelestrak, FeedPE0SAT},
+		Timeout: 20 * time.Second,
+		Logf:    func(string, ...any) {},
+	}
+}
+
+func (f *Fetcher) cachePath() string { return filepath.Join(f.Dir, CacheName) }
+
+// LoadCache reads the elements kept from last time, with the file's own
+// modification time as the fetch time.
+//
+// This is what makes the first screen after a launch a full one: an operator who
+// opens the satellite tab on a train, or on a shack PC with no internet, still
+// gets last week's elements — which are perfectly good for knowing what passes
+// tonight — instead of an empty list and a spinner.
+func (f *Fetcher) LoadCache() ([]Element, time.Time, error) {
+	p := f.cachePath()
+	fh, err := os.Open(p)
+	if err != nil {
+		return nil, time.Time{}, err
+	}
+	defer fh.Close()
+	els, skipped, err := ParseTLESet(fh)
+	if err != nil {
+		return nil, time.Time{}, err
+	}
+	at := time.Time{}
+	if st, serr := os.Stat(p); serr == nil {
+		at = st.ModTime()
+	}
+	if skipped > 0 {
+		f.Logf("sat: %d cached entries were unusable and were skipped", skipped)
+	}
+	return els, at, nil
+}
+
+// Fetch downloads a fresh set and writes the cache.
+//
+// The cache is only replaced once a feed has produced usable elements: a feed
+// that answers with an error page, a captive-portal login or an empty file must
+// not take away the set the station already had.
+func (f *Fetcher) Fetch(ctx context.Context) ([]Element, error) {
+	var lastErr error
+	for _, url := range f.Feeds {
+		els, body, err := f.fetchOne(ctx, url)
+		if err != nil {
+			f.Logf("sat: %s: %v", shortHost(url), err)
+			lastErr = err
+			continue
+		}
+		if err := f.writeCache(body); err != nil {
+			// Not fatal: the elements are in hand and the station can track
+			// tonight. Only the next cold start loses by it, and it says so.
+			f.Logf("sat: could not write the element cache: %v", err)
+		}
+		f.Logf("sat: %d satellites from %s", len(els), shortHost(url))
+		return els, nil
+	}
+	if lastErr == nil {
+		lastErr = fmt.Errorf("no feed configured")
+	}
+	return nil, fmt.Errorf("sat: could not fetch the element set: %w", lastErr)
+}
+
+func (f *Fetcher) fetchOne(ctx context.Context, url string) ([]Element, []byte, error) {
+	to := f.Timeout
+	if to <= 0 {
+		to = 20 * time.Second
+	}
+	ctx, cancel := context.WithTimeout(ctx, to)
+	defer cancel()
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+	// Named, because Celestrak asks that clients identify themselves and answers
+	// an anonymous flood with a rate limit.
+	req.Header.Set("User-Agent", "OpsLog satellite tracker")
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return nil, nil, fmt.Errorf("HTTP %s", resp.Status)
+	}
+	body, err := io.ReadAll(io.LimitReader(resp.Body, 8<<20))
+	if err != nil {
+		return nil, nil, err
+	}
+	els, skipped, err := ParseTLESet(strings.NewReader(string(body)))
+	if err != nil {
+		return nil, nil, err
+	}
+	if skipped > 0 {
+		f.Logf("sat: %s: %d entries were unusable and were skipped", shortHost(url), skipped)
+	}
+	return els, body, nil
+}
+
+func (f *Fetcher) writeCache(body []byte) error {
+	if strings.TrimSpace(f.Dir) == "" {
+		return fmt.Errorf("no data directory")
+	}
+	if err := os.MkdirAll(f.Dir, 0o755); err != nil {
+		return err
+	}
+	// Written beside and renamed: a power cut mid-write must not leave a
+	// half-file that parses as twenty satellites instead of two hundred.
+	tmp := f.cachePath() + ".tmp"
+	if err := os.WriteFile(tmp, body, 0o644); err != nil {
+		return err
+	}
+	return os.Rename(tmp, f.cachePath())
+}
+
+// shortHost is a feed's host, for a log line that fits.
+func shortHost(url string) string {
+	s := strings.TrimPrefix(strings.TrimPrefix(url, "https://"), "http://")
+	if i := strings.IndexAny(s, "/?"); i > 0 {
+		s = s[:i]
+	}
+	return s
+}

internal/sat/tle_test.go

@@ -0,0 +1,87 @@
+package sat
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// Both shapes of the same file: three lines per satellite, and the two-line
+// form some feeds still serve. A reader that only understood one of them would
+// come back empty from a mirror and look like a network fault.
+func TestParseTLESetReadsBothShapes(t *testing.T) {
+	three := issName + "\n" + issLine1 + "\n" + issLine2 + "\n"
+	els, skipped, err := ParseTLESet(strings.NewReader(three))
+	if err != nil || len(els) != 1 || skipped != 0 {
+		t.Fatalf("three-line: %d sats, %d skipped, err %v", len(els), skipped, err)
+	}
+	if els[0].Name != issName {
+		t.Errorf("name %q", els[0].Name)
+	}
+
+	two := issLine1 + "\n" + issLine2 + "\n"
+	els, _, err = ParseTLESet(strings.NewReader(two))
+	if err != nil || len(els) != 1 {
+		t.Fatalf("two-line: %d sats, err %v", len(els), err)
+	}
+	if els[0].NORAD != 25544 {
+		t.Errorf("a nameless entry lost its identity: %+v", els[0])
+	}
+}
+
+// One bad satellite must not cost the operator the other hundred and
+// ninety-nine — but the count of what was dropped has to come back, or a
+// silently shorter list reads as a complete one.
+func TestParseTLESetSkipsWhatItCannotRead(t *testing.T) {
+	feed := strings.Join([]string{
+		"JUNK SATELLITE",
+		"1 99999U 00000A   24298.00000000  .00000000  00000+0  00000+0 0  0000", // bad checksum
+		"2 99999  00.0000 000.0000 0000000 000.0000 000.0000 00.00000000000000",
+		"",
+		issName, issLine1, issLine2,
+	}, "\n")
+	els, skipped, err := ParseTLESet(strings.NewReader(feed))
+	if err != nil {
+		t.Fatalf("the whole feed was refused for one bad entry: %v", err)
+	}
+	if len(els) != 1 || els[0].Name != issName {
+		t.Errorf("kept %d satellites: %+v", len(els), els)
+	}
+	if skipped != 1 {
+		t.Errorf("skipped = %d, want 1 — a silently shorter list reads as a complete one", skipped)
+	}
+	// Nothing usable at all IS an error: an error page or a captive-portal login
+	// parses as zero satellites, and that must never replace a good set.
+	if _, _, err := ParseTLESet(strings.NewReader("<html>login required</html>")); err == nil {
+		t.Error("an HTML error page was accepted as an element set")
+	}
+}
+
+// The cache is what makes the first screen after a launch a full one — on a
+// train, or on a shack PC with no internet.
+func TestCacheRoundTrip(t *testing.T) {
+	dir := t.TempDir()
+	f := NewFetcher(dir)
+	f.Logf = func(string, ...any) {}
+
+	body := issName + "\n" + issLine1 + "\n" + issLine2 + "\n"
+	if err := f.writeCache([]byte(body)); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+	if _, err := os.Stat(filepath.Join(dir, CacheName)); err != nil {
+		t.Fatalf("the cache file is not where an operator would look for it: %v", err)
+	}
+	// And no leftovers: the temp file is renamed, not copied.
+	if _, err := os.Stat(filepath.Join(dir, CacheName+".tmp")); err == nil {
+		t.Error("the half-written file was left behind")
+	}
+
+	els, at, err := f.LoadCache()
+	if err != nil || len(els) != 1 {
+		t.Fatalf("load: %d sats, err %v", len(els), err)
+	}
+	if at.IsZero() {
+		t.Error("the cache has no age, so nothing can say whether to trust it")
+	}
+}

internal/steppir/moving_test.go

@@ -0,0 +1,41 @@
+package steppir
+
+import (
+	"testing"
+	"time"
+)
+
+// The controller says nothing until its own poll comes round, so a move has to
+// be reported from the moment it is COMMANDED. Without it the app's "block TX
+// while the elements travel" had a hole: the grace covering the command ran out
+// before the first poll that would have seen the movement, and the transmitter
+// was released in the middle of a move.
+func TestAJustCommandedMoveReportsMotion(t *testing.T) {
+	c := &Client{}
+	c.lastStatus = &Status{Connected: true} // idle, as the controller last said
+
+	if st, _ := c.GetStatus(); st.MotorsMoving != 0 {
+		t.Fatal("an idle antenna reports motion")
+	}
+
+	c.statusMu.Lock()
+	c.moveCmdAt = time.Now()
+	c.statusMu.Unlock()
+
+	st, _ := c.GetStatus()
+	if st.MotorsMoving == 0 {
+		t.Error("a move commanded a moment ago is not reported as motion")
+	}
+	if c.lastStatus.MotorsMoving != 0 {
+		t.Error("the optimistic flag leaked into the cached status the poll owns")
+	}
+
+	// Bounded: an antenna that never reports motion must not latch the transmit
+	// inhibit on for ever.
+	c.statusMu.Lock()
+	c.moveCmdAt = time.Now().Add(-moveOptimisticWindow - time.Second)
+	c.statusMu.Unlock()
+	if st, _ := c.GetStatus(); st.MotorsMoving != 0 {
+		t.Error("the optimistic window never expires")
+	}
+}

internal/steppir/steppir.go

@@ -65,6 +65,25 @@ const (
 // self-corrects instead of lying forever.
 const pendingDirTTL = 45 * time.Second
 
+// The same two cadences the Ultrabeam uses, and for the same reason: transmit
+// is inhibited while the elements travel, so every poll interval between the
+// motors stopping and this client noticing is a second the operator cannot call
+// with the antenna already in place.
+const (
+	pollIdle   = 2 * time.Second
+	pollMoving = 250 * time.Millisecond
+)
+
+// moveOptimisticWindow is how long after a commanded move GetStatus reports
+// motion before the controller has had a chance to say so.
+//
+// The SteppIR reports nothing until its own poll comes round, so without this
+// the app's "block TX while moving" had a hole in it: the grace that covers the
+// command ran out before the first poll that would have seen the movement, and
+// the transmitter was released in the middle of a move. Bounded, so an antenna
+// that never reports motion cannot latch the inhibit on for ever.
+const moveOptimisticWindow = 3 * time.Second
+
 // Transport says how to reach the controller.
 type Transport struct {
 	Mode string // "tcp" | "serial"
@@ -103,6 +122,8 @@ type Client struct {
 	statusMu   sync.RWMutex
 	lastStatus *Status
 	lastSetKHz int
+	// moveCmdAt is when a move was last COMMANDED — see moveOptimisticWindow.
+	moveCmdAt time.Time
 	// lastDriftKHz is the frequency last reported for a controller that had gone
 	// somewhere other than where it was told, so the disagreement is stated once
 	// and not on every poll. Zero when it is where it should be.
@@ -191,7 +212,28 @@ func (c *Client) GetStatus() (*Status, error) {
 	if c.lastStatus == nil {
 		return &Status{Connected: false}, nil
 	}
-	return c.lastStatus, nil
+	// A COPY, so the optimistic flag below can never leak into the status the
+	// poll goroutine owns — and so a caller holding the value cannot see it
+	// change under them mid-read.
+	st := *c.lastStatus
+	if st.Connected && st.MotorsMoving == 0 && c.movingOptimisticallyLocked() {
+		st.MotorsMoving = 1 // sentinel: commanded, not yet reported (read as != 0)
+	}
+	return &st, nil
+}
+
+// movingOptimisticallyLocked reports a move commanded too recently for the
+// controller to have answered. Callers hold statusMu.
+func (c *Client) movingOptimisticallyLocked() bool {
+	return !c.moveCmdAt.IsZero() && time.Since(c.moveCmdAt) < moveOptimisticWindow
+}
+
+// MovingOptimistically is the same question from outside the lock — the poll
+// loop asks it to decide its cadence.
+func (c *Client) MovingOptimistically() bool {
+	c.statusMu.RLock()
+	defer c.statusMu.RUnlock()
+	return c.movingOptimisticallyLocked()
 }
 
 // open dials the transport. Callers hold connMu.
@@ -266,8 +308,9 @@ func (c *Client) pollLoop() {
 			close(c.done)
 		}
 	}()
-	ticker := time.NewTicker(2 * time.Second)
+	ticker := time.NewTicker(pollIdle)
 	defer ticker.Stop()
+	fast := false
 	for {
 		select {
 		case <-c.stopChan:
@@ -315,6 +358,17 @@ func (c *Client) pollLoop() {
 			c.lastStatus = st
 			c.statusMu.Unlock()
 			c.checkDrift(st)
+
+			// Follow the motors with the poll rate; changed only when it changes,
+			// since the antenna is polled for hours on end.
+			if moving := st.MotorsMoving != 0 || c.MovingOptimistically(); moving != fast {
+				fast = moving
+				if fast {
+					ticker.Reset(pollMoving)
+				} else {
+					ticker.Reset(pollIdle)
+				}
+			}
 		}
 	}
 }
@@ -639,6 +693,7 @@ func (c *Client) SetFrequency(freqKhz int, direction int) error {
 	c.statusMu.Lock()
 	c.lastSetKHz = freqKhz
 	c.pendingDir, c.pendingDirAt, c.pendingDirSet = direction, time.Now(), true
+	c.moveCmdAt = time.Now() // report motion at once — see moveOptimisticWindow
 	c.statusMu.Unlock()
 	return nil
 }

internal/ultrabeam/ultrabeam.go

@@ -134,6 +134,23 @@ type Client struct {
 // clears rather than latching the TX-inhibit on for ever.
 const ubMoveOptimisticWindow = 3 * time.Second
 
+// Poll cadences: what an idle antenna is worth, and what a moving one is worth.
+// See the poll loop.
+const (
+	ubPollIdle   = 2 * time.Second
+	ubPollMoving = 250 * time.Millisecond
+)
+
+// movingOptimistically reports whether a move was commanded so recently that the
+// antenna cannot have answered yet — the same window GetStatus reports motion
+// for, so the fast poll starts with the movement rather than one interval into
+// it.
+func (c *Client) movingOptimistically() bool {
+	c.statusMu.RLock()
+	defer c.statusMu.RUnlock()
+	return !c.moveCmdAt.IsZero() && time.Since(c.moveCmdAt) < ubMoveOptimisticWindow
+}
+
 // LastSetKHz returns the frequency (kHz) most recently commanded to the antenna,
 // or 0 if none yet.
 func (c *Client) LastSetKHz() int {
@@ -312,8 +329,22 @@ func (c *Client) pollLoop() {
 			close(c.done)
 		}
 	}()
-	ticker := time.NewTicker(2 * time.Second) // Increased from 500ms to 2s
+	// TWO CADENCES, and the fast one is what matters.
+	//
+	// An idle antenna has nothing to say, so two seconds is generous. A MOVING
+	// one has one thing to say and it is urgent: transmit is inhibited while the
+	// elements travel, so every poll interval between the motors stopping and
+	// this loop noticing is a second the operator cannot call — with the antenna
+	// already in place and the rig still gagged. Reported from the air as "it
+	// stays orange one or two seconds after it has finished".
+	//
+	// While the motors run — or a move has just been commanded — the antenna is
+	// asked four times a second. The controller answers a status query in
+	// milliseconds; this is nothing to it, and it lasts only as long as the
+	// movement does.
+	ticker := time.NewTicker(ubPollIdle)
 	defer ticker.Stop()
+	fast := false
 
 	pollCount := 0
 	pollFails := 0 // consecutive failed status polls (transient timeouts tolerated)
@@ -436,6 +467,18 @@ func (c *Client) pollLoop() {
 			c.lastStatus = status
 			c.statusMu.Unlock()
 
+			// Follow the motors with the poll rate. Changed only when it actually
+			// changes: Reset on a ticker is cheap but not free, and the antenna is
+			// polled for hours on end.
+			if moving := status.MotorsMoving != 0 || c.movingOptimistically(); moving != fast {
+				fast = moving
+				if fast {
+					ticker.Reset(ubPollMoving)
+				} else {
+					ticker.Reset(ubPollIdle)
+				}
+			}
+
 		case <-c.stopChan:
 			return
 		}

profilereload_test.go

@@ -34,6 +34,12 @@ func TestProfileSwitchReappliesEveryStartupDevice(t *testing.T) {
 		// sweepers. Its settings do follow the profile: reloadAfterProfileSwitch
 		// calls applyAutoCall, which re-reads them and clears the target.
 		"startAutoCall": "a single sweeper goroutine; applyAutoCall in the reload carries the settings",
+		// The elements and the frequency plan are FILES, shared by every
+		// profile — there is one sky. What is per profile (the favourites, the
+		// minimum elevation, the locator) is read live on every call, so a
+		// switch is already reflected without rebuilding anything. The tracker,
+		// which does transmit, IS stopped by reloadAfterProfileSwitch.
+		"startSatellites": "one sky: the elements and the plan are shared files, and the per-profile settings are read live",
 	}
 
 	startup := body(t, string(src), "func (a *App) startup(ctx context.Context) {")

pskchase.go

@@ -36,6 +36,28 @@ import (
 // have one without the other. They only share the feed, which either one starts.
 const keyChaseNew = "cluster.chase_new"
 
+// keyChaseNewBandsOff lists the bands the panel is NOT to show, comma
+// separated.
+//
+// Stored as the EXCLUSIONS rather than the selection, so that an empty setting
+// — every operator who has never opened this — means "show them all", and so
+// that a band added to the station's list later appears here on its own. Stored
+// the other way round, a selection saved today would silently hide 4 m the day
+// a transverter arrives.
+const keyChaseNewBandsOff = "cluster.chase_new_bands_off"
+
+// ChaseNewBands is the band vocabulary of the panel's own filter: HF through
+// 70 cm, in the order an operator reads a band plan.
+//
+// A fixed list, not the station's: the two answer different questions. The
+// station list says what this station can work at all, and still applies —
+// this one says what is worth WATCHING right now, which changes with the hour
+// and the season, not with the shack.
+var ChaseNewBands = []string{
+	"160m", "80m", "60m", "40m", "30m", "20m", "17m", "15m", "12m", "10m",
+	"6m", "4m", "2m", "70cm",
+}
+
 // chaseNewMax bounds the panel. A list nobody can read to the bottom is not more
 // information, and the oldest rows are the least likely to still be on the air.
 const chaseNewMax = 200
@@ -149,6 +171,69 @@ var chaseModes = map[string]bool{
 // atomic rather than the settings store.
 func (a *App) chaseNewEnabled() bool { return a.chaseNewOn.Load() }
 
+// GetChaseNewBands returns the bands the panel is set to SHOW — every band in
+// the vocabulary that has not been switched off.
+func (a *App) GetChaseNewBands() []string {
+	off := map[string]bool{}
+	for _, b := range splitCSV(a.settingOr(keyChaseNewBandsOff, "")) {
+		off[strings.ToLower(strings.TrimSpace(b))] = true
+	}
+	out := make([]string, 0, len(ChaseNewBands))
+	for _, b := range ChaseNewBands {
+		if !off[b] {
+			out = append(out, b)
+		}
+	}
+	return out
+}
+
+// SetChaseNewBands takes the bands to SHOW and stores the complement.
+//
+// Nothing is filtered out of the store retroactively: the rows already
+// collected stay until they age out, and the next message is the one that
+// obeys. A panel that emptied itself on a settings click would look like it had
+// lost the feed.
+func (a *App) SetChaseNewBands(show []string) {
+	want := map[string]bool{}
+	for _, b := range show {
+		want[strings.ToLower(strings.TrimSpace(b))] = true
+	}
+	var off []string
+	for _, b := range ChaseNewBands {
+		if !want[b] {
+			off = append(off, b)
+		}
+	}
+	a.setSetting(keyChaseNewBandsOff, strings.Join(off, ","))
+	a.refreshChaseNewBands()
+	applog.Printf("chase new: showing %d of %d bands", len(ChaseNewBands)-len(off), len(ChaseNewBands))
+}
+
+// refreshChaseNewBands re-reads the panel's own band filter into the cache the
+// feed consults. Called at startup, and whenever the selection is saved.
+func (a *App) refreshChaseNewBands() {
+	off := map[string]bool{}
+	for _, b := range splitCSV(a.settingOr(keyChaseNewBandsOff, "")) {
+		if b = strings.ToLower(strings.TrimSpace(b)); b != "" {
+			off[b] = true
+		}
+	}
+	a.chaseNewBandsOff.Store(off)
+}
+
+// chaseNewBandShown is the per-message half: a map read on the MQTT goroutine.
+func (a *App) chaseNewBandShown(band string) bool {
+	v := a.chaseNewBandsOff.Load()
+	if v == nil {
+		return true // nothing loaded yet — better to show than to swallow
+	}
+	off, ok := v.(map[string]bool)
+	if !ok {
+		return true
+	}
+	return !off[strings.ToLower(strings.TrimSpace(band))]
+}
+
 // chaseBandAllowed reports whether a band is one the operator uses.
 //
 // PSK Reporter carries every band its receivers listen on, including microwave
@@ -217,7 +302,11 @@ func (a *App) feedChaseNew(sp pskr.Spot) {
 	// Both tests before the status lookup: they are map reads on short keys and
 	// they throw away most of the feed, so nothing further down pays for a band
 	// this station cannot work or a mode nobody answers.
-	if !chaseModes[mode] || !a.chaseBandAllowed(band) {
+	// Two band tests, and they answer two questions: can this station work the
+	// band at all (its own list), and does the operator want to WATCH it right
+	// now (this panel's own filter). A station with 2 m equipment that is
+	// chasing HF tonight needs the second one.
+	if !chaseModes[mode] || !a.chaseBandAllowed(band) || !a.chaseNewBandShown(band) {
 		return
 	}
 

rxdefaults_test.go

@@ -10,6 +10,10 @@ import (
 
 // A contact that was not split still has a receive side, and the record
 // forwarded to another logger has to carry it: Log4OM reads BAND_RX.
+//
+// The record UPLOADED to a service must not: in ADIF an absent BAND_RX means
+// "same as transmit", and Wavelog shown both draws "17m/17m" on a simplex FT8
+// contact — reported by OE6CLD, who had never logged a split QSO in his life.
 func TestFillRXDefaults(t *testing.T) {
 	hz := int64(14074000)
 	q := qso.QSO{Callsign: "F4BPO", Band: "20m", FreqHz: &hz}
@@ -22,7 +26,7 @@ func TestFillRXDefaults(t *testing.T) {
 	}
 	// Assert on the RECORD another logger reads, not merely on the struct:
 	// both halves of the receive side have to reach it.
-	rec := strings.ToUpper(adif.SingleRecordADIF(q))
+	rec := strings.ToUpper(adif.ForwardRecordADIF(q))
 	if !strings.Contains(rec, "<BAND_RX:3>20M") {
 		t.Errorf("BAND_RX missing from the forwarded record:\n%s", rec)
 	}
@@ -40,3 +44,14 @@ func TestFillRXDefaultsKeepsSplit(t *testing.T) {
 		t.Errorf("split QSO was overwritten: band_rx=%q freq_rx=%v", q.BandRX, q.FreqRXHz)
 	}
 }
+
+// A genuine split contact is uploaded AS split: the rule above is about a
+// receive side that repeats the transmit side, not about dropping one.
+func TestSplitIsUploadedWithItsReceiveSide(t *testing.T) {
+	tx, rx := int64(14195000), int64(18100000)
+	q := qso.QSO{Callsign: "F4BPO", Band: "20m", BandRX: "17m", FreqHz: &tx, FreqRXHz: &rx}
+	up := strings.ToUpper(adif.SingleRecordADIF(q))
+	if !strings.Contains(up, "<BAND_RX:3>17M") || !strings.Contains(up, "<FREQ_RX:9>18.100000") {
+		t.Errorf("a cross-band contact lost its receive side:\n%s", up)
+	}
+}

telemetry.go

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

update.go

@@ -212,20 +212,28 @@ func (a *App) DownloadAndApplyUpdate(url string) error {
 	_ = os.Remove(exe + ":Zone.Identifier")
 	applog.Printf("update: installed new exe, scheduling relaunch")
 
-	// Relaunch via a detached, hidden PowerShell that WAITS for this process to exit
+	// THE NEW EXE STARTS ITSELF. No helper, no script.
-	// (so the single-instance mutex is free) and THEN starts the new exe. Launching
+	//
-	// the new exe directly while we're still alive raced the mutex and often left
+	// This used to go through a hidden PowerShell that waited for our process to
-	// nothing running; waiting for our own exit first makes the restart reliable,
+	// die and then launched the new image — which is, byte for byte, the shape of
-	// and the launcher outlives us.
+	// a dropper: an unsigned binary replaces itself on disk, clears the
-	quoted := strings.ReplaceAll(exe, "'", "''")
+	// mark-of-the-web, and spawns a windowless PowerShell that starts another
-	ps := fmt.Sprintf(
+	// executable. Windows Defender's machine-learning model reads that shape and
-		"Wait-Process -Id %d -ErrorAction SilentlyContinue; Start-Sleep -Milliseconds 400; Start-Process -FilePath '%s' -ArgumentList '--post-update'",
+	// not our intentions, and an operator updating to 0.27.14 had OpsLog removed
-		os.Getpid(), quoted)
+	// under Trojan:Script/Wacatac.H!ml — the "Script/" being the PowerShell.
-	cmd := exec.Command("powershell", "-NoProfile", "-WindowStyle", "Hidden", "-Command", ps)
+	//
+	// The wait it existed for is not needed: --post-update already makes the new
+	// instance patient with the single-instance mutex (see acquireInstance), so it
+	// can start while this one is still shutting down and simply wait its turn.
+	cmd := exec.Command(exe, "--post-update")
+	cmd.Dir = dir
 	cmd.SysProcAttr = &syscall.SysProcAttr{HideWindow: true, CreationFlags: 0x08000000} // CREATE_NO_WINDOW
 	if err := cmd.Start(); err != nil {
 		return fmt.Errorf("schedule relaunch: %w", err)
 	}
+	// Released rather than waited on: this process is about to exit, and a child
+	// that outlives its parent must not be left as a zombie handle.
+	_ = cmd.Process.Release()
 	if a.ctx != nil {
 		wruntime.Quit(a.ctx)
 	} else {
@@ -249,6 +257,12 @@ func (a *App) DownloadAndApplyUpdate(url string) error {
 // than an update that waits. Only a successful swap passes --post-update, so a
 // failure leaves the .new file in place for the next attempt rather than having
 // the cleanup delete the download.
+// The LAST resort still needs a helper that outlives this process: nothing else
+// can move a file over an image that is still running. It stays PowerShell —
+// there is no smaller tool on a stock Windows that can wait for a pid and then
+// move a file — but it is reached only when the rename above failed, which is
+// rare, and never on the ordinary update path (see the relaunch there for why
+// that matters to Defender).
 func (a *App) scheduleDeferredSwap(exe, pending string) error {
 	// Clear the "downloaded from the internet" mark before it becomes the exe —
 	// SmartScreen silently blocks a programmatic launch of a marked file, and the

uploadconfigured_test.go

@@ -0,0 +1,74 @@
+package main
+
+import (
+	"strings"
+	"testing"
+
+	"hamlog/internal/extsvc"
+)
+
+// An upload to a service with no credentials used to look exactly like one that
+// worked: it ran on its own goroutine and reported into the QSL Manager's
+// console, which is not open when the command came from the QSO list.
+func TestUploadRefusesAnUnconfiguredService(t *testing.T) {
+	var empty extsvc.ExternalServices
+	for _, svc := range []extsvc.Service{
+		extsvc.ServiceCloudlog, extsvc.ServiceQRZ, extsvc.ServiceClublog,
+		extsvc.ServiceHRDLog, extsvc.ServiceEQSL, extsvc.ServiceHamQTH, extsvc.ServiceLoTW,
+	} {
+		err := uploadConfigured(svc, empty)
+		if err == nil {
+			t.Errorf("%s: an unconfigured service was accepted", svc)
+			continue
+		}
+		if !strings.Contains(err.Error(), "Settings") {
+			t.Errorf("%s: %q does not say where to fix it", svc, err)
+		}
+	}
+}
+
+// And a CONFIGURED service is not turned away. Club Log is the one that was:
+// its API key is OpsLog's own application key, embedded and never entered, so
+// demanding it refused every operator who had the service working.
+func TestAConfiguredServiceIsAccepted(t *testing.T) {
+	var cfg extsvc.ExternalServices
+	cfg.Clublog.Email, cfg.Clublog.Password, cfg.Clublog.Callsign = "[email protected]", "secret", "F4BPO"
+	cfg.QRZ.APIKey = "1234-5678"
+	cfg.Cloudlog.URL, cfg.Cloudlog.APIKey, cfg.Cloudlog.StationID = "https://log.example.com", "cl-key", "3"
+	cfg.EQSL.Username, cfg.EQSL.Password = "F4BPO", "secret"
+	cfg.HamQTH.Username, cfg.HamQTH.Password = "f4bpo", "secret"
+	cfg.HRDLog.Callsign, cfg.HRDLog.Code = "F4BPO", "12345"
+	cfg.LoTW.TQSLPath, cfg.LoTW.StationLocation = `C:\Program Files (x86)\TrustedQSL\tqsl.exe`, "Home"
+
+	for _, svc := range []extsvc.Service{
+		extsvc.ServiceCloudlog, extsvc.ServiceQRZ, extsvc.ServiceClublog,
+		extsvc.ServiceHRDLog, extsvc.ServiceEQSL, extsvc.ServiceHamQTH, extsvc.ServiceLoTW,
+	} {
+		if err := uploadConfigured(svc, cfg); err != nil {
+			t.Errorf("%s: a configured service was refused: %v", svc, err)
+		}
+	}
+}
+
+// The message names what is actually missing, so the operator opens the right
+// field rather than checking three that were already filled in.
+func TestTheRefusalNamesTheMissingFields(t *testing.T) {
+	var cfg extsvc.ExternalServices
+	cfg.Clublog.Email = "[email protected]"
+	err := uploadConfigured(extsvc.ServiceClublog, cfg)
+	if err == nil {
+		t.Fatal("a half-configured Club Log was accepted")
+	}
+	msg := err.Error()
+	if strings.Contains(msg, "email") {
+		t.Errorf("%q asks for the one field that IS set", msg)
+	}
+	for _, want := range []string{"password", "logbook callsign"} {
+		if !strings.Contains(msg, want) {
+			t.Errorf("%q does not mention the missing %s", msg, want)
+		}
+	}
+	if strings.Contains(strings.ToLower(msg), "api key") {
+		t.Errorf("%q asks for the API key — it is OpsLog's own, embedded", msg)
+	}
+}

wsjthighlight_test.go

@@ -0,0 +1,47 @@
+package main
+
+import (
+	"testing"
+
+	udp "hamlog/internal/integrations/udp"
+)
+
+// The text colour is derived from the background, never stored: an operator who
+// picks a dark blue must not end up with black text on it in somebody else's
+// window and conclude the feature is broken.
+func TestHighlightForegroundFollowsTheBackground(t *testing.T) {
+	var a App
+	for _, tc := range []struct {
+		bg   string
+		want udp.RGB
+	}{
+		{"#111827", hlWhite}, // near-black
+		{"#16823C", hlWhite}, // the new-DXCC green
+		{"#F472B6", hlBlack}, // the watchlist pink
+		{"#FFFFFF", hlBlack},
+		{"#E27A18", hlBlack}, // orange
+	} {
+		bg, fg := a.colourFor("", tc.bg)
+		if got, ok := parseHexRGB(tc.bg); !ok || got != bg {
+			t.Errorf("%s: background came back as %v", tc.bg, bg)
+		}
+		if fg != tc.want {
+			t.Errorf("%s: foreground %v, want %v", tc.bg, fg, tc.want)
+		}
+	}
+}
+
+// A colour that cannot be read is refused rather than half-read: silently
+// becoming black is worse than keeping the default.
+func TestHighlightColourParsing(t *testing.T) {
+	for _, s := range []string{"#F472B6", "f472b6", " #F472B6 "} {
+		if c, ok := parseHexRGB(s); !ok || c != (udp.RGB{R: 244, G: 114, B: 182}) {
+			t.Errorf("%q → %v ok=%v", s, c, ok)
+		}
+	}
+	for _, s := range []string{"", "#FFF", "pink", "#GGGGGG", "#F472B6F"} {
+		if _, ok := parseHexRGB(s); ok {
+			t.Errorf("%q was accepted", s)
+		}
+	}
+}