chore: release v0.27.20

Asked why the satellite dropdown exists when the passes are on the right, and
the honest answer was that the table was incomplete. Three kinds of satellite
never appeared in it: QO-100, which has no pass because it never sets; one whose
elements have not arrived, which cannot be predicted at all; and one whose next
pass falls beyond the prediction window. Following a satellite and not finding it
in the list reads as OpsLog having lost it.

They are listed at the end now, each saying which of the three it is, and
clicking one selects it exactly like a pass row. The table stops being "what is
coming" and becomes "what you follow, soonest first" — which is what an operator
was scanning it for anyway.

The dropdown stays, and now for one reason rather than by default: it is the
only selector left when the readout column is hidden, which is what an operator
does when they want the map full width during a pass.

Co-Authored-By: Claude Opus 5 (1M context) <[email protected]>

BUILDING-LINUX.md

@@ -0,0 +1,112 @@
+# Building OpsLog on Linux
+
+OpsLog is developed on Windows. The Linux build shares every line of the
+frontend and all but a handful of Go files; what differs is listed at the bottom
+of this page.
+
+**It cannot be cross-compiled from Windows.** Wails links against the system
+WebKit on Linux, which needs cgo and the GTK/WebKit headers, so the binary has
+to be produced on a Linux machine (or a container). What *can* be checked from
+Windows — and is, at every release — is that the Go half still compiles:
+
+```bash
+GOOS=linux GOARCH=amd64 CGO_ENABLED=0 go build ./...
+GOOS=linux GOARCH=amd64 CGO_ENABLED=0 go vet ./...
+```
+
+## The short way
+
+```bash
+./scripts/linux-setup.sh
+```
+
+It checks everything below, prints the one install command your distribution
+needs if something is missing, and builds when nothing is. The rest of this page
+is what it checks, for when you would rather do it by hand.
+
+## Dependencies
+
+```bash
+# Debian / Ubuntu
+sudo apt install build-essential pkg-config libgtk-3-dev libwebkit2gtk-4.1-dev nodejs npm
+
+# Fedora
+sudo dnf install gcc-c++ pkgconf-pkg-config gtk3-devel webkit2gtk4.1-devel nodejs npm
+
+# Arch
+sudo pacman -S base-devel pkgconf gtk3 webkit2gtk-4.1 nodejs npm
+```
+
+**Go and node do not come from the package manager.** No current distribution
+ships a Go new enough for `go.mod` (Ubuntu 24.04 / Mint 22 have 1.22, Ubuntu
+22.04 / Mint 21 have 1.18), and Ubuntu 22.04 / Mint 21 ship node 12 where Vite
+needs 18. Both are the usual reason a first build fails with an error that
+points somewhere else entirely:
+
+```bash
+# Go, from go.dev
+wget https://go.dev/dl/go1.25.1.linux-amd64.tar.gz
+sudo rm -rf /usr/local/go && sudo tar -C /usr/local -xzf go1.25.1.linux-amd64.tar.gz
+echo 'export PATH=/usr/local/go/bin:$HOME/go/bin:$PATH' >> ~/.profile   # log out and back in
+
+# node 20, only if `node -v` is below 18
+curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash - && sudo apt install nodejs
+```
+
+Then the Wails CLI:
+
+```bash
+go install github.com/wailsapp/wails/v2/cmd/[email protected]
+wails doctor          # says what is still missing
+```
+
+`libwebkit2gtk-4.0` also works; pass `-tags webkit2_40` to `wails build` if your
+distribution only has the older one.
+
+## Build
+
+```bash
+wails build           # → build/bin/OpsLog
+./build/bin/OpsLog
+```
+
+`wails dev` works the same as on Windows.
+
+## Runtime requirements
+
+- **PulseAudio or PipeWire** for the voice keyer, the QSO recorder and the CW
+  decoder. PipeWire is fine — OpsLog speaks the PulseAudio protocol, which
+  `pipewire-pulse` answers. Without a sound server those three features report
+  "cannot reach the sound server" and everything else works normally.
+- **Serial port access** for CAT, keyers, rotators and amplifiers. Ports appear
+  as `/dev/ttyUSB0`, `/dev/ttyACM0`… and on most distributions belong to the
+  `dialout` group:
+
+  ```bash
+  sudo usermod -aG dialout $USER      # log out and back in
+  ```
+
+  This is the single most common reason a rig that works in WSJT-X shows
+  "permission denied" in OpsLog.
+- **TrustedQSL** (`tqsl`) for LoTW uploads, from your package manager. OpsLog
+  finds it on `PATH`.
+
+## Where OpsLog keeps its data
+
+Next to the binary, in `data/` — the same portable layout as on Windows, so a
+folder in your home directory carries the logbook with it.
+
+If the binary sits somewhere you cannot write (`/usr/bin`, `/opt`), OpsLog uses
+`~/.local/share/OpsLog/data` instead and says so in `startup.log`. The startup
+log itself lives in `~/.cache/OpsLog/startup.log`.
+
+## What is different from the Windows build
+
+| | |
+|---|---|
+| **OmniRig** | Not available — it is Windows COM automation. Use a native backend instead: Icom CI-V (USB and network), Yaesu, Kenwood/Elecraft, FlexRadio, TCI, Xiegu. |
+| **Denkovi USB relay** | Not available — it needs FTDI's `ftd2xx.dll`. The other relay backends work. |
+| **Audio** | PulseAudio/PipeWire instead of WASAPI. Same devices, same fixed 16 kHz mono format. |
+| **Auto-update** | Works, and is simpler: Linux lets a running binary be replaced, so none of the Windows deferred-swap machinery is needed. |
+| **Window placement** | OpsLog cannot read the monitor layout, so a saved window position is always trusted rather than clamped onto a visible screen. |
+| **Single instance** | An `flock` on `$XDG_RUNTIME_DIR/OpsLog/instance.lock` instead of a named mutex. It cannot raise the existing window, only refuse to start a second one. |

app_sat_rotator.go

@@ -0,0 +1,313 @@
+package main
+
+// How a satellite station points its antenna.
+//
+// It does NOT configure a rotator. Every rotator interface OpsLog knows lives in
+// Settings ▸ Rotator, once, and the satellite page only CHOOSES one of them.
+// The two used to be separate: EasyComm and PstRotator were described inside the
+// satellite settings while five other backends were described in the rotator
+// list, so an operator with one mast described it twice — and could describe it
+// differently the second time, which is a station that works on HF and not on a
+// pass, for no reason anyone can see.
+//
+// What remains here is the adapter: turning whichever backend the operator
+// picked into the three things a pass needs — point it, ask where it is, let go
+// of it at the end.
+
+import (
+	"fmt"
+	"math"
+	"strings"
+	"sync"
+
+	"hamlog/internal/rotator/gs232"
+	"hamlog/internal/rotator/pst"
+	"hamlog/internal/rotator/spid"
+)
+
+// 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 legacy satellite-only rotator kinds. They are no longer stored; they
+// survive only so migrateSatRotator can read what an operator configured before
+// the rotator list existed.
+const (
+	satRotEasycomm = "easycomm"
+	satRotPst      = "pstrotator"
+)
+
+// newSatRotator builds a controller for the rotor the satellite page selected.
+func (a *App) newSatRotator(s SatSettings) (satRotator, error) {
+	if strings.TrimSpace(s.RotID) == "" {
+		return nil, fmt.Errorf("no rotator chosen for satellite tracking — pick one in Settings ▸ Satellite")
+	}
+	lr, ok := a.rotorByKey(s.RotID)
+	if !ok {
+		// The rotor was deleted from the list after being chosen here. Say that,
+		// rather than failing to connect to an address nobody can see any more.
+		return nil, fmt.Errorf("the rotator chosen for satellite tracking no longer exists in Settings ▸ Rotator")
+	}
+	// Azimuth only: any rotor will do, including the tower the operator already
+	// turns for HF. See SatSettings.RotAzOnly for why this is the common case
+	// rather than a fallback.
+	if s.RotAzOnly {
+		return &azOnlySatRotator{link: lr.Link}, nil
+	}
+	if !lr.HasEl {
+		name := strings.TrimSpace(lr.Name)
+		if name == "" {
+			name = "this rotator"
+		}
+		return nil, fmt.Errorf("%s has no elevation axis — tick \"follow the azimuth only\" in Settings ▸ Satellite, or pick an az/el rotator", name)
+	}
+	l := lr.Link
+	switch l.Type {
+	case "pst":
+		return &pstSatRotator{c: pst.New(l.Host, l.Port), maxAz: l.MaxAz}, nil
+	case "easycomm":
+		return easycommClient(l), nil
+	case "erc":
+		return &gs232SatRotator{c: ercClient(l), maxAz: l.MaxAz}, nil
+	case "spid":
+		return &spidSatRotator{c: spidClient(l)}, nil
+	default:
+		return nil, fmt.Errorf("the %s backend cannot be pointed in elevation", l.Type)
+	}
+}
+
+// SatelliteRotorChoice is one entry in the satellite page's rotator dropdown.
+type SatelliteRotorChoice struct {
+	Key string `json:"key"`
+	// Name is the operator's label; Type is the backend's, for the rotors left
+	// unnamed (a list of three blank rows is a list of one rotor as far as
+	// anybody can tell).
+	Name  string `json:"name"`
+	Type  string `json:"type"`
+	HasEl bool   `json:"has_el"`
+}
+
+// ListSatelliteRotors returns every configured rotor, elevation-capable or not.
+//
+// Never filtered. Which of them can be USED depends on the azimuth-only switch,
+// and that is a question for the panel: with it off an azimuth rotor is shown
+// greyed and says why, with it on every rotor is fair game. Hiding them
+// outright would only teach an operator with one mast that OpsLog cannot find
+// it.
+func (a *App) ListSatelliteRotors() ([]SatelliteRotorChoice, error) {
+	devs, err := a.GetRotators()
+	if err != nil {
+		return nil, err
+	}
+	out := []SatelliteRotorChoice{}
+	for _, r := range flattenRotors(devs) {
+		out = append(out, SatelliteRotorChoice{
+			Key: r.Key, Name: r.Name, Type: rotorTypeInfo(r.Link.Type).Label, HasEl: r.HasEl,
+		})
+	}
+	return out, nil
+}
+
+// gs232SatRotator points an ERC-M (or any GS-232 az/el controller) through the
+// W command.
+//
+// The 450° overlap is handled HERE and not in the package, the same way the
+// EasyComm client does it: a controller reports 0-450 and takes 0-450, but the
+// tracker works in true bearings, and which of the two ways round to reach 010°
+// depends on where the mast currently is.
+type gs232SatRotator struct {
+	c     *gs232.Client
+	maxAz int
+}
+
+func (g *gs232SatRotator) Point(az, el float64) error {
+	return g.c.GoToAzEl(int(math.Round(satWrapAz(az, g.maxAz))), int(math.Round(clampEl(el))))
+}
+
+func (g *gs232SatRotator) Heading() (float64, float64, bool, error) {
+	az, el, _, err := g.c.Position()
+	if err != nil {
+		return 0, 0, false, err
+	}
+	return float64(az), float64(el), true, nil
+}
+
+// Close: nothing to release. The serial port is held by the gs232 package, which
+// keeps it open across the whole session on purpose — an Arduino-based
+// controller reboots every time its port is opened.
+func (g *gs232SatRotator) Close() {}
+
+// spidSatRotator points a SPID Rot2Prog. Its protocol is absolute and binary,
+// with no overlap notion to manage: the controller is told a bearing and a
+// resolution and works out its own path.
+type spidSatRotator struct{ c *spid.Client }
+
+func (s *spidSatRotator) Point(az, el float64) error {
+	a := math.Mod(az, 360)
+	if a < 0 {
+		a += 360
+	}
+	return s.c.GoTo(int(math.Round(a)), int(math.Round(clampEl(el))))
+}
+
+func (s *spidSatRotator) Heading() (float64, float64, bool, error) {
+	az, el, err := s.c.Heading()
+	if err != nil {
+		return 0, 0, false, err
+	}
+	return float64(az), float64(el), true, nil
+}
+
+func (s *spidSatRotator) Close() {}
+
+// satWrapAz maps a true bearing onto what the controller accepts. On a 450°
+// mast the far end of the overlap is reachable two ways and the higher number is
+// chosen for the last 90°, which is what keeps a pass crossing north from
+// unwinding the cable in the middle of it.
+func satWrapAz(az float64, maxAz int) float64 {
+	a := math.Mod(az, 360)
+	if a < 0 {
+		a += 360
+	}
+	if maxAz == 450 && a < 90 {
+		return a + 360
+	}
+	return a
+}
+
+// clampEl keeps the elevation inside what a mast will accept. 180 and not 90: a
+// G-5500 goes past the zenith and keeps counting, which is how an overhead pass
+// is followed without swinging the azimuth 180° through the middle of it.
+func clampEl(el float64) float64 {
+	if el < 0 {
+		return 0
+	}
+	if el > 180 {
+		return 180
+	}
+	return el
+}
+
+// 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 the direct backends
+// need 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
+	}
+	el = clampEl(el)
+	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() {}
+
+// azOnlySatRotator follows the satellite in azimuth and never touches the
+// elevation axis, whatever the rotor happens to have.
+//
+// It works because of the geometry, not in spite of it: a pass at the far edge
+// of the footprint stays between the horizon and about fifteen degrees for its
+// whole length, and a yagi's beamwidth swallows that. What it costs is the high
+// passes — a bird straight overhead is a moving azimuth and a useless bearing —
+// and that is the operator's trade to make, which is why it is a switch and not
+// a silent fallback.
+//
+// It drives whichever rotor was chosen through the same per-backend dispatch the
+// compass uses, so a PstRotator, a Rotator Genius, an ARCO, a DCU-1, a SPID and
+// the az/el ones all work here without a second implementation of each.
+type azOnlySatRotator struct{ link rotorLink }
+
+// Point sends the azimuth alone. The elevation is passed as -1, the callers'
+// "no opinion", so a rotor that HAS an elevation axis is left where it is rather
+// than being driven to the horizon.
+func (r *azOnlySatRotator) Point(az, _ float64) error {
+	a := math.Mod(az, 360)
+	if a < 0 {
+		a += 360
+	}
+	return linkGoTo(r.link, int(math.Round(a)), -1)
+}
+
+// Heading reports the azimuth. The elevation comes back as whatever the
+// controller said, which for an azimuth rotor is zero — the panel is told
+// separately not to draw it (SatTrackStatus.RotAzOnly), because zero is a real
+// bearing and not the absence of one.
+//
+// live stays true when the AZIMUTH was genuinely read: it means "this is a
+// reading and not the last command", and that answer is honest whatever the
+// other axis does or does not do.
+func (r *azOnlySatRotator) Heading() (float64, float64, bool, error) {
+	az, el, _, _, err := linkHeading(r.link)
+	if err != nil {
+		return 0, 0, false, err
+	}
+	return az, el, true, nil
+}
+
+func (r *azOnlySatRotator) Close() {}

app_sat_track.go

@@ -0,0 +1,636 @@
+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
+	rotAzOnly 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"`
+	// RotAzOnly: the elevation is not being driven and RotEl means nothing.
+	// Sent so the panel can leave it out rather than draw an antenna lying on
+	// the horizon, which is what an undriven zero looks like.
+	RotAzOnly bool `json:"rot_az_only"`
+}
+
+// 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 := a.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
+			t.rotAzOnly = set.RotAzOnly
+			t.status.RotAzOnly = set.RotAzOnly
+		}
+	}
+
+	// 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 := a.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
+		}
+	}
+	// In azimuth-only mode the elevation is never commanded, so comparing it
+	// would find a difference on every tick and send a command for nothing —
+	// the antenna ordered to the same bearing once a second for the whole pass.
+	moved := math.Abs(az-t.rotAz) >= t.rotStep
+	if !t.rotAzOnly {
+		moved = moved || math.Abs(el-t.rotEl) >= t.rotStep
+	}
+	if t.rotSent && !moved {
+		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,108 @@
+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)
+		}
+	}
+}
+
+// Azimuth-only tracking must not command the rotor once a second.
+//
+// The step check used to compare BOTH axes, so with the elevation never
+// commanded its difference stayed above the step for the whole pass and every
+// tick sent the antenna to the bearing it was already on. A rotator is a
+// mechanical thing with a finite number of turns in it.
+func TestPointRotatorAzOnlyIgnoresElevation(t *testing.T) {
+	rec := &countingRotator{}
+	tr := &satTracker{rot: rec, rotStep: 5, rotAzOnly: true}
+
+	// The satellite climbs while the bearing barely moves — a pass going
+	// overhead from the side, which is the shape that provoked this.
+	for _, p := range []sat.Position{
+		{Az: 100, El: 5},
+		{Az: 101, El: 20},
+		{Az: 102, El: 45},
+		{Az: 103, El: 70},
+	} {
+		tr.pointRotator(p, false)
+	}
+	if rec.n != 1 {
+		t.Errorf("azimuth-only sent %d commands for 3° of bearing, want 1", rec.n)
+	}
+	if rec.lastAz != 100 {
+		t.Errorf("commanded azimuth %v, want the first one", rec.lastAz)
+	}
+
+	// And it still follows the azimuth when the azimuth actually moves.
+	tr.pointRotator(sat.Position{Az: 130, El: 70}, false)
+	if rec.n != 2 {
+		t.Errorf("a 30° swing was not followed: %d commands", rec.n)
+	}
+}
+
+// With an elevation axis, a climb is still followed.
+func TestPointRotatorFollowsElevationWhenItCan(t *testing.T) {
+	rec := &countingRotator{}
+	tr := &satTracker{rot: rec, rotStep: 5}
+	tr.pointRotator(sat.Position{Az: 100, El: 5}, false)
+	tr.pointRotator(sat.Position{Az: 101, El: 40}, false)
+	if rec.n != 2 {
+		t.Errorf("a 35° climb was not followed: %d commands", rec.n)
+	}
+	if rec.lastEl != 40 {
+		t.Errorf("commanded elevation %v, want 40", rec.lastEl)
+	}
+}
+
+type countingRotator struct {
+	n              int
+	lastAz, lastEl float64
+}
+
+func (c *countingRotator) Point(az, el float64) error {
+	c.n++
+	c.lastAz, c.lastEl = az, el
+	return nil
+}
+func (c *countingRotator) Heading() (float64, float64, bool, error) { return 0, 0, false, nil }
+func (c *countingRotator) Close()                                   {}

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
-// application's window, which has no idea what theme OpsLog wears.
+// The DEFAULT palette. Fixed colours, not theme tokens — they are painted into
+// 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
@@ -65,9 +75,81 @@ var (
 	// 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}
-	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 {
-		if _, ok := a.watchlist.Match(call); ok {
-			c := hlWatchlist
-			f := hlBlack
-			return &c, &f, "watchlist"
-		}
-	}
 	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 {
+			bgc, fgc := a.colourFor(keyWsjtColWatchlist, hexOfRGB(hlWatchlist))
+			return &bgc, &fgc, "watchlist"
+		}
+	}
 	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,
-	// judged by the same ledger and the same digital-mode grouping the cluster
-	// uses, so the two windows cannot disagree about what "worked" means.
-	if a.wsjtHLWorkedOn.Load() && band != "" && mode != "" {
-		m := strings.ToUpper(strings.TrimSpace(mode))
-		if c.normMode != nil {
-			m = c.normMode(m)
-		}
-		if _, ok := c.workedCallSlots[strings.ToUpper(call)+"|"+strings.ToLower(band)+"|"+m]; ok {
-			bgc, fgc := hlWorked, hlWorkedFg
+	// A dupe, judged by the same ledger and the same digital-mode grouping the
+	// cluster 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
+	// screen where nearly every line is coloured has stopped saying anything.
+	if workedHere && a.wsjtHLWorkedOn.Load() {
+		bgc, fgc := a.colourFor(keyWsjtColWorked, hexOfRGB(hlWorked))
 		return &bgc, &fgc, "worked"
 	}
-	}
 	return nil, nil, ""
 }

autostart.go

@@ -6,10 +6,8 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
-	"strconv"
 	"strings"
 	"sync"
-	"syscall"
 
 	"hamlog/internal/applog"
 
