chore: release v0.26.0

app.go

@@ -694,16 +694,21 @@ type App struct {
 	pskr *pskr.Watcher
 	// Self-spot throttle: when and on what frequency we last announced ourselves.
 	// Held in memory only — a restart legitimately re-announces the station.
-	selfSpotMu     sync.Mutex
+	selfSpotMu   sync.Mutex
-	selfSpotAt     time.Time
+	selfSpotAt   time.Time
-	selfSpotHz     int64
+	selfSpotHz   int64
-	pota           *pota.Cache
+	pota         *pota.Cache
-	uls            *uls.Store // US callsign→county/grid (offline FCC ULS), lazily opened
+	uls          *uls.Store // US callsign→county/grid (offline FCC ULS), lazily opened
-	awardRefs      *awardref.Repo
+	awardRefs    *awardref.Repo
-	qslTemplates   *qslcard.Repo
+	qslTemplates *qslcard.Repo
-	operating      *operating.Repo
+	operating    *operating.Repo
-	udp            *udp.Manager
+	udp          *udp.Manager
-	udpRepo        *udp.Repo
+	udpRepo      *udp.Repo
+	// Program id of the last decoding application that reported its status.
+	// Halt Tx is routed by id, and the panel's Halt button must work even when
+	// nothing is transmitting at that instant — so the id is remembered from
+	// every Status rather than read off a live transmission.
+	lastTxID       atomic.Value // string
 	extsvc         *extsvc.Manager
 	winkeyer       *winkeyer.Manager
 	clublog        *clublog.Manager
@@ -4290,6 +4295,13 @@ func (a *App) insertPOTAQSOs(entries []pota.HunterQSO) int {
 			added++
 		}
 	}
+	// Bulk insert, so the caches are dropped ONCE at the end rather than per row.
+	// invalidateAwardStats is the right hammer here: a raw a.qso.Add leaves the
+	// cluster worked-index, the award snapshot AND the QSO numbering all holding
+	// a pre-import answer, and this import inserts into the MIDDLE of the order.
+	if added > 0 {
+		a.invalidateAwardStats()
+	}
 	return added
 }
 
@@ -6667,6 +6679,127 @@ func (a *App) BandSlotQSOs(callsign string, dxccNum int, band, modeClass string)
 	return out, nil
 }
 
+// FlexTXOnBand moves the FlexRadio's transmitter to the slice listening on the
+// given band, and focuses it.
+//
+// Why this exists: two decoding instances on two slices — say 20 m on slice A
+// and 80 m on slice B — both feed OpsLog, and answering a decode routes the
+// Reply to the right INSTANCE. But the instance keys one radio, and the radio
+// transmits on whichever slice carries the TX flag. Answer an 80 m decode with
+// TX still on the 20 m slice and the exchange goes out on the wrong band, or
+// nowhere at all.
+//
+// A no-op that reports success on any other backend: only a Flex has slices, and
+// a caller that has to ask what radio is attached before answering a decode is a
+// caller that will get it wrong somewhere.
+func (a *App) FlexTXOnBand(band string) error {
+	if a.cat == nil {
+		return nil
+	}
+	st, ok := a.cat.FlexState()
+	if !ok || len(st.Slices) == 0 {
+		return nil // not a Flex, or no slices yet — nothing to move
+	}
+	want := strings.ToLower(strings.TrimSpace(band))
+	if want == "" {
+		return nil
+	}
+	// The whole band is examined BEFORE anything moves. Taking the first slice
+	// that matches was wrong the moment two slices share a band — which is
+	// exactly what split is: an RX slice and a TX slice, same band, a few kHz
+	// apart. The loop would find the RX one first, see no TX flag on it, and move
+	// the transmitter onto it — collapsing the split into simplex, and with it
+	// the panel's split indicator.
+	//
+	// If any slice on this band already transmits, there is nothing to do: the
+	// radio is already set up for this band, split or not, and it is not this
+	// function's business to rearrange it.
+	var target *cat.FlexSliceInfo
+	for i := range st.Slices {
+		s := &st.Slices[i]
+		if strings.ToLower(s.Band) != want {
+			continue
+		}
+		if s.TX {
+			return nil
+		}
+		if target == nil {
+			target = s
+		}
+	}
+	if target == nil {
+		// No slice on that band. Silent: the operator may simply be answering a
+		// decode from a receiver that is not this radio.
+		return nil
+	}
+	{
+		s := target
+		applog.Printf("flex: moving TX to slice %s (%s) to answer a %s decode", s.Letter, s.Band, band)
+		// TX only. NOT SetActiveSlice — that sets a persistent PIN whose whole
+		// contract is "the operator chose this slice in OpsLog", overriding the
+		// radio's own active flag until the slice closes. Calling it from here
+		// made every click on a decode silently re-pin the operating slice, and
+		// split — which is built around whichever slice is active — then created
+		// a new slice instead of pairing with the existing one, every time.
+		//
+		// Where the transmitter goes and which slice the operator is working from
+		// are two different questions. This answers only the first.
+		return a.cat.FlexDo(func(fc cat.FlexController) error { return fc.SetTXSlice(s.Index) })
+	}
+}
+
+// SendDecodeFreeText puts a message in the decoding application's free-text box
+// and, with send, transmits it at once.
+//
+// The one transmit primitive that behaves the same across the whole family,
+// because it matches against no decode. It does NOT start a QSO — FT8 free text
+// is 13 characters and does not set the DX call, so no sequencing follows — and
+// it is offered as "send this text", never as a way to call a station.
+func (a *App) SendDecodeFreeText(instance, text string, send bool) error {
+	if a.udp == nil {
+		return fmt.Errorf("udp not initialized")
+	}
+	if strings.TrimSpace(instance) == "" {
+		instance = a.lastTxInstance()
+	}
+	err := a.udp.SendFreeText(instance, text, send)
+	if err != nil {
+		applog.Printf("udp: free text on %q failed: %v", instance, err)
+	}
+	return err
+}
+
+// GridSquares returns the 4-character Maidenhead squares in the log, with
+// whether each is confirmed.
+//
+// modeClass scopes it the way the rest of the app does: "DIGI", "CW", "PHONE",
+// or "" for every mode. "DIGI" is the one this was built for — a map of the
+// squares worked on FT8/FT4 answers "where have I actually been heard" in a way
+// no list of callsigns does.
+//
+// Confirmed means LoTW, a card or eQSL — the same three the award engine counts,
+// so a square cannot be green here and unconfirmed in the Awards panel.
+func (a *App) GridSquares(modeClass string) ([]qso.GridSquare, error) {
+	if a.qso == nil {
+		return nil, fmt.Errorf("db not initialized")
+	}
+	want := strings.ToUpper(strings.TrimSpace(modeClass))
+	keep := func(mode string) bool {
+		switch want {
+		case "", "ALL":
+			return true
+		case "FTX":
+			// The FT family alone, which is narrower than digital and usually the
+			// honest answer beside an FTx panel: a square worked on RTTY in a
+			// contest is not a square worked on FT8.
+			return ftxModes[strings.ToUpper(strings.TrimSpace(mode))]
+		default:
+			return award.ModeClass(mode) == want
+		}
+	}
+	return a.qso.GridSquares(a.ctx, keep)
+}
+
 // SetCompactMode toggles a tiny always-on-top window that exposes just the
 // QSO entry — useful when running on a single screen alongside WSJT-X,
 // JT-Alert or the cluster.
