chore: release v0.25.3

Same bug as yesterday's, one screen further on. The QSL Info table maps the
statuses it knows — Y, R, I, M — and falls through to "No" for anything else.
ADIF's V is anything else. So a contact confirmed AND validated by LoTW was
reported as not received, in the one place an operator opens to check.

V now has its own label, Verified, in the green of a confirmation, and it is in
the dropdown too. That second half matters more than it looks: a select whose
value is not among its items renders blank, so a verified contact looked like
nothing had been recorded — and the operator's next click would have replaced
the strongest confirmation they hold with whatever they picked instead.

The QSL Manager's bulk list is deliberately left alone: it sets paper QSL
status across a selection and defaults to "leave", so it never displays a
stored value, and "verified" is not something a paper card can be.

app.go

@@ -57,6 +57,7 @@ import (
 	"hamlog/internal/relaydev"
 	"hamlog/internal/rigctld"
 	"hamlog/internal/rotator/dcu1"
+	"hamlog/internal/rotator/spid"
 	"hamlog/internal/rotator/gs232"
 	"hamlog/internal/rotator/pst"
 	"hamlog/internal/rotgenius"
@@ -486,16 +487,21 @@ var defaultBands = []string{
 	"160m", "80m", "60m", "40m", "30m", "20m", "17m", "15m",
 	"12m", "10m", "6m", "2m", "70cm", "23cm",
 }
+
+// defaultModes is what a fresh install starts with — the modes most operators
+// actually use, in the order they are offered. AM and DIGITALVOICE are NOT here
+// on purpose: they stay in the Available catalogue for whoever wants them, but
+// a list that opens with nine entries when two are never touched costs a scroll
+// on every mode change.
 var defaultModes = []ModePreset{
 	{Name: "SSB", DefaultRSTSent: "59", DefaultRSTRcvd: "59"},
 	{Name: "CW", DefaultRSTSent: "599", DefaultRSTRcvd: "599"},
 	{Name: "FT8", DefaultRSTSent: "+00", DefaultRSTRcvd: "+00"},
 	{Name: "FT4", DefaultRSTSent: "+00", DefaultRSTRcvd: "+00"},
+	{Name: "FT2", DefaultRSTSent: "+00", DefaultRSTRcvd: "+00"},
 	{Name: "RTTY", DefaultRSTSent: "599", DefaultRSTRcvd: "599"},
 	{Name: "PSK31", DefaultRSTSent: "599", DefaultRSTRcvd: "599"},
-	{Name: "AM", DefaultRSTSent: "59", DefaultRSTRcvd: "59"},
 	{Name: "FM", DefaultRSTSent: "59", DefaultRSTRcvd: "59"},
-	{Name: "DIGITALVOICE", DefaultRSTSent: "59", DefaultRSTRcvd: "59"},
 }
 
 // Default RST report lists, editable in Settings → Modes. Phone carries the
@@ -646,6 +652,17 @@ type App struct {
 	// bounds itself by age instead, so memory follows how many distinct stations
 	// have actually been heard in two years rather than a made-up ceiling.
 	gridStore *gridcache.Store
+
+	// chaseNew holds the "new against the log" stations PSK Reporter is hearing
+	// near here; chaseNewOn is the option cached for the MQTT goroutine, which
+	// consults it once per message and must not reach the settings store.
+	chaseNew   *chaseNewStore
+	chaseNewOn atomic.Bool
+	// chaseBands is the operator's own band list, cached for the same reason:
+	// it decides whether a decode is an opportunity or a row in the way, and it
+	// is consulted once per message.
+	chaseBandsMu sync.RWMutex
+	chaseBands   map[string]bool
 	// pskr is the PSK Reporter MQTT feed, up only while the opening watch is on.
 	// It is the source that makes VHF detection work at all: the cluster and RBN
 	// carry a handful of 6 m spots where PSK Reporter carries hundreds.
@@ -1103,6 +1120,10 @@ func (a *App) startup(ctx context.Context) {
 			wruntime.EventsEmit(a.ctx, "cat:state", s)
 		}
 		a.emitRadioUDP(s)
+		// Custom outbound rows bound to a band change (antenna switches). The
+		// comparison against the last band lives in the helper, so this callback
+		// firing on every user-relevant change costs one string compare.
+		a.udpTriggerBandChange(s)
 		// Feed the frequency to any amplifier we are pretending to be a radio
 		// for. Just two atomic stores per amp — the reply itself is built when
 		// the amp polls, so a fast-tuning VFO costs nothing here.
@@ -1411,8 +1432,11 @@ func (a *App) startup(ctx context.Context) {
 	go a.chatLoop()        // multi-op: poll the shared chat + heartbeat presence
 	go a.hrdlogOnAirLoop() // publish frequency/mode/rig on hrdlog.net when enabled
 	// Locator store BEFORE the feed: the feed asks whether it exists to decide
-	// which bands to subscribe to.
+	// which bands to subscribe to. Same for the chase-new option, read into its
+	// atomic here so the feed and the MQTT goroutine agree from the first message.
 	a.startGridCache()
+	a.chaseNew = newChaseNewStore()
+	a.refreshChaseNew()
 	// PSK Reporter. After the operator's grid is known: without it there is no
 	// distance to measure and no receiver squares to filter on, so it stays down.
 	a.startBandOpenFeed()
@@ -2758,7 +2782,10 @@ func (a *App) AddQSO(q qso.QSO) (id int64, err error) {
 			a.maybeSelfSpot(qc)
 			a.publishSoon() // refresh the published web page, debounced
 			if a.udp != nil {
-				a.udp.EmitLoggedADIF(adif.SingleRecordADIF(qc))
+				rec := adif.SingleRecordADIF(qc)
+				a.udp.EmitLoggedADIF(rec)
+				a.udp.EmitLoggedQSOWSJT(wsjtLoggedQSO(qc), rec)
+				a.udpTriggerQSOLogged(qc)
 			}
 			// Nudge the grid again so the award_refs columns appear once materialised.
 			if a.ctx != nil {
@@ -6199,7 +6226,11 @@ type QSLBulkUpdate struct {
 	RcvdStatus string `json:"rcvd_status"` // Y|N|R|I — "" = unchanged
 	SentDate   string `json:"sent_date"`   // YYYYMMDD — "" = unchanged
 	RcvdDate   string `json:"rcvd_date"`   // YYYYMMDD — "" = unchanged
-	Via        string `json:"via"`         // QSL_VIA — "" = unchanged
+	// Via and RcvdVia are the ADIF QSL Via enumeration (B bureau / D direct /
+	// E electronic), NOT the manager — that is QSL_VIA and belongs on the QSO,
+	// not on a stack of cards being confirmed together. "" = unchanged.
+	Via     string `json:"via"`      // → QSL_SENT_VIA
+	RcvdVia string `json:"rcvd_via"` // → QSL_RCVD_VIA
 	Notes   string `json:"notes"`    // NOTES — "" = unchanged
 	Comment string `json:"comment"`  // COMMENT — "" = unchanged
 }
@@ -6238,6 +6269,12 @@ func (a *App) BulkUpdateQSL(ids []int64, u QSLBulkUpdate) (int, error) {
 		if v := adif.NormaliseQSLVia(u.Via); v != "" {
 			q.QSLSentVia, changed = v, true
 		}
+		// How the card CAME BACK. A stack confirmed together usually arrived the
+		// same way — a bureau delivery is exactly that — so it belongs here
+		// beside the received date rather than one QSO at a time in the editor.
+		if v := adif.NormaliseQSLVia(u.RcvdVia); v != "" {
+			q.QSLRcvdVia, changed = v, true
+		}
 		if v := strings.TrimSpace(u.Notes); v != "" {
 			q.Notes, changed = v, true
 		}
@@ -7131,6 +7168,13 @@ func (a *App) lookupCallsign(callsign string, force bool) (lookup.Result, error)
 		}
 	}
 	a.enrichFromULS(&r, callsign)
+	// Custom outbound rows bound to a lookup. After the enrichment, so a
+	// template sees the same grid and county the entry panel is about to show —
+	// two answers for one callsign is how a rotator ends up pointed elsewhere
+	// than the screen says.
+	if err == nil {
+		a.udpTriggerLookup(&r)
+	}
 	return r, err
 }
 
@@ -12174,7 +12218,10 @@ func (a *App) LogUDPLoggedADIF(adifText string) (int64, error) {
 		// path — otherwise a QSO logged FROM WSJT-X/JTDX/MSHV was never re-emitted
 		// to the outbound ADIF listeners (Log4OM, N1MM, gridtracker…).
 		if a.udp != nil {
-			a.udp.EmitLoggedADIF(adif.SingleRecordADIF(qc))
+			rec := adif.SingleRecordADIF(qc)
+			a.udp.EmitLoggedADIF(rec)
+			a.udp.EmitLoggedQSOWSJT(wsjtLoggedQSO(qc), rec)
+			a.udpTriggerQSOLogged(qc)
 		}
 		if a.ctx != nil {
 			wruntime.EventsEmit(a.ctx, "qso:logged", id) // refresh again so award_refs show
@@ -13359,7 +13406,7 @@ func flexPowerClass(mode string) string {
 		return "phone"
 	case "CW", "CWR":
 		return "cw"
-	case "FT8", "FT4", "JT65", "JT9", "JS8", "RTTY", "PSK", "PSK31", "PSK63",
+	case "FT8", "FT4", "FT2", "JT65", "JT9", "JS8", "RTTY", "PSK", "PSK31", "PSK63",
 		"BPSK", "QPSK", "MFSK", "OLIVIA", "CONTESTI", "DATA", "DIGITALVOICE",
 		"DIGU", "DIGL", "Q65", "MSK144", "WSPR", "FST4", "FST4W", "ARDOP", "VARA":
 		return "digi"
@@ -13962,6 +14009,10 @@ func (a *App) SaveListsSettings(l ListsSettings) error {
 			return err
 		}
 	}
+	// The Chase New feed filters on this list per message and reads it from a
+	// cache, so a band ticked here has to reach that cache now — otherwise it
+	// takes effect at the next restart, which looks like the option not working.
+	a.refreshChaseBands()
 	return nil
 }
 
@@ -14136,6 +14187,10 @@ type RotatorDevice struct {
 	Transport    string `json:"transport"`     // ARCO: "tcp" (LAN) | "serial" (USB COM)
 	ComPort      string `json:"com_port"`      // GS-232 serial transport
 	Baud         int    `json:"baud"`          // GS-232 serial baud (an ERC needs it; an ARCO ignores it)
+	// SpidModel picks the SPID dialect: "rot2prog" (RAS/BIG-RAS/MD-01/MD-02,
+	// azimuth + elevation) or "rot1prog" (the older azimuth-only controller).
+	// They differ in reply length and baud rate, so guessing is not an option.
+	SpidModel string `json:"spid_model,omitempty"`
 }
 
 // logicalRotor is one addressable rotor. Flattening the device list expands a
@@ -14148,7 +14203,7 @@ type logicalRotor struct {
 
 // normRotorType clamps a rotor type to a known backend.
 func normRotorType(t string) string {
-	if t == "rotgenius" || t == "arco" || t == "dcu1" {
+	if t == "rotgenius" || t == "arco" || t == "dcu1" || t == "spid" {
 		return t
 	}
 	return "pst"
@@ -14174,6 +14229,7 @@ func deviceLink(d RotatorDevice, sub int) rotorLink {
 	l := rotorLink{
 		Type: normRotorType(d.Type), Host: d.Host, Port: d.Port,
 		Transport: d.Transport, ComPort: d.ComPort, Baud: d.Baud, HasElevation: d.HasElevation,
+		SpidModel: d.SpidModel,
 	}
 	if l.Host == "" {
 		l.Host = "127.0.0.1"
@@ -14182,8 +14238,13 @@ func deviceLink(d RotatorDevice, sub int) rotorLink {
 		l.Port = rotatorDefaultPort(l.Type)
 	}
 	if l.Baud <= 0 {
+		// A SPID runs at 600 or 1200 baud depending on the dialect; 0 lets its
+		// driver pick, and forcing 9600 here would have made every controller
+		// mute for a reason nobody would guess.
+		if l.Type != "spid" {
 			l.Baud = 9600
 		}
+	}
 	if l.Transport != "serial" {
 		l.Transport = "tcp"
 	}
@@ -14318,6 +14379,7 @@ type rotorLink struct {
 	ComPort      string
 	Baud         int
 	HasElevation bool
+	SpidModel    string // SPID: "rot2prog" (default) | "rot1prog"
 }
 
 // activeRotorIndex returns the compass-selected rotor index, clamped to the
@@ -14365,6 +14427,22 @@ func dcu1Client(l rotorLink) *dcu1.Client {
 	return dcu1.New(l.Host, l.Port)
 }
 
+// spidClient builds the SPID (AlfaSpid) client for a rotor.
+//
+// Serial only, and that is the point: these controllers have a COM port and
+// nothing else. The request this answers was to drive them WITHOUT PstRotator
+// sitting in between, so there is no network transport to offer.
+//
+// Baud 0 lets the driver take the dialect's documented default — 600 baud for
+// Rot2Prog, 1200 for Rot1Prog. Those numbers look wrong and are not.
+func spidClient(l rotorLink) *spid.Client {
+	m := spid.Rot2Prog
+	if l.SpidModel == string(spid.Rot1Prog) {
+		m = spid.Rot1Prog
+	}
+	return spid.New(l.ComPort, l.Baud, m)
+}
+
 // RotatorHeading is the live antenna heading for the status bar and compass.
 type RotatorHeading struct {
 	Enabled bool   `json:"enabled"`
@@ -14431,6 +14509,16 @@ func (a *App) GetRotatorHeading() RotatorHeading {
 		base.Azimuth = az
 		base.Raw = raw
 		return base
+	case "spid":
+		az, _, herr := spidClient(link).Heading()
+		if herr != nil {
+			base.Raw = herr.Error()
+			return base
+		}
+		base.OK = true
+		base.Azimuth = az
+		base.Raw = fmt.Sprintf("%d°", az)
+		return base
 	case "dcu1":
 		az, raw, herr := dcu1Client(link).Heading()
 		if herr != nil {
@@ -14457,6 +14545,20 @@ func (a *App) GetRotatorHeading() RotatorHeading {
 // RotatorGoTo points the active rotor at the given azimuth (and optional
 // elevation if it is configured for it).
 func (a *App) RotatorGoTo(az int, el int) error {
+	return a.RotatorGoToPath(az, el, "")
+}
+
+// RotatorGoToPath is RotatorGoTo with the path that produced the bearing —
+// "SP", "LP", or "" when the caller has no opinion (the compass, a spot click).
+//
+// It exists for the custom outbound rows: an operator wanted the message to say
+// WHICH bearing was taken, and the azimuth alone cannot tell you — 137° is short
+// path to one station and long path to another.
+func (a *App) RotatorGoToPath(az int, el int, path string) error {
+	// The trigger fires on the COMMAND, before any rotor is required: an
+	// operator may drive a switch or a display from the bearing without owning a
+	// rotator at all, and the early return below would swallow it.
+	a.udpTriggerRotator(az, el, strings.ToUpper(strings.TrimSpace(path)))
 	lr, _, _, ok := a.activeRotor()
 	if !ok {
 		return fmt.Errorf("no rotator configured")
@@ -14467,6 +14569,8 @@ func (a *App) RotatorGoTo(az int, el int) error {
 		return rotgenius.New(link.Host, link.Port).GoTo(link.Num, az)
 	case "arco":
 		return arcoClient(link).GoTo(az)
+	case "spid":
+		return spidClient(link).GoTo(az, el)
 	case "dcu1":
 		return dcu1Client(link).GoTo(az)
 	default:
@@ -14486,6 +14590,8 @@ func (a *App) RotatorStop() error {
 		return rotgenius.New(link.Host, link.Port).Stop()
 	case "arco":
 		return arcoClient(link).Stop()
+	case "spid":
+		return spidClient(link).Stop()
 	case "dcu1":
 		return dcu1Client(link).Stop()
 	default:
@@ -14506,6 +14612,8 @@ func (a *App) RotatorPark() error {
 		return fmt.Errorf("park is a PstRotator feature; not available on the Rotator Genius")
 	case "arco":
 		return fmt.Errorf("park is a PstRotator feature; not available over the ARCO GS-232 link")
+	case "spid":
+		return fmt.Errorf("park is a PstRotator feature; a SPID controller has no park command")
 	case "dcu1":
 		return fmt.Errorf("park is a PstRotator feature; not available over the DCU-1 link")
 	default:
@@ -14546,6 +14654,15 @@ func testRotorLink(l rotorLink) error {
 		// GS-232 — without moving the antenna.
 		_, _, err := arcoClient(l).Heading()
 		return err
+	case "spid":
+		if strings.TrimSpace(l.ComPort) == "" {
+			return fmt.Errorf("select the SPID controller's COM port first")
+		}
+		// A status read proves the port, the baud rate and the dialect at once,
+		// without moving anything — and a wrong dialect shows up here as a reply
+		// of the wrong length rather than as an antenna that turns oddly later.
+		_, _, err := spidClient(l).Heading()
+		return err
 	case "dcu1":
 		if l.Transport == "serial" && strings.TrimSpace(l.ComPort) == "" {
 			return fmt.Errorf("select the DCU-1 controller's COM port first")
@@ -14571,26 +14688,39 @@ func boolStr(b bool) string {
 // StationDevice is one configured relay board for the Station Control tab.
 type StationDevice struct {
 	ID       string   `json:"id"`
-	Type     string   `json:"type"` // "webswitch" | "kmtronic" | "dingtian" | "denkovi" | "usbrelay"
+	Type     string   `json:"type"` // "webswitch" | "kmtronic" | "dingtian" | "denkovi" | "usbrelay" | "httpgen"
 	Name     string   `json:"name"`
 	Host     string   `json:"host"`               // IP for network boards; FTDI serial for denkovi; COM port for usbrelay
 	User     string   `json:"user,omitempty"`     // KMTronic HTTP auth; Dingtian HTTP session ID (blank = none)
 	Pass     string   `json:"pass,omitempty"`     // KMTronic HTTP auth; Dingtian relay password (0–9999)
 	Channels int      `json:"channels,omitempty"` // usbrelay/denkovi/dingtian: number of relays
 	Labels   []string `json:"labels"`             // per-relay label (index 0 = relay 1)
+
+	// Generic HTTP board only. Per-relay URLs win over the patterns, which is
+	// what lets a hand-made switch with nothing in common between its channels
+	// be described at all.
+	OnURLs  []string `json:"on_urls,omitempty"` // index 0 = relay 1
+	OffURLs []string `json:"off_urls,omitempty"`
+	OnPat   string   `json:"on_pattern,omitempty"` // fallback, {relay} substituted
+	OffPat  string   `json:"off_pattern,omitempty"`
 }
 
 // deviceRelayCount is the relay count for a configured device — fixed by type,
 // except the Denkovi (4 or 8) and the generic USB-serial board, whose channel
 // count the user picks.
 func deviceRelayCount(d StationDevice) int {
-	if d.Type == "usbrelay" || d.Type == "denkovi" || d.Type == "dingtian" {
+	if d.Type == "usbrelay" || d.Type == "denkovi" || d.Type == "dingtian" || d.Type == "httpgen" {
 		if d.Channels >= 1 {
 			return d.Channels
 		}
 		if d.Type == "dingtian" {
 			return 2 // the smallest board; the real count comes from its status reply
 		}
+		if d.Type == "httpgen" {
+			// A hand-made switch is usually two to four ways, and its URLs are
+			// typed one per relay — eight empty rows would be eight rows to read.
+			return 4
+		}
 		return 8
 	}
 	return relayCountFor(d.Type)
@@ -14724,7 +14854,7 @@ func (a *App) SaveStationDevices(devs []StationDevice) error {
 	}
 	for i := range devs {
 		switch devs[i].Type {
-		case "kmtronic", "dingtian", "denkovi", "usbrelay", "webswitch":
+		case "kmtronic", "dingtian", "denkovi", "usbrelay", "webswitch", "httpgen":
 			// known type — keep
 		default:
 			devs[i].Type = "webswitch"
@@ -15150,13 +15280,32 @@ func (a *App) startUltrabeam() {
 		go a.motorAnt.Stop()
 		a.motorAnt = nil
 	}
+	// Every way out of here used to be silent, which is how an antenna that had
+	// been working for three minutes went off the air with NOTHING in the log
+	// after the disconnection — the operator could not tell a deliberate stop
+	// from a lost port from a cleared setting.
 	s, err := a.GetUltrabeamSettings()
-	if err != nil || !s.Enabled {
+	if err != nil {
+		applog.Printf("antenna: not started — settings unavailable: %v", err)
+		return
+	}
+	if !s.Enabled {
+		applog.Printf("antenna: not started — turned off in Settings")
 		return
 	}
 	c := newMotorClient(s)
 	if c == nil {
-		return // not configured (missing host/COM)
+		if s.Transport == "serial" {
+			applog.Printf("antenna: %s not started — no serial port configured", s.Type)
+		} else {
+			applog.Printf("antenna: %s not started — no host configured", s.Type)
+		}
+		return
+	}
+	if s.Transport == "serial" {
+		applog.Printf("antenna: %s starting on %s @ %d baud", s.Type, s.COM, s.Baud)
+	} else {
+		applog.Printf("antenna: %s starting on %s:%d", s.Type, s.Host, s.Port)
 	}
 	a.motorAnt = c
 	_ = a.motorAnt.Start()
@@ -16525,7 +16674,72 @@ type WinkeyerSettings struct {
 
 // ListSerialPorts returns the available COM ports for the keyer dropdown.
 func (a *App) ListSerialPorts() ([]string, error) {
-	return winkeyer.ListPorts()
+	ports, err := winkeyer.ListPorts()
+	if err != nil {
+		return nil, err
+	}
+	return tidySerialPorts(ports), nil
+}
+
+// tidySerialPorts removes duplicates and puts the list in the order a human
+// reads it.
+//
+// Windows enumerates serial ports from HARDWARE\DEVICEMAP\SERIALCOMM, which maps
+// a DEVICE path to a COM name — so the same name legitimately appears twice when
+// two devices claim it. That happens with a driver uninstalled without cleaning
+// up after itself, and with virtual-port software. An operator saw COM1 and COM3
+// listed twice, and the dropdown showed "COM3COM3" as its value, because two
+// entries with the same value both counted as selected.
+//
+// The order is natural, not lexical: COM4 belongs between COM3 and COM8, and
+// listing it after COM9 is how a port gets overlooked on a machine with a dozen.
+// Anything not named COMn keeps its own alphabetical order, after them.
+//
+// A duplicate is worth a log line rather than silence: two devices holding one
+// COM name is also why one of them is "busy" when the other is opened, and that
+// is not something an operator can work out from a dropdown.
+func tidySerialPorts(ports []string) []string {
+	seen := make(map[string]bool, len(ports))
+	out := make([]string, 0, len(ports))
+	for _, p := range ports {
+		name := strings.TrimSpace(p)
+		if name == "" {
+			continue
+		}
+		key := strings.ToUpper(name)
+		if seen[key] {
+			applog.Printf("serial: %s is claimed by more than one device in the Windows port map — listing it once", name)
+			continue
+		}
+		seen[key] = true
+		out = append(out, name)
+	}
+	sort.SliceStable(out, func(i, j int) bool {
+		ni, oki := comPortNumber(out[i])
+		nj, okj := comPortNumber(out[j])
+		switch {
+		case oki && okj:
+			return ni < nj
+		case oki:
+			return true // COMn before anything else
+		case okj:
+			return false
+		}
+		return out[i] < out[j]
+	})
+	return out
+}
+
+// comPortNumber extracts n from "COMn", false for any other shape.
+func comPortNumber(s string) (int, bool) {
+	if len(s) <= 3 || !strings.EqualFold(s[:3], "COM") {
+		return 0, false
+	}
+	n, err := strconv.Atoi(s[3:])
+	if err != nil {
+		return 0, false
+	}
+	return n, true
 }
 
 // GetWinkeyerSettings returns the persisted keyer config (with sane defaults).
@@ -17016,6 +17230,40 @@ func (a *App) SaveSelfSpotSettings(s SelfSpotSettings) error {
 // Fires on the FIRST QSO of a frequency, then at most once per configured gap.
 // Called from both log paths (manual entry and UDP auto-log), off the critical
 // path — a cluster that is slow or down must never hold up logging.
+// spotCommentMax is the DX cluster comment field: 30 characters, and nodes
+// silently drop what does not fit.
+const spotCommentMax = 30
+
+// selfSpotComment builds the comment for a spot of OUR OWN station: the mode,
+// then the references WE are activating.
+//
+// MY_POTA_REF and friends, deliberately — not the QSO's award references, which
+// belong to the station we worked. Spotting yourself with the other operator's
+// park number announces you from a place you are not.
+//
+// A reference goes in whole or not at all: half a park number on the cluster is
+// worse than none, since nobody can act on it.
+func selfSpotComment(q qso.QSO) string {
+	out := strings.ToUpper(strings.TrimSpace(q.Mode))
+	for _, r := range []struct{ code, ref string }{
+		{"POTA", q.MyPOTARef},
+		{"SOTA", q.MySOTARef},
+		{"WWFF", q.MyWWFFRef},
+		{"IOTA", q.MyIOTA},
+	} {
+		ref := strings.ToUpper(strings.TrimSpace(r.ref))
+		if ref == "" {
+			continue
+		}
+		next := strings.TrimSpace(out + " " + r.code + " " + ref)
+		if len(next) > spotCommentMax {
+			continue // a shorter reference may still fit
+		}
+		out = next
+	}
+	return out
+}
+
 func (a *App) maybeSelfSpot(q qso.QSO) {
 	cfg, err := a.GetSelfSpotSettings()
 	if err != nil || !cfg.Enabled {
@@ -17051,7 +17299,7 @@ func (a *App) maybeSelfSpot(q qso.QSO) {
 	a.selfSpotMu.Unlock()
 
 	khz := math.Round(float64(hz)/100) / 10 // 0.1 kHz — the resolution a cluster keeps
-	if err := a.SendClusterSpot(call, khz, strings.ToUpper(strings.TrimSpace(q.Mode))); err != nil {
+	if err := a.SendClusterSpot(call, khz, selfSpotComment(q)); err != nil {
 		// Not sent (no enabled server, node not connected). Restore the previous
 		// state so the NEXT QSO tries again, instead of sitting out a gap that
 		// never produced a spot.
@@ -18076,3 +18324,39 @@ func (a *App) ampTargets(id string, linked []string) []string {
 	}
 	return out
 }
+
+// wsjtLoggedQSO maps a logged contact onto the fields a WSJT-X "QSO Logged"
+// message carries, for the outbound UDP row that speaks that protocol.
+//
+// TIME_OFF falls back to TIME_ON: the message has both, and a receiver that
+// files the contact by the end time would put a QSO with no recorded end at the
+// zero date — 1 January year 1, which is what a Julian day of zero means.
+func wsjtLoggedQSO(q qso.QSO) udp.LoggedQSO {
+	out := udp.LoggedQSO{
+		DXCall:       q.Callsign,
+		DXGrid:       q.Grid,
+		Mode:         q.Mode,
+		ReportSent:   q.RSTSent,
+		ReportRcvd:   q.RSTRcvd,
+		Comments:     q.Comment,
+		Name:         q.Name,
+		TimeOn:       q.QSODate.UTC(),
+		TimeOff:      q.QSODate.UTC(),
+		OperatorCall: q.Operator,
+		MyCall:       q.StationCallsign,
+		MyGrid:       q.MyGrid,
+		ExchangeSent: q.STXString,
+		ExchangeRcvd: q.SRXString,
+		PropMode:     q.PropMode,
+	}
+	if !q.QSODateOff.IsZero() {
+		out.TimeOff = q.QSODateOff.UTC()
+	}
+	if q.FreqHz != nil && *q.FreqHz > 0 {
+		out.TxFreqHz = uint64(*q.FreqHz)
+	}
+	if q.TXPower != nil && *q.TXPower > 0 {
+		out.TxPower = strconv.FormatFloat(*q.TXPower, 'f', -1, 64)
+	}
+	return out
+}

bandopen_sources.go

@@ -138,7 +138,10 @@ func (a *App) startBandOpenFeed() {
 		a.clearBandOpenings()
 	}
 	chaseGrids := a.gridStore != nil
-	if !s.Enabled && !chaseGrids {
+	chaseNew := a.chaseNewEnabled()
+	// Three consumers, one feed. Any one of them is reason enough to bring it up,
+	// and turning one off must not cut the others loose.
+	if !s.Enabled && !chaseGrids && !chaseNew {
 		return
 	}
 	// Every spot is measured from the operator's position. Without one there is
@@ -149,10 +152,11 @@ func (a *App) startBandOpenFeed() {
 		return
 	}
 
-	// Grid chasing wants every band; the opening watch wants its four. "+" is the
+	// Grid chasing and new-chasing want every band; the opening watch wants its
-	// MQTT single-level wildcard, so one subscription per square covers the lot.
+	// four. "+" is the MQTT single-level wildcard, so one subscription per square
+	// covers the lot.
 	bands := s.Bands
-	if chaseGrids {
+	if chaseGrids || chaseNew {
 		bands = []string{"+"}
 	}
 	// Filter at the BROKER on the receiver's square rather than receiving the
@@ -168,8 +172,13 @@ func (a *App) startBandOpenFeed() {
 		onGrid = func(call, grid string) { a.rememberDecodeGrid(call, grid, gridcache.SourceMQTT) }
 	}
 	var onSpot func(pskr.Spot)
-	if s.Enabled {
+	switch {
+	case s.Enabled && chaseNew:
+		onSpot = func(sp pskr.Spot) { a.feedBandOpen(sp); a.feedChaseNew(sp) }
+	case s.Enabled:
 		onSpot = a.feedBandOpen
+	case chaseNew:
+		onSpot = a.feedChaseNew
 	}
 
 	a.pskr = pskr.New(pskr.Config{
@@ -195,8 +204,8 @@ func (a *App) startBandOpenFeed() {
 		applog.Printf("pskr: feed did not start: %v", err)
 		return
 	}
-	applog.Printf("pskr: feed up — bands %v, %d receiver squares (openings=%v, grids=%v)",
+	applog.Printf("pskr: feed up — bands %v, %d receiver squares (openings=%v, grids=%v, chase-new=%v)",
-		bands, len(rxGrids), s.Enabled, chaseGrids)
+		bands, len(rxGrids), s.Enabled, chaseGrids, chaseNew)
 }
 
 // feedBandOpen hands one PSK Reporter decode to the detector.

changelog.json

@@ -1,4 +1,44 @@
 [
+  {
+    "version": "0.25.3",
+    "date": "",
+    "en": [
+      "Confirmations: a LoTW contact marked V (verified) counted for the awards but nowhere else — the band/mode matrix, the slot statistics, the row colours and the QSL Info table all read it as unconfirmed, the last one showing it as “No”. It now reads as Verified everywhere.",
+      "Rotators: SPID / AlfaSpid controllers are driven natively over their own COM port — Rot2Prog and Rot1Prog — so PstRotator is no longer needed in between. Two towers means two rotors, as before."
+    ],
+    "fr": [
+      "Confirmations : un contact LoTW marqué V (vérifié) comptait pour les diplômes et nulle part ailleurs — la matrice bande/mode, les statistiques de créneaux, la coloration des lignes et le tableau Infos QSL le lisaient comme non confirmé, le dernier l’affichant même « Non ». Il s’affiche désormais « Vérifié » partout.",
+      "Rotors : les contrôleurs SPID / AlfaSpid sont pilotés nativement par leur propre port COM — Rot2Prog et Rot1Prog — sans passer par PstRotator. Deux pylônes restent deux rotors, comme avant."
+    ]
+  },
+  {
+    "version": "0.25.2",
+    "date": "",
+    "en": [
+      "Send Spot: the comment now carries the award references after the mode — the ones you assigned (POTA, SOTA, IOTA…), not the DXCC, zone and prefix every reader works out from the callsign. A self-spot carries your OWN activation references.",
+      "Modes: a fresh install now starts with SSB, CW, FT8, FT4, FT2, RTTY, PSK31 and FM. AM and DIGITALVOICE stay in the available list but are no longer selected by default.",
+      "Chase new: a panel listing the stations PSK Reporter is hearing within about 300 km of you that are new against your log — on FT8, FT4, FT2, PSK31 and RTTY, and only on the bands you have selected. One badge per row, the most valuable first (entity, band, mode, slot, prefix, square), with a filter for each, a toolbar button to show it and a cross to close it. Click a row to put the callsign in the entry and tune the rig.",
+      "QSL Manager, paper QSL: the route is set per direction — bureau, direct or electronic, beside the sent status and beside the received one — and applies to the whole selection at once.",
+      "Connections (was “UDP integrations”): two new outbound services. “WSJT-X logged QSO” announces each contact on the WSJT-X UDP interface, both messages WSJT-X itself sends, for loggers that listen there rather than for plain-text ADIF (Logger32 among them). “Custom message” lets you choose what fires it — band change, QSO logged, rotator command, callsign lookup — and what it says, sent as a UDP datagram or an HTTP request.",
+      "Connections: everything sent is now written to the log. Outbound messages say where they went and, for custom ones, what they contained; a message that came out empty says so instead of vanishing; a password in a URL is hidden; and an ADIF listener sharing a port with a WSJT source now names that traffic once rather than a line per decode.",
+      "Station relays: new “HTTP relay” device for home-made and generic switches — an ON and an OFF URL, either one pattern with {relay} or one pair per relay, with a channel count from 1 to 16. It then follows the same per-band rules as the named boards.",
+      "Serial ports: a port claimed by two devices in the Windows port map was listed twice in every port dropdown, and showed as “COM3COM3”. Listed once now, and in natural order — COM4 between COM3 and COM8, not after COM9.",
+      "Motorized antenna: an antenna that lost its serial port stopped answering with nothing at all in the log, and a controller that settled somewhere other than where it was sent looked exactly the same. Both now say what happened, once.",
+      "Appearance: the Sahara theme is lighter, parchment rather than deep sand, with a terracotta accent."
+    ],
+    "fr": [
+      "Envoi de spot : le commentaire porte désormais les références de diplôme après le mode — celles que vous avez attribuées (POTA, SOTA, IOTA…), pas le DXCC, la zone et le préfixe que chacun déduit de l’indicatif. Un auto-spot porte VOS références d’activation.",
+      "Modes : une installation neuve démarre avec SSB, CW, FT8, FT4, FT2, RTTY, PSK31 et FM. AM et DIGITALVOICE restent dans la liste disponible mais ne sont plus sélectionnés par défaut.",
+      "Chasse au nouveau : un panneau listant les stations que PSK Reporter entend à moins de 300 km de chez vous et qui sont nouvelles par rapport à votre log — en FT8, FT4, FT2, PSK31 et RTTY, et seulement sur les bandes que vous avez sélectionnées. Une seule indication par ligne, la plus précieuse d’abord (entité, bande, mode, créneau, préfixe, carré), avec un filtre pour chacune, un bouton dans la barre pour l’afficher et une croix pour le fermer. Un clic met l’indicatif en saisie et accorde la radio.",
+      "Gestionnaire QSL, QSL papier : la voie se règle par sens — bureau, direct ou électronique, à côté du statut envoyé et à côté du statut reçu — et s’applique à toute la sélection d’un coup.",
+      "Connexions (ex-« Intégrations UDP ») : deux nouvelles sorties. « QSO enregistré WSJT-X » annonce chaque contact sur l’interface UDP WSJT-X, les deux messages que WSJT-X émet lui-même, pour les loggers qui écoutent là plutôt que l’ADIF en texte brut (Logger32 entre autres). « Message personnalisé » vous laisse choisir ce qui la déclenche — changement de bande, QSO enregistré, commande de rotor, recherche d’indicatif — et ce qu’elle dit, en datagramme UDP ou en requête HTTP.",
+      "Connexions : tout ce qui part est désormais inscrit au journal. Les messages sortants indiquent leur destination et, pour les personnalisés, leur contenu ; un message rendu vide le signale au lieu de disparaître ; un mot de passe dans une URL est masqué ; et un écouteur ADIF partageant un port avec une source WSJT nomme ce trafic une fois au lieu d’écrire une ligne par décodage.",
+      "Relais de station : nouveau périphérique « Relais HTTP » pour les commutateurs faits main ou génériques — une URL ON et une URL OFF, soit un modèle avec {relay}, soit une paire par relais, avec un nombre de voies de 1 à 16. Il suit ensuite les mêmes règles par bande que les cartes reconnues.",
+      "Ports série : un port revendiqué par deux périphériques dans la table Windows apparaissait en double dans toutes les listes, et s’affichait « COM3COM3 ». Une seule fois désormais, et dans l’ordre naturel — COM4 entre COM3 et COM8, pas après COM9.",
+      "Antenne motorisée : une antenne ayant perdu son port série cessait de répondre sans rien laisser dans le journal, et un contrôleur qui se fixait ailleurs que là où on l’avait envoyé ressemblait exactement à ça. Les deux disent maintenant ce qui s’est passé, une fois.",
+      "Apparence : le thème Sahara s’éclaircit, parchemin plutôt que sable profond, avec un accent terre cuite."
+    ]
+  },
   {
     "version": "0.25.1",
     "date": "",

cmd/dbdiag/main.go

@@ -109,9 +109,9 @@ func probeWB(conn *sql.DB, call string, dxcc int) {
         SELECT band, mode,
                MAX(CASE WHEN callsign = ? THEN 1 ELSE 0 END),
                MAX(CASE WHEN callsign = ?
-                         AND (lotw_rcvd = 'Y' OR qsl_rcvd = 'Y' OR eqsl_rcvd = 'Y')
+                         AND (lotw_rcvd IN ('Y','V') OR qsl_rcvd IN ('Y','V') OR eqsl_rcvd IN ('Y','V'))
                         THEN 1 ELSE 0 END),
-               MAX(CASE WHEN lotw_rcvd = 'Y' OR qsl_rcvd = 'Y' OR eqsl_rcvd = 'Y'
+               MAX(CASE WHEN lotw_rcvd IN ('Y','V') OR qsl_rcvd IN ('Y','V') OR eqsl_rcvd IN ('Y','V')
                         THEN 1 ELSE 0 END)
         FROM qso WHERE dxcc = ?
         GROUP BY band, mode

frontend/src/App.tsx

@@ -1,7 +1,7 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import {
   Activity, AlertCircle, Antenna, Bell, Check, CheckCircle2, ChevronDown, Clock, CloudOff, Compass, Database, Ear, Eraser, Flame, Gauge, Hash, Loader2, Lock,
-  Maximize2, Minimize2, Mic, MessageSquare, Pencil, Radio, RadioTower, RefreshCw, Satellite, Send, Settings, SlidersHorizontal, SpellCheck, Square, Terminal, Trash2, Unlock, X, Zap,
+  Maximize2, Minimize2, Mic, MessageSquare, Pencil, Radar, Radio, RadioTower, RefreshCw, Satellite, Send, Settings, SlidersHorizontal, SpellCheck, Square, Terminal, Trash2, Unlock, X, Zap,
 } from 'lucide-react';
 
 import {
@@ -17,6 +17,7 @@ import {
   SMTPConfigured, SendLogToDeveloper,
   WorkedBefore,
   SetCompactMode, SetCompactHeight,
+  RotatorGoToPath,
   GetCATState, SetCATFrequency, SetCATMode, SwitchCATRig, FlexApplyBandAntenna, FlexApplyBandPower,
   GetSecretStatus, UnlockSecrets,
   RefreshCtyDat, DownloadAllReferenceLists,
@@ -51,11 +52,11 @@ import {
   ReportLiveActivity, LiveLastQSOAgeSec,
   GetAmpStatuses, AmpOperate,
   GetFlexState, FlexAmpOperate,
-  GetPSKReporterStatus, GetLiveOpenings,
+  GetPSKReporterStatus, GetLiveOpenings, GetChaseNew,
   QSLViaRepairStatus, RepairQSLVia, DismissQSLViaRepair,
 } from '../wailsjs/go/main/App';
 import { Combobox } from '@/components/ui/combobox';
-import { applyAwardRefs } from '@/lib/awardRefs';
+import { applyAwardRefs, parseAwardRefs as parseManualRefs, spotRefList } from '@/lib/awardRefs';
 import { EventsOn, BrowserOpenURL, WindowMinimise, WindowToggleMaximise, WindowIsMaximised, Quit } from '../wailsjs/runtime/runtime';
 import type { adif as adifModels, lookup as lookupModels, cat as catModels } from '../wailsjs/go/models';
 import type { QSOForm, WorkedBeforeView, StationSettingsForm, ListsSettingsForm, ModePresetForm } from '@/types';
@@ -82,6 +83,7 @@ import { AntGeniusPanel, type AGStatus } from '@/components/AntGeniusPanel';
 import { TunerGeniusPanel, type TGStatus } from '@/components/TunerGeniusPanel';
 import { AmpWidget } from '@/components/AmpWidget';
 import { ScpPanel, type ScpResult } from '@/components/ScpPanel';
+import { ChaseNewPanel } from '@/components/ChaseNewPanel';
 import { FilterBuilder, type QueryFilter } from '@/components/FilterBuilder';
 import { AwardsPanel } from '@/components/AwardsPanel';
 import { StatsPanel } from '@/components/StatsPanel';
@@ -141,7 +143,9 @@ type CATState = Omit<catModels.RigState, 'convertValues'>;
 // threshold is bypassed while filtering — see buildActiveFilter).
 const FILTERED_LIMIT_CAP = 10000;
 const DEFAULT_BANDS = ['160m','80m','60m','40m','30m','20m','17m','15m','12m','10m','6m','2m','70cm','23cm'];
-const DEFAULT_MODES = ['SSB','CW','FT8','FT4','RTTY','PSK31','AM','FM','DIGITALVOICE'];
+// Mirrors defaultModes in app.go — the fallback used before the backend answers.
+// AM and DIGITALVOICE stay in the catalogue but are not offered by default.
+const DEFAULT_MODES = ['SSB','CW','FT8','FT4','FT2','RTTY','PSK31','FM'];
 // Modes the QSO recorder captures (phone only). Mirrors recordableMode() in
 // app.go — digital modes carry no useful audio, and CW has no DAX audio on Flex,
 // so neither is recorded (no REC badge / timer for them).
@@ -311,7 +315,7 @@ function modeAccent(mode?: string): string {
 type RSTLists = { phone: string[]; cw: string[]; digital: string[] };
 function rstCategory(mode: string): keyof RSTLists {
   const m = (mode || '').toUpperCase();
-  const digital = ['FT8', 'FT4', 'JT65', 'JT9', 'JS8', 'Q65', 'MSK144', 'FST4', 'FST4W', 'MFSK', 'OLIVIA', 'JT4', 'WSPR'];
+  const digital = ['FT8', 'FT4', 'FT2', 'JT65', 'JT9', 'JS8', 'Q65', 'MSK144', 'FST4', 'FST4W', 'MFSK', 'OLIVIA', 'JT4', 'WSPR'];
   if (digital.includes(m)) return 'digital';
   if (['CW', 'RTTY', 'PSK31', 'PSK63', 'PSK', 'PSK125'].includes(m)) return 'cw';
   return 'phone';
@@ -2084,21 +2088,49 @@ export default function App() {
   const [showAntGenius, setShowAntGenius] = useState(() => localStorage.getItem('opslog.showAntGenius') !== '0');
   const [showTuner, setShowTuner] = useState(() => localStorage.getItem('opslog.showTuner') !== '0');
   const [showScp, setShowScp] = useState(() => localStorage.getItem('opslog.showScp') !== '0');
+  // The Chase New widget follows its own setting rather than a local toggle: the
+  // panel is only meaningful while the PSK Reporter feed is up, and that is what
+  // the setting decides.
+  const [chaseNewOn, setChaseNewOn] = useState(false);
+  // The setting decides whether the feature exists; this decides whether the
+  // panel is on screen — the same split the Super Check Partial panel uses.
+  const [showChaseNew, setShowChaseNew] = useState(() => localStorage.getItem('opslog.showChaseNew') !== '0');
+  const refreshChaseNew = useCallback(() => { GetChaseNew().then(setChaseNewOn).catch(() => {}); }, []);
+  useEffect(() => { refreshChaseNew(); }, [refreshChaseNew]);
   const [showBeamOnMap, setShowBeamOnMap] = useState(() => localStorage.getItem('opslog.showBeamOnMap') !== '0');
 
   // Award code → scanned field (e.g. POTA→pota_ref, WWFF→wwff). Used to route
   // picked award references to the QSO field/extras each award actually reads.
   const awardFieldRef = useRef<Record<string, string>>({});
+  // The same map as state, because the spot comment has to be recomputed once it
+  // arrives — a ref would leave the first Send Spot of a session with no
+  // references at all, or with the computed ones it is meant to filter out.
+  const [awardFields, setAwardFields] = useState<Record<string, string>>({});
   useEffect(() => {
     GetAwardDefs()
       .then((defs) => {
         const m: Record<string, string> = {};
         for (const d of (defs ?? []) as any[]) m[String(d.code).toUpperCase()] = String(d.field || '').toLowerCase();
         awardFieldRef.current = m;
+        setAwardFields(m);
       })
       .catch(() => {});
   }, []);
 
+  // Award references offered to the Send Spot window, as cluster-ready strings.
+  //
+  // The entry panel holds them as "CODE@REF;CODE@REF" while the QSO is being
+  // typed; once it is logged they live on the row as the materialised award_refs
+  // object. Take the entry's when there is one — spotting usually happens with
+  // the station still in the field — and fall back to the last logged QSO, which
+  // is where the callsign and frequency defaults come from too.
+  const spotEntryRefs = useMemo(() => {
+    const entry = spotRefList(parseManualRefs(details.award_refs ?? ''), awardFields);
+    if (entry.length) return entry;
+    return spotRefList(parseAwardRefs(qsos[0]?.award_refs), awardFields);
+  }, [details.award_refs, qsos, awardFields]);
+
+
   // === Clock ===
   const [utcNow, setUtcNow] = useState('');
   useEffect(() => {
@@ -2617,6 +2649,9 @@ export default function App() {
         // case its one-shot fetch ran during the startup race (before the
         // backend was determined) and grabbed the wrong/stale value.
         GetDBConnectionInfo().then((i) => { if (alive) setDbConn(i as any); }).catch(() => {});
+        // Same race, same fix: the toolbar options were read once at mount,
+        // possibly before the profile was active, and a "no" then was final.
+        refreshChaseNew();
       } else if (!ok && alive && tries++ < 360) {
         // Quick retries at first (normal startup connects in ~2 s); then keep
         // trying for several minutes, because the very first migration against a
@@ -2629,7 +2664,7 @@ export default function App() {
     };
     attempt();
     return () => { alive = false; if (timer) window.clearTimeout(timer); };
-  }, [refresh]);
+  }, [refresh, refreshChaseNew]);
   useEffect(() => {
     (async () => {
       try {
@@ -2650,6 +2685,10 @@ export default function App() {
       loadStation();
       loadLists();
       loadCATCfg();
+      // Options the toolbar reads. At mount the database may still be opening,
+      // and a one-shot read then answers "off" for everything — which is why the
+      // Chase New button only appeared after a trip through Settings.
+      refreshChaseNew();
     })();
     // Poll the CAT state at launch until the rig reports a frequency: the
     // backend connects asynchronously and only PUSHES cat:state on change, so
@@ -5332,13 +5371,15 @@ export default function App() {
             {(() => {
               const p = dxPath;
               const disabled = !p;
-              const goto = (az: number) => RotatorGoTo(Math.round(az), -1).catch((err) => setError(String(err?.message ?? err)));
+              // The path is passed through so a custom outbound row can say which
+              // bearing was taken — 137° is short path to one station and long to another.
+              const goto = (az: number, path: 'SP' | 'LP') => RotatorGoToPath(Math.round(az), -1, path).catch((err) => setError(String(err?.message ?? err)));
               return (
                 <div className="inline-flex items-center rounded-full border border-info-border bg-info-muted overflow-hidden text-[11px] font-mono font-semibold">
                   <button
                     type="button"
                     disabled={disabled}
-                    onClick={() => p && goto(p.bearingShort)}
+                    onClick={() => p && goto(p.bearingShort, 'SP')}
                     title={p
                       ? `Rotate short-path · ${Math.round(p.distanceShort).toLocaleString()} km`
                       : (station.my_grid ? 'No remote grid' : 'Set your station grid in Preferences')}
@@ -5355,7 +5396,7 @@ export default function App() {
                   <button
                     type="button"
                     disabled={disabled}
-                    onClick={() => p && goto(p.bearingLong)}
+                    onClick={() => p && goto(p.bearingLong, 'LP')}
                     title={p ? `Rotate long-path · ${Math.round(p.distanceLong).toLocaleString()} km` : ''}
                     className={cn(
                       'px-1.5 py-0.5 border-l border-info-border text-[10px] transition-colors',
@@ -5551,6 +5592,20 @@ export default function App() {
                 <SpellCheck className="size-4" />
               </button>
             )}
+            {chaseNewOn && (
+              <button
+                type="button"
+                onClick={() => { const v = !showChaseNew; setShowChaseNew(v); writeUiPref('opslog.showChaseNew', v ? '1' : '0'); }}
+                title={showChaseNew ? `${t('chn.toggle')} — ${t('chn.close')}` : t('chn.toggle')}
+                className={cn(
+                  'relative inline-flex items-center justify-center size-7 rounded-md border transition-colors',
+                  showChaseNew ? 'border-success-border bg-success-muted text-success-muted-foreground hover:bg-success-muted'
+                    : 'border-border text-muted-foreground hover:bg-muted',
+                )}
+              >
+                <Radar className="size-4" />
+              </button>
+            )}
             {chatAvailable && (
               <button
                 type="button"
@@ -6070,7 +6125,7 @@ export default function App() {
       {/* Reserved free space to the right. The WinKeyer CW keyer and/or the
           Digital Voice Keyer take this slot when enabled (Log4OM-style);
           otherwise it shows the QRZ profile photo. */}
-      {!compact && (chatShown || wkEnabled || dvkEnabled || lookupResult?.image_url || (showRotor && (rotatorHeading.enabled || dxPath)) || (showAntGenius && agEnabled) || (showTuner && tgEnabled) || (showAmpWidget && ampSts.length > 0) || (showScp && scpEnabled) || (showLiveStations && dbConn?.backend === 'mysql')) && (
+      {!compact && (chatShown || wkEnabled || dvkEnabled || lookupResult?.image_url || (showRotor && (rotatorHeading.enabled || dxPath)) || (showAntGenius && agEnabled) || (showTuner && tgEnabled) || (showAmpWidget && ampSts.length > 0) || (showScp && scpEnabled) || (chaseNewOn && showChaseNew) || (showLiveStations && dbConn?.backend === 'mysql')) && (
         // relative + absolute inner (like the F1-F5 panel): a taller widget (e.g.
         // the DVK with Auto CQ) can't grow the row — the row height stays set by
         // the entry strip and each widget fills that height, scrolling inside.
@@ -6196,6 +6251,16 @@ export default function App() {
               />
             </div>
           )}
+          {chaseNewOn && showChaseNew && (
+            <div className="w-[420px] shrink-0 min-h-0">
+              {/* Same reflex as clicking a cluster spot: the callsign into the
+                  entry, and the rig onto the frequency it was decoded on. */}
+              <ChaseNewPanel onPick={(sp) => {
+                onCallsignInput(sp.call, { force: true });
+                if (sp.freq_hz) void tuneRigCAT(sp.freq_hz, sp.mode);
+              }} onClose={() => { setShowChaseNew(false); writeUiPref('opslog.showChaseNew', '0'); }} />
+            </div>
+          )}
           {dvkEnabled && (
             <div className="w-[320px] shrink-0 min-h-0">
               <DvkPanel
@@ -7216,6 +7281,9 @@ export default function App() {
               : (qsos[0]?.freq_hz ? Math.round((qsos[0].freq_hz / 1000) * 10) / 10 : 0)
         }
         defaultMode={mode || qsos[0]?.mode || ''}
+        // Award references: the ones on the QSO being entered, else those already
+        // logged for the last QSO — the same source the callsign above falls back to.
+        defaultRefs={spotEntryRefs}
         targetName={
           clusterServers
             .filter((s) => s.enabled)
@@ -7226,6 +7294,7 @@ export default function App() {
           freqKHz: q.freq_hz ? Math.round((q.freq_hz / 1000) * 10) / 10 : 0,
           mode: q.mode ?? '',
           band: q.band,
+          refs: spotRefList(parseAwardRefs(q.award_refs), awardFields),
         }))}
         onSend={async (call, freqKHz, comment) => {
           await SendClusterSpot(call, freqKHz, comment);
@@ -7239,7 +7308,7 @@ export default function App() {
       {showSettings && (
         <SettingsModal
           initialSection={settingsSection}
-          onClose={() => { setShowSettings(false); setSettingsSection(undefined); }}
+          onClose={() => { setShowSettings(false); setSettingsSection(undefined); refreshChaseNew(); }}
           onSaved={() => {
             loadStation(); loadLists(); loadCATCfg(); reloadWk(); refreshManualRecReady();
             // Drop the cached spot statuses. They are computed once per

frontend/src/components/AwardsPanel.tsx

@@ -7,6 +7,7 @@ import { Button } from '@/components/ui/button';
 import { Checkbox } from '@/components/ui/checkbox';
 import { Select, SelectTrigger, SelectValue, SelectContent, SelectItem } from '@/components/ui/select';
 import { cn } from '@/lib/utils';
+import { isQSLConfirmed } from '@/lib/qsl';
 import { AwardEditor } from '@/components/AwardEditor';
 import { useI18n } from '@/lib/i18n';
 import { writeUiPref } from '@/lib/uiPref';
@@ -818,7 +819,7 @@ function CellQSOModal({ code, cell, modeClass, onClose }: { code: string; cell:
                     <td className="py-1 pr-2 font-mono font-semibold">{q.callsign}</td>
                     <td className="py-1 pr-2">{q.band}</td>
                     <td className="py-1 pr-2">{q.mode}</td>
-                    <td className="py-1 pr-3 text-muted-foreground">{[q.lotw_rcvd === 'Y' && 'LoTW', q.qsl_rcvd === 'Y' && 'QSL', q.eqsl_rcvd === 'Y' && 'eQSL'].filter(Boolean).join(', ')}</td>
+                    <td className="py-1 pr-3 text-muted-foreground">{[isQSLConfirmed(q.lotw_rcvd) && 'LoTW', isQSLConfirmed(q.qsl_rcvd) && 'QSL', isQSLConfirmed(q.eqsl_rcvd) && 'eQSL'].filter(Boolean).join(', ')}</td>
                   </tr>
                 ))}
               </tbody>

frontend/src/components/BandSlotGrid.tsx

@@ -3,6 +3,7 @@ import { Star, Radio, Sunrise, Sunset, X, Loader2 } from 'lucide-react';
 import { Badge } from '@/components/ui/badge';
 import { cn } from '@/lib/utils';
 import { sunTimes } from '@/lib/sun';
+import { isQSLConfirmed } from '@/lib/qsl';
 import { BandSlotQSOs } from '../../wailsjs/go/main/App';
 import type { WorkedBeforeView } from '@/types';
 
@@ -426,7 +427,7 @@ function SlotQSOModal({ call, dxcc, entity, band, cls, onClose, onEdit }: {
               </thead>
               <tbody>
                 {rows.map((q, i) => {
-                  const cfm = q.lotw_rcvd === 'Y' || q.eqsl_rcvd === 'Y' || q.qsl_rcvd === 'Y';
+                  const cfm = isQSLConfirmed(q.lotw_rcvd) || isQSLConfirmed(q.eqsl_rcvd) || isQSLConfirmed(q.qsl_rcvd);
                   const mine = q.callsign === call;
                   return (
                     <tr key={q.id ?? i} className="border-t border-border/40 even:bg-muted/[0.06] hover:bg-primary/[0.06] transition-colors">

frontend/src/components/CallHistoryPanel.tsx

@@ -1,6 +1,7 @@
 import { Star } from 'lucide-react';
 import { Badge } from '@/components/ui/badge';
 import { useI18n } from '@/lib/i18n';
+import { isQSLConfirmed } from '@/lib/qsl';
 import type { WorkedBeforeView } from '@/types';
 
 type WorkedBefore = WorkedBeforeView;
@@ -97,10 +98,10 @@ export function CallHistoryPanel({ wb, busy, currentCall }: Props) {
                     <td className="px-2 py-1 font-mono border-b border-border/40 whitespace-nowrap">{e.rst_sent ?? ''}</td>
                     <td className="px-2 py-1 font-mono border-b border-border/40 whitespace-nowrap">{e.rst_rcvd ?? ''}</td>
                     <td className="px-2 py-1 border-b border-border/40 whitespace-nowrap text-muted-foreground">
-                      {e.lotw_rcvd === 'Y' && (
+                      {isQSLConfirmed(e.lotw_rcvd) && (
                         <span className="inline-block w-[14px] h-[14px] rounded text-center leading-[14px] text-[9px] font-bold text-info-foreground bg-info mr-0.5" title={t('chp.lotwRcvd')}>L</span>
                       )}
-                      {e.qsl_rcvd === 'Y' && (
+                      {isQSLConfirmed(e.qsl_rcvd) && (
                         <span className="inline-block w-[14px] h-[14px] rounded text-center leading-[14px] text-[9px] font-bold text-success-foreground bg-success mr-0.5" title={t('chp.bureauRcvd')}>B</span>
                       )}
                     </td>

frontend/src/components/ChaseNewPanel.tsx

@@ -0,0 +1,217 @@
+// ChaseNewPanel — the stations PSK Reporter is hearing NEAR HERE that are new
+// against the log.
+//
+// A DX cluster tells you what somebody chose to spot. This tells you what is
+// actually being decoded in your own region, which is a different and often
+// larger set: nobody spots the FT8 caller running ten watts from a rare square.
+//
+// The one thing an operator has to know, and the reason for the line at the
+// bottom: PSK Reporter carries DIGITAL MODES ONLY. An empty panel means nothing
+// new is being decoded on FT8/FT4/JS8 near here — not that the band is dead.
+import { useEffect, useMemo, useState } from 'react';
+import { Radar, Loader2, X } from 'lucide-react';
+import { useI18n } from '@/lib/i18n';
+import { markerColour } from '@/lib/spotMarkers';
+import { cn } from '@/lib/utils';
+import { GetChaseNewSpots } from '../../wailsjs/go/main/App';
+
+export interface ChaseNewSpot {
+  call: string;
+  band: string;
+  mode: string;
+  freq_hz?: number;
+  grid?: string;
+  country?: string;
+  cont?: string;
+  dist_km?: number;
+  bearing?: number;
+  status?: string;
+  new_pfx?: boolean;
+  new_grid?: boolean;
+  lotw?: boolean;
+  at: string;
+}
+
+interface Props {
+  // Tuning the rig to a row is the whole point — a station heard on 14.074 is
+  // only useful if you can get there in one click.
+  onPick?: (s: ChaseNewSpot) => void;
+  onClose?: () => void;
+}
+
+// The categories, in priority order. A station can be several at once — a new
+// band AND a new prefix — but a row shows ONE, the first that matches here.
+//
+// The order is by what would make an operator leave what they are doing: a new
+// entity beats a new band on it, which beats a new mode, which beats a new slot;
+// a prefix or a square is worth knowing but never worth interrupting a QSO for.
+// Two badges on one line also made the list unreadable at a glance, which is the
+// only thing this panel is for.
+type Category = 'dxcc' | 'band' | 'mode' | 'slot' | 'pfx' | 'grid';
+
+const CATEGORIES: Array<{ key: Category; labelKey: string; colour: string }> = [
+  { key: 'dxcc', labelKey: 'clg2.newDxcc', colour: 'var(--danger)' },
+  { key: 'band', labelKey: 'clg2.newBand', colour: 'var(--danger)' },
+  { key: 'mode', labelKey: 'clg2.newMode', colour: 'var(--danger)' },
+  { key: 'slot', labelKey: 'clg2.newSlot', colour: 'var(--danger)' },
+  { key: 'pfx', labelKey: 'clg2.newPfx', colour: markerColour('new_pfx') },
+  { key: 'grid', labelKey: 'clg2.newGrid', colour: markerColour('new_grid') },
+];
+
+// categoryOf is the single thing a row says about a station.
+function categoryOf(s: ChaseNewSpot): Category | null {
+  switch (s.status) {
+    case 'new': return 'dxcc';
+    case 'new-band': return 'band';
+    case 'new-mode': return 'mode';
+    case 'new-slot': return 'slot';
+  }
+  if (s.new_pfx) return 'pfx';
+  if (s.new_grid) return 'grid';
+  return null;
+}
+
+const FILTER_KEY = 'opslog.chaseNewFilters';
+
+function loadFilters(): Set<Category> {
+  try {
+    const raw = localStorage.getItem(FILTER_KEY);
+    if (raw) {
+      const list = JSON.parse(raw) as Category[];
+      if (Array.isArray(list)) return new Set(list);
+    }
+  } catch { /* a corrupt preference is not worth a broken panel */ }
+  return new Set(CATEGORIES.map((c) => c.key));
+}
+
+export function ChaseNewPanel({ onPick, onClose }: Props) {
+  const { t } = useI18n();
+  const [spots, setSpots] = useState<ChaseNewSpot[]>([]);
+  const [loaded, setLoaded] = useState(false);
+  const [on, setOn] = useState<Set<Category>>(loadFilters);
+
+  // Polled rather than pushed: the feed can deliver several a second under an
+  // opening, and an event per row would be a redraw per row for a list nobody
+  // reads that fast.
+  useEffect(() => {
+    let alive = true;
+    const tick = async () => {
+      try {
+        const r = ((await GetChaseNewSpots()) ?? []) as ChaseNewSpot[];
+        if (alive) { setSpots(r); setLoaded(true); }
+      } catch { /* the feed may not be up yet */ }
+    };
+    tick();
+    const id = window.setInterval(tick, 5000);
+    return () => { alive = false; window.clearInterval(id); };
+  }, []);
+
+  function toggle(k: Category) {
+    setOn((prev) => {
+      const next = new Set(prev);
+      if (next.has(k)) next.delete(k); else next.add(k);
+      try { localStorage.setItem(FILTER_KEY, JSON.stringify([...next])); } catch { /* not worth failing over */ }
+      return next;
+    });
+  }
+
+  const shown = useMemo(() => {
+    return spots.filter((s) => {
+      const c = categoryOf(s);
+      return c !== null && on.has(c);
+    });
+  }, [spots, on]);
+
+  return (
+    <div className="flex h-full flex-col rounded-md border border-border bg-card overflow-hidden">
+      <div className="flex items-center gap-2 border-b border-border px-2 py-1.5">
+        <Radar className="size-3.5 shrink-0 text-primary" />
+        <span className="shrink-0 text-xs font-semibold">{t('chn.title')}</span>
+
+        {/* Filters, in the same order and colours as the badges they hide. */}
+        <div className="flex flex-1 flex-wrap items-center gap-1">
+          {CATEGORIES.map((c) => (
+            <button
+              key={c.key}
+              type="button"
+              onClick={() => toggle(c.key)}
+              title={t('chn.filterHint')}
+              className={cn(
+                'rounded border px-1 py-px text-[9px] font-bold uppercase tracking-wide transition-colors',
+                on.has(c.key) ? 'border-transparent' : 'border-border text-muted-foreground opacity-50',
+              )}
+              style={on.has(c.key) ? { color: c.colour, borderColor: c.colour } : undefined}
+            >
+              {t(c.labelKey).replace(/^(NEW|NOUV)\s+/i, '')}
+            </button>
+          ))}
+        </div>
+
+        <span className="shrink-0 text-[10px] text-muted-foreground">
+          {loaded ? t('chn.count', { n: shown.length }) : ''}
+        </span>
+        {onClose && (
+          <button
+            type="button"
+            onClick={onClose}
+            title={t('chn.close')}
+            className="shrink-0 rounded p-0.5 text-muted-foreground hover:bg-muted hover:text-foreground"
+          >
+            <X className="size-3.5" />
+          </button>
+        )}
+      </div>
+
+      <div className="flex-1 overflow-y-auto">
+        {!loaded ? (
+          <div className="flex items-center justify-center gap-2 p-3 text-[11px] text-muted-foreground">
+            <Loader2 className="size-3 animate-spin" /> {t('chn.loading')}
+          </div>
+        ) : shown.length === 0 ? (
+          <p className="p-3 text-[11px] text-muted-foreground leading-relaxed">
+            {spots.length === 0 ? t('chn.empty') : t('chn.allFiltered')}
+          </p>
+        ) : (
+          <div className="divide-y divide-border/60">
+            {shown.map((s, i) => {
+              const c = categoryOf(s);
+              const def = CATEGORIES.find((x) => x.key === c);
+              return (
+                <button
+                  key={`${s.call}-${s.band}-${s.mode}-${i}`}
+                  type="button"
+                  onClick={() => onPick?.(s)}
+                  className="flex w-full items-center gap-1.5 px-2 py-1 text-left text-[11px] hover:bg-accent/40"
+                  title={[
+                    s.country,
+                    s.grid,
+                    s.dist_km ? `${s.dist_km} km` : '',
+                    s.freq_hz ? `${(s.freq_hz / 1000).toFixed(1)} kHz` : '',
+                  ].filter(Boolean).join(' · ')}
+                >
+                  <span className="w-[84px] shrink-0 truncate font-mono font-bold">{s.call}</span>
+                  <span className="w-9 shrink-0 font-mono text-muted-foreground">{s.band}</span>
+                  <span className="w-10 shrink-0 truncate text-muted-foreground">{s.mode}</span>
+                  {/* No frequency column: clicking the row tunes the rig to it,
+                      so the number was a thing to read and never to use. It is
+                      still carried on the spot — the click is what needs it —
+                      and shows in the row's tooltip for anyone who wants it.
+                      The country takes the space it freed. */}
+                  <span className="min-w-0 flex-1 truncate text-muted-foreground">{s.country ?? ''}</span>
+                  {def && (
+                    <span className="shrink-0 text-[9px] font-bold" style={{ color: def.colour }}>
+                      {t(def.labelKey)}
+                    </span>
+                  )}
+                  {s.lotw && <span className="shrink-0 text-[9px] text-info" title="LoTW">L</span>}
+                </button>
+              );
+            })}
+          </div>
+        )}
+      </div>
+
+      <p className="border-t border-border px-2 py-1 text-[10px] text-muted-foreground">{t('chn.digitalOnly')}</p>
+    </div>
+  );
+}

frontend/src/components/QSLManagerModal.tsx

@@ -54,7 +54,9 @@ const QSL_STATUSES = [
   { v: 'I', label: 'qslm.ignore' },
 ];
 
-// QSL routing methods for the paper-QSL "Via" dropdown (was free text).
+// QSL routing methods for the paper-QSL route dropdowns, one per direction.
+// These are the ADIF QSL Via enumeration (B/D/E) and go to QSL_SENT_VIA and
+// QSL_RCVD_VIA — NOT to QSL_VIA, which holds the manager's callsign.
 const QSL_VIA_OPTIONS = [
   { v: '_', label: 'qslm.leave' },
   { v: 'B', label: 'qslm.viaBureau' },
@@ -149,7 +151,8 @@ export function QSLManagerPanel({ onEditQSO }: { onEditQSO?: (id: number) => voi
   const [qslSent, setQslSent] = useState('_');
   const [qslRcvdDate, setQslRcvdDate] = useState('');
   const [qslSentDate, setQslSentDate] = useState('');
-  const [qslVia, setQslVia] = useState('_');
+  const [qslVia, setQslVia] = useState('_');       // how the card was SENT
+  const [qslRcvdVia, setQslRcvdVia] = useState('_'); // how it CAME BACK
   const [qslNotes, setQslNotes] = useState('');
   const [qslComment, setQslComment] = useState('');
 
@@ -181,6 +184,7 @@ export function QSLManagerPanel({ onEditQSO }: { onEditQSO?: (id: number) => voi
         sent_date: ymd(qslSentDate),
         rcvd_date: ymd(qslRcvdDate),
         via: qslVia === '_' ? '' : qslVia,
+        rcvd_via: qslRcvdVia === '_' ? '' : qslRcvdVia,
         notes: qslNotes,
         comment: qslComment,
       } as any);
@@ -553,6 +557,10 @@ export function QSLManagerPanel({ onEditQSO }: { onEditQSO?: (id: number) => voi
       {/* Paper-QSL apply form */}
       {service === 'paper' && (
         <div className="flex items-end flex-wrap gap-3 px-3 py-2 border-t border-border bg-muted/20 shrink-0">
+          {/* Each direction carries its own route, and each sits with the status
+              and date it belongs to. A stack confirmed in one go usually arrived
+              the same way — a bureau delivery is exactly that — which is why the
+              route belongs on this form and not one QSO at a time in the editor. */}
           <div className="flex flex-col gap-1">
             <label className="text-[10px] uppercase tracking-wider text-muted-foreground">{t('qslm.qslReceived')}</label>
             <div className="flex gap-1.5">
@@ -561,6 +569,10 @@ export function QSLManagerPanel({ onEditQSO }: { onEditQSO?: (id: number) => voi
                 <SelectContent>{QSL_STATUSES.map((s) => <SelectItem key={s.v} value={s.v}>{t(s.label)}</SelectItem>)}</SelectContent>
               </Select>
               <Input type="date" className="h-8 w-36" value={qslRcvdDate} onChange={(e) => setQslRcvdDate(e.target.value)} title={t('qslm.qslRcvdDateTitle')} />
+              <Select value={qslRcvdVia} onValueChange={setQslRcvdVia}>
+                <SelectTrigger className="h-8 w-32" title={t('qslm.rcvdViaTitle')}><SelectValue /></SelectTrigger>
+                <SelectContent>{QSL_VIA_OPTIONS.map((o) => <SelectItem key={o.v} value={o.v}>{t(o.label)}</SelectItem>)}</SelectContent>
+              </Select>
             </div>
           </div>
           <div className="flex flex-col gap-1">
@@ -571,15 +583,12 @@ export function QSLManagerPanel({ onEditQSO }: { onEditQSO?: (id: number) => voi
                 <SelectContent>{QSL_STATUSES.map((s) => <SelectItem key={s.v} value={s.v}>{t(s.label)}</SelectItem>)}</SelectContent>
               </Select>
               <Input type="date" className="h-8 w-36" value={qslSentDate} onChange={(e) => setQslSentDate(e.target.value)} title={t('qslm.qslSentDateTitle')} />
-            </div>
-          </div>
-          <div className="flex flex-col gap-1">
-            <label className="text-[10px] uppercase tracking-wider text-muted-foreground">{t('qslm.via')}</label>
               <Select value={qslVia} onValueChange={setQslVia}>
-              <SelectTrigger className="h-8 w-32"><SelectValue /></SelectTrigger>
+                <SelectTrigger className="h-8 w-32" title={t('qslm.sentViaTitle')}><SelectValue /></SelectTrigger>
                 <SelectContent>{QSL_VIA_OPTIONS.map((o) => <SelectItem key={o.v} value={o.v}>{t(o.label)}</SelectItem>)}</SelectContent>
               </Select>
             </div>
+          </div>
           <div className="flex flex-col gap-1">
             <label className="text-[10px] uppercase tracking-wider text-muted-foreground">{t('qslm.notes')}</label>
             <Input className="h-8 w-40" value={qslNotes} onChange={(e) => setQslNotes(e.target.value)} placeholder={t('qslm.notesPlaceholder')} />

frontend/src/components/QSOEditModal.tsx

@@ -41,9 +41,14 @@ function pfxOf(call: string): string {
 const BANDS = ['2190m','630m','160m','80m','60m','40m','30m','20m','17m','15m','12m','10m','6m','4m','2m','1.25m','70cm','33cm','23cm','13cm','9cm','6cm','3cm','1.25cm','6mm','4mm','2.5mm','2mm','1mm'];
 const MODES = ['SSB','CW','FT8','FT4','RTTY','PSK31','AM','FM','DIGITALVOICE','MFSK','OLIVIA','JS8','JT65','JT9'];
 // label holds an i18n key (resolved with t() at render time).
+// V is in the list because the log HOLDS it: a LoTW download writes "verified"
+// rather than "yes". A dropdown without it renders a verified contact as blank,
+// which reads as "nothing recorded" — and the operator's next click would replace
+// the strongest confirmation they have with whatever they picked instead.
 const QSL_STATUSES = [
   { value: '_', label: 'qedit.qslDash' },
   { value: 'Y', label: 'qedit.qslYes' },
+  { value: 'V', label: 'qedit.qslVerified' },
   { value: 'N', label: 'qedit.qslNo'  },
   { value: 'R', label: 'qedit.qslRequested' },
   { value: 'I', label: 'qedit.qslIgnore' },
@@ -99,9 +104,14 @@ function StatusCell({ value }: { value?: string }) {
   //                       every row; painting that orange (as it used to be, in the
   //                       same orange as Requested) made the table shout about a
   //                       non-problem and told you nothing apart.
+  //   Verified  green   — ADIF's V: confirmed AND validated by the awarding body.
+  //                       It is what a LoTW download writes, and this table used
+  //                       to fall through to "No" for it — reporting a verified
+  //                       contact as unconfirmed, in the one place an operator
+  //                       goes to check.
   //   Ignore    dashed  — deliberately excluded, on purpose.
-  const label = v === 'Y' ? t('qedit.qslYes') : v === 'R' ? t('qedit.qslRequested') : v === 'I' ? t('qedit.qslIgnore') : v === 'M' ? t('qedit.statusModified') : t('qedit.qslNo');
+  const label = v === 'Y' ? t('qedit.qslYes') : v === 'V' ? t('qedit.qslVerified') : v === 'R' ? t('qedit.qslRequested') : v === 'I' ? t('qedit.qslIgnore') : v === 'M' ? t('qedit.statusModified') : t('qedit.qslNo');
-  const cls = v === 'Y' ? 'bg-success text-success-foreground border border-success'
+  const cls = v === 'Y' || v === 'V' ? 'bg-success text-success-foreground border border-success'
     : v === 'R' ? 'bg-info-muted text-info-muted-foreground border border-info-border'
     : v === 'M' ? 'bg-warning text-warning-foreground border border-warning'
     : v === 'I' ? 'bg-muted text-muted-foreground border border-dashed border-border italic'

frontend/src/components/SendSpotModal.tsx

@@ -13,6 +13,32 @@ export interface RecentSpotQSO {
   freqKHz: number;
   mode: string;
   band?: string;
+  // Award references logged for this QSO, each one complete and ready to read
+  // on a cluster line ("POTA FR-11553"). Empty for an ordinary contact.
+  refs?: string[];
+}
+
+// SPOT_COMMENT_MAX is the DX cluster comment field: 30 characters, and nodes
+// truncate what does not fit without saying so. Only the comment BUILT here is
+// held to it — whatever the operator types is their own business.
+const SPOT_COMMENT_MAX = 30;
+
+// spotComment puts the award references after the mode, the order a cluster
+// line is read in: "CW POTA FR-11553".
+//
+// A reference goes in whole or not at all. Truncation would leave "CW POTA" or
+// half a park number on the air, which is worse than saying nothing: a spot
+// nobody can act on still costs everyone who reads it.
+export function spotComment(mode: string, refs?: string[]): string {
+  let out = (mode || '').trim();
+  for (const ref of refs ?? []) {
+    const one = ref.trim();
+    if (!one) continue;
+    const next = out ? `${out} ${one}` : one;
+    if (next.length > SPOT_COMMENT_MAX) continue; // a shorter one may still fit
+    out = next;
+  }
+  return out;
 }
 
 interface Props {
@@ -23,6 +49,9 @@ interface Props {
   defaultCall: string;
   defaultFreqKHz: number;
   defaultMode: string;
+  // Award references on the QSO being entered (or on the last logged one),
+  // appended to the comment after the mode.
+  defaultRefs?: string[];
   // Master cluster name, shown so the user knows where the spot goes.
   targetName?: string;
   recent: RecentSpotQSO[];
@@ -33,7 +62,7 @@ interface Props {
 // the master cluster: callsign + frequency (kHz) + a free message (defaults
 // to the mode). A "Latest QSOs" list lets the operator one-click a recent
 // contact into the form.
-export function SendSpotModal({ open, onClose, defaultCall, defaultFreqKHz, defaultMode, targetName, recent, onSend }: Props) {
+export function SendSpotModal({ open, onClose, defaultCall, defaultFreqKHz, defaultMode, defaultRefs, targetName, recent, onSend }: Props) {
   const { t } = useI18n();
   const [call, setCall] = useState('');
   const [freqKHz, setFreqKHz] = useState('');
@@ -48,12 +77,12 @@ export function SendSpotModal({ open, onClose, defaultCall, defaultFreqKHz, defa
     if (!open) return;
     setCall((defaultCall || '').toUpperCase());
     setFreqKHz(defaultFreqKHz > 0 ? trimKHz(defaultFreqKHz) : '');
-    setMessage(defaultMode || '');
+    setMessage(spotComment(defaultMode, defaultRefs));
     setError('');
     setOk(false);
     // Focus the freq if the call is already known, else the call.
     setTimeout(() => callRef.current?.focus(), 50);
-  }, [open, defaultCall, defaultFreqKHz, defaultMode]);
+  }, [open, defaultCall, defaultFreqKHz, defaultMode, defaultRefs]);
 
   async function send() {
     const c = call.trim().toUpperCase();
@@ -77,7 +106,7 @@ export function SendSpotModal({ open, onClose, defaultCall, defaultFreqKHz, defa
   function pick(q: RecentSpotQSO) {
     setCall(q.callsign.toUpperCase());
     if (q.freqKHz > 0) setFreqKHz(trimKHz(q.freqKHz));
-    if (q.mode) setMessage(q.mode);
+    setMessage(spotComment(q.mode, q.refs));
     setError('');
   }
 

frontend/src/components/SettingsModal.tsx

@@ -52,7 +52,7 @@ import {
   GetADIFMonitor, SaveADIFMonitor, PickADIFMonitorFile,
   GetRelayAuto, SaveRelayAuto, GetStationDevices,
   GetAwardDefs, GetTrackedAwards, SaveTrackedAwards,
-  GetBandOpenSettings, SaveBandOpenSettings, GetPSKReporterStatus, GetChaseNewGrids, SetChaseNewGrids, GetGridCacheStatus, GetLinkedAmps, SetLinkedAmps, GetSpotTTLMinutes, SetSpotTTLMinutes,
+  GetBandOpenSettings, SaveBandOpenSettings, GetPSKReporterStatus, GetChaseNewGrids, SetChaseNewGrids, GetChaseNew, SetChaseNew, GetGridCacheStatus, GetLinkedAmps, SetLinkedAmps, GetSpotTTLMinutes, SetSpotTTLMinutes,
 } from '../../wailsjs/go/main/App';
 import type { profile as profileModels } from '../../wailsjs/go/models';
 import type { LookupSettingsForm, StationSettingsForm, ListsSettingsForm, ModePresetForm } from '@/types';
@@ -109,6 +109,7 @@ const MODE_CATALOG: Array<{ name: string; sent: string; rcvd: string }> = [
   { name: 'DIGITALVOICE', sent: '59',  rcvd: '59'  },
   { name: 'FT8',          sent: '-10', rcvd: '-10' },
   { name: 'FT4',          sent: '-10', rcvd: '-10' },
+  { name: 'FT2',          sent: '-10', rcvd: '-10' },
   { name: 'JS8',          sent: '-10', rcvd: '-10' },
   { name: 'MSK144',       sent: '+00', rcvd: '+00' },
   { name: 'JT65',         sent: '-15', rcvd: '-15' },
@@ -412,7 +413,7 @@ const THEME_SWATCH: Record<Exclude<ThemeChoice, 'auto'>, { bg: string; card: str
   'light-warm':    { bg: '#e8dfc9', card: '#faf6ea', accent: '#b8410c' },
   'light-cool':    { bg: '#f4f6f8', card: '#ffffff', accent: '#2563eb' },
   'light-sage':    { bg: '#eef1ec', card: '#f8faf6', accent: '#2f855a' },
-  'sahara':        { bg: '#dcceab', card: '#faf6eb', accent: '#a55f14' },
+  'sahara':        { bg: '#e6ded0', card: '#f3eee2', accent: '#c4501e' },
   'light-nordic':  { bg: '#eef1f7', card: '#ffffff', accent: '#4f46e5' },
   'dim-slate':     { bg: '#343b47', card: '#3d4552', accent: '#fb923c' },
   'dark-warm':     { bg: '#221d18', card: '#2e2820', accent: '#e07a2e' },
@@ -700,7 +701,13 @@ const MOTOR_BAND_DEFAULT_KHZ: Record<string, number> = {
   '40m': 7100, '30m': 10125, '20m': 14150, '17m': 18110,
   '15m': 21150, '12m': 24930, '10m': 28400, '6m': 50150,
 };
-const relayCountUI = (type: string) => (type === 'kmtronic' || type === 'denkovi' ? 8 : 5);
+// Fallback only: the rule editor sizes itself from the device's labels, which
+// SaveStationDevices already normalises to the real relay count. This is what it
+// falls back to when a device somehow has none, so it only needs to be in the
+// right neighbourhood — but it is the third place that counts relays, and the
+// first two disagreeing is what pinned the HTTP board at four.
+const relayCountUI = (type: string) =>
+  type === 'kmtronic' || type === 'denkovi' ? 8 : type === 'httpgen' ? 4 : 5;
 
 // Live status + OPERATE/STANDBY toggle for ONE configured amplifier (by config
 // id) — SPE / ACOM / PGXL alike. Module-scoped (not a nested component) so it
@@ -1561,6 +1568,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   // feed up or down — so the write has to go where those live.
   const [bandOpen, setBandOpen] = useState<any>({ enabled: false, bands: [], available: [] });
   const [chaseGrids, setChaseGrids] = useState(false);
+  const [chaseNew, setChaseNew] = useState(false);
   const [spotTTL, setSpotTTL] = useState(0);
   const [spotTTLText, setSpotTTLText] = useState('0');
   const [gridStat, setGridStat] = useState<any>(null);
@@ -1573,6 +1581,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     (async () => {
       try { setBandOpen(await GetBandOpenSettings()); } catch { /* defaults stand */ }
       try { setChaseGrids(await GetChaseNewGrids()); } catch { /* defaults stand */ }
+      try { setChaseNew(await GetChaseNew()); } catch { /* defaults stand */ }
       try { setLinkedAmps((await GetLinkedAmps()) ?? []); } catch { /* defaults stand */ }
       try { const n = await GetSpotTTLMinutes(); setSpotTTL(n); setSpotTTLText(String(n)); } catch { /* defaults stand */ }
     })();
@@ -3665,7 +3674,10 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             const isRG = dev.type === 'rotgenius';
             const isARCO = dev.type === 'arco';
             const isDCU1 = dev.type === 'dcu1';
-            const isSerialCap = isARCO || isDCU1; // COM-port or serial-over-IP controllers
+            // A SPID has a COM port and nothing else — no network transport to
+            // offer, which is the whole point of driving it without PstRotator.
+            const isSPID = dev.type === 'spid';
+            const isSerialCap = isARCO || isDCU1 || isSPID; // COM-port or serial-over-IP controllers
             const transport = dev.transport ?? 'tcp';
             return (
               <div key={dev.id || i} className="rounded-xl border border-border bg-card/40 p-3 space-y-3">
@@ -3684,13 +3696,14 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                     {/* Each backend gets its default port: Rotator Genius 9006, ARCO 4001
                         (placeholder — must match the ARCO's LAN menu), PstRotator 12000. */}
                     <Select value={dev.type ?? 'pst'}
-                      onValueChange={(v) => patch(i, { type: v as any, port: v === 'rotgenius' ? 9006 : (v === 'arco' || v === 'dcu1') ? 4001 : 12000, ...(v === 'dcu1' ? { transport: 'serial' } : {}) })}>
+                      onValueChange={(v) => patch(i, { type: v as any, port: v === 'rotgenius' ? 9006 : (v === 'arco' || v === 'dcu1') ? 4001 : 12000, ...(v === 'dcu1' || v === 'spid' ? { transport: 'serial' } : {}), ...(v === 'spid' ? { baud: 600, spid_model: 'rot2prog' } : {}) })}>
                       <SelectTrigger className="h-9"><SelectValue /></SelectTrigger>
                       <SelectContent>
                         <SelectItem value="pst">PstRotator (UDP)</SelectItem>
                         <SelectItem value="rotgenius">Rotator Genius (4O3A, native)</SelectItem>
                         <SelectItem value="arco">GS-232A controller (microHAM ARCO, ERC…)</SelectItem>
                         <SelectItem value="dcu1">Hy-Gain DCU-1 (RotorCard DXA, Rotor-EZ, Green Heron)</SelectItem>
+                        <SelectItem value="spid">SPID / AlfaSpid (RAS, BIG-RAS, MD-01, MD-02)</SelectItem>
                       </SelectContent>
                     </Select>
                   </div>
@@ -3707,8 +3720,24 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                       </Select>
                     </div>
                   )}
+                  {/* SPID: pick the dialect. They differ in reply length AND baud
+                      rate, so this cannot be detected — a wrong choice is a
+                      controller that never answers. */}
+                  {isSPID && (
+                    <div className="space-y-1">
+                      <Label>{t('rot.spidModel')}</Label>
+                      <Select value={dev.spid_model || 'rot2prog'}
+                        onValueChange={(v) => patch(i, { spid_model: v as any, baud: v === 'rot1prog' ? 1200 : 600 })}>
+                        <SelectTrigger className="h-9"><SelectValue /></SelectTrigger>
+                        <SelectContent>
+                          <SelectItem value="rot2prog">Rot2Prog (RAS, BIG-RAS/HR, MD-01, MD-02)</SelectItem>
+                          <SelectItem value="rot1prog">Rot1Prog (azimuth only)</SelectItem>
+                        </SelectContent>
+                      </Select>
+                    </div>
+                  )}
                   {/* ARCO and DCU-1 controllers reach over the LAN (TCP) or a serial COM. */}
-                  {isSerialCap && (
+                  {isSerialCap && !isSPID && (
                     <div className="space-y-1">
                       <Label>Connection</Label>
                       <Select value={transport} onValueChange={(v) => patch(i, { transport: v as any })}>
@@ -3742,10 +3771,13 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                       <Button size="sm" variant="outline" className="h-9" onClick={() => ListSerialPorts().then((p) => setWkPorts((p ?? []) as string[])).catch(() => {})}>
                         <ArrowDown className="size-3.5 rotate-90" />
                       </Button>
-                      <Select value={String(dev.baud || 9600)} onValueChange={(v) => patch(i, { baud: Number(v) })}>
+                      {/* A SPID runs at 600 or 1200 baud — not a typo, a pulse
+                          controller has nothing to say quickly. Offering only the
+                          usual rates would have left it permanently mute. */}
+                      <Select value={String(dev.baud || (isSPID ? 600 : 9600))} onValueChange={(v) => patch(i, { baud: Number(v) })}>
                         <SelectTrigger className="h-9 w-28"><SelectValue /></SelectTrigger>
                         <SelectContent>
-                          {[4800, 9600, 19200, 38400, 57600].map((b) => (
+                          {(isSPID ? [600, 1200, 2400, 4800, 9600] : [4800, 9600, 19200, 38400, 57600]).map((b) => (
                             <SelectItem key={b} value={String(b)}>{b} baud</SelectItem>
                           ))}
                         </SelectContent>
@@ -3775,6 +3807,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                 {isRG && <p className="text-xs text-muted-foreground">{t('rot.rgHint')}</p>}
                 {isARCO && <p className="text-xs text-muted-foreground">{t('rot.arcoHint')}</p>}
                 {isDCU1 && <p className="text-xs text-muted-foreground">{t('rot.dcu1Hint')}</p>}
+                {isSPID && <p className="text-xs text-muted-foreground">{t('rot.spidHint')}</p>}
                 {/* Which antenna this rotor carries — only relevant with >1 rotor. */}
                 {multi && (
                   <div className="space-y-1 max-w-xs">
@@ -4338,6 +4371,17 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             )}
           </div>
 
+          {/* Chase new — its own option, NOT nested under grid chasing. Chasing
+              squares and chasing entities are different wants; they only share
+              the PSK Reporter feed, which either one brings up. */}
+          <div className="border-t border-border/60 pt-3 space-y-2">
+            <label className="flex items-start gap-2 text-sm cursor-pointer">
+              <Checkbox checked={chaseNew} className="mt-0.5"
+                onCheckedChange={(c) => { setChaseNew(!!c); SetChaseNew(!!c).catch(() => {}); }} />
+              <span>{t('chn.option')} <span className="text-xs text-muted-foreground">{t('chn.optionHelp')}</span></span>
+            </label>
+          </div>
+
           {/* Band-opening watch. It lives HERE, with the cluster nodes, because
               switching it on adds two of them — the operator should see that
               happen where it happens rather than find nodes they did not add. */}

frontend/src/components/StationControlPanel.tsx

@@ -23,7 +23,12 @@ import {
 
 type RotatorProps = { centerLat?: number | null; centerLon?: number | null; bearing?: number | null };
 
-type Device = { id: string; type: string; name: string; host: string; user?: string; pass?: string; channels?: number; labels: string[] };
+type Device = {
+  id: string; type: string; name: string; host: string;
+  user?: string; pass?: string; channels?: number; labels: string[];
+  // Generic HTTP board only. The per-relay URLs win over the patterns.
+  on_urls?: string[]; off_urls?: string[]; on_pattern?: string; off_pattern?: string;
+};
 type Relay = { number: number; label: string; on: boolean };
 type DevStatus = { id: string; name: string; type: string; connected: boolean; error?: string; relays: Relay[] };
 
@@ -34,14 +39,20 @@ type DevStatus = { id: string; name: string; type: string; connected: boolean; e
 const CARD_MIN = 430; // narrowest a card may get before "Auto" drops a column
 const GRID_GAP = 16; // px between cards, both axes
 
-const RELAY_COUNT: Record<string, number> = { webswitch: 5, kmtronic: 8, denkovi: 8, usbrelay: 8, dingtian: 2 };
+const RELAY_COUNT: Record<string, number> = { webswitch: 5, kmtronic: 8, denkovi: 8, usbrelay: 8, dingtian: 2, httpgen: 4 };
-const TYPE_LABEL: Record<string, string> = { webswitch: 'WebSwitch 1216H', kmtronic: 'KMTronic 8-relay', denkovi: 'Denkovi USB (FT245)', usbrelay: 'Denkovi USB (serial)', dingtian: 'Dingtian IOT relay' };
+const TYPE_LABEL: Record<string, string> = { webswitch: 'WebSwitch 1216H', kmtronic: 'KMTronic 8-relay', denkovi: 'Denkovi USB (FT245)', usbrelay: 'Denkovi USB (serial)', dingtian: 'Dingtian IOT relay', httpgen: 'HTTP relay' };
 
 // Relay count for a configured device: fixed by type, except Denkovi (4/8) and
 // the generic USB-serial board, whose channel count the user picks.
+// chanCount is the relay count for a device. It MUST agree with
+// deviceRelayCount in app.go: the two decide how many labels and URL rows the
+// editor shows and how many relays the driver is built for, and a type known to
+// one and not the other silently pins the count to its fixed default — which is
+// exactly what happened when the HTTP board was added here and not below.
 const chanCount = (d: Device): number =>
   (d.type === 'denkovi' || d.type === 'usbrelay') ? (d.channels && d.channels >= 1 ? d.channels : 8)
     : d.type === 'dingtian' ? (d.channels && d.channels >= 1 ? d.channels : 2)
+      : d.type === 'httpgen' ? (d.channels && d.channels >= 1 ? d.channels : 4)
         : (RELAY_COUNT[d.type] ?? 5);
 
 function blankDevice(): Device {
@@ -675,6 +686,7 @@ function DeviceEditor({ device, onChange, onSave, onCancel, t }: {
   const isDingtian = device.type === 'dingtian';
   const isDenkovi = device.type === 'denkovi';
   const isUsbRelay = device.type === 'usbrelay';
+  const isHTTPGen = device.type === 'httpgen';
   // COM ports for the generic USB-serial relay picker.
   const [serialPorts, setSerialPorts] = useState<string[]>([]);
   useEffect(() => {
@@ -726,6 +738,7 @@ function DeviceEditor({ device, onChange, onSave, onCancel, t }: {
               <SelectItem value="dingtian">Dingtian IOT relay (LAN / WiFi)</SelectItem>
               <SelectItem value="denkovi">Denkovi USB (FT245 / D2XX)</SelectItem>
               <SelectItem value="usbrelay">Denkovi USB (serial / COM)</SelectItem>
+              <SelectItem value="httpgen">{t('station.typeHttpGen')}</SelectItem>
             </SelectContent>
           </Select>
         </div>
@@ -734,7 +747,7 @@ function DeviceEditor({ device, onChange, onSave, onCancel, t }: {
           <Input value={device.name} placeholder={TYPE_LABEL[device.type]} onChange={(e) => onChange({ ...device, name: e.target.value })} />
         </div>
       </div>
-      {(isDenkovi || isUsbRelay || isDingtian) && (
+      {(isDenkovi || isUsbRelay || isDingtian || isHTTPGen) && (
         <div className="space-y-1 max-w-[10rem]">
           <Label>{t('station.channels')}</Label>
           <Select value={String(chanCount(device))} onValueChange={(v) => setChannels(parseInt(v, 10))}>
@@ -820,6 +833,57 @@ function DeviceEditor({ device, onChange, onSave, onCancel, t }: {
         )}
       </div>
       )}
+      {/* Generic HTTP board: a URL to switch each relay on and one to switch it
+          off. Two ways to fill it, and the per-relay one is why this type
+          exists — a hand-made switch often has URLs with nothing in common
+          between channels, which no pattern can express. */}
+      {isHTTPGen && (
+        <div className="space-y-3 rounded-md border border-border/60 p-3">
+          <div className="grid grid-cols-2 gap-3">
+            <div className="space-y-1">
+              <Label>{t('station.onPattern')}</Label>
+              <Input className="font-mono text-xs" placeholder="http://192.168.1.9/relay?n={relay}&state=on"
+                value={device.on_pattern ?? ''}
+                onChange={(e) => onChange({ ...device, on_pattern: e.target.value })} />
+            </div>
+            <div className="space-y-1">
+              <Label>{t('station.offPattern')}</Label>
+              <Input className="font-mono text-xs" placeholder="http://192.168.1.9/relay?n={relay}&state=off"
+                value={device.off_pattern ?? ''}
+                onChange={(e) => onChange({ ...device, off_pattern: e.target.value })} />
+            </div>
+          </div>
+          <div className="text-[10px] text-muted-foreground">{t('station.patternHint')}</div>
+          <div className="space-y-1">
+            <Label>{t('station.perRelayUrls')}</Label>
+            <div className="space-y-1">
+              {device.labels.map((_, i) => (
+                <div key={i} className="grid grid-cols-[2.5rem_1fr_1fr] items-center gap-2">
+                  <span className="text-[11px] text-muted-foreground">{i + 1}</span>
+                  <Input className="h-8 font-mono text-[11px]" placeholder={t('station.onUrlPh')}
+                    value={device.on_urls?.[i] ?? ''}
+                    onChange={(e) => {
+                      const on_urls = [...(device.on_urls ?? [])];
+                      while (on_urls.length < device.labels.length) on_urls.push('');
+                      on_urls[i] = e.target.value;
+                      onChange({ ...device, on_urls });
+                    }} />
+                  <Input className="h-8 font-mono text-[11px]" placeholder={t('station.offUrlPh')}
+                    value={device.off_urls?.[i] ?? ''}
+                    onChange={(e) => {
+                      const off_urls = [...(device.off_urls ?? [])];
+                      while (off_urls.length < device.labels.length) off_urls.push('');
+                      off_urls[i] = e.target.value;
+                      onChange({ ...device, off_urls });
+                    }} />
+                </div>
+              ))}
+            </div>
+            <div className="text-[10px] text-muted-foreground">{t('station.perRelayHint')}</div>
+          </div>
+        </div>
+      )}
+
       <div className="space-y-1">
         <Label>{t('station.labels')}</Label>
         <div className="grid grid-cols-4 gap-2">

frontend/src/components/UDPIntegrationsPanel.tsx

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useState } from 'react';
+import React, { useCallback, useEffect, useState } from 'react';
 import { Plus, Trash2, Edit2, RefreshCcw, ArrowDownToLine, ArrowUpFromLine } from 'lucide-react';
 import {
   ListUDPIntegrations, SaveUDPIntegration, DeleteUDPIntegration, ReloadUDPIntegrations,
@@ -24,7 +24,13 @@ type UDPConfig = {
   direction: 'inbound' | 'outbound';
   name: string;
   port: number;
-  service_type: 'wsjt' | 'adif' | 'n1mm' | 'remote_call' | 'db_updated' | 'pstrotator_freq' | 'n1mm_radioinfo';
+  service_type: 'wsjt' | 'adif' | 'n1mm' | 'remote_call' | 'db_updated' | 'pstrotator_freq' | 'n1mm_radioinfo' | 'wsjt_log' | 'custom';
+  // Custom rows only.
+  trigger?: string;
+  template?: string;
+  transport?: string;
+  url?: string;
+  line_end?: string;
   multicast: boolean;
   multicast_group: string;
   destination_ip: string;
@@ -77,6 +83,28 @@ const SERVICE_TYPES: Array<{
     hint: 'udpp.svcDbHint',
     defaults: { port: 2333, destination_ip: '127.0.0.1' },
   },
+  {
+    // Announces the QSO on the WSJT-X UDP interface instead of as plain text.
+    // Named for the protocol, not for one program: Logger32 is what it was
+    // built against, but anything listening on that interface takes it, and a
+    // label saying "Logger32" would have every other operator scroll past.
+    // 2250 is Logger32's first additional socket — a starting point, not a rule.
+    id: 'wsjt_log',
+    direction: 'outbound',
+    label: 'udpp.svcWsjtLogLabel',
+    hint: 'udpp.svcWsjtLogHint',
+    defaults: { port: 2250, destination_ip: '127.0.0.1' },
+  },
+  {
+    // The general case: the operator picks the moment and writes the message.
+    // Mainly for antenna switches, which are driven by a URL and want the band
+    // change — but nothing about it is specific to them.
+    id: 'custom',
+    direction: 'outbound',
+    label: 'udpp.svcCustomLabel',
+    hint: 'udpp.svcCustomHint',
+    defaults: { port: 12000, destination_ip: '127.0.0.1' },
+  },
   {
     id: 'pstrotator_freq',
     direction: 'outbound',
@@ -93,6 +121,27 @@ const SERVICE_TYPES: Array<{
   },
 ];
 
+// The fields each trigger carries, and NOTHING else.
+//
+// This list is the point of the whole feature. A rotation has no frequency, a
+// lookup has no report — and a placeholder the trigger cannot fill renders as
+// nothing at all. Without seeing what is available, an operator writes {freq}
+// on a band change, gets an empty string, and has no way to learn why. So the
+// panel prints them under the box, for the trigger actually selected.
+const TRIGGER_FIELDS: Record<string, string[]> = {
+  qso_logged: ['call', 'band', 'band_m', 'mode', 'freq_hz', 'freq_mhz', 'grid', 'name', 'country', 'dxcc', 'rst_s', 'rst_r', 'comment', 'date', 'time'],
+  rotator_goto: ['az', 'el', 'path'],
+  lookup_done: ['call', 'name', 'grid', 'country', 'qth', 'state', 'dxcc'],
+  band_change: ['band', 'band_m', 'freq_hz', 'freq_mhz', 'mode'],
+};
+
+const TRIGGERS = [
+  { id: 'band_change', label: 'udpp.trgBand' },
+  { id: 'qso_logged', label: 'udpp.trgQso' },
+  { id: 'rotator_goto', label: 'udpp.trgRotator' },
+  { id: 'lookup_done', label: 'udpp.trgLookup' },
+];
+
 type Props = { onError: (msg: string) => void };
 
 export function UDPIntegrationsPanel({ onError }: Props) {
@@ -124,6 +173,7 @@ export function UDPIntegrationsPanel({ onError }: Props) {
       destination_ip: preset.defaults.destination_ip ?? '',
       enabled: true,
       sort_order: items.filter((i) => i.direction === direction).length,
+      trigger: '', template: '', transport: 'udp', url: '', line_end: '',
     });
   }
 
@@ -376,7 +426,7 @@ function EditDialog({
             </div>
           )}
 
-          {draft.direction === 'outbound' && (
+          {draft.direction === 'outbound' && draft.service_type !== 'custom' && (
             <div className="space-y-1">
               <Label>{t('udpp.destinationIp')}</Label>
               <Input
@@ -388,6 +438,10 @@ function EditDialog({
             </div>
           )}
 
+          {draft.service_type === 'custom' && (
+            <CustomFields draft={draft} setDraft={setDraft} />
+          )}
+
           <label className="flex items-center gap-2 text-sm cursor-pointer">
             <Checkbox
               checked={draft.enabled}
@@ -413,3 +467,108 @@ function EditDialog({
 
 // silence unused-import for cn — kept for future styling tweaks
 void cn;
+
+// CustomFields is the editor for a custom outbound row: what fires it, how it
+// leaves, and what it says.
+function CustomFields({ draft, setDraft }: {
+  draft: UDPConfig;
+  setDraft: React.Dispatch<React.SetStateAction<UDPConfig>>;
+}) {
+  const { t } = useI18n();
+  const fields = TRIGGER_FIELDS[draft.trigger ?? ''] ?? [];
+  const isURL = draft.transport === 'url';
+  return (
+    <div className="space-y-4 rounded-md border border-border/60 p-3">
+      <div className="grid grid-cols-2 gap-3">
+        <div className="space-y-1">
+          <Label>{t('udpp.trigger')}</Label>
+          <Select value={draft.trigger || 'band_change'} onValueChange={(v) => setDraft((d) => ({ ...d, trigger: v }))}>
+            <SelectTrigger><SelectValue /></SelectTrigger>
+            <SelectContent>
+              {TRIGGERS.map((x) => <SelectItem key={x.id} value={x.id}>{t(x.label)}</SelectItem>)}
+            </SelectContent>
+          </Select>
+        </div>
+        <div className="space-y-1">
+          <Label>{t('udpp.transport')}</Label>
+          <Select value={draft.transport || 'udp'} onValueChange={(v) => setDraft((d) => ({ ...d, transport: v }))}>
+            <SelectTrigger><SelectValue /></SelectTrigger>
+            <SelectContent>
+              <SelectItem value="udp">{t('udpp.transportUdp')}</SelectItem>
+              <SelectItem value="url">{t('udpp.transportUrl')}</SelectItem>
+            </SelectContent>
+          </Select>
+        </div>
+      </div>
+
+      {/* The one place these two features overlap. A relay board is a STATE per
+          band, not an event: Station Control tracks it, reads the boards at
+          startup and does not re-switch while the VFO moves inside a band. A
+          URL fired on a band change has none of that, and building the mapping
+          by hand here is work that is already done there. */}
+      {draft.trigger === 'band_change' && isURL && (
+        <div className="rounded border border-warning-border bg-warning-muted px-2 py-1.5 text-[11px] text-warning-muted-foreground leading-relaxed">
+          {t('udpp.relayInstead')}
+        </div>
+      )}
+
+      {isURL ? (
+        <div className="space-y-1">
+          <Label>{t('udpp.url')}</Label>
+          <Input
+            className="font-mono text-xs"
+            placeholder="http://192.168.1.50/antenna?band={band}"
+            value={draft.url ?? ''}
+            onChange={(e) => setDraft((d) => ({ ...d, url: e.target.value }))}
+          />
+          <div className="text-[10px] text-muted-foreground">{t('udpp.urlHint')}</div>
+        </div>
+      ) : (
+        <>
+          <div className="grid grid-cols-[1fr_auto] gap-2">
+            <div className="space-y-1">
+              <Label>{t('udpp.destinationIp')}</Label>
+              <Input
+                className="font-mono"
+                placeholder="127.0.0.1"
+                value={draft.destination_ip}
+                onChange={(e) => setDraft((d) => ({ ...d, destination_ip: e.target.value }))}
+              />
+            </div>
+            <div className="space-y-1">
+              <Label>{t('udpp.lineEnd')}</Label>
+              <Select value={draft.line_end || 'none'} onValueChange={(v) => setDraft((d) => ({ ...d, line_end: v === 'none' ? '' : v }))}>
+                <SelectTrigger className="w-28"><SelectValue /></SelectTrigger>
+                <SelectContent>
+                  <SelectItem value="none">{t('udpp.lineEndNone')}</SelectItem>
+                  <SelectItem value="lf">LF</SelectItem>
+                  <SelectItem value="crlf">CRLF</SelectItem>
+                </SelectContent>
+              </Select>
+            </div>
+          </div>
+          <div className="space-y-1">
+            <Label>{t('udpp.template')}</Label>
+            <textarea
+              className="w-full min-h-[64px] rounded-md border border-input bg-background px-2 py-1.5 font-mono text-xs"
+              placeholder="<AZIMUT>{az}</AZIMUT>"
+              value={draft.template ?? ''}
+              onChange={(e) => setDraft((d) => ({ ...d, template: e.target.value }))}
+            />
+          </div>
+        </>
+      )}
+
+      {/* What this trigger can actually fill in. */}
+      <div className="space-y-1">
+        <div className="text-[10px] uppercase tracking-wider text-muted-foreground">{t('udpp.fieldsAvailable')}</div>
+        <div className="flex flex-wrap gap-1">
+          {fields.map((f) => (
+            <code key={f} className="rounded bg-muted px-1 py-px text-[10px] text-muted-foreground">{`{${f}}`}</code>
+          ))}
+        </div>
+        <div className="text-[10px] text-muted-foreground">{t('udpp.fieldsHint')}</div>
+      </div>
+    </div>
+  );
+}

frontend/src/lib/awardRefs.ts

@@ -154,3 +154,41 @@ export function buildAwardRefs(qso: any, pickable: Array<{ code: string; field:
   }
   return out.join(';');
 }
+
+// COMPUTED_AWARD_FIELDS mirrors isComputedAwardField in app.go: awards whose
+// reference is derived from the callsign and cty.dat, never assigned by hand.
+//
+// State and county are deliberately absent, there as here — an operator sets
+// those themselves and they drive real predefined-list awards (WAS, WAJA, JCC).
+const COMPUTED_AWARD_FIELDS = new Set([
+  'dxcc', 'cqz', 'ituz', 'prefix', 'callsign', 'cont', 'country', 'grid', 'grid4',
+]);
+
+// spotRefList turns a QSO's code→ref map into the strings a DX-cluster comment
+// wants: ["SOTA HA/KM-018"].
+//
+// COMPUTED awards are dropped. A QSO's materialised references hold both kinds,
+// and the derived ones — DXCC, WAC, WAZ, WPX — are exactly what every reader of
+// the spot works out from the callsign anyway. Announcing "WAC EU WAZ 15 WPX HA5"
+// spends the whole 30-character comment saying nothing, and buries the one
+// reference worth chasing. Same rule as the QSO editor, which is why these are
+// the references it lists on the LEFT and not in its read-only panel.
+//
+// fieldOf is award code → scanned field (from GetAwardDefs). A code missing from
+// it is dropped rather than guessed: showing a reference on the air matters more
+// than showing all of them.
+//
+// A code carrying several references (a two-fer park) yields one entry each, so
+// a spot can take the one that fits instead of emitting a truncated pair.
+// Shortest first: when they cannot all fit, more references beat fewer.
+export function spotRefList(byCode: Record<string, string>, fieldOf: Record<string, string>): string[] {
+  const out: string[] = [];
+  for (const [code, refs] of Object.entries(byCode ?? {})) {
+    const field = fieldOf?.[code.toUpperCase()];
+    if (!field || COMPUTED_AWARD_FIELDS.has(field)) continue;
+    for (const ref of String(refs).split(',').map((s) => s.trim()).filter(Boolean)) {
+      out.push(`${code.toUpperCase()} ${ref.toUpperCase()}`);
+    }
+  }
+  return out.sort((a, b) => a.length - b.length || a.localeCompare(b));
+}

frontend/src/lib/qsl.ts

@@ -0,0 +1,17 @@
+// One answer to "is this QSL received".
+//
+// ADIF's QSL_Rcvd enumeration has BOTH Y and V: Y is "received", V is
+// "verified" — and V is what a LoTW download writes for a confirmation the ARRL
+// has validated. Testing for 'Y' alone therefore misses exactly the
+// confirmations an operator cares most about.
+//
+// It showed on screen: the Awards panel had Morocco validated on five bands
+// while the band/mode matrix beside it showed the entity as merely worked. The
+// award engine accepted Y or V; every other test in the app accepted Y.
+//
+// The Go side has the same rule twice over — award.isYes and qso.ConfirmedValues
+// — and all three have to agree. If you add a value here, add it there.
+export function isQSLConfirmed(v: unknown): boolean {
+  const s = String(v ?? '').trim().toUpperCase();
+  return s === 'Y' || s === 'V';
+}

frontend/src/lib/rowColors.ts

@@ -1,3 +1,4 @@
+import { isQSLConfirmed } from '@/lib/qsl';
 // Row colouring for the log grid, by QSL status.
 //
 // Four categories, each scoped to the channels the operator cares about —
@@ -32,7 +33,9 @@ const FIELDS: Record<string, { sent: string; rcvd: string }> = {
 // ADIF QSL fields are single letters. Y is the only one that means "yes";
 // R (requested) and Q (queued) mean it has not gone out yet — a different state,
 // and the one an operator looks for when deciding what to send.
-const yes = (v: any) => String(v ?? '').trim().toUpperCase() === 'Y';
+// Y or V — see lib/qsl. A LoTW-verified contact is confirmed, and colouring it
+// as unconfirmed is the same bug the band/mode matrix had.
+const yes = (v: any) => isQSLConfirmed(v);
 const owed = (v: any) => {
   const s = String(v ?? '').trim().toUpperCase();
   return s === 'R' || s === 'Q';

frontend/src/lib/uiPref.ts

@@ -17,6 +17,7 @@ const PORTABLE_KEYS = [
   'opslog.autofocusWB',   // auto-focus Worked-before
   'hamlog.filterPresets', // Filter Builder saved presets
   'opslog.showRotor',     // rotor compass shown next to the keyers
+  'opslog.showChaseNew',  // Chase New panel shown next to the keyers
   'opslog.showAmpWidget', // amplifier widget shown next to the keyers
   'opslog.ampSel.widget', // which amplifier that widget shows ("all" or an amp id)
   'opslog.showBeamOnMap', // antenna beam lobe drawn on the Main map

frontend/src/style.css

@@ -785,27 +785,27 @@
    The accent moves from Warm light's burnt orange to ochre to keep the two
    themes apart at a glance in the theme picker. ---------------------------- */
 [data-theme="sahara"] {
-  --background: #dcceab;            /* deep sand — the page */
+  --background: #e6ded0;            /* parchment — the page */
-  --foreground: #2b2318;            /* deep warm brown-ink */
+  --foreground: #3a3227;            /* warm brown-ink */
-  --card: #faf6eb;                  /* lifted panel / entry strip — kept cream */
+  --card: #f3eee2;                  /* panels, entry strip, log rows */
-  --card-foreground: #2b2318;
+  --card-foreground: #3a3227;
-  --popover: #faf6eb;
+  --popover: #f3eee2;
-  --popover-foreground: #2b2318;
+  --popover-foreground: #3a3227;
-  --primary: #a55f14;               /* ochre */
+  --primary: #c4501e;               /* terracotta — buttons and the frequency */
-  --primary-foreground: #fffbf2;
+  --primary-foreground: #fdf8f0;
-  --secondary: #cdbb92;
+  --secondary: #ded5c4;
-  --secondary-foreground: #2b2318;
+  --secondary-foreground: #3a3227;
-  --muted: #cdbb92;                 /* toolbars / tab bar / table headers */
+  --muted: #ded5c4;                 /* toolbars / tab bar / table headers */
-  --muted-foreground: #544731;      /* readable on both sands */
+  --muted-foreground: #6a5f4e;      /* readable on both parchments */
-  --accent: #e9d3a6;                /* warm highlight */
+  --accent: #ecd9c0;                /* warm highlight */
-  --accent-foreground: #6b3a06;
+  --accent-foreground: #7a3410;
-  --destructive: #b91c1c;
+  --destructive: #b3401b;
   --destructive-foreground: #ffffff;
-  --destructive-muted: #fdecec;
+  --destructive-muted: #f7e4da;
-  --destructive-muted-foreground: #b91c1c;
+  --destructive-muted-foreground: #8f3315;
-  --border: #b6a179;                /* sand a step down again, so edges read */
+  --border: #cdc2ae;                /* one step down, so edges read without lines */
-  --input: #b6a179;
+  --input: #cdc2ae;
-  --ring: #c2760c;                  /* amber focus ring */
+  --ring: #c4501e;                  /* the accent, so focus matches the buttons */
 
   --success: #15803d;
   --success-foreground: #ffffff;
@@ -843,11 +843,11 @@
   --mx-call-work: #7fd6a4;
   --mx-dx-conf:   #3730a3;
   --mx-dx-work:   #a5b4fc;
-  --mx-none:      #cdbb92;
+  --mx-none:      #ded5c4;
 
-  --scrollbar-thumb: #ac9868;
+  --scrollbar-thumb: #c2b6a0;
-  --scrollbar-thumb-hover: #927d4e;
+  --scrollbar-thumb-hover: #a5977e;
-  --card-shadow: 0 1px 2px rgba(43, 35, 24, 0.07), 0 0 0 1px rgba(43, 35, 24, 0.03);
+  --card-shadow: 0 1px 2px rgba(58, 50, 39, 0.06), 0 0 0 1px rgba(58, 50, 39, 0.03);
   color-scheme: light;
 }
 

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

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

@@ -406,8 +406,12 @@ export function GetCatalogCodes():Promise<Array<string>>;
 
 export function GetChangelog():Promise<Array<main.ChangelogEntry>>;
 
+export function GetChaseNew():Promise<boolean>;
+
 export function GetChaseNewGrids():Promise<boolean>;
 
+export function GetChaseNewSpots():Promise<Array<main.ChaseNewSpot>>;
+
 export function GetChatHistory(arg1:number):Promise<Array<main.ChatMessage>>;
 
 export function GetClublogCtyInfo():Promise<main.ClublogCtyInfo>;
@@ -872,6 +876,8 @@ export function RevealDataFolder():Promise<void>;
 
 export function RotatorGoTo(arg1:number,arg2:number):Promise<void>;
 
+export function RotatorGoToPath(arg1:number,arg2:number,arg3:string):Promise<void>;
+
 export function RotatorPark():Promise<void>;
 
 export function RotatorStop():Promise<void>;
@@ -992,6 +998,8 @@ export function SetCIVTrace(arg1:boolean):Promise<void>;
 
 export function SetCWDecoderPitch(arg1:number):Promise<void>;
 
+export function SetChaseNew(arg1:boolean):Promise<void>;
+
 export function SetChaseNewGrids(arg1:boolean):Promise<void>;
 
 export function SetClublogCtyEnabled(arg1:boolean):Promise<void>;

frontend/wailsjs/go/main/App.js

@@ -754,10 +754,18 @@ export function GetChangelog() {
   return window['go']['main']['App']['GetChangelog']();
 }
 
+export function GetChaseNew() {
+  return window['go']['main']['App']['GetChaseNew']();
+}
+
 export function GetChaseNewGrids() {
   return window['go']['main']['App']['GetChaseNewGrids']();
 }
 
+export function GetChaseNewSpots() {
+  return window['go']['main']['App']['GetChaseNewSpots']();
+}
+
 export function GetChatHistory(arg1) {
   return window['go']['main']['App']['GetChatHistory'](arg1);
 }
@@ -1686,6 +1694,10 @@ export function RotatorGoTo(arg1, arg2) {
   return window['go']['main']['App']['RotatorGoTo'](arg1, arg2);
 }
 
+export function RotatorGoToPath(arg1, arg2, arg3) {
+  return window['go']['main']['App']['RotatorGoToPath'](arg1, arg2, arg3);
+}
+
 export function RotatorPark() {
   return window['go']['main']['App']['RotatorPark']();
 }
@@ -1926,6 +1938,10 @@ export function SetCWDecoderPitch(arg1) {
   return window['go']['main']['App']['SetCWDecoderPitch'](arg1);
 }
 
+export function SetChaseNew(arg1) {
+  return window['go']['main']['App']['SetChaseNew'](arg1);
+}
+
 export function SetChaseNewGrids(arg1) {
   return window['go']['main']['App']['SetChaseNewGrids'](arg1);
 }

frontend/wailsjs/go/models.ts

@@ -2131,6 +2131,44 @@ export namespace main {
 	        this.fr = source["fr"];
 	    }
 	}
+	export class ChaseNewSpot {
+	    call: string;
+	    band: string;
+	    mode: string;
+	    freq_hz: number;
+	    grid: string;
+	    country?: string;
+	    cont?: string;
+	    dist_km: number;
+	    bearing: number;
+	    status?: string;
+	    new_pfx?: boolean;
+	    new_grid?: boolean;
+	    lotw?: boolean;
+	    at: string;
+	
+	    static createFrom(source: any = {}) {
+	        return new ChaseNewSpot(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.call = source["call"];
+	        this.band = source["band"];
+	        this.mode = source["mode"];
+	        this.freq_hz = source["freq_hz"];
+	        this.grid = source["grid"];
+	        this.country = source["country"];
+	        this.cont = source["cont"];
+	        this.dist_km = source["dist_km"];
+	        this.bearing = source["bearing"];
+	        this.status = source["status"];
+	        this.new_pfx = source["new_pfx"];
+	        this.new_grid = source["new_grid"];
+	        this.lotw = source["lotw"];
+	        this.at = source["at"];
+	    }
+	}
 	export class ChatMessage {
 	    id: number;
 	    operator: string;
@@ -2701,6 +2739,7 @@ export namespace main {
 	    sent_date: string;
 	    rcvd_date: string;
 	    via: string;
+	    rcvd_via: string;
 	    notes: string;
 	    comment: string;
 	
@@ -2715,6 +2754,7 @@ export namespace main {
 	        this.sent_date = source["sent_date"];
 	        this.rcvd_date = source["rcvd_date"];
 	        this.via = source["via"];
+	        this.rcvd_via = source["rcvd_via"];
 	        this.notes = source["notes"];
 	        this.comment = source["comment"];
 	    }
@@ -2993,6 +3033,7 @@ export namespace main {
 	    transport: string;
 	    com_port: string;
 	    baud: number;
+	    spid_model?: string;
 	
 	    static createFrom(source: any = {}) {
 	        return new RotatorDevice(source);
@@ -3014,6 +3055,7 @@ export namespace main {
 	        this.transport = source["transport"];
 	        this.com_port = source["com_port"];
 	        this.baud = source["baud"];
+	        this.spid_model = source["spid_model"];
 	    }
 	}
 	export class RotatorHeading {
@@ -3233,6 +3275,10 @@ export namespace main {
 	    pass?: string;
 	    channels?: number;
 	    labels: string[];
+	    on_urls?: string[];
+	    off_urls?: string[];
+	    on_pattern?: string;
+	    off_pattern?: string;
 	
 	    static createFrom(source: any = {}) {
 	        return new StationDevice(source);
@@ -3248,6 +3294,10 @@ export namespace main {
 	        this.pass = source["pass"];
 	        this.channels = source["channels"];
 	        this.labels = source["labels"];
+	        this.on_urls = source["on_urls"];
+	        this.off_urls = source["off_urls"];
+	        this.on_pattern = source["on_pattern"];
+	        this.off_pattern = source["off_pattern"];
 	    }
 	}
 	export class StationRelay {
@@ -5103,6 +5153,11 @@ export namespace udp {
 	    destination_ip: string;
 	    enabled: boolean;
 	    sort_order: number;
+	    trigger: string;
+	    template: string;
+	    transport: string;
+	    url: string;
+	    line_end: string;
 	
 	    static createFrom(source: any = {}) {
 	        return new Config(source);
@@ -5120,6 +5175,11 @@ export namespace udp {
 	        this.destination_ip = source["destination_ip"];
 	        this.enabled = source["enabled"];
 	        this.sort_order = source["sort_order"];
+	        this.trigger = source["trigger"];
+	        this.template = source["template"];
+	        this.transport = source["transport"];
+	        this.url = source["url"];
+	        this.line_end = source["line_end"];
 	    }
 	}
 

internal/db/migrations/0028_udp_custom_trigger.sql

@@ -0,0 +1,17 @@
+-- Custom outbound messages: a trigger, a template, and a transport.
+--
+-- Until now an outbound row was one of a handful of hard-coded emitters, each
+-- with its own format and its own moment. This adds the general case: pick what
+-- fires it, write what it says, and choose whether it leaves as a UDP datagram
+-- or an HTTP request.
+--
+-- The HTTP half is what makes it useful for antenna switches — most of them are
+-- driven by a URL like http://192.168.1.50/antenna?band=20m — and the band
+-- change is the trigger they want, being rare by nature.
+--
+-- Empty on every existing row, which is what the hard-coded services expect.
+ALTER TABLE integrations_udp ADD COLUMN trig      TEXT NOT NULL DEFAULT '';
+ALTER TABLE integrations_udp ADD COLUMN template  TEXT NOT NULL DEFAULT '';
+ALTER TABLE integrations_udp ADD COLUMN transport TEXT NOT NULL DEFAULT '';
+ALTER TABLE integrations_udp ADD COLUMN url       TEXT NOT NULL DEFAULT '';
+ALTER TABLE integrations_udp ADD COLUMN line_end  TEXT NOT NULL DEFAULT '';

internal/integrations/udp/adifignore_test.go

@@ -0,0 +1,40 @@
+package udp
+
+import (
+	"encoding/binary"
+	"testing"
+)
+
+// An operator's log arrived with four hundred identical "ADIF payload ignored"
+// lines and nothing else legible: two inbound listeners were configured on the
+// SAME multicast group and port, one WSJT and one ADIF, so every WSJT-X decode
+// was delivered to both and the ADIF one rejected each in writing. An FT8 cycle
+// is dozens of decodes every fifteen seconds.
+//
+// The listener has to recognise that traffic and say what it is — once.
+func TestIgnoredADIFStaysBounded(t *testing.T) {
+	s := &Server{cfg: Config{Name: "FLDIGI", Port: 2237}}
+
+	// A WSJT-X packet: magic first. One line is the whole diagnosis, so the
+	// counter is pushed past the cap immediately.
+	pkt := make([]byte, 16)
+	binary.BigEndian.PutUint32(pkt[:4], wsjtMagic)
+	s.noteIgnoredADIF(pkt)
+	if s.badPkts <= maxBadPktDumps {
+		t.Errorf("badPkts = %d — WSJT traffic should silence the listener at once", s.badPkts)
+	}
+
+	// Anything else is described a few times before going quiet, so an ordinary
+	// keep-alive does not get the same one-line treatment as a real diagnosis.
+	s2 := &Server{cfg: Config{Name: "FLDIGI", Port: 2237}}
+	s2.noteIgnoredADIF([]byte("keep-alive"))
+	if s2.badPkts > maxBadPktDumps {
+		t.Errorf("one unusable payload silenced the listener (badPkts = %d)", s2.badPkts)
+	}
+	for i := 0; i < 50; i++ {
+		s2.noteIgnoredADIF([]byte("keep-alive"))
+	}
+	if s2.badPkts <= maxBadPktDumps {
+		t.Errorf("badPkts = %d — the throttle never engaged", s2.badPkts)
+	}
+}

internal/integrations/udp/config.go

@@ -37,6 +37,34 @@ const (
 	ServiceDBUpdated ServiceType = "db_updated"      // ADIF of each locally-logged QSO (on save)
 	ServicePstFreq   ServiceType = "pstrotator_freq" // <PST><FREQUENCY> radio freq (on freq change)
 	ServiceN1MMRadio ServiceType = "n1mm_radioinfo"  // N1MM RadioInfo XML: freq+mode (on freq/mode change)
+	// ServiceWSJTLog wraps the same ADIF in a WSJT-X "Logged ADIF" datagram.
+	// Logger32 and others listen on the WSJT-X interface, not for plain text, and
+	// discard a bare ADIF record without a word — so the two cannot be one row.
+	ServiceWSJTLog ServiceType = "wsjt_log"
+	// ServiceCustom is the general case: the operator picks the trigger, writes
+	// the message, and chooses UDP or HTTP. See Trigger and Config.Template.
+	ServiceCustom ServiceType = "custom"
+)
+
+// Trigger names the moment a custom outbound row fires.
+type Trigger string
+
+const (
+	TriggerQSOLogged  Trigger = "qso_logged"
+	TriggerRotatorGo  Trigger = "rotator_goto"
+	TriggerLookupDone Trigger = "lookup_done"
+	// TriggerBandChange is the RIG changing band, not the entry form: a switch
+	// follows the radio, not what is being typed. Rare by nature, so unlike a
+	// frequency trigger it needs no damping.
+	TriggerBandChange Trigger = "band_change"
+)
+
+// Transport is how a custom row leaves: a UDP datagram or an HTTP GET.
+type Transport string
+
+const (
+	TransportUDP Transport = "udp"
+	TransportURL Transport = "url"
 )
 
 // Config is one user-defined UDP connection.
@@ -51,6 +79,13 @@ type Config struct {
 	DestinationIP  string      `json:"destination_ip"` // outbound only
 	Enabled        bool        `json:"enabled"`
 	SortOrder      int         `json:"sort_order"`
+
+	// Custom rows only (ServiceCustom).
+	Trigger   Trigger   `json:"trigger"`
+	Template  string    `json:"template"`  // message text with {fields}
+	Transport Transport `json:"transport"` // udp | url
+	URL       string    `json:"url"`       // URL template, when transport is url
+	LineEnd   string    `json:"line_end"`  // "" | lf | crlf — UDP only
 }
 
 // Repo is the persistence layer for UDP integration rows.
@@ -62,7 +97,8 @@ func (r *Repo) List(ctx context.Context) ([]Config, error) {
 	rows, err := r.db.QueryContext(ctx, `
 		SELECT id, direction, name, port, service_type,
 		       multicast, multicast_group, destination_ip,
-		       enabled, sort_order
+		       enabled, sort_order,
+		       trig, template, transport, url, line_end
 		FROM integrations_udp
 		ORDER BY direction, sort_order, id`)
 	if err != nil {
@@ -74,7 +110,8 @@ func (r *Repo) List(ctx context.Context) ([]Config, error) {
 		var c Config
 		var mc, en int
 		if err := rows.Scan(&c.ID, &c.Direction, &c.Name, &c.Port, &c.ServiceType,
-			&mc, &c.MulticastGroup, &c.DestinationIP, &en, &c.SortOrder); err != nil {
+			&mc, &c.MulticastGroup, &c.DestinationIP, &en, &c.SortOrder,
+			&c.Trigger, &c.Template, &c.Transport, &c.URL, &c.LineEnd); err != nil {
 			return nil, err
 		}
 		c.Multicast = mc != 0
@@ -101,10 +138,12 @@ func (r *Repo) Save(ctx context.Context, c *Config) error {
 	if c.ID == 0 {
 		res, err := r.db.ExecContext(ctx, `
 			INSERT INTO integrations_udp(direction, name, port, service_type,
-			    multicast, multicast_group, destination_ip, enabled, sort_order)
+			    multicast, multicast_group, destination_ip, enabled, sort_order,
-			VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+			    trig, template, transport, url, line_end)
+			VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
 			c.Direction, c.Name, c.Port, c.ServiceType,
-			mc, c.MulticastGroup, c.DestinationIP, en, c.SortOrder)
+			mc, c.MulticastGroup, c.DestinationIP, en, c.SortOrder,
+			c.Trigger, c.Template, c.Transport, c.URL, c.LineEnd)
 		if err != nil {
 			return fmt.Errorf("insert udp: %w", err)
 		}
@@ -117,10 +156,12 @@ func (r *Repo) Save(ctx context.Context, c *Config) error {
 		  direction = ?, name = ?, port = ?, service_type = ?,
 		  multicast = ?, multicast_group = ?, destination_ip = ?,
 		  enabled = ?, sort_order = ?,
+		  trig = ?, template = ?, transport = ?, url = ?, line_end = ?,
 		  updated_at = ?
 		WHERE id = ?`,
 		c.Direction, c.Name, c.Port, c.ServiceType,
-		mc, c.MulticastGroup, c.DestinationIP, en, c.SortOrder, db.NowISO(), c.ID)
+		mc, c.MulticastGroup, c.DestinationIP, en, c.SortOrder,
+		c.Trigger, c.Template, c.Transport, c.URL, c.LineEnd, db.NowISO(), c.ID)
 	if err != nil {
 		return fmt.Errorf("update udp: %w", err)
 	}

internal/integrations/udp/custom.go

@@ -0,0 +1,205 @@
+package udp
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+
+	"hamlog/internal/applog"
+)
+
+// Custom outbound messages: a trigger, a template, a transport.
+//
+// The hard-coded emitters beside this one each speak a published format at a
+// fixed moment. This is the escape hatch: the operator chooses when it fires and
+// writes what it says. It exists mainly for antenna switches, which are driven
+// by a URL — http://192.168.1.50/antenna?band=20m — and want the band change,
+// but nothing here is specific to them.
+//
+// The presets are NOT reimplemented on top of this. PstRotator and N1MM
+// RadioInfo are documented formats that work; a typo in a template would break
+// them silently, and "it worked before I touched anything" is not a trade worth
+// making for one less code path.
+
+// httpTimeout bounds a request. A UDP datagram leaves and is forgotten; an HTTP
+// call to a switch that has been unplugged will otherwise sit there for the
+// operating system's own timeout — and this fires on a band change, which is
+// exactly when nobody wants to wait.
+const httpTimeout = 3 * time.Second
+
+// customHTTP is the client for URL rows. One client, reused: a new one per
+// request leaks connections on a switch that keeps them alive.
+var customHTTP = &http.Client{Timeout: httpTimeout}
+
+// Render substitutes {field} placeholders in tmpl.
+//
+// escape decides how a value is written, and it is not cosmetic: in a URL every
+// value has to be percent-encoded, or the first portable callsign — F4BPO/P —
+// puts a path separator in the middle of a query string, and a name with a
+// space breaks the request outright. In a UDP payload the opposite holds: the
+// receiver wants the text as typed.
+//
+// A placeholder with no value becomes empty rather than staying as "{freq}".
+// Leaving the braces would send them down the wire, and a receiver would store
+// the literal text as if it meant something.
+func Render(tmpl string, fields map[string]string, escape bool) string {
+	var b strings.Builder
+	for {
+		i := strings.IndexByte(tmpl, '{')
+		if i < 0 {
+			b.WriteString(tmpl)
+			return b.String()
+		}
+		j := strings.IndexByte(tmpl[i:], '}')
+		if j < 0 {
+			b.WriteString(tmpl) // an unclosed brace is literal text
+			return b.String()
+		}
+		b.WriteString(tmpl[:i])
+		key := strings.ToLower(strings.TrimSpace(tmpl[i+1 : i+j]))
+		v := fields[key]
+		if escape {
+			v = url.QueryEscape(v)
+		}
+		b.WriteString(v)
+		tmpl = tmpl[i+j+1:]
+	}
+}
+
+// lineEnding turns the stored choice into the bytes appended to a UDP payload.
+// Many receivers read a line at a time and wait for a terminator; a trailing
+// space in a text box is invisible and lost on the first copy-paste, so this is
+// a choice rather than something to type.
+func lineEnding(s string) string {
+	switch strings.ToLower(strings.TrimSpace(s)) {
+	case "lf":
+		return "\n"
+	case "crlf":
+		return "\r\n"
+	}
+	return ""
+}
+
+// EmitTrigger fires every enabled custom row bound to this trigger.
+//
+// Runs the sends in the background: an HTTP request must never sit on the path
+// of the thing that caused it — a band change waiting on an antenna switch is a
+// band change the operator watches not happen.
+func (m *Manager) EmitTrigger(t Trigger, fields map[string]string) {
+	var rows []Config
+	for _, c := range m.Outbound(ServiceCustom) {
+		if c.Trigger == t {
+			rows = append(rows, c)
+		}
+	}
+	if len(rows) == 0 {
+		return
+	}
+	for _, c := range rows {
+		go m.fireCustom(c, fields)
+	}
+}
+
+func (m *Manager) fireCustom(c Config, fields map[string]string) {
+	if c.Transport == TransportURL {
+		target := Render(c.URL, fields, true)
+		if strings.TrimSpace(target) == "" {
+			m.noteEmptyRender(c, c.URL)
+			return
+		}
+		m.getURL(c, target)
+		return
+	}
+	payload := Render(c.Template, fields, false) + lineEnding(c.LineEnd)
+	if strings.TrimSpace(payload) == "" {
+		m.noteEmptyRender(c, c.Template)
+		return
+	}
+	m.sendTo(c, []byte(payload))
+}
+
+// noteEmptyRender reports a template that produced nothing.
+//
+// Silence here was the worst of the lot: a row whose template is a single
+// placeholder the trigger does not carry — {freq} on a band change — renders
+// empty, sends nothing, and looked exactly like a row that had never fired. The
+// operator has no way to tell a typo from a trigger that is not reaching them.
+//
+// Throttled with the same per-row timer as a failing URL: a template that is
+// wrong stays wrong on every band change.
+func (m *Manager) noteEmptyRender(c Config, tmpl string) {
+	m.noteCustomProblem(c, fmt.Sprintf(
+		"on %s the message came out empty — %q filled in nothing. Check the field names against the list under the box.",
+		c.Trigger, tmpl))
+}
+
+// getURL performs the request and reports what came back.
+//
+// The status code is logged, not just transport errors. A switch answering 404
+// because a firmware update moved its endpoint is a total failure that looks
+// exactly like success from here — the datagram equivalent does not exist, and
+// an operator would have no way to tell.
+func (m *Manager) getURL(c Config, target string) {
+	ctx, cancel := context.WithTimeout(context.Background(), httpTimeout)
+	defer cancel()
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, target, nil)
+	if err != nil {
+		applog.Printf("udp: [%s] bad URL %q: %v", c.Name, redactURL(target), err)
+		return
+	}
+	resp, err := customHTTP.Do(req)
+	if err != nil {
+		m.noteCustomProblem(c, fmt.Sprintf("%s failed: %v", redactURL(target), err))
+		return
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode >= 400 {
+		m.noteCustomProblem(c, fmt.Sprintf("%s answered %s", redactURL(target), resp.Status))
+		return
+	}
+	applog.Printf("udp: [%s] on %s GET %s → %s", c.Name, c.Trigger, redactURL(target), resp.Status)
+}
+
+// redactURL hides the password in a URL before it reaches the log.
+//
+// The URL is what makes this feature debuggable, so it is logged in full — but
+// an operator who put http://admin:secret@switch/ in the box is going to send
+// that log to somebody when something goes wrong. Storing the password as typed
+// was a deliberate choice for LAN gear; writing it into a file that travels is
+// not the same choice, and was never made.
+func redactURL(raw string) string {
+	u, err := url.Parse(raw)
+	if err != nil || u.User == nil {
+		return raw
+	}
+	if _, hasPass := u.User.Password(); !hasPass {
+		return raw
+	}
+	u.User = url.UserPassword(u.User.Username(), "***")
+	// Qt-style escaping of the placeholder would give %2A%2A%2A; put it back so
+	// the line stays readable.
+	return strings.ReplaceAll(u.String(), "%2A%2A%2A", "***")
+}
+
+// noteCustomProblem logs a failing URL row, throttled per row: a switch that is
+// off answers the same way on every band change, and this fires on every one.
+func (m *Manager) noteCustomProblem(c Config, msg string) {
+	m.httpFailMu.Lock()
+	if m.httpFailAt == nil {
+		m.httpFailAt = map[int64]time.Time{}
+	}
+	last := m.httpFailAt[c.ID]
+	now := time.Now()
+	quiet := now.Sub(last) < 5*time.Minute
+	if !quiet {
+		m.httpFailAt[c.ID] = now
+	}
+	m.httpFailMu.Unlock()
+	if quiet {
+		return
+	}
+	applog.Printf("udp: [%s] %s", c.Name, msg)
+}

internal/integrations/udp/custom_test.go

@@ -0,0 +1,108 @@
+package udp
+
+import (
+	"strings"
+	"testing"
+)
+
+// The escaping rule is the whole difference between a template that works on
+// the bench and one that fails on the first portable callsign.
+func TestRenderEscapesForURLsOnly(t *testing.T) {
+	fields := map[string]string{
+		"call": "F4BPO/P", "name": "Jean Pierre", "band": "20m", "az": "137",
+	}
+	// UDP: the receiver wants the text as typed.
+	if got := Render("<CALL>{call}</CALL>", fields, false); got != "<CALL>F4BPO/P</CALL>" {
+		t.Errorf("UDP render = %q", got)
+	}
+	// URL: a slash in a callsign is a path separator, a space breaks the request.
+	if got := Render("http://sw/a?c={call}&n={name}", fields, true); got != "http://sw/a?c=F4BPO%2FP&n=Jean+Pierre" {
+		t.Errorf("URL render = %q", got)
+	}
+}
+
+// A placeholder the trigger does not carry becomes empty, not the literal
+// "{freq}" — otherwise the braces go down the wire and a receiver files them.
+func TestRenderDropsUnknownFields(t *testing.T) {
+	if got := Render("<AZIMUT>{az}</AZIMUT>{freq}", map[string]string{"az": "137"}, false); got != "<AZIMUT>137</AZIMUT>" {
+		t.Errorf("got %q", got)
+	}
+}
+
+// Text that merely looks like a placeholder must survive: an unclosed brace is
+// content, not a broken field.
+func TestRenderLeavesLiteralBraces(t *testing.T) {
+	for _, c := range []struct{ in, want string }{
+		{"no fields here", "no fields here"},
+		{"{unclosed", "{unclosed"},
+		{"a } b", "a } b"},
+	} {
+		if got := Render(c.in, map[string]string{}, false); got != c.want {
+			t.Errorf("Render(%q) = %q, want %q", c.in, got, c.want)
+		}
+	}
+}
+
+// Field names are matched case- and space-insensitively: an operator typing
+// {Band} or { band } means the band.
+func TestRenderFieldNamesAreForgiving(t *testing.T) {
+	f := map[string]string{"band": "20m"}
+	for _, tmpl := range []string{"{band}", "{Band}", "{ BAND }"} {
+		if got := Render(tmpl, f, false); got != "20m" {
+			t.Errorf("Render(%q) = %q, want 20m", tmpl, got)
+		}
+	}
+}
+
+// Receivers that read a line at a time need a terminator, and a trailing space
+// in a text box is invisible — hence a choice rather than something to type.
+func TestLineEnding(t *testing.T) {
+	for in, want := range map[string]string{
+		"": "", "lf": "\n", "LF": "\n", "crlf": "\r\n", " CRLF ": "\r\n", "nonsense": "",
+	} {
+		if got := lineEnding(in); got != want {
+			t.Errorf("lineEnding(%q) = %q, want %q", in, got, want)
+		}
+	}
+}
+
+// These logs get sent to whoever is helping when something breaks. Storing a
+// switch password as typed was a deliberate choice for LAN gear; putting it in
+// a file that travels is a different one, and was never made.
+func TestRedactURLHidesThePassword(t *testing.T) {
+	for in, want := range map[string]string{
+		"http://admin:[email protected]/ant?b=20m": "http://admin:***@192.168.1.50/ant?b=20m",
+		// No credentials, nothing to hide — and the URL must come back untouched,
+		// because it is the thing being debugged.
+		"http://192.168.1.50/ant?b=20m": "http://192.168.1.50/ant?b=20m",
+		// A username with no password is not a secret.
+		"http://[email protected]/ant": "http://[email protected]/ant",
+		// Not a URL at all: leave it, the operator needs to see what they typed.
+		"not a url {band}": "not a url {band}",
+	} {
+		if got := redactURL(in); got != want {
+			t.Errorf("redactURL(%q) = %q, want %q", in, got, want)
+		}
+	}
+}
+
+// "sent 18 bytes" says nothing about whether the substitution came out right.
+// The payload is shown for custom rows and only those: an ADIF record or a
+// binary WSJT frame on every QSO would bury the log.
+func TestSentPreviewIsForCustomRowsOnly(t *testing.T) {
+	custom := Config{ServiceType: ServiceCustom, Trigger: TriggerBandChange}
+	got := sentPreview(custom, []byte("<BAND>20</BAND>\r\n"))
+	if got != ` on band_change: "<BAND>20</BAND>\r\n"` {
+		t.Errorf("custom preview = %q", got)
+	}
+	// A line ending is a choice the operator made — it has to be visible, and it
+	// must not break the log line in two.
+	if strings.ContainsAny(got, "\r\n") {
+		t.Error("the preview put a real newline in the log line")
+	}
+	for _, s := range []ServiceType{ServiceDBUpdated, ServiceWSJTLog, ServiceN1MMRadio} {
+		if p := sentPreview(Config{ServiceType: s}, []byte("<CALL:5>VK9XX<EOR>")); p != "" {
+			t.Errorf("%s should not dump its payload, got %q", s, p)
+		}
+	}
+}

internal/integrations/udp/outbound.go

@@ -86,12 +86,92 @@ func (m *Manager) EmitLoggedADIF(adif string) {
 	if strings.TrimSpace(adif) == "" {
 		return
 	}
-	for _, c := range m.Outbound(ServiceDBUpdated) {
+	rows := m.Outbound(ServiceDBUpdated)
+	if len(rows) == 0 {
+		// Said once per session, not per QSO. An operator who configured a second
+		// logger and sees nothing arrive needs to know the difference between "we
+		// sent it" and "there was nothing to send to" — and the usual cause is a
+		// row created as an inbound ADIF listener instead of an outbound message.
+		m.noADIFOnce.Do(func() {
+			applog.Printf("udp: a QSO was logged but no outbound \"ADIF message\" row is enabled — " +
+				"nothing is forwarded to another logger")
+		})
+		return
+	}
+	for _, c := range rows {
 		m.sendTo(c, []byte(adif))
 	}
 }
 
+// EmitLoggedQSOWSJT announces a logged contact on the WSJT-X interface, for
+// receivers that speak it rather than plain text — Logger32's additional UDP
+// sockets among them.
+//
+// BOTH messages go out, "QSO Logged" (5) then "Logged ADIF" (12), because that
+// is exactly what WSJT-X does for every contact. Which one a receiver takes is
+// its own business: MacLoggerDX reads the structured one by default and offers
+// the ADIF as an option, and sending only the ADIF is why a QSO reached
+// Logger32's socket and never reached its log. Anything built for WSJT-X
+// already sees both from the real thing, so neither is a surprise and nothing
+// logs the contact twice.
+func (m *Manager) EmitLoggedQSOWSJT(q LoggedQSO, adifRec string) {
+	rows := m.Outbound(ServiceWSJTLog)
+	if len(rows) == 0 {
+		return
+	}
+	qsoPkt := BuildWSJTQSOLogged("OpsLog", q)
+	var adifPkt []byte
+	if strings.TrimSpace(adifRec) != "" {
+		adifPkt = BuildWSJTLoggedADIF("OpsLog", adifRec)
+	}
+	for _, c := range rows {
+		m.sendTo(c, qsoPkt)
+		if adifPkt != nil {
+			m.sendTo(c, adifPkt)
+		}
+	}
+}
+
+// sentPreview appends what was actually sent, for the rows where that is worth
+// reading.
+//
+// Custom rows only, and deliberately: their payload is a template the operator
+// wrote, and "sent 18 bytes" tells them nothing about whether the substitution
+// came out as they meant. The ADIF and WSJT-X rows carry a whole record or a
+// binary frame, and dumping either into the log on every QSO would bury it.
+//
+// The trigger is named too — a row that fires on the wrong moment looks exactly
+// like a row that does not fire.
+func sentPreview(c Config, payload []byte) string {
+	if c.ServiceType != ServiceCustom {
+		return ""
+	}
+	const maxShown = 200
+	s := string(payload)
+	if len(s) > maxShown {
+		s = s[:maxShown] + "…"
+	}
+	// %q below already renders a carriage return as \r rather than breaking the
+	// log line in two — and it is the line ending the operator chose, so it has
+	// to be visible. Escaping it by hand first would double every backslash.
+	if c.Trigger != "" {
+		return fmt.Sprintf(" on %s: %q", c.Trigger, s)
+	}
+	return fmt.Sprintf(": %q", s)
+}
+
 // sendTo resolves the row's destination (host:port) and fires one datagram.
+//
+// A successful send is logged, not just a failure. UDP has no delivery report:
+// when an operator says "I set up an ADIF message to Logger32 on port 2250 and
+// nothing arrives", the only thing that separates "OpsLog never sent it" from
+// "the other program did not take it" is a line saying we sent. Without one,
+// both look identical from here — and the first is far more common, because a
+// row created as an INBOUND ADIF listener rather than an OUTBOUND ADIF message
+// matches nothing and emits nothing, in silence.
+//
+// Rate is not a concern: these fire on a QSO being logged or a frequency
+// change, not per packet on a socket.
 func (m *Manager) sendTo(c Config, payload []byte) {
 	host := strings.TrimSpace(c.DestinationIP)
 	if host == "" {
@@ -100,5 +180,8 @@ func (m *Manager) sendTo(c Config, payload []byte) {
 	dst := fmt.Sprintf("%s:%d", host, c.Port)
 	if err := SendUDP(dst, payload); err != nil {
 		applog.Printf("udp: [%s] outbound send to %s failed: %v", c.Name, dst, err)
+		return
 	}
+	applog.Printf("udp: [%s] sent %d bytes to %s (%s)%s",
+		c.Name, len(payload), dst, c.ServiceType, sentPreview(c, payload))
 }

internal/integrations/udp/server.go

@@ -2,6 +2,7 @@ package udp
 
 import (
 	"context"
+	"encoding/binary"
 	"fmt"
 	"net"
 	"regexp"
@@ -268,6 +269,44 @@ func (s *Server) logBadPacket(kind string, remote *net.UDPAddr, pkt []byte, err
 	}
 }
 
+// noteIgnoredADIF reports a payload the ADIF listener could not use, ONCE per
+// cause and then quietly.
+//
+// This used to log a line per datagram. An operator's log arrived with four
+// hundred identical "ADIF payload ignored" lines and nothing else legible: two
+// inbound listeners were configured on the SAME multicast group and port
+// (239.255.0.1:2237, one WSJT and one ADIF), so every WSJT-X decode packet was
+// delivered to both, and the ADIF one rejected each of them in writing. An FT8
+// cycle is dozens of decodes every fifteen seconds.
+//
+// So the WSJT-X magic number is checked here. When it matches, the payload is
+// not "chatter" — it is a specific, fixable misconfiguration, and saying which
+// is the difference between a log the operator can act on and one they cannot.
+func (s *Server) noteIgnoredADIF(pkt []byte) {
+	s.mu.Lock()
+	s.badPkts++
+	n := s.badPkts
+	s.mu.Unlock()
+	if n > maxBadPktDumps {
+		return
+	}
+	if len(pkt) >= 4 && binary.BigEndian.Uint32(pkt[:4]) == wsjtMagic {
+		applog.Printf("udp: [%s] this is WSJT-X traffic, not ADIF — port %d is shared with a WSJT source; "+
+			"give the ADIF forwarder (JTAlert / GridTracker) its own port, or set this listener's service to WSJT\n",
+			s.cfg.Name, s.cfg.Port)
+		// One line is the whole diagnosis: nothing is gained by counting to five.
+		s.mu.Lock()
+		s.badPkts = maxBadPktDumps + 1
+		s.mu.Unlock()
+		return
+	}
+	applog.Printf("udp: [%s] ADIF payload ignored (no <call:>/<eor>) — %s\n", s.cfg.Name, describePacket(pkt))
+	if n == maxBadPktDumps {
+		applog.Printf("udp: [%s] further unusable payloads on port %d will not be logged\n",
+			s.cfg.Name, s.cfg.Port)
+	}
+}
+
 func (s *Server) handle(pkt []byte, remote *net.UDPAddr) {
 	ev := Event{ConfigID: s.cfg.ID, Service: s.cfg.ServiceType, Source: remote.String()}
 	switch s.cfg.ServiceType {
@@ -338,7 +377,7 @@ func (s *Server) handle(pkt []byte, remote *net.UDPAddr) {
 		text := string(pkt)
 		low := strings.ToLower(text)
 		if !strings.Contains(low, "<call:") || !strings.Contains(low, "<eor") {
-			applog.Printf("udp: [%s] ADIF payload ignored (no <call:>/<eor>)\n", s.cfg.Name)
+			s.noteIgnoredADIF(pkt)
 			return
 		}
 		ev.LoggedADIF = text
@@ -458,6 +497,15 @@ type Manager struct {
 	repo *Repo
 	out  chan Event
 
+	// noADIFOnce keeps the "nothing to forward to" note to one line a session
+	// rather than one per QSO logged.
+	noADIFOnce sync.Once
+
+	// httpFailAt throttles the complaint from a custom URL row, per row: a
+	// switch that is off answers the same way on every band change.
+	httpFailMu sync.Mutex
+	httpFailAt map[int64]time.Time
+
 	mu       sync.Mutex
 	inbound  map[int64]*Server
 	outbound []Config

internal/integrations/udp/wsjtsend.go

@@ -0,0 +1,148 @@
+package udp
+
+import (
+	"bytes"
+	"encoding/binary"
+	"time"
+)
+
+// Sending WSJT-X UDP messages, as opposed to parsing them (wsjt.go).
+//
+// This exists for Logger32, and for anything else that listens on the WSJT-X
+// interface rather than for plain text. Logger32's "additional WSJT/JTDX UDP
+// sockets" receivers — ports 2250, 2251, 2252 — are documented as receiving
+// "UDP logging packets": they speak the WSJT-X v2 protocol, and a raw ADIF
+// record posted to them is discarded without a word.
+//
+// That is a real distinction and not a detail: an operator can watch OpsLog
+// report "sent 1153 bytes to 127.0.0.1:2250" and see nothing whatsoever appear
+// in Logger32, because both statements are true.
+
+// buildQString encodes a Qt QString/QByteArray as QDataStream writes it: a
+// big-endian int32 length followed by the UTF-8 bytes. A negative length means
+// null, which is not what we ever want here — an empty string is length 0.
+func buildQString(s string) []byte {
+	out := make([]byte, 4, 4+len(s))
+	binary.BigEndian.PutUint32(out, uint32(len(s)))
+	return append(out, s...)
+}
+
+// BuildWSJTLoggedADIF frames a WSJT-X "Logged ADIF" datagram (message type 12).
+//
+//	uint32  magic   0xadbccbda
+//	uint32  schema  2
+//	uint32  type    12
+//	QString id      the sending program's name
+//	QString adif    the ADIF record
+//
+// id matters more than it looks: a receiver uses it to tell instances apart, and
+// some show it in their log. "OpsLog" is honest — pretending to be WSJT-X would
+// make a second instance of the real thing indistinguishable from us.
+func BuildWSJTLoggedADIF(id, adif string) []byte {
+	var b bytes.Buffer
+	var hdr [12]byte
+	binary.BigEndian.PutUint32(hdr[0:4], wsjtMagic)
+	binary.BigEndian.PutUint32(hdr[4:8], 2) // schema 2 — what WSJT-X 2.x speaks
+	binary.BigEndian.PutUint32(hdr[8:12], wsjtMsgLoggedADIF)
+	b.Write(hdr[:])
+	b.Write(buildQString(id))
+	b.Write(buildQString(adif))
+	return b.Bytes()
+}
+
+// LoggedQSO is what a WSJT-X "QSO Logged" message carries. Declared here rather
+// than taking a qso.QSO so this package stays free of the logbook — it speaks a
+// wire protocol and nothing else.
+type LoggedQSO struct {
+	DXCall       string
+	DXGrid       string
+	TxFreqHz     uint64
+	Mode         string
+	ReportSent   string
+	ReportRcvd   string
+	TxPower      string
+	Comments     string
+	Name         string
+	TimeOn       time.Time // UTC
+	TimeOff      time.Time // UTC
+	OperatorCall string
+	MyCall       string
+	MyGrid       string
+	ExchangeSent string
+	ExchangeRcvd string
+	PropMode     string
+}
+
+// BuildWSJTQSOLogged frames a WSJT-X "QSO Logged" datagram (message type 5).
+//
+// This is the message most loggers listen for — MacLoggerDX takes it by default
+// and offers the ADIF one as an alternative, and WSJT-X itself sends BOTH for
+// every contact. Sending only the ADIF form was the reason a QSO reached
+// Logger32's socket and never reached its log.
+//
+// Field order is fixed by WSJT-X's NetworkMessage.hpp and cannot be rearranged:
+// a receiver reads them positionally, so one field out of place shifts every
+// one after it.
+func BuildWSJTQSOLogged(id string, q LoggedQSO) []byte {
+	var b bytes.Buffer
+	var hdr [12]byte
+	binary.BigEndian.PutUint32(hdr[0:4], wsjtMagic)
+	binary.BigEndian.PutUint32(hdr[4:8], 2)
+	binary.BigEndian.PutUint32(hdr[8:12], wsjtMsgQSOLogged)
+	b.Write(hdr[:])
+	b.Write(buildQString(id))
+	b.Write(buildQDateTimeUTC(q.TimeOff))
+	b.Write(buildQString(q.DXCall))
+	b.Write(buildQString(q.DXGrid))
+	var f [8]byte
+	binary.BigEndian.PutUint64(f[:], q.TxFreqHz)
+	b.Write(f[:])
+	b.Write(buildQString(q.Mode))
+	b.Write(buildQString(q.ReportSent))
+	b.Write(buildQString(q.ReportRcvd))
+	b.Write(buildQString(q.TxPower))
+	b.Write(buildQString(q.Comments))
+	b.Write(buildQString(q.Name))
+	b.Write(buildQDateTimeUTC(q.TimeOn))
+	b.Write(buildQString(q.OperatorCall))
+	b.Write(buildQString(q.MyCall))
+	b.Write(buildQString(q.MyGrid))
+	b.Write(buildQString(q.ExchangeSent))
+	b.Write(buildQString(q.ExchangeRcvd))
+	b.Write(buildQString(q.PropMode))
+	return b.Bytes()
+}
+
+// buildQDateTimeUTC encodes a QDateTime the way QDataStream has since Qt 5:
+//
+//	qint64  Julian day number
+//	quint32 milliseconds since midnight
+//	quint8  time spec — 1 is UTC, which is the only one we ever send
+//
+// Everything in the logbook is already UTC, and a receiver that guessed local
+// time from a spec of 0 would file the contact in the wrong hour.
+func buildQDateTimeUTC(t time.Time) []byte {
+	t = t.UTC()
+	out := make([]byte, 0, 13)
+	var jd [8]byte
+	binary.BigEndian.PutUint64(jd[:], uint64(julianDay(t)))
+	out = append(out, jd[:]...)
+	ms := uint32(t.Hour()*3600000 + t.Minute()*60000 + t.Second()*1000 + t.Nanosecond()/1e6)
+	var m [4]byte
+	binary.BigEndian.PutUint32(m[:], ms)
+	out = append(out, m[:]...)
+	return append(out, 1) // Qt::UTC
+}
+
+// julianDay is the standard Gregorian-to-JDN conversion. Integer division
+// throughout — this is the arithmetic Qt uses, and a floating-point version
+// lands a day out at the edges.
+func julianDay(t time.Time) int64 {
+	y := int64(t.Year())
+	m := int64(t.Month())
+	d := int64(t.Day())
+	a := (14 - m) / 12
+	y2 := y + 4800 - a
+	m2 := m + 12*a - 3
+	return d + (153*m2+2)/5 + 365*y2 + y2/4 - y2/100 + y2/400 - 32045
+}

internal/integrations/udp/wsjtsend_test.go

@@ -0,0 +1,139 @@
+package udp
+
+import (
+	"bytes"
+	"encoding/binary"
+	"testing"
+	"time"
+)
+
+// What we send has to be what we can read back: Logger32 and the rest decode
+// this with the same rules our own parser uses, so a round trip through
+// ParseWSJT is the honest check.
+//
+// The case behind it: OpsLog reported "sent 1153 bytes to 127.0.0.1:2250" and
+// Logger32 showed nothing. Both were true — its UDP sockets speak the WSJT-X
+// protocol and discard a bare ADIF record without a word.
+func TestWSJTLoggedADIFRoundTrips(t *testing.T) {
+	const rec = "<CALL:5>VK9XX<BAND:3>20m<MODE:3>FT8<QSO_DATE:8>20260814<TIME_ON:6>174433<EOR>"
+	pkt := BuildWSJTLoggedADIF("OpsLog", rec)
+
+	ev, ok, err := ParseWSJT(pkt)
+	if err != nil {
+		t.Fatalf("ParseWSJT: %v", err)
+	}
+	if !ok {
+		t.Fatal("our own parser did not recognise the datagram we build")
+	}
+	if ev.LoggedADIF != rec {
+		t.Errorf("ADIF = %q, want %q", ev.LoggedADIF, rec)
+	}
+	if ev.ProgramID != "OpsLog" {
+		t.Errorf("id = %q, want OpsLog — a receiver uses it to tell instances apart", ev.ProgramID)
+	}
+}
+
+// The header is fixed and other programs match on it byte for byte.
+func TestWSJTLoggedADIFHeader(t *testing.T) {
+	pkt := BuildWSJTLoggedADIF("OpsLog", "<EOR>")
+	want := []byte{
+		0xad, 0xbc, 0xcb, 0xda, // magic
+		0x00, 0x00, 0x00, 0x02, // schema 2
+		0x00, 0x00, 0x00, 0x0c, // type 12 — Logged ADIF
+		0x00, 0x00, 0x00, 0x06, // len("OpsLog")
+		'O', 'p', 's', 'L', 'o', 'g',
+		0x00, 0x00, 0x00, 0x05, // len("<EOR>")
+		'<', 'E', 'O', 'R', '>',
+	}
+	if !bytes.Equal(pkt, want) {
+		t.Errorf("packet = % X\nwant     % X", pkt, want)
+	}
+}
+
+// The julian day has to match Qt's, because the receiver turns it back into a
+// date. A day out here files every contact on the wrong day.
+func TestJulianDayMatchesKnownValues(t *testing.T) {
+	for _, c := range []struct {
+		date time.Time
+		want int64
+	}{
+		// Checked against the standard tables: JDN is the count at noon UTC.
+		{time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC), 2451545},
+		{time.Date(1970, 1, 1, 0, 0, 0, 0, time.UTC), 2440588},
+		{time.Date(2026, 8, 15, 0, 0, 0, 0, time.UTC), 2461268},
+	} {
+		if got := julianDay(c.date); got != c.want {
+			t.Errorf("julianDay(%s) = %d, want %d", c.date.Format("2006-01-02"), got, c.want)
+		}
+	}
+}
+
+// QDateTime is julian day, then milliseconds since midnight, then the time
+// spec. A receiver reads them positionally, and a spec of 0 (local time) would
+// have it re-interpret a UTC contact in its own zone.
+func TestQDateTimeIsUTCAndPositional(t *testing.T) {
+	got := buildQDateTimeUTC(time.Date(2026, 8, 15, 17, 44, 33, 0, time.UTC))
+	if len(got) != 13 {
+		t.Fatalf("%d bytes, want 13", len(got))
+	}
+	if jd := int64(binary.BigEndian.Uint64(got[0:8])); jd != 2461268 {
+		t.Errorf("julian day = %d, want 2461268", jd)
+	}
+	wantMs := uint32((17*3600 + 44*60 + 33) * 1000)
+	if ms := binary.BigEndian.Uint32(got[8:12]); ms != wantMs {
+		t.Errorf("ms since midnight = %d, want %d", ms, wantMs)
+	}
+	if got[12] != 1 {
+		t.Errorf("time spec = %d, want 1 (UTC)", got[12])
+	}
+}
+
+// The QSO Logged message is read positionally: one field out of place shifts
+// every one after it, and the receiver silently files nonsense. This pins the
+// order against WSJT-X's NetworkMessage.hpp.
+func TestWSJTQSOLoggedFieldOrder(t *testing.T) {
+	pkt := BuildWSJTQSOLogged("OpsLog", LoggedQSO{
+		DXCall: "VK9XX", DXGrid: "QH30", TxFreqHz: 14074000, Mode: "FT8",
+		ReportSent: "-12", ReportRcvd: "-08", TxPower: "50", Comments: "tnx",
+		Name: "Ken", TimeOn: time.Date(2026, 8, 15, 17, 44, 0, 0, time.UTC),
+		TimeOff: time.Date(2026, 8, 15, 17, 45, 0, 0, time.UTC),
+		MyCall:  "F4BPO", MyGrid: "IN95", OperatorCall: "F4BPO",
+		PropMode: "",
+	})
+	r := bytes.NewReader(pkt)
+	var magic, schema, mtype uint32
+	binary.Read(r, binary.BigEndian, &magic)
+	binary.Read(r, binary.BigEndian, &schema)
+	binary.Read(r, binary.BigEndian, &mtype)
+	if magic != wsjtMagic || schema != 2 || mtype != wsjtMsgQSOLogged {
+		t.Fatalf("header magic=%08x schema=%d type=%d", magic, schema, mtype)
+	}
+	id, _ := readQString(r)
+	if id != "OpsLog" {
+		t.Errorf("id = %q", id)
+	}
+	r.Seek(13, 1) // QSO off
+	call, _ := readQString(r)
+	grid, _ := readQString(r)
+	var freq uint64
+	binary.Read(r, binary.BigEndian, &freq)
+	mode, _ := readQString(r)
+	sent, _ := readQString(r)
+	rcvd, _ := readQString(r)
+	if call != "VK9XX" || grid != "QH30" || freq != 14074000 || mode != "FT8" || sent != "-12" || rcvd != "-08" {
+		t.Errorf("got call=%q grid=%q freq=%d mode=%q sent=%q rcvd=%q", call, grid, freq, mode, sent, rcvd)
+	}
+	pwr, _ := readQString(r)
+	comments, _ := readQString(r)
+	name, _ := readQString(r)
+	if pwr != "50" || comments != "tnx" || name != "Ken" {
+		t.Errorf("got pwr=%q comments=%q name=%q", pwr, comments, name)
+	}
+	r.Seek(13, 1) // QSO on
+	op, _ := readQString(r)
+	myCall, _ := readQString(r)
+	myGrid, _ := readQString(r)
+	if op != "F4BPO" || myCall != "F4BPO" || myGrid != "IN95" {
+		t.Errorf("got op=%q myCall=%q myGrid=%q", op, myCall, myGrid)
+	}
+}

internal/pskr/pskr.go

@@ -54,6 +54,9 @@ type Spot struct {
 	Band string
 	Mode string
 	Grid string // transmitter's grid, 4 characters
+	// FreqHz is where the decode happened. The band alone is enough for an
+	// opening, but a station worth chasing has to be tuned to.
+	FreqHz  int64
 	DistKm  int // from the operator
 	Bearing int // degrees from the operator, short path
 	At      time.Time
@@ -269,6 +272,7 @@ func (w *Watcher) handle(_ mqtt.Client, m mqtt.Message) {
 	s := Spot{
 		Call: call, Band: strings.ToLower(strings.TrimSpace(p.Band)),
 		Mode: strings.ToUpper(strings.TrimSpace(p.Mode)), Grid: grid[:4],
+		FreqHz: p.Freq,
 		DistKm: dist, Bearing: brg,
 		// Stamped on receipt: the broker's own timestamps vary between payload
 		// versions, and the window this feeds is measured in minutes.

internal/pskr/spotfreq_test.go

@@ -0,0 +1,29 @@
+package pskr
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+// The frequency has to survive from the payload to the Spot: the Chase New
+// panel is only useful if a click can put the rig on the station, and a row
+// showing "—" instead of 14074.0 is a row nobody can act on.
+func TestWirePayloadCarriesFrequency(t *testing.T) {
+	const payload = `{"sq":1,"f":14074123,"md":"FT8","rp":-12,"sc":"VK9XX","sl":"QH30","rc":"F4BPO","rl":"IN95","b":"20m"}`
+	var p wire
+	if err := json.Unmarshal([]byte(payload), &p); err != nil {
+		t.Fatalf("unmarshal: %v", err)
+	}
+	if p.Freq != 14074123 {
+		t.Errorf("Freq = %d, want 14074123", p.Freq)
+	}
+	if p.TxCall != "VK9XX" || p.Band != "20m" || p.Mode != "FT8" {
+		t.Errorf("unexpected decode: %+v", p)
+	}
+	// And the Spot the watcher builds must carry it — this is the field that was
+	// declared, documented, and then never assigned.
+	s := Spot{Call: p.TxCall, Band: p.Band, Mode: p.Mode, FreqHz: p.Freq}
+	if s.FreqHz != p.Freq {
+		t.Errorf("Spot.FreqHz = %d, want %d", s.FreqHz, p.Freq)
+	}
+}

internal/qso/confirmedvalues_test.go

@@ -0,0 +1,65 @@
+package qso
+
+import (
+	"context"
+	"database/sql"
+	"testing"
+
+	_ "modernc.org/sqlite"
+)
+
+// A LoTW confirmation the ARRL has validated arrives as V, not Y — ADIF's
+// QSL_Rcvd enumeration has both. Every SQL query here compared against 'Y'
+// alone, so the band/mode matrix showed an entity as merely worked while the
+// Awards panel beside it showed the same entity validated on five bands.
+//
+// This drives the real queries against a real database rather than asserting on
+// the constant: the constant being right is not the point, the queries using it
+// is.
+func TestConfirmedCountsVerifiedNotJustYes(t *testing.T) {
+	db, err := sql.Open("sqlite", "file:confirmedvalues?mode=memory&cache=shared")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+	if _, err := db.Exec(`CREATE TABLE qso (
+		id INTEGER PRIMARY KEY, callsign TEXT, dxcc INTEGER, band TEXT, mode TEXT,
+		lotw_rcvd TEXT, qsl_rcvd TEXT, eqsl_rcvd TEXT)`); err != nil {
+		t.Fatal(err)
+	}
+	// Two Morocco contacts: one verified through LoTW, one not confirmed at all.
+	if _, err := db.Exec(`INSERT INTO qso (callsign, dxcc, band, mode, lotw_rcvd, qsl_rcvd, eqsl_rcvd)
+		VALUES ('CN8ABC', 446, '30m', 'FT8', 'V', '', ''),
+		       ('CN8XYZ', 446, '20m', 'FT8', 'N', '', '')`); err != nil {
+		t.Fatal(err)
+	}
+
+	var confirmed30, confirmed20 int
+	q := `SELECT band, MAX(CASE WHEN lotw_rcvd IN ` + ConfirmedValues +
+		` OR qsl_rcvd IN ` + ConfirmedValues + ` OR eqsl_rcvd IN ` + ConfirmedValues +
+		` THEN 1 ELSE 0 END) FROM qso WHERE dxcc = 446 GROUP BY band`
+	rows, err := db.QueryContext(context.Background(), q)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var band string
+		var c int
+		if err := rows.Scan(&band, &c); err != nil {
+			t.Fatal(err)
+		}
+		switch band {
+		case "30m":
+			confirmed30 = c
+		case "20m":
+			confirmed20 = c
+		}
+	}
+	if confirmed30 != 1 {
+		t.Error("a LoTW 'V' (verified) was not counted as confirmed — the matrix would show the entity as merely worked")
+	}
+	if confirmed20 != 0 {
+		t.Error("an 'N' was counted as confirmed")
+	}
+}

internal/qso/qso.go

@@ -1907,9 +1907,9 @@ func (r *Repo) WorkedBefore(ctx context.Context, callsign string, dxccHint int,
         SELECT band, mode,
                MAX(CASE WHEN callsign = ? THEN 1 ELSE 0 END),
                MAX(CASE WHEN callsign = ?
-                         AND (lotw_rcvd = 'Y' OR qsl_rcvd = 'Y' OR eqsl_rcvd = 'Y')
+                         AND (lotw_rcvd IN `+ConfirmedValues+` OR qsl_rcvd IN `+ConfirmedValues+` OR eqsl_rcvd IN `+ConfirmedValues+`)
                         THEN 1 ELSE 0 END),
-               MAX(CASE WHEN lotw_rcvd = 'Y' OR qsl_rcvd = 'Y' OR eqsl_rcvd = 'Y'
+               MAX(CASE WHEN lotw_rcvd IN `+ConfirmedValues+` OR qsl_rcvd IN `+ConfirmedValues+` OR eqsl_rcvd IN `+ConfirmedValues+`
                         THEN 1 ELSE 0 END)
         FROM qso
         WHERE dxcc = ?
@@ -2792,12 +2792,27 @@ type SlotStats struct {
 	DIGConfirmed int `json:"dig_confirmed"`
 }
 
+// ConfirmedValues is what a QSL-received field holds when the contact IS
+// confirmed, as an SQL list.
+//
+// Y AND V. ADIF's QSL_Rcvd enumeration has both: Y is "received", V is
+// "verified" — and that is what a LoTW download writes for a confirmation the
+// ARRL has validated. Testing only = 'Y' therefore misses exactly the
+// confirmations an operator cares most about.
+//
+// This was visible on screen: the Awards panel showed Morocco validated on five
+// bands while the band/mode matrix beside it showed the entity as merely worked,
+// because the award engine's isYes accepts "Y" or "V" and every SQL query here
+// compared against 'Y' alone. One definition of confirmed, in one place, is the
+// only way those two agree.
+const ConfirmedValues = "('Y','V')"
+
 // GetSlotStats computes the worked/confirmed slot and DXCC tallies in one pass.
 // "Confirmed" = LoTW or paper QSL received (the award-valid sources).
 func (r *Repo) GetSlotStats(ctx context.Context) (SlotStats, error) {
 	rows, err := r.db.QueryContext(ctx, `
 		SELECT COALESCE(dxcc,0), LOWER(COALESCE(band,'')), UPPER(COALESCE(mode,'')),
-		       CASE WHEN lotw_rcvd='Y' OR qsl_rcvd='Y' THEN 1 ELSE 0 END
+		       CASE WHEN lotw_rcvd IN `+ConfirmedValues+` OR qsl_rcvd IN `+ConfirmedValues+` THEN 1 ELSE 0 END
 		FROM qso`)
 	if err != nil {
 		return SlotStats{}, err

internal/relaydev/httpgen.go

@@ -0,0 +1,124 @@
+package relaydev
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+	"strings"
+	"sync"
+)
+
+// A generic HTTP relay board: one URL to switch a relay on, one to switch it off.
+//
+// This is for the home-made switch — an ESP8266 with a web page, a Shelly, a
+// Sonoff running third-party firmware, any of the boxes that answer a GET and
+// have no protocol worth naming. The named drivers beside it exist because
+// their boards need something specific; this one exists because most of them
+// need nothing at all.
+//
+// TWO WAYS TO CONFIGURE IT, and the difference matters:
+//
+//   - one URL pair with {relay} in it, used for every relay:
+//     http://192.168.1.9/relay?n={relay}&state=on
+//   - or one pair per relay, when the box has no pattern to speak of:
+//     relay 1 → http://192.168.1.9/FF0101 , relay 2 → .../FF0201
+//
+// The second is the reason this driver exists. A hand-made switch often has
+// URLs with nothing in common between channels, and a template with {relay}
+// cannot express that.
+//
+// STATE IS REMEMBERED, NOT READ. Most of these boxes have no status endpoint,
+// or answer with a web page nobody can parse reliably. Status therefore returns
+// what we last commanded — see the method for what that costs.
+type httpGen struct {
+	onURLs  []string // index 0 = relay 1; "" falls back to the pattern
+	offURLs []string
+	onPat   string // pattern with {relay}, used when the per-relay URL is empty
+	offPat  string
+	user    string
+	pass    string
+	count   int
+
+	mu    sync.Mutex
+	state []bool
+}
+
+// NewHTTPGeneric builds the driver. onURLs/offURLs are per relay (index 0 =
+// relay 1) and may be short or hold empty entries; onPat/offPat are the
+// fallback patterns.
+func NewHTTPGeneric(onURLs, offURLs []string, onPat, offPat, user, pass string, count int) Device {
+	if count <= 0 {
+		count = len(onURLs)
+	}
+	if count <= 0 {
+		count = 1
+	}
+	return &httpGen{
+		onURLs: onURLs, offURLs: offURLs,
+		onPat: onPat, offPat: offPat,
+		user: user, pass: pass, count: count,
+		state: make([]bool, count),
+	}
+}
+
+func (h *httpGen) Count() int   { return h.count }
+func (h *httpGen) Close() error { return nil } // stateless HTTP, nothing to release
+
+// urlFor picks the per-relay URL, falling back to the pattern.
+func (h *httpGen) urlFor(relay int, on bool) string {
+	list, pat := h.offURLs, h.offPat
+	if on {
+		list, pat = h.onURLs, h.onPat
+	}
+	if i := relay - 1; i >= 0 && i < len(list) {
+		if u := strings.TrimSpace(list[i]); u != "" {
+			return u
+		}
+	}
+	if pat = strings.TrimSpace(pat); pat == "" {
+		return ""
+	}
+	return strings.ReplaceAll(pat, "{relay}", strconv.Itoa(relay))
+}
+
+func (h *httpGen) Set(ctx context.Context, relay int, on bool) error {
+	if relay < 1 || relay > h.count {
+		return fmt.Errorf("relay %d out of range 1..%d", relay, h.count)
+	}
+	u := h.urlFor(relay, on)
+	if u == "" {
+		// Naming the direction matters: an operator who filled the ON URLs and
+		// left OFF empty gets a switch that latches, and "no URL configured"
+		// alone would not say which half is missing.
+		dir := "OFF"
+		if on {
+			dir = "ON"
+		}
+		return fmt.Errorf("no %s URL configured for relay %d", dir, relay)
+	}
+	if _, err := get(ctx, u, h.user, h.pass); err != nil {
+		return err
+	}
+	h.mu.Lock()
+	if i := relay - 1; i < len(h.state) {
+		h.state[i] = on
+	}
+	h.mu.Unlock()
+	return nil
+}
+
+// Status returns what was last commanded, not what the board is doing.
+//
+// These boxes rarely have a status endpoint worth trusting, so there is nothing
+// to read. The cost is real and worth stating: after OpsLog restarts, every
+// relay reads as off until something switches it, so the automatic control
+// re-commands each one once. That is a harmless extra command on a board with
+// no memory of its own — and far better than guessing a state and leaving an
+// antenna disconnected because we assumed it was already selected.
+func (h *httpGen) Status(ctx context.Context) ([]bool, error) {
+	h.mu.Lock()
+	defer h.mu.Unlock()
+	out := make([]bool, h.count)
+	copy(out, h.state)
+	return out, nil
+}

internal/relaydev/httpgen_test.go

@@ -0,0 +1,92 @@
+package relaydev
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"sync"
+	"testing"
+)
+
+// The pattern form: one URL pair for the whole board, {relay} substituted.
+func TestHTTPGenericPattern(t *testing.T) {
+	var mu sync.Mutex
+	var got []string
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		mu.Lock()
+		got = append(got, r.URL.String())
+		mu.Unlock()
+	}))
+	defer srv.Close()
+
+	d := NewHTTPGeneric(nil, nil,
+		srv.URL+"/relay?n={relay}&state=on",
+		srv.URL+"/relay?n={relay}&state=off", "", "", 4)
+	if err := d.Set(context.Background(), 2, true); err != nil {
+		t.Fatalf("Set on: %v", err)
+	}
+	if err := d.Set(context.Background(), 3, false); err != nil {
+		t.Fatalf("Set off: %v", err)
+	}
+	mu.Lock()
+	defer mu.Unlock()
+	want := []string{"/relay?n=2&state=on", "/relay?n=3&state=off"}
+	if strings.Join(got, " ") != strings.Join(want, " ") {
+		t.Errorf("requested %v, want %v", got, want)
+	}
+}
+
+// The per-relay form, which is the reason this driver exists: a hand-made
+// switch often has URLs with nothing in common between channels, and no
+// pattern can express that.
+func TestHTTPGenericPerRelayURLsWinOverThePattern(t *testing.T) {
+	var mu sync.Mutex
+	var got []string
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		mu.Lock()
+		got = append(got, r.URL.Path)
+		mu.Unlock()
+	}))
+	defer srv.Close()
+
+	d := NewHTTPGeneric(
+		[]string{srv.URL + "/FF0101", "", srv.URL + "/weird/on"},
+		[]string{srv.URL + "/FF0100", "", ""},
+		srv.URL+"/pattern/on/{relay}", srv.URL+"/pattern/off/{relay}", "", "", 3)
+
+	_ = d.Set(context.Background(), 1, true)  // its own URL
+	_ = d.Set(context.Background(), 2, true)  // empty → falls back to the pattern
+	_ = d.Set(context.Background(), 3, false) // no OFF of its own → pattern
+	mu.Lock()
+	defer mu.Unlock()
+	want := []string{"/FF0101", "/pattern/on/2", "/pattern/off/3"}
+	if strings.Join(got, " ") != strings.Join(want, " ") {
+		t.Errorf("requested %v, want %v", got, want)
+	}
+}
+
+// A switch with the ON URLs filled and OFF left empty latches. The error has to
+// name the direction, or the operator cannot tell which half is missing.
+func TestHTTPGenericNamesTheMissingDirection(t *testing.T) {
+	d := NewHTTPGeneric([]string{"http://x/on"}, nil, "", "", "", "", 1)
+	err := d.Set(context.Background(), 1, false)
+	if err == nil || !strings.Contains(err.Error(), "OFF") {
+		t.Errorf("err = %v, want it to name the OFF direction", err)
+	}
+}
+
+// Status reports what was commanded: these boxes have nothing to read.
+func TestHTTPGenericRemembersWhatItCommanded(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}))
+	defer srv.Close()
+	d := NewHTTPGeneric(nil, nil, srv.URL+"/on/{relay}", srv.URL+"/off/{relay}", "", "", 3)
+	_ = d.Set(context.Background(), 2, true)
+	st, err := d.Status(context.Background())
+	if err != nil {
+		t.Fatalf("Status: %v", err)
+	}
+	if len(st) != 3 || st[0] || !st[1] || st[2] {
+		t.Errorf("state = %v, want only relay 2 on", st)
+	}
+}

internal/rotator/spid/spid.go

@@ -0,0 +1,257 @@
+// Package spid drives a SPID (AlfaSpid) rotator over its own serial protocol,
+// Rot1Prog or Rot2Prog — the controllers sold as RAS, RAK, BIG-RAS/HR, MD-01
+// and MD-02.
+//
+// It exists so an operator with SPID rotators does not need PstRotator running
+// just to turn an antenna. Two towers with a controller each is the ordinary
+// case; each one is a separate serial port and a separate rotor in OpsLog.
+//
+// WIRE FORMAT
+//
+// Every command is 13 bytes:
+//
+//	 0    1  2  3  4    5    6  7  8  9    10   11  12
+//	0x57 H1 H2 H3 H4   PH   V1 V2 V3 V4   PV   K  0x20
+//
+// K is the command: 0x0F stop, 0x1F status, 0x2F set.
+//
+// The DIGITS ARE ASCII in a command ('0'+d) and RAW BYTES in a reply (0..9).
+// That asymmetry is the whole trap in this protocol: send raw digits and the
+// controller ignores you, read them as ASCII and every heading is 48 degrees
+// times a hundred out. It is pinned by the tests beside this file.
+//
+// PH and PV are the resolution in pulses per degree — 1, 2 or 4 — and are raw
+// in both directions. The target is scaled by it:
+//
+//	u_az = PH × (360 + az)      and the four decimal digits of u_az are sent
+//
+// A reply is 12 bytes for Rot2Prog (azimuth and elevation) or 5 for Rot1Prog
+// (azimuth only, three digits):
+//
+//	az = H1×100 + H2×10 + H3 + H4/10 − 360
+//
+// The 360 offset is what lets the controller report a rotator that has turned
+// past north in either direction, which is the point of a pulse-counting
+// rotator: −180…540 rather than 0…359.
+//
+// Serial is 8N1 at 600 baud for Rot2Prog and 1200 for Rot1Prog. Those are not
+// typos — a pulse controller has nothing to say quickly.
+//
+// Verified against Hamlib's spid.c (rotators/spid/spid.c), which is the
+// reference implementation, and SPID's published protocol note. NOT yet run
+// against real hardware here; the tests pin the frames, the controller is the
+// only thing that can confirm the rest.
+package spid
+
+import (
+	"fmt"
+	"strings"
+	"sync"
+	"time"
+
+	"go.bug.st/serial"
+)
+
+// Model selects the dialect.
+type Model string
+
+const (
+	Rot1Prog Model = "rot1prog" // azimuth only, 5-byte reply, 1200 baud
+	Rot2Prog Model = "rot2prog" // azimuth + elevation, 12-byte reply, 600 baud
+)
+
+const (
+	cmdStop   = 0x0F
+	cmdStatus = 0x1F
+	cmdSet    = 0x2F
+
+	frameStart = 0x57
+	frameEnd   = 0x20
+)
+
+// Client is one controller on one serial port.
+//
+// The port is opened per exchange rather than held: a rotator is polled every
+// few seconds at most, and holding a COM port open for the life of the program
+// is what stops an operator from using their controller's own software
+// alongside — which they will want while they are still trusting this.
+type Client struct {
+	mu    sync.Mutex
+	port  string
+	baud  int
+	model Model
+	// resolution is pulses per degree: 1, 2 or 4. The controller is configured
+	// for one of them and answers with it, so a wrong value here corrects itself
+	// on the first status read.
+	resolution byte
+}
+
+// New builds a client. baud 0 takes the model's documented default.
+func New(comPort string, baud int, model Model) *Client {
+	if model != Rot1Prog {
+		model = Rot2Prog
+	}
+	if baud <= 0 {
+		baud = 600
+		if model == Rot1Prog {
+			baud = 1200
+		}
+	}
+	return &Client{port: strings.TrimSpace(comPort), baud: baud, model: model, resolution: 1}
+}
+
+// BuildStatus frames the "where are you" command.
+func BuildStatus() []byte { return buildCmd(0, 0, 0, 0, cmdStatus) }
+
+// BuildStop frames the "stop now" command.
+func BuildStop() []byte { return buildCmd(0, 0, 0, 0, cmdStop) }
+
+// BuildSet frames a target. resolution is the controller's pulses per degree.
+//
+// Azimuth is offset by 360 before scaling, so a target of −10° and one of 350°
+// are different instructions: the first turns anticlockwise past north, the
+// second does not. Feeding a 0…359 heading in is therefore always safe.
+func BuildSet(az, el float64, resolution byte) []byte {
+	if resolution == 0 {
+		resolution = 1
+	}
+	uaz := int(float64(resolution)*(360+az) + 0.5)
+	uel := int(float64(resolution)*(360+el) + 0.5)
+	return buildCmd(uaz, uel, resolution, resolution, cmdSet)
+}
+
+func buildCmd(uaz, uel int, ph, pv byte, k byte) []byte {
+	c := make([]byte, 13)
+	c[0] = frameStart
+	if k == cmdSet {
+		c[1] = '0' + byte(uaz/1000%10)
+		c[2] = '0' + byte(uaz/100%10)
+		c[3] = '0' + byte(uaz/10%10)
+		c[4] = '0' + byte(uaz%10)
+		c[5] = ph
+		c[6] = '0' + byte(uel/1000%10)
+		c[7] = '0' + byte(uel/100%10)
+		c[8] = '0' + byte(uel/10%10)
+		c[9] = '0' + byte(uel%10)
+		c[10] = pv
+	}
+	c[11] = k
+	c[12] = frameEnd
+	return c
+}
+
+// ParseStatus decodes a reply. Returns the azimuth, the elevation (0 for
+// Rot1Prog) and the resolution the controller reported.
+func ParseStatus(buf []byte, model Model) (az, el float64, resolution byte, err error) {
+	want := 12
+	if model == Rot1Prog {
+		want = 5
+	}
+	if len(buf) < want {
+		return 0, 0, 0, fmt.Errorf("spid: short reply (%d bytes, want %d)", len(buf), want)
+	}
+	if buf[0] != frameStart || buf[want-1] != frameEnd {
+		return 0, 0, 0, fmt.Errorf("spid: not a reply frame: % X", buf[:want])
+	}
+	az = float64(buf[1])*100 + float64(buf[2])*10 + float64(buf[3])
+	if model == Rot1Prog {
+		return az - 360, 0, 1, nil
+	}
+	az += float64(buf[4]) / 10
+	el = float64(buf[6])*100 + float64(buf[7])*10 + float64(buf[8]) + float64(buf[9])/10
+	resolution = buf[5]
+	if resolution == 0 {
+		resolution = 1
+	}
+	return az - 360, el - 360, resolution, nil
+}
+
+// GoTo points the rotator at az (and el, on a Rot2Prog with elevation).
+func (c *Client) GoTo(az int, el int) error {
+	c.mu.Lock()
+	res := c.resolution
+	c.mu.Unlock()
+	e := 0.0
+	if el >= 0 && c.model == Rot2Prog {
+		e = float64(el)
+	}
+	_, err := c.exchange(BuildSet(float64(az), e, res), 0)
+	return err
+}
+
+// Stop interrupts a rotation in progress.
+func (c *Client) Stop() error {
+	// The controller answers a stop with its position, like a status — read it
+	// so the reply does not sit in the buffer and get taken for the ANSWER to
+	// the next poll, which would report a heading one command stale for ever.
+	_, err := c.exchange(BuildStop(), c.replyLen())
+	return err
+}
+
+// Heading reads the current position.
+func (c *Client) Heading() (az int, el int, err error) {
+	buf, err := c.exchange(BuildStatus(), c.replyLen())
+	if err != nil {
+		return 0, 0, err
+	}
+	a, e, res, err := ParseStatus(buf, c.model)
+	if err != nil {
+		return 0, 0, err
+	}
+	// Believe the controller about its own resolution: it is configured on the
+	// front panel, and a wrong guess here would scale every target we send.
+	c.mu.Lock()
+	c.resolution = res
+	c.mu.Unlock()
+	return int(a + 0.5), int(e + 0.5), nil
+}
+
+func (c *Client) replyLen() int {
+	if c.model == Rot1Prog {
+		return 5
+	}
+	return 12
+}
+
+// exchange opens the port, writes one frame and reads the expected reply.
+func (c *Client) exchange(cmd []byte, wantBytes int) ([]byte, error) {
+	if c.port == "" {
+		return nil, fmt.Errorf("spid: no serial port configured")
+	}
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	p, err := serial.Open(c.port, &serial.Mode{
+		BaudRate: c.baud, DataBits: 8, Parity: serial.NoParity, StopBits: serial.OneStopBit,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("spid: open %s: %w", c.port, err)
+	}
+	defer p.Close()
+	// 600 baud is 60 bytes a second: a 12-byte reply takes a fifth of a second
+	// to arrive on the wire alone, before the controller has thought about it.
+	_ = p.SetReadTimeout(2 * time.Second)
+	if _, err := p.Write(cmd); err != nil {
+		return nil, fmt.Errorf("spid: write: %w", err)
+	}
+	if wantBytes == 0 {
+		return nil, nil
+	}
+	buf := make([]byte, 0, wantBytes)
+	tmp := make([]byte, wantBytes)
+	deadline := time.Now().Add(3 * time.Second)
+	for len(buf) < wantBytes && time.Now().Before(deadline) {
+		n, err := p.Read(tmp)
+		if n > 0 {
+			buf = append(buf, tmp[:n]...)
+			continue
+		}
+		if err != nil {
+			break
+		}
+	}
+	if len(buf) < wantBytes {
+		return nil, fmt.Errorf("spid: no reply from %s (%d of %d bytes) — check the port, the baud rate (%d) and that nothing else holds the controller",
+			c.port, len(buf), wantBytes, c.baud)
+	}
+	return buf, nil
+}

internal/rotator/spid/spid_test.go

@@ -0,0 +1,99 @@
+package spid
+
+import (
+	"math"
+	"testing"
+)
+
+// The frames are pinned against Hamlib's spid.c, the reference implementation.
+// This protocol has one trap and it is here: digits go out as ASCII and come
+// back RAW. Getting that backwards points an antenna at a heading nobody asked
+// for, and nothing in the app would notice.
+func TestSetFrameMatchesTheReference(t *testing.T) {
+	// Hamlib: u_az = PH × (360 + az), then the four decimal digits as ASCII;
+	// PH and PV raw; K = 0x2F.
+	got := BuildSet(0, 0, 1) // 360 → "0360"
+	want := []byte{0x57, '0', '3', '6', '0', 0x01, '0', '3', '6', '0', 0x01, 0x2F, 0x20}
+	assertBytes(t, "az 0 res 1", got, want)
+
+	// 90° at half-degree resolution: 2 × 450 = 900 → "0900".
+	got = BuildSet(90, 0, 2)
+	want = []byte{0x57, '0', '9', '0', '0', 0x02, '0', '7', '2', '0', 0x02, 0x2F, 0x20}
+	assertBytes(t, "az 90 res 2", got, want)
+
+	// A quarter-degree controller, 359°: 4 × 719 = 2876.
+	got = BuildSet(359, 0, 4)
+	want = []byte{0x57, '2', '8', '7', '6', 0x04, '1', '4', '4', '0', 0x04, 0x2F, 0x20}
+	assertBytes(t, "az 359 res 4", got, want)
+}
+
+// Status and stop carry no position: every data byte is zero, only K differs.
+func TestStatusAndStopFrames(t *testing.T) {
+	assertBytes(t, "status", BuildStatus(),
+		[]byte{0x57, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x1F, 0x20})
+	assertBytes(t, "stop", BuildStop(),
+		[]byte{0x57, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x0F, 0x20})
+}
+
+// A reply's digits are RAW, and the 360 offset is what lets a pulse-counting
+// controller report a rotator that has turned past north — the whole reason
+// these rotators exist.
+func TestParseStatusRot2Prog(t *testing.T) {
+	// 0x57 H1 H2 H3 H4 PH V1 V2 V3 V4 PV 0x20
+	// az digits 4,5,1,5 → 451.5 − 360 = 91.5
+	frame := []byte{0x57, 4, 5, 1, 5, 0x02, 3, 6, 0, 0, 0x02, 0x20}
+	az, el, res, err := ParseStatus(frame, Rot2Prog)
+	if err != nil {
+		t.Fatalf("ParseStatus: %v", err)
+	}
+	if math.Abs(az-91.5) > 0.001 {
+		t.Errorf("az = %v, want 91.5", az)
+	}
+	if math.Abs(el-0) > 0.001 {
+		t.Errorf("el = %v, want 0", el)
+	}
+	if res != 2 {
+		t.Errorf("resolution = %d, want 2 — the controller's own value must win", res)
+	}
+}
+
+// Rot1Prog: five bytes, three digits, no elevation.
+func TestParseStatusRot1Prog(t *testing.T) {
+	az, el, res, err := ParseStatus([]byte{0x57, 4, 5, 1, 0x20}, Rot1Prog)
+	if err != nil {
+		t.Fatalf("ParseStatus: %v", err)
+	}
+	if math.Abs(az-91) > 0.001 {
+		t.Errorf("az = %v, want 91", az)
+	}
+	if el != 0 || res != 1 {
+		t.Errorf("el = %v, res = %d — Rot1Prog has neither", el, res)
+	}
+}
+
+// A truncated or foreign frame must be refused rather than decoded into a
+// heading: half a reply read as a position turns an antenna somewhere real.
+func TestParseStatusRefusesRubbish(t *testing.T) {
+	for name, frame := range map[string][]byte{
+		"short":    {0x57, 4, 5, 1},
+		"no start": {0x00, 4, 5, 1, 5, 1, 3, 6, 0, 0, 1, 0x20},
+		"no end":   {0x57, 4, 5, 1, 5, 1, 3, 6, 0, 0, 1, 0x00},
+		"empty":    {},
+	} {
+		if _, _, _, err := ParseStatus(frame, Rot2Prog); err == nil {
+			t.Errorf("%s: decoded without complaint", name)
+		}
+	}
+}
+
+func assertBytes(t *testing.T, what string, got, want []byte) {
+	t.Helper()
+	if len(got) != len(want) {
+		t.Fatalf("%s: % X\nwant     % X", what, got, want)
+	}
+	for i := range want {
+		if got[i] != want[i] {
+			t.Fatalf("%s: % X\nwant     % X", what, got, want)
+		}
+	}
+}

internal/steppir/drift_test.go

@@ -0,0 +1,50 @@
+package steppir
+
+import "testing"
+
+// An operator's log read as "the antenna stops responding": every tune was
+// commanded, acknowledged with the requested frequency on the next poll, then
+// replaced on the poll after by a different one — 21075 asked, 21075 confirmed,
+// 21050 reported — with the operator tuning again each time. Nothing in the log
+// named that, so it looked like a dead link.
+func TestCheckDriftReportsOnceAndRecovers(t *testing.T) {
+	c := &Client{}
+	c.lastSetKHz = 21075
+
+	// Where it was asked to go: nothing to say.
+	c.checkDrift(&Status{Frequency: 21075})
+	if c.lastDriftKHz != 0 {
+		t.Errorf("a controller on frequency was reported as drifting (%d)", c.lastDriftKHz)
+	}
+	// Its own grid is not a fault.
+	c.checkDrift(&Status{Frequency: 21070})
+	if c.lastDriftKHz != 0 {
+		t.Errorf("%d kHz is within tolerance and was reported", 21070)
+	}
+	// Somewhere else entirely: recorded, so it is said once.
+	c.checkDrift(&Status{Frequency: 21050})
+	if c.lastDriftKHz != 21050 {
+		t.Errorf("lastDriftKHz = %d, want 21050", c.lastDriftKHz)
+	}
+	// Still there on the next poll: nothing new to say, and the marker stands.
+	c.checkDrift(&Status{Frequency: 21050})
+	if c.lastDriftKHz != 21050 {
+		t.Errorf("lastDriftKHz = %d after a repeat, want it unchanged", c.lastDriftKHz)
+	}
+	// Back where it belongs: the marker clears, so the next divergence is said.
+	c.checkDrift(&Status{Frequency: 21075})
+	if c.lastDriftKHz != 0 {
+		t.Errorf("lastDriftKHz = %d after recovery, want 0", c.lastDriftKHz)
+	}
+}
+
+// A frequency read while the elements are travelling is not a disagreement, it
+// is an antenna on its way — reporting it would cry wolf on every single tune.
+func TestCheckDriftIgnoresMovingMotors(t *testing.T) {
+	c := &Client{}
+	c.lastSetKHz = 21075
+	c.checkDrift(&Status{Frequency: 21000, MotorsMoving: 1})
+	if c.lastDriftKHz != 0 {
+		t.Errorf("a moving antenna was reported as drifting (%d)", c.lastDriftKHz)
+	}
+}

internal/steppir/steppir.go

@@ -88,6 +88,10 @@ type Client struct {
 
 	connMu sync.Mutex
 	conn   io.ReadWriteCloser
+	// openFails counts consecutive failures to reopen the port, so the retry
+	// reports the first one and the recovery, and stays quiet in between.
+	// Guarded by connMu.
+	openFails int
 
 	// ioMu serialises EVERY exchange on the shared connection — a status query
 	// (write "?A" then read 11 bytes) and a command write must never interleave,
@@ -98,6 +102,10 @@ type Client struct {
 	statusMu   sync.RWMutex
 	lastStatus *Status
 	lastSetKHz int
+	// lastDriftKHz is the frequency last reported for a controller that had gone
+	// somewhere other than where it was told, so the disagreement is stated once
+	// and not on every poll. Zero when it is where it should be.
+	lastDriftKHz int
 
 	// lastRaw holds the previous raw status frame so we only log a status line
 	// when the controller's reply actually changes — enough to diagnose a stuck
@@ -187,6 +195,35 @@ func (c *Client) open() (io.ReadWriteCloser, error) {
 	}
 }
 
+// openFailQuiet is how many consecutive failed reopens are reported before the
+// loop goes quiet about them. A port that has gone (adapter unplugged, another
+// program holding it) stays gone, and one line every two seconds would be the
+// entire log.
+const openFailQuiet = 3
+
+// noteOpenFailure logs a failure to reopen the port, throttled. Caller must NOT
+// hold connMu — it is taken here.
+func (c *Client) noteOpenFailure(err error) {
+	c.connMu.Lock()
+	c.openFails++
+	n := c.openFails
+	c.connMu.Unlock()
+	switch {
+	case n <= openFailQuiet:
+		log.Printf("steppir: cannot open %s: %v (attempt %d)", c.target(), err, n)
+	case n == openFailQuiet+1:
+		log.Printf("steppir: still cannot open %s — retrying every 2 s, further attempts will not be logged until it comes back", c.target())
+	}
+}
+
+// target names what the client is trying to reach, for the log.
+func (c *Client) target() string {
+	if c.tr.Mode == "serial" {
+		return fmt.Sprintf("%s @ %d baud", c.tr.COM, c.tr.Baud)
+	}
+	return fmt.Sprintf("%s:%d", c.tr.Host, c.tr.Port)
+}
+
 func (c *Client) pollLoop() {
 	ticker := time.NewTicker(2 * time.Second)
 	defer ticker.Stop()
@@ -201,8 +238,19 @@ func (c *Client) pollLoop() {
 				if err != nil {
 					c.connMu.Unlock()
 					c.setDisconnected()
+					// SAY SO. This retried every two seconds in complete silence,
+					// so an antenna that lost its port stopped answering and the
+					// log had nothing at all after the disconnection — which is
+					// exactly what an operator reports as "it worked for a while
+					// and then it didn't". Throttled, because a port that is gone
+					// stays gone and this would otherwise be the whole log.
+					c.noteOpenFailure(err)
 					continue
 				}
+				if c.openFails > 0 {
+					log.Printf("steppir: reconnected after %d failed attempt(s)", c.openFails)
+					c.openFails = 0
+				}
 				c.conn = conn
 			}
 			c.connMu.Unlock()
@@ -225,10 +273,61 @@ func (c *Client) pollLoop() {
 			c.applyPendingDir(st)
 			c.lastStatus = st
 			c.statusMu.Unlock()
+			c.checkDrift(st)
 		}
 	}
 }
 
+// driftToleranceKHz is how far the controller's reported frequency may sit from
+// the one we commanded before it is worth saying so. A SteppIR quantises to its
+// own grid, so a few kHz is normal and must not be reported as a fault.
+const driftToleranceKHz = 10
+
+// checkDrift reports a controller that settled somewhere other than where it was
+// told to go.
+//
+// This exists because of a log that read as "the antenna stops responding": every
+// tune was commanded, acknowledged on the next poll with the requested frequency,
+// and then REPLACED on the poll after by a different one — 21075 asked, 21075
+// confirmed, 21050 reported, over and over, with the operator tuning again each
+// time. Nothing in the log named that, so it looked like a dead link rather than
+// a controller with a mind of its own (its own radio interface tracking the rig,
+// or a front-panel mode that overrides the host).
+//
+// Only when the motors have stopped: a frequency read mid-travel is not a
+// disagreement, it is an antenna on its way. And only when the value changes, so
+// a controller parked somewhere else does not fill the log.
+func (c *Client) checkDrift(st *Status) {
+	if st.MotorsMoving != 0 {
+		return
+	}
+	c.statusMu.Lock()
+	want := c.lastSetKHz
+	last := c.lastDriftKHz
+	if want <= 0 || st.Frequency <= 0 {
+		c.statusMu.Unlock()
+		return
+	}
+	diff := st.Frequency - want
+	if diff < 0 {
+		diff = -diff
+	}
+	if diff <= driftToleranceKHz {
+		c.lastDriftKHz = 0 // back where it was asked to be
+		c.statusMu.Unlock()
+		return
+	}
+	if last == st.Frequency {
+		c.statusMu.Unlock()
+		return // already said, and it has not moved since
+	}
+	c.lastDriftKHz = st.Frequency
+	c.statusMu.Unlock()
+	log.Printf("steppir: commanded %d kHz but the controller settled on %d kHz — "+
+		"something else is driving it (its own radio interface, or a front-panel mode overriding the host)",
+		want, st.Frequency)
+}
+
 // applyPendingDir replaces a freshly polled direction with the one the operator
 // last commanded, until the controller confirms it (or the hold expires). The
 // caller holds statusMu.

pskchase.go

@@ -0,0 +1,287 @@
+package main
+
+// Chase New — a widget listing the stations PSK Reporter is hearing NEAR HERE
+// that are new against the log.
+//
+// The feed is the one the band-opening watch and the grid store already use, so
+// this costs no extra subscription when either is on: it reads messages that
+// were arriving and being discarded. Measured on the live broker, one ring of
+// neighbour squares is 0.2 to 1.2 messages a second.
+//
+// Two things about the data decide the shape of everything below:
+//
+//   - PSK Reporter is DIGITAL ONLY. This can never show a new entity on CW or
+//     SSB, and the panel says so rather than letting an operator conclude the
+//     band is dead when it is full of CW.
+//   - A report says "X was heard BY Y". The watcher already drops anything
+//     collected further than NearKm from the operator (internal/pskr), so what
+//     arrives here is a station being heard in this region — not a world map.
+//
+// "New" is NOT decided here. It goes through ClusterSpotStatuses, the same
+// function the DX cluster grid uses, because two definitions of new is how the
+// two panels quietly start disagreeing about the same callsign.
+
+import (
+	"sort"
+	"strings"
+	"sync"
+	"time"
+
+	"hamlog/internal/applog"
+	"hamlog/internal/pskr"
+)
+
+// keyChaseNew turns the widget on. Deliberately NOT nested under "chase grids":
+// chasing squares and chasing entities are different wants, and an operator may
+// have one without the other. They only share the feed, which either one starts.
+const keyChaseNew = "cluster.chase_new"
+
+// chaseNewMax bounds the panel. A list nobody can read to the bottom is not more
+// information, and the oldest rows are the least likely to still be on the air.
+const chaseNewMax = 200
+
+// chaseSeenTTL is how long the same station stays de-duplicated on one band and
+// mode. PSK Reporter re-reports a calling station every cycle — without this the
+// panel would be one operator repeated fifty times.
+const chaseSeenTTL = 10 * time.Minute
+
+// ChaseNewSpot is one station worth looking at, as the widget shows it.
+type ChaseNewSpot struct {
+	Call    string `json:"call"`
+	Band    string `json:"band"`
+	Mode    string `json:"mode"`
+	FreqHz  int64  `json:"freq_hz"`
+	Grid    string `json:"grid"`
+	Country string `json:"country,omitempty"`
+	Cont    string `json:"cont,omitempty"`
+	DistKm  int    `json:"dist_km"`
+	Bearing int    `json:"bearing"`
+	// Status is the entity-level verdict from the cluster's own vocabulary:
+	// new | new-band | new-mode | new-slot. Empty when the row is here for a
+	// prefix or a square instead.
+	Status  string `json:"status,omitempty"`
+	NewPfx  bool   `json:"new_pfx,omitempty"`
+	NewGrid bool   `json:"new_grid,omitempty"`
+	LoTW    bool   `json:"lotw,omitempty"`
+	At      string `json:"at"` // RFC3339, stamped on receipt
+}
+
+// chaseNewStore holds what the widget shows. Written from the MQTT goroutine,
+// read by the UI poll, so everything is behind one mutex — the work per message
+// is a handful of map lookups and this must never become the reason the broker's
+// buffer backs up.
+type chaseNewStore struct {
+	mu    sync.Mutex
+	spots []ChaseNewSpot       // newest last
+	seen  map[string]time.Time // "CALL|BAND|MODE" → when it was last shown
+}
+
+func newChaseNewStore() *chaseNewStore {
+	return &chaseNewStore{seen: make(map[string]time.Time, 512)}
+}
+
+// put adds a spot unless the same station on the same band and mode is already
+// on the list. Returns false when it was a duplicate.
+func (s *chaseNewStore) put(sp ChaseNewSpot, now time.Time) bool {
+	key := sp.Call + "|" + sp.Band + "|" + sp.Mode
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if last, ok := s.seen[key]; ok && now.Sub(last) < chaseSeenTTL {
+		return false
+	}
+	s.seen[key] = now
+	s.spots = append(s.spots, sp)
+	if len(s.spots) > chaseNewMax {
+		s.spots = s.spots[len(s.spots)-chaseNewMax:]
+	}
+	// The de-duplication map is the only thing here that grows without a natural
+	// bound, so it is swept when it gets large rather than on every message.
+	if len(s.seen) > 4*chaseNewMax {
+		for k, t := range s.seen {
+			if now.Sub(t) >= chaseSeenTTL {
+				delete(s.seen, k)
+			}
+		}
+	}
+	return true
+}
+
+// list returns the spots newer than ttl, newest first.
+func (s *chaseNewStore) list(ttl time.Duration, now time.Time) []ChaseNewSpot {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	out := make([]ChaseNewSpot, 0, len(s.spots))
+	for _, sp := range s.spots {
+		at, err := time.Parse(time.RFC3339, sp.At)
+		if err == nil && ttl > 0 && now.Sub(at) > ttl {
+			continue
+		}
+		out = append(out, sp)
+	}
+	sort.SliceStable(out, func(i, j int) bool { return out[i].At > out[j].At })
+	return out
+}
+
+func (s *chaseNewStore) clear() {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.spots = nil
+	s.seen = make(map[string]time.Time, 512)
+}
+
+// chaseModes is what the panel will show. PSK Reporter reports everything its
+// receivers decode, and most of it is not a contact waiting to happen:
+//
+//   - WSPR is a beacon. Nobody answers a WSPR transmission, so a "new entity on
+//     WSPR" is a path report, not a station to work — and on a quiet band it
+//     would be most of the list.
+//   - JT65, JT9, FST4W, Q65 and the rest are real but rare enough that they
+//     would only dilute what an operator scans.
+//
+// The list is the modes an operator actually calls on. Deliberately not a
+// setting: a widget with its own mode list is a second place to get the answer
+// wrong, and this one is short enough to read.
+var chaseModes = map[string]bool{
+	"FT8": true, "FT4": true, "FT2": true, "PSK31": true, "RTTY": true,
+}
+
+// chaseNewEnabled reads the option. Called per message, so it reads the cached
+// atomic rather than the settings store.
+func (a *App) chaseNewEnabled() bool { return a.chaseNewOn.Load() }
+
+// chaseBandAllowed reports whether a band is one the operator uses.
+//
+// PSK Reporter carries every band its receivers listen on, including microwave
+// segments nobody in the region is equipped for. A 13 cm decode is not an
+// opportunity for a station with no 13 cm — it is a row in the way.
+//
+// The answer is the operator's own band list (Settings → Modes & bands), read
+// once and cached: this is consulted per message, and re-reading a JSON setting
+// at that rate on the MQTT goroutine is exactly what must not happen.
+func (a *App) chaseBandAllowed(band string) bool {
+	a.chaseBandsMu.RLock()
+	m := a.chaseBands
+	a.chaseBandsMu.RUnlock()
+	if m == nil {
+		return true // list not loaded yet — better to show than to swallow
+	}
+	return m[strings.ToLower(strings.TrimSpace(band))]
+}
+
+// refreshChaseBands re-reads the operator's band list into the cache. Called
+// when the widget is switched on and whenever the lists are saved.
+func (a *App) refreshChaseBands() {
+	s, _ := a.GetListsSettings()
+	m := make(map[string]bool, len(s.Bands))
+	for _, b := range s.Bands {
+		if b = strings.ToLower(strings.TrimSpace(b)); b != "" {
+			m[b] = true
+		}
+	}
+	a.chaseBandsMu.Lock()
+	a.chaseBands = m
+	a.chaseBandsMu.Unlock()
+}
+
+// refreshChaseNew re-reads the option into the atomic the feed consults.
+func (a *App) refreshChaseNew() {
+	on := a.settingOr(keyChaseNew, "") == "1"
+	a.chaseNewOn.Store(on)
+	if on {
+		// Read the band list here rather than per message. Saving the lists calls
+		// back into this, so a band ticked in Settings applies to the next decode.
+		a.refreshChaseBands()
+	}
+	if !on && a.chaseNew != nil {
+		// Drop the list rather than leave it on screen: it would go stale with no
+		// feed behind it, and a frozen list of "new" stations is worse than none.
+		a.chaseNew.clear()
+	}
+}
+
+// feedChaseNew turns one PSK Reporter decode into a widget row, or drops it.
+//
+// Runs on the MQTT goroutine. The cheap tests come first — the option, then the
+// de-duplication — so a station already listed costs one map lookup and nothing
+// else.
+func (a *App) feedChaseNew(sp pskr.Spot) {
+	if !a.chaseNewEnabled() || a.chaseNew == nil {
+		return
+	}
+	call := strings.ToUpper(strings.TrimSpace(sp.Call))
+	if call == "" {
+		return
+	}
+	band := strings.ToLower(strings.TrimSpace(sp.Band))
+	mode := strings.ToUpper(strings.TrimSpace(sp.Mode))
+	// Both tests before the status lookup: they are map reads on short keys and
+	// they throw away most of the feed, so nothing further down pays for a band
+	// this station cannot work or a mode nobody answers.
+	if !chaseModes[mode] || !a.chaseBandAllowed(band) {
+		return
+	}
+
+	// The same verdict the cluster grid computes, from the same cached index:
+	// map lookups per spot, no query.
+	st := a.ClusterSpotStatuses([]SpotQuery{{Call: call, Band: band, Mode: mode}})
+	if len(st) == 0 {
+		return
+	}
+	s := st[0]
+	isNew := s.Status == "new" || s.Status == "new-band" ||
+		s.Status == "new-mode" || s.Status == "new-slot" || s.NewPfx || s.NewGrid
+	if !isNew {
+		return
+	}
+
+	now := time.Now()
+	row := ChaseNewSpot{
+		Call: call, Band: band, Mode: mode, FreqHz: sp.FreqHz,
+		Grid: sp.Grid, Country: s.Country, Cont: s.Continent,
+		DistKm: sp.DistKm, Bearing: sp.Bearing,
+		Status: s.Status, NewPfx: s.NewPfx, NewGrid: s.NewGrid, LoTW: s.LoTW,
+		At: now.UTC().Format(time.RFC3339),
+	}
+	// The grid the watcher gives is the transmitter's own, straight off the air —
+	// better than anything we could look up, so it is kept even when the status
+	// index had one.
+	if row.Grid == "" {
+		row.Grid = s.Grid
+	}
+	a.chaseNew.put(row, now)
+}
+
+// GetChaseNewSpots returns what the widget should show, newest first, aged out
+// with the same spot lifetime the cluster and band maps use — one setting for
+// "how long is a spot worth looking at", not three.
+func (a *App) GetChaseNewSpots() []ChaseNewSpot {
+	if a.chaseNew == nil || !a.chaseNewEnabled() {
+		return []ChaseNewSpot{}
+	}
+	ttl := time.Duration(a.GetSpotTTLMinutes()) * time.Minute
+	return a.chaseNew.list(ttl, time.Now())
+}
+
+// GetChaseNew reports whether the widget is on.
+//
+// Reads the SETTING, not the cached atomic. The atomic exists for the MQTT
+// goroutine and is false until startup has read the option — so a UI that asked
+// this while the database was still opening was told "off", believed it, and
+// never asked again. The toolbar button only appeared after opening Settings
+// and closing it, which is what re-read it.
+func (a *App) GetChaseNew() bool { return a.settingOr(keyChaseNew, "") == "1" }
+
+// SetChaseNew turns the widget on or off and brings the feed up or down with it.
+func (a *App) SetChaseNew(on bool) error {
+	v := "0"
+	if on {
+		v = "1"
+	}
+	a.setSetting(keyChaseNew, v)
+	a.refreshChaseNew()
+	// The feed is shared: startBandOpenSources decides whether it is still needed
+	// by anything else, so turning this off does not cut the grid store loose.
+	a.startBandOpenFeed()
+	applog.Printf("chase new: %v", on)
+	return nil
+}

pskchase_test.go

@@ -0,0 +1,111 @@
+package main
+
+import (
+	"testing"
+	"time"
+)
+
+// The panel must not become one station repeated. PSK Reporter re-reports a
+// calling operator every cycle, and dozens of receivers report the same
+// transmission, so a station arrives many times a minute.
+func TestChaseNewStoreDeduplicates(t *testing.T) {
+	s := newChaseNewStore()
+	t0 := time.Date(2026, 8, 14, 12, 0, 0, 0, time.UTC)
+	row := ChaseNewSpot{Call: "VK9XX", Band: "20m", Mode: "FT8", At: t0.Format(time.RFC3339)}
+
+	if !s.put(row, t0) {
+		t.Fatal("the first sighting was rejected")
+	}
+	if s.put(row, t0.Add(2*time.Minute)) {
+		t.Error("the same station on the same band and mode was listed twice")
+	}
+	// A different band is a different opportunity — a new-band slot is exactly
+	// what an operator is watching for.
+	other := row
+	other.Band = "15m"
+	if !s.put(other, t0.Add(2*time.Minute)) {
+		t.Error("the same station on another band was suppressed")
+	}
+	// Once the window has passed it is worth showing again: the station is still
+	// there, and the row it had has aged out of the list.
+	if !s.put(row, t0.Add(chaseSeenTTL+time.Minute)) {
+		t.Error("the station never came back after the de-duplication window")
+	}
+}
+
+// The list is aged with the operator's own spot lifetime, so a station heard an
+// hour ago is not offered as something to chase now.
+func TestChaseNewStoreAgesOut(t *testing.T) {
+	s := newChaseNewStore()
+	t0 := time.Date(2026, 8, 14, 12, 0, 0, 0, time.UTC)
+	s.put(ChaseNewSpot{Call: "OLD", Band: "20m", Mode: "FT8", At: t0.Format(time.RFC3339)}, t0)
+	s.put(ChaseNewSpot{Call: "NEW", Band: "20m", Mode: "FT8",
+		At: t0.Add(20 * time.Minute).Format(time.RFC3339)}, t0.Add(20*time.Minute))
+
+	got := s.list(15*time.Minute, t0.Add(21*time.Minute))
+	if len(got) != 1 || got[0].Call != "NEW" {
+		t.Fatalf("got %+v, want only NEW", got)
+	}
+	// Newest first: an operator reads the top of this list and nothing else.
+	s.put(ChaseNewSpot{Call: "NEWEST", Band: "20m", Mode: "FT8",
+		At: t0.Add(25 * time.Minute).Format(time.RFC3339)}, t0.Add(25*time.Minute))
+	got = s.list(15*time.Minute, t0.Add(26*time.Minute))
+	if len(got) != 2 || got[0].Call != "NEWEST" {
+		t.Fatalf("got %+v, want NEWEST first", got)
+	}
+}
+
+// The list is bounded. A widget that grows without limit under a 6 m opening
+// costs memory for rows nobody will ever scroll to.
+func TestChaseNewStoreIsBounded(t *testing.T) {
+	s := newChaseNewStore()
+	t0 := time.Date(2026, 8, 14, 12, 0, 0, 0, time.UTC)
+	for i := 0; i < chaseNewMax+50; i++ {
+		at := t0.Add(time.Duration(i) * time.Second)
+		s.put(ChaseNewSpot{
+			Call: "S" + time.Duration(i).String(), Band: "20m", Mode: "FT8",
+			At: at.Format(time.RFC3339),
+		}, at)
+	}
+	if got := len(s.list(0, t0.Add(time.Hour))); got != chaseNewMax {
+		t.Errorf("kept %d rows, want the %d cap", got, chaseNewMax)
+	}
+}
+
+// The panel is for stations an operator can call. WSPR is a beacon — nobody
+// answers one — and on a quiet band it would be most of the list.
+func TestChaseModesExcludeBeaconsAndOddities(t *testing.T) {
+	for _, m := range []string{"FT8", "FT4", "FT2", "PSK31", "RTTY"} {
+		if !chaseModes[m] {
+			t.Errorf("%s should be listed", m)
+		}
+	}
+	for _, m := range []string{"WSPR", "JT65", "JT9", "FST4W", "Q65", "JS8", "MSK144", "OLIVIA", ""} {
+		if chaseModes[m] {
+			t.Errorf("%s should not be listed", m)
+		}
+	}
+}
+
+// A decode on a band the operator does not have is not an opportunity, it is a
+// row in the way — PSK Reporter carries microwave segments nobody in the region
+// is equipped for.
+func TestChaseBandAllowed(t *testing.T) {
+	a := &App{}
+	// Nothing loaded yet: show rather than swallow, or the panel would look
+	// broken for the first seconds after it is switched on.
+	if !a.chaseBandAllowed("13cm") {
+		t.Error("with no band list loaded, nothing should be filtered")
+	}
+	a.chaseBands = map[string]bool{"20m": true, "40m": true, "6m": true}
+	for _, b := range []string{"20m", "40m", "6m", " 20M "} {
+		if !a.chaseBandAllowed(b) {
+			t.Errorf("%q is in the operator's list and was dropped", b)
+		}
+	}
+	for _, b := range []string{"13cm", "23cm", "2m", "630m", ""} {
+		if a.chaseBandAllowed(b) {
+			t.Errorf("%q is not in the operator's list and was kept", b)
+		}
+	}
+}

relaycount_test.go

@@ -0,0 +1,30 @@
+package main
+
+import "testing"
+
+// The relay count is decided in Go and mirrored in the panel. When the HTTP
+// board was added to one and not the other, an operator could pick 8 channels
+// and still get 4 rows — the selector "did nothing".
+//
+// This pins the Go side, which is the one the driver is built from.
+func TestDeviceRelayCountHonoursTheChosenChannels(t *testing.T) {
+	for _, typ := range []string{"httpgen", "usbrelay", "denkovi", "dingtian"} {
+		for _, n := range []int{1, 2, 4, 8, 16} {
+			if got := deviceRelayCount(StationDevice{Type: typ, Channels: n}); got != n {
+				t.Errorf("%s with %d channels → %d", typ, n, got)
+			}
+		}
+	}
+	// Fixed-size boards ignore it: their hardware decides.
+	for typ, want := range map[string]int{"webswitch": 5, "kmtronic": 8} {
+		if got := deviceRelayCount(StationDevice{Type: typ, Channels: 3}); got != want {
+			t.Errorf("%s → %d, want its fixed %d", typ, got, want)
+		}
+	}
+	// Unset falls back to something sensible per type, not to another's default.
+	for typ, want := range map[string]int{"httpgen": 4, "dingtian": 2, "usbrelay": 8, "denkovi": 8} {
+		if got := deviceRelayCount(StationDevice{Type: typ}); got != want {
+			t.Errorf("%s with no choice → %d, want %d", typ, got, want)
+		}
+	}
+}

selfspot_comment_test.go

@@ -0,0 +1,52 @@
+package main
+
+import (
+	"testing"
+
+	"hamlog/internal/qso"
+)
+
+// A self-spot announces OUR station, so it must carry the references we are
+// activating (MY_POTA_REF…), never the QSO's award references — those belong to
+// the station we worked, and spotting yourself with someone else's park number
+// puts you somewhere you are not.
+func TestSelfSpotComment(t *testing.T) {
+	for name, c := range map[string]struct {
+		q    qso.QSO
+		want string
+	}{
+		"mode only": {
+			q:    qso.QSO{Mode: "cw"},
+			want: "CW",
+		},
+		"my park": {
+			q:    qso.QSO{Mode: "SSB", MyPOTARef: "fr-11553"},
+			want: "SSB POTA FR-11553",
+		},
+		"two references": {
+			q:    qso.QSO{Mode: "CW", MyPOTARef: "FR-11553", MySOTARef: "F/AM-123"},
+			want: "CW POTA FR-11553 SOTA F/AM-123",
+		},
+		// 30 characters is all a cluster keeps. The third reference is dropped
+		// whole rather than cut in half.
+		"too long drops the extra": {
+			q: qso.QSO{
+				Mode: "CW", MyPOTARef: "FR-11553", MySOTARef: "F/AM-123",
+				MyWWFFRef: "FFF-0123",
+			},
+			want: "CW POTA FR-11553 SOTA F/AM-123",
+		},
+		// A QSO's own award references are the DX's, and must not leak in.
+		"dx references are not ours": {
+			q:    qso.QSO{Mode: "FT8", POTARef: "US-0001", AwardRefs: `{"POTA":"US-0001"}`},
+			want: "FT8",
+		},
+	} {
+		if got := selfSpotComment(c.q); got != c.want {
+			t.Errorf("%s: got %q, want %q", name, got, c.want)
+		}
+		if got := selfSpotComment(c.q); len(got) > spotCommentMax {
+			t.Errorf("%s: %d characters, over the %d a cluster keeps", name, len(got), spotCommentMax)
+		}
+	}
+}

serialports_test.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+	"strings"
+	"testing"
+)
+
+// The exact list an operator's machine produced: COM1 and COM3 each claimed by
+// two devices in the Windows port map, and no order to speak of. The dropdown
+// showed every duplicate, and rendered its own value as "COM3COM3" because two
+// entries with the same value both counted as selected.
+func TestTidySerialPortsDeduplicatesAndOrders(t *testing.T) {
+	got := tidySerialPorts([]string{"COM1", "COM1", "COM3", "COM8", "COM9", "COM4", "COM3"})
+	want := []string{"COM1", "COM3", "COM4", "COM8", "COM9"}
+	if strings.Join(got, ",") != strings.Join(want, ",") {
+		t.Errorf("got %v, want %v", got, want)
+	}
+}
+
+// COM10 after COM9, not between COM1 and COM2 — lexical order is how a port
+// gets overlooked on a machine with a dozen of them.
+func TestTidySerialPortsSortsNaturally(t *testing.T) {
+	got := tidySerialPorts([]string{"COM10", "COM2", "COM1", "COM20", "COM3"})
+	want := []string{"COM1", "COM2", "COM3", "COM10", "COM20"}
+	if strings.Join(got, ",") != strings.Join(want, ",") {
+		t.Errorf("got %v, want %v", got, want)
+	}
+}
+
+// Not every port is a COMn: a device path or a Unix name must survive, after
+// the numbered ones, in its own order.
+func TestTidySerialPortsKeepsOtherNames(t *testing.T) {
+	got := tidySerialPorts([]string{"/dev/ttyUSB1", "COM3", "/dev/ttyUSB0", "COM1", "", "  "})
+	want := []string{"COM1", "COM3", "/dev/ttyUSB0", "/dev/ttyUSB1"}
+	if strings.Join(got, ",") != strings.Join(want, ",") {
+		t.Errorf("got %v, want %v", got, want)
+	}
+}
+
+// Case is not identity on Windows: "com3" and "COM3" are one port, and letting
+// both through would put the same duplicate back in the list.
+func TestTidySerialPortsIgnoresCase(t *testing.T) {
+	if got := tidySerialPorts([]string{"COM3", "com3"}); len(got) != 1 || got[0] != "COM3" {
+		t.Errorf("got %v, want [COM3]", got)
+	}
+}

telemetry.go

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

udptrigger.go

@@ -0,0 +1,148 @@
+package main
+
+// Wiring the custom outbound UDP/URL rows to the moments that fire them.
+//
+// One function per trigger, each building the fields its template can use. The
+// field SET is per trigger and that is the point: a rotation has no frequency, a
+// lookup has no report. The Settings panel lists what each one offers, because a
+// template that quietly renders an empty string is the worst kind of wrong.
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"sync"
+
+	"hamlog/internal/cat"
+	"hamlog/internal/integrations/udp"
+	"hamlog/internal/lookup"
+	"hamlog/internal/qso"
+)
+
+// lastTriggerBand remembers the rig's band so a change can be told from a
+// frequency moving inside one. Guarded because the CAT callback and a settings
+// reload can both reach it.
+var (
+	lastTriggerBandMu sync.Mutex
+	lastTriggerBand   string
+)
+
+// udpTriggerQSOLogged fires after a contact is written to the log.
+func (a *App) udpTriggerQSOLogged(q qso.QSO) {
+	if a.udp == nil {
+		return
+	}
+	f := map[string]string{
+		"call":    q.Callsign,
+		"band":    q.Band,
+		"band_m":  bandMetres(q.Band),
+		"mode":    q.Mode,
+		"grid":    q.Grid,
+		"name":    q.Name,
+		"country": q.Country,
+		"rst_s":   q.RSTSent,
+		"rst_r":   q.RSTRcvd,
+		"comment": q.Comment,
+		"date":    q.QSODate.UTC().Format("20060102"),
+		"time":    q.QSODate.UTC().Format("150405"),
+	}
+	if q.FreqHz != nil && *q.FreqHz > 0 {
+		f["freq_hz"] = strconv.FormatInt(*q.FreqHz, 10)
+		f["freq_mhz"] = fmt.Sprintf("%.6f", float64(*q.FreqHz)/1e6)
+	}
+	if q.DXCC != nil {
+		f["dxcc"] = strconv.Itoa(*q.DXCC)
+	}
+	a.udp.EmitTrigger(udp.TriggerQSOLogged, f)
+}
+
+// udpTriggerRotator fires whenever the antenna is told to turn — the header's
+// SP and LP buttons, the compass, a click on a spot.
+//
+// Hooked to the COMMAND rather than to a button: one place, and it stays true
+// when the interface changes. path is "SP", "LP" or "" when the caller did not
+// say which.
+func (a *App) udpTriggerRotator(az, el int, path string) {
+	if a.udp == nil {
+		return
+	}
+	f := map[string]string{
+		"az":   strconv.Itoa(az),
+		"path": path,
+	}
+	if el >= 0 {
+		f["el"] = strconv.Itoa(el)
+	}
+	a.udp.EmitTrigger(udp.TriggerRotatorGo, f)
+}
+
+// udpTriggerLookup fires after a callbook lookup returns.
+func (a *App) udpTriggerLookup(r *lookup.Result) {
+	if a.udp == nil || r == nil {
+		return
+	}
+	a.udp.EmitTrigger(udp.TriggerLookupDone, map[string]string{
+		"call":    r.Callsign,
+		"name":    r.Name,
+		"grid":    r.Grid,
+		"country": r.Country,
+		"qth":     r.QTH,
+		"state":   r.State,
+		"dxcc":    strconv.Itoa(r.DXCC),
+	})
+}
+
+// udpTriggerBandChange fires when the RIG changes band — not the entry form: an
+// antenna switch follows the radio, not what is being typed.
+//
+// Called from the CAT state callback, which runs on every user-relevant change,
+// so the comparison against the last band is what makes this rare rather than
+// continuous. No damping needed beyond that.
+func (a *App) udpTriggerBandChange(s cat.RigState) {
+	if a.udp == nil {
+		return
+	}
+	band := strings.ToLower(strings.TrimSpace(s.Band))
+	if band == "" || !s.Connected {
+		return
+	}
+	lastTriggerBandMu.Lock()
+	changed := band != lastTriggerBand
+	if changed {
+		lastTriggerBand = band
+	}
+	lastTriggerBandMu.Unlock()
+	if !changed {
+		return
+	}
+	f := map[string]string{
+		"band":   band,
+		"band_m": bandMetres(band),
+		"mode":   s.Mode,
+	}
+	if s.FreqHz > 0 {
+		f["freq_hz"] = strconv.FormatInt(s.FreqHz, 10)
+		f["freq_mhz"] = fmt.Sprintf("%.6f", float64(s.FreqHz)/1e6)
+	}
+	a.udp.EmitTrigger(udp.TriggerBandChange, f)
+}
+
+// bandMetres turns "20m" into "20" — an antenna switch usually wants the number
+// and nothing else, and asking an operator to strip it in a template would be
+// one more thing to get wrong.
+func bandMetres(band string) string {
+	b := strings.ToLower(strings.TrimSpace(band))
+	b = strings.TrimSuffix(b, "m")
+	b = strings.TrimSuffix(b, "c") // "70cm" → "70c" → "70"
+	if b == "" {
+		return ""
+	}
+	for _, r := range b {
+		if r < '0' || r > '9' {
+			if r != '.' {
+				return ""
+			}
+		}
+	}
+	return b
+}