chore: release v0.26.0

Every station on an already-worked band was flagged NEW MODE.

A WSJT-X 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 was passed straight through as though it were a mode. The
status resolver then compared "~" against the modes worked for the entity,
matched nothing, and concluded the mode had never been worked. Same cause
put "~ -07" in the comment of every decode spot pushed to the FlexRadio
panadapter, which nobody had traced back.

Resolved through a marker table, with the mode from the sender's last
Status as the fallback - Status is the message that carries the real name.
So an unlisted or future marker degrades to correct rather than to
nonsense, and a sender that puts the name in the field directly is believed
as-is. With neither available the mode is left empty, which makes the
resolver answer "worked": the safe side, since a wrong mode invents a
new-mode flag exactly as the marker did.

app.go

@@ -704,6 +704,11 @@ type App struct {
 	operating    *operating.Repo
 	udp          *udp.Manager
 	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
@@ -3155,9 +3160,10 @@ func (a *App) applyStationDefaults(q *qso.QSO, includeIdentity bool) {
 	if err != nil {
 		return
 	}
-	// STATION_CALLSIGN drives upload routing, so only stamp it on NEW QSOs — on
+	// STATION_CALLSIGN drives upload routing, so it is filled only when the
-	// import backfill, stamping the active call onto a QSO that lacked one could
+	// caller asks for identity — and only when the record has none. A QSO that
-	// misroute it in a mixed-call log.
+	// already names its station keeps it, which is what stops a mixed-call log
+	// being re-routed; a QSO with the field blank has nothing to protect.
 	if includeIdentity && q.StationCallsign == "" {
 		q.StationCallsign = p.Callsign
 	}
@@ -4289,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
 }
 
@@ -6666,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.
@@ -6811,6 +6945,9 @@ func (a *App) ImportADIF(path string, dupMode string, applyCty bool, applyStatio
 		_ = a.clublog.EnsureLoaded()
 	}
 	clLoaded := a.clublog != nil && a.clublog.Loaded()
+	// Counted rather than assumed: "did it fill the callsign?" is the first
+	// question after an import, and the log is where it gets answered.
+	stationStamped := 0
 	if applyCty || applyStation {
 		im.Enrich = func(q *qso.QSO) {
 			if applyCty {
@@ -6822,9 +6959,23 @@ func (a *App) ImportADIF(path string, dupMode string, applyCty bool, applyStatio
 			// Unconditional: see fillDistance.
 			fillDistance(q)
 			if applyStation {
-				// Backfill empty MY_* descriptive fields from the active profile
+				// Backfill every empty station field from the active profile,
-				// (identity fields left alone to keep mixed-call routing intact).
+				// STATION_CALLSIGN included.
-				a.applyStationDefaults(q, false)
+				//
+				// It used to be the one field held back, on the grounds that
+				// stamping the active call could re-route a mixed-call log. That
+				// protected nothing: the same option already writes this profile's
+				// grid, rig, antenna and postal address onto every record it finds
+				// blank, so it has assumed "this log is mine" long before reaching
+				// the callsign — and a record that CARRIES a call is never touched,
+				// which is what actually keeps a multi-op log intact. Withholding it
+				// only meant the option quietly failed the one field an operator
+				// checks afterwards.
+				hadStation := strings.TrimSpace(q.StationCallsign) != ""
+				a.applyStationDefaults(q, true)
+				if !hadStation && strings.TrimSpace(q.StationCallsign) != "" {
+					stationStamped++
+				}
 				// Also stamp the default QSL/LoTW/eQSL confirmation statuses on
 				// any that are still empty (same defaults new QSOs get).
 				a.applyQSLDefaults(q)
@@ -6835,6 +6986,9 @@ func (a *App) ImportADIF(path string, dupMode string, applyCty bool, applyStatio
 		wruntime.EventsEmit(a.ctx, "import:progress", map[string]int{"processed": processed, "total": total})
 	}
 	res, err := im.ImportFile(a.ctx, path)
+	if stationStamped > 0 {
+		applog.Printf("import: STATION_CALLSIGN filled from the active profile on %d record(s) that carried none", stationStamped)
+	}
 	if err == nil && (res.Imported > 0 || res.Updated > 0) {
 		a.recomputeAwardRefsAsync() // materialise award_refs for the imported rows
 	}
@@ -8267,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
@@ -8318,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
@@ -8331,12 +8512,17 @@ 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
+	// "DL1ABC-#" resolves to nothing.
+	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)
 	for _, mt := range matches {
 		if a.ctx != nil && (mt.Rule.Visual || mt.Rule.Sound) {
@@ -8390,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.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.
@@ -12612,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
@@ -12668,6 +12865,32 @@ func (a *App) consumeUDPEvents() {
 		if a.ctx == nil {
 			continue
 		}
+		// The operator's own transmit state, from Status. Emitted before the
+		// 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: the
+		// field is EMPTY between overs — that is its normal state, not a sender
+		// that withholds it — and the panel still has to say who is being called
+		// 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,
+				"freq_hz":      ev.FreqHz,
+				"band":         bandForHz(ev.FreqHz),
+				"instance":     ev.ProgramID,
+				"at":           time.Now().UTC().Format(time.RFC3339),
+			})
+		}
 		switch {
 		case ev.DecodeCall != "":
 			// Remember the grid before anything else: a CQ is the one message that
@@ -12675,6 +12898,41 @@ func (a *App) consumeUDPEvents() {
 			if ev.DecodeGrid != "" {
 				a.rememberDecodeGrid(ev.DecodeCall, ev.DecodeGrid, gridcache.SourceDecode)
 			}
+			// Hand every decode to the UI. Unconditional, and BEFORE the
+			// panadapter block below, which skips a call it spotted moments ago:
+			// that de-duplication exists to spare the radio, and applying it here
+			// would silently drop most of a period from the panel that is meant to
+			// show the period whole.
+			at := ev.DecodeAt
+			if at.IsZero() {
+				at = time.Now().UTC() // sender gave no timestamp — arrival will do
+			}
+			wruntime.EventsEmit(a.ctx, "udp:decode", map[string]any{
+				"call":      ev.DecodeCall,
+				"grid":      ev.DecodeGrid,
+				"snr":       ev.DecodeSNR,
+				"freq_hz":   ev.DecodeFreqHz,
+				"dial_hz":   ev.DecodeDial,
+				"band":      bandForHz(ev.DecodeFreqHz),
+				"mode":      ev.Mode,
+				"msg":       ev.DecodeMsg,
+				"cq":        ev.DecodeCQ,
+				"at":        at.Format(time.RFC3339),
+				"tr_period": ev.DecodeTRPeriod,
+				"off_air":   ev.DecodeOffAir,
+				"source":    ev.Source,
+				"instance":  ev.ProgramID,
+				"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. 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
 			// after the configured duration. De-duped per call in the Flex backend.
@@ -18146,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
@@ -18186,7 +18450,14 @@ type clusterStatusCache struct {
 	callCounties map[string]string
 	workedPOTA   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
@@ -18201,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
@@ -18257,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
@@ -18300,6 +18580,68 @@ type GridCacheStatus struct {
 	Pending int  `json:"pending"` // waiting for the next batch write
 }
 
+// AnswerDecode tells the decoding application to call a station — the same
+// thing as double-clicking the line in WSJT-X's own Band Activity window.
+//
+// This is not something OpsLog can do by tuning the radio. On FT8 the whole band
+// sits inside one passband, so moving the dial changes nothing about who gets
+// answered: the decision belongs to WSJT-X/MSHV, and the Reply message is the
+// only way to hand it over. The panel therefore does NOT retune the rig on a
+// click, which would only fight the digital application for the VFO.
+//
+// Every argument replays the decode as it arrived, because the target matches it
+// against its own decode list and ignores anything it cannot find.
+func (a *App) AnswerDecode(instance string, ms uint32, snr int, dt float64, audioHz int64, mode, msg string, lowConf bool) error {
+	if a.udp == nil {
+		return fmt.Errorf("udp not initialized")
+	}
+	err := a.udp.SendReply(udp.Reply{
+		ProgramID:     instance,
+		MsSinceMidnig: ms,
+		SNR:           int32(snr),
+		DeltaTime:     dt,
+		DeltaFreqHz:   uint32(audioHz),
+		Mode:          mode,
+		Message:       msg,
+		LowConfidence: lowConf,
+	})
+	if err != nil {
+		applog.Printf("udp: answer decode %q on %q failed: %v", msg, instance, err)
+	}
+	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}
@@ -18493,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
-			// callsign and gives up, so EVERY spot came back with no continent and
-			// 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,
@@ -18520,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"
@@ -29,6 +30,7 @@ import (
 const (
 	keyBandOpenEnabled = "bandopen.enabled"
 	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

@@ -1,4 +1,42 @@
 [
+  {
+    "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."
+    ],
+    "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."
+    ]
+  },
   {
     "version": "0.25.9",
     "date": "",

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 { 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,9 @@ 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';
 import { formatDateTimeUTC } from '@/lib/dateFormat';
@@ -1031,6 +1034,36 @@ export default function App() {
     setStationTabOpen(false);
     setActiveTab((t) => (t === 'station' ? 'recent' : t));
   }
+  // FTx decodes — same closable-tab pattern, but its open state is REMEMBERED:
+  // 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');
+    setActiveTab('decodes');
+  }
+  function closeDecodesTab() {
+    setDecodesTabOpen(false);
+    writeUiPref('opslog.decodesTab', '0');
+    setActiveTab((t) => (t === 'decodes' ? 'recent' : t));
+  }
   // Recent QSOs row cap, persisted. With AG Grid's virtual scroller
   // huge logs render OK once loaded, but a 25k+ logbook still takes a
   // couple of seconds to round-trip from SQLite at launch. Defaulting
@@ -1641,12 +1674,12 @@ export default function App() {
   // map ("map1"), the locator street map ("map2"), the cluster grid or the
   // worked-before grid. Per-profile (stored via SetUIPref → profile-prefixed),
   // so it's loaded async on mount and re-read on profile:changed below.
-  type MainPaneKind = 'map1' | 'map2' | 'cluster' | 'worked' | 'flex' | 'recent' | 'icom' | 'yaesu' | 'netcontrol';
+  type MainPaneKind = 'map1' | 'map2' | 'cluster' | 'worked' | 'flex' | 'recent' | 'icom' | 'yaesu' | 'netcontrol' | 'decodes';
   const [mapZoomSignal, setMapZoomSignal] = useState(0); // bump → world map auto-zooms now
   const [mainPaneLeft, setMainPaneLeft] = useState<MainPaneKind>('map1');
   const [mainPaneRight, setMainPaneRight] = useState<MainPaneKind>('map2');
   const loadMainPanes = useCallback(async () => {
-    const valid = (v: string): v is MainPaneKind => v === 'map1' || v === 'map2' || v === 'cluster' || v === 'worked' || v === 'flex' || v === 'recent' || v === 'icom' || v === 'yaesu' || v === 'netcontrol';
+    const valid = (v: string): v is MainPaneKind => v === 'map1' || v === 'map2' || v === 'cluster' || v === 'worked' || v === 'flex' || v === 'recent' || v === 'icom' || v === 'yaesu' || v === 'netcontrol' || v === 'decodes';
     const [l, r] = await Promise.all([
       GetUIPref('mainPaneLeft').catch(() => ''),
       GetUIPref('mainPaneRight').catch(() => ''),
@@ -1685,6 +1718,10 @@ export default function App() {
   // a stale closure.
   const spotsRef = useRef(spots);
   useEffect(() => { spotsRef.current = spots; }, [spots]);
+  // The decoded stations, for the same reason: the status refresh and the cache
+  // prune below both need them, and neither may re-subscribe every time a decode
+  // lands. Filled by an effect next to the `decodes` state further down.
+  const decodesRef = useRef<DecodeRow[]>([]);
   // Bound the status cache. Keyed per call|band|mode, it otherwise kept an entry
   // for every station ever seen — under an RBN firehose (thousands of unique
   // calls/hour) that grew without limit to gigabytes. Prune it back to the live
@@ -1696,10 +1733,16 @@ export default function App() {
       const keys = Object.keys(prev);
       if (keys.length <= SPOTS_CAP * 2) return prev;
       const live = new Set(spots.map((x) => spotStatusKey(x.dx_call, x.band ?? '', x.comment ?? '', x.freq_hz)));
+      // Decoded stations count as live too. They share this cache, and pruning
+      // to the cluster spots alone would evict every one of them — on a busy
+      // band the decodes are what push the cache past the cap in the first
+      // place, so the panel would blank its own badges the moment it filled up.
+      for (const d of decodesRef.current) live.add(`${d.call}|${d.band ?? ''}|${(d.mode ?? '').toUpperCase()}`);
       const pruned: typeof prev = {};
       for (const k of keys) if (live.has(k)) pruned[k] = prev[k];
       return pruned;
     });
+    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [spots]);
   // Re-fetch the status of every SHOWN spot and OVERWRITE the cache (merge, never
   // clear). Overwriting keeps the other NEW badges on screen until their fresh
@@ -1708,7 +1751,6 @@ export default function App() {
   // count (it scans the logbook once), so this is as cheap as the poll already is.
   const refreshSpotStatuses = useCallback(async () => {
     const cur = spotsRef.current;
-    if (!cur.length) return;
     const queries: { call: string; band: string; mode: string; pota_ref: string; spotter: string }[] = [];
     const seen = new Set<string>();
     for (const s of cur) {
@@ -1717,6 +1759,19 @@ export default function App() {
       seen.add(k);
       queries.push({ call: s.dx_call, band: s.band ?? '', mode: inferSpotMode(s.comment ?? '', s.freq_hz), pota_ref: (s as any).pota_ref ?? '', spotter: s.spotter ?? '' });
     }
+    // The decoded stations as well. Their verdict is resolved once when the
+    // decode arrives and then cached for ever, so a station worked five minutes
+    // ago went on wearing its NEW SLOT badge for the rest of the half hour it
+    // stays in the list — reported on an EY35S already in the log. Deduplicated
+    // by call+band+mode, so half an hour of a busy band is a few hundred
+    // queries, and the backend answers a whole batch with one pass of the log.
+    for (const d of decodesRef.current) {
+      const mode = (d.mode ?? '').toUpperCase();
+      const k = `${d.call}|${d.band ?? ''}|${mode}`;
+      if (seen.has(k)) continue;
+      seen.add(k);
+      queries.push({ call: d.call, band: d.band ?? '', mode, pota_ref: '', spotter: '' });
+    }
     if (!queries.length) return;
     try {
       const res = await ClusterSpotStatuses(queries as any);
@@ -1749,7 +1804,8 @@ export default function App() {
   const spotsDirtyRef = useRef(false);
   useEffect(() => {
     const vis = mainPaneLeft === 'cluster' || mainPaneRight === 'cluster'
-      || activeTab === 'cluster' || activeTab === 'bandmap' || showBandMap;
+      || mainPaneLeft === 'decodes' || mainPaneRight === 'decodes'
+      || activeTab === 'cluster' || activeTab === 'bandmap' || activeTab === 'decodes' || showBandMap;
     if (vis && !spotsVisibleRef.current && spotsDirtyRef.current) {
       spotsDirtyRef.current = false;
       void refreshSpotStatuses();
@@ -1790,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.
@@ -2018,6 +2075,116 @@ export default function App() {
   // settings dialog closes, which is the only place it changes.
   const [rowColors, setRowColors] = useState<any>(null);
   useEffect(() => { GetRowColors().then(setRowColors).catch(() => {}); }, [showSettings]);
+  // ── FTx decodes from the inbound UDP feed ──────────────────────────
+  //
+  // Held in the frontend, like the cluster spots: they are a live view, not
+  // data, and nothing outside this panel reads them. Pruned to a rolling
+  // half hour — long enough to hold a whole opening, short enough that a night
+  // of FT8 on 20 m does not turn the list into something no filter can rescue.
+  const DECODE_KEEP_MS = 30 * 60 * 1000;
+  const [decodes, setDecodes] = useState<DecodeRow[]>([]);
+  const [txMsgs, setTxMsgs] = useState<TxMsgRow[]>([]);
+  // 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[]>([]);
+  const pendingDecodeTimer = useRef<number | undefined>(undefined);
+
   // Rotor quick-turn buttons (Settings → Rotator). Same reload trigger as the
   // row colours: the settings dialog is the only place they change.
   const [rotorPresets, setRotorPresets] = useState<{ label: string; azimuth: number }[]>([]);
@@ -2157,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.
@@ -3010,6 +3182,97 @@ export default function App() {
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 
+  // ── FTx decodes ────────────────────────────────────────────────────
+  useEffect(() => {
+    // Resolve the new-entity / new-slot flags into the SAME map the cluster
+    // fills. One cache, one verdict: a call must not be "new band" in the
+    // decodes panel and plain worked in the cluster list two seconds later.
+    const flushDecodes = async () => {
+      pendingDecodeTimer.current = undefined;
+      const batch = pendingDecodesRef.current;
+      pendingDecodesRef.current = [];
+      if (batch.length === 0) return;
+      try {
+        const known = spotStatusRef.current;
+        const seen = new Set<string>();
+        const unknown: { call: string; band: string; mode: string; pota_ref: string; spotter: string }[] = [];
+        for (const d of batch) {
+          const k = `${d.call}|${d.band ?? ''}|${(d.mode ?? '').toUpperCase()}`;
+          if (seen.has(k) || known[k]) continue;
+          seen.add(k);
+          unknown.push({ call: d.call, band: d.band ?? '', mode: (d.mode ?? '').toUpperCase(), pota_ref: '', spotter: '' });
+        }
+        if (unknown.length > 0) {
+          const res = await ClusterSpotStatuses(unknown as any);
+          setSpotStatus((prev) => {
+            const next = { ...prev };
+            for (const r of res) {
+              const k = `${r.call}|${r.band ?? ''}|${(r.mode ?? '').toUpperCase()}`;
+              next[k] = {
+                status: r.status ?? '',
+                country: r.country,
+                continent: (r as any).continent,
+                worked_call: !!(r as any).worked_call,
+                worked_slot: !!(r as any).worked_slot,
+                new_county: !!(r as any).new_county, lotw: !!(r as any).lotw,
+                grid: (r as any).grid, new_grid: !!(r as any).new_grid,
+                county: (r as any).county, state: (r as any).state,
+                new_pota: !!(r as any).new_pota,
+                new_pfx: !!(r as any).new_pfx, pfx: (r as any).pfx,
+              };
+            }
+            return next;
+          });
+        }
+      } catch { /* status unresolved — the decode still shows, just unflagged */ }
+      setDecodes((arr) => {
+        const cutoff = Date.now() - DECODE_KEEP_MS;
+        const next = [...arr, ...batch].filter((d) => Date.parse(d.at) >= cutoff);
+        return next;
+      });
+    };
+
+    const unsubDecode = EventsOn('udp:decode', (d: DecodeRow) => {
+      pendingDecodesRef.current.push(d);
+      if (pendingDecodeTimer.current === undefined) {
+        pendingDecodeTimer.current = window.setTimeout(flushDecodes, 300);
+      }
+    });
+
+    // The operator's own transmission. Status repeats it about once a second
+    // for the whole over, so it is recorded ONCE per message: the panel wants
+    // "I sent this in that period", not sixty copies of it.
+    const unsubTx = EventsOn('udp:tx_state', (m: any) => {
+      // The live strip takes every Status: it has to say who is being called
+      // 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;
+      setTxMsgs((arr) => {
+        const last = arr[arr.length - 1];
+        if (last && last.msg === m.msg && Date.parse(m.at) - Date.parse(last.at) < 30_000) return arr;
+        const cutoff = Date.now() - DECODE_KEEP_MS;
+        return [...arr, m as TxMsgRow].filter((x) => Date.parse(x.at) >= cutoff);
+      });
+    });
+
+    return () => {
+      unsubDecode?.(); unsubTx?.();
+      if (pendingDecodeTimer.current !== undefined) window.clearTimeout(pendingDecodeTimer.current);
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
   // ── UDP integration events ───────────────────────────────────────────
   // Live updates from external apps (WSJT-X / JTDX / MSHV / DXHunter…).
   // We push the broadcast DX call into the entry field and auto-log any
@@ -4173,6 +4436,8 @@ export default function App() {
       { type: 'item', label: t('tools.qslManager'), action: 'tools.qslmanager' },
       { 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' },
@@ -4222,6 +4487,8 @@ export default function App() {
       case 'tools.qslmanager':  setQslTabOpen(true); setActiveTab('qsl'); break;
       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;
@@ -5051,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);
@@ -5306,6 +5581,74 @@ export default function App() {
     </button>
   );
 
+  // The FT decodes panel, built in ONE place: it is offered both as a tab and as
+  // a Main-view pane, and two copies of this call would be two sets of props to
+  // keep in step.
+  const renderDecodesPanel = () => (
+    <DecodesPanel
+      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
+      // a Reply, which is the same thing as double-clicking the line in their
+      // own window.
+      //
+      // Deliberately NOT a rig tune, unlike a cluster spot. On FT8 the whole
+      // band is inside one passband, so moving the dial changes nothing about
+      // who gets answered — and it would only fight the digital application
+      // 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,
+          // 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)));
+      }}
+    />
+  );
+
   // Render one Main-view pane. The two sides (mainPaneLeft/Right) each pick from
   // the same four choices, configured per-profile in Settings → Main view.
   const renderMainPane = (kind: MainPaneKind) => {
@@ -5324,6 +5667,14 @@ export default function App() {
         );
       case 'map2':
         return <LocatorMap toGrid={grid} toLabel={callsign} />;
+      case 'decodes':
+        // Same panel as the tab, in a pane. It brings its own filter bar and
+        // column header, so it needs no frame of its own here.
+        return (
+          <div className="h-full w-full min-h-0 flex flex-col bg-card border border-border rounded-lg overflow-hidden">
+            {renderDecodesPanel()}
+          </div>
+        );
       case 'cluster':
         return (
           <div className="h-full w-full min-h-0 flex flex-col bg-card border border-border rounded-lg overflow-hidden">
@@ -6312,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}
@@ -6596,6 +6949,39 @@ 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')}
+                  {decodes.length > 0 && (
+                    <span className="text-[10px] tabular-nums text-muted-foreground">{decodes.length}</span>
+                  )}
+                  <span
+                    role="button"
+                    aria-label="Close FT decodes"
+                    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(); closeDecodesTab(); }}
+                  >
+                    <X className="size-3" />
+                  </span>
+                </TabsTrigger>
+              )}
               {stationTabOpen && (
                 <TabsTrigger value="station" className="gap-1.5">
                   {t('station.title')}
@@ -6637,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())}
                   />
@@ -7006,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>
             )}
 
@@ -7045,6 +7451,18 @@ 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()}
+              </TabsContent>
+            )}
+
             {stationTabOpen && (
               <TabsContent value="station" className="mt-0 flex flex-col min-h-0 flex-1 data-[state=inactive]:hidden">
                 <StationControlPanel

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/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">
+            <Button variant="ghost" size="sm" className="h-6 text-[11px]"
+              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,6 +98,11 @@ 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>
+      {/* Conditional like every other entry. These two were drawn
+          unconditionally, and the grid passes them through an arrow that calls
+          an optional handler — so in a grid that wires neither (the QSL
+          Manager) both appeared and did precisely nothing when clicked. */}
+      {onUpdateFromCty && (
         <button
           className="flex w-full items-center gap-2 px-3 py-1.5 text-left hover:bg-accent/50"
           onClick={() => { onUpdateFromCty(menu.ids); onClose(); }}
@@ -105,6 +110,8 @@ export function QSOContextMenu({ menu, onClose, onUpdateFromCty, onUpdateFromQRZ
           <Globe2 className="size-4 text-primary" />
           <span>{t('qctx.fixCountry')}</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(); }}
@@ -112,6 +119,7 @@ export function QSOContextMenu({ menu, onClose, onUpdateFromCty, onUpdateFromQRZ
           <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',
@@ -1029,7 +1032,7 @@ function RelayAutoPanel() {
 // panes show, independently: the great-circle map, the locator street map, the
 // cluster grid or the worked-before grid. Per-profile (stored via SetUIPref,
 // which is profile-prefixed). Self-contained so it owns its async-loaded state.
-const MAIN_PANE_VALUES = ['map1', 'map2', 'cluster', 'worked', 'recent', 'netcontrol'];
+const MAIN_PANE_VALUES = ['map1', 'map2', 'cluster', 'worked', 'recent', 'netcontrol', 'decodes'];
 function MainViewPanes({ onChanged, flexAvailable, icomAvailable, yaesuAvailable }: { onChanged?: (side: 'left' | 'right', value: string) => void; flexAvailable?: boolean; icomAvailable?: boolean; yaesuAvailable?: boolean }) {
   const { t } = useI18n();
   const [left, setLeft] = useState('map1');
@@ -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

@@ -53,6 +53,8 @@ export function AmpPower(arg1:string,arg2:boolean):Promise<void>;
 
 export function AmpPowerLevel(arg1:string,arg2:string):Promise<void>;
 
+export function AnswerDecode(arg1:string,arg2:number,arg3:number,arg4:number,arg5:number,arg6:string,arg7:string,arg8:boolean):Promise<void>;
+
 export function AntGeniusActivate(arg1:number,arg2:number):Promise<void>;
 
 export function AntGeniusDeselect(arg1:number):Promise<void>;
@@ -355,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>;
@@ -457,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>>;
@@ -567,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>;
@@ -951,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>;
@@ -1009,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

@@ -46,6 +46,10 @@ export function AmpPowerLevel(arg1, arg2) {
   return window['go']['main']['App']['AmpPowerLevel'](arg1, arg2);
 }
 
+export function AnswerDecode(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) {
+  return window['go']['main']['App']['AnswerDecode'](arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+}
+
 export function AntGeniusActivate(arg1, arg2) {
   return window['go']['main']['App']['AntGeniusActivate'](arg1, arg2);
 }
@@ -650,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);
 }
@@ -854,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']();
 }
@@ -1074,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);
 }
@@ -1842,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);
 }
@@ -1958,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,6 +47,11 @@ 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
+	// 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"`

internal/extsvc/clublog.go

@@ -40,12 +40,26 @@ func looksLikeHTML(s string) bool {
 // anything in the operator's log, which is what a test button must never do.
 const clublogDownloadURL = "https://clublog.org/getadif.php"
 
-// clublogAppAPIKey is OpsLog's Club Log *application* API key. Club Log
+// clublogAppAPIKey is OpsLog's own Club Log *application* API key, issued to
-// requires an api parameter that identifies the client software (not the
+// "OpsLog" by G7VJR on 2026-08-18.
-// user) — the same way Log4OM embeds its own key — so we ship it baked in
+//
-// rather than asking each user for one. It's an application identifier, not
+// Club Log requires an api parameter identifying the client SOFTWARE, not the
-// a user secret, but note it is visible in the source and the binary.
+// user — the same way Log4OM embeds its own — so it ships baked in rather than
-const clublogAppAPIKey = "5767f19333363a9ef432ee9cd4141fe76b8adf38"
+// asking every operator to request one.
+//
+// It replaces a key that was registered to XV9Q, not to OpsLog. That was not a
+// cosmetic detail: every OpsLog upload in the world was attributed to that
+// callsign, its owner received the abuse warnings OpsLog earned, and a
+// revocation aimed at them would have cut Club Log uploads for every user of
+// this program at once.
+//
+// Club Log asks that the key not be published in source code. The source lives
+// on a private remote and only the built exe is released — but the key is still
+// recoverable from that binary by anyone who looks, as it is for every logger
+// that embeds one. Treat it as an identifier that can be attributed, never as a
+// secret: it authorises nothing on its own, since every request also carries the
+// operator's own e-mail and password.
+const clublogAppAPIKey = "8df47807a412c586787c9401c96c10c135d6e580"
 
 // UploadClublog pushes one ADIF record to Club Log in real time. The user
 // supplies the account email + password and the logbook callsign; the

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

@@ -0,0 +1,115 @@
+package udp
+
+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
+// be passed on as if it were a mode. Everything downstream compared it against
+// the modes in the log, matched nothing, and reported every station on an
+// already-worked band as a NEW MODE.
+func TestDecodeModeNameResolvesTheMarker(t *testing.T) {
+	for raw, want := range map[string]string{
+		"~": "FT8",
+		"+": "FT4",
+		"#": "JT65",
+		"@": "JT9",
+	} {
+		if got := DecodeModeName(raw, "FT8"); got != want {
+			t.Errorf("DecodeModeName(%q) = %q, want %q", raw, got, want)
+		}
+	}
+}
+
+// A sender that puts the real name in the field is believed as-is — several do,
+// and the marker table must not get in their way.
+func TestDecodeModeNameKeepsARealName(t *testing.T) {
+	for _, raw := range []string{"FT8", "ft4", "JS8", "Q65"} {
+		if got := DecodeModeName(raw, ""); got == "" || got != upper(raw) {
+			t.Errorf("DecodeModeName(%q) = %q, want the name itself", raw, got)
+		}
+	}
+}
+
+// The safety net: an unknown marker falls back to the mode from the sender's
+// last Status, which always carries the real name. This is what keeps a future
+// or unlisted marker degrading to correct rather than to nonsense.
+func TestDecodeModeNameFallsBackToStatus(t *testing.T) {
+	if got := DecodeModeName("%", "FT4"); got != "FT4" {
+		t.Errorf("unknown marker resolved to %q, want the Status mode FT4", got)
+	}
+	if got := DecodeModeName("", "FT8"); got != "FT8" {
+		t.Errorf("empty mode resolved to %q, want the Status mode FT8", got)
+	}
+	// Nothing known at all is empty rather than a guess: an empty mode makes the
+	// status resolver answer "worked", which is the safe side — a wrong mode
+	// would invent a new-mode flag exactly as the marker did.
+	if got := DecodeModeName("%", ""); got != "" {
+		t.Errorf("with no Status mode the result was %q, want empty", got)
+	}
+}
+
+func upper(s string) string {
+	out := []rune(s)
+	for i, r := range out {
+		if r >= 'a' && r <= 'z' {
+			out[i] = r - 32
+		}
+	}
+	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

@@ -0,0 +1,70 @@
+package udp
+
+import (
+	"testing"
+	"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) {
+	// Just after midnight, a stamp from the last seconds of yesterday.
+	now := time.Date(2026, 3, 14, 0, 0, 1, 0, time.UTC)
+	got := decodeTimeAt(sec(23, 59, 58), now)
+	if want := time.Date(2026, 3, 13, 23, 59, 58, 0, time.UTC); !got.Equal(want) {
+		t.Errorf("23:59:58 seen at 00:00:01 → %s, want %s (yesterday)", got, want)
+	}
+	if got.After(now) {
+		t.Errorf("%s is in the future — it would sort to the top of the list for the session", got)
+	}
+}
+
+// The mirror case: just before midnight, a stamp from the first seconds of
+// tomorrow. Our clock is still on the old day.
+func TestDecodeTimeCrossesMidnightBackwards(t *testing.T) {
+	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)
+	}
+}
+
+// The whole point of the timestamp is grouping, so two decodes from the same
+// fifteen-second slot must floor to the same period however far apart in the
+// slot they were heard.
+func TestDecodesInOneSlotShareAPeriod(t *testing.T) {
+	now := time.Date(2026, 3, 13, 12, 30, 7, 0, time.UTC)
+	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("%s and %s fell in different periods", a, b)
+	}
+	if floor(at(12, 30, 14)) == floor(at(12, 30, 15)) {
+		t.Error("12:30:14 and 12:30:15 are different slots and must not share a period")
+	}
+}

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

@@ -77,6 +77,37 @@ func reusingListenConfig() net.ListenConfig {
 	}
 }
 
+// decodeTime turns WSJT-X's milliseconds-since-midnight into a UTC instant.
+//
+// The sender gives a time of DAY with no date, so the date comes from our own
+// clock — and the two can straddle midnight: a decode stamped 23:59:58 that
+// reaches us at 00:00:01 would otherwise be dated a day late and sort to the top
+// 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 {
+	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 {
+	case at.Sub(now) > 12*time.Hour:
+		at = at.AddDate(0, 0, -1) // stamped late yesterday, arrived after midnight
+	case now.Sub(at) > 12*time.Hour:
+		at = at.AddDate(0, 0, 1) // stamped just after midnight, our clock still on the old day
+	}
+	return at
+}
+
 // Event is what a Server emits to its consumer for every parsed packet.
 // At most one of the fields is populated per event.
 type Event struct {
@@ -92,10 +123,55 @@ 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
+	DecodeMsg    string // the decoded line as printed ("CQ K1ABC FN42")
+	// DecodeAt is the decode's own UTC timestamp, rebuilt from the sender's
+	// milliseconds-since-midnight. It is what groups decodes into T/R periods:
+	// a period's worth arrives in one burst, so arrival time would put them all
+	// in whichever slot the burst happened to land in.
+	DecodeAt time.Time
+	// DecodeTRPeriod is the transmit/receive period in seconds, from the last
+	// Status of the same program (15 = FT8). 0 when the sender never said.
+	DecodeTRPeriod int
+	DecodeDial     int64 // dial frequency the decode was heard on, for the band
+	DecodeOffAir   bool  // decoded from a file rather than off the air
+	// The three fields below are shown in the panel AND replayed verbatim when
+	// answering the station — WSJT-X matches a Reply against its own decode list,
+	// so every one has to go back exactly as it came.
+	DecodeDT      float64 // seconds into the slot the transmission started
+	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
+	// Reply message would have to be sent back to, so it is carried even though
+	// nothing replies yet.
+	ProgramID string
+
+	// TxMessage is what the operator's digital app is sending, with Transmitting
+	// true while the carrier is actually up. From Status, so ~1 Hz.
+	TxMessage    string
+	Transmitting bool
+	// 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
@@ -113,6 +189,9 @@ type Event struct {
 // Server is a single inbound UDP listener.
 type Server struct {
 	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{}
@@ -127,6 +206,15 @@ type Server struct {
 	// 50.400 panadapter. WSJT-X requires --rig-name for a second instance, so the
 	// id is distinct whenever there is more than one.
 	dialHz map[string]int64
+	// trPeriod is the T/R period (seconds) from each program's last Status —
+	// what tells a decode which slot it belongs to.
+	trPeriod map[string]int
+	// lastFrom is the address each program's packets arrive from — where a Reply
+	// has to be sent. See SendReply.
+	lastFrom map[string]*net.UDPAddr
+	// lastMode is the mode NAME from each program's last Status, used to resolve
+	// a Decode's one-character mode marker.
+	lastMode map[string]string
 	lastDX   string // WSJT: last non-empty DX Call seen, to detect a clear
 
 	// badPkts counts datagrams this listener could not parse, so the diagnostic
@@ -171,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{}),
 	}
@@ -340,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:
@@ -351,6 +451,18 @@ func (s *Server) handle(pkt []byte, remote *net.UDPAddr) {
 		if !ok {
 			return
 		}
+		// Where this application's packets come from, so a Reply can be sent back
+		// to it. Per PROGRAM, not per listener: two receivers share one multicast
+		// group, and a reply must reach the one that heard the station — and it
+		// must go to the sender's own address, never to the group.
+		if w.ProgramID != "" && remote != nil {
+			s.mu.Lock()
+			if s.lastFrom == nil {
+				s.lastFrom = map[string]*net.UDPAddr{}
+			}
+			s.lastFrom[w.ProgramID] = remote
+			s.mu.Unlock()
+		}
 		// Status carries the current dial frequency; remember it so Decode audio
 		// offsets can be turned into RF frequencies for the panadapter.
 		if w.FreqHz > 0 && !w.IsDecode {
@@ -359,11 +471,40 @@ func (s *Server) handle(pkt []byte, remote *net.UDPAddr) {
 				s.dialHz = map[string]int64{}
 			}
 			s.dialHz[w.ProgramID] = w.FreqHz
+			// The T/R period travels with Status, and a decode has to be told
+			// which slot it belongs to — so it is remembered per program the
+			// same way the dial is.
+			if w.TRPeriod > 0 {
+				if s.trPeriod == nil {
+					s.trPeriod = map[string]int{}
+				}
+				s.trPeriod[w.ProgramID] = w.TRPeriod
+			}
+			// The mode NAME, which only Status carries: a Decode gives the
+			// one-character marker instead. See DecodeModeName.
+			if w.Mode != "" {
+				if s.lastMode == nil {
+					s.lastMode = map[string]string{}
+				}
+				s.lastMode[w.ProgramID] = w.Mode
+			}
 			s.mu.Unlock()
 		}
+		if !w.IsDecode && (w.TxMessage != "" || w.DECall != "") {
+			// What the operator is sending, and to whom. Carried on every Status,
+			// so the consumer sees it change as the QSO progresses. The program id
+			// travels with it because a second receiver has a transmit state of
+			// its own.
+			ev.TxMessage = w.TxMessage
+			ev.Transmitting = w.Transmitting
+			ev.DECall = w.DECall
+			ev.ProgramID = w.ProgramID
+		}
 		if w.IsDecode {
 			s.mu.Lock()
 			dial := s.dialHz[w.ProgramID]
+			tr := s.trPeriod[w.ProgramID]
+			statusMode := s.lastMode[w.ProgramID]
 			s.mu.Unlock()
 			if dial <= 0 {
 				// No Status from THIS instance yet. Guessing with another
@@ -376,7 +517,19 @@ func (s *Server) handle(pkt []byte, remote *net.UDPAddr) {
 			ev.DecodeFreqHz = dial + w.DeltaFreqHz
 			ev.DecodeSNR = w.SNR
 			ev.DecodeCQ = w.IsCQ
-			ev.Mode = w.Mode
+			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
+			ev.DecodeOffAir = w.OffAir
+			ev.ProgramID = w.ProgramID
+			ev.DecodeDT = w.DeltaTime
+			ev.DecodeAudioHz = w.DeltaFreqHz
+			ev.DecodeMs = w.DecodeMsSinceMidnight
+			ev.DecodeLowConf = w.LowConfidence
 			break
 		}
 		// Only a logged QSO is worth a line — WSJT-X/MSHV send a Status packet
@@ -501,7 +654,10 @@ func (s *Server) handle(pkt []byte, remote *net.UDPAddr) {
 	// Empty events are useless; skip — EXCEPT a clear signal, which is meant to be
 	// empty (the DX Call was cleared in the digital app), and a tune-only
 	// request (freq with no callsign).
-	if ev.DXCall == "" && ev.LoggedADIF == "" && ev.DecodeCall == "" && !ev.ClearCall && ev.TuneFreqHz == 0 {
+	// TxMessage rides on Status, which also carries the DX call — but a Status
+	// with an empty DX call and a live transmit message (calling CQ) used to be
+	// dropped here, and that is exactly the message the decodes panel needs.
+	if ev.DXCall == "" && ev.LoggedADIF == "" && ev.DecodeCall == "" && ev.TxMessage == "" && !ev.ClearCall && ev.TuneFreqHz == 0 {
 		return
 	}
 	select {
@@ -564,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
@@ -616,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,10 +51,54 @@ 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
+	// DeltaTime is how far into the slot the transmission started, in seconds —
+	// WSJT-X's "DT" column. Read and discarded before; kept now because it is
+	// shown, and because a Reply has to replay the decode field for field.
+	DeltaTime float64
+	// DecodeMsg is the decoded text as WSJT-X printed it ("CQ K1ABC FN42",
+	// "F4BPO K1ABC -07"). Kept whole rather than only its parsed pieces: the
+	// 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
+	// burst and a slow link shifts the lot into the next slot.
+	DecodeMsSinceMidnight uint32
+	DecodeIsNew           bool // sender's "is_new": first time this line was decoded
+	LowConfidence         bool // sender is unsure of the decode
+	OffAir                bool // decoded from a file, not off the air
+
+	// ---- Status extras ----
+
+	// TxMessage is what the operator is sending right now ("CQ F4BPO JN18"),
+	// with Transmitting saying whether the carrier is actually up. Both come
+	// from Status, so they arrive about once a second.
+	TxMessage    string
+	Transmitting bool
+	// TxEnabled is the sender's "Enable Tx" toggle. It is what the WATCHDOG
+	// 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
+	// a custom period.
+	TRPeriod int
 }
 
 // maxFwdHeader bounds how far into a packet the WSJT-X magic may sit behind a
@@ -166,40 +210,81 @@ func ParseWSJT(pkt []byte) (WSJTEvent, bool, error) {
 			return WSJTEvent{}, false, err
 		}
 		ev.DXCall = strings.ToUpper(strings.TrimSpace(dxCall))
-		// Skip report, tx_mode (QUtf8), tx_enabled (bool), transmitting,
+		// report, tx_mode → skipped.
-		// decoding, rx_df (qint32), tx_df (qint32), de_call (QUtf8),
-		// de_grid (QUtf8) → then dx_grid.
 		for _, name := range []string{"report", "tx_mode"} {
 			if _, err := readQString(r); err != nil {
 				return ev, true, fmt.Errorf("read %s: %w", name, err)
 			}
 		}
-		// 3 booleans (each 1 byte)
+		// tx_enabled, transmitting, decoding (1 byte each). The middle one is
-		for i := 0; i < 3; i++ {
+		// worth keeping: it says the carrier is up, which is what turns TxMessage
-			var b uint8
+		// from "what I would send" into "what is going out".
-			if err := binary.Read(r, binary.BigEndian, &b); err != nil {
+		var txEnabled, transmitting, decoding uint8
+		for _, p := range []*uint8{&txEnabled, &transmitting, &decoding} {
+			if err := binary.Read(r, binary.BigEndian, p); err != nil {
 				return ev, true, err
 			}
 		}
-		// 2 int32
+		ev.Transmitting = transmitting != 0
+		ev.TxEnabled = txEnabled != 0
+		// rx_df, tx_df
 		var i32 int32
 		for i := 0; i < 2; i++ {
 			if err := binary.Read(r, binary.BigEndian, &i32); err != nil {
 				return ev, true, err
 			}
 		}
-		// de_call, de_grid, dx_grid
+		deCall, err := readQString(r)
-		if _, err := readQString(r); err != nil {
+		if err != nil {
 			return ev, true, err
 		}
-		if _, err := readQString(r); err != nil {
+		ev.DECall = strings.ToUpper(strings.TrimSpace(deCall))
+		deGrid, err := readQString(r)
+		if err != nil {
 			return ev, true, err
 		}
+		ev.DEGrid = strings.ToUpper(strings.TrimSpace(deGrid))
 		dxGrid, err := readQString(r)
 		if err != nil {
 			return ev, true, err
 		}
 		ev.DXGrid = strings.ToUpper(strings.TrimSpace(dxGrid))
+
+		// Everything past here was APPENDED to the schema over successive
+		// releases, and JTDX and MSHV each stop at their own point. A short
+		// packet is therefore normal, not an error: read as far as the sender
+		// went and keep what we got. That is why the tail below swallows its
+		// errors instead of reporting them — the fields already parsed are good.
+		var b uint8
+		if binary.Read(r, binary.BigEndian, &b) != nil { // tx_watchdog
+			return ev, true, nil
+		}
+		if _, err := readQString(r); err != nil { // sub_mode
+			return ev, true, nil
+		}
+		if binary.Read(r, binary.BigEndian, &b) != nil { // fast_mode
+			return ev, true, nil
+		}
+		if binary.Read(r, binary.BigEndian, &b) != nil { // special_operation_mode
+			return ev, true, nil
+		}
+		var u32 uint32
+		if binary.Read(r, binary.BigEndian, &u32) != nil { // frequency_tolerance
+			return ev, true, nil
+		}
+		if binary.Read(r, binary.BigEndian, &u32) != nil { // tr_period (seconds)
+			return ev, true, nil
+		}
+		// 0xFFFFFFFF is WSJT-X's "not applicable" for the quint32 fields.
+		if u32 > 0 && u32 < 3600 {
+			ev.TRPeriod = int(u32)
+		}
+		if _, err := readQString(r); err != nil { // configuration_name
+			return ev, true, nil
+		}
+		if txMsg, err := readQString(r); err == nil {
+			ev.TxMessage = strings.TrimSpace(txMsg)
+		}
 		return ev, true, nil
 
 	case wsjtMsgDecode:
@@ -217,6 +302,7 @@ func ParseWSJT(pkt []byte) (WSJTEvent, bool, error) {
 		if err := binary.Read(r, binary.BigEndian, &b); err != nil { // is_new
 			return WSJTEvent{}, false, err
 		}
+		ev.DecodeIsNew = b != 0
 		var t32, df uint32
 		var snr int32
 		if err := binary.Read(r, binary.BigEndian, &t32); err != nil { // time
@@ -229,6 +315,7 @@ func ParseWSJT(pkt []byte) (WSJTEvent, bool, error) {
 		if err := binary.Read(r, binary.BigEndian, &dt); err != nil { // delta_time
 			return WSJTEvent{}, false, err
 		}
+		ev.DeltaTime = dt
 		if err := binary.Read(r, binary.BigEndian, &df); err != nil { // delta_frequency
 			return WSJTEvent{}, false, err
 		}
@@ -240,6 +327,11 @@ func ParseWSJT(pkt []byte) (WSJTEvent, bool, error) {
 		if err != nil {
 			return WSJTEvent{}, false, err
 		}
+		// low_confidence and off_air were appended later; absent on older senders.
+		var lowConf, offAir uint8
+		_ = binary.Read(r, binary.BigEndian, &lowConf)
+		_ = binary.Read(r, binary.BigEndian, &offAir)
+
 		call, isCQ, grid := wsjtSender(msg)
 		if call == "" {
 			return WSJTEvent{}, false, nil // free-text / telemetry / unparseable → ignore
@@ -251,6 +343,11 @@ func ParseWSJT(pkt []byte) (WSJTEvent, bool, error) {
 		ev.DeltaFreqHz = int64(df)
 		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
 		return ev, true, nil
 
 	case wsjtMsgLoggedADIF:
@@ -303,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, ""
@@ -370,3 +481,50 @@ func readQString(r *bytes.Reader) (string, error) {
 	}
 	return string(buf), nil
 }
+
+// decodeModeChar maps the single character WSJT-X puts in a Decode's mode field
+// to the mode it stands for.
+//
+// A Decode does NOT carry the mode's name. It carries the one-character marker
+// that appears in the decode line and in ALL.TXT — "~" for FT8, "+" for FT4 —
+// and that character was being passed straight through as if it were a mode.
+// Everything downstream then compared "~" against the modes in the log, matched
+// nothing, and called every station on an already-worked band a new MODE.
+//
+// The table covers what is common; anything missing falls back to the mode from
+// the sender's last Status, which carries the real name — so an unlisted or
+// future marker degrades to correct rather than to nonsense.
+var decodeModeChar = map[string]string{
+	"~": "FT8",
+	"+": "FT4",
+	"#": "JT65",
+	"@": "JT9",
+	"&": "MSK144",
+	":": "Q65",
+	"`": "FST4",
+}
+
+// DecodeModeName resolves a Decode's mode field to a real mode name. statusMode
+// is the mode from the same program's last Status, used when the field is a
+// marker we do not know, or empty.
+func DecodeModeName(raw, statusMode string) string {
+	raw = strings.TrimSpace(raw)
+	if m, ok := decodeModeChar[raw]; ok {
+		return m
+	}
+	// A mode name is at least two alphanumeric characters ("FT8", "JS8", "Q65").
+	// Anything shorter, or carrying punctuation, is a marker rather than a name.
+	if len(raw) >= 2 {
+		named := true
+		for _, r := range raw {
+			if !(r >= 'A' && r <= 'Z') && !(r >= 'a' && r <= 'z') && !(r >= '0' && r <= '9') {
+				named = false
+				break
+			}
+		}
+		if named {
+			return strings.ToUpper(raw)
+		}
+	}
+	return strings.ToUpper(strings.TrimSpace(statusMode))
+}

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

@@ -0,0 +1,138 @@
+package udp
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"net"
+	"strings"
+
+	"hamlog/internal/applog"
+)
+
+// WSJT-X Reply (message type 4) — "answer this station".
+//
+// It is the same thing as double-clicking the line in WSJT-X's own Band
+// Activity window: the application looks the decode up in its list, sets its
+// transmit frequency to the caller's, fills the DX call and starts the exchange.
+// Which is why OpsLog cannot do this by tuning the radio — on FT8 the whole band
+// sits inside one passband, so moving the dial changes nothing about who gets
+// answered. The decision belongs to the decoding application, and this is the
+// only way to hand it over.
+//
+// The payload REPLAYS the decode being answered, and WSJT-X matches it against
+// what it decoded. Every field has to come back exactly as it went out — which
+// is why the parser now keeps the time, the delta time, the audio offset and the
+// message text rather than only what the panadapter needed.
+//
+//	Reply    type 4
+//	  id                utf8    the target application's own id
+//	  time              quint32 ms since midnight, from the decode
+//	  snr               qint32
+//	  delta_time        double  seconds
+//	  delta_frequency   quint32 audio offset in the passband, Hz
+//	  mode              utf8
+//	  message           utf8
+//	  low_confidence    bool
+//	  modifiers         quint8  keyboard modifiers (0 = a plain click)
+const wsjtMsgReply = 4
+
+// Reply is one "call this station" request, rebuilt from a decode.
+type Reply struct {
+	ProgramID     string // which application to talk to ("WSJT-X", "MSHV", "WSJT-X - 2")
+	MsSinceMidnig uint32
+	SNR           int32
+	DeltaTime     float64
+	DeltaFreqHz   uint32
+	Mode          string
+	Message       string
+	LowConfidence bool
+}
+
+// writeQString writes a Qt QString/QUtf8: a big-endian int32 length then the
+// bytes. An EMPTY string is length 0, not the -1 that means null — WSJT-X reads
+// a null where it expects text as a malformed packet and drops the whole reply.
+func writeQString(b *bytes.Buffer, s string) {
+	_ = binary.Write(b, binary.BigEndian, int32(len(s)))
+	b.WriteString(s)
+}
+
+// EncodeReply builds the datagram.
+func EncodeReply(r Reply) []byte {
+	var b bytes.Buffer
+	_ = binary.Write(&b, binary.BigEndian, uint32(wsjtMagic))
+	_ = binary.Write(&b, binary.BigEndian, uint32(2)) // schema 2 — the one every current sender speaks
+	_ = binary.Write(&b, binary.BigEndian, uint32(wsjtMsgReply))
+	writeQString(&b, r.ProgramID)
+	_ = binary.Write(&b, binary.BigEndian, r.MsSinceMidnig)
+	_ = binary.Write(&b, binary.BigEndian, r.SNR)
+	_ = binary.Write(&b, binary.BigEndian, r.DeltaTime)
+	_ = binary.Write(&b, binary.BigEndian, r.DeltaFreqHz)
+	writeQString(&b, r.Mode)
+	writeQString(&b, r.Message)
+	var low uint8
+	if r.LowConfidence {
+		low = 1
+	}
+	_ = binary.Write(&b, binary.BigEndian, low)
+	_ = binary.Write(&b, binary.BigEndian, uint8(0)) // modifiers: a plain click
+	return b.Bytes()
+}
+
+// SendReply hands a Reply to the application that produced the decode.
+//
+// Routed by PROGRAM ID, not by listener: two receivers can share one multicast
+// group, and answering a station heard on the 6 m instance by talking to the
+// 20 m one would start a call on the wrong band. The id is what tells them
+// apart, and the address the reply goes to is the one that instance's packets
+// actually arrive from — a multicast listener must answer back to the sender,
+// not to the group.
+func (m *Manager) SendReply(r Reply) error {
+	if strings.TrimSpace(r.ProgramID) == "" {
+		return fmt.Errorf("no application id — cannot tell which receiver to answer 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(r.ProgramID)
+		if conn == nil || addr == nil {
+			continue
+		}
+		pkt := EncodeReply(r)
+		if _, err := conn.WriteToUDP(pkt, addr); err != nil {
+			return fmt.Errorf("send reply to %s at %s: %w", r.ProgramID, addr, err)
+		}
+		// 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)
+}
+
+// replyTarget returns this listener's socket and the address the given program
+// last sent from, or nils when it has never been heard here.
+func (s *Server) replyTarget(programID string) (*net.UDPConn, *net.UDPAddr) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if s.conn == nil || s.lastFrom == nil {
+		return nil, nil
+	}
+	addr, ok := s.lastFrom[programID]
+	if !ok {
+		return nil, nil
+	}
+	return s.conn, addr
+}

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.