@@ -76,10 +74,7 @@ func (a *App) SaveAutostartPrograms(progs []AutostartProgram) error {
 func (a *App) BrowseExecutable() (string, error) {
 	return wruntime.OpenFileDialog(a.ctx, wruntime.OpenDialogOptions{
 		Title:   "Choose a program to launch on startup",
-		Filters: []wruntime.FileFilter{
-			{DisplayName: "Programs (*.exe;*.bat;*.cmd)", Pattern: "*.exe;*.bat;*.cmd"},
-			{DisplayName: "All files (*.*)", Pattern: "*.*"},
-		},
+		Filters: executableFilters(),
 	})
 }
 
@@ -150,9 +145,7 @@ func (a *App) CloseAutostartPrograms() {
 		if name == "" {
 			name = filepath.Base(p.Path)
 		}
-		cmd := exec.Command("taskkill", "/PID", strconv.Itoa(pid))
-		cmd.SysProcAttr = &syscall.SysProcAttr{HideWindow: true, CreationFlags: 0x08000000}
-		if out, err := cmd.CombinedOutput(); err != nil {
+		if out, err := closeProcess(pid); err != nil {
 			applog.Printf("autostart: could not close %s (pid %d): %v — %s", name, pid, err, strings.TrimSpace(string(out)))
 			continue
 		}
@@ -227,33 +220,3 @@ func splitArgs(s string) []string {
 	}
 	return args
 }
-
-// runningProcessNames returns the set of lowercase executable names currently
-// running, via the Windows `tasklist`. Best effort — on failure the set is
-// empty (we then just attempt to launch, which is acceptable).
-func runningProcessNames() map[string]bool {
-	out := map[string]bool{}
-	cmd := exec.Command("tasklist", "/FO", "CSV", "/NH")
-	cmd.SysProcAttr = &syscall.SysProcAttr{HideWindow: true, CreationFlags: 0x08000000} // CREATE_NO_WINDOW
-	data, err := cmd.Output()
-	if err != nil {
-		applog.Printf("autostart: tasklist failed: %v", err)
-		return out
-	}
-	for _, line := range strings.Split(string(data), "\n") {
-		line = strings.TrimSpace(line)
-		if line == "" {
-			continue
-		}
-		// CSV row: "image.exe","PID",... — take the first quoted field.
-		field := line
-		if i := strings.Index(line[1:], "\""); i >= 0 && strings.HasPrefix(line, "\"") {
-			field = line[1 : i+1]
-		}
-		field = strings.Trim(field, "\"")
-		if field != "" {
-			out[strings.ToLower(field)] = true
-		}
-	}
-	return out
-}

bootlog.go

@@ -23,12 +23,9 @@ import (
 	"time"
 )
 
-// bootLogPath is the file, or "" when even LOCALAPPDATA is unavailable.
+// bootLogPath is the file, or "" when no writable folder can be found at all.
 func bootLogPath() string {
-	dir := os.Getenv("LOCALAPPDATA")
-	if strings.TrimSpace(dir) == "" {
-		dir = os.TempDir()
-	}
+	dir := bootLogDir()
 	if dir == "" {
 		return ""
 	}
@@ -136,11 +133,23 @@ func webviewDataPath() string {
 // stuckMarkerPath is written before the window is attempted and removed once it
 // opens, so the NEXT launch can tell that the last one never got there.
 func stuckMarkerPath() string {
-	dir := os.Getenv("LOCALAPPDATA")
-	if strings.TrimSpace(dir) == "" {
-		dir = os.TempDir()
+	return filepath.Join(bootLogDir(), "OpsLog", ".launching")
 }
-	return filepath.Join(dir, "OpsLog", ".launching")
+
+// bootLogDir is where the breadcrumbs live: %LOCALAPPDATA% on Windows, and on
+// Linux the XDG cache directory (~/.cache) that os.UserCacheDir resolves to.
+//
+// The temp directory is the last resort and not the first, because it is the
+// one place the evidence does not survive: a station that reboots after a
+// failed launch loses exactly the log that would have explained it.
+func bootLogDir() string {
+	if dir := strings.TrimSpace(os.Getenv("LOCALAPPDATA")); dir != "" {
+		return dir
+	}
+	if dir, err := os.UserCacheDir(); err == nil && strings.TrimSpace(dir) != "" {
+		return dir
+	}
+	return os.TempDir()
 }
 
 // lastLaunchHung is set at startup from the marker left by the previous run.

changelog.json

@@ -1,42 +1,192 @@
 [
+  {
+    "version": "0.27.20",
+    "date": "",
+    "en": [
+      "Every rotator interface now lives in Settings ▸ Rotator, and the satellite page only picks one of them. EasyComm and PstRotator used to be described inside the satellite settings while the other backends were described in the rotator list, so one mast was configured twice. What you already set up is moved into the list for you and selected.",
+      "Each rotator interface says whether it drives azimuth alone or azimuth and elevation, beside the interface itself. The satellite rotator list shows the azimuth-only ones greyed out rather than hiding them, so a rotor that cannot follow a pass says why.",
+      "New rotator interface: ERC-M by DF9GR, the azimuth/elevation controller for a Yaesu G-5500. Over its USB COM port or the network, with its emulation set to GS-232. Untested on hardware — reports welcome.",
+      "EasyComm II is now an ordinary rotator interface, so it can turn the antenna from the compass and from a spot click, not only during a satellite pass.",
+      "On the satellite map, an unselected satellite is readable: a bigger dot with a dark halo under a white ring, which shows up on a street map and on a dark ocean alike, and the ones above the horizon carry their name.",
+      "Hovering a satellite on the map now says what a pass is worth — elevation and azimuth, distance and whether it is closing or going away, rise and set with the countdown, and how high it will get. It no longer closes itself every five seconds while you read it.",
+      "The satellite footprint is drawn for the selected bird only. A footprint is thousands of kilometres across, and a dozen of them overlapped into a wash of circles that hid the coastline, the ground track and the satellites themselves.",
+      "The frequency plan goes from 25 satellites to 44, cut from Celestrak, PE0SAT and the SatNOGS transponder database instead of typed by hand — the nine Tevel-2 satellites, the Chinese space station, AO-27, AO-123, RS-44 and twenty more. Twelve that had re-entered are gone, first-generation Tevel among them. Your own file is merged rather than replaced: satellites you have never seen are added, and any frequency you corrected stands.",
+      "A satellite is now found by its catalog number rather than by its name. \"RADFXSAT (FOX-1B)\" and \"AO-91\" are the same bird, and so are \"TIANYAN 01\" and \"TO-108\" — the second pair never met before, so TO-108 tracked nothing.",
+      "On the satellite tab, the mode is a coloured badge instead of a grey footnote, and an FM bird shows its CTCSS tone with the same weight as a frequency — a repeater called without its tone does not answer, and the operator hears an empty channel and concludes the satellite is not up. When there is no tone it says so, rather than leaving a blank that could mean either. The mode also appears in the transponder list and in the header, so it survives hiding the readout column.",
+      "New option: follow the azimuth only. A station with an ordinary rotator and no elevation motor can now track a satellite — a pass at the edge of the footprint stays between the horizon and about 15° for its whole length, and a beam covers that with its beamwidth. With it on, any rotator in the list can be chosen. What you give up is the high passes, where a satellite overhead has a bearing that means nothing, which is why it is a switch and not something OpsLog decides for you.",
+      "The pass table now lists every satellite you follow, not only the ones with a pass coming. QO-100 never has one because it never sets, a bird whose elements have not arrived cannot be predicted, and one whose next pass falls beyond the window is simply past the horizon of the table — all three used to look like satellites OpsLog had lost. They sit at the end, each saying which of the three it is, and clicking one selects it like any other row."
+    ],
+    "fr": [
+      "Toutes les interfaces de rotor sont désormais dans Réglages ▸ Rotator, et la page satellite ne fait qu’en choisir une. EasyComm et PstRotator se configuraient dans les réglages satellite pendant que les autres se configuraient dans la liste des rotors : un même pylône était décrit deux fois. Ce que vous aviez réglé est déplacé dans la liste et sélectionné automatiquement.",
+      "Chaque interface de rotor indique si elle pilote l’azimut seul ou l’azimut et l’élévation, juste à côté de l’interface. La liste des rotors de la page satellite affiche les azimut-seul en grisé plutôt que de les cacher : un rotor qui ne peut pas suivre un passage dit pourquoi.",
+      "Nouvelle interface de rotor : ERC-M de DF9GR, le contrôleur azimut/élévation pour un Yaesu G-5500. Via son port COM USB ou le réseau, avec son émulation réglée sur GS-232. Non testé sur matériel — vos retours sont les bienvenus.",
+      "EasyComm II devient une interface de rotor comme les autres : elle peut tourner l’antenne depuis le compas et depuis un clic sur un spot, plus seulement pendant un passage satellite.",
+      "Sur la carte satellite, un satellite non sélectionné est lisible : un point plus gros avec un halo sombre sous un anneau blanc, visible aussi bien sur une carte routière que sur un océan noir, et ceux au-dessus de l’horizon portent leur nom.",
+      "Le survol d’un satellite sur la carte indique désormais ce que vaut le passage — élévation et azimut, distance et si elle diminue ou augmente, lever et coucher avec le décompte, et la hauteur qu’il atteindra. L’infobulle ne se referme plus toutes les cinq secondes pendant qu’on la lit.",
+      "L’empreinte au sol n’est tracée que pour le satellite sélectionné. Une empreinte fait des milliers de kilomètres, et une douzaine se superposaient en un lavis de cercles qui masquait le trait de côte, la trace au sol et les satellites eux-mêmes.",
+      "Le plan de fréquences passe de 25 à 44 satellites, généré depuis Celestrak, PE0SAT et la base de transpondeurs SatNOGS au lieu d’être saisi à la main — les neuf Tevel-2, la station spatiale chinoise, AO-27, AO-123, RS-44 et vingt autres. Douze rentrés dans l’atmosphère ont été retirés, dont les Tevel de première génération. Votre fichier est fusionné et non remplacé : les satellites inconnus sont ajoutés, et vos corrections de fréquence restent.",
+      "Un satellite est désormais trouvé par son numéro de catalogue plutôt que par son nom. « RADFXSAT (FOX-1B) » et « AO-91 » sont le même oiseau, tout comme « TIANYAN 01 » et « TO-108 » — ces deux-là ne se rencontraient jamais, donc TO-108 ne suivait rien.",
+      "Sur l’onglet satellite, le mode est une pastille colorée au lieu d’une note grise, et un satellite FM affiche sa tonalité CTCSS avec le même poids qu’une fréquence — un relais appelé sans sa tonalité ne répond pas, et l’OM entend un canal vide et en conclut que le satellite n’est pas passé. Quand il n’y a pas de tonalité, c’est écrit, plutôt qu’un blanc qui pourrait vouloir dire l’un ou l’autre. Le mode apparaît aussi dans la liste des transpondeurs et dans l’en-tête, donc il survit au masquage de la colonne de droite.",
+      "Nouvelle option : suivre l’azimut seulement. Une station avec un rotor ordinaire et sans moteur d’élévation peut désormais suivre un satellite — un passage en bord d’empreinte reste entre l’horizon et 15° environ sur toute sa durée, et une beam couvre ça avec son ouverture. Avec l’option activée, n’importe quel rotor de la liste peut être choisi. Ce qu’on perd, ce sont les passages hauts, où un satellite au zénith a un cap qui ne veut plus rien dire — d’où un réglage plutôt qu’un choix fait à votre place.",
+      "Le tableau des passages liste désormais tous les satellites suivis, et plus seulement ceux qui ont un passage à venir. QO-100 n’en a jamais puisqu’il ne se couche pas, un satellite dont les éléments ne sont pas arrivés ne peut pas être prédit, et celui dont le prochain passage tombe au-delà de la fenêtre est simplement hors de portée du tableau — les trois avaient l’air de satellites qu’OpsLog avait perdus. Ils sont en fin de liste, chacun disant lequel des trois cas il est, et un clic les sélectionne comme n’importe quelle ligne."
+    ]
+  },
+  {
+    "version": "0.27.19",
+    "date": "",
+    "en": [
+      "After an update, OpsLog starts again. The fix that stopped Defender calling the updater a trojan removed the helper that waited for the old process to die, and nothing took over the job: the new instance was patient with the single-instance lock for twenty seconds while the old one is allowed thirty to shut down — closing a remote logbook, a CAT session, sometimes a backup. Where that ran long the new process gave up in silence, leaving no window and a leftover OpsLog in the task manager. It now waits for the previous process itself, ending the instant it does; and if it really has not gone, it says so instead of claiming OpsLog is already running.",
+      "A UDP row set to multicast on an address that is not one now listens anyway. 127.0.0.1 in the group box is the common mistake — it is the address every other field in every other program wants — but a multicast group runs 224.0.0.0 to 239.255.255.255, and joining anything else failed on every interface with a Windows error naming nothing the operator had typed. The row simply did not run. It now listens on unicast, which is what such an address means, and says so in the log.",
+      "The confirmation defaults added for the newest services were blank. HAMLOG.online arrived after most profiles were set up, so it had no default at all — and blank is not a status anybody chose. Every service now starts the same way: the sent side at R (waiting to go out), the received side at N. A blank left by a service that did not exist when you last saved is filled in; a status you chose yourself is untouched.",
+      "OmniRig: a setting for rig files whose CW is the reverse one. OmniRig has two CW modes and nothing says which one a rig file calls plain CW — some Icom files map PM_CW_U to CW, others to CW-R — so clicking a CW spot on an IC-7610 landed the radio in CW-R, and the only way out was to edit the rig file. Settings → CAT → OmniRig now has a tick box for it, applied at once without dropping the link. (If your VFOs read the wrong way round on the same rig, the VFO override beside it is the answer: rig files disagree there too.)",
+      "Choosing a radio now switches CAT on. The master switch sits above the radio dropdown, and leaving it off while you pick your brand, type the address and run the detector — which finds your radio and prints its name — is a trap: a Flex 6700 owner did exactly that, saved six times, and got no link and no error. Picking a radio, or clicking one the detector found, ticks it. The panel also says so plainly while it is off, and the log line that used to announce \"link unchanged, staying connected\" when nothing was connected now says CAT is switched off.",
+      "My rig and my antenna are dropdowns now, in the entry form and in the QSO editor, offering what you declared in Settings → Operating conditions — and the antennas of the rig you picked, since that is what they hang off. Typing them again on every contact was both work and a source of spellings that do not match: \"IC-7610\", \"IC 7610\" and \"ic7610\" are three different rigs to an award and to a filter. Free text still works, for a QSO made from somebody else's station.",
+      "The FT decodes list is capped at 2000 rows. The rolling half hour is not a limit on a crowded evening — three decoders fill it with several thousand — and the panel slowed down long before anything aged out, since every row is a layout, a status and a distance. Past two thousand the oldest go, which is what has already been scrolled past.",
+      "The rotor dial sits on the panel instead of punching a hole in it. It was drawn on a full black square, which read as a tile dropped into the widget rather than an instrument on it; it is a disc now, and the corners are whatever it is sitting on. The continents are brighter too — at the old shade the land was about eight per cent lighter than the sea, technically a map and practically a dark square with a suggestion in it."
+    ],
+    "fr": [
+      "Après une mise à jour, OpsLog redémarre. Le correctif qui a fait cesser la détection en cheval de Troie a supprimé l'assistant qui attendait la mort de l'ancien processus, et rien n'a repris ce travail : la nouvelle instance patientait vingt secondes sur le verrou d'instance unique alors que l'ancienne dispose de trente pour se fermer — elle referme un journal distant, une session CAT, parfois une sauvegarde. Quand cela durait, le nouveau processus abandonnait en silence : pas de fenêtre, et un OpsLog restant dans le gestionnaire des tâches. Il attend désormais l'ancien processus lui-même, et repart à l'instant où celui-ci s'arrête ; et s'il n'est vraiment pas parti, il le dit au lieu d'annoncer qu'OpsLog tourne déjà.",
+      "Une ligne UDP réglée en multicast sur une adresse qui n'en est pas une écoute désormais quand même. 127.0.0.1 dans le champ groupe est l'erreur classique — c'est l'adresse que réclame tout autre champ de tout autre programme — mais un groupe multicast va de 224.0.0.0 à 239.255.255.255, et rejoindre autre chose échouait sur toutes les interfaces avec une erreur Windows ne nommant rien de ce que l'opérateur avait saisi. La ligne ne tournait tout simplement pas. Elle écoute maintenant en unicast, ce que veut dire une telle adresse, et le dit dans le journal.",
+      "Les statuts par défaut des services les plus récents étaient vides. HAMLOG.online est arrivé après la configuration de la plupart des profils : il n'avait donc aucun défaut — et vide n'est pas un statut que quelqu'un a choisi. Chaque service démarre désormais pareil : côté envoi R (en attente de départ), côté réception N. Un vide laissé par un service qui n'existait pas lors de votre dernier enregistrement est comblé ; un statut que vous avez choisi n'est pas touché.",
+      "OmniRig : un réglage pour les fichiers de rig dont la CW est l'inverse. OmniRig a deux modes CW et rien ne dit lequel un fichier appelle CW tout court — certains fichiers Icom associent PM_CW_U à CW, d'autres à CW-R — si bien qu'un clic sur un spot CW mettait un IC-7610 en CW-R, sans autre issue que de modifier le fichier de rig. Réglages → CAT → OmniRig a désormais une case pour cela, appliquée aussitôt sans couper la liaison. (Si vos VFO sont inversés sur la même radio, le sélecteur de VFO juste à côté est la réponse : les fichiers de rig divergent là aussi.)",
+      "Choisir une radio active désormais le CAT. L'interrupteur principal est au-dessus de la liste des radios, et le laisser éteint pendant qu'on choisit sa marque, saisit l'adresse et lance la détection — qui trouve la radio et affiche son nom — est un piège : un possesseur de Flex 6700 a fait exactement cela, enregistré six fois, sans liaison ni erreur. Choisir une radio, ou cliquer sur celle que la détection a trouvée, coche la case. Le panneau le dit aussi clairement tant qu'elle est décochée, et la ligne de journal qui annonçait « liaison inchangée, toujours connecté » alors que rien n'était connecté dit maintenant que le CAT est désactivé.",
+      "Mon équipement et mon antenne sont désormais des listes déroulantes, dans la saisie comme dans l'éditeur de QSO, proposant ce que vous avez déclaré dans Réglages → Conditions de trafic — et les antennes du poste choisi, puisque c'est à lui qu'elles sont rattachées. Les retaper à chaque contact était à la fois du travail et une source d'orthographes divergentes : « IC-7610 », « IC 7610 » et « ic7610 » sont trois équipements différents pour un diplôme et pour un filtre. La saisie libre reste possible, pour un QSO fait depuis la station de quelqu'un d'autre.",
+      "La liste des décodages FT est plafonnée à 2000 lignes. La demi-heure glissante n'est pas une limite un soir chargé — trois décodeurs la remplissent de plusieurs milliers — et le panneau ralentissait bien avant que quoi que ce soit n'expire, chaque ligne étant une mise en page, un statut et une distance. Au-delà de deux mille, les plus anciennes partent : celles qu'on a déjà dépassées en défilant.",
+      "Le cadran du rotor se pose sur le panneau au lieu d'y percer un trou. Il était dessiné sur un carré noir plein, qui se lisait comme une tuile posée dans le widget plutôt que comme un instrument dessus ; c'est un disque désormais, et les coins sont ce sur quoi il repose. Les continents sont aussi plus clairs — à l'ancienne teinte, la terre était environ huit pour cent plus claire que la mer : techniquement une carte, en pratique un carré sombre avec une suggestion dedans."
+    ]
+  },
+  {
+    "version": "0.27.18",
+    "date": "",
+    "en": [
+      "The dialogs you type in no longer sit on a blurred backdrop. A backdrop filter covers the whole window and is recomputed every time anything above it repaints — and behind these dialogs is an application that never stops moving: CAT polling four times a second, spots arriving, meters sweeping, maps redrawing. Worse in one place: the cluster editor opens from Preferences, so its overlay was a second full-window filter stacked over the first. Preferences, the cluster editor, the QSO editor, bulk edit, alert rules and award definitions now dim the background instead of blurring it; everything else keeps the blur.",
+      "One padlock on the entry form instead of five. Logging a contact from paper — a contest sheet, a friend's report, a QSO worked on another radio — means the frequency, the band, the mode, the date and both times all have to stop following the rig and the clock at once. That was five clicks in five different places, each of which had to be found first. The padlock beside Start UTC now holds all of them, and releases all of them.",
+      "Preferences no longer says the section name twice — the small line above each panel repeated the heading right under it, and the sidebar beside it already shows which section is open.",
+      "The band matrix can open on the digital mode you actually work. An operator who only ever does FT8 was shown DIGI every time and had to click through to their own mode on every callsign; Settings → General now chooses which digital row the matrix starts on. The row still rotates when you click it, and DIGI — all of them together — stays the default.",
+      "The MQTT chip is gone from the status bar. That is the name of a message protocol, not of anything an operator has. The state it carried — the openings feed up or down, and how many reports have arrived — is in the Chase New panel, which is the place that uses it.",
+      "The callsign box no longer narrows when you close the padlock. Its row gains a date field for a manual entry, and a flex row makes room by shrinking its children — so the widest box, the one the eye is on while typing, was the one that visibly moved. The callsign and both report boxes are now a notch narrower and fixed there, whether the date is showing or not."
+    ],
+    "fr": [
+      "Les dialogues dans lesquels on tape ne reposent plus sur un fond flouté. Un filtre de fond couvre toute la fenêtre et est recalculé chaque fois que quoi que ce soit au-dessus se repeint — et derrière ces dialogues il y a une application qui ne s'arrête jamais de bouger : le CAT qui interroge quatre fois par seconde, les spots qui arrivent, les vumètres qui balaient, les cartes qui se redessinent. Pire à un endroit : l'éditeur de cluster s'ouvre depuis les Préférences, donc son fond était un deuxième filtre plein écran empilé sur le premier. Les Préférences, l'éditeur de cluster, l'éditeur de QSO, l'édition groupée, les règles d'alerte et les définitions de diplômes assombrissent désormais le fond au lieu de le flouter ; tout le reste garde le flou.",
+      "Un seul cadenas dans la saisie au lieu de cinq. Enregistrer un contact depuis une feuille — un carnet de concours, le report d'un ami, un QSO fait sur une autre radio — suppose que la fréquence, la bande, le mode, la date et les deux heures cessent tous en même temps de suivre le poste et l'horloge. C'étaient cinq clics à cinq endroits différents, qu'il fallait d'abord trouver. Le cadenas à côté de Début UTC les fige maintenant tous, et les libère tous.",
+      "Les Préférences ne disent plus deux fois le nom de la section — la petite ligne au-dessus de chaque panneau répétait le titre juste en dessous, et la barre latérale montre déjà laquelle est ouverte.",
+      "La matrice peut s'ouvrir sur le mode numérique que vous travaillez vraiment. Celui qui ne fait que du FT8 voyait DIGI à chaque fois et devait cliquer jusqu'à son mode pour chaque indicatif ; Réglages → Général choisit désormais la ligne numérique sur laquelle la matrice démarre. La ligne continue de tourner au clic, et DIGI — tous ensemble — reste le défaut.",
+      "La pastille MQTT disparaît de la barre d'état. C'est le nom d'un protocole de messages, pas de quelque chose que possède un opérateur. Ce qu'elle indiquait — le flux d'ouvertures actif ou non, et le nombre de reports arrivés — est dans le panneau Chasse au nouveau, à l'endroit qui s'en sert.",
+      "Le champ indicatif ne rétrécit plus quand on ferme le cadenas. Sa ligne gagne un champ date pour une saisie manuelle, et une ligne flex fait de la place en rétrécissant ses enfants — donc le plus large, celui que l'œil suit pendant la frappe, était celui qui bougeait visiblement. L'indicatif et les deux champs de report sont désormais un cran plus étroits et fixes, que la date soit affichée ou non."
+    ]
+  },
+  {
+    "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.",
+      "Station Control shows what commands the station, not only what it switches. The radio is there now — frequency, mode, band, and the split pair when there is one — with the CW keyer beside it (speed up and down, and Stop, because a message going to the wrong callsign has to end now) and the voice keyer with its recorded messages as buttons, so a CQ goes out without leaving the tab. The two keyers appear only when there is something behind them: a port configured, or a message actually recorded. All three move and reorder with the other cards."
+    ],
+    "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.",
+      "Contrôle station montre ce qui commande la station, et plus seulement ce qui la commute. La radio y figure désormais — fréquence, mode, bande, et le couple split quand il y en a un — avec à côté le manipulateur CW (vitesse en plus ou en moins, et Stop, parce qu'un message parti vers le mauvais indicatif doit s'arrêter tout de suite) et le manipulateur vocal avec ses messages enregistrés en boutons, pour lancer un CQ sans quitter l'onglet. Les deux manipulateurs n'apparaissent que s'il y a quelque chose derrière : un port configuré, ou un message réellement enregistré. Les trois se déplacent et se réordonnent avec les autres cartes."
+    ]
+  },
+  {
+    "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": [
-      "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.",
-      "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).",
-      "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.",
-      "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.",
-      "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.",
       "[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.",
-      "[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 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.",
-      "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.",
-      "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: 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.",
-      "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.",
-      "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."
+      "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": [
-      "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.",
-      "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).",
-      "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.",
-      "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.",
-      "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.",
       "[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.",
-      "[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 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.",
-      "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.",
-      "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) »).",
-      "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’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.",
-      "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."
+      "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."
     ]
   },
   {

cmd/satgen/main.go

@@ -0,0 +1,444 @@
+// Command satgen refreshes internal/sat/birds.json from the public databases.
+//
+// A one-shot generator, run by hand, NOT part of the build — the same
+// arrangement as cmd/cntygen. Satellites are switched between modes and new
+// ones fly, and the shipped frequency plan should be re-cut every few releases
+// rather than typed from memory.
+//
+//	go run ./cmd/satgen
+//
+// It reads three sources and joins them on the NORAD catalog number:
+//
+//   - Celestrak's amateur group and PE0SAT's mirror, for WHICH satellites
+//     OpsLog can get elements for. There is no point shipping a frequency plan
+//     for a bird whose TLE never arrives.
+//   - SatNOGS DB, for the transmitters. It is the maintained, machine-readable
+//     transponder database; AMSAT's chart is authoritative but is a web page.
+//
+// It NEVER destroys a curated entry. The hand-written plans carry things
+// SatNOGS does not reliably hold — a CTCSS tone, a readable label, the QO-100
+// passband as operators actually describe it — so an existing bird is kept
+// verbatim and only has its NORAD number filled in. New satellites are appended.
+// Read the diff before committing it: this is a starting point for an operator,
+// and a wrong uplink is worse than a missing one.
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	"hamlog/internal/sat"
+)
+
+const (
+	birdsPath   = "internal/sat/birds.json"
+	satnogsTX   = "https://db.satnogs.org/api/transmitters/?format=json"
+	satnogsSats = "https://db.satnogs.org/api/satellites/?format=json"
+)
+
+// satellite is the subset of a SatNOGS satellite record we use. Its whole
+// purpose is the decay date: a frequency plan for a spacecraft that burned up
+// two years ago is a row in the operator's list that will never do anything.
+type satellite struct {
+	NORAD   int    `json:"norad_cat_id"`
+	Name    string `json:"name"`
+	Names   string `json:"names"` // other designations, comma or newline separated
+	Status  string `json:"status"`
+	Decayed string `json:"decayed"`
+}
+
+// tleFeeds are the element sources OpsLog itself reads (see internal/sat/tle.go).
+var tleFeeds = []string{
+	"https://celestrak.org/NORAD/elements/gp.php?GROUP=amateur&FORMAT=tle",
+	"http://tle.pe0sat.nl/kepler/amateur.txt",
+}
+
+// transmitter is the subset of a SatNOGS DB record we use.
+type transmitter struct {
+	Description  string `json:"description"`
+	Alive        bool   `json:"alive"`
+	Type         string `json:"type"` // Transmitter | Transponder | Transceiver
+	UplinkLow    int64  `json:"uplink_low"`
+	UplinkHigh   int64  `json:"uplink_high"`
+	DownlinkLow  int64  `json:"downlink_low"`
+	DownlinkHigh int64  `json:"downlink_high"`
+	Mode         string `json:"mode"`
+	Invert       bool   `json:"invert"`
+	NORAD        int    `json:"norad_cat_id"`
+	Status       string `json:"status"`
+}
+
+func main() {
+	feed, err := loadFeeds()
+	if err != nil {
+		die(err)
+	}
+	fmt.Printf("elements: %d satellites across %d feeds\n", len(feed), len(tleFeeds))
+
+	txs, err := loadTransmitters()
+	if err != nil {
+		die(err)
+	}
+	fmt.Printf("satnogs: %d transmitters\n", len(txs))
+
+	cat, err := loadSatellites()
+	if err != nil {
+		die(err)
+	}
+	fmt.Printf("satnogs: %d catalogued satellites\n", len(cat))
+
+	birds, err := loadBirds()
+	if err != nil {
+		die(err)
+	}
+	fmt.Printf("existing plan: %d satellites\n", len(birds))
+
+	// 0. Drop what has come down. SatNOGS carries the re-entry date, so this is
+	//    a documented fact rather than a judgement about which of the missing
+	//    satellites are missing for good — the first-generation Tevel
+	//    constellation alone had left eight rows that could never do anything.
+	kept := birds[:0]
+	for _, b := range birds {
+		if s, ok := decayed(b, cat); ok {
+			fmt.Printf("  - %s re-entered %s — removed\n", b.Name, strings.TrimSuffix(s.Decayed, "T00:00:00Z"))
+			continue
+		}
+		kept = append(kept, b)
+	}
+	birds = kept
+
+	// 1. Give every curated entry its catalog number, so the join stops
+	//    depending on how three different parties spell the same satellite.
+	covered := map[int]bool{}
+	for i := range birds {
+		if birds[i].NORAD == 0 {
+			if n, ok := noradFor(birds[i], feed); ok {
+				birds[i].NORAD = n
+				fmt.Printf("  + NORAD %5d for %s\n", n, birds[i].Name)
+			} else {
+				fmt.Printf("  ! no elements found for %s — left without a catalog number\n", birds[i].Name)
+			}
+		}
+		if birds[i].NORAD != 0 {
+			covered[birds[i].NORAD] = true
+		}
+	}
+
+	// 2. Append the satellites we can track and have a usable uplink for.
+	byNORAD := map[int][]transmitter{}
+	for _, t := range txs {
+		if !usable(t) || feed[t.NORAD] == "" || covered[t.NORAD] {
+			continue
+		}
+		byNORAD[t.NORAD] = append(byNORAD[t.NORAD], t)
+	}
+	added := 0
+	for n, list := range byNORAD {
+		b := sat.Bird{Name: displayName(feed[n]), NORAD: n}
+		if alias := strings.TrimSpace(feed[n]); alias != "" && alias != b.Name {
+			b.Aliases = []string{alias}
+		}
+		for _, t := range list {
+			b.Transponders = append(b.Transponders, toTransponder(t))
+		}
+		sort.Slice(b.Transponders, func(i, j int) bool {
+			return b.Transponders[i].DownLo < b.Transponders[j].DownLo
+		})
+		birds = append(birds, b)
+		added++
+		fmt.Printf("  NEW %5d %-24s %d transponder(s)\n", n, b.Name, len(b.Transponders))
+	}
+
+	sort.SliceStable(birds, func(i, j int) bool { return birds[i].Name < birds[j].Name })
+	out, err := json.MarshalIndent(birds, "", "  ")
+	if err != nil {
+		die(err)
+	}
+	if err := os.WriteFile(birdsPath, append(out, '\n'), 0o644); err != nil {
+		die(err)
+	}
+	fmt.Printf("\nwrote %s — %d satellites (%d new)\n", birdsPath, len(birds), added)
+}
+
+// usable decides whether a SatNOGS transmitter is something an operator can
+// work through.
+//
+// The database holds every emission a satellite makes, and most of them are not
+// a contact: a telemetry beacon with a command uplink is listed exactly like an
+// FM repeater, and shipping the command channel as a transponder would invite
+// somebody to transmit on it. So both ends must exist, and anything that
+// describes itself as telemetry or control is refused unless it also calls
+// itself a repeater, a transponder or a digipeater.
+func usable(t transmitter) bool {
+	if !t.Alive || t.Status != "active" {
+		return false
+	}
+	if t.UplinkLow <= 0 || t.DownlinkLow <= 0 {
+		return false
+	}
+	d := strings.ToLower(t.Description)
+	isWorkable := strings.Contains(d, "repeater") || strings.Contains(d, "transponder") ||
+		strings.Contains(d, "digipeater") || strings.Contains(d, "aprs") ||
+		strings.Contains(d, "voice") || strings.Contains(d, "sstv") || strings.Contains(d, "dstar")
+	if isWorkable {
+		return true
+	}
+	for _, bad := range []string{"telemetry", "command", "control", "dtmf", "beacon", "tlm"} {
+		if strings.Contains(d, bad) {
+			return false
+		}
+	}
+	// An ANALOG emission with both ends is a contact by construction: nobody
+	// puts an FM or SSB uplink on a satellite for housekeeping. This is what
+	// catches the plainly-described repeaters — AO-27 says only "Mode V/U FM",
+	// and rejecting it for not using the word "repeater" would have dropped one
+	// of the best-known FM birds there is.
+	if m := adifMode(t.Mode); m == "FM" || m == "SSB" || m == "CW" {
+		return true
+	}
+	// A digital emission has to say what it is. A GMSK uplink is a command
+	// channel far more often than it is a digipeater, and shipping the wrong one
+	// invites an operator to transmit on a control frequency.
+	return t.Type == "Transponder" || (t.UplinkHigh > t.UplinkLow && t.DownlinkHigh > t.DownlinkLow)
+}
+
+// ctcssRe pulls a tone out of prose. SatNOGS has no field for it, and it is not
+// optional: an FM uplink without the right tone opens nothing at all.
+var ctcssRe = regexp.MustCompile(`(?i)(?:ctcss|pl)[^0-9]{0,4}(\d{2,3}(?:\.\d)?)|(\d{2,3}(?:\.\d)?)\s*(?:hz)?\s*(?:ctcss|pl)\b`)
+
+func toTransponder(t transmitter) sat.Transponder {
+	tp := sat.Transponder{
+		Label:     cleanLabel(t.Description),
+		Mode:      adifMode(t.Mode),
+		DownLo:    t.DownlinkLow,
+		DownHi:    t.DownlinkHigh,
+		UpLo:      t.UplinkLow,
+		UpHi:      t.UplinkHigh,
+		Inverting: t.Invert,
+	}
+	// A "high" equal to the "low" is SatNOGS saying "a channel", not a one-hertz
+	// passband; Transponder.Linear() must not be fooled into interpolating.
+	if tp.DownHi <= tp.DownLo {
+		tp.DownHi = 0
+	}
+	if tp.UpHi <= tp.UpLo {
+		tp.UpHi = 0
+	}
+	// Inversion is a property of a PASSBAND. SatNOGS sets the flag on some FM
+	// channels too, where it means nothing — the code ignores it there, but a
+	// data file that says an FM repeater inverts is a data file that will
+	// mislead the next person to read it.
+	if tp.DownHi == 0 || tp.UpHi == 0 {
+		tp.Inverting = false
+	}
+	if m := ctcssRe.FindStringSubmatch(t.Description); m != nil {
+		v := m[1]
+		if v == "" {
+			v = m[2]
+		}
+		if f, err := strconv.ParseFloat(v, 64); err == nil && f >= 60 && f <= 260 {
+			tp.CTCSS = f
+		}
+	}
+	return tp
+}
+
+// adifMode maps SatNOGS' modulation names onto the four modes a log knows.
+func adifMode(m string) string {
+	switch u := strings.ToUpper(strings.TrimSpace(m)); {
+	case strings.HasPrefix(u, "FM"), u == "SSTV", u == "DSTAR", u == "NFM":
+		return "FM"
+	case u == "USB", u == "LSB", u == "SSB":
+		return "SSB"
+	case u == "CW":
+		return "CW"
+	default:
+		return "DATA"
+	}
+}
+
+func cleanLabel(s string) string {
+	s = strings.TrimSpace(s)
+	if s == "" {
+		return "Transponder"
+	}
+	return s
+}
+
+// displayName prefers the OSCAR designation an operator says out loud.
+// "SAUDISAT 1C (SO-50)" is SO-50 to everybody except a catalog.
+func displayName(feedName string) string {
+	s := strings.TrimSpace(feedName)
+	if i := strings.IndexByte(s, '('); i > 0 && strings.HasSuffix(s, ")") {
+		inner := strings.TrimSpace(s[i+1 : len(s)-1])
+		if oscarRe.MatchString(inner) {
+			return inner
+		}
+	}
+	// "RS-44 & BREEZE-KM R/B" — the rocket body it flies with is not its name.
+	if i := strings.Index(s, " & "); i > 0 {
+		return strings.TrimSpace(s[:i])
+	}
+	return s
+}
+
+var oscarRe = regexp.MustCompile(`^[A-Z]{1,3}-\d{1,3}$`)
+
+// noradFor finds a curated entry's catalog number by the name matching the
+// package already does.
+//
+// Deterministic on purpose. One satellite can hold TWO catalog entries — a
+// deployment catalogued before the objects were told apart, GreenCube being
+// 53106 and 53109 in the two feeds — and iterating the map picked a different
+// one each run, so the generated file changed for no reason and the diff was
+// unreadable. Candidates are therefore scored and tied on the lower number:
+// a feed name whose designation IS the bird's name ("GREENCUBE (IO-117)" for
+// IO-117) beats one that only matches through an alias.
+func noradFor(b sat.Bird, feed map[int]string) (int, bool) {
+	nums := make([]int, 0, len(feed))
+	for n := range feed {
+		nums = append(nums, n)
+	}
+	sort.Ints(nums)
+
+	best, bestScore := 0, -1
+	for _, n := range nums {
+		name := feed[n]
+		if !b.Matches(name) {
+			continue
+		}
+		score := 0
+		if strings.EqualFold(displayName(name), b.Name) {
+			score = 2
+		} else if strings.EqualFold(strings.TrimSpace(name), b.Name) {
+			score = 1
+		}
+		if score > bestScore {
+			best, bestScore = n, score
+		}
+	}
+	return best, best != 0
+}
+
+func loadFeeds() (map[int]string, error) {
+	out := map[int]string{}
+	for _, url := range tleFeeds {
+		body, err := get(url)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "warning: %s: %v\n", url, err)
+			continue
+		}
+		lines := []string{}
+		for _, l := range strings.Split(string(body), "\n") {
+			if s := strings.TrimSpace(l); s != "" {
+				lines = append(lines, s)
+			}
+		}
+		for i := 0; i+2 < len(lines); i += 3 {
+			if !strings.HasPrefix(lines[i+1], "1 ") || len(lines[i+1]) < 7 {
+				continue
+			}
+			n, err := strconv.Atoi(strings.TrimSpace(lines[i+1][2:7]))
+			if err != nil || n <= 0 {
+				continue
+			}
+			// First feed wins: Celestrak's spelling is the one the operator sees.
+			if _, had := out[n]; !had {
+				out[n] = lines[i]
+			}
+		}
+	}
+	if len(out) == 0 {
+		return nil, fmt.Errorf("no elements from any feed")
+	}
+	return out, nil
+}
+
+// decayed reports whether this bird's spacecraft has re-entered, matching on
+// the catalog number when we have one and on the designations SatNOGS lists
+// otherwise — "NAYIF-1" carries "EO-88" only in its alternative names.
+func decayed(b sat.Bird, cat []satellite) (satellite, bool) {
+	for _, s := range cat {
+		if s.Status != "re-entered" && s.Decayed == "" {
+			continue
+		}
+		if b.NORAD != 0 {
+			if s.NORAD == b.NORAD {
+				return s, true
+			}
+			continue
+		}
+		names := append(strings.FieldsFunc(s.Names, func(r rune) bool { return r == ',' || r == '\n' }), s.Name)
+		for _, n := range names {
+			if strings.TrimSpace(n) == "" {
+				continue
+			}
+			if b.Matches(strings.TrimSpace(n)) {
+				return s, true
+			}
+		}
+	}
+	return satellite{}, false
+}
+
+func loadSatellites() ([]satellite, error) {
+	body, err := get(satnogsSats)
+	if err != nil {
+		return nil, err
+	}
+	var out []satellite
+	if err := json.Unmarshal(body, &out); err != nil {
+		return nil, fmt.Errorf("satnogs satellites: %w", err)
+	}
+	return out, nil
+}
+
+func loadTransmitters() ([]transmitter, error) {
+	body, err := get(satnogsTX)
+	if err != nil {
+		return nil, err
+	}
+	var out []transmitter
+	if err := json.Unmarshal(body, &out); err != nil {
+		return nil, fmt.Errorf("satnogs: %w", err)
+	}
+	return out, nil
+}
+
+func loadBirds() ([]sat.Bird, error) {
+	b, err := os.ReadFile(birdsPath)
+	if err != nil {
+		return nil, err
+	}
+	var out []sat.Bird
+	if err := json.Unmarshal(b, &out); err != nil {
+		return nil, fmt.Errorf("%s: %w", birdsPath, err)
+	}
+	return out, nil
+}
+
+func get(url string) ([]byte, error) {
+	c := &http.Client{Timeout: 90 * time.Second}
+	resp, err := c.Get(url)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("%s: %s", url, resp.Status)
+	}
+	return io.ReadAll(io.LimitReader(resp.Body, 32<<20))
+}
+
+func die(err error) {
+	fmt.Fprintln(os.Stderr, "satgen:", err)
+	os.Exit(1)
+}

datadir_linux.go

@@ -0,0 +1,74 @@
+//go:build linux
+
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"sync"
+)
+
+// systemInstallDataDir keeps the portable "data beside the binary" layout where
+// it works, and falls back to the XDG data directory where it cannot.
+//
+// Both halves are needed on Linux, and only on Linux. A tarball or AppImage
+// unpacked into the home directory behaves exactly like the Windows build —
+// the folder travels with the program, which is the whole point of the design.
+// But the ordinary way software arrives here is a package that installs into
+// /usr/bin or /opt, where no user may write, and telling an operator to "move
+// the program somewhere writable" is telling them their distribution installed
+// it wrong. So when the folder beside the binary is read-only, OpsLog keeps its
+// data in ~/.local/share/OpsLog instead and says so in the log.
+//
+// Detection is by TRYING, not by matching path prefixes: /opt, /usr/local and a
+// NFS-mounted home are all writable on some stations and not on others, and the
+// only honest test is whether the write succeeds.
+func systemInstallDataDir(besideExe string) (string, bool) {
+	xdgOnce.Do(func() { xdgDir, xdgUsed = resolveDataDir(besideExe) })
+	return xdgDir, xdgUsed
+}
+
+var (
+	xdgOnce sync.Once
+	xdgDir  string
+	xdgUsed bool
+)
+
+func resolveDataDir(besideExe string) (string, bool) {
+	if writable(besideExe) {
+		return "", false
+	}
+	base := os.Getenv("XDG_DATA_HOME")
+	if base == "" {
+		home, err := os.UserHomeDir()
+		if err != nil || home == "" {
+			return "", false // nowhere better to go; let the caller report the failure
+		}
+		base = filepath.Join(home, ".local", "share")
+	}
+	alt := filepath.Join(base, "OpsLog", "data")
+	if !writable(alt) {
+		return "", false
+	}
+	bootLog("data dir: %s is not writable — keeping the data in %s instead", besideExe, alt)
+	return alt, true
+}
+
+// writable reports whether dir can be created and written to. The probe file is
+// removed again; a leftover in the data folder would be one more thing to
+// explain.
+func writable(dir string) bool {
+	if err := os.MkdirAll(dir, 0o755); err != nil {
+		return false
+	}
+	probe := filepath.Join(dir, ".writetest")
+	if err := os.WriteFile(probe, []byte("ok"), 0o644); err != nil {
+		return false
+	}
+	_ = os.Remove(probe)
+	return true
+}
+
+// dataDirAdvice is what the operator is told when neither location works — a
+// full disk, or a home directory that is not writable either.
+const dataDirAdvice = "\n\nOpsLog keeps its data next to the program, or in ~/.local/share/OpsLog when that folder belongs to the system. Neither could be written to: check the disk is not full and that your home directory is writable."

datadir_windows.go

@@ -0,0 +1,16 @@
+//go:build windows
+
+package main
+
+// systemInstallDataDir never diverts on Windows: the data folder is beside the
+// executable, full stop. That is what makes an OpsLog on a USB stick carry its
+// logbook with it, and an operator who copies the folder to a new PC find
+// everything already there.
+//
+// A copy dropped into Program Files is refused the write and told so (see
+// checkDataDirWritable) rather than quietly logging somewhere else, because
+// "where are my QSOs?" is a far worse afternoon than "move this folder".
+func systemInstallDataDir(besideExe string) (string, bool) { return "", false }
+
+// dataDirAdvice is what the operator is told when that folder cannot be written.
+const dataDirAdvice = "\n\nMove OpsLog.exe somewhere your account can write — a folder in Documents, or the desktop — and start it again. Program Files is refused to anything not running as administrator."

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,
@@ -52,7 +52,7 @@ import {
   ReportLiveActivity, LiveLastQSOAgeSec,
   GetAmpStatuses, AmpOperate,
   GetFlexState, FlexAmpOperate,
-  GetPSKReporterStatus, GetLiveOpenings, GetChaseNew,
+  GetLiveOpenings, GetChaseNew,
   QSLViaRepairStatus, RepairQSLVia, DismissQSLViaRepair,
   GetAutoCallStatus, SetAutoCall, SetAutoCallOnly, TakeAutoCallTarget, HaltAutoCall, WatchlistEntries,
 } from '../wailsjs/go/main/App';
@@ -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';
@@ -305,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);
@@ -371,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')}
@@ -561,7 +566,9 @@ function LockPad({ on, title, onToggle }: { on: boolean; title: string; onToggle
       type="button"
       tabIndex={-1}
       onClick={onToggle}
-      title={`${on ? 'Unlock' : 'Lock'} ${title}`}
+      // The whole tooltip, not a verb glued to a noun: the caller knows what
+      // this padlock does and can say it in the operator's own language.
+      title={title}
       className={cn(
         'inline-flex items-center justify-center size-3.5 rounded transition-colors',
         on ? 'text-warning hover:text-warning' : 'text-muted-foreground/40 hover:text-muted-foreground',
@@ -613,31 +620,34 @@ export default function App() {
   });
   const locksRef = useRef(locks);
   useEffect(() => { locksRef.current = locks; }, [locks]);
-  const toggleLock = (k: LockKey) => {
-    setLocks((s) => {
-      const wasLocked = s[k];
-      const next = { ...s, [k]: !wasLocked };
-      if (wasLocked) {
-        // Unlocking → restore automatic behavior. Without this the locked
-        // value would linger forever: a stale Start time would never refresh
-        // even after a new callsign is entered.
-        if (k === 'start') {
-          // If a QSO is currently in progress (callsign typed), snap start
-          // to now since we missed the auto-start moment. Otherwise clear.
+  // ONE padlock, not five.
+  //
+  // Logging a contact from a piece of paper — a contest sheet, a friend's
+  // report, a QSO worked on another radio — means the frequency, the band, the
+  // mode, the date and both times all have to stop following the rig and the
+  // clock at once. That is a single decision, and it used to be five clicks in
+  // five different places, each of which had to be found first.
+  //
+  // The five per-field locks stay underneath, because everything downstream
+  // reads them and they say the right thing individually ("this value is
+  // decoupled from the rig"). Only the control is one.
+  const manualEntry = locks.start && locks.end && locks.band && locks.mode && locks.freq;
+  const setManualEntry = (on: boolean) => {
+    setLocks({ band: on, mode: on, freq: on, start: on, end: on });
+    if (on) {
+      // Pre-filled with today's date and the current UTC time so the fields are
+      // not empty; the operator only has to correct them.
+      const now = new Date();
+      setQsoStartedAt((d) => d ?? now);
+      setQsoEndedAt((d) => d ?? now);
+    } else {
+      // Back to automatic. Without this the frozen values would linger for
+      // ever: a start time held from a backdated entry would never refresh,
+      // even after a new callsign is typed. A QSO already in progress snaps its
+      // start to now, since the moment it would have been taken has passed.
       setQsoStartedAt(callsign.trim() ? new Date() : null);
-        } else if (k === 'end') {
-          // Drop the frozen end so the field tracks the live UTC clock.
       setQsoEndedAt(null);
     }
-      } else {
-        // Locking (manual / deferred entry) → pre-fill with today's date + the
-        // current UTC time so the fields aren't empty; the operator just adjusts.
-        const now = new Date();
-        if (k === 'start') setQsoStartedAt((d) => d ?? now);
-        else if (k === 'end') setQsoEndedAt((d) => d ?? now);
-      }
-      return next;
-    });
   };
   const [band, setBand] = useState('20m');
   const [mode, setMode] = useState('SSB');
@@ -717,6 +727,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.
@@ -1341,6 +1360,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');
@@ -2329,16 +2359,6 @@ export default function App() {
     return () => window.clearInterval(t);
   }, []);
 
-  // PSK Reporter feed, for the status-bar chip. Polled slowly: the chip only
-  // says up or down, and the count behind it is a tooltip.
-  const [pskr, setPskr] = useState<any>(null);
-  useEffect(() => {
-    const load = () => { GetPSKReporterStatus().then(setPskr).catch(() => {}); };
-    load();
-    const t = window.setInterval(load, 10000);
-    return () => window.clearInterval(t);
-  }, []);
-
   // "ON AIR" status-bar badge: mirrors the multi-op live status this operator
   // publishes — online (blinking) when a QSO was logged in the last 5 min, else
   // offline. Publishing is always on for a shared MySQL logbook (no user toggle:
@@ -2574,6 +2594,15 @@ export default function App() {
   // half hour — long enough to hold a whole opening, short enough that a night
   // of FT8 on 20 m does not turn the list into something no filter can rescue.
   const DECODE_KEEP_MS = 30 * 60 * 1000;
+  // And a hard ceiling on the count, because the half hour is not one on a
+  // crowded band.
+  //
+  // Three decoders on an open evening put several thousand rows in that window,
+  // and the panel slows down long before the age limit removes any of them:
+  // every one is a row to lay out, a status to resolve and a distance to work
+  // out. Two thousand is more than a screen can hold many times over, and past
+  // it the oldest go — the newest period is what an operator is reading.
+  const DECODE_MAX = 2000;
   const [decodes, setDecodes] = useState<DecodeRow[]>([]);
   const [txMsgs, setTxMsgs] = useState<TxMsgRow[]>([]);
   // The LIVE transmit state, replaced on every Status — what is going out now
@@ -3087,15 +3116,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
@@ -3265,12 +3322,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);
@@ -3826,7 +3896,9 @@ export default function App() {
             return !b2 || (d.band ?? '').toLowerCase() === b2;
           });
         const next = [...kept, ...fresh].filter((d) => Date.parse(d.at) >= cutoff);
-        return next;
+        // Oldest first in this list, so the ceiling is applied from the front:
+        // what goes is what was already scrolled past.
+        return next.length > DECODE_MAX ? next.slice(next.length - DECODE_MAX) : next;
       });
     };
     flushDecodesRef.current = () => { void flushDecodes(); };