@@ -8288,6 +8421,20 @@ func (a *App) clusterEventWorker() {
 		}
 		s := *ev.spot
 		if a.dxcc != nil {
+			// The SPOTTER's continent, resolved here rather than in the per-call
+			// status cache. That cache is keyed by call|band|mode, and one DX call
+			// is spotted by skimmers all over the world within the same minute —
+			// so all of them collapsed onto whichever spotter happened to arrive
+			// first, and the continent filter passed every one of them. It is a
+			// property of the spot and now travels with it.
+			//
+			// The skimmer suffix goes first: RBN reports as "VU2OY-#" and cluster
+			// nodes as "DL1ABC-2", which the prefix matcher cannot resolve.
+			if sp := skimmerBase(s.Spotter); sp != "" {
+				if m, ok := a.dxcc.Lookup(sp); ok {
+					s.SpotterContinent = m.Continent
+				}
+			}
 			if m, ok := a.dxcc.Lookup(s.DXCall); ok && m.Entity != nil {
 				s.Country = m.Entity.Name
 				s.Continent = m.Continent
@@ -8339,6 +8486,19 @@ func (a *App) clusterEventWorker() {
 	}
 }
 
+// skimmerBase strips the reporting suffix from a spotter callsign: RBN skimmers
+// announce as "VU2OY-#" and cluster nodes as "DL1ABC-2". The DXCC prefix matcher
+// sees an unknown callsign and gives up on those, which is how the spotter's
+// continent came back empty for every RBN spot. A real callsign never contains a
+// hyphen, so cutting at the first one is safe.
+func skimmerBase(spotter string) string {
+	s := strings.TrimSpace(spotter)
+	if i := strings.IndexByte(s, '-'); i > 0 {
+		s = s[:i]
+	}
+	return s
+}
+
 func (a *App) evaluateAlerts(s cluster.Spot) {
 	if a.alertStore == nil {
 		return
@@ -8352,10 +8512,15 @@ func (a *App) evaluateAlerts(s cluster.Spot) {
 		Spotter:   s.Spotter,
 	}
 	// The spotter's country/continent (cty.dat) — resolved lazily for Origin rules.
-	if a.dxcc != nil && s.Spotter != "" {
+	// Through skimmerBase for the same reason the cluster filter needs it: an
-		if m, ok := a.dxcc.Lookup(s.Spotter); ok && m.Entity != nil {
+	// Origin rule on "spotter continent = EU" never matched an RBN spot, because
-			sp.SpotterCountry = m.Entity.Name
+	// "DL1ABC-#" resolves to nothing.
-			sp.SpotterContinent = m.Continent
+	if a.dxcc != nil {
+		if base := skimmerBase(s.Spotter); base != "" {
+			if m, ok := a.dxcc.Lookup(base); ok && m.Entity != nil {
+				sp.SpotterCountry = m.Entity.Name
+				sp.SpotterContinent = m.Continent
+			}
 		}
 	}
 	matches := a.alertStore.Evaluate(sp, time.Now(), a.isWorkedBandMode)
@@ -8411,10 +8576,13 @@ func (a *App) noteWorked(call, band, mode string) {
 		return
 	}
 	a.wcbmMu.Lock()
-	if a.wcbm == nil {
+	// nil means "not built yet", and isWorkedBandMode reads that as its cue to
-		a.wcbm = map[string]struct{}{}
+	// load the whole log. Seeding a one-entry map here would look built and
+	// answer "never worked" for everything else. The row is already inserted, so
+	// the later rebuild picks this contact up anyway.
+	if a.wcbm != nil {
+		a.wcbm[wcbmKey(call, band, mode)] = struct{}{}
 	}
-	a.wcbm[wcbmKey(call, band, mode)] = struct{}{}
 	a.wcbmMu.Unlock()
 	// The cluster worked-index snapshot is now stale (this call/slot just became
 	// worked) — drop it so the next spot batch recolours with the new QSO.
@@ -12633,6 +12801,14 @@ func (a *App) LogUDPLoggedADIF(adifText string) (int64, error) {
 	// log. This insert bypasses AddQSO entirely, which is why UDP-logged contacts
 	// came out unnumbered while hand-logged ones did not.
 	a.noteQSONumbered(id, q.QSODate)
+	// And for the same reason, the worked indexes have to be told here too.
+	// AddQSO does this; bypassing it left the cluster/decode status snapshot
+	// holding its pre-QSO answer for the rest of the session — so a station
+	// worked through WSJT-X / JTDX / MSHV went on wearing NEW GRID, NEW CALL and
+	// NEW PFX after the QSO was in the log. Reported on RA3Y (KO73), still badged
+	// NEW GRID two minutes after the contact. Hand-logged contacts never showed
+	// it, which is exactly what made it look like a display bug.
+	a.noteWorked(q.Callsign, q.Band, q.Mode)
 	a.noteLiveQSO() // multi-op: flip this operator back "online" (publishes async)
 	// Announce the log AT ONCE so the grid / ON-AIR badge / stations-on-air widget
 	// refresh immediately, then run the DB-heavy enrichment off the critical path
@@ -12693,14 +12869,19 @@ func (a *App) consumeUDPEvents() {
 		// switch because a Status carries BOTH a DX call and a transmit message,
 		// and the switch below takes only one branch.
 		//
-		// Sent on EVERY Status, not only when there is a transmit message: MSHV
+		// Sent on EVERY Status, not only when there is a transmit message: the
-		// and older JTDX builds stop before tx_message in the Status payload, and
+		// field is EMPTY between overs — that is its normal state, not a sender
-		// the panel still has to be able to say who is being called and whether
+		// that withholds it — and the panel still has to say who is being called
-		// the carrier is up. A Status always carries de_call, so that is the test.
+		// and whether the carrier is up. A Status always carries de_call, so that
+		// is the test.
 		if ev.DECall != "" || ev.TxMessage != "" {
+			if ev.ProgramID != "" {
+				a.lastTxID.Store(ev.ProgramID)
+			}
 			wruntime.EventsEmit(a.ctx, "udp:tx_state", map[string]any{
 				"msg":          ev.TxMessage,
 				"transmitting": ev.Transmitting,
+				"tx_enabled":   ev.TxEnabled,
 				"de_call":      ev.DECall,
 				"dx_call":      ev.DXCall,
 				"mode":         ev.Mode,
@@ -12744,9 +12925,13 @@ func (a *App) consumeUDPEvents() {
 				"dt":        ev.DecodeDT,
 				"audio_hz":  ev.DecodeAudioHz,
 				// Carried so a click can answer the station: WSJT-X matches a
-				// Reply against its own decode list, field for field.
+				// Reply against its own decode list, field for field. mode_raw is
+				// the mode as the Decode sent it (the "~"/"+" marker) — "mode"
+				// above is the resolved name, which the match rejects.
 				"ms":       ev.DecodeMs,
 				"low_conf": ev.DecodeLowConf,
+				"mode_raw": ev.DecodeModeRaw,
+				"msg_raw":  ev.DecodeMsgRaw,
 			})
 			// A WSJT-X decode (heard station). Render it on the FlexRadio
 			// panadapter when the option is on; green + SNR comment, auto-expiring
@@ -18219,6 +18404,12 @@ type SpotStatus struct {
 	// carries the SPOTTER's grid at best, never the DX's.
 	Grid    string `json:"grid,omitempty"`
 	NewGrid bool   `json:"new_grid"`
+	// GridState splits NewGrid into its two meanings: "new" (never worked under
+	// the operator's scope) and "unconf" (worked, awaiting a confirmation). Empty
+	// when there is nothing to chase. They are different decisions — a QSO to
+	// make against a QSL to chase — and one badge for both is what made a station
+	// worked an hour ago still read as NEW GRID.
+	GridState string `json:"grid_state,omitempty"`
 	// SpotterContinent is the continent of the station that SENT the spot, not of
 	// the DX. It answers a different question — "is anyone near me hearing this?"
 	// — which is what makes it worth filtering on: a JA spot on 20 m tells a
@@ -18256,10 +18447,17 @@ type clusterStatusCache struct {
 	// callCounties holds callsign → "STATE,County" for stations already logged
 	// with a county, so a spot shows the county the entry panel showed rather
 	// than the one derived from the licence ZIP. See qso.CallCounties.
-	callCounties  map[string]string
+	callCounties map[string]string
-	workedPOTA    map[string]struct{}
+	workedPOTA   map[string]struct{}
-	workedPfx     map[string]struct{}
+	workedPfx    map[string]struct{}
-	workedGrids   map[string]struct{} // "GRID|MODE", mode normalised like the rest
+	// workedGrids answers "is this square already mine" under EVERY band-and-mode
+	// scope, keyed by qso.GridKey and valued by whether the square is confirmed.
+	// One index for all six scopes and both hunting modes: the operator switches
+	// between them freely, and rebuilding the log index on each toggle would make
+	// a dropdown take seconds.
+	workedGrids   map[string]bool
+	gridScope     gridScope           // the scope and hunt the cache was built under —
+	gridHunt      string              // a change to either rebuilds it
 	normMode      func(string) string // nil unless digital-mode grouping is on
 	groupDigital  bool                // settings the maps were built under —
 	sameSlot      bool                // a change rebuilds the snapshot
@@ -18274,12 +18472,21 @@ func (a *App) clusterStatusMaps() *clusterStatusCache {
 	groupDigital := a.groupDigitalSlots()
 	sameSlot := a.clusterWorkedSameSlot()
 	slotHighlight := a.clusterSlotHighlight()
+	// Read BEFORE taking the lock: settingOr goes to the settings store, and
+	// holding the status mutex across that is how two subsystems deadlock.
+	gs := a.GetGridScopeSettings()
+	gridScopeNow := lookupGridScope(gs.Scope)
+	gridHuntNow := gs.Hunt
 	a.clusterStatusMu.Lock()
 	defer a.clusterStatusMu.Unlock()
-	if c := a.clusterStatusIdx; c != nil && c.groupDigital == groupDigital && c.sameSlot == sameSlot && c.slotHighlight == slotHighlight {
+	if c := a.clusterStatusIdx; c != nil && c.groupDigital == groupDigital && c.sameSlot == sameSlot &&
+		c.slotHighlight == slotHighlight && c.gridScope == gridScopeNow && c.gridHunt == gridHuntNow {
 		return c
 	}
-	c := &clusterStatusCache{groupDigital: groupDigital, sameSlot: sameSlot, slotHighlight: slotHighlight}
+	c := &clusterStatusCache{
+		groupDigital: groupDigital, sameSlot: sameSlot, slotHighlight: slotHighlight,
+		gridScope: gridScopeNow, gridHunt: gridHuntNow,
+	}
 	if a.qso == nil {
 		a.clusterStatusIdx = c
 		return c
@@ -18330,7 +18537,7 @@ func (a *App) clusterStatusMaps() *clusterStatusCache {
 	// One more DISTINCT scan when the snapshot is rebuilt, then pure map lookups
 	// per spot — the same shape as the county and POTA sets beside it, which is
 	// why grids cost nothing under an RBN firehose.
-	c.workedGrids, _ = a.qso.WorkedGridKeys(a.ctx, c.normMode)
+	c.workedGrids, _ = a.qso.GridWorkedIndex(a.ctx, gridClassesOf)
 	// Worked WPX prefixes, derived from the callsigns we already loaded — no
 	// extra query. Derived rather than read from the stored PFX column: that
 	// column is only filled when an import supplied it, and deriving keeps this
@@ -18404,6 +18611,37 @@ func (a *App) AnswerDecode(instance string, ms uint32, snr int, dt float64, audi
 	return err
 }
 
+// HaltDecodeTx tells the decoding application to stop transmitting — the same
+// as its own Halt Tx button.
+//
+// autoTxOnly false stops the transmission mid-over; true lets the current over
+// finish and only then disables auto-Tx. Both are real operator intentions: the
+// first is "I called the wrong station", the second is "this QSO is done".
+//
+// instance may be empty, in which case the halt goes to whichever application
+// last reported that it is transmitting — with one receiver, which is the
+// normal case, that is simply the one running.
+func (a *App) HaltDecodeTx(instance string, autoTxOnly bool) error {
+	if a.udp == nil {
+		return fmt.Errorf("udp not initialized")
+	}
+	if strings.TrimSpace(instance) == "" {
+		instance = a.lastTxInstance()
+	}
+	err := a.udp.SendHaltTx(instance, autoTxOnly)
+	if err != nil {
+		applog.Printf("udp: halt tx on %q failed: %v", instance, err)
+	}
+	return err
+}
+
+// lastTxInstance is the program id of the last decoding application heard from,
+// or "" if none has reported yet.
+func (a *App) lastTxInstance() string {
+	s, _ := a.lastTxID.Load().(string)
+	return s
+}
+
 // GetGridCacheStatus reports what the locator store holds.
 func (a *App) GetGridCacheStatus() GridCacheStatus {
 	out := GridCacheStatus{Enabled: a.gridStore != nil}
@@ -18597,26 +18835,28 @@ func (a *App) ClusterSpotStatuses(spots []SpotQuery) []SpotStatus {
 		}
 		// The spotter's continent, and whether the DX uploads to LoTW. Both are
 		// in-memory lookups on tables already loaded, so they add nothing per spot.
+		//
+		// NOTE: the cluster list no longer filters on THIS copy — it is keyed by
+		// call|band|mode, so every spotter of one call shares it. The filter reads
+		// the spot's own SpotterContinent instead. Kept because the field is part
+		// of the published status shape.
 		if a.dxcc != nil && q.Spotter != "" {
-			// Strip the skimmer suffix first. RBN spotters report as "VU2OY-#" and
+			if sp := skimmerBase(q.Spotter); sp != "" {
-			// a cluster node as "DL1ABC-2"; the prefix matcher sees an unknown
+				if m, ok := a.dxcc.Lookup(sp); ok {
-			// callsign and gives up, so EVERY spot came back with no continent and
+					out[i].SpotterContinent = m.Continent
-			// the filter silently matched nothing. A real callsign never contains a
+				}
-			// hyphen, so cutting at the first one is safe.
-			sp := q.Spotter
-			if i := strings.IndexByte(sp, '-'); i > 0 {
-				sp = sp[:i]
-			}
-			if m, ok := a.dxcc.Lookup(sp); ok {
-				out[i].SpotterContinent = m.Continent
 			}
 		}
 		if a.lotwUsers != nil {
 			out[i].LoTW = a.lotwUsers.Lookup(q.Call).IsUser
 		}
-		// NEW GRID: the square this station announced in a CQ we decoded. The mode
+		// NEW GRID: the square this station announced on the UDP decode feed.
-		// is part of the key, so the "group digital modes" option decides whether a
+		//
-		// grid worked on FT8 still counts as new on FT4 — one rule, no branch here.
+		// This runs for CLUSTER spots as well as decodes — one function serves
+		// both — but a cluster line never carries the DX's grid, only the
+		// spotter's. So a spot is judged here exactly when the same callsign has
+		// also been heard on the decode feed, and stays unjudged otherwise. That
+		// is the honest answer: no grid known is not the same as no grid needed.
 		{
 			// Read through the accessor: the decode goroutine swaps these maps on
 			// rotation, so touching them unguarded is a race on the map header,
@@ -18624,13 +18864,14 @@ func (a *App) ClusterSpotStatuses(spots []SpotQuery) []SpotStatus {
 			g := a.lookupDecodeGrid(q.Call)
 			if g != "" {
 				out[i].Grid = g
-				cm := out[i].Mode
+				// The scope decides whether the band and the exact mode matter,
-				if normMode != nil && cm != "" {
+				// and the hunt whether an unconfirmed square still counts as
-					cm = normMode(cm)
+				// wanted. Both are the operator's settings — see gridscope.go.
-				}
+				// Two states, not one: never worked is a QSO to make, worked but
-				if _, done := idx.workedGrids[g+"|"+cm]; !done {
+				// unconfirmed is a QSL to chase. NewGrid stays the yes/no the
-					out[i].NewGrid = true
+				// filters read; GridState says WHICH, so the badge can differ.
-				}
+				out[i].GridState = gridStateFor(idx.workedGrids, idx.gridScope, idx.gridHunt, g, out[i].Band, out[i].Mode)
+				out[i].NewGrid = out[i].GridState != ""
 			}
 		}
 		// NEW COUNTY. Two sources, better one first:

bandopen_nearkm_test.go

@@ -0,0 +1,37 @@
+package main
+
+import (
+	"testing"
+
+	"hamlog/internal/pskr"
+)
+
+// The receiver radius is what makes an opening report evidence about the
+// OPERATOR's path rather than someone else's. Both ends of the range destroy
+// that: too small and no receiver is ever near enough, too large and the
+// reports are about a different part of the world. A stored value that would do
+// either has to fall back rather than be honoured.
+func TestBandOpenNearKmClamps(t *testing.T) {
+	for _, tc := range []struct {
+		name string
+		raw  string
+		want int
+	}{
+		{"unset falls back", "", pskr.DefaultNearKm},
+		{"not a number falls back", "soon", pskr.DefaultNearKm},
+		{"zero falls back", "0", pskr.DefaultNearKm},
+		{"negative falls back", "-100", pskr.DefaultNearKm},
+		{"absurdly tight falls back", "5", pskr.DefaultNearKm},
+		{"absurdly wide falls back", "5000", pskr.DefaultNearKm},
+		{"a real choice is kept", "100", 100},
+		{"the lower bound is kept", "25", 25},
+		{"the upper bound is kept", "1000", 1000},
+		{"surrounding space is ignored", "  150 ", 150},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			if got := bandOpenNearKm(tc.raw); got != tc.want {
+				t.Errorf("bandOpenNearKm(%q) = %d, want %d", tc.raw, got, tc.want)
+			}
+		})
+	}
+}

bandopen_sources.go

@@ -16,6 +16,7 @@ package main
 // they no longer need.
 
 import (
+	"strconv"
 	"strings"
 
 	"hamlog/internal/applog"
@@ -28,7 +29,8 @@ import (
 
 const (
 	keyBandOpenEnabled = "bandopen.enabled"
-	keyBandOpenBands   = "bandopen.bands" // comma-separated; empty = the default set
+	keyBandOpenBands   = "bandopen.bands"  // comma-separated; empty = the default set
+	keyBandOpenNearKm  = "bandopen.nearkm" // receiver radius; empty = pskr.DefaultNearKm
 )
 
 // rbnNodes are the two Reverse Beacon Network endpoints the watch wants: CW and
@@ -45,6 +47,18 @@ type BandOpenSettings struct {
 	// Available is every band that can be watched, so the UI does not carry its
 	// own copy of a list that belongs to the detector.
 	Available []string `json:"available"`
+	// NearKm is how close a RECEIVER has to be for its report to count as
+	// evidence about the operator's own path. An opening on these bands reaches
+	// an AREA, and the right radius is a judgement about how big that area is —
+	// a 2 m tropo duct is not a 10 m Es footprint — so it is the operator's to
+	// make rather than a constant.
+	//
+	// Tightening it costs nothing in traffic: the broker subscription is one
+	// ring of squares whatever this says, and this only decides what survives
+	// once the messages are here. It costs SENSITIVITY — too small a radius in a
+	// thinly-populated region leaves no receivers at all, and a watch with
+	// nothing to look at reports nothing while appearing to work.
+	NearKm int `json:"near_km"`
 }
 
 func (a *App) GetBandOpenSettings() BandOpenSettings {
@@ -52,6 +66,7 @@ func (a *App) GetBandOpenSettings() BandOpenSettings {
 		Enabled:   a.settingOr(keyBandOpenEnabled, "") == "1",
 		Bands:     splitCSV(a.settingOr(keyBandOpenBands, "")),
 		Available: pskr.Bands,
+		NearKm:    bandOpenNearKm(a.settingOr(keyBandOpenNearKm, "")),
 	}
 	// Keep only bands that are still offered. A saved selection outlives the code
 	// that made it: 12 m was dropped from the watched set, but every operator who
@@ -78,9 +93,23 @@ func keepKnownBands(want []string) []string {
 	return out
 }
 
+// bandOpenNearKm reads the stored receiver radius, falling back to the default
+// for anything unset or out of range. The bounds are the two ways to make the
+// watch useless: below 25 km almost nobody is ever near enough to hear anything,
+// and past 1000 km the reports stop being about the operator's own path — which
+// is the entire premise of measuring from a receiver rather than a transmitter.
+func bandOpenNearKm(raw string) int {
+	n, err := strconv.Atoi(strings.TrimSpace(raw))
+	if err != nil || n < 25 || n > 1000 {
+		return pskr.DefaultNearKm
+	}
+	return n
+}
+
 func (a *App) SaveBandOpenSettings(s BandOpenSettings) error {
 	a.setSetting(keyBandOpenEnabled, map[bool]string{true: "1", false: "0"}[s.Enabled])
 	a.setSetting(keyBandOpenBands, strings.Join(s.Bands, ","))
+	a.setSetting(keyBandOpenNearKm, strconv.Itoa(bandOpenNearKm(strconv.Itoa(s.NearKm))))
 	if s.Enabled {
 		a.ensureRBNNodes()
 	}
@@ -184,6 +213,7 @@ func (a *App) startBandOpenFeed() {
 	a.pskr = pskr.New(pskr.Config{
 		Bands:   bands,
 		RxGrids: rxGrids,
+		NearKm:  s.NearKm,
 		OpLat:   a.opLat, OpLon: a.opLon,
 		Geo: func(grid string) (int, int, bool) {
 			lat, lon, ok := gridToLatLon(grid)

changelog.json

@@ -3,16 +3,38 @@
     "version": "0.26.0",
     "date": "",
     "en": [
+      "A new FT decodes tab: every decode from WSJT-X, JTDX or MSHV, grouped by transmit period, with what is new and what you are sending. Clicking a decode asks the application to call that station, exactly as double-clicking the line in its own window does. Columns are resizable and remembered, the filter bar with them, Clear empties the lists and Halt stops the transmission. With two receivers running the table splits into one column per band, each with its own transmit line, Halt and Clear, and the column lights up when that receiver is on the air. On a FlexRadio, answering a decode moves the transmitter to the slice listening on that band — unless that band already transmits, so an existing split is left alone.",
+      "FT decodes: auto-call. OpsLog can answer a decode without you clicking it — pick what qualifies (a new entity, band, mode, band+mode slot, grid, US county, POTA park or WPX prefix) and add a watch list of callsigns, with or without conditions of their own. It answers a CQ only, one station at a time across the whole station, never while any receiver is still mid-QSO, with a cooldown per callsign, and every call is written to the log with its reason. Armed from the decodes toolbar or Settings → FTx decodes, and off until you turn it on.",
+      "A grid-square map (Tools → Grid squares): every 4-character square in the log, confirmed squares solid and worked ones faint, scoped to digital or the FT modes, on the basemap of your choice. It answers the one question a decode list cannot — not who is on the band, but where the station has actually been reaching.",
+      "UDP: a new outbound type relays the WSJT-X stream. Every datagram received from WSJT-X, JTDX or MSHV is re-sent byte for byte to another program — JTAlert, GridTracker, a second logger — which each sender cannot do on its own, since they talk to one address only. Forwarded verbatim, with no origin header of the kind that has to be stripped back off at the far end, and a target naming one of OpsLog’s own ports is refused rather than looped.",
+      "New-grid detection now reads the grid from a reply as well as from a CQ. \"C91RU IZ5EME JN52\" — a station answering with its locator — is the commonest grid-bearing message on a busy band, and only CQs were being read: any station whose CQ you happened to miss had no known grid at all and could never be flagged as a new one. This is why other tools showed far more wanted grids than OpsLog did.",
+      "New-grid chasing is now scoped the way GridTracker scopes it, so the two agree. Pick how a square counts as already worked — this band or any band, crossed with any digital mode, this exact mode, or any FT mode (FT8/FT4/FT2) — and whether to chase only squares never worked or unconfirmed ones too, which are still missing from the award. The two are shown differently: a square never worked is a QSO to make, one worked and awaiting a confirmation is a QSL to chase, and they no longer share a badge. Settings → DX Cluster. The decodes table also gained a Grid column.",
+      "Cluster: NEW badges now clear after a contact however it was logged. Only hand-logging refreshed the worked snapshot, so a station worked through WSJT-X / JTDX / MSHV — or replayed from the offline outbox, arriving from a multi-op partner, or imported from the POTA hunter log — kept its NEW, NEW BAND, NEW MODE, NEW SLOT, NEW GRID, NEW PFX or NEW POTA badge for the rest of the session.",
+      "DX cluster: the Spotter continent filter matches again. One callsign is spotted by skimmers all over the world within a minute, and they all shared a single cached entry belonging to whichever spotter arrived first — so picking AF left the Indian and American skimmers in the list. Each spot now carries its own spotter continent. Alert rules on the spotter’s continent or country were missing RBN spots for a related reason and now match too.",
+      "Recent QSOs: the callsign search takes wildcards. A plain word now matches the START of a call — 4S finds 4S7AB — while * is any run of characters and ? exactly one, so *4S ends with 4S and *4S* contains it anywhere. It was an unconditional contains-match before, which made asking for a prefix impossible.",
+      "QSL Manager: the right-click menu now carries the same actions as Recent QSOs — ADIF export of the selection, export with a chosen field set, Cabrillo, bulk edit, the callbook and cty.dat updates, e-mail and delete. Filtered exports are deliberately not offered here: \"the filter\" means the Recent-QSOs filter, not the rows on screen. Two entries that appeared in this tab and did nothing when clicked are fixed at the same time — the menu now shows an action only where it is actually wired.",
+      "Column pickers and the ADIF export field chooser gained a whole-dialog Select all / Clear. Only per-group links existed, so clearing a selection meant one click per group — a dozen of them before you could tick the handful you actually wanted. Applies to Recent QSOs, Worked before, the cluster list and the export dialog, and covers the award columns the per-group links never touched.",
+      "Rotator: a Compact mode option (Settings → Rotator) reduces the rotor widget to the dial and the short/long-path azimuths under it. Left off, the widget keeps its quick-turn buttons, azimuth box and Stop.",
+      "Band-opening watch: the radius that counts a receiver as \"around here\" is now adjustable (Settings → DX Cluster), 25–1000 km, still 300 km by default. An opening on 10 m reaches a whole region, a 2 m duct does not, and the right distance is a judgement only the operator can make. Tightening it costs no extra traffic — the subscription is unchanged — only sensitivity.",
       "Club Log uploads are now identified as OpsLog. They were credited to another station's application key, which took the blame for them.",
-      "ADIF import: \"fill my station fields\" now fills the station callsign too, on records that carry none.",
+      "ADIF import: \"fill my station fields\" now fills the station callsign too, on records that carry none."
-      "A new FT decodes tab: every decode from WSJT-X, JTDX or MSHV, grouped by transmit period, with what is new and what you are sending.",
-      "Clicking a decode asks WSJT-X or MSHV to call that station, exactly as double-clicking the line in their own window does."
     ],
     "fr": [
+      "Un onglet Décodages FT : tous les décodages de WSJT-X, JTDX ou MSHV, groupés par période d’émission, avec ce qui est nouveau et ce que tu émets. Cliquer un décodage demande au logiciel d’appeler cette station, exactement comme un double-clic sur la ligne dans sa propre fenêtre. Les colonnes se redimensionnent et sont mémorisées, la barre de filtres avec elles, Vider efface les listes et Stop arrête l’émission. Avec deux récepteurs, le tableau se scinde en une colonne par bande, chacune avec sa ligne d’émission, son Stop et son Vider, et la colonne s’allume quand c’est ce récepteur qui émet. Sur un FlexRadio, répondre à un décodage déplace l’émetteur sur la slice qui écoute cette bande — sauf si cette bande émet déjà, pour ne pas défaire un split en place.",
+      "Décodages FT : appel automatique. OpsLog peut répondre à un décodage sans que tu cliques — choisis ce qui le déclenche (nouvelle entité, bande, mode, couple bande+mode, carré, comté US, parc POTA ou préfixe WPX) et ajoute une liste d’indicatifs surveillés, avec ou sans conditions propres. Uniquement sur un CQ, une station à la fois pour toute la station, jamais tant qu’un récepteur est encore en QSO, avec un délai de garde par indicatif, et chaque appel est écrit dans le journal avec sa raison. S’arme depuis la barre d’outils des décodages ou Réglages → Décodages FTx, et reste désactivé tant que tu ne l’actives pas.",
+      "Une carte des carrés locator (Outils → Carrés locator) : tous les carrés de 4 caractères du journal, les confirmés en plein et les contactés en pâle, au choix en numérique ou en modes FT, sur le fond de carte de ton choix. Elle répond à la seule question qu’une liste de décodages ne peut pas traiter : non pas qui est sur la bande, mais jusqu’où la station porte réellement.",
+      "UDP : un nouveau type sortant relaie le flux WSJT-X. Chaque datagramme reçu de WSJT-X, JTDX ou MSHV est réémis octet pour octet vers un autre logiciel — JTAlert, GridTracker, un second carnet — ce qu’aucun émetteur ne sait faire seul puisqu’il ne parle qu’à une adresse. Transmis tel quel, sans l’en-tête d’origine qu’il faut ensuite retirer à l’autre bout, et une cible désignant un port d’écoute d’OpsLog est refusée au lieu de boucler.",
+      "La détection des nouveaux carrés lit désormais le locator dans une réponse autant que dans un CQ. « C91RU IZ5EME JN52 » — une station qui répond avec son locator — est le message porteur de locator le plus fréquent sur une bande chargée, et seuls les CQ étaient lus : une station dont on avait manqué le CQ n’avait aucun locator connu et ne pouvait jamais être signalée comme nouvelle. C’est ce qui expliquait l’écart avec les autres logiciels sur le nombre de carrés recherchés.",
+      "La chasse aux nouveaux carrés se règle désormais comme dans GridTracker, pour que les deux soient d’accord. Choisis ce qui fait qu’un carré est déjà fait — cette bande ou toutes bandes, croisé avec tout mode numérique, ce mode exact, ou tout mode FT (FT8/FT4/FT2) — et si tu chasses seulement les carrés jamais contactés ou aussi les non confirmés, qui manquent encore au diplôme. Les deux s’affichent différemment : un carré jamais contacté est un QSO à faire, un carré contacté en attente de confirmation est une QSL à relancer, et ils ne partagent plus le même badge. Réglages → Cluster DX. Le tableau des décodages gagne aussi une colonne Locator.",
+      "Cluster : les badges NEW s’effacent enfin après un contact, quel que soit le mode de journalisation. Seule la saisie manuelle rafraîchissait l’instantané des contacts, si bien qu’une station travaillée via WSJT-X / JTDX / MSHV — ou rejouée depuis la file hors-ligne, reçue d’un partenaire multi-op, ou importée du journal chasseur POTA — gardait son badge NEW, NEW BAND, NEW MODE, NEW SLOT, NEW GRID, NEW PFX ou NEW POTA jusqu’à la fin de la session.",
+      "Cluster DX : le filtre Continent du spotter fonctionne à nouveau. Un même indicatif est spotté par des skimmers du monde entier en une minute, et tous partageaient une seule entrée en cache appartenant au premier spotter arrivé — choisir AF laissait donc les skimmers indiens et américains dans la liste. Chaque spot porte désormais son propre continent de spotter. Les règles d’alerte sur le continent ou le pays du spotter rataient les spots RBN pour une raison voisine et fonctionnent aussi.",
+      "QSO récents : la recherche d’indicatif accepte les jokers. Un mot simple correspond désormais au DÉBUT de l’indicatif — 4S trouve 4S7AB — tandis que * remplace n’importe quelle suite de caractères et ? exactement un : *4S se termine par 4S, *4S* le contient n’importe où. C’était auparavant une recherche « contient » systématique, qui rendait impossible la recherche par préfixe.",
+      "Gestionnaire QSL : le menu contextuel propose désormais les mêmes actions que les QSO récents — export ADIF de la sélection, export avec choix des champs, Cabrillo, édition en masse, mises à jour cty.dat et annuaires, e-mail et suppression. Les exports « filtrés » n’y sont volontairement pas offerts : « le filtre » désigne celui des QSO récents, pas les lignes affichées ici. Deux entrées qui apparaissaient dans cet onglet sans rien faire sont corrigées au passage — le menu n’affiche plus une action que là où elle est réellement branchée.",
+      "Les sélecteurs de colonnes et le choix des champs à l’export ADIF ont désormais un Tout sélectionner / Tout décocher global. Seuls les liens par groupe existaient, si bien que vider une sélection demandait un clic par groupe — une douzaine avant de pouvoir cocher les quelques champs voulus. Vaut pour les QSO récents, Déjà contacté, la liste cluster et la fenêtre d’export, et couvre les colonnes de diplômes que les liens par groupe ne touchaient pas.",
+      "Rotor : une option Mode compact (Réglages → Rotor) réduit le widget au cadran et aux azimuts courte/longue distance en dessous. Désactivée, le widget garde ses boutons de rotation rapide, sa case d’azimut et Stop.",
+      "Veille d’ouverture : le rayon qui fait qu’un récepteur compte comme « près d’ici » est désormais réglable (Réglages → Cluster DX), de 25 à 1000 km, toujours 300 km par défaut. Une ouverture sur 10 m couvre toute une région, un conduit sur 2 m non, et la bonne distance est un jugement qui n’appartient qu’à l’opérateur. Le resserrer ne coûte aucun trafic supplémentaire — l’abonnement ne change pas — seulement de la sensibilité.",
       "Les envois Club Log s’identifient désormais comme OpsLog. Ils étaient attribués à la clé applicative d’une autre station, qui en portait la responsabilité.",
-      "Import ADIF : « remplir mes champs station » renseigne aussi l’indicatif de station, sur les enregistrements qui n’en portent pas.",
+      "Import ADIF : « remplir mes champs station » renseigne aussi l’indicatif de station, sur les enregistrements qui n’en portent pas."
-      "Un onglet Decodes FT : tous les décodes de WSJT-X, JTDX ou MSHV, groupés par période, avec ce qui est nouveau et ce que tu émets.",
-      "Cliquer un décode demande à WSJT-X ou MSHV d’appeler la station, exactement comme un double-clic dans leur propre fenêtre."
     ]
   },
   {

frontend/src/App.tsx

@@ -94,7 +94,7 @@ import { ShutdownProgress } from '@/components/ShutdownProgress';
 import { ClusterGrid } from '@/components/ClusterGrid';
 import { cleanSpotter, inferSpotMode, spotModeCategory, spotStatusKey } from '@/lib/spot';
 import { applySpotDisplay, readSpotDisplayOptions, spotIsWorked, SPOT_DISPLAY_OPTIONS_EXPOSED } from '@/lib/spotDisplay';
-import { AnswerDecode, GetMatrixColors, GetRotorPresets, GetRowColors, GetSpotTTLMinutes, IsNewUSCounty } from '../wailsjs/go/main/App';
+import { AnswerDecode, HaltDecodeTx, LogUIError, FlexTXOnBand, GetMatrixColors, GetRotorPresets, GetRowColors, GetSpotTTLMinutes, IsNewUSCounty } from '../wailsjs/go/main/App';
 import { applyMatrixColors } from '@/lib/matrixColors';
 import { WorkedBeforeGrid } from '@/components/WorkedBeforeGrid';
 import { NetControlPanel } from '@/components/NetControlPanel';
@@ -108,6 +108,8 @@ import { DetailsPanel, type DetailsState } from '@/components/DetailsPanel';
 import { SendSpotModal, type RecentSpotQSO } from '@/components/SendSpotModal';
 import { WinkeyerPanel, type WKStatus, type WKMacro } from '@/components/WinkeyerPanel';
 import { RotorCompass } from '@/components/RotorCompass';
+import { GridSquareMap } from '@/components/GridSquareMap';
+import { loadAutoCall, shouldAutoCall, autoCallKey, type AutoCallSettings } from '@/lib/autocall';
 import { DecodesPanel, type Decode as DecodeRow, type TxMsg as TxMsgRow } from '@/components/DecodesPanel';
 import { subscribeRotorHeading, pokeRotorHeading } from '@/lib/rotorHeading';
 import { writeUiPref } from '@/lib/uiPref';
@@ -1036,6 +1038,22 @@ export default function App() {
   // unlike Statistics, which is consulted and closed, this one is a panel an
   // operator running digital modes leaves open for the session.
   const [decodesTabOpen, setDecodesTabOpen] = useState(() => localStorage.getItem('opslog.decodesTab') === '1');
+  // The grid-square map is its OWN closable tab, not a column beside the decode
+  // table. It is an analysis view — consulted a few times an evening — and the
+  // space beside the table is worth far more to a second receiver's decodes when
+  // two bands are running. Full width also makes it legible, which it was not in
+  // a 38 % column.
+  const [gridsTabOpen, setGridsTabOpen] = useState(() => localStorage.getItem('opslog.gridsTab') === '1');
+  function openGridsTab() {
+    setGridsTabOpen(true);
+    writeUiPref('opslog.gridsTab', '1');
+    setActiveTab('grids');
+  }
+  function closeGridsTab() {
+    setGridsTabOpen(false);
+    writeUiPref('opslog.gridsTab', '0');
+    setActiveTab((t) => (t === 'grids' ? 'recent' : t));
+  }
   function openDecodesTab() {
     setDecodesTabOpen(true);
     writeUiPref('opslog.decodesTab', '1');
@@ -1828,6 +1846,7 @@ export default function App() {
   const [showSettings, setShowSettings] = useState(false);
   // Re-read the "beam on map" toggle when Preferences closes (it's edited there).
   useEffect(() => { if (!showSettings) setShowBeamOnMap(localStorage.getItem('opslog.showBeamOnMap') !== '0'); }, [showSettings]);
+  useEffect(() => { if (!showSettings) setRotorCompact(localStorage.getItem('opslog.rotorCompact') === '1'); }, [showSettings]);
   // Openings under way, for the blinking status-bar badge. Polled rather than
   // event-driven: the badge also has to go OUT when a band goes quiet, and
   // nothing emits an event for something that stopped happening.
@@ -2068,7 +2087,99 @@ export default function App() {
   // The LIVE transmit state, replaced on every Status — what is going out now
   // and to whom, which the period history cannot answer between overs.
   const [txState, setTxState] = useState<TxMsgRow | null>(null);
+  // The same, per receiver. With two instances the single txState is whichever
+  // one reported last, so a split view cannot say WHICH is on the air — which is
+  // the only question worth asking when both are calling.
+  const [txStates, setTxStates] = useState<Record<string, TxMsgRow>>({});
   useEffect(() => { decodesRef.current = decodes; }, [decodes]);
+
+  // ── Auto-call ──────────────────────────────────────────────────────
+  //
+  // Answers a decode without the operator clicking it. The DECISION lives in
+  // lib/autocall (one pure function, so the dangerous part can be read and
+  // argued with); this is only the plumbing that runs it and keys the radio.
+  //
+  // Re-read when Preferences closes, like every other setting edited there.
+  const [autoCall, setAutoCall] = useState<AutoCallSettings>(loadAutoCall);
+  useEffect(() => { if (!showSettings) setAutoCall(loadAutoCall()); }, [showSettings]);
+  // When each callsign was last answered, so a station still calling CQ is not
+  // re-answered every slot while the QSO it started is still running.
+  const autoCalledRef = useRef<Map<string, number>>(new Map());
+  // Decodes are scanned once. Without this the same decode is reconsidered on
+  // every status refresh, and a cooldown that has just expired would fire again
+  // on a decode minutes old.
+  const autoSeenRef = useRef<Set<string>>(new Set());
+  // Set when a call goes out, so nothing else fires until the receiver's own
+  // status catches up and `busy` can be trusted again.
+  const autoHoldUntilRef = useRef(0);
+  // Per receiver, when the carrier was last up. Feeds the stale-exchange
+  // backstop below.
+  const lastTxAtRef = useRef<Map<string, number>>(new Map());
+  useEffect(() => {
+    if (!autoCall.enabled) return;
+    const now = Date.now();
+    // A QSO is in progress somewhere if ANY receiver is transmitting or still
+    // holding a DX call it has not finished with. Both matter: between overs the
+    // carrier is down but the exchange is not over, and calling someone else
+    // then is exactly the "it never stops" behaviour.
+    const busy = Object.values(txStates).some((tx) => {
+      if (tx?.transmitting) return true;
+      // A DX call still set means the exchange is not finished — but ONLY while
+      // the sender still intends to transmit. The watchdog stops transmission
+      // and leaves the DX call behind, and reading the call alone left auto-call
+      // waiting for a QSO that had already been given up on, for ever.
+      if (!tx?.dx_call?.trim()) return false;
+      if (tx.tx_enabled === false) return false;
+      // Backstop for a sender that never reports the toggle: an exchange with no
+      // transmission for three minutes is over, whatever the DX call still says.
+      // Measured from the last TIME THE CARRIER WAS UP — Status itself arrives
+      // every second and so can never go stale.
+      const last = lastTxAtRef.current.get(tx.instance ?? '');
+      return last === undefined || now - last < 180_000;
+    })
+      // The hold closes the gap between sending a Reply and the receiver saying
+      // it has acted on it — about a second. Without it the OTHER instance still
+      // looks idle in that window and gets a call of its own.
+      || now < autoHoldUntilRef.current;
+    for (const d of decodes) {
+      const seenKey = `${d.call}|${d.ms ?? d.at}|${d.instance ?? ''}`;
+      if (autoSeenRef.current.has(seenKey)) continue;
+      // Only decodes from the CURRENT period are worth answering: replying to a
+      // slot that has closed asks the far end to match a decode it has dropped.
+      if (now - Date.parse(d.at) > 30_000) { autoSeenRef.current.add(seenKey); continue; }
+      const e = spotStatus[`${d.call}|${d.band ?? ''}|${(d.mode ?? '').toUpperCase()}`];
+      // NOT marked seen until its status has resolved. Statuses land a few
+      // hundred milliseconds after the decode, so consuming it on first sight
+      // would throw away almost every decode unjudged — the effect re-runs when
+      // spotStatus changes, and this is what lets it look again.
+      if (!e) continue;
+      autoSeenRef.current.add(seenKey);
+      const verdict = shouldAutoCall(autoCall, d, e as any, {
+        busy,
+        calledAt: autoCalledRef.current,
+        now,
+        myCall: station.callsign,
+      });
+      if (!verdict.call) continue;
+      autoCalledRef.current.set(d.call.toUpperCase(), now);
+      autoHoldUntilRef.current = now + 12_000; // an FT8 slot, near enough
+      // Same reason as a manual click: put the transmitter on the decode's band
+      // before answering, or a second slice answers on the wrong one.
+      FlexTXOnBand(d.band ?? '').catch(() => {});
+      // Logged, always: an automatic transmission with no record of WHY is the
+      // one thing an operator cannot argue with after the fact.
+      LogUIError('auto-call', `calling ${d.call} — ${verdict.reason}`, '');
+      AnswerDecode(
+        d.instance ?? '', d.ms ?? 0, d.snr, d.dt ?? 0,
+        d.audio_hz ?? 0, d.mode_raw || d.mode || '', d.msg_raw ?? d.msg ?? '', !!d.low_conf,
+      ).catch((e2: any) => setError(String(e2?.message ?? e2)));
+      onCallsignInput(d.call, { force: true });
+      break; // one per pass: a period can hold several, and we work one station
+    }
+    // The seen-set is bounded by the same half hour the decode list keeps.
+    if (autoSeenRef.current.size > 20000) autoSeenRef.current.clear();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [decodes, spotStatus, autoCall, txStates]);
   // Staged like the cluster's, so a period arriving as one burst of fifty
   // packets costs one status lookup and one render, not fifty of each.
   const pendingDecodesRef = useRef<DecodeRow[]>([]);
@@ -2213,6 +2324,11 @@ export default function App() {
   const refreshChaseNew = useCallback(() => { GetChaseNew().then(setChaseNewOn).catch(() => {}); }, []);
   useEffect(() => { refreshChaseNew(); }, [refreshChaseNew]);
   const [showBeamOnMap, setShowBeamOnMap] = useState(() => localStorage.getItem('opslog.showBeamOnMap') !== '0');
+  // Compact rotor widget (Settings → Rotator): dial + SP/LP only. RotorCompass
+  // already draws exactly that when it is given neither presets nor onStop —
+  // withholding them IS the compact mode, so there is no second layout to keep
+  // in step with the first.
+  const [rotorCompact, setRotorCompact] = useState(() => localStorage.getItem('opslog.rotorCompact') === '1');
 
   // 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.
@@ -3131,6 +3247,14 @@ export default function App() {
       // even between overs, and on a sender that never reports its transmit
       // text at all.
       setTxState(m as TxMsgRow);
+      if (m?.instance) {
+        setTxStates((prev) => ({ ...prev, [m.instance]: m as TxMsgRow }));
+        // When this receiver last actually TRANSMITTED, which is not the same as
+        // when it last spoke: Status arrives about once a second whether the
+        // carrier is up or not, so it can never say how long an exchange has
+        // been stalled.
+        if (m.transmitting) lastTxAtRef.current.set(m.instance, Date.now());
+      }
       // The period history takes only real transmissions — Status repeats
       // itself once a second whether the carrier is up or not.
       if (!m?.transmitting || !String(m?.msg ?? '').trim()) return;
@@ -4313,6 +4437,7 @@ export default function App() {
       { type: 'item', label: t('stats.tab'), action: 'tools.stats' },
       { type: 'item', label: t('station.title'), action: 'tools.station' },
       { type: 'item', label: t('dec.tab'), action: 'tools.decodes' },
+      { type: 'item', label: t('gsm.title'), action: 'tools.grids' },
       { type: 'item', label: t('tools.qslDesigner'), action: 'tools.qsldesigner' },
       { type: 'separator' },
       { type: 'item', label: (wkEnabled ? '✓ ' : '') + t('tools.winkeyer'), action: 'tools.winkeyer' },
@@ -4363,6 +4488,7 @@ export default function App() {
       case 'tools.stats':       setStatsTabOpen(true); setActiveTab('stats'); break;
       case 'tools.station':     setStationTabOpen(true); setActiveTab('station'); break;
       case 'tools.decodes':     openDecodesTab(); break;
+      case 'tools.grids':       openGridsTab(); break;
       case 'tools.qsldesigner': setQslDesignerOpen(true); break;
       case 'tools.winkeyer':    wkSetEnabled(!wkEnabled); break;
       case 'tools.dvk':         setDvkEnabled((v) => !v); break;
@@ -5192,18 +5318,26 @@ export default function App() {
           || (!!e?.new_grid && clusterStatusFilter.has('new-grid'));
         if (!matches) return false;
       }
-      // LoTW only, and the spotter's continent. Both are properties of the
+      // The spotter's continent comes from the SPOT, never from spotStatus.
-      // station rather than judgements about the spot, so they AND with the
+      // spotStatus is keyed by call|band|mode, and one DX call is spotted by
-      // status chips instead of joining that OR: "a new band, and from Europe".
+      // skimmers on every continent within the same minute — so they all shared
-      if (clusterLotwOnly || clusterSpotterConts.size > 0) {
+      // whichever spotter arrived first, and picking AF left the Indian and
+      // American skimmers exactly where they were. The spot carries its own.
+      //
+      // A spot whose spotter could not be resolved IS dropped here: the value
+      // arrives with the row, so there is no window to flicker through, and
+      // silently keeping unresolved rows is what made the old bug invisible.
+      if (clusterSpotterConts.size > 0) {
+        if (!clusterSpotterConts.has((s as any).spotter_continent ?? '')) return false;
+      }
+      // LoTW is a property of the DX station, so it stays on the status entry —
+      // where call|band|mode is exactly the right key.
+      if (clusterLotwOnly) {
         const k = spotStatusKey(s.dx_call, s.band ?? '', s.comment ?? '', s.freq_hz);
         const e = spotStatus[k];
         // An unresolved spot is not filtered out. The status arrives a moment
         // after the row does, and dropping it meanwhile made the list flicker.
-        if (e) {
+        if (e && !e.lotw) return false;
-          if (clusterLotwOnly && !e.lotw) return false;
-          if (clusterSpotterConts.size > 0 && e.spotter_continent && !clusterSpotterConts.has(e.spotter_continent)) return false;
-        }
       }
       if (clusterHideWorked) {
         const k = spotStatusKey(s.dx_call, s.band ?? '', s.comment ?? '', s.freq_hz);
@@ -5455,6 +5589,15 @@ export default function App() {
       decodes={decodes}
       txMsgs={txMsgs}
       txState={txState}
+      txStates={txStates}
+      autoCallOn={autoCall.enabled}
+      // Written through the same key Preferences uses, so the two can never
+      // disagree about whether the machine is armed.
+      onToggleAutoCall={() => setAutoCall((prev) => {
+        const next = { ...prev, enabled: !prev.enabled };
+        writeUiPref(autoCallKey, JSON.stringify(next));
+        return next;
+      })}
       spotStatus={spotStatus as any}
       myCall={station.callsign}
       // A click ANSWERS the station: it hands the decode back to WSJT-X/MSHV as
@@ -5467,11 +5610,42 @@ export default function App() {
       // for the VFO. The entry is still filled, so the QSO can be logged here.
       onCall={(d) => {
         onCallsignInput(d.call, { force: true });
+        // With two slices on two bands, the Reply reaches the right INSTANCE but
+        // the radio still transmits on whichever slice holds the TX flag. Move
+        // it to the decode's band first, or an 80 m answer goes out on 20 m.
+        // A no-op on any backend without slices.
+        FlexTXOnBand(d.band ?? '').catch(() => { /* not a Flex, or no such slice */ });
         AnswerDecode(
           d.instance ?? '', d.ms ?? 0, d.snr, d.dt ?? 0,
-          d.audio_hz ?? 0, d.mode ?? '', d.msg ?? '', !!d.low_conf,
+          // The RAW mode marker, not the resolved name: the receiving
+          // application matches the Reply against its decode list field for
+          // field, and JTDX drops one that says "FT8" where it decoded "~".
+          d.audio_hz ?? 0, d.mode_raw || d.mode || '', d.msg_raw ?? d.msg ?? '', !!d.low_conf,
         ).catch((e: any) => setError(String(e?.message ?? e)));
       }}
+      // Wipes the live view only — nothing here is stored, and the staging
+      // buffer goes too or the next flush would put back what was just cleared.
+      onClear={(instance) => {
+        if (!instance) {
+          pendingDecodesRef.current = [];
+          setDecodes([]);
+          setTxMsgs([]);
+          setTxState(null);
+          setTxStates({});
+          return;
+        }
+        // One receiver only: the other pane keeps everything it was showing,
+        // which is the whole reason for clearing just one.
+        pendingDecodesRef.current = pendingDecodesRef.current.filter((d) => (d.instance ?? '') !== instance);
+        setDecodes((a) => a.filter((d) => (d.instance ?? '') !== instance));
+        setTxMsgs((a) => a.filter((m) => (m.instance ?? '') !== instance));
+        setTxStates((prev) => { const n = { ...prev }; delete n[instance]; return n; });
+      }}
+      // An empty instance lets the backend fall back to whichever application
+      // last reported its status — the normal single-receiver case.
+      onHalt={(instance) => {
+        HaltDecodeTx(instance, false).catch((e: any) => setError(String(e?.message ?? e)));
+      }}
     />
   );
 
@@ -6489,12 +6663,14 @@ export default function App() {
             </div>
           )}
           {/* Rotor compass: azimuth dial + needles + click-to-turn. Shows when a
-              rotator is configured or a DX bearing exists. */}
+              rotator is configured or a DX bearing exists. Compact mode drops the
+              controls column, so the widget is just the dial and needs only its
+              width. */}
           {showRotor && (rotatorHeading.enabled || dxPath) && (
-            <div className="w-[320px] shrink-0 min-h-0">
+            <div className={cn('shrink-0 min-h-0', rotorCompact ? 'w-[196px]' : 'w-[320px]')}>
               <RotorCompass
-                presets={rotorPresets}
+                presets={rotorCompact ? undefined : rotorPresets}
-                onStop={() => { RotatorStop().then(pokeRotorHeading).catch((err) => setError(String(err?.message ?? err))); }}
+                onStop={rotorCompact ? undefined : () => { RotatorStop().then(pokeRotorHeading).catch((err) => setError(String(err?.message ?? err))); }}
                 bearing={dxPath?.bearingShort ?? null}
                 headings={beamHeadings}
                 boomHeading={boomHeading}
@@ -6773,6 +6949,21 @@ export default function App() {
                   </span>
                 </TabsTrigger>
               )}
+              {gridsTabOpen && (
+                <TabsTrigger value="grids" className="gap-1.5">
+                  {t('gsm.title')}
+                  <span
+                    role="button"
+                    aria-label="Close grid squares"
+                    title="Close"
+                    className="inline-flex items-center justify-center size-4 rounded hover:bg-foreground/10 text-muted-foreground hover:text-foreground"
+                    onPointerDown={(e) => { e.stopPropagation(); }}
+                    onClick={(e) => { e.stopPropagation(); closeGridsTab(); }}
+                  >
+                    <X className="size-3" />
+                  </span>
+                </TabsTrigger>
+              )}
               {decodesTabOpen && (
                 <TabsTrigger value="decodes" className="gap-1.5">
                   {t('dec.tab')}
@@ -6832,7 +7023,8 @@ export default function App() {
                 <div className="relative flex-1">
                   <Input
                     className="w-full pr-8 font-mono"
-                    placeholder="Search callsign…"
+                    placeholder={t('rq.searchPh')}
+                    title={t('rq.searchTip')}
                     value={filterCallsign}
                     onChange={(e) => setFilterCallsign(e.target.value.toUpperCase())}
                   />
@@ -7201,7 +7393,26 @@ export default function App() {
                 updating) while you work on other tabs. */}
             {qslTabOpen && (
               <TabsContent value="qsl" forceMount className="mt-0 flex flex-col min-h-0 flex-1 data-[state=inactive]:hidden">
-                <QSLManagerPanel onEditQSO={openEdit} />
+                <QSLManagerPanel
+                  onEditQSO={openEdit}
+                  // The same row actions the Recent QSOs grid offers. Only the
+                  // selection-based exports: exporting "the filter" would mean
+                  // the Recent-QSOs filter, not the rows shown here.
+                  actions={{
+                    onUpdateFromCty: bulkUpdateFromCty,
+                    onUpdateFromQRZ: bulkUpdateFromQRZ,
+                    onUpdateFromClublog: bulkUpdateFromClublog,
+                    onUpdateCountyFromULS: ulsReady ? bulkUpdateCountyFromULS : undefined,
+                    onSendTo: bulkSendTo,
+                    onSendRecording: bulkSendRecording,
+                    onSendEQSL: (ids) => setEqslQsoId(ids[0] ?? null),
+                    onBulkEdit: openBulkEdit,
+                    onExportSelected: exportSelectedADIF,
+                    onExportSelectedFields: exportSelectedFields,
+                    onExportCabrilloSelected: exportSelectedCabrillo,
+                    onDelete: (ids) => setDeletingIds(ids),
+                  }}
+                />
               </TabsContent>
             )}
 
@@ -7240,6 +7451,12 @@ export default function App() {
               </TabsContent>
             )}
 
+            {gridsTabOpen && (
+              <TabsContent value="grids" className="mt-0 flex flex-col min-h-0 flex-1 data-[state=inactive]:hidden">
+                <GridSquareMap myGrid={station.my_grid} className="flex-1 min-h-0" />
+              </TabsContent>
+            )}
+
             {decodesTabOpen && (
               <TabsContent value="decodes" className="mt-0 flex flex-col min-h-0 flex-1 data-[state=inactive]:hidden">
                 {renderDecodesPanel()}

frontend/src/components/ClusterGrid.tsx

@@ -69,6 +69,7 @@ export type SpotStatusEntry = {
   spotter_continent?: string;
   grid?: string;
   new_grid?: boolean;
+  grid_state?: string;
 };
 
 type Props = {
@@ -266,12 +267,12 @@ const makeColCatalog = (t: TFn): ColEntry[] => [
       if (s?.new_county) parts.push(t('clg2.newCounty'));
       if (s?.new_pota) parts.push(t('clg2.newPota'));
       if (s?.new_pfx) parts.push(t('clg2.newPfx'));
-      if (s?.new_grid) parts.push(t('clg2.newGrid'));
+      if (s?.new_grid) parts.push(s.grid_state === 'unconf' ? t('clg2.newGridUnconf') : t('clg2.newGrid'));
       return parts.join(' ');
     },
     cellRenderer: (p: any) => {
       const s = statusFor(p);
-      const parts: { text: string; color: string }[] = [];
+      const parts: { text: string; color: string; dim?: boolean }[] = [];
       const main = statusColor(s);
       if (main) {
         const label = s?.status === 'new' ? t('clg2.newDxcc')
@@ -287,12 +288,19 @@ const makeColCatalog = (t: TFn): ColEntry[] => [
       if (s?.new_county) parts.push({ text: t('clg2.newCounty'), color: markerColour('new_county') });
       if (s?.new_pota) parts.push({ text: t('clg2.newPota'), color: markerColour('new_pota') });
       if (s?.new_pfx) parts.push({ text: t('clg2.newPfx'), color: markerColour('new_pfx') });
-      if (s?.new_grid) parts.push({ text: t('clg2.newGrid'), color: markerColour('new_grid') });
+      // Worked-but-unconfirmed is a QSL to chase, not a QSO to make. Same hue
+      // held back, so it reads as "less" of the same thing rather than a
+      // different fact — and the label says which.
+      if (s?.new_grid) {
+        parts.push(s.grid_state === 'unconf'
+          ? { text: t('clg2.newGridUnconf'), color: markerColour('new_grid'), dim: true }
+          : { text: t('clg2.newGrid'), color: markerColour('new_grid') });
+      }
       if (parts.length === 0) return <span style={{ color: 'var(--muted-foreground)', fontSize: 10 }}>—</span>;
       return (
         <span style={{ whiteSpace: 'nowrap' }}>
           {parts.map((pt, i) => (
-            <span key={i} style={{ color: pt.color, fontWeight: 700 }}>
+            <span key={i} style={{ color: pt.color, fontWeight: 700, opacity: pt.dim ? 0.5 : 1 }}>
               {i > 0 ? ' · ' : ''}{pt.text}
             </span>
           ))}
@@ -638,6 +646,17 @@ export function ClusterGrid({ rows, spotStatus, onSpotClick }: Props) {
               {t('clg2.pickerDesc')}
             </DialogDescription>
           </DialogHeader>
+          {/* Whole-dialog controls. showAll/hideAll with no group already mean
+              "every column"; only the buttons were missing, so hiding the lot
+              took one click per group. */}
+          <div className="flex items-center gap-1 px-1 text-[11px] text-muted-foreground">
+            <span>{t('clg2.allGroups')}</span>
+            <button type="button" className="text-[11px] text-primary hover:underline px-1"
+              onClick={() => showAll()}>{t('clg2.all')}</button>
+            <span className="opacity-40">·</span>
+            <button type="button" className="text-[11px] text-muted-foreground hover:underline px-1"
+              onClick={() => hideAll()}>{t('clg2.none')}</button>
+          </div>
           <div className="max-h-[60vh] overflow-y-auto py-2">
             {GROUP_ORDER.map((group) => {
               const cols = COL_CATALOG.filter((c) => c.group === group);

frontend/src/components/DecodesPanel.tsx

@@ -13,10 +13,11 @@
 // come from the same resolver the cluster uses, so a call means the same thing in
 // both panels rather than being judged twice by two rules.
 import { useEffect, useMemo, useState } from 'react';
-import { Radio, Search, X, Signal, ArrowUpRight, Timer } from 'lucide-react';
+import { Radio, Search, X, Signal, ArrowUpRight, Timer, Trash2, Ban, Columns2, Bot } from 'lucide-react';
 import { cn } from '@/lib/utils';
 import { useI18n } from '@/lib/i18n';
 import { markerColour, type SpotMarkerKey } from '@/lib/spotMarkers';
+import { writeUiPref } from '@/lib/uiPref';
 
 export type Decode = {
   call: string;
@@ -38,6 +39,12 @@ export type Decode = {
   // Replayed verbatim when answering the station — see AnswerDecode.
   ms?: number;
   low_conf?: boolean;
+  // The mode field as the Decode carried it (the "~"/"+" marker). `mode` above
+  // is the resolved name, for display and for the log; a Reply has to send this
+  // one back or the receiving application finds no matching decode.
+  mode_raw?: string;
+  // The message as sent, untrimmed — replayed in a Reply for the same reason.
+  msg_raw?: string;
 };
 
 export type TxMsg = {
@@ -49,6 +56,9 @@ export type TxMsg = {
   freq_hz?: number;
   instance?: string;
   transmitting?: boolean;
+  // The sender's Enable Tx toggle. The watchdog clears it while leaving the DX
+  // call set — the only sign an exchange was abandoned rather than paused.
+  tx_enabled?: boolean;
   at: string;
 };
 
@@ -62,6 +72,9 @@ type StatusEntry = {
   new_pota?: boolean;
   new_pfx?: boolean;
   new_grid?: boolean;
+  // "new" = never worked, "unconf" = worked and awaiting a confirmation.
+  grid_state?: string;
+  grid?: string;
   lotw?: boolean;
 };
 
@@ -71,9 +84,27 @@ interface Props {
   // txState is the LIVE transmit state — what is going out right now and to
   // whom. Separate from txMsgs, which is the history threaded into the periods.
   txState?: TxMsg | null;
+  // The same, keyed by instance. In a split view the shared txState is whichever
+  // receiver reported last, which is a coin toss — each pane needs its own.
+  txStates?: Record<string, TxMsg>;
   spotStatus: Record<string, StatusEntry>;
   onCall: (d: Decode) => void;
   myCall?: string;
+  // Drop every decode and transmit message held for this panel. The list is a
+  // live view, not data — clearing it costs nothing but the seconds until the
+  // next period lands.
+  // instance = clear just that receiver's decodes; empty = all of them. A split
+  // view needs the narrow form: clearing both because you wanted one is the same
+  // loss of context the split exists to prevent.
+  onClear?: (instance?: string) => void;
+  // Stop the decoding application transmitting, mid-over. Routed to one
+  // instance by program id — see HaltDecodeTx.
+  onHalt?: (instance: string) => void;
+  // Auto-call on/off, mirrored here as well as in Preferences: it is the one
+  // setting an operator wants to reach WITHOUT leaving the band — turning the
+  // machine off is not something to go hunting through a settings tree for.
+  autoCallOn?: boolean;
+  onToggleAutoCall?: () => void;
 }
 
 // The "new" categories, as toggle badges — the same idea and the same colours as
@@ -113,6 +144,33 @@ function catsOf(e: StatusEntry | undefined): Set<NewCat> {
 }
 
 const CAT_KEY = 'opslog.decodeCats';
+const SPLIT_KEY = 'opslog.decodeSplit';
+const FILTER_KEY = 'opslog.decodeFilters';
+
+// usePersisted is useState that survives the panel being unmounted.
+//
+// All the filters share ONE stored object rather than a key each: they are read
+// and written together, and a dozen localStorage entries for one filter bar is a
+// dozen things to keep in step when one of them is renamed.
+function readFilters(): Record<string, unknown> {
+  try {
+    const v = JSON.parse(localStorage.getItem(FILTER_KEY) || '{}');
+    return v && typeof v === 'object' ? v : {};
+  } catch { return {}; }
+}
+function usePersisted<T>(key: string, fallback: T): [T, (v: T) => void] {
+  const [v, setV] = useState<T>(() => {
+    const stored = readFilters()[key];
+    return (typeof stored === typeof fallback ? stored as T : fallback);
+  });
+  const set = (next: T) => {
+    setV(next);
+    try {
+      localStorage.setItem(FILTER_KEY, JSON.stringify({ ...readFilters(), [key]: next }));
+    } catch { /* quota / private mode — the filter still works this session */ }
+  };
+  return [v, set];
+}
 
 // DEFAULT_TR is the slot length assumed when nothing better is known. Fifteen
 // seconds is FT8, the overwhelming majority of what arrives here; a wrong guess
@@ -144,15 +202,17 @@ function trSeconds(mode?: string, reported?: number): number {
   return DEFAULT_TR;
 }
 
-// ROW is the column template, shared by the header and every row so the two can
+// ROW is the grid shell, shared by the header and every row so the two can
-// never drift. Full width and left-aligned — an earlier pass centred it inside a
+// never drift. The column TEMPLATE is no longer baked in: every column has a
-// maximum width, which on a wide screen opened a huge dead margin down the left
+// width the operator can drag, so the table takes exactly the room it needs and
-// before the first callsign.
+// no more.
 //
-// Message is the one elastic column, with a floor so it does not collapse; the
+// Message used to be an elastic 1fr column. On a wide screen that handed it
-// slack lands there rather than between two fixed columns, which is what read as
+// every spare pixel — a message column hundreds of pixels wider than its longest
-// a hole in the middle of every line.
+// line, with Country and Status marooned against the far edge. Fixed widths
-const ROW = 'grid grid-cols-[64px_50px_44px_56px_50px_44px_minmax(240px,1fr)_140px_186px] items-stretch';
+// throughout mean the slack stays OUTSIDE the table, which is where a second
+// panel can go.
+const ROW = 'grid items-stretch';
 
 // CELL draws the column rule. items-stretch above plus a right border here is
 // what makes the lines run unbroken from the header to the bottom of the list —
@@ -160,6 +220,84 @@ const ROW = 'grid grid-cols-[64px_50px_44px_56px_50px_44px_minmax(240px,1fr)_140
 const CELL = 'flex items-center min-w-0 px-2 border-r border-border/30';
 const CELL_LAST = 'flex items-center min-w-0 px-2 gap-1 overflow-hidden';
 
+// ── Columns ──────────────────────────────────────────────────────────────────
+// One declaration per column, in display order: the header, the widths and the
+// resize handles all read from this, so a column cannot be resized in the header
+// and stay the old width in the body.
+type ColKey = 'time' | 'snr' | 'dt' | 'freq' | 'band' | 'mode' | 'msg' | 'grid' | 'country' | 'status';
+const COLS: { key: ColKey; tkey: string; def: number; min: number }[] = [
+  { key: 'time',    tkey: 'dec.colTime',    def: 64,  min: 44 },
+  { key: 'snr',     tkey: 'dec.colSnr',     def: 50,  min: 36 },
+  { key: 'dt',      tkey: 'dec.colDt',      def: 44,  min: 32 },
+  { key: 'freq',    tkey: 'dec.colFreq',    def: 56,  min: 40 },
+  { key: 'band',    tkey: 'dec.colBand',    def: 50,  min: 36 },
+  { key: 'mode',    tkey: 'dec.colMode',    def: 44,  min: 36 },
+  // 300 px holds the longest real FT8 line ("<3B9/SQ9UM> LZ3BS KN22") with room
+  // to spare; anything past that was the dead space this replaces.
+  { key: 'msg',     tkey: 'dec.colMsg',     def: 300, min: 120 },
+  // The grid was carried and shown nowhere: it drives the NEW GRID badge, and
+  // an operator chasing squares could see the verdict but never the square.
+  { key: 'grid',    tkey: 'dec.colGrid',    def: 62,  min: 46 },
+  { key: 'country', tkey: 'dec.colCountry', def: 140, min: 70 },
+  { key: 'status',  tkey: 'dec.colStatus',  def: 186, min: 80 },
+];
+const COL_MAX = 600;
+const COLW_KEY = 'opslog.decodeColWidths';
+
+type ColWidths = Record<ColKey, number>;
+const defaultWidths = (): ColWidths =>
+  Object.fromEntries(COLS.map((c) => [c.key, c.def])) as ColWidths;
+
+// Stored widths are merged ONTO the defaults rather than used as-is: a saved set
+// from before a column existed would otherwise leave that column at zero width.
+function loadWidths(): ColWidths {
+  const out = defaultWidths();
+  try {
+    const raw = localStorage.getItem(COLW_KEY);
+    if (!raw) return out;
+    const saved = JSON.parse(raw) as Partial<Record<ColKey, unknown>>;
+    for (const c of COLS) {
+      const v = saved[c.key];
+      if (typeof v === 'number' && Number.isFinite(v)) {
+        out[c.key] = Math.min(COL_MAX, Math.max(c.min, Math.round(v)));
+      }
+    }
+  } catch { /* corrupt value — the defaults are a fine answer */ }
+  return out;
+}
+
+// The drag handle sitting on a column's right edge. Pointer capture, so a fast
+// drag that outruns the cursor still tracks instead of dropping the column.
+// Double-click restores that one column's default width.
+function ColResizer({ onResize, onReset }: { onResize: (dx: number) => void; onReset: () => void }) {
+  return (
+    <span
+      role="separator"
+      aria-orientation="vertical"
+      onDoubleClick={(e) => { e.stopPropagation(); onReset(); }}
+      onPointerDown={(e) => {
+        e.preventDefault();
+        e.stopPropagation();
+        const startX = e.clientX;
+        const el = e.currentTarget;
+        el.setPointerCapture(e.pointerId);
+        const move = (ev: PointerEvent) => onResize(ev.clientX - startX);
+        const up = () => {
+          el.removeEventListener('pointermove', move);
+          el.removeEventListener('pointerup', up);
+        };
+        el.addEventListener('pointermove', move);
+        el.addEventListener('pointerup', up);
+      }}
+      // Wider than it looks: a 1px target is unusable, so the hit area is 7px
+      // with only the hairline painted on hover.
+      className="absolute top-0 right-0 z-10 h-full w-[7px] translate-x-[3px] cursor-col-resize
+                 before:absolute before:inset-y-0 before:left-1/2 before:w-px before:bg-transparent
+                 hover:before:bg-primary"
+    />
+  );
+}
+
 // The "new" badges. Every one of these is a REASON TO CALL, which is why they
 // get a column of their own rather than a coloured edge: a stripe says something
 // is special, a badge says what, and the operator is deciding whether to break
@@ -305,10 +443,77 @@ function snrTone(snr: number): string {
   return 'text-muted-foreground/70';
 }
 
-export function DecodesPanel({ decodes, txMsgs, txState, spotStatus, onCall, myCall }: Props) {
+// buildPeriods cuts a decode list into T/R periods. A plain function, not a
+// memo, because it is run ONCE PER PANE: with two receivers on two bands the
+// panel shows two independent period lists side by side, and each has to be cut
+// with its own slot boundaries.
+function buildPeriods(filtered: Decode[], txMsgs: TxMsg[]) {
+  const by = new Map<number, { decodes: Decode[]; tx: TxMsg[] }>();
+  for (const d of filtered) {
+    const at = Date.parse(d.at);
+    if (!Number.isFinite(at)) continue;
+    const k = periodStartMs(at, trSeconds(d.mode, d.tr_period));
+    let g = by.get(k);
+    if (!g) { g = { decodes: [], tx: [] }; by.set(k, g); }
+    g.decodes.push(d);
+  }
+  for (const m of txMsgs) {
+    const at = Date.parse(m.at);
+    if (!Number.isFinite(at)) continue;
+    const k = periodStartMs(at, trSeconds(m.mode, undefined));
+    // A transmit slot CREATES its period when there is none.
+    //
+    // This is the whole alternation, and getting it wrong hid the feature
+    // completely: FT8 transmits and receives in opposite slots, so the period
+    // you were sending in is exactly the one with no decodes in it. Dropping
+    // the message when its period was empty meant it never appeared at all.
+    let g = by.get(k);
+    if (!g) { g = { decodes: [], tx: [] }; by.set(k, g); }
+    g.tx.push(m);
+  }
+  return [...by.entries()]
+    .sort((a, b) => b[0] - a[0])
+    .map(([start, g]) => ({
+      start,
+      // The slot length this period was cut with, so its heading is labelled
+      // the same way it was grouped.
+      tr: trSeconds(g.decodes[0]?.mode ?? g.tx[0]?.mode, g.decodes[0]?.tr_period),
+      tx: g.tx,
+      // Strongest first inside a period: the eye should land on what is
+      // workable, and time within a slot means nothing — they were all
+      // transmitting simultaneously.
+      decodes: g.decodes.sort((x, y) => y.snr - x.snr),
+    }));
+}
+
+export function DecodesPanel({ decodes, txMsgs, txState, txStates, spotStatus, onCall, myCall, onClear, onHalt, autoCallOn, onToggleAutoCall }: Props) {
   const { t } = useI18n();
-  const [cqOnly, setCqOnly] = useState(false);
+  // Column widths, dragged in the header and shared by every row. Persisted
-  const [lotwOnly, setLotwOnly] = useState(false);
+  // through writeUiPref (not raw localStorage) so the layout travels with data/
+  // like every other portable preference.
+  const [colw, setColw] = useState<ColWidths>(loadWidths);
+  const template = useMemo(() => COLS.map((c) => `${colw[c.key]}px`).join(' '), [colw]);
+  const tableW = useMemo(() => COLS.reduce((s, c) => s + colw[c.key], 0), [colw]);
+  const setColWidth = (key: ColKey, px: number) => {
+    const col = COLS.find((c) => c.key === key)!;
+    const w = Math.min(COL_MAX, Math.max(col.min, Math.round(px)));
+    setColw((prev) => {
+      if (prev[key] === w) return prev;
+      const next = { ...prev, [key]: w };
+      writeUiPref(COLW_KEY, JSON.stringify(next));
+      return next;
+    });
+  };
+  // Split the table into one column per receiver. Off by default: it only means
+  // anything with two instances running, and a single-receiver operator should
+  // not have to turn something off to get the layout they had.
+  const [splitByInstance, setSplitByInstance] = useState(() => localStorage.getItem(SPLIT_KEY) === '1');
+  // Every filter below is persisted, NOT just the NEW badges. The panel is
+  // remounted on a tab change, so anything held only in React state comes back
+  // cleared — which left the badges lit and the rest silently reset, a list that
+  // looks filtered and is not.
+  const [cqOnly, setCqOnly] = usePersisted('cqOnly', false);
+  const [lotwOnly, setLotwOnly] = usePersisted('lotwOnly', false);
   const [cats, setCats] = useState<Set<NewCat>>(() => {
     try {
       const raw = JSON.parse(localStorage.getItem(CAT_KEY) || '[]');
@@ -321,11 +526,11 @@ export function DecodesPanel({ decodes, txMsgs, txState, spotStatus, onCall, myC
     try { localStorage.setItem(CAT_KEY, JSON.stringify([...next])); } catch { /* not worth failing over */ }
     return next;
   });
-  const [bandSel, setBandSel] = useState('');
+  const [bandSel, setBandSel] = usePersisted('bandSel', '');
-  const [modeSel, setModeSel] = useState('');
+  const [modeSel, setModeSel] = usePersisted('modeSel', '');
-  const [contSel, setContSel] = useState('');
+  const [contSel, setContSel] = usePersisted('contSel', '');
-  const [minSnr, setMinSnr] = useState('');
+  const [minSnr, setMinSnr] = usePersisted('minSnr', '');
-  const [search, setSearch] = useState('');
+  const [search, setSearch] = usePersisted('search', '');
 
   const statusOf = (d: Decode): StatusEntry | undefined =>
     spotStatus[`${d.call}|${d.band ?? ''}|${(d.mode ?? '').toUpperCase()}`];
@@ -395,44 +600,27 @@ export function DecodesPanel({ decodes, txMsgs, txState, spotStatus, onCall, myC
 
   // Group into periods, newest first, and drop the operator's transmissions into
   // the slot they went out in.
-  const groups = useMemo(() => {
+  // One PANE per receiver when the split is on. Two receivers on two bands is
-    const by = new Map<number, { decodes: Decode[]; tx: TxMsg[] }>();
+  // the day this panel earns its keep, and merging their decodes into one list
-    for (const d of filtered) {
+  // throws away the only thing that tells them apart.
-      const at = Date.parse(d.at);
+  //
-      if (!Number.isFinite(at)) continue;
+  // Each pane cuts its own periods: the bands differ, so the slot boundaries and
-      const k = periodStartMs(at, trSeconds(d.mode, d.tr_period));
+  // the transmit messages belong to one receiver and not the other.
-      let g = by.get(k);
+  const panes = useMemo(() => {
-      if (!g) { g = { decodes: [], tx: [] }; by.set(k, g); }
+    if (!splitByInstance || instances.length < 2) {
-      g.decodes.push(d);
+      return [{ key: '', label: '', tx: txState ?? undefined, periods: buildPeriods(filtered, txMsgs) }];
     }
-    for (const m of txMsgs) {
+    return instances.map((inst) => ({
-      const at = Date.parse(m.at);
+      key: inst,
-      if (!Number.isFinite(at)) continue;
+      label: inst,
-      const k = periodStartMs(at, trSeconds(m.mode, undefined));
+      tx: txStates?.[inst],
-      // A transmit slot CREATES its period when there is none.
+      periods: buildPeriods(
-      //
+        filtered.filter((d) => (d.instance ?? '') === inst),
-      // This is the whole alternation, and getting it wrong hid the feature
+        txMsgs.filter((m) => (m.instance ?? '') === inst),
-      // completely: FT8 transmits and receives in opposite slots, so the period
+      ),
-      // you were sending in is exactly the one with no decodes in it. Dropping
+    }));
-      // the message when its period was empty meant it never appeared at all.
+  }, [filtered, txMsgs, splitByInstance, instances, txState, txStates]);
-      let g = by.get(k);
+
-      if (!g) { g = { decodes: [], tx: [] }; by.set(k, g); }
-      g.tx.push(m);
-    }
-    return [...by.entries()]
-      .sort((a, b) => b[0] - a[0])
-      .map(([start, g]) => ({
-        start,
-        // The slot length this period was cut with, so its heading is labelled
-        // the same way it was grouped.
-        tr: trSeconds(g.decodes[0]?.mode ?? g.tx[0]?.mode, g.decodes[0]?.tr_period),
-        tx: g.tx,
-        // Strongest first inside a period: the eye should land on what is
-        // workable, and time within a slot means nothing — they were all
-        // transmitting simultaneously.
-        decodes: g.decodes.sort((x, y) => y.snr - x.snr),
-      }));
-  }, [filtered, txMsgs]);
 
   const resetFilters = () => {
     setCqOnly(false); setLotwOnly(false); setBandSel('');
@@ -467,10 +655,10 @@ export function DecodesPanel({ decodes, txMsgs, txState, spotStatus, onCall, myC
         <PeriodClock trSec={liveTr} mode={liveMode} />
         <span className="w-px h-5 bg-border/60 mx-1" />
 
-        <button type="button" className={chip(cqOnly, 'success')} onClick={() => setCqOnly((v) => !v)}>
+        <button type="button" className={chip(cqOnly, 'success')} onClick={() => setCqOnly(!cqOnly)}>
           {t('dec.cqOnly')}
         </button>
-        <button type="button" className={chip(lotwOnly)} onClick={() => setLotwOnly((v) => !v)}>
+        <button type="button" className={chip(lotwOnly)} onClick={() => setLotwOnly(!lotwOnly)}>
           {t('dec.lotwOnly')}
         </button>
 
@@ -545,6 +733,21 @@ export function DecodesPanel({ decodes, txMsgs, txState, spotStatus, onCall, myC
         <span className="flex-1" />
         {/* Which receivers are feeding this. Only with more than one — with a
             single MSHV it is a label stating the obvious. */}
+        {/* Only with two receivers running: with one it would be a control that
+            does nothing, which is worse than no control. */}
+        {instances.length > 1 && (
+          <button
+            type="button"
+            onClick={() => setSplitByInstance((v) => { try { localStorage.setItem(SPLIT_KEY, v ? '0' : '1'); } catch { /* quota */ } return !v; })}
+            title={t('dec.splitTip')}
+            className={cn('h-8 px-2.5 rounded-lg text-sm inline-flex items-center gap-1.5 border',
+              splitByInstance
+                ? 'border-primary bg-primary text-primary-foreground'
+                : 'border-border text-muted-foreground hover:bg-muted hover:text-foreground')}
+          >
+            <Columns2 className="size-3.5" /> {t('dec.split')}
+          </button>
+        )}
         {instances.length > 1 && (
           <span className="text-xs text-muted-foreground">
             {t('dec.instances', { n: instances.length })}
@@ -553,6 +756,55 @@ export function DecodesPanel({ decodes, txMsgs, txState, spotStatus, onCall, myC
         <span className="text-sm text-muted-foreground tabular-nums">
           {t('dec.count', { shown: filtered.length, total: decodes.length })}
         </span>
+
+        {/* Halt and Clear sit together at the right, away from the filters: one
+            talks to the radio, the other only to this list, and neither is a
+            filter. Halt goes LAST — it is the one that must be findable without
+            reading, and the end of the row is the one position that never moves
+            as filters come and go. */}
+        {onToggleAutoCall && (
+          <button
+            type="button"
+            onClick={onToggleAutoCall}
+            title={t('dec.autoCallTip')}
+            className={cn('h-8 px-2.5 rounded-lg text-sm inline-flex items-center gap-1.5 border',
+              // Lit when it is armed, because what matters at a glance is not
+              // "where is the switch" but "is this thing about to transmit".
+              autoCallOn
+                ? 'border-warning bg-warning text-warning-foreground'
+                : 'border-border text-muted-foreground hover:bg-muted hover:text-foreground')}
+          >
+            <Bot className="size-3.5" /> {t('dec.autoCall')}
+          </button>
+        )}
+        {onHalt && (
+          <button
+            type="button"
+            onClick={() => onHalt(txState?.instance ?? '')}
+            title={t('dec.haltTitle')}
+            className={cn('h-8 px-2.5 rounded-lg text-sm inline-flex items-center gap-1.5 border',
+              // Hot while the carrier is actually up: that is when the button is
+              // urgent, and an always-red control stops being read as a warning.
+              txState?.transmitting
+                ? 'border-danger bg-danger text-danger-foreground hover:brightness-110'
+                : 'border-border text-muted-foreground hover:bg-muted hover:text-foreground')}
+          >
+            <Ban className="size-3.5" /> {t('dec.halt')}
+          </button>
+        )}
+        {onClear && (
+          <button
+            type="button"
+            onClick={() => onClear()}
+            disabled={decodes.length === 0 && txMsgs.length === 0}
+            title={t('dec.clearAllTitle')}
+            className="h-8 px-2.5 rounded-lg text-sm text-muted-foreground border border-border
+                       hover:bg-muted hover:text-foreground inline-flex items-center gap-1.5
+                       disabled:opacity-40 disabled:pointer-events-none"
+          >
+            <Trash2 className="size-3.5" /> {t('dec.clearAll')}
+          </button>
+        )}
       </div>
 
       {/* ── What I am sending, and to whom ─────────────────────────── */}
@@ -560,8 +812,7 @@ export function DecodesPanel({ decodes, txMsgs, txState, spotStatus, onCall, myC
         Its own strip rather than a line in the list: it is the one thing on this
         screen that is about the operator and not about the band, and while a
         period scrolls away this stays put. It appears as soon as a Status
-        arrives, so it says who is being called even on a sender that never
+        arrives, so it says who is being called even before anything is sent.
-        reports its transmit text.
       */}
       {txState && (txState.msg || txState.dx_call) && (
         <div className={cn('flex items-center gap-3 px-3 py-2 shrink-0 border-b',
@@ -571,9 +822,18 @@ export function DecodesPanel({ decodes, txMsgs, txState, spotStatus, onCall, myC
             {txState.transmitting && <span className="size-2 rounded-full bg-primary animate-pulse" />}
             {txState.transmitting ? t('dec.txNow') : t('dec.txIdle')}
           </span>
+          {/* An EMPTY tx_message is the ordinary state between overs — WSJT-X,
+              JTDX and MSHV all send Status about once a second with nothing in
+              that field when nothing is queued. Reading it as "this application
+              does not report its transmit text" accused the sender of a
+              shortcoming on the strength of one empty string, and said so for
+              most of every cycle. Only a sender that is KEYED and still tells us
+              nothing has actually withheld anything. */}
           {txState.msg
             ? <span className="font-mono text-base font-semibold text-foreground truncate">{txState.msg}</span>
-            : <span className="text-sm text-muted-foreground italic">{t('dec.txUnknown')}</span>}
+            : <span className="text-sm text-muted-foreground italic">
+                {txState.transmitting ? t('dec.txUnknown') : t('dec.txNothing')}
+              </span>}
           {txState.dx_call && (
             <span className="flex items-center gap-1.5 shrink-0">
               <span className="text-xs text-muted-foreground uppercase tracking-wider">{t('dec.working')}</span>
@@ -588,24 +848,83 @@ export function DecodesPanel({ decodes, txMsgs, txState, spotStatus, onCall, myC
         </div>
       )}
 
+      {/* One table per receiver when the split is on, side by side. Each pane
+          carries its OWN column header: they are independent tables at their own
+          widths, and one shared header row would line up with none of them. */}
+      <div className="flex-1 min-h-0 flex gap-px bg-border/40">
+        {panes.map((pane) => (
+          <div key={pane.key}
+            className={cn('flex-1 min-w-0 flex flex-col min-h-0 bg-card',
+              pane.tx?.transmitting && 'ring-2 ring-primary ring-inset')}>
+            {pane.label && (
+              <div className={cn('shrink-0 flex items-center gap-1.5 px-2 py-1 border-b border-border',
+                pane.tx?.transmitting ? 'bg-primary/15 border-primary/40' : 'bg-muted/40')}>
+                <span className="text-[10px] font-semibold uppercase tracking-wider text-muted-foreground truncate">
+                  {pane.label}
+                </span>
+                {/* This pane's OWN transmit line. The shared strip shows whichever
+                    instance reported last, which in a split view is a coin toss. */}
+                {pane.tx?.msg && (
+                  <span className={cn('font-mono text-[11px] truncate',
+                    pane.tx.transmitting ? 'text-primary font-semibold' : 'text-muted-foreground')}>
+                    {pane.tx.transmitting && (
+                      <span className="inline-flex items-center gap-1 mr-1.5 font-sans font-bold uppercase tracking-wider">
+                        <span className="inline-block size-1.5 rounded-full bg-primary animate-pulse" />
+                        {t('dec.txNow')}
+                      </span>
+                    )}
+                    {pane.tx.msg}
+                  </span>
+                )}
+                <span className="flex-1" />
+                {onHalt && (
+                  <button type="button"
+                    onClick={() => onHalt(pane.key)}
+                    title={t('dec.haltOne', { n: pane.label })}
+                    className={cn('h-6 px-1.5 rounded text-[11px] inline-flex items-center gap-1 border',
+                      pane.tx?.transmitting
+                        ? 'border-danger bg-danger text-danger-foreground'
+                        : 'border-border text-muted-foreground hover:bg-muted hover:text-foreground')}>
+                    <Ban className="size-3" /> {t('dec.halt')}
+                  </button>
+                )}
+                {onClear && (
+                  <button type="button"
+                    onClick={() => onClear(pane.key)}
+                    title={t('dec.clearOne', { n: pane.label })}
+                    className="h-6 px-1.5 rounded text-[11px] inline-flex items-center gap-1 border border-border text-muted-foreground hover:bg-muted hover:text-foreground">
+                    <Trash2 className="size-3" />
+                  </button>
+                )}
+              </div>
+            )}
       {/* ── Column header ──────────────────────────────────────────── */}
-      <div className="shrink-0 border-b border-border bg-background">
+      <div className="shrink-0 border-b border-border bg-background overflow-hidden">
-        <div className={cn(ROW, 'h-7 text-[10px] font-semibold uppercase tracking-wider text-muted-foreground')}>
+        <div className={cn(ROW, 'h-7 text-[10px] font-semibold uppercase tracking-wider text-muted-foreground')}
-          <span className={CELL}>{t('dec.colTime')}</span>
+          style={{ gridTemplateColumns: template, width: tableW }}>
-          <span className={cn(CELL, 'justify-end')}>{t('dec.colSnr')}</span>
+          {COLS.map((c, i) => (
-          <span className={cn(CELL, 'justify-end')} title={t('dec.colDtTitle')}>{t('dec.colDt')}</span>
+            <span key={c.key}
-          <span className={cn(CELL, 'justify-end')} title={t('dec.colFreqTitle')}>{t('dec.colFreq')}</span>
+              // Not CELL_LAST for the final column: its overflow-hidden would
-          <span className={CELL}>{t('dec.colBand')}</span>
+              // clip that column's own resize handle.
-          <span className={CELL}>{t('dec.colMode')}</span>
+              className={cn('relative flex items-center min-w-0 px-2',
-          <span className={CELL}>{t('dec.colMsg')}</span>
+                i < COLS.length - 1 && 'border-r border-border/30',
-          <span className={CELL}>{t('dec.colCountry')}</span>
+                // The three numeric columns label their own right edge, where the
-          <span className={CELL_LAST}>{t('dec.colStatus')}</span>
+                // figures are.
+                (c.key === 'snr' || c.key === 'dt' || c.key === 'freq') && 'justify-end')}
+              title={c.key === 'dt' ? t('dec.colDtTitle') : c.key === 'freq' ? t('dec.colFreqTitle') : undefined}>
+              <span className="truncate">{t(c.tkey)}</span>
+              <ColResizer
+                onResize={(dx) => setColWidth(c.key, colw[c.key] + dx)}
+                onReset={() => setColWidth(c.key, c.def)}
+              />
+            </span>
+          ))}
         </div>
       </div>
 
       {/* ── Periods ────────────────────────────────────────────────── */}
-      <div className="flex-1 min-h-0 overflow-y-auto">
+      <div className="flex-1 min-h-0 overflow-y-auto overflow-x-hidden">
-        {groups.length === 0 && (
+        {pane.periods.length === 0 && (
           <div className="h-full flex items-center justify-center px-6 text-center">
             <p className="text-sm text-muted-foreground max-w-md">
               {decodes.length === 0 ? t('dec.empty') : t('dec.emptyFiltered')}
@@ -613,7 +932,7 @@ export function DecodesPanel({ decodes, txMsgs, txState, spotStatus, onCall, myC
           </div>
         )}
 
-        {groups.map((g, gi) => (
+        {pane.periods.map((g, gi) => (
           <section key={g.start}>
             {/* Period header — sticky, so the slot being read is always named. */}
             <header className="sticky top-0 z-10 px-3 bg-muted/95 backdrop-blur border-y border-border/60">
@@ -666,7 +985,8 @@ export function DecodesPanel({ decodes, txMsgs, txState, spotStatus, onCall, myC
                   type="button"
                   onClick={() => onCall(d)}
                   title={t('dec.callTitle', { call: d.call })}
-                  className={cn(ROW, 'w-full text-left border-b border-border/20 transition-colors',
+                  style={{ gridTemplateColumns: template, width: tableW }}
+                  className={cn(ROW, 'text-left border-b border-border/20 transition-colors',
                     replying ? 'bg-success/20 hover:bg-success/25'
                       : worked ? 'bg-danger/15 hover:bg-danger/20'
                       : mine ? 'bg-info/10'
@@ -716,6 +1036,16 @@ export function DecodesPanel({ decodes, txMsgs, txState, spotStatus, onCall, myC
                     <span className="truncate">{renderMsg(d.msg ?? '', me, calling)}</span>
                   </span>
 
+                  {/* The decode's own grid first, the remembered one as the
+                      fallback: this period's message is more current than
+                      whatever was cached from an earlier one. Dimmed when it is
+                      the remembered value, so "heard it now" and "known from
+                      before" are not read as the same thing. */}
+                  <span className={cn(CELL, 'font-mono text-[11px]',
+                    d.grid ? 'text-foreground/85' : 'text-muted-foreground/70')}>
+                    <span className="truncate">{d.grid || e?.grid || ''}</span>
+                  </span>
+
                   <span className={cn(CELL, 'text-[11px] text-muted-foreground')}>
                     <span className="truncate">{e?.country ?? ''}</span>
                   </span>
@@ -737,13 +1067,25 @@ export function DecodesPanel({ decodes, txMsgs, txState, spotStatus, onCall, myC
                         {t(entity.label)}
                       </span>
                     )}
-                    {extras.map((b) => (
+                    {extras.map((b) => {
-                      <span key={b.key as string}
+                      // A square WORKED but not yet confirmed is a different job
-                        className="rounded border px-1 py-px text-[10px] font-semibold uppercase tracking-wide bg-transparent shrink-0"
+                      // from one never worked: a QSL to chase, not a QSO to make.
-                        style={{ borderColor: markerColour(b.marker), color: markerColour(b.marker) }}>
+                      // Same hue, held back — the badge reads as "less" of the
-                        {t(b.label)}
+                      // same thing, and its label says which. One badge for both
-                      </span>
+                      // is what made a station worked an hour ago read as new.
-                    ))}
+                      const unconf = b.key === 'new_grid' && e?.grid_state === 'unconf';
+                      const c = markerColour(b.marker);
+                      return (
+                        <span key={b.key as string}
+                          title={unconf ? t('dec.bgGridUnconfTip') : undefined}
+                          className="rounded border px-1 py-px text-[10px] font-semibold uppercase tracking-wide bg-transparent shrink-0"
+                          style={unconf
+                            ? { borderColor: c, color: c, opacity: 0.45, borderStyle: 'dashed' }
+                            : { borderColor: c, color: c }}>
+                          {unconf ? t('dec.bgGridUnconf') : t(b.label)}
+                        </span>
+                      );
+                    })}
                     {replying && (
                       <span className="rounded px-1 py-px text-[10px] font-bold uppercase bg-success text-success-foreground shrink-0">
                         {t('dec.toYou')}
@@ -755,6 +1097,9 @@ export function DecodesPanel({ decodes, txMsgs, txState, spotStatus, onCall, myC
             })}
           </section>
         ))}
+      </div>
+          </div>
+        ))}
       </div>
     </div>
   );

frontend/src/components/ExportFieldsDialog.tsx

@@ -86,6 +86,13 @@ export function ExportFieldsDialog({ open, count, onExport, onClose }: {
     return [...m.entries()];
   }, [official]);
 
+  // Every tag the dialog can offer — the extras AND every group — so "select
+  // all" means what it says rather than "all the official ones".
+  const everyTag = useMemo(
+    () => [...extras, ...groups.flatMap(([, list]) => list.map((d) => d.name))],
+    [extras, groups],
+  );
+
   const toggle = (name: string, on: boolean) =>
     setSel((s) => { const n = new Set(s); if (on) n.add(name); else n.delete(name); return n; });
   const setMany = (names: string[], on: boolean) =>
@@ -114,11 +121,25 @@ export function ExportFieldsDialog({ open, count, onExport, onClose }: {
           <DialogDescription>{t('exf.desc')}</DialogDescription>
         </DialogHeader>
 
+        {/* Whole-dialog select/clear, next to the count they change. Per-group
+            links alone meant clearing the selection was one click PER GROUP —
+            a dozen of them to get to "just the handful I want". */}
         <div className="flex items-center gap-2 px-1 text-[11px] text-muted-foreground">
           <span>{t('exf.chosen', { n: sel.size })}</span>
-          <Button variant="ghost" size="sm" className="ml-auto h-6 text-[11px]" onClick={() => setSel(defaultSet(official))}>
+          <span className="ml-auto inline-flex items-center gap-1">
-            {t('exf.defaults')}
+            <Button variant="ghost" size="sm" className="h-6 text-[11px]"
-          </Button>
+              onClick={() => setSel(new Set(everyTag))}>
+              {t('exf.selectAll')}
+            </Button>
+            <Button variant="ghost" size="sm" className="h-6 text-[11px]"
+              disabled={sel.size === 0}
+              onClick={() => setSel(new Set())}>
+              {t('exf.selectNone')}
+            </Button>
+            <Button variant="ghost" size="sm" className="h-6 text-[11px]" onClick={() => setSel(defaultSet(official))}>
+              {t('exf.defaults')}
+            </Button>
+          </span>
         </div>
 
         <div className="grid grid-cols-3 gap-3 max-h-[56vh] overflow-y-auto pr-1">

frontend/src/components/GridSquareMap.tsx

@@ -0,0 +1,227 @@
+import { useEffect, useMemo, useRef, useState } from 'react';
+import L from 'leaflet';
+import 'leaflet/dist/leaflet.css';
+import { Loader2, RefreshCw } from 'lucide-react';
+import { GridSquares } from '../../wailsjs/go/main/App';
+import { gridSquareBounds, gridToLatLon } from '@/lib/maidenhead';
+import { useI18n } from '@/lib/i18n';
+import { cn } from '@/lib/utils';
+import { BASEMAPS, addBasemap, loadBasemap, type BasemapKey } from '@/components/MainMap';
+import { writeUiPref } from '@/lib/uiPref';
+
+// GridSquareMap — every Maidenhead square in the log, drawn on a world map.
+//
+// A square, not a marker. The question this answers is "where have I been
+// heard", and the shape of the answer is an area: a wall of squares across the
+// Atlantic and a bare Pacific says something about an antenna that a scatter of
+// pins does not. Confirmed and merely worked are two fills of the same hue —
+// the distinction is a STATE of one thing, not two categories, so it must not
+// be two unrelated colours.
+//
+// 4 characters, never 6: at world zoom a 6-character square is sub-pixel, and
+// aggregating to the big square is also how the count means "contacts in this
+// square" rather than "contacts at this exact spot".
+
+type Square = { grid: string; count: number; confirmed: boolean; band?: string; mode?: string };
+
+// The SAME basemaps the Main-tab world map offers, imported rather than copied:
+// two lists of tile servers is how one map ends up on a provider the other has
+// already been blocked by. This map opened on a hardcoded dark Carto, which is
+// the least legible of the four under translucent squares.
+
+// Leaflet geometry is painted onto a CANVAS, and canvas takes a colour, not a
+// stylesheet: "var(--success)" handed to fillStyle is simply invalid and the
+// shape is silently not drawn — a map with a correct square count and nothing
+// on it. So the token is RESOLVED to its literal value here, once per theme,
+// which is also why every other map in this app passes hex.
+function cssColour(token: string, fallback: string): string {
+  try {
+    const v = getComputedStyle(document.documentElement).getPropertyValue(token).trim();
+    return v || fallback;
+  } catch { return fallback; }
+}
+
+// Mode scope. Two, because the map lives beside a panel that decodes FTx: CW,
+// phone and "everything" answer a question nobody is asking here, and a row of
+// choices that are never the right one is just noise to read past.
+//
+// Digital is every digital mode; FTx is the FT family alone, which is the
+// narrower and usually the honest one — a square worked on RTTY in a contest is
+// not a square worked on FT8.
+const SCOPES = [
+  { key: 'DIGI', label: 'gsm.digital' },
+  { key: 'FTX', label: 'gsm.ftx' },
+] as const;
+type ScopeKey = typeof SCOPES[number]['key'];
+
+const SCOPE_KEY = 'opslog.gridMapScope';
+
+export function GridSquareMap({ myGrid, className }: { myGrid?: string; className?: string }) {
+  const { t } = useI18n();
+  const hostRef = useRef<HTMLDivElement>(null);
+  const mapRef = useRef<L.Map | null>(null);
+  const layerRef = useRef<L.LayerGroup | null>(null);
+  const [squares, setSquares] = useState<Square[] | null>(null);
+  const [busy, setBusy] = useState(false);
+  const [err, setErr] = useState('');
+  const [scope, setScope] = useState<ScopeKey>(
+    () => (SCOPES.some((s) => s.key === localStorage.getItem(SCOPE_KEY))
+      ? (localStorage.getItem(SCOPE_KEY) as ScopeKey) : 'DIGI'));
+
+  const [basemap, setBasemap] = useState<BasemapKey>(loadBasemap);
+  // Repaint the squares when the THEME changes, not the basemap: the fills come
+  // from theme tokens resolved at draw time, so a theme switch leaves them on
+  // the old palette until something forces a redraw.
+  const [themeTick, setThemeTick] = useState(0);
+  useEffect(() => {
+    const obs = new MutationObserver(() => setThemeTick((n) => n + 1));
+    obs.observe(document.documentElement, { attributes: true, attributeFilter: ['data-theme'] });
+    return () => obs.disconnect();
+  }, []);
+
+  const load = async (sc: ScopeKey = scope) => {
+    setBusy(true); setErr('');
+    try {
+      const r = (await GridSquares(sc)) as any;
+      setSquares((Array.isArray(r) ? r : []) as Square[]);
+    } catch (e: any) {
+      setErr(String(e?.message ?? e));
+      setSquares([]);
+    } finally { setBusy(false); }
+  };
+  useEffect(() => { void load(scope); /* eslint-disable-next-line react-hooks/exhaustive-deps */ }, [scope]);
+
+  // One-time map creation. preferCanvas: a busy digital log is a few thousand
+  // rectangles, and as SVG that is a few thousand DOM nodes to lay out on every
+  // pan.
+  useEffect(() => {
+    if (!hostRef.current || mapRef.current) return;
+    const m = L.map(hostRef.current, {
+      preferCanvas: true,
+      zoomControl: true,
+      attributionControl: true,
+      worldCopyJump: true,
+      minZoom: 1,
+    }).setView([25, 0], 2);
+    mapRef.current = m;
+    layerRef.current = L.layerGroup().addTo(m);
+    return () => { m.remove(); mapRef.current = null; layerRef.current = null; };
+  }, []);
+
+  // The chosen basemap, shared with the Main-tab map so picking one there and
+  // finding another here cannot happen.
+  const baseRef = useRef<L.TileLayer | null>(null);
+  const labelsRef = useRef<L.TileLayer | null>(null);
+  useEffect(() => {
+    const m = mapRef.current;
+    if (!m) return;
+    addBasemap(m, basemap, baseRef, labelsRef);
+    baseRef.current?.bringToBack();
+  }, [basemap]);
+
+  // Redraw the squares.
+  useEffect(() => {
+    const layer = layerRef.current;
+    if (!layer) return;
+    layer.clearLayers();
+    // Resolved once for the whole redraw, not per square: getComputedStyle
+    // forces a style flush, and doing that a thousand times is a visible stall.
+    const confirmedColour = cssColour('--success', '#16a34a');
+    const workedColour = cssColour('--chart-1', '#2a78d6');
+    const meColour = cssColour('--warning', '#f59e0b');
+    for (const sq of squares ?? []) {
+      const b = gridSquareBounds(sq.grid);
+      if (!b) continue;
+      // One hue, two states. Confirmed is the solid, saturated one; worked is
+      // the same colour held back — so the eye reads "more" and "less" of the
+      // same thing rather than two unrelated facts.
+      const colour = sq.confirmed ? confirmedColour : workedColour;
+      L.rectangle([[b.south, b.west], [b.north, b.east]], {
+        color: colour,
+        weight: 0.5,
+        opacity: sq.confirmed ? 0.9 : 0.5,
+        fillColor: colour,
+        fillOpacity: sq.confirmed ? 0.55 : 0.22,
+      })
+        .bindTooltip(
+          `${sq.grid} — ${sq.count} QSO${sq.count > 1 ? 's' : ''}` +
+          `${sq.band ? ` · ${sq.band}` : ''}${sq.mode ? ` ${sq.mode}` : ''}` +
+          `${sq.confirmed ? ` · ${t('gsm.confirmed')}` : ''}`,
+          { sticky: true },
+        )
+        .addTo(layer);
+    }
+    // The operator's own square, so the pattern has an origin to be read from.
+    const me = myGrid ? gridToLatLon(myGrid) : null;
+    if (me) {
+      L.circleMarker([me.lat, me.lon], {
+        radius: 4, color: meColour, weight: 2,
+        fillColor: meColour, fillOpacity: 1,
+      }).bindTooltip(myGrid!.toUpperCase(), { sticky: true }).addTo(layer);
+    }
+  }, [squares, myGrid, t, themeTick]);
+
+  const stats = useMemo(() => {
+    const list = squares ?? [];
+    return { total: list.length, confirmed: list.filter((s) => s.confirmed).length };
+  }, [squares]);
+
+  return (
+    // isolate is load-bearing, not tidiness. Leaflet puts its panes at z-index
+    // 400 and its zoom control at 1000, in the PAGE's stacking context — and the
+    // modals here are z-50. Without a stacking context of its own the map floats
+    // over Preferences and hides the Save and Close buttons. isolation:isolate
+    // confines every z-index Leaflet sets to this element.
+    <section className={cn('isolate relative flex flex-col min-h-0 rounded-lg border border-border bg-card overflow-hidden', className)}>
+      <header className="flex items-center gap-2 px-2.5 py-1.5 border-b border-border bg-muted/40 shrink-0 flex-wrap">
+        <span className="text-xs font-semibold uppercase tracking-wider text-muted-foreground">
+          {t('gsm.title')}
+        </span>
+        <div className="inline-flex rounded-md border border-border overflow-hidden">
+          {SCOPES.map((s, i) => (
+            <button key={s.key} type="button"
+              onClick={() => { setScope(s.key); try { localStorage.setItem(SCOPE_KEY, s.key); } catch { /* quota */ } }}
+              className={cn('px-1.5 h-6 text-[11px] whitespace-nowrap', i > 0 && 'border-l border-border',
+                scope === s.key ? 'bg-primary text-primary-foreground' : 'hover:bg-muted text-muted-foreground')}>
+              {t(s.label)}
+            </button>
+          ))}
+        </div>
+        <span className="text-[11px] text-muted-foreground tabular-nums">
+          {t('gsm.count', { n: stats.total, c: stats.confirmed })}
+        </span>
+        <select
+          value={basemap}
+          onChange={(e) => { const v = e.target.value as BasemapKey; setBasemap(v); writeUiPref('opslog.mapBasemap', v); }}
+          title={t('gsm.basemap')}
+          className="h-6 rounded border border-border bg-background px-1 text-[11px]"
+        >
+          {(Object.keys(BASEMAPS) as BasemapKey[]).map((k) => (
+            <option key={k} value={k}>{BASEMAPS[k].label}</option>
+          ))}
+        </select>
+        <span className="flex-1" />
+        <button type="button" onClick={() => void load()} disabled={busy} title={t('gsm.refresh')}
+          className="inline-flex items-center justify-center size-6 rounded border border-border hover:bg-muted disabled:opacity-50">
+          {busy ? <Loader2 className="size-3 animate-spin" /> : <RefreshCw className="size-3" />}
+        </button>
+      </header>
+      {err && <p className="px-2.5 py-1 text-[11px] text-destructive shrink-0">{err}</p>}
+      {/* The map host must have a real height or Leaflet renders nothing at all
+          — flex-1 + min-h-0, never a percentage. */}
+      <div ref={hostRef} className="flex-1 min-h-0" />
+      <footer className="flex items-center gap-3 px-2.5 py-1 border-t border-border bg-muted/30 shrink-0 text-[10px] text-muted-foreground">
+        <span className="inline-flex items-center gap-1.5">
+          <span className="inline-block size-2.5 rounded-[2px]"
+            style={{ background: 'var(--success)', opacity: 0.75 }} />
+          {t('gsm.confirmed')}
+        </span>
+        <span className="inline-flex items-center gap-1.5">
+          <span className="inline-block size-2.5 rounded-[2px]"
+            style={{ background: 'var(--chart-1)', opacity: 0.35 }} />
+          {t('gsm.worked')}
+        </span>
+      </footer>
+    </section>
+  );
+}

frontend/src/components/MainMap.tsx

@@ -61,8 +61,8 @@ const ESRI_STREET_ATTR = 'Tiles © Esri — Source: Esri, HERE, Garmin, &cop
 // Selectable basemaps for the world (great-circle) map. All key-free and all
 // LABELLED (country/continent names). `labelsUrl` adds a transparent place-name
 // overlay on top of an imagery basemap (so satellite keeps its names too).
-type BasemapKey = 'light' | 'voyager' | 'street' | 'satellite';
+export type BasemapKey = 'light' | 'voyager' | 'street' | 'satellite';
-const BASEMAPS: Record<BasemapKey, { label: string; url: string; attr: string; subdomains?: string; labelsUrl?: string }> = {
+export const BASEMAPS: Record<BasemapKey, { label: string; url: string; attr: string; subdomains?: string; labelsUrl?: string }> = {
   light:     { label: 'Light',     url: CARTO_LIGHT, attr: CARTO_ATTR, subdomains: 'abcd' },
   voyager:   { label: 'Voyager',   url: 'https://{s}.basemaps.cartocdn.com/rastertiles/voyager/{z}/{x}/{y}{r}.png',
                attr: CARTO_ATTR, subdomains: 'abcd' },
@@ -71,7 +71,7 @@ const BASEMAPS: Record<BasemapKey, { label: string; url: string; attr: string; s
                attr: 'Tiles &copy; Esri — Source: Esri, Maxar, Earthstar Geographics',
                labelsUrl: 'https://server.arcgisonline.com/ArcGIS/rest/services/Reference/World_Boundaries_and_Places/MapServer/tile/{z}/{y}/{x}' },
 };
-function loadBasemap(): BasemapKey {
+export function loadBasemap(): BasemapKey {
   const v = localStorage.getItem('opslog.mapBasemap');
   return v === 'voyager' || v === 'street' || v === 'satellite' ? v : 'light';
 }
@@ -80,7 +80,7 @@ function loadBasemap(): BasemapKey {
 // place-name overlay. updateWhenIdle/keepBuffer keep the number of live tiles
 // down: satellite loads TWO tile layers, so its tile count — and the composited
 // layers WebView2 has to hold — is double every other basemap's.
-function addBasemap(
+export function addBasemap(
   m: L.Map,
   key: BasemapKey,
   base: React.MutableRefObject<L.TileLayer | null>,

frontend/src/components/QSLManagerModal.tsx

@@ -111,7 +111,33 @@ export function fmtQslDate(s?: string): string {
 
 // QSL Manager as an in-app tab panel: upload logged QSOs to online logbooks
 // and download confirmations, while the rest of the app stays usable.
-export function QSLManagerPanel({ onEditQSO }: { onEditQSO?: (id: number) => void } = {}) {
+// GridActions are the row actions the context menu offers, forwarded straight to
+// whichever grid this panel is showing.
+//
+// The FILTERED exports are deliberately absent. "Export everything the filter
+// matches" means the Recent-QSOs filter, and the rows here come from a different
+// query entirely — offering it would export something other than what is on the
+// screen, which is the one thing an export must never do. Selection-based
+// exports have no such ambiguity: the ids are the rows you ticked.
+export type GridActions = {
+  onUpdateFromCty?: (ids: number[]) => void;
+  onUpdateFromQRZ?: (ids: number[]) => void;
+  onUpdateFromClublog?: (ids: number[]) => void;
+  onUpdateCountyFromULS?: (ids: number[]) => void;
+  onSendTo?: (service: string, ids: number[]) => void;
+  onSendRecording?: (ids: number[]) => void;
+  onSendEQSL?: (ids: number[]) => void;
+  onBulkEdit?: (ids: number[]) => void;
+  onExportSelected?: (ids: number[]) => void;
+  onExportSelectedFields?: (ids: number[]) => void;
+  onExportCabrilloSelected?: (ids: number[]) => void;
+  onDelete?: (ids: number[]) => void;
+};
+
+export function QSLManagerPanel({ onEditQSO, actions }: {
+  onEditQSO?: (id: number) => void;
+  actions?: GridActions;
+} = {}) {
   const { t } = useI18n();
   const [service, setService] = useState('lotw');
   // The callsign this profile signs/uploads/downloads as for the selected
@@ -443,6 +469,8 @@ export function QSLManagerPanel({ onEditQSO }: { onEditQSO?: (id: number) => voi
                 total={paperRows.length}
                 selectAllSignal={paperSelAllSig}
                 onRowSelected={(ids) => setPaperSel(new Set(ids))}
+                {...actions}
+                onRowDoubleClicked={onEditQSO ? (q) => onEditQSO(q.id as number) : undefined}
               />
             </div>
           )
@@ -549,6 +577,8 @@ export function QSLManagerPanel({ onEditQSO }: { onEditQSO?: (id: number) => voi
               total={rows.length}
               selectAllSignal={uploadSelAllSig}
               onRowSelected={onUploadRowSelected}
+              {...actions}
+              onRowDoubleClicked={onEditQSO ? (q) => onEditQSO(q.id as number) : undefined}
             />
           </div>
         )}

frontend/src/components/QSOContextMenu.tsx

@@ -7,8 +7,8 @@ export type QSOMenuState = { x: number; y: number; ids: number[] } | null;
 type Props = {
   menu: QSOMenuState;
   onClose: () => void;
-  onUpdateFromCty: (ids: number[]) => void;
+  onUpdateFromCty?: (ids: number[]) => void;
-  onUpdateFromQRZ: (ids: number[]) => void;
+  onUpdateFromQRZ?: (ids: number[]) => void;
   onUpdateFromClublog?: (ids: number[]) => void;
   // Only passed once the offline US county database has been downloaded —
   // an entry that can only ever answer "no database" is not worth a line here.
@@ -98,20 +98,28 @@ export function QSOContextMenu({ menu, onClose, onUpdateFromCty, onUpdateFromQRZ
       <div className="px-3 py-1 text-[11px] uppercase tracking-wider text-muted-foreground">
         {t('qctx.selected', { n })}
       </div>
-      <button
+      {/* Conditional like every other entry. These two were drawn
-        className="flex w-full items-center gap-2 px-3 py-1.5 text-left hover:bg-accent/50"
+          unconditionally, and the grid passes them through an arrow that calls
-        onClick={() => { onUpdateFromCty(menu.ids); onClose(); }}
+          an optional handler — so in a grid that wires neither (the QSL
-      >
+          Manager) both appeared and did precisely nothing when clicked. */}
-        <Globe2 className="size-4 text-primary" />
+      {onUpdateFromCty && (
-        <span>{t('qctx.fixCountry')}</span>
+        <button
-      </button>
+          className="flex w-full items-center gap-2 px-3 py-1.5 text-left hover:bg-accent/50"
-      <button
+          onClick={() => { onUpdateFromCty(menu.ids); onClose(); }}
-        className="flex w-full items-center gap-2 px-3 py-1.5 text-left hover:bg-accent/50"
+        >
-        onClick={() => { onUpdateFromQRZ(menu.ids); onClose(); }}
+          <Globe2 className="size-4 text-primary" />
-      >
+          <span>{t('qctx.fixCountry')}</span>
-        <RefreshCw className="size-4 text-info" />
+        </button>
-        <span>{t('qctx.updateQrz')}</span>
+      )}
-      </button>
+      {onUpdateFromQRZ && (
+        <button
+          className="flex w-full items-center gap-2 px-3 py-1.5 text-left hover:bg-accent/50"
+          onClick={() => { onUpdateFromQRZ(menu.ids); onClose(); }}
+        >
+          <RefreshCw className="size-4 text-info" />
+          <span>{t('qctx.updateQrz')}</span>
+        </button>
+      )}
       {onUpdateFromClublog && (
         <button
           className="flex w-full items-center gap-2 px-3 py-1.5 text-left hover:bg-accent/50"

frontend/src/components/RecentQSOsGrid.tsx

@@ -631,6 +631,20 @@ export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal,
     api.setColumnsVisible(ids, false);
     saveColumnState();
   }
+  // Whole-dialog show/hide. showAll/hideAll cover the CATALOGUE only; the award
+  // columns live in their own persisted code set, so a global that skipped them
+  // would leave a row of columns behind and look broken.
+  function setEverything(visible: boolean) {
+    const api = gridRef.current?.api;
+    if (!api) return;
+    api.setColumnsVisible(COL_CATALOG.map((c) => c.colId!), visible);
+    if (awardCols && awardCols.length > 0) {
+      persistAwardShown(visible ? new Set(awardCols.map((a) => a.code.toUpperCase())) : new Set());
+      api.setColumnsVisible(awardCols.map((a) => `award_${a.code}`), visible);
+    }
+    saveColumnState();
+  }
+
   function resetDefaults() {
     const api = gridRef.current?.api;
     if (!api) return;
@@ -711,11 +725,15 @@ export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal,
         </div>
       </div>
 
+      {/* Every handler is passed STRAIGHT through, never wrapped in an arrow: a
+          wrapper is always truthy, so the menu drew "Fix country" and "Update
+          from the callsign databases" even in a grid that wired neither — and
+          clicking them did nothing at all. */}
       <QSOContextMenu
         menu={menu}
         onClose={() => setMenu(null)}
-        onUpdateFromCty={(ids) => onUpdateFromCty?.(ids)}
+        onUpdateFromCty={onUpdateFromCty}
-        onUpdateFromQRZ={(ids) => onUpdateFromQRZ?.(ids)}
+        onUpdateFromQRZ={onUpdateFromQRZ}
         onUpdateFromClublog={onUpdateFromClublog}
         onUpdateCountyFromULS={onUpdateCountyFromULS}
         onSendTo={onSendTo}
@@ -738,6 +756,16 @@ export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal,
               {t('rqg.pickerDesc')}
             </DialogDescription>
           </DialogHeader>
+          {/* Whole-dialog controls. The per-group links alone meant hiding
+              everything was one click PER GROUP, and there are a dozen. */}
+          <div className="flex items-center gap-1 px-5 text-[11px] text-muted-foreground">
+            <span>{t('rqg.pickerAllGroups')}</span>
+            <button type="button" className="text-[11px] text-primary hover:underline px-1"
+              onClick={() => setEverything(true)}>{t('rqg.all')}</button>
+            <span className="opacity-40">·</span>
+            <button type="button" className="text-[11px] text-muted-foreground hover:underline px-1"
+              onClick={() => setEverything(false)}>{t('rqg.none')}</button>
+          </div>
           <div className="grid grid-cols-3 gap-4 max-h-[60vh] overflow-y-auto px-5 py-3">
             {GROUP_ORDER.map((group) => {
               const cols = COL_CATALOG.filter((c) => c.group === group);

frontend/src/components/SettingsModal.tsx

@@ -55,7 +55,7 @@ import {
   GetFolderSync, SaveFolderSync, PickFolderSyncFolder, GetFolderSyncStatus, SyncFolderNow,
   GetRelayAuto, SaveRelayAuto, GetStationDevices,
   GetAwardDefs, GetTrackedAwards, SaveTrackedAwards,
-  GetBandOpenSettings, SaveBandOpenSettings, GetPSKReporterStatus, GetChaseNewGrids, SetChaseNewGrids, GetChaseNew, SetChaseNew, GetGridCacheStatus, GetLinkedAmps, SetLinkedAmps, GetSpotTTLMinutes, SetSpotTTLMinutes,
+  GetBandOpenSettings, SaveBandOpenSettings, GetGridScopeSettings, SaveGridScopeSettings, 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';
@@ -76,6 +76,7 @@ import {
 } from '@/components/ui/select';
 import { cn } from '@/lib/utils';
 import { writeUiPref } from '@/lib/uiPref';
+import { loadAutoCall, autoCallKey, type AutoCallSettings, type AutoCallCriteria } from '@/lib/autocall';
 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';
@@ -202,6 +203,7 @@ type SectionId =
   | 'uscounties'
   | 'awards'
   | 'cat'
+  | 'ftx'
   | 'rotator'
   | 'winkeyer'
   | 'antenna'
@@ -306,6 +308,7 @@ function buildTree(flexAvailable: boolean, t: (k: string) => string): TreeNode[]
         { kind: 'item', label: t('sec.modes'), id: 'lists-modes' },
       ]},
       { kind: 'item', label: t('sec.cluster'),     id: 'cluster' },
+      { kind: 'item', label: t('sec.ftx'),         id: 'ftx' },
       { kind: 'item', label: t('sec.udp'), id: 'udp' },
       { kind: 'item', label: t('sec.adifmon'), id: 'adifmon' },
       { kind: 'item', label: t('sec.foldersync'), id: 'foldersync' },
@@ -325,7 +328,7 @@ function buildTree(flexAvailable: boolean, t: (k: string) => string): TreeNode[]
 const SECTION_KEY: Partial<Record<SectionId, string>> = {
   station: 'sec.station', profiles: 'sec.profiles', operating: 'sec.operating', confirmations: 'sec.confirmations',
   'external-services': 'sec.external', appearance: 'sec.appearance', lookup: 'sec.lookup', 'lists-bands': 'sec.bands', 'lists-modes': 'sec.modes',
-  cluster: 'sec.cluster', backup: 'sec.backup', database: 'sec.database', autostart: 'sec.autostart', udp: 'sec.udp',
+  cluster: 'sec.cluster', ftx: 'sec.ftx', backup: 'sec.backup', database: 'sec.database', autostart: 'sec.autostart', udp: 'sec.udp',
   adifmon: 'sec.adifmon',
   foldersync: 'sec.foldersync',
   webpublish: 'sec.webpublish',
@@ -1519,6 +1522,10 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   const [autofocusWB, setAutofocusWB] = useState(() => localStorage.getItem('opslog.autofocusWB') !== '0');
   const [checkUpdates, setCheckUpdates] = useState(() => localStorage.getItem('opslog.checkUpdates') !== '0');
   const [showBeamMap, setShowBeamMap] = useState(() => localStorage.getItem('opslog.showBeamOnMap') !== '0');
+  // Compact rotor widget: the dial and the SP/LP readout only. Off by default —
+  // the full widget is what the operator has today, and a setting that changes
+  // a panel the moment you upgrade is a setting that gets blamed for it.
+  const [rotorCompact, setRotorCompact] = useState(() => localStorage.getItem('opslog.rotorCompact') === '1');
   const [startEqEnd, setStartEqEnd] = useState(() => localStorage.getItem('opslog.startEqualsEnd') === '1');
   const [lookupOnBlur, setLookupOnBlur] = useState(() => localStorage.getItem('opslog.lookupOnBlur') === '1');
   const [groupDigital, setGroupDigital] = useState(() => localStorage.getItem('opslog.groupDigitalSlots') === '1');
@@ -1724,6 +1731,14 @@ 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: [] });
+  // How a worked square is matched, and what counts as still wanted.
+  const [autoCall, setAutoCall] = useState<AutoCallSettings>(loadAutoCall);
+  const [gridScope, setGridScope] = useState<any>({ scope: 'mix_digi', hunt: 'new', scopes: [] });
+  useEffect(() => { GetGridScopeSettings().then((g) => setGridScope(g as any)).catch(() => {}); }, []);
+  const saveGridScope = async (next: any) => {
+    setGridScope(next);
+    try { await SaveGridScopeSettings(next); } catch { /* the panel keeps the choice either way */ }
+  };
   const [chaseGrids, setChaseGrids] = useState(false);
   const [chaseNew, setChaseNew] = useState(false);
   const [spotTTL, setSpotTTL] = useState(0);
@@ -4180,10 +4195,25 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             </div>
           )}
 
+          {/* How much of the rotor widget to draw. Compact keeps the dial and the
+              SP/LP azimuths and drops the controls — for an operator who turns
+              the antenna from the bearing pill or from PstRotator and wants the
+              dial to take a column, not a panel. */}
+          <div className="border-t border-border/60 pt-3 space-y-2">
+            <div className="text-sm font-semibold">{t('rot.widget')}</div>
+            <label className="flex items-center gap-2 text-sm">
+              <Checkbox checked={rotorCompact}
+                onCheckedChange={(c) => { const v = !!c; setRotorCompact(v); writeUiPref('opslog.rotorCompact', v ? '1' : '0'); }} />
+              {t('rot.compact')}
+            </label>
+            <p className="text-xs text-muted-foreground">{t('rot.compactHint')}</p>
+          </div>
+
           {/* Quick-turn buttons for the rotor widget. Their azimuths start out
               computed from the station square, so they are right for THIS QTH
-              rather than copied from someone else's. */}
+              rather than copied from someone else's. Hidden in compact mode —
-          <div className="border-t border-border/60 pt-3 space-y-2">
+              editing buttons that are not drawn is a trap. */}
+          <div className={cn('border-t border-border/60 pt-3 space-y-2', rotorCompact && 'opacity-40')}>
             <div className="text-sm font-semibold">{t('rot.presets')}</div>
             <p className="text-xs text-muted-foreground">{t('rot.presetsHint')}</p>
             <div className="space-y-1.5">
@@ -4560,6 +4590,91 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     setEditingServer(next);
   }
 
+  // FTx decodes: what OpsLog does on its own with the digital stream.
+  //
+  // Auto-call KEYS THE TRANSMITTER without anyone clicking, so the panel is
+  // deliberately explicit about it: off by default, every criterion opt-in, and
+  // a plain statement of what the machine will do once it is on.
+  function FtxPanel() {
+    const set = (patch: Partial<AutoCallSettings>) => {
+      const next = { ...autoCall, ...patch };
+      setAutoCall(next);
+      writeUiPref(autoCallKey, JSON.stringify(next));
+    };
+    const crit = (which: 'criteria' | 'watchCriteria', k: keyof AutoCallCriteria) => (
+      <label key={k} className="flex items-center gap-1.5 text-xs cursor-pointer">
+        <Checkbox
+          checked={!!autoCall[which][k]}
+          onCheckedChange={(v) => set({ [which]: { ...autoCall[which], [k]: !!v } } as any)}
+        />
+        {t(`ftx.c_${k}`)}
+      </label>
+    );
+    const KEYS: (keyof AutoCallCriteria)[] = ['dxcc', 'band', 'mode', 'slot', 'grid', 'county', 'pota', 'pfx'];
+    return (
+      <>
+        <SectionHeader title={t('sec.ftx')} hint={t('ftx.hint')} />
+        <div className="space-y-4">
+          <div className="rounded-md border border-border p-3 space-y-3">
+            <label className="flex items-start gap-2 text-sm cursor-pointer">
+              <Checkbox checked={autoCall.enabled} className="mt-0.5"
+                onCheckedChange={(v) => set({ enabled: !!v })} />
+              <span>
+                {t('ftx.enable')}{' '}
+                <span className="text-xs text-muted-foreground">{t('ftx.enableHint')}</span>
+              </span>
+            </label>
+
+            {autoCall.enabled && (
+              <div className="pl-6 space-y-3">
+                <div>
+                  <p className="text-xs font-semibold text-muted-foreground mb-1.5">{t('ftx.callWhen')}</p>
+                  <div className="grid grid-cols-2 gap-x-4 gap-y-1">{KEYS.map((k) => crit('criteria', k))}</div>
+                </div>
+
+                <div className="border-t border-border/60 pt-3">
+                  <p className="text-xs font-semibold text-muted-foreground mb-1">{t('ftx.watch')}</p>
+                  <p className="text-[11px] text-muted-foreground mb-1.5 leading-relaxed">{t('ftx.watchHint')}</p>
+                  <Textarea
+                    className="h-20 font-mono text-xs"
+                    placeholder={"4S7*\nTM0HQ\n*/P"}
+                    defaultValue={(autoCall.watch ?? []).join('\n')}
+                    key={`w-${(autoCall.watch ?? []).length}`}
+                    onBlur={(e) => set({
+                      watch: e.target.value.split('\n').map((x) => x.trim().toUpperCase()).filter(Boolean),
+                    })}
+                  />
+                  {(autoCall.watch ?? []).length > 0 && (
+                    <div className="mt-2">
+                      <p className="text-[11px] text-muted-foreground mb-1">{t('ftx.watchOnlyIf')}</p>
+                      <div className="grid grid-cols-2 gap-x-4 gap-y-1">{KEYS.map((k) => crit('watchCriteria', k))}</div>
+                    </div>
+                  )}
+                </div>
+
+                <div className="border-t border-border/60 pt-3 flex items-center gap-2 flex-wrap">
+                  <span className="text-xs text-muted-foreground">{t('ftx.cooldown')}</span>
+                  <Input type="number" min={10} max={3600} className="w-24 h-7 text-xs"
+                    defaultValue={autoCall.cooldownSec}
+                    key={`cd-${autoCall.cooldownSec}`}
+                    onBlur={(e) => {
+                      const v = parseInt(e.target.value, 10);
+                      if (!isNaN(v) && v >= 10 && v <= 3600) set({ cooldownSec: v });
+                    }} />
+                  <span className="text-xs text-muted-foreground">s</span>
+                </div>
+
+                <p className="text-[11px] rounded border border-warning-border bg-warning-muted text-warning-muted-foreground px-2 py-1.5 leading-relaxed">
+                  {t('ftx.warn')}
+                </p>
+              </div>
+            )}
+          </div>
+        </div>
+      </>
+    );
+  }
+
   function ClusterPanel() {
     const sorted = [...clusterServers].sort((a, b) => (a.sort_order ?? 0) - (b.sort_order ?? 0));
     return (
@@ -4714,6 +4829,36 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                 {pskrStatus?.running ? ` · ${t('bo.feedUp', { n: pskrStatus.received ?? 0 })}` : ''}
               </p>
             )}
+
+            {/* What counts as "I already have this square". There is no single
+                right answer — a VUCC chaser counts a square per band, someone
+                filling a wall map counts it once — so it is a choice, and the
+                same six GridTracker offers, because a square wanted in one and
+                not the other is a bug report every time. */}
+            <div className="pl-6 space-y-1.5 pt-1">
+              <div className="flex items-center gap-2 flex-wrap">
+                <span className="text-xs text-muted-foreground w-28 shrink-0">{t('gsc.scope')}</span>
+                <Select value={gridScope.scope} onValueChange={(v) => saveGridScope({ ...gridScope, scope: v })}>
+                  <SelectTrigger className="h-7 w-64 text-xs"><SelectValue /></SelectTrigger>
+                  <SelectContent>
+                    {(gridScope.scopes ?? []).map((s: any) => (
+                      <SelectItem key={s.key} value={s.key}>{t(`gsc.scope_${s.key}`)}</SelectItem>
+                    ))}
+                  </SelectContent>
+                </Select>
+              </div>
+              <div className="flex items-center gap-2 flex-wrap">
+                <span className="text-xs text-muted-foreground w-28 shrink-0">{t('gsc.hunt')}</span>
+                <Select value={gridScope.hunt} onValueChange={(v) => saveGridScope({ ...gridScope, hunt: v })}>
+                  <SelectTrigger className="h-7 w-64 text-xs"><SelectValue /></SelectTrigger>
+                  <SelectContent>
+                    <SelectItem value="new">{t('gsc.huntNew')}</SelectItem>
+                    <SelectItem value="new_unconfirmed">{t('gsc.huntUnconf')}</SelectItem>
+                  </SelectContent>
+                </Select>
+              </div>
+              <p className="text-[11px] text-muted-foreground leading-relaxed">{t('gsc.hint')}</p>
+            </div>
           </div>
 
           {/* Chase new — its own option, NOT nested under grid chasing. Chasing
@@ -4754,6 +4899,28 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                     );
                   })}
                 </div>
+                {/* How near a RECEIVER has to be. This is the whole premise of
+                    the watch — a report is evidence about YOUR path only if it
+                    was collected near you — and the right distance differs by
+                    band, so it is the operator's call. Committed on blur/Enter,
+                    not per keystroke: each save restarts the feed. */}
+                <div className="flex items-center gap-2 flex-wrap">
+                  <span className="text-xs text-muted-foreground">{t('bo.nearKm')}</span>
+                  <Input
+                    type="number" min={25} max={1000} step={25}
+                    className="w-24 h-7 text-xs"
+                    defaultValue={bandOpen.near_km ?? 300}
+                    key={`nk-${bandOpen.near_km ?? 300}`}
+                    onBlur={(e) => {
+                      const v = parseInt(e.target.value, 10);
+                      if (!isNaN(v) && v !== bandOpen.near_km) saveBandOpen({ ...bandOpen, near_km: v });
+                    }}
+                    onKeyDown={(e) => { if (e.key === 'Enter') (e.target as HTMLInputElement).blur(); }}
+                  />
+                  <span className="text-xs text-muted-foreground">km</span>
+                </div>
+                <p className="text-[11px] text-muted-foreground leading-relaxed">{t('bo.nearKmHint')}</p>
+
                 {/* A live count, because a feed that is connected but silent looks
                     exactly like one that is broken until a number moves. */}
                 <p className="text-xs text-muted-foreground">
@@ -6670,6 +6837,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     'lists-bands':  BandsPanel,
     'lists-modes':  ModesPanel,
     cluster:        ClusterPanel,
+    ftx:            FtxPanel,
     udp:            UDPIntegrationsPanelWrapper,
     // Module-scope components, wrapped so their props can be passed. The nested
     // panels below go through PanelHost instead — which is what now lets either

frontend/src/components/UDPIntegrationsPanel.tsx

@@ -24,7 +24,7 @@ type UDPConfig = {
   direction: 'inbound' | 'outbound';
   name: string;
   port: number;
-  service_type: 'wsjt' | 'adif' | 'n1mm' | 'remote_call' | 'db_updated' | 'pstrotator_freq' | 'n1mm_radioinfo' | 'wsjt_log' | 'custom';
+  service_type: 'wsjt' | 'adif' | 'n1mm' | 'remote_call' | 'db_updated' | 'pstrotator_freq' | 'n1mm_radioinfo' | 'wsjt_log' | 'wsjt_relay' | 'custom';
   // Custom rows only.
   trigger?: string;
   template?: string;
@@ -95,6 +95,19 @@ const SERVICE_TYPES: Array<{
     hint: 'udpp.svcWsjtLogHint',
     defaults: { port: 2250, destination_ip: '127.0.0.1' },
   },
+  {
+    // Feeds a SECOND application the stream this OpsLog receives. WSJT-X, JTDX
+    // and MSHV each send to ONE address, so without a relay the choice is
+    // between OpsLog and JTAlert/GridTracker rather than both.
+    //
+    // 2238 by default: beside the 2237 the sender uses, and free. Pointing it AT
+    // 2237 would name an OpsLog listener, which the relay refuses.
+    id: 'wsjt_relay',
+    direction: 'outbound',
+    label: 'udpp.svcWsjtRelayLabel',
+    hint: 'udpp.svcWsjtRelayHint',
+    defaults: { port: 2238, 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

frontend/src/components/WorkedBeforeGrid.tsx

@@ -298,6 +298,20 @@ export function WorkedBeforeGrid({ wb, myGrid, busy, currentCall, onRowDoubleCli
               {t('wbg.pickerDesc')}
             </DialogDescription>
           </DialogHeader>
+          {/* Whole-dialog controls — the award columns included, which the
+              catalogue-only helpers do not cover. */}
+          <div className="flex items-center gap-1 px-5 text-[11px] text-muted-foreground">
+            <span>{t('wbg.allGroups')}</span>
+            <button type="button" className="text-[11px] text-primary hover:underline px-1"
+              onClick={() => { showAll(); (awardCols ?? []).forEach((a) => setColVisible(`award_${a.code}`, true)); }}>
+              {t('wbg.all')}
+            </button>
+            <span className="opacity-40">·</span>
+            <button type="button" className="text-[11px] text-muted-foreground hover:underline px-1"
+              onClick={() => { hideAll(); (awardCols ?? []).forEach((a) => setColVisible(`award_${a.code}`, false)); }}>
+              {t('wbg.none')}
+            </button>
+          </div>
           <div className="grid grid-cols-2 gap-4 max-h-[60vh] overflow-y-auto px-5 py-3">
             {GROUP_ORDER.map((group) => {
               const cols = COL_CATALOG.filter((c) => c.group === group);

frontend/src/lib/autocall.ts

@@ -0,0 +1,176 @@
+// Auto-call: let OpsLog answer a decode without the operator clicking it.
+//
+// This KEYS THE TRANSMITTER on its own, which is why the rules here are written
+// as a series of refusals rather than a search for a reason to call. Everything
+// below has to be true; anything unknown means no.
+//
+// The decision is made here, in one pure function, precisely because it is the
+// dangerous part: it can be read, argued with and tested without a radio.
+
+export type AutoCallCriteria = {
+  dxcc: boolean;      // entity never worked
+  band: boolean;      // entity never worked on this band
+  mode: boolean;      // entity never worked in this mode
+  slot: boolean;      // band and mode each worked, never together
+  grid: boolean;      // square wanted under the grid scope
+  county: boolean;    // US county never worked
+  pota: boolean;      // park never worked
+  sota: boolean;      // summit never worked (spot-tagged only)
+  pfx: boolean;       // CQ WPX prefix never worked
+};
+
+export type AutoCallSettings = {
+  enabled: boolean;
+  criteria: AutoCallCriteria;
+  // Callsigns to answer on sight, wildcards allowed (4S7*, */P). Each is still
+  // subject to `watchCriteria` — "call TM0HQ, but only if it is a new band" is
+  // the request, not "call it every time it appears".
+  watch: string[];
+  // Empty means call a watched callsign whenever it is not already worked.
+  watchCriteria: AutoCallCriteria;
+  // Seconds to ignore a callsign after calling it, so a station that keeps
+  // sending CQ is not re-answered every slot while the QSO is in progress.
+  cooldownSec: number;
+};
+
+export const emptyCriteria: AutoCallCriteria = {
+  dxcc: false, band: false, mode: false, slot: false,
+  grid: false, county: false, pota: false, sota: false, pfx: false,
+};
+
+export const defaultAutoCall: AutoCallSettings = {
+  // OFF, and it stays off until asked for. Unattended transmit is not something
+  // to inherit from an upgrade.
+  enabled: false,
+  criteria: { ...emptyCriteria },
+  watch: [],
+  watchCriteria: { ...emptyCriteria },
+  cooldownSec: 120,
+};
+
+const AC_KEY = 'opslog.autoCall';
+
+export function loadAutoCall(): AutoCallSettings {
+  try {
+    const raw = localStorage.getItem(AC_KEY);
+    if (!raw) return { ...defaultAutoCall };
+    const v = JSON.parse(raw);
+    return {
+      ...defaultAutoCall,
+      ...v,
+      criteria: { ...emptyCriteria, ...(v?.criteria ?? {}) },
+      watchCriteria: { ...emptyCriteria, ...(v?.watchCriteria ?? {}) },
+      watch: Array.isArray(v?.watch) ? v.watch : [],
+    };
+  } catch { return { ...defaultAutoCall }; }
+}
+
+export const autoCallKey = AC_KEY;
+
+// A decode's resolved novelty, the same shape the panel already renders from.
+export type DecodeStatus = {
+  status?: string;
+  worked_call?: boolean;
+  new_grid?: boolean;
+  grid_state?: string;
+  new_county?: boolean;
+  new_pota?: boolean;
+  new_pfx?: boolean;
+};
+
+// matchesWildcard is the same rule the alert filters use: * is any run, ? is one.
+export function matchesWildcard(pattern: string, call: string): boolean {
+  const p = pattern.trim().toUpperCase();
+  const c = call.trim().toUpperCase();
+  if (!p) return false;
+  const re = new RegExp('^' + p.split('').map((ch) => (
+    ch === '*' ? '.*' : ch === '?' ? '.' : ch.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  )).join('') + '$');
+  return re.test(c);
+}
+
+// anyCriterion is false for an all-off set, which is what makes "watch this
+// callsign, no conditions" expressible.
+function anyCriterion(c: AutoCallCriteria): boolean {
+  return Object.values(c).some(Boolean);
+}
+
+// meets reports whether a decode satisfies at least one ticked criterion.
+function meets(c: AutoCallCriteria, e: DecodeStatus): boolean {
+  if (c.dxcc && e.status === 'new') return true;
+  if (c.band && e.status === 'new-band') return true;
+  if (c.mode && e.status === 'new-mode') return true;
+  if (c.slot && e.status === 'new-slot') return true;
+  // A square that is merely UNCONFIRMED is not called: the QSO is already made,
+  // and calling again would work a duplicate to chase a QSL.
+  if (c.grid && e.new_grid && e.grid_state !== 'unconf') return true;
+  if (c.county && e.new_county) return true;
+  if (c.pota && e.new_pota) return true;
+  if (c.pfx && e.new_pfx) return true;
+  return false;
+}
+
+export type AutoCallDecode = {
+  call: string;
+  cq?: boolean;
+  msg?: string;
+  instance?: string;
+};
+
+// shouldAutoCall decides whether to answer one decode. The reason is returned
+// for the log: an automatic transmission with no record of WHY is the thing an
+// operator cannot argue with after the fact.
+export function shouldAutoCall(
+  s: AutoCallSettings,
+  d: AutoCallDecode,
+  e: DecodeStatus | undefined,
+  opts: {
+    // busy is "some receiver is mid-QSO", NOT "this one is transmitting".
+    //
+    // The distinction is the whole bug it fixes: with two instances the caller
+    // used to test a single global transmit flag, which belonged to whichever
+    // receiver reported last. So while slice A worked a station, slice B looked
+    // idle and auto-call started another QSO on it — and the moment either
+    // finished it chained straight into the next. One station at a time means
+    // one across ALL receivers, not one per receiver.
+    busy: boolean;
+    calledAt: Map<string, number>;
+    now: number;
+    myCall?: string;
+  },
+): { call: boolean; reason: string } {
+  const no = (why: string) => ({ call: false, reason: why });
+  if (!s.enabled) return no('off');
+  if (!e) return no('status not resolved yet');
+  const call = (d.call ?? '').trim().toUpperCase();
+  if (!call) return no('no callsign');
+  // Never answer ourselves, however the decode reached us.
+  if (opts.myCall && call === opts.myCall.trim().toUpperCase()) return no('own callsign');
+  // Only a CQ. Answering a station mid-QSO is both rude and futile — WSJT-X
+  // actions a Reply only for CQ and QRZ anyway.
+  if (!d.cq) return no('not a CQ');
+  // Not while ANY receiver is mid-QSO — transmitting, or holding a DX call it
+  // has not finished with. Starting a second exchange before the first is done
+  // is what turned this into a machine that called without stopping.
+  if (opts.busy) return no('a QSO is already in progress');
+  const last = opts.calledAt.get(call);
+  if (last !== undefined && opts.now - last < s.cooldownSec * 1000) return no('called recently');
+
+  // The watch list first: an explicitly named station outranks the general
+  // criteria, and may carry conditions of its own.
+  const watched = s.watch.some((p) => matchesWildcard(p, call));
+  if (watched) {
+    if (!anyCriterion(s.watchCriteria)) {
+      // No conditions attached: call it unless it is already worked.
+      return e.worked_call ? no('watched, but already worked') : { call: true, reason: 'watch list' };
+    }
+    return meets(s.watchCriteria, e)
+      ? { call: true, reason: 'watch list + criteria' }
+      : no('watched, but no criterion met');
+  }
+
+  if (!anyCriterion(s.criteria)) return no('no criteria ticked');
+  return meets(s.criteria, e)
+    ? { call: true, reason: 'criteria' }
+    : no('no criterion met');
+}

frontend/src/lib/uiPref.ts

@@ -17,6 +17,8 @@ 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.rotorCompact',  // rotor widget: dial + SP/LP only, no quick-turn buttons or Stop
+  'opslog.decodesGridMap',// FT decodes tab: grid-square map shown beside the table
   '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)
@@ -45,6 +47,7 @@ const PORTABLE_KEYS = [
   'opslog.bandMapWidth',    // docked band map: column width (px)
   'opslog.bandMapTabWidth', // Band map tab: shared card width (px)
   'opslog.bandMapZoom',     // band map zoom (px/kHz step) remembered per band, as one {band: index} map
+  'opslog.decodeColWidths', // FT decodes table: per-column widths (px), as one {col: px} map
   // NOTE: 'hamlog.awardColsShown' and the grid column layouts are NOT listed here.
   // They are handled by lib/gridPrefs, which scopes the localStorage cache PER
   // PROFILE and mirrors to the DB (already per-profile) itself — mirroring them

frontend/src/version.ts

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

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

@@ -357,6 +357,8 @@ export function FlexSetXITFreq(arg1:number):Promise<void>;
 
 export function FlexStopCW():Promise<void>;
 
+export function FlexTXOnBand(arg1:string):Promise<void>;
+
 export function FlexTune(arg1:boolean):Promise<void>;
 
 export function GetACOMStatus():Promise<acom.Status>;
@@ -459,6 +461,8 @@ export function GetFolderSyncStatus():Promise<main.FolderSyncStatus>;
 
 export function GetGridCacheStatus():Promise<main.GridCacheStatus>;
 
+export function GetGridScopeSettings():Promise<main.GridScopeSettings>;
+
 export function GetIcomState():Promise<cat.IcomTXState>;
 
 export function GetLinkedAmps():Promise<Array<string>>;
@@ -569,6 +573,10 @@ export function GetWorkedCallVariants():Promise<boolean>;
 
 export function GetYaesuState():Promise<cat.YaesuTXState>;
 
+export function GridSquares(arg1:string):Promise<Array<qso.GridSquare>>;
+
+export function HaltDecodeTx(arg1:string,arg2:boolean):Promise<void>;
+
 export function HasBuiltinReferences(arg1:string):Promise<boolean>;
 
 export function IcomRefresh():Promise<void>;
@@ -953,6 +961,8 @@ export function SaveFlexBandPower(arg1:Record<string, main.FlexBandPower>):Promi
 
 export function SaveFolderSync(arg1:main.FolderSyncConfig):Promise<void>;
 
+export function SaveGridScopeSettings(arg1:main.GridScopeSettings):Promise<void>;
+
 export function SaveListsSettings(arg1:main.ListsSettings):Promise<void>;
 
 export function SaveLookupSettings(arg1:main.LookupSettings):Promise<void>;
@@ -1011,6 +1021,8 @@ export function SendClusterCommand(arg1:string):Promise<void>;
 
 export function SendClusterSpot(arg1:string,arg2:number,arg3:string):Promise<void>;
 
+export function SendDecodeFreeText(arg1:string,arg2:string,arg3:boolean):Promise<void>;
+
 export function SendEQSL(arg1:number,arg2:number,arg3:string):Promise<void>;
 
 export function SendLogToDeveloper():Promise<void>;

frontend/wailsjs/go/main/App.js

@@ -654,6 +654,10 @@ export function FlexStopCW() {
   return window['go']['main']['App']['FlexStopCW']();
 }
 
+export function FlexTXOnBand(arg1) {
+  return window['go']['main']['App']['FlexTXOnBand'](arg1);
+}
+
 export function FlexTune(arg1) {
   return window['go']['main']['App']['FlexTune'](arg1);
 }
@@ -858,6 +862,10 @@ export function GetGridCacheStatus() {
   return window['go']['main']['App']['GetGridCacheStatus']();
 }
 
+export function GetGridScopeSettings() {
+  return window['go']['main']['App']['GetGridScopeSettings']();
+}
+
 export function GetIcomState() {
   return window['go']['main']['App']['GetIcomState']();
 }
@@ -1078,6 +1086,14 @@ export function GetYaesuState() {
   return window['go']['main']['App']['GetYaesuState']();
 }
 
+export function GridSquares(arg1) {
+  return window['go']['main']['App']['GridSquares'](arg1);
+}
+
+export function HaltDecodeTx(arg1, arg2) {
+  return window['go']['main']['App']['HaltDecodeTx'](arg1, arg2);
+}
+
 export function HasBuiltinReferences(arg1) {
   return window['go']['main']['App']['HasBuiltinReferences'](arg1);
 }
@@ -1846,6 +1862,10 @@ export function SaveFolderSync(arg1) {
   return window['go']['main']['App']['SaveFolderSync'](arg1);
 }
 
+export function SaveGridScopeSettings(arg1) {
+  return window['go']['main']['App']['SaveGridScopeSettings'](arg1);
+}
+
 export function SaveListsSettings(arg1) {
   return window['go']['main']['App']['SaveListsSettings'](arg1);
 }
@@ -1962,6 +1982,10 @@ export function SendClusterSpot(arg1, arg2, arg3) {
   return window['go']['main']['App']['SendClusterSpot'](arg1, arg2, arg3);
 }
 
+export function SendDecodeFreeText(arg1, arg2, arg3) {
+  return window['go']['main']['App']['SendDecodeFreeText'](arg1, arg2, arg3);
+}
+
 export function SendEQSL(arg1, arg2, arg3) {
   return window['go']['main']['App']['SendEQSL'](arg1, arg2, arg3);
 }

frontend/wailsjs/go/models.ts

@@ -2001,6 +2001,7 @@ export namespace main {
 	    enabled: boolean;
 	    bands: string[];
 	    available: string[];
+	    near_km: number;
 	
 	    static createFrom(source: any = {}) {
 	        return new BandOpenSettings(source);
@@ -2011,6 +2012,7 @@ export namespace main {
 	        this.enabled = source["enabled"];
 	        this.bands = source["bands"];
 	        this.available = source["available"];
+	        this.near_km = source["near_km"];
 	    }
 	}
 	export class CATSettings {
@@ -2567,6 +2569,56 @@ export namespace main {
 	        this.pending = source["pending"];
 	    }
 	}
+	export class gridScope {
+	    key: string;
+	    band: boolean;
+	    mode: string;
+	
+	    static createFrom(source: any = {}) {
+	        return new gridScope(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.key = source["key"];
+	        this.band = source["band"];
+	        this.mode = source["mode"];
+	    }
+	}
+	export class GridScopeSettings {
+	    scope: string;
+	    hunt: string;
+	    scopes: gridScope[];
+	
+	    static createFrom(source: any = {}) {
+	        return new GridScopeSettings(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.scope = source["scope"];
+	        this.hunt = source["hunt"];
+	        this.scopes = this.convertValues(source["scopes"], gridScope);
+	    }
+	
+		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 ModePreset {
 	    name: string;
 	    default_rst_sent?: string;
@@ -3362,6 +3414,7 @@ export namespace main {
 	    new_pota: boolean;
 	    grid?: string;
 	    new_grid: boolean;
+	    grid_state?: string;
 	    spotter_continent?: string;
 	    lotw: boolean;
 	    new_pfx: boolean;
@@ -3387,6 +3440,7 @@ export namespace main {
 	        this.new_pota = source["new_pota"];
 	        this.grid = source["grid"];
 	        this.new_grid = source["new_grid"];
+	        this.grid_state = source["grid_state"];
 	        this.spotter_continent = source["spotter_continent"];
 	        this.lotw = source["lotw"];
 	        this.new_pfx = source["new_pfx"];
@@ -4519,6 +4573,26 @@ export namespace qso {
 	        this.minutes = source["minutes"];
 	    }
 	}
+	export class GridSquare {
+	    grid: string;
+	    count: number;
+	    confirmed: boolean;
+	    band?: string;
+	    mode?: string;
+	
+	    static createFrom(source: any = {}) {
+	        return new GridSquare(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.grid = source["grid"];
+	        this.count = source["count"];
+	        this.confirmed = source["confirmed"];
+	        this.band = source["band"];
+	        this.mode = source["mode"];
+	    }
+	}
 	export class ListFilter {
 	    callsign?: string;
 	    band?: string;

gridscope.go

@@ -0,0 +1,187 @@
+package main
+
+import (
+	"strings"
+
+	"hamlog/internal/award"
+	"hamlog/internal/qso"
+)
+
+// New-grid scoping: WHICH prior contacts count as "I already have this square".
+//
+// The question has no single right answer, which is why it is a setting rather
+// than a rule. A VUCC chaser counts a square per band; someone filling in a
+// wall map counts it once. GridTracker offers the same six combinations, and an
+// operator running both alongside each other needs them to agree — a square
+// "wanted" in one and not the other is a bug report every time.
+const (
+	keyGridScope = "grid.scope" // band+mode combination — see gridScopes
+	keyGridHunt  = "grid.hunt"  // "new" | "new_unconfirmed"
+)
+
+// gridScope is one band × mode combination.
+type gridScope struct {
+	Key string `json:"key"`
+	// Band is true when the square has to have been worked on THIS band. False
+	// is GridTracker's "Mix Bands": any band counts.
+	Band bool `json:"band"`
+	// Mode is how much of the mode matters:
+	//   "digi" — any digital mode at all
+	//   "ftx"  — any of the FT family (FT8/FT4/FT2)
+	//   "mode" — this exact mode and no other
+	Mode string `json:"mode"`
+}
+
+var gridScopes = []gridScope{
+	{Key: "band_digi", Band: true, Mode: "digi"},
+	{Key: "band_mode", Band: true, Mode: "mode"},
+	{Key: "band_ftx", Band: true, Mode: "ftx"},
+	{Key: "mix_digi", Band: false, Mode: "digi"},
+	{Key: "mix_mode", Band: false, Mode: "mode"},
+	{Key: "mix_ftx", Band: false, Mode: "ftx"},
+}
+
+// defaultGridScope matches what the panel showed before the setting existed:
+// any band, any digital mode. Changing an operator's badges on upgrade is worse
+// than offering them a choice they have not made yet.
+const defaultGridScope = "mix_digi"
+
+func lookupGridScope(key string) gridScope {
+	for _, s := range gridScopes {
+		if s.Key == key {
+			return s
+		}
+	}
+	for _, s := range gridScopes {
+		if s.Key == defaultGridScope {
+			return s
+		}
+	}
+	return gridScopes[0]
+}
+
+// ftxModes is the FT family, which is a narrower thing than "digital": an
+// operator chasing squares on FT8 does not count the RTTY contest contact, and
+// GridTracker draws the same line.
+var ftxModes = map[string]bool{"FT8": true, "FT4": true, "FT2": true}
+
+// gridClassesOf lists every bucket one logged mode belongs to. A single FT8
+// contact counts under its own name, under FTx and under digital — the scopes
+// overlap by construction, so the index stores all three and the lookup picks.
+func gridClassesOf(mode string) []string {
+	m := strings.ToUpper(strings.TrimSpace(mode))
+	if m == "" {
+		return nil
+	}
+	out := []string{"m:" + m}
+	if ftxModes[m] {
+		out = append(out, "ftx")
+	}
+	if award.ModeClass(m) == "DIGI" {
+		out = append(out, "digi")
+	}
+	return out
+}
+
+// gridClassFor turns the scope plus the mode being heard into the one class to
+// look up. Empty means "this scope cannot judge this mode" — a phone contact
+// under an FTx scope — and the caller then flags nothing rather than guessing.
+func gridClassFor(s gridScope, mode string) string {
+	m := strings.ToUpper(strings.TrimSpace(mode))
+	if m == "" {
+		return ""
+	}
+	switch s.Mode {
+	case "mode":
+		return "m:" + m
+	case "ftx":
+		if ftxModes[m] {
+			return "ftx"
+		}
+		return ""
+	default: // digi
+		if award.ModeClass(m) == "DIGI" {
+			return "digi"
+		}
+		return ""
+	}
+}
+
+// GridScopeSettings is the panel's shape.
+type GridScopeSettings struct {
+	Scope string `json:"scope"`
+	Hunt  string `json:"hunt"`
+	// Scopes is the list the UI renders, so it cannot drift from the one the
+	// lookup honours.
+	Scopes []gridScope `json:"scopes"`
+}
+
+func (a *App) GetGridScopeSettings() GridScopeSettings {
+	return GridScopeSettings{
+		Scope:  lookupGridScope(a.settingOr(keyGridScope, "")).Key,
+		Hunt:   gridHunt(a.settingOr(keyGridHunt, "")),
+		Scopes: gridScopes,
+	}
+}
+
+// gridHunt normalises the hunting mode. "new" is never-worked; "new_unconfirmed"
+// also chases a square worked but not yet confirmed — the same square is still
+// missing from the award either way.
+func gridHunt(v string) string {
+	if strings.TrimSpace(v) == "new_unconfirmed" {
+		return "new_unconfirmed"
+	}
+	return "new"
+}
+
+func (a *App) SaveGridScopeSettings(s GridScopeSettings) error {
+	a.setSetting(keyGridScope, lookupGridScope(s.Scope).Key)
+	a.setSetting(keyGridHunt, gridHunt(s.Hunt))
+	// The worked-grid index is built under these rules, so it is now stale.
+	a.clusterStatusMu.Lock()
+	a.clusterStatusIdx = nil
+	a.clusterStatusMu.Unlock()
+	return nil
+}
+
+// Grid states a heard square can be in, from the operator's point of view.
+//
+// "wanted" is not one state but two, and they call for different decisions: a
+// square never worked is a QSO to make, one worked and not yet confirmed is a
+// QSL to chase. Reporting both as plain NEW GRID — which is what this did when
+// the unconfirmed hunt was added — leaves an operator staring at a badge on a
+// station the log plainly says they worked an hour ago.
+const (
+	gridStateNew    = "new"    // never worked under this scope
+	gridStateUnconf = "unconf" // worked under this scope, not yet confirmed
+)
+
+// gridStateFor classifies one heard square. "" means nothing to chase: already
+// confirmed, or a mode this scope cannot judge.
+//
+// band is where it was heard and mode what it was heard in — the SCOPE decides
+// whether either is allowed to matter.
+func gridStateFor(idx map[string]bool, s gridScope, hunt, grid, band, mode string) string {
+	cls := gridClassFor(s, mode)
+	if cls == "" || len(grid) < 4 {
+		return ""
+	}
+	key := qso.GridKey(strings.ToUpper(grid[:4]), "", cls)
+	if s.Band {
+		key = qso.GridKey(strings.ToUpper(grid[:4]), band, cls)
+	}
+	confirmed, worked := idx[key]
+	switch {
+	case !worked:
+		return gridStateNew
+	case !confirmed && hunt == "new_unconfirmed":
+		return gridStateUnconf
+	default:
+		return ""
+	}
+}
+
+// gridIsWanted is gridStateFor reduced to the yes/no the filters need.
+func gridIsWanted(idx map[string]bool, s gridScope, hunt, grid, band, mode string) bool {
+	return gridStateFor(idx, s, hunt, grid, band, mode) != ""
+}

gridscope_test.go

@@ -0,0 +1,126 @@
+package main
+
+import (
+	"testing"
+
+	"hamlog/internal/qso"
+)
+
+// idx builds a worked-grid index the way GridWorkedIndex does, so the test
+// exercises the real key shape rather than a convenient one.
+func idx(entries ...struct {
+	grid, band, mode string
+	confirmed        bool
+}) map[string]bool {
+	m := map[string]bool{}
+	for _, e := range entries {
+		for _, cls := range gridClassesOf(e.mode) {
+			for _, k := range []string{qso.GridKey(e.grid, e.band, cls), qso.GridKey(e.grid, "", cls)} {
+				m[k] = m[k] || e.confirmed
+			}
+		}
+	}
+	return m
+}
+
+type entry = struct {
+	grid, band, mode string
+	confirmed        bool
+}
+
+// The six scopes are six different questions, and the whole point of offering
+// them is that the same square answers differently.
+func TestGridScopes(t *testing.T) {
+	// JN36 worked once: 20 m, FT8, not confirmed.
+	i := idx(entry{"JN36", "20m", "FT8", false})
+
+	for _, tc := range []struct {
+		scope string
+		band  string
+		mode  string
+		want  bool
+		why   string
+	}{
+		{"band_ftx", "20m", "FT8", false, "same band, same family — already mine"},
+		{"band_ftx", "15m", "FT8", true, "another band, and the scope counts bands"},
+		{"mix_ftx", "15m", "FT8", false, "another band, but this scope does not care"},
+		{"band_mode", "20m", "FT4", true, "same band, but FT4 is not FT8 under an exact-mode scope"},
+		{"band_ftx", "20m", "FT4", false, "same band, and FT4 is in the same FT family"},
+		{"band_digi", "20m", "RTTY", false, "digital counts every digital mode"},
+		{"band_ftx", "20m", "RTTY", false, "RTTY is outside an FTx scope — it is not evidence either way, so nothing is flagged"},
+		{"mix_digi", "15m", "FT4", false, "the widest scope: worked anywhere, any digital"},
+	} {
+		got := gridIsWanted(i, lookupGridScope(tc.scope), "new", "JN36", tc.band, tc.mode)
+		if got != tc.want {
+			t.Errorf("scope %s, %s %s → wanted=%v, want %v — %s", tc.scope, tc.band, tc.mode, got, tc.want, tc.why)
+		}
+	}
+}
+
+// "New + unconfirmed" chases a square that is worked but not yet confirmed: it
+// is still missing from the award, which is the only sense in which it is done.
+func TestGridHuntUnconfirmed(t *testing.T) {
+	unconf := idx(entry{"JN36", "20m", "FT8", false})
+	conf := idx(entry{"IO91", "20m", "FT8", true})
+
+	if gridIsWanted(unconf, lookupGridScope("band_ftx"), "new", "JN36", "20m", "FT8") {
+		t.Error("worked-but-unconfirmed must NOT be wanted when hunting only what is new")
+	}
+	if !gridIsWanted(unconf, lookupGridScope("band_ftx"), "new_unconfirmed", "JN36", "20m", "FT8") {
+		t.Error("worked-but-unconfirmed must BE wanted when hunting unconfirmed too")
+	}
+	if gridIsWanted(conf, lookupGridScope("band_ftx"), "new_unconfirmed", "IO91", "20m", "FT8") {
+		t.Error("a confirmed square is finished under either hunt")
+	}
+}
+
+// A mode the scope cannot judge flags nothing rather than guessing: a phone
+// contact under an FTx scope is not evidence either way.
+func TestGridScopeIgnoresModesItCannotJudge(t *testing.T) {
+	i := idx(entry{"JN36", "20m", "FT8", false})
+	for _, mode := range []string{"SSB", "CW", ""} {
+		if gridIsWanted(i, lookupGridScope("band_ftx"), "new", "KO01", "20m", mode) {
+			t.Errorf("mode %q is outside an FTx scope — nothing should be flagged", mode)
+		}
+	}
+}
+
+// An unknown or unset scope falls back rather than answering "wanted" for
+// everything, which is what an empty class would have done.
+func TestGridScopeFallsBack(t *testing.T) {
+	if got := lookupGridScope("").Key; got != defaultGridScope {
+		t.Errorf("unset scope = %q, want the default %q", got, defaultGridScope)
+	}
+	if got := lookupGridScope("nonsense").Key; got != defaultGridScope {
+		t.Errorf("unknown scope = %q, want the default %q", got, defaultGridScope)
+	}
+	if got := gridHunt("nonsense"); got != "new" {
+		t.Errorf("unknown hunt = %q, want new", got)
+	}
+}
+
+// The two wanted states must be told apart, not merged. A square worked an hour
+// ago and awaiting a QSL is a different job from one never worked, and reporting
+// both as plain NEW GRID is what made a station the log plainly shows as worked
+// still wear the badge.
+func TestGridStateSeparatesNewFromUnconfirmed(t *testing.T) {
+	i := idx(
+		entry{"JN74", "20m", "FT8", false}, // worked, no confirmation yet
+		entry{"IO91", "20m", "FT8", true},  // worked and confirmed
+	)
+	s := lookupGridScope("band_ftx")
+
+	if got := gridStateFor(i, s, "new_unconfirmed", "KO99", "20m", "FT8"); got != gridStateNew {
+		t.Errorf("never worked → %q, want %q", got, gridStateNew)
+	}
+	if got := gridStateFor(i, s, "new_unconfirmed", "JN74", "20m", "FT8"); got != gridStateUnconf {
+		t.Errorf("worked but unconfirmed → %q, want %q", got, gridStateUnconf)
+	}
+	if got := gridStateFor(i, s, "new_unconfirmed", "IO91", "20m", "FT8"); got != "" {
+		t.Errorf("confirmed → %q, want nothing to chase", got)
+	}
+	// Under the plain "new" hunt an unconfirmed square is finished business.
+	if got := gridStateFor(i, s, "new", "JN74", "20m", "FT8"); got != "" {
+		t.Errorf("unconfirmed under the new-only hunt → %q, want nothing", got)
+	}
+}

internal/cluster/cluster.go

@@ -47,7 +47,12 @@ type Spot struct {
 	SourceID   int64     `json:"source_id"`   // ID of the cluster server this came from
 	SourceName string    `json:"source_name"` // display name (handy in the UI when multiple servers)
 	Spotter    string    `json:"spotter"`     // DE field
-	DXCall     string    `json:"dx_call"`     // the DX station heard
+	// SpotterContinent belongs to the SPOT, not to the DX station: one call is
+	// spotted by dozens of skimmers on every continent within a minute. It is
+	// resolved per spot at ingest for exactly that reason — see the note on the
+	// spotter-continent filter in App.tsx.
+	SpotterContinent string `json:"spotter_continent,omitempty"`
+	DXCall           string `json:"dx_call"` // the DX station heard
 	FreqKHz    float64   `json:"freq_khz"`
 	FreqHz     int64     `json:"freq_hz"`
 	Band       string    `json:"band,omitempty"`

internal/integrations/udp/config.go

@@ -37,6 +37,19 @@ 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)
+	// ServiceWSJTRelay re-sends every datagram an inbound WSJT listener receives,
+	// byte for byte, to somewhere else.
+	//
+	// WSJT-X, JTDX and MSHV send to ONE address. Anything else that wants the
+	// same stream — JTAlert, GridTracker, a second logger — has to be fed by a
+	// relay, and this is it, so OpsLog stops being the reason you cannot run the
+	// two together.
+	//
+	// VERBATIM, with no origin header prepended. The relays in the field add one
+	// ("127.0.0.1:2237|"), which is precisely why stripForwarderHeader exists on
+	// the receiving side here; inflicting the same thing on whatever is
+	// downstream would be repeating a mistake we had to write code to survive.
+	ServiceWSJTRelay ServiceType = "wsjt_relay"
 	// 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.

internal/integrations/udp/decodegrid_test.go

@@ -0,0 +1,75 @@
+package udp
+
+import (
+	"bytes"
+	"encoding/binary"
+	"testing"
+)
+
+// A grid reaches OpsLog in TWO kinds of message, not one. The reply that
+// answers a CQ with a locator — "C91RU IZ5EME JN52" — is the commonest of them
+// on a busy band, and reading only CQs meant any station whose CQ we happened
+// to miss had no known grid at all, so it could never be flagged as a new one.
+func TestDecodeGridFromBothMessageShapes(t *testing.T) {
+	for _, tc := range []struct {
+		msg  string
+		call string
+		cq   bool
+		grid string
+		why  string
+	}{
+		{"CQ RW9MZ MO74", "RW9MZ", true, "MO74", "a plain CQ"},
+		{"CQ DX F4BPO JN36", "F4BPO", true, "JN36", "a CQ with a modifier"},
+		{"C91RU IZ5EME JN52", "IZ5EME", false, "JN52", "a reply answering with its grid"},
+		{"YB1EWD YO6GLT KN36", "YO6GLT", false, "KN36", "the same, other way round"},
+
+		// Everything else in the third slot is a report or a sign-off, and must
+		// never be mistaken for a locator.
+		{"C91RU IZ5EME -05", "IZ5EME", false, "", "a signal report is not a grid"},
+		{"C91RU IZ5EME R-05", "IZ5EME", false, "", "a rogered report is not a grid"},
+		{"C91RU IZ5EME RRR", "IZ5EME", false, "", "RRR is not a grid"},
+		{"C91RU IZ5EME RR73", "IZ5EME", false, "", "RR73 has the shape of one and is not"},
+		{"C91RU IZ5EME 73", "IZ5EME", false, "", "73 is not a grid"},
+		{"<YO7LBX> 8F81SU RR73", "8F81SU", false, "", "a hashed call, signing off"},
+	} {
+		call, cq, grid := wsjtSender(tc.msg)
+		if call != tc.call || cq != tc.cq || grid != tc.grid {
+			t.Errorf("wsjtSender(%q) = (%q, %v, %q), want (%q, %v, %q) — %s",
+				tc.msg, call, cq, grid, tc.call, tc.cq, tc.grid, tc.why)
+		}
+	}
+}
+
+// The Reply replays the decode field for field, so the message must survive the
+// trip UNTRIMMED. DecodeMsg is trimmed for display; DecodeMsgRaw is what goes
+// back, and a stripped trailing space is a mismatch the far end reports nowhere.
+func TestDecodeKeepsTheUntrimmedMessage(t *testing.T) {
+	qstr := func(b *bytes.Buffer, v string) {
+		binary.Write(b, binary.BigEndian, int32(len(v)))
+		b.WriteString(v)
+	}
+	const padded = "CQ RW9MZ MO74  "
+	var p bytes.Buffer
+	binary.Write(&p, binary.BigEndian, uint32(wsjtMagic))
+	binary.Write(&p, binary.BigEndian, uint32(2))
+	binary.Write(&p, binary.BigEndian, uint32(wsjtMsgDecode))
+	qstr(&p, "JTDX")
+	binary.Write(&p, binary.BigEndian, uint8(1))
+	binary.Write(&p, binary.BigEndian, uint32(45_000_000))
+	binary.Write(&p, binary.BigEndian, int32(-6))
+	binary.Write(&p, binary.BigEndian, float64(0.2))
+	binary.Write(&p, binary.BigEndian, uint32(1500))
+	qstr(&p, "~")
+	qstr(&p, padded)
+
+	ev, ok, err := ParseWSJT(p.Bytes())
+	if err != nil || !ok {
+		t.Fatalf("parse: %v ok=%v", err, ok)
+	}
+	if ev.DecodeMsgRaw != padded {
+		t.Errorf("DecodeMsgRaw = %q, want %q — a Reply built from this will not match", ev.DecodeMsgRaw, padded)
+	}
+	if ev.DecodeMsg != "CQ RW9MZ MO74" {
+		t.Errorf("DecodeMsg = %q, want it trimmed for display", ev.DecodeMsg)
+	}
+}

internal/integrations/udp/decodemode_test.go

@@ -1,6 +1,11 @@
 package udp
 
-import "testing"
+import (
+	"bytes"
+	"encoding/binary"
+	"net"
+	"testing"
+)
 
 // A Decode does not carry the mode's NAME. It carries the one-character marker
 // from the decode line — "~" for FT8, "+" for FT4 — and that character used to
@@ -57,3 +62,54 @@ func upper(s string) string {
 	}
 	return string(out)
 }
+
+// Resolving the marker must not DESTROY it. A Reply is matched by the receiving
+// application against its own decode list field for field, and the mode field it
+// compares is the one it sent — the marker. Sending the resolved name instead is
+// accepted silently and simply never transmits: JTDX finds no matching decode,
+// and no error is reported anywhere to say so. Reported as "clicking a CQ does
+// nothing in JTDX".
+//
+// So a Decode has to carry BOTH: Mode for the log and the status resolver,
+// DecodeModeRaw for the Reply.
+func TestDecodeKeepsTheRawModeMarkerForReplies(t *testing.T) {
+	qstr := func(b *bytes.Buffer, v string) {
+		binary.Write(b, binary.BigEndian, int32(len(v)))
+		b.WriteString(v)
+	}
+	var p bytes.Buffer
+	binary.Write(&p, binary.BigEndian, uint32(wsjtMagic))
+	binary.Write(&p, binary.BigEndian, uint32(2))             // schema
+	binary.Write(&p, binary.BigEndian, uint32(wsjtMsgDecode)) // type 2
+	qstr(&p, "JTDX")                                          // id
+	binary.Write(&p, binary.BigEndian, uint8(1))              // is_new
+	binary.Write(&p, binary.BigEndian, uint32(45_000_000))    // time (ms since midnight)
+	binary.Write(&p, binary.BigEndian, int32(-6))             // snr
+	binary.Write(&p, binary.BigEndian, float64(0.2))          // delta_time
+	binary.Write(&p, binary.BigEndian, uint32(1500))          // delta_frequency
+	qstr(&p, "~")                                             // mode — the MARKER
+	qstr(&p, "CQ EN35UKR")                                    // message
+
+	out := make(chan Event, 4)
+	s := &Server{
+		out:      out,
+		cfg:      Config{Name: "JTDX", ServiceType: ServiceWSJT},
+		lastMode: map[string]string{"JTDX": "FT8"},
+		dialHz:   map[string]int64{"JTDX": 14074000},
+	}
+	s.handle(p.Bytes(), &net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 2237})
+
+	var ev Event
+	select {
+	case ev = <-out:
+	default:
+		t.Fatal("no event emitted for the decode")
+	}
+	if ev.Mode != "FT8" {
+		t.Errorf("resolved Mode = %q, want FT8 (what the log and the status resolver need)", ev.Mode)
+	}
+	if ev.DecodeModeRaw != "~" {
+		t.Errorf("DecodeModeRaw = %q, want %q — a Reply built from this will not match and JTDX will not transmit",
+			ev.DecodeModeRaw, "~")
+	}
+}

internal/integrations/udp/decodetime_test.go

@@ -5,31 +5,50 @@ import (
 	"time"
 )
 
+const ms = 1000
+
+func sec(h, m, s int) uint32 { return uint32((h*3600 + m*60 + s) * ms) }
+
 // WSJT-X stamps a decode with a time of DAY and no date, so the date has to come
 // from our own clock — and around midnight the two disagree. A decode stamped
 // 23:59:58 that reaches us at 00:00:01 would be dated the NEW day, putting it
 // almost 24 hours in the future: it would sort to the top of the decodes panel
 // and stay there for the rest of the session, and its period would never line up
 // with the ones around it.
+//
+// The clock is passed IN. The previous version of this test read the real one
+// and so failed every afternoon — a 23:59:58 stamp seen at 17:00 is genuinely
+// hours in the future, and no rule can make it otherwise. A suite that is red
+// for half the day is a suite nobody reads.
 func TestDecodeTimeCrossesMidnight(t *testing.T) {
-	const ms = 1000
+	// Just after midnight, a stamp from the last seconds of yesterday.
-	sec := func(h, m, s int) uint32 { return uint32((h*3600 + m*60 + s) * ms) }
+	now := time.Date(2026, 3, 14, 0, 0, 1, 0, time.UTC)
-
+	got := decodeTimeAt(sec(23, 59, 58), now)
-	got := decodeTime(sec(23, 59, 58))
+	if want := time.Date(2026, 3, 13, 23, 59, 58, 0, time.UTC); !got.Equal(want) {
-	now := time.Now().UTC()
+		t.Errorf("23:59:58 seen at 00:00:01 → %s, want %s (yesterday)", got, want)
-	// Whatever the clock says, a decode must never land in the future beyond the
-	// slack of a single period, nor more than a day in the past.
-	if d := got.Sub(now); d > time.Minute {
-		t.Errorf("decode at 23:59:58 resolved to %s, %s in the FUTURE", got.Format(time.RFC3339), d)
 	}
-	if d := now.Sub(got); d > 24*time.Hour {
+	if got.After(now) {
-		t.Errorf("decode at 23:59:58 resolved to %s, %s in the past", got.Format(time.RFC3339), d)
+		t.Errorf("%s is in the future — it would sort to the top of the list for the session", got)
 	}
+}
 
-	// And the ordinary case: a stamp close to now stays on today.
+// The mirror case: just before midnight, a stamp from the first seconds of
-	near := decodeTime(sec(now.Hour(), now.Minute(), now.Second()))
+// tomorrow. Our clock is still on the old day.
-	if diff := near.Sub(now); diff > 2*time.Second || diff < -2*time.Second {
+func TestDecodeTimeCrossesMidnightBackwards(t *testing.T) {
-		t.Errorf("a decode stamped at the current time resolved to %s (%s off)", near.Format(time.RFC3339), diff)
+	now := time.Date(2026, 3, 13, 23, 59, 58, 0, time.UTC)
+	got := decodeTimeAt(sec(0, 0, 1), now)
+	if want := time.Date(2026, 3, 14, 0, 0, 1, 0, time.UTC); !got.Equal(want) {
+		t.Errorf("00:00:01 seen at 23:59:58 → %s, want %s (tomorrow)", got, want)
+	}
+}
+
+// The ordinary case, which is every decode that is not within a few seconds of
+// midnight: the stamp belongs to today and is left alone.
+func TestDecodeTimeOrdinary(t *testing.T) {
+	now := time.Date(2026, 3, 13, 14, 30, 0, 0, time.UTC)
+	got := decodeTimeAt(sec(14, 29, 45), now)
+	if want := time.Date(2026, 3, 13, 14, 29, 45, 0, time.UTC); !got.Equal(want) {
+		t.Errorf("a stamp close to now → %s, want %s", got, want)
 	}
 }
 
@@ -37,16 +56,15 @@ func TestDecodeTimeCrossesMidnight(t *testing.T) {
 // fifteen-second slot must floor to the same period however far apart in the
 // slot they were heard.
 func TestDecodesInOneSlotShareAPeriod(t *testing.T) {
-	const ms = 1000
+	now := time.Date(2026, 3, 13, 12, 30, 7, 0, time.UTC)
-	at := func(h, m, s int) time.Time { return decodeTime(uint32((h*3600 + m*60 + s) * ms)) }
+	at := func(h, m, s int) time.Time { return decodeTimeAt(sec(h, m, s), now) }
 	floor := func(x time.Time) int64 { return x.Unix() / 15 * 15 }
 
 	a, b := at(12, 30, 0), at(12, 30, 14)
 	if floor(a) != floor(b) {
-		t.Errorf("12:30:00 and 12:30:14 fell in different periods (%d vs %d)", floor(a), floor(b))
+		t.Errorf("%s and %s fell in different periods", a, b)
 	}
-	c := at(12, 30, 15)
+	if floor(at(12, 30, 14)) == floor(at(12, 30, 15)) {
-	if floor(a) == floor(c) {
+		t.Error("12:30:14 and 12:30:15 are different slots and must not share a period")
-		t.Error("12:30:00 and 12:30:15 shared a period — the slot boundary was not honoured")
 	}
 }

internal/integrations/udp/outbound.go

@@ -2,6 +2,7 @@ package udp
 
 import (
 	"fmt"
+	"net"
 	"strings"
 
 	"hamlog/internal/applog"
@@ -185,3 +186,94 @@ func (m *Manager) sendTo(c Config, payload []byte) {
 	applog.Printf("udp: [%s] sent %d bytes to %s (%s)%s",
 		c.Name, len(payload), dst, c.ServiceType, sentPreview(c, payload))
 }
+
+// RelayInbound re-sends one received datagram, unchanged, to every configured
+// relay destination.
+//
+// Called with the RAW bytes as they arrived — before parsing, and whatever the
+// parse made of them. A packet this build cannot decode is still a packet the
+// application downstream may understand perfectly well, and a relay that only
+// forwards what it understood is a relay that silently drops the fields it has
+// not learned about yet.
+//
+// Loop guard: a destination that is one of our OWN inbound ports on a local
+// address would come straight back in and be relayed again, for ever, at line
+// rate. Such a row is skipped and said so once — quietly dropping it would look
+// like a relay that does not work.
+func (m *Manager) RelayInbound(pkt []byte, fromPort int) {
+	if len(pkt) == 0 {
+		return
+	}
+	rows := m.Outbound(ServiceWSJTRelay)
+	if len(rows) == 0 {
+		return
+	}
+	m.mu.Lock()
+	ports := make(map[int]struct{}, len(m.inbound))
+	for _, s := range m.inbound {
+		ports[s.cfg.Port] = struct{}{}
+	}
+	m.mu.Unlock()
+
+	for _, c := range rows {
+		if isLoopback(c.DestinationIP) {
+			if _, mine := ports[c.Port]; mine {
+				m.relayLoopOnce(c)
+				continue
+			}
+		}
+		// Deliberately not sendTo: that logs a line per datagram, and this runs
+		// on every decode of every period — it would bury the log within minutes.
+		host := strings.TrimSpace(c.DestinationIP)
+		if host == "" {
+			host = "127.0.0.1"
+		}
+		dst := fmt.Sprintf("%s:%d", host, c.Port)
+		if err := SendUDP(dst, pkt); err != nil {
+			m.relayErrOnce(c, dst, err)
+		}
+	}
+	_ = fromPort
+}
+
+// isLoopback reports whether a destination names this machine. Empty counts:
+// sendTo defaults it to 127.0.0.1.
+func isLoopback(host string) bool {
+	h := strings.TrimSpace(host)
+	if h == "" || h == "localhost" {
+		return true
+	}
+	ip := net.ParseIP(h)
+	return ip != nil && ip.IsLoopback()
+}
+
+// relayLoopOnce and relayErrOnce keep a repeating relay complaint to one line a
+// session. Both fire per datagram otherwise, which on a busy band is hundreds a
+// minute and makes the log useless for anything else.
+func (m *Manager) relayLoopOnce(c Config) {
+	m.relayWarnMu.Lock()
+	defer m.relayWarnMu.Unlock()
+	if m.relayWarned == nil {
+		m.relayWarned = map[int64]bool{}
+	}
+	if m.relayWarned[c.ID] {
+		return
+	}
+	m.relayWarned[c.ID] = true
+	applog.Printf("udp: [%s] relay target %s:%d is one of OpsLog's OWN listening ports — "+
+		"that would feed the stream back into itself for ever. Nothing is relayed on this row; "+
+		"point it at the other application's port.", c.Name, c.DestinationIP, c.Port)
+}
+
+func (m *Manager) relayErrOnce(c Config, dst string, err error) {
+	m.relayWarnMu.Lock()
+	defer m.relayWarnMu.Unlock()
+	if m.relayWarned == nil {
+		m.relayWarned = map[int64]bool{}
+	}
+	if m.relayWarned[-c.ID-1] {
+		return
+	}
+	m.relayWarned[-c.ID-1] = true
+	applog.Printf("udp: [%s] relay to %s failed: %v (said once)", c.Name, dst, err)
+}

internal/integrations/udp/relay_test.go

@@ -0,0 +1,77 @@
+package udp
+
+import (
+	"net"
+	"testing"
+	"time"
+)
+
+// The relay exists so a second application can be fed the same WSJT-X stream,
+// and the ONE thing it must get right is that the bytes are unchanged. The
+// relays in the field prepend an origin header ("127.0.0.1:2237|") — which is
+// why stripForwarderHeader had to be written on the receiving side — so a
+// header here would inflict on the next program the fault we had to survive.
+func TestRelayForwardsVerbatim(t *testing.T) {
+	dst, err := net.ListenUDP("udp", &net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 0})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer dst.Close()
+	port := dst.LocalAddr().(*net.UDPAddr).Port
+
+	m := &Manager{outbound: []Config{{
+		ID: 1, Name: "relay", ServiceType: ServiceWSJTRelay,
+		DestinationIP: "127.0.0.1", Port: port,
+	}}}
+
+	// A packet with bytes that no parser here understands, on purpose: the relay
+	// must not care what it is carrying.
+	sent := []byte{0xad, 0xbc, 0xcb, 0xda, 0x00, 0x00, 0x00, 0x63, 0xde, 0xad, 0xbe, 0xef}
+	m.RelayInbound(sent, 2237)
+
+	buf := make([]byte, 1024)
+	_ = dst.SetReadDeadline(time.Now().Add(2 * time.Second))
+	n, _, err := dst.ReadFromUDP(buf)
+	if err != nil {
+		t.Fatalf("nothing relayed: %v", err)
+	}
+	if got := buf[:n]; string(got) != string(sent) {
+		t.Errorf("relayed % X, want % X — the bytes must go out unchanged", got, sent)
+	}
+}
+
+// A relay aimed at one of OpsLog's OWN listening ports would come straight back
+// in, be relayed again, and saturate the loopback within seconds. The row is
+// skipped instead.
+func TestRelayRefusesToFeedItself(t *testing.T) {
+	own, err := net.ListenUDP("udp", &net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 0})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer own.Close()
+	port := own.LocalAddr().(*net.UDPAddr).Port
+
+	m := &Manager{
+		inbound: map[int64]*Server{
+			7: {cfg: Config{ID: 7, Port: port, ServiceType: ServiceWSJT}},
+		},
+		outbound: []Config{{
+			ID: 1, Name: "loop", ServiceType: ServiceWSJTRelay,
+			DestinationIP: "127.0.0.1", Port: port,
+		}},
+	}
+	m.RelayInbound([]byte{1, 2, 3, 4}, 2237)
+
+	buf := make([]byte, 64)
+	_ = own.SetReadDeadline(time.Now().Add(300 * time.Millisecond))
+	if n, _, err := own.ReadFromUDP(buf); err == nil {
+		t.Fatalf("relayed %d bytes back into our own listener — that is the loop", n)
+	}
+}
+
+// No relay rows configured must cost nothing and send nothing.
+func TestRelayWithNoRowsIsSilent(t *testing.T) {
+	m := &Manager{}
+	m.RelayInbound([]byte{1, 2, 3}, 2237) // must not panic
+	m.RelayInbound(nil, 2237)
+}

internal/integrations/udp/server.go

@@ -85,7 +85,18 @@ func reusingListenConfig() net.ListenConfig {
 // of the list for the rest of the session. More than half a day apart is read as
 // the wrong side of midnight and moved.
 func decodeTime(msSinceMidnight uint32) time.Time {
-	now := time.Now().UTC()
+	return decodeTimeAt(msSinceMidnight, time.Now().UTC())
+}
+
+// decodeTimeAt is decodeTime with the clock passed in.
+//
+// Split out so the midnight rule can be tested at midnight instead of at
+// whatever time the suite happens to run: the test used to read the real clock
+// and failed every afternoon, because a 23:59:58 stamp seen at 17:00 is hours in
+// the future and no rule can make it otherwise. A test that fails for half the
+// day teaches everyone to ignore the suite.
+func decodeTimeAt(msSinceMidnight uint32, now time.Time) time.Time {
+	now = now.UTC()
 	midnight := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, time.UTC)
 	at := midnight.Add(time.Duration(msSinceMidnight) * time.Millisecond)
 	switch {
@@ -112,7 +123,7 @@ type Event struct {
 
 	// A WSJT-X Decode (heard station) to render on the panadapter.
 	DecodeCall   string // transmitting (DE) callsign
-	DecodeGrid   string // 4-char grid, CQ decodes only
+	DecodeGrid   string // 4-char grid: from a CQ, or a reply answering with its locator
 	DecodeFreqHz int64  // RF frequency (dial + audio offset)
 	DecodeSNR    int    // reported SNR (dB)
 	DecodeCQ     bool   // the decode was a CQ
@@ -134,6 +145,17 @@ type Event struct {
 	DecodeAudioHz int64   // audio offset inside the passband
 	DecodeMs      uint32  // the decode's raw ms-since-midnight, as sent
 	DecodeLowConf bool
+	// DecodeModeRaw is the mode field EXACTLY as the Decode carried it — the
+	// one-character marker ("~", "+"), not the resolved name in Mode.
+	//
+	// Both are needed and they are not interchangeable. Mode is what the log and
+	// the status resolver want. This is what a Reply must echo: the receiving
+	// application matches a Reply against its own decode list field for field,
+	// and JTDX rejects one whose mode reads "FT8" where it decoded "~" — the
+	// click is accepted, nothing is transmitted, and nothing is reported.
+	DecodeModeRaw string
+	// DecodeMsgRaw is the message as sent, untrimmed — see DecodeModeRaw.
+	DecodeMsgRaw string
 	// ProgramID is the sending application's own id ("WSJT-X", "MSHV", or
 	// "WSJT-X - 2" for a second instance started with --rig-name). It is what
 	// tells two receivers apart on one multicast group — and it is the address a
@@ -145,7 +167,11 @@ type Event struct {
 	// true while the carrier is actually up. From Status, so ~1 Hz.
 	TxMessage    string
 	Transmitting bool
-	DECall       string // the operator's own call, as the digital app knows it
+	// TxEnabled is the sender's Enable Tx toggle — see WSJTEvent.TxEnabled. The
+	// watchdog clears it, which is the only reliable sign an exchange was
+	// abandoned rather than merely paused between overs.
+	TxEnabled bool
+	DECall    string // the operator's own call, as the digital app knows it
 
 	// ClearCall is set when a WSJT/JTDX/MSHV Status message reports an EMPTY DX
 	// Call after previously reporting one — i.e. the operator cleared the call in
@@ -162,7 +188,10 @@ type Event struct {
 
 // Server is a single inbound UDP listener.
 type Server struct {
-	cfg     Config
+	cfg Config
+	// mgr is the owning Manager, so a listener can reach the outbound rows.
+	// The relay is the only thing that needs it.
+	mgr     *Manager
 	conn    *net.UDPConn
 	out     chan<- Event
 	stop    chan struct{}
@@ -230,10 +259,11 @@ func describePacket(pkt []byte) string {
 	return fmt.Sprintf("%d bytes | text %q%s | hex %s%s", len(pkt), text.String(), more, strings.TrimSpace(hex.String()), more)
 }
 
-func newServer(cfg Config, out chan<- Event) *Server {
+func newServer(cfg Config, out chan<- Event, mgr *Manager) *Server {
 	return &Server{
 		cfg:  cfg,
 		out:  out,
+		mgr:  mgr,
 		stop: make(chan struct{}),
 		done: make(chan struct{}),
 	}
@@ -399,6 +429,17 @@ func (s *Server) noteIgnoredADIF(pkt []byte) {
 }
 
 func (s *Server) handle(pkt []byte, remote *net.UDPAddr) {
+	// Relay FIRST, and unconditionally: before parsing, and whatever the parse
+	// then makes of it. A datagram this build cannot decode is still one the
+	// application downstream may understand, and a relay that forwards only what
+	// it understood drops exactly the fields it has yet to learn about.
+	//
+	// WSJT listeners only. The other inbound services are text protocols with no
+	// second consumer to speak of, and relaying an ADIF record twice would log
+	// the contact twice.
+	if s.cfg.ServiceType == ServiceWSJT && s.mgr != nil {
+		s.mgr.RelayInbound(pkt, s.cfg.Port)
+	}
 	ev := Event{ConfigID: s.cfg.ID, Service: s.cfg.ServiceType, Source: remote.String()}
 	switch s.cfg.ServiceType {
 	case ServiceWSJT:
@@ -477,7 +518,9 @@ func (s *Server) handle(pkt []byte, remote *net.UDPAddr) {
 			ev.DecodeSNR = w.SNR
 			ev.DecodeCQ = w.IsCQ
 			ev.Mode = DecodeModeName(w.Mode, statusMode)
+			ev.DecodeModeRaw = w.Mode
 			ev.DecodeMsg = w.DecodeMsg
+			ev.DecodeMsgRaw = w.DecodeMsgRaw
 			ev.DecodeAt = decodeTime(w.DecodeMsSinceMidnight)
 			ev.DecodeTRPeriod = tr
 			ev.DecodeDial = dial
@@ -677,6 +720,13 @@ type Manager struct {
 	httpFailMu sync.Mutex
 	httpFailAt map[int64]time.Time
 
+	// relayWarned keeps a relay row's complaint (a loop target, a dead
+	// destination) to one line a session. Keyed by row id for the loop warning
+	// and by -id-1 for the send failure, so one row can say each once.
+	// Without this a busy band writes hundreds of identical lines a minute.
+	relayWarnMu sync.Mutex
+	relayWarned map[int64]bool
+
 	mu       sync.Mutex
 	inbound  map[int64]*Server
 	outbound []Config
@@ -729,7 +779,7 @@ func (m *Manager) Reload(ctx context.Context) []string {
 			m.mu.Unlock()
 			continue
 		}
-		srv := newServer(c, m.out)
+		srv := newServer(c, m.out, m)
 		if err := srv.start(); err != nil {
 			applog.Printf("udp: start %q failed: %v", c.Name, err)
 			errs = append(errs, fmt.Sprintf("%s: %v", c.Name, err))

internal/integrations/udp/wsjt.go

@@ -51,7 +51,7 @@ type WSJTEvent struct {
 	// known dial frequency (from Status) to DeltaFreqHz to get the RF frequency.
 	IsDecode    bool
 	DecodeCall  string // the sender (DE) callsign extracted from the message text
-	DecodeGrid  string // 4-char grid, CQ decodes only — the exchange carries none
+	DecodeGrid  string // 4-char grid: from a CQ, or a reply that answers with its locator
 	DeltaFreqHz int64  // audio offset within the passband (Hz)
 	SNR         int    // reported signal-to-noise (dB)
 	IsCQ        bool   // the decode was a CQ call
@@ -64,6 +64,12 @@ type WSJTEvent struct {
 	// exchange is what tells an operator where a station is in a QSO, and no set
 	// of extracted fields says "R-09" the way the line itself does.
 	DecodeMsg string
+	// DecodeMsgRaw is the message EXACTLY as the datagram carried it, trailing
+	// spaces and all. DecodeMsg above is trimmed for display; a Reply has to
+	// send this one, because the receiving application matches a Reply against
+	// its own decode list field for field and a stripped space is a mismatch it
+	// reports nowhere.
+	DecodeMsgRaw string
 	// DecodeMsSinceMidnight is the decode's own timestamp, in milliseconds since
 	// 00:00 UTC, as the sender reported it. It is what groups decodes into T/R
 	// PERIODS — arrival time cannot, since a whole period's decodes land in one
@@ -80,8 +86,14 @@ type WSJTEvent struct {
 	// from Status, so they arrive about once a second.
 	TxMessage    string
 	Transmitting bool
-	DECall       string // the operator's own callsign, as the digital app knows it
+	// TxEnabled is the sender's "Enable Tx" toggle. It is what the WATCHDOG
-	DEGrid       string // and their square
+	// turns off: the application stops transmitting but leaves the DX call set,
+	// so a caller that reads only the DX call believes the QSO is still running
+	// and waits for ever. This is the difference between "between overs" and
+	// "given up".
+	TxEnabled bool
+	DECall    string // the operator's own callsign, as the digital app knows it
+	DEGrid    string // and their square
 	// TRPeriod is the transmit/receive period in seconds (15 for FT8, 7 or 8 for
 	// FT4 depending on the sender's rounding). The authority on how long a slot
 	// is — better than inferring it from the mode name, which says nothing about
@@ -214,6 +226,7 @@ func ParseWSJT(pkt []byte) (WSJTEvent, bool, error) {
 			}
 		}
 		ev.Transmitting = transmitting != 0
+		ev.TxEnabled = txEnabled != 0
 		// rx_df, tx_df
 		var i32 int32
 		for i := 0; i < 2; i++ {
@@ -331,6 +344,7 @@ func ParseWSJT(pkt []byte) (WSJTEvent, bool, error) {
 		ev.SNR = int(snr)
 		ev.Mode = strings.ToUpper(strings.TrimSpace(mode))
 		ev.DecodeMsg = strings.TrimSpace(msg)
+		ev.DecodeMsgRaw = msg
 		ev.DecodeMsSinceMidnight = t32
 		ev.LowConfidence = lowConf != 0
 		ev.OffAir = offAir != 0
@@ -386,7 +400,21 @@ func wsjtSender(message string) (call string, isCQ bool, grid string) {
 		return "", true, ""
 	}
 	// Standard exchange: the DE (sender) call is the second token.
+	//
+	// And the THIRD token is a grid whenever the station is answering with its
+	// locator — "C91RU IZ5EME JN52", the ordinary first reply to a CQ. This used
+	// to return no grid at all on the grounds that "the exchange carries none",
+	// which is simply not true: it is the commonest grid-bearing message on a
+	// busy band, and only a CQ being read meant a station whose CQ we missed had
+	// no known grid — so it could never be flagged as a new one. GridTracker
+	// reads both, which is why its wanted-grid count ran so far ahead of ours.
+	//
+	// isGridField is what keeps the reports and sign-offs out: -05, R-05, RRR,
+	// 73 and RR73 all fail it, on length, charset or by name.
 	if len(f) >= 2 && looksLikeCall(f[1]) {
+		if len(f) >= 3 && isGridField(f[2]) {
+			return f[1], false, f[2]
+		}
 		return f[1], false, ""
 	}
 	return "", false, ""

internal/integrations/udp/wsjtfreetext.go

@@ -0,0 +1,78 @@
+package udp
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"strings"
+
+	"hamlog/internal/applog"
+)
+
+// WSJT-X Free Text (message type 9) — "put this in the free-text box, and send".
+//
+//	Free Text  type 9
+//	  id    utf8  the target application's own id
+//	  text  utf8  the message
+//	  send  bool  true = transmit it now, false = only fill the box
+//
+// What this is FOR, and what it is not:
+//
+// It is the one "transmit this now" primitive that behaves the same on WSJT-X,
+// WSJT-Z, JTDX, JTDX-Improved and MSHV, because it needs no decode to match
+// against — unlike Reply, which the receiving application will only action if it
+// can find the exact decode being answered.
+//
+// It is NOT a way to call a station. FT8 free text is 13 characters, so a
+// standard "<DX> <ME> <GRID>" does not fit, and more importantly the text goes
+// out AS free text without setting the DX Call — so the sequencer never takes
+// over, and no report, RR73 or logging prompt follows. Use it for a 73, a short
+// note or a CQ; use Reply to start a QSO.
+const wsjtMsgFreeText = 9
+
+// EncodeFreeText builds the datagram. send=false fills the box without keying.
+func EncodeFreeText(programID, text string, send bool) []byte {
+	var b bytes.Buffer
+	_ = binary.Write(&b, binary.BigEndian, uint32(wsjtMagic))
+	_ = binary.Write(&b, binary.BigEndian, uint32(2)) // schema 2 — what every current sender speaks
+	_ = binary.Write(&b, binary.BigEndian, uint32(wsjtMsgFreeText))
+	writeQString(&b, programID)
+	writeQString(&b, text)
+	var s uint8
+	if send {
+		s = 1
+	}
+	_ = binary.Write(&b, binary.BigEndian, s)
+	return b.Bytes()
+}
+
+// SendFreeText hands a free-text message to one decoding application.
+//
+// Routed by program id to the address that instance's packets arrive from, for
+// the same reason as SendReply and SendHaltTx: two receivers can share one
+// multicast group, and transmitting from the wrong one is worse than not
+// transmitting at all.
+func (m *Manager) SendFreeText(programID, text string, send bool) error {
+	if strings.TrimSpace(programID) == "" {
+		return fmt.Errorf("no application id — cannot tell which receiver to send with")
+	}
+	m.mu.Lock()
+	servers := make([]*Server, 0, len(m.inbound))
+	for _, s := range m.inbound {
+		servers = append(servers, s)
+	}
+	m.mu.Unlock()
+
+	for _, s := range servers {
+		conn, addr := s.replyTarget(programID)
+		if conn == nil || addr == nil {
+			continue
+		}
+		if _, err := conn.WriteToUDP(EncodeFreeText(programID, text, send), addr); err != nil {
+			return fmt.Errorf("send free text to %s at %s: %w", programID, addr, err)
+		}
+		applog.Printf("udp: free text sent to %s at %s — %q (send=%v)", programID, addr, text, send)
+		return nil
+	}
+	return fmt.Errorf("no packet has arrived from %q yet — nothing to send to", programID)
+}

internal/integrations/udp/wsjtfreetext_test.go

@@ -0,0 +1,45 @@
+package udp
+
+import (
+	"bytes"
+	"testing"
+)
+
+// The wire format, byte for byte. A malformed Free Text is discarded in silence
+// by the far end, exactly like a malformed Reply — so a wrong byte here shows up
+// as a button that does nothing.
+func TestEncodeFreeText(t *testing.T) {
+	got := EncodeFreeText("JTDX", "73 GL", true)
+	want := []byte{
+		0xad, 0xbc, 0xcb, 0xda, // magic
+		0x00, 0x00, 0x00, 0x02, // schema 2
+		0x00, 0x00, 0x00, 0x09, // type 9 — Free Text
+		0x00, 0x00, 0x00, 0x04, 'J', 'T', 'D', 'X',
+		0x00, 0x00, 0x00, 0x05, '7', '3', ' ', 'G', 'L',
+		0x01, // send now
+	}
+	if !bytes.Equal(got, want) {
+		t.Errorf("EncodeFreeText\n got %#v\nwant %#v", got, want)
+	}
+}
+
+// send=false fills the box without keying — the difference is one byte, and
+// getting it backwards would transmit when the operator only meant to prepare.
+func TestEncodeFreeTextWithoutSending(t *testing.T) {
+	got := EncodeFreeText("MSHV", "", false)
+	if got[len(got)-1] != 0x00 {
+		t.Errorf("send flag = %#x, want 0 — this would transmit unasked", got[len(got)-1])
+	}
+	// An empty text is a zero-length QString, never the -1 that means null:
+	// WSJT-X drops a packet with a null where it expects text.
+	if !bytes.Equal(got[len(got)-5:len(got)-1], []byte{0, 0, 0, 0}) {
+		t.Errorf("empty text was not encoded as a zero-length string: % X", got)
+	}
+}
+
+func TestSendFreeTextRejectsEmptyID(t *testing.T) {
+	m := &Manager{}
+	if err := m.SendFreeText("  ", "73", true); err == nil {
+		t.Fatal("expected an error for a blank program id")
+	}
+}

internal/integrations/udp/wsjthalt.go

@@ -0,0 +1,73 @@
+package udp
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"strings"
+
+	"hamlog/internal/applog"
+)
+
+// WSJT-X Halt Tx (message type 8) — "stop transmitting".
+//
+// The same two things the Halt Tx button and the Enable Tx toggle do in the
+// application's own window:
+//
+//	Halt Tx  type 8
+//	  id            utf8  the target application's own id
+//	  auto_tx_only  bool  false = stop the transmission NOW
+//	                      true  = let this over finish, then stop auto-Tx
+//
+// Both are useful and they are not the same operation. Stopping mid-over is what
+// you want when you have called the wrong station or realised the frequency is
+// occupied; finishing the over first is what you want when the QSO is complete
+// and cutting the transmission would leave the other end waiting for a report
+// that never lands.
+const wsjtMsgHaltTx = 8
+
+// EncodeHaltTx builds the datagram. autoTxOnly false halts immediately.
+func EncodeHaltTx(programID string, autoTxOnly bool) []byte {
+	var b bytes.Buffer
+	_ = binary.Write(&b, binary.BigEndian, uint32(wsjtMagic))
+	_ = binary.Write(&b, binary.BigEndian, uint32(2)) // schema 2 — what every current sender speaks
+	_ = binary.Write(&b, binary.BigEndian, uint32(wsjtMsgHaltTx))
+	writeQString(&b, programID)
+	var auto uint8
+	if autoTxOnly {
+		auto = 1
+	}
+	_ = binary.Write(&b, binary.BigEndian, auto)
+	return b.Bytes()
+}
+
+// SendHaltTx tells one decoding application to stop transmitting.
+//
+// Routed by PROGRAM ID and answered back to the address that instance's packets
+// arrive from, exactly like SendReply: two receivers can share one multicast
+// group, and halting the 20 m instance because the 6 m one is transmitting would
+// be worse than doing nothing.
+func (m *Manager) SendHaltTx(programID string, autoTxOnly bool) error {
+	if strings.TrimSpace(programID) == "" {
+		return fmt.Errorf("no application id — cannot tell which receiver to halt")
+	}
+	m.mu.Lock()
+	servers := make([]*Server, 0, len(m.inbound))
+	for _, s := range m.inbound {
+		servers = append(servers, s)
+	}
+	m.mu.Unlock()
+
+	for _, s := range servers {
+		conn, addr := s.replyTarget(programID)
+		if conn == nil || addr == nil {
+			continue
+		}
+		if _, err := conn.WriteToUDP(EncodeHaltTx(programID, autoTxOnly), addr); err != nil {
+			return fmt.Errorf("send halt to %s at %s: %w", programID, addr, err)
+		}
+		applog.Printf("udp: halt tx sent to %s at %s (auto_tx_only=%v)", programID, addr, autoTxOnly)
+		return nil
+	}
+	return fmt.Errorf("no packet has arrived from %q yet — nothing to halt", programID)
+}

internal/integrations/udp/wsjthalt_test.go

@@ -0,0 +1,75 @@
+package udp
+
+import (
+	"bytes"
+	"testing"
+)
+
+// The Halt Tx datagram, byte for byte. A wrong byte here does not fail loudly —
+// WSJT-X drops a malformed packet in silence, and the operator sees a Halt
+// button that simply does nothing.
+func TestEncodeHaltTx(t *testing.T) {
+	tests := []struct {
+		name       string
+		id         string
+		autoTxOnly bool
+		want       []byte
+	}{
+		{
+			name: "halt now",
+			id:   "WSJT-X",
+			want: []byte{
+				0xad, 0xbc, 0xcb, 0xda, // magic
+				0x00, 0x00, 0x00, 0x02, // schema 2
+				0x00, 0x00, 0x00, 0x08, // type 8 — Halt Tx
+				0x00, 0x00, 0x00, 0x06, // id length
+				'W', 'S', 'J', 'T', '-', 'X',
+				0x00, // auto_tx_only = false → stop mid-over
+			},
+		},
+		{
+			name:       "finish the over first",
+			id:         "MSHV",
+			autoTxOnly: true,
+			want: []byte{
+				0xad, 0xbc, 0xcb, 0xda,
+				0x00, 0x00, 0x00, 0x02,
+				0x00, 0x00, 0x00, 0x08,
+				0x00, 0x00, 0x00, 0x04,
+				'M', 'S', 'H', 'V',
+				0x01,
+			},
+		},
+		{
+			// An empty id is length 0, never the -1 that means a null QString:
+			// a null where text is expected makes WSJT-X discard the packet.
+			name: "empty id is a zero-length string",
+			id:   "",
+			want: []byte{
+				0xad, 0xbc, 0xcb, 0xda,
+				0x00, 0x00, 0x00, 0x02,
+				0x00, 0x00, 0x00, 0x08,
+				0x00, 0x00, 0x00, 0x00,
+				0x00,
+			},
+		},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			got := EncodeHaltTx(tc.id, tc.autoTxOnly)
+			if !bytes.Equal(got, tc.want) {
+				t.Errorf("EncodeHaltTx(%q, %v)\n got %#v\nwant %#v", tc.id, tc.autoTxOnly, got, tc.want)
+			}
+		})
+	}
+}
+
+// SendHaltTx must refuse an empty id rather than broadcast a halt at whatever
+// application happens to answer: with two receivers sharing a multicast group,
+// halting the wrong one is worse than doing nothing.
+func TestSendHaltTxRejectsEmptyID(t *testing.T) {
+	m := &Manager{}
+	if err := m.SendHaltTx("   ", false); err == nil {
+		t.Fatal("expected an error for a blank program id")
+	}
+}

internal/integrations/udp/wsjtreply.go

@@ -107,7 +107,16 @@ func (m *Manager) SendReply(r Reply) error {
 		if _, err := conn.WriteToUDP(pkt, addr); err != nil {
 			return fmt.Errorf("send reply to %s at %s: %w", r.ProgramID, addr, err)
 		}
-		applog.Printf("udp: reply sent to %s at %s — %q", r.ProgramID, addr, r.Message)
+		// Says whether the decode being answered was a CQ, because that is what
+		// decides whether the far end will act on it at all: the protocol only
+		// requires a Reply to be honoured for a CQ or QRZ. Without this the log
+		// showed a reply going out and nothing happening, and the reason had to
+		// be deduced from the message text by eye.
+		kind := "not a CQ — the far end may ignore it"
+		if strings.HasPrefix(strings.TrimSpace(strings.ToUpper(r.Message)), "CQ ") {
+			kind = "CQ"
+		}
+		applog.Printf("udp: reply sent to %s at %s — %q (%s)", r.ProgramID, addr, r.Message, kind)
 		return nil
 	}
 	return fmt.Errorf("no packet has arrived from %q yet — nothing to answer to", r.ProgramID)

internal/qso/qso.go

@@ -1475,13 +1475,67 @@ func conditionSQL(c Condition) (string, []any, error) {
 	}
 }
 
+// quickCallsignLike turns the Recent-QSOs search box into a SQL LIKE pattern.
+//
+// The rule, which is the one an operator already has in their head from the
+// alert filters:
+//
+//	4S     → starts with 4S      (4S%)
+//	*4S    → ends with 4S        (%4S)
+//	*4S*   → contains 4S         (%4S%)
+//	4S?    → 4S and one more     (4S_)
+//
+// So a plain word is a PREFIX — the common case, and what makes typing a call
+// feel like a call sign lookup rather than a text search. The moment a wildcard
+// appears the pattern is taken literally end to end, which is the only way
+// "*4S" can mean "ends with" while "4S" means "starts with".
+//
+// This used to be an unconditional contains-match, so there was no way to ask
+// for a prefix at all: searching 4S returned every call with 4S buried in it.
+//
+// % and _ typed by the operator are escaped to literals — otherwise a search
+// for "_" would quietly match everything.
+func quickCallsignLike(pattern string) string {
+	p := strings.TrimSpace(pattern)
+	var b strings.Builder
+	esc := func(r rune) {
+		switch r {
+		case '%', '_', '!':
+			b.WriteByte('!')
+		}
+		b.WriteRune(r)
+	}
+	if !strings.ContainsAny(p, "*?") {
+		for _, r := range p {
+			esc(r)
+		}
+		b.WriteByte('%') // plain text = prefix
+		return b.String()
+	}
+	for _, r := range p {
+		switch r {
+		case '*':
+			b.WriteByte('%')
+		case '?':
+			b.WriteByte('_')
+		default:
+			esc(r)
+		}
+	}
+	return b.String()
+}
+
 // buildWhere assembles the predicate (everything after WHERE) + args.
 func buildWhere(f QueryFilter) (string, []any, error) {
 	pred := "1=1"
 	var args []any
 	if qc := strings.TrimSpace(f.QuickCallsign); qc != "" {
-		pred += " AND callsign LIKE ?"
+		// ESCAPE '!' rather than the usual backslash: the clause is a literal in
-		args = append(args, "%"+qc+"%")
+		// the SQL text, and '\\' is one character to MySQL but two to SQLite,
+		// which rejects it. '!' is one character to both and appears in no
+		// callsign.
+		pred += " AND callsign LIKE ? ESCAPE '!'"
+		args = append(args, quickCallsignLike(qc))
 	}
 	if len(f.Conditions) > 0 {
 		joiner := " AND "
@@ -1605,6 +1659,136 @@ func (r *Repo) IterateByIDs(ctx context.Context, ids []int64, fn func(QSO) error
 	return rows.Err()
 }
 
+// GridKey builds the lookup key for the worked-grid index.
+//
+// band is "" for a "mix bands" scope, which is why the index stores BOTH forms
+// for every contact: asking "worked anywhere" must not mean walking the map.
+func GridKey(grid, band, class string) string {
+	return grid + "|" + strings.ToLower(band) + "|" + class
+}
+
+// GridWorkedIndex maps every worked square to whether it is CONFIRMED, under
+// every band-and-mode scope the operator can choose between.
+//
+// One QSO lands in several buckets, because the scopes overlap: an FT8 contact
+// counts for "this exact mode", for "any FTx mode" and for "any digital mode",
+// and each of those under both its own band and the any-band form. classesOf is
+// supplied by the caller — the meaning of DIGI and FTx belongs upstairs with the
+// rest of the mode vocabulary, not here.
+//
+// The value is "confirmed", not merely "present", so the same index answers both
+// hunting modes: chase what has never been worked, or chase what is not yet
+// confirmed. Confirmed means LoTW, a card or eQSL — the three the award engine
+// counts, so a square cannot be confirmed here and unconfirmed there.
+func (r *Repo) GridWorkedIndex(ctx context.Context, classesOf func(mode string) []string) (map[string]bool, error) {
+	rows, err := r.db.QueryContext(ctx, `
+		SELECT COALESCE(grid,''), UPPER(COALESCE(mode,'')), LOWER(COALESCE(band,'')),
+		       COALESCE(lotw_rcvd,''), COALESCE(qsl_rcvd,''), COALESCE(eqsl_rcvd,'')
+		FROM qso
+		WHERE grid IS NOT NULL AND grid != ''`)
+	if err != nil {
+		return nil, fmt.Errorf("query worked grids: %w", err)
+	}
+	defer rows.Close()
+	out := make(map[string]bool, 8192)
+	for rows.Next() {
+		var grid, mode, band, lotw, card, eqsl string
+		if err := rows.Scan(&grid, &mode, &band, &lotw, &card, &eqsl); err != nil {
+			return nil, err
+		}
+		g := strings.ToUpper(strings.TrimSpace(grid))
+		if len(g) < 4 {
+			continue
+		}
+		g = g[:4]
+		confirmed := lotw == "Y" || card == "Y" || eqsl == "Y"
+		for _, cls := range classesOf(mode) {
+			if cls == "" {
+				continue
+			}
+			// || is never a downgrade: one confirmed contact confirms the square
+			// for that scope, whatever the others say.
+			for _, k := range []string{GridKey(g, band, cls), GridKey(g, "", cls)} {
+				out[k] = out[k] || confirmed
+			}
+		}
+	}
+	return out, rows.Err()
+}
+
+// GridSquare is one 4-character Maidenhead square in the log.
+type GridSquare struct {
+	Grid      string `json:"grid"`
+	Count     int    `json:"count"`
+	Confirmed bool   `json:"confirmed"`
+	// Band and Mode of the most recent contact in the square, for the tooltip.
+	// The square is the subject here, not the QSO, so one example is enough —
+	// listing every band a square was worked on turns a map into a table.
+	Band string `json:"band,omitempty"`
+	Mode string `json:"mode,omitempty"`
+}
+
+// GridSquares aggregates the log into 4-character squares, newest contact
+// deciding the example band/mode.
+//
+// modeOf filters and is supplied by the caller (it owns what "digital" means):
+// return false to drop a QSO. Aggregation to 4 characters happens HERE rather
+// than in SQL — the column holds 4, 6 and 8-character grids, and lower(substr)
+// in SQL would differ between SQLite and MySQL for no gain.
+func (r *Repo) GridSquares(ctx context.Context, keep func(mode string) bool) ([]GridSquare, error) {
+	rows, err := r.db.QueryContext(ctx, `
+		SELECT COALESCE(grid,''), UPPER(COALESCE(mode,'')), LOWER(COALESCE(band,'')),
+		       COALESCE(lotw_rcvd,''), COALESCE(qsl_rcvd,''), COALESCE(eqsl_rcvd,'')
+		FROM qso
+		WHERE grid IS NOT NULL AND grid != ''
+		ORDER BY qso_date ASC, id ASC`)
+	if err != nil {
+		return nil, fmt.Errorf("query grid squares: %w", err)
+	}
+	defer rows.Close()
+	out := map[string]*GridSquare{}
+	for rows.Next() {
+		var grid, mode, band, lotw, card, eqsl string
+		if err := rows.Scan(&grid, &mode, &band, &lotw, &card, &eqsl); err != nil {
+			return nil, err
+		}
+		if keep != nil && !keep(mode) {
+			continue
+		}
+		g := strings.ToUpper(strings.TrimSpace(grid))
+		if len(g) < 4 {
+			continue
+		}
+		g = g[:4]
+		// Guard the shape: a malformed grid would draw a rectangle somewhere
+		// arbitrary, and a map with one square in the sea is a map nobody trusts.
+		if g[0] < 'A' || g[0] > 'R' || g[1] < 'A' || g[1] > 'R' ||
+			g[2] < '0' || g[2] > '9' || g[3] < '0' || g[3] > '9' {
+			continue
+		}
+		sq := out[g]
+		if sq == nil {
+			sq = &GridSquare{Grid: g}
+			out[g] = sq
+		}
+		sq.Count++
+		// Ascending order, so the last write wins = the most recent contact.
+		sq.Band, sq.Mode = band, mode
+		if lotw == "Y" || card == "Y" || eqsl == "Y" {
+			sq.Confirmed = true
+		}
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	list := make([]GridSquare, 0, len(out))
+	for _, sq := range out {
+		list = append(list, *sq)
+	}
+	sort.Slice(list, func(i, j int) bool { return list[i].Grid < list[j].Grid })
+	return list, nil
+}
+
 // BandSlotQSOs returns every contact on one band that belongs to a slot of the
 // entry matrix: the exact callsign, or any callsign in the same DXCC entity.
 // Mode is NOT filtered here — the class (phone / CW / digital) is a derived

internal/qso/quickcall_test.go

@@ -0,0 +1,28 @@
+package qso
+
+import "testing"
+
+// The search box is the one place an operator types a callsign fragment, and
+// the three shapes below are what they expect from every other logger. A plain
+// word is a PREFIX: it used to be an unconditional contains-match, so asking
+// for "calls starting with 4S" was impossible.
+func TestQuickCallsignLike(t *testing.T) {
+	for _, tc := range []struct{ in, want, why string }{
+		{"4S", "4S%", "plain text is a prefix"},
+		{"*4S", "%4S", "a leading star means ends-with"},
+		{"*4S*", "%4S%", "stars both ends mean contains"},
+		{"4S*", "4S%", "a trailing star is the same prefix, written out"},
+		{"4S?", "4S_", "? is exactly one character"},
+		{"*", "%", "a lone star matches everything"},
+		{"  4S  ", "4S%", "surrounding space is not part of the call"},
+		// Escaping: a LIKE metacharacter the operator typed is a literal.
+		{"A_B", "A!_B%", "_ typed by hand is a literal underscore"},
+		{"50%", "50!%%", "% typed by hand is a literal percent"},
+		{"A!B", "A!!B%", "the escape character escapes itself"},
+		{"*A_B*", "%A!_B%", "escaping still applies inside a wildcard pattern"},
+	} {
+		if got := quickCallsignLike(tc.in); got != tc.want {
+			t.Errorf("quickCallsignLike(%q) = %q, want %q — %s", tc.in, got, tc.want, tc.why)
+		}
+	}
+}

offline.go

@@ -161,6 +161,11 @@ func (a *App) replayOfflineQueue() (int, error) {
 			failed = append(failed, q)
 			continue
 		}
+		// These are contacts the operator MADE — the worked indexes have to learn
+		// them, or every one of them keeps its NEW badge in the cluster and decode
+		// lists until the next restart. a.qso.Add is the raw insert; only AddQSO
+		// does this for you, and the outbox replay does not go through it.
+		a.noteWorked(q.Callsign, q.Band, q.Mode)
 		imported++
 	}
 

syncfolder.go

@@ -507,6 +507,10 @@ func (a *App) applySyncRecord(rec syncfolder.Record) bool {
 	if err := a.qso.SetSyncUID(a.ctx, newID, rec.UID); err != nil {
 		applog.Printf("foldersync: stamping the new QSO %d: %v", newID, err)
 	}
+	// A partner's contact counts as worked for this station too — that is the
+	// point of a multi-op log — so the worked indexes must learn it exactly as
+	// they do for our own. Raw insert, so nothing else does it.
+	a.noteWorked(q.Callsign, q.Band, q.Mode)
 	return true
 }
 

telemetry.go

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