chore: release v0.19.9

theme: self-heal the persisted theme after mount. The synchronous boot
read only looks at localStorage, which is empty when the WebView cleared
its storage or when syncPortablePrefs ran before the backend wired its
settings store (GetUIPref returned "" with no error) — so a restart could
silently land on the default light theme. ThemeProvider now re-reads the
portable pref from the DB once the backend is up (retrying briefly to ride
out a slow startup) and applies it, without clobbering a manual pick.

ClusterGrid: the Call cell now uses a danger pill for NEW DXCC, consistent
with the NEW BAND / NEW MODE pills, instead of a full-cell red fill. cellChip
inherits the column's font size (no fixed 9px / height) so a pill around a
callsign stays the same size as the plain callsigns beside it.

DvkPanel: the voice-keyer TX indicator (LED + label) is red while
transmitting, not orange.

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

app.go

@@ -435,8 +435,13 @@ type App struct {
 	// to run inline in the read loop, so a single slow step stopped draining the
 	// TCP socket and the whole feed fell behind the node (visible as the grid
 	// lagging telnet). The read loop now just enqueues here; one worker does the work.
-	clusterEventCh chan clusterEvent
-	clusterDropped int64 // spots/lines dropped when the queue was full (atomic)
+	// Unbounded FIFO: a burst grows the backlog instead of dropping spots.
+	clusterEvents *clusterQueue
+	// wcbm is an in-memory "CALL|BAND|MODE" worked-index so the alert engine never
+	// queries the DB per cluster spot (an FT8 firehose would swamp a remote MySQL).
+	// Loaded once, appended to on each log, rebuilt after bulk changes.
+	wcbm   map[string]struct{}
+	wcbmMu sync.RWMutex
 	pota           *pota.Cache
 	uls            *uls.Store // US callsign→county/grid (offline FCC ULS), lazily opened
 	awardRefs      *awardref.Repo
@@ -802,6 +807,7 @@ func (a *App) startup(ctx context.Context) {
 	applog.Printf("startup: logbook backend = %s", backend)
 	a.logDb = logbookConn
 	a.qso = qso.NewRepo(logbookConn)
+	go a.rebuildWorkedIndex() // in-memory worked-index for per-spot alert checks
 
 	// cty.dat for offline DXCC / country resolution. Cached on disk; first
 	// run downloads it from country-files.com in the background so startup
@@ -900,10 +906,11 @@ func (a *App) startup(ctx context.Context) {
 	// renders the row with all metadata already filled (no flicker of
 	// empty Country / Cont columns while the batch status fetch runs).
 	// Cluster events are processed OFF the socket-read goroutine (see clusterEvent /
-	// clusterEventWorker). Sized large so ordinary traffic and even an SH/DX/100
-	// burst never fill it; a full queue drops-and-counts rather than block the read
-	// loop, which was the actual cause of the feed falling behind telnet.
-	a.clusterEventCh = make(chan clusterEvent, 8192)
+	// clusterEventWorker). The queue is UNBOUNDED so no spot is ever dropped: an
+	// SH/DX or RBN burst grows the backlog and drains once enrichment catches up,
+	// while the read loop still never blocks (that was the cause of the feed falling
+	// behind telnet).
+	a.clusterEvents = newClusterQueue()
 	go a.clusterEventWorker()
 
 	a.cluster = cluster.NewManager(
@@ -1851,6 +1858,7 @@ func (a *App) AddQSO(q qso.QSO) (id int64, err error) {
 	}
 	if err == nil {
 		q.ID = id
+		a.noteWorked(q.Callsign, q.Band, q.Mode) // keep the alert worked-index fresh
 		// Announce the log so UI widgets can react (e.g. the Flex panel zeroing RIT).
 		wruntime.EventsEmit(a.ctx, "qso:logged", id)
 		a.saveQSORecording(&q)
@@ -3377,6 +3385,10 @@ func (a *App) invalidateAwardStats() {
 	a.awardSnap = nil
 	a.awardSnapRev = ""
 	a.awardSnapMu.Unlock()
+	// Bulk QSO changes (import, delete, bulk edit) also land here — refresh the
+	// worked-index so alert "needed" checks stay accurate. Async: never block the
+	// mutation, and it's a single lightweight query.
+	go a.rebuildWorkedIndex()
 }
 
 // RescanAwards forces the next award computation to re-pull the logbook from the
@@ -4470,13 +4482,23 @@ func (a *App) UpdateQSO(q qso.QSO) error {
 // bound", so two empty strings mean the whole log. `to` is inclusive: a bare date
 // is stretched to 23:59:59 of that day, otherwise picking today as the end would
 // silently drop today's QSOs.
-func (a *App) GetLogStats(fromISO, toISO, contestID string, year int) (qso.Stats, error) {
+func (a *App) GetLogStats(fromISO, toISO, contestID string, year int, operator string) (qso.Stats, error) {
 	if a.qso == nil {
 		return qso.Stats{}, fmt.Errorf("db not initialized")
 	}
 	from := parseStatsBound(fromISO, false)
 	to := parseStatsBound(toISO, true)
-	return a.qso.Stats(a.ctx, from, to, contestID, year)
+	return a.qso.Stats(a.ctx, from, to, contestID, year, operator)
+}
+
+// GetOperators lists the distinct operators present in the log (upper-cased),
+// for the Statistics operator picker. "—" stands for QSOs the station owner
+// logged himself (empty OPERATOR). Sorted, owner-bucket last.
+func (a *App) GetOperators() ([]string, error) {
+	if a.qso == nil {
+		return nil, fmt.Errorf("db not initialized")
+	}
+	return a.qso.Operators(a.ctx)
 }
 
 // GetContestRuns lists the (contest, year) pairs actually present in the log, so
@@ -5881,20 +5903,85 @@ type clusterEvent struct {
 	line *cluster.Line
 }
 
-// enqueueClusterEvent hands an event to the worker WITHOUT blocking. It runs on
-// the cluster session's socket-read goroutine: blocking here would stop draining
-// the TCP socket, the node's send buffer would fill, and the feed would fall
-// behind — the exact bug this indirection fixes. If the queue is full (processing
-// can't keep up), drop and count rather than stall the whole feed.
-func (a *App) enqueueClusterEvent(ev clusterEvent) {
-	select {
-	case a.clusterEventCh <- ev:
-	default:
-		n := atomic.AddInt64(&a.clusterDropped, 1)
-		if n == 1 || n%100 == 0 {
-			applog.Printf("cluster: processing backlog — dropped %d event(s); the feed is faster than enrichment/UI", n)
-		}
+// clusterQueue is an unbounded FIFO between the socket-read goroutines (producers,
+// which must never block or the TCP feed stalls) and the single clusterEventWorker
+// (consumer). Unlike a bounded channel it NEVER drops an event: a burst just grows
+// the backlog, which drains once enrichment catches up.
+type clusterQueue struct {
+	mu     sync.Mutex
+	cond   *sync.Cond
+	buf    []clusterEvent
+	head   int  // index of the next event to pop (waste reclaimed by compaction)
+	closed bool
+}
+
+func newClusterQueue() *clusterQueue {
+	q := &clusterQueue{}
+	q.cond = sync.NewCond(&q.mu)
+	return q
+}
+
+// push appends an event and wakes the worker. Amortised O(1); never blocks, never
+// drops.
+func (q *clusterQueue) push(ev clusterEvent) {
+	q.mu.Lock()
+	if q.closed {
+		q.mu.Unlock()
+		return
 	}
+	q.buf = append(q.buf, ev)
+	q.mu.Unlock()
+	q.cond.Signal()
+}
+
+// pop blocks until an event is available, returning ok=false only once the queue
+// is closed AND fully drained.
+func (q *clusterQueue) pop() (clusterEvent, bool) {
+	q.mu.Lock()
+	for q.head == len(q.buf) && !q.closed {
+		q.cond.Wait()
+	}
+	if q.head == len(q.buf) { // closed and drained
+		q.mu.Unlock()
+		return clusterEvent{}, false
+	}
+	ev := q.buf[q.head]
+	q.buf[q.head] = clusterEvent{} // release pointers held by the consumed slot
+	q.head++
+	switch {
+	case q.head == len(q.buf):
+		// Fully drained → reset to reuse the backing array from the front.
+		q.buf = q.buf[:0]
+		q.head = 0
+	case q.head > 1024 && q.head*2 >= len(q.buf):
+		// Head waste is large → compact so a long sustained burst doesn't grow
+		// the backing array without bound.
+		n := copy(q.buf, q.buf[q.head:])
+		for i := n; i < len(q.buf); i++ {
+			q.buf[i] = clusterEvent{}
+		}
+		q.buf = q.buf[:n]
+		q.head = 0
+	}
+	q.mu.Unlock()
+	return ev, true
+}
+
+// close wakes any waiting consumer so it can exit once the backlog is drained.
+func (q *clusterQueue) close() {
+	q.mu.Lock()
+	q.closed = true
+	q.mu.Unlock()
+	q.cond.Broadcast()
+}
+
+// enqueueClusterEvent hands an event to the worker WITHOUT blocking and WITHOUT
+// dropping. It runs on the cluster session's socket-read goroutine: blocking here
+// would stop draining the TCP socket, the node's send buffer would fill, and the
+// feed would fall behind — the exact bug this indirection fixes. The queue is
+// unbounded, so a burst grows the backlog rather than losing a spot.
+func (a *App) enqueueClusterEvent(ev clusterEvent) {
+	a.clusterEvents.push(ev)
 }
 
 // clusterEventWorker drains clusterEventCh and does everything that used to run
@@ -5902,7 +5989,11 @@ func (a *App) enqueueClusterEvent(ev clusterEvent) {
 // to the UI, run alert rules (which may query a remote MySQL) and mirror it to the
 // Flex panadapter — all serialised on this one goroutine, off the read path.
 func (a *App) clusterEventWorker() {
-	for ev := range a.clusterEventCh {
+	for {
+		ev, ok := a.clusterEvents.pop()
+		if !ok {
+			return
+		}
 		if ev.line != nil {
 			if a.ctx != nil {
 				wruntime.EventsEmit(a.ctx, "cluster:line", *ev.line)
@@ -5999,21 +6090,60 @@ func (a *App) evaluateAlerts(s cluster.Spot) {
 
 // isWorkedBandMode reports whether the exact callsign is already logged on the
 // given band+mode (used by rules with "skip worked before").
+// wcbmKey builds the worked-index key: "CALL|BAND|MODE", all upper-cased.
+func wcbmKey(call, band, mode string) string {
+	return strings.ToUpper(strings.TrimSpace(call)) + "|" +
+		strings.ToUpper(strings.TrimSpace(band)) + "|" +
+		strings.ToUpper(strings.TrimSpace(mode))
+}
+
+// rebuildWorkedIndex loads the whole "CALL|BAND|MODE" worked-index into memory in
+// one pass. Called at startup and after bulk changes (import, delete, bulk edit).
+func (a *App) rebuildWorkedIndex() {
+	if a.qso == nil {
+		return
+	}
+	m, err := a.qso.WorkedCallBandModeKeys(a.ctx)
+	if err != nil {
+		applog.Printf("worked-index: rebuild failed: %v", err)
+		return
+	}
+	a.wcbmMu.Lock()
+	a.wcbm = m
+	a.wcbmMu.Unlock()
+}
+
+// noteWorked adds a just-logged QSO to the in-memory worked-index, so an alert
+// rule sees it as worked immediately without a full rebuild.
+func (a *App) noteWorked(call, band, mode string) {
+	if strings.TrimSpace(call) == "" {
+		return
+	}
+	a.wcbmMu.Lock()
+	if a.wcbm == nil {
+		a.wcbm = map[string]struct{}{}
+	}
+	a.wcbm[wcbmKey(call, band, mode)] = struct{}{}
+	a.wcbmMu.Unlock()
+}
+
+// isWorkedBandMode reports whether this exact call+band+mode is in the log,
+// answered from the in-memory index (no DB round-trip per spot). If the index
+// hasn't loaded yet it lazily builds it once.
 func (a *App) isWorkedBandMode(call, band, mode string) bool {
 	if a.qso == nil || strings.TrimSpace(call) == "" {
 		return false
 	}
-	rows, err := a.qso.List(a.ctx, qso.ListFilter{Callsign: call, Band: band, Mode: mode, Limit: 5})
-	if err != nil {
-		return false
+	a.wcbmMu.RLock()
+	ready := a.wcbm != nil
+	a.wcbmMu.RUnlock()
+	if !ready {
+		a.rebuildWorkedIndex()
 	}
-	call = strings.ToUpper(strings.TrimSpace(call))
-	for _, q := range rows {
-		if strings.ToUpper(strings.TrimSpace(q.Callsign)) == call {
-			return true
-		}
-	}
-	return false
+	a.wcbmMu.RLock()
+	_, ok := a.wcbm[wcbmKey(call, band, mode)]
+	a.wcbmMu.RUnlock()
+	return ok
 }
 
 // sendAlertEmail notifies the operator by e-mail that a wanted station was
@@ -8632,6 +8762,19 @@ func (a *App) UpdateQSOsFromQRZ(ids []int64) (int, error) {
 		if r.QTH != "" {
 			q.QTH = r.QTH
 		}
+		if r.Address != "" {
+			q.Address = r.Address // full street address, not just the city (QTH)
+		}
+		if r.Email != "" {
+			q.Email = r.Email
+		}
+		if r.QSLVia != "" {
+			q.QSLVia = r.QSLVia
+		}
+		if r.Lat != 0 || r.Lon != 0 {
+			lat, lon := r.Lat, r.Lon
+			q.Lat, q.Lon = &lat, &lon
+		}
 		if err := a.qso.Update(a.ctx, q); err == nil {
 			changed++
 		}

frontend/src/App.tsx

@@ -1064,6 +1064,15 @@ export default function App() {
   // Keyed by `${call}|${band}|${mode}` so two spots of the same call on
   // different slots don't share the same colour.
   const [spotStatus, setSpotStatus] = useState<Record<string, { status: string; country?: string; continent?: string; worked_call?: boolean; new_county?: boolean; new_pota?: boolean }>>({});
+  // Live mirror of spotStatus so the incoming-spot buffer can tell which slots
+  // still need resolving without re-subscribing the cluster:spot listener.
+  const spotStatusRef = useRef(spotStatus);
+  useEffect(() => { spotStatusRef.current = spotStatus; }, [spotStatus]);
+  // Incoming spots are staged here for a few ms, their status resolved, then
+  // committed to `spots` together — so a row paints with its NEW BAND/MODE badge
+  // already on, instead of flashing plain text then flipping to the pill.
+  const pendingSpotsRef = useRef<ClusterSpot[]>([]);
+  const pendingSpotTimer = useRef<number | undefined>(undefined);
 
   // === Modals ===
   const [editingQSO, setEditingQSO] = useState<QSO | null>(null);
@@ -1740,13 +1749,76 @@ export default function App() {
       const activeIds = new Set((sts ?? []).map((s) => s.server_id));
       setSpots((arr) => arr.filter((sp) => activeIds.has(sp.source_id)));
     });
-    const unsubSpot = EventsOn('cluster:spot', (sp: ClusterSpot) => {
+    // Commit the staged spots: resolve the status for any slot we don't know yet
+    // FIRST, then insert the rows — so they appear with the right badge already
+    // painted instead of flashing plain text then flipping to a pill.
+    const flushPendingSpots = async () => {
+      pendingSpotTimer.current = undefined;
+      const batch = pendingSpotsRef.current;
+      pendingSpotsRef.current = [];
+      if (batch.length === 0) return;
+      // Resolve unknown statuses before the rows go in.
+      try {
+        const known = spotStatusRef.current;
+        const unknown: { call: string; band: string; mode: string; pota_ref: string }[] = [];
+        const seen = new Set<string>();
+        for (const s of batch) {
+          const k = spotStatusKey(s.dx_call, s.band ?? '', s.comment ?? '', s.freq_hz);
+          if (seen.has(k) || known[k]) continue;
+          seen.add(k);
+          unknown.push({
+            call: s.dx_call, band: s.band ?? '',
+            mode: inferSpotMode(s.comment ?? '', s.freq_hz),
+            pota_ref: (s as any).pota_ref ?? '',
+          });
+        }
+        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,
+                new_county: !!(r as any).new_county,
+                new_pota: !!(r as any).new_pota,
+              };
+            }
+            return next;
+          });
+        }
+      } catch {}
+      // Now insert the staged rows. Same de-dupe as before: a station re-spotted
+      // (RBN skimmers on a CQ, several nodes relaying) shows as ONE live row that
+      // the freshest spot REPLACES and floats to the top. Historical (SH/DX
+      // replay) rows are left alone.
       setSpots((arr) => {
-        const next = [sp, ...arr];
+        const key = (x: ClusterSpot) => `${(x.dx_call ?? '').toUpperCase()}|${(x.band ?? '').toLowerCase()}`;
+        const hist = (x: ClusterSpot) => !!(x as any).historical;
+        let next = arr;
+        for (const sp of batch) {
+          const k = key(sp);
+          const filtered = hist(sp) ? next : next.filter((x) => hist(x) || key(x) !== k);
+          next = [sp, ...filtered];
+        }
         return next.length > SPOTS_CAP ? next.slice(0, SPOTS_CAP) : next;
       });
+    };
+    const unsubSpot = EventsOn('cluster:spot', (sp: ClusterSpot) => {
+      // Stage the spot; a short timer resolves its status then commits it.
+      pendingSpotsRef.current.push(sp);
+      // 50 ms is enough to coalesce an RBN burst into one status lookup (the
+      // worked-index is in memory, so resolving is near-instant) while staying
+      // imperceptible.
+      if (pendingSpotTimer.current === undefined) {
+        pendingSpotTimer.current = window.setTimeout(flushPendingSpots, 50);
+      }
       // Self-spot: someone spotted OUR callsign — show it in the shared header
       // toast (same place as the other notifications), not a separate banner.
+      // Fired immediately (not staged) so the notification never lags the spot.
       const mine = myCallRef.current;
       if (mine && (sp.dx_call ?? '').toUpperCase() === mine) {
         const by = cleanSpotter(sp.spotter ?? '') || '?';
@@ -1754,7 +1826,10 @@ export default function App() {
         showToast(`Spotted by ${by}${c ? ` with ${c}` : ''}`);
       }
     });
-    return () => { unsubState?.(); unsubSpot?.(); };
+    return () => {
+      unsubState?.(); unsubSpot?.();
+      if (pendingSpotTimer.current !== undefined) window.clearTimeout(pendingSpotTimer.current);
+    };
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 

frontend/src/components/ClusterGrid.tsx

@@ -113,6 +113,26 @@ function tok(name: string, text: string): Badge {
   return { text, fg: `var(--${name}-muted-foreground)`, bg: `var(--${name}-muted)`, bd: `var(--${name}-border)` };
 }
 
+// cellChip wraps a Band/Mode cell value in a small rounded pill (same look as the
+// Status badges) when the slot is notable, instead of flooding the whole cell with
+// a heavy muted fill that turned into an ugly olive block on dark themes. `name` is
+// null → plain text, no pill.
+function cellChip(value: any, name: string | null): any {
+  const txt = value === undefined || value === null || value === '' ? '' : String(value);
+  if (!name) return txt || <span style={{ color: 'var(--muted-foreground)', fontSize: 10 }}>—</span>;
+  // Inherit the column's font size (no fixed 9px / height) so a pill around a
+  // callsign stays the same size as the plain callsigns next to it — just tinted
+  // and rounded, not shrunk.
+  return (
+    <span style={{
+      display: 'inline-flex', alignItems: 'center', lineHeight: 1.1,
+      backgroundColor: `var(--${name}-muted)`, color: `var(--${name}-muted-foreground)`,
+      border: `1px solid var(--${name}-border)`, fontWeight: 700,
+      padding: '1px 6px', borderRadius: 999, whiteSpace: 'nowrap',
+    }}>{txt}</span>
+  );
+}
+
 function statusBadge(t: TFn, s: SpotStatusEntry | undefined): Badge | null {
   switch (s?.status) {
     case 'new':      return tok('danger',  t('clg2.newDxcc'));
@@ -129,22 +149,22 @@ const makeColCatalog = (t: TFn): ColEntry[] => [
     headerName: t('clg2.c.time'), field: 'time_utc' as any, width: 80, cellClass: 'font-mono',
     defaultVisible: true,
     sort: 'desc',
-    cellStyle: { color: '#7a6b50' },
+    cellStyle: { color: 'var(--muted-foreground)' },
   },
   {
     group: 'Spot', label: t('clg2.c.call'),  colId: 'call',
     headerName: t('clg2.c.call'), field: 'dx_call' as any, width: 120,
     defaultVisible: true,
     cellClass: 'font-mono',
-    // Only STATUS calls get a colour: new DXCC entity → filled cell (no padded
-    // pill, so calls stay aligned), worked-call → blue. A plain spot inherits the
-    // theme's normal text colour (var(--foreground)) so callsigns blend in with
-    // the rest of the row across every theme instead of always shouting orange.
-    cellStyle: (p: any): any => {
+    // NEW DXCC → a danger pill around the call, consistent with the NEW BAND /
+    // NEW MODE pills (same look, same tokens). Worked-call stays blue bold text;
+    // a plain spot inherits the theme's normal text colour so callsigns blend in
+    // with the rest of the row instead of always shouting a colour.
+    cellRenderer: (p: any) => {
       const s = statusFor(p);
-      if (s?.status === 'new') return { backgroundColor: 'var(--danger-muted)', color: 'var(--danger-muted-foreground)', fontWeight: 700 };
-      if (s?.worked_call) return { color: 'var(--info)', fontWeight: 700 };
-      return { fontWeight: 700 };
+      if (s?.status === 'new') return cellChip(p.value, 'danger');
+      const color = s?.worked_call ? 'var(--info)' : undefined;
+      return <span style={{ color, fontWeight: 700 }}>{p.value ?? ''}</span>;
     },
     tooltipValueGetter: (p: any) => {
       const s = statusFor(p);
@@ -204,7 +224,7 @@ const makeColCatalog = (t: TFn): ColEntry[] => [
     group: 'Spot', label: t('clg2.c.pota'), colId: 'pota',
     headerName: t('clg2.c.pota'), field: 'pota_ref' as any, width: 92, cellClass: 'font-mono',
     defaultVisible: true,
-    cellStyle: { color: '#166534' },
+    cellStyle: { color: 'var(--success)' },
     tooltipValueGetter: (p: any) => (p.data?.pota_name ? t('clg2.tipPota', { name: p.data.pota_name }) : undefined),
   },
   {
@@ -219,10 +239,8 @@ const makeColCatalog = (t: TFn): ColEntry[] => [
     headerName: t('clg2.c.band'), field: 'band' as any, width: 75,
     defaultVisible: true,
     cellClass: 'font-mono',
-    // NEW BAND for this entity → fill the cell (keeps the band text aligned).
-    cellStyle: (p: any) => (statusFor(p)?.status === 'new-band'
-      ? { backgroundColor: '#fde68a', color: '#92400e', fontWeight: 700 }
-      : undefined),
+    // NEW BAND for this entity → small warning pill around the band text.
+    cellRenderer: (p: any) => cellChip(p.value, statusFor(p)?.status === 'new-band' ? 'warning' : null),
     tooltipValueGetter: (p: any) => (statusFor(p)?.status === 'new-band' ? t('clg2.tipNewBand') : undefined),
   },
   {
@@ -231,16 +249,11 @@ const makeColCatalog = (t: TFn): ColEntry[] => [
     defaultVisible: true,
     cellClass: 'font-mono',
     valueGetter: (p: any) => p.data ? inferSpotMode(p.data.comment ?? '', p.data.freq_hz) : '',
-    // Fill the mode cell: teal = NEW MODE (mode never worked on this entity),
-    // yellow = NEW SLOT (this band+mode combo new, but the mode was worked elsewhere).
-    cellStyle: (p: any) => {
-      const st = statusFor(p)?.status;
-      // Both NEW MODE and NEW SLOT highlight the mode cell (same yellow); the
-      // Status badge text tells them apart.
-      if (st === 'new-mode' || st === 'new-slot') return { backgroundColor: '#fef08a', color: '#854d0e', fontWeight: 700 };
-      return undefined;
-    },
-    cellRenderer: (p: any) => p.value ? p.value : <span style={{ color: '#a8a29e', fontSize: 10 }}>—</span>,
+    // Only NEW MODE pills the mode cell — there the mode itself is genuinely new
+    // for the entity. NEW SLOT means band AND mode were each worked before (just
+    // not together), so highlighting the mode cell would wrongly imply "CW is new";
+    // that case is signalled by the Status badge alone.
+    cellRenderer: (p: any) => cellChip(p.value, statusFor(p)?.status === 'new-mode' ? 'caution' : null),
     tooltipValueGetter: (p: any) => {
       const st = statusFor(p)?.status;
       if (st === 'new-mode') return t('clg2.tipNewMode');
@@ -252,7 +265,7 @@ const makeColCatalog = (t: TFn): ColEntry[] => [
     group: 'Spot', label: t('clg2.c.pfx'), colId: 'pfx',
     headerName: t('clg2.c.pfx'), width: 60, cellClass: 'font-mono',
     valueGetter: (p: any) => fmtPfx(p.data?.dx_call ?? ''),
-    cellStyle: { color: '#7a6b50' },
+    cellStyle: { color: 'var(--muted-foreground)' },
   },
   {
     group: 'Geo', label: t('clg2.c.cqz'), colId: 'cqz',
@@ -289,7 +302,7 @@ const makeColCatalog = (t: TFn): ColEntry[] => [
     valueGetter: (p: any) => p.data?.country ?? p.context?.spotStatus?.[
       spotStatusKey(p.data?.dx_call, p.data?.band ?? '', p.data?.comment ?? '', p.data?.freq_hz)
     ]?.country ?? '',
-    cellStyle: { color: '#7a6b50' },
+    cellStyle: { color: 'var(--muted-foreground)' },
   },
   {
     group: 'Spot', label: t('clg2.c.continent'), colId: 'continent',
@@ -298,31 +311,31 @@ const makeColCatalog = (t: TFn): ColEntry[] => [
     valueGetter: (p: any) => p.data?.continent ?? p.context?.spotStatus?.[
       spotStatusKey(p.data?.dx_call, p.data?.band ?? '', p.data?.comment ?? '', p.data?.freq_hz)
     ]?.continent ?? '',
-    cellStyle: { color: '#7a6b50', fontSize: 10 },
+    cellStyle: { color: 'var(--muted-foreground)', fontSize: 10 },
   },
   {
     group: 'Spot', label: t('clg2.c.spotter'), colId: 'spotter',
     headerName: t('clg2.c.spotter'), field: 'spotter' as any, width: 100, cellClass: 'font-mono',
     defaultVisible: true,
     valueFormatter: (p) => cleanSpotter(p.value ?? ''),
-    cellStyle: { color: '#7a6b50' },
+    cellStyle: { color: 'var(--muted-foreground)' },
   },
   {
     group: 'Spot', label: t('clg2.c.source'), colId: 'source',
     headerName: t('clg2.c.source'), field: 'source_name' as any, width: 100,
     defaultVisible: true,
-    cellStyle: { color: '#9a8870', fontSize: 10 },
+    cellStyle: { color: 'var(--muted-foreground)', fontSize: 10 },
   },
   {
     group: 'Spot', label: t('clg2.c.locator'), colId: 'locator',
     headerName: t('clg2.h.locator'), field: 'locator' as any, width: 80, cellClass: 'font-mono',
-    cellStyle: { color: '#7a6b50' },
+    cellStyle: { color: 'var(--muted-foreground)' },
   },
   {
     group: 'Spot', label: t('clg2.c.comment'), colId: 'comment',
     headerName: t('clg2.c.comment'), field: 'comment' as any, flex: 1, minWidth: 160,
     defaultVisible: true,
-    cellStyle: { color: '#7a6b50' },
+    cellStyle: { color: 'var(--muted-foreground)' },
   },
   {
     group: 'Spot', label: t('clg2.c.received_at'), colId: 'received_at',

frontend/src/components/DvkPanel.tsx

@@ -25,8 +25,8 @@ export function DvkPanel({ messages, status, onPlay, onStop, onClose }: Props) {
       <div className="flex items-center gap-2 px-3 py-1.5 border-b border-border bg-muted/40 shrink-0">
         <Mic className="size-3.5 text-primary" />
         <span className="text-[11px] font-semibold uppercase tracking-wider">{t('dvkp.voiceKeyer')}</span>
-        <span className={cn('size-2 rounded-full', status.playing ? 'bg-warning animate-pulse' : 'bg-success')} />
-        {status.playing && <span className="text-[10px] text-warning font-medium">tx...</span>}
+        <span className={cn('size-2 rounded-full', status.playing ? 'bg-danger animate-pulse' : 'bg-success')} />
+        {status.playing && <span className="text-[10px] text-danger font-medium">TX</span>}
         <div className="flex-1" />
         <Button variant="ghost" size="sm" className="h-6 px-2 text-[11px]" onClick={onStop} disabled={!status.playing}>
           <Square className="size-3" /> {t('dvkp.stop')}

frontend/src/components/FlexPanel.tsx

@@ -320,15 +320,18 @@ export function FlexPanel({ onCWSpeed, onReportRST }: { onCWSpeed?: (wpm: number
   const rxOff = off || !st.rx_avail;
 
   // Radio-style global RIT tuning: Ctrl+←/→ nudges the RIT offset (Ctrl+Shift =
-  // ±100 Hz) from anywhere, without having to click the RIT field first. A
-  // focused offset row (data-offsetrow) or a text field handles its own keys, so
-  // this never double-fires. Only active while RIT is on and the RX is available.
+  // ±100 Hz) from ANYWHERE — including while the callsign/RST entry field has
+  // focus, which is where the operator is while working a station. Only the RIT
+  // offset row itself (data-offsetrow) is skipped, since it handles its own
+  // arrows. Text-field word navigation via Ctrl+← / → is overridden only while
+  // RIT is actually engaged (guarded below), which is fine mid-QSO. Requires RIT
+  // on and the RX available.
   useEffect(() => {
     const onKey = (e: KeyboardEvent) => {
       if (!(e.ctrlKey || e.metaKey)) return;
       if (e.key !== 'ArrowLeft' && e.key !== 'ArrowRight') return;
       const ae = document.activeElement as HTMLElement | null;
-      if (ae && (ae.hasAttribute('data-offsetrow') || /^(input|textarea|select)$/i.test(ae.tagName) || ae.isContentEditable)) return;
+      if (ae && ae.hasAttribute('data-offsetrow')) return;
       if (!st.rit || rxOff) return;
       e.preventDefault();
       const mag = e.shiftKey ? 100 : 10;

frontend/src/components/SettingsModal.tsx

@@ -540,6 +540,7 @@ function AutostartPanelComponent() {
 // (a random install ID + version + OS, sent once a day). Real component so it
 // can own its state; embedded inside GeneralPanel.
 function TelemetryToggle() {
+  const { t } = useI18n();
   const [on, setOn] = useState(true);
   const [loaded, setLoaded] = useState(false);
   useEffect(() => {
@@ -549,8 +550,8 @@ function TelemetryToggle() {
     <label className="flex items-center gap-2 text-sm cursor-pointer">
       <Checkbox checked={on} disabled={!loaded}
         onCheckedChange={(c) => { const v = !!c; setOn(v); SetTelemetryEnabled(v).catch(() => {}); }} />
-      Send anonymous usage statistics
-      <span className="text-xs text-muted-foreground">(install ID + version + OS, once a day — no callsign or QSO data)</span>
+      {t('settings.telemetry')}
+      <span className="text-xs text-muted-foreground">({t('settings.telemetryHint')})</span>
     </label>
   );
 }
@@ -560,6 +561,7 @@ function TelemetryToggle() {
 // events — a small web script on your server renders it for the QRZ page. Only
 // useful on a MySQL logbook. Self-contained component (owns its async state).
 function LiveStatusToggle() {
+  const { t } = useI18n();
   const [on, setOn] = useState(false);
   const [loaded, setLoaded] = useState(false);
   useEffect(() => {
@@ -569,7 +571,7 @@ function LiveStatusToggle() {
     <label className="flex items-center gap-2 text-sm cursor-pointer">
       <Checkbox checked={on} disabled={!loaded}
         onCheckedChange={(c) => { const v = !!c; setOn(v); SetLiveStatusEnabled(v).catch(() => {}); }} />
-      Publish live operator status <span className="text-xs text-muted-foreground">(multi-op on shared MySQL — feeds a QRZ live page)</span>
+      {t('settings.liveStatus')} <span className="text-xs text-muted-foreground">({t('settings.liveStatusHint')})</span>
     </label>
   );
 }
@@ -578,25 +580,20 @@ function LiveStatusToggle() {
 // 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_OPTIONS: { value: string; label: string }[] = [
-  { value: 'map1', label: 'Map — great-circle + beam' },
-  { value: 'map2', label: 'Map — locator (street)' },
-  { value: 'cluster', label: 'Cluster spots' },
-  { value: 'worked', label: 'Worked before' },
-  { value: 'recent', label: 'Recent QSOs' },
-  { value: 'netcontrol', label: 'Net control' },
-];
+const MAIN_PANE_VALUES = ['map1', 'map2', 'cluster', 'worked', 'recent', 'netcontrol'];
 function MainViewPanes({ onChanged, flexAvailable, icomAvailable }: { onChanged?: (side: 'left' | 'right', value: string) => void; flexAvailable?: boolean; icomAvailable?: boolean }) {
+  const { t } = useI18n();
   const [left, setLeft] = useState('map1');
   const [right, setRight] = useState('map2');
   // Radio-control panes are only offered when that CAT backend is active. Sorted A→Z.
   const options = [
-    ...MAIN_PANE_OPTIONS,
-    ...(flexAvailable ? [{ value: 'flex', label: 'FlexRadio controls' }] : []),
-    ...(icomAvailable ? [{ value: 'icom', label: 'Icom console' }] : []),
-  ].sort((a, b) => a.label.localeCompare(b.label));
+    ...MAIN_PANE_VALUES,
+    ...(flexAvailable ? ['flex'] : []),
+    ...(icomAvailable ? ['icom'] : []),
+  ].map((value) => ({ value, label: t(`settings.pane.${value}`) }))
+    .sort((a, b) => a.label.localeCompare(b.label));
   useEffect(() => {
-    const valid = (v: string) => v === 'flex' || v === 'icom' || MAIN_PANE_OPTIONS.some((o) => o.value === v);
+    const valid = (v: string) => v === 'flex' || v === 'icom' || MAIN_PANE_VALUES.includes(v);
     Promise.all([GetUIPref('mainPaneLeft').catch(() => ''), GetUIPref('mainPaneRight').catch(() => '')])
       .then(([l, r]) => { if (valid(l)) setLeft(l); if (valid(r)) setRight(r); });
   }, []);
@@ -609,11 +606,11 @@ function MainViewPanes({ onChanged, flexAvailable, icomAvailable }: { onChanged?
   };
   return (
     <div className="border-t border-border/60 pt-4 space-y-2">
-      <h4 className="text-sm font-semibold text-foreground">Main view</h4>
-      <p className="text-xs text-muted-foreground">Choose what the Main tab shows on each side (per profile).</p>
+      <h4 className="text-sm font-semibold text-foreground">{t('settings.mainView')}</h4>
+      <p className="text-xs text-muted-foreground">{t('settings.mainViewHint')}</p>
       <div className="grid grid-cols-2 gap-3 max-w-xl">
         <label className="flex flex-col gap-1 text-xs">
-          <span className="text-muted-foreground">Left pane</span>
+          <span className="text-muted-foreground">{t('settings.leftPane')}</span>
           <Select value={left} onValueChange={(v) => pick('left', v)}>
             <SelectTrigger className="h-8 text-xs"><SelectValue /></SelectTrigger>
             <SelectContent>
@@ -622,7 +619,7 @@ function MainViewPanes({ onChanged, flexAvailable, icomAvailable }: { onChanged?
           </Select>
         </label>
         <label className="flex flex-col gap-1 text-xs">
-          <span className="text-muted-foreground">Right pane</span>
+          <span className="text-muted-foreground">{t('settings.rightPane')}</span>
           <Select value={right} onValueChange={(v) => pick('right', v)}>
             <SelectTrigger className="h-8 text-xs"><SelectValue /></SelectTrigger>
             <SelectContent>

frontend/src/components/StatsPanel.tsx

@@ -1,6 +1,6 @@
 import { useEffect, useMemo, useState } from 'react';
 import { BarChart3, Loader2, RefreshCw, Table2 } from 'lucide-react';
-import { GetLogStats, GetContestRuns } from '../../wailsjs/go/main/App';
+import { GetLogStats, GetContestRuns, GetOperators } from '../../wailsjs/go/main/App';
 import { useI18n } from '@/lib/i18n';
 import { cn } from '@/lib/utils';
 
@@ -115,7 +115,7 @@ function HBars({ data, max, empty, share, labelWidth = 'w-20' }: { data: Bucket[
 // Sorting bands by COUNT would destroy the band-plan reading; the order is the
 // information.
 
-function VBars({ data, empty, height = 150 }: { data: Bucket[]; empty: string; height?: number }) {
+function VBars({ data, empty, height = 150, showValues, colorful }: { data: Bucket[]; empty: string; height?: number; showValues?: boolean; colorful?: boolean }) {
   const peak = Math.max(1, ...data.map((d) => d.count));
   if (data.length === 0) return <p className="text-[11px] text-muted-foreground italic py-4 text-center">{empty}</p>;
   // Thin the x labels once the bars get narrow. A label under EVERY one of 48
@@ -129,12 +129,13 @@ function VBars({ data, empty, height = 150 }: { data: Bucket[]; empty: string; h
       {data.map((d, i) => (
         <div key={d.key} className="flex-1 min-w-0 flex flex-col items-center justify-end h-full group"
           title={`${d.key} — ${nf(d.count)}`}>
-          <span className="text-[9px] text-muted-foreground mb-0.5 opacity-0 group-hover:opacity-100 transition-opacity tabular-nums whitespace-nowrap">
+          <span className={cn('text-[9px] font-semibold mb-0.5 tabular-nums whitespace-nowrap',
+            showValues ? 'text-foreground' : 'text-muted-foreground opacity-0 group-hover:opacity-100 transition-opacity')}>
             {nf(d.count)}
           </span>
           <div
             className="w-full rounded-t-[4px] transition-[height] duration-300"
-            style={{ height: `${Math.max(2, (d.count / peak) * 100)}%`, background: 'var(--chart-1)' }}
+            style={{ height: `${Math.max(2, (d.count / peak) * 100)}%`, background: colorful ? `var(--chart-${(i % 8) + 1})` : 'var(--chart-1)' }}
           />
           <span className="mt-1 h-3 text-[9px] text-muted-foreground w-full text-center whitespace-nowrap overflow-visible">
             {i % every === 0 ? d.key : ''}
@@ -490,10 +491,14 @@ export function StatsPanel() {
   // that contest AND lets the window derive from its own span — no date typing.
   const [runs, setRuns] = useState<ContestRun[]>([]);
   const [contest, setContest] = useState('');
+  // Operator picker: '' = all operators, "—" = station owner (empty OPERATOR).
+  const [operators, setOperators] = useState<string[]>([]);
+  const [operator, setOperator] = useState('');
 
   useEffect(() => { GetContestRuns().then((r: any) => setRuns((r ?? []) as ContestRun[])).catch(() => {}); }, []);
+  useEffect(() => { GetOperators().then((o: any) => setOperators((o ?? []) as string[])).catch(() => {}); }, []);
 
-  const load = async (p: Period = period, f = from, t2 = to, c = contest) => {
+  const load = async (p: Period = period, f = from, t2 = to, c = contest, op = operator) => {
     // A contest defines its own window (its first→last QSO), so we send no dates
     // with it — the backend derives them. Sending a period as well would be two
     // filters fighting over the same axis.
@@ -501,7 +506,7 @@ export function StatsPanel() {
     const [a, b] = c ? ['', ''] : periodRange(p, f, t2);
     setBusy(true); setErr('');
     try {
-      const raw = (await GetLogStats(a, b, cid, parseInt(cyr, 10) || 0)) as any;
+      const raw = (await GetLogStats(a, b, cid, parseInt(cyr, 10) || 0, op)) as any;
       // Harden the boundary: a Go nil slice arrives as JSON null, and a single
       // .length on null unmounts the whole React tree — a white screen. Normalise
       // once, here, rather than guarding at every use site and missing one.
@@ -522,9 +527,9 @@ export function StatsPanel() {
   // are set — otherwise every keystroke in the date box would re-scan the log.
   useEffect(() => {
     if (!contest && period === 'custom' && !(from && to)) return;
-    load(period, from, to, contest);
+    load(period, from, to, contest, operator);
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [period, from, to, contest]);
+  }, [period, from, to, contest, operator]);
 
   // The rate / off-air block belongs to a CONTEST-shaped effort, and nowhere else.
   // Over a year it degenerates into nonsense — "4 156 h off air", a 94-hour "break"
@@ -569,6 +574,20 @@ export function StatsPanel() {
           ))}
         </select>
 
+        {/* Operator picker — narrows every stat (totals, DXCC, top countries,
+            continent split, rate) to one operator from the log. "—" = the
+            station owner (QSOs logged with no OPERATOR set). */}
+        {operators.length > 1 && (
+          <select value={operator} onChange={(e) => setOperator(e.target.value)}
+            className="h-7 rounded-md border border-input bg-background px-1.5 text-xs max-w-[180px]"
+            title={t('stats.operatorTip')}>
+            <option value="">{t('stats.allOperators')}</option>
+            {operators.map((op) => (
+              <option key={op} value={op}>{op === '—' ? t('stats.stationOwner') : op}</option>
+            ))}
+          </select>
+        )}
+
         <div className={cn('inline-flex rounded-md border border-border overflow-hidden', contest && 'opacity-40 pointer-events-none')}>
           {([
             ['all', t('stats.pAll')], ['ytd', t('stats.pYTD')],
@@ -705,7 +724,7 @@ export function StatsPanel() {
       ) : (
         <div className="grid grid-cols-1 lg:grid-cols-2 gap-2.5">
           <Card title={t('stats.byBand')} sub={t('stats.byBandSub')}>
-            <VBars data={stats.by_band} empty={empty} />
+            <VBars data={stats.by_band} empty={empty} showValues colorful />
           </Card>
           <Card title={t('stats.byMode')}>
             <HBars data={stats.by_mode} max={8} empty={empty} />
@@ -718,7 +737,7 @@ export function StatsPanel() {
           {/* EVERY operator, never a top-N: on a multi-op contest the point is who
               worked what, and a cap would quietly delete the 9th operator. Scrolls
               instead of truncating. */}
-          <Card title={t('stats.byOperator')} sub={t('stats.byOperatorSub')}>
+          <Card title={t('stats.byOperator')}>
             <div className="max-h-[240px] overflow-auto pr-1 min-w-0">
               <HBars data={stats.by_operator} empty={empty} share />
             </div>

frontend/src/lib/i18n.tsx

@@ -67,7 +67,7 @@ const en: Dict = {
   'stats.best60': 'Best 60 min', 'stats.best60Tip': 'Best ROLLING 60 minutes (not the best clock hour) — the figure contesters quote.',
   'stats.activeHours': 'Time on air', 'stats.onAirTip': 'Window minus every silence of 30 min or more. On-air + off-air = the window, by construction.',
   'stats.offAir': 'Off air', 'stats.offAirSub': 'Silences ≥ 30 min — {d} total',
-  'stats.noGaps': 'No break of 30 min or more.', 'stats.rateSheet': 'Rate sheet', 'stats.rateSheetSub': 'Hour by hour — who made the QSOs (silent hours omitted)', 'stats.noContest': '— No contest —',
+  'stats.noGaps': 'No break of 30 min or more.', 'stats.rateSheet': 'Rate sheet', 'stats.rateSheetSub': 'Hour by hour — who made the QSOs (silent hours omitted)', 'stats.noContest': '— No contest —', 'stats.allOperators': '— All operators —', 'stats.stationOwner': '— Station owner —', 'stats.operatorTip': 'Narrow every statistic to one operator from the log.',
   'cluster.console': 'Console', 'cluster.clear': 'Clear', 'cluster.hideConsole': 'Hide console', 'cluster.showConsole': 'Show the raw cluster console',
   'cluster.consoleEmpty': 'Raw cluster traffic appears here — including the answers to your commands (SH/DX, WHO, …).',
   'msg.expand': 'Click to read the full message',
@@ -80,6 +80,17 @@ const en: Dict = {
   'offline.synced': '{n} QSO(s) added to the logbook',
   'offline.stillDown': 'Database still unreachable — your QSOs are safe',
   'settings.theme': 'Theme', 'settings.themeHint': 'Interface colour theme.',
+  'settings.telemetry': 'Send anonymous usage statistics',
+  'settings.telemetryHint': 'install ID + version + OS, once a day — no callsign or QSO data',
+  'settings.liveStatus': 'Publish live operator status',
+  'settings.liveStatusHint': 'multi-op on shared MySQL — feeds a QRZ live page',
+  'settings.mainView': 'Main view',
+  'settings.mainViewHint': 'Choose what the Main tab shows on each side (per profile).',
+  'settings.leftPane': 'Left pane', 'settings.rightPane': 'Right pane',
+  'settings.pane.map1': 'Map — great-circle + beam', 'settings.pane.map2': 'Map — locator (street)',
+  'settings.pane.cluster': 'Cluster spots', 'settings.pane.worked': 'Worked before',
+  'settings.pane.recent': 'Recent QSOs', 'settings.pane.netcontrol': 'Net control',
+  'settings.pane.flex': 'FlexRadio controls', 'settings.pane.icom': 'Icom console',
   'theme.auto': 'Auto (system)', 'theme.light-warm': 'Warm light', 'theme.light-cool': 'Cool light',
   'theme.light-sage': 'Sage light', 'theme.dim-slate': 'Dim slate', 'theme.dark-warm': 'Warm dark',
   'theme.dark-graphite': 'Graphite dark', 'theme.high-contrast': 'High contrast',
@@ -346,7 +357,7 @@ const fr: Dict = {
   'stats.best60': 'Meilleure heure', 'stats.best60Tip': 'Meilleurs 60 min GLISSANTES (pas la meilleure heure ronde) — le chiffre que citent les contesteurs.',
   'stats.activeHours': 'Temps en l’air', 'stats.onAirTip': 'Fenêtre moins tous les silences de 30 min ou plus. Temps en l’air + hors antenne = la fenêtre, par construction.',
   'stats.offAir': 'Hors antenne', 'stats.offAirSub': 'Silences ≥ 30 min — {d} au total',
-  'stats.noGaps': 'Aucune pause de 30 min ou plus.', 'stats.rateSheet': 'Feuille de cadence', 'stats.rateSheetSub': 'Heure par heure — qui a fait les QSO (heures muettes omises)', 'stats.noContest': '— Aucun contest —',
+  'stats.noGaps': 'Aucune pause de 30 min ou plus.', 'stats.rateSheet': 'Feuille de cadence', 'stats.rateSheetSub': 'Heure par heure — qui a fait les QSO (heures muettes omises)', 'stats.noContest': '— Aucun contest —', 'stats.allOperators': '— Tous les opérateurs —', 'stats.stationOwner': '— Propriétaire station —', 'stats.operatorTip': "Restreindre toutes les statistiques à un opérateur du log.",
   'cluster.console': 'Console', 'cluster.clear': 'Effacer', 'cluster.hideConsole': 'Masquer la console', 'cluster.showConsole': 'Afficher la console brute du cluster',
   'cluster.consoleEmpty': 'Le trafic brut du cluster s’affiche ici — y compris les réponses à tes commandes (SH/DX, WHO, …).',
   'msg.expand': 'Cliquer pour lire le message en entier',
@@ -359,6 +370,17 @@ const fr: Dict = {
   'offline.synced': '{n} QSO ajoutés au journal',
   'offline.stillDown': 'Base toujours injoignable — tes QSO sont en sécurité',
   'settings.theme': 'Thème', 'settings.themeHint': "Thème de couleur de l'interface.",
+  'settings.telemetry': "Envoyer des statistiques d'usage anonymes",
+  'settings.telemetryHint': "ID d'installation + version + OS, une fois par jour — aucun indicatif ni donnée QSO",
+  'settings.liveStatus': 'Publier le statut opérateur en direct',
+  'settings.liveStatusHint': 'multi-op sur MySQL partagé — alimente une page live QRZ',
+  'settings.mainView': 'Vue principale',
+  'settings.mainViewHint': "Choisis ce que l'onglet Principal affiche de chaque côté (par profil).",
+  'settings.leftPane': 'Volet gauche', 'settings.rightPane': 'Volet droit',
+  'settings.pane.map1': 'Carte — orthodromie + faisceau', 'settings.pane.map2': 'Carte — locator (rue)',
+  'settings.pane.cluster': 'Spots cluster', 'settings.pane.worked': 'Déjà contactés',
+  'settings.pane.recent': 'QSO récents', 'settings.pane.netcontrol': 'Gestion de net',
+  'settings.pane.flex': 'Contrôles FlexRadio', 'settings.pane.icom': 'Console Icom',
   'theme.auto': 'Auto (système)', 'theme.light-warm': 'Clair chaud', 'theme.light-cool': 'Clair froid',
   'theme.light-sage': 'Clair sauge', 'theme.dim-slate': 'Ardoise tamisé', 'theme.dark-warm': 'Sombre chaud',
   'theme.dark-graphite': 'Sombre graphite', 'theme.high-contrast': 'Contraste élevé',

frontend/src/lib/theme.tsx

@@ -1,5 +1,6 @@
-import { createContext, useContext, useState, useEffect, useCallback, type ReactNode } from 'react';
+import { createContext, useContext, useState, useEffect, useCallback, useRef, type ReactNode } from 'react';
 import { writeUiPref } from './uiPref';
+import { GetUIPref } from '../../wailsjs/go/main/App';
 
 // Theme system. Each choice maps to a `data-theme` value on <html> that the
 // CSS variables in style.css key off of. 'auto' follows the OS light/dark
@@ -49,13 +50,44 @@ export function useTheme(): Ctx { return useContext(ThemeCtx); }
 
 export function ThemeProvider({ children }: { children: ReactNode }) {
   const [theme, setThemeState] = useState<ThemeChoice>(() => readStored());
+  // Set once the operator changes the theme by hand, so the self-heal below
+  // never clobbers a fresh choice with a value it read a moment earlier.
+  const userPicked = useRef(false);
 
   const setTheme = useCallback((t: ThemeChoice) => {
+    userPicked.current = true;
     setThemeState(t);
     applyThemeToDom(t);
     writeUiPref(LS_KEY, t);
   }, []);
 
+  // Self-heal the persisted theme. The synchronous boot read (localStorage) can
+  // miss it when the WebView cleared its storage, OR when syncPortablePrefs ran
+  // while the backend was still starting (settings store not wired yet → GetUIPref
+  // returned "" with no error, so nothing was restored) — the "restart lands on
+  // the light theme sometimes" bug. Re-read the portable pref from the DB once the
+  // backend is up and apply it, retrying briefly to ride out a slow startup.
+  useEffect(() => {
+    let cancelled = false;
+    let tries = 0;
+    const load = () => {
+      tries += 1;
+      GetUIPref(LS_KEY).then((raw) => {
+        if (cancelled || userPicked.current) return;
+        const v = raw as ThemeChoice;
+        if (v && ALL.includes(v)) {
+          try { localStorage.setItem(LS_KEY, v); } catch { /* quota */ }
+          applyThemeToDom(v); // idempotent — safe to call unconditionally
+          setThemeState(v);
+          return; // restored
+        }
+        if (tries < 8) window.setTimeout(load, 300); // empty (unset or backend not ready yet) → retry
+      }).catch(() => { if (!cancelled && tries < 8) window.setTimeout(load, 300); });
+    };
+    load();
+    return () => { cancelled = true; };
+  }, []);
+
   // While in 'auto', re-resolve when the OS light/dark preference flips.
   useEffect(() => {
     if (theme !== 'auto') return;

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

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

@@ -356,7 +356,7 @@ export function GetLoTWUsersStatus():Promise<main.LoTWUsersStatus>;
 
 export function GetLogFilePath():Promise<string>;
 
-export function GetLogStats(arg1:string,arg2:string,arg3:string,arg4:number):Promise<qso.Stats>;
+export function GetLogStats(arg1:string,arg2:string,arg3:string,arg4:number,arg5:string):Promise<qso.Stats>;
 
 export function GetLogbookRevision():Promise<string>;
 
@@ -368,6 +368,8 @@ export function GetOfflineStatus():Promise<main.OfflineStatus>;
 
 export function GetOnlineOperators():Promise<Array<main.ChatPresence>>;
 
+export function GetOperators():Promise<Array<string>>;
+
 export function GetPGXLSettings():Promise<main.PGXLSettings>;
 
 export function GetPGXLStatus():Promise<powergenius.Status>;

frontend/wailsjs/go/main/App.js

@@ -670,8 +670,8 @@ export function GetLogFilePath() {
   return window['go']['main']['App']['GetLogFilePath']();
 }
 
-export function GetLogStats(arg1, arg2, arg3, arg4) {
-  return window['go']['main']['App']['GetLogStats'](arg1, arg2, arg3, arg4);
+export function GetLogStats(arg1, arg2, arg3, arg4, arg5) {
+  return window['go']['main']['App']['GetLogStats'](arg1, arg2, arg3, arg4, arg5);
 }
 
 export function GetLogbookRevision() {
@@ -694,6 +694,10 @@ export function GetOnlineOperators() {
   return window['go']['main']['App']['GetOnlineOperators']();
 }
 
+export function GetOperators() {
+  return window['go']['main']['App']['GetOperators']();
+}
+
 export function GetPGXLSettings() {
   return window['go']['main']['App']['GetPGXLSettings']();
 }

internal/cluster/cluster.go

@@ -534,8 +534,14 @@ func (s *session) emitLine(text string, sent bool) {
 // ---------- parsing ----------
 
 // spotRE matches "DX de SPOTTER: FREQ DXCALL COMMENT TIME [LOC]".
+//
+// The spotter→freq separator is (?::\s*|\s+): a colon followed by ANY number of
+// spaces (including ZERO), or one-or-more spaces with no colon. Some RBN skimmer
+// nodes glue the frequency straight onto the colon — "DX de DL1HWS-3-#:14024.0 …"
+// — which the old ":?\s+" (colon then a REQUIRED space) rejected, dropping every
+// spot from those nodes.
 var spotRE = regexp.MustCompile(
-	`^\s*DX\s+de\s+([A-Z0-9/#\-]+):?\s+(\d+\.?\d*)\s+([A-Z0-9/]+)\s+(.*?)\s+(\d{4}Z?)(?:\s+([A-R]{2}\d{2}(?:[A-X]{2})?))?\s*$`,
+	`^\s*DX\s+de\s+([A-Z0-9/#\-]+)(?::\s*|\s+)(\d+\.?\d*)\s+([A-Z0-9/]+)\s+(.*?)\s+(\d{4}Z?)(?:\s+([A-R]{2}\d{2}(?:[A-X]{2})?))?\s*$`,
 )
 
 // Pacing for the per-server init commands.

internal/qso/qso.go

@@ -1809,6 +1809,28 @@ func (r *Repo) WorkedCountyKeys(ctx context.Context, keyFn func(state, cnty stri
 	return out, rows.Err()
 }
 
+// WorkedCallBandModeKeys returns the set of every worked "CALL|BAND|MODE" key
+// (all upper-cased), loaded in one pass. It backs the in-memory worked-index the
+// alert engine checks per cluster spot — a DB query per spot cannot keep up with
+// an FT8 skimmer firehose (and hammers a remote MySQL).
+func (r *Repo) WorkedCallBandModeKeys(ctx context.Context) (map[string]struct{}, error) {
+	rows, err := r.db.QueryContext(ctx,
+		`SELECT upper(callsign), upper(band), upper(mode) FROM qso WHERE callsign != ''`)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	out := make(map[string]struct{}, 4096)
+	for rows.Next() {
+		var c, b, m string
+		if err := rows.Scan(&c, &b, &m); err != nil {
+			return nil, err
+		}
+		out[c+"|"+b+"|"+m] = struct{}{}
+	}
+	return out, rows.Err()
+}
+
 // WorkedPOTARefs returns the set of POTA park references already worked
 // (upper-cased). A QSO's pota_ref may hold several comma-separated parks
 // (an n-fer); each is added separately.

internal/qso/stats.go

@@ -210,9 +210,49 @@ func yes(s string) bool {
 // it is set and no explicit window is given, the window becomes the contest's own
 // span — so rate, best-hour and off-air figures are computed over the contest
 // itself without the operator having to look its dates up.
-func (r *Repo) Stats(ctx context.Context, from, to time.Time, contestID string, year int) (Stats, error) {
+// Operators returns the distinct operators in the log (upper-cased), with "—"
+// for QSOs the station owner logged himself (empty OPERATOR). Sorted, with "—"
+// last so the picker reads real callsigns first.
+func (r *Repo) Operators(ctx context.Context) ([]string, error) {
+	rows, err := r.db.QueryContext(ctx, `SELECT DISTINCT COALESCE(operator,'') FROM qso`)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	seen := map[string]struct{}{}
+	for rows.Next() {
+		var op string
+		if err := rows.Scan(&op); err != nil {
+			return nil, err
+		}
+		op = strings.ToUpper(strings.TrimSpace(op))
+		if op == "" {
+			op = "—"
+		}
+		seen[op] = struct{}{}
+	}
+	out := make([]string, 0, len(seen))
+	hasOwner := false
+	for op := range seen {
+		if op == "—" {
+			hasOwner = true
+			continue
+		}
+		out = append(out, op)
+	}
+	sort.Strings(out)
+	if hasOwner {
+		out = append(out, "—")
+	}
+	return out, rows.Err()
+}
+
+func (r *Repo) Stats(ctx context.Context, from, to time.Time, contestID string, year int, operator string) (Stats, error) {
 	var s Stats
 	contestID = strings.ToUpper(strings.TrimSpace(contestID))
+	// Operator filter: "" = all operators; "—" = QSOs the station owner logged
+	// himself (empty OPERATOR); any other value = that operator's QSOs only.
+	opFilter := strings.ToUpper(strings.TrimSpace(operator))
 
 	rows, err := r.db.QueryContext(ctx, `
 		SELECT callsign, qso_date, band, mode, cont, country, dxcc,
@@ -257,6 +297,17 @@ func (r *Repo) Stats(ctx context.Context, from, to time.Time, contestID string,
 			continue
 		}
 
+		// An empty OPERATOR means "the station owner logged it himself" — bucket
+		// it as "—". Computed here so the operator filter can also drop QSOs that
+		// aren't this operator's before they reach ANY bucket.
+		op := strings.ToUpper(strings.TrimSpace(oper.String))
+		if op == "" {
+			op = "—"
+		}
+		if opFilter != "" && op != opFilter {
+			continue
+		}
+
 		// Window first: a QSO outside the period must not reach ANY bucket. Doing
 		// this after the counting (the obvious mistake) would leave the mode/band/
 		// operator charts showing the whole log while only the trend was filtered.
@@ -288,12 +339,7 @@ func (r *Repo) Stats(ctx context.Context, from, to time.Time, contestID string,
 		if b := strings.ToLower(strings.TrimSpace(band.String)); b != "" {
 			bandC[b]++
 		}
-		// An empty OPERATOR means "the station owner logged it himself" — bucket
-		// it explicitly rather than dropping the QSO from the operator chart.
-		op := strings.ToUpper(strings.TrimSpace(oper.String))
-		if op == "" {
-			op = "—"
-		}
+		// op was resolved above (with the operator filter applied).
 		opC[op]++
 		if st := strings.ToUpper(strings.TrimSpace(station.String)); st != "" {
 			stationC[st]++

telemetry.go

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