@@ -5160,6 +5232,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' },
@@ -5217,6 +5290,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;
@@ -5353,8 +5427,15 @@ export default function App() {
   // "59+30" turned up, which is five characters plus its padding and no longer
   // fitted. The RST fields are back to their original width; the callsign keeps
   // the rest of the row.
+  // shrink-0, and a notch narrower than it used to be.
+  //
+  // The row it sits in gains a date field when the padlock is closed, and a
+  // flex row makes room by shrinking its children — so the callsign box, the
+  // widest of them, visibly narrowed the moment the operator started a manual
+  // entry. The field the eye is on while typing must not move. It is now the
+  // size it will always be, and the slack comes from the boxes beside it.
   const callsignBlock = (
-    <div className="flex flex-col w-56" data-esm="call">
+    <div className="flex flex-col w-52 shrink-0" data-esm="call">
       <Label className="flex items-center gap-2 h-3.5" style={{ marginBottom: 6 }}>
         <span className="text-primary font-semibold">{t('field.callsign')}</span>
         {lookupBusy && (
@@ -5500,8 +5581,12 @@ export default function App() {
       </div>
     </div>
   );
+  // Both report boxes: a notch narrower and pinned, for the same reason as the
+  // callsign. They were the next widest things in the row, so once the callsign
+  // stopped giving, they were the ones that moved when the date appeared.
+  // "59+20" is the longest report either ever holds and still fits.
   const rstTxBlock = (
-    <div className="flex flex-col w-20" data-esm="rsttx"><Label className="mb-1 h-3.5">{t('field.rstTx')}</Label>
+    <div className="flex flex-col w-[4.5rem] shrink-0" data-esm="rsttx"><Label className="mb-1 h-3.5">{t('field.rstTx')}</Label>
       {/* 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. */}
@@ -5511,7 +5596,7 @@ export default function App() {
     </div>
   );
   const rstRxBlock = (
-    <div className="flex flex-col w-20" data-esm="rstrx"><Label className="mb-1 h-3.5">{t('field.rstRx')}</Label>
+    <div className="flex flex-col w-[4.5rem] shrink-0" 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; }}
         onWheelStep={(d) => { setRstRcvd((v) => stepRST(v, d, mode)); rstUserEditedRef.current = true; }} />
@@ -5547,7 +5632,7 @@ export default function App() {
   ) : null;
   const startBlock = (
     <div className="flex flex-col w-28">
-      <Label className="mb-1 h-3.5 flex items-center gap-1 text-success">{t('field.startUtc')} <LockPad on={locks.start} title="start time" onToggle={() => toggleLock('start')} /></Label>
+      <Label className="mb-1 h-3.5 flex items-center gap-1 text-success">{t('field.startUtc')} <LockPad on={manualEntry} title={manualEntry ? t('field.manualEntryOff') : t('field.manualEntryOn')} onToggle={() => setManualEntry(!manualEntry)} /></Label>
       <Input
         readOnly={!locks.start}
         tabIndex={locks.start ? 0 : -1}
@@ -5566,7 +5651,7 @@ export default function App() {
   );
   const endBlock = (
     <div className="flex flex-col w-28">
-      <Label className="mb-1 h-3.5 flex items-center gap-1 text-danger">{t('field.endUtc')} <LockPad on={locks.end} title="end time" onToggle={() => toggleLock('end')} /></Label>
+      <Label className="mb-1 h-3.5 flex items-center gap-1 text-danger">{t('field.endUtc')}</Label>
       <Input
         readOnly={!locks.end}
         tabIndex={locks.end ? 0 : -1}
@@ -5837,7 +5922,7 @@ export default function App() {
   // used in the full layout to save vertical height.
   const bandRow = (
     <div className="flex items-center gap-2">
-      <Label className="w-20 shrink-0 flex items-center gap-1">{t('field.band')} <LockPad on={locks.band} title="band" onToggle={() => toggleLock('band')} /></Label>
+      <Label className="w-20 shrink-0 flex items-center gap-1">{t('field.band')}</Label>
       <div className="flex-1 min-w-0">
         <Select value={band} onValueChange={onBandUserChange}>
           <SelectTrigger tabIndex={-1} className="h-8"><SelectValue /></SelectTrigger>
@@ -5848,7 +5933,7 @@ export default function App() {
   );
   const modeRow = (
     <div className="flex items-center gap-2">
-      <Label className="w-20 shrink-0 flex items-center gap-1">{t('field.mode')} <LockPad on={locks.mode} title="mode" onToggle={() => toggleLock('mode')} /></Label>
+      <Label className="w-20 shrink-0 flex items-center gap-1">{t('field.mode')}</Label>
       <div className="flex-1 min-w-0">
         <Select value={mode} onValueChange={onModeUserChange}>
           <SelectTrigger tabIndex={-1} className="h-8"><SelectValue /></SelectTrigger>
@@ -5876,7 +5961,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
@@ -5894,6 +6001,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');
   };
 
@@ -5923,7 +6031,7 @@ export default function App() {
   };
   const freqBlock = (
     <div className="flex flex-col w-32">
-      <Label className="mb-1 h-3.5 flex items-center gap-1">{t('field.txFreq')} <LockPad on={locks.freq} title="frequency" onToggle={() => toggleLock('freq')} /></Label>
+      <Label className="mb-1 h-3.5 flex items-center gap-1">{t('field.txFreq')}</Label>
       <Input
         tabIndex={-1}
         className="font-mono"
@@ -6830,9 +6938,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}
@@ -6929,8 +7037,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" />}
-                {!ubStatus.moving && showMotorAnt && ubStatus.connected && <span className="absolute -top-0.5 -right-0.5 size-2 rounded-full bg-success" />}
+                {motorMoving && <span className="absolute -top-0.5 -right-0.5 size-2 rounded-full bg-warning animate-pulse" />}
+                {!motorMoving && showMotorAnt && ubStatus.connected && <span className="absolute -top-0.5 -right-0.5 size-2 rounded-full bg-success" />}
               </button>
             )}
             {agEnabled && (
@@ -7733,7 +7841,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
@@ -8020,7 +8128,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>}
@@ -8087,6 +8195,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')}
@@ -8735,6 +8858,18 @@ 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' && (
@@ -8796,7 +8931,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>
@@ -8967,6 +9102,7 @@ export default function App() {
               catUp={catUp}
               catState={catState}
               onOpenSettings={() => { setSettingsSection('cat'); setShowSettings(true); }}
+              onRadioSwitched={loadCATCfg}
             />
             <Chip
               on={rotatorHeading.enabled && rotatorHeading.ok}
@@ -9012,26 +9148,12 @@ export default function App() {
                 </button>
               );
             })}
-            {/* PSK Reporter, next to the hardware chips because it is the same
-                kind of fact: a link that is either up or it is not. Shown ONLY
-                when the opening watch is on — a permanently grey chip for a
-                feature nobody enabled is clutter, and the bar is 28 px.
-
-                The decode count is in the tooltip rather than the chip: it moves
-                several times a second on an open band, and a number flickering in
-                the corner of the eye is not information, it is a distraction. */}
-            {pskr?.running && (
-              <button
-                type="button"
-                title={t('pskr.tip', { n: pskr.received ?? 0, bands: (pskr.bands ?? []).join(' ') })}
-                onClick={() => { setSettingsSection('cluster'); setShowSettings(true); }}
-                className="inline-flex items-center gap-1.5 px-2 h-5 rounded border text-[11px] transition-colors border-border hover:bg-muted cursor-pointer shrink-0"
-              >
-                <span className={cn('size-2 rounded-full',
-                  (pskr.received ?? 0) > 0 ? 'bg-success' : 'bg-warning')} />
-                MQTT
-              </button>
-            )}
+            {/* The PSK Reporter chip used to sit here, labelled MQTT. That is
+                the name of a message protocol, not of anything an operator has:
+                a chip in the status bar has to say what it is about, and this
+                one told nobody anything. The state it carried — the openings
+                feed up or down, and how many reports have arrived — is shown in
+                the Chase New panel, which is the place that uses it. */}
             {/* ON AIR badge: "did I log a QSO in the last 5 min" — meaningful on ANY
                 logbook backend (only the live_status PUBLISHING is MySQL-specific),
                 so it is always shown. Gating it on MySQL made it vanish for
@@ -9212,7 +9334,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/AlertsModal.tsx

@@ -141,7 +141,7 @@ export function AlertsModal({ onClose, bands, modes, countries }: {
 
   return (
     <Dialog open onOpenChange={(o) => { if (!o) onClose(); }}>
-      <DialogContent className="max-w-4xl">
+      <DialogContent overlayBlur={false} className="max-w-4xl">
         <DialogHeader>
           <DialogTitle className="flex items-center gap-2"><Bell className="size-4 text-primary" /> {t('altm.title')}</DialogTitle>
           <DialogDescription>{t('altm.desc')}</DialogDescription>

frontend/src/components/AwardEditor.tsx

@@ -403,7 +403,7 @@ export function AwardEditor({ open, onClose, onSaved }: Props) {
 
   return (
     <Dialog open={open} onOpenChange={(o) => { if (!o) onClose(); }}>
-      <DialogContent className="max-w-6xl w-[95vw] max-h-[92vh] grid grid-rows-[auto_1fr_auto] gap-0 p-0">
+      <DialogContent overlayBlur={false} className="max-w-6xl w-[95vw] max-h-[92vh] grid grid-rows-[auto_1fr_auto] gap-0 p-0">
         <DialogHeader className="px-5 py-3 border-b">
           <DialogTitle>{t('awed.awardManagement')}</DialogTitle>
         </DialogHeader>

frontend/src/components/BandSlotGrid.tsx

@@ -60,7 +60,11 @@ const DEFAULT_BANDS: { tag: string; label: string }[] = [
 ];
 const CLASSES = ['PH', 'CW', 'DIG'] as const;
 
-const PHONE_MODES = new Set(['SSB','USB','LSB','AM','FM','DIGITALVOICE','PHONE']);
+export const PHONE_MODES = new Set(['SSB','USB','LSB','AM','FM','DIGITALVOICE','PHONE']);
+
+// Which digital row the matrix opens on. Empty = DIG, the group of them all.
+// Set in Settings ▸ General; see the rotation below.
+export const MATRIX_DIGI_KEY = 'opslog.matrixDigiMode';
 function classMatchesMode(cls: string, mode: string): boolean {
   const u = (mode || '').toUpperCase();
   if (cls === 'PH') return PHONE_MODES.has(u);
@@ -143,7 +147,17 @@ export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, modes,
       .filter((m) => m !== '' && m !== 'CW' && !PHONE_MODES.has(m)),
     [modes],
   );
+  // Where the rotation STARTS. An operator who only ever works FT8 was shown
+  // "DIG" every time and had to click to the mode they actually use, on every
+  // callsign — so the row they want is the one it opens on. Empty (the default)
+  // keeps DIG, which is right for anyone working several digital modes.
   const [digIdx, setDigIdx] = useState(0); // 0 = the DIG group itself
+  useEffect(() => {
+    const want = (localStorage.getItem(MATRIX_DIGI_KEY) || '').toUpperCase().trim();
+    if (!want) { setDigIdx(0); return; }
+    const i = digModes.indexOf(want);
+    setDigIdx(i >= 0 ? i + 1 : 0);
+  }, [digModes]);
   // A shorter mode list (the operator edited it) must not strand the rotation
   // on a row that no longer exists.
   const digPos = digModes.length ? digIdx % (digModes.length + 1) : 0;

frontend/src/components/BulkEditModal.tsx

@@ -193,7 +193,7 @@ export function BulkEditModal({ open, ids, onClose, onApplied }: Props) {
 
   return (
     <Dialog open={open} onOpenChange={(o) => { if (!o) onClose(); }}>
-      <DialogContent className="max-w-md">
+      <DialogContent overlayBlur={false} className="max-w-md">
         <DialogHeader>
           <DialogTitle>{t('bulk.title')}</DialogTitle>
           <DialogDescription>

frontend/src/components/DecodesPanel.tsx

@@ -12,7 +12,7 @@
 // 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';
@@ -320,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';
 
@@ -671,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
@@ -802,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 = () => {
@@ -1198,7 +1297,10 @@ 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) => {
+            const sortable = SORTABLE.includes(c.key as SortKey);
+            const active = sortable && sortKey === c.key;
+            return (
               <span key={c.key}
                 // Not CELL_LAST for the final column: its overflow-hidden would
                 // clip that column's own resize handle.
@@ -1206,15 +1308,22 @@ export function DecodesPanel({ decodes, txMsgs, txState, txStates, spotStatus, r
                   i < cols.length - 1 && 'border-r border-border/30',
                   // The three numeric columns label their own right edge, where the
                   // figures are.
-                (c.key === 'snr' || c.key === 'dt' || c.key === 'freq' || c.key === 'dist') && 'justify-end')}
-              title={c.key === 'dt' ? t('dec.colDtTitle') : c.key === 'freq' ? t('dec.colFreqTitle') : undefined}>
+                  (c.key === 'snr' || c.key === 'dt' || c.key === 'freq' || c.key === 'dist') && 'justify-end',
+                  sortable && 'cursor-pointer select-none hover:text-foreground',
+                  active && 'text-primary')}
+                onClick={sortable ? () => toggleSort(c.key as SortKey) : undefined}
+                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>
 

frontend/src/components/DetailsPanel.tsx

@@ -9,6 +9,7 @@ import {
 import { cn } from '@/lib/utils';
 import { useI18n } from '@/lib/i18n';
 import { Combobox } from '@/components/ui/combobox';
+import { useOperatingLists } from '@/lib/operatingLists';
 import { pathBetween, pathBetweenLatLon, gridToLatLon } from '@/lib/maidenhead';
 import { BandSlotGrid } from '@/components/BandSlotGrid';
 import { AwardRefSelector } from '@/components/AwardRefSelector';
@@ -158,6 +159,7 @@ function Field({ label, span = 1, className, children }: { label: string; span?:
 
 export function DetailsPanel({ callsign, prefix, operatorGrid, remoteGrid, qth, name, country, comment, note, details, onChange, wb, wbBusy, band, mode, bands, modes, satellites = [], slotCall, slotBand, slotMode, slotWb, slotWbBusy, tab, onTab, keyerActive, onEditQso }: Props) {
   const { t } = useI18n();
+  const oper = useOperatingLists(tab);
   const [internalOpen, setInternalOpen] = useState<TabName>('stats');
   const open = tab ?? internalOpen; // controlled when `tab` is provided
 
@@ -476,11 +478,21 @@ export function DetailsPanel({ callsign, prefix, operatorGrid, remoteGrid, qth,
               </SelectContent>
             </Select>
           </Field>
+          {/* The rigs and antennas already declared in Settings ▸ Operating
+              conditions. Typing them again on every contact is both work and a
+              source of spellings that do not match — "IC-7610", "IC 7610" and
+              "ic7610" are three different rigs to an award and to a filter.
+              Free text stays allowed: a QSO made from somebody else's station
+              carries a rig that was never in this tree. */}
           <Field label={t('detp.rig')} span={3}>
-            <Input value={details.my_rig} onChange={(e) => onChange({ my_rig: e.target.value })} />
+            <Combobox value={details.my_rig} options={oper.rigs} showToggle allowFreeText
+              onChange={(v) => onChange({ my_rig: v })} />
           </Field>
           <Field label={t('detp.antenna')} span={3}>
-            <Input value={details.my_antenna} onChange={(e) => onChange({ my_antenna: e.target.value })} />
+            {/* The antennas of the chosen rig, since that is what they hang off
+                — and all of them when the rig is one this tree does not know. */}
+            <Combobox value={details.my_antenna} options={oper.antennasFor(details.my_rig)} showToggle allowFreeText
+              onChange={(v) => onChange({ my_antenna: v })} />
           </Field>
           {satelliteMode && (
             <>

frontend/src/components/FTMapPanel.tsx

@@ -6,6 +6,7 @@ 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
@@ -128,7 +129,7 @@ export function FTMapPanel({ decodes, myGrid, onSelect, onCall }: {
     };
     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
@@ -164,15 +165,21 @@ export function FTMapPanel({ decodes, myGrid, onSelect, onCall }: {
       L.polyline(pts as L.LatLngExpression[][], {
         color: colour, weight: 1.3, opacity: 0.65 * fade, smoothFactor: 0,
       }).addTo(layer);
+      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 twice the size takes the clicks.
+        // 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' })
-        .addTo(layer);
+      }).bindTooltip(label, { direction: 'top' }).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,
-      }).addTo(layer);
+      }).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.

frontend/src/components/GridSquareMap.tsx

@@ -6,7 +6,8 @@ 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';
 
@@ -86,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
@@ -253,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,6 +3,7 @@ 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';
@@ -116,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 v === 'voyager' || v === 'street' || v === 'satellite' ? v : 'light';
+  return loadMapBase(MAP_BASE_WORLD, 'light');
 }
 
 // addBasemap (re)installs the imagery layer and, for satellite, its transparent
@@ -445,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'

frontend/src/components/QSOEditModal.tsx

@@ -19,6 +19,7 @@ import {
 } from '@/components/ui/select';
 import { Checkbox } from '@/components/ui/checkbox';
 import { Combobox } from '@/components/ui/combobox';
+import { useOperatingLists } from '@/lib/operatingLists';
 import { cn } from '@/lib/utils';
 import { flagURL } from '@/lib/flags';
 import { useI18n } from '@/lib/i18n';
@@ -288,6 +289,9 @@ function QslViaSelect({ value, onChange }: { value?: string; onChange: (v: strin
 
 export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], bands, modes }: Props) {
   const { t } = useI18n();
+  // Read once per opening of the editor: rigs and antennas do not change while
+  // a contact is being corrected.
+  const oper = useOperatingLists();
   // Use the operator's configured band/mode lists (incl. custom ones like 13cm);
   // fall back to the built-in sets. Always include the QSO's own band/mode so an
   // imported/legacy value is never silently dropped from the dropdown.
@@ -542,7 +546,7 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
 
   return (
     <Dialog open onOpenChange={(o) => { if (!o) onClose(); }}>
-      <DialogContent className="max-w-5xl max-h-[92vh] grid grid-rows-[auto_1fr_auto] gap-0 p-0">
+      <DialogContent overlayBlur={false} className="max-w-5xl max-h-[92vh] grid grid-rows-[auto_1fr_auto] gap-0 p-0">
         <DialogHeader className="flex-row items-baseline gap-2">
           <DialogTitle>{t('qedit.title')}</DialogTitle>
           <span className="font-mono text-xs text-muted-foreground">#{draft.id} — {draft.callsign}</span>
@@ -982,8 +986,18 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
                 <F label={t('qedit.street')} span={2}><Input value={draft.my_street ?? ''} onChange={(e) => set('my_street', e.target.value)} /></F>
                 <F label={t('qedit.city')} span={2}><Input value={draft.my_city ?? ''} onChange={(e) => set('my_city', e.target.value)} /></F>
                 <F label={t('qedit.postal')} span={2}><Input value={draft.my_postal_code ?? ''} onChange={(e) => set('my_postal_code', e.target.value)} /></F>
-                <F label={t('qedit.rig')} span={3}><Input value={draft.my_rig ?? ''} onChange={(e) => set('my_rig', e.target.value)} /></F>
-                <F label={t('qedit.antenna')} span={3}><Input value={draft.my_antenna ?? ''} onChange={(e) => set('my_antenna', e.target.value)} /></F>
+                {/* The station's own rigs and antennas (Settings ▸ Operating
+                    conditions), so a correction here spells them the same way
+                    the log already does. Free text stays: an imported contact
+                    carries whatever the other logger wrote. */}
+                <F label={t('qedit.rig')} span={3}>
+                  <Combobox value={draft.my_rig ?? ''} options={oper.rigs} showToggle allowFreeText
+                    onChange={(v) => set('my_rig', v)} />
+                </F>
+                <F label={t('qedit.antenna')} span={3}>
+                  <Combobox value={draft.my_antenna ?? ''} options={oper.antennasFor(draft.my_rig ?? '')} showToggle allowFreeText
+                    onChange={(v) => set('my_antenna', v)} />
+                </F>
               </div>
             </TabsContent>
 

frontend/src/components/RotorCompass.tsx

@@ -70,13 +70,23 @@ const TARGET_FADE_MS = 500;
 // in four colour schemes stops being readable. The chrome around it — card,
 // borders, buttons — follows the theme as everything else does.
 const COMPASS_ORANGE = '#F97316';
+// Three things are drawn on this dial and they must never be mistaken for one
+// another: where the antenna IS (green, as everywhere else in OpsLog), where
+// the mouse would send it (orange, the dial's own colour), and where it has
+// been ORDERED to go (yellow, the same yellow as the figure under the readout).
+const BEAM_GREEN = '#22C55E';
+type BeamKind = 'antenna' | 'hover';
 // The target is yellow in BOTH places it appears: the figure under the current
 // azimuth and the dot on the dial. One idea, one colour.
 const TARGET_YELLOW = '#FBBF24';
 const MAP_BG_TOP = '#0B1015';
 const MAP_BG_BOTTOM = '#080C11';
-const MAP_LAND = '#202832';
-const MAP_LAND_SECONDARY = '#25303A';
+// The continents, and they have to be VISIBLE. At #202832 on a #0B1015 ground
+// the land was some eight per cent brighter than the sea — technically a map,
+// practically a dark square with a suggestion in it. These read as coastlines
+// while staying well under the beams, which are what the dial is for.
+const MAP_LAND = '#33414F';
+const MAP_LAND_SECONDARY = '#41525F';
 
 // What each rotor was last seen at, and what it was last told to do, kept
 // OUTSIDE the component and keyed by rotor index.
@@ -118,7 +128,7 @@ function unwrapRotation(nextAngle: number, previousRotation: number | null): num
 
 function RotorCompassDial({
   azimuth, secondary, boom, targetAzimuth, targetFading,
-  shortPath, longPath, centerLat, centerLon, onGoto,
+  shortPath, longPath, centerLat, centerLon, onGoto, onHoverAzimuth,
 }: {
   azimuth: number | null;
   // The second lobe of a bidirectional Ultrabeam, and the mechanical boom when
@@ -132,6 +142,10 @@ function RotorCompassDial({
   centerLat?: number | null;
   centerLon?: number | null;
   onGoto?: (az: number) => void;
+  // What the mouse is over, so the readout can show it. The figure belongs
+  // beside the current heading, not on the map: a number floating over a beam
+  // is read by moving the eye, and this one is read while aiming.
+  onHoverAzimuth?: (az: number | null) => void;
 }) {
   // Gradient and mask ids must be unique per instance: two compasses on one
   // screen (docked widget + Station Control) would otherwise share the first
@@ -144,16 +158,19 @@ function RotorCompassDial({
   const SIZE = 320;
   const CENTER = SIZE / 2;
 
-  // The scale is a SQUARE ring, not a circle: it puts the tick marks at the
-  // edge of the panel, which is where the room is.
-  const SCALE_HALF = 108;
-  const CARDINAL_TICK_OUTER_HALF = SCALE_HALF + 7;
-  const MAJOR_TICK_INNER_HALF = SCALE_HALF - 17;
+  // A CIRCLE, not a square ring. The square put the ticks in the corners of
+  // the panel, which is where the room is — and made every distance from the
+  // centre depend on the direction, so a marker at 45° sat further out than one
+  // at north. A dial is read by angle; the ring it is read against has to be
+  // the same distance away all the way round.
+  const SCALE_RADIUS = 112;
+  const CARDINAL_TICK_OUTER_RADIUS = SCALE_RADIUS + 7;
+  const MAJOR_TICK_INNER_RADIUS = SCALE_RADIUS - 17;
   const POINTER_TIP_RADIUS = 72;
-  const CARDINAL_LABEL_INSET = 23;
+  const CARDINAL_LABEL_RADIUS = SCALE_RADIUS + 24;
   const CENTER_DOT_RADIUS = 4.2;
   const MAP_RADIUS = CENTER - 1;
-  // Around the centre the cursor's direction is meaningless — a pixel either
+  // Around the centre the cursor’s direction is meaningless — a pixel either
   // way is forty degrees — so no heading is derived there.
   const HOVER_DEAD_ZONE = 14;
 
@@ -171,34 +188,15 @@ function RotorCompassDial({
     return geoPath(projection as any)(LAND as any) || '';
   }, [centerLat, centerLon]);
 
-  // A point on the square scale at a given azimuth.
-  const squarePoint = (angle: number, halfExtent: number) => {
-    const radians = (normalizeAzimuth(angle) * Math.PI) / 180;
-    const dx = Math.sin(radians);
-    const dy = -Math.cos(radians);
-    const divisor = Math.max(Math.abs(dx), Math.abs(dy), 0.0001);
-    const scale = halfExtent / divisor;
-    return { x: CENTER + dx * scale, y: CENTER + dy * scale };
-  };
-
   const radialPoint = (angle: number, radius: number) => {
     const radians = (normalizeAzimuth(angle) * Math.PI) / 180;
     return { x: CENTER + Math.sin(radians) * radius, y: CENTER - Math.cos(radians) * radius };
   };
 
-  const radialDistanceToSquare = (angle: number, halfExtent: number) => {
-    const radians = (normalizeAzimuth(angle) * Math.PI) / 180;
-    const dx = Math.sin(radians);
-    const dy = -Math.cos(radians);
-    return halfExtent / Math.max(Math.abs(dx), Math.abs(dy), 0.0001);
-  };
-
-  // Markers sit halfway between the pointer's tip and the scale, so they stay
-  // clear of both whatever direction they are in — the ring is a square.
-  const markerRadius = (angle: number) => {
-    const tickInnerRadius = radialDistanceToSquare(angle, MAJOR_TICK_INNER_HALF);
-    return POINTER_TIP_RADIUS + (tickInnerRadius - POINTER_TIP_RADIUS) / 2;
-  };
+  // Markers sit halfway between the beam’s tip and the scale, clear of both.
+  // One number now: on a circular ring the answer no longer depends on which
+  // way the marker lies.
+  const markerRadius = POINTER_TIP_RADIUS + (MAJOR_TICK_INNER_RADIUS - POINTER_TIP_RADIUS) / 2;
 
   const azimuthFromMouseEvent = (event: ReactMouseEvent<SVGSVGElement>): number | null => {
     const rect = event.currentTarget.getBoundingClientRect();
@@ -214,6 +212,7 @@ function RotorCompassDial({
 
   const clearHover = () => {
     setHoverAzimuth(null);
+    onHoverAzimuth?.(null);
     setHoverRotation(null);
     hoverRotationRef.current = null;
   };
@@ -225,6 +224,7 @@ function RotorCompassDial({
     const nextRotation = unwrapRotation(nextAzimuth, hoverRotationRef.current);
     hoverRotationRef.current = nextRotation;
     setHoverAzimuth(nextAzimuth);
+    onHoverAzimuth?.(nextAzimuth);
     setHoverRotation(nextRotation);
   };
 
@@ -239,7 +239,7 @@ function RotorCompassDial({
   const degreeLabels = [30, 60, 120, 150, 210, 240, 300, 330];
 
   const renderPathDot = (angle: number, type: 'sp' | 'lp') => {
-    const point = radialPoint(angle, markerRadius(angle));
+    const point = radialPoint(angle, markerRadius);
     return (
       <circle cx={point.x} cy={point.y} r="4.2" fill="currentColor"
         className={type === 'sp' ? 'text-success' : 'text-destructive'}
@@ -248,42 +248,56 @@ function RotorCompassDial({
   };
 
   const renderTargetDot = (angle: number) => {
-    const point = radialPoint(angle, markerRadius(angle));
+    const point = radialPoint(angle, markerRadius);
     return (
       <circle cx={point.x} cy={point.y} r="4.2" fill={TARGET_YELLOW} pointerEvents="none"
         style={{ opacity: targetFading ? 0 : 0.95, transition: `opacity ${TARGET_FADE_MS}ms ease-out` }} />
     );
   };
 
-  // The pointer is drawn once and rotated, so the browser animates the turn
-  // instead of the component redrawing a triangle every telemetry read.
-  const renderPointer = (rotation: number, colour: string | null, opacity: number, animated: boolean) => {
-    const tipY = 88;
-    const baseY = 110;
-    const innerTipY = 98;
+  // A BEAM, not an arrow. The dial answers "where is the antenna looking", and
+  // an antenna does not look along a line — it looks through a lobe. Drawn as a
+  // sector that fades outwards, which is also the shape of the thing it stands
+  // for; the arrow said a precision the beamwidth does not have.
+  //
+  // Drawn pointing north and rotated as a whole, so the browser animates the
+  // turn instead of the component recomputing an arc on every telemetry read —
+  // and rotation is the ONLY source of angle here, which is what keeps the
+  // mouse preview exactly under the cursor.
+  const BEAM_HALF_ANGLE = 17.5;
+  const renderBeam = (rotation: number, kind: BeamKind, opacity: number, animated: boolean) => {
+    const left = radialPoint(-BEAM_HALF_ANGLE, SCALE_RADIUS);
+    const right = radialPoint(BEAM_HALF_ANGLE, SCALE_RADIUS);
     return (
       <g
-        className={colour ? undefined : 'text-success'}
         pointerEvents="none"
         style={{
           transform: `rotate(${rotation}deg)`,
           transformOrigin: `${CENTER}px ${CENTER}px`,
           opacity,
-          transition: animated ? 'transform 350ms ease-out' : 'transform 70ms linear, opacity 120ms ease-out',
+          transition: animated
+            ? 'transform 500ms cubic-bezier(0.16,1,0.3,1), opacity 500ms ease-out'
+            : 'transform 70ms linear, opacity 120ms ease-out',
         }}
       >
-        <path d={`M ${CENTER - 13} ${baseY} L ${CENTER} ${tipY} L ${CENTER + 13} ${baseY}`}
-          fill="none" stroke={colour ?? 'currentColor'} strokeWidth="5.5"
-          strokeLinecap="round" strokeLinejoin="round" />
-        <path d={`M ${CENTER - 4.5} ${baseY - 2} L ${CENTER} ${innerTipY} L ${CENTER + 4.5} ${baseY - 2}`}
-          fill="none" stroke={colour ?? 'currentColor'} strokeWidth="2"
-          strokeLinecap="round" strokeLinejoin="round" opacity="0.6" />
+        <path
+          d={`M ${CENTER} ${CENTER} L ${left.x} ${left.y} A ${SCALE_RADIUS} ${SCALE_RADIUS} 0 0 1 ${right.x} ${right.y} Z`}
+          fill={`url(#beam-${kind}-${uid})`}
+        />
+        {/* The axis: the heading itself, to the rim, fading outwards so the
+            eye is drawn to where it starts rather than where it ends. */}
+        <line x1={CENTER} y1={CENTER} x2={CENTER} y2={CENTER - SCALE_RADIUS}
+          stroke={`url(#axis-${kind}-${uid})`} strokeWidth="2" strokeLinecap="round" />
       </g>
     );
   };
 
   return (
-    <div className="w-full h-full min-w-0 aspect-square rounded-md border border-border bg-background flex items-center justify-center overflow-hidden">
+    // No card of its own, and no square: the dial is drawn as a disc and the
+    // corners are left to whatever it is sitting on. A black tile inside the
+    // rotor panel read as a hole punched in it — the widget is already a card,
+    // and this is an instrument on that card, not a second one.
+    <div className="w-full h-full min-w-0 aspect-square flex items-center justify-center overflow-hidden">
       <svg
         viewBox={`0 0 ${SIZE} ${SIZE}`}
         className={cn('block w-full h-full select-none', onGoto ? 'cursor-crosshair' : 'cursor-default')}
@@ -312,12 +326,30 @@ function RotorCompassDial({
           <mask id={mapFadeMaskId}>
             <rect x="0" y="0" width={SIZE} height={SIZE} fill={`url(#${mapFadeGradientId})`} />
           </mask>
+          {/* One pair per beam kind: the sector's wash and its axis. Both fade
+              outwards — a lobe has no edge, and drawing one would claim a
+              beamwidth the antenna does not have. */}
+          {([['antenna', BEAM_GREEN], ['hover', COMPASS_ORANGE]] as const).map(([kind, colour]) => (
+            <g key={kind}>
+              <linearGradient id={`beam-${kind}-${uid}`} x1="0" y1="0" x2="0" y2="1">
+                <stop offset="0%" stopColor={colour} stopOpacity="0.45" />
+                <stop offset="55%" stopColor={colour} stopOpacity="0.22" />
+                <stop offset="100%" stopColor={colour} stopOpacity="0" />
+              </linearGradient>
+              <linearGradient id={`axis-${kind}-${uid}`} x1="0" y1={CENTER} x2="0" y2={CENTER - SCALE_RADIUS}
+                gradientUnits="userSpaceOnUse">
+                <stop offset="0%" stopColor={colour} stopOpacity="1" />
+                <stop offset="55%" stopColor={colour} stopOpacity="0.45" />
+                <stop offset="100%" stopColor={colour} stopOpacity="0" />
+              </linearGradient>
+            </g>
+          ))}
         </defs>
 
-        <rect x="0" y="0" width={SIZE} height={SIZE} fill={`url(#${bgGradientId})`} />
+        <circle cx={CENTER} cy={CENTER} r={MAP_RADIUS} fill={`url(#${bgGradientId})`} />
 
         {landPath && (
-          <g mask={`url(#${mapFadeMaskId})`} opacity="0.78" pointerEvents="none">
+          <g mask={`url(#${mapFadeMaskId})`} opacity="0.92" pointerEvents="none">
             <path d={landPath} fill={MAP_LAND} />
             <path d={landPath} fill={MAP_LAND_SECONDARY} opacity="0.22" transform="translate(0.35 0.35)" />
           </g>
@@ -329,8 +361,8 @@ function RotorCompassDial({
             const cardinal = angle % 90 === 0;
             const major = angle % 30 === 0;
             const medium = !major && angle % 10 === 0;
-            const outer = squarePoint(angle, cardinal ? CARDINAL_TICK_OUTER_HALF : SCALE_HALF);
-            const inner = squarePoint(angle, major ? MAJOR_TICK_INNER_HALF : medium ? SCALE_HALF - 11 : SCALE_HALF - 6);
+            const outer = radialPoint(angle, cardinal ? CARDINAL_TICK_OUTER_RADIUS : SCALE_RADIUS);
+            const inner = radialPoint(angle, major ? MAJOR_TICK_INNER_RADIUS : medium ? SCALE_RADIUS - 11 : SCALE_RADIUS - 6);
             return (
               <line key={`tick-${angle}`} x1={inner.x} y1={inner.y} x2={outer.x} y2={outer.y}
                 stroke="currentColor" strokeLinecap="round"
@@ -343,7 +375,7 @@ function RotorCompassDial({
 
         <g pointerEvents="none">
           {degreeLabels.map((angle) => {
-            const position = squarePoint(angle, SCALE_HALF + 20);
+            const position = radialPoint(angle, SCALE_RADIUS + 22);
             return (
               <text key={`degree-${angle}`} x={position.x} y={position.y}
                 textAnchor="middle" dominantBaseline="middle" fill="currentColor"
@@ -354,22 +386,25 @@ function RotorCompassDial({
           })}
         </g>
 
+        {/* The cardinals sit on the same circle as everything else. Each carries
+            a small outward nudge: the letters are not the same height, and set
+            on a true circle S and W read as if they had slipped inwards. */}
         <g pointerEvents="none">
-          {([['N', CENTER, CARDINAL_LABEL_INSET], ['E', SIZE - CARDINAL_LABEL_INSET, CENTER],
-             ['S', CENTER, SIZE - CARDINAL_LABEL_INSET], ['W', CARDINAL_LABEL_INSET, CENTER]] as const).map(
-            ([label, x, y]) => (
-              <text key={label} x={x} y={y} textAnchor="middle" dominantBaseline="middle"
+          {([['N', 0, 0], ['E', 90, 2], ['S', 180, 4], ['W', 270, 3]] as const).map(([label, angle, nudge]) => {
+            const position = radialPoint(angle, CARDINAL_LABEL_RADIUS + nudge);
+            return (
+              <text key={label} x={position.x} y={position.y} textAnchor="middle" dominantBaseline="middle"
                 fill={COMPASS_ORANGE} className="text-[27px] font-black">
                 {label}
               </text>
-            ),
-          )}
+            );
+          })}
         </g>
 
         {/* Where the mouse is pointing, in the same shape as the antenna's own
             pointer: the click sends the antenna there, so the preview should
             look like what it will produce. */}
-        {hoverAzimuth != null && hoverRotation != null && renderPointer(hoverRotation, COMPASS_ORANGE, 0.78, false)}
+        {hoverAzimuth != null && hoverRotation != null && renderBeam(hoverRotation, 'hover', 1, false)}
 
         {shortPath != null && renderPathDot(shortPath, 'sp')}
         {longPath != null && renderPathDot(longPath, 'lp')}
@@ -391,9 +426,10 @@ function RotorCompassDial({
           );
         })()}
 
-        {/* The second lobe of a bidirectional antenna: same pointer, dimmed. */}
-        {secondary != null && renderPointer(normalizeAzimuth(secondary), null, 0.42, true)}
-        {azimuth != null && renderPointer(normalizeAzimuth(azimuth), null, 0.96, true)}
+        {/* The second lobe of a bidirectional antenna: the same beam, dimmed —
+            it radiates as much, and it is not where the operator aimed. */}
+        {secondary != null && renderBeam(normalizeAzimuth(secondary), 'antenna', 0.45, true)}
+        {azimuth != null && renderBeam(normalizeAzimuth(azimuth), 'antenna', 1, true)}
 
         <circle cx={CENTER} cy={CENTER} r={CENTER_DOT_RADIUS} fill={COMPASS_ORANGE} pointerEvents="none" />
       </svg>
@@ -435,6 +471,8 @@ export function RotorCompass({
     () => rememberedTargets.get(rotorKey) ?? null,
   );
   const [targetFading, setTargetFading] = useState(false);
+  // Where the mouse is aiming, while it is over the dial.
+  const [hoverAzimuth, setHoverAzimuth] = useState<number | null>(null);
 
   const flashTimerRef = useRef<number | undefined>(undefined);
   const movementTimerRef = useRef<number | undefined>(undefined);
@@ -580,9 +618,22 @@ export function RotorCompass({
     return columns;
   }, [presets]);
 
-  // 192 dial + 6 gap + 154 controls + 16 padding, plus 60 per preset column.
+  // THE SELECTOR HAS TO COME OUT OF SOMEWHERE.
+  //
+  // With more than one rotor a row of buttons appears above the dial, and the
+  // widget's height is not its own to take: it sits in a strip whose height is
+  // set by the entry form beside it. The extra row simply pushed the bottom of
+  // the panel off the end — the SP/LP pair and half the Stop button gone.
+  //
+  // So the dial and the button rows give the row back, in proportion: 24 px off
+  // the dial and 8 off each of the three rows is the height of a selector, and
+  // nothing has to be dropped.
+  const tight = !!(rotors && rotors.length > 1);
+  const dialPx = tight ? 168 : 192;
+  const rowPx = tight ? 52 : 60;
+  // 6 gap + 154 controls + 16 padding, plus 60 per preset column.
   const controlsWidth = 154 + presetColumns.length * 60;
-  const widgetWidth = 368 + presetColumns.length * 60;
+  const widgetWidth = dialPx + 176 + presetColumns.length * 60;
 
   const markMovementCommanded = () => {
     movementSeenRef.current = false;
@@ -683,7 +734,8 @@ export function RotorCompass({
 
   const renderPresetColumn = (column: RotorPreset[], columnIndex: number) => (
     <div key={`preset-column-${columnIndex}`}
-      className="w-[54px] min-w-[54px] shrink-0 grid grid-rows-[60px_60px_60px] gap-1.5 min-h-0">
+      className="w-[54px] min-w-[54px] shrink-0 grid gap-1.5 min-h-0"
+      style={{ gridTemplateRows: `repeat(3, ${rowPx}px)` }}>
       {[0, 2, 4].map((row) => (
         <div key={row} className="h-full min-h-0 grid grid-rows-2 gap-1">
           {column[row] && renderPresetButton(column[row], columnIndex * 6 + row)}
@@ -719,17 +771,36 @@ export function RotorCompass({
   );
 
   const mainControls = (
-    <div className="w-[154px] min-w-[154px] shrink-0 grid grid-rows-[60px_60px_60px] gap-1.5 min-h-0">
+    <div className="w-[154px] min-w-[154px] shrink-0 grid gap-1.5 min-h-0"
+      style={{ gridTemplateRows: `repeat(3, ${rowPx}px)` }}>
       {/* Where the antenna is, and under it — smaller, yellow, and only while it
           matters — where it was told to go. */}
       <div className="h-full min-h-0 rounded-md border border-border bg-background/30 px-1 text-center relative overflow-hidden">
+        {/* Two readings in ONE place, cross-faded: where the antenna is, and —
+            while the mouse is over the dial — where a click would send it. The
+            aiming figure is what the operator is reading at that moment, and
+            putting it somewhere else means looking away from the beam to find
+            it. The green one does not move, so nothing jumps when the mouse
+            leaves the dial. */}
         <div className={cn(
-          'absolute left-1/2 top-1/2 -translate-x-1/2 font-mono text-[30px] leading-none font-bold tabular-nums whitespace-nowrap transition-all duration-300 ease-out',
+          'absolute left-1/2 top-1/2 -translate-x-1/2 font-mono leading-none font-bold tabular-nums whitespace-nowrap transition-all duration-300 ease-out',
+          tight ? 'text-[26px]' : 'text-[30px]',
           targetAzimuth != null ? '-translate-y-[72%]' : '-translate-y-1/2',
+          hoverAzimuth != null ? 'opacity-0 scale-95' : 'opacity-100 scale-100',
           displayAzimuth != null ? 'text-success' : 'text-muted-foreground',
         )}>
           {displayAzimuth != null ? `${displayAzimuth}°` : '—'}
         </div>
+
+        <div className={cn(
+          'absolute left-1/2 top-1/2 -translate-x-1/2 font-mono leading-none font-bold tabular-nums whitespace-nowrap transition-all duration-300 ease-out',
+          tight ? 'text-[26px]' : 'text-[30px]',
+          targetAzimuth != null ? '-translate-y-[72%]' : '-translate-y-1/2',
+          hoverAzimuth != null ? 'opacity-100 scale-100' : 'opacity-0 scale-95 pointer-events-none',
+        )}
+          style={{ color: COMPASS_ORANGE }}>
+          {hoverAzimuth != null ? `${hoverAzimuth}°` : ''}
+        </div>
         {targetAzimuth != null && (
           <div
             className={cn(
@@ -812,6 +883,7 @@ export function RotorCompass({
       centerLat={centerLat}
       centerLon={centerLon}
       onGoto={onGoto ? gotoAzimuth : undefined}
+      onHoverAzimuth={setHoverAzimuth}
     />
   );
 
@@ -857,7 +929,7 @@ export function RotorCompass({
       </div>
 
       {rotors && rotors.length > 1 && (
-        <div className="flex flex-wrap gap-1 px-2 pt-1.5">
+        <div className="flex flex-wrap gap-1 px-2 pt-1">
           {rotors.map((name, index) => {
             const active = (activeRotor ?? 0) === index;
             const label = name?.trim() || `Rotor ${index + 1}`;
@@ -875,8 +947,10 @@ export function RotorCompass({
       )}
 
       {showControls ? (
-        <div className="flex items-stretch gap-1.5 p-2 min-h-0">
-          <div className="w-[192px] min-w-[192px] h-[192px] min-h-[192px] shrink-0">{dial}</div>
+        // The padding gives its share too: four pixels, which is what the
+        // selector row still owed after the dial and the buttons had paid.
+        <div className={cn('flex items-stretch gap-1.5 min-h-0', tight ? 'p-1.5' : 'p-2')}>
+          <div className="shrink-0" style={{ width: dialPx, minWidth: dialPx, height: dialPx, minHeight: dialPx }}>{dial}</div>
           <div className="shrink-0 flex gap-1.5 min-h-0"
             style={{ width: `${controlsWidth}px`, minWidth: `${controlsWidth}px` }}>
             {mainControls}

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

@@ -1,5 +1,5 @@
 import { useCallback, useEffect, useLayoutEffect, useRef, useState } from 'react';
-import { Plus, Pencil, Trash2, Power, PlugZap, Loader2, Check, X, Compass, Square, Antenna as AntennaIcon, ArrowDownToLine, Minus, RefreshCw, GripVertical, ChevronUp, ChevronDown } from 'lucide-react';
+import { Plus, Pencil, Trash2, Power, PlugZap, Loader2, Check, X, Compass, Square, Antenna as AntennaIcon, ArrowDownToLine, Minus, RefreshCw, GripVertical, ChevronUp, ChevronDown, Radio, Zap, Mic } from 'lucide-react';
 import { Button } from '@/components/ui/button';
 import { Input } from '@/components/ui/input';
 import { Label } from '@/components/ui/label';
@@ -25,6 +25,9 @@ import {
   GetAmpStatuses, GetFlexState,
   GetTunerGeniusStatus, GetTunerGeniusSettings,
   GetPSUStatus, GetPSUSettings, SetPSUOutput,
+  GetCATState,
+  GetWinkeyerStatus, WinkeyerSetSpeed, WinkeyerStop, WinkeyerConnect,
+  GetDVKStatus, GetDVKMessages, DVKPlay, DVKStop,
 } from '../../wailsjs/go/main/App';
 
 type RotatorProps = { centerLat?: number | null; centerLon?: number | null; bearing?: number | null };
@@ -82,6 +85,181 @@ function PSUCard({ st, busy, onToggle, t }: {
   );
 }
 
+// ── What commands the station, and not only what it switches ───────────────
+//
+// This tab began as the relay and rotator dashboard, and stopped there: the
+// three things an operator touches most — the radio, the CW keyer and the voice
+// keyer — were the ones missing from the page that claims to show the station.
+//
+// Each card polls its own binding and holds its own state, like PSUCard above.
+// That is deliberate: they can then be dropped into the grid, reordered and
+// hidden with everything else, and adding one costs nothing to the panel around
+// it. None of them tries to be the full console — a card says what the thing is
+// doing and offers the one or two controls worth reaching for from here.
+
+const fmtMHz = (hz: number) => (hz > 0 ? (hz / 1e6).toFixed(6) : '—');
+
+// The radio. The frequency and the mode large, because that is what an operator
+// glances at, and the split pair underneath only when there IS a split — a
+// second frequency shown at all times is one more number to read past.
+function RigCard({ t }: { t: (k: string, v?: any) => string }) {
+  const [st, setSt] = useState<any>(null);
+  useEffect(() => {
+    let alive = true;
+    const tick = () => GetCATState().then((s: any) => { if (alive) setSt(s); }).catch(() => {});
+    tick();
+    const h = window.setInterval(tick, 1000);
+    return () => { alive = false; window.clearInterval(h); };
+  }, []);
+  const on = !!st?.connected;
+  return (
+    <div className="rounded-xl border border-border bg-card shadow-sm overflow-hidden h-full">
+      <div className="flex items-center gap-2 px-3 py-2 border-b border-border/60 bg-muted/30">
+        <Radio className="size-4 text-primary" />
+        <div className="text-sm font-semibold truncate">{st?.rig || t('station.rig')}</div>
+        <span className={cn('ml-auto size-2 rounded-full shrink-0', on ? 'bg-success' : 'bg-muted-foreground/40')}
+          title={on ? t('station.online') : (st?.error || t('station.offline'))} />
+      </div>
+      <div className="p-3 space-y-2">
+        <div className="flex items-baseline gap-2">
+          <span className="text-xl font-semibold tabular-nums leading-none">{fmtMHz(st?.freq_hz ?? 0)}</span>
+          <span className="text-xs text-muted-foreground">MHz</span>
+        </div>
+        <div className="flex items-center gap-2 flex-wrap text-[11px]">
+          {!!st?.mode && <span className="rounded px-1.5 py-px font-semibold bg-primary/15 text-primary border border-primary/30">{st.mode}</span>}
+          {!!st?.band && <span className="text-muted-foreground">{st.band}</span>}
+          {!!st?.vfo && <span className="text-muted-foreground">VFO {st.vfo}</span>}
+          {!!st?.backend && <span className="ml-auto text-muted-foreground/70 truncate">{st.backend}</span>}
+        </div>
+        {st?.split && (
+          <div className="flex items-center gap-2 text-[11px] tabular-nums">
+            <span className="rounded px-1.5 py-px font-semibold bg-warning-muted text-warning-muted-foreground border border-warning-border">SPLIT</span>
+            <span className="text-muted-foreground">RX {fmtMHz(st?.freq_rx_hz ?? 0)}</span>
+          </div>
+        )}
+        {!on && (
+          <div className="text-[11px] text-muted-foreground truncate" title={st?.error || ''}>
+            {st?.enabled ? (st?.error || t('station.rigDown')) : t('station.rigOff')}
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}
+
+// The CW keyer. Speed is the control an operator reaches for mid-QSO — a
+// station answers faster or slower than expected and the reply has to match —
+// so it is here rather than only in the docked panel, and Stop is beside it
+// because a message sent to the wrong callsign has to end NOW.
+function KeyerCard({ t }: { t: (k: string, v?: any) => string }) {
+  const [st, setSt] = useState<any>(null);
+  useEffect(() => {
+    let alive = true;
+    const tick = () => GetWinkeyerStatus().then((s: any) => { if (alive) setSt(s); }).catch(() => {});
+    tick();
+    const h = window.setInterval(tick, 1000);
+    return () => { alive = false; window.clearInterval(h); };
+  }, []);
+  const on = !!st?.connected;
+  const wpm = st?.wpm || 0;
+  const step = (d: number) => {
+    const w = Math.max(5, Math.min(50, wpm + d));
+    setSt((cur: any) => ({ ...(cur ?? {}), wpm: w })); // shows at once; the poll confirms
+    WinkeyerSetSpeed(w).catch(() => {});
+  };
+  return (
+    <div className="rounded-xl border border-border bg-card shadow-sm overflow-hidden h-full">
+      <div className="flex items-center gap-2 px-3 py-2 border-b border-border/60 bg-muted/30">
+        <Zap className="size-4 text-primary" />
+        <div className="text-sm font-semibold truncate">{t('station.keyer')}</div>
+        {st?.busy && <span className="text-[10px] font-bold text-danger animate-pulse">TX</span>}
+        <span className={cn('ml-auto size-2 rounded-full shrink-0', on ? 'bg-success' : 'bg-muted-foreground/40')}
+          title={on ? t('station.online') : (st?.error || t('station.offline'))} />
+      </div>
+      <div className="p-3 space-y-2">
+        <div className="flex items-center gap-2">
+          <Button variant="outline" size="icon" className="size-7" disabled={!on} onClick={() => step(-1)}>
+            <Minus className="size-3.5" />
+          </Button>
+          <div className="flex items-baseline gap-1">
+            <span className="text-xl font-semibold tabular-nums leading-none">{wpm || '—'}</span>
+            <span className="text-xs text-muted-foreground">WPM</span>
+          </div>
+          <Button variant="outline" size="icon" className="size-7" disabled={!on} onClick={() => step(1)}>
+            <Plus className="size-3.5" />
+          </Button>
+          <Button variant="outline" size="sm" className="ml-auto h-7 px-2" disabled={!on || !st?.busy}
+            onClick={() => WinkeyerStop().catch(() => {})}>
+            <Square className="size-3 mr-1" />{t('station.stop')}
+          </Button>
+        </div>
+        <div className="flex items-center gap-2 text-[11px] text-muted-foreground">
+          <span className="truncate">{st?.port || t('station.noPort')}</span>
+          {!!st?.version && <span className="ml-auto shrink-0">v{st.version}</span>}
+        </div>
+        {!on && (
+          <Button variant="outline" size="sm" className="w-full h-7"
+            onClick={() => WinkeyerConnect().catch(() => {})}>
+            {t('station.connect')}
+          </Button>
+        )}
+      </div>
+    </div>
+  );
+}
+
+// The voice keyer. The messages themselves, because a card that only said
+// "idle" would be a light and not a control — from here a CQ goes out without
+// leaving the tab.
+function VoiceKeyerCard({ t }: { t: (k: string, v?: any) => string }) {
+  const [st, setSt] = useState<any>({ playing: false, recording: false });
+  const [msgs, setMsgs] = useState<any[]>([]);
+  useEffect(() => {
+    let alive = true;
+    const tick = () => GetDVKStatus().then((s: any) => { if (alive) setSt(s ?? {}); }).catch(() => {});
+    tick();
+    const h = window.setInterval(tick, 1000);
+    // The recordings change when the operator records one, which is rare and
+    // never from this tab — read once, and again only on a status change worth
+    // it would be more machinery than it saves.
+    GetDVKMessages().then((m: any[]) => { if (alive) setMsgs(m ?? []); }).catch(() => {});
+    return () => { alive = false; window.clearInterval(h); };
+  }, []);
+  const recorded = msgs.filter((m) => m.has_audio);
+  return (
+    <div className="rounded-xl border border-border bg-card shadow-sm overflow-hidden h-full">
+      <div className="flex items-center gap-2 px-3 py-2 border-b border-border/60 bg-muted/30">
+        <Mic className="size-4 text-primary" />
+        <div className="text-sm font-semibold truncate">{t('station.voiceKeyer')}</div>
+        {st?.playing && <span className="text-[10px] font-bold text-danger animate-pulse">TX</span>}
+        {st?.recording && <span className="text-[10px] font-bold text-warning animate-pulse">REC</span>}
+        <Button variant="ghost" size="sm" className="ml-auto h-6 px-2 text-[11px]"
+          disabled={!st?.playing} onClick={() => DVKStop().catch(() => {})}>
+          <Square className="size-3 mr-1" />{t('station.stop')}
+        </Button>
+      </div>
+      <div className="p-3">
+        {recorded.length === 0 ? (
+          <div className="text-[11px] text-muted-foreground">{t('station.noVoiceMsg')}</div>
+        ) : (
+          <div className="flex flex-wrap gap-1.5">
+            {recorded.map((m) => (
+              <button key={m.slot} type="button"
+                onClick={() => DVKPlay(m.slot).catch(() => {})}
+                disabled={st?.playing}
+                title={`${m.duration_sec?.toFixed?.(1) ?? ''}s`}
+                className="rounded-md border border-border bg-muted/30 px-2 py-1 text-[11px] font-medium hover:bg-muted disabled:opacity-40">
+                <span className="text-muted-foreground mr-1">F{m.slot}</span>
+                {m.label || `#${m.slot}`}
+              </button>
+            ))}
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}
+
 type Device = {
   id: string; type: string; name: string; host: string;
   user?: string; pass?: string; channels?: number; labels: string[];
@@ -317,6 +495,25 @@ export function StationControlPanel({ centerLat, centerLon, bearing }: RotatorPr
   }, [poll, pollAnt, devices.length]);
 
   const persistOrder = (next: string[]) => { setOrder(next); writeUiPref('opslog.stationOrder', JSON.stringify(next)); };
+
+  // Whether the two keyers exist at this station. Asked ONCE, on opening the
+  // tab: a keyer is bought, wired and configured, not something that appears
+  // mid-session, and polling for the answer would be a round trip a second for
+  // a fact that does not change. A keyer counts as present when it is connected
+  // or a port is configured for it, the voice keyer when at least one message
+  // has actually been recorded — an empty set of slots is not a keyer.
+  const [keyerShown, setKeyerShown] = useState(false);
+  const [dvkShown, setDvkShown] = useState(false);
+  useEffect(() => {
+    let alive = true;
+    GetWinkeyerStatus().then((s: any) => {
+      if (alive) setKeyerShown(!!s && (!!s.connected || !!String(s.port ?? '').trim()));
+    }).catch(() => {});
+    GetDVKMessages().then((m: any[]) => {
+      if (alive) setDvkShown((m ?? []).some((x) => x?.has_audio));
+    }).catch(() => {});
+    return () => { alive = false; };
+  }, []);
   // Reorder so `dragged` lands just before `target`.
   const onDrop = (targetId: string) => {
     const src = dragId.current; dragId.current = null;
@@ -419,6 +616,13 @@ export function StationControlPanel({ centerLat, centerLon, bearing }: RotatorPr
   // single ~430px column — they are the same cards the FlexRadio panel shows
   // full-width, and they need that room here too.
   const widgets: { id: string; node: React.ReactNode; wide?: boolean }[] = [];
+  // The radio first: it is the station, and everything else on this page is
+  // something attached to it. Then the two keyers, each only when there is
+  // something behind it — an operator who works neither CW nor voice keyer
+  // should not be given two dead cards to read past.
+  widgets.push({ id: 'rig', node: <RigCard t={t} /> });
+  if (keyerShown) widgets.push({ id: 'keyer', node: <KeyerCard t={t} /> });
+  if (dvkShown) widgets.push({ id: 'dvk', node: <VoiceKeyerCard t={t} />, wide: true });
   if (rot.enabled) {
     widgets.push({ id: 'rotator', node: <RotatorWidget hd={rot} refetch={pokeRotorHeading} centerLat={centerLat} centerLon={centerLon} bearing={bearing} t={t} /> });
   }

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>
-            {t('udpp.hlWorked')}
-            <span className="block text-[11px] text-muted-foreground">{t('udpp.hlWorkedHint')}</span>
-          </span>
+          <span>{t('udpp.hlWorked')}</span>
         </label>
       )}
       <label className="flex items-start gap-2 text-sm cursor-pointer max-w-2xl">

frontend/src/components/ui/buffered-input.tsx

@@ -0,0 +1,102 @@
+import * as React from 'react';
+import { Input } from '@/components/ui/input';
+
+// A text field that types into itself first.
+//
+// Preferences is one component holding two hundred pieces of state, and its
+// biggest panels are eight hundred lines of form. A plain controlled input
+// sends every keystroke into that state, so every character re-renders the
+// whole dialog — the external-services panel, the CAT panel — and the letter
+// appears after the finger has left the key.
+//
+// This keeps the text where it is being typed and hands it up shortly after.
+// The value shown is the operator's, immediately; the parent's copy catches up
+// a moment later, which is soon enough for anything that reads it — nothing in
+// a settings form acts on a half-typed word.
+//
+// It is a drop-in for Input, on purpose: the fix is a changed import, not a
+// hundred edited call sites. Which means it has to behave correctly in every
+// shape those call sites take:
+//
+//   • Blur flushes at once, so clicking Save cannot lose the last word typed,
+//     and so does unmounting — a panel changed mid-word still hands up what
+//     was there.
+//   • A value that comes back DIFFERENT from what was sent up is adopted, even
+//     while the field has focus. That is how the fields which normalise as you
+//     type keep working: a callsign box that upper-cases, a port box that
+//     drops everything but digits. They echo a corrected value, and the
+//     correction wins.
+//   • A value changed from outside while the field is idle wins too — that is
+//     how loading the settings, or switching profile, refills the form.
+//   • Types that are not text — checkbox, colour, file — pass straight
+//     through. There is no typing to buffer and their events are not text.
+const PASSTHROUGH = new Set(['checkbox', 'radio', 'file', 'color', 'range', 'submit', 'button', 'image', 'reset']);
+
+// Short enough that a normalising field corrects itself while the operator is
+// still on the same word, long enough that a burst of typing is one render.
+const DEBOUNCE_MS = 120;
+
+export const BufferedInput = React.forwardRef<HTMLInputElement, React.InputHTMLAttributes<HTMLInputElement>>(
+  ({ value, onChange, onBlur, onFocus, type, ...props }, ref) => {
+    const buffered = value !== undefined && !!onChange && !PASSTHROUGH.has(type ?? 'text');
+    const incoming = String(value ?? '');
+    const [local, setLocal] = React.useState(incoming);
+    const focused = React.useRef(false);
+    const timer = React.useRef<number | undefined>(undefined);
+    // What we last handed up. Anything else arriving from the parent is the
+    // parent's own doing — a normalisation, a reload — and it wins.
+    const emitted = React.useRef(incoming);
+    const pending = React.useRef<React.ChangeEvent<HTMLInputElement> | null>(null);
+    const onChangeRef = React.useRef(onChange);
+    React.useEffect(() => { onChangeRef.current = onChange; }, [onChange]);
+
+    React.useEffect(() => {
+      if (!focused.current || incoming !== emitted.current) {
+        setLocal(incoming);
+        emitted.current = incoming;
+      }
+    }, [incoming]);
+
+    const flush = React.useCallback(() => {
+      window.clearTimeout(timer.current);
+      timer.current = undefined;
+      const e = pending.current;
+      pending.current = null;
+      if (e) {
+        emitted.current = e.target.value;
+        onChangeRef.current?.(e);
+      }
+    }, []);
+
+    // Unmounted mid-word — the panel changed, the dialog closed — still hands
+    // up what was typed.
+    React.useEffect(() => () => {
+      window.clearTimeout(timer.current);
+      if (pending.current) onChangeRef.current?.(pending.current);
+    }, []);
+
+    if (!buffered) {
+      return <Input ref={ref} type={type} value={value} onChange={onChange} onBlur={onBlur} onFocus={onFocus} {...props} />;
+    }
+    return (
+      <Input
+        ref={ref}
+        type={type}
+        value={local}
+        onFocus={(e) => { focused.current = true; onFocus?.(e); }}
+        onChange={(e) => {
+          const v = e.target.value;
+          setLocal(v);
+          // The element's value changes again before the timer fires, so what
+          // matters is copied out of it now.
+          pending.current = { ...e, target: { ...e.target, value: v } } as React.ChangeEvent<HTMLInputElement>;
+          window.clearTimeout(timer.current);
+          timer.current = window.setTimeout(flush, DEBOUNCE_MS);
+        }}
+        onBlur={(e) => { focused.current = false; flush(); onBlur?.(e); }}
+        {...props}
+      />
+    );
+  },
+);
+BufferedInput.displayName = 'BufferedInput';

frontend/src/components/ui/dialog.tsx

@@ -8,14 +8,23 @@ const DialogTrigger = DialogPrimitive.Trigger;
 const DialogPortal = DialogPrimitive.Portal;
 const DialogClose = DialogPrimitive.Close;
 
+// blur=false drops the backdrop filter and dims harder instead.
+//
+// A backdrop-filter over the whole window is recomputed every time anything
+// above it repaints — and underneath this one sits an application that never
+// stops moving: CAT polls four times a second, spots arrive, meters sweep, maps
+// redraw. On a long-lived dialog with text fields in it, that shows as a delay
+// between the key and the letter. Ornament is not worth a keyboard that feels
+// slow, so the dialogs an operator TYPES in for minutes at a time turn it off.
 const DialogOverlay = React.forwardRef<
   React.ElementRef<typeof DialogPrimitive.Overlay>,
-  React.ComponentPropsWithoutRef<typeof DialogPrimitive.Overlay>
->(({ className, ...props }, ref) => (
+  React.ComponentPropsWithoutRef<typeof DialogPrimitive.Overlay> & { blur?: boolean }
+>(({ className, blur = true, ...props }, ref) => (
   <DialogPrimitive.Overlay
     ref={ref}
     className={cn(
-      'fixed inset-0 z-50 bg-stone-900/40 backdrop-blur-sm data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0',
+      'fixed inset-0 z-50 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0',
+      blur ? 'bg-stone-900/40 backdrop-blur-sm' : 'bg-stone-900/60',
       className,
     )}
     {...props}
@@ -25,10 +34,10 @@ DialogOverlay.displayName = DialogPrimitive.Overlay.displayName;
 
 const DialogContent = React.forwardRef<
   React.ElementRef<typeof DialogPrimitive.Content>,
-  React.ComponentPropsWithoutRef<typeof DialogPrimitive.Content> & { hideClose?: boolean; hideOverlay?: boolean }
->(({ className, children, hideClose, hideOverlay, ...props }, ref) => (
+  React.ComponentPropsWithoutRef<typeof DialogPrimitive.Content> & { hideClose?: boolean; hideOverlay?: boolean; overlayBlur?: boolean }
+>(({ className, children, hideClose, hideOverlay, overlayBlur, ...props }, ref) => (
   <DialogPortal>
-    {!hideOverlay && <DialogOverlay />}
+    {!hideOverlay && <DialogOverlay blur={overlayBlur} />}
     <DialogPrimitive.Content
       ref={ref}
       className={cn(

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/operatingLists.ts

@@ -0,0 +1,66 @@
+// The station's own rigs and antennas, for the MY_RIG and MY_ANTENNA fields.
+//
+// They are already defined once, in Settings ▸ Operating conditions — a station
+// per rig, with the antennas hanging off it. Typing them again into every
+// contact is both work and a source of spellings that do not match: "IC-7610",
+// "IC 7610" and "ic7610" are three different rigs to an award, a filter and to
+// anyone reading the log later.
+//
+// So the two fields offer what the operator has already declared. FREE TEXT
+// stays allowed: a QSO made from somebody else's station, or imported from
+// another logger, carries a rig that was never in this tree and must still be
+// loggable — the same rule the satellite-name field follows.
+import { useEffect, useState } from 'react';
+import { ListOperatingTree } from '../../wailsjs/go/main/App';
+
+export type OperatingLists = {
+  rigs: string[];
+  // Every antenna in the profile, whichever rig it belongs to.
+  antennas: string[];
+  // The antennas of ONE rig. Falls back to all of them for a rig that is not in
+  // the tree — an operator typing a borrowed rig's name should still be offered
+  // their own antennas rather than nothing.
+  antennasFor: (rig: string) => string[];
+};
+
+const EMPTY: OperatingLists = { rigs: [], antennas: [], antennasFor: () => [] };
+
+function build(stations: any[]): OperatingLists {
+  const rigs: string[] = [];
+  const byRig = new Map<string, string[]>();
+  const all = new Set<string>();
+  for (const st of stations ?? []) {
+    const name = String(st?.name ?? '').trim();
+    const ants = ((st?.antennas ?? []) as any[])
+      .map((a) => String(a?.name ?? '').trim())
+      .filter(Boolean);
+    if (name) {
+      rigs.push(name);
+      byRig.set(name.toUpperCase(), ants);
+    }
+    for (const a of ants) all.add(a);
+  }
+  const antennas = [...all];
+  return {
+    rigs,
+    antennas,
+    antennasFor: (rig: string) => byRig.get(String(rig ?? '').trim().toUpperCase()) ?? antennas,
+  };
+}
+
+// useOperatingLists reads the tree when the component mounts, and again whenever
+// `reloadKey` changes — pass something that moves when Preferences close, so a
+// rig added there is offered without a restart.
+export function useOperatingLists(reloadKey?: unknown): OperatingLists {
+  const [lists, setLists] = useState<OperatingLists>(EMPTY);
+  useEffect(() => {
+    let live = true;
+    ListOperatingTree()
+      .then((st: any) => { if (live) setLists(build(st ?? [])); })
+      // An empty list simply leaves both fields as free text, which is what they
+      // were before they had a list at all.
+      .catch(() => {});
+    return () => { live = false; };
+  }, [reloadKey]);
+  return lists;
+}

frontend/src/lib/uiPref.ts

@@ -31,11 +31,13 @@ const PORTABLE_KEYS = [
   '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.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.matrixDigiMode',    // band matrix: which digital row it opens on ('' = DIGI, the group)
   '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
@@ -58,6 +60,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
@@ -90,6 +94,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/style.css

@@ -1245,3 +1245,40 @@
 .leaflet-container {
   background: var(--card) !important;
 }
+
+/* Satellite map tooltips. Leaflet's own are a white box with a grey border —
+   fine on a street map, a bright rectangle on a dark one, and always the wrong
+   colours for whichever theme the operator chose. These follow the theme, and
+   are wide enough for a pass: AOS, LOS, elevation and range each on their own
+   line. */
+.leaflet-tooltip.sat-tip {
+  background: var(--popover);
+  color: var(--popover-foreground);
+  border: 1px solid var(--border);
+  border-radius: 0.5rem;
+  box-shadow: 0 4px 16px rgb(0 0 0 / 0.35);
+  padding: 0.4rem 0.55rem;
+  font-size: 11px;
+  line-height: 1.45;
+  white-space: nowrap;
+}
+.leaflet-tooltip.sat-tip::before { border-top-color: var(--border); }
+.sat-tip-name { font-weight: 600; font-size: 12px; margin-bottom: 0.2rem; }
+.sat-tip-row { display: flex; justify-content: space-between; gap: 1.25rem; }
+.sat-tip-row > span:first-child { color: var(--muted-foreground); }
+.sat-tip-note { color: var(--muted-foreground); font-style: italic; }
+
+/* The name beside a satellite that is up right now. A plain div marker and
+   not a Leaflet tooltip, because Leaflet keeps one tooltip per layer and the
+   hover detail is the one worth keeping. */
+.sat-name-label {
+  pointer-events: none;
+  white-space: nowrap;
+  font-size: 10px;
+  font-weight: 600;
+  /* Painted twice — a dark halo under a light glyph — because the label sits on
+     satellite imagery, on a street map and on a dark ocean in the same session,
+     and no single colour is readable on all three. */
+  color: #fff;
+  text-shadow: 0 0 3px #000, 0 0 3px #000, 0 1px 2px #000;
+}

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.14';
+export const APP_VERSION = '0.27.20';
 
 // 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>;
@@ -580,6 +583,8 @@ export function GetRelayAuto():Promise<main.RelayAutoConfig>;
 
 export function GetRotatorHeading():Promise<main.RotatorHeading>;
 
+export function GetRotatorTypes():Promise<Array<main.RotatorTypeInfo>>;
+
 export function GetRotators():Promise<Array<main.RotatorDevice>>;
 
 export function GetRotorPresets():Promise<Array<main.RotorPreset>>;
@@ -588,6 +593,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>;
@@ -648,6 +677,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>>;
@@ -802,6 +833,8 @@ export function ListQSOFiltered(arg1:qso.QueryFilter):Promise<Array<qso.QSO>>;
 
 export function ListRadios():Promise<Array<main.RadioListEntry>>;
 
+export function ListSatelliteRotors():Promise<Array<main.SatelliteRotorChoice>>;
+
 export function ListSerialPorts():Promise<Array<string>>;
 
 export function ListTQSLStationLocations():Promise<Array<extsvc.StationLocation>>;
@@ -972,6 +1005,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>;
@@ -1114,6 +1149,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>;
@@ -1308,6 +1345,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>;
@@ -1352,10 +1391,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>;
@@ -1396,6 +1439,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);
 }
@@ -1094,6 +1098,10 @@ export function GetRotatorHeading() {
   return window['go']['main']['App']['GetRotatorHeading']();
 }
 
+export function GetRotatorTypes() {
+  return window['go']['main']['App']['GetRotatorTypes']();
+}
+
 export function GetRotators() {
   return window['go']['main']['App']['GetRotators']();
 }
@@ -1110,6 +1118,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']();
 }
@@ -1230,6 +1286,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']();
 }
@@ -1538,6 +1598,10 @@ export function ListRadios() {
   return window['go']['main']['App']['ListRadios']();
 }
 
+export function ListSatelliteRotors() {
+  return window['go']['main']['App']['ListSatelliteRotors']();
+}
+
 export function ListSerialPorts() {
   return window['go']['main']['App']['ListSerialPorts']();
 }
@@ -1878,6 +1942,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']();
 }
@@ -2162,6 +2230,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);
 }
@@ -2550,6 +2622,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);
 }
@@ -2638,6 +2714,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);
 }
@@ -2646,6 +2726,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);
 }
@@ -2726,6 +2810,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

@@ -2360,6 +2360,7 @@ export namespace main {
 	    backend: string;
 	    omnirig_rig: number;
 	    omnirig_vfo: string;
+	    omnirig_cw_lower: boolean;
 	    digi_as_usb: boolean;
 	    flex_host: string;
 	    flex_port: number;
@@ -2379,6 +2380,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;
@@ -2413,6 +2415,7 @@ export namespace main {
 	        this.backend = source["backend"];
 	        this.omnirig_rig = source["omnirig_rig"];
 	        this.omnirig_vfo = source["omnirig_vfo"];
+	        this.omnirig_cw_lower = source["omnirig_cw_lower"];
 	        this.digi_as_usb = source["digi_as_usb"];
 	        this.flex_host = source["flex_host"];
 	        this.flex_port = source["flex_port"];
@@ -2432,6 +2435,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"];
@@ -3877,6 +3881,7 @@ export namespace main {
 	    com_port: string;
 	    baud: number;
 	    spid_model?: string;
+	    max_az?: number;
 	
 	    static createFrom(source: any = {}) {
 	        return new RotatorDevice(source);
@@ -3899,6 +3904,7 @@ export namespace main {
 	        this.com_port = source["com_port"];
 	        this.baud = source["baud"];
 	        this.spid_model = source["spid_model"];
+	        this.max_az = source["max_az"];
 	    }
 	}
 	export class RotatorHeading {
@@ -3906,6 +3912,8 @@ export namespace main {
 	    ok: boolean;
 	    azimuth: number;
 	    raw: string;
+	    elevation: number;
+	    has_elevation: boolean;
 	    rotors: string[];
 	    active: number;
 	    motorized: boolean;
@@ -3920,11 +3928,39 @@ export namespace main {
 	        this.ok = source["ok"];
 	        this.azimuth = source["azimuth"];
 	        this.raw = source["raw"];
+	        this.elevation = source["elevation"];
+	        this.has_elevation = source["has_elevation"];
 	        this.rotors = source["rotors"];
 	        this.active = source["active"];
 	        this.motorized = source["motorized"];
 	    }
 	}
+	export class RotatorTypeInfo {
+	    id: string;
+	    label: string;
+	    elevation: boolean;
+	    elevation_optional: boolean;
+	    serial: boolean;
+	    network: boolean;
+	    default_port: number;
+	    default_baud: number;
+	
+	    static createFrom(source: any = {}) {
+	        return new RotatorTypeInfo(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.id = source["id"];
+	        this.label = source["label"];
+	        this.elevation = source["elevation"];
+	        this.elevation_optional = source["elevation_optional"];
+	        this.serial = source["serial"];
+	        this.network = source["network"];
+	        this.default_port = source["default_port"];
+	        this.default_baud = source["default_baud"];
+	    }
+	}
 	export class RotorPreset {
 	    label: string;
 	    azimuth: number;
@@ -4001,6 +4037,371 @@ 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_id: string;
+	    rot_az_only: boolean;
+	    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_id = source["rot_id"];
+	        this.rot_az_only = source["rot_az_only"];
+	        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;
+	    rot_az_only: 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"];
+	        this.rot_az_only = source["rot_az_only"];
+	    }
+	}
+	
+	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 SatelliteRotorChoice {
+	    key: string;
+	    name: string;
+	    type: string;
+	    has_el: boolean;
+	
+	    static createFrom(source: any = {}) {
+	        return new SatelliteRotorChoice(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.key = source["key"];
+	        this.name = source["name"];
+	        this.type = source["type"];
+	        this.has_el = source["has_el"];
+	    }
+	}
 	export class ScpStatus {
 	    enabled: boolean;
 	    count: number;
@@ -4592,6 +4993,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"];
+	    }
+	}
 
 }
 
@@ -6053,6 +6472,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,11 +3,13 @@ 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
 	github.com/go-sql-driver/mysql v1.10.0
 	github.com/gorilla/websocket v1.5.3
+	github.com/jfreymuth/pulse v0.1.3
 	github.com/jlaffaye/ftp v0.2.2
 	github.com/moutend/go-wca v0.3.0
 	github.com/wailsapp/wails/v2 v2.11.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=
@@ -27,6 +29,8 @@ github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs
 github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM=
 github.com/jchv/go-winloader v0.0.0-20210711035445-715c2860da7e h1:Q3+PugElBCf4PFpxhErSzU3/PY5sFL5Z6rfv4AbGAck=
 github.com/jchv/go-winloader v0.0.0-20210711035445-715c2860da7e/go.mod h1:alcuEEnZsY1WQsagKhZDsoPCRoOijYqhZvPwLG0kzVs=
+github.com/jfreymuth/pulse v0.1.3 h1:bc5TdxiB8E+2INnFjFWWgyfgXtz2IyNNNCX+Wt/ZD14=
+github.com/jfreymuth/pulse v0.1.3/go.mod h1:cpYspI6YljhkUf1WLXLLDmeaaPFc3CnGLjDZf9dZ4no=
 github.com/jlaffaye/ftp v0.2.2 h1:JwjrXCAIjN9ZYrF1/8qlmHFXDteh9MHYaiEIh/Oqtd8=
 github.com/jlaffaye/ftp v0.2.2/go.mod h1:zuLAKdqFqFvNgkCrH0SC7K1XyUiydS7BFCmmoHUWWg0=
 github.com/labstack/echo/v4 v4.13.3 h1:pwhpCPrTl5qry5HRdM5FwdXnhXSLSY+WE+YQSeCaafY=

internal/adif/export.go

@@ -407,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/device.go

@@ -0,0 +1,39 @@
+package audio
+
+// Device is one audio endpoint (a capture input or a render output).
+//
+// ID is whatever the platform calls the endpoint and is PERSISTED in settings:
+// a WASAPI endpoint id on Windows, a PulseAudio source/sink name on Linux.
+// It is opaque to everything above this package, which only ever hands it back.
+type Device struct {
+	ID      string `json:"id"`      // opaque platform endpoint id (persisted)
+	Name    string `json:"name"`    // friendly name shown in dropdowns
+	Default bool   `json:"default"` // is this the system default endpoint
+}
+
+// DeviceName resolves an endpoint id to its friendly name.
+//
+// Diagnostics quote the id that was CONFIGURED, which is a GUID — an operator
+// told "no audio at all from {0.0.1.00000000}.{6a27abfd…}" learns nothing they
+// can act on, while "no audio at all from DAX RX 1 (FlexRadio DAX)" points
+// straight at the DAX panel.
+//
+// Falls back to the id when the endpoint cannot be found, which is itself worth
+// seeing: a device that has disappeared explains an empty recording too.
+func DeviceName(id string) string {
+	if id == "" {
+		return "(none)"
+	}
+	for _, list := range []func() ([]Device, error){ListInputDevices, ListOutputDevices} {
+		devs, err := list()
+		if err != nil {
+			continue
+		}
+		for _, d := range devs {
+			if d.ID == id {
+				return d.Name
+			}
+		}
+	}
+	return id
+}

internal/audio/devices.go

@@ -15,13 +15,6 @@ import (
 	"github.com/moutend/go-wca/pkg/wca"
 )
 
-// Device is one audio endpoint (a capture input or a render output).
-type Device struct {
-	ID      string `json:"id"`      // stable WASAPI endpoint id (persisted)
-	Name    string `json:"name"`    // friendly name shown in dropdowns
-	Default bool   `json:"default"` // is this the system default endpoint
-}
-
 // ListInputDevices returns the active capture endpoints — microphones,
 // line-in, and the soundcard input wired to the rig's audio out ("From Radio").
 func ListInputDevices() ([]Device, error) { return listEndpoints(wca.ECapture) }
@@ -101,30 +94,3 @@ func endpointName(dev *wca.IMMDevice, fallback string) string {
 	}
 	return fallback
 }
-
-// DeviceName resolves an endpoint id to its friendly name.
-//
-// Diagnostics quote the id that was CONFIGURED, which is a GUID — an operator
-// told "no audio at all from {0.0.1.00000000}.{6a27abfd…}" learns nothing they
-// can act on, while "no audio at all from DAX RX 1 (FlexRadio DAX)" points
-// straight at the DAX panel.
-//
-// Falls back to the id when the endpoint cannot be found, which is itself worth
-// seeing: a device that has disappeared explains an empty recording too.
-func DeviceName(id string) string {
-	if id == "" {
-		return "(none)"
-	}
-	for _, list := range []func() ([]Device, error){ListInputDevices, ListOutputDevices} {
-		devs, err := list()
-		if err != nil {
-			continue
-		}
-		for _, d := range devs {
-			if d.ID == id {
-				return d.Name
-			}
-		}
-	}
-	return id
-}

internal/audio/devices_linux.go

@@ -0,0 +1,99 @@
+//go:build linux
+
+package audio
+
+// devices_linux.go — audio endpoints on Linux, through PulseAudio.
+//
+// PulseAudio and not ALSA, for two reasons that both matter here. ALSA's C
+// library needs cgo, and OpsLog is a pure-Go build; and PulseAudio is the API
+// that is actually present on a ham's desktop — PipeWire, which most current
+// distributions ship, answers the PulseAudio protocol through pipewire-pulse,
+// so one client speaks to both. github.com/jfreymuth/pulse implements that
+// protocol in Go over the server's Unix socket, so nothing is linked in.
+//
+// The endpoint id we persist is the sink/source NAME
+// ("alsa_input.usb-Icom_Inc._IC-7610-00.analog-stereo"), never the numeric
+// index: the index is assigned at boot in device-arrival order and moves the
+// moment a rig is plugged in before a headset.
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/jfreymuth/pulse"
+)
+
+// pulseClient opens a short-lived connection to the local sound server. Each
+// call gets its own: the connection is a Unix socket to a server that may be
+// restarted underneath us (a PipeWire update, a user logging the session out
+// and in), and holding one open for the lifetime of the app means every later
+// call fails until OpsLog itself restarts.
+func pulseClient() (*pulse.Client, error) {
+	c, err := pulse.NewClient(pulse.ClientApplicationName("OpsLog"))
+	if err != nil {
+		return nil, fmt.Errorf("cannot reach the sound server (is PulseAudio or PipeWire running?): %w", err)
+	}
+	return c, nil
+}
+
+// ListInputDevices returns the capture sources.
+//
+// Monitor sources (".monitor", what a given output is playing) are kept rather
+// than filtered out. They look like clutter until you meet the operator whose
+// rig audio reaches OpsLog through a virtual cable — on Linux that is a
+// null-sink and its monitor, and hiding it would hide the only device that
+// works for them.
+func ListInputDevices() ([]Device, error) {
+	c, err := pulseClient()
+	if err != nil {
+		return nil, err
+	}
+	defer c.Close()
+
+	srcs, err := c.ListSources()
+	if err != nil {
+		return nil, err
+	}
+	defID := ""
+	if d, err := c.DefaultSource(); err == nil && d != nil {
+		defID = d.ID()
+	}
+	out := make([]Device, 0, len(srcs))
+	for _, s := range srcs {
+		out = append(out, Device{ID: s.ID(), Name: endpointLabel(s.Name(), s.ID()), Default: s.ID() == defID})
+	}
+	return out, nil
+}
+
+// ListOutputDevices returns the render sinks.
+func ListOutputDevices() ([]Device, error) {
+	c, err := pulseClient()
+	if err != nil {
+		return nil, err
+	}
+	defer c.Close()
+
+	sinks, err := c.ListSinks()
+	if err != nil {
+		return nil, err
+	}
+	defID := ""
+	if d, err := c.DefaultSink(); err == nil && d != nil {
+		defID = d.ID()
+	}
+	out := make([]Device, 0, len(sinks))
+	for _, s := range sinks {
+		out = append(out, Device{ID: s.ID(), Name: endpointLabel(s.Name(), s.ID()), Default: s.ID() == defID})
+	}
+	return out, nil
+}
+
+// endpointLabel prefers the server's human description ("USB Audio CODEC
+// Analog Stereo") and falls back to the raw name, which is ugly but still
+// identifies the device — an empty entry in the dropdown identifies nothing.
+func endpointLabel(desc, id string) string {
+	if d := strings.TrimSpace(desc); d != "" {
+		return d
+	}
+	return id
+}

internal/audio/engine.go

@@ -5,7 +5,6 @@ package audio
 import (
 	"fmt"
 	"runtime"
-	"sync"
 	"time"
 	"unsafe"
 
@@ -281,63 +280,6 @@ func playPCM(deviceID string, pcm []byte, rate, ch, bits int, stop <-chan struct
 	}
 }
 
-// pcmRing is a thread-safe, latency-bounded FIFO of PCM bytes feeding a live
-// render stream. Producers (a USB-codec capture, or a decoded network audio
-// stream) Push freshly-arrived samples; the render loop Pulls. It is the shared
-// hand-off point between "where the audio comes from" (USB device / UDP 50003)
-// and "where it's heard" (any WASAPI output) — so the transport can be swapped
-// without touching the render side, mirroring the civTransport split on the CAT
-// side. On overflow the oldest audio is dropped to keep latency bounded; on
-// underrun Pull simply returns short and the render loop pads with silence.
-type pcmRing struct {
-	mu  sync.Mutex
-	buf []byte
-	max int // hard cap in bytes (drops oldest beyond this → bounded latency)
-}
-
-// newPCMRing makes a ring whose backlog is capped at maxBytes. Size it from the
-// acceptable latency: bytesPerSec (=32000) worth ≈ 1 s.
-func newPCMRing(maxBytes int) *pcmRing {
-	if maxBytes <= 0 {
-		maxBytes = bytesPerSec // 1 s default
-	}
-	return &pcmRing{max: maxBytes}
-}
-
-// Push appends samples, dropping the oldest audio if the backlog would exceed
-// the cap (a slow/absent consumer never makes the producer block or grow without
-// bound). A short glitch beats runaway latency for live monitoring.
-func (r *pcmRing) Push(p []byte) {
-	if len(p) == 0 {
-		return
-	}
-	r.mu.Lock()
-	r.buf = append(r.buf, p...)
-	if len(r.buf) > r.max {
-		drop := len(r.buf) - r.max
-		r.buf = append(r.buf[:0], r.buf[drop:]...)
-	}
-	r.mu.Unlock()
-}
-
-// pull removes and returns up to maxBytes of queued PCM (a private copy), or nil
-// when empty. The render loop pads any shortfall with silence.
-func (r *pcmRing) pull(maxBytes int) []byte {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-	if len(r.buf) == 0 || maxBytes <= 0 {
-		return nil
-	}
-	n := maxBytes
-	if n > len(r.buf) {
-		n = len(r.buf)
-	}
-	out := make([]byte, n)
-	copy(out, r.buf[:n])
-	r.buf = append(r.buf[:0], r.buf[n:]...)
-	return out
-}
-
 // renderStream continuously renders PCM pulled from src to a device until stop
 // closes — the streaming counterpart to playPCM's fixed buffer. On underrun it
 // writes silence rather than glitching, keeping the WASAPI clock steady so live

internal/audio/engine_linux.go

@@ -0,0 +1,275 @@
+//go:build linux
+
+package audio
+
+// engine_linux.go — the four calls the rest of the package makes into the sound
+// card, implemented on PulseAudio. The Windows half of this pair is engine.go
+// (WASAPI); nothing above these functions knows which one it is talking to.
+//
+// Capture is fixed at 16 kHz mono 16-bit, the format the DVK, the recorder and
+// the CW tap all share (see wav.go). We ask the server for it and let the
+// server resample from whatever the device really runs at — the same division
+// of labour as WASAPI's AUTOCONVERTPCM, and for the same reason: a rig codec
+// that only does 48 kHz must still feed a 16 kHz pipeline, and the sound
+// server's converter filters before it decimates, where a naive one folds the
+// receiver hiss above 8 kHz straight back on top of the voice.
+
+import (
+	"fmt"
+	"io"
+	"time"
+
+	"github.com/jfreymuth/pulse"
+	"github.com/jfreymuth/pulse/proto"
+)
+
+// chunkFrames is how much audio a playback reader hands over at once (20 ms).
+// It bounds how much silence a padded underrun can queue ahead of real audio,
+// which is what keeps live monitoring from drifting seconds behind the rig.
+const chunkFrames = sampleRate / 50
+
+// channelMap describes n channels to the server. Only mono and stereo occur
+// here — capture is always mono, and playback follows the WAV being played.
+func channelMap(n int) proto.ChannelMap {
+	if n >= 2 {
+		return proto.ChannelMap{proto.ChannelLeft, proto.ChannelRight}
+	}
+	return proto.ChannelMap{proto.ChannelMono}
+}
+
+// chunkWriter turns the record stream's byte deliveries into onChunk calls.
+// The server reuses its buffer between deliveries, so every chunk is copied
+// before it leaves: the recorder keeps the slices it is given.
+type chunkWriter struct{ onChunk func([]byte) }
+
+func (w chunkWriter) Write(p []byte) (int, error) {
+	if len(p) > 0 && w.onChunk != nil {
+		cp := make([]byte, len(p))
+		copy(cp, p)
+		w.onChunk(cp)
+	}
+	return len(p), nil
+}
+
+// recordPCM captures from a device into 16 kHz mono 16-bit PCM bytes until the
+// stop channel is closed.
+func recordPCM(deviceID string, stop <-chan struct{}) ([]byte, error) {
+	out := make([]byte, 0, bytesPerSec*4)
+	err := captureStream(deviceID, stop, func(chunk []byte) { out = append(out, chunk...) })
+	return out, err
+}
+
+// captureStream opens a device and calls onChunk with freshly-captured 16 kHz
+// mono 16-bit PCM as it arrives, until stop closes. onChunk receives a private
+// copy it may retain.
+func captureStream(deviceID string, stop <-chan struct{}, onChunk func([]byte)) error {
+	c, err := pulseClient()
+	if err != nil {
+		return err
+	}
+	defer c.Close()
+
+	// Rate and channels first, then latency — the latency option sizes its
+	// buffer from both, so setting it earlier would size it from the defaults.
+	//
+	// 50 ms of fragment: the CW decoder is downstream of this and works on the
+	// chunks as they arrive, so a server-chosen fragment of a quarter of a
+	// second would make it decide about a dit long after the dit was over.
+	opts := []pulse.RecordOption{
+		pulse.RecordSampleRate(sampleRate),
+		pulse.RecordChannels(channelMap(channels)),
+		pulse.RecordLatency(0.05),
+		pulse.RecordMediaName("OpsLog capture"),
+	}
+	// An empty id means "whatever the desktop calls the default", which is also
+	// what an operator who has never opened the audio settings expects.
+	if deviceID != "" {
+		src, err := c.SourceByID(deviceID)
+		if err != nil {
+			return fmt.Errorf("no audio input %q: %w", deviceID, err)
+		}
+		opts = append(opts, pulse.RecordSource(src))
+	}
+	st, err := c.NewRecord(pulse.NewWriter(chunkWriter{onChunk}, proto.FormatInt16LE), opts...)
+	if err != nil {
+		return fmt.Errorf("open capture: %w", err)
+	}
+	defer st.Close()
+
+	st.Start()
+	<-stop
+	st.Stop()
+	return st.Error()
+}
+
+// playPCM plays a fixed buffer to a device and returns when it has been heard
+// (or when stop closes, which cuts it short).
+func playPCM(deviceID string, pcm []byte, rate, ch, bits int, stop <-chan struct{}) error {
+	if len(pcm) == 0 {
+		return nil
+	}
+	format, err := pulseFormat(bits)
+	if err != nil {
+		return err
+	}
+	frameBytes := ch * bits / 8
+	if frameBytes <= 0 || rate <= 0 {
+		return fmt.Errorf("bad audio format")
+	}
+
+	c, err := pulseClient()
+	if err != nil {
+		return err
+	}
+	defer c.Close()
+
+	// The reader hands out the buffer a slice at a time and ends the stream
+	// with EndOfData — the library's own sentinel. io.EOF would work as an end
+	// too, but it is recorded as the stream's error, and a message finishing
+	// normally must not look like a fault in the log.
+	pos := 0
+	read := func(buf []byte) (int, error) {
+		select {
+		case <-stop:
+			return 0, pulse.EndOfData
+		default:
+		}
+		if pos >= len(pcm) {
+			return 0, pulse.EndOfData
+		}
+		n := copy(buf, pcm[pos:])
+		n -= n % frameBytes // never hand the server a partial frame
+		if n == 0 {
+			return 0, pulse.EndOfData
+		}
+		pos += n
+		return n, nil
+	}
+
+	opts := []pulse.PlaybackOption{
+		pulse.PlaybackSampleRate(rate),
+		pulse.PlaybackChannels(channelMap(ch)),
+		pulse.PlaybackLatency(0.1),
+		pulse.PlaybackMediaName("OpsLog playback"),
+	}
+	if deviceID != "" {
+		sink, err := c.SinkByID(deviceID)
+		if err != nil {
+			return fmt.Errorf("no audio output %q: %w", deviceID, err)
+		}
+		opts = append(opts, pulse.PlaybackSink(sink))
+	}
+	st, err := c.NewPlayback(pulse.NewReader(readerFunc(read), format), opts...)
+	if err != nil {
+		return fmt.Errorf("open playback: %w", err)
+	}
+	defer st.Close()
+
+	st.Start()
+
+	// Drain blocks until the server has played everything queued. Waiting on it
+	// in a goroutine keeps stop responsive: a voice message must cut off the
+	// instant the operator unkeys, not at the end of the buffer.
+	drained := make(chan struct{})
+	go func() { st.Drain(); close(drained) }()
+	select {
+	case <-drained:
+	case <-stop:
+		st.Stop()
+	}
+	return st.Error()
+}
+
+// renderStream continuously renders PCM pulled from src to a device until stop
+// closes — the streaming counterpart to playPCM's fixed buffer. On underrun it
+// writes silence rather than glitching, keeping the server's clock steady so
+// live monitor audio flows smoothly even when the source stalls briefly.
+func renderStream(deviceID string, rate, ch, bits int, stop <-chan struct{}, src *pcmRing) error {
+	format, err := pulseFormat(bits)
+	if err != nil {
+		return err
+	}
+	frameBytes := ch * bits / 8
+	if frameBytes <= 0 || rate <= 0 || src == nil {
+		return fmt.Errorf("bad audio format")
+	}
+
+	c, err := pulseClient()
+	if err != nil {
+		return err
+	}
+	defer c.Close()
+
+	// Never return 0 bytes without an error: the library's playback loop would
+	// spin on it. A stalled source therefore yields silence, which is also the
+	// behaviour that keeps the clock running.
+	chunk := chunkFrames * frameBytes
+	read := func(buf []byte) (int, error) {
+		select {
+		case <-stop:
+			return 0, pulse.EndOfData
+		default:
+		}
+		n := len(buf)
+		if n > chunk {
+			n = chunk
+		}
+		n -= n % frameBytes
+		if n == 0 {
+			n = frameBytes
+		}
+		got := copy(buf[:n], src.pull(n))
+		for i := got; i < n; i++ {
+			buf[i] = 0
+		}
+		return n, nil
+	}
+
+	opts := []pulse.PlaybackOption{
+		pulse.PlaybackSampleRate(rate),
+		pulse.PlaybackChannels(channelMap(ch)),
+		pulse.PlaybackLatency(0.1),
+		pulse.PlaybackMediaName("OpsLog monitor"),
+	}
+	if deviceID != "" {
+		sink, err := c.SinkByID(deviceID)
+		if err != nil {
+			return fmt.Errorf("no audio output %q: %w", deviceID, err)
+		}
+		opts = append(opts, pulse.PlaybackSink(sink))
+	}
+	st, err := c.NewPlayback(pulse.NewReader(readerFunc(read), format), opts...)
+	if err != nil {
+		return fmt.Errorf("open monitor: %w", err)
+	}
+	defer st.Close()
+
+	st.Start()
+	<-stop
+	st.Stop()
+	// Give the server a moment to notice the stream stopped before the client
+	// socket goes away, so the last fragment is heard instead of clipped.
+	time.Sleep(20 * time.Millisecond)
+	return st.Error()
+}
+
+// pulseFormat maps a WAV bit depth onto the server's sample formats. 8 and 16
+// bit cover everything OpsLog produces or reads; anything else is refused by
+// name rather than played as noise.
+func pulseFormat(bits int) (byte, error) {
+	switch bits {
+	case 8:
+		return proto.FormatUint8, nil
+	case 16:
+		return proto.FormatInt16LE, nil
+	default:
+		return 0, fmt.Errorf("unsupported sample size %d-bit (8 or 16 expected)", bits)
+	}
+}
+
+// readerFunc adapts a read closure to io.Reader.
+type readerFunc func([]byte) (int, error)
+
+func (f readerFunc) Read(p []byte) (int, error) { return f(p) }
+
+var _ io.Reader = readerFunc(nil)

internal/audio/manager.go

@@ -1,5 +1,3 @@
-//go:build windows
-
 package audio
 
 import (
@@ -15,6 +13,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 +228,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 +263,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 +338,19 @@ func (m *Manager) PushMonitorAudio(pcm []byte) {
 	m.mu.Lock()
 	ring := m.monRing
 	m.mu.Unlock()
-	if ring != nil {
-		ring.Push(pcm)
+	if ring == nil {
+		// 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/audio/mp3.go

@@ -1,5 +1,3 @@
-//go:build windows
-
 package audio
 
 import (

internal/audio/recorder.go

@@ -1,5 +1,3 @@
-//go:build windows
-
 package audio
 
 import (

internal/audio/ring.go

@@ -0,0 +1,60 @@
+package audio
+
+import "sync"
+
+// pcmRing is a thread-safe, latency-bounded FIFO of PCM bytes feeding a live
+// render stream. Producers (a USB-codec capture, or a decoded network audio
+// stream) Push freshly-arrived samples; the render loop Pulls. It is the shared
+// hand-off point between "where the audio comes from" (USB device / UDP 50003)
+// and "where it's heard" (any WASAPI output) — so the transport can be swapped
+// without touching the render side, mirroring the civTransport split on the CAT
+// side. On overflow the oldest audio is dropped to keep latency bounded; on
+// underrun Pull simply returns short and the render loop pads with silence.
+type pcmRing struct {
+	mu  sync.Mutex
+	buf []byte
+	max int // hard cap in bytes (drops oldest beyond this → bounded latency)
+}
+
+// newPCMRing makes a ring whose backlog is capped at maxBytes. Size it from the
+// acceptable latency: bytesPerSec (=32000) worth ≈ 1 s.
+func newPCMRing(maxBytes int) *pcmRing {
+	if maxBytes <= 0 {
+		maxBytes = bytesPerSec // 1 s default
+	}
+	return &pcmRing{max: maxBytes}
+}
+
+// Push appends samples, dropping the oldest audio if the backlog would exceed
+// the cap (a slow/absent consumer never makes the producer block or grow without
+// bound). A short glitch beats runaway latency for live monitoring.
+func (r *pcmRing) Push(p []byte) {
+	if len(p) == 0 {
+		return
+	}
+	r.mu.Lock()
+	r.buf = append(r.buf, p...)
+	if len(r.buf) > r.max {
+		drop := len(r.buf) - r.max
+		r.buf = append(r.buf[:0], r.buf[drop:]...)
+	}
+	r.mu.Unlock()
+}
+
+// pull removes and returns up to maxBytes of queued PCM (a private copy), or nil
+// when empty. The render loop pads any shortfall with silence.
+func (r *pcmRing) pull(maxBytes int) []byte {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	if len(r.buf) == 0 || maxBytes <= 0 {
+		return nil
+	}
+	n := maxBytes
+	if n > len(r.buf) {
+		n = len(r.buf)
+	}
+	out := make([]byte, n)
+	copy(out, r.buf[:n])
+	r.buf = append(r.buf[:0], r.buf[n:]...)
+	return out
+}

internal/audio/wav.go

@@ -1,5 +1,3 @@
-//go:build windows
-
 package audio
 
 import (

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 {
@@ -1101,6 +1145,23 @@ func (m *Manager) YaesuDo(fn func(YaesuController) error) error {
 	})
 }
 
+// OmniRigController is the handful of OmniRig preferences that can be changed
+// without dropping the rig link.
+type OmniRigController interface {
+	SetCWLower(bool) // which of OmniRig's two CW bits means plain CW
+}
+
+// OmniRigDo dispatches an OmniRig preference onto the CAT goroutine.
+func (m *Manager) OmniRigDo(fn func(OmniRigController) error) error {
+	return m.exec(func(b Backend) error {
+		oc, ok := b.(OmniRigController)
+		if !ok {
+			return fmt.Errorf("active CAT backend is not OmniRig")
+		}
+		return fn(oc)
+	})
+}
+
 // KenwoodController is the Kenwood/Elecraft CW-over-CAT capability (the KY keyer),
 // so a K3 can key CW through its single CAT link instead of a second COM port.
 type KenwoodController interface {

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

@@ -1,5 +1,3 @@
-//go:build windows
-
 package cat
 
 import (
@@ -67,6 +65,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 +233,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 +464,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/flexdiscover.go

@@ -1,5 +1,3 @@
-//go:build windows
-
 package cat
 
 import (
@@ -9,8 +7,6 @@ import (
 	"strconv"
 	"syscall"
 	"time"
-
-	"golang.org/x/sys/windows"
 )
 
 // FlexRadio is one radio found by discovery.
@@ -38,7 +34,7 @@ func DiscoverFlex(timeout time.Duration) ([]FlexRadio, error) {
 		Control: func(_, _ string, c syscall.RawConn) error {
 			var serr error
 			_ = c.Control(func(fd uintptr) {
-				serr = windows.SetsockoptInt(windows.Handle(fd), windows.SOL_SOCKET, windows.SO_REUSEADDR, 1)
+				serr = setSocketReuse(fd)
 			})
 			return serr
 		},

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

@@ -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
@@ -232,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
@@ -269,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/omnirig.go

@@ -1,3 +1,5 @@
+//go:build windows
+
 package cat
 
 import (
@@ -36,6 +38,14 @@ type OmniRig struct {
 	// on the main VFO) and read B — the frequency "never followed the knob",
 	// while it was following the other one all along.
 	ForceVFO string
+	// CWLower sends PM_CW_L rather than PM_CW_U when asked for CW.
+	//
+	// OmniRig has two CW modes and nothing says which one an .ini file calls
+	// plain CW. Icom rig files disagree: on some PM_CW_U is CI-V mode 0x03 (CW),
+	// on others it is 0x07 (CW-R). An operator clicking a CW spot on an IC-7610
+	// landed in CW-R every time and had to edit the rig file to get out of it.
+	// This is the setting that means he does not have to.
+	CWLower bool
 
 	omnirig *ole.IDispatch
 	rig     *ole.IDispatch
@@ -76,7 +86,7 @@ type OmniRig struct {
 // NewOmniRig creates a non-connected backend. Call Connect before use.
 // NewOmniRig builds the backend. forceVFO is "" to follow whatever the rig file
 // reports, or "A"/"B" to override it — see the ForceVFO field.
-func NewOmniRig(rigNum int, forceVFO string) *OmniRig {
+func NewOmniRig(rigNum int, forceVFO string, cwLower bool) *OmniRig {
 	if rigNum < 1 || rigNum > 2 {
 		rigNum = 1
 	}
@@ -84,7 +94,7 @@ func NewOmniRig(rigNum int, forceVFO string) *OmniRig {
 	if v != "A" && v != "B" {
 		v = ""
 	}
-	return &OmniRig{RigNum: rigNum, ForceVFO: v}
+	return &OmniRig{RigNum: rigNum, ForceVFO: v, CWLower: cwLower}
 }
 
 func (o *OmniRig) Name() string { return "omnirig" }
@@ -602,6 +612,13 @@ func (o *OmniRig) SetFrequency(hz int64) error {
 	return nil
 }
 
+// SetCWLower chooses which of OmniRig's two CW bits means plain CW.
+//
+// Applied to the RUNNING backend, because the CAT link does not depend on it:
+// dropping the rig — and with it WSJT-X's rigctl session — to change which bit
+// a mode maps to would cost far more than it fixes.
+func (o *OmniRig) SetCWLower(on bool) { o.CWLower = on }
+
 // SetMode maps an ADIF mode to the OmniRig PM_* bit and pushes it to the rig.
 // For SSB, the USB/LSB side is chosen from the rig's current frequency
 // following worldwide convention (LSB below 14 MHz, USB above).
@@ -625,7 +642,13 @@ func (o *OmniRig) SetMode(mode string) error {
 	)
 	switch strings.ToUpper(strings.TrimSpace(mode)) {
 	case "CW":
+		// Which bit means plain CW is a property of the RIG FILE, not of CW —
+		// see the CWLower field.
+		if o.CWLower {
+			bit, bitName = pmCWL, "PM_CW_L"
+		} else {
 			bit, bitName = pmCWU, "PM_CW_U"
+		}
 	case "SSB":
 		// Decide USB vs LSB from the frequency. Prefer the freq we just COMMANDED
 		// (a clicked spot sets freq then mode ~150ms later): OmniRig's Freq

internal/cat/omnirig_activate32.go

@@ -1,3 +1,5 @@
+//go:build windows
+
 package cat
 
 import (

internal/cat/omnirig_elevation_test.go

@@ -1,3 +1,5 @@
+//go:build windows
+
 package cat
 
 import (

internal/cat/omnirig_other.go

@@ -0,0 +1,34 @@
+//go:build !windows
+
+package cat
+
+import "errors"
+
+// OmniRig is COM automation against a Windows-only application, so off Windows
+// there is nothing to talk to. The backend still EXISTS here rather than being
+// compiled out of app.go, because a settings database is portable: an operator
+// who moves a profile from Windows to Linux keeps "omnirig" as their saved CAT
+// backend, and OpsLog must start and say why the rig is silent instead of
+// failing to build or panicking on a nil backend.
+//
+// The fix for those operators is a native backend (Icom, Yaesu, Kenwood/
+// Elecraft, Flex, TCI, Xiegu all speak to the radio directly) or Hamlib.
+type OmniRig struct{ CWLower bool }
+
+var errOmniRigWindowsOnly = errors.New("OmniRig runs only on Windows — pick a native CAT backend (Icom, Yaesu, Kenwood/Elecraft, FlexRadio, TCI, Xiegu) in Settings ▸ CAT")
+
+func NewOmniRig(rigNum int, forceVFO string, cwLower bool) *OmniRig {
+	return &OmniRig{CWLower: cwLower}
+}
+
+func (o *OmniRig) Name() string                 { return "omnirig" }
+func (o *OmniRig) Connect() error               { return errOmniRigWindowsOnly }
+func (o *OmniRig) Disconnect()                  {}
+func (o *OmniRig) ReadState() (RigState, error) { return RigState{}, errOmniRigWindowsOnly }
+func (o *OmniRig) SetFrequency(hz int64) error  { return errOmniRigWindowsOnly }
+func (o *OmniRig) SetMode(mode string) error    { return errOmniRigWindowsOnly }
+func (o *OmniRig) SetPTT(on bool) error         { return errOmniRigWindowsOnly }
+
+// SetCWLower satisfies OmniRigController so the preference push at startup is a
+// no-op here rather than a "backend does not support this" error in the log.
+func (o *OmniRig) SetCWLower(on bool) { o.CWLower = on }

internal/cat/omnirig_vfo_test.go

@@ -1,3 +1,5 @@
+//go:build windows
+
 package cat
 
 import "testing"

internal/cat/sockreuse_unix.go

@@ -0,0 +1,16 @@
+//go:build !windows
+
+package cat
+
+import "golang.org/x/sys/unix"
+
+// setSocketReuse is the Unix half of the Windows SO_REUSEADDR above. Linux
+// wants SO_REUSEPORT as well before two processes may share a bound UDP port;
+// it is not defined on every Unix, so a refusal there is ignored.
+func setSocketReuse(fd uintptr) error {
+	if err := unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_REUSEADDR, 1); err != nil {
+		return err
+	}
+	_ = unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_REUSEPORT, 1)
+	return nil
+}

internal/cat/sockreuse_windows.go

@@ -0,0 +1,14 @@
+//go:build windows
+
+package cat
+
+import "golang.org/x/sys/windows"
+
+// setSocketReuse enables SO_REUSEADDR before bind, so discovery can listen on
+// :4992 while SmartSDR is already listening for the same radio broadcast.
+// Without it the second bind fails with WSAEADDRINUSE and the operator has to
+// type the radio's IP by hand.
+func setSocketReuse(fd uintptr) error {
+	return windows.SetsockoptInt(windows.Handle(fd),
+		windows.SOL_SOCKET, windows.SO_REUSEADDR, 1)
+}

internal/cat/tci.go

@@ -1,5 +1,3 @@
-//go:build windows
-
 package cat
 
 import (

internal/cat/tci_audio.go

@@ -1,5 +1,3 @@
-//go:build windows
-
 package cat
 
 // TCI audio — receiving the radio's audio over the same WebSocket that carries

internal/cat/tci_manager.go

@@ -1,5 +1,3 @@
-//go:build windows
-
 package cat
 
 import "fmt"

internal/cat/tci_panel.go

@@ -1,5 +1,3 @@
-//go:build windows
-
 package cat
 
 // The TCI control panel: what the radio already tells us, gathered up.

internal/cat/tci_ptt_test.go

@@ -1,5 +1,3 @@
-//go:build windows
-
 package cat
 
 import "testing"

internal/cat/tci_spot_test.go

@@ -1,5 +1,3 @@
-//go:build windows
-
 package cat
 
 import "testing"

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")
+		add(set(cfg.LoTW.StationLocation), "the TQSL station location")
+		if len(need) > 0 {
+			return missing("LoTW", need...)
+		}
+	}
+	return nil
+}

internal/extsvc/lotw.go

@@ -297,29 +297,6 @@ func ListStationLocations(stationDataPath string) ([]StationLocation, error) {
 	return out, nil
 }
 
-// DefaultTQSLPath returns the usual tqsl.exe install path on Windows, or ""
-// if not found.
-func DefaultTQSLPath() string {
-	for _, p := range []string{
-		`C:\Program Files (x86)\TrustedQSL\tqsl.exe`,
-		`C:\Program Files\TrustedQSL\tqsl.exe`,
-	} {
-		if fileExists(p) {
-			return p
-		}
-	}
-	return ""
-}
-
-// DefaultStationDataPath returns TQSL's station_data location (%APPDATA%\
-// TrustedQSL\station_data on Windows), or "" if APPDATA isn't set.
-func DefaultStationDataPath() string {
-	if appData := os.Getenv("APPDATA"); appData != "" {
-		return filepath.Join(appData, "TrustedQSL", "station_data")
-	}
-	return ""
-}
-
 func fileExists(p string) bool {
 	info, err := os.Stat(p)
 	return err == nil && !info.IsDir()
@@ -375,7 +352,7 @@ func UploadLoTW(ctx context.Context, cfg ServiceConfig, tempDir, adifRecord stri
 	case tqsl == "":
 		return UploadResult{}, fmt.Errorf("lotw: TQSL path not set")
 	case !fileExists(tqsl):
-		return UploadResult{}, fmt.Errorf("lotw: tqsl.exe not found at %q", tqsl)
+		return UploadResult{}, fmt.Errorf("lotw: TQSL not found at %q", tqsl)
 	case loc == "":
 		return UploadResult{}, fmt.Errorf("lotw: station location not set")
 	case strings.TrimSpace(adifRecord) == "":
@@ -515,7 +492,7 @@ func TestLoTW(cfg ServiceConfig, stationDataPath string) (string, error) {
 	tqsl := strings.TrimSpace(cfg.TQSLPath)
 	loc := strings.TrimSpace(cfg.StationLocation)
 	if tqsl == "" || !fileExists(tqsl) {
-		return "", fmt.Errorf("lotw: tqsl.exe not found (set the TQSL path)")
+		return "", fmt.Errorf("lotw: TQSL not found (set the TQSL path)")
 	}
 	if loc == "" {
 		return "", fmt.Errorf("lotw: pick a station location")

internal/extsvc/tqslpath_unix.go

@@ -0,0 +1,66 @@
+//go:build !windows
+
+package extsvc
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+)
+
+// DefaultTQSLPath finds TrustedQSL, or returns "" so the operator can point at
+// it by hand.
+//
+// PATH is asked FIRST, unlike the Windows side where two fixed install folders
+// are the whole story. On Linux tqsl comes from the distribution's package
+// manager, a Flatpak or a self-built copy, and each puts it somewhere
+// different; whichever one the operator installed is the one their shell finds.
+// The fixed list below is only for a desktop session that started without a
+// useful PATH.
+func DefaultTQSLPath() string {
+	if p, err := exec.LookPath("tqsl"); err == nil && fileExists(p) {
+		return p
+	}
+	candidates := []string{
+		"/usr/bin/tqsl",
+		"/usr/local/bin/tqsl",
+		"/var/lib/flatpak/exports/bin/org.arrl.tqsl",
+		filepath.Join(os.Getenv("HOME"), ".local/share/flatpak/exports/bin/org.arrl.tqsl"),
+	}
+	if runtime.GOOS == "darwin" {
+		candidates = append(candidates, "/Applications/TrustedQSL/tqsl.app/Contents/MacOS/tqsl")
+	}
+	for _, p := range candidates {
+		if fileExists(p) {
+			return p
+		}
+	}
+	return ""
+}
+
+// DefaultStationDataPath returns TQSL's station_data location.
+//
+// ~/.tqsl is where the Unix build of TrustedQSL keeps its configuration. A
+// Flatpak install redirects it into the sandbox
+// (~/.var/app/org.arrl.tqsl/data/tqsl), so that is tried too — an operator on a
+// Flatpak TQSL otherwise sees an empty station-location list with nothing to
+// explain it.
+func DefaultStationDataPath() string {
+	home, err := os.UserHomeDir()
+	if err != nil || home == "" {
+		return ""
+	}
+	for _, p := range []string{
+		filepath.Join(home, ".tqsl", "station_data"),
+		filepath.Join(home, ".var", "app", "org.arrl.tqsl", "data", "tqsl", "station_data"),
+	} {
+		if fileExists(p) {
+			return p
+		}
+	}
+	// Nothing found: name the ordinary location anyway. The settings field then
+	// shows the path TQSL would create on its first run, which is a better
+	// starting point for the operator than an empty box.
+	return filepath.Join(home, ".tqsl", "station_data")
+}

internal/extsvc/tqslpath_windows.go

@@ -0,0 +1,30 @@
+//go:build windows
+
+package extsvc
+
+import (
+	"os"
+	"path/filepath"
+)
+
+// DefaultTQSLPath returns the usual tqsl.exe install path, or "" if not found.
+func DefaultTQSLPath() string {
+	for _, p := range []string{
+		`C:\Program Files (x86)\TrustedQSL\tqsl.exe`,
+		`C:\Program Files\TrustedQSL\tqsl.exe`,
+	} {
+		if fileExists(p) {
+			return p
+		}
+	}
+	return ""
+}
+
+// DefaultStationDataPath returns TQSL's station_data location
+// (%APPDATA%\TrustedQSL\station_data), or "" if APPDATA isn't set.
+func DefaultStationDataPath() string {
+	if appData := os.Getenv("APPDATA"); appData != "" {
+		return filepath.Join(appData, "TrustedQSL", "station_data")
+	}
+	return ""
+}

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/multicastgroup_test.go

@@ -0,0 +1,35 @@
+package udp
+
+import (
+	"net"
+	"testing"
+)
+
+// A "multicast" row whose group is not a multicast address.
+//
+// 127.0.0.1 in that box is the common mistake — it is the address every other
+// field in every other program wants — and it used to fail the join on every
+// interface with a Windows error about an address not being valid in its
+// context. The row did not run and the message named nothing the operator had
+// typed. Reported by an operator whose WSJT-X rows were dead for exactly this
+// reason, while a third row on unicast worked perfectly beside them.
+func TestOnlyRealMulticastGroupsAreJoined(t *testing.T) {
+	for _, tc := range []struct {
+		addr      string
+		multicast bool
+	}{
+		{"224.0.0.1", true},   // the all-hosts group WSJT-X offers
+		{"239.255.0.1", true}, // the administratively-scoped range
+		{"127.0.0.1", false},  // loopback: the mistake
+		{"192.168.1.10", false},
+		{"0.0.0.0", false},
+	} {
+		ip := net.ParseIP(tc.addr)
+		if ip == nil {
+			t.Fatalf("%s does not parse", tc.addr)
+		}
+		if got := ip.IsMulticast(); got != tc.multicast {
+			t.Errorf("%s: IsMulticast() = %v, wanted %v", tc.addr, got, tc.multicast)
+		}
+	}
+}

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
@@ -301,7 +310,28 @@ func newServer(cfg Config, out chan<- Event, mgr *Manager) *Server {
 
 func (s *Server) start() error {
 	var conn *net.UDPConn
-	if s.cfg.Multicast {
+	// "Multicast" ticked with an address that is not one.
+	//
+	// 127.0.0.1 in the group box is the common mistake, and it is an
+	// understandable one — it is the address every other field in every other
+	// program wants. But a multicast group is 224.0.0.0 to 239.255.255.255, and
+	// joining anything else fails on every interface with a Windows error about
+	// an address not being valid in its context. The row then simply does not
+	// run, and an operator reads a setsockopt message that names nothing they
+	// typed.
+	//
+	// So it listens anyway, as unicast, which is what an address like that means
+	// — and says what it did. The row works, and the reason it is not multicast
+	// is in the log rather than in a kernel error code.
+	multicast := s.cfg.Multicast
+	if multicast {
+		if ip := net.ParseIP(strings.TrimSpace(s.cfg.MulticastGroup)); ip != nil && !ip.IsMulticast() {
+			applog.Printf("udp: [%s] %s is not a multicast address (those run 224.0.0.0-239.255.255.255) — listening on unicast :%d instead\n",
+				s.cfg.Name, ip, s.cfg.Port)
+			multicast = false
+		}
+	}
+	if multicast {
 		group := strings.TrimSpace(s.cfg.MulticastGroup)
 		if group == "" {
 			return fmt.Errorf("multicast enabled but group address is empty")
@@ -403,6 +433,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 +672,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()
-		prev := s.lastDX
-		s.lastDX = w.DXCall
-		s.mu.Unlock()
-		if w.DXCall == "" && prev != "" {
+		if s.noteDXCall(inst, w.DXCall) {
 			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/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/gs232/gs232.go

@@ -16,9 +16,12 @@
 // GS-232A subset used:
 //
 //	Maaa<CR>      move to azimuth aaa (000-450)
+//	Waaa eee<CR>  move to azimuth aaa AND elevation eee (az/el controllers)
 //	S<CR>         stop rotation
 //	C<CR>         query azimuth — replies "+0aaa" (GS-232A) or "AZ=aaa" (GS-232B
 //	              flavour); both are parsed.
+//	C2<CR>        query both axes — "+0aaa+0eee" / "AZ=aaa EL=eee"
+//	B<CR>         query elevation alone, for the controllers that do not answer C2
 package gs232
 
 import (
@@ -242,3 +245,84 @@ func (c *Client) Heading() (az int, raw string, err error) {
 	az, _ = strconv.Atoi(m[1])
 	return az % 360, raw, nil
 }
+
+// --- Elevation: the az/el controllers ---
+//
+// The ERC-M (Easy Rotor Control, DF9GR) is the reason this half exists. It
+// drives a Yaesu G-5500 — the az/el pair most satellite stations own — and
+// emulates GS-232 over its USB port, so the same three commands that already
+// pointed an azimuth rotator point a satellite antenna once elevation is added.
+//
+// A plain ERC or a microHAM ARCO answers the azimuth commands and ignores
+// these; that is why the elevation capability is a property of the configured
+// TYPE and not something probed at runtime. Asking a controller with no
+// elevation motor where its elevation is gets an answer, and the answer is
+// zero, for ever.
+
+// GoToAzEl points an az/el controller at both axes in one command. GS-232's W
+// takes the two angles separated by a space, azimuth first.
+//
+// Elevation is clamped to 0-180 rather than 0-90: a G-5500 goes past the zenith
+// and keeps counting, which is how an overhead pass is followed without swinging
+// the azimuth 180° through the middle of it.
+func (c *Client) GoToAzEl(az, el int) error {
+	az = ((az % 360) + 360) % 360
+	if el < 0 {
+		el = 0
+	}
+	if el > 180 {
+		el = 180
+	}
+	_, err := c.roundTrip(fmt.Sprintf("W%03d %03d", az, el), false)
+	return err
+}
+
+// elRe matches the elevation half of a reply, in either flavour. The GS-232A
+// form of C2 is "+0aaa+0eee" — two identically-shaped groups — so the azimuth
+// is taken from the first match and the elevation from the second, which is
+// what bothRe below does; this one is for the reply to a bare B.
+var elRe = regexp.MustCompile(`(?:\+0|EL=)(\d{3})`)
+
+// bothRe pulls both angles out of a C2 reply.
+var bothRe = regexp.MustCompile(`(?:\+0|AZ=)(\d{3})[^0-9+]*(?:\+0|EL=)(\d{3})`)
+
+// Position queries both axes.
+//
+// C2 first, because one exchange is one chance for a serial line to go quiet.
+// Controllers that answer C2 with the azimuth alone — some ERC firmware does —
+// fall through to the two separate queries rather than reporting an elevation
+// of zero, which would read as "the antenna is on the horizon" and is the one
+// wrong answer that looks plausible.
+func (c *Client) Position() (az, el int, raw string, err error) {
+	raw, err = c.roundTrip("C2", true)
+	if err == nil {
+		if m := bothRe.FindStringSubmatch(raw); m != nil {
+			a, _ := strconv.Atoi(m[1])
+			e, _ := strconv.Atoi(m[2])
+			return a % 360, e, raw, nil
+		}
+	}
+	a, azRaw, aerr := c.Heading()
+	if aerr != nil {
+		return 0, 0, azRaw, aerr
+	}
+	e, elRaw, eerr := c.Elevation()
+	if eerr != nil {
+		return a, 0, azRaw + " " + elRaw, eerr
+	}
+	return a, e, azRaw + " " + elRaw, nil
+}
+
+// Elevation queries the elevation axis alone.
+func (c *Client) Elevation() (el int, raw string, err error) {
+	raw, err = c.roundTrip("B", true)
+	if err != nil {
+		return 0, raw, err
+	}
+	m := elRe.FindStringSubmatch(raw)
+	if m == nil {
+		return 0, raw, fmt.Errorf("unrecognised elevation reply %q", raw)
+	}
+	el, _ = strconv.Atoi(m[1])
+	return el, raw, nil
+}

internal/rotator/gs232/reply_test.go

@@ -32,3 +32,68 @@ func TestAzimuthReplies(t *testing.T) {
 		}
 	}
 }
+
+// The az/el replies an ERC-M sends back to C2, in both flavours. The GS-232A
+// form is two identical "+0nnn" groups running together with nothing between
+// them, which is exactly the shape that makes a naive azimuth regex match the
+// ELEVATION when the azimuth is read a second time.
+func TestPositionReplies(t *testing.T) {
+	cases := []struct {
+		raw            string
+		wantAz, wantEl int
+	}{
+		{"+0140+0032\r\n", 140, 32},    // GS-232A, the ERC-M's own form
+		{"+0000+0000\r", 0, 0},         // parked
+		{"AZ=140 EL=032\r\n", 140, 32}, // GS-232B flavour
+		{"AZ=005 EL=090\r\n", 5, 90},   // straight up
+		{"+0270+0180\r\n", 270, 180},   // past the zenith, still counting
+		{"\r\n+0075+0005\r\n", 75, 5},  // a leftover terminator ahead of it
+		{"+0450+0045\r\n", 90, 45},     // 450° mast in its overlap
+	}
+	for _, c := range cases {
+		m := bothRe.FindStringSubmatch(strings.TrimSpace(c.raw))
+		if m == nil {
+			t.Errorf("no position found in %q", c.raw)
+			continue
+		}
+		az, _ := strconv.Atoi(m[1])
+		el, _ := strconv.Atoi(m[2])
+		if az%360 != c.wantAz || el != c.wantEl {
+			t.Errorf("%q → az %d el %d, want az %d el %d", c.raw, az%360, el, c.wantAz, c.wantEl)
+		}
+	}
+}
+
+// A controller that answers C2 with the azimuth alone must NOT be read as
+// "elevation zero" — that is a plausible-looking wrong answer, the antenna
+// sitting on the horizon, and it would send the tracker chasing it.
+func TestPositionRejectsAzimuthOnlyReply(t *testing.T) {
+	for _, raw := range []string{"+0140\r\n", "AZ=140\r\n", "?>\r\n"} {
+		if m := bothRe.FindStringSubmatch(strings.TrimSpace(raw)); m != nil {
+			t.Errorf("%q parsed as a two-axis reply (%v) — it is not one", raw, m[1:])
+		}
+	}
+}
+
+// The reply to a bare B, for the controllers that do not answer C2.
+func TestElevationReplies(t *testing.T) {
+	cases := []struct {
+		raw  string
+		want int
+	}{
+		{"+0032\r\n", 32},
+		{"EL=032\r\n", 32},
+		{"+0000\r", 0},
+		{"+0090\r\n", 90},
+	}
+	for _, c := range cases {
+		m := elRe.FindStringSubmatch(strings.TrimSpace(c.raw))
+		if m == nil {
+			t.Errorf("no elevation found in %q", c.raw)
+			continue
+		}
+		if got, _ := strconv.Atoi(m[1]); got != c.want {
+			t.Errorf("%q → %d, want %d", c.raw, got, c.want)
+		}
+	}
+}

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,355 @@
+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"`
+	// NORAD is the catalog number, and the only exact way to find this
+	// satellite's elements: the feed, AMSAT and the operator all spell the NAME
+	// differently, while the number is carried inside the TLE itself. Aliases
+	// remain for the entries that predate it and for a hand-written plan.
+	NORAD   int      `json:"norad,omitempty"`
+	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)
+		}
+		// New satellites reach an EXISTING station too.
+		//
+		// The operator's copy is written once, on the first run, and was then
+		// theirs for ever — which meant a release that added nine Tevel-2
+		// satellites reached nobody who had already opened the tab. Merging on
+		// each load fixes that without taking anything back: a satellite the
+		// operator already has is left exactly as it is, edits included, and
+		// only the ones they have never seen are added. Deleting a bird from the
+		// file therefore brings it back, which is the price of the trade — and
+		// the cheaper half of it, since an unwanted satellite is one row and a
+		// missing one is a pass nobody can work.
+		if n := b.addMissing(shippedBirds); n > 0 {
+			if out, merr := json.MarshalIndent(b.list, "", "  "); merr == nil {
+				_ = os.WriteFile(path, append(out, '\n'), 0o644)
+			}
+		}
+		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)
+}
+
+// addMissing appends the satellites in `shipped` that this list does not already
+// hold, and reports how many were added.
+//
+// "Already hold" is by catalog number first and by the loose name second, so an
+// operator who renamed a bird, or who has it under the feed's spelling, does not
+// get a second copy of it. Nothing existing is touched: their frequencies, their
+// labels and their corrections all stand.
+func (b *Birds) addMissing(shipped []byte) int {
+	var list []Bird
+	if err := json.Unmarshal(shipped, &list); err != nil {
+		return 0
+	}
+	b.mu.Lock()
+	have := make(map[int]bool, len(b.list))
+	for _, x := range b.list {
+		if x.NORAD != 0 {
+			have[x.NORAD] = true
+		}
+	}
+	added := 0
+	for _, cand := range list {
+		if cand.NORAD != 0 && have[cand.NORAD] {
+			continue
+		}
+		known := false
+		for _, name := range append([]string{cand.Name}, cand.Aliases...) {
+			if k := loose(name); k != "" {
+				if _, ok := b.byKey[k]; ok {
+					known = true
+					break
+				}
+			}
+		}
+		if known {
+			continue
+		}
+		b.list = append(b.list, cand)
+		if cand.NORAD != 0 {
+			have[cand.NORAD] = true
+		}
+		if k := loose(cand.Name); k != "" {
+			b.byKey[k] = len(b.list) - 1
+		}
+		added++
+	}
+	b.mu.Unlock()
+	return added
+}

internal/sat/birds.json

@@ -0,0 +1,706 @@
+[
+  {
+    "name": "AO-123",
+    "norad": 61781,
+    "aliases": [
+      "ASRTU-1 (AO-123)"
+    ],
+    "transponders": [
+      {
+        "label": "Mode V/U - FM Transceiver",
+        "mode": "FM",
+        "down_lo": 435400000,
+        "up_lo": 145850000
+      }
+    ]
+  },
+  {
+    "name": "AO-27",
+    "norad": 22825,
+    "aliases": [
+      "EYESAT A (AO-27)"
+    ],
+    "transponders": [
+      {
+        "label": "Mode V/U FM",
+        "mode": "FM",
+        "down_lo": 436795000,
+        "up_lo": 145850000
+      }
+    ]
+  },
+  {
+    "name": "AO-7",
+    "norad": 7530,
+    "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": "AO-73",
+    "norad": 39444,
+    "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": "AO-91",
+    "norad": 43017,
+    "aliases": [
+      "RADFXSAT",
+      "FOX-1B",
+      "RADFXSAT (FOX-1B)"
+    ],
+    "transponders": [
+      {
+        "label": "FM voice repeater",
+        "mode": "FM",
+        "down_lo": 145960000,
+        "up_lo": 435250000,
+        "ctcss": 67
+      }
+    ]
+  },
+  {
+    "name": "BEESAT-1",
+    "norad": 35933,
+    "transponders": [
+      {
+        "label": "Digipeater (Mobitex, idle mode: 10 sec interval)",
+        "mode": "DATA",
+        "down_lo": 435950000,
+        "up_lo": 435950000
+      }
+    ]
+  },
+  {
+    "name": "CO-65",
+    "norad": 32785,
+    "aliases": [
+      "CUTE-1.7+APD II (CO-65)"
+    ],
+    "transponders": [
+      {
+        "label": "Mode L/U Digipeater",
+        "mode": "DATA",
+        "down_lo": 437475000,
+        "up_lo": 1267600000
+      }
+    ]
+  },
+  {
+    "name": "CROCUBE",
+    "norad": 62394,
+    "transponders": [
+      {
+        "label": "Mode U/U - GFSK9k6 - Digipeater - AX.25",
+        "mode": "DATA",
+        "down_lo": 436775000,
+        "up_lo": 436775000
+      }
+    ]
+  },
+  {
+    "name": "CSS",
+    "norad": 48274,
+    "transponders": [
+      {
+        "label": "3A V/V digipeater AFSK-FM 1200",
+        "mode": "DATA",
+        "down_lo": 145825000,
+        "up_lo": 145825000
+      },
+      {
+        "label": "1A V/V crew voice NFM",
+        "mode": "FM",
+        "down_lo": 145985000,
+        "up_lo": 145850000
+      },
+      {
+        "label": "2B U/V FM repeater NFM",
+        "mode": "FM",
+        "down_lo": 145985000,
+        "up_lo": 435075000
+      },
+      {
+        "label": "4A V/V imaging SSTV-FM",
+        "mode": "FM",
+        "down_lo": 145985000,
+        "up_lo": 145850000
+      },
+      {
+        "label": "1B U/U crew voice NFM",
+        "mode": "FM",
+        "down_lo": 436510000,
+        "up_lo": 435050000
+      },
+      {
+        "label": "2A V/U FM repeater NFM",
+        "mode": "FM",
+        "down_lo": 436510000,
+        "up_lo": 145875000
+      },
+      {
+        "label": "4B U/U imaging SSTV-FM",
+        "mode": "FM",
+        "down_lo": 436510000,
+        "up_lo": 435050000
+      },
+      {
+        "label": "3B U/U digipeater AFSK-FM 1200",
+        "mode": "DATA",
+        "down_lo": 437550000,
+        "up_lo": 437550000
+      }
+    ]
+  },
+  {
+    "name": "ESEO",
+    "norad": 43792,
+    "transponders": [
+      {
+        "label": "FM",
+        "mode": "FM",
+        "down_lo": 145895000,
+        "up_lo": 1263500000
+      }
+    ]
+  },
+  {
+    "name": "FLORIPASAT-1",
+    "norad": 44885,
+    "transponders": [
+      {
+        "label": "Mode U/U GFSK2k4 Repeater",
+        "mode": "DATA",
+        "down_lo": 436100000,
+        "up_lo": 436100000
+      }
+    ]
+  },
+  {
+    "name": "FO-29",
+    "norad": 24278,
+    "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": "FORESAIL-1P",
+    "norad": 66778,
+    "transponders": [
+      {
+        "label": "Mode U/U - GMSK9k6 - Digipeater - Skylink",
+        "mode": "DATA",
+        "down_lo": 437125000,
+        "up_lo": 437125000
+      }
+    ]
+  },
+  {
+    "name": "GRBBETA",
+    "norad": 60237,
+    "transponders": [
+      {
+        "label": "Mode V/V - GFSK9k6 - Digipeater - AX.25",
+        "mode": "DATA",
+        "down_lo": 145935000,
+        "up_lo": 145935000
+      },
+      {
+        "label": "Mode U/U - GFSK9k6 - Digipeater - AX.25",
+        "mode": "DATA",
+        "down_lo": 436785000,
+        "up_lo": 436785000
+      }
+    ]
+  },
+  {
+    "name": "IO-117",
+    "norad": 53109,
+    "aliases": [
+      "GREENCUBE",
+      "MEZTLI"
+    ],
+    "transponders": [
+      {
+        "label": "Digipeater (1200 bd GMSK)",
+        "mode": "DATA",
+        "down_lo": 435310000,
+        "up_lo": 435310000
+      }
+    ]
+  },
+  {
+    "name": "IO-86",
+    "norad": 40931,
+    "aliases": [
+      "LAPAN-A2",
+      "LAPAN-ORARI"
+    ],
+    "transponders": [
+      {
+        "label": "FM voice repeater",
+        "mode": "FM",
+        "down_lo": 435880000,
+        "up_lo": 145880000,
+        "ctcss": 88.5
+      }
+    ]
+  },
+  {
+    "name": "ISAT",
+    "norad": 43879,
+    "transponders": [
+      {
+        "label": "MODE U/U DSTAR VOICE",
+        "mode": "FM",
+        "down_lo": 435525000,
+        "up_lo": 437325000
+      }
+    ]
+  },
+  {
+    "name": "ISS (ZARYA)",
+    "norad": 25544,
+    "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": "JO-97",
+    "norad": 43803,
+    "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": "KNACKSAT-2",
+    "norad": 67683,
+    "transponders": [
+      {
+        "label": "Mode V/V - FSK9k6 - Digipeater - AX.25 G3RUH",
+        "mode": "DATA",
+        "down_lo": 145825000,
+        "up_lo": 145825000
+      }
+    ]
+  },
+  {
+    "name": "KOSEN-1",
+    "norad": 49402,
+    "transponders": [
+      {
+        "label": "Mode HF/U - Onboard SDR",
+        "mode": "DATA",
+        "down_lo": 435525000,
+        "up_lo": 21125000,
+        "up_hi": 21150000
+      }
+    ]
+  },
+  {
+    "name": "LASARSAT",
+    "norad": 62391,
+    "transponders": [
+      {
+        "label": "Mode U/U - GFSK9k6 - Digipeater - AX.25",
+        "mode": "DATA",
+        "down_lo": 436925000,
+        "up_lo": 436925000
+      }
+    ]
+  },
+  {
+    "name": "LILACSAT-2",
+    "norad": 40908,
+    "transponders": [
+      {
+        "label": "APRS Digipeater",
+        "mode": "DATA",
+        "down_lo": 144390000,
+        "up_lo": 144390000
+      }
+    ]
+  },
+  {
+    "name": "NO-44",
+    "norad": 26931,
+    "aliases": [
+      "PCSAT (NO-44)"
+    ],
+    "transponders": [
+      {
+        "label": "Mode V/V APRS AFSK",
+        "mode": "DATA",
+        "down_lo": 145825000,
+        "up_lo": 145825000
+      }
+    ]
+  },
+  {
+    "name": "PO-101",
+    "norad": 43678,
+    "aliases": [
+      "DIWATA-2",
+      "DIWATA-2B"
+    ],
+    "transponders": [
+      {
+        "label": "FM voice repeater (scheduled)",
+        "mode": "FM",
+        "down_lo": 145900000,
+        "up_lo": 437500000,
+        "ctcss": 141.3
+      }
+    ]
+  },
+  {
+    "name": "QB50P1",
+    "norad": 40025,
+    "transponders": [
+      {
+        "label": "Linear Transponder",
+        "mode": "SSB",
+        "down_lo": 145935000,
+        "down_hi": 145965000,
+        "up_lo": 435047000,
+        "up_hi": 435077000,
+        "inverting": true
+      }
+    ]
+  },
+  {
+    "name": "QMR-KWT-2",
+    "norad": 67291,
+    "transponders": [
+      {
+        "label": "V/U FM Transponder CTCSS 67.0 Hz",
+        "mode": "FM",
+        "down_lo": 436950000,
+        "up_lo": 145920000,
+        "ctcss": 67
+      }
+    ]
+  },
+  {
+    "name": "QO-100",
+    "norad": 43700,
+    "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": "RS-44",
+    "norad": 44909,
+    "aliases": [
+      "DOSAAF-85"
+    ],
+    "transponders": [
+      {
+        "label": "Linear (inverting)",
+        "mode": "SSB",
+        "down_lo": 435640000,
+        "down_hi": 435680000,
+        "up_lo": 145965000,
+        "up_hi": 146005000,
+        "inverting": true
+      }
+    ]
+  },
+  {
+    "name": "SO-50",
+    "norad": 27607,
+    "aliases": [
+      "SAUDISAT 1C",
+      "SAUDISAT 1C (SO-50)"
+    ],
+    "transponders": [
+      {
+        "label": "FM voice repeater",
+        "mode": "FM",
+        "down_lo": 436795000,
+        "up_lo": 145850000,
+        "ctcss": 67
+      }
+    ]
+  },
+  {
+    "name": "SONATE-2",
+    "norad": 59112,
+    "transponders": [
+      {
+        "label": "Mode V/V - APRS digipeater",
+        "mode": "DATA",
+        "down_lo": 145825000,
+        "up_lo": 145825000
+      }
+    ]
+  },
+  {
+    "name": "TAURUS-1",
+    "norad": 44530,
+    "transponders": [
+      {
+        "label": "Mode V/U FM 67.0 PL",
+        "mode": "FM",
+        "down_lo": 436760000,
+        "up_lo": 145820000,
+        "ctcss": 67
+      }
+    ]
+  },
+  {
+    "name": "TEVEL2-1",
+    "norad": 63217,
+    "transponders": [
+      {
+        "label": "Mode V/U - FM Transponder",
+        "mode": "FM",
+        "down_lo": 436400000,
+        "up_lo": 145970000
+      }
+    ]
+  },
+  {
+    "name": "TEVEL2-2",
+    "norad": 63219,
+    "transponders": [
+      {
+        "label": "Mode V/U - FM Transponder - Beacon",
+        "mode": "FM",
+        "down_lo": 436400000,
+        "up_lo": 145970000
+      }
+    ]
+  },
+  {
+    "name": "TEVEL2-3",
+    "norad": 63218,
+    "transponders": [
+      {
+        "label": "Mode V/U - FM Transponder",
+        "mode": "FM",
+        "down_lo": 436400000,
+        "up_lo": 145970000
+      }
+    ]
+  },
+  {
+    "name": "TEVEL2-4",
+    "norad": 63213,
+    "transponders": [
+      {
+        "label": "Mode V/U - FM Transponder",
+        "mode": "FM",
+        "down_lo": 436400000,
+        "up_lo": 145970000
+      }
+    ]
+  },
+  {
+    "name": "TEVEL2-5",
+    "norad": 63214,
+    "transponders": [
+      {
+        "label": "Mode V/U - FM Transponder",
+        "mode": "FM",
+        "down_lo": 436400000,
+        "up_lo": 145970000
+      }
+    ]
+  },
+  {
+    "name": "TEVEL2-6",
+    "norad": 63215,
+    "transponders": [
+      {
+        "label": "Mode V/U - FM Transponder",
+        "mode": "FM",
+        "down_lo": 436400000,
+        "up_lo": 145970000
+      }
+    ]
+  },
+  {
+    "name": "TEVEL2-7",
+    "norad": 63238,
+    "transponders": [
+      {
+        "label": "Mode V/U - FM Transponder",
+        "mode": "FM",
+        "down_lo": 436400000,
+        "up_lo": 145970000
+      }
+    ]
+  },
+  {
+    "name": "TEVEL2-8",
+    "norad": 63239,
+    "transponders": [
+      {
+        "label": "Mode V/U - FM Transponder - Beacon",
+        "mode": "FM",
+        "down_lo": 436400000,
+        "up_lo": 145970000
+      }
+    ]
+  },
+  {
+    "name": "TEVEL2-9",
+    "norad": 63237,
+    "transponders": [
+      {
+        "label": "Mode V/U - FM Transponder",
+        "mode": "FM",
+        "down_lo": 436400000,
+        "up_lo": 145970000
+      }
+    ]
+  },
+  {
+    "name": "TO-108",
+    "norad": 44881,
+    "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": "UKUBE-1",
+    "norad": 40074,
+    "transponders": [
+      {
+        "label": "Inverting linear transponder",
+        "mode": "SSB",
+        "down_lo": 145930000,
+        "down_hi": 145950000,
+        "up_lo": 435074300,
+        "up_hi": 435094300,
+        "inverting": true
+      }
+    ]
+  },
+  {
+    "name": "XIWANG-1 (HOPE-1)",
+    "norad": 36122,
+    "transponders": [
+      {
+        "label": "Mode V/U FM",
+        "mode": "FM",
+        "down_lo": 435675000,
+        "up_lo": 145825000
+      }
+    ]
+  }
+]