chore: release v0.25.4

Logger32's WinKeyer debug against the K3NG that will not answer OpsLog is a
capture of the exchange working, on the same keyer and the same port:

    Sent: 13 13 13 00 04 55
    Rcvd: 55            (72 ms)
    Sent: 00 02  Host open
    Rcvd: 23            (WK2 v23)

That is the sequence I already send. The difference is the grouping: Logger32
puts the three nulls and the echo probe in ONE write, and we split them with a
50 ms pause and a buffer purge in between. On a keyer that reboots when the
port opens, that pause is a window for it to come up mid-sequence and swallow
half of it — and there was nothing to wait for, since a null produces no reply.

The handshake bytes are now logged unconditionally, not behind the diagnostic
option. "No WinKeyer answered" cannot be told apart from a wrong port, a wrong
baud rate, a keyer still booting, or another program holding the line. The
bytes can, and it is four lines per connect attempt.

amps_linked_test.go

@@ -0,0 +1,63 @@
+package main
+
+import "testing"
+
+// The coupling is a SET, not a global switch.
+//
+// A station can run a combiner pair AND a third amplifier that has nothing to
+// do with it — two SPE on the combiner, a PowerGenius on another antenna. A
+// global flag would send that third one into OPERATE alongside them.
+func TestAmpTargetsFollowTheGroup(t *testing.T) {
+	a := &App{}
+	a.ampInsts = map[string]*ampInst{"spe1": {}, "spe2": {}, "pgxl": {}}
+	group := []string{"spe1", "spe2"}
+
+	// A member commands the whole group, itself first.
+	got := a.ampTargets("spe2", group)
+	if len(got) != 2 || got[0] != "spe2" || got[1] != "spe1" {
+		t.Errorf("member = %v, want [spe2 spe1] — the clicked one first", got)
+	}
+
+	// The amplifier OUTSIDE the group keeps its buttons to itself.
+	if got := a.ampTargets("pgxl", group); len(got) != 1 || got[0] != "pgxl" {
+		t.Errorf("outsider = %v, want just [pgxl]", got)
+	}
+
+	// No group at all: everyone is on their own.
+	if got := a.ampTargets("spe1", nil); len(got) != 1 || got[0] != "spe1" {
+		t.Errorf("no group = %v, want just [spe1]", got)
+	}
+
+	// A group remembering an amplifier that is gone must not carry it: it would
+	// fail the command for a member that no longer exists.
+	if got := a.ampTargets("spe1", []string{"spe1", "deleted"}); len(got) != 1 || got[0] != "spe1" {
+		t.Errorf("stale member = %v, want it dropped", got)
+	}
+}
+
+// One amplifier coupled to itself is not a group — storing it would make every
+// command fan out to a single member for ever, which is just noise.
+func TestLinkedAmpsNeedsTwo(t *testing.T) {
+	for _, tc := range []struct {
+		in   []string
+		want int
+	}{
+		{[]string{"a", "b"}, 2},
+		{[]string{"a"}, 0},
+		{[]string{"  ", "a"}, 0}, // blanks are not members
+		{nil, 0},
+	} {
+		clean := make([]string, 0, len(tc.in))
+		for _, id := range tc.in {
+			if id != "" && id != "  " {
+				clean = append(clean, id)
+			}
+		}
+		if len(clean) < 2 {
+			clean = nil
+		}
+		if len(clean) != tc.want {
+			t.Errorf("SetLinkedAmps(%v) would keep %d, want %d", tc.in, len(clean), tc.want)
+		}
+	}
+}

app_qsl_designer.go

@@ -31,7 +31,7 @@ import (
 const (
 	keyQSLEmailSubject = "qsl.email_subject"
 	keyQSLEmailBody    = "qsl.email_body"
-	keyQSLAutoSend     = "qsl.auto_send"      // "1" → render+send an eQSL on log when an e-mail and default template exist
+	keyQSLAutoSend     = "qsl.auto_send"       // "1" → render+send an eQSL on log when an e-mail and default template exist
 	keyQSLDefaultMsg   = "qsl.default_message" // fallback QSL message printed on the card when the QSO's own QSLMSG is empty
 )
 
@@ -748,3 +748,165 @@ func sampleQSO() qso.QSO {
 		QSLMsg:   "TNX FB QSO — 73!",
 	}
 }
+
+// QSLForeignTemplate is one card design belonging to ANOTHER profile, offered
+// for copying into the active one.
+type QSLForeignTemplate struct {
+	ID          int64  `json:"id"`
+	Name        string `json:"name"`
+	ProfileID   int64  `json:"profile_id"`
+	ProfileName string `json:"profile_name"`
+}
+
+// QSLListOtherProfileTemplates lists the designs the ACTIVE profile cannot see.
+//
+// A second profile is usually the same operator with a different rig or a
+// different locator — same callsign, same cards. Redrawing a design because the
+// antenna changed is work nobody should have to do, and the designs a profile
+// already sees (its own, and the shared ones) are deliberately left out: they
+// are not something to copy.
+func (a *App) QSLListOtherProfileTemplates() ([]QSLForeignTemplate, error) {
+	if a.qslTemplates == nil || a.profiles == nil {
+		return nil, fmt.Errorf("db not initialized")
+	}
+	active := int64(-1)
+	if p, err := a.profiles.Active(a.ctx); err == nil {
+		active = p.ID
+	}
+	names := map[int64]string{}
+	if list, err := a.ListProfiles(); err == nil {
+		for _, p := range list {
+			names[p.ID] = p.Name
+		}
+	}
+	all, err := a.qslTemplates.List(a.ctx)
+	if err != nil {
+		return nil, err
+	}
+	out := []QSLForeignTemplate{}
+	for _, r := range all {
+		// Shared designs (no profile) already appear in every profile's list.
+		if r.ProfileID == nil || *r.ProfileID == active {
+			continue
+		}
+		out = append(out, QSLForeignTemplate{
+			ID: r.ID, Name: r.Name, ProfileID: *r.ProfileID,
+			ProfileName: firstNonEmptyStr(names[*r.ProfileID], fmt.Sprintf("profile %d", *r.ProfileID)),
+		})
+	}
+	return out, nil
+}
+
+// QSLCopyTemplateToActiveProfile duplicates another profile's design into the
+// active one and returns the new id.
+//
+// A COPY, not a move or a share. The original profile keeps its design
+// untouched, and the copy is free to diverge — a second profile usually exists
+// because something differs, and that something often ends up on the card.
+func (a *App) QSLCopyTemplateToActiveProfile(id int64) (int64, error) {
+	if a.qslTemplates == nil {
+		return 0, fmt.Errorf("db not initialized")
+	}
+	src, err := a.qslTemplates.Get(a.ctx, id)
+	if err != nil {
+		return 0, err
+	}
+	// The stored document references photos by NAME, relative to the template's
+	// own asset folder — so copying the JSON alone would point the new design at
+	// files that are not in its folder, and the save would fail validation.
+	//
+	// The files are copied too, giving the duplicate its own folder. Sharing the
+	// source's would mean deleting one design silently emptied the other.
+	rec := qslcard.Record{Name: src.Name + " (copy)", JSON: src.JSON}
+	if p, e := a.profiles.Active(a.ctx); e == nil {
+		rec.ProfileID = &p.ID
+	}
+	// Saved first: a new template needs its id before it can own a folder.
+	if err := a.qslTemplates.Save(a.ctx, &rec); err != nil {
+		return 0, err
+	}
+	srcDir := qslcard.TemplateDir(a.qslDir(), id)
+	dstDir := qslcard.TemplateDir(a.qslDir(), rec.ID)
+	// A design with no pictures at all has no folder, and that is not a failure.
+	// Anything else IS: this used to be written as "ignore os.IsNotExist", which
+	// also swallowed every ENOENT raised while copying — so a failed copy looked
+	// like a design that had nothing to copy, and the operator got "hero photo
+	// not found" with no clue why.
+	if _, statErr := os.Stat(srcDir); statErr == nil {
+		if err := copyDirContents(srcDir, dstDir); err != nil {
+			// Roll back rather than leave a design whose pictures are missing.
+			_ = a.qslTemplates.Delete(a.ctx, rec.ID)
+			_ = qslcard.RemoveTemplateDir(a.qslDir(), rec.ID)
+			return 0, fmt.Errorf("copy template assets: %w", err)
+		}
+	}
+	// Every failure from here rolls back BOTH halves: deleting only the row would
+	// leave the copied pictures on disk under an id nothing refers to.
+	rollback := func() {
+		_ = a.qslTemplates.Delete(a.ctx, rec.ID)
+		_ = qslcard.RemoveTemplateDir(a.qslDir(), rec.ID)
+	}
+	t, err := qslcard.Parse([]byte(rec.JSON))
+	if err != nil {
+		rollback()
+		return 0, err
+	}
+	if err := qslcard.Validate(t, qslcard.PhotoExistsIn(dstDir)); err != nil {
+		rollback()
+		return 0, fmt.Errorf("copied design is incomplete: %w", err)
+	}
+	applog.Printf("qsl: copied template %q (id %d) into the active profile as %q (id %d)",
+		src.Name, id, rec.Name, rec.ID)
+	return rec.ID, nil
+}
+
+// copyQSLTemplatesToProfile duplicates one profile's QSL designs into another,
+// PICTURES INCLUDED.
+//
+// This was an INSERT … SELECT, which cloned the rows and nothing else. A design
+// references its photos by name, relative to its own asset folder, so every
+// duplicated design pointed at a folder that did not exist: no thumbnail in the
+// designer, and nothing to print. The rows looked right, which is why it went
+// unnoticed — the damage is entirely on disk.
+//
+// Row by row rather than in one statement, because each new design needs its id
+// before it can own a folder. A design whose files cannot be copied is dropped
+// rather than kept empty: an operator who sees the design listed will believe
+// it works.
+func (a *App) copyQSLTemplatesToProfile(fromProfile, toProfile int64) error {
+	if a.qslTemplates == nil {
+		return fmt.Errorf("db not initialized")
+	}
+	all, err := a.qslTemplates.List(a.ctx)
+	if err != nil {
+		return err
+	}
+	for _, src := range all {
+		if src.ProfileID == nil || *src.ProfileID != fromProfile {
+			continue
+		}
+		rec := qslcard.Record{Name: src.Name, JSON: src.JSON, IsDefault: src.IsDefault}
+		to := toProfile
+		rec.ProfileID = &to
+		if err := a.qslTemplates.Save(a.ctx, &rec); err != nil {
+			return err
+		}
+		srcDir := qslcard.TemplateDir(a.qslDir(), src.ID)
+		if _, statErr := os.Stat(srcDir); statErr != nil {
+			continue // a design with no pictures at all — nothing to carry over
+		}
+		if err := copyDirContents(srcDir, qslcard.TemplateDir(a.qslDir(), rec.ID)); err != nil {
+			_ = a.qslTemplates.Delete(a.ctx, rec.ID)
+			_ = qslcard.RemoveTemplateDir(a.qslDir(), rec.ID)
+			return fmt.Errorf("copy assets of %q: %w", src.Name, err)
+		}
+	}
+	return nil
+}
+
+func firstNonEmptyStr(a, b string) string {
+	if strings.TrimSpace(a) != "" {
+		return a
+	}
+	return b
+}

appearance.go

@@ -0,0 +1,159 @@
+package main
+
+// Row colouring for the log grid, by QSL / LoTW status — the thing Logger32 does
+// and the reason an operator can tell at a glance what still needs sending.
+//
+// Rules are ORDERED and the first match wins, because a contact is usually
+// several things at once: one confirmed on LoTW and by card is confirmed, not
+// "sent, awaiting reply". Putting the order in the data rather than in a chain
+// of ifs is what lets the settings panel show it in the same order it applies.
+
+import (
+	"encoding/json"
+	"regexp"
+	"strings"
+)
+
+// RowColorRule is one status and the colour it paints.
+type RowColorRule struct {
+	ID      string `json:"id"`
+	Color   string `json:"color"`
+	Enabled bool   `json:"enabled"`
+	// Channels this rule looks at: qsl (paper), lotw, eqsl, qrz.
+	//
+	// Empty means ALL of them — what an operator expects from a rule they have
+	// not narrowed, and what keeps a config written before this field meaningful.
+	Channels []string `json:"channels"`
+}
+
+// The QSL channels a rule can be scoped to.
+var rowColorChannels = []string{"qsl", "lotw", "eqsl", "qrz"}
+
+// RowColorSettings is the whole appearance block.
+type RowColorSettings struct {
+	Enabled bool `json:"enabled"`
+	// Style is how the colour is shown: "bar" paints a stripe down the left edge,
+	// "tint" washes the row, "both" does each.
+	//
+	// A bar is the default because a filled row is a poor signal in a log where
+	// nearly every contact has SOME QSL state: colour that is always present
+	// stops being information and becomes a striped background, with the data
+	// behind it. The stripe says the same thing and costs nothing to read.
+	Style string `json:"style"`
+	// Intensity is the tint strength in percent. Only used by "tint"/"both".
+	Intensity int `json:"intensity"`
+	// BandMapLotw marks stations that upload to LoTW on the band map, with the
+	// same "L" badge the cluster list uses — one visual vocabulary across the two
+	// views rather than a second invention.
+	BandMapLotw bool `json:"bandmap_lotw"`
+	// Configured distinguishes "saved with this off" from "saved before the
+	// option existed", so a new marker can default ON without silently turning
+	// itself back on for an operator who switched it off.
+	Configured bool           `json:"configured"`
+	Rules      []RowColorRule `json:"rules"`
+}
+
+// The rule ids, in priority order. The frontend matches on these and holds the
+// labels, so a translated name never has to travel through the settings.
+// The four categories, in the order they are tested — first match wins.
+//
+// "To send" comes FIRST on purpose. A contact can be confirmed on LoTW and
+// still owe a paper card, and the colour an operator scans for is the one that
+// means "there is something left to do here". Put after "confirmed", that row
+// would go green and the card would never be printed.
+//
+// "Worked" is the catch-all: a contact with nothing sent, nothing asked for and
+// nothing back. Off by default — with it on, every remaining row is painted.
+var rowColorOrder = []string{
+	"to_send",   // requested or queued on a watched channel, not gone out
+	"confirmed", // a watched channel has a confirmation back
+	"sent",      // gone out on a watched channel, nothing back yet
+	"worked",    // none of the above
+}
+
+// Defaults: green for done, amber for waiting, blue for owed. Deliberately
+// muted — they are composited at low opacity over a dark grid, and a saturated
+// value there reads as an error state rather than a status.
+var rowColorDefaults = map[string]string{
+	"to_send":   "#a855f7",
+	"confirmed": "#16a34a",
+	"sent":      "#f59e0b",
+	"worked":    "#64748b",
+}
+
+// hexColor guards what reaches the stylesheet. The value is interpolated into a
+// CSS color-mix() by the grid, so anything that is not plainly a hex colour is
+// refused rather than passed through.
+var hexColor = regexp.MustCompile(`^#[0-9a-fA-F]{6}$`)
+
+func normRowColors(s RowColorSettings) RowColorSettings {
+	byID := map[string]RowColorRule{}
+	for _, r := range s.Rules {
+		byID[r.ID] = r
+	}
+	out := RowColorSettings{
+		Enabled: s.Enabled, Style: s.Style, Intensity: s.Intensity,
+		BandMapLotw: s.BandMapLotw, Configured: true,
+	}
+	if !s.Configured {
+		out.BandMapLotw = true // new option, on unless the operator says otherwise
+	}
+	switch out.Style {
+	case "bar", "tint", "both":
+	default:
+		out.Style = "bar"
+	}
+	// Clamped rather than rejected: the value only shapes a colour-mix, and a
+	// number outside the range is a slider that got away, not a fault worth
+	// resetting the operator's whole choice for.
+	if out.Intensity < 5 {
+		out.Intensity = 12
+	} else if out.Intensity > 45 {
+		out.Intensity = 45
+	}
+	ok := map[string]bool{}
+	for _, c := range rowColorChannels {
+		ok[c] = true
+	}
+	for _, id := range rowColorOrder {
+		r := byID[id]
+		r.ID = id
+		if !hexColor.MatchString(strings.TrimSpace(r.Color)) {
+			r.Color = rowColorDefaults[id]
+		}
+		// Keep only channels we know, in the canonical order, de-duplicated.
+		want := map[string]bool{}
+		for _, c := range r.Channels {
+			want[strings.ToLower(strings.TrimSpace(c))] = true
+		}
+		chans := []string{}
+		for _, c := range rowColorChannels {
+			if want[c] {
+				chans = append(chans, c)
+			}
+		}
+		r.Channels = chans
+		out.Rules = append(out.Rules, r)
+	}
+	return out
+}
+
+// GetRowColors returns the row-colouring configuration, defaults included so the
+// panel never has to invent one.
+func (a *App) GetRowColors() RowColorSettings {
+	var s RowColorSettings
+	if raw := a.settingOr(keyRowColors, ""); raw != "" {
+		_ = json.Unmarshal([]byte(raw), &s)
+	}
+	return normRowColors(s)
+}
+
+// SaveRowColors persists it.
+func (a *App) SaveRowColors(s RowColorSettings) error {
+	b, err := json.Marshal(normRowColors(s))
+	if err != nil {
+		return err
+	}
+	a.setSetting(keyRowColors, string(b))
+	return nil
+}

appearance_test.go

@@ -0,0 +1,114 @@
+package main
+
+import "testing"
+
+// The colour is interpolated into a CSS color-mix() by the grid, so anything
+// that is not plainly a hex colour has to be refused rather than passed on.
+func TestRowColorsRefuseAnythingButHex(t *testing.T) {
+	in := RowColorSettings{Enabled: true, Rules: []RowColorRule{
+		{ID: "confirmed", Color: "#123abc", Enabled: true},
+		{ID: "sent", Color: "red; background:url(x)", Enabled: true},
+		{ID: "to_send", Color: "", Enabled: true},
+	}}
+	got := normRowColors(in)
+
+	byID := map[string]RowColorRule{}
+	for _, r := range got.Rules {
+		byID[r.ID] = r
+	}
+	if byID["confirmed"].Color != "#123abc" {
+		t.Errorf("a valid colour was rewritten: %q", byID["confirmed"].Color)
+	}
+	if byID["sent"].Color != rowColorDefaults["sent"] {
+		t.Errorf("an injection attempt survived: %q", byID["sent"].Color)
+	}
+	if byID["to_send"].Color != rowColorDefaults["to_send"] {
+		t.Errorf("an empty colour was kept: %q", byID["to_send"].Color)
+	}
+}
+
+// Priority lives in the data, not in a chain of ifs: a contact confirmed on
+// LoTW AND by card is confirmed, not "sent, awaiting reply". The panel shows
+// the rules in the order they apply, so that order must survive a round trip.
+func TestRowColorsKeepPriorityOrder(t *testing.T) {
+	// Saved in a jumbled order, as a hand-edited settings row could be.
+	got := normRowColors(RowColorSettings{Rules: []RowColorRule{
+		{ID: "to_send", Color: "#111111"},
+		{ID: "confirmed", Color: "#222222"},
+	}})
+	if len(got.Rules) != len(rowColorOrder) {
+		t.Fatalf("got %d rules, want every one present", len(got.Rules))
+	}
+	for i, id := range rowColorOrder {
+		if got.Rules[i].ID != id {
+			t.Errorf("rule %d is %q, want %q", i, got.Rules[i].ID, id)
+		}
+	}
+	// The saved colours survived the reordering: each stayed with its own rule.
+	byID := map[string]string{}
+	for _, r := range got.Rules {
+		byID[r.ID] = r.Color
+	}
+	if byID["to_send"] != "#111111" || byID["confirmed"] != "#222222" {
+		t.Errorf("colours moved between rules: %v", byID)
+	}
+}
+
+// Style and strength are normalised, not rejected: they only shape a colour, and
+// a value that got away is a slider, not a fault worth resetting the operator's
+// whole choice for.
+func TestRowColorsNormaliseStyleAndIntensity(t *testing.T) {
+	for _, tc := range []struct {
+		inStyle   string
+		inPct     int
+		wantStyle string
+		wantPct   int
+	}{
+		{"bar", 12, "bar", 12},
+		{"tint", 30, "tint", 30},
+		{"both", 45, "both", 45},
+		{"", 0, "bar", 12},           // never configured
+		{"wallpaper", 12, "bar", 12}, // not a style we draw
+		{"tint", 900, "tint", 45},    // clamped, not reset
+		{"tint", -5, "tint", 12},
+	} {
+		got := normRowColors(RowColorSettings{Style: tc.inStyle, Intensity: tc.inPct})
+		if got.Style != tc.wantStyle || got.Intensity != tc.wantPct {
+			t.Errorf("(%q,%d) -> (%q,%d), want (%q,%d)",
+				tc.inStyle, tc.inPct, got.Style, got.Intensity, tc.wantStyle, tc.wantPct)
+		}
+	}
+}
+
+// Channels are normalised to the canonical order, and anything unknown is
+// dropped. Empty stays empty, because empty means "every channel" — a rule the
+// operator has not narrowed must not silently become a rule about nothing.
+func TestRowColorChannelsNormalise(t *testing.T) {
+	got := normRowColors(RowColorSettings{Rules: []RowColorRule{
+		{ID: "confirmed", Color: "#111111", Channels: []string{"LOTW", "pigeon", "qsl", "lotw"}},
+		{ID: "sent", Color: "#222222"},
+	}})
+	byID := map[string][]string{}
+	for _, r := range got.Rules {
+		byID[r.ID] = r.Channels
+	}
+	if len(byID["confirmed"]) != 2 || byID["confirmed"][0] != "qsl" || byID["confirmed"][1] != "lotw" {
+		t.Errorf("confirmed channels = %v, want [qsl lotw] — canonical order, deduped, unknown dropped", byID["confirmed"])
+	}
+	if len(byID["sent"]) != 0 {
+		t.Errorf("sent channels = %v, want empty (meaning every channel)", byID["sent"])
+	}
+}
+
+// The order IS the priority, and "to send" leads. A contact confirmed on LoTW
+// that still owes a paper card must read as owing the card — put after
+// "confirmed" it would go green and never be printed.
+func TestToSendOutranksConfirmed(t *testing.T) {
+	got := normRowColors(RowColorSettings{})
+	if got.Rules[0].ID != "to_send" {
+		t.Errorf("first rule is %q, want to_send", got.Rules[0].ID)
+	}
+	if got.Rules[len(got.Rules)-1].ID != "worked" {
+		t.Errorf("last rule is %q, want worked as the catch-all", got.Rules[len(got.Rules)-1].ID)
+	}
+}

bandopen_sources.go

@@ -21,6 +21,8 @@ import (
 	"hamlog/internal/applog"
 	"hamlog/internal/bandopen"
 	"hamlog/internal/cluster"
+	"hamlog/internal/geo"
+	"hamlog/internal/gridcache"
 	"hamlog/internal/pskr"
 )
 
@@ -126,19 +128,63 @@ func (a *App) startBandOpenFeed() {
 		a.pskr = nil
 	}
 	s := a.GetBandOpenSettings()
+	a.bandOpen.on.Store(s.Enabled)
+	a.setBandOpenBands(s.Bands)
 	if !s.Enabled {
+		// Put out whatever is currently lit. Leaving the badges up would keep
+		// announcing an opening from a watch that is now off, and they only fade
+		// on a timer fed by spots this path no longer looks at — so they would
+		// hang there until the app restarted.
+		a.clearBandOpenings()
+	}
+	chaseGrids := a.gridStore != nil
+	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
 	// nothing to measure, and a detector fed unmeasurable spots reports nothing
 	// while looking like it is working.
 	if !a.opSet {
-		applog.Printf("bandopen: no station grid set — the opening watch needs one to measure a path")
+		applog.Printf("pskr: no station grid set — the feed needs one to measure a path")
 		return
 	}
+
+	// Grid chasing and new-chasing want every band; the opening watch wants its
+	// four. "+" is the MQTT single-level wildcard, so one subscription per square
+	// covers the lot.
+	bands := s.Bands
+	if chaseGrids || chaseNew {
+		bands = []string{"+"}
+	}
+	// Filter at the BROKER on the receiver's square rather than receiving the
+	// world and discarding it here. Measured on the live feed: the four opening
+	// bands unfiltered are 83 messages a second, of which roughly one in a
+	// hundred survived the NearKm test below. One ring of squares — about the
+	// same 300 km — is 0.2 to 1.2 a second, and the same for every operator,
+	// where filtering by DXCC ranged from 1.2 (OH) to 72.5 (K).
+	rxGrids := geo.NeighbourGrids(a.opLat, a.opLon, 1)
+
+	var onGrid func(call, grid string)
+	if chaseGrids {
+		onGrid = func(call, grid string) { a.rememberDecodeGrid(call, grid, gridcache.SourceMQTT) }
+	}
+	var onSpot func(pskr.Spot)
+	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{
-		Bands: s.Bands,
-		OpLat: a.opLat, OpLon: a.opLon,
+		Bands:   bands,
+		RxGrids: rxGrids,
+		OpLat:   a.opLat, OpLon: a.opLon,
 		Geo: func(grid string) (int, int, bool) {
 			lat, lon, ok := gridToLatLon(grid)
 			if !ok {
@@ -150,12 +196,16 @@ func (a *App) startBandOpenFeed() {
 			b := int(initialBearingDeg(a.opLat, a.opLon, lat, lon) + 0.5)
 			return d, b, true
 		},
-		OnSpot: a.feedBandOpen,
+		OnSpot: onSpot,
+		OnGrid: onGrid,
 		Logf:   applog.Printf,
 	})
 	if err := a.pskr.Start(); err != nil {
-		applog.Printf("bandopen: PSK Reporter feed did not start: %v", err)
+		applog.Printf("pskr: feed did not start: %v", err)
+		return
 	}
+	applog.Printf("pskr: feed up — bands %v, %d receiver squares (openings=%v, grids=%v, chase-new=%v)",
+		bands, len(rxGrids), s.Enabled, chaseGrids, chaseNew)
 }
 
 // feedBandOpen hands one PSK Reporter decode to the detector.
@@ -164,7 +214,7 @@ func (a *App) startBandOpenFeed() {
 // so it does the least possible: the detector's own window and de-duplication
 // by callsign are what turn that flood into one announcement.
 func (a *App) feedBandOpen(s pskr.Spot) {
-	if !bandopen.Watched(s.Band) {
+	if !a.bandOpenWanted(s.Band) {
 		return
 	}
 	a.bandOpen.mu.Lock()

bandopening.go

@@ -11,6 +11,7 @@ import (
 	"fmt"
 	"strings"
 	"sync"
+	"sync/atomic"
 	"time"
 
 	"hamlog/internal/applog"
@@ -21,7 +22,21 @@ import (
 )
 
 type bandOpenState struct {
-	mu   sync.Mutex
+	// on mirrors the "Watch for band openings" setting.
+	//
+	// Cached rather than read per spot: this is the cluster hot path, where a
+	// settings query per spot is exactly what the rest of this file avoids.
+	// startBandOpenFeed owns it — it runs at startup and again on every save, so
+	// the switch takes effect without a restart.
+	on atomic.Bool
+	// bands is the operator's SELECTED set, held as map[string]bool.
+	//
+	// bandopen.Watched only says which bands the detector is capable of; it
+	// knows nothing about the chips in Settings. Nothing checked the selection
+	// on either feed path, so unticking 10 m and 2 m changed the subscription and
+	// left the cluster path announcing them anyway.
+	bands atomic.Value
+	mu    sync.Mutex
 	det  *bandopen.Detector
 	last []bandopen.Opening // most recent first, for the UI
 	// live holds the announced openings that are still going, keyed by band, and
@@ -45,6 +60,16 @@ const maxRememberedOpenings = 20
 
 // detectBandOpening feeds one spot to the detector and announces a hit.
 func (a *App) detectBandOpening(s cluster.Spot) {
+	// The watch has to be switched on.
+	//
+	// It was not checked here at all: the setting only ever governed the extra
+	// DATA SOURCES (the RBN nodes and the PSK Reporter feed), while the detector
+	// itself ran on every ordinary cluster spot. So an operator who had never
+	// enabled the watch still got opening banners, from a feature they had
+	// deliberately left off.
+	if !a.bandOpen.on.Load() || !a.bandOpenWanted(s.Band) {
+		return
+	}
 	// No operator grid = no distance and no bearing on the spot, and the whole
 	// detection rests on those two. Say nothing rather than guess.
 	if !a.opSet || s.DistanceKm <= 0 || !bandopen.Watched(s.Band) {
@@ -122,6 +147,56 @@ func (a *App) GetLiveOpenings() []bandopen.Opening {
 	return out
 }
 
+// bandOpenWanted reports whether the operator has this band ticked. Falls back
+// to the detector's own set until a selection has been stored, so a band is
+// never silently dropped before the settings have been read.
+func (a *App) bandOpenWanted(band string) bool {
+	if !bandopen.Watched(band) {
+		return false
+	}
+	sel, ok := a.bandOpen.bands.Load().(map[string]bool)
+	if !ok || len(sel) == 0 {
+		return true
+	}
+	return sel[strings.ToLower(strings.TrimSpace(band))]
+}
+
+// setBandOpenBands records the selection and puts out badges for bands that
+// have just been unticked — they fade on a timer fed by spots the detector no
+// longer looks at, so they would otherwise stay lit until the next restart.
+func (a *App) setBandOpenBands(bands []string) {
+	sel := make(map[string]bool, len(bands))
+	for _, b := range bands {
+		sel[strings.ToLower(strings.TrimSpace(b))] = true
+	}
+	a.bandOpen.bands.Store(sel)
+
+	a.bandOpen.mu.Lock()
+	defer a.bandOpen.mu.Unlock()
+	for b := range a.bandOpen.live {
+		if len(sel) > 0 && !sel[b] {
+			delete(a.bandOpen.live, b)
+			delete(a.bandOpen.aliveUntil, b)
+			applog.Printf("bandopen: %s is no longer watched — badge cleared", strings.ToUpper(b))
+		}
+	}
+}
+
+// clearBandOpenings puts out every lit badge and forgets the detector's window.
+// Called when the watch is switched off: the badges fade on a timer fed by
+// spots the detector no longer looks at, so without this they would stay up
+// until the next restart. The remembered list is left alone — those openings
+// really did happen, and the operator may still want to see what he missed.
+func (a *App) clearBandOpenings() {
+	a.bandOpen.mu.Lock()
+	defer a.bandOpen.mu.Unlock()
+	a.bandOpen.live = nil
+	a.bandOpen.aliveUntil = nil
+	// Drop the accumulated spot window too, so switching the watch back on starts
+	// from what is on the air now rather than from an hour-old burst.
+	a.bandOpen.det = nil
+}
+
 // announceOpening logs and pushes one detection. Shared by both feeds — the
 // cluster path here and the PSK Reporter path in bandopen_sources.go — so an
 // opening reads the same however it was noticed.

bandopening_gate_test.go

@@ -0,0 +1,118 @@
+package main
+
+import (
+	"testing"
+	"time"
+
+	"hamlog/internal/bandopen"
+	"hamlog/internal/cluster"
+)
+
+// The "Watch for band openings" switch has to gate the DETECTOR, not just the
+// extra data sources.
+//
+// It originally governed only the RBN nodes and the PSK Reporter feed, while
+// the detector itself ran on every ordinary cluster spot — so an operator who
+// had never enabled the watch still got opening banners for a feature he had
+// deliberately left off. That is what this pins.
+func TestBandOpenWatchGatesTheDetector(t *testing.T) {
+	spot := func() cluster.Spot {
+		return cluster.Spot{
+			DXCall: "EA1ABC", Band: "6m", DistanceKm: 1400, ShortPath: 210,
+			ReceivedAt: time.Now(),
+		}
+	}
+
+	// Switched off: the spot must not even reach the detector.
+	off := &App{opSet: true, opLat: 48.0, opLon: 2.0}
+	off.detectBandOpening(spot())
+	if off.bandOpen.det != nil {
+		t.Error("the detector ran with the watch switched off")
+	}
+
+	// Switched on: the same spot is accepted (one spot is not an opening, so
+	// nothing is announced — but the detector now exists and is collecting).
+	on := &App{opSet: true, opLat: 48.0, opLon: 2.0}
+	on.bandOpen.on.Store(true)
+	on.detectBandOpening(spot())
+	if on.bandOpen.det == nil {
+		t.Error("the detector did not run with the watch switched on")
+	}
+}
+
+// Switching the watch off must put the badges out. They fade on a timer fed by
+// spots the detector no longer looks at, so left alone they would stay lit
+// until the next restart.
+func TestClearBandOpeningsPutsTheBadgesOut(t *testing.T) {
+	a := &App{}
+	a.bandOpen.live = map[string]bandopen.Opening{"6m": {Band: "6m", Calls: 9}}
+	a.bandOpen.aliveUntil = map[string]time.Time{"6m": time.Now().Add(time.Hour)}
+	a.bandOpen.det = bandopen.New(bandopen.DefaultConfig())
+	a.bandOpen.last = []bandopen.Opening{{Band: "6m", Calls: 9}}
+
+	a.clearBandOpenings()
+
+	if got := a.GetLiveOpenings(); len(got) != 0 {
+		t.Errorf("a badge stayed lit after the watch was switched off: %v", got)
+	}
+	if a.bandOpen.det != nil {
+		t.Error("the accumulated spot window survived — switching back on would start from a stale burst")
+	}
+	// The history is NOT cleared: those openings really happened.
+	if len(a.GetBandOpenings()) != 1 {
+		t.Error("the remembered openings were thrown away")
+	}
+}
+
+// Unticking a band in Settings must actually stop its announcements.
+//
+// Nothing checked the operator's selection on either feed path: bandopen.Watched
+// only says which bands the detector is CAPABLE of. So a station with just 6 m
+// ticked still got 10 m and 2 m badges, from the cluster path and — once grid
+// chasing widened the subscription to every band — from PSK Reporter too.
+func TestBandOpenHonoursTheSelectedBands(t *testing.T) {
+	a := &App{opSet: true, opLat: 48, opLon: 2}
+	a.bandOpen.on.Store(true)
+	a.setBandOpenBands([]string{"6m"})
+
+	if !a.bandOpenWanted("6m") {
+		t.Error("6m is ticked and was refused")
+	}
+	for _, b := range []string{"10m", "2m", "4m"} {
+		if a.bandOpenWanted(b) {
+			t.Errorf("%s is not ticked and was accepted", b)
+		}
+	}
+	// A band the detector cannot watch at all stays out whatever is stored.
+	if a.bandOpenWanted("20m") {
+		t.Error("20m is not a watched band and was accepted")
+	}
+
+	// And the cluster path must obey it too.
+	a.detectBandOpening(cluster.Spot{
+		DXCall: "K1ABC", Band: "10m", DistanceKm: 6000, ShortPath: 280, ReceivedAt: time.Now(),
+	})
+	if a.bandOpen.det != nil {
+		t.Error("a spot on an unticked band reached the detector")
+	}
+}
+
+// Unticking a band puts its badge out. They fade on a timer fed by spots the
+// detector no longer looks at, so it would otherwise stay lit until a restart.
+func TestUntickingABandClearsItsBadge(t *testing.T) {
+	a := &App{}
+	a.bandOpen.live = map[string]bandopen.Opening{
+		"6m":  {Band: "6m", Calls: 9},
+		"10m": {Band: "10m", Calls: 5},
+	}
+	a.bandOpen.aliveUntil = map[string]time.Time{
+		"6m":  time.Now().Add(time.Hour),
+		"10m": time.Now().Add(time.Hour),
+	}
+	a.setBandOpenBands([]string{"6m"})
+
+	live := a.GetLiveOpenings()
+	if len(live) != 1 || live[0].Band != "6m" {
+		t.Errorf("live openings = %v, want only 6m", live)
+	}
+}

bulkfields_test.go

@@ -0,0 +1,35 @@
+package main
+
+import (
+	"testing"
+
+	"hamlog/internal/qso"
+)
+
+// A bulk-editable field passes through THREE tables: the field list in the UI,
+// bulkFieldColumns here, and bulkEditableCols in internal/qso. Mode and RST were
+// added to the first and the third and not the second, so the dialog offered
+// them and the save failed with "unknown field" — reported from the field.
+//
+// Nothing warns about that: each table is valid on its own. This is the check.
+func TestEveryMappedBulkFieldIsWhitelisted(t *testing.T) {
+	for id, col := range bulkFieldColumns {
+		if !qso.BulkEditable(col) {
+			t.Errorf("bulk field %q maps to column %q, which internal/qso refuses to write", id, col)
+		}
+	}
+}
+
+// And the reverse: a column the qso layer allows but nothing maps to is dead
+// weight — it looks supported from the inside and cannot be reached from outside.
+func TestNoUnreachableBulkColumn(t *testing.T) {
+	mapped := map[string]bool{}
+	for _, col := range bulkFieldColumns {
+		mapped[col] = true
+	}
+	for _, col := range qso.BulkEditableColumns() {
+		if !mapped[col] {
+			t.Errorf("column %q is bulk-writable but no field maps to it — unreachable", col)
+		}
+	}
+}

changelog.json

@@ -1,4 +1,194 @@
 [
+  {
+    "version": "0.25.4",
+    "date": "",
+    "en": [
+      "WinKeyer: the opening probe goes out as one write, matching a capture of a client that talks to the same K3NG keyer, and the handshake bytes are always logged so a keyer that stays silent can be diagnosed."
+    ],
+    "fr": [
+      "WinKeyer : la sonde d’ouverture part en un seul envoi, calquée sur la capture d’un client qui dialogue avec le même manipulateur K3NG, et les octets de la poignée de main sont toujours journalisés pour diagnostiquer un manipulateur muet."
+    ]
+  },
+  {
+    "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": "",
+    "en": [
+      "Amplifiers: tick the ones sharing a combiner and ON, OFF and OPERATE act on all of them at once. Each keeps its own meters.",
+      "Shared CAT: JTDX and WSJT-X no longer get an error for turning split off or setting the transmit mode — which made JTDX abandon a transmission — and the wire trace now logs every exchange.",
+      "QSL designer: a card design can be copied from another profile, pictures included, and duplicating a profile now carries its designs’ pictures too instead of leaving cards that cannot be printed.",
+      "Appearance: new Sahara theme, warm sand tones for long sessions in daylight.",
+      "US counties: Connecticut returned the census planning regions, and San Francisco, Doña Ana, Baltimore city and several Alaska boroughs matched nothing at all. The cluster now shows the same county as the Info panel. Re-download the county database.",
+      "QSL: the manager (QSL_VIA) and the sending method (QSL_SENT_VIA / QSL_RCVD_VIA) are separate fields at last, as ADIF defines them. Imports keep both, exports write both, and a log where they were mixed is offered a correction at startup.",
+      "WinKeyer: the opening handshake follows K1EL’s own sequence (RTS off, parser resync, echo test), which wakes keyers that stayed silent, and a port where nothing answers now says so instead of showing “connected”. A keyer that reboots when the port opens — K3NG and other Arduino builds — is waited out and remembered, so it opens directly next time."
+    ],
+    "fr": [
+      "Amplificateurs : cochez ceux qui partagent un combineur et ON, OFF et OPERATE agissent sur tous à la fois. Chacun garde ses propres mesures.",
+      "CAT partagé : JTDX et WSJT-X ne reçoivent plus d’erreur en coupant le split ou en réglant le mode d’émission — ce qui faisait abandonner une transmission à JTDX — et la trace consigne désormais chaque échange.",
+      "Concepteur QSL : un design peut être copié depuis un autre profil, images comprises, et dupliquer un profil emporte aussi les images de ses designs au lieu de laisser des cartes impossibles à imprimer.",
+      "Apparence : nouveau thème Sahara, tons sable chauds pour les longues sessions en plein jour.",
+      "Comtés US : le Connecticut renvoyait les planning regions du recensement, et San Francisco, Doña Ana, Baltimore city et plusieurs districts d’Alaska ne correspondaient à rien. Le cluster affiche maintenant le même comté que le panneau Info. Rechargez la base des comtés.",
+      "QSL : le manager (QSL_VIA) et le mode d’envoi (QSL_SENT_VIA / QSL_RCVD_VIA) sont enfin deux champs distincts, comme le veut l’ADIF. Les imports gardent les deux, les exports les écrivent, et un log où ils étaient mélangés se voit proposer une correction au démarrage.",
+      "WinKeyer : la séquence d’ouverture suit celle de K1EL (RTS bas, resynchronisation, test d’écho), ce qui réveille les manipulateurs muets, et un port où rien ne répond le dit au lieu d’afficher « connecté ». Un manipulateur qui redémarre à l’ouverture du port — K3NG et autres montages Arduino — est attendu puis mémorisé, pour s’ouvrir directement ensuite."
+    ]
+  },
+  {
+    "version": "0.25.0",
+    "date": "",
+    "en": [
+      "Cluster: \"Hide worked\" no longer hides a spot that is a new prefix, county, grid or park in an entity already worked.",
+      "DX Cluster: a spot lifetime can be set — 5, 10, 15 minutes or your own value — after which spots leave the list and the band maps.",
+      "Call lookup: QRZ.com now fills Name with the first name only, and optionally with the operator nickname instead.",
+      "Entry form: a narrower left column, State beside the locator, and a new line with County, CQ, ITU and DXCC.",
+      "Station Control: the short and long path headings are repeated under the compass, at a readable size and clickable.",
+      "Compact mode: the window now fits the entry strip instead of leaving a band of empty space below it.",
+      "HRDLog: an ON AIR option publishes your live frequency, mode and rig on hrdlog.net.",
+      "ADIF: the county is exported as STATE,COUNTY as the standard requires, and a county imported that way now fills the state too.",
+      "A /MM or /AM callsign no longer resolves to a country — RI1FJL/MM read as Franz Josef Land while the expedition was still sailing there."
+    ],
+    "fr": [
+      "Cluster : « Masquer les contactés » ne masque plus un spot qui est un nouveau préfixe, comté, carré ou parc dans une contrée déjà faite.",
+      "Cluster DX : on peut fixer une durée de vie des spots — 5, 10, 15 minutes ou une valeur libre — au-delà de laquelle ils quittent la liste et les band maps.",
+      "Recherche d indicatif : QRZ.com remplit désormais Nom avec le seul prénom, et au choix avec le surnom de l opérateur.",
+      "Saisie : colonne de gauche plus étroite, État à côté du locator, et une nouvelle ligne Comté, CQ, ITU et DXCC.",
+      "Contrôle station : les azimuts court et long chemin sont repris sous la boussole, lisibles et cliquables.",
+      "Mode compact : la fenêtre épouse la bande de saisie au lieu de laisser une bande vide en dessous.",
+      "HRDLog : une option ON AIR publie ta fréquence, ton mode et ta radio en direct sur hrdlog.net.",
+      "ADIF : le comté est exporté sous la forme ÉTAT,COMTÉ comme l exige le standard, et un comté importé ainsi remplit aussi l état.",
+      "Un indicatif en /MM ou /AM ne se résout plus en pays — RI1FJL/MM affichait Franz Josef Land alors que l expédition faisait encore route."
+    ]
+  },
+  {
+    "version": "0.24.9",
+    "date": "",
+    "en": [
+      "Appearance: row colouring now defaults to a left stripe, with a filled row and its strength offered as choices.",
+      "The band map now follows the cluster filters — LoTW only, spotter continent, hide worked, status and mode chips.",
+      "Band map: stations that upload to LoTW now carry the same L badge as the cluster list, switchable in Appearance.",
+      "LoTW: contacts TQSL leaves out — already uploaded, or outside the certificate date range — are no longer reported as uploaded.",
+      "FT8: a contact is logged with the grid the station actually sent, not the home square from QRZ — expeditions were logged in the wrong place.",
+      "SPE amplifier: switching it off is shown at once, instead of needing a second press of OFF.",
+      "Appearance: row colouring is now Worked / Confirmed / QSL sent / To be sent, each scoped to the channels you pick — paper, LoTW, eQSL, QRZ.com."
+    ],
+    "fr": [
+      "Apparence : la coloration des lignes se fait par défaut sur une barre à gauche, la ligne remplie et son intensité restant proposées.",
+      "La band map suit désormais les filtres du cluster — LoTW seulement, continent du spotter, masquer les contactés, statuts et modes.",
+      "Band map : les stations qui utilisent LoTW portent le même badge L que la liste du cluster, activable dans Apparence.",
+      "LoTW : les contacts que TQSL écarte — déjà envoyés, ou hors de la plage de dates du certificat — ne sont plus annoncés comme envoyés.",
+      "FT8 : un contact est enregistré avec le locator réellement émis par la station, et non le carré du domicile depuis QRZ — les expéditions étaient logguées au mauvais endroit.",
+      "Amplificateur SPE : l extinction s affiche immédiatement, au lieu de demander un second appui sur OFF.",
+      "Apparence : la coloration des lignes devient Contacté / Confirmé / QSL envoyée / À envoyer, chacune limitée aux canaux choisis — papier, LoTW, eQSL, QRZ.com."
+    ]
+  },
+  {
+    "version": "0.24.8",
+    "date": "",
+    "en": [
+      "Cluster: the grid cache now holds 100,000 callsigns and rotates instead of emptying itself, so locators stop vanishing from the list.",
+      "New option \"Chase new grids\": locators learnt from your decodes and from PSK Reporter are kept in their own database, with their source.",
+      "Band openings: the PSK Reporter feed is now filtered at the broker, which cuts it from about 83 messages a second to under two.",
+      "Band openings: unticking a band now actually stops its announcements, and puts its badge out.",
+      "Callsign lookup: the website, postal code and HamQTH profile picture are now read — the QSO web column was never filled by any lookup.",
+      "New selectable column \"QSO number\": position in the log, 1 for the oldest contact.",
+      "New Appearance settings: colour whole log rows by QSL status, with your own colours from a palette.",
+      "The QSO number was missing on contacts logged from WSJT-X — that path bypassed the numbering."
+    ],
+    "fr": [
+      "Cluster : le cache de locators garde 100 000 indicatifs et tourne au lieu de se vider, les locators ne disparaissent donc plus de la liste.",
+      "Nouvelle option « Chasse aux nouveaux carrés » : les locators appris de tes décodes et de PSK Reporter sont conservés dans leur propre base, avec leur source.",
+      "Ouvertures de bande : le flux PSK Reporter est désormais filtré chez le broker, ce qui le fait passer d environ 83 messages par seconde à moins de deux.",
+      "Ouvertures de bande : décocher une bande arrête réellement ses annonces et éteint son badge.",
+      "Recherche d indicatif : le site web, le code postal et la photo de profil HamQTH sont désormais lus — la colonne web du QSO n était jamais remplie.",
+      "Nouvelle colonne sélectionnable « Numéro de QSO » : position dans le log, 1 pour le contact le plus ancien.",
+      "Nouveaux réglages Apparence : colorer les lignes entières du log selon le statut QSL, avec tes couleurs choisies dans une palette.",
+      "Le numéro de QSO manquait sur les contacts enregistrés depuis WSJT-X — ce chemin contournait la numérotation."
+    ]
+  },
+  {
+    "version": "0.24.7",
+    "date": "",
+    "en": [
+      "QSOs logged from WSJT-X now carry the space weather and the distance, like hand-logged ones.",
+      "Band openings: EME contacts are no longer mistaken for an opening. Each band now has the longest path the atmosphere can carry.",
+      "Kenwood: WSJT-X \"Fake It\" no longer leaves the dial on the transmit frequency.",
+      "PowerGenius XL: the Station Control card now shows power, current, SWR and temperature without a FlexRadio.",
+      "Motorized antennas: tracking now offers three modes — every frequency change, past a step, or band change only.",
+      "Motorized antennas: each covered band now has its own tune frequency, set in Settings.",
+      "Awards: a single award can now be exported on its own.",
+      "Awards: each reference now has its own validity window, so a reference that ceased to exist stops counting for later QSOs.",
+      "Band openings: the watch switch now governs the detection itself, not just the extra data sources."
+    ],
+    "fr": [
+      "Les QSO enregistrés depuis WSJT-X portent désormais la météo spatiale et la distance, comme ceux saisis à la main.",
+      "Ouvertures de bande : les contacts EME ne sont plus pris pour une ouverture. Chaque bande a désormais la distance maximale que l atmosphère peut porter.",
+      "Kenwood : le « Fake It » de WSJT-X ne laisse plus le VFO sur la fréquence d émission.",
+      "PowerGenius XL : la carte du Contrôle station affiche puissance, courant, ROS et température sans FlexRadio.",
+      "Antennes motorisées : le suivi propose trois modes — à chaque changement de fréquence, au-delà d un pas, ou au changement de bande.",
+      "Antennes motorisées : chaque bande couverte a désormais sa propre fréquence d accord, réglable dans les Réglages.",
+      "Diplômes : un diplôme peut désormais être exporté seul.",
+      "Diplômes : chaque référence a désormais sa fenêtre de validité, une référence disparue cesse donc de compter pour les QSO suivants.",
+      "Ouvertures de bande : l interrupteur de la veille gouverne désormais la détection elle-même, plus seulement les sources de données."
+    ]
+  },
+  {
+    "version": "0.24.6",
+    "date": "",
+    "en": [
+      "Bulk edit can now set mode, submode and RST. They were excluded as per-QSO fields, which missed the point: bulk edit is for repairing a batch — an import that mapped every contact to SSB, an ADIF with no mode at all — and refusing meant editing a hundred rows one at a time. Setting the mode clears the submode, since one left over from the old mode contradicts the new one. Band stays with frequency, which already sets the two together.",
+      "Web publishing: the page now widens to fit the table. It was capped at a comfortable reading width, so with more than about eight columns the rest sat behind a scrollbar on a screen wide enough to show them all — and Windows hides that scrollbar until something moves, which made a table that scrolls look like a table missing columns. Columns also take the width their contents need instead of being squeezed to fit first.",
+      "Every QSO now carries its distance. Nothing ever recorded one, so the field went out empty in every ADIF export and left the Distance column blank on a published page. It is computed from the two locators when a contact is logged and when an ADIF is imported, and a one-time pass fills in the QSOs already in your log the first time this version runs — in the background, without asking. A distance the imported file supplied is always kept.",
+      "RDA: 1015 districts were filed under the wrong DXCC entity. Every reference sat on European Russia; 991 belong to Asiatic Russia and the 24 KA- districts to Kaliningrad, which is a separate entity altogether. Corrected against the reference list, and Kaliningrad added to the award filter so those 24 can be claimed at all.",
+      "QSO filter: asking a field to equal nothing now finds the empty ones. SQL answers that question with nothing at all — a missing value never equals an empty one — so the filter looked broken rather than wrong. Empty on a numeric field also covers zero as well as missing, which SQLite and MySQL disagreed about.",
+      "Callsign lookup: a /QRP call now returns its locator. The lookup falls back to the home callsign when the slashed form is not registered, and then cleared the location — right for /P and /M, where the operator is somewhere other than their registered address, and wrong for /QRP, which says something about power and nothing about place. The grid came back empty while the same call without the suffix answered perfectly."
+    ],
+    "fr": [
+      "L édition groupée sait enfin régler le mode, le sous-mode et le RST. Ils étaient exclus comme champs propres à chaque QSO, ce qui manquait l essentiel : l édition groupée sert à RÉPARER un lot — un import qui a tout mis en SSB, un ADIF sans aucun mode — et refuser obligeait à corriger cent lignes une par une. Régler le mode efface le sous-mode, celui de l ancien mode contredisant le nouveau. La bande reste avec la fréquence, qui pose déjà les deux ensemble.",
+      "Publication web : la page s élargit désormais à la taille du tableau. Elle était bridée à une largeur de lecture confortable, donc au-delà de huit colonnes environ le reste passait derrière une barre de défilement sur un écran assez large pour tout montrer — et Windows masque cette barre tant que rien ne bouge, si bien qu un tableau qui défile ressemblait à un tableau amputé. Les colonnes prennent aussi la largeur qu il leur faut au lieu d être comprimées d abord.",
+      "Chaque QSO porte désormais sa distance. Rien ne l enregistrait, elle partait donc vide dans chaque export ADIF et laissait la colonne Distance blanche sur une page publiée. Elle est calculée depuis les deux locators à l enregistrement d un contact et à l import d un ADIF, et une passe unique complète les QSO déjà présents au premier lancement de cette version — en tâche de fond, sans rien demander. Une distance fournie par le fichier importé est toujours conservée.",
+      "RDA : 1015 districts étaient rangés sous la mauvaise entité DXCC. Toutes les références étaient sur la Russie européenne ; 991 relèvent de la Russie asiatique et les 24 districts KA- de Kaliningrad, qui est une entité à part entière. Corrigé d après la liste de référence, et Kaliningrad ajouté au filtre de l award pour que ces 24 puissent être revendiqués.",
+      "Filtre QSO : demander à un champ d être égal à rien trouve désormais les vides. SQL répond à cette question par rien du tout — une valeur absente n est jamais égale à une valeur vide — et le filtre paraissait cassé plutôt que mal posé. Vide sur un champ numérique couvre aussi le zéro autant que l absence, ce sur quoi SQLite et MySQL n étaient pas d accord.",
+      "Recherche d indicatif : un indicatif en /QRP rend enfin son locator. La recherche se rabat sur l indicatif de base quand la forme avec barre n est pas enregistrée, puis effaçait la localisation — ce qui est juste pour /P et /M, où l opérateur n est pas à son adresse déclarée, et faux pour /QRP, qui parle de puissance et pas de lieu. Le locator revenait vide alors que le même indicatif sans le suffixe répondait parfaitement."
+    ]
+  },
   {
     "version": "0.24.5",
     "date": "",

cmd/cntygen/main.go

@@ -9,6 +9,7 @@ import (
 	"os"
 	"sort"
 	"strings"
+	"unicode/utf8"
 
 	"hamlog/internal/award"
 )
@@ -58,6 +59,15 @@ func main() {
 	sc.Scan() // header
 	for sc.Scan() {
 		line := sc.Text()
+		// The FIPS CSV is not reliably UTF-8, and the one county whose name is
+		// not ASCII (Doña Ana, NM) came through mangled once already — it landed
+		// in the reference as "NM/DO̱AANA", a code no log could ever match,
+		// silently costing that county for every operator. Refuse the row rather
+		// than emit a broken one.
+		if !utf8.ValidString(line) {
+			fmt.Fprintf(os.Stderr, "cntygen: skipping non-UTF-8 line: %q\n", line)
+			continue
+		}
 		parts := strings.SplitN(line, ",", 3)
 		if len(parts) < 3 {
 			continue

cmd/ctzipgen/main.go

@@ -0,0 +1,203 @@
+package main
+
+// One-shot generator: emits internal/uls/ctcounty_gen.go, the Connecticut
+// ZIP → legal county table. Not part of the build.
+//
+// Why it has to exist
+// -------------------
+// internal/uls resolves a US callsign to a county through GeoNames' ZIP table.
+// The Census replaced Connecticut's eight counties with nine PLANNING REGIONS
+// as county-equivalents in 2022, and GeoNames followed: 418 of Connecticut's
+// 429 ZIPs now report "Capitol Region", "Lower Connecticut River Valley" and
+// so on. CQ's USA-CA award did not follow, callbooks did not follow, and no
+// operator's log did either — so every Connecticut station resolved to a name
+// nothing could match, showed as a new county for ever, and counted for no
+// award. Roughly 15 000 US callsigns.
+//
+// A planning region is NOT a renamed county — it is built from towns drawn
+// from several different counties — so there is no name-to-name mapping to be
+// had. The ZIP is the only handle, hence this table.
+//
+// Sources (both public, both free)
+// --------------------------------
+//	geonames  US.txt from https://download.geonames.org/export/zip/US.zip
+//	          — the ZIP list itself, and each ZIP's centroid.
+//	crosswalk https://www2.census.gov/geo/docs/maps-data/data/rel2020/
+//	          zcta520/tab20_zcta520_county20_natl.txt
+//	          — the 2020 ZCTA↔county relationship file, which predates the
+//	            change and therefore still carries the eight real counties.
+//
+// The crosswalk covers 278 of the 418 affected ZIPs. The rest are PO-box-only
+// ZIPs, which have no ZCTA at all; each is given the county of the nearest
+// resolved ZIP centroid. That is sound here because a PO-box ZIP sits inside
+// the town it serves, and Connecticut's counties are tens of kilometres across
+// — the fallback can only err on a ZIP that straddles a county line, which the
+// ZIP-to-county approach is already documented as accepting (~98%).
+//
+// Usage:
+//
+//	go run ./cmd/ctzipgen US.txt tab20_zcta520_county20_natl.txt > internal/uls/ctcounty_gen.go
+
+import (
+	"bufio"
+	"fmt"
+	"math"
+	"os"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+type zipPt struct {
+	zip      string
+	lat, lon float64
+	county   string // from the crosswalk, "" if the ZIP has no ZCTA
+	geoName  string // what GeoNames says today
+}
+
+func main() {
+	if len(os.Args) < 3 {
+		fmt.Fprintln(os.Stderr, "usage: ctzipgen US.txt tab20_zcta520_county20_natl.txt")
+		os.Exit(2)
+	}
+
+	// 1. Every Connecticut ZIP, with its centroid, from GeoNames.
+	var pts []*zipPt
+	byZip := map[string]*zipPt{}
+	f, err := os.Open(os.Args[1])
+	must(err)
+	sc := bufio.NewScanner(f)
+	sc.Buffer(make([]byte, 0, 64*1024), 256*1024)
+	for sc.Scan() {
+		c := strings.Split(sc.Text(), "\t")
+		if len(c) < 11 || strings.ToUpper(strings.TrimSpace(c[4])) != "CT" {
+			continue
+		}
+		z := strings.TrimSpace(c[1])
+		if z == "" || byZip[z] != nil {
+			continue
+		}
+		p := &zipPt{zip: z, lat: atof(c[9]), lon: atof(c[10]), geoName: strings.TrimSpace(c[5])}
+		byZip[z] = p
+		pts = append(pts, p)
+	}
+	must(sc.Err())
+	f.Close()
+
+	// 2. The 2020 county for each ZCTA. A ZCTA can straddle a county line, so
+	//    keep the county holding the largest share of its land area.
+	best := map[string]float64{}
+	f2, err := os.Open(os.Args[2])
+	must(err)
+	sc2 := bufio.NewScanner(f2)
+	sc2.Buffer(make([]byte, 0, 64*1024), 1<<20)
+	sc2.Scan() // header
+	for sc2.Scan() {
+		c := strings.Split(sc2.Text(), "|")
+		if len(c) < 18 || !strings.HasPrefix(c[9], "09") {
+			continue
+		}
+		p := byZip[strings.TrimSpace(c[1])]
+		if p == nil {
+			continue
+		}
+		area := atof(c[16])
+		if p.county != "" && area <= best[p.zip] {
+			continue
+		}
+		best[p.zip] = area
+		p.county = strings.TrimSuffix(strings.TrimSpace(c[10]), " County")
+	}
+	must(sc2.Err())
+	f2.Close()
+
+	// 3. Fill the PO-box-only ZIPs from the nearest ZIP the crosswalk resolved.
+	var anchors []*zipPt
+	for _, p := range pts {
+		if p.county != "" {
+			anchors = append(anchors, p)
+		}
+	}
+	if len(anchors) == 0 {
+		fmt.Fprintln(os.Stderr, "ctzipgen: crosswalk resolved nothing — wrong file?")
+		os.Exit(1)
+	}
+	filled := 0
+	for _, p := range pts {
+		if p.county != "" {
+			continue
+		}
+		nearest, bestD := "", math.MaxFloat64
+		for _, a := range anchors {
+			if d := haversine(p.lat, p.lon, a.lat, a.lon); d < bestD {
+				bestD, nearest = d, a.county
+			}
+		}
+		p.county = nearest
+		filled++
+	}
+
+	// 4. Self-check: the ZIPs GeoNames still labels with a real county must
+	//    agree with what we derived, or the derivation is wrong.
+	real := map[string]bool{
+		"Fairfield": true, "Hartford": true, "Litchfield": true, "Middlesex": true,
+		"New Haven": true, "New London": true, "Tolland": true, "Windham": true,
+	}
+	checked, bad := 0, 0
+	for _, p := range pts {
+		if !real[p.geoName] {
+			continue
+		}
+		checked++
+		if p.geoName != p.county {
+			bad++
+			fmt.Fprintf(os.Stderr, "MISMATCH %s: geonames %q, derived %q\n", p.zip, p.geoName, p.county)
+		}
+	}
+	fmt.Fprintf(os.Stderr, "ctzipgen: %d zips, %d from crosswalk, %d by nearest; cross-check %d/%d agree\n",
+		len(pts), len(pts)-filled, filled, checked-bad, checked)
+	if bad > 0 {
+		os.Exit(1)
+	}
+
+	sort.Slice(pts, func(i, j int) bool { return pts[i].zip < pts[j].zip })
+
+	var b strings.Builder
+	b.WriteString("// Code generated by cmd/ctzipgen. DO NOT EDIT.\n\n")
+	b.WriteString("package uls\n\n")
+	b.WriteString("// ctCounty maps a Connecticut ZIP to its legal county.\n")
+	b.WriteString("//\n")
+	b.WriteString("// GeoNames reports Connecticut's 2022 planning regions instead, which no\n")
+	b.WriteString("// award, callbook or log uses. See cmd/ctzipgen for how this was built and\n")
+	b.WriteString("// why a name-to-name mapping cannot work.\n")
+	fmt.Fprintf(&b, "var ctCounty = map[string]string{\n")
+	for _, p := range pts {
+		fmt.Fprintf(&b, "\t%q: %q,\n", p.zip, p.county)
+	}
+	b.WriteString("}\n")
+	fmt.Print(b.String())
+}
+
+func atof(s string) float64 {
+	v, _ := strconv.ParseFloat(strings.TrimSpace(s), 64)
+	return v
+}
+
+// haversine returns the great-circle distance in km. Connecticut is small
+// enough that a flat approximation would do, but this costs nothing and cannot
+// be wrong near the state's edges.
+func haversine(lat1, lon1, lat2, lon2 float64) float64 {
+	const r = 6371.0
+	dLat := (lat2 - lat1) * math.Pi / 180
+	dLon := (lon2 - lon1) * math.Pi / 180
+	a := math.Sin(dLat/2)*math.Sin(dLat/2) +
+		math.Cos(lat1*math.Pi/180)*math.Cos(lat2*math.Pi/180)*math.Sin(dLon/2)*math.Sin(dLon/2)
+	return 2 * r * math.Asin(math.Sqrt(a))
+}
+
+func must(err error) {
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "ctzipgen:", err)
+		os.Exit(1)
+	}
+}

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

copydir_test.go

@@ -0,0 +1,61 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// TestCopyDirContentsCreatesDestination pins the bug that broke copying a QSL
+// design between profiles.
+//
+// copyDirContents wrote straight into dst without creating it, so the first
+// os.Create failed with ENOENT. The caller was written as "ignore
+// os.IsNotExist", meaning "the source has no assets, that is fine" — and ENOENT
+// from the failed write matched it exactly. Nothing was copied, no error was
+// reported, and the operator saw "copied design is incomplete: hero photo file
+// … not found" from the validation two lines later.
+func TestCopyDirContentsCreatesDestination(t *testing.T) {
+	base := t.TempDir()
+	src := filepath.Join(base, "src")
+	if err := os.MkdirAll(filepath.Join(src, "sub"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(src, "img_25c06bda.jpg"), []byte("hero"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(src, "sub", "back.png"), []byte("back"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	// dst does not exist — the case of every first copy.
+	dst := filepath.Join(base, "dst")
+	if err := copyDirContents(src, dst); err != nil {
+		t.Fatalf("copyDirContents: %v", err)
+	}
+	for name, want := range map[string]string{
+		"img_25c06bda.jpg": "hero",
+		"sub/back.png":     "back",
+	} {
+		got, err := os.ReadFile(filepath.Join(dst, filepath.FromSlash(name)))
+		if err != nil {
+			t.Errorf("%s: %v", name, err)
+			continue
+		}
+		if string(got) != want {
+			t.Errorf("%s = %q, want %q", name, got, want)
+		}
+	}
+}
+
+// A missing SOURCE is still an error from copyDirContents itself — it is the
+// caller that decides whether a design with no pictures is acceptable, and it
+// can only decide that if this does not quietly succeed.
+func TestCopyDirContentsMissingSource(t *testing.T) {
+	base := t.TempDir()
+	if err := copyDirContents(filepath.Join(base, "nope"), filepath.Join(base, "dst")); err == nil {
+		t.Fatal("copying a missing source returned no error")
+	} else if !os.IsNotExist(err) {
+		t.Fatalf("want a not-exist error, got %v", err)
+	}
+}

decodegrids_test.go

@@ -0,0 +1,160 @@
+package main
+
+import (
+	"fmt"
+	"path/filepath"
+	"sync"
+	"testing"
+
+	"hamlog/internal/gridcache"
+)
+
+// The grid cache used to drop EVERYTHING at its ceiling. That was survivable
+// while the only feed was this station's own decodes, which never reached it.
+// Fed by anything larger it is a cliff: every locator in the cluster list
+// disappears at once, periodically, and the operator sees the column empty
+// itself for no reason.
+//
+// Rotation keeps the previous generation, so a full cache costs the older half
+// and nothing more.
+func TestDecodeGridRotationKeepsThePreviousGeneration(t *testing.T) {
+	a := &App{}
+
+	// Fill exactly one generation.
+	for i := 0; i < decodeGridsCap; i++ {
+		a.rememberDecodeGrid(fmt.Sprintf("CALL%06d", i), "JN36", gridcache.SourceDecode)
+	}
+	if got := a.lookupDecodeGrid("CALL000000"); got != "JN36" {
+		t.Fatalf("first entry lost before any rotation: %q", got)
+	}
+	if a.decodeGridsOld != nil {
+		t.Fatal("rotated early — the cap is the ceiling of ONE generation")
+	}
+
+	// One more entry rotates.
+	a.rememberDecodeGrid("NEWCALL", "IO91", gridcache.SourceDecode)
+	if a.decodeGridsOld == nil {
+		t.Fatal("did not rotate at the cap")
+	}
+	if got := a.lookupDecodeGrid("NEWCALL"); got != "IO91" {
+		t.Errorf("the entry that caused the rotation was lost: %q", got)
+	}
+	// The whole previous generation is still readable — this is the point.
+	if got := a.lookupDecodeGrid("CALL000000"); got != "JN36" {
+		t.Errorf("a locator from the previous generation was dropped: %q — that is the cliff again", got)
+	}
+	if got := a.lookupDecodeGrid("CALL099999"); got != "JN36" {
+		t.Errorf("previous generation incomplete: %q", got)
+	}
+
+	// A second rotation is what finally retires the oldest half.
+	for i := 0; i < decodeGridsCap; i++ {
+		a.rememberDecodeGrid(fmt.Sprintf("SECOND%06d", i), "KP20", gridcache.SourceDecode)
+	}
+	if got := a.lookupDecodeGrid("CALL000000"); got != "" {
+		t.Errorf("the cache is unbounded: %q survived two rotations", got)
+	}
+	if got := a.lookupDecodeGrid("NEWCALL"); got != "IO91" {
+		t.Errorf("an entry one generation old was retired too early: %q", got)
+	}
+}
+
+// Callsigns are normalised on the way in AND on the way out, or a spot for
+// "f4bpo" would miss a grid learnt as "F4BPO".
+func TestDecodeGridCaseAndBlanks(t *testing.T) {
+	a := &App{}
+	a.rememberDecodeGrid(" f4bpo ", "JN36", gridcache.SourceDecode)
+	if got := a.lookupDecodeGrid("F4BPO"); got != "JN36" {
+		t.Errorf("lookup of the upper-case form failed: %q", got)
+	}
+	a.rememberDecodeGrid("", "JN36", gridcache.SourceDecode)
+	a.rememberDecodeGrid("K1ABC", "", gridcache.SourceDecode)
+	if got := a.lookupDecodeGrid("K1ABC"); got != "" {
+		t.Errorf("stored an empty grid: %q", got)
+	}
+}
+
+// The write path runs on the decode goroutine while the cluster status builder
+// reads. Rotation swaps the map headers, so an unguarded read is a data race
+// rather than a stale value.
+//
+// This build is CGO-free, so -race is not available here; the test exercises the
+// interleaving and would fault on a concurrent map access even without it.
+func TestDecodeGridConcurrentAccess(t *testing.T) {
+	a := &App{}
+	var wg sync.WaitGroup
+	wg.Add(2)
+	go func() {
+		defer wg.Done()
+		for i := 0; i < 20000; i++ {
+			a.rememberDecodeGrid(fmt.Sprintf("W%05d", i), "FN31", gridcache.SourceDecode)
+		}
+	}()
+	go func() {
+		defer wg.Done()
+		for i := 0; i < 20000; i++ {
+			_ = a.lookupDecodeGrid(fmt.Sprintf("W%05d", i))
+		}
+	}()
+	wg.Wait()
+}
+
+// Only a CHANGE may reach the write batch.
+//
+// The feeds repeat themselves — the same station is reported by dozens of
+// receivers a minute — so queueing every report would put the whole stream in
+// the batch instead of the news in it, and turn a cache into a write amplifier.
+func TestOnlyChangesAreQueued(t *testing.T) {
+	st, err := gridcache.Open(filepath.Join(t.TempDir(), "grids.db"), nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer st.Close()
+	a := &App{gridStore: st}
+
+	a.rememberDecodeGrid("F4BPO", "JN36", gridcache.SourceDecode)
+	if n := st.Pending(); n != 1 {
+		t.Fatalf("a new locator queued %d writes, want 1", n)
+	}
+	if err := st.Flush(); err != nil {
+		t.Fatal(err)
+	}
+
+	// The same report, a hundred times over, is not news.
+	for i := 0; i < 100; i++ {
+		a.rememberDecodeGrid("F4BPO", "JN36", gridcache.SourceDecode)
+	}
+	if n := st.Pending(); n != 0 {
+		t.Errorf("unchanged reports queued %d writes — the batch would carry the whole feed", n)
+	}
+
+	// A station that moved is.
+	a.rememberDecodeGrid("F4BPO", "KP30", gridcache.SourceDecode)
+	if n := st.Pending(); n != 1 {
+		t.Errorf("a changed locator queued %d writes, want 1", n)
+	}
+	if got := a.lookupDecodeGrid("F4BPO"); got != "KP30" {
+		t.Errorf("the map kept the old locator: %q", got)
+	}
+}
+
+// Rotation must be OFF while a store is attached: it would discard callsigns the
+// database still holds, and the lookup would then miss something we know.
+func TestNoRotationWhilePersisting(t *testing.T) {
+	st, err := gridcache.Open(filepath.Join(t.TempDir(), "grids.db"), nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer st.Close()
+	a := &App{gridStore: st}
+
+	for i := 0; i < decodeGridsCap+10; i++ {
+		a.rememberDecodeGrid(fmt.Sprintf("CALL%06d", i), "JN36", gridcache.SourceDecode)
+	}
+	if a.decodeGridsOld != nil {
+		t.Error("rotated while a store was attached — locators the database holds would go missing")
+	}
+	if got := a.lookupDecodeGrid("CALL000000"); got != "JN36" {
+		t.Errorf("the first entry was dropped: %q", got)
+	}
+}

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 {
@@ -16,7 +16,8 @@ import {
   GetStartupStatus, CheckForUpdate, DownloadAndApplyUpdate, GetLiveStations, GetWhatsNew, GetChangelog,
   SMTPConfigured, SendLogToDeveloper,
   WorkedBefore,
-  SetCompactMode,
+  SetCompactMode, SetCompactHeight,
+  RotatorGoToPath,
   GetCATState, SetCATFrequency, SetCATMode, SwitchCATRig, FlexApplyBandAntenna, FlexApplyBandPower,
   GetSecretStatus, UnlockSecrets,
   RefreshCtyDat, DownloadAllReferenceLists,
@@ -51,10 +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';
@@ -81,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';
@@ -90,7 +93,8 @@ import { ExportFieldsDialog } from '@/components/ExportFieldsDialog';
 import { ShutdownProgress } from '@/components/ShutdownProgress';
 import { ClusterGrid } from '@/components/ClusterGrid';
 import { cleanSpotter, inferSpotMode, spotModeCategory, spotStatusKey } from '@/lib/spot';
-import { applySpotDisplay, readSpotDisplayOptions } from '@/lib/spotDisplay';
+import { applySpotDisplay, readSpotDisplayOptions, spotIsWorked, SPOT_DISPLAY_OPTIONS_EXPOSED } from '@/lib/spotDisplay';
+import { GetRowColors, GetSpotTTLMinutes, IsNewUSCounty } from '../wailsjs/go/main/App';
 import { WorkedBeforeGrid } from '@/components/WorkedBeforeGrid';
 import { NetControlPanel } from '@/components/NetControlPanel';
 import { ContestPanel, CONTEST_DEFAULT, type ContestSession } from '@/components/ContestPanel';
@@ -139,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).
@@ -309,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';
@@ -528,6 +534,28 @@ export default function App() {
     setCompact(next);
     SetCompactMode(next);
   }
+  // Fit the compact window to what was actually rendered.
+  //
+  // The height was a constant "tuned so the compact entry strip fits in a single
+  // row". A constant tuned against a layout stops being true the moment the
+  // layout changes, and this one outlived a strip that had since lost a row —
+  // leaving a band of empty window under the fields. Measure instead.
+  const compactRootRef = useRef<HTMLDivElement | null>(null);
+  useEffect(() => {
+    if (!compact) return;
+    const fit = () => {
+      const el = compactRootRef.current;
+      if (!el) return;
+      // Rounded, so a sub-pixel reflow cannot start a resize loop.
+      // + the compact topbar, which is a fixed h-8 (32px), + a couple of pixels
+      // for the border so the strip is never clipped by one row of anti-aliasing.
+      SetCompactHeight(Math.round(el.getBoundingClientRect().height) + 32 + 2);
+    };
+    const id = window.setTimeout(fit, 60); // let the strip paint first
+    const ro = new ResizeObserver(fit);
+    if (compactRootRef.current) ro.observe(compactRootRef.current);
+    return () => { window.clearTimeout(id); ro.disconnect(); };
+  }, [compact]);
 
   // CAT — receives live rig state via Wails events.
   const [catState, setCatState] = useState<CATState>({ enabled: false, connected: false } as any);
@@ -1497,8 +1525,11 @@ export default function App() {
   // beside Hide worked and not among the status chips.
   const [clusterLotwOnly, setClusterLotwOnly] = useState(() => localStorage.getItem('opslog.clusterLotwOnly') === '1');
   const [clusterSpotterConts, setClusterSpotterConts] = useState<Set<string>>(() => lsSet<string>('opslog.clusterSpotterCont'));
-  const [clusterMuteWorked, setClusterMuteWorked] = useState(() => localStorage.getItem('opslog.clusterMuteWorked') === '1');
-  const [clusterSlotHighlight, setClusterSlotHighlight] = useState(() => localStorage.getItem('opslog.clusterSlotHighlight') === '1');
+  // Read through lib/spotDisplay, not straight from localStorage: while the two
+  // options are withdrawn it answers false, so the cluster list cannot end up
+  // applying an option the operator can no longer see or switch off.
+  const [clusterMuteWorked, setClusterMuteWorked] = useState(() => readSpotDisplayOptions().muteWorked);
+  const [clusterSlotHighlight, setClusterSlotHighlight] = useState(() => readSpotDisplayOptions().slotHighlight);
   const [clusterStatusFilter, setClusterStatusFilter] = useState<Set<SpotFilterKey>>(() => lsSet<SpotFilterKey>('opslog.clusterStatusFilter'));
   // Mode filter chips. Empty set = show every mode. Categories map the
   // inferred per-spot mode onto SSB (phone) / CW / DATA (digital).
@@ -1767,6 +1798,20 @@ export default function App() {
   // close so the next plain "Preferences" launch reverts to default.
   const [settingsSection, setSettingsSection] = useState<string | undefined>(undefined);
   const [showDeleteAll, setShowDeleteAll] = useState(false);
+  // How many QSOs hold a QSL routing word where the manager belongs — null when
+  // there is nothing to offer, or the operator has already answered. Asked once
+  // per log, a moment after startup so it does not race the first paint.
+  const [qslViaRepair, setQslViaRepair] = useState<number | null>(null);
+  useEffect(() => {
+    let alive = true;
+    const id = window.setTimeout(async () => {
+      try {
+        const s: any = await QSLViaRepairStatus();
+        if (alive && !s?.asked && (s?.affected ?? 0) > 0) setQslViaRepair(s.affected);
+      } catch { /* a log we cannot query yet will be offered next start */ }
+    }, 4000);
+    return () => { alive = false; window.clearTimeout(id); };
+  }, []);
   const [showAbout, setShowAbout] = useState(false);
   // "What's new": the changelog for the version(s) since the operator last ran,
   // shown once on the first launch after an update (EN/FR per the UI language).
@@ -1920,6 +1965,35 @@ export default function App() {
   // change). The grid reads them straight from the row — no per-page backend
   // recompute — so here we just parse the stored JSON string into the code→ref
   // object the award columns expect (keys are already upper-case).
+  // Row colouring by QSL status (Settings → Appearance). Reloaded when the
+  // settings dialog closes, which is the only place it changes.
+  const [rowColors, setRowColors] = useState<any>(null);
+  useEffect(() => { GetRowColors().then(setRowColors).catch(() => {}); }, [showSettings]);
+  // Spot lifetime (Settings → DX Cluster). Spots are actually REMOVED rather
+  // than filtered at render: the cluster list, every band map and the counts all
+  // read the same array, so pruning it once is what makes the setting mean the
+  // same thing everywhere — and it gives the memory back.
+  const [spotTTLMin, setSpotTTLMin] = useState(0);
+  useEffect(() => { GetSpotTTLMinutes().then(setSpotTTLMin).catch(() => {}); }, [showSettings]);
+  useEffect(() => {
+    if (spotTTLMin <= 0) return; // 0 = keep until the count cap pushes them out
+    const sweep = () => {
+      const cutoff = Date.now() - spotTTLMin * 60_000;
+      setSpots((arr) => {
+        const kept = arr.filter((sp) => {
+          const t = Date.parse((sp as any).received_at ?? '');
+          return isNaN(t) || t >= cutoff; // an unparseable stamp is never a reason to drop a spot
+        });
+        return kept.length === arr.length ? arr : kept;
+      });
+    };
+    sweep();
+    // Half a minute: fine enough that a 5-minute setting is honoured closely,
+    // coarse enough to be invisible next to the spot stream itself.
+    const id = window.setInterval(sweep, 30_000);
+    return () => window.clearInterval(id);
+  }, [spotTTLMin]);
+
   const qsosWithAwards = useMemo(
     () => (qsos as any[]).map((q) => ({ ...q, award_refs: parseAwardRefs(q.award_refs) })),
     [qsos],
@@ -2014,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(() => {
@@ -2547,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
@@ -2559,7 +2664,7 @@ export default function App() {
     };
     attempt();
     return () => { alive = false; if (timer) window.clearTimeout(timer); };
-  }, [refresh]);
+  }, [refresh, refreshChaseNew]);
   useEffect(() => {
     (async () => {
       try {
@@ -2580,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
@@ -3300,7 +3409,7 @@ export default function App() {
         sat_name: details.sat_name, sat_mode: details.sat_mode,
         contest_id: details.contest_id,
         srx: srxE.num, stx: stxE.num, srx_string: srxE.str, stx_string: stxE.str,
-        email: details.email,
+        email: details.email, web: details.web,
       };
       applyAwardRefs(payload, details.award_refs ?? '', awardFieldRef.current);
       // Contest mode overrides the exchange fields: CONTEST_ID, the sent
@@ -3663,6 +3772,7 @@ export default function App() {
         ituz:    d.ituz    ?? (last.ituz || undefined),
         cont:    d.cont    || last.cont  || '',
         email:   d.email   || last.email || '',
+        web:     d.web     || last.web || '',
         qsl_via: d.qsl_via || last.qsl_via || '',
       };
     });
@@ -3725,6 +3835,7 @@ export default function App() {
         ituz:    d.ituz    ?? (r.ituz || undefined),
         cont:    d.cont    || (r.cont ?? ''),
         email:   d.email   || (r.email ?? ''),
+        web:     d.web     || (r.web ?? ''),
         qsl_via: d.qsl_via || (r.qsl_via ?? ''),
       }));
       // Backfill anything the provider didn't supply from the last time we worked
@@ -4404,6 +4515,67 @@ export default function App() {
         onBlur={() => setQth(titleCase)} />
     </div>
   );
+  // State sits between QTH and the locator: it is part of the same "where is
+  // this station" reading, and it is what several awards key off (WAS, the US
+  // county work). Narrow — it holds two or three characters.
+  const stateBlock = (
+    <div className="flex flex-col w-[70px] shrink-0"><Label className="mb-1 h-3.5">{t('field.state')}</Label>
+      <Input value={details.state ?? ''} className="font-mono"
+        onChange={(e) => setDetails((d) => ({ ...d, state: e.target.value.toUpperCase() }))} />
+    </div>
+  );
+  // County beside State: the lookup fills QTH, State, County and the locator
+  // together, and they are read together. Wider than State because a county name
+  // is a name — "St. Tammany Parish", not a code.
+  // The row Comment/Note freed by moving onto one line: county, zones and the
+  // ADIF entity number. All four are filled by the lookup and were previously
+  // only visible after opening a tab — which is the wrong place for values an
+  // operator wants to SEE are right before pressing Log.
+  //
+  // A numeric field stores undefined when cleared, not 0: zero is a real DXCC
+  // number for "no entity" and a real answer for a zone, so an empty box must
+  // stay empty rather than assert something.
+  // NEW badge on the county — the same answer the Details tab gives, moved to
+  // where the county is now typed. Debounced: this field is typed into as well
+  // as filled by the lookup, and the check hits the database.
+  const [entryNewCounty, setEntryNewCounty] = useState(false);
+  useEffect(() => {
+    const cnty = (details.cnty ?? '').trim();
+    if (!cnty) { setEntryNewCounty(false); return; }
+    let alive = true;
+    const id = window.setTimeout(async () => {
+      try {
+        const isNew = await IsNewUSCounty(details.state ?? '', cnty);
+        if (alive) setEntryNewCounty(!!isNew);
+      } catch { if (alive) setEntryNewCounty(false); }
+    }, 300);
+    return () => { alive = false; window.clearTimeout(id); };
+  }, [details.state, details.cnty]);
+
+  const num = (v: string): number | undefined => {
+    const s = v.replace(/[^0-9]/g, '');
+    return s === '' ? undefined : parseInt(s, 10);
+  };
+  const geoDetailRow = (
+    <div className="flex gap-4 items-end">
+      <div className="flex flex-col flex-1 min-w-0"><Label className="mb-1 h-3.5">{t('field.cnty')}</Label>
+        <Input value={details.cnty ?? ''}
+          onChange={(e) => setDetails((d) => ({ ...d, cnty: e.target.value }))} />
+      </div>
+      <div className="flex flex-col w-[64px] shrink-0"><Label className="mb-1 h-3.5">{t('field.cqz')}</Label>
+        <Input value={details.cqz ?? ''} className="font-mono"
+          onChange={(e) => setDetails((d) => ({ ...d, cqz: num(e.target.value) }))} />
+      </div>
+      <div className="flex flex-col w-[64px] shrink-0"><Label className="mb-1 h-3.5">{t('field.ituz')}</Label>
+        <Input value={details.ituz ?? ''} className="font-mono"
+          onChange={(e) => setDetails((d) => ({ ...d, ituz: num(e.target.value) }))} />
+      </div>
+      <div className="flex flex-col w-[72px] shrink-0"><Label className="mb-1 h-3.5">{t('field.dxcc')}</Label>
+        <Input value={details.dxcc ?? ''} className="font-mono"
+          onChange={(e) => setDetails((d) => ({ ...d, dxcc: num(e.target.value) }))} />
+      </div>
+    </div>
+  );
   const gridBlock = (
     <div className="flex flex-col w-[76px] shrink-0"><Label className="mb-1 h-3.5">{t('field.grid')}</Label>
       <Input value={grid} placeholder="JN05" className="font-mono" onChange={(e) => { setGrid(e.target.value); markEdited('grid'); }} />
@@ -4707,12 +4879,21 @@ export default function App() {
   // Cluster spots after every active filter (band / mode / status / search /
   // hide-worked / group). Shared by the Cluster tab and the Main-view cluster
   // pane so both show exactly the same list.
-  const clusterRenderedRows = useMemo(() => {
-    const bandsActive = clusterLockBand ? new Set([band]) : clusterBands;
+  // Everything the operator has said about WHICH STATIONS they care about —
+  // LoTW only, the spotter's continent, hide worked, the status and mode chips,
+  // the search box, the source node.
+  //
+  // Shared with the band map, which used to receive the raw stream filtered by
+  // band alone: switching on "LoTW users only" changed the cluster list and left
+  // the panadapter showing everyone. Two views of one spot stream disagreeing
+  // about the same spot is the fault lib/spotDisplay already exists to prevent.
+  //
+  // The BAND filter is deliberately not in here: a band map's band IS its
+  // filter, and applying the cluster's would empty every map but one.
+  const spotPassesStationFilters = useCallback((s: ClusterSpot): boolean => {
     const search = clusterSearch.trim().toUpperCase();
-    const list = spots.filter((s) => {
+    {
       if (clusterFilterSource && s.source_id !== clusterFilterSource) return false;
-      if (bandsActive.size > 0 && !bandsActive.has(s.band ?? '')) return false;
       if (search && !s.dx_call.includes(search)) return false;
       if (clusterLockMode) {
         const spotMode = inferSpotMode(s.comment ?? '', s.freq_hz);
@@ -4761,9 +4942,27 @@ export default function App() {
         const k = spotStatusKey(s.dx_call, s.band ?? '', s.comment ?? '', s.freq_hz);
         const e = spotStatus[k];
         if (!e) return false;
-        if (e.worked_call || e.status === 'worked') return false;
+        // A spot that is NEW for something is not "worked", whatever the entity
+        // says. The extra markers are orthogonal to the entity status — the same
+        // rule the band map already states — so a new prefix, county, grid or
+        // park in an entity worked years ago is exactly what an operator is
+        // hunting, and hiding it is the opposite of what was asked.
+        //
+        // Reported on BH2SWB and 4X9AA: both flagged NEW PFX, neither ever
+        // worked, both vanished the moment "hide worked" went on.
+        const isNew = !!(e.new_pota || e.new_county || e.new_pfx || e.new_grid);
+        if (!isNew && (e.worked_call || e.status === 'worked')) return false;
       }
       return true;
+    }
+  }, [clusterFilterSource, clusterSearch, clusterLockMode, mode, clusterModeFilter,
+    clusterStatusFilter, spotStatus, clusterLotwOnly, clusterSpotterConts, clusterHideWorked]);
+
+  const clusterRenderedRows = useMemo(() => {
+    const bandsActive = clusterLockBand ? new Set([band]) : clusterBands;
+    const list = spots.filter((s) => {
+      if (bandsActive.size > 0 && !bandsActive.has(s.band ?? '')) return false;
+      return spotPassesStationFilters(s);
     });
     let rendered = list as (ClusterSpot & { repeats?: number })[];
     if (clusterGroup) {
@@ -4843,8 +5042,11 @@ export default function App() {
         <div className="space-y-0.5">
           {fSwitch(t('clu.hideWorked'), clusterHideWorked, setClusterHideWorked)}
           {fSwitch(t('clu.groupDup'), clusterGroup, setClusterGroup)}
-          {fSwitch(t('clu.muteWorkedShort'), clusterMuteWorked, (v) => { setClusterMuteWorked(v); writeUiPref('opslog.clusterMuteWorked', v ? '1' : '0'); })}
-          {fSwitch(t('clu.slotHighlightShort'), clusterSlotHighlight, (v) => { setClusterSlotHighlight(v); writeUiPref('opslog.clusterSlotHighlight', v ? '1' : '0'); })}
+          {/* The two display options are withdrawn for now — the flag is in
+              lib/spotDisplay, and it also forces them off for the band map, so
+              there is one place to flip when they come back. */}
+          {SPOT_DISPLAY_OPTIONS_EXPOSED && fSwitch(t('clu.muteWorkedShort'), clusterMuteWorked, (v) => { setClusterMuteWorked(v); writeUiPref('opslog.clusterMuteWorked', v ? '1' : '0'); })}
+          {SPOT_DISPLAY_OPTIONS_EXPOSED && fSwitch(t('clu.slotHighlightShort'), clusterSlotHighlight, (v) => { setClusterSlotHighlight(v); writeUiPref('opslog.clusterSlotHighlight', v ? '1' : '0'); })}
           {fSwitch(t('clu.lotwOnly'), clusterLotwOnly, (v) => { setClusterLotwOnly(v); writeUiPref('opslog.clusterLotwOnly', v ? '1' : '0'); })}
         </div>
 
@@ -5062,6 +5264,7 @@ export default function App() {
               // rewrote the other's widths.
               storageKey="mainpane"
               rows={qsosWithAwards as any}
+                rowColors={rowColors}
               myGrid={station.my_grid}
               total={total}
               awardCols={awardCols}
@@ -5168,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')}
@@ -5191,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',
@@ -5387,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"
@@ -5765,7 +5984,7 @@ export default function App() {
           Enter from any <input> inside the strip logs the QSO. Radix Selects
           render as <button> elements and are ignored by this handler — they
           keep their own keyboard behaviour. */}
-      <div className={cn(!compact && 'flex gap-2.5 items-stretch px-2.5 pt-2.5 shrink-0')}>
+      <div ref={compactRootRef} className={cn(!compact && 'flex gap-2.5 items-stretch px-2.5 pt-2.5 shrink-0')}>
       <section
         className={cn('bg-card shadow-sm border-border',
           compact
@@ -5820,25 +6039,30 @@ export default function App() {
                 to be pushed outside the entry panel and clipped. Wrapping drops
                 it to its own line instead, which stays readable. */}
             <div className="flex gap-4 items-end flex-wrap">
-              <div className="flex flex-col w-[300px] shrink-0"><Label className="mb-1 h-3.5">Name</Label>
+              <div className="flex flex-col w-[230px] shrink-0"><Label className="mb-1 h-3.5">{t('field.name')}</Label>
                 <Input value={name} onChange={(e) => { setName(e.target.value); markEdited('name'); }}
                   onBlur={() => setName(titleCase)} />
               </div>
               {qthBlock}
+              {stateBlock}
               {gridBlock}
             </div>
 
             {/* Row 3: tight left detail column (Band/Mode/Country) and
-                single-line Comment/Note on the right. */}
+                Comment/Note SIDE BY SIDE on the right — one line each was a lot
+                of vertical space for two fields that are usually short. */}
             <div className="flex gap-4 items-start">
-              <div className="flex flex-col gap-1.5 w-[300px] shrink-0">
+              <div className="flex flex-col gap-1.5 w-[230px] shrink-0">
                 {bandRow}
                 {modeRow}
                 {countryRow}
               </div>
               <div className="flex flex-col gap-1.5 flex-1 min-w-0">
-                {commentLine}
-                {noteLine}
+                {geoDetailRow}
+                <div className="flex gap-4">
+                  <div className="flex-1 min-w-0">{commentLine}</div>
+                  <div className="flex-1 min-w-0">{noteLine}</div>
+                </div>
               </div>
             </div>
 
@@ -5901,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.
@@ -6027,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
@@ -6345,6 +6579,7 @@ export default function App() {
               <RecentQSOsGrid
                 key={`rqg2-${activeProfileId ?? 'x'}`}
                 rows={qsosWithAwards as any}
+                rowColors={rowColors}
                 myGrid={station.my_grid}
                 total={total}
                 awardCols={awardCols}
@@ -6760,13 +6995,14 @@ export default function App() {
                     </div>
                     <BandMap
                       band={b}
-                      spots={spots.filter((s) => s.band === b)}
+                      spots={spots.filter((s) => s.band === b && spotPassesStationFilters(s))}
                       spotStatus={spotStatus}
                       currentFreqHz={band === b && freqMhz ? Math.round(parseFloat(freqMhz) * 1_000_000) : 0}
                       onSpotClick={handleSpotClick}
                       onClose={() => toggleBandMapBand(b)}
                       hideDigital={bandMapHideFt}
                       fitToBand={bandMapFit}
+                      showLotw={!!rowColors?.bandmap_lotw}
                     />
                   </div>
                 ))}
@@ -6796,11 +7032,12 @@ export default function App() {
               side={bandMapSide}
               onToggleSide={toggleBandMapSide}
               band={band}
-              spots={spots.filter((s) => s.band === band)}
+              spots={spots.filter((s) => s.band === band && spotPassesStationFilters(s))}
               spotStatus={spotStatus}
               currentFreqHz={band && freqMhz ? Math.round(parseFloat(freqMhz) * 1_000_000) : 0}
               onSpotClick={handleSpotClick}
               onClose={() => setBandMapShown(false)}
+              showLotw={!!rowColors?.bandmap_lotw}
               keyNav
             />
           </div>
@@ -7044,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)
@@ -7054,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);
@@ -7067,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
@@ -7118,6 +7359,27 @@ export default function App() {
           />
         );
       })()}
+      {/* One-time offer to move QSL routing words out of the manager field.
+          Shown with a count and never acted on without an answer: it rewrites
+          what the operator sees in their own log. Either answer is final —
+          asking again after a "no" would be a nag. */}
+      {qslViaRepair !== null && (
+        <ConfirmDialog
+          title={t('qslvia.title')}
+          message={t('qslvia.body', { n: qslViaRepair.toLocaleString() })}
+          confirmLabel={t('qslvia.confirm')}
+          cancelLabel={t('qslvia.cancel')}
+          onConfirm={async () => {
+            const n = qslViaRepair;
+            setQslViaRepair(null);
+            try {
+              const r: any = await RepairQSLVia();
+              showToast(t('qslvia.done', { n: (r?.moved ?? n).toLocaleString() }));
+            } catch { /* the log keeps the reason; nothing to undo */ }
+          }}
+          onCancel={() => { setQslViaRepair(null); DismissQSLViaRepair().catch(() => {}); }}
+        />
+      )}
       {showDeleteAll && (
         <ConfirmDialog
           title="Delete ALL QSOs?"

frontend/src/components/AmpCard.tsx

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

frontend/src/components/AppearancePanel.tsx

@@ -0,0 +1,153 @@
+import { useEffect, useState } from 'react';
+import { GetRowColors, SaveRowColors } from '../../wailsjs/go/main/App';
+import { Checkbox } from '@/components/ui/checkbox';
+import { useI18n } from '@/lib/i18n';
+import { cn } from '@/lib/utils';
+import type { RowColorSettings } from '@/lib/rowColors';
+
+// A fixed palette plus a free picker. Muted values on purpose: they are
+// composited at low opacity over a dark grid, where a saturated colour reads as
+// an error state rather than a status.
+const PALETTE = [
+  '#16a34a', '#0ea5e9', '#f59e0b', '#a855f7',
+  '#dc2626', '#14b8a6', '#eab308', '#ec4899',
+  '#64748b', '#84cc16', '#6366f1', '#f97316',
+];
+
+// The rule ids the backend orders; the labels live here so a translation never
+// travels through the settings row.
+const LABELS: Record<string, string> = {
+  to_send: 'appr.ruleToSend',
+  confirmed: 'appr.ruleConfirmed',
+  sent: 'appr.ruleSent',
+  worked: 'appr.ruleWorked',
+};
+
+// The channels a rule can be scoped to. "worked" is the catch-all — it means
+// nothing on ANY channel — so narrowing it would say nothing.
+const CHANNELS = ['qsl', 'lotw', 'eqsl', 'qrz'] as const;
+const CHANNEL_LABELS: Record<string, string> = {
+  qsl: 'appr.chQsl', lotw: 'LoTW', eqsl: 'eQSL', qrz: 'QRZ.com',
+};
+
+export function AppearancePanel() {
+  const { t } = useI18n();
+  const [cfg, setCfg] = useState<RowColorSettings | null>(null);
+
+  useEffect(() => {
+    (async () => {
+      try { setCfg((await GetRowColors()) as any); } catch { /* defaults on the backend */ }
+    })();
+  }, []);
+
+  const save = (next: RowColorSettings) => {
+    setCfg(next);
+    SaveRowColors(next as any).catch(() => {});
+  };
+  const patchRule = (id: string, patch: Partial<{ color: string; enabled: boolean; channels: string[] }>) => {
+    if (!cfg) return;
+    save({ ...cfg, rules: cfg.rules.map((r) => (r.id === id ? { ...r, ...patch } : r)) });
+  };
+
+  // The rule card shows the row exactly as the grid will draw it, so the choice
+  // is made by looking rather than by imagining.
+  const preview = (color: string): Record<string, string> => {
+    const st = cfg?.style ?? 'bar';
+    const pct = cfg?.intensity ?? 12;
+    const out: Record<string, string> = {};
+    if (st === 'tint' || st === 'both') out.backgroundColor = `color-mix(in srgb, ${color} ${pct}%, transparent)`;
+    if (st === 'bar' || st === 'both') out.boxShadow = `inset 3px 0 0 ${color}`;
+    return out;
+  };
+
+  if (!cfg) return <div className="p-1 text-sm text-muted-foreground">…</div>;
+
+  return (
+    <div className="space-y-4">
+      <label className="flex items-start gap-2 text-sm cursor-pointer">
+        <Checkbox checked={!!cfg.bandmap_lotw} className="mt-0.5"
+          onCheckedChange={(c) => save({ ...cfg, bandmap_lotw: !!c } as any)} />
+        <span>{t('appr.bandmapLotw')} <span className="text-xs text-muted-foreground">{t('appr.bandmapLotwHint')}</span></span>
+      </label>
+
+      <label className="flex items-start gap-2 text-sm cursor-pointer">
+        <Checkbox checked={cfg.enabled} className="mt-0.5"
+          onCheckedChange={(c) => save({ ...cfg, enabled: !!c })} />
+        <span>{t('appr.enable')} <span className="text-xs text-muted-foreground">{t('appr.enableHint')}</span></span>
+      </label>
+
+      {cfg.enabled && (
+        <div className="space-y-3">
+          {/* Style first: it decides whether the colours below are a signal or a
+              wallpaper, which matters more than which hue they are. */}
+          <div className="flex items-center gap-3 flex-wrap">
+            <span className="text-sm">{t('appr.style')}</span>
+            <div className="inline-flex rounded-md border border-border overflow-hidden text-xs">
+              {(['bar', 'tint', 'both'] as const).map((v) => (
+                <button key={v} type="button" onClick={() => save({ ...cfg, style: v })}
+                  className={cn('px-3 py-1.5 font-medium', (cfg.style ?? 'bar') === v ? 'bg-primary text-primary-foreground' : 'text-muted-foreground hover:bg-muted')}>
+                  {t('appr.style' + v[0].toUpperCase() + v.slice(1))}
+                </button>
+              ))}
+            </div>
+            {(cfg.style ?? 'bar') !== 'bar' && (
+              <label className="flex items-center gap-2 text-sm">
+                {t('appr.intensity')}
+                <input type="range" min={5} max={45} step={1} value={cfg.intensity ?? 12}
+                  onChange={(e) => save({ ...cfg, intensity: parseInt(e.target.value, 10) })}
+                  className="w-32 accent-[var(--primary)]" />
+                <span className="font-mono text-xs text-muted-foreground w-8">{cfg.intensity ?? 12}%</span>
+              </label>
+            )}
+          </div>
+          {/* Order matters and is shown: a contact is usually several of these at
+              once, and the first match wins. */}
+          <p className="text-xs text-muted-foreground">{t('appr.orderHint')}</p>
+          {cfg.rules.map((r, i) => (
+            <div key={r.id} className="rounded-lg border border-border/60 p-2.5 space-y-2"
+              style={r.enabled ? preview(r.color) : undefined}>
+              <label className="flex items-center gap-2 text-sm cursor-pointer">
+                <Checkbox checked={r.enabled} onCheckedChange={(c) => patchRule(r.id, { enabled: !!c })} />
+                <span className="font-mono text-xs text-muted-foreground">{i + 1}.</span>
+                <span className="font-medium">{t(LABELS[r.id] ?? r.id)}</span>
+              </label>
+              {/* Which channels this category looks at. None ticked = all of
+                  them, which is what an unnarrowed rule should mean. */}
+              {r.enabled && r.id !== 'worked' && (
+                <div className="flex items-center gap-3 flex-wrap pl-6 text-xs">
+                  {CHANNELS.map((c) => {
+                    const on = !r.channels?.length || r.channels.includes(c);
+                    return (
+                      <label key={c} className="flex items-center gap-1.5 cursor-pointer">
+                        <Checkbox checked={on} onCheckedChange={(v) => {
+                          const cur = r.channels?.length ? r.channels : [...CHANNELS];
+                          const next = v ? [...new Set([...cur, c])] : cur.filter((x) => x !== c);
+                          patchRule(r.id, { channels: next });
+                        }} />
+                        {CHANNEL_LABELS[c]?.startsWith('appr.') ? t(CHANNEL_LABELS[c]) : CHANNEL_LABELS[c]}
+                      </label>
+                    );
+                  })}
+                </div>
+              )}
+              {r.enabled && (
+                <div className="flex items-center gap-1.5 flex-wrap pl-6">
+                  {PALETTE.map((c) => (
+                    <button key={c} type="button" title={c}
+                      onClick={() => patchRule(r.id, { color: c })}
+                      className={cn('size-6 rounded-md border-2 transition-transform hover:scale-110',
+                        r.color.toLowerCase() === c ? 'border-foreground' : 'border-transparent')}
+                      style={{ backgroundColor: c }} />
+                  ))}
+                  <input type="color" value={r.color} title={t('appr.custom')}
+                    onChange={(e) => patchRule(r.id, { color: e.target.value })}
+                    className="size-6 rounded-md border border-border bg-transparent p-0 cursor-pointer" />
+                </div>
+              )}
+            </div>
+          ))}
+        </div>
+      )}
+    </div>
+  );
+}

frontend/src/components/AwardEditor.tsx

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

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/BandMap.tsx

@@ -38,6 +38,9 @@ type SpotStatusEntry = {
   new_county?: boolean;
   new_pota?: boolean;
   new_pfx?: boolean;
+  // Whether the station uploads to LoTW. Not a status — it says nothing about
+  // whether the spot is worth chasing — so it is drawn as a badge, never a colour.
+  lotw?: boolean;
 };
 
 // The extra markers are ORTHOGONAL to the entity status: a spot can be a worked
@@ -79,6 +82,8 @@ interface Props {
   // globally from the band-map tab toolbar.
   hideDigital?: boolean;
   fitToBand?: boolean;
+  // Mark stations that upload to LoTW (Settings → Appearance).
+  showLotw?: boolean;
   // keyNav enables Ctrl+↑ / Ctrl+↓ to hop to the next spot above / below the rig
   // frequency (and tune to it). Only the docked Main-view band map sets this, so
   // the multi-band Band Map tab (several maps) doesn't fight over the shortcut.
@@ -227,7 +232,7 @@ const BOT_PAD = 14;    // the top-most freq label isn't clipped at y=0
 // last; ties broken by closeness to the rig freq).
 const MAX_VISIBLE_SPOTS = 30;
 
-export function BandMap({ band, spots, spotStatus: spotStatusRaw, currentFreqHz, onSpotClick, onClose, side = 'right', onToggleSide, hideDigital = false, fitToBand = false, keyNav = false }: Props) {
+export function BandMap({ band, spots, spotStatus: spotStatusRaw, currentFreqHz, onSpotClick, onClose, side = 'right', onToggleSide, hideDigital = false, fitToBand = false, keyNav = false, showLotw = false }: Props) {
   const { t } = useI18n();
 
   // The two display options are applied ONCE here, on the whole map, so the
@@ -649,6 +654,15 @@ export function BandMap({ band, spots, spotStatus: spotStatusRaw, currentFreqHz,
                 })()}
                 <span className="flex items-center gap-1.5 px-2 font-mono text-[11px] font-bold leading-none">
                   <span>{p.spot.dx_call}</span>
+                  {/* Same badge the cluster list draws, for the same reason: the
+                      muted-blue of a confirmation, never a status colour —
+                      whether a station uploads to LoTW says nothing about
+                      whether the spot is worth chasing. A glyph rather than a
+                      colour also keeps it off the channel the statuses use. */}
+                  {showLotw && entry?.lotw && (
+                    <span title={t('clu.lotwBadge')} className="text-[9px] font-normal rounded px-1 py-px"
+                      style={{ background: 'color-mix(in srgb, var(--info) 22%, transparent)', color: 'var(--info)' }}>L</span>
+                  )}
                   {mode && (
                     <span className="text-[9px] font-normal text-current/70 bg-current/10 rounded px-1 py-px">
                       {mode}

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';
 
@@ -172,8 +173,17 @@ export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, hasCal
     () => (lat == null || lon == null ? null : sunTimes(new Date(), lat, lon)),
     [lat, lon],
   );
+  // Stacked, not side by side. Laid out in a row this cost about 150 px of a
+  // header that has to hold the callsign, the badges and the band grid, and it
+  // was what pushed the whole row onto a second line. Two short times one above
+  // the other take a fraction of that and no extra height: the row is already
+  // taller than one line of text.
+  //
+  // "UTC" moves into the tooltip with them — the times are monospaced and always
+  // UTC everywhere in OpsLog, so the label was spending width to repeat a
+  // convention the operator already lives by.
   const sunBlock = sun ? (
-    <div className="ml-auto flex items-center gap-3 text-xs shrink-0"
+    <div className="ml-auto flex flex-col items-end leading-tight text-xs shrink-0"
       title="Sunrise / sunset at the DX station (UTC)">
       {sun.polarDay ? (
         <span className="font-semibold text-warning">midnight sun</span>
@@ -182,14 +192,13 @@ export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, hasCal
       ) : (
         <>
           <span className="flex items-center gap-1">
-            <Sunrise className="size-3.5 text-warning" />
+            <Sunrise className="size-3 text-warning" />
             <span className="font-mono tabular-nums">{sun.rise || '—'}</span>
           </span>
           <span className="flex items-center gap-1">
-            <Sunset className="size-3.5 text-info" />
+            <Sunset className="size-3 text-info" />
             <span className="font-mono tabular-nums">{sun.set || '—'}</span>
           </span>
-          <span className="text-muted-foreground">UTC</span>
         </>
       )}
     </div>
@@ -418,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/BulkEditModal.tsx

@@ -30,6 +30,8 @@ const FIELDS: FieldDef[] = [
   { id: 'qsl_rcvd',          label: 'bulk.fQslRcvd',         group: 'QSL / upload', kind: 'status' },
   { id: 'qsl_rcvd_date',     label: 'bulk.fQslRcvdDate',     group: 'QSL / upload', kind: 'date' },
   { id: 'qsl_via',           label: 'bulk.fQslVia',          group: 'QSL / upload', kind: 'text' },
+  { id: 'qsl_sent_via',      label: 'bulk.fQslSentVia',      group: 'QSL / upload', kind: 'text' },
+  { id: 'qsl_rcvd_via',      label: 'bulk.fQslRcvdVia',      group: 'QSL / upload', kind: 'text' },
   { id: 'lotw_sent',         label: 'bulk.fLotwSent',        group: 'QSL / upload', kind: 'status' },
   { id: 'lotw_sent_date',    label: 'bulk.fLotwSentDate',    group: 'QSL / upload', kind: 'date' },
   { id: 'lotw_rcvd',         label: 'bulk.fLotwRcvd',        group: 'QSL / upload', kind: 'status' },
@@ -91,6 +93,17 @@ const FIELDS: FieldDef[] = [
   { id: 'iota',     label: 'bulk.fIota',    group: 'Contacted station', kind: 'text', upper: true },
   { id: 'sig',      label: 'bulk.fSig',     group: 'Contacted station', kind: 'text' },
   { id: 'sig_info', label: 'bulk.fSigInfo', group: 'Contacted station', kind: 'text' },
+  // The contact itself — repair fields, not description fields. An import that
+  // mapped every QSO to SSB, or an ADIF with no MODE at all, is fixed here
+  // instead of one row at a time.
+  //
+  // Band is deliberately absent: it travels with the frequency below, because a
+  // band contradicting its own frequency is invalid ADIF and every export would
+  // carry the contradiction.
+  { id: 'mode',     label: 'bulk.fMode',    group: 'The contact', kind: 'text', upper: true },
+  { id: 'submode',  label: 'bulk.fSubmode', group: 'The contact', kind: 'text', upper: true },
+  { id: 'rst_sent', label: 'bulk.fRstSent', group: 'The contact', kind: 'text' },
+  { id: 'rst_rcvd', label: 'bulk.fRstRcvd', group: 'The contact', kind: 'text' },
   // Misc
   // Frequency (MHz) — sets freq_hz AND recomputes band. Main use: fixing a batch
   // logged on a stale/default frequency after CAT dropped.
@@ -110,7 +123,12 @@ const STATUS_VALUES: { v: string; label: string }[] = [
   { v: '_', label: 'bulk.statusBlank' },
 ];
 
-const GROUPS = ['QSL / upload', 'My station', 'Contacted station', 'Contest', 'Propagation', 'Misc'];
+// Derived from the fields themselves, in the order they are declared.
+//
+// This used to be a hand-written list, and a group added to FIELDS but not to it
+// simply never rendered — the fields existed, passed every check, and could not
+// be picked. Two lists that must agree, with nothing to make them.
+const GROUPS = [...new Set(FIELDS.map((f) => f.group))];
 // Maps the internal group key → its i18n label key.
 const GROUP_LABELS: Record<string, string> = {
   'QSL / upload': 'bulk.groupQsl',
@@ -119,6 +137,7 @@ const GROUP_LABELS: Record<string, string> = {
   'Contest': 'bulk.groupContest',
   'Propagation': 'bulk.groupPropagation',
   'Misc': 'bulk.groupMisc',
+  'The contact': 'bulk.groupContact',
 };
 
 type Props = {
@@ -177,7 +196,7 @@ export function BulkEditModal({ open, ids, onClose, onApplied }: Props) {
               <SelectContent>
                 {GROUPS.map((g) => (
                   <div key={g}>
-                    <div className="px-2 py-1 text-[10px] uppercase tracking-wider text-muted-foreground">{t(GROUP_LABELS[g])}</div>
+                    <div className="px-2 py-1 text-[10px] uppercase tracking-wider text-muted-foreground">{GROUP_LABELS[g] ? t(GROUP_LABELS[g]) : g}</div>
                     {FIELDS.filter((f) => f.group === g)
                       .map((f) => ({ f, txt: t(f.label) }))
                       .sort((a, b) => a.txt.localeCompare(b.txt))

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/DetailsPanel.tsx

@@ -42,6 +42,7 @@ export interface DetailsState {
   srx_string?: string;
   stx_string?: string;
   email: string;
+  web?: string;
   // Award references for the contacted station (set via the Awards tab picker).
   // Semicolon-delimited "AWARD@REF" entries, e.g. "POTA@FR-11553;IOTA@EU-064".
   // App.tsx maps these back to pota_ref/sota_ref/iota when saving the QSO.
@@ -373,12 +374,16 @@ export function DetailsPanel({ callsign, prefix, operatorGrid, remoteGrid, qth,
               <Input value={details.address} onChange={(e) => onChange({ address: e.target.value })} />
             </Field>
           </div>
-          <Field label={t('detp.qslMessage')} span={7}>
-            <Input value={details.qsl_msg} onChange={(e) => onChange({ qsl_msg: e.target.value })} />
-          </Field>
-          <Field label={t('detp.qslVia')} span={5}>
+          {/* QSL via gets the room, not the message. Width should follow use, and
+              these two are nowhere near equal: a manager's callsign is filled in
+              constantly and a QSL message almost never. The message had 7 columns
+              of 12 for text most operators never type. */}
+          <Field label={t('detp.qslVia')} span={7}>
             <Input value={details.qsl_via} onChange={(e) => onChange({ qsl_via: e.target.value })} />
           </Field>
+          <Field label={t('detp.qslMessage')} span={5}>
+            <Input value={details.qsl_msg} onChange={(e) => onChange({ qsl_msg: e.target.value })} />
+          </Field>
         </div>
       )}
 
@@ -494,8 +499,14 @@ export function DetailsPanel({ callsign, prefix, operatorGrid, remoteGrid, qth,
           <Field label="STX">
             <Input value={details.stx_string ?? ''} placeholder={t('detp.sentExchangePh')} onChange={(e) => onChange({ stx_string: e.target.value })} />
           </Field>
-          <Field label={t('detp.contactedEmail')} span={3}>
-            <Input value={details.email} placeholder="[email protected]" onChange={(e) => onChange({ email: e.target.value })} />
+          {/* No placeholder: a greyed-out sample address in an empty field reads
+              as a value the lookup found, and that is exactly the field an
+              operator checks to see whether it found one. */}
+          <Field label={t('detp.contactedEmail')} span={2}>
+            <Input value={details.email} onChange={(e) => onChange({ email: e.target.value })} />
+          </Field>
+          <Field label={t('detp.contactedWeb')}>
+            <Input value={details.web ?? ''} onChange={(e) => onChange({ web: e.target.value })} />
           </Field>
         </div>
       )}

frontend/src/components/FilterBuilder.tsx

@@ -68,6 +68,8 @@ const FIELDS: { value: string; label: string; type: FieldType }[] = [
   { value: 'qsl_rcvd', label: 'fltb.fQslRcvd', type: 'text' },
   { value: 'qsl_rcvd_date', label: 'fltb.fQslRcvdDate', type: 'adifdate' },
   { value: 'qsl_via', label: 'fltb.fQslVia', type: 'text' },
+  { value: 'qsl_sent_via', label: 'fltb.fQslSentVia', type: 'text' },
+  { value: 'qsl_rcvd_via', label: 'fltb.fQslRcvdVia', type: 'text' },
   { value: 'lotw_sent', label: 'fltb.fLotwSent', type: 'text' },
   { value: 'lotw_sent_date', label: 'fltb.fLotwSentDate', type: 'adifdate' },
   { value: 'lotw_rcvd', label: 'fltb.fLotwRcvd', type: 'text' },

frontend/src/components/QSLManagerModal.tsx

@@ -54,12 +54,14 @@ 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: 'Bureau', label: 'qslm.viaBureau' },
-  { v: 'Direct', label: 'qslm.viaDirect' },
-  { v: 'Electronic', label: 'qslm.viaElectronic' },
+  { v: 'B', label: 'qslm.viaBureau' },
+  { v: 'D', label: 'qslm.viaDirect' },
+  { v: 'E', label: 'qslm.viaElectronic' },
 ];
 
 // Maps a service value → its i18n label key (only for services with
@@ -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')} />
+              <Select value={qslVia} onValueChange={setQslVia}>
+                <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.via')}</label>
-            <Select value={qslVia} onValueChange={setQslVia}>
-              <SelectTrigger className="h-8 w-32"><SelectValue /></SelectTrigger>
-              <SelectContent>{QSL_VIA_OPTIONS.map((o) => <SelectItem key={o.v} value={o.v}>{t(o.label)}</SelectItem>)}</SelectContent>
-            </Select>
-          </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' },
@@ -57,10 +62,12 @@ type ConfDef = {
   key: string; label: string;
   sent?: keyof QSOForm; rcvd?: keyof QSOForm;
   sentDate?: keyof QSOForm; rcvdDate?: keyof QSOForm;
-  via?: keyof QSOForm;
+  // How the card travelled, each way (ADIF QSL_SENT_VIA / QSL_RCVD_VIA). Paper
+  // only — the electronic channels below ARE the route.
+  sentVia?: keyof QSOForm; rcvdVia?: keyof QSOForm;
 };
 const CONFIRMATIONS: ConfDef[] = [
-  { key: 'QSL',     label: 'QSL (paper)', sent: 'qsl_sent',  rcvd: 'qsl_rcvd',  sentDate: 'qsl_sent_date',  rcvdDate: 'qsl_rcvd_date',  via: 'qsl_via' },
+  { key: 'QSL',     label: 'QSL (paper)', sent: 'qsl_sent',  rcvd: 'qsl_rcvd',  sentDate: 'qsl_sent_date',  rcvdDate: 'qsl_rcvd_date',  sentVia: 'qsl_sent_via', rcvdVia: 'qsl_rcvd_via' },
   { key: 'LOTW',    label: 'LoTW',        sent: 'lotw_sent', rcvd: 'lotw_rcvd', sentDate: 'lotw_sent_date', rcvdDate: 'lotw_rcvd_date' },
   { key: 'EQSL',    label: 'eQSL',        sent: 'eqsl_sent', rcvd: 'eqsl_rcvd', sentDate: 'eqsl_sent_date', rcvdDate: 'eqsl_rcvd_date' },
   { key: 'QRZCOM',  label: 'QRZ.com',     sent: 'qrzcom_qso_upload_status' as any, sentDate: 'qrzcom_qso_upload_date' as any, rcvd: 'qrzcom_qso_download_status' as any, rcvdDate: 'qrzcom_qso_download_date' as any },
@@ -97,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 cls = v === 'Y' ? 'bg-success text-success-foreground border border-success'
+  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' || 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'
@@ -216,6 +228,28 @@ function QslSelect({ value, onChange }: { value?: string; onChange: (v: string)
   );
 }
 
+// The ADIF QSL Via enumeration. M (manager) is import-only in the standard, so
+// it is not offered here — a file that arrives carrying it keeps it, and this
+// list is what an operator may choose.
+const QSL_VIA_CHOICES = [
+  { value: '_', label: 'qedit.qslDash' },
+  { value: 'B', label: 'qedit.viaBureau' },
+  { value: 'D', label: 'qedit.viaDirect' },
+  { value: 'E', label: 'qedit.viaElectronic' },
+];
+
+function QslViaSelect({ value, onChange }: { value?: string; onChange: (v: string) => void }) {
+  const { t } = useI18n();
+  return (
+    <Select value={value || '_'} onValueChange={(v) => onChange(v === '_' ? '' : v)}>
+      <SelectTrigger><SelectValue /></SelectTrigger>
+      <SelectContent>
+        {QSL_VIA_CHOICES.map((s) => <SelectItem key={s.value} value={s.value}>{t(s.label)}</SelectItem>)}
+      </SelectContent>
+    </Select>
+  );
+}
+
 export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], bands, modes }: Props) {
   const { t } = useI18n();
   // Use the operator's configured band/mode lists (incl. custom ones like 13cm);
@@ -633,7 +667,12 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
                     <Label>{t('qedit.qslMsg')}</Label>
                     <Input value={draft.qsl_msg ?? ''} onChange={(e) => set('qsl_msg', e.target.value)} />
                   </div>
-                  <div><Label>{t('qedit.qslVia')}</Label><Input value={draft.qsl_via ?? ''} onChange={(e) => set('qsl_via', e.target.value)} /></div>
+                  {/* The manager, and only the manager — ADIF QSL_VIA. How the
+                      card travelled is a separate field, on the QSL Info tab. */}
+                  <div>
+                    <Label>{t('qedit.qslVia')}</Label>
+                    <Input value={draft.qsl_via ?? ''} onChange={(e) => set('qsl_via', e.target.value)} placeholder={t('qedit.qslViaPlaceholder')} />
+                  </div>
                 </div>
               </div>
             </TabsContent>
@@ -734,8 +773,14 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
                             </div>
                             <div><Label>{t('qedit.dateSent')}</Label><AdifDateInput value={val(def.sentDate)} onChange={(v) => put(def.sentDate, v)} /></div>
                             <div><Label>{t('qedit.dateReceived')}</Label><AdifDateInput value={val(def.rcvdDate)} onChange={(v) => put(def.rcvdDate, v)} disabled={!def.rcvdDate} /></div>
-                            {def.via && (
-                              <div className="col-span-2"><Label>{t('qedit.via')}</Label><Input value={val(def.via)} onChange={(e) => put(def.via, e.target.value)} placeholder={t('qedit.viaPlaceholder')} /></div>
+                            {/* How the card travelled, each way — ADIF's QSL Via
+                                enumeration. Not the manager: that is a callsign
+                                and lives on the Contact's details tab. */}
+                            {def.sentVia && (
+                              <div><Label>{t('qedit.sentVia')}</Label><QslViaSelect value={val(def.sentVia)} onChange={(v) => put(def.sentVia, v)} /></div>
+                            )}
+                            {def.rcvdVia && (
+                              <div><Label>{t('qedit.rcvdVia')}</Label><QslViaSelect value={val(def.rcvdVia)} onChange={(v) => put(def.rcvdVia, v)} /></div>
                             )}
                           </div>
                           <p className="text-[11px] text-muted-foreground">

frontend/src/components/RecentQSOsGrid.tsx

@@ -18,6 +18,7 @@ import { Checkbox } from '@/components/ui/checkbox';
 import { loadLocal, loadRemote, saveState, seedLocal } from '@/lib/gridPrefs';
 import { useI18n } from '@/lib/i18n';
 import { gridToLatLon, pathBetweenLatLon } from '@/lib/maidenhead';
+import { rowStyleFor, type RowColorSettings } from '@/lib/rowColors';
 
 // Register every Community feature once. v32+ requires explicit registration;
 // AllCommunityModule keeps it simple and pulls in sort/filter/resize/reorder/
@@ -80,6 +81,8 @@ type Props = {
   // One column per defined award; the cell shows the reference this QSO counts
   // for (from row.award_refs[CODE], attached by the parent). Hidden by default.
   awardCols?: { code: string; name: string }[];
+  // Whole-row colouring by QSL / LoTW status (Settings → Appearance).
+  rowColors?: RowColorSettings | null;
 };
 
 const BASE_COLSTATE_KEY = 'hamlog.qsoColState.v2';
@@ -132,6 +135,10 @@ function qsoDistanceKm(d: any, myGrid?: string): number | undefined {
 
 export const makeColCatalog = (t: TFn, myGrid?: string): ColEntry[] => [
   // ── QSO basics ──
+  // Position in the log, oldest = 1. Filled by the backend over the WHOLE log,
+  // so it does not change when a filter narrows what is shown.
+  { group: 'QSO', label: t('rqg.c.number'), colId: 'number', headerName: t('rqg.h.number'), field: 'number' as any, width: 80, type: 'rightAligned', cellClass: 'font-mono',
+    comparator: (a, b) => (a ?? 0) - (b ?? 0) },
   { group: 'QSO', label: t('rqg.c.qso_date'),  colId: 'qso_date', headerName: t('rqg.c.qso_date'), field: 'qso_date' as any, width: 150, cellClass: 'font-mono', valueFormatter: (p) => fmtDateUTC(p.value), sort: 'desc', defaultVisible: true },
   { group: 'QSO', label: t('rqg.c.qso_date_off'),  colId: 'qso_date_off', headerName: t('rqg.c.qso_date_off'), field: 'qso_date_off' as any, width: 150, cellClass: 'font-mono', valueFormatter: (p) => fmtDateUTC(p.value) },
   { group: 'QSO', label: t('rqg.c.callsign'),  colId: 'callsign', headerName: t('rqg.c.callsign'), field: 'callsign' as any, width: 110, cellClass: 'font-mono font-semibold', defaultVisible: true },
@@ -179,6 +186,8 @@ export const makeColCatalog = (t: TFn, myGrid?: string): ColEntry[] => [
   { group: 'QSL',  label: t('rqg.c.qsl_sent_date'),colId: 'qsl_sent_date', headerName: t('rqg.h.qsl_sent_date'), field: 'qsl_sent_date' as any, width: 120, valueFormatter: (p) => fmtDateOnly(p.value) },
   { group: 'QSL',  label: t('rqg.c.qsl_rcvd_date'),colId: 'qsl_rcvd_date', headerName: t('rqg.h.qsl_rcvd_date'), field: 'qsl_rcvd_date' as any, width: 120, valueFormatter: (p) => fmtDateOnly(p.value) },
   { group: 'QSL',  label: t('rqg.c.qsl_via'),      colId: 'qsl_via',       headerName: t('rqg.c.qsl_via'),    field: 'qsl_via' as any,       width: 130 },
+  { group: 'QSL',  label: t('rqg.c.qsl_sent_via'), colId: 'qsl_sent_via',  headerName: t('rqg.h.qsl_sent_via'), field: 'qsl_sent_via' as any, width: 110 },
+  { group: 'QSL',  label: t('rqg.c.qsl_rcvd_via'), colId: 'qsl_rcvd_via',  headerName: t('rqg.h.qsl_rcvd_via'), field: 'qsl_rcvd_via' as any, width: 110 },
   { group: 'QSL',  label: t('rqg.c.qsl_msg'),      colId: 'qsl_msg',       headerName: t('rqg.c.qsl_msg'),    field: 'qsl_msg' as any,       width: 200 },
   { group: 'QSL',  label: t('rqg.c.qslmsg_rcvd'), colId: 'qslmsg_rcvd',   headerName: t('rqg.c.qslmsg_rcvd'), field: 'qslmsg_rcvd' as any, width: 200 },
 
@@ -299,7 +308,7 @@ const sanitizeAwardCols = (st: any[] | null | undefined): any[] =>
     return rest;
   });
 
-export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal, rowDragCall, passOrder, onGridApi, storageKey, onRowDoubleClicked, onRowClicked, onRowSelected, onRowSelectedQso, onUpdateFromCty, onUpdateFromQRZ, onUpdateFromClublog, onSendTo, onSendRecording, onSendEQSL, onBulkEdit, onExportSelected, onExportSelectedFields, onExportFiltered, onExportCabrilloSelected, onExportCabrilloFiltered, onDelete, onFilteredCountChange, awardCols }: Props) {
+export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal, rowDragCall, passOrder, onGridApi, storageKey, onRowDoubleClicked, onRowClicked, onRowSelected, onRowSelectedQso, onUpdateFromCty, onUpdateFromQRZ, onUpdateFromClublog, onSendTo, onSendRecording, onSendEQSL, onBulkEdit, onExportSelected, onExportSelectedFields, onExportFiltered, onExportCabrilloSelected, onExportCabrilloFiltered, onDelete, onFilteredCountChange, awardCols, rowColors }: Props) {
   const { t } = useI18n();
   const gridRef = useRef<any>(null);
   const [pickerOpen, setPickerOpen] = useState(false);
@@ -696,6 +705,7 @@ export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal,
             animateRows={false}
             suppressCellFocus
             getRowId={(p) => String((p.data as any).id)}
+            getRowStyle={(p) => rowStyleFor(p.data, rowColors ?? null)}
           />
         </div>
       </div>

frontend/src/components/RotorCompass.tsx

@@ -128,7 +128,9 @@ export function RotorCompass({ bearing, headings, boomHeading, pattern, centerLa
         </div>
       )}
 
-      <div className="flex items-center justify-center p-2 min-h-0">
+      {/* flex-col: the readout goes BELOW the dial. This wrapper was a row, so a
+          sibling of the <svg> landed beside it. */}
+      <div className="flex flex-col items-center justify-center p-2 min-h-0">
         <svg
           viewBox={`0 0 ${SIZE} ${SIZE}`}
           className={onGoto ? 'cursor-pointer select-none' : 'select-none'}
@@ -188,6 +190,31 @@ export function RotorCompass({ bearing, headings, boomHeading, pattern, centerLa
           ); })}
           <circle cx={C} cy={C} r={3.5} fill="#15803d" stroke="#fff" strokeWidth={1} />
         </svg>
+
+        {/* Short and long path to the DX, in figures.
+            The bezel already carries the short path as a red marker, but a
+            marker is a direction, not a number — the same pair sits in the
+            status bar at 10px and operators reported not being able to read it.
+            Here because it belongs to the compass: every place that draws one
+            gets the readout, instead of each caller inventing its own.
+            Clickable when the caller can turn, like the status bar's. */}
+        <div className="flex gap-1.5 mt-2 font-mono w-full">
+          {([['SP', bearing ?? null], ['LP', bearing == null ? null : (bearing + 180) % 360]] as const).map(([lbl, az]) => (
+            <button key={lbl} type="button" disabled={az == null || !onGoto}
+              onClick={() => { if (az != null && onGoto) onGoto(Math.round(az)); }}
+              title={az == null ? '' : `${lbl} ${Math.round(az)}°`}
+              className={
+                'flex-1 rounded-md border py-1 text-xs font-semibold tabular-nums transition-colors ' +
+                (az == null
+                  ? 'border-border text-muted-foreground/50 cursor-not-allowed'
+                  : onGoto
+                    ? 'border-info-border text-info-muted-foreground hover:bg-info-muted cursor-pointer'
+                    : 'border-border text-muted-foreground cursor-default')
+              }>
+              {lbl} {az == null ? '—' : `${Math.round(az)}°`}
+            </button>
+          ))}
+        </div>
       </div>
     </section>
   );

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,
+  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';
@@ -77,6 +77,7 @@ import { getDateFormat, setDateFormat, type DateFormat } from '@/lib/dateFormat'
 import { useI18n, FlagGB, FlagFR, type Lang } from '@/lib/i18n';
 import { useTheme, CONCRETE_THEMES, type ThemeChoice } from '@/lib/theme';
 import { OperatingPanel } from '@/components/OperatingPanel';
+import { AppearancePanel } from '@/components/AppearancePanel';
 import { UDPIntegrationsPanel } from '@/components/UDPIntegrationsPanel';
 
 type LookupSettings = LookupSettingsForm;
@@ -108,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' },
@@ -176,6 +178,7 @@ interface Props {
    `disabled: true` greys them out and shows the "coming soon" placeholder. */
 type SectionId =
   | 'general'
+  | 'appearance'
   | 'email'
   | 'station'
   | 'profiles'
@@ -266,6 +269,7 @@ function buildTree(flexAvailable: boolean, t: (k: string) => string): TreeNode[]
   {
     kind: 'group', label: t('nav.software'), icon: Cog, defaultOpen: true, children: [
       { kind: 'item', label: t('sec.general'), id: 'general' },
+      { kind: 'item', label: t('sec.appearance'), id: 'appearance' },
       { kind: 'item', label: t('sec.email'), id: 'email' },
       { kind: 'item', label: t('sec.lookup'), id: 'lookup' },
       { kind: 'group', label: t('nav.lists'), icon: Database, defaultOpen: true, children: [
@@ -290,7 +294,7 @@ function buildTree(flexAvailable: boolean, t: (k: string) => string): TreeNode[]
 // Map section id → i18n key (breadcrumb / placeholders).
 const SECTION_KEY: Partial<Record<SectionId, string>> = {
   station: 'sec.station', profiles: 'sec.profiles', operating: 'sec.operating', confirmations: 'sec.confirmations',
-  'external-services': 'sec.external', lookup: 'sec.lookup', 'lists-bands': 'sec.bands', 'lists-modes': 'sec.modes',
+  'external-services': 'sec.external', appearance: 'sec.appearance', lookup: 'sec.lookup', 'lists-bands': 'sec.bands', 'lists-modes': 'sec.modes',
   cluster: 'sec.cluster', backup: 'sec.backup', database: 'sec.database', autostart: 'sec.autostart', udp: 'sec.udp',
   adifmon: 'sec.adifmon',
   webpublish: 'sec.webpublish',
@@ -409,6 +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: '#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' },
@@ -689,7 +694,20 @@ const RELAY_BANDS = ['160m', '80m', '60m', '40m', '30m', '20m', '17m', '15m', '1
 // Bands a motorized HF/6 m antenna (Ultrabeam / SteppIR) can cover — the follow
 // filter is a subset of these. Must match motorBands in app.go, low → high.
 const MOTOR_BANDS = ['40m', '30m', '20m', '17m', '15m', '12m', '10m', '6m'];
-const relayCountUI = (type: string) => (type === 'kmtronic' || type === 'denkovi' ? 8 : 5);
+// Shown as placeholders only — the backend owns these values (motorBands in
+// app.go) and resolves what a band button actually commands. Duplicated here
+// purely so an empty box can say what leaving it empty will do.
+const MOTOR_BAND_DEFAULT_KHZ: Record<string, number> = {
+  '40m': 7100, '30m': 10125, '20m': 14150, '17m': 18110,
+  '15m': 21150, '12m': 24930, '10m': 28400, '6m': 50150,
+};
+// 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
@@ -1214,6 +1232,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     hamqth_user: '', hamqth_password: '',
     primary: '', failsafe: '',
     download_images: false,
+    qrz_prefer_nickname: false,
     cache_ttl_days: 30,
   });
   // Per-provider Test state — keeps the success/error feedback adjacent
@@ -1250,8 +1269,8 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   const [rotatorTest, setRotatorTest] = useState<{ ok: boolean; msg: string } | null>(null);
 
   // Motorized antenna (Ultrabeam TCP or SteppIR TCP/serial) settings.
-  const [ultrabeam, setUltrabeam] = useState<{ enabled: boolean; type: string; transport: string; host: string; port: number; com: string; baud: number; follow: boolean; step_khz: number; tx_inhibit: boolean; bands: string[]; freq_min_mhz: number; freq_max_mhz: number }>({
-    enabled: false, type: 'ultrabeam', transport: 'tcp', host: '', port: 23, com: '', baud: 9600, follow: false, step_khz: 50, tx_inhibit: false, bands: [], freq_min_mhz: 13, freq_max_mhz: 54,
+  const [ultrabeam, setUltrabeam] = useState<{ enabled: boolean; type: string; transport: string; host: string; port: number; com: string; baud: number; follow: boolean; step_khz: number; track_mode: string; band_freqs: Record<string, number>; tx_inhibit: boolean; bands: string[]; freq_min_mhz: number; freq_max_mhz: number }>({
+    enabled: false, type: 'ultrabeam', transport: 'tcp', host: '', port: 23, com: '', baud: 9600, follow: false, step_khz: 50, track_mode: 'step', band_freqs: {}, tx_inhibit: false, bands: [], freq_min_mhz: 13, freq_max_mhz: 54,
   });
   const [ubTesting, setUbTesting] = useState(false);
   const [ubTest, setUbTest] = useState<{ ok: boolean; msg: string } | null>(null);
@@ -1263,6 +1282,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   // Amplifier list — operators can run SEVERAL amps (even two SPEs combined),
   // each with its own connection. Saved as a whole via SaveAmplifiers.
   const [amps, setAmps] = useState<AmpUI[]>([]);
+  const [linkedAmps, setLinkedAmps] = useState<string[]>([]);
 
   // WinKeyer CW keyer settings + macro editor.
   type WKMac = { label: string; text: string };
@@ -1431,13 +1451,15 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     tqsl_path: string; station_location: string; key_password: string;
     upload_flags: string[]; write_log: boolean;
     auto_upload: boolean; upload_mode: string;
+    // HRDLog only: publish the live frequency/mode/rig on hrdlog.net.
+    on_air?: boolean;
   };
   type ExternalServices = { qrz: ExtServiceCfg; clublog: ExtServiceCfg; lotw: ExtServiceCfg; hrdlog: ExtServiceCfg; eqsl: ExtServiceCfg; cloudlog: ExtServiceCfg; delete_remote?: boolean };
   const emptyExtCfg = (): ExtServiceCfg => ({
     api_key: '', url: '', station_id: '', email: '', username: '', password: '', callsign: '', code: '', qth_nickname: '',
     force_station_callsign: '', tqsl_path: '', station_location: '', key_password: '',
     upload_flags: ['N', 'R'], write_log: false,
-    auto_upload: false, upload_mode: 'immediate',
+    auto_upload: false, upload_mode: 'immediate', on_air: false,
   });
   const [extSvc, setExtSvc] = useState<ExternalServices>({
     qrz: emptyExtCfg(), clublog: emptyExtCfg(), lotw: emptyExtCfg(), hrdlog: emptyExtCfg(), eqsl: emptyExtCfg(), cloudlog: emptyExtCfg(), delete_remote: false,
@@ -1474,7 +1496,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     finally { setScpBusy(false); }
   };
   // US Counties (offline FCC ULS) — download progress arrives via events.
-  const [ulsStatus, setUlsStatus] = useState<{ count: number; updated_at?: string }>({ count: 0 });
+  const [ulsStatus, setUlsStatus] = useState<{ count: number; updated_at?: string; needs_refresh?: boolean }>({ count: 0 });
   const [ulsBusy, setUlsBusy] = useState(false);
   const [ulsProgress, setUlsProgress] = useState<{ stage: string; pct: number } | null>(null);
   const [ulsMsg, setUlsMsg] = useState<{ ok: boolean; text: string } | null>(null);
@@ -1545,6 +1567,11 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   // has side effects there — adding the RBN nodes, bringing the PSK Reporter
   // 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);
   const [pskrStatus, setPskrStatus] = useState<any>(null);
   const saveBandOpen = async (next: any) => {
     setBandOpen(next);
@@ -1553,11 +1580,16 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   useEffect(() => {
     (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 */ }
     })();
     // Poll the feed while the panel is open: a live count is the only thing that
     // distinguishes "connected" from "connected and receiving nothing".
     const t = window.setInterval(async () => {
       try { setPskrStatus(await GetPSKReporterStatus()); } catch { /* ignore */ }
+      try { setGridStat(await GetGridCacheStatus()); } catch { /* ignore */ }
     }, 3000);
     return () => window.clearInterval(t);
   }, []);
@@ -2295,6 +2327,23 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
               </span>
             </span>
           </label>
+
+          {/* QRZ only. HamQTH's <nick> already fills the Name field with the
+              on-air name, so the same switch there would toggle a behaviour it
+              has no way to turn off. */}
+          <label className="flex items-start gap-2 text-sm cursor-pointer mt-3">
+            <Checkbox
+              checked={!!(lookup as any).qrz_prefer_nickname}
+              onCheckedChange={(c) => setLookup((s) => ({ ...s, qrz_prefer_nickname: !!c } as any))}
+              className="mt-0.5"
+            />
+            <span>
+              {t('lk.qrzNickname')}
+              <span className="block text-xs text-muted-foreground mt-0.5">
+                {t('lk.qrzNicknameHint')}
+              </span>
+            </span>
+          </label>
         </div>
 
         <div className="mt-6 pt-4 border-t border-border">
@@ -3140,45 +3189,96 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
           <div className="border-t border-border/60 pt-3 space-y-2">
             <label className="flex items-center gap-2 text-sm cursor-pointer">
               <Checkbox checked={ultrabeam.follow} onCheckedChange={(c) => setUltrabeam((s) => ({ ...s, follow: !!c }))} />
-              Follow rig frequency (auto-tune the antenna)
+              {t('hw.motorFollow')}
             </label>
             {ultrabeam.follow && (
-              <div className="flex items-center gap-3 pl-6">
-                <Label className="text-sm">Re-tune step</Label>
-                <Select value={String(ultrabeam.step_khz)} onValueChange={(v) => setUltrabeam((s) => ({ ...s, step_khz: parseInt(v, 10) || 50 }))}>
-                  <SelectTrigger className="h-8 w-32"><SelectValue /></SelectTrigger>
-                  <SelectContent>
-                    <SelectItem value="25">25 kHz</SelectItem>
-                    <SelectItem value="50">50 kHz</SelectItem>
-                    <SelectItem value="100">100 kHz</SelectItem>
-                  </SelectContent>
-                </Select>
-                <span className="text-xs text-muted-foreground">re-tune only when the frequency moves this far</span>
+              <div className="space-y-2 pl-6">
+                <div className="flex items-center gap-3">
+                  <Label className="text-sm">{t('station.trackModeTip')}</Label>
+                  <Select value={ultrabeam.track_mode || 'step'} onValueChange={(v) => setUltrabeam((s) => ({ ...s, track_mode: v }))}>
+                    <SelectTrigger className="h-8 w-52"><SelectValue /></SelectTrigger>
+                    <SelectContent>
+                      <SelectItem value="always">{t('station.trackAlways')}</SelectItem>
+                      <SelectItem value="step">{t('station.trackStep')}</SelectItem>
+                      <SelectItem value="band">{t('station.trackBand')}</SelectItem>
+                    </SelectContent>
+                  </Select>
+                </div>
+                {/* The step is only a question in step mode — the other two modes
+                    have nothing to threshold. */}
+                {(ultrabeam.track_mode || 'step') === 'step' && (
+                  <div className="flex items-center gap-3">
+                    <Label className="text-sm">{t('hw.motorStep')}</Label>
+                    <Select value={String(ultrabeam.step_khz)} onValueChange={(v) => setUltrabeam((s) => ({ ...s, step_khz: parseInt(v, 10) || 50 }))}>
+                      <SelectTrigger className="h-8 w-32"><SelectValue /></SelectTrigger>
+                      <SelectContent>
+                        <SelectItem value="25">25 kHz</SelectItem>
+                        <SelectItem value="50">50 kHz</SelectItem>
+                        <SelectItem value="100">100 kHz</SelectItem>
+                      </SelectContent>
+                    </Select>
+                  </div>
+                )}
+                <p className="text-xs text-muted-foreground">
+                  {(ultrabeam.track_mode || 'step') === 'always' ? t('station.trackAlwaysTip')
+                    : (ultrabeam.track_mode || 'step') === 'band' ? t('station.trackBandTip')
+                      : t('station.trackStepTipMode')}
+                </p>
               </div>
             )}
           </div>
           {(isSteppir || ultrabeam.type === 'ultrabeam') && (
             <div className="border-t border-border/60 pt-3 space-y-2">
               <Label className="text-sm">{t('hw.motorBands')}</Label>
-              <div className="flex items-center gap-1.5 flex-wrap">
+              {/* Band, and under it the frequency its button tunes to — the
+                  layout of the SteppIR controller's own Bands and Frequencies
+                  table, which is where operators expect to find this. The box
+                  only appears on a selected band: a tune frequency for a band the
+                  antenna is not allowed on is a setting with no effect. Left
+                  empty it shows the default as placeholder, so the field is
+                  self-documenting and clearing it is how you go back. */}
+              <div className="flex items-start gap-1.5 flex-wrap">
                 {MOTOR_BANDS.map((b) => {
                   const on = ultrabeam.bands.includes(b);
                   return (
-                    <button key={b} type="button"
-                      onClick={() => setUltrabeam((s) => ({
-                        ...s,
-                        bands: on ? s.bands.filter((x) => x !== b) : [...s.bands, b],
-                      }))}
-                      className={`h-8 min-w-[3rem] rounded-md border px-2 text-sm font-medium transition-colors ${
-                        on
-                          ? 'border-primary bg-primary/15 text-primary'
-                          : 'border-input bg-background text-muted-foreground hover:bg-muted'
-                      }`}>
-                      {b}
-                    </button>
+                    <div key={b} className="flex flex-col gap-1">
+                      <button type="button"
+                        onClick={() => setUltrabeam((s) => ({
+                          ...s,
+                          bands: on ? s.bands.filter((x) => x !== b) : [...s.bands, b],
+                        }))}
+                        className={`h-8 w-[4.5rem] rounded-md border px-2 text-sm font-medium transition-colors ${
+                          on
+                            ? 'border-primary bg-primary/15 text-primary'
+                            : 'border-input bg-background text-muted-foreground hover:bg-muted'
+                        }`}>
+                        {b}
+                      </button>
+                      {on && (
+                        <input
+                          type="text" inputMode="numeric"
+                          value={ultrabeam.band_freqs?.[b] ? String(ultrabeam.band_freqs[b]) : ''}
+                          placeholder={String(MOTOR_BAND_DEFAULT_KHZ[b] ?? '')}
+                          title={t('hw.motorBandFreqHint')}
+                          onChange={(e) => {
+                            // Keep only digits, and store nothing for an empty box
+                            // so it round-trips to "use the default" rather than
+                            // to a zero the backend would have to interpret.
+                            const digits = e.target.value.replace(/[^0-9]/g, '');
+                            setUltrabeam((s) => {
+                              const next = { ...(s.band_freqs || {}) };
+                              if (digits === '') delete next[b]; else next[b] = parseInt(digits, 10);
+                              return { ...s, band_freqs: next };
+                            });
+                          }}
+                          className="h-7 w-[4.5rem] rounded-md border border-input bg-background px-1.5 text-center text-xs font-mono outline-none focus:border-primary"
+                        />
+                      )}
+                    </div>
                   );
                 })}
               </div>
+              <p className="text-xs text-muted-foreground">{t('hw.motorBandFreqHint')}</p>
             </div>
           )}
           <div className="border-t border-border/60 pt-3 space-y-1">
@@ -3514,6 +3614,38 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             <Plus className="size-3.5 mr-1" /> {t('amp.add')}
           </Button>
 
+          {/* WHICH amplifiers are coupled, not whether coupling is on.
+              A station can run a combiner pair AND a third amplifier that has
+              nothing to do with it — two SPE on the combiner, a PowerGenius on
+              another antenna — so a single switch would send that third one into
+              OPERATE alongside them. Shown from two amplifiers up. */}
+          {amps.length > 1 && (
+            <div className="border-t border-border/60 pt-3 space-y-2">
+              <div className="text-sm">{t('amp.linked')}</div>
+              <p className="text-xs text-muted-foreground">{t('amp.linkedHint')}</p>
+              <div className="flex flex-wrap gap-x-4 gap-y-1.5">
+                {amps.filter((x) => (x.id ?? '') !== '').map((x) => {
+                  const on = linkedAmps.includes(x.id!);
+                  return (
+                    <label key={x.id} className="flex items-center gap-1.5 text-sm cursor-pointer">
+                      <Checkbox checked={on} onCheckedChange={(c) => {
+                        const next = c ? [...linkedAmps, x.id!] : linkedAmps.filter((v) => v !== x.id);
+                        setLinkedAmps(next);
+                        SetLinkedAmps(next).catch(() => {});
+                      }} />
+                      {x.name?.trim() || x.type}
+                    </label>
+                  );
+                })}
+              </div>
+              {/* An amplifier saved without an id cannot be a member — say so
+                  rather than silently leaving it out of the list. */}
+              {amps.some((x) => (x.id ?? '') === '') && (
+                <p className="text-xs text-muted-foreground">{t('amp.linkedSaveFirst')}</p>
+              )}
+            </div>
+          )}
+
         </div>
       </>
     );
@@ -3542,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">
@@ -3561,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>
@@ -3584,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 })}>
@@ -3619,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>
@@ -3652,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">
@@ -4169,6 +4325,63 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
               things set up once. A preferences dialog you reopen every ten minutes
               is a filter in the wrong place. */}
 
+          {/* Grid chasing. Here rather than in the filter panel because it is set
+              up once: it decides whether locators learnt from decodes are KEPT
+              across restarts, not what the list shows right now. */}
+          {/* Spot lifetime. Applies to the cluster list AND every band map: the
+              spots are removed from the shared list rather than hidden, so the
+              setting cannot mean one thing in one view and another elsewhere. */}
+          <div className="border-t border-border/60 pt-3 space-y-2">
+            <div className="flex items-center gap-3 flex-wrap">
+              <span className="text-sm">{t('clu.spotTtl')}</span>
+              <div className="inline-flex rounded-md border border-border overflow-hidden text-xs">
+                {[0, 5, 10, 15, 30, 60].map((v) => (
+                  <button key={v} type="button"
+                    onClick={() => { setSpotTTL(v); setSpotTTLText(String(v)); SetSpotTTLMinutes(v).catch(() => {}); }}
+                    className={cn('px-2.5 py-1.5 font-medium', spotTTL === v ? 'bg-primary text-primary-foreground' : 'text-muted-foreground hover:bg-muted')}>
+                    {v === 0 ? t('clu.spotTtlNever') : `${v}′`}
+                  </button>
+                ))}
+              </div>
+              {/* Raw text in local state: binding the input straight to the
+                  clamped number makes an empty field impossible to type into. */}
+              <Input className="h-8 w-20" value={spotTTLText}
+                onChange={(e) => {
+                  const raw = e.target.value.replace(/[^0-9]/g, '');
+                  setSpotTTLText(raw);
+                  const n = Math.min(720, parseInt(raw, 10) || 0);
+                  setSpotTTL(n);
+                  SetSpotTTLMinutes(n).catch(() => {});
+                }} />
+              <span className="text-xs text-muted-foreground">{t('clu.spotTtlHint')}</span>
+            </div>
+          </div>
+
+          <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={chaseGrids} className="mt-0.5"
+                onCheckedChange={(c) => { setChaseGrids(!!c); SetChaseNewGrids(!!c).catch(() => {}); }} />
+              <span>{t('clu.chaseGrids')} <span className="text-xs text-muted-foreground">{t('clu.chaseGridsHint')}</span></span>
+            </label>
+            {chaseGrids && (
+              <p className="pl-6 text-xs text-muted-foreground">
+                {t('clu.chaseGridsStat', { n: gridStat?.known ?? 0, p: gridStat?.pending ?? 0 })}
+                {pskrStatus?.running ? ` · ${t('bo.feedUp', { n: pskrStatus.received ?? 0 })}` : ''}
+              </p>
+            )}
+          </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. */}
@@ -4887,6 +5100,20 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                 {t('es.autoUpload')}
               </label>
 
+              {/* ON AIR is a live status, not an upload: it needs the rig
+                  readable, not a QSO. Its own switch beside the upload one
+                  rather than folded into it. */}
+              <label className="flex items-start gap-2 text-sm cursor-pointer">
+                <Checkbox className="mt-0.5"
+                  checked={!!(hrdlog as any).on_air}
+                  onCheckedChange={(c) => setHrdlog({ on_air: !!c } as any)}
+                />
+                <span>
+                  {t('es.hrdOnAir')}
+                  <span className="block text-xs text-muted-foreground mt-0.5">{t('es.hrdOnAirHint')}</span>
+                </span>
+              </label>
+
               <div className="grid grid-cols-[170px_1fr] gap-3 items-center">
                 <Label className="text-sm">{t('es.uploadTiming')}</Label>
                 <Select
@@ -6050,6 +6277,15 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             </Button>
           </div>
 
+          {/* A database downloaded by an older OpsLog still holds Connecticut's
+              planning regions instead of its counties. The download date cannot
+              show that, so say it outright. */}
+          {loaded && ulsStatus.needs_refresh && !ulsBusy && (
+            <div className="text-[11px] rounded border border-warning-border bg-warning-muted text-warning-muted-foreground px-2 py-1.5 leading-relaxed">
+              {t('uscty.stale')}
+            </div>
+          )}
+
           {ulsProgress && (
             <div className="space-y-1">
               <div className="text-[11px] text-muted-foreground flex justify-between">
@@ -6084,6 +6320,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   // Map sections to their content + icon (for placeholder).
   const PANELS: Record<SectionId, () => JSX.Element> = {
     general:        GeneralPanel,
+    appearance:     () => <AppearancePanel />,
     email:          EmailPanel,
     station:        StationPanel,
     profiles:       ProfilesPanel,

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,15 +39,21 @@ 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 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 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', 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)
-      : (RELAY_COUNT[d.type] ?? 5);
+      : d.type === 'httpgen' ? (d.channels && d.channels >= 1 ? d.channels : 4)
+        : (RELAY_COUNT[d.type] ?? 5);
 
 function blankDevice(): Device {
   return { id: '', type: 'webswitch', name: '', host: '', user: '', pass: '', labels: Array(5).fill('') };
@@ -77,6 +88,8 @@ function RotatorWidget({ hd, refetch, centerLat, centerLon, bearing, t }: Rotato
           title={hd.ok ? t('station.online') : t('station.rotatorNoRead')} />
       </div>
       <div className="p-3 flex gap-4 items-start">
+        {/* The SP/LP readout lives INSIDE RotorCompass, so every compass in the
+            app carries it rather than each caller drawing its own. */}
         <RotorCompass
           bearing={bearing ?? null}
           headings={hd.ok ? [hd.azimuth] : []}
@@ -116,7 +129,7 @@ function RotatorWidget({ hd, refetch, centerLat, centerLon, bearing, t }: Rotato
   );
 }
 
-type AntStatus = { enabled: boolean; type: string; connected: boolean; direction: number; frequency: number; moving: boolean; elements: number[]; follow?: boolean; step_khz?: number; bands?: string[] };
+type AntStatus = { enabled: boolean; type: string; connected: boolean; direction: number; frequency: number; moving: boolean; elements: number[]; follow?: boolean; step_khz?: number; track_mode?: string; bands?: string[]; band_freqs?: Record<string, number> };
 
 // Where each band button points the antenna.
 //
@@ -241,7 +254,10 @@ function MotorAntennaWidget({ ant, refetch, t }: { ant: AntStatus; refetch: () =
           <div className="text-[10px] font-semibold uppercase tracking-wider text-muted-foreground mb-1">{t('station.bands')}</div>
           <div className="grid grid-cols-5 gap-1">
             {(ant.bands ?? []).map((b: string) => {
-              const khz = ANT_BAND_KHZ[b];
+              // Where this band tunes is resolved by the backend — the operator's
+              // per-band choice from Settings, or the default. ANT_BAND_KHZ is only
+              // the floor for a status poll that hasn't landed yet.
+              const khz = ant.band_freqs?.[b] || ANT_BAND_KHZ[b];
               if (!khz) return null;
               // "On this band" from the antenna's own frequency, not the rig's:
               // the widget must show where the ANTENNA is, which is the whole
@@ -277,23 +293,38 @@ function MotorAntennaWidget({ ant, refetch, t }: { ant: AntStatus; refetch: () =
 
         {/* Tracking. Here rather than only in Settings because it is an operating
             decision — off to park the antenna, on to resume — not something set
-            up once. The step only shows when tracking is on: a threshold for
-            something switched off is a question the operator cannot act on. */}
-        <div className="flex items-center gap-2">
-          <button type="button"
-            onClick={() => run(SetMotorFollow(!ant.follow, 0))}
-            className={cn('flex-1 rounded-md border py-1.5 text-xs font-semibold transition-colors',
-              ant.follow ? 'bg-success-muted text-success-muted-foreground border-success-border' : 'border-border hover:bg-muted')}>
-            {ant.follow ? t('station.trackOn') : t('station.trackOff')}
-          </button>
+            up once. Mode and step only show when tracking is on: settings for
+            something switched off are questions the operator cannot act on. And
+            the step only shows in step mode, where it is the one thing it means. */}
+        <div className="space-y-1.5">
+          <div className="flex items-center gap-2">
+            <button type="button"
+              onClick={() => run(SetMotorFollow(!ant.follow, 0, ''))}
+              className={cn('flex-1 rounded-md border py-1.5 text-xs font-semibold transition-colors',
+                ant.follow ? 'bg-success-muted text-success-muted-foreground border-success-border' : 'border-border hover:bg-muted')}>
+              {ant.follow ? t('station.trackOn') : t('station.trackOff')}
+            </button>
+            {ant.follow && (ant.track_mode || 'step') === 'step' && (
+              <select
+                value={String(ant.step_khz || 50)}
+                onChange={(e) => run(SetMotorFollow(true, parseInt(e.target.value, 10), ''))}
+                className="h-[30px] rounded-md border border-border bg-background px-1 text-xs font-mono"
+                title={t('station.trackStepTip')}
+              >
+                {[25, 50, 100].map((s) => <option key={s} value={s}>{s} kHz</option>)}
+              </select>
+            )}
+          </div>
           {ant.follow && (
             <select
-              value={String(ant.step_khz || 50)}
-              onChange={(e) => run(SetMotorFollow(true, parseInt(e.target.value, 10)))}
-              className="h-[30px] rounded-md border border-border bg-background px-1 text-xs font-mono"
-              title={t('station.trackStepTip')}
+              value={ant.track_mode || 'step'}
+              onChange={(e) => run(SetMotorFollow(true, 0, e.target.value))}
+              className="w-full h-[30px] rounded-md border border-border bg-background px-1.5 text-xs"
+              title={t('station.trackModeTip')}
             >
-              {[25, 50, 100].map((s) => <option key={s} value={s}>{s} kHz</option>)}
+              <option value="always" title={t('station.trackAlwaysTip')}>{t('station.trackAlways')}</option>
+              <option value="step" title={t('station.trackStepTipMode')}>{t('station.trackStep')}</option>
+              <option value="band" title={t('station.trackBandTip')}>{t('station.trackBand')}</option>
             </select>
           )}
         </div>
@@ -655,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(() => {
@@ -706,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>
@@ -714,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))}>
@@ -800,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/components/qsl/QslDesignerModal.tsx

@@ -13,6 +13,7 @@ import { Checkbox } from '@/components/ui/checkbox';
 import { Label } from '@/components/ui/label';
 import {
   QSLPickPhotos, QSLGenerateProposals, QSLListTemplates, QSLGetTemplate,
+  QSLListOtherProfileTemplates, QSLCopyTemplateToActiveProfile,
   QSLSaveTemplate, QSLSetDefaultTemplate, QSLDeleteTemplate, QSLSavePreview,
   QSLPreviewDataURL, QSLResolvePreview, QSLStylePresets,
 } from '../../../wailsjs/go/main/App';
@@ -59,6 +60,7 @@ export function QslDesignerModal({ open, onClose }: Props) {
   const [busy, setBusy] = useState(false);
   const [error, setError] = useState('');
   const [saved, setSaved] = useState<QSLTemplateInfo[]>([]);
+  const [foreign, setForeign] = useState<any[]>([]);
   const [previews, setPreviews] = useState<Record<number, string>>({});
   const [presets, setPresets] = useState<QSLPresetInfo[]>([]);
   const [fontFamilies, setFontFamilies] = useState<string[]>([]);
@@ -88,6 +90,8 @@ export function QslDesignerModal({ open, onClose }: Props) {
         if (url) p[t.id] = url;
       }));
       setPreviews(p);
+      // The designs this profile cannot see, offered for copying.
+      try { setForeign(((await QSLListOtherProfileTemplates()) ?? []) as any[]); } catch { /* nothing to offer */ }
     } catch (e) {
       setError(String(e));
     }
@@ -274,7 +278,29 @@ export function QslDesignerModal({ open, onClose }: Props) {
             </section>
 
             <section className="space-y-2">
-              <h3 className="text-sm font-semibold">Saved templates</h3>
+              <div className="flex items-center gap-3">
+                <h3 className="text-sm font-semibold">Saved templates</h3>
+                {/* Designs owned by another profile. A second profile is usually
+                    the same operator with a different rig or locator — same
+                    callsign, same cards — and redrawing one because the antenna
+                    changed is work nobody should have to do. */}
+                {!!foreign.length && (
+                  <select
+                    value=""
+                    onChange={async (e) => {
+                      const id = parseInt(e.target.value, 10);
+                      if (!id) return;
+                      try { await QSLCopyTemplateToActiveProfile(id); await refreshSaved(); }
+                      catch (err) { setError(String(err)); }
+                    }}
+                    className="h-7 rounded-md border border-border bg-background px-2 text-xs">
+                    <option value="">Copy from another profile…</option>
+                    {foreign.map((f) => (
+                      <option key={f.id} value={f.id}>{f.profile_name} — {f.name}</option>
+                    ))}
+                  </select>
+                )}
+              </div>
               {!saved.length && <p className="text-xs text-muted-foreground">None yet.</p>}
               <div className="grid grid-cols-3 gap-3">
                 {saved.map((t) => (

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

@@ -0,0 +1,96 @@
+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 —
+// paper QSL, LoTW, eQSL, QRZ.com. The rules are ORDERED and the first match
+// wins, because a contact is usually several of them at once.
+
+export type RowColorRule = {
+  id: string;
+  color: string;
+  enabled: boolean;
+  channels?: string[]; // empty = every channel
+};
+export type RowColorSettings = {
+  enabled: boolean;
+  style?: 'bar' | 'tint' | 'both';
+  intensity?: number;
+  bandmap_lotw?: boolean;
+  rules: RowColorRule[];
+};
+
+export const CHANNELS = ['qsl', 'lotw', 'eqsl', 'qrz'] as const;
+
+// The two QSO fields behind each channel. QRZ.com and Club Log call theirs an
+// "upload status" rather than a QSL flag, but they carry the same Y / R letters.
+const FIELDS: Record<string, { sent: string; rcvd: string }> = {
+  qsl: { sent: 'qsl_sent', rcvd: 'qsl_rcvd' },
+  lotw: { sent: 'lotw_sent', rcvd: 'lotw_rcvd' },
+  eqsl: { sent: 'eqsl_sent', rcvd: 'eqsl_rcvd' },
+  qrz: { sent: 'qrzcom_qso_upload_status', rcvd: 'qrzcom_qso_download_status' },
+};
+
+// 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.
+// 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';
+};
+
+const chansOf = (r: RowColorRule): readonly string[] =>
+  r.channels && r.channels.length ? r.channels : CHANNELS;
+
+function ruleMatches(q: any, r: RowColorRule): boolean {
+  const cs = chansOf(r);
+  switch (r.id) {
+    case 'confirmed':
+      return cs.some((c) => yes(q[FIELDS[c]?.rcvd]));
+    case 'sent':
+      return cs.some((c) => yes(q[FIELDS[c]?.sent]));
+    case 'to_send':
+      return cs.some((c) => owed(q[FIELDS[c]?.sent]));
+    case 'worked':
+      // The catch-all: nothing sent, nothing asked for, nothing back.
+      return !CHANNELS.some((c) => yes(q[FIELDS[c].rcvd]) || yes(q[FIELDS[c].sent]) || owed(q[FIELDS[c].sent]));
+    default:
+      return false;
+  }
+}
+
+// Walks the rules IN ORDER — the order is the priority, and the settings panel
+// shows it numbered so it can be read rather than guessed.
+export function matchRowRule(q: any, cfg: RowColorSettings | null): RowColorRule | null {
+  if (!q || !cfg?.rules) return null;
+  for (const r of cfg.rules) {
+    if (r.enabled && ruleMatches(q, r)) return r;
+  }
+  return null;
+}
+
+// The colour is never a fill by default.
+//
+// A log where nearly every contact has SOME QSL state ends up with every row
+// painted, and colour that is always present stops being information. The
+// default is a stripe down the left edge; a tint is offered at a chosen strength.
+export function rowStyleFor(q: any, cfg: RowColorSettings | null): Record<string, string> | undefined {
+  if (!cfg?.enabled) return undefined;
+  const rule = matchRowRule(q, cfg);
+  if (!rule?.color) return undefined;
+
+  const style = cfg.style ?? 'bar';
+  const pct = Math.max(5, Math.min(45, cfg.intensity ?? 12));
+  const out: Record<string, string> = {};
+  if (style === 'tint' || style === 'both') {
+    out.backgroundColor = `color-mix(in srgb, ${rule.color} ${pct}%, transparent)`;
+  }
+  if (style === 'bar' || style === 'both') {
+    // inset shadow rather than a border: a border would shift the cells three
+    // pixels on coloured rows only, and the columns would stop lining up.
+    out.boxShadow = `inset 3px 0 0 ${rule.color}`;
+  }
+  return out;
+}

frontend/src/lib/spotDisplay.ts

@@ -13,7 +13,17 @@
 
 export type SpotDisplayOptions = { muteWorked: boolean; slotHighlight: boolean };
 
+// Both options are withdrawn from the filter panel for now. The machinery below
+// is deliberately kept whole — it is correct and hard-won — so putting the two
+// switches back is this one flag and the block they came from in App.tsx.
+//
+// The saved preferences are left untouched in localStorage rather than cleared:
+// an operator who had either turned on gets them back exactly as they were the
+// day the options return, instead of silently starting from off.
+export const SPOT_DISPLAY_OPTIONS_EXPOSED = false;
+
 export function readSpotDisplayOptions(): SpotDisplayOptions {
+  if (!SPOT_DISPLAY_OPTIONS_EXPOSED) return { muteWorked: false, slotHighlight: false };
   try {
     return {
       muteWorked: localStorage.getItem('opslog.clusterMuteWorked') === '1',
@@ -64,3 +74,16 @@ export function applySpotDisplay<T extends Entry>(s: T, o: SpotDisplayOptions):
   }
   return e;
 }
+
+// spotIsWorked answers "does this spot bring me nothing?", which is what the
+// "hide worked" filter is really asking.
+//
+// The extra markers are ORTHOGONAL to the entity status — a spot can be a worked
+// entity AND a new park, prefix, county or grid — so they win. Without that, a
+// new prefix in an entity worked years ago vanished the moment the filter went
+// on, which is the opposite of what an operator hunting prefixes wants.
+export function spotIsWorked(e: Entry): boolean {
+  if (!e) return false;
+  if (e.new_pota || e.new_county || e.new_pfx || e.new_grid) return false;
+  return !!e.worked_call || e.status === 'worked';
+}

frontend/src/lib/theme.tsx

@@ -6,14 +6,14 @@ import { GetUIPref } from '../../wailsjs/go/main/App';
 // CSS variables in style.css key off of. 'auto' follows the OS light/dark
 // preference. The choice is persisted (localStorage + portable UI pref, so it
 // travels with the data/ folder like the language).
-export type ThemeChoice = 'auto' | 'light-warm' | 'light-cool' | 'light-sage' | 'light-nordic'
+export type ThemeChoice = 'auto' | 'light-warm' | 'light-cool' | 'light-sage' | 'light-nordic' | 'sahara'
   | 'dim-slate' | 'dark-warm' | 'dark-graphite' | 'dark-indigo' | 'dark-teal' | 'dark-plum' | 'high-contrast';
 
 // Selectable, concrete themes (excludes 'auto') in display order: lights first,
 // then darks, with high-contrast last — it is an accessibility choice, not a
 // taste one, and listing it among the moods buries it.
 export const CONCRETE_THEMES: Exclude<ThemeChoice, 'auto'>[] = [
-  'light-warm', 'light-cool', 'light-sage', 'light-nordic',
+  'light-warm', 'light-cool', 'light-sage', 'light-nordic', 'sahara',
   'dim-slate', 'dark-warm', 'dark-graphite', 'dark-indigo', 'dark-teal', 'dark-plum',
   'high-contrast',
 ];

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

@@ -775,6 +775,82 @@
   color-scheme: light;
 }
 
+/* ---- Theme 1e: Sahara — Warm light, taken a step deeper --------------------
+   Warm light's cream is kept for panels and the entry strip (#faf6eb, the one
+   surface an operator stares at while typing a call), but the page behind them
+   and every toolbar, tab bar and table header go one shade further into the
+   sand. That was the whole request: same family, just a little darker, so the
+   cream panels lift clearly instead of blending into the page.
+   Ink is a deep warm brown rather than black: pure black on sand glares.
+   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: #e6ded0;            /* parchment — the page */
+  --foreground: #3a3227;            /* warm brown-ink */
+  --card: #f3eee2;                  /* panels, entry strip, log rows */
+  --card-foreground: #3a3227;
+  --popover: #f3eee2;
+  --popover-foreground: #3a3227;
+  --primary: #c4501e;               /* terracotta — buttons and the frequency */
+  --primary-foreground: #fdf8f0;
+  --secondary: #ded5c4;
+  --secondary-foreground: #3a3227;
+  --muted: #ded5c4;                 /* toolbars / tab bar / table headers */
+  --muted-foreground: #6a5f4e;      /* readable on both parchments */
+  --accent: #ecd9c0;                /* warm highlight */
+  --accent-foreground: #7a3410;
+  --destructive: #b3401b;
+  --destructive-foreground: #ffffff;
+  --destructive-muted: #f7e4da;
+  --destructive-muted-foreground: #8f3315;
+  --border: #cdc2ae;                /* one step down, so edges read without lines */
+  --input: #cdc2ae;
+  --ring: #c4501e;                  /* the accent, so focus matches the buttons */
+
+  --success: #15803d;
+  --success-foreground: #ffffff;
+  --success-muted: #dcf3e1;
+  --success-muted-foreground: #14532d;
+  --success-border: #86d99f;
+
+  --warning: #b45309;
+  --warning-foreground: #ffffff;
+  --warning-muted: #fbeacd;
+  --warning-muted-foreground: #7c3d05;
+  --warning-border: #e8b96a;
+
+  --caution: #a16207;
+  --caution-foreground: #1c1917;
+  --caution-muted: #f7edcb;
+  --caution-muted-foreground: #713f12;
+  --caution-border: #e0c069;
+
+  --danger: #be123c;
+  --danger-foreground: #ffffff;
+  --danger-muted: #fbe3e8;
+  --danger-muted-foreground: #9f1239;
+  --danger-border: #ee9aac;
+
+  --info: #0369a1;
+  --info-foreground: #ffffff;
+  --info-muted: #e0eef6;
+  --info-muted-foreground: #075985;
+  --info-border: #86c5e4;
+
+  /* Band/mode matrix — the app's blues kept, on a sand neutral so an empty slot
+     recedes into the grid instead of punching a hole in it. */
+  --mx-call-conf: #15803d;
+  --mx-call-work: #7fd6a4;
+  --mx-dx-conf:   #3730a3;
+  --mx-dx-work:   #a5b4fc;
+  --mx-none:      #ded5c4;
+
+  --scrollbar-thumb: #c2b6a0;
+  --scrollbar-thumb-hover: #a5977e;
+  --card-shadow: 0 1px 2px rgba(58, 50, 39, 0.06), 0 0 0 1px rgba(58, 50, 39, 0.03);
+  color-scheme: light;
+}
+
 /* ── Data-viz palette (Statistics dashboard) ────────────────────────────────
    A VALIDATED categorical palette, not hand-picked: the slot ORDER is what makes
    it colour-blind-safe (worst adjacent ΔE 24.2 light / 10.3 dark), so never
@@ -793,7 +869,8 @@
 [data-theme="light-warm"],
 [data-theme="light-cool"],
 [data-theme="light-sage"],
-[data-theme="light-nordic"] {
+[data-theme="light-nordic"],
+[data-theme="sahara"] {
   --chart-1: #2a78d6; /* blue    — default single-series hue */
   --chart-2: #1baf7a; /* aqua    */
   --chart-3: #eda100; /* yellow  */

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

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

@@ -88,6 +88,8 @@ export function AwardRefsForQSOs(arg1:Array<number>):Promise<Record<number, Reco
 
 export function AwardsFolder():Promise<string>;
 
+export function BackfillDistances():Promise<main.BackfillDistancesResult>;
+
 export function BackfillUSCounties():Promise<main.BackfillUSCountiesResult>;
 
 export function BandSlotQSOs(arg1:string,arg2:number,arg3:string,arg4:string):Promise<Array<qso.QSO>>;
@@ -174,6 +176,8 @@ export function DiscoverFlexRadios():Promise<Array<cat.FlexRadio>>;
 
 export function DismissAwardUpdate(arg1:string):Promise<void>;
 
+export function DismissQSLViaRepair():Promise<void>;
+
 export function DownloadAllReferenceLists():Promise<string>;
 
 export function DownloadAndApplyUpdate(arg1:string):Promise<void>;
@@ -402,6 +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>;
@@ -438,8 +448,12 @@ export function GetFlexBandPower():Promise<Record<string, main.FlexBandPower>>;
 
 export function GetFlexState():Promise<cat.FlexTXState>;
 
+export function GetGridCacheStatus():Promise<main.GridCacheStatus>;
+
 export function GetIcomState():Promise<cat.IcomTXState>;
 
+export function GetLinkedAmps():Promise<Array<string>>;
+
 export function GetListsSettings():Promise<main.ListsSettings>;
 
 export function GetLiveOpenings():Promise<Array<bandopen.Opening>>;
@@ -486,6 +500,8 @@ export function GetRotatorHeading():Promise<main.RotatorHeading>;
 
 export function GetRotators():Promise<Array<main.RotatorDevice>>;
 
+export function GetRowColors():Promise<main.RowColorSettings>;
+
 export function GetSPEStatus():Promise<spe.Status>;
 
 export function GetScpStatus():Promise<main.ScpStatus>;
@@ -498,6 +514,8 @@ export function GetSlotStats():Promise<qso.SlotStats>;
 
 export function GetSolarData():Promise<solar.Data>;
 
+export function GetSpotTTLMinutes():Promise<number>;
+
 export function GetStartupStatus():Promise<main.StartupStatus>;
 
 export function GetStationDevices():Promise<Array<main.StationDevice>>;
@@ -758,6 +776,8 @@ export function PopulateBuiltinReferences(arg1:string):Promise<number>;
 
 export function PublishLogNow():Promise<string>;
 
+export function QSLCopyTemplateToActiveProfile(arg1:number):Promise<number>;
+
 export function QSLDefaultTemplateID():Promise<number>;
 
 export function QSLDeleteTemplate(arg1:number):Promise<void>;
@@ -772,6 +792,8 @@ export function QSLGetEmailTemplates():Promise<main.QSLEmailTemplates>;
 
 export function QSLGetTemplate(arg1:number):Promise<string>;
 
+export function QSLListOtherProfileTemplates():Promise<Array<main.QSLForeignTemplate>>;
+
 export function QSLListTemplates():Promise<Array<main.QSLTemplateInfo>>;
 
 export function QSLPhotoDataURL(arg1:number,arg2:string):Promise<string>;
@@ -792,6 +814,8 @@ export function QSLSetDefaultTemplate(arg1:number):Promise<void>;
 
 export function QSLStylePresets():Promise<Array<main.QSLPresetInfo>>;
 
+export function QSLViaRepairStatus():Promise<main.QSLViaRepairStatus>;
+
 export function QSOAudioBegin():Promise<boolean>;
 
 export function QSOAudioCancel():Promise<void>;
@@ -830,6 +854,8 @@ export function RenameLogbook(arg1:string):Promise<void>;
 
 export function RenderEQSL(arg1:number,arg2:number):Promise<string>;
 
+export function RepairQSLVia():Promise<main.QSLViaRepairResult>;
+
 export function ReplaceAwardReferences(arg1:string,arg2:Array<awardref.Ref>):Promise<number>;
 
 export function ReportLiveActivity(arg1:number,arg2:string,arg3:string):Promise<void>;
@@ -850,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>;
@@ -922,6 +950,8 @@ export function SaveRelayAuto(arg1:main.RelayAutoConfig):Promise<void>;
 
 export function SaveRotators(arg1:Array<main.RotatorDevice>):Promise<void>;
 
+export function SaveRowColors(arg1:main.RowColorSettings):Promise<void>;
+
 export function SaveSelfSpotSettings(arg1:main.SelfSpotSettings):Promise<void>;
 
 export function SaveStationDevices(arg1:Array<main.StationDevice>):Promise<void>;
@@ -968,19 +998,27 @@ 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>;
 
 export function SetClublogMostWantedEnabled(arg1:boolean):Promise<void>;
 
 export function SetClusterAutoConnect(arg1:boolean):Promise<void>;
 
+export function SetCompactHeight(arg1:number):Promise<void>;
+
 export function SetCompactMode(arg1:boolean):Promise<void>;
 
 export function SetDVKLabel(arg1:number,arg2:string):Promise<void>;
 
 export function SetKenwoodKeySpeed(arg1:number):Promise<void>;
 
-export function SetMotorFollow(arg1:boolean,arg2:number):Promise<void>;
+export function SetLinkedAmps(arg1:Array<string>):Promise<void>;
+
+export function SetMotorFollow(arg1:boolean,arg2:number,arg3:string):Promise<void>;
 
 export function SetOpsLogQSLReceived(arg1:number,arg2:boolean):Promise<void>;
 
@@ -988,6 +1026,8 @@ export function SetPassphrase(arg1:string):Promise<void>;
 
 export function SetScpEnabled(arg1:boolean):Promise<void>;
 
+export function SetSpotTTLMinutes(arg1:number):Promise<void>;
+
 export function SetTelemetryEnabled(arg1:boolean):Promise<void>;
 
 export function SetUIPref(arg1:string,arg2:string):Promise<void>;

frontend/wailsjs/go/main/App.js

@@ -118,6 +118,10 @@ export function AwardsFolder() {
   return window['go']['main']['App']['AwardsFolder']();
 }
 
+export function BackfillDistances() {
+  return window['go']['main']['App']['BackfillDistances']();
+}
+
 export function BackfillUSCounties() {
   return window['go']['main']['App']['BackfillUSCounties']();
 }
@@ -290,6 +294,10 @@ export function DismissAwardUpdate(arg1) {
   return window['go']['main']['App']['DismissAwardUpdate'](arg1);
 }
 
+export function DismissQSLViaRepair() {
+  return window['go']['main']['App']['DismissQSLViaRepair']();
+}
+
 export function DownloadAllReferenceLists() {
   return window['go']['main']['App']['DownloadAllReferenceLists']();
 }
@@ -746,6 +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);
 }
@@ -818,10 +838,18 @@ export function GetFlexState() {
   return window['go']['main']['App']['GetFlexState']();
 }
 
+export function GetGridCacheStatus() {
+  return window['go']['main']['App']['GetGridCacheStatus']();
+}
+
 export function GetIcomState() {
   return window['go']['main']['App']['GetIcomState']();
 }
 
+export function GetLinkedAmps() {
+  return window['go']['main']['App']['GetLinkedAmps']();
+}
+
 export function GetListsSettings() {
   return window['go']['main']['App']['GetListsSettings']();
 }
@@ -914,6 +942,10 @@ export function GetRotators() {
   return window['go']['main']['App']['GetRotators']();
 }
 
+export function GetRowColors() {
+  return window['go']['main']['App']['GetRowColors']();
+}
+
 export function GetSPEStatus() {
   return window['go']['main']['App']['GetSPEStatus']();
 }
@@ -938,6 +970,10 @@ export function GetSolarData() {
   return window['go']['main']['App']['GetSolarData']();
 }
 
+export function GetSpotTTLMinutes() {
+  return window['go']['main']['App']['GetSpotTTLMinutes']();
+}
+
 export function GetStartupStatus() {
   return window['go']['main']['App']['GetStartupStatus']();
 }
@@ -1458,6 +1494,10 @@ export function PublishLogNow() {
   return window['go']['main']['App']['PublishLogNow']();
 }
 
+export function QSLCopyTemplateToActiveProfile(arg1) {
+  return window['go']['main']['App']['QSLCopyTemplateToActiveProfile'](arg1);
+}
+
 export function QSLDefaultTemplateID() {
   return window['go']['main']['App']['QSLDefaultTemplateID']();
 }
@@ -1486,6 +1526,10 @@ export function QSLGetTemplate(arg1) {
   return window['go']['main']['App']['QSLGetTemplate'](arg1);
 }
 
+export function QSLListOtherProfileTemplates() {
+  return window['go']['main']['App']['QSLListOtherProfileTemplates']();
+}
+
 export function QSLListTemplates() {
   return window['go']['main']['App']['QSLListTemplates']();
 }
@@ -1526,6 +1570,10 @@ export function QSLStylePresets() {
   return window['go']['main']['App']['QSLStylePresets']();
 }
 
+export function QSLViaRepairStatus() {
+  return window['go']['main']['App']['QSLViaRepairStatus']();
+}
+
 export function QSOAudioBegin() {
   return window['go']['main']['App']['QSOAudioBegin']();
 }
@@ -1602,6 +1650,10 @@ export function RenderEQSL(arg1, arg2) {
   return window['go']['main']['App']['RenderEQSL'](arg1, arg2);
 }
 
+export function RepairQSLVia() {
+  return window['go']['main']['App']['RepairQSLVia']();
+}
+
 export function ReplaceAwardReferences(arg1, arg2) {
   return window['go']['main']['App']['ReplaceAwardReferences'](arg1, arg2);
 }
@@ -1642,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']();
 }
@@ -1786,6 +1842,10 @@ export function SaveRotators(arg1) {
   return window['go']['main']['App']['SaveRotators'](arg1);
 }
 
+export function SaveRowColors(arg1) {
+  return window['go']['main']['App']['SaveRowColors'](arg1);
+}
+
 export function SaveSelfSpotSettings(arg1) {
   return window['go']['main']['App']['SaveSelfSpotSettings'](arg1);
 }
@@ -1878,6 +1938,14 @@ 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);
+}
+
 export function SetClublogCtyEnabled(arg1) {
   return window['go']['main']['App']['SetClublogCtyEnabled'](arg1);
 }
@@ -1890,6 +1958,10 @@ export function SetClusterAutoConnect(arg1) {
   return window['go']['main']['App']['SetClusterAutoConnect'](arg1);
 }
 
+export function SetCompactHeight(arg1) {
+  return window['go']['main']['App']['SetCompactHeight'](arg1);
+}
+
 export function SetCompactMode(arg1) {
   return window['go']['main']['App']['SetCompactMode'](arg1);
 }
@@ -1902,8 +1974,12 @@ export function SetKenwoodKeySpeed(arg1) {
   return window['go']['main']['App']['SetKenwoodKeySpeed'](arg1);
 }
 
-export function SetMotorFollow(arg1, arg2) {
-  return window['go']['main']['App']['SetMotorFollow'](arg1, arg2);
+export function SetLinkedAmps(arg1) {
+  return window['go']['main']['App']['SetLinkedAmps'](arg1);
+}
+
+export function SetMotorFollow(arg1, arg2, arg3) {
+  return window['go']['main']['App']['SetMotorFollow'](arg1, arg2, arg3);
 }
 
 export function SetOpsLogQSLReceived(arg1, arg2) {
@@ -1918,6 +1994,10 @@ export function SetScpEnabled(arg1) {
   return window['go']['main']['App']['SetScpEnabled'](arg1);
 }
 
+export function SetSpotTTLMinutes(arg1) {
+  return window['go']['main']['App']['SetSpotTTLMinutes'](arg1);
+}
+
 export function SetTelemetryEnabled(arg1) {
   return window['go']['main']['App']['SetTelemetryEnabled'](arg1);
 }

frontend/wailsjs/go/models.ts

@@ -1331,6 +1331,7 @@ export namespace extsvc {
 	    upload_flags: string[];
 	    write_log: boolean;
 	    auto_upload: boolean;
+	    on_air: boolean;
 	    upload_mode: string;
 	
 	    static createFrom(source: any = {}) {
@@ -1355,6 +1356,7 @@ export namespace extsvc {
 	        this.upload_flags = source["upload_flags"];
 	        this.write_log = source["write_log"];
 	        this.auto_upload = source["auto_upload"];
+	        this.on_air = source["on_air"];
 	        this.upload_mode = source["upload_mode"];
 	    }
 	}
@@ -1441,6 +1443,8 @@ export namespace lookup {
 	    cont?: string;
 	    email?: string;
 	    qsl_via?: string;
+	    web?: string;
+	    zip?: string;
 	    image_url?: string;
 	    source: string;
 	    // Go type: time
@@ -1468,6 +1472,8 @@ export namespace lookup {
 	        this.cont = source["cont"];
 	        this.email = source["email"];
 	        this.qsl_via = source["qsl_via"];
+	        this.web = source["web"];
+	        this.zip = source["zip"];
 	        this.image_url = source["image_url"];
 	        this.source = source["source"];
 	        this.fetched_at = this.convertValues(source["fetched_at"], null);
@@ -1931,6 +1937,22 @@ export namespace main {
 	        this.to = source["to"];
 	    }
 	}
+	export class BackfillDistancesResult {
+	    scanned: number;
+	    filled: number;
+	    no_grid: number;
+	
+	    static createFrom(source: any = {}) {
+	        return new BackfillDistancesResult(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.scanned = source["scanned"];
+	        this.filled = source["filled"];
+	        this.no_grid = source["no_grid"];
+	    }
+	}
 	export class BackfillUSCountiesResult {
 	    scanned: number;
 	    county: number;
@@ -2109,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;
@@ -2403,6 +2463,22 @@ export namespace main {
 	        this.body = source["body"];
 	    }
 	}
+	export class GridCacheStatus {
+	    enabled: boolean;
+	    known: number;
+	    pending: number;
+	
+	    static createFrom(source: any = {}) {
+	        return new GridCacheStatus(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.enabled = source["enabled"];
+	        this.known = source["known"];
+	        this.pending = source["pending"];
+	    }
+	}
 	export class ModePreset {
 	    name: string;
 	    default_rst_sent?: string;
@@ -2505,6 +2581,7 @@ export namespace main {
 	    primary: string;
 	    failsafe: string;
 	    download_images: boolean;
+	    qrz_prefer_nickname: boolean;
 	    cache_ttl_days: number;
 	
 	    static createFrom(source: any = {}) {
@@ -2520,6 +2597,7 @@ export namespace main {
 	        this.primary = source["primary"];
 	        this.failsafe = source["failsafe"];
 	        this.download_images = source["download_images"];
+	        this.qrz_prefer_nickname = source["qrz_prefer_nickname"];
 	        this.cache_ttl_days = source["cache_ttl_days"];
 	    }
 	}
@@ -2661,6 +2739,7 @@ export namespace main {
 	    sent_date: string;
 	    rcvd_date: string;
 	    via: string;
+	    rcvd_via: string;
 	    notes: string;
 	    comment: string;
 	
@@ -2675,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"];
 	    }
@@ -2745,6 +2825,24 @@ export namespace main {
 	        this.data_b64 = source["data_b64"];
 	    }
 	}
+	export class QSLForeignTemplate {
+	    id: number;
+	    name: string;
+	    profile_id: number;
+	    profile_name: string;
+	
+	    static createFrom(source: any = {}) {
+	        return new QSLForeignTemplate(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.id = source["id"];
+	        this.name = source["name"];
+	        this.profile_id = source["profile_id"];
+	        this.profile_name = source["profile_name"];
+	    }
+	}
 	export class QSLPresetInfo {
 	    name: string;
 	    label: string;
@@ -2801,6 +2899,32 @@ export namespace main {
 	        this.updated_at = source["updated_at"];
 	    }
 	}
+	export class QSLViaRepairResult {
+	    moved: number;
+	
+	    static createFrom(source: any = {}) {
+	        return new QSLViaRepairResult(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.moved = source["moved"];
+	    }
+	}
+	export class QSLViaRepairStatus {
+	    affected: number;
+	    asked: boolean;
+	
+	    static createFrom(source: any = {}) {
+	        return new QSLViaRepairStatus(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.affected = source["affected"];
+	        this.asked = source["asked"];
+	    }
+	}
 	export class QSOAwardRef {
 	    code: string;
 	    ref: string;
@@ -2909,6 +3033,7 @@ export namespace main {
 	    transport: string;
 	    com_port: string;
 	    baud: number;
+	    spid_model?: string;
 	
 	    static createFrom(source: any = {}) {
 	        return new RotatorDevice(source);
@@ -2930,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 {
@@ -2956,6 +3082,64 @@ export namespace main {
 	        this.motorized = source["motorized"];
 	    }
 	}
+	export class RowColorRule {
+	    id: string;
+	    color: string;
+	    enabled: boolean;
+	    channels: string[];
+	
+	    static createFrom(source: any = {}) {
+	        return new RowColorRule(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.id = source["id"];
+	        this.color = source["color"];
+	        this.enabled = source["enabled"];
+	        this.channels = source["channels"];
+	    }
+	}
+	export class RowColorSettings {
+	    enabled: boolean;
+	    style: string;
+	    intensity: number;
+	    bandmap_lotw: boolean;
+	    configured: boolean;
+	    rules: RowColorRule[];
+	
+	    static createFrom(source: any = {}) {
+	        return new RowColorSettings(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.enabled = source["enabled"];
+	        this.style = source["style"];
+	        this.intensity = source["intensity"];
+	        this.bandmap_lotw = source["bandmap_lotw"];
+	        this.configured = source["configured"];
+	        this.rules = this.convertValues(source["rules"], RowColorRule);
+	    }
+	
+		convertValues(a: any, classs: any, asMap: boolean = false): any {
+		    if (!a) {
+		        return a;
+		    }
+		    if (a.slice && a.map) {
+		        return (a as any[]).map(elem => this.convertValues(elem, classs));
+		    } else if ("object" === typeof a) {
+		        if (asMap) {
+		            for (const key of Object.keys(a)) {
+		                a[key] = new classs(a[key]);
+		            }
+		            return a;
+		        }
+		        return new classs(a);
+		    }
+		    return a;
+		}
+	}
 	export class ScpStatus {
 	    enabled: boolean;
 	    count: number;
@@ -3091,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);
@@ -3106,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 {
@@ -3246,6 +3438,7 @@ export namespace main {
 	export class ULSStatusResult {
 	    count: number;
 	    updated_at: string;
+	    needs_refresh: boolean;
 	
 	    static createFrom(source: any = {}) {
 	        return new ULSStatusResult(source);
@@ -3255,6 +3448,7 @@ export namespace main {
 	        if ('string' === typeof source) source = JSON.parse(source);
 	        this.count = source["count"];
 	        this.updated_at = source["updated_at"];
+	        this.needs_refresh = source["needs_refresh"];
 	    }
 	}
 	export class UltrabeamSettings {
@@ -3267,8 +3461,10 @@ export namespace main {
 	    baud: number;
 	    follow: boolean;
 	    step_khz: number;
+	    track_mode: string;
 	    tx_inhibit: boolean;
 	    bands: string[];
+	    band_freqs: Record<string, number>;
 	    freq_min_mhz: number;
 	    freq_max_mhz: number;
 	
@@ -3287,8 +3483,10 @@ export namespace main {
 	        this.baud = source["baud"];
 	        this.follow = source["follow"];
 	        this.step_khz = source["step_khz"];
+	        this.track_mode = source["track_mode"];
 	        this.tx_inhibit = source["tx_inhibit"];
 	        this.bands = source["bands"];
+	        this.band_freqs = source["band_freqs"];
 	        this.freq_min_mhz = source["freq_min_mhz"];
 	        this.freq_max_mhz = source["freq_max_mhz"];
 	    }
@@ -3304,7 +3502,9 @@ export namespace main {
 	    elements: number[];
 	    follow: boolean;
 	    step_khz: number;
+	    track_mode: string;
 	    bands: string[];
+	    band_freqs: Record<string, number>;
 	
 	    static createFrom(source: any = {}) {
 	        return new UltrabeamStatusInfo(source);
@@ -3322,7 +3522,9 @@ export namespace main {
 	        this.elements = source["elements"];
 	        this.follow = source["follow"];
 	        this.step_khz = source["step_khz"];
+	        this.track_mode = source["track_mode"];
 	        this.bands = source["bands"];
+	        this.band_freqs = source["band_freqs"];
 	    }
 	}
 	export class UpdateInfo {
@@ -4162,6 +4364,7 @@ export namespace qso {
 	}
 	export class QSO {
 	    id: number;
+	    number?: number;
 	    callsign: string;
 	    // Go type: time
 	    qso_date: any;
@@ -4203,6 +4406,8 @@ export namespace qso {
 	    qsl_sent_date?: string;
 	    qsl_rcvd_date?: string;
 	    qsl_via?: string;
+	    qsl_sent_via?: string;
+	    qsl_rcvd_via?: string;
 	    qsl_msg?: string;
 	    qslmsg_rcvd?: string;
 	    lotw_sent?: string;
@@ -4302,6 +4507,7 @@ export namespace qso {
 	    constructor(source: any = {}) {
 	        if ('string' === typeof source) source = JSON.parse(source);
 	        this.id = source["id"];
+	        this.number = source["number"];
 	        this.callsign = source["callsign"];
 	        this.qso_date = this.convertValues(source["qso_date"], null);
 	        this.qso_date_off = this.convertValues(source["qso_date_off"], null);
@@ -4341,6 +4547,8 @@ export namespace qso {
 	        this.qsl_sent_date = source["qsl_sent_date"];
 	        this.qsl_rcvd_date = source["qsl_rcvd_date"];
 	        this.qsl_via = source["qsl_via"];
+	        this.qsl_sent_via = source["qsl_sent_via"];
+	        this.qsl_rcvd_via = source["qsl_rcvd_via"];
 	        this.qsl_msg = source["qsl_msg"];
 	        this.qslmsg_rcvd = source["qslmsg_rcvd"];
 	        this.lotw_sent = source["lotw_sent"];
@@ -4945,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);
@@ -4962,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"];
 	    }
 	}
 

hrdlogonair.go

@@ -0,0 +1,74 @@
+package main
+
+// HRDLog "ON AIR" — publishing the live frequency, mode and rig on hrdlog.net,
+// so the site shows "F4BPO is on air 14,074,000 FT8 IC-7300" while the station
+// is operating.
+//
+// The endpoint and its field names come from HRDLog's own library
+// (github.com/iw1qlh/HRDLOG-net-library), not from reading someone's traffic.
+
+import (
+	"context"
+	"strings"
+	"time"
+
+	"hamlog/internal/applog"
+	"hamlog/internal/extsvc"
+)
+
+// onAirEvery is how often the status is refreshed. HRDLog drops a station from
+// the on-air list when it stops hearing from it, so this is a heartbeat, not a
+// change notification.
+const onAirEvery = 2 * time.Minute
+
+// hrdlogOnAirLoop publishes while the option is on and the rig is readable.
+func (a *App) hrdlogOnAirLoop() {
+	defer func() { _ = recover() }() // never crash the app from a status broadcast
+	t := time.NewTicker(onAirEvery)
+	defer t.Stop()
+	for range t.C {
+		a.publishHRDLogOnAir()
+	}
+}
+
+// publishHRDLogOnAir sends one update. Silent when switched off, unconfigured,
+// or when the rig has nothing to report — an announcement with no frequency
+// would say the operator is on air on 0 Hz.
+func (a *App) publishHRDLogOnAir() {
+	cfg := a.loadExternalServices().HRDLog
+	if !cfg.OnAir || strings.TrimSpace(cfg.Callsign) == "" || strings.TrimSpace(cfg.Code) == "" {
+		return
+	}
+	if a.cat == nil {
+		return
+	}
+	st := a.cat.State()
+	if !st.Connected || st.FreqHz <= 0 {
+		return
+	}
+	// The rig NAME as the operator knows it — that string is what the site
+	// displays. The active profile's MyRig first, since it is what every QSO is
+	// stamped with; the CAT backend's own model only when the profile has none.
+	radio := ""
+	if a.profiles != nil {
+		if pr, err := a.profiles.Active(a.ctx); err == nil {
+			radio = strings.TrimSpace(pr.MyRig)
+		}
+	}
+	if radio == "" {
+		radio = strings.TrimSpace(st.Rig)
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
+	defer cancel()
+	msg, err := extsvc.SendHRDLogOnAir(ctx, nil, cfg.Callsign, cfg.Code, st.FreqHz, st.Mode, radio)
+	if err != nil {
+		// Logged, never surfaced: this is a broadcast the operator did not ask
+		// for at this instant, and a toast every two minutes on a flaky link
+		// would be worse than the missing status.
+		applog.Printf("hrdlog on-air: %v (%s)", err, msg)
+		return
+	}
+	applog.Printf("hrdlog on-air: %s %.3f MHz %s (%s) — %s",
+		cfg.Callsign, float64(st.FreqHz)/1e6, st.Mode, radio, msg)
+}

internal/adif/charcount_test.go

@@ -19,8 +19,8 @@ func TestCharCountLengthRepair(t *testing.T) {
 		},
 		{
 			name:     "cyrillic",
-			wantQTH:  "Дзержинск",        // 9 chars / 18 bytes, declared 9
-			wantName: "Александр Чайка",  // 15 chars / 29 bytes, declared 15
+			wantQTH:  "Дзержинск",       // 9 chars / 18 bytes, declared 9
+			wantName: "Александр Чайка", // 15 chars / 29 bytes, declared 15
 			adi:      "<EOH>\n<CALL:6>UA3TFS<NAME:15>Александр Чайка<QTH:9>Дзержинск<EOR>\n",
 		},
 	}

internal/adif/county_test.go

@@ -0,0 +1,46 @@
+package adif
+
+import "testing"
+
+// ADIF defines CNTY as "STATE,COUNTY" — "GA,BARROW". OpsLog exported the bare
+// county, which a receiving logger cannot resolve: county names repeat across
+// states, and there is a Washington County in thirty of them.
+func TestADIFCountyFormat(t *testing.T) {
+	for _, tc := range []struct{ state, county, want string }{
+		{"GA", "BARROW", "GA,BARROW"},
+		{"ga", "Barrow", "GA,Barrow"},    // the state is a code, upper-cased; the name is not touched
+		{"", "BARROW", "BARROW"},         // no state known: a bare name beats nothing
+		{"GA", "", ""},                   // no county: nothing to write
+		{"GA", "GA,BARROW", "GA,BARROW"}, // already formatted — never double the prefix
+		{"  GA  ", " BARROW ", "GA,BARROW"},
+	} {
+		if got := adifCounty(tc.state, tc.county); got != tc.want {
+			t.Errorf("adifCounty(%q, %q) = %q, want %q", tc.state, tc.county, got, tc.want)
+		}
+	}
+}
+
+// And the mirror: a file from a logger that follows the standard must fill both
+// columns, while a file carrying the bare county still imports unchanged.
+func TestSplitADIFCounty(t *testing.T) {
+	for _, tc := range []struct{ in, county, state string }{
+		{"GA,BARROW", "BARROW", "GA"},
+		{"ga, Barrow", "Barrow", "GA"},
+		{"BARROW", "BARROW", ""}, // the old OpsLog form, and many other loggers
+		{"", "", ""},
+		{"  ", "", ""},
+	} {
+		c, s := splitADIFCounty(tc.in)
+		if c != tc.county || s != tc.state {
+			t.Errorf("splitADIFCounty(%q) = (%q, %q), want (%q, %q)", tc.in, c, s, tc.county, tc.state)
+		}
+	}
+}
+
+// Round trip: what OpsLog writes, OpsLog reads back to the same two values.
+func TestCountyRoundTrip(t *testing.T) {
+	c, s := splitADIFCounty(adifCounty("GA", "BARROW"))
+	if c != "BARROW" || s != "GA" {
+		t.Errorf("round trip gave (%q, %q), want (BARROW, GA)", c, s)
+	}
+}

internal/adif/export.go

@@ -15,9 +15,9 @@ import (
 
 // ExportResult summarises an ADIF export for the UI.
 type ExportResult struct {
-	Path    string `json:"path"`
-	Count   int    `json:"count"`
-	SizeKB  int64  `json:"size_kb"`
+	Path   string `json:"path"`
+	Count  int    `json:"count"`
+	SizeKB int64  `json:"size_kb"`
 }
 
 // Exporter streams every QSO in a repo to an ADIF (.adi) file.
@@ -221,7 +221,7 @@ func writeRecord(bw *bufio.Writer, q qso.QSO, includeApp bool, allow map[string]
 	w("VUCC_GRIDS", q.VUCCGrids)
 	w("COUNTRY", q.Country)
 	w("STATE", q.State)
-	w("CNTY", q.County)
+	w("CNTY", adifCounty(q.State, q.County))
 	wi("DXCC", q.DXCC)
 	w("CONT", q.Continent)
 	wi("CQZ", q.CQZ)
@@ -241,6 +241,14 @@ func writeRecord(bw *bufio.Writer, q qso.QSO, includeApp bool, allow map[string]
 	w("QSLSDATE", q.QSLSentDate)
 	w("QSLRDATE", q.QSLRcvdDate)
 	w("QSL_VIA", q.QSLVia)
+	// M (manager) is import-only in the QSL Via enumeration: we keep it when a
+	// file gives it to us, but a file we write must not carry it.
+	if q.QSLSentVia != QSLViaManager {
+		w("QSL_SENT_VIA", q.QSLSentVia)
+	}
+	if q.QSLRcvdVia != QSLViaManager {
+		w("QSL_RCVD_VIA", q.QSLRcvdVia)
+	}
 	w("QSLMSG", q.QSLMsg)
 	w("QSLMSG_RCVD", q.QSLMsgRcvd)
 	w("LOTW_QSL_SENT", q.LOTWSent)
@@ -285,7 +293,7 @@ func writeRecord(bw *bufio.Writer, q qso.QSO, includeApp bool, allow map[string]
 	w("MY_GRIDSQUARE_EXT", q.MyGridExt)
 	w("MY_COUNTRY", q.MyCountry)
 	w("MY_STATE", q.MyState)
-	w("MY_CNTY", q.MyCounty)
+	w("MY_CNTY", adifCounty(q.MyState, q.MyCounty))
 	w("MY_IOTA", q.MyIOTA)
 	w("MY_SOTA_REF", q.MySOTARef)
 	w("MY_POTA_REF", q.MyPOTARef)
@@ -391,10 +399,10 @@ var parentMode = map[string]string{
 	"ISCAT": "MFSK", "Q65": "MFSK", "FST4": "MFSK", "FST4W": "MFSK",
 	"MFSK16": "MFSK", "MFSK32": "MFSK", "MFSK64": "MFSK", "MFSK128": "MFSK",
 	"OLIVIA": "MFSK",
-	"PSK31": "PSK", "PSK63": "PSK", "PSK125": "PSK", "PSK250": "PSK", "PSK500": "PSK",
+	"PSK31":  "PSK", "PSK63": "PSK", "PSK125": "PSK", "PSK250": "PSK", "PSK500": "PSK",
 	"QPSK31": "PSK", "QPSK63": "PSK", "QPSK125": "PSK", "QPSK250": "PSK", "QPSK500": "PSK",
 	"FREEDV": "DIGITALVOICE",
-	"VARA": "DYNAMIC", "VARA HF": "DYNAMIC", "VARA FM": "DYNAMIC", "VARAC": "DYNAMIC",
+	"VARA":   "DYNAMIC", "VARA HF": "DYNAMIC", "VARA FM": "DYNAMIC", "VARAC": "DYNAMIC",
 	"THOR4": "THOR", "THOR8": "THOR", "THOR16": "THOR", "THOR32": "THOR",
 	"DOMINOF": "DOMINO", "DOMINOEX": "DOMINO",
 	"HELL80": "HELL", "FMHELL": "HELL",
@@ -413,3 +421,25 @@ func modeForExport(mode, submode string) (string, string) {
 	}
 	return mode, ""
 }
+
+// adifCounty renders CNTY the way ADIF specifies: "STATE,COUNTY", e.g.
+// "GA,BARROW".
+//
+// OpsLog stores the two apart, and exported only the county — which a receiving
+// logger cannot resolve, since county names repeat across states (there is a
+// Washington County in thirty of them). The award engine here was never
+// affected because it reads the columns, not the ADIF; the damage was to
+// everyone we send a file to.
+//
+// The county alone is still written when no state is known: a bare name is
+// worth more than nothing, and inventing a prefix would be worse than either.
+// A county that ALREADY carries a comma is passed through — it has been
+// formatted once, and doubling the prefix would corrupt it.
+func adifCounty(state, county string) string {
+	c := strings.TrimSpace(county)
+	s := strings.TrimSpace(state)
+	if c == "" || s == "" || strings.Contains(c, ",") {
+		return c
+	}
+	return strings.ToUpper(s) + "," + c
+}

internal/adif/fields.go

@@ -16,23 +16,23 @@ import "strings"
 type FieldKind string
 
 const (
-	KindText    FieldKind = "text"    // String / IntlString / MultilineString
-	KindNumber  FieldKind = "number"  // Number / PositiveInteger
-	KindDate    FieldKind = "date"    // ADIF Date (YYYYMMDD)
-	KindTime    FieldKind = "time"    // ADIF Time (HHMMSS / HHMM)
-	KindBool    FieldKind = "boolean" // Boolean (Y/N)
-	KindEnum    FieldKind = "enum"    // Enumeration
-	KindLoc     FieldKind = "location" // Location (e.g. "N048 09.000")
+	KindText   FieldKind = "text"     // String / IntlString / MultilineString
+	KindNumber FieldKind = "number"   // Number / PositiveInteger
+	KindDate   FieldKind = "date"     // ADIF Date (YYYYMMDD)
+	KindTime   FieldKind = "time"     // ADIF Time (HHMMSS / HHMM)
+	KindBool   FieldKind = "boolean"  // Boolean (Y/N)
+	KindEnum   FieldKind = "enum"     // Enumeration
+	KindLoc    FieldKind = "location" // Location (e.g. "N048 09.000")
 )
 
 // FieldDef describes one ADIF QSO field.
 type FieldDef struct {
-	Name       string    `json:"name"`        // canonical uppercase ADIF tag
-	Kind       FieldKind `json:"kind"`        // editor widget hint
-	Category   string    `json:"category"`    // grouping for the UI
-	Promoted   bool      `json:"promoted"`    // has a dedicated QSO column
-	Deprecated bool      `json:"deprecated"`  // import-only per the spec
-	Intl       bool      `json:"intl"`        // *_INTL UTF-8 variant
+	Name       string    `json:"name"`       // canonical uppercase ADIF tag
+	Kind       FieldKind `json:"kind"`       // editor widget hint
+	Category   string    `json:"category"`   // grouping for the UI
+	Promoted   bool      `json:"promoted"`   // has a dedicated QSO column
+	Deprecated bool      `json:"deprecated"` // import-only per the spec
+	Intl       bool      `json:"intl"`       // *_INTL UTF-8 variant
 }
 
 // adifVersion is the ADIF spec version OpsLog targets for import/export.
@@ -135,8 +135,8 @@ var Fields = []FieldDef{
 	{Name: "QSLSDATE", Kind: KindDate, Category: "QSL", Promoted: true},
 	{Name: "QSLRDATE", Kind: KindDate, Category: "QSL", Promoted: true},
 	{Name: "QSL_VIA", Kind: KindText, Category: "QSL", Promoted: true},
-	{Name: "QSL_SENT_VIA", Kind: KindEnum, Category: "QSL"},
-	{Name: "QSL_RCVD_VIA", Kind: KindEnum, Category: "QSL"},
+	{Name: "QSL_SENT_VIA", Kind: KindEnum, Category: "QSL", Promoted: true},
+	{Name: "QSL_RCVD_VIA", Kind: KindEnum, Category: "QSL", Promoted: true},
 	{Name: "QSLMSG", Kind: KindText, Category: "QSL", Promoted: true},
 	{Name: "QSLMSG_INTL", Kind: KindText, Category: "QSL", Intl: true},
 	{Name: "QSLMSG_RCVD", Kind: KindText, Category: "QSL", Promoted: true},

internal/adif/import.go

@@ -428,7 +428,12 @@ func recordToQSO(rec Record) (qso.QSO, bool) {
 	q.VUCCGrids = strings.ToUpper(rec["vucc_grids"])
 	q.Country = rec["country"]
 	q.State = strings.ToUpper(rec["state"])
-	q.County = rec["cnty"]
+	q.County, _ = splitADIFCounty(rec["cnty"])
+	if st := rec["state"]; strings.TrimSpace(st) == "" {
+		if _, fromCnty := splitADIFCounty(rec["cnty"]); fromCnty != "" {
+			q.State = fromCnty
+		}
+	}
 	if v, ok := parseInt(rec["dxcc"]); ok {
 		q.DXCC = &v
 	}
@@ -459,10 +464,17 @@ func recordToQSO(rec Record) (qso.QSO, bool) {
 	q.QSLRcvd = rec["qsl_rcvd"]
 	q.QSLSentDate = rec["qslsdate"]
 	q.QSLRcvdDate = rec["qslrdate"]
+	// QSL_VIA is the manager. QSL_SENT_VIA / QSL_RCVD_VIA are the routing
+	// method, an enumeration of their own.
+	//
+	// These used to be one field here: an empty QSL_VIA was filled from
+	// QSL_SENT_VIA, on the theory that loggers writing one meant the other.
+	// They do not — Log4OM defaults QSL_SENT_VIA to E, and the import put "E"
+	// where every panel in OpsLog shows the manager's callsign. Keeping them
+	// apart is also what lets an export give them back.
 	q.QSLVia = rec["qsl_via"]
-	if q.QSLVia == "" { // many loggers (Log4OM) write QSL_SENT_VIA instead
-		q.QSLVia = rec["qsl_sent_via"]
-	}
+	q.QSLSentVia = NormaliseQSLVia(rec["qsl_sent_via"])
+	q.QSLRcvdVia = NormaliseQSLVia(rec["qsl_rcvd_via"])
 	q.QSLMsg = rec["qslmsg"]
 	q.QSLMsgRcvd = rec["qslmsg_rcvd"]
 	q.LOTWSent = rec["lotw_qsl_sent"]
@@ -515,7 +527,12 @@ func recordToQSO(rec Record) (qso.QSO, bool) {
 	q.MyGridExt = strings.ToUpper(rec["my_gridsquare_ext"])
 	q.MyCountry = rec["my_country"]
 	q.MyState = strings.ToUpper(rec["my_state"])
-	q.MyCounty = rec["my_cnty"]
+	q.MyCounty, _ = splitADIFCounty(rec["my_cnty"])
+	if st := rec["my_state"]; strings.TrimSpace(st) == "" {
+		if _, fromCnty := splitADIFCounty(rec["my_cnty"]); fromCnty != "" {
+			q.MyState = fromCnty
+		}
+	}
 	q.MyIOTA = strings.ToUpper(rec["my_iota"])
 	q.MySOTARef = strings.ToUpper(rec["my_sota_ref"])
 	q.MyPOTARef = strings.ToUpper(rec["my_pota_ref"])
@@ -698,3 +715,20 @@ var promotableSubmodes = map[string]bool{
 func submodeSubsumesParent(submode string) bool {
 	return promotableSubmodes[submode]
 }
+
+// splitADIFCounty reads CNTY, which ADIF defines as "STATE,COUNTY".
+//
+// Returns the county on its own plus the state the field carried, so an import
+// from a logger that follows the standard fills BOTH columns here. Files that
+// write the bare county — as OpsLog itself used to — still import unchanged.
+//
+// The state from the field never overrides an explicit STATE tag: STATE is the
+// dedicated field and the more specific statement. It only fills a blank.
+func splitADIFCounty(cnty string) (county, state string) {
+	cnty = strings.TrimSpace(cnty)
+	i := strings.Index(cnty, ",")
+	if i < 0 {
+		return cnty, ""
+	}
+	return strings.TrimSpace(cnty[i+1:]), strings.ToUpper(strings.TrimSpace(cnty[:i]))
+}

internal/adif/qslvia.go

@@ -0,0 +1,53 @@
+package adif
+
+import "strings"
+
+// The ADIF "QSL Via" enumeration, used by QSL_SENT_VIA and QSL_RCVD_VIA. It
+// says how a card travelled, and is a different thing entirely from QSL_VIA,
+// which is the manager's callsign.
+const (
+	QSLViaBureau     = "B"
+	QSLViaDirect     = "D"
+	QSLViaElectronic = "E"
+	// QSLViaManager is import-only in the standard: it may be read from another
+	// logger's file, never written to one. OpsLog keeps it when it arrives so
+	// the operator's own data is not silently altered, and NormaliseQSLVia is
+	// the only place that decides so.
+	QSLViaManager = "M"
+)
+
+// NormaliseQSLVia folds what other loggers and OpsLog's own older versions put
+// in a routing field down to the ADIF enumeration.
+//
+// It accepts the letter, the English word, and the French one — OpsLog wrote
+// "Bureau", "Direct" and "Electronic" in full for a long time, and the QSL
+// Manager panel still shows those words to a French operator. Anything it does
+// not recognise comes back empty rather than being passed through: this feeds
+// an enumerated ADIF field, and inventing a value there breaks the file for
+// every other logger that reads it.
+func NormaliseQSLVia(s string) string {
+	switch strings.ToUpper(strings.TrimSpace(s)) {
+	case "B", "BUREAU", "BURO", "VIA BUREAU":
+		return QSLViaBureau
+	case "D", "DIRECT":
+		return QSLViaDirect
+	case "E", "ELECTRONIC", "ELECTRONIQUE", "ÉLECTRONIQUE", "OQRS":
+		return QSLViaElectronic
+	case "M", "MANAGER":
+		return QSLViaManager
+	}
+	return ""
+}
+
+// IsQSLViaRouting reports whether a QSL_VIA value is in fact a routing method
+// that ended up in the manager field.
+//
+// It exists for one repair: OpsLog's QSL Manager panel wrote "Bureau",
+// "Direct" and "Electronic" into QSL_VIA, and imports folded QSL_SENT_VIA
+// there too, so logs hold a mixture of managers and routing words in one
+// column. A manager is a callsign, never one of these six words, so the test
+// is exact — but it is deliberately narrow: anything else, including a manager
+// whose callsign happens to be unusual, is left alone.
+func IsQSLViaRouting(s string) bool {
+	return NormaliseQSLVia(s) != ""
+}

internal/adif/qslvia_test.go

@@ -0,0 +1,37 @@
+package adif
+
+import "testing"
+
+func TestNormaliseQSLVia(t *testing.T) {
+	for in, want := range map[string]string{
+		"B": "B", "b": "B", "Bureau": "B", "BUREAU": "B", " buro ": "B",
+		"D": "D", "Direct": "D", "direct": "D",
+		"E": "E", "Electronic": "E", "électronique": "E", "OQRS": "E",
+		"M": "M", "Manager": "M",
+		// A manager's callsign is not a routing method, and neither is noise.
+		"M0OXO": "", "EA5GL": "", "": "", "Bureau via M0OXO": "", "X": "",
+	} {
+		if got := NormaliseQSLVia(in); got != want {
+			t.Errorf("NormaliseQSLVia(%q) = %q, want %q", in, got, want)
+		}
+	}
+}
+
+// The repair moves values out of the manager column. A false positive would
+// erase a real manager, so the guard is worth its own test: every callsign-like
+// value must be refused.
+func TestIsQSLViaRoutingRefusesManagers(t *testing.T) {
+	for _, call := range []string{
+		"M0OXO", "EA5GL", "F5CWU", "DJ9ZB", "W3HNK", "IK2DUW", "N7RO",
+		"BUREAU M0OXO", "via bureau DL1XYZ", "QSL DIRECT ONLY",
+	} {
+		if IsQSLViaRouting(call) {
+			t.Errorf("%q was taken for a routing method — the repair would erase it", call)
+		}
+	}
+	for _, v := range []string{"B", "D", "E", "M", "Bureau", "Direct", "Electronic"} {
+		if !IsQSLViaRouting(v) {
+			t.Errorf("%q should be recognised as a routing method", v)
+		}
+	}
+}

internal/adif/roundtrip_test.go

@@ -20,7 +20,7 @@ func TestPromotedFieldsRoundTrip(t *testing.T) {
 	in := qso.QSO{
 		Callsign: "EA8ABC", Band: "20m", Mode: "SSB",
 		QSODate: time.Date(2026, 6, 6, 12, 0, 0, 0, time.UTC),
-		SIG: "POTA", SIGInfo: "US-0001", MySIG: "WWFF", MySIGInfo: "ONFF-0001",
+		SIG:     "POTA", SIGInfo: "US-0001", MySIG: "WWFF", MySIGInfo: "ONFF-0001",
 		WWFFRef: "ONFF-0001", MyWWFFRef: "F-FFF-0001",
 		Distance: &dist, RXPower: &rxp, AIndex: &a,
 		SKCC: "12345S", FISTS: "999", TenTen: "55555",
@@ -119,3 +119,85 @@ func renderRecord(q qso.QSO, includeApp bool) string {
 	bw.Flush()
 	return buf.String()
 }
+
+// TestQSLViaFieldsRoundTrip covers the case reported as issue #16: a log
+// exported by another logger carries a manager in QSL_VIA and a routing method
+// in QSL_SENT_VIA, and the two must stay apart.
+//
+// Before this, QSL_SENT_VIA was folded into QSL_VIA whenever QSL_VIA was empty
+// — so a Log4OM log, which defaults QSL_SENT_VIA to E, showed "E" wherever
+// OpsLog displays the manager — and QSL_RCVD_VIA was thrown away outright: it
+// was listed as a promoted field with no column behind it, so it was not even
+// kept among the extras. Neither was ever exported, which made an import
+// followed by an export destroy both.
+func TestQSLViaFieldsRoundTrip(t *testing.T) {
+	in := qso.QSO{
+		Callsign: "3B9FR", Band: "20m", Mode: "CW",
+		QSODate:    time.Date(2026, 6, 6, 12, 0, 0, 0, time.UTC),
+		QSLVia:     "M0OXO", // the manager
+		QSLSentVia: "D",     // sent direct
+		QSLRcvdVia: "B",     // came back via the bureau
+	}
+	var buf bytes.Buffer
+	bw := bufio.NewWriter(&buf)
+	bw.WriteString("<EOH>\n")
+	writeRecord(bw, in, true, nil)
+	bw.Flush()
+
+	var rec Record
+	if err := Parse(strings.NewReader(buf.String()), func(r Record) error { rec = r; return nil }); err != nil {
+		t.Fatalf("parse: %v", err)
+	}
+	out, ok := recordToQSO(rec)
+	if !ok {
+		t.Fatal("recordToQSO returned !ok")
+	}
+	for name, c := range map[string]struct{ got, want string }{
+		"QSL_VIA":      {out.QSLVia, in.QSLVia},
+		"QSL_SENT_VIA": {out.QSLSentVia, in.QSLSentVia},
+		"QSL_RCVD_VIA": {out.QSLRcvdVia, in.QSLRcvdVia},
+	} {
+		if c.got != c.want {
+			t.Errorf("%s: got %q, want %q", name, c.got, c.want)
+		}
+	}
+}
+
+// TestQSLSentViaDoesNotBecomeManager pins the exact shape a Log4OM export has:
+// no QSL_VIA at all, QSL_SENT_VIA defaulted to E. The manager field must come
+// back empty rather than holding "E".
+func TestQSLSentViaDoesNotBecomeManager(t *testing.T) {
+	const rec = "<CALL:5>OE6CLD<QSO_DATE:8>20260606<TIME_ON:4>1200<BAND:3>20m<MODE:2>CW" +
+		"<QSL_SENT_VIA:1>E<EOR>\n"
+	var got Record
+	if err := Parse(strings.NewReader("<EOH>\n"+rec), func(r Record) error { got = r; return nil }); err != nil {
+		t.Fatalf("parse: %v", err)
+	}
+	q, ok := recordToQSO(got)
+	if !ok {
+		t.Fatal("recordToQSO returned !ok")
+	}
+	if q.QSLVia != "" {
+		t.Errorf("QSL_VIA = %q — the routing method leaked into the manager field again", q.QSLVia)
+	}
+	if q.QSLSentVia != "E" {
+		t.Errorf("QSL_SENT_VIA = %q, want %q", q.QSLSentVia, "E")
+	}
+}
+
+// M is import-only in the ADIF QSL Via enumeration: keep it when given, never
+// write it back out.
+func TestQSLViaManagerIsImportOnly(t *testing.T) {
+	in := qso.QSO{
+		Callsign: "3B9FR", Band: "20m", Mode: "CW",
+		QSODate:    time.Date(2026, 6, 6, 12, 0, 0, 0, time.UTC),
+		QSLSentVia: "M", QSLRcvdVia: "M",
+	}
+	var buf bytes.Buffer
+	bw := bufio.NewWriter(&buf)
+	writeRecord(bw, in, true, nil)
+	bw.Flush()
+	if s := buf.String(); strings.Contains(s, "QSL_SENT_VIA") || strings.Contains(s, "QSL_RCVD_VIA") {
+		t.Errorf("exported an import-only value:\n%s", s)
+	}
+}

internal/award/award.go

@@ -449,6 +449,34 @@ type RefMeta struct {
 	Pattern  string
 	re       *regexp.Regexp
 	Valid    bool
+	// Per-reference validity window, ISO "2006-01-02". A reference is not
+	// forever: a park is delisted, a county is merged, a castle loses its
+	// reference number. A QSO made while it existed still counts — it was a valid
+	// contact on the day — and one made after it stopped existing does not.
+	//
+	// Empty means "no window of its own", and the award's own ValidFrom/ValidTo
+	// then govern, as they already do for every QSO in the award (see inScope).
+	// That fallback is deliberately NOT duplicated here: two places enforcing the
+	// same dates is two places for them to disagree.
+	ValidFrom string
+	ValidTo   string
+}
+
+// activeOn reports whether the reference existed on the day of the QSO.
+//
+// Compared as ISO date strings rather than parsed times on purpose: the stored
+// values are "2025-08-01"-shaped and lexical order on that shape IS
+// chronological order, so this cannot fail on a malformed date the way a parse
+// can — a reference with a typo in its window keeps counting instead of silently
+// vanishing from an operator's totals.
+func (m RefMeta) activeOn(day string) bool {
+	if m.ValidFrom != "" && day < m.ValidFrom {
+		return false
+	}
+	if m.ValidTo != "" && day > m.ValidTo {
+		return false
+	}
+	return true
 }
 
 // NewRefList builds the engine's reference view from (code, meta) pairs.
@@ -721,9 +749,14 @@ func EmissionOf(mode string) string { return emissionOf(mode) }
 // abbreviating "Saint"→"St." and hyphenating "Matanuska-Susitna". The rules:
 //   - if cnty already carries "ST,County", split on the first comma; else take
 //     the state from the STATE column;
-//   - upper-case; drop periods and apostrophes; hyphens→space; strip a trailing
-//     County/Parish/Borough/Census Area/Municipality; fold Saint(e)→St(e);
-//     collapse whitespace;
+//   - upper-case; fold accents (the FIPS list writes "Doña Ana", callbooks and
+//     logs write "Dona Ana"); drop periods and apostrophes; hyphens→space;
+//     expand the parenthetical shapes GeoNames uses for county-equivalents
+//     ("Baltimore (city)", "Nome (CA)") and drop its "City and County of"
+//     style prefixes; strip a trailing County/Parish/Borough/Census Area/
+//     Municipality; fold Saint(e)→St(e); collapse whitespace;
+//   - fold the counties renamed since the USA-CA list was drawn onto the name
+//     the award still uses, so a QSO there counts for something (see renamed);
 //   - require a 2-letter state and a non-empty county, else no match ("").
 func USCountyKey(state, cnty string) string {
 	s := strings.TrimSpace(cnty)
@@ -736,10 +769,11 @@ func USCountyKey(state, cnty string) string {
 	} else {
 		st, co = strings.TrimSpace(state), s
 	}
-	co = strings.ToUpper(co)
+	co = strings.ToUpper(foldAccents(co))
 	co = strings.ReplaceAll(co, ".", "")
 	co = strings.ReplaceAll(co, "'", "")
 	co = strings.ReplaceAll(co, "-", " ")
+	co = expandCountyEquivalent(co)
 	for _, suf := range []string{" COUNTY", " PARISH", " BOROUGH", " CENSUS AREA", " MUNICIPALITY"} {
 		if strings.HasSuffix(co, suf) {
 			co = strings.TrimSuffix(co, suf)
@@ -760,6 +794,9 @@ func USCountyKey(state, cnty string) string {
 	if len(st) != 2 || co == "" {
 		return ""
 	}
+	if alias, ok := renamed[st+"/"+co]; ok {
+		co = alias
+	}
 	// Separator is "/", NOT ",": the QSOFIELDS matcher splits a field value on
 	// commas/semicolons (n-fer POTA "US-1,US-2"), which would shatter "AL,AUTAUGA"
 	// into two non-matching tokens. The stored ADIF cnty keeps its comma; only
@@ -956,11 +993,13 @@ func candidates(d *Def, re *regexp.Regexp, q *qso.QSO, rl refList, hasList bool)
 // describes is worse than no trace, because it is believed.
 func candidatesTrace(d *Def, re *regexp.Regexp, q *qso.QSO, rl refList, hasList bool, ex *Explanation) []string {
 	predefined := hasList && !d.Dynamic
+	// The day of the contact, for per-reference validity windows.
+	day := q.QSODate.Format("2006-01-02")
 
 	// run executes one rule and, when tracing, records it.
 	run := func(label, field, matchBy, pattern string, rex *regexp.Regexp, exact bool, leading, trailing, prefix string) []string {
 		raw := searchOne(field, matchBy, rex, exact, leading, trailing, prefix, q, rl, predefined)
-		kept := keepRefs(predefined, rl, raw)
+		kept := keepRefs(predefined, rl, raw, day)
 		if ex != nil {
 			s := Step{Rule: label, Field: field, MatchBy: matchBy, Exact: exact, Pattern: pattern,
 				FieldValue: strings.TrimSpace(stripAffix(fieldRaw(field, q), leading, trailing)),
@@ -974,7 +1013,7 @@ func candidatesTrace(d *Def, re *regexp.Regexp, q *qso.QSO, rl refList, hasList
 				if _, ok := keptSet[n]; ok {
 					continue
 				}
-				s.Rejected = append(s.Rejected, rejection(predefined, rl, n))
+				s.Rejected = append(s.Rejected, rejection(predefined, rl, n, day))
 			}
 			ex.Steps = append(ex.Steps, s)
 		}
@@ -1026,7 +1065,7 @@ func candidatesTrace(d *Def, re *regexp.Regexp, q *qso.QSO, rl refList, hasList
 	// hand. Applied HERE (not just in MatchQSO) so Compute — which powers the
 	// awards panel and the per-QSO refs editor — honours overrides too. For a
 	// predefined award the ref is still validated against the list below.
-	manual := keepRefs(predefined, rl, manualRefs(q, d.Code))
+	manual := keepRefs(predefined, rl, manualRefs(q, d.Code), day)
 	if ex != nil {
 		ex.Manual = manual
 	}
@@ -1065,7 +1104,7 @@ func candidatesTrace(d *Def, re *regexp.Regexp, q *qso.QSO, rl refList, hasList
 // become a reference. "Nothing matched" is the least useful thing a matcher can
 // say; every one of this week's award bugs was a rejection with a plain reason
 // that nothing was printing.
-func rejection(predefined bool, rl refList, code string) Rejected {
+func rejection(predefined bool, rl refList, code, day string) Rejected {
 	switch {
 	case code == "":
 		return Rejected{Candidate: code, Reason: "empty"}
@@ -1076,6 +1115,17 @@ func rejection(predefined bool, rl refList, code string) Rejected {
 	if !ok {
 		return Rejected{Candidate: code, Reason: "not in the award's reference list"}
 	}
+	// Spell the dates out. "Did not count" on a contact the operator remembers
+	// making is exactly the moment they need to be told it is the REFERENCE that
+	// has a window, not their log that is wrong.
+	if !m.activeOn(day) {
+		switch {
+		case m.ValidTo != "" && day > m.ValidTo:
+			return Rejected{Candidate: code, Reason: fmt.Sprintf("the reference ceased to exist on %s, after this QSO of %s", m.ValidTo, day)}
+		default:
+			return Rejected{Candidate: code, Reason: fmt.Sprintf("the reference did not exist until %s, after this QSO of %s", m.ValidFrom, day)}
+		}
+	}
 	if !m.Valid {
 		return Rejected{Candidate: code, Reason: "listed but disabled"}
 	}
@@ -1088,7 +1138,7 @@ func rejection(predefined bool, rl refList, code string) Rejected {
 // so we do NOT additionally require the QSO's entity to match the reference's own
 // DXCC — that wrongly excluded e.g. WAS Alaska (state AK is DXCC entity 6, not
 // 291). Per-reference DXCC stays metadata for the picker.
-func keepRefs(predefined bool, rl refList, found []string) []string {
+func keepRefs(predefined bool, rl refList, found []string, day string) []string {
 	if !predefined {
 		out := make([]string, 0, len(found))
 		for _, c := range found {
@@ -1106,6 +1156,10 @@ func keepRefs(predefined bool, rl refList, found []string) []string {
 		if !ok || !m.Valid {
 			continue
 		}
+		// The reference has to have existed on the day of the contact.
+		if !m.activeOn(day) {
+			continue
+		}
 		if _, dup := seen[c]; dup {
 			continue
 		}

internal/award/refvalidity_test.go

@@ -0,0 +1,109 @@
+package award
+
+import (
+	"testing"
+	"time"
+
+	"hamlog/internal/qso"
+)
+
+func day(s string) time.Time {
+	t, err := time.Parse("2006-01-02", s)
+	if err != nil {
+		panic(err)
+	}
+	return t
+}
+
+// A reference is not forever. A park is delisted, a district is merged, a castle
+// loses its number. A contact made while it existed still counts — it was a
+// valid contact on the day — and one made after it stopped existing does not.
+func TestRefValidityWindow(t *testing.T) {
+	m := RefMeta{Code: "KL-01", Valid: true, ValidTo: "2025-08-31"}
+	for _, tc := range []struct {
+		day  string
+		want bool
+	}{
+		{"2019-01-01", true},
+		{"2025-08-31", true}, // the last day it existed still counts
+		{"2025-09-01", false},
+		{"2026-08-12", false},
+	} {
+		if got := m.activeOn(tc.day); got != tc.want {
+			t.Errorf("KL-01 on %s: active=%v, want %v", tc.day, got, tc.want)
+		}
+	}
+
+	// A reference that only came into being partway through.
+	n := RefMeta{Code: "KL-99", Valid: true, ValidFrom: "2025-01-15"}
+	if n.activeOn("2025-01-14") {
+		t.Error("counted a QSO from before the reference existed")
+	}
+	if !n.activeOn("2025-01-15") {
+		t.Error("the first day it existed must count")
+	}
+
+	// No window of its own: the award's own dates govern, as they already do for
+	// every QSO in the award. Nothing here may narrow that.
+	if !(RefMeta{Code: "X", Valid: true}).activeOn("1970-01-01") {
+		t.Error("a reference with no window must count on any date")
+	}
+}
+
+// The whole point: the same QSO counts before the cutoff and does not after.
+func TestExpiredRefStopsCountingForLaterQSOs(t *testing.T) {
+	d := &Def{
+		Code: "RDA", Name: "Russian District Award", Valid: true,
+		Type: TypeQSOFields, Field: "note", MatchBy: "code",
+		Confirm: []string{"lotw"},
+	}
+	metas := []RefMeta{
+		{Code: "KL-01", Name: "Petrozavodsk", Valid: true, ValidTo: "2025-08-31"},
+		{Code: "KL-04", Name: "Kostomuksha", Valid: true},
+	}
+
+	q := func(ref, on string) *qso.QSO {
+		return &qso.QSO{Callsign: "RA1ABC", Band: "20m", Notes: ref, QSODate: day(on)}
+	}
+
+	if got := MatchQSO(*d, metas, q("KL-01", "2025-06-01")); len(got) != 1 || got[0] != "KL-01" {
+		t.Errorf("a QSO made while KL-01 existed must count: got %v", got)
+	}
+	if got := MatchQSO(*d, metas, q("KL-01", "2025-09-15")); len(got) != 0 {
+		t.Errorf("a QSO made after KL-01 ceased to exist must not count: got %v", got)
+	}
+	if got := MatchQSO(*d, metas, q("KL-04", "2025-09-15")); len(got) != 1 || got[0] != "KL-04" {
+		t.Errorf("a reference with no window is unaffected: got %v", got)
+	}
+}
+
+// The claim that an empty per-reference window "inherits the award's" has to be
+// a fact about the code, not a comment. Compute and MatchQSO both gate on
+// inScope, which enforces the award's own dates — so a reference with no window
+// of its own is already bounded by them, and duplicating the check per reference
+// would only create a second place for the same dates to disagree.
+func TestEmptyRefWindowInheritsTheAward(t *testing.T) {
+	d := Def{
+		Code: "RDA", Name: "Russian District Award", Valid: true,
+		Type: TypeQSOFields, Field: "note", MatchBy: "code",
+		Confirm:   []string{"lotw"},
+		ValidFrom: "1991-06-12", // the award itself starts here
+	}
+	metas := []RefMeta{{Code: "KL-04", Name: "Kostomuksha", Valid: true}} // no window of its own
+
+	q := func(on string) *qso.QSO {
+		return &qso.QSO{Callsign: "RA1ABC", Band: "20m", Notes: "KL-04", QSODate: day(on)}
+	}
+	if got := MatchQSO(d, metas, q("1991-06-11")); len(got) != 0 {
+		t.Errorf("a QSO before the AWARD's start counted for a reference with no window of its own: %v", got)
+	}
+	if got := MatchQSO(d, metas, q("1991-06-12")); len(got) != 1 {
+		t.Errorf("a QSO on the award's first day must count: %v", got)
+	}
+
+	// And a reference window NARROWER than the award's still applies on top.
+	metas[0].ValidTo = "2025-08-31"
+	if got := MatchQSO(d, metas, q("2025-09-01")); len(got) != 0 {
+		t.Errorf("the reference's own end date was ignored: %v", got)
+	}
+}

internal/award/uscounty_names.go

@@ -0,0 +1,120 @@
+package award
+
+import "strings"
+
+// Name normalisation for USCountyKey. It exists because the county a QSO
+// carries and the county the USA-CA reference list carries come from different
+// hands and rarely agree letter for letter:
+//
+//   - the reference is the FIPS list ("Doña Ana County", "Baltimore city");
+//   - a callbook writes what the licensee typed;
+//   - and OpsLog's own offline resolver reads GeoNames, which spells the
+//     county-equivalents its own way ("Baltimore (city)", "Nome (CA)",
+//     "City and County of San Francisco").
+//
+// Measured against a full FCC ULS import (1.56 M US callsigns), the shapes
+// handled here account for ~7 300 stations whose county matched nothing at all
+// — they showed as a new county for ever and counted for no award.
+//
+// Everything here is SPELLING. A county that genuinely no longer exists under
+// that name is a different problem, handled by renamed below.
+
+// foldAccents strips the diacritics that separate a FIPS name from the ASCII
+// every log and callbook actually holds. Only the letters that occur in US
+// place names are listed — this is not a general Unicode folder, and it must
+// not become one: silently folding arbitrary marks would let two distinct
+// references collapse onto one key.
+var accents = strings.NewReplacer(
+	"ñ", "n", "Ñ", "N",
+	"á", "a", "Á", "A",
+	"é", "e", "É", "E",
+	"í", "i", "Í", "I",
+	"ó", "o", "Ó", "O",
+	"ú", "u", "Ú", "U",
+	"ü", "u", "Ü", "U",
+	"ç", "c", "Ç", "C",
+)
+
+func foldAccents(s string) string {
+	// Fast path: US county names are ASCII with a single exception (Doña Ana),
+	// so the common case must not pay for the replacer.
+	for i := 0; i < len(s); i++ {
+		if s[i] >= 0x80 {
+			return accents.Replace(s)
+		}
+	}
+	return s
+}
+
+// expandCountyEquivalent rewrites GeoNames' parenthetical and prefixed spellings
+// of county-equivalents into the plain FIPS form, which the rest of USCountyKey
+// then normalises as usual.
+//
+// Input is already upper-cased with periods and hyphens removed.
+//
+//	BALTIMORE (CITY)                 → BALTIMORE CITY   (FIPS "Baltimore city")
+//	NOME (CA)                        → NOME CENSUS AREA (suffix stripped after)
+//	CITY AND COUNTY OF SAN FRANCISCO → SAN FRANCISCO
+//
+// The truncated "(CITY" is not a typo here: GeoNames really does ship
+// "Colonial Heights (city" with the closing parenthesis missing.
+func expandCountyEquivalent(co string) string {
+	switch {
+	case strings.HasSuffix(co, " (CITY)"):
+		co = strings.TrimSuffix(co, " (CITY)") + " CITY"
+	case strings.HasSuffix(co, " (CITY"):
+		co = strings.TrimSuffix(co, " (CITY") + " CITY"
+	case strings.HasSuffix(co, " (CA)"):
+		co = strings.TrimSuffix(co, " (CA)") + " CENSUS AREA"
+	}
+	// "City and County of X" and "City and Borough of X" are the same place as
+	// FIPS's bare "X" (San Francisco, Denver, Honolulu, Juneau, Sitka). Note the
+	// order: the longer prefixes must be tried before "CITY OF ".
+	for _, p := range []string{
+		"CITY AND COUNTY OF ",
+		"CITY AND BOROUGH OF ",
+		"MUNICIPALITY OF ",
+		"BOROUGH OF ",
+		"CITY OF ",
+	} {
+		if strings.HasPrefix(co, p) {
+			return strings.TrimPrefix(co, p)
+		}
+	}
+	return co
+}
+
+// renamed folds a county renamed or re-drawn since the CQ USA-CA list was
+// published onto the name the award still counts. Keys and values are finished
+// USCountyKey county parts (upper-case, no spaces), looked up as "ST/COUNTY".
+//
+// This deliberately does NOT track the FIPS list. USA-CA is a fixed target of
+// ~3 100 counties; when a state renames one, the award does not reissue its
+// list, so a QSO with the new name would otherwise match nothing and count for
+// nothing. Folding it onto the old name is the only outcome that scores.
+//
+// Connecticut is absent on purpose. Its 2022 planning regions are not renamed
+// counties: a region is drawn from towns belonging to several different
+// counties, so there is no name that maps to another name. That one is resolved
+// from the station's ZIP, in internal/uls.
+var renamed = map[string]string{
+	// Wade Hampton Census Area, AK → Kusilvak Census Area (2015).
+	"AK/KUSILVAK": "WADEHAMPTON",
+	// Shannon County, SD → Oglala Lakota County (2015).
+	"SD/OGLALALAKOTA": "SHANNON",
+	// Valdez-Cordova Census Area, AK was split in two (2019). Both halves fold
+	// back to the parent the award still lists.
+	"AK/CHUGACH":     "VALDEZCORDOVA",
+	"AK/COPPERRIVER": "VALDEZCORDOVA",
+
+	// Alaska's four "X City and Borough". The reference codes for these look
+	// wrong and are not: the trailing " BOROUGH" is stripped as a county type,
+	// leaving "JUNEAU CITY AND". Nothing else in the chain produces that shape
+	// — a log that simply says "Juneau", and GeoNames' "City and Borough of
+	// Juneau", both arrive here as "JUNEAU" and would match nothing. Rather
+	// than re-key four published references, bend the bare name onto them.
+	"AK/JUNEAU":   "JUNEAUCITYAND",
+	"AK/SITKA":    "SITKACITYAND",
+	"AK/WRANGELL": "WRANGELLCITYAND",
+	"AK/YAKUTAT":  "YAKUTATCITYAND",
+}

internal/awardref/uscounties_gen.go

@@ -1943,7 +1943,7 @@ func usCounties() []Ref {
 		ref("NM/COLFAX", "Colfax County, NM", 291),
 		ref("NM/CURRY", "Curry County, NM", 291),
 		ref("NM/DEBACA", "De Baca County, NM", 291),
-		ref("NM/DO̱AANA", "Do̱a Ana County, NM", 291),
+		ref("NM/DONAANA", "Doña Ana County, NM", 291),
 		ref("NM/EDDY", "Eddy County, NM", 291),
 		ref("NM/GRANT", "Grant County, NM", 291),
 		ref("NM/GUADALUPE", "Guadalupe County, NM", 291),

internal/awardref/uscounties_test.go

@@ -0,0 +1,118 @@
+package awardref
+
+import (
+	"strings"
+	"testing"
+	"unicode/utf8"
+
+	"hamlog/internal/award"
+)
+
+// TestUSCountyRefsSelfConsistent is the guard that was missing when the Doña Ana
+// row shipped mangled: its code was "NM/DO̱AANA", which no log, no callbook and
+// no county database could ever produce, so that county was unwinnable and
+// nothing said so.
+//
+// Every reference must reproduce its own code from its own display name through
+// award.USCountyKey — the same function cmd/cntygen used to build it. That ties
+// the generated file to the matcher: change the normalisation rules and this
+// fails the moment one of the 3 102 references stops matching itself.
+func TestUSCountyRefsSelfConsistent(t *testing.T) {
+	refs := usCounties()
+	if len(refs) < 3000 {
+		t.Fatalf("only %d counties — the generated list looks truncated", len(refs))
+	}
+	for _, r := range refs {
+		if !utf8.ValidString(r.Name) || !utf8.ValidString(r.Code) {
+			t.Errorf("%s (%q): not valid UTF-8", r.Code, r.Name)
+			continue
+		}
+		// Name is "County Name, ST".
+		i := strings.LastIndex(r.Name, ", ")
+		if i < 0 {
+			t.Errorf("%s: name %q is not \"County, ST\"", r.Code, r.Name)
+			continue
+		}
+		name, st := r.Name[:i], r.Name[i+2:]
+		if got := award.USCountyKey(st, name); got != r.Code {
+			t.Errorf("USCountyKey(%q, %q) = %q, want %q", st, name, got, r.Code)
+		}
+	}
+}
+
+// TestUSCountyRefsUnique catches a normalisation rule loose enough to collapse
+// two real counties onto one key — the failure mode that would silently merge
+// them in every award total.
+func TestUSCountyRefsUnique(t *testing.T) {
+	seen := map[string]string{}
+	for _, r := range usCounties() {
+		if prev, dup := seen[r.Code]; dup {
+			t.Errorf("code %s is shared by %q and %q", r.Code, prev, r.Name)
+			continue
+		}
+		seen[r.Code] = r.Name
+	}
+}
+
+// TestUSCountyResolverShapes pins the spellings OpsLog's own offline resolver
+// produces (GeoNames, via internal/uls) against the reference. These are the
+// real strings that were failing to match, with the number of US callsigns each
+// covers in a full FCC ULS import.
+func TestUSCountyResolverShapes(t *testing.T) {
+	valid := map[string]bool{}
+	for _, r := range usCounties() {
+		valid[r.Code] = true
+	}
+	cases := []struct {
+		st, county, want string
+	}{
+		{"CA", "City and County of San Francisco", "CA/SANFRANCISCO"}, // 4 217 calls
+		{"NM", "Doña Ana", "NM/DONAANA"},                              // 1 214
+		{"NM", "Dona Ana", "NM/DONAANA"},                              // what logs hold
+		{"MD", "Baltimore (city)", "MD/BALTIMORECITY"},                // 885
+		{"MO", "St. Louis (city)", "MO/STLOUISCITY"},                  // 574
+		{"MO", "St. Louis", "MO/STLOUIS"},                             // the county, distinct
+		{"AK", "Nome (CA)", "AK/NOME"},                                // 252
+		{"AK", "Yukon-Koyukuk (CA)", "AK/YUKONKOYUKUK"},               // 84
+		{"AK", "City and Borough of Wrangell", "AK/WRANGELLCITYAND"},  // 27
+		{"AK", "Juneau", "AK/JUNEAUCITYAND"},                          // a log that just says Juneau
+		{"AK", "Kusilvak", "AK/WADEHAMPTON"},                          // renamed 2015
+		{"SD", "Oglala Lakota County", "SD/SHANNON"},                  // renamed 2015
+		{"AK", "Chugach Census Area", "AK/VALDEZCORDOVA"},             // split 2019
+		{"AK", "Copper River Census Area", "AK/VALDEZCORDOVA"},
+		{"CO", "City and County of Denver", "CO/DENVER"},
+		{"HI", "City and County of Honolulu", "HI/HONOLULU"},
+	}
+	for _, c := range cases {
+		got := award.USCountyKey(c.st, c.county)
+		if got != c.want {
+			t.Errorf("USCountyKey(%q, %q) = %q, want %q", c.st, c.county, got, c.want)
+			continue
+		}
+		if !valid[got] {
+			t.Errorf("USCountyKey(%q, %q) = %q, which is not in the reference list", c.st, c.county, got)
+		}
+	}
+}
+
+// TestUSCountyKeepsVirginiaCitiesOut guards the other direction: cmd/cntygen
+// drops Virginia's independent cities and Carson City on purpose, because CQ's
+// USA-CA does not count them. Normalising their names must not smuggle them
+// back in as some neighbouring county.
+func TestUSCountyKeepsVirginiaCitiesOut(t *testing.T) {
+	valid := map[string]bool{}
+	for _, r := range usCounties() {
+		valid[r.Code] = true
+	}
+	for _, c := range []string{"Virginia Beach (city)", "City of Alexandria", "Lynchburg (city)"} {
+		if k := award.USCountyKey("VA", c); valid[k] {
+			t.Errorf("%q resolved to %s, which USA-CA does not count", c, k)
+		}
+	}
+	// Charles City and James City ARE counties, despite the name.
+	for _, c := range []string{"Charles City", "James City"} {
+		if k := award.USCountyKey("VA", c); !valid[k] {
+			t.Errorf("%q resolved to %s, which is missing from the reference", c, k)
+		}
+	}
+}

internal/bandopen/bandopen.go

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

internal/bandopen/eme_test.go

@@ -0,0 +1,51 @@
+package bandopen
+
+import (
+	"testing"
+	"time"
+)
+
+// A 2 m "opening" was announced at 9650 km towards Japan on stations that were
+// plainly working EME. The moon is not an opening: an operator pointing an
+// antenna at that bearing finds nothing.
+func TestEMEIsNotAnOpeningOnTwoMetres(t *testing.T) {
+	d := New(DefaultConfig())
+	base := time.Date(2026, 8, 12, 6, 0, 0, 0, time.UTC)
+	for i, call := range []string{"7M4RRM", "JA7RPC", "JF1AWC", "JK1TPA", "JH1JCQ"} {
+		if op := d.Add(Spot{
+			Call: call, Band: "2m", DistKm: 9650, Bearing: 40 + i*3,
+			At: base.Add(time.Duration(i) * time.Minute),
+		}, 47.0); op != nil {
+			t.Fatalf("a 9650 km 2 m path was announced as an opening: %+v", op)
+		}
+	}
+}
+
+// But a real 2 m opening — an Es chain at a plausible distance — must survive.
+func TestLongButPlausibleTwoMetresStillCounts(t *testing.T) {
+	d := New(DefaultConfig())
+	base := time.Date(2026, 6, 20, 18, 0, 0, 0, time.UTC)
+	var got *Opening
+	for i, call := range []string{"EA1AA", "CT1BB", "EA7CC", "CT7DD"} {
+		if op := d.Add(Spot{
+			Call: call, Band: "2m", DistKm: 2000 + i*30, Bearing: 200 + i*4,
+			At: base.Add(time.Duration(i) * time.Minute),
+		}, 47.0); op != nil {
+			got = op
+		}
+	}
+	if got == nil {
+		t.Fatal("a 2000 km 2 m burst in one sector was not reported")
+	}
+}
+
+// Six metres keeps no ceiling: multi-hop Es genuinely goes that far, which is
+// why the flat limit was removed in the first place.
+func TestSixMetresHasNoCeiling(t *testing.T) {
+	if MaxKmFor("6m") != 0 || MaxKmFor("10m") != 0 {
+		t.Error("6 m and 10 m must have no distance ceiling")
+	}
+	if MaxKmFor("2m") == 0 {
+		t.Error("2 m must have one")
+	}
+}

internal/cat/kenwood.go

@@ -440,7 +440,31 @@ func (k *Kenwood) SetFrequency(hz int64) error {
 	if k.curVFO == "B" {
 		cmd = "FB"
 	}
-	return k.write(fmt.Sprintf("%s%011d;", cmd, hz))
+	if err := k.write(fmt.Sprintf("%s%011d;", cmd, hz)); err != nil {
+		return err
+	}
+	// Remember what we just commanded.
+	//
+	// While PTT is held the poll is skipped and State() hands back lastState — the
+	// rig answers "?;" to IF; mid-transmission, and reading that as a fault used
+	// to drop the whole link. But a frequency SET during that window then went
+	// unrecorded, so the cache kept describing the dial as it was before.
+	//
+	// WSJT-X's "Fake It" is exactly that sequence: move the dial, key, transmit,
+	// and afterwards put it back. Polling during the over, it was told the rig was
+	// still on the receive frequency — so there was nothing to put back, and the
+	// dial stayed on the transmit frequency for good. Every following over
+	// started from there, which is the drift that was reported.
+	//
+	// Only simplex is updated here. Under split, FreqHz means the transmit
+	// frequency while this write lands on whichever VFO the operator is on, and
+	// guessing which side moved would be worse than a stale value the next poll
+	// corrects on its own.
+	if !k.lastState.Split {
+		k.curFreq = hz
+		k.lastState.FreqHz = hz
+	}
+	return nil
 }
 
 func (k *Kenwood) SetMode(mode string) error {

internal/cat/kenwood_fakeit_test.go

@@ -0,0 +1,100 @@
+package cat
+
+import "testing"
+
+// WSJT-X "Fake It" against the transmit-window cache.
+//
+// Fake It keeps the radio on one dial frequency and shifts it only for the
+// duration of each over: set the transmit frequency, key, transmit, unkey, set
+// it back. The restore is not unconditional — WSJT-X reads the frequency back
+// and puts the dial where it believes it should be.
+//
+// That read lands inside the window where this backend deliberately stops
+// polling, because a Kenwood answers "?;" to IF; while it is transmitting and
+// treating that as a fault used to drop the whole shared link. The cache
+// answers instead. So the cache has to account for frequency SETS made during
+// the window, or it describes the dial as it was before the over — and WSJT-X,
+// told the radio is already on the receive frequency, has nothing to restore.
+//
+// This reproduces the sequence from a reported session: the dial stayed on the
+// transmit frequency after the first over and every later one started there.
+func TestKenwoodFakeItRestoresAfterTransmit(t *testing.T) {
+	const (
+		rxHz = 7074000 // where the operator is listening
+		txHz = 7075500 // where Fake It moves the dial to transmit
+	)
+
+	rig := &ts2000{vfoA: rxHz, mode: '2'}
+	k := NewKenwood("COM-TEST", 9600, "FT8")
+	k.dialPort = dialTo(rig)
+	if err := k.Connect(); err != nil {
+		t.Fatalf("connect: %v", err)
+	}
+	defer k.Disconnect()
+
+	if s, err := k.ReadState(); err != nil || s.FreqHz != rxHz {
+		t.Fatalf("before the over: %d (err %v) — want %d", s.FreqHz, err, rxHz)
+	}
+
+	// The over: shift the dial, then key.
+	if err := k.SetFrequency(txHz); err != nil {
+		t.Fatalf("set transmit frequency: %v", err)
+	}
+	if err := k.SetPTT(true); err != nil {
+		t.Fatalf("ptt on: %v", err)
+	}
+
+	// WSJT-X reads back mid-over. The wire is not polled here — this is the
+	// cache talking, and it must not still be saying rxHz.
+	s, err := k.ReadState()
+	if err != nil {
+		t.Fatalf("read during the over: %v", err)
+	}
+	if s.FreqHz != txHz {
+		t.Errorf("during the over the backend reported %d, want %d — "+
+			"reporting the pre-over frequency is what stops Fake It restoring the dial", s.FreqHz, txHz)
+	}
+
+	if err := k.SetPTT(false); err != nil {
+		t.Fatalf("ptt off: %v", err)
+	}
+
+	// The restore, once the over is done.
+	if err := k.SetFrequency(rxHz); err != nil {
+		t.Fatalf("restore: %v", err)
+	}
+	if rig.vfoA != rxHz {
+		t.Errorf("dial left on %d after the over, want %d", rig.vfoA, rxHz)
+	}
+	if s, err := k.ReadState(); err != nil || s.FreqHz != rxHz {
+		t.Errorf("after the over: %d (err %v) — want %d", s.FreqHz, err, rxHz)
+	}
+}
+
+// Under split the same write must NOT touch the cache: FreqHz means the
+// transmit frequency while the write lands on whichever VFO the operator is on,
+// so guessing which side moved would put a wrong number in front of the
+// operator. A stale one survives only until the next poll.
+func TestKenwoodSplitCacheLeftToThePoll(t *testing.T) {
+	rig := &ts2000{vfoA: 14025000, vfoB: 14030000, mode: '3', split: true}
+	k := NewKenwood("COM-TEST", 9600, "CW")
+	k.dialPort = dialTo(rig)
+	if err := k.Connect(); err != nil {
+		t.Fatalf("connect: %v", err)
+	}
+	defer k.Disconnect()
+
+	s, err := k.ReadState()
+	if err != nil || !s.Split {
+		t.Fatalf("split not seen: %+v (err %v)", s, err)
+	}
+	before := s.FreqHz
+
+	if err := k.SetFrequency(14026000); err != nil {
+		t.Fatalf("set: %v", err)
+	}
+	if k.lastState.FreqHz != before {
+		t.Errorf("split cache moved to %d on a VFO write, want it left at %d for the poll",
+			k.lastState.FreqHz, before)
+	}
+}

internal/db/migrations/0026_lookup_web_zip.sql

@@ -0,0 +1,7 @@
+-- The lookup cache gains the two fields the providers were already sending and
+-- nothing was reading: the operator's own site, and the postal code.
+--
+-- `web` matters beyond the cache: the qso table has had a `web` column since
+-- 0003 and no lookup ever filled it.
+ALTER TABLE callsign_cache ADD COLUMN web TEXT;
+ALTER TABLE callsign_cache ADD COLUMN zip TEXT;

internal/db/migrations/0027_qsl_sent_rcvd_via.sql

@@ -0,0 +1,18 @@
+-- QSL_SENT_VIA / QSL_RCVD_VIA — the ADIF fields that say HOW a card travelled.
+--
+-- Until now OpsLog had one column, qsl_via, and used it for two unrelated
+-- things: the QSL manager (what ADIF's QSL_VIA holds) and the routing method.
+-- Imports made it worse — QSL_SENT_VIA was folded into qsl_via when qsl_via was
+-- empty, so a Log4OM log arrived with "E" sitting where the manager belongs —
+-- and QSL_RCVD_VIA was dropped outright, listed as a promoted field with no
+-- column behind it, so it was not even kept among the extras.
+--
+-- These two columns hold the ADIF enumeration: B (bureau), D (direct),
+-- E (electronic). M (manager) is accepted on import only, per the standard.
+--
+-- Adding the columns is all that happens here. Existing qsl_via values are NOT
+-- touched: separating a manager from a routing word rewrites what an operator
+-- can see in their own log, so it is offered once, with a count, and only runs
+-- when they say yes.
+ALTER TABLE qso ADD COLUMN qsl_sent_via TEXT;
+ALTER TABLE qso ADD COLUMN qsl_rcvd_via TEXT;

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

@@ -132,6 +132,18 @@ func (db *DB) Entities() []*Entity {
 func (db *DB) Lookup(callsign string) (Match, bool) {
 	db.mu.RLock()
 	defer db.mu.RUnlock()
+	// Maritime and aeronautical mobile belong to NO entity, and that is not a
+	// technicality — the station is at sea or in the air. RI1FJL/MM resolved to
+	// Franz Josef Land while the expedition was still on its way there, telling
+	// the operator they had worked an entity they had not.
+	//
+	// The previous choice was deliberate ("the log should still show the
+	// operator's country") and it is wrong for exactly that reason: a home
+	// country here is not extra information, it is a false claim about where the
+	// contact happened.
+	if IsMobileNoEntity(callsign) {
+		return Match{}, false
+	}
 	call := normalizeCallsign(callsign)
 	if call == "" {
 		return Match{}, false
@@ -364,3 +376,22 @@ func replaceAreaDigit(call string, d byte) string {
 	}
 	return call
 }
+
+// IsMobileNoEntity reports a callsign DXCC assigns to no entity: a TRAILING
+// /MM (maritime mobile) or /AM (aeronautical mobile).
+//
+// Trailing only. A LEADING "MM" is the Scotland prefix and "AM" is Spain, so
+// MM0ABC and AM5X are ordinary calls — treating those as entity-less would be a
+// far larger error than the one this fixes.
+func IsMobileNoEntity(callsign string) bool {
+	s := strings.ToUpper(strings.TrimSpace(callsign))
+	i := strings.LastIndex(s, "/")
+	if i < 0 {
+		return false
+	}
+	switch s[i+1:] {
+	case "MM", "AM":
+		return true
+	}
+	return false
+}

internal/dxcc/dxcc_names_gen.go

@@ -4,348 +4,348 @@ package dxcc
 // numbers. Generated by joining cty.dat to the authoritative ARRL/ADIF entity
 // list (k0swe/dxcc-json) by primary prefix + canonical name. 344 entities.
 var dxccByName = map[string]int{
-	"afghanistan": 3,
-	"agalega & st. brandon": 4,
-	"aland islands": 5,
-	"alaska": 6,
-	"albania": 7,
-	"algeria": 400,
-	"american samoa": 9,
+	"afghanistan":              3,
+	"agalega & st. brandon":    4,
+	"aland islands":            5,
+	"alaska":                   6,
+	"albania":                  7,
+	"algeria":                  400,
+	"american samoa":           9,
 	"amsterdam & st. paul is.": 10,
-	"andaman & nicobar is.": 11,
-	"andorra": 203,
-	"angola": 401,
-	"anguilla": 12,
-	"annobon island": 195,
-	"antarctica": 13,
-	"antigua & barbuda": 94,
-	"argentina": 100,
-	"armenia": 14,
-	"aruba": 91,
-	"ascension island": 205,
-	"asiatic russia": 15,
-	"asiatic turkey": 390,
-	"austral islands": 508,
-	"australia": 150,
-	"austria": 206,
-	"aves island": 17,
-	"azerbaijan": 18,
-	"azores": 149,
-	"bahamas": 60,
-	"bahrain": 304,
-	"baker & howland islands": 20,
-	"balearic islands": 21,
-	"banaba island": 490,
-	"bangladesh": 305,
-	"barbados": 62,
-	"bear island": 259,
-	"belarus": 27,
-	"belgium": 209,
-	"belize": 66,
-	"benin": 416,
-	"bermuda": 64,
-	"bhutan": 306,
-	"bolivia": 104,
-	"bonaire": 520,
-	"bosnia-herzegovina": 501,
-	"botswana": 402,
-	"bouvet": 24,
-	"brazil": 108,
-	"british virgin islands": 65,
-	"brunei darussalam": 345,
-	"bulgaria": 212,
-	"burkina faso": 480,
-	"burundi": 404,
-	"cambodia": 312,
-	"cameroon": 406,
-	"canada": 1,
-	"canary islands": 29,
-	"cape verde": 409,
-	"cayman islands": 69,
+	"andaman & nicobar is.":    11,
+	"andorra":                  203,
+	"angola":                   401,
+	"anguilla":                 12,
+	"annobon island":           195,
+	"antarctica":               13,
+	"antigua & barbuda":        94,
+	"argentina":                100,
+	"armenia":                  14,
+	"aruba":                    91,
+	"ascension island":         205,
+	"asiatic russia":           15,
+	"asiatic turkey":           390,
+	"austral islands":          508,
+	"australia":                150,
+	"austria":                  206,
+	"aves island":              17,
+	"azerbaijan":               18,
+	"azores":                   149,
+	"bahamas":                  60,
+	"bahrain":                  304,
+	"baker & howland islands":  20,
+	"balearic islands":         21,
+	"banaba island":            490,
+	"bangladesh":               305,
+	"barbados":                 62,
+	"bear island":              259,
+	"belarus":                  27,
+	"belgium":                  209,
+	"belize":                   66,
+	"benin":                    416,
+	"bermuda":                  64,
+	"bhutan":                   306,
+	"bolivia":                  104,
+	"bonaire":                  520,
+	"bosnia-herzegovina":       501,
+	"botswana":                 402,
+	"bouvet":                   24,
+	"brazil":                   108,
+	"british virgin islands":   65,
+	"brunei darussalam":        345,
+	"bulgaria":                 212,
+	"burkina faso":             480,
+	"burundi":                  404,
+	"cambodia":                 312,
+	"cameroon":                 406,
+	"canada":                   1,
+	"canary islands":           29,
+	"cape verde":               409,
+	"cayman islands":           69,
 	"central african republic": 408,
-	"central kiribati": 31,
-	"ceuta & melilla": 32,
-	"chad": 410,
-	"chagos islands": 33,
-	"chatham islands": 34,
-	"chesterfield islands": 512,
-	"chile": 112,
-	"china": 318,
-	"christmas island": 35,
-	"clipperton island": 36,
-	"cocos (keeling) islands": 38,
-	"cocos island": 37,
-	"colombia": 116,
-	"comoros": 411,
-	"conway reef": 489,
-	"corsica": 214,
-	"costa rica": 308,
-	"cote d'ivoire": 428,
-	"crete": 40,
-	"croatia": 497,
-	"crozet island": 41,
-	"cuba": 70,
-	"curacao": 517,
-	"cyprus": 215,
-	"czech republic": 503,
-	"dem. rep. of the congo": 414,
-	"denmark": 221,
-	"desecheo island": 43,
-	"djibouti": 382,
-	"dodecanese": 45,
-	"dominica": 95,
-	"dominican republic": 72,
-	"dpr of korea": 344,
-	"ducie island": 513,
-	"east malaysia": 46,
-	"easter island": 47,
-	"eastern kiribati": 48,
-	"ecuador": 120,
-	"egypt": 478,
-	"el salvador": 74,
-	"england": 223,
-	"equatorial guinea": 49,
-	"eritrea": 51,
-	"estonia": 52,
-	"ethiopia": 53,
-	"european russia": 54,
-	"european turkey": 390,
-	"falkland islands": 141,
-	"faroe islands": 222,
-	"fed. rep. of germany": 230,
-	"fernando de noronha": 56,
-	"fiji": 176,
-	"finland": 224,
-	"france": 227,
-	"franz josef land": 61,
-	"french guiana": 63,
-	"french polynesia": 175,
-	"gabon": 420,
-	"galapagos islands": 71,
-	"georgia": 75,
-	"ghana": 424,
-	"gibraltar": 233,
-	"glorioso islands": 99,
-	"greece": 236,
-	"greenland": 237,
-	"grenada": 77,
-	"guadeloupe": 79,
-	"guam": 103,
-	"guantanamo bay": 105,
-	"guatemala": 76,
-	"guernsey": 106,
-	"guinea": 107,
-	"guinea-bissau": 109,
-	"guyana": 129,
-	"haiti": 78,
-	"hawaii": 110,
-	"heard island": 111,
-	"honduras": 80,
-	"hong kong": 321,
-	"hungary": 239,
-	"iceland": 242,
-	"india": 324,
-	"indonesia": 327,
-	"iran": 330,
-	"iraq": 333,
-	"ireland": 245,
-	"isle of man": 114,
-	"israel": 336,
-	"italy": 248,
-	"itu hq": 117,
-	"jamaica": 82,
-	"jan mayen": 118,
-	"japan": 339,
-	"jersey": 122,
-	"johnston island": 123,
-	"jordan": 342,
-	"juan de nova, europa": 124,
-	"juan fernandez islands": 125,
-	"kaliningrad": 126,
-	"kazakhstan": 130,
-	"kenya": 430,
-	"kerguelen islands": 131,
-	"kermadec islands": 133,
-	"kingdom of eswatini": 468,
-	"kure island": 138,
-	"kuwait": 348,
-	"kyrgyzstan": 135,
-	"lakshadweep islands": 142,
-	"laos": 143,
-	"latvia": 145,
-	"lebanon": 354,
-	"lesotho": 432,
-	"liberia": 434,
-	"libya": 436,
-	"liechtenstein": 251,
-	"lithuania": 146,
-	"lord howe island": 147,
-	"luxembourg": 254,
-	"macao": 152,
-	"macquarie island": 153,
-	"madagascar": 438,
-	"madeira islands": 256,
-	"malawi": 440,
-	"maldives": 159,
-	"mali": 442,
-	"malpelo island": 161,
-	"malta": 257,
-	"mariana islands": 166,
-	"market reef": 167,
-	"marquesas islands": 509,
-	"marshall islands": 168,
-	"martinique": 84,
-	"mauritania": 444,
-	"mauritius": 165,
-	"mayotte": 169,
-	"mellish reef": 171,
-	"mexico": 50,
-	"micronesia": 173,
-	"midway island": 174,
-	"minami torishima": 177,
-	"moldova": 179,
-	"monaco": 260,
-	"mongolia": 363,
-	"montenegro": 514,
-	"montserrat": 96,
-	"morocco": 446,
-	"mount athos": 180,
-	"mozambique": 181,
-	"myanmar": 309,
-	"n.z. subantarctic is.": 16,
-	"namibia": 464,
-	"nauru": 157,
-	"navassa island": 182,
-	"nepal": 369,
-	"netherlands": 263,
-	"new caledonia": 162,
-	"new zealand": 170,
-	"nicaragua": 86,
-	"niger": 187,
-	"nigeria": 450,
-	"niue": 188,
-	"norfolk island": 189,
-	"north cook islands": 191,
-	"north macedonia": 502,
-	"northern ireland": 265,
-	"norway": 266,
-	"ogasawara": 192,
-	"oman": 370,
-	"pakistan": 372,
-	"palau": 22,
-	"palestine": 510,
+	"central kiribati":         31,
+	"ceuta & melilla":          32,
+	"chad":                     410,
+	"chagos islands":           33,
+	"chatham islands":          34,
+	"chesterfield islands":     512,
+	"chile":                    112,
+	"china":                    318,
+	"christmas island":         35,
+	"clipperton island":        36,
+	"cocos (keeling) islands":  38,
+	"cocos island":             37,
+	"colombia":                 116,
+	"comoros":                  411,
+	"conway reef":              489,
+	"corsica":                  214,
+	"costa rica":               308,
+	"cote d'ivoire":            428,
+	"crete":                    40,
+	"croatia":                  497,
+	"crozet island":            41,
+	"cuba":                     70,
+	"curacao":                  517,
+	"cyprus":                   215,
+	"czech republic":           503,
+	"dem. rep. of the congo":   414,
+	"denmark":                  221,
+	"desecheo island":          43,
+	"djibouti":                 382,
+	"dodecanese":               45,
+	"dominica":                 95,
+	"dominican republic":       72,
+	"dpr of korea":             344,
+	"ducie island":             513,
+	"east malaysia":            46,
+	"easter island":            47,
+	"eastern kiribati":         48,
+	"ecuador":                  120,
+	"egypt":                    478,
+	"el salvador":              74,
+	"england":                  223,
+	"equatorial guinea":        49,
+	"eritrea":                  51,
+	"estonia":                  52,
+	"ethiopia":                 53,
+	"european russia":          54,
+	"european turkey":          390,
+	"falkland islands":         141,
+	"faroe islands":            222,
+	"fed. rep. of germany":     230,
+	"fernando de noronha":      56,
+	"fiji":                     176,
+	"finland":                  224,
+	"france":                   227,
+	"franz josef land":         61,
+	"french guiana":            63,
+	"french polynesia":         175,
+	"gabon":                    420,
+	"galapagos islands":        71,
+	"georgia":                  75,
+	"ghana":                    424,
+	"gibraltar":                233,
+	"glorioso islands":         99,
+	"greece":                   236,
+	"greenland":                237,
+	"grenada":                  77,
+	"guadeloupe":               79,
+	"guam":                     103,
+	"guantanamo bay":           105,
+	"guatemala":                76,
+	"guernsey":                 106,
+	"guinea":                   107,
+	"guinea-bissau":            109,
+	"guyana":                   129,
+	"haiti":                    78,
+	"hawaii":                   110,
+	"heard island":             111,
+	"honduras":                 80,
+	"hong kong":                321,
+	"hungary":                  239,
+	"iceland":                  242,
+	"india":                    324,
+	"indonesia":                327,
+	"iran":                     330,
+	"iraq":                     333,
+	"ireland":                  245,
+	"isle of man":              114,
+	"israel":                   336,
+	"italy":                    248,
+	"itu hq":                   117,
+	"jamaica":                  82,
+	"jan mayen":                118,
+	"japan":                    339,
+	"jersey":                   122,
+	"johnston island":          123,
+	"jordan":                   342,
+	"juan de nova, europa":     124,
+	"juan fernandez islands":   125,
+	"kaliningrad":              126,
+	"kazakhstan":               130,
+	"kenya":                    430,
+	"kerguelen islands":        131,
+	"kermadec islands":         133,
+	"kingdom of eswatini":      468,
+	"kure island":              138,
+	"kuwait":                   348,
+	"kyrgyzstan":               135,
+	"lakshadweep islands":      142,
+	"laos":                     143,
+	"latvia":                   145,
+	"lebanon":                  354,
+	"lesotho":                  432,
+	"liberia":                  434,
+	"libya":                    436,
+	"liechtenstein":            251,
+	"lithuania":                146,
+	"lord howe island":         147,
+	"luxembourg":               254,
+	"macao":                    152,
+	"macquarie island":         153,
+	"madagascar":               438,
+	"madeira islands":          256,
+	"malawi":                   440,
+	"maldives":                 159,
+	"mali":                     442,
+	"malpelo island":           161,
+	"malta":                    257,
+	"mariana islands":          166,
+	"market reef":              167,
+	"marquesas islands":        509,
+	"marshall islands":         168,
+	"martinique":               84,
+	"mauritania":               444,
+	"mauritius":                165,
+	"mayotte":                  169,
+	"mellish reef":             171,
+	"mexico":                   50,
+	"micronesia":               173,
+	"midway island":            174,
+	"minami torishima":         177,
+	"moldova":                  179,
+	"monaco":                   260,
+	"mongolia":                 363,
+	"montenegro":               514,
+	"montserrat":               96,
+	"morocco":                  446,
+	"mount athos":              180,
+	"mozambique":               181,
+	"myanmar":                  309,
+	"n.z. subantarctic is.":    16,
+	"namibia":                  464,
+	"nauru":                    157,
+	"navassa island":           182,
+	"nepal":                    369,
+	"netherlands":              263,
+	"new caledonia":            162,
+	"new zealand":              170,
+	"nicaragua":                86,
+	"niger":                    187,
+	"nigeria":                  450,
+	"niue":                     188,
+	"norfolk island":           189,
+	"north cook islands":       191,
+	"north macedonia":          502,
+	"northern ireland":         265,
+	"norway":                   266,
+	"ogasawara":                192,
+	"oman":                     370,
+	"pakistan":                 372,
+	"palau":                    22,
+	"palestine":                510,
 	"palmyra & jarvis islands": 197,
-	"panama": 88,
-	"papua new guinea": 163,
-	"paraguay": 132,
-	"peru": 136,
-	"peter 1 island": 199,
-	"philippines": 375,
-	"pitcairn island": 172,
-	"poland": 269,
-	"portugal": 272,
-	"pr. edward & marion is.": 201,
-	"pratas island": 505,
-	"puerto rico": 202,
-	"qatar": 376,
-	"republic of korea": 137,
-	"republic of kosovo": 522,
-	"republic of south sudan": 521,
-	"republic of the congo": 412,
-	"reunion island": 453,
-	"revillagigedo": 204,
-	"rodriguez island": 207,
-	"romania": 275,
-	"rotuma island": 460,
-	"rwanda": 454,
-	"saba & st. eustatius": 519,
-	"sable island": 211,
-	"samoa": 190,
+	"panama":                   88,
+	"papua new guinea":         163,
+	"paraguay":                 132,
+	"peru":                     136,
+	"peter 1 island":           199,
+	"philippines":              375,
+	"pitcairn island":          172,
+	"poland":                   269,
+	"portugal":                 272,
+	"pr. edward & marion is.":  201,
+	"pratas island":            505,
+	"puerto rico":              202,
+	"qatar":                    376,
+	"republic of korea":        137,
+	"republic of kosovo":       522,
+	"republic of south sudan":  521,
+	"republic of the congo":    412,
+	"reunion island":           453,
+	"revillagigedo":            204,
+	"rodriguez island":         207,
+	"romania":                  275,
+	"rotuma island":            460,
+	"rwanda":                   454,
+	"saba & st. eustatius":     519,
+	"sable island":             211,
+	"samoa":                    190,
 	"san andres & providencia": 216,
 	"san felix & san ambrosio": 217,
-	"san marino": 278,
-	"sao tome & principe": 219,
-	"sardinia": 225,
-	"saudi arabia": 378,
-	"scarborough reef": 506,
-	"scotland": 279,
-	"senegal": 456,
-	"serbia": 296,
-	"seychelles": 379,
-	"shetland islands": 279,
-	"sierra leone": 458,
-	"singapore": 381,
-	"sint maarten": 518,
-	"slovak republic": 504,
-	"slovenia": 499,
-	"solomon islands": 185,
-	"somalia": 232,
-	"south africa": 462,
-	"south cook islands": 234,
-	"south georgia island": 235,
-	"south orkney islands": 238,
-	"south sandwich islands": 240,
-	"south shetland islands": 241,
-	"sov mil order of malta": 246,
-	"spain": 281,
-	"spratly islands": 247,
-	"sri lanka": 315,
-	"st. barthelemy": 516,
-	"st. helena": 250,
-	"st. kitts & nevis": 249,
-	"st. lucia": 97,
-	"st. martin": 213,
-	"st. paul island": 252,
-	"st. peter & st. paul": 253,
-	"st. pierre & miquelon": 277,
-	"st. vincent": 98,
-	"sudan": 466,
-	"suriname": 140,
-	"svalbard": 259,
-	"swains island": 515,
-	"sweden": 284,
-	"switzerland": 287,
-	"syria": 384,
-	"taiwan": 386,
-	"tajikistan": 262,
-	"tanzania": 470,
-	"temotu province": 507,
-	"thailand": 387,
-	"the gambia": 422,
-	"timor - leste": 511,
-	"togo": 483,
-	"tokelau islands": 270,
-	"tonga": 160,
-	"trindade & martim vaz": 273,
-	"trinidad & tobago": 90,
+	"san marino":               278,
+	"sao tome & principe":      219,
+	"sardinia":                 225,
+	"saudi arabia":             378,
+	"scarborough reef":         506,
+	"scotland":                 279,
+	"senegal":                  456,
+	"serbia":                   296,
+	"seychelles":               379,
+	"shetland islands":         279,
+	"sierra leone":             458,
+	"singapore":                381,
+	"sint maarten":             518,
+	"slovak republic":          504,
+	"slovenia":                 499,
+	"solomon islands":          185,
+	"somalia":                  232,
+	"south africa":             462,
+	"south cook islands":       234,
+	"south georgia island":     235,
+	"south orkney islands":     238,
+	"south sandwich islands":   240,
+	"south shetland islands":   241,
+	"sov mil order of malta":   246,
+	"spain":                    281,
+	"spratly islands":          247,
+	"sri lanka":                315,
+	"st. barthelemy":           516,
+	"st. helena":               250,
+	"st. kitts & nevis":        249,
+	"st. lucia":                97,
+	"st. martin":               213,
+	"st. paul island":          252,
+	"st. peter & st. paul":     253,
+	"st. pierre & miquelon":    277,
+	"st. vincent":              98,
+	"sudan":                    466,
+	"suriname":                 140,
+	"svalbard":                 259,
+	"swains island":            515,
+	"sweden":                   284,
+	"switzerland":              287,
+	"syria":                    384,
+	"taiwan":                   386,
+	"tajikistan":               262,
+	"tanzania":                 470,
+	"temotu province":          507,
+	"thailand":                 387,
+	"the gambia":               422,
+	"timor - leste":            511,
+	"togo":                     483,
+	"tokelau islands":          270,
+	"tonga":                    160,
+	"trindade & martim vaz":    273,
+	"trinidad & tobago":        90,
 	"tristan da cunha & gough": 274,
-	"tromelin island": 276,
-	"tunisia": 474,
-	"turkmenistan": 280,
-	"turks & caicos islands": 89,
-	"tuvalu": 282,
-	"uganda": 286,
-	"uk base areas on cyprus": 283,
-	"ukraine": 288,
-	"united arab emirates": 391,
-	"united nations hq": 289,
-	"united states": 291,
-	"uruguay": 144,
-	"us virgin islands": 285,
-	"uzbekistan": 292,
-	"vanuatu": 158,
-	"vatican city": 295,
-	"venezuela": 148,
-	"vienna intl ctr": 206,
-	"vietnam": 293,
-	"wake island": 297,
-	"wales": 294,
-	"wallis & futuna islands": 298,
-	"west malaysia": 299, // hand-fixed: generation joined it to 155 by mistake (9M2 = ADIF 299)
-	"western kiribati": 301,
-	"western sahara": 302,
-	"willis island": 303,
-	"yemen": 492,
-	"zambia": 482,
-	"zimbabwe": 452,
+	"tromelin island":          276,
+	"tunisia":                  474,
+	"turkmenistan":             280,
+	"turks & caicos islands":   89,
+	"tuvalu":                   282,
+	"uganda":                   286,
+	"uk base areas on cyprus":  283,
+	"ukraine":                  288,
+	"united arab emirates":     391,
+	"united nations hq":        289,
+	"united states":            291,
+	"uruguay":                  144,
+	"us virgin islands":        285,
+	"uzbekistan":               292,
+	"vanuatu":                  158,
+	"vatican city":             295,
+	"venezuela":                148,
+	"vienna intl ctr":          206,
+	"vietnam":                  293,
+	"wake island":              297,
+	"wales":                    294,
+	"wallis & futuna islands":  298,
+	"west malaysia":            299, // hand-fixed: generation joined it to 155 by mistake (9M2 = ADIF 299)
+	"western kiribati":         301,
+	"western sahara":           302,
+	"willis island":            303,
+	"yemen":                    492,
+	"zambia":                   482,
+	"zimbabwe":                 452,
 }

internal/dxcc/dxcc_test.go

@@ -178,9 +178,9 @@ Sicily:                   15:  28:  EU:   37.50:   -14.00:    -1.0:  *IT9:
 		t.Fatalf("load: %v", err)
 	}
 	cases := map[string]string{
-		"IW9EZO": "Italy",    // Sicily (*IT9) → Italy
+		"IW9EZO": "Italy", // Sicily (*IT9) → Italy
 		"IT9CLY": "Italy",
-		"IG9A":   "Italy",    // African Italy (*IG9) → Italy
+		"IG9A":   "Italy", // African Italy (*IG9) → Italy
 		"IK0ABC": "Italy",
 		"IS0XYZ": "Sardinia", // real DXCC entity — must stay Sardinia
 		"IM0ABC": "Sardinia",
@@ -210,25 +210,25 @@ Sicily:                   15:  28:  EU:   37.50:   -14.00:    -1.0:  *IT9:
 
 func TestNormalize(t *testing.T) {
 	cases := map[string]string{
-		"F4BPO":      "F4BPO",
-		"f4bpo":      "F4BPO",
-		" F4BPO ":    "F4BPO",
-		"F4BPO/P":    "F4BPO",
-		"F4BPO/MM":   "F4BPO", // maritime mobile → strip, keep home entity for the log
-		"F4BPO/AM":   "F4BPO", // aeronautical mobile → strip, keep home entity for the log
-		"F4BPO/M":    "F4BPO", // plain mobile keeps the home entity
-		"F4BPO/5":    "F5BPO", // "/5" re-homes to call area 5
-		"HD5MW/8":    "HD8MW", // "/8" → Galápagos call area (HD8)
-		"7X2ARA/4":   "7X4ARA", // "/4" changes the AREA digit (2→4), NOT the 7 of the 7X prefix (was wrongly 4X2ARA = Israel)
-		"3A2ABC/6":   "3A6ABC", // digit-first prefix 3A: area digit is the 2, not the 3
-		"4X1AB/2":    "4X2AB",  // 4X (Israel) area 1→2, keep the leading 4
-		"DL/F4BPO":   "DL",
-		"MM/KA9P":    "MM",    // leading MM = Scotland operating prefix
-		"MM/LY3X/P":  "MM",
-		"F4BPO/W6":   "W6",
-		"VK9/F4BPO":  "VK9",
-		"4U1UN/B":    "4U1UN", // trailing /B = beacon → strip, keep the base call
-		"B/F4BPO":    "B",     // leading B = China operating prefix, NOT a beacon
+		"F4BPO":     "F4BPO",
+		"f4bpo":     "F4BPO",
+		" F4BPO ":   "F4BPO",
+		"F4BPO/P":   "F4BPO",
+		"F4BPO/MM":  "F4BPO",  // maritime mobile → strip, keep home entity for the log
+		"F4BPO/AM":  "F4BPO",  // aeronautical mobile → strip, keep home entity for the log
+		"F4BPO/M":   "F4BPO",  // plain mobile keeps the home entity
+		"F4BPO/5":   "F5BPO",  // "/5" re-homes to call area 5
+		"HD5MW/8":   "HD8MW",  // "/8" → Galápagos call area (HD8)
+		"7X2ARA/4":  "7X4ARA", // "/4" changes the AREA digit (2→4), NOT the 7 of the 7X prefix (was wrongly 4X2ARA = Israel)
+		"3A2ABC/6":  "3A6ABC", // digit-first prefix 3A: area digit is the 2, not the 3
+		"4X1AB/2":   "4X2AB",  // 4X (Israel) area 1→2, keep the leading 4
+		"DL/F4BPO":  "DL",
+		"MM/KA9P":   "MM", // leading MM = Scotland operating prefix
+		"MM/LY3X/P": "MM",
+		"F4BPO/W6":  "W6",
+		"VK9/F4BPO": "VK9",
+		"4U1UN/B":   "4U1UN", // trailing /B = beacon → strip, keep the base call
+		"B/F4BPO":   "B",     // leading B = China operating prefix, NOT a beacon
 	}
 	for in, want := range cases {
 		if got := normalizeCallsign(in); got != want {

internal/dxcc/maritime_test.go

@@ -0,0 +1,39 @@
+package dxcc
+
+import "testing"
+
+// /MM and /AM belong to NO DXCC entity: the station is at sea or in the air.
+//
+// This is not a technicality. RI1FJL/MM resolved to Franz Josef Land while the
+// expedition was still sailing there, which told the operator they had worked
+// an entity they had not.
+func TestMobileNoEntity(t *testing.T) {
+	for _, tc := range []struct {
+		call string
+		want bool
+	}{
+		{"RI1FJL/MM", true},
+		{"YB1SCY/AM", true},
+		{"ri1fjl/mm", true},
+		{" RI1FJL/MM ", true},
+		// A LEADING MM is Scotland and AM is Spain. Treating those as
+		// entity-less would be a far larger error than the one this fixes.
+		{"MM0ABC", false},
+		{"AM5X", false},
+		{"MM/F4BPO", false},
+		{"AM/DL1ABC", false},
+		// Other suffixes keep their entity — a portable station is still ashore.
+		{"F4BPO/P", false},
+		{"F4BPO/M", false},
+		{"4U1UN/B", false},
+		{"F4BPO", false},
+		// Only the LAST element counts: RI1FJL/MM/P is still maritime, and a
+		// call whose /MM is not final is not.
+		{"RI1FJL/MM/P", false},
+		{"", false},
+	} {
+		if got := IsMobileNoEntity(tc.call); got != tc.want {
+			t.Errorf("IsMobileNoEntity(%q) = %v, want %v", tc.call, got, tc.want)
+		}
+	}
+}

internal/email/email.go

@@ -4,6 +4,7 @@ package email
 
 import (
 	"fmt"
+	"os"
 	"time"
 
 	"github.com/wneessen/go-mail"
@@ -85,7 +86,32 @@ func SendFiles(cfg Config, to, subject, body string, attachPaths []string) error
 		return fmt.Errorf("smtp client: %w", err)
 	}
 	if err := client.DialAndSend(m); err != nil {
-		return fmt.Errorf("send: %w", err)
+		return fmt.Errorf("send via %s:%d (%s, %s): %w",
+			cfg.Host, cfg.Port, cfg.Encryption, describeSize(attachPaths), err)
 	}
 	return nil
 }
+
+// describeSize reports what was attached, in bytes.
+//
+// "An existing connection was forcibly closed" during DATA is the same message
+// whether the server refused the size, hit a quota, or simply dropped the
+// socket — and the first of those is the only one the operator can act on
+// directly. Naming the size rules it in or out without a second attempt.
+func describeSize(paths []string) string {
+	var total int64
+	n := 0
+	for _, p := range paths {
+		if p == "" {
+			continue
+		}
+		if fi, err := os.Stat(p); err == nil {
+			total += fi.Size()
+			n++
+		}
+	}
+	if n == 0 {
+		return "no attachment"
+	}
+	return fmt.Sprintf("%d attachment(s), %d KB", n, (total+1023)/1024)
+}

internal/email/size_test.go

@@ -0,0 +1,34 @@
+package email
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// "An existing connection was forcibly closed" during DATA reads the same
+// whether the server refused the SIZE, hit a quota, or just dropped the socket
+// — and only the first is something the operator can act on. Naming the size in
+// the error rules it in or out without a second attempt.
+func TestDescribeSize(t *testing.T) {
+	dir := t.TempDir()
+	a := filepath.Join(dir, "card.jpg")
+	if err := os.WriteFile(a, make([]byte, 2048), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	if got := describeSize(nil); got != "no attachment" {
+		t.Errorf("no attachment = %q", got)
+	}
+	if got := describeSize([]string{""}); got != "no attachment" {
+		t.Errorf("blank path = %q, want it ignored", got)
+	}
+	if got := describeSize([]string{a}); got != "1 attachment(s), 2 KB" {
+		t.Errorf("one file = %q", got)
+	}
+	// A path that does not exist must not be counted — the mail library skips it,
+	// so reporting it would describe a message that was never sent.
+	if got := describeSize([]string{a, filepath.Join(dir, "gone.jpg")}); got != "1 attachment(s), 2 KB" {
+		t.Errorf("missing file counted: %q", got)
+	}
+}

internal/extsvc/extsvc.go

@@ -65,23 +65,25 @@ const (
 // AutoUpload + UploadMode are common to all (timing is per-service, so the
 // user can run e.g. Club Log immediate and QRZ delayed).
 type ServiceConfig struct {
-	APIKey               string     `json:"api_key"`
-	URL                  string     `json:"url"`                    // Cloudlog/Wavelog: base URL of the user's own instance
-	StationID            string     `json:"station_id"`             // Cloudlog/Wavelog: station profile (location) id
-	Email                string     `json:"email"`                  // Club Log account email
-	Username             string     `json:"username"`               // LoTW website login (for confirmation download)
-	Password             string     `json:"password"`               // Club Log account / LoTW website password
-	Callsign             string     `json:"callsign"`               // Club Log / HRDLog logbook (owner) callsign
-	Code                 string     `json:"code"`                   // HRDLog: account upload code
-	QTHNickname          string     `json:"qth_nickname"`           // eQSL: QTH nickname (when the account has several)
-	ForceStationCallsign string     `json:"force_station_callsign"` // QRZ + LoTW: override STATION_CALLSIGN
-	TQSLPath             string     `json:"tqsl_path"`              // LoTW: path to tqsl.exe
-	StationLocation      string     `json:"station_location"`       // LoTW: TQSL Station Location name
-	KeyPassword          string     `json:"key_password"`           // LoTW: certificate private-key password (optional)
-	UploadFlags          []string   `json:"upload_flags"`           // LoTW: set of lotw_sent values that mean "ready to upload" — any of "N"/"R"
-	WriteLog             bool       `json:"write_log"`              // LoTW: pass -t to write a TQSL diagnostic log
-	AutoUpload           bool       `json:"auto_upload"`
-	UploadMode           UploadMode `json:"upload_mode"`
+	APIKey               string   `json:"api_key"`
+	URL                  string   `json:"url"`                    // Cloudlog/Wavelog: base URL of the user's own instance
+	StationID            string   `json:"station_id"`             // Cloudlog/Wavelog: station profile (location) id
+	Email                string   `json:"email"`                  // Club Log account email
+	Username             string   `json:"username"`               // LoTW website login (for confirmation download)
+	Password             string   `json:"password"`               // Club Log account / LoTW website password
+	Callsign             string   `json:"callsign"`               // Club Log / HRDLog logbook (owner) callsign
+	Code                 string   `json:"code"`                   // HRDLog: account upload code
+	QTHNickname          string   `json:"qth_nickname"`           // eQSL: QTH nickname (when the account has several)
+	ForceStationCallsign string   `json:"force_station_callsign"` // QRZ + LoTW: override STATION_CALLSIGN
+	TQSLPath             string   `json:"tqsl_path"`              // LoTW: path to tqsl.exe
+	StationLocation      string   `json:"station_location"`       // LoTW: TQSL Station Location name
+	KeyPassword          string   `json:"key_password"`           // LoTW: certificate private-key password (optional)
+	UploadFlags          []string `json:"upload_flags"`           // LoTW: set of lotw_sent values that mean "ready to upload" — any of "N"/"R"
+	WriteLog             bool     `json:"write_log"`              // LoTW: pass -t to write a TQSL diagnostic log
+	AutoUpload           bool     `json:"auto_upload"`
+	// OnAir: HRDLog only — publish the live frequency, mode and rig on the site.
+	OnAir      bool       `json:"on_air"`
+	UploadMode UploadMode `json:"upload_mode"`
 }
 
 // normalised returns the config with whitespace trimmed and a valid upload
@@ -142,4 +144,10 @@ type UploadResult struct {
 	OK      bool   // the service accepted (or already had) the QSO
 	LogID   string // service-assigned record id, when provided
 	Message string // human-readable detail (reason on failure)
+	// Ignored is set when the service accepted the submission but left some or
+	// all of the QSOs out of it. TQSL does this for contacts already uploaded
+	// AND for contacts outside the certificate's date range, and reports both
+	// with the same exit code — so the caller must show the message rather than
+	// decide on its own that everything went through.
+	Ignored bool
 }

internal/extsvc/hrdlog.go

@@ -6,6 +6,7 @@ import (
 	"io"
 	"net/http"
 	"net/url"
+	"strconv"
 	"strings"
 	"time"
 )
@@ -143,3 +144,59 @@ func TestHRDLog(ctx context.Context, client *http.Client, cfg ServiceConfig) (st
 	}
 	return fmt.Sprintf("Credentials accepted — %s", callsign), nil
 }
+
+// hrdlogOnAirURL is HRDLog's live-status endpoint — what puts "F4BPO is on air
+// 14,074,000 FM IC-7300" on the site's front page.
+//
+// Endpoint and field names taken from HRDLog's own library (github.com/iw1qlh/
+// HRDLOG-net-library, HrdProtocol.SendOnAirAsync), not from guesswork: it posts
+// Frequency in Hz, Mode, Radio, Callsign, Code and App.
+//
+// HTTPS where that library uses plain HTTP. The upload code is a credential and
+// has no business crossing the network in clear; the sibling NewEntry endpoint
+// on the same host already serves TLS.
+const hrdlogOnAirURL = "https://robot.hrdlog.net/OnAir.aspx"
+
+// SendHRDLogOnAir publishes the current frequency, mode and rig.
+//
+// Deliberately fire-and-forget in spirit: it is a status broadcast, so a
+// failure is logged and never surfaced as an error the operator must clear —
+// but the message is returned so the caller can log WHAT the site said rather
+// than only that something went wrong.
+func SendHRDLogOnAir(ctx context.Context, client *http.Client, callsign, code string, freqHz int64, mode, radio string) (string, error) {
+	callsign = strings.ToUpper(strings.TrimSpace(callsign))
+	code = strings.TrimSpace(code)
+	if callsign == "" || code == "" {
+		return "", fmt.Errorf("hrdlog: callsign and upload code required")
+	}
+	if freqHz <= 0 {
+		return "", fmt.Errorf("hrdlog: no frequency to announce")
+	}
+	form := url.Values{}
+	form.Set("Callsign", callsign)
+	form.Set("Code", code)
+	form.Set("App", hrdlogApp)
+	form.Set("Frequency", strconv.FormatInt(freqHz, 10))
+	form.Set("Mode", strings.TrimSpace(mode))
+	form.Set("Radio", strings.TrimSpace(radio))
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, hrdlogOnAirURL, strings.NewReader(form.Encode()))
+	if err != nil {
+		return "", fmt.Errorf("hrdlog on-air: build request: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	if client == nil {
+		client = &http.Client{Timeout: 15 * time.Second}
+	}
+	resp, err := client.Do(req)
+	if err != nil {
+		return "", fmt.Errorf("hrdlog on-air: %w", err)
+	}
+	defer resp.Body.Close()
+	body, _ := io.ReadAll(io.LimitReader(resp.Body, 32*1024))
+	msg := strings.TrimSpace(string(body))
+	if resp.StatusCode != http.StatusOK {
+		return msg, fmt.Errorf("hrdlog on-air: http %d", resp.StatusCode)
+	}
+	return msg, nil
+}

internal/extsvc/lotw.go

@@ -178,8 +178,12 @@ func fileExists(p string) bool {
 //
 //	tqsl -d -x -a all -l "<location>" -u [-p <keypass>] <file.adi>
 //
-// Exit codes (TQSL): 0 = uploaded; 8 = nothing new (all duplicates/out of
-// range); 9 = some uploaded, some skipped; anything else = failure.
+// Exit codes are TQSL's own (see the table in its cmdline help). 8 and 9 are
+// the ones that matter and both used to be read as plain success: 8 means NO
+// QSOs were processed and 9 means some were left out — in each case because
+// they were already uploaded OR outside the callsign certificate's date range.
+// Reporting either as success is how a contact came to be stamped "uploaded"
+// while LoTW had never seen it.
 func UploadLoTW(ctx context.Context, cfg ServiceConfig, tempDir, adifRecord string) (UploadResult, error) {
 	tqsl := strings.TrimSpace(cfg.TQSLPath)
 	loc := strings.TrimSpace(cfg.StationLocation)
@@ -249,11 +253,31 @@ func UploadLoTW(ctx context.Context, cfg ServiceConfig, tempDir, adifRecord stri
 		}
 	}
 
+	// TQSL's exit codes, from its own cmdline documentation. Two of them used to
+	// be read as plain success, and that is how contacts came to be stamped
+	// "uploaded" while LoTW had never seen them:
+	//
+	//	8  NO QSOs were processed — already uploaded OR OUT OF DATE RANGE
+	//	9  some processed, some ignored — same two reasons
+	//	14 some already uploaded, the rest signed
+	//
+	// "Out of date range" is the one that bites: a contact older than the
+	// callsign certificate's validity is silently left out, and reporting that as
+	// success stamped it sent for ever. TQSL says which case it is in its output,
+	// so the message is carried up rather than replaced with a guess.
 	switch code {
-	case 0, 9:
+	case 0:
 		return UploadResult{OK: true, Message: "uploaded to LoTW"}, nil
+	case 9, 14:
+		return UploadResult{OK: true, Ignored: true, Message: tqslDetail(msg,
+			"uploaded — but TQSL left some contacts out (already uploaded, or outside the certificate's date range)")}, nil
 	case 8:
-		return UploadResult{OK: true, Message: "already uploaded (duplicate)"}, nil
+		// Nothing reached LoTW. NOT stamped as sent: a duplicate left at "R" is
+		// harmless and will be refused again, while a contact wrongly marked sent
+		// is one the operator will never think to look at again.
+		return UploadResult{OK: false, Ignored: true, Message: tqslDetail(msg,
+				"TQSL uploaded nothing — every contact was already uploaded, or outside the certificate's date range")},
+			fmt.Errorf("lotw: no QSOs processed")
 	default:
 		if msg == "" {
 			msg = fmt.Sprintf("tqsl exit code %d", code)
@@ -262,6 +286,29 @@ func UploadLoTW(ctx context.Context, cfg ServiceConfig, tempDir, adifRecord stri
 	}
 }
 
+// tqslDetail keeps the lines of TQSL's own output that say what happened to the
+// contacts, and appends the summary.
+//
+// TQSL is explicit — "414 QSO records were already uploaded", "N QSO records
+// are out of date range" — and that sentence is the whole answer to "why is my
+// contact not on LoTW". It used to be captured and thrown away.
+func tqslDetail(out, summary string) string {
+	var keep []string
+	for _, ln := range strings.Split(out, "\n") {
+		ln = strings.TrimSpace(ln)
+		l := strings.ToLower(ln)
+		if strings.Contains(l, "qso") && (strings.Contains(l, "already uploaded") ||
+			strings.Contains(l, "date range") || strings.Contains(l, "ignored") ||
+			strings.Contains(l, "duplicate")) {
+			keep = append(keep, ln)
+		}
+	}
+	if len(keep) == 0 {
+		return summary
+	}
+	return summary + " — " + strings.Join(keep, "; ")
+}
+
 // TestLoTW validates the LoTW config: tqsl present and the chosen station
 // location exists in station_data.
 func TestLoTW(cfg ServiceConfig, stationDataPath string) (string, error) {

internal/extsvc/lotw_exit_test.go

@@ -0,0 +1,44 @@
+package extsvc
+
+import "testing"
+
+// TQSL's own exit codes, from its cmdline documentation:
+//
+//	0  success
+//	8  NO QSOs were processed — already uploaded OR out of date range
+//	9  some processed, some ignored — same two reasons
+//	14 some already uploaded, the rest signed
+//
+// 8 and 9 both used to be read as plain success, and that is how a contact came
+// to be stamped "uploaded to LoTW" while LoTW had never seen it. The one that
+// bites is "out of date range": a contact older than the callsign certificate's
+// validity is silently left out of the submission.
+func TestTQSLDetailKeepsTheReason(t *testing.T) {
+	out := `13:22:01: Signing using Callsign G0ABC, DXCC Entity ENGLAND
+13:22:02: /tmp/x.adi: 20 QSO records are out of date range
+13:22:02: Final Status: No QSOs were processed (8)`
+	got := tqslDetail(out, "summary")
+	if got == "summary" {
+		t.Fatal("threw away TQSL's explanation — that sentence is the whole answer to \"why is my contact not on LoTW\"")
+	}
+	if !contains(got, "out of date range") {
+		t.Errorf("the reason was lost: %q", got)
+	}
+}
+
+func TestTQSLDetailFallsBackToTheSummary(t *testing.T) {
+	if got := tqslDetail("nothing useful here", "summary"); got != "summary" {
+		t.Errorf("got %q, want the plain summary when TQSL said nothing specific", got)
+	}
+}
+
+func contains(h, n string) bool {
+	return len(h) >= len(n) && (func() bool {
+		for i := 0; i+len(n) <= len(h); i++ {
+			if h[i:i+len(n)] == n {
+				return true
+			}
+		}
+		return false
+	})()
+}

internal/geo/geo.go

@@ -0,0 +1,120 @@
+// Package geo is the one place that turns Maidenhead locators into positions,
+// and positions into distances and bearings.
+//
+// It exists because there were about to be three copies. These functions lived
+// in package main, which the internal packages cannot import, so the PSK
+// Reporter watcher had its geometry injected from main and the web publisher
+// was about to grow its own. A bearing that disagrees with itself between two
+// panels is the kind of fault nobody reports, because each screen looks
+// plausible on its own.
+package geo
+
+import (
+	"math"
+	"strings"
+)
+
+// GridToLatLon parses a Maidenhead locator (4 or 6 characters) and returns the
+// centre of that square in degrees. ok=false on malformed input.
+func GridToLatLon(grid string) (lat, lon float64, ok bool) {
+	g := strings.ToUpper(strings.TrimSpace(grid))
+	if len(g) < 4 {
+		return 0, 0, false
+	}
+	A := g[0] - 'A'
+	B := g[1] - 'A'
+	C := g[2] - '0'
+	D := g[3] - '0'
+	if A > 17 || B > 17 || C > 9 || D > 9 {
+		return 0, 0, false
+	}
+	lon = -180 + float64(A)*20 + float64(C)*2
+	lat = -90 + float64(B)*10 + float64(D)*1
+	if len(g) >= 6 {
+		E := g[4] - 'A'
+		F := g[5] - 'A'
+		if E <= 23 && F <= 23 {
+			lon += float64(E)*(5.0/60.0) + 2.5/60.0
+			lat += float64(F)*(2.5/60.0) + 1.25/60.0
+			return lat, lon, true
+		}
+	}
+	// 4-character locator: aim at the centre of the square.
+	lon += 1
+	lat += 0.5
+	return lat, lon, true
+}
+
+// HaversineKm returns the great-circle distance between two positions in
+// kilometres. Mean Earth radius 6371 km.
+func HaversineKm(lat1, lon1, lat2, lon2 float64) float64 {
+	const R = 6371.0
+	rad := math.Pi / 180.0
+	dLat := (lat2 - lat1) * rad
+	dLon := (lon2 - lon1) * rad
+	a := math.Sin(dLat/2)*math.Sin(dLat/2) +
+		math.Cos(lat1*rad)*math.Cos(lat2*rad)*math.Sin(dLon/2)*math.Sin(dLon/2)
+	return R * 2 * math.Atan2(math.Sqrt(a), math.Sqrt(1-a))
+}
+
+// DistanceBetweenGrids is the distance in kilometres between two locators,
+// ok=false when either cannot be parsed.
+func DistanceBetweenGrids(a, b string) (km float64, ok bool) {
+	lat1, lon1, ok1 := GridToLatLon(a)
+	lat2, lon2, ok2 := GridToLatLon(b)
+	if !ok1 || !ok2 {
+		return 0, false
+	}
+	return HaversineKm(lat1, lon1, lat2, lon2), true
+}
+
+// LatLonToGrid returns the 4-character Maidenhead square for a position.
+func LatLonToGrid(lat, lon float64) string {
+	lon = math.Mod(lon+180, 360)
+	if lon < 0 {
+		lon += 360
+	}
+	lat = lat + 90
+	if lat < 0 {
+		lat = 0
+	} else if lat > 180 {
+		lat = 180
+	}
+	return string([]byte{
+		byte('A' + int(lon/20)),
+		byte('A' + int(lat/10)),
+		byte('0' + int(math.Mod(lon, 20)/2)),
+		byte('0' + int(math.Mod(lat, 10)/1)),
+	})
+}
+
+// NeighbourGrids returns the square holding (lat, lon) and the ring of squares
+// around it — 9 squares for ring 1, 25 for ring 2.
+//
+// Used to filter the PSK Reporter feed at the BROKER rather than in OpsLog. A
+// square is about 111 km tall and 150 km wide at mid latitudes, so one ring is
+// roughly the 300 km "around here" the feed already meant, and the traffic that
+// used to be received and discarded is never sent.
+func NeighbourGrids(lat, lon float64, ring int) []string {
+	if ring < 0 {
+		ring = 0
+	}
+	seen := map[string]bool{}
+	out := []string{}
+	for dLat := -ring; dLat <= ring; dLat++ {
+		for dLon := -ring; dLon <= ring; dLon++ {
+			// One square step: 1° of latitude, 2° of longitude.
+			la := lat + float64(dLat)
+			lo := lon + float64(dLon)*2
+			if la > 90 || la < -90 {
+				continue // past a pole there is no square, not a wrapped one
+			}
+			g := LatLonToGrid(la, lo)
+			if !seen[g] {
+				seen[g] = true
+				out = append(out, g)
+			}
+		}
+	}
+	return out
+}

internal/geo/neighbour_test.go

@@ -0,0 +1,49 @@
+package geo
+
+import "testing"
+
+// The squares the PSK Reporter feed is filtered on. A wrong ring means either
+// receiving the world again or hearing nothing.
+func TestNeighbourGrids(t *testing.T) {
+	// JN36 is around 46.5N 5.5E.
+	lat, lon, ok := GridToLatLon("JN36")
+	if !ok {
+		t.Fatal("JN36 did not resolve")
+	}
+	if got := LatLonToGrid(lat, lon); got != "JN36" {
+		t.Fatalf("round trip gave %q, want JN36", got)
+	}
+
+	ring := NeighbourGrids(lat, lon, 1)
+	if len(ring) != 9 {
+		t.Errorf("ring 1 has %d squares, want 9: %v", len(ring), ring)
+	}
+	found := false
+	for _, g := range ring {
+		if g == "JN36" {
+			found = true
+		}
+		if len(g) != 4 {
+			t.Errorf("not a 4-character square: %q", g)
+		}
+	}
+	if !found {
+		t.Errorf("the operator's own square is missing from %v", ring)
+	}
+	if n := len(NeighbourGrids(lat, lon, 0)); n != 1 {
+		t.Errorf("ring 0 has %d squares, want just the operator's", n)
+	}
+	if n := len(NeighbourGrids(lat, lon, 2)); n != 25 {
+		t.Errorf("ring 2 has %d squares, want 25", n)
+	}
+}
+
+// Near a pole a step north has nowhere to go; it must be dropped, not wrapped
+// onto a square on the far side of the world.
+func TestNeighbourGridsNearThePole(t *testing.T) {
+	for _, g := range NeighbourGrids(89.5, 25, 1) {
+		if len(g) != 4 {
+			t.Errorf("bad square near the pole: %q", g)
+		}
+	}
+}

internal/gridcache/gridcache.go

@@ -0,0 +1,226 @@
+// Package gridcache is the long-term callsign→grid store behind grid chasing.
+//
+// Its own SQLite file, not a table in the settings database: that one sits
+// wherever the operator put it, often a synchronised folder, and this rewrites
+// itself every minute. Deleting the file costs a few days of listening.
+//
+// A callsign has one grid and the newest report wins — a stale locator reads as
+// a square already worked, which is worse than none.
+package gridcache
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"strings"
+	"sync"
+	"time"
+
+	_ "modernc.org/sqlite"
+)
+
+// Retention bounds a store that would otherwise only ever grow. Two years is
+// chosen to be far longer than any propagation interest and short enough that a
+// reassigned callsign eventually stops carrying its previous holder's square —
+// the one way this cache can be actively wrong rather than merely empty.
+const Retention = 2 * 365 * 24 * time.Hour
+
+// FlushEvery is the batch interval. Long enough that a burst of reports costs
+// one transaction, short enough that a crash loses a minute of learning.
+const FlushEvery = 60 * time.Second
+
+// Sources a locator can come from.
+const (
+	SourceDecode = "decode" // a CQ this station's own receiver decoded
+	SourceMQTT   = "mqtt"   // a PSK Reporter report
+)
+
+// Entry is one locator and where it came from.
+type Entry struct {
+	Grid   string
+	Source string
+}
+
+type Store struct {
+	db *sql.DB
+
+	mu    sync.Mutex
+	dirty map[string]Entry // call → what to write
+
+	stop     chan struct{}
+	stopOnce sync.Once
+	wg       sync.WaitGroup
+
+	logf func(string, ...any)
+}
+
+// Open creates or opens the store at path and prunes what has aged out.
+func Open(path string, logf func(string, ...any)) (*Store, error) {
+	if logf == nil {
+		logf = func(string, ...any) {}
+	}
+	// WAL so a flush never blocks a read, and a busy timeout because the flush
+	// goroutine and the startup load can overlap on a slow disk.
+	db, err := sql.Open("sqlite", path+"?_pragma=journal_mode(WAL)&_pragma=busy_timeout(5000)")
+	if err != nil {
+		return nil, fmt.Errorf("gridcache: open %s: %w", path, err)
+	}
+	if _, err := db.Exec("CREATE TABLE IF NOT EXISTS grids (" +
+		"call TEXT PRIMARY KEY, grid TEXT NOT NULL, updated_at INTEGER NOT NULL, " +
+		"source TEXT NOT NULL DEFAULT '')"); err != nil {
+		db.Close()
+		return nil, fmt.Errorf("gridcache: schema: %w", err)
+	}
+	// A file written before the column existed keeps its rows; this fails
+	// harmlessly when the column is already there.
+	db.Exec("ALTER TABLE grids ADD COLUMN source TEXT NOT NULL DEFAULT ''")
+	s := &Store{db: db, dirty: map[string]Entry{}, stop: make(chan struct{}), logf: logf}
+	if n, err := s.prune(); err != nil {
+		s.logf("gridcache: prune failed: %v", err)
+	} else if n > 0 {
+		s.logf("gridcache: pruned %d locators not heard in %d days", n, int(Retention.Hours()/24))
+	}
+	return s, nil
+}
+
+func (s *Store) prune() (int64, error) {
+	cut := time.Now().Add(-Retention).Unix()
+	res, err := s.db.Exec(`DELETE FROM grids WHERE updated_at < ?`, cut)
+	if err != nil {
+		return 0, err
+	}
+	return res.RowsAffected()
+}
+
+// LoadAll returns every stored locator, for seeding the in-memory map at
+// startup. One query and one map build — the point of the whole package is that
+// nothing afterwards has to ask the database anything.
+func (s *Store) LoadAll() (map[string]string, error) {
+	rows, err := s.db.Query(`SELECT call, grid FROM grids`)
+	if err != nil {
+		return nil, fmt.Errorf("gridcache: load: %w", err)
+	}
+	defer rows.Close()
+	out := make(map[string]string, 4096)
+	for rows.Next() {
+		var call, grid string
+		if err := rows.Scan(&call, &grid); err != nil {
+			return nil, err
+		}
+		out[call] = grid
+	}
+	return out, rows.Err()
+}
+
+// Put queues a locator for writing. Callers pass only what CHANGED — an
+// unchanged report is the common case by a wide margin and must not reach here,
+// or the batch would carry the whole feed instead of the news in it.
+func (s *Store) Put(call, grid, source string) {
+	call = strings.ToUpper(strings.TrimSpace(call))
+	grid = strings.TrimSpace(grid)
+	if call == "" || grid == "" {
+		return
+	}
+	s.mu.Lock()
+	s.dirty[call] = Entry{Grid: grid, Source: source}
+	s.mu.Unlock()
+}
+
+// Start runs the flush loop until Close.
+func (s *Store) Start(ctx context.Context) {
+	s.wg.Add(1)
+	go func() {
+		defer s.wg.Done()
+		t := time.NewTicker(FlushEvery)
+		defer t.Stop()
+		for {
+			select {
+			case <-s.stop:
+				return
+			case <-ctx.Done():
+				return
+			case <-t.C:
+				if err := s.Flush(); err != nil {
+					s.logf("gridcache: flush failed: %v", err)
+				}
+			}
+		}
+	}()
+}
+
+// Flush writes the pending batch in one transaction. Safe to call with nothing
+// pending, which is most of the time on a quiet band.
+func (s *Store) Flush() error {
+	s.mu.Lock()
+	if len(s.dirty) == 0 {
+		s.mu.Unlock()
+		return nil
+	}
+	batch := s.dirty
+	s.dirty = map[string]Entry{}
+	s.mu.Unlock()
+
+	tx, err := s.db.Begin()
+	if err != nil {
+		s.requeue(batch)
+		return err
+	}
+	st, err := tx.Prepare(`INSERT INTO grids (call, grid, updated_at, source) VALUES (?, ?, ?, ?)
+		ON CONFLICT(call) DO UPDATE SET grid = excluded.grid, updated_at = excluded.updated_at,
+		source = excluded.source`)
+	if err != nil {
+		tx.Rollback()
+		s.requeue(batch)
+		return err
+	}
+	defer st.Close()
+	now := time.Now().Unix()
+	for call, e := range batch {
+		if _, err := st.Exec(call, e.Grid, now, e.Source); err != nil {
+			tx.Rollback()
+			s.requeue(batch)
+			return err
+		}
+	}
+	if err := tx.Commit(); err != nil {
+		s.requeue(batch)
+		return err
+	}
+	// Logged because a batch that never reaches the disk looks exactly like one
+	// that does: the locators are in memory either way until the next restart,
+	// which is the one moment the difference shows.
+	s.logf("gridcache: wrote %d locators", len(batch))
+	return nil
+}
+
+// requeue puts a failed batch back, without overwriting anything learnt while it
+// was in flight — the newer value is the right one.
+func (s *Store) requeue(batch map[string]Entry) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	for call, e := range batch {
+		if _, newer := s.dirty[call]; !newer {
+			s.dirty[call] = e
+		}
+	}
+}
+
+// Pending reports how many locators are waiting to be written.
+func (s *Store) Pending() int {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	return len(s.dirty)
+}
+
+// Close stops the loop and writes whatever is pending. A restart is the moment
+// the cache is most valuable, so losing the last minute of learning to a clean
+// shutdown would be a poor trade.
+func (s *Store) Close() error {
+	s.stopOnce.Do(func() { close(s.stop) })
+	s.wg.Wait()
+	err := s.Flush()
+	if cerr := s.db.Close(); err == nil {
+		err = cerr
+	}
+	return err
+}

internal/gridcache/gridcache_test.go

@@ -0,0 +1,153 @@
+package gridcache
+
+import (
+	"path/filepath"
+	"testing"
+	"time"
+)
+
+func open(t *testing.T) (*Store, string) {
+	t.Helper()
+	path := filepath.Join(t.TempDir(), "grids.db")
+	s, err := Open(path, nil)
+	if err != nil {
+		t.Fatalf("open: %v", err)
+	}
+	return s, path
+}
+
+// The whole reason the store exists: what was learnt is still there after a
+// restart, so the cluster's locator column is full in the first second instead
+// of after an hour of listening.
+func TestSurvivesRestart(t *testing.T) {
+	s, path := open(t)
+	s.Put("F4BPO", "JN36", SourceDecode)
+	s.Put("OH5CX", "KP30", SourceDecode)
+	if err := s.Flush(); err != nil {
+		t.Fatalf("flush: %v", err)
+	}
+	if err := s.Close(); err != nil {
+		t.Fatalf("close: %v", err)
+	}
+
+	again, err := Open(path, nil)
+	if err != nil {
+		t.Fatalf("reopen: %v", err)
+	}
+	defer again.Close()
+	got, err := again.LoadAll()
+	if err != nil {
+		t.Fatalf("load: %v", err)
+	}
+	if got["F4BPO"] != "JN36" || got["OH5CX"] != "KP30" {
+		t.Errorf("locators lost across a restart: %v", got)
+	}
+}
+
+// A callsign has ONE grid and the newest report wins. Operators move, go
+// portable, go on expedition — and a stale locator is worse than none for grid
+// chasing, because it reads as a square already worked.
+func TestNewestReportWins(t *testing.T) {
+	s, _ := open(t)
+	defer s.Close()
+
+	s.Put("F4BPO", "JN36", SourceDecode)
+	if err := s.Flush(); err != nil {
+		t.Fatal(err)
+	}
+	s.Put("F4BPO", "KP30", SourceDecode) // moved
+	if err := s.Flush(); err != nil {
+		t.Fatal(err)
+	}
+
+	got, err := s.LoadAll()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got["F4BPO"] != "KP30" {
+		t.Errorf("grid = %q, want the newer KP30", got["F4BPO"])
+	}
+	if len(got) != 1 {
+		t.Errorf("a callsign must hold one row, got %d: %v", len(got), got)
+	}
+}
+
+// Nothing reaches the disk until a flush, and a flush with nothing pending is
+// not an error — that is most minutes on a quiet band.
+func TestBatching(t *testing.T) {
+	s, _ := open(t)
+	defer s.Close()
+
+	for _, c := range []string{"A1AA", "B2BB", "C3CC"} {
+		s.Put(c, "JN36", SourceDecode)
+	}
+	if n := s.Pending(); n != 3 {
+		t.Errorf("pending = %d, want 3 queued and unwritten", n)
+	}
+	if got, _ := s.LoadAll(); len(got) != 0 {
+		t.Errorf("wrote before the flush: %v", got)
+	}
+	if err := s.Flush(); err != nil {
+		t.Fatal(err)
+	}
+	if n := s.Pending(); n != 0 {
+		t.Errorf("pending = %d after a flush, want 0", n)
+	}
+	if got, _ := s.LoadAll(); len(got) != 3 {
+		t.Errorf("flush wrote %d rows, want 3", len(got))
+	}
+	if err := s.Flush(); err != nil {
+		t.Errorf("empty flush must be a no-op, got %v", err)
+	}
+}
+
+// Age is what bounds a store that would otherwise only grow. A callsign not
+// heard in two years is likely reassigned, and carrying its previous holder's
+// square is the one way this cache can be actively wrong rather than empty.
+func TestPruneOnOpen(t *testing.T) {
+	s, path := open(t)
+	s.Put("FRESH", "JN36", SourceDecode)
+	s.Put("STALE", "IO91", SourceDecode)
+	if err := s.Flush(); err != nil {
+		t.Fatal(err)
+	}
+	// Backdate one row past the retention window.
+	old := time.Now().Add(-Retention - 24*time.Hour).Unix()
+	if _, err := s.db.Exec(`UPDATE grids SET updated_at = ? WHERE call = 'STALE'`, old); err != nil {
+		t.Fatal(err)
+	}
+	s.Close()
+
+	again, err := Open(path, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer again.Close()
+	got, _ := again.LoadAll()
+	if _, ok := got["STALE"]; ok {
+		t.Error("an entry past the retention window survived — the store is unbounded")
+	}
+	if got["FRESH"] != "JN36" {
+		t.Error("pruning took a live entry with it")
+	}
+}
+
+// Close has to write what the last minute learnt: a restart is exactly when the
+// cache is worth the most, so losing it to a clean shutdown would be a poor
+// trade.
+func TestCloseFlushes(t *testing.T) {
+	s, path := open(t)
+	s.Put("LATE", "JN36", SourceDecode)
+	if err := s.Close(); err != nil {
+		t.Fatalf("close: %v", err)
+	}
+	again, err := Open(path, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer again.Close()
+	got, _ := again.LoadAll()
+	if got["LATE"] != "JN36" {
+		t.Error("what was pending at shutdown was dropped")
+	}
+}

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)
-			VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+			    multicast, multicast_group, destination_ip, enabled, sort_order,
+			    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/lookup/hamqth.go

@@ -94,6 +94,13 @@ func (h *HamQTH) fetch(ctx context.Context, sessionID, callsign string) (Result,
 	if err != nil {
 		return Result{}, err
 	}
+	return parseHamQTHSearch(body)
+}
+
+// parseHamQTHSearch turns one answer into a Result. Split out from the request
+// so the field mapping can be checked against a captured payload — which is how
+// the missing full name and picture were found.
+func parseHamQTHSearch(body []byte) (Result, error) {
 	var resp hamqthRoot
 	if err := xml.Unmarshal(body, &resp); err != nil {
 		return Result{}, fmt.Errorf("hamqth: parse callsign: %w", err)
@@ -112,11 +119,20 @@ func (h *HamQTH) fetch(ctx context.Context, sessionID, callsign string) (Result,
 	if s.Callsign == "" {
 		return Result{}, ErrNotFound
 	}
+	// <nick> is the name the operator goes BY on the air, which is what belongs
+	// in a log — "Igor", not "Igor Vladimirovich Getman". adr_name is the postal
+	// name and is used only when there is nothing else, so a record carrying
+	// neither nick nor name no longer resolves to blank.
+	name := strings.TrimSpace(s.Nick + " " + s.LastName)
+	if name == "" {
+		name = strings.TrimSpace(s.AdrName)
+	}
 	r := Result{
 		Callsign:  strings.ToUpper(s.Callsign),
-		Name:      strings.TrimSpace(s.Nick + " " + s.LastName),
+		Name:      name,
 		QTH:       firstNonEmpty(s.QTH, s.AdrCity),
 		Address:   s.AdrStreet1,
+		Zip:       s.AdrZip,
 		State:     strings.ToUpper(s.USState),
 		County:    s.USCounty,
 		Country:   firstNonEmpty(s.AdrCountry, s.Country),
@@ -124,6 +140,8 @@ func (h *HamQTH) fetch(ctx context.Context, sessionID, callsign string) (Result,
 		Continent: strings.ToUpper(s.Continent),
 		Email:     s.Email,
 		QSLVia:    s.QSLVia,
+		Web:       s.Web,
+		ImageURL:  s.Picture,
 	}
 	r.Lat, _ = strconv.ParseFloat(s.Latitude, 64)
 	r.Lon, _ = strconv.ParseFloat(s.Longitude, 64)
@@ -182,4 +200,14 @@ type hamqthSearch struct {
 	Continent  string `xml:"continent"`
 	Email      string `xml:"email"`
 	QSLVia     string `xml:"qsl_via"`
+	// AdrName is the full postal name. Many records carry it and no <name> at
+	// all, so building the name from <nick> + <name> silently kept the first
+	// name and dropped the rest.
+	AdrName string `xml:"adr_name"`
+	AdrZip  string `xml:"adr_zip"`
+	// Picture is HamQTH's profile photo. Result.ImageURL was documented as "QRZ
+	// only" because this element was never read — QRZ calls the same thing
+	// <image>.
+	Picture string `xml:"picture"`
+	Web     string `xml:"web"`
 }

internal/lookup/hamqth_fields_test.go

@@ -0,0 +1,128 @@
+package lookup
+
+import (
+	"encoding/xml"
+	"testing"
+)
+
+// A real HamQTH answer, captured from the live API.
+//
+// Two things it settles. The email IS returned and must reach the QSO. And the
+// element names are not the ones a reading of the documentation suggests:
+// there is no <name> here at all, the full name is <adr_name>, and the picture
+// is <picture> where QRZ calls it <image>. The stray <div> is an advert the
+// server injects into its own XML; the parser has to shrug it off.
+const hamqthEU1EU = `<?xml version="1.0"?>
+<HamQTH xmlns="https://www.hamqth.com" version="2.8">
+<div id="in-page-channel-node-id" data-channel-name="in_page_channel_Sux7_K"/>
+<search>
+<callsign>eu1eu</callsign>
+<nick>Igor</nick>
+<qth>Minsk-5</qth>
+<country>Belarus</country>
+<adif>27</adif>
+<itu>29</itu>
+<cq>16</cq>
+<grid>KO33SV</grid>
+<adr_name>Igor Vladimirovich Getman</adr_name>
+<adr_street1>A/ya 143</adr_street1>
+<adr_city>Minsk-5</adr_city>
+<adr_zip>220005</adr_zip>
+<adr_country>Belarus</adr_country>
+<adr_adif>27</adr_adif>
+<district>WAARB-LE</district>
+<lotw>?</lotw>
+<qsldirect>?</qsldirect>
+<qsl>?</qsl>
+<eqsl>Y</eqsl>
+<email>eu1eu@mail.ru</email>
+<latitude>53.88999938964844</latitude>
+<longitude>27.59000015258789</longitude>
+<continent>EU</continent>
+<utc_offset>-2</utc_offset>
+<picture>https://www.hamqth.com/images/default/ts-930_qith_old_radios.jpg</picture>
+</search>
+</HamQTH>`
+
+func TestHamQTHParsesEveryUsefulField(t *testing.T) {
+	var root hamqthRoot
+	if err := xml.Unmarshal([]byte(hamqthEU1EU), &root); err != nil {
+		t.Fatalf("parse: %v", err)
+	}
+	s := root.Search
+
+	for _, c := range []struct{ name, got, want string }{
+		{"callsign", s.Callsign, "eu1eu"},
+		{"email", s.Email, "[email protected]"},
+		{"grid", s.Grid, "KO33SV"},
+		{"qth", s.QTH, "Minsk-5"},
+		{"street", s.AdrStreet1, "A/ya 143"},
+		{"city", s.AdrCity, "Minsk-5"},
+		{"country", s.AdrCountry, "Belarus"},
+		{"continent", s.Continent, "EU"},
+		{"dxcc", s.DXCC, "27"},
+		{"cq", s.CQ, "16"},
+		{"itu", s.ITU, "29"},
+	} {
+		if c.got != c.want {
+			t.Errorf("%s = %q, want %q", c.name, c.got, c.want)
+		}
+	}
+}
+
+// The fields the parser was blind to. Each is data OpsLog has somewhere to put.
+func TestHamQTHParsesTheFieldsThatWereMissing(t *testing.T) {
+	var root hamqthRoot
+	if err := xml.Unmarshal([]byte(hamqthEU1EU), &root); err != nil {
+		t.Fatalf("parse: %v", err)
+	}
+	s := root.Search
+
+	// The postal name, the fallback when a record carries no nick and no name.
+	if s.AdrName != "Igor Vladimirovich Getman" {
+		t.Errorf("adr_name = %q", s.AdrName)
+	}
+	if s.LastName != "" {
+		t.Errorf("this record has no <name>; got %q", s.LastName)
+	}
+	// The profile picture. Result.ImageURL existed and said "QRZ only" — HamQTH
+	// sends one too, under a different element name.
+	if s.Picture == "" {
+		t.Error("picture not parsed")
+	}
+	if s.AdrZip != "220005" {
+		t.Errorf("adr_zip = %q", s.AdrZip)
+	}
+}
+
+// End to end: what the provider hands back must carry the email, the full name
+// and the picture.
+func TestHamQTHResultCarriesTheLot(t *testing.T) {
+	r, err := parseHamQTHSearch([]byte(hamqthEU1EU))
+	if err != nil {
+		t.Fatalf("parse: %v", err)
+	}
+	if r.Email != "[email protected]" {
+		t.Errorf("Email = %q — this is what was reported missing", r.Email)
+	}
+	// The nick, not the postal name: a log wants the name the operator goes by
+	// on the air. adr_name is only the fallback when there is nothing else.
+	if r.Name != "Igor" {
+		t.Errorf("Name = %q, want the on-air nick", r.Name)
+	}
+	if r.ImageURL == "" {
+		t.Error("ImageURL empty — HamQTH sent a picture")
+	}
+	if r.Grid != "KO33SV" {
+		t.Errorf("Grid = %q", r.Grid)
+	}
+	if r.Lat < 53.8 || r.Lat > 53.9 {
+		t.Errorf("Lat = %v", r.Lat)
+	}
+	if r.DXCC != 27 || r.CQZ != 16 || r.ITUZ != 29 {
+		t.Errorf("dxcc/cq/itu = %d/%d/%d", r.DXCC, r.CQZ, r.ITUZ)
+	}
+	if r.Address != "A/ya 143" {
+		t.Errorf("Address = %q", r.Address)
+	}
+}

internal/lookup/lookup.go

@@ -21,23 +21,29 @@ var ErrNotFound = errors.New("callsign not found")
 
 // Result is the normalized lookup output regardless of provider.
 type Result struct {
-	Callsign  string    `json:"callsign"`
-	Name      string    `json:"name,omitempty"`
-	QTH       string    `json:"qth,omitempty"`
-	Address   string    `json:"address,omitempty"`
-	State     string    `json:"state,omitempty"`
-	County    string    `json:"cnty,omitempty"`
-	Country   string    `json:"country,omitempty"`
-	Grid      string    `json:"grid,omitempty"`
-	Lat       float64   `json:"lat,omitempty"`
-	Lon       float64   `json:"lon,omitempty"`
-	DXCC      int       `json:"dxcc,omitempty"`
-	CQZ       int       `json:"cqz,omitempty"`
-	ITUZ      int       `json:"ituz,omitempty"`
-	Continent string    `json:"cont,omitempty"`
-	Email     string    `json:"email,omitempty"`
-	QSLVia    string    `json:"qsl_via,omitempty"`
-	ImageURL  string    `json:"image_url,omitempty"` // profile picture URL (QRZ only for now)
+	Callsign  string  `json:"callsign"`
+	Name      string  `json:"name,omitempty"`
+	QTH       string  `json:"qth,omitempty"`
+	Address   string  `json:"address,omitempty"`
+	State     string  `json:"state,omitempty"`
+	County    string  `json:"cnty,omitempty"`
+	Country   string  `json:"country,omitempty"`
+	Grid      string  `json:"grid,omitempty"`
+	Lat       float64 `json:"lat,omitempty"`
+	Lon       float64 `json:"lon,omitempty"`
+	DXCC      int     `json:"dxcc,omitempty"`
+	CQZ       int     `json:"cqz,omitempty"`
+	ITUZ      int     `json:"ituz,omitempty"`
+	Continent string  `json:"cont,omitempty"`
+	Email     string  `json:"email,omitempty"`
+	QSLVia    string  `json:"qsl_via,omitempty"`
+	// Web is the operator's own site. The QSO table has had a `web` column all
+	// along and nothing ever filled it, because no provider mapping read the
+	// field.
+	Web string `json:"web,omitempty"`
+	// Zip is the postal code. HamQTH and QRZ both send one.
+	Zip       string    `json:"zip,omitempty"`
+	ImageURL  string    `json:"image_url,omitempty"` // profile picture URL
 	Source    string    `json:"source"`              // "qrz", "hamqth", or "cache"
 	FetchedAt time.Time `json:"fetched_at"`
 }
@@ -176,12 +182,20 @@ func (m *Manager) Lookup(ctx context.Context, callsign string) (Result, error) {
 			r.Callsign = call
 			r.Source = p.Name()
 			r.FetchedAt = time.Now().UTC()
-			// The home record's location is the operator's HOME, not where they
-			// are portable now — clear it so cty.dat fills the real entity.
-			r.Country, r.Continent = "", ""
-			r.CQZ, r.ITUZ, r.DXCC = 0, 0, 0
-			r.Lat, r.Lon = 0, 0
-			r.Grid, r.State, r.County = "", "", ""
+			// The home record's location is the operator's HOME — clear it so
+			// cty.dat fills in where they actually are.
+			//
+			// UNLESS the suffix says nothing about location. /QRP is a statement
+			// about power, not about place: M0BFS/QRP is M0BFS, at home, running
+			// five watts. Wiping the grid there threw away the one field the
+			// operator was looking the call up for, and it came back empty while
+			// the same lookup without the suffix answered perfectly.
+			if !saysNothingAboutLocation(call) {
+				r.Country, r.Continent = "", ""
+				r.CQZ, r.ITUZ, r.DXCC = 0, 0, 0
+				r.Lat, r.Lon = 0, 0
+				r.Grid, r.State, r.County = "", "", ""
+			}
 			fillFromDXCC(&r, dxcc) // entity/zones/lat-lon from the FULL (slashed) call
 			normalizeNames(&r)
 			_ = m.cache.Put(ctx, r)
@@ -232,6 +246,33 @@ var LogSink = func(string, ...any) {}
 // right and must be looked up exactly as entered.
 var opSuffixes = map[string]bool{"M": true, "MM": true, "AM": true, "P": true, "QRP": true}
 
+// nonLocationSuffixes say nothing about WHERE the operator is.
+//
+// /QRP is a statement about power. /M and /P and their kin are not: mobile and
+// portable both mean "somewhere other than the home station", which is exactly
+// why the home record's location is discarded for them. Keeping that distinction
+// is the difference between a grid that is stale and a grid that is absent.
+var nonLocationSuffixes = map[string]bool{"QRP": true}
+
+// saysNothingAboutLocation reports a call whose every suffix leaves the operator
+// at their registered address — so the home record's location can be trusted.
+func saysNothingAboutLocation(call string) bool {
+	parts := strings.Split(strings.ToUpper(strings.TrimSpace(call)), "/")
+	if len(parts) < 2 {
+		return false
+	}
+	base := strings.TrimSpace(parts[0])
+	if len(base) < 3 || !strings.ContainsAny(base, "0123456789") {
+		return false // "JW/OR1A": the first part is a prefix — a location change
+	}
+	for _, p := range parts[1:] {
+		if !nonLocationSuffixes[strings.TrimSpace(p)] {
+			return false
+		}
+	}
+	return true
+}
+
 // stripOpSuffix returns the bare callsign when call carries nothing but
 // operational suffixes ("F4LYI/M" → "F4LYI", true). Reports false for anything
 // that changes entity or area ("JW/OR1A", "F4BPO/8"), and for a call whose base
@@ -411,12 +452,13 @@ func (c *Cache) Get(ctx context.Context, callsign string) (Result, bool) {
 	row := c.db.QueryRowContext(ctx, `
         SELECT callsign, name, qth, address, state, cnty, country, grid,
                lat, lon, dxcc, cqz, ituz, cont, email, qsl_via, image_url,
-               source, fetched_at
+               web, zip, source, fetched_at
         FROM callsign_cache WHERE callsign = ?`, callsign)
 	var (
 		r                                         Result
 		name, qth, addr, state, cnty              sql.NullString
 		country, grid, cont, email, qslVia, image sql.NullString
+		web, zip                                  sql.NullString
 		src                                       string
 		dxcc, cqz, ituz                           sql.NullInt64
 		lat, lon                                  sql.NullFloat64
@@ -424,7 +466,7 @@ func (c *Cache) Get(ctx context.Context, callsign string) (Result, bool) {
 	)
 	if err := row.Scan(&r.Callsign, &name, &qth, &addr, &state, &cnty,
 		&country, &grid, &lat, &lon,
-		&dxcc, &cqz, &ituz, &cont, &email, &qslVia, &image,
+		&dxcc, &cqz, &ituz, &cont, &email, &qslVia, &image, &web, &zip,
 		&src, &fetched); err != nil {
 		return Result{}, false
 	}
@@ -446,6 +488,8 @@ func (c *Cache) Get(ctx context.Context, callsign string) (Result, bool) {
 	r.Lon = lon.Float64
 	r.Continent = cont.String
 	r.Email = email.String
+	r.Web = web.String
+	r.Zip = zip.String
 	r.QSLVia = qslVia.String
 	r.ImageURL = image.String
 	r.DXCC = int(dxcc.Int64)
@@ -462,7 +506,7 @@ func (c *Cache) Put(ctx context.Context, r Result) error {
 	updateCols := []string{
 		"name", "qth", "address", "state", "cnty",
 		"country", "grid", "lat", "lon",
-		"dxcc", "cqz", "ituz", "cont", "email", "qsl_via", "image_url",
+		"dxcc", "cqz", "ituz", "cont", "email", "qsl_via", "image_url", "web", "zip",
 		"source", "fetched_at",
 	}
 	// The lookup cache always lives in the local SQLite database, so SQLite
@@ -475,8 +519,8 @@ func (c *Cache) Put(ctx context.Context, r Result) error {
         INSERT INTO callsign_cache(callsign, name, qth, address, state, cnty,
                                    country, grid, lat, lon,
                                    dxcc, cqz, ituz, cont, email, qsl_via, image_url,
-                                   source, fetched_at)
-        VALUES(?,?,?,?,?,?, ?,?,?,?, ?,?,?,?,?,?,?, ?,?)
+                                   web, zip, source, fetched_at)
+        VALUES(?,?,?,?,?,?, ?,?,?,?, ?,?,?,?,?,?,?, ?,?, ?,?)
         ON CONFLICT(callsign) DO UPDATE SET ` + strings.Join(sets, ", ")
 	_, err := c.db.ExecContext(ctx, q,
 		r.Callsign, nullable(r.Name), nullable(r.QTH), nullable(r.Address),
@@ -485,7 +529,7 @@ func (c *Cache) Put(ctx context.Context, r Result) error {
 		nullableFloat(r.Lat), nullableFloat(r.Lon),
 		nullableInt(r.DXCC), nullableInt(r.CQZ), nullableInt(r.ITUZ),
 		nullable(r.Continent), nullable(r.Email), nullable(r.QSLVia),
-		nullable(r.ImageURL),
+		nullable(r.ImageURL), nullable(r.Web), nullable(r.Zip),
 		r.Source, db.NowISO(),
 	)
 	return err

internal/lookup/normalize_test.go

@@ -4,14 +4,14 @@ import "testing"
 
 func TestTitleCase(t *testing.T) {
 	cases := map[string]string{
-		"NOEL CHENAVARD":     "Noel Chenavard",
-		"VETRAZ-MONTHOUX":    "Vetraz-Monthoux",
-		"o'brien":            "O'Brien",
+		"NOEL CHENAVARD":        "Noel Chenavard",
+		"VETRAZ-MONTHOUX":       "Vetraz-Monthoux",
+		"o'brien":               "O'Brien",
 		"866 ROUTE DES VOIRONS": "866 Route Des Voirons",
-		"PARIS":              "Paris",
-		"":                   "",
-		"  saint-étienne  ":  "Saint-Étienne",
-		"JOHN":               "John",
+		"PARIS":                 "Paris",
+		"":                      "",
+		"  saint-étienne  ":     "Saint-Étienne",
+		"JOHN":                  "John",
 	}
 	for in, want := range cases {
 		if got := titleCase(in); got != want {

internal/lookup/qrz.go

@@ -21,8 +21,14 @@ type QRZ struct {
 
 	HTTP *http.Client
 
-	mu      sync.Mutex
-	session string
+	// PreferNickname takes QRZ's <nickname> over the composed first+last name
+	// when the operator has published one. It is the name they go BY on the air,
+	// which is what belongs in a log — HamQTH's <nick> is already used that way,
+	// and this brings QRZ into line for operators who want it.
+	PreferNickname bool
+
+	mu       sync.Mutex
+	session  string
 	loggedAt time.Time
 }
 
@@ -117,7 +123,7 @@ func (q *QRZ) fetch(ctx context.Context, sessionKey, callsign string) (Result, e
 	}
 	r := Result{
 		Callsign:  strings.ToUpper(c.Call),
-		Name:      joinName(c.FName, c.Name),
+		Name:      qrzName(q.PreferNickname, c.Nickname, c.FName, c.Name),
 		QTH:       c.Addr2,
 		Address:   composeQRZAddress(c.Addr1, c.Addr2, c.Zip, c.Country),
 		State:     strings.ToUpper(c.State),
@@ -169,6 +175,7 @@ type qrzSession struct {
 type qrzCallsign struct {
 	Call      string `xml:"call"`
 	FName     string `xml:"fname"`
+	Nickname  string `xml:"nickname"` // the name the operator goes by on the air
 	Name      string `xml:"name"`
 	Addr1     string `xml:"addr1"`
 	Addr2     string `xml:"addr2"`
@@ -213,19 +220,6 @@ func composeQRZAddress(addr1, addr2, zip, country string) string {
 	return strings.Join(parts, ", ")
 }
 
-func joinName(first, last string) string {
-	first = strings.TrimSpace(first)
-	last = strings.TrimSpace(last)
-	switch {
-	case first != "" && last != "":
-		return first + " " + last
-	case first != "":
-		return first
-	default:
-		return last
-	}
-}
-
 func firstNonEmpty(s ...string) string {
 	for _, v := range s {
 		v = strings.TrimSpace(v)
@@ -235,3 +229,28 @@ func firstNonEmpty(s ...string) string {
 	}
 	return ""
 }
+
+// qrzName picks what goes in the log's Name field.
+//
+// The FIRST name only. A log greets an operator, it does not address an
+// envelope: "Robert" is what goes out on the air, and "Robert Smith" filled the
+// field with something no one would ever send. The surname stays available in
+// the record; it simply is not the name of the contact.
+//
+// The nickname is taken ahead of it when the operator asked for that AND QRZ
+// has one — a blank nickname must never blank the name, which is the whole
+// reason this is a fallback rather than a swap.
+//
+// The surname is the last resort: a record with no first name at all is better
+// answered with a surname than with nothing.
+func qrzName(preferNickname bool, nickname, fname, name string) string {
+	if preferNickname {
+		if n := strings.TrimSpace(nickname); n != "" {
+			return n
+		}
+	}
+	if f := strings.TrimSpace(fname); f != "" {
+		return f
+	}
+	return strings.TrimSpace(name)
+}

internal/lookup/qrzname_test.go

@@ -0,0 +1,33 @@
+package lookup
+
+import "testing"
+
+// What goes in a log's Name field is the FIRST name. A log greets an operator;
+// it does not address an envelope. "Robert Smith" filled the field with
+// something no one would ever send on the air.
+//
+// The nickname wins ahead of it when asked for — but a published nickname is
+// optional, so an empty one must fall through rather than blank the name. That
+// is the whole difference between a fallback and a swap.
+func TestQRZName(t *testing.T) {
+	for _, tc := range []struct {
+		name                  string
+		prefer                bool
+		nickname, fname, last string
+		want                  string
+	}{
+		{"first name only, never the surname", false, "Bob", "Robert", "Smith", "Robert"},
+		{"nickname when asked for", true, "Bob", "Robert", "Smith", "Bob"},
+		{"no nickname published falls back to the FIRST name", true, "", "Robert", "Smith", "Robert"},
+		{"a blank nickname is not a nickname", true, "   ", "Robert", "Smith", "Robert"},
+		{"option off ignores the nickname", false, "Bob", "Robert", "Smith", "Robert"},
+		{"surname is the last resort, not the default", true, "", "", "Smith", "Smith"},
+		{"nothing published at all", false, "", "", "", ""},
+		{"nickname alone", true, "Bob", "", "", "Bob"},
+	} {
+		if got := qrzName(tc.prefer, tc.nickname, tc.fname, tc.last); got != tc.want {
+			t.Errorf("%s: qrzName(%v, %q, %q, %q) = %q, want %q",
+				tc.name, tc.prefer, tc.nickname, tc.fname, tc.last, got, tc.want)
+		}
+	}
+}

internal/lookup/suffix_location_test.go

@@ -0,0 +1,27 @@
+package lookup
+
+import "testing"
+
+// A grid came back empty for M0BFS/QRP while the same lookup without the suffix
+// answered perfectly. The home-call pass wiped the location on the grounds that
+// a portable operator is not at their registered address — true for /P and /M,
+// and simply wrong for /QRP, which is a statement about power.
+func TestSaysNothingAboutLocation(t *testing.T) {
+	keep := []string{"M0BFS/QRP", "f4bpo/qrp", "G0ABC/QRP"}
+	for _, c := range keep {
+		if !saysNothingAboutLocation(c) {
+			t.Errorf("%s: the home location should be kept — /QRP does not move anyone", c)
+		}
+	}
+	// These DO move the operator, or change the entity outright.
+	drop := []string{"F4BPO/P", "F4BPO/M", "F4BPO/MM", "F4BPO/AM", "JW/OR1A", "VP8/F4BPO", "F4BPO/8", "F4BPO"}
+	for _, c := range drop {
+		if saysNothingAboutLocation(c) {
+			t.Errorf("%s: the home location must NOT be trusted", c)
+		}
+	}
+	// A power suffix on top of a portable one still moves them.
+	if saysNothingAboutLocation("F4BPO/P/QRP") {
+		t.Error("F4BPO/P/QRP is portable — location must not be kept")
+	}
+}