chore: release v0.11.2

app.go

@@ -379,6 +379,10 @@ type App struct {
 	dbBackend           string      // "sqlite" | "mysql" — the logbook backend actually opened at startup
 	dbBackendErr        string      // non-empty when a configured MySQL backend failed and we fell back to SQLite
 	catFlexSpots        bool        // push cluster spots to the FlexRadio panadapter
+	liveActMu           sync.Mutex  // guards the entry-strip activity reported for live status
+	liveFreqHz          int64       // last freq/band/mode the UI reported (fallback when CAT is off)
+	liveBand            string
+	liveMode            string
 	awardSnapMu         sync.Mutex  // guards the award QSO snapshot
 	awardSnap           []qso.QSO   // light-scanned + enriched logbook snapshot reused across award computations
 	awardSnapRev        string      // logbook revision the snapshot was built at ("" = none)
@@ -769,6 +773,7 @@ func (a *App) startup(ctx context.Context) {
 	// Anonymous usage heartbeat (once/day) so we can gauge active users. No-op
 	// when disabled in Preferences or until the PostHog key is configured.
 	go a.sendTelemetryHeartbeat()
+	go a.liveStatusLoop() // multi-op: heartbeat current activity to shared MySQL
 
 	fmt.Println("OpsLog: db ready at", a.dbPath)
 }
@@ -2452,6 +2457,16 @@ func (a *App) invalidateAwardStats() {
 	a.awardSnapMu.Unlock()
 }
 
+// RescanAwards forces the next award computation to re-pull the logbook from the
+// database, bypassing the in-memory snapshot. Bound to the Awards panel's
+// "Rescan" button so the operator can refresh after an external change the
+// revision check can't see (e.g. a LoTW/QRZ confirmation download that only
+// flips qsl_rcvd flags on existing rows).
+func (a *App) RescanAwards() error {
+	a.invalidateAwardStats()
+	return nil
+}
+
 // awardRefMetas loads the reference lists of PREDEFINED awards (Dynamic=false)
 // into the engine view. Dynamic awards (POTA/SOTA/…) are skipped — their lists
 // are large and not needed for matching; their names are filled afterwards.
@@ -5416,6 +5431,13 @@ func (a *App) runDownloadConfirmations(svc extsvc.Service, cfg extsvc.ExternalSe
 	default:
 		emit(fmt.Sprintf("Confirmation download isn't available for %s yet.", svc))
 	}
+	// Confirmations flip lotw_rcvd/qsl_rcvd on EXISTING rows, which doesn't move
+	// the logbook revision (count:maxID) — so the cached award snapshot would
+	// stay stale. Drop it whenever anything was matched or added so the next
+	// Awards view reflects the new confirmations.
+	if matched > 0 || added > 0 {
+		a.invalidateAwardStats()
+	}
 	done(matched+added, total)
 }
 
@@ -6298,6 +6320,196 @@ func (a *App) SetCATMode(mode string) error {
 	return err
 }
 
+// ── FlexRadio control tab (Phase 1: SmartSDR-style transmit controls) ──
+// These are no-ops / errors unless the active CAT backend is a FlexRadio.
+
+// GetFlexState returns the radio's transmit/ATU state for the FlexRadio tab.
+// Available=false when the active backend isn't a connected Flex.
+func (a *App) GetFlexState() cat.FlexTXState {
+	if a.cat == nil {
+		return cat.FlexTXState{}
+	}
+	st, _ := a.cat.FlexState()
+	return st
+}
+
+func (a *App) FlexSetPower(p int) error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	return a.cat.FlexDo(func(fc cat.FlexController) error { return fc.SetRFPower(p) })
+}
+
+func (a *App) FlexSetTunePower(p int) error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	return a.cat.FlexDo(func(fc cat.FlexController) error { return fc.SetTunePower(p) })
+}
+
+func (a *App) FlexTune(on bool) error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	return a.cat.FlexDo(func(fc cat.FlexController) error { return fc.SetTune(on) })
+}
+
+func (a *App) FlexSetVox(on bool) error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	return a.cat.FlexDo(func(fc cat.FlexController) error { return fc.SetVOX(on) })
+}
+
+func (a *App) FlexSetVoxLevel(l int) error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	return a.cat.FlexDo(func(fc cat.FlexController) error { return fc.SetVOXLevel(l) })
+}
+
+func (a *App) FlexSetVoxDelay(ms int) error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	return a.cat.FlexDo(func(fc cat.FlexController) error { return fc.SetVOXDelay(ms) })
+}
+
+func (a *App) FlexAmpOperate(on bool) error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	return a.cat.FlexDo(func(fc cat.FlexController) error { return fc.SetAmpOperate(on) })
+}
+
+func (a *App) FlexSetProcessor(on bool) error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	return a.cat.FlexDo(func(fc cat.FlexController) error { return fc.SetProcessor(on) })
+}
+
+func (a *App) FlexSetProcessorLevel(l int) error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	return a.cat.FlexDo(func(fc cat.FlexController) error { return fc.SetProcessorLevel(l) })
+}
+
+func (a *App) FlexSetMon(on bool) error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	return a.cat.FlexDo(func(fc cat.FlexController) error { return fc.SetMon(on) })
+}
+
+func (a *App) FlexSetMonLevel(l int) error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	return a.cat.FlexDo(func(fc cat.FlexController) error { return fc.SetMonLevel(l) })
+}
+
+func (a *App) FlexSetMic(l int) error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	return a.cat.FlexDo(func(fc cat.FlexController) error { return fc.SetMic(l) })
+}
+
+func (a *App) FlexMox(on bool) error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	return a.cat.SetPTT(on) // MOX = manual transmit (xmit 1/0)
+}
+
+func (a *App) FlexATUStart() error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	return a.cat.FlexDo(func(fc cat.FlexController) error { return fc.ATUStart() })
+}
+
+func (a *App) FlexATUBypass() error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	return a.cat.FlexDo(func(fc cat.FlexController) error { return fc.ATUBypass() })
+}
+
+func (a *App) FlexSetATUMemories(on bool) error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	return a.cat.FlexDo(func(fc cat.FlexController) error { return fc.SetATUMemories(on) })
+}
+
+// RX slice DSP controls (target the active receive slice).
+
+func (a *App) FlexSetAGCMode(m string) error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	return a.cat.FlexDo(func(fc cat.FlexController) error { return fc.SetAGCMode(m) })
+}
+
+func (a *App) FlexSetAGCThreshold(l int) error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	return a.cat.FlexDo(func(fc cat.FlexController) error { return fc.SetAGCThreshold(l) })
+}
+
+func (a *App) FlexSetAudioLevel(l int) error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	return a.cat.FlexDo(func(fc cat.FlexController) error { return fc.SetAudioLevel(l) })
+}
+
+func (a *App) FlexSetNB(on bool) error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	return a.cat.FlexDo(func(fc cat.FlexController) error { return fc.SetNB(on) })
+}
+
+func (a *App) FlexSetNBLevel(l int) error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	return a.cat.FlexDo(func(fc cat.FlexController) error { return fc.SetNBLevel(l) })
+}
+
+func (a *App) FlexSetNR(on bool) error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	return a.cat.FlexDo(func(fc cat.FlexController) error { return fc.SetNR(on) })
+}
+
+func (a *App) FlexSetNRLevel(l int) error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	return a.cat.FlexDo(func(fc cat.FlexController) error { return fc.SetNRLevel(l) })
+}
+
+func (a *App) FlexSetANF(on bool) error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	return a.cat.FlexDo(func(fc cat.FlexController) error { return fc.SetANF(on) })
+}
+
+func (a *App) FlexSetANFLevel(l int) error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	return a.cat.FlexDo(func(fc cat.FlexController) error { return fc.SetANFLevel(l) })
+}
+
 // SwitchCATRig hot-swaps the active OmniRig slot (Rig1 ↔ Rig2) without
 // requiring a trip through the full Settings panel. Persists the choice
 // so it survives restart.

docs/livestatus/tm74-status.php

@@ -0,0 +1,105 @@
+<?php
+/**
+ * OpsLog multi-operator LIVE STATUS renderer.
+ *
+ * Reads the shared `live_status` table that every OpsLog instance heartbeats
+ * (operator call + station call + freq/band/mode, refreshed every ~15s) and
+ * shows the operators active in the last 2 minutes.
+ *
+ * Put this file on YOUR web server (the one reachable from the internet), point
+ * it at the SAME MySQL database OpsLog uses for the shared logbook, and embed it
+ * on the QRZ.com bio of the station call:
+ *
+ *     <img src="https://your-server/tm74-status.php?img=1">     (image, cached ~min by QRZ)
+ *  or <a href="https://your-server/tm74-status.php">Live operators</a>   (real-time page)
+ *
+ * QRZ strips <script>/<iframe>, so only an <img> auto-updates the page.
+ */
+
+$DB_HOST = '10.10.10.15';      // your MySQL host (same as OpsLog's logbook)
+$DB_NAME = 'opslog';           // database name
+$DB_USER = 'opslog';
+$DB_PASS = 'CHANGE_ME';
+$STALE_SECONDS = 120;          // an operator is "active" if seen within this window
+
+// PHP 8.1+ makes mysqli THROW on errors by default; turn that off so a missing
+// `live_status` table (not yet created by OpsLog) just yields an empty list
+// instead of a fatal "table doesn't exist".
+mysqli_report(MYSQLI_REPORT_OFF);
+
+$mysqli = @new mysqli($DB_HOST, $DB_USER, $DB_PASS, $DB_NAME);
+if ($mysqli->connect_errno) {
+    http_response_code(500);
+    exit('DB error');
+}
+
+// The table is created by OpsLog on first publish; tolerate it not existing yet.
+$rows = [];
+$sql = "SELECT operator, station, freq_hz, band, mode, updated_at
+        FROM live_status
+        WHERE updated_at >= UTC_TIMESTAMP() - INTERVAL ? SECOND
+        ORDER BY band, freq_hz";
+if ($stmt = @$mysqli->prepare($sql)) {
+    $stmt->bind_param('i', $STALE_SECONDS);
+    @$stmt->execute();
+    if ($res = $stmt->get_result()) {
+        while ($r = $res->fetch_assoc()) $rows[] = $r;
+    }
+}
+
+$station = $rows ? $rows[0]['station'] : 'OpsLog';
+$fmtFreq = function ($hz) { return $hz > 0 ? number_format($hz / 1e6, 3) . ' MHz' : '—'; };
+
+// ── Image output (SVG) for the QRZ <img> embed: ?img=1 ──────────────────────
+if (isset($_GET['img'])) {
+    header('Content-Type: image/svg+xml');
+    header('Cache-Control: no-cache, max-age=30');
+    $rowH = 26; $h = 44 + max(1, count($rows)) * $rowH; $w = 440;
+    echo "<svg xmlns='http://www.w3.org/2000/svg' width='$w' height='$h' font-family='Segoe UI,Arial'>";
+    echo "<rect width='$w' height='$h' rx='8' fill='#0f172a'/>";
+    echo "<text x='14' y='26' fill='#38bdf8' font-size='15' font-weight='bold'>" . htmlspecialchars($station) . " — live operators</text>";
+    $y = 44 + 18;
+    if (!$rows) {
+        echo "<text x='14' y='$y' fill='#94a3b8' font-size='13'>No operator active right now.</text>";
+    }
+    foreach ($rows as $r) {
+        $line = sprintf('%-10s  %-4s  %-9s  %s', $r['operator'], $r['band'], $r['mode'], $fmtFreq($r['freq_hz']));
+        echo "<text x='14' y='$y' fill='#e2e8f0' font-size='13' font-family='monospace'>" . htmlspecialchars($line) . "</text>";
+        $y += $rowH;
+    }
+    echo "</svg>";
+    exit;
+}
+
+// ── HTML page (real-time when opened directly; auto-refreshes every 20s) ─────
+header('Content-Type: text/html; charset=utf-8');
+?><!doctype html>
+<html lang="en"><head><meta charset="utf-8">
+<meta http-equiv="refresh" content="20">
+<title><?= htmlspecialchars($station) ?> — live operators</title>
+<style>
+  body { font-family: Segoe UI, Arial, sans-serif; background:#0f172a; color:#e2e8f0; margin:0; padding:16px; }
+  h1 { color:#38bdf8; font-size:18px; margin:0 0 12px; }
+  table { border-collapse:collapse; width:100%; max-width:560px; }
+  th,td { text-align:left; padding:6px 12px; border-bottom:1px solid #1e293b; font-size:14px; }
+  th { color:#94a3b8; text-transform:uppercase; font-size:11px; letter-spacing:.05em; }
+  td.mono { font-family:monospace; }
+  .none { color:#94a3b8; }
+</style></head><body>
+<h1><?= htmlspecialchars($station) ?> — operators active now</h1>
+<?php if (!$rows): ?>
+  <p class="none">No operator active right now.</p>
+<?php else: ?>
+  <table>
+    <tr><th>Operator</th><th>Band</th><th>Mode</th><th>Frequency</th></tr>
+    <?php foreach ($rows as $r): ?>
+      <tr>
+        <td><strong><?= htmlspecialchars($r['operator']) ?></strong></td>
+        <td><?= htmlspecialchars($r['band']) ?></td>
+        <td><?= htmlspecialchars($r['mode']) ?></td>
+        <td class="mono"><?= $fmtFreq($r['freq_hz']) ?></td>
+      </tr>
+    <?php endforeach; ?>
+  </table>
+<?php endif; ?>
+</body></html>

frontend/src/App.tsx

@@ -31,6 +31,8 @@ import {
   GetDVKMessages, GetDVKStatus, DVKPlay, DVKStop,
   QSOAudioBegin, QSOAudioCancel, QSOAudioRestart,
   GetAwardDefs,
+  GetUIPref,
+  ReportLiveActivity,
 } from '../wailsjs/go/main/App';
 import { Combobox } from '@/components/ui/combobox';
 import { applyAwardRefs } from '@/lib/awardRefs';
@@ -49,7 +51,8 @@ import { SettingsModal } from '@/components/SettingsModal';
 import { FirstRunModal } from '@/components/FirstRunModal';
 import { QSOEditModal } from '@/components/QSOEditModal';
 import { BandMap } from '@/components/BandMap';
-import { MainMap } from '@/components/MainMap';
+import { WorldMap, LocatorMap } from '@/components/MainMap';
+import { FlexPanel } from '@/components/FlexPanel';
 import { FilterBuilder, type QueryFilter } from '@/components/FilterBuilder';
 import { AwardsPanel } from '@/components/AwardsPanel';
 import { RecentQSOsGrid } from '@/components/RecentQSOsGrid';
@@ -659,6 +662,36 @@ export default function App() {
       return next;
     });
   }, []);
+  // Main tab is two configurable panes; each side shows one of the great-circle
+  // 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';
+  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';
+    const [l, r] = await Promise.all([
+      GetUIPref('mainPaneLeft').catch(() => ''),
+      GetUIPref('mainPaneRight').catch(() => ''),
+    ]);
+    setMainPaneLeft(valid(l) ? l : 'map1');
+    setMainPaneRight(valid(r) ? r : 'map2');
+  }, []);
+  useEffect(() => { loadMainPanes(); }, [loadMainPanes]);
+  // Report the current entry-strip band/mode/freq to the backend so the live
+  // operator status (multi-op) has band/mode/freq even when the CAT is off.
+  useEffect(() => {
+    const hz = freqMhz ? Math.round(parseFloat(freqMhz) * 1_000_000) : 0;
+    ReportLiveActivity(hz || 0, band || '', mode || '').catch(() => {});
+  }, [band, mode, freqMhz]);
+  // Cluster filter sidebar visibility — shared by the Cluster tab and the
+  // Main-view cluster pane (portable UI pref). Hiding it keeps the filters
+  // active, it just reclaims the width.
+  const [clusterShowFilters, setClusterShowFilters] = useState(() => localStorage.getItem('opslog.clusterShowFilters') !== '0');
+  const toggleClusterFilters = useCallback(() => {
+    setClusterShowFilters((v) => { const n = !v; writeUiPref('opslog.clusterShowFilters', n ? '1' : '0'); return n; });
+  }, []);
   type SortKey = 'time' | 'call' | 'freq' | 'band' | 'mode' | 'spotter' | 'source';
   const [clusterSort, setClusterSort] = useState<{ key: SortKey; dir: 'asc' | 'desc' }>({ key: 'time', dir: 'desc' });
   // Cached per-call slot status: "new" | "new-band" | "new-slot" | "worked".
@@ -784,6 +817,17 @@ export default function App() {
     return [base];
   }, [rotatorHeading.enabled, rotatorHeading.ok, rotatorHeading.azimuth, ubStatus.enabled, ubStatus.connected, ubStatus.direction]);
 
+  // Mechanical boom (rotor) heading + Ultrabeam pattern — so the compass/map can
+  // show where the antenna physically points (boom) vs where it radiates when
+  // the Ultrabeam is reversed/bidirectional.
+  const boomHeading = useMemo<number | null>(() => (
+    rotatorHeading.enabled && rotatorHeading.ok ? ((rotatorHeading.azimuth % 360) + 360) % 360 : null
+  ), [rotatorHeading.enabled, rotatorHeading.ok, rotatorHeading.azimuth]);
+  const ubPattern = useMemo<'normal' | 'reverse' | 'bi' | null>(() => {
+    if (!(ubStatus.enabled && ubStatus.connected)) return null;
+    return ubStatus.direction === 1 ? 'reverse' : ubStatus.direction === 2 ? 'bi' : 'normal';
+  }, [ubStatus.enabled, ubStatus.connected, ubStatus.direction]);
+
   // Portable UI toggles (mirrored to the DB via writeUiPref / syncPortablePrefs).
   const [showRotor, setShowRotor] = useState(() => localStorage.getItem('opslog.showRotor') !== '0');
   const [showBeamOnMap, setShowBeamOnMap] = useState(() => localStorage.getItem('opslog.showBeamOnMap') !== '0');
@@ -1275,10 +1319,10 @@ export default function App() {
   // side reloads its managers; this keeps the React state in sync.
   useEffect(() => {
     const off = EventsOn('profile:changed', () => {
-      loadStation(); loadLists(); loadCATCfg(); reloadWk();
+      loadStation(); loadLists(); loadCATCfg(); reloadWk(); loadMainPanes();
     });
     return () => { off(); };
-  }, [loadStation, loadLists, loadCATCfg, reloadWk]);
+  }, [loadStation, loadLists, loadCATCfg, reloadWk, loadMainPanes]);
   useEffect(() => {
     (async () => {
       await reloadWk();
@@ -2026,6 +2070,14 @@ export default function App() {
       <Combobox value={rstRcvd} options={rstOptions(mode, rstLists)} allowFreeText commitOnType onChange={(v) => { setRstRcvd(v); rstUserEditedRef.current = true; }} />
     </div>
   );
+  // DX country flag, shown large next to RST (moved here from the Country field).
+  const flagBlock = flagURL(details.dxcc) ? (
+    <div className="flex flex-col justify-end shrink-0">
+      <img src={flagURL(details.dxcc)} alt={country} title={country}
+        className="h-9 rounded-[3px] border border-border/60 shadow-sm"
+        referrerPolicy="no-referrer" onError={(e) => { (e.currentTarget as HTMLImageElement).style.display = 'none'; }} />
+    </div>
+  ) : null;
   // Deferred-entry date: only shown when the start time is locked (back-entering
   // a past QSO). Sets the DATE part of qsoStartedAt; the time field keeps the time.
   const dateBlock = locks.start ? (
@@ -2148,13 +2200,7 @@ export default function App() {
   );
   const countryRow = (
     <div className="flex items-center gap-2">
-      <Label className="w-20 shrink-0 flex items-center gap-1.5">
+      <Label className="w-20 shrink-0">Country</Label>
-        Country
-        {flagURL(details.dxcc) && (
-          <img src={flagURL(details.dxcc)} alt="" className="h-3 rounded-[2px] border border-border/50 shadow-sm mr-0.5"
-            referrerPolicy="no-referrer" onError={(e) => { (e.currentTarget as HTMLImageElement).style.display = 'none'; }} />
-        )}
-      </Label>
       <div className="flex-1 min-w-0">
         <Combobox value={country} options={countries} placeholder="Country" onChange={(v) => { setCountry(v); markEdited('country'); }} />
       </div>
@@ -2243,6 +2289,250 @@ export default function App() {
     </div>
   );
 
+  // Cluster spots after every active filter (band / mode / status / search /
+  // hide-worked / group). Shared by the Cluster tab and the Main-view cluster
+  // pane so both show exactly the same list.
+  const clusterRenderedRows = useMemo(() => {
+    const bandsActive = clusterLockBand ? new Set([band]) : clusterBands;
+    const search = clusterSearch.trim().toUpperCase();
+    const list = spots.filter((s) => {
+      if (clusterFilterSource && s.source_id !== clusterFilterSource) return false;
+      if (bandsActive.size > 0 && !bandsActive.has(s.band ?? '')) return false;
+      if (search && !s.dx_call.includes(search)) return false;
+      if (clusterLockMode) {
+        const spotMode = inferSpotMode(s.comment ?? '', s.freq_hz);
+        if (spotMode && mode && spotMode !== mode) return false;
+      }
+      if (clusterModeFilter.size > 0) {
+        const cat = spotModeCategory(inferSpotMode(s.comment ?? '', s.freq_hz));
+        if (!cat || !clusterModeFilter.has(cat)) return false;
+      }
+      if (clusterStatusFilter.size > 0) {
+        const k = spotStatusKey(s.dx_call, s.band ?? '', s.comment ?? '', s.freq_hz);
+        const st = spotStatus[k]?.status || '';
+        if (!clusterStatusFilter.has(st as SpotStatusKey)) return false;
+      }
+      if (clusterHideWorked) {
+        const k = spotStatusKey(s.dx_call, s.band ?? '', s.comment ?? '', s.freq_hz);
+        const e = spotStatus[k];
+        if (!e) return false;
+        if (e.worked_call || e.status === 'worked') return false;
+      }
+      return true;
+    });
+    let rendered = list as (ClusterSpot & { repeats?: number })[];
+    if (clusterGroup) {
+      const seen = new Map<string, ClusterSpot & { repeats: number }>();
+      for (const s of list) {
+        const e = seen.get(s.dx_call);
+        if (e) { e.repeats++; }
+        else seen.set(s.dx_call, { ...s, repeats: 1 });
+      }
+      rendered = Array.from(seen.values());
+    }
+    return rendered;
+  }, [spots, clusterLockBand, band, clusterBands, clusterSearch, clusterFilterSource,
+      clusterLockMode, mode, clusterModeFilter, clusterStatusFilter, spotStatus,
+      clusterHideWorked, clusterGroup]);
+
+  // The Log4OM-style cluster filter sidebar (callsign search, hide-worked,
+  // group, band/mode/status/source). Rendered both in the Cluster tab and the
+  // Main-view cluster pane; toggled by clusterShowFilters.
+  const renderClusterFilters = () => (
+    <div className="w-56 shrink-0 border-l border-border/60 flex flex-col min-h-0 bg-muted/10">
+      <div className="px-2.5 py-2 border-b border-border/60 flex items-center justify-between">
+        <span className="text-[11px] font-semibold uppercase tracking-wider text-muted-foreground">Filters</span>
+        <button type="button" onClick={toggleClusterFilters} title="Hide filters"
+          className="text-muted-foreground hover:text-foreground">
+          <X className="size-3.5" />
+        </button>
+      </div>
+      <div className="flex-1 overflow-auto p-2.5 space-y-3 text-xs">
+        {/* Callsign search */}
+        <Input
+          className="h-7 text-xs font-mono uppercase"
+          placeholder="Search call…"
+          value={clusterSearch}
+          onChange={(e) => setClusterSearch(e.target.value.toUpperCase())}
+        />
+
+        {/* Toggles */}
+        <div className="space-y-1.5">
+          <label className="flex items-center gap-1.5 cursor-pointer">
+            <Checkbox checked={clusterHideWorked} onCheckedChange={(c) => setClusterHideWorked(!!c)} />
+            Hide worked
+          </label>
+          <label className="flex items-center gap-1.5 cursor-pointer">
+            <Checkbox checked={clusterGroup} onCheckedChange={(c) => setClusterGroup(!!c)} />
+            Group duplicates
+          </label>
+        </div>
+
+        {/* Band filter — multi-select listbox */}
+        <div>
+          <div className="flex items-center justify-between mb-1">
+            <span className="text-[10px] uppercase tracking-wider text-muted-foreground">Bands</span>
+            <div className="flex items-center gap-2">
+              <button
+                type="button"
+                onClick={() => setClusterLockBand((v) => !v)}
+                className={cn('inline-flex items-center gap-0.5 text-[10px] px-1 py-0.5 rounded border',
+                  clusterLockBand ? 'bg-amber-100 text-amber-800 border-amber-300' : 'text-muted-foreground border-border hover:bg-muted')}
+                title="Lock to the entry strip's current band"
+              >
+                {clusterLockBand ? <Lock className="size-2.5" /> : <Unlock className="size-2.5" />} {band}
+              </button>
+              {clusterBands.size > 0 && (
+                <button type="button" onClick={() => setClusterBands(new Set())} className="text-[10px] text-muted-foreground hover:text-foreground underline">clear</button>
+              )}
+            </div>
+          </div>
+          <div className={cn('rounded border border-border max-h-36 overflow-auto bg-background', clusterLockBand && 'opacity-40 pointer-events-none')}>
+            {bands.map((b) => {
+              const on = clusterBands.has(b);
+              return (
+                <button
+                  key={b}
+                  type="button"
+                  onClick={() => setClusterBands((s) => { const n = new Set(s); if (n.has(b)) n.delete(b); else n.add(b); return n; })}
+                  className={cn('block w-full text-left px-2 py-0.5 font-mono text-[11px] border-b border-border/30 last:border-0',
+                    on ? 'bg-primary text-primary-foreground' : 'hover:bg-accent/50')}
+                >
+                  {b}
+                </button>
+              );
+            })}
+          </div>
+        </div>
+
+        {/* Mode lock */}
+        <button
+          type="button"
+          onClick={() => setClusterLockMode((v) => !v)}
+          className={cn('inline-flex items-center gap-1 px-1.5 py-0.5 rounded border text-[10px]',
+            clusterLockMode ? 'bg-amber-100 text-amber-800 border-amber-300' : 'text-muted-foreground border-border hover:bg-muted')}
+          title="Only show spots whose mode matches the entry strip"
+        >
+          {clusterLockMode ? <Lock className="size-2.5" /> : <Unlock className="size-2.5" />} Lock mode ({mode})
+        </button>
+
+        {/* Status filter */}
+        <div>
+          <div className="text-[10px] uppercase tracking-wider text-muted-foreground mb-1">Status</div>
+          <div className="flex flex-wrap gap-1">
+            {([
+              { k: 'new'      as SpotStatusKey, label: 'NEW',       cls: 'bg-rose-100 text-rose-800 border-rose-300' },
+              { k: 'new-band' as SpotStatusKey, label: 'NEW BAND',  cls: 'bg-amber-100 text-amber-800 border-amber-300' },
+              { k: 'new-slot' as SpotStatusKey, label: 'NEW SLOT',  cls: 'bg-yellow-100 text-yellow-800 border-yellow-300' },
+              { k: 'worked'   as SpotStatusKey, label: 'WORKED',    cls: 'bg-muted text-muted-foreground border-border' },
+            ]).map((s) => {
+              const on = clusterStatusFilter.has(s.k);
+              return (
+                <button key={s.k} type="button"
+                  onClick={() => setClusterStatusFilter((cur) => { const n = new Set(cur); if (n.has(s.k)) n.delete(s.k); else n.add(s.k); return n; })}
+                  className={cn('px-1.5 py-0.5 rounded border text-[10px] font-bold tracking-wider transition-opacity', on ? s.cls : `${s.cls} opacity-40 hover:opacity-100`)}>
+                  {s.label}
+                </button>
+              );
+            })}
+          </div>
+        </div>
+
+        {/* Mode filter */}
+        <div>
+          <div className="text-[10px] uppercase tracking-wider text-muted-foreground mb-1">Mode</div>
+          <div className="flex flex-wrap gap-1">
+            {([
+              { k: 'SSB'  as SpotModeCat, label: 'SSB',  cls: 'bg-sky-100 text-sky-800 border-sky-300' },
+              { k: 'CW'   as SpotModeCat, label: 'CW',   cls: 'bg-violet-100 text-violet-800 border-violet-300' },
+              { k: 'DATA' as SpotModeCat, label: 'DATA', cls: 'bg-emerald-100 text-emerald-800 border-emerald-300' },
+            ]).map((s) => {
+              const on = clusterModeFilter.has(s.k);
+              return (
+                <button key={s.k} type="button"
+                  onClick={() => setClusterModeFilter((cur) => { const n = new Set(cur); if (n.has(s.k)) n.delete(s.k); else n.add(s.k); return n; })}
+                  className={cn('px-1.5 py-0.5 rounded border text-[10px] font-bold tracking-wider transition-opacity', on ? s.cls : `${s.cls} opacity-40 hover:opacity-100`)}>
+                  {s.label}
+                </button>
+              );
+            })}
+          </div>
+        </div>
+
+        {/* Source */}
+        <div>
+          <div className="text-[10px] uppercase tracking-wider text-muted-foreground mb-1">Source</div>
+          <Select value={String(clusterFilterSource || '_')} onValueChange={(v) => setClusterFilterSource(v === '_' ? '' : parseInt(v, 10))}>
+            <SelectTrigger className="w-full h-7 text-xs"><SelectValue placeholder="All sources" /></SelectTrigger>
+            <SelectContent>
+              <SelectItem value="_">All sources</SelectItem>
+              {clusterServers.map((s) => <SelectItem key={s.id} value={String(s.id)}>{s.name}</SelectItem>)}
+            </SelectContent>
+          </Select>
+        </div>
+      </div>
+    </div>
+  );
+
+  // A small "show filters" button shown when the sidebar is collapsed.
+  const clusterFiltersToggleBtn = (
+    <button type="button" onClick={toggleClusterFilters}
+      title={clusterShowFilters ? 'Hide filters' : 'Show filters'}
+      className={cn('inline-flex items-center gap-1 px-1.5 py-0.5 rounded border text-[10px] font-medium',
+        clusterShowFilters ? 'bg-primary text-primary-foreground border-primary' : 'text-muted-foreground border-border hover:bg-muted')}>
+      <SlidersHorizontal className="size-3" /> Filters
+    </button>
+  );
+
+  // 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) => {
+    switch (kind) {
+      case 'map1':
+        return (
+          <WorldMap
+            fromGrid={station.my_grid}
+            toGrid={grid}
+            fromLabel={station.callsign}
+            toLabel={callsign}
+            beamAzimuths={showBeamOnMap ? beamHeadings : []}
+            boomAzimuth={showBeamOnMap && ubPattern && ubPattern !== 'normal' ? boomHeading : null}
+          />
+        );
+      case 'map2':
+        return <LocatorMap toGrid={grid} toLabel={callsign} />;
+      case 'cluster':
+        return (
+          <div className="h-full w-full min-h-0 flex flex-col bg-card border border-border rounded-lg overflow-hidden">
+            <div className="flex items-center justify-between px-2 py-1 border-b border-border/60 shrink-0">
+              <span className="text-[11px] font-semibold uppercase tracking-wider text-muted-foreground">Cluster</span>
+              {clusterFiltersToggleBtn}
+            </div>
+            <div className="flex-1 min-h-0 flex">
+              <div className="flex-1 min-w-0 flex flex-col min-h-0">
+                <ClusterGrid rows={clusterRenderedRows as any} spotStatus={spotStatus} onSpotClick={handleSpotClick} />
+              </div>
+              {clusterShowFilters && renderClusterFilters()}
+            </div>
+          </div>
+        );
+      case 'worked':
+        return (
+          <div className="h-full w-full min-h-0 flex flex-col bg-card border border-border rounded-lg overflow-hidden">
+            <WorkedBeforeGrid wb={wb} busy={wbBusy} currentCall={callsign} onRowDoubleClicked={(q) => openEdit(q.id as number)}
+              onUpdateFromCty={bulkUpdateFromCty} onUpdateFromQRZ={bulkUpdateFromQRZ} onUpdateFromClublog={bulkUpdateFromClublog}
+              onSendTo={bulkSendTo} onSendRecording={bulkSendRecording} onSendEQSL={(ids) => setEqslQsoId(ids[0] ?? null)} />
+          </div>
+        );
+      case 'flex':
+        return (
+          <div className="h-full w-full min-h-0 rounded-lg overflow-hidden border border-border">
+            <FlexPanel />
+          </div>
+        );
+    }
+  };
+
   return (
     <div className="flex flex-col h-screen bg-background">
       <ShutdownProgress />
@@ -2646,6 +2936,7 @@ export default function App() {
               {callsignBlock}
               {rstTxBlock}
               {rstRxBlock}
+              {flagBlock}
               <div className="ml-auto flex gap-2">
                 {dateBlock}
                 {startBlock}
@@ -2724,6 +3015,8 @@ export default function App() {
               <RotorCompass
                 bearing={dxPath?.bearingShort ?? null}
                 headings={beamHeadings}
+                boomHeading={boomHeading}
+                pattern={ubPattern}
                 centerLat={gridToLatLon(station.my_grid)?.lat ?? null}
                 centerLon={gridToLatLon(station.my_grid)?.lon ?? null}
                 rotorEnabled={rotatorHeading.enabled && rotatorHeading.ok}
@@ -2817,6 +3110,7 @@ export default function App() {
               </TabsTrigger>
               <TabsTrigger value="awards">Awards</TabsTrigger>
               <TabsTrigger value="bandmap">Band Map</TabsTrigger>
+              {catState.backend === 'flex' && <TabsTrigger value="flex">FlexRadio</TabsTrigger>}
               {/* Not a tab — QRZ blocks embedding, so this opens the call's
                   QRZ.com page in the system browser. Styled like a trigger. */}
               <button
@@ -3022,60 +3316,15 @@ export default function App() {
                 })}
                 <div className="flex-1" />
                 <Badge variant="secondary" className="text-[10px]">{spots.length} live</Badge>
+                {clusterFiltersToggleBtn}
               </div>
 
               {/* Filters moved to the right-side panel (see below). */}
 
               {(() => {
-                // Apply every filter. `bandsActive` is the band set the
+                // Filtered + grouped spots (shared with the Main-view cluster
-                // user clicked, OR the entry's locked band when Lock band
+                // pane). All the filter state lives in the right-side panel.
-                // is on. Mode lock compares the spot's inferred mode to
+                const rendered = clusterRenderedRows;
-                // the entry's current one.
-                const bandsActive = clusterLockBand
-                  ? new Set([band])
-                  : clusterBands;
-                const search = clusterSearch.trim().toUpperCase();
-                let list = spots.filter((s) => {
-                  if (clusterFilterSource && s.source_id !== clusterFilterSource) return false;
-                  if (bandsActive.size > 0 && !bandsActive.has(s.band ?? '')) return false;
-                  if (search && !s.dx_call.includes(search)) return false;
-                  if (clusterLockMode) {
-                    const spotMode = inferSpotMode(s.comment ?? '', s.freq_hz);
-                    if (spotMode && mode && spotMode !== mode) return false;
-                  }
-                  if (clusterModeFilter.size > 0) {
-                    const cat = spotModeCategory(inferSpotMode(s.comment ?? '', s.freq_hz));
-                    if (!cat || !clusterModeFilter.has(cat)) return false;
-                  }
-                  if (clusterStatusFilter.size > 0) {
-                    const k = spotStatusKey(s.dx_call, s.band ?? '', s.comment ?? '', s.freq_hz);
-                    const st = spotStatus[k]?.status || '';
-                    if (!clusterStatusFilter.has(st as SpotStatusKey)) return false;
-                  }
-                  // Hide worked: drop spots whose exact call is already worked,
-                  // or whose entity+band+mode slot is already in the log. The
-                  // status is resolved asynchronously, so we also hide spots
-                  // whose status isn't known yet — otherwise a worked spot would
-                  // flash in (no status) then vanish once it resolves. A new
-                  // spot waits for its status, then appears only if not worked.
-                  if (clusterHideWorked) {
-                    const k = spotStatusKey(s.dx_call, s.band ?? '', s.comment ?? '', s.freq_hz);
-                    const e = spotStatus[k];
-                    if (!e) return false;
-                    if (e.worked_call || e.status === 'worked') return false;
-                  }
-                  return true;
-                });
-                let rendered = list as (ClusterSpot & { repeats?: number })[];
-                if (clusterGroup) {
-                  const seen = new Map<string, ClusterSpot & { repeats: number }>();
-                  for (const s of list) {
-                    const e = seen.get(s.dx_call);
-                    if (e) { e.repeats++; }
-                    else seen.set(s.dx_call, { ...s, repeats: 1 });
-                  }
-                  rendered = Array.from(seen.values());
-                }
                 if (rendered.length === 0) {
                   return (
                     <div className="flex-1 flex flex-col items-center justify-center text-muted-foreground gap-2 py-12">
@@ -3131,134 +3380,9 @@ export default function App() {
               </div>
               </div>{/* /left column */}
 
-              {/* Right-side filter panel (Log4OM style) */}
+              {/* Right-side filter panel (Log4OM style) — shared with the
-              <div className="w-56 shrink-0 border-l border-border/60 flex flex-col min-h-0 bg-muted/10">
+                  Main-view cluster pane; toggle hides it in both places. */}
-                <div className="px-2.5 py-2 border-b border-border/60 text-[11px] font-semibold uppercase tracking-wider text-muted-foreground">Filters</div>
+              {clusterShowFilters && renderClusterFilters()}
-                <div className="flex-1 overflow-auto p-2.5 space-y-3 text-xs">
-                  {/* Callsign search */}
-                  <Input
-                    className="h-7 text-xs font-mono uppercase"
-                    placeholder="Search call…"
-                    value={clusterSearch}
-                    onChange={(e) => setClusterSearch(e.target.value.toUpperCase())}
-                  />
-
-                  {/* Toggles */}
-                  <div className="space-y-1.5">
-                    <label className="flex items-center gap-1.5 cursor-pointer">
-                      <Checkbox checked={clusterHideWorked} onCheckedChange={(c) => setClusterHideWorked(!!c)} />
-                      Hide worked
-                    </label>
-                    <label className="flex items-center gap-1.5 cursor-pointer">
-                      <Checkbox checked={clusterGroup} onCheckedChange={(c) => setClusterGroup(!!c)} />
-                      Group duplicates
-                    </label>
-                  </div>
-
-                  {/* Band filter — multi-select listbox */}
-                  <div>
-                    <div className="flex items-center justify-between mb-1">
-                      <span className="text-[10px] uppercase tracking-wider text-muted-foreground">Bands</span>
-                      <div className="flex items-center gap-2">
-                        <button
-                          type="button"
-                          onClick={() => setClusterLockBand((v) => !v)}
-                          className={cn('inline-flex items-center gap-0.5 text-[10px] px-1 py-0.5 rounded border',
-                            clusterLockBand ? 'bg-amber-100 text-amber-800 border-amber-300' : 'text-muted-foreground border-border hover:bg-muted')}
-                          title="Lock to the entry strip's current band"
-                        >
-                          {clusterLockBand ? <Lock className="size-2.5" /> : <Unlock className="size-2.5" />} {band}
-                        </button>
-                        {clusterBands.size > 0 && (
-                          <button type="button" onClick={() => setClusterBands(new Set())} className="text-[10px] text-muted-foreground hover:text-foreground underline">clear</button>
-                        )}
-                      </div>
-                    </div>
-                    <div className={cn('rounded border border-border max-h-36 overflow-auto bg-background', clusterLockBand && 'opacity-40 pointer-events-none')}>
-                      {bands.map((b) => {
-                        const on = clusterBands.has(b);
-                        return (
-                          <button
-                            key={b}
-                            type="button"
-                            onClick={() => setClusterBands((s) => { const n = new Set(s); if (n.has(b)) n.delete(b); else n.add(b); return n; })}
-                            className={cn('block w-full text-left px-2 py-0.5 font-mono text-[11px] border-b border-border/30 last:border-0',
-                              on ? 'bg-primary text-primary-foreground' : 'hover:bg-accent/50')}
-                          >
-                            {b}
-                          </button>
-                        );
-                      })}
-                    </div>
-                  </div>
-
-                  {/* Mode lock */}
-                  <button
-                    type="button"
-                    onClick={() => setClusterLockMode((v) => !v)}
-                    className={cn('inline-flex items-center gap-1 px-1.5 py-0.5 rounded border text-[10px]',
-                      clusterLockMode ? 'bg-amber-100 text-amber-800 border-amber-300' : 'text-muted-foreground border-border hover:bg-muted')}
-                    title="Only show spots whose mode matches the entry strip"
-                  >
-                    {clusterLockMode ? <Lock className="size-2.5" /> : <Unlock className="size-2.5" />} Lock mode ({mode})
-                  </button>
-
-                  {/* Status filter */}
-                  <div>
-                    <div className="text-[10px] uppercase tracking-wider text-muted-foreground mb-1">Status</div>
-                    <div className="flex flex-wrap gap-1">
-                      {([
-                        { k: 'new'      as SpotStatusKey, label: 'NEW',       cls: 'bg-rose-100 text-rose-800 border-rose-300' },
-                        { k: 'new-band' as SpotStatusKey, label: 'NEW BAND',  cls: 'bg-amber-100 text-amber-800 border-amber-300' },
-                        { k: 'new-slot' as SpotStatusKey, label: 'NEW SLOT',  cls: 'bg-yellow-100 text-yellow-800 border-yellow-300' },
-                        { k: 'worked'   as SpotStatusKey, label: 'WORKED',    cls: 'bg-muted text-muted-foreground border-border' },
-                      ]).map((s) => {
-                        const on = clusterStatusFilter.has(s.k);
-                        return (
-                          <button key={s.k} type="button"
-                            onClick={() => setClusterStatusFilter((cur) => { const n = new Set(cur); if (n.has(s.k)) n.delete(s.k); else n.add(s.k); return n; })}
-                            className={cn('px-1.5 py-0.5 rounded border text-[10px] font-bold tracking-wider transition-opacity', on ? s.cls : `${s.cls} opacity-40 hover:opacity-100`)}>
-                            {s.label}
-                          </button>
-                        );
-                      })}
-                    </div>
-                  </div>
-
-                  {/* Mode filter */}
-                  <div>
-                    <div className="text-[10px] uppercase tracking-wider text-muted-foreground mb-1">Mode</div>
-                    <div className="flex flex-wrap gap-1">
-                      {([
-                        { k: 'SSB'  as SpotModeCat, label: 'SSB',  cls: 'bg-sky-100 text-sky-800 border-sky-300' },
-                        { k: 'CW'   as SpotModeCat, label: 'CW',   cls: 'bg-violet-100 text-violet-800 border-violet-300' },
-                        { k: 'DATA' as SpotModeCat, label: 'DATA', cls: 'bg-emerald-100 text-emerald-800 border-emerald-300' },
-                      ]).map((s) => {
-                        const on = clusterModeFilter.has(s.k);
-                        return (
-                          <button key={s.k} type="button"
-                            onClick={() => setClusterModeFilter((cur) => { const n = new Set(cur); if (n.has(s.k)) n.delete(s.k); else n.add(s.k); return n; })}
-                            className={cn('px-1.5 py-0.5 rounded border text-[10px] font-bold tracking-wider transition-opacity', on ? s.cls : `${s.cls} opacity-40 hover:opacity-100`)}>
-                            {s.label}
-                          </button>
-                        );
-                      })}
-                    </div>
-                  </div>
-
-                  {/* Source */}
-                  <div>
-                    <div className="text-[10px] uppercase tracking-wider text-muted-foreground mb-1">Source</div>
-                    <Select value={String(clusterFilterSource || '_')} onValueChange={(v) => setClusterFilterSource(v === '_' ? '' : parseInt(v, 10))}>
-                      <SelectTrigger className="w-full h-7 text-xs"><SelectValue placeholder="All sources" /></SelectTrigger>
-                      <SelectContent>
-                        <SelectItem value="_">All sources</SelectItem>
-                        {clusterServers.map((s) => <SelectItem key={s.id} value={String(s.id)}>{s.name}</SelectItem>)}
-                      </SelectContent>
-                    </Select>
-                  </div>
-                </div>
-              </div>
             </TabsContent>
 
             <TabsContent value="worked" className="mt-0 flex flex-col min-h-0 flex-1">
@@ -3277,19 +3401,27 @@ export default function App() {
             )}
 
             <TabsContent value="main" className="flex-1 min-h-0 p-0">
-              <MainMap
+              {/* Two configurable panes (per-profile, Settings → Main view).
-                fromGrid={station.my_grid}
+                  Each side shows one of: great-circle map, locator map, cluster
-                toGrid={grid}
+                  or worked-before. */}
-                fromLabel={station.callsign}
+              <div className="grid grid-cols-2 grid-rows-1 gap-2 h-full min-h-0 p-2">
-                toLabel={callsign}
+                <div className="min-h-0 min-w-0 flex">{renderMainPane(mainPaneLeft)}</div>
-                beamAzimuths={showBeamOnMap ? beamHeadings : []}
+                <div className="min-h-0 min-w-0 flex">{renderMainPane(mainPaneRight)}</div>
-              />
+              </div>
             </TabsContent>
 
             <TabsContent value="awards" className="flex-1 min-h-0 p-0">
               <AwardsPanel onEditQSO={openEdit} />
             </TabsContent>
 
+            {/* FlexRadio SmartSDR-style control panel — only present when the CAT
+                backend is a FlexRadio. */}
+            {catState.backend === 'flex' && (
+              <TabsContent value="flex" className="flex-1 min-h-0 p-0">
+                <FlexPanel />
+              </TabsContent>
+            )}
+
             {/* Band Map: several bands shown side-by-side (panadapter-style
                 strips). Pick bands with the chips; each strip is clickable to
                 tune the rig. */}
@@ -3443,6 +3575,8 @@ export default function App() {
           initialSection={settingsSection}
           onClose={() => { setShowSettings(false); setSettingsSection(undefined); }}
           onSaved={() => { loadStation(); loadLists(); loadCATCfg(); reloadWk(); }}
+          onMainPaneChanged={(side, v) => { if (side === 'left') setMainPaneLeft(v as MainPaneKind); else setMainPaneRight(v as MainPaneKind); }}
+          flexAvailable={catState.backend === 'flex'}
         />
       )}
 

frontend/src/components/AwardsPanel.tsx

@@ -1,6 +1,6 @@
 import { useEffect, useMemo, useState } from 'react';
 import { Award as AwardIcon, RefreshCw, Loader2, Search, Pencil, X, Grid3x3, List, BarChart3, AlertTriangle, ChevronUp, ChevronDown } from 'lucide-react';
-import { GetAwardDefs, GetAward, AwardCellQSOs, GetAwardStats, AwardMissingQSOs, ListAwardReferences, AssignAwardRefToQSOs } from '../../wailsjs/go/main/App';
+import { GetAwardDefs, GetAward, AwardCellQSOs, GetAwardStats, AwardMissingQSOs, ListAwardReferences, AssignAwardRefToQSOs, RescanAwards } from '../../wailsjs/go/main/App';
 import { Input } from '@/components/ui/input';
 import { Button } from '@/components/ui/button';
 import { Checkbox } from '@/components/ui/checkbox';
@@ -76,6 +76,9 @@ export function AwardsPanel({ onEditQSO }: { onEditQSO?: (id: number) => void }
   const [showMissing, setShowMissing] = useState(false);
   const [stats, setStats] = useState<AwardStats | null>(null);
   const [statsLoading, setStatsLoading] = useState(false);
+  // Bumped by Rescan to force the stats matrix to re-fetch (the selected award
+  // didn't change, but the backend snapshot did).
+  const [rescanTick, setRescanTick] = useState(0);
 
   // Lazily fetch the statistics matrix when the Stats view is shown.
   useEffect(() => {
@@ -85,7 +88,24 @@ export function AwardsPanel({ onEditQSO }: { onEditQSO?: (id: number) => void }
       .then((s) => setStats(s as any))
       .catch(() => setStats(null))
       .finally(() => setStatsLoading(false));
-  }, [view, selected]);
+  }, [view, selected, rescanTick]);
+
+  // Rescan: drop the backend snapshot (so confirmations from a fresh LoTW/QRZ
+  // download are picked up) and the cached results, then recompute everything.
+  async function rescan() {
+    if (!selected) return;
+    setLoading(true);
+    try {
+      await RescanAwards();
+      setByCode({});
+      setRescanTick((t) => t + 1);
+      await compute(selected, true);
+    } catch (e: any) {
+      setErr(String(e?.message ?? e));
+    } finally {
+      setLoading(false);
+    }
+  }
 
   // Compute one award (cached). force=true bypasses the cache (Rescan).
   async function compute(code: string, force = false) {
@@ -192,8 +212,8 @@ export function AwardsPanel({ onEditQSO }: { onEditQSO?: (id: number) => void }
           <Button variant="ghost" size="sm" className="h-7 px-2" onClick={() => setEditing(true)} title="Edit awards">
             <Pencil className="size-3.5" />
           </Button>
-          <Button variant="outline" size="sm" className="h-7 px-2" onClick={() => compute(selected, true)} disabled={loading || !selected}
+          <Button variant="outline" size="sm" className="h-7 px-2" onClick={rescan} disabled={loading || !selected}
-            title="Rescan all QSOs and recompute this award">
+            title="Re-pull the logbook and recompute (picks up new LoTW/QRZ confirmations)">
             {loading ? <Loader2 className="size-3.5 mr-1 animate-spin" /> : <RefreshCw className="size-3.5 mr-1" />}
             Rescan
           </Button>

frontend/src/components/FlexPanel.tsx

@@ -0,0 +1,433 @@
+import { useEffect, useRef, useState } from 'react';
+import { Radio, Zap, Mic2, Settings2, Power, AudioLines, Antenna, Flame, Gauge } from 'lucide-react';
+import {
+  GetFlexState, FlexSetPower, FlexSetTunePower, FlexTune, FlexSetVox, FlexSetVoxLevel, FlexSetVoxDelay,
+  FlexSetProcessor, FlexSetProcessorLevel, FlexSetMon, FlexSetMonLevel, FlexSetMic,
+  FlexMox, FlexATUStart, FlexATUBypass, FlexSetATUMemories, FlexAmpOperate,
+  FlexSetAGCMode, FlexSetAGCThreshold, FlexSetAudioLevel,
+  FlexSetNB, FlexSetNBLevel, FlexSetNR, FlexSetNRLevel, FlexSetANF, FlexSetANFLevel,
+} from '../../wailsjs/go/main/App';
+import { cn } from '@/lib/utils';
+
+type FlexState = {
+  available: boolean; model?: string;
+  rf_power: number; tune_power: number; tune: boolean; transmitting: boolean;
+  vox_enable: boolean; vox_level: number; vox_delay: number;
+  proc_enable: boolean; proc_level: number;
+  mon: boolean; mon_level: number; mic_level: number;
+  atu_status?: string; atu_memories: boolean;
+  rx_avail: boolean; agc_mode?: string; agc_threshold: number; audio_level: number;
+  nb: boolean; nb_level: number; nr: boolean; nr_level: number; anf: boolean; anf_level: number;
+  amp_available: boolean; amp_model?: string; amp_operate: boolean; amp_fault?: string;
+  meters?: Meter[];
+};
+
+type Meter = { id: number; src?: string; name?: string; unit?: string; value: number; lo: number; hi: number };
+
+const ZERO: FlexState = {
+  available: false, rf_power: 0, tune_power: 0, tune: false, transmitting: false,
+  vox_enable: false, vox_level: 0, vox_delay: 0, proc_enable: false, proc_level: 0,
+  mon: false, mon_level: 0, mic_level: 0, atu_memories: false,
+  rx_avail: false, agc_threshold: 0, audio_level: 0,
+  nb: false, nb_level: 0, nr: false, nr_level: 0, anf: false, anf_level: 0,
+  amp_available: false, amp_operate: false,
+};
+
+function Slider({ value, onChange, disabled, accent = '#16a34a', step = 1, max = 100 }: {
+  value: number; onChange: (v: number) => void; disabled?: boolean; accent?: string; step?: number; max?: number;
+}) {
+  const v = Math.max(0, Math.min(max, value));
+  const pct = max > 0 ? (v / max) * 100 : 0;
+  const ref = useRef<HTMLInputElement>(null);
+  // Mouse-wheel adjusts the slider. React's onWheel is passive (preventDefault
+  // is ignored), so attach a non-passive native listener; read live values via
+  // refs to avoid stale closures.
+  const valRef = useRef(value); valRef.current = value;
+  const cbRef = useRef(onChange); cbRef.current = onChange;
+  const disRef = useRef(disabled); disRef.current = disabled;
+  const stepRef = useRef(step); stepRef.current = step;
+  const maxRef = useRef(max); maxRef.current = max;
+  useEffect(() => {
+    const el = ref.current;
+    if (!el) return;
+    const onWheel = (e: WheelEvent) => {
+      if (disRef.current) return;
+      e.preventDefault();
+      const d = e.deltaY < 0 ? stepRef.current : -stepRef.current;
+      const nv = Math.max(0, Math.min(maxRef.current, valRef.current + d));
+      if (nv !== valRef.current) cbRef.current(nv);
+    };
+    el.addEventListener('wheel', onWheel, { passive: false });
+    return () => el.removeEventListener('wheel', onWheel);
+  }, []);
+  return (
+    <input
+      ref={ref}
+      type="range" min={0} max={max} value={v} disabled={disabled}
+      onChange={(e) => onChange(parseInt(e.target.value, 10))}
+      className={cn('flex-1 h-1.5 rounded-full appearance-none cursor-pointer disabled:opacity-30 disabled:cursor-default',
+        '[&::-webkit-slider-thumb]:appearance-none [&::-webkit-slider-thumb]:size-3.5 [&::-webkit-slider-thumb]:rounded-full',
+        '[&::-webkit-slider-thumb]:bg-white [&::-webkit-slider-thumb]:border-2 [&::-webkit-slider-thumb]:shadow-sm [&::-webkit-slider-thumb]:cursor-pointer')}
+      style={{ background: `linear-gradient(to right, ${accent} ${pct}%, #d8cfb8 ${pct}%)`, borderColor: accent }}
+    />
+  );
+}
+
+// Segmented — radio-style multi-choice (AGC, Processor preset).
+function Segmented({ value, options, onChange, disabled }: {
+  value: string; options: { v: string; l: string }[]; onChange: (v: string) => void; disabled?: boolean;
+}) {
+  return (
+    <div className="inline-flex rounded-md border border-border overflow-hidden shrink-0">
+      {options.map((o) => (
+        <button key={o.v} type="button" disabled={disabled} onClick={() => onChange(o.v)}
+          className={cn('px-2 py-1 text-[11px] font-bold tracking-wide transition-colors disabled:opacity-30 border-l border-border first:border-l-0',
+            value === o.v ? 'bg-primary text-primary-foreground' : 'bg-card text-muted-foreground hover:bg-muted')}>
+          {o.l}
+        </button>
+      ))}
+    </div>
+  );
+}
+
+// Chip — a compact on/off pill (NB/NR/ANF/VOX/MON…).
+function Chip({ on, onClick, label, disabled, accent = 'emerald' }: {
+  on: boolean; onClick: () => void; label: string; disabled?: boolean; accent?: 'emerald' | 'violet' | 'cyan' | 'amber';
+}) {
+  const onCls = {
+    emerald: 'bg-emerald-600 border-emerald-600 text-white',
+    violet: 'bg-violet-600 border-violet-600 text-white',
+    cyan: 'bg-cyan-600 border-cyan-600 text-white',
+    amber: 'bg-amber-500 border-amber-500 text-white',
+  }[accent];
+  return (
+    <button type="button" onClick={onClick} disabled={disabled}
+      className={cn('w-14 shrink-0 px-2 py-1 rounded-md text-[11px] font-bold border transition-colors disabled:opacity-30',
+        on ? onCls : 'bg-card text-muted-foreground border-border hover:bg-muted')}>
+      {label}
+    </button>
+  );
+}
+
+function LevelRow({ label, on, onToggle, value, onLevel, disabled, accent, sliderAccent }: {
+  label: string; on: boolean; onToggle: () => void; value: number; onLevel: (v: number) => void;
+  disabled?: boolean; accent?: 'emerald' | 'violet' | 'cyan' | 'amber'; sliderAccent?: string;
+}) {
+  return (
+    <div className="flex items-center gap-2">
+      <Chip on={on} onClick={onToggle} label={label} disabled={disabled} accent={accent} />
+      <Slider value={value} disabled={disabled || !on} accent={sliderAccent} onChange={onLevel} />
+      <span className="w-8 text-right text-xs font-mono tabular-nums text-muted-foreground">{value}</span>
+    </div>
+  );
+}
+
+// MeterBar — a segmented "LED" instrument bar (radio look) scaled by lo/hi.
+// `display` overrides the numeric readout; `segColor` colours segments by their
+// 0..1 position (zones); the top ~18% light red by default (overload/peak).
+const METER_SEGMENTS = 26;
+function MeterBar({ label, value, unit, lo, hi, accent = '#16a34a', extra, display, segColor }: {
+  label: string; value: number; unit?: string; lo: number; hi: number; accent?: string; extra?: string; display?: string;
+  segColor?: (frac: number) => string;
+}) {
+  const span = hi - lo;
+  const pct = span > 0 ? Math.max(0, Math.min(100, ((value - lo) / span) * 100)) : 0;
+  const lit = Math.round((pct / 100) * METER_SEGMENTS);
+  return (
+    <div className="rounded-lg border border-border/70 px-2.5 py-2 bg-gradient-to-b from-card to-muted/40 shadow-sm min-w-0">
+      <div className="flex items-baseline justify-between gap-1 mb-1.5">
+        <span className="text-[10px] font-bold uppercase tracking-wider text-muted-foreground truncate">{label}</span>
+        <span className="text-sm font-mono font-bold tabular-nums whitespace-nowrap text-foreground/90">
+          {display !== undefined ? display : (
+            <>{Math.abs(value) >= 100 ? value.toFixed(0) : value.toFixed(1)}<span className="text-muted-foreground text-[10px] ml-0.5">{unit}</span></>
+          )}
+        </span>
+      </div>
+      <div className="flex gap-[2px] h-2.5 items-stretch">
+        {Array.from({ length: METER_SEGMENTS }).map((_, i) => {
+          const on = i < lit;
+          const frac = i / METER_SEGMENTS;
+          const col = segColor ? segColor(frac) : (frac > 0.82 ? '#dc2626' : accent);
+          return (
+            <div key={i} className="flex-1 rounded-[1.5px] transition-colors duration-100"
+              style={on ? { background: col, boxShadow: `0 0 3px ${col}66` } : { background: '#cfc6ad', opacity: 0.45 }} />
+          );
+        })}
+      </div>
+      {extra && <div className="text-[10px] text-muted-foreground/70 mt-1 text-right font-mono">{extra}</div>}
+    </div>
+  );
+}
+
+function Card({ icon: Icon, title, accent, children }: { icon: any; title: string; accent?: string; children: React.ReactNode }) {
+  return (
+    <div className="rounded-xl border border-border bg-card shadow-sm overflow-hidden">
+      <div className="flex items-center gap-2 px-3 py-2 border-b border-border/60 bg-muted/30">
+        <Icon className="size-4" style={{ color: accent ?? 'var(--primary)' }} />
+        <span className="text-xs font-bold uppercase tracking-wider text-foreground/80">{title}</span>
+      </div>
+      <div className="p-3 space-y-3">{children}</div>
+    </div>
+  );
+}
+
+export function FlexPanel() {
+  const [st, setSt] = useState<FlexState>(ZERO);
+  const hold = useRef<Record<string, number>>({});
+
+  useEffect(() => {
+    let alive = true;
+    const tick = async () => {
+      try {
+        const s = (await GetFlexState()) as any as FlexState;
+        if (!alive) return;
+        setSt((prev) => {
+          const now = Date.now();
+          const merged: any = { ...s };
+          for (const k in hold.current) {
+            if (hold.current[k] > now) merged[k] = (prev as any)[k];
+          }
+          return merged as FlexState;
+        });
+      } catch { /* not connected */ }
+    };
+    tick();
+    const id = window.setInterval(tick, 400);
+    return () => { alive = false; window.clearInterval(id); };
+  }, []);
+
+  const change = (key: keyof FlexState, val: number | boolean | string, send: () => Promise<any>) => {
+    hold.current[key] = Date.now() + 900;
+    setSt((p) => ({ ...p, [key]: val }));
+    send().catch(() => {});
+  };
+
+  const off = !st.available;
+  const rxOff = off || !st.rx_avail;
+  const PROC = [{ v: '0', l: 'NOR' }, { v: '1', l: 'DX' }, { v: '2', l: 'DX+' }];
+  const AGC = [{ v: 'off', l: 'OFF' }, { v: 'slow', l: 'SLOW' }, { v: 'med', l: 'MED' }, { v: 'fast', l: 'FAST' }];
+
+  return (
+    <div className="h-full min-h-0 overflow-auto bg-background">
+      <div className="max-w-5xl mx-auto p-3 space-y-3">
+        {/* Header strip */}
+        <div className="flex items-center gap-3 rounded-xl px-4 py-3 text-white shadow-sm"
+          style={{ background: 'linear-gradient(135deg,#1e293b,#0f172a)' }}>
+          <Radio className="size-6 text-sky-400" />
+          <div className="flex flex-col leading-tight">
+            <span className="text-base font-extrabold tracking-tight">{st.model || 'FlexRadio'}</span>
+            <span className="text-[11px] text-slate-400">SmartSDR remote control</span>
+          </div>
+          <div className="flex-1" />
+          <span className={cn('inline-flex items-center gap-1.5 px-3 py-1.5 rounded-lg text-sm font-extrabold tracking-wider',
+            !st.available ? 'bg-slate-700 text-slate-300'
+              : st.transmitting ? 'bg-rose-500 text-white shadow-[0_0_16px] shadow-rose-500/60' : 'bg-emerald-500 text-white')}>
+            <span className="size-2 rounded-full bg-current" />
+            {!st.available ? 'OFFLINE' : st.transmitting ? 'TX' : 'RX'}
+          </span>
+        </div>
+
+        {off && (
+          <div className="text-center text-sm text-muted-foreground py-6">
+            Waiting for the FlexRadio… (set CAT to FlexRadio and connect)
+          </div>
+        )}
+
+        {/* TX + RX columns */}
+        <div className="grid grid-cols-1 lg:grid-cols-2 gap-3">
+          {/* TRANSMIT */}
+          <Card icon={Zap} title="Transmit" accent="#dc2626">
+            <div className="flex items-center gap-3">
+              <span className="w-20 shrink-0 text-xs font-medium text-muted-foreground">RF Power</span>
+              <Slider value={st.rf_power} disabled={off} accent="#dc2626" onChange={(v) => change('rf_power', v, () => FlexSetPower(v))} />
+              <span className="w-9 text-right text-sm font-mono font-bold tabular-nums">{st.rf_power}</span>
+            </div>
+            <div className="flex items-center gap-3">
+              <span className="w-20 shrink-0 text-xs font-medium text-muted-foreground">Tune Pwr</span>
+              <Slider value={st.tune_power} disabled={off} accent="#d97706" onChange={(v) => change('tune_power', v, () => FlexSetTunePower(v))} />
+              <span className="w-9 text-right text-sm font-mono font-bold tabular-nums">{st.tune_power}</span>
+            </div>
+            <div className="flex items-center gap-2 pt-0.5">
+              <button type="button" disabled={off}
+                onClick={() => change('tune', !st.tune, () => FlexTune(!st.tune))}
+                className={cn('flex-1 px-3 py-2.5 rounded-lg text-sm font-extrabold tracking-wide border-2 transition-all disabled:opacity-30',
+                  st.tune ? 'bg-amber-500 text-white border-amber-500 shadow-[0_0_14px] shadow-amber-500/50' : 'bg-card text-amber-700 border-amber-400 hover:bg-amber-50')}>
+                TUNE
+              </button>
+              <button type="button" disabled={off}
+                onClick={() => change('transmitting', !st.transmitting, () => FlexMox(!st.transmitting))}
+                className={cn('flex-1 px-3 py-2.5 rounded-lg text-sm font-extrabold tracking-wide border-2 transition-all disabled:opacity-30',
+                  st.transmitting ? 'bg-rose-600 text-white border-rose-600 shadow-[0_0_14px] shadow-rose-600/50' : 'bg-card text-rose-700 border-rose-400 hover:bg-rose-50')}>
+                <Power className="size-4 inline mr-1 -mt-0.5" /> MOX
+              </button>
+            </div>
+
+            <div className="border-t border-border/60 pt-3 space-y-3">
+              <div className="flex items-center gap-2">
+                <Chip on={st.proc_enable} disabled={off} label="PROC" accent="violet"
+                  onClick={() => change('proc_enable', !st.proc_enable, () => FlexSetProcessor(!st.proc_enable))} />
+                <Segmented value={String(st.proc_level)} options={PROC} disabled={off || !st.proc_enable}
+                  onChange={(v) => change('proc_level', parseInt(v, 10), () => FlexSetProcessorLevel(parseInt(v, 10)))} />
+                <span className="flex-1" />
+              </div>
+              <LevelRow label="VOX" on={st.vox_enable} disabled={off} value={st.vox_level} sliderAccent="#16a34a"
+                onToggle={() => change('vox_enable', !st.vox_enable, () => FlexSetVox(!st.vox_enable))}
+                onLevel={(v) => change('vox_level', v, () => FlexSetVoxLevel(v))} />
+              <div className="flex items-center gap-2">
+                <span className="w-14 shrink-0 text-[11px] font-bold text-muted-foreground pl-0.5">VOX Dly</span>
+                <Slider value={st.vox_delay} disabled={off || !st.vox_enable} accent="#16a34a"
+                  onChange={(v) => change('vox_delay', v, () => FlexSetVoxDelay(v))} />
+                <span className="w-8 text-right text-xs font-mono tabular-nums text-muted-foreground">{st.vox_delay}</span>
+              </div>
+              <LevelRow label="MON" on={st.mon} disabled={off} value={st.mon_level} accent="cyan" sliderAccent="#0891b2"
+                onToggle={() => change('mon', !st.mon, () => FlexSetMon(!st.mon))}
+                onLevel={(v) => change('mon_level', v, () => FlexSetMonLevel(v))} />
+              <div className="flex items-center gap-2">
+                <span className="w-14 shrink-0 text-[11px] font-bold text-muted-foreground">MIC</span>
+                <Slider value={st.mic_level} disabled={off} accent="#2563eb" onChange={(v) => change('mic_level', v, () => FlexSetMic(v))} />
+                <span className="w-8 text-right text-xs font-mono tabular-nums text-muted-foreground">{st.mic_level}</span>
+              </div>
+            </div>
+          </Card>
+
+          {/* RECEIVE */}
+          <Card icon={AudioLines} title="Receive (active slice)" accent="#0891b2">
+            <div className="flex items-center gap-2">
+              <span className="w-14 shrink-0 text-[11px] font-bold text-muted-foreground">AGC</span>
+              <Segmented value={(st.agc_mode || 'med').toLowerCase()} options={AGC} disabled={rxOff}
+                onChange={(v) => change('agc_mode', v, () => FlexSetAGCMode(v))} />
+            </div>
+            <div className="flex items-center gap-2">
+              <span className="w-14 shrink-0 text-[11px] font-bold text-muted-foreground">Thresh</span>
+              <Slider value={st.agc_threshold} disabled={rxOff} accent="#64748b" onChange={(v) => change('agc_threshold', v, () => FlexSetAGCThreshold(v))} />
+              <span className="w-8 text-right text-xs font-mono tabular-nums text-muted-foreground">{st.agc_threshold}</span>
+            </div>
+            <div className="flex items-center gap-2">
+              <span className="w-14 shrink-0 text-[11px] font-bold text-muted-foreground">AF</span>
+              <Slider value={st.audio_level} disabled={rxOff} accent="#16a34a" onChange={(v) => change('audio_level', v, () => FlexSetAudioLevel(v))} />
+              <span className="w-8 text-right text-xs font-mono tabular-nums text-muted-foreground">{st.audio_level}</span>
+            </div>
+            <div className="border-t border-border/60 pt-3 space-y-3">
+              <LevelRow label="NB" on={st.nb} disabled={rxOff} value={st.nb_level} accent="amber" sliderAccent="#d97706"
+                onToggle={() => change('nb', !st.nb, () => FlexSetNB(!st.nb))}
+                onLevel={(v) => change('nb_level', v, () => FlexSetNBLevel(v))} />
+              <LevelRow label="NR" on={st.nr} disabled={rxOff} value={st.nr_level} accent="cyan" sliderAccent="#0891b2"
+                onToggle={() => change('nr', !st.nr, () => FlexSetNR(!st.nr))}
+                onLevel={(v) => change('nr_level', v, () => FlexSetNRLevel(v))} />
+              <LevelRow label="ANF" on={st.anf} disabled={rxOff} value={st.anf_level} accent="violet" sliderAccent="#7c3aed"
+                onToggle={() => change('anf', !st.anf, () => FlexSetANF(!st.anf))}
+                onLevel={(v) => change('anf_level', v, () => FlexSetANFLevel(v))} />
+            </div>
+          </Card>
+        </div>
+
+        {/* ATU */}
+        <Card icon={Settings2} title="Antenna Tuner">
+          <div className="flex items-center gap-2 flex-wrap">
+            <button type="button" disabled={off} onClick={() => FlexATUStart().catch(() => {})}
+              className="px-3 py-1.5 rounded-md text-xs font-bold border border-emerald-400 text-emerald-700 hover:bg-emerald-50 disabled:opacity-30">
+              <Antenna className="size-3.5 inline mr-1 -mt-0.5" /> Tune ATU
+            </button>
+            <button type="button" disabled={off} onClick={() => FlexATUBypass().catch(() => {})}
+              className="px-3 py-1.5 rounded-md text-xs font-bold border border-border text-muted-foreground hover:bg-muted disabled:opacity-30">
+              Bypass
+            </button>
+            <Chip on={st.atu_memories} disabled={off} label="MEM"
+              onClick={() => change('atu_memories', !st.atu_memories, () => FlexSetATUMemories(!st.atu_memories))} />
+            <div className="flex-1" />
+            {st.atu_status && (
+              <span className="text-xs font-mono text-muted-foreground">{st.atu_status.replace(/_/g, ' ')}</span>
+            )}
+          </div>
+        </Card>
+
+        {/* External amplifier (PowerGenius XL) — only when detected. */}
+        {st.amp_available && (
+          <Card icon={Flame} title={`Amplifier${st.amp_model ? ' · ' + st.amp_model : ''}`} accent="#ea580c">
+            <div className="flex items-center gap-3">
+              <button type="button" disabled={off}
+                onClick={() => change('amp_operate', !st.amp_operate, () => FlexAmpOperate(!st.amp_operate))}
+                className={cn('px-4 py-2 rounded-lg text-sm font-extrabold tracking-wide border-2 transition-all disabled:opacity-30',
+                  st.amp_operate ? 'bg-orange-600 text-white border-orange-600 shadow-[0_0_14px] shadow-orange-600/50' : 'bg-card text-orange-700 border-orange-400 hover:bg-orange-50')}>
+                {st.amp_operate ? 'OPERATE' : 'STANDBY'}
+              </button>
+              <span className="text-xs text-muted-foreground">
+                {st.amp_operate ? 'Amplifier is in line (transmitting through PA).' : 'Amplifier bypassed (standby).'}
+              </span>
+              <div className="flex-1" />
+              {st.amp_fault && st.amp_fault !== 'NONE' && (
+                <span className="px-2 py-1 rounded bg-rose-100 text-rose-800 text-xs font-bold">FAULT: {st.amp_fault}</span>
+              )}
+            </div>
+            <p className="text-[11px] text-muted-foreground">Amplifier power / SWR / temperature appear in the Meters panel below (src AMP).</p>
+          </Card>
+        )}
+
+        {/* Live meters (UDP VITA-49 stream) */}
+        <Card icon={Gauge} title="Meters">
+          {(() => {
+            const meters = st.meters || [];
+            if (off || meters.length === 0) {
+              return <p className="text-[11px] text-muted-foreground text-center py-2">No meters yet — waiting for the radio's UDP stream…</p>;
+            }
+            const isDbm = (m?: Meter) => !!m && /dbm/i.test(m.unit || '');
+            const dbmToW = (d: number) => Math.pow(10, (d - 30) / 10);
+            // Radio meters (exclude the amplifier's, which we show separately).
+            const radio = (name: string) => meters.find((m) =>
+              (m.name || '').toUpperCase().includes(name) && !(m.src || '').toUpperCase().includes('AMP'));
+            const sig = radio('LEVEL') || radio('SIGNAL');
+            const fwd = radio('FWDPWR');
+            const swr = radio('SWR');
+            const alc = radio('ALC');
+            const temp = radio('PATEMP');
+            const volts = radio('13.8B') || meters.find((m) => /volts/i.test(m.unit || '') && !(m.src || '').toUpperCase().includes('AMP'));
+            const amp = meters.filter((m) => (m.src || '').toUpperCase().includes('AMP')
+              && !/^(RL|DRV)$/i.test((m.name || '').trim()));
+            const accentFor = (m: Meter) => /swr/i.test(`${m.unit}${m.name}`) ? '#dc2626'
+              : /temp|degc|degf/i.test(`${m.unit}${m.name}`) ? '#ea580c'
+              : /volt/i.test(m.unit || '') ? '#2563eb' : '#16a34a';
+            // S-meter: dBm → S-units (S9 = -73 dBm on HF, 6 dB per unit).
+            const sUnit = (dbm: number) => {
+              const s = (dbm + 127) / 6; // S0 = -127 dBm
+              if (s >= 9) {
+                const over = Math.round(dbm + 73); // dB over S9
+                return { display: over > 0 ? `S9+${over}` : 'S9', bar: s };
+              }
+              return { display: `S${Math.max(0, Math.round(s))}`, bar: Math.max(0, s) };
+            };
+            const cur = [
+              sig && (() => { const s = sUnit(sig.value); return (
+                <MeterBar key="s" label="S-METER" value={s.bar} lo={0} hi={19} accent="#16a34a" display={s.display} extra={`${sig.value.toFixed(1)} dBm`}
+                  segColor={(fr) => { const sv = fr * 19; return sv < 9 ? '#16a34a' : sv < 14 ? '#f59e0b' : '#dc2626'; }} />
+              ); })(),
+              fwd && <MeterBar key="p" label="PWR" unit="W" lo={0} hi={120} accent="#dc2626"
+                value={isDbm(fwd) ? dbmToW(fwd.value) : fwd.value} extra={isDbm(fwd) ? `${fwd.value.toFixed(1)} dBm` : undefined} />,
+              swr && <MeterBar key="w" label="SWR" value={swr.value} unit="" lo={1} hi={3} accent="#d97706" />,
+              alc && <MeterBar key="a" label="ALC" value={alc.value} unit={alc.unit} lo={alc.lo} hi={alc.hi || 100} accent="#7c3aed" />,
+              temp && <MeterBar key="t" label="PA TEMP" value={temp.value} unit={temp.unit} lo={temp.lo || 0} hi={temp.hi || 80} accent="#ea580c" />,
+              volts && <MeterBar key="v" label="VOLTS" value={volts.value} unit={volts.unit} lo={volts.lo || 0} hi={volts.hi || 15} accent="#2563eb" />,
+            ].filter(Boolean);
+            return (
+              <>
+                <div className="grid grid-cols-2 sm:grid-cols-3 gap-2">{cur}</div>
+                {amp.length > 0 && (
+                  <div className="border-t border-border/60 pt-2 mt-1">
+                    <div className="text-[10px] font-bold tracking-wider text-muted-foreground mb-1.5">AMPLIFIER</div>
+                    <div className="grid grid-cols-2 sm:grid-cols-3 gap-2">
+                      {amp.map((m) => {
+                        if (/fwd|pwr/i.test(m.name || '') && isDbm(m)) {
+                          return <MeterBar key={m.id} label={m.name || `AMP ${m.id}`} value={dbmToW(m.value)} unit="W" lo={0} hi={1500} accent="#dc2626" extra={`${m.value.toFixed(1)} dBm`} />;
+                        }
+                        return <MeterBar key={m.id} label={m.name || `AMP ${m.id}`} value={m.value} unit={m.unit} lo={m.lo} hi={m.hi} accent={accentFor(m)} />;
+                      })}
+                    </div>
+                  </div>
+                )}
+              </>
+            );
+          })()}
+        </Card>
+      </div>
+    </div>
+  );
+}

frontend/src/components/MainMap.tsx

@@ -14,22 +14,15 @@ function saveMapView(m: L.Map) {
   writeUiPref('opslog.mapView', JSON.stringify({ lat: c.lat, lon: c.lng, zoom: m.getZoom() }));
 }
 
-// MainMap — Log4OM-style dual map for the Main tab:
+// The Main tab is built from two independent map panes that the operator can
-//  • Left: a world map with the great-circle path drawn from the operator to
+// place on either side (Settings → Main view):
-//    the contacted station, plus distance + short/long-path azimuth.
+//  • WorldMap   ("map1"): a world map with the great-circle path from the
-//  • Right: a street map zoomed onto the contacted station's grid locator.
+//    operator to the contacted station, distance, short/long-path azimuth and
+//    the antenna beam lobe.
+//  • LocatorMap ("map2"): a street map zoomed onto the contacted station's grid.
 // Built on Leaflet + free OSM/Carto tiles (no API key). Endpoints use
 // circleMarkers / divIcons so we don't depend on Leaflet's image assets.
 
-interface Props {
-  fromGrid: string;   // operator grid (active profile)
-  toGrid: string;     // contacted-station grid
-  fromLabel?: string; // operator callsign
-  toLabel?: string;   // DX callsign
-  beamAzimuths?: number[];     // antenna heading(s) (deg) → draw a beam lobe each
-  beamWidth?: number;          // beamwidth (deg), default 30
-}
-
 // unwrapLon makes a lat/lon ring continuous in longitude (each point within
 // 180° of the previous) so a polygon crossing the antimeridian doesn't snap
 // across the whole map. Coords may exceed ±180; Leaflet (worldCopyJump) is fine.
@@ -53,6 +46,24 @@ const OSM = 'https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png';
 const CARTO_ATTR = '© OpenStreetMap © CARTO';
 const OSM_ATTR = '© OpenStreetMap contributors';
 
+// 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';
+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' },
+  street:    { label: 'Street',    url: OSM, attr: OSM_ATTR },
+  satellite: { label: 'Satellite', url: 'https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}',
+               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 {
+  const v = localStorage.getItem('opslog.mapBasemap');
+  return v === 'voyager' || v === 'street' || v === 'satellite' ? v : 'light';
+}
+
 function dot(color: string): L.DivIcon {
   return L.divIcon({
     className: '',
@@ -62,14 +73,24 @@ function dot(color: string): L.DivIcon {
   });
 }
 
-export function MainMap({ fromGrid, toGrid, fromLabel, toLabel, beamAzimuths, beamWidth }: Props) {
+interface WorldProps {
+  fromGrid: string;   // operator grid (active profile)
+  toGrid: string;     // contacted-station grid
+  fromLabel?: string; // operator callsign
+  toLabel?: string;   // DX callsign
+  beamAzimuths?: number[];     // radiating heading(s) (deg) → draw a beam lobe each
+  beamWidth?: number;          // beamwidth (deg), default 30
+  boomAzimuth?: number | null; // mechanical boom (rotor) heading → grey reference line
+}
+
+// WorldMap — great-circle path + beam lobe(s), the "map1" pane.
+export function WorldMap({ fromGrid, toGrid, fromLabel, toLabel, beamAzimuths, beamWidth, boomAzimuth }: WorldProps) {
   const worldRef = useRef<HTMLDivElement>(null);
-  const locatorRef = useRef<HTMLDivElement>(null);
   const worldMap = useRef<L.Map | null>(null);
-  const locatorMap = useRef<L.Map | null>(null);
-  // Layers we add/remove as the QSO changes (kept separate from the basemap).
   const worldOverlay = useRef<L.LayerGroup | null>(null);
-  const locatorOverlay = useRef<L.LayerGroup | null>(null);
+  const baseLayer = useRef<L.TileLayer | null>(null);
+  const labelsLayer = useRef<L.TileLayer | null>(null);
+  const [basemap, setBasemap] = useState<BasemapKey>(loadBasemap);
 
   // Auto-zoom the world map to fit QTH→DX on each QSO. When off, the operator
   // pans/zooms freely (e.g. a whole-world view) and the view is remembered
@@ -83,100 +104,110 @@ export function MainMap({ fromGrid, toGrid, fromLabel, toLabel, beamAzimuths, be
     if (worldRef.current && !worldMap.current) {
       const m = L.map(worldRef.current, { zoomControl: true, attributionControl: true, worldCopyJump: true })
         .setView([20, 0], 1);
-      L.tileLayer(CARTO_LIGHT, { attribution: CARTO_ATTR, subdomains: 'abcd', maxZoom: 19 }).addTo(m);
+      const bm = BASEMAPS[basemap];
+      baseLayer.current = L.tileLayer(bm.url, { attribution: bm.attr, subdomains: bm.subdomains ?? 'abc', maxZoom: 19 }).addTo(m);
+      if (bm.labelsUrl) labelsLayer.current = L.tileLayer(bm.labelsUrl, { maxZoom: 19 }).addTo(m);
       worldOverlay.current = L.layerGroup().addTo(m);
       worldMap.current = m;
-      // Restore the saved free-pan view when not auto-zooming.
       const sv = loadMapView();
       if (!autoZoomRef.current && sv) m.setView([sv.lat, sv.lon], sv.zoom);
-      // Remember the view as the user pans/zooms (only meaningful when free).
       m.on('moveend', () => { if (!autoZoomRef.current) saveMapView(m); });
     }
-    if (locatorRef.current && !locatorMap.current) {
+    const t = window.setTimeout(() => { worldMap.current?.invalidateSize(); }, 80);
-      const m = L.map(locatorRef.current, { zoomControl: true, attributionControl: true })
-        .setView([20, 0], 2);
-      L.tileLayer(OSM, { attribution: OSM_ATTR, maxZoom: 19 }).addTo(m);
-      locatorOverlay.current = L.layerGroup().addTo(m);
-      locatorMap.current = m;
-    }
-    // The Main tab may have just become visible — fix tile sizing.
-    const t = window.setTimeout(() => {
-      worldMap.current?.invalidateSize();
-      locatorMap.current?.invalidateSize();
-    }, 80);
     return () => window.clearTimeout(t);
   }, []);
 
-  // Redraw overlays whenever the operator/DX grids change.
+  // Swap the basemap (and its optional place-name overlay) when the operator
+  // picks a different one. Vector overlays (path/beam) live in Leaflet's
+  // overlayPane, always above any tile layer, so nothing to re-stack there.
   useEffect(() => {
-    const wm = worldMap.current, lm = locatorMap.current;
+    const m = worldMap.current;
-    const wo = worldOverlay.current, lo = locatorOverlay.current;
+    if (!m) return;
-    if (!wm || !lm || !wo || !lo) return;
+    if (baseLayer.current) { m.removeLayer(baseLayer.current); baseLayer.current = null; }
+    if (labelsLayer.current) { m.removeLayer(labelsLayer.current); labelsLayer.current = null; }
+    const bm = BASEMAPS[basemap];
+    baseLayer.current = L.tileLayer(bm.url, { attribution: bm.attr, subdomains: bm.subdomains ?? 'abc', maxZoom: 19 }).addTo(m);
+    if (bm.labelsUrl) labelsLayer.current = L.tileLayer(bm.labelsUrl, { maxZoom: 19 }).addTo(m);
+  }, [basemap]);
+
+  // Redraw overlays whenever the operator/DX grids (or beam) change.
+  useEffect(() => {
+    const wm = worldMap.current, wo = worldOverlay.current;
+    if (!wm || !wo) return;
     wo.clearLayers();
-    lo.clearLayers();
 
     const from = gridToLatLon(fromGrid);
     const to = gridToLatLon(toGrid);
 
-    // ── Antenna beam lobe(s) (drawn first, under the arc/markers) ──
-    if (from && beamAzimuths && beamAzimuths.length) {
-      const half = (beamWidth ?? 30) / 2;
-      const D = 5500; // lobe length (km)
-      // A great circle pointing poleward runs to lat ±90, where Mercator is
-      // infinite — the line then snaps across the top of the map. Generate the
-      // radial with plenty of points (smooth curve) and STOP it just before the
-      // pole, so a north/south beam draws a clean line toward the edge instead.
-      const radial = (b: number): [number, number][] => {
-        const pts: [number, number][] = [];
-        const N = 64;
-        for (let i = 1; i <= N; i++) {
-          const d = destinationPoint(from.lat, from.lon, b, (D * i) / N);
-          pts.push([d.lat, d.lon]);
-          if (Math.abs(d.lat) > 86) break; // near a pole — stop before the snap
-        }
-        return pts;
-      };
-      for (const az of beamAzimuths) {
-        const arc: [number, number][] = [];
-        for (let b = az - half; b <= az + half + 0.001; b += 2) {
-          const d = destinationPoint(from.lat, from.lon, b, D);
-          arc.push([d.lat, d.lon]);
-        }
-        const ring = unwrapLon([
-          [from.lat, from.lon],
-          ...radial(az - half),
-          ...arc,
-          ...radial(az + half).reverse(),
-        ]);
-        // Near a pole the lobe's two edges diverge wildly (one runs NW, the
-        // other NE) and look broken on a Mercator map — so for a poleward beam
-        // show ONLY the clean boresight (below). Otherwise draw the filled lobe.
-        if (!ring.some(([la]) => Math.abs(la) > 78)) {
-          L.polygon(ring as L.LatLngExpression[], {
-            color: '#dc2626', weight: 1, opacity: 0.5, fillColor: '#dc2626', fillOpacity: 0.14,
-          }).addTo(wo);
-        }
-        // Boresight (dashed centre line) — always; great-circle polyline is safe.
-        const cl = unwrapLon([[from.lat, from.lon], ...radial(az)]);
-        L.polyline(cl as L.LatLngExpression[], { color: '#dc2626', weight: 1.5, opacity: 0.7, dashArray: '5 4' })
-          .bindTooltip(`Beam ${Math.round(az)}°`, { permanent: false, direction: 'top' }).addTo(wo);
-      }
-    }
-
-    // ── Left: world + great-circle arc ──
-    if (from) L.marker([from.lat, from.lon], { icon: dot('#059669'), title: fromLabel || 'Home' }).addTo(wo);
-    if (to) {
-      L.marker([to.lat, to.lon], { icon: dot('#dc2626'), title: toLabel || 'DX' })
-        .bindTooltip(toLabel || toGrid, { permanent: false, direction: 'top' }).addTo(wo);
-    }
     if (from && to) {
-      const pts = greatCirclePoints(from.lat, from.lon, to.lat, to.lon, 96);
+      L.marker([from.lat, from.lon], { icon: dot('#2563eb'), title: fromLabel || 'QTH' })
-      L.polyline(pts as L.LatLngExpression[], { color: '#dc2626', weight: 2, opacity: 0.9 }).addTo(wo);
+        .bindTooltip(`${fromLabel ? fromLabel + ' · ' : ''}${fromGrid.toUpperCase()}`, { permanent: false, direction: 'top' })
-      // Only re-frame the map when auto-zoom is on; otherwise keep the user's
+        .addTo(wo);
-      // chosen (remembered) view so the beam heading stays visible.
+      L.marker([to.lat, to.lon], { icon: dot('#dc2626'), title: toLabel || 'DX' })
+        .bindTooltip(`${toLabel ? toLabel + ' · ' : ''}${toGrid.toUpperCase()}`, { permanent: false, direction: 'top' })
+        .addTo(wo);
+      const pts = greatCirclePoints(from.lat, from.lon, to.lat, to.lon, 128);
+      // smoothFactor: 0 keeps every vertex (Leaflet otherwise simplifies the
+      // line, which makes a smooth arc look angular/bumpy).
+      L.polyline(unwrapLon(pts) as L.LatLngExpression[],
+        { color: '#2563eb', weight: 2, opacity: 0.85, smoothFactor: 0 }).addTo(wo);
+
+      // ── Antenna beam lobe(s) (drawn first, under the arc/markers) ──
+      if (beamAzimuths && beamAzimuths.length) {
+        const half = (beamWidth ?? 30) / 2;
+        const D = 5500; // lobe length (km)
+        // Great-circle radial out to distance D, stopping just short of the pole
+        // so a poleward line doesn't snap across the top of the Mercator map.
+        const radial = (b: number): [number, number][] => {
+          const out: [number, number][] = [];
+          const N = 64;
+          for (let i = 1; i <= N; i++) {
+            const d = destinationPoint(from.lat, from.lon, b, (D * i) / N);
+            out.push([d.lat, d.lon]);
+            if (Math.abs(d.lat) > 86) break; // near a pole — stop before the snap
+          }
+          return out;
+        };
+        for (const az of beamAzimuths) {
+          // Draw the lobe as a FAN of translucent great-circle radials, not a
+          // filled polygon: a polygon breaks badly near the poles on Mercator
+          // (its edges run off toward ±90° and the fill smears across the map),
+          // while each radial LINE stays clean. The overlapping lines read as a
+          // lobe — solid near the antenna, fanning out toward the front. Works
+          // for any azimuth, north/south included.
+          for (let b = az - half; b <= az + half + 0.001; b += 1.5) {
+            const line = unwrapLon([[from.lat, from.lon], ...radial(b)]);
+            L.polyline(line as L.LatLngExpression[], { color: '#ff2d2d', weight: 6, opacity: 0.12, smoothFactor: 0 }).addTo(wo);
+          }
+          const cl = unwrapLon([[from.lat, from.lon], ...radial(az)]);
+          // Dark casing under the boresight so the bright dashed line stays
+          // readable on any basemap (esp. dark satellite imagery). Same dashArray
+          // as the red line so the casing tracks each dash — otherwise the wide
+          // casing peeks through the gaps and the line looks bumpy.
+          L.polyline(cl as L.LatLngExpression[], { color: '#000', weight: 4, opacity: 0.4, dashArray: '5 4', smoothFactor: 0 }).addTo(wo);
+          L.polyline(cl as L.LatLngExpression[], { color: '#ff2d2d', weight: 2, opacity: 0.95, dashArray: '5 4', smoothFactor: 0 })
+            .bindTooltip(`Beam ${Math.round(az)}°`, { permanent: false, direction: 'top' }).addTo(wo);
+        }
+      }
+
+      // Mechanical boom (rotor) direction — thin grey dashed line. Drawn when the
+      // Ultrabeam radiates elsewhere (reverse/bi) so the boom heading stays visible
+      // next to the red radiating lobe(s).
+      if (boomAzimuth != null) {
+        const bpts: [number, number][] = [[from.lat, from.lon]];
+        const N = 64, D = 5500;
+        for (let i = 1; i <= N; i++) {
+          const d = destinationPoint(from.lat, from.lon, boomAzimuth, (D * i) / N);
+          bpts.push([d.lat, d.lon]);
+          if (Math.abs(d.lat) > 86) break;
+        }
+        L.polyline(unwrapLon(bpts) as L.LatLngExpression[], { color: '#64748b', weight: 1.5, opacity: 0.85, dashArray: '3 4', smoothFactor: 0 })
+          .bindTooltip(`Boom ${Math.round(boomAzimuth)}°`, { permanent: false, direction: 'top' }).addTo(wo);
+      }
+
       if (autoZoom) {
         const bounds = L.latLngBounds([[from.lat, from.lon], [to.lat, to.lon]]);
-        pts.forEach((p) => bounds.extend(p as L.LatLngExpression)); // include the arc
+        pts.forEach((p) => bounds.extend(p as L.LatLngExpression));
         wm.fitBounds(bounds, { padding: [30, 30], maxZoom: 6 });
       }
     } else if (autoZoom && to) {
@@ -184,8 +215,89 @@ export function MainMap({ fromGrid, toGrid, fromLabel, toLabel, beamAzimuths, be
     } else if (autoZoom && from) {
       wm.setView([from.lat, from.lon], 3);
     }
+    setTimeout(() => { wm.invalidateSize(); }, 0);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [fromGrid, toGrid, fromLabel, toLabel, (beamAzimuths ?? []).map((a) => Math.round(a)).join(','), beamWidth, boomAzimuth, autoZoom]);
 
-    // ── Right: street map on the DX locator ──
+  const path = pathBetween(fromGrid, toGrid);
+
+  return (
+    <div className="relative isolate h-full w-full rounded-lg overflow-hidden border border-border">
+      <div ref={worldRef} className="absolute inset-0" />
+      {/* Basemap picker — Light / Street / Satellite (key-free tiles). */}
+      <div className="absolute top-1 left-12 z-[500] flex rounded-md overflow-hidden shadow border border-border backdrop-blur">
+        {(Object.keys(BASEMAPS) as BasemapKey[]).map((k) => (
+          <button
+            key={k}
+            type="button"
+            onClick={() => { setBasemap(k); writeUiPref('opslog.mapBasemap', k); }}
+            title={`Basemap: ${BASEMAPS[k].label}`}
+            className={`px-2 py-1 text-[11px] font-medium transition-colors ${
+              basemap === k ? 'bg-primary text-primary-foreground' : 'bg-card/90 text-muted-foreground hover:bg-card'
+            }`}
+          >
+            {BASEMAPS[k].label}
+          </button>
+        ))}
+      </div>
+      {/* Auto-zoom toggle: on = frame QTH→DX each QSO; off = free pan/zoom
+          (remembered across restarts), so the beam heading stays visible. */}
+      <button
+        type="button"
+        onClick={() => {
+          const v = !autoZoom;
+          setAutoZoom(v);
+          writeUiPref('opslog.mapAutoZoomDX', v ? '1' : '0');
+          const m = worldMap.current;
+          if (!v && m) saveMapView(m);
+        }}
+        title={autoZoom ? 'Auto-zoom to DX is ON — click for free pan/zoom (remembered)' : 'Free pan/zoom — click to auto-zoom to the DX'}
+        className={`absolute top-1 right-1 z-[500] rounded-md px-2 py-1 text-[11px] font-medium shadow border backdrop-blur transition-colors ${
+          autoZoom ? 'bg-primary text-primary-foreground border-primary' : 'bg-card/90 text-muted-foreground border-border hover:bg-card'
+        }`}
+      >
+        Zoom DX
+      </button>
+      {path && (
+        <div className="absolute bottom-1 left-1 z-[500] rounded-md bg-card/90 backdrop-blur px-2 py-1 text-[11px] font-mono shadow border border-border pointer-events-none">
+          <div><span className="text-muted-foreground">Dist</span> {Math.round(path.distanceShort).toLocaleString()} km
+            <span className="text-muted-foreground"> · LP</span> {Math.round(path.distanceLong).toLocaleString()} km</div>
+          <div><span className="text-muted-foreground">Az SP</span> {Math.round(path.bearingShort)}°
+            <span className="text-muted-foreground"> · LP</span> {Math.round(path.bearingLong)}°</div>
+        </div>
+      )}
+    </div>
+  );
+}
+
+interface LocatorProps {
+  toGrid: string;     // contacted-station grid
+  toLabel?: string;   // DX callsign
+}
+
+// LocatorMap — street map zoomed onto the DX grid, the "map2" pane.
+export function LocatorMap({ toGrid, toLabel }: LocatorProps) {
+  const locatorRef = useRef<HTMLDivElement>(null);
+  const locatorMap = useRef<L.Map | null>(null);
+  const locatorOverlay = useRef<L.LayerGroup | null>(null);
+
+  useEffect(() => {
+    if (locatorRef.current && !locatorMap.current) {
+      const m = L.map(locatorRef.current, { zoomControl: true, attributionControl: true })
+        .setView([20, 0], 2);
+      L.tileLayer(OSM, { attribution: OSM_ATTR, maxZoom: 19 }).addTo(m);
+      locatorOverlay.current = L.layerGroup().addTo(m);
+      locatorMap.current = m;
+    }
+    const t = window.setTimeout(() => { locatorMap.current?.invalidateSize(); }, 80);
+    return () => window.clearTimeout(t);
+  }, []);
+
+  useEffect(() => {
+    const lm = locatorMap.current, lo = locatorOverlay.current;
+    if (!lm || !lo) return;
+    lo.clearLayers();
+    const to = gridToLatLon(toGrid);
     if (to) {
       L.marker([to.lat, to.lon], { icon: dot('#dc2626'), title: toLabel || 'DX' })
         .bindTooltip(`${toLabel ? toLabel + ' · ' : ''}${toGrid.toUpperCase()}`, { permanent: false, direction: 'top' })
@@ -195,57 +307,18 @@ export function MainMap({ fromGrid, toGrid, fromLabel, toLabel, beamAzimuths, be
         L.rectangle([[b.south, b.west], [b.north, b.east]], { color: '#dc2626', weight: 1, fillOpacity: 0.06 }).addTo(lo);
       }
       lm.setView([to.lat, to.lon], toGrid.trim().length >= 6 ? 9 : 7);
-    } else if (from) {
-      lm.setView([from.lat, from.lon], 5);
     }
-    setTimeout(() => { wm.invalidateSize(); lm.invalidateSize(); }, 0);
+    setTimeout(() => { lm.invalidateSize(); }, 0);
-    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [toGrid, toLabel]);
-  }, [fromGrid, toGrid, fromLabel, toLabel, (beamAzimuths ?? []).map((a) => Math.round(a)).join(','), beamWidth, autoZoom]);
-
-  const path = pathBetween(fromGrid, toGrid);
 
   return (
-    <div className="flex flex-col h-full min-h-0 gap-2 p-2">
+    <div className="relative isolate h-full w-full rounded-lg overflow-hidden border border-border">
-      <div className="grid grid-cols-2 gap-2 flex-1 min-h-0">
+      <div ref={locatorRef} className="absolute inset-0" />
-        <div className="relative isolate rounded-lg overflow-hidden border border-border">
+      {!gridToLatLon(toGrid) && (
-          <div ref={worldRef} className="absolute inset-0" />
+        <div className="absolute inset-0 z-[500] flex items-center justify-center text-xs text-muted-foreground bg-card/60 pointer-events-none">
-          {/* Auto-zoom toggle: on = frame QTH→DX each QSO; off = free pan/zoom
+          Enter a grid or look up the callsign to center the map.
-              (remembered across restarts), so the beam heading stays visible. */}
-          <button
-            type="button"
-            onClick={() => {
-              const v = !autoZoom;
-              setAutoZoom(v);
-              writeUiPref('opslog.mapAutoZoomDX', v ? '1' : '0');
-              const m = worldMap.current;
-              if (!v && m) saveMapView(m); // entering free mode → remember current view
-              // (turning it on re-frames via the redraw effect, which depends on autoZoom)
-            }}
-            title={autoZoom ? 'Auto-zoom to DX is ON — click for free pan/zoom (remembered)' : 'Free pan/zoom — click to auto-zoom to the DX'}
-            className={`absolute top-1 right-1 z-[500] rounded-md px-2 py-1 text-[11px] font-medium shadow border backdrop-blur transition-colors ${
-              autoZoom ? 'bg-primary text-primary-foreground border-primary' : 'bg-card/90 text-muted-foreground border-border hover:bg-card'
-            }`}
-          >
-            Zoom DX
-          </button>
-          {path && (
-            <div className="absolute bottom-1 left-1 z-[500] rounded-md bg-card/90 backdrop-blur px-2 py-1 text-[11px] font-mono shadow border border-border pointer-events-none">
-              <div><span className="text-muted-foreground">Dist</span> {Math.round(path.distanceShort).toLocaleString()} km
-                <span className="text-muted-foreground"> · LP</span> {Math.round(path.distanceLong).toLocaleString()} km</div>
-              <div><span className="text-muted-foreground">Az SP</span> {Math.round(path.bearingShort)}°
-                <span className="text-muted-foreground"> · LP</span> {Math.round(path.bearingLong)}°</div>
-            </div>
-          )}
         </div>
-        <div className="relative isolate rounded-lg overflow-hidden border border-border">
+      )}
-          <div ref={locatorRef} className="absolute inset-0" />
-          {!gridToLatLon(toGrid) && (
-            <div className="absolute inset-0 z-[500] flex items-center justify-center text-xs text-muted-foreground bg-card/60 pointer-events-none">
-              Enter a grid or look up the callsign to center the map.
-            </div>
-          )}
-        </div>
-      </div>
     </div>
   );
 }

frontend/src/components/RotorCompass.tsx

@@ -18,7 +18,9 @@ const GRATICULE = geoGraticule10();
 
 interface Props {
   bearing?: number | null;       // short-path azimuth to DX (deg)
-  headings: number[];            // antenna heading(s) — rotor + Ultrabeam pattern
+  headings: number[];            // radiating heading(s) — rotor + Ultrabeam pattern
+  boomHeading?: number | null;   // mechanical boom (rotor) azimuth, shown grey when it differs
+  pattern?: 'normal' | 'reverse' | 'bi' | null; // Ultrabeam pattern (for the badge)
   centerLat?: number | null;     // operator latitude (projection centre)
   centerLon?: number | null;     // operator longitude
   rotorEnabled?: boolean;
@@ -36,7 +38,7 @@ function pt(az: number, radius: number): [number, number] {
   return [C + radius * Math.cos(a), C + radius * Math.sin(a)];
 }
 
-export function RotorCompass({ bearing, headings, centerLat, centerLon, rotorEnabled, onGoto, onClose }: Props) {
+export function RotorCompass({ bearing, headings, boomHeading, pattern, centerLat, centerLon, rotorEnabled, onGoto, onClose }: Props) {
   const cardinals = useMemo(
     () => [ { d: 0, l: 'N' }, { d: 45, l: 'NE' }, { d: 90, l: 'E' }, { d: 135, l: 'SE' },
             { d: 180, l: 'S' }, { d: 225, l: 'SW' }, { d: 270, l: 'W' }, { d: 315, l: 'NW' } ],
@@ -76,6 +78,18 @@ export function RotorCompass({ bearing, headings, centerLat, centerLon, rotorEna
         <span className={cn('size-2 rounded-full', rotorEnabled ? 'bg-emerald-500' : 'bg-muted-foreground/40')}
           title={rotorEnabled ? 'Rotator connected' : 'Rotator disabled'} />
         <div className="flex-1" />
+        {pattern && (
+          <span
+            className={cn('px-1 py-px rounded text-[9px] font-bold tracking-wide',
+              pattern === 'reverse' ? 'bg-amber-200 text-amber-900'
+                : pattern === 'bi' ? 'bg-sky-200 text-sky-900'
+                : 'bg-emerald-200 text-emerald-900')}
+            title={pattern === 'reverse' ? 'Ultrabeam reversed — radiates opposite the boom'
+              : pattern === 'bi' ? 'Ultrabeam bidirectional — radiates both ways'
+              : 'Ultrabeam normal'}>
+            {pattern === 'reverse' ? 'REV' : pattern === 'bi' ? 'BI' : 'NORM'}
+          </span>
+        )}
         <span className="font-mono text-sm font-bold text-emerald-700 tabular-nums">
           {headLabel != null ? `${Math.round(headLabel).toString().padStart(3, '0')}°` : '—'}
         </span>
@@ -123,7 +137,21 @@ export function RotorCompass({ bearing, headings, centerLat, centerLon, rotorEna
             <circle cx={x} cy={y} r={3} fill="#dc2626" stroke="#fff" strokeWidth={1} />
           ); })()}
 
-          {/* antenna heading needle(s) — green; two when bidirectional */}
+          {/* mechanical boom (rotor) heading — grey dashed needle, shown when the
+              Ultrabeam radiates somewhere other than the boom (reverse/bi) so the
+              operator sees where the antenna physically points vs where it boom-sits */}
+          {boomHeading != null && pattern && pattern !== 'normal' && (() => {
+            const [x, y] = pt(boomHeading, MAP_R - 2);
+            return (
+              <g>
+                <title>Boom (rotor) {Math.round(boomHeading)}°</title>
+                <line x1={C} y1={C} x2={x} y2={y} stroke="#64748b" strokeWidth={2} strokeDasharray="3 3" strokeLinecap="round" />
+                <circle cx={x} cy={y} r={3} fill="#64748b" stroke="#fff" strokeWidth={1} />
+              </g>
+            );
+          })()}
+
+          {/* radiating heading needle(s) — green; two when bidirectional */}
           {headings.map((h, i) => { const [x, y] = pt(h, MAP_R - 2); return (
             <g key={i}>
               <line x1={C} y1={C} x2={x} y2={y} stroke="#15803d" strokeWidth={3} strokeLinecap="round" opacity={i === 0 ? 1 : 0.55} />

frontend/src/components/SettingsModal.tsx

@@ -29,11 +29,13 @@ import {
   GetDataDir,
   GetAutostartPrograms, SaveAutostartPrograms, BrowseExecutable, LaunchAutostartProgram,
   GetTelemetryEnabled, SetTelemetryEnabled,
+  GetLiveStatusEnabled, SetLiveStatusEnabled,
   GetQSLDefaults, SaveQSLDefaults,
   GetExternalServices, SaveExternalServices, TestQRZUpload, TestClublogUpload,
   GetPOTAToken, SavePOTAToken,
   TestLoTWUpload, ListTQSLStationLocations,
   ComputeStationInfo,
+  GetUIPref, SetUIPref,
 } from '../../wailsjs/go/main/App';
 import type { profile as profileModels } from '../../wailsjs/go/models';
 import type { LookupSettingsForm, StationSettingsForm, ListsSettingsForm, ModePresetForm } from '@/types';
@@ -136,6 +138,8 @@ interface Props {
   initialSection?: string;
   onClose: () => void;
   onSaved: () => void;
+  onMainPaneChanged?: (side: 'left' | 'right', value: string) => void; // live Main-view layout update
+  flexAvailable?: boolean; // CAT backend is FlexRadio → offer it as a Main pane
 }
 
 // Pretty little card showing what OpsLog will stamp on each QSO based on
@@ -445,6 +449,82 @@ function TelemetryToggle() {
   );
 }
 
+// LiveStatusToggle publishes this operator's current activity (call + band +
+// freq + mode) to the shared MySQL `live_status` table every ~15s, for multi-op
+// 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 [on, setOn] = useState(false);
+  const [loaded, setLoaded] = useState(false);
+  useEffect(() => {
+    GetLiveStatusEnabled().then((v) => setOn(!!v)).catch(() => {}).finally(() => setLoaded(true));
+  }, []);
+  return (
+    <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>
+    </label>
+  );
+}
+
+// MainViewPanes lets the operator choose what the Main tab's left and right
+// 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' },
+];
+function MainViewPanes({ onChanged, flexAvailable }: { onChanged?: (side: 'left' | 'right', value: string) => void; flexAvailable?: boolean }) {
+  const [left, setLeft] = useState('map1');
+  const [right, setRight] = useState('map2');
+  // FlexRadio is only offered when the CAT backend is a Flex.
+  const options = flexAvailable
+    ? [...MAIN_PANE_OPTIONS, { value: 'flex', label: 'FlexRadio controls' }]
+    : MAIN_PANE_OPTIONS;
+  useEffect(() => {
+    const valid = (v: string) => v === 'flex' || MAIN_PANE_OPTIONS.some((o) => o.value === v);
+    Promise.all([GetUIPref('mainPaneLeft').catch(() => ''), GetUIPref('mainPaneRight').catch(() => '')])
+      .then(([l, r]) => { if (valid(l)) setLeft(l); if (valid(r)) setRight(r); });
+  }, []);
+  const pick = (side: 'left' | 'right', v: string) => {
+    if (side === 'left') setLeft(v); else setRight(v);
+    // Persist (per-profile) AND tell the parent the new value directly, so the
+    // Main view updates from the chosen value — never a stale DB re-read.
+    SetUIPref(side === 'left' ? 'mainPaneLeft' : 'mainPaneRight', v).catch(() => {});
+    onChanged?.(side, v);
+  };
+  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>
+      <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>
+          <Select value={left} onValueChange={(v) => pick('left', v)}>
+            <SelectTrigger className="h-8 text-xs"><SelectValue /></SelectTrigger>
+            <SelectContent>
+              {options.map((o) => <SelectItem key={o.value} value={o.value}>{o.label}</SelectItem>)}
+            </SelectContent>
+          </Select>
+        </label>
+        <label className="flex flex-col gap-1 text-xs">
+          <span className="text-muted-foreground">Right pane</span>
+          <Select value={right} onValueChange={(v) => pick('right', v)}>
+            <SelectTrigger className="h-8 text-xs"><SelectValue /></SelectTrigger>
+            <SelectContent>
+              {options.map((o) => <SelectItem key={o.value} value={o.value}>{o.label}</SelectItem>)}
+            </SelectContent>
+          </Select>
+        </label>
+      </div>
+    </div>
+  );
+}
+
 // FlexDiscover scans the LAN for FlexRadio broadcasts and lets the user pick one
 // (fills the IP/port). Self-contained so it can own its state (rendered inside
 // the hook-less CATPanel).
@@ -495,7 +575,7 @@ function ComingSoon({ id, icon: Icon }: { id: SectionId; icon?: any }) {
   );
 }
 
-export function SettingsModal({ onClose, onSaved, initialSection }: Props) {
+export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChanged, flexAvailable }: Props) {
   const [selected, setSelected] = useState<SectionId>((initialSection as SectionId) || 'station');
   const [loading, setLoading] = useState(true);
   const [saving, setSaving] = useState(false);
@@ -3291,6 +3371,9 @@ export function SettingsModal({ onClose, onSaved, initialSection }: Props) {
             Check for updates at startup <span className="text-xs text-muted-foreground">(notifies when a newer OpsLog is published)</span>
           </label>
           <TelemetryToggle />
+          <LiveStatusToggle />
+
+          <MainViewPanes onChanged={onMainPaneChanged} flexAvailable={flexAvailable} />
 
           <div className="border-t border-border/60 pt-4 space-y-2">
             <h4 className="text-sm font-semibold text-foreground">Password encryption</h4>

frontend/src/lib/uiPref.ts

@@ -22,6 +22,8 @@ const PORTABLE_KEYS = [
   'opslog.mapAutoZoomDX', // Main map: auto-zoom to the DX (vs free pan/zoom)
   'opslog.mapView',       // Main map: remembered free-pan view (lat/lon/zoom)
   'opslog.lookupOnBlur',  // run the callsign lookup on blur instead of while typing
+  'opslog.clusterShowFilters', // cluster filter sidebar shown (tab + Main pane)
+  'opslog.mapBasemap',    // world map basemap (light / street / satellite)
 ];
 
 // syncPortablePrefs reconciles the DB with the local cache at startup:

frontend/src/version.ts

@@ -1,6 +1,6 @@
-// Single source of truth for the app version shown in the UI (header + About).
+// 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.11';
+export const APP_VERSION = '0.11.2';
 
-// Author / credits, shown in Help → About.
+// Author / credits, shown in Help -> About.
 export const APP_AUTHOR = 'F4BPO';

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

@@ -115,6 +115,56 @@ export function FilterFields():Promise<Array<string>>;
 
 export function FindQSOsForUpload(arg1:string,arg2:string):Promise<Array<qso.UploadRow>>;
 
+export function FlexATUBypass():Promise<void>;
+
+export function FlexATUStart():Promise<void>;
+
+export function FlexAmpOperate(arg1:boolean):Promise<void>;
+
+export function FlexMox(arg1:boolean):Promise<void>;
+
+export function FlexSetAGCMode(arg1:string):Promise<void>;
+
+export function FlexSetAGCThreshold(arg1:number):Promise<void>;
+
+export function FlexSetANF(arg1:boolean):Promise<void>;
+
+export function FlexSetANFLevel(arg1:number):Promise<void>;
+
+export function FlexSetATUMemories(arg1:boolean):Promise<void>;
+
+export function FlexSetAudioLevel(arg1:number):Promise<void>;
+
+export function FlexSetMic(arg1:number):Promise<void>;
+
+export function FlexSetMon(arg1:boolean):Promise<void>;
+
+export function FlexSetMonLevel(arg1:number):Promise<void>;
+
+export function FlexSetNB(arg1:boolean):Promise<void>;
+
+export function FlexSetNBLevel(arg1:number):Promise<void>;
+
+export function FlexSetNR(arg1:boolean):Promise<void>;
+
+export function FlexSetNRLevel(arg1:number):Promise<void>;
+
+export function FlexSetPower(arg1:number):Promise<void>;
+
+export function FlexSetProcessor(arg1:boolean):Promise<void>;
+
+export function FlexSetProcessorLevel(arg1:number):Promise<void>;
+
+export function FlexSetTunePower(arg1:number):Promise<void>;
+
+export function FlexSetVox(arg1:boolean):Promise<void>;
+
+export function FlexSetVoxDelay(arg1:number):Promise<void>;
+
+export function FlexSetVoxLevel(arg1:number):Promise<void>;
+
+export function FlexTune(arg1:boolean):Promise<void>;
+
 export function GetActiveProfile():Promise<profile.Profile>;
 
 export function GetAudioSettings():Promise<main.AudioSettings>;
@@ -163,8 +213,12 @@ export function GetEmailSettings():Promise<main.EmailSettings>;
 
 export function GetExternalServices():Promise<extsvc.ExternalServices>;
 
+export function GetFlexState():Promise<cat.FlexTXState>;
+
 export function GetListsSettings():Promise<main.ListsSettings>;
 
+export function GetLiveStatusEnabled():Promise<boolean>;
+
 export function GetLogFilePath():Promise<string>;
 
 export function GetLogbookRevision():Promise<string>;
@@ -313,6 +367,10 @@ export function RenderEQSL(arg1:number,arg2:number):Promise<string>;
 
 export function ReplaceAwardReferences(arg1:string,arg2:Array<awardref.Ref>):Promise<number>;
 
+export function ReportLiveActivity(arg1:number,arg2:string,arg3:string):Promise<void>;
+
+export function RescanAwards():Promise<void>;
+
 export function ResetAwardDefs():Promise<Array<award.Def>>;
 
 export function ResetDatabaseToDefault():Promise<void>;
@@ -395,6 +453,8 @@ export function SetCompactMode(arg1:boolean):Promise<void>;
 
 export function SetDVKLabel(arg1:number,arg2:string):Promise<void>;
 
+export function SetLiveStatusEnabled(arg1:boolean):Promise<void>;
+
 export function SetPassphrase(arg1:string):Promise<void>;
 
 export function SetTelemetryEnabled(arg1:boolean):Promise<void>;

frontend/wailsjs/go/main/App.js

@@ -202,6 +202,106 @@ export function FindQSOsForUpload(arg1, arg2) {
   return window['go']['main']['App']['FindQSOsForUpload'](arg1, arg2);
 }
 
+export function FlexATUBypass() {
+  return window['go']['main']['App']['FlexATUBypass']();
+}
+
+export function FlexATUStart() {
+  return window['go']['main']['App']['FlexATUStart']();
+}
+
+export function FlexAmpOperate(arg1) {
+  return window['go']['main']['App']['FlexAmpOperate'](arg1);
+}
+
+export function FlexMox(arg1) {
+  return window['go']['main']['App']['FlexMox'](arg1);
+}
+
+export function FlexSetAGCMode(arg1) {
+  return window['go']['main']['App']['FlexSetAGCMode'](arg1);
+}
+
+export function FlexSetAGCThreshold(arg1) {
+  return window['go']['main']['App']['FlexSetAGCThreshold'](arg1);
+}
+
+export function FlexSetANF(arg1) {
+  return window['go']['main']['App']['FlexSetANF'](arg1);
+}
+
+export function FlexSetANFLevel(arg1) {
+  return window['go']['main']['App']['FlexSetANFLevel'](arg1);
+}
+
+export function FlexSetATUMemories(arg1) {
+  return window['go']['main']['App']['FlexSetATUMemories'](arg1);
+}
+
+export function FlexSetAudioLevel(arg1) {
+  return window['go']['main']['App']['FlexSetAudioLevel'](arg1);
+}
+
+export function FlexSetMic(arg1) {
+  return window['go']['main']['App']['FlexSetMic'](arg1);
+}
+
+export function FlexSetMon(arg1) {
+  return window['go']['main']['App']['FlexSetMon'](arg1);
+}
+
+export function FlexSetMonLevel(arg1) {
+  return window['go']['main']['App']['FlexSetMonLevel'](arg1);
+}
+
+export function FlexSetNB(arg1) {
+  return window['go']['main']['App']['FlexSetNB'](arg1);
+}
+
+export function FlexSetNBLevel(arg1) {
+  return window['go']['main']['App']['FlexSetNBLevel'](arg1);
+}
+
+export function FlexSetNR(arg1) {
+  return window['go']['main']['App']['FlexSetNR'](arg1);
+}
+
+export function FlexSetNRLevel(arg1) {
+  return window['go']['main']['App']['FlexSetNRLevel'](arg1);
+}
+
+export function FlexSetPower(arg1) {
+  return window['go']['main']['App']['FlexSetPower'](arg1);
+}
+
+export function FlexSetProcessor(arg1) {
+  return window['go']['main']['App']['FlexSetProcessor'](arg1);
+}
+
+export function FlexSetProcessorLevel(arg1) {
+  return window['go']['main']['App']['FlexSetProcessorLevel'](arg1);
+}
+
+export function FlexSetTunePower(arg1) {
+  return window['go']['main']['App']['FlexSetTunePower'](arg1);
+}
+
+export function FlexSetVox(arg1) {
+  return window['go']['main']['App']['FlexSetVox'](arg1);
+}
+
+export function FlexSetVoxDelay(arg1) {
+  return window['go']['main']['App']['FlexSetVoxDelay'](arg1);
+}
+
+export function FlexSetVoxLevel(arg1) {
+  return window['go']['main']['App']['FlexSetVoxLevel'](arg1);
+}
+
+export function FlexTune(arg1) {
+  return window['go']['main']['App']['FlexTune'](arg1);
+}
+
 export function GetActiveProfile() {
   return window['go']['main']['App']['GetActiveProfile']();
 }
@@ -298,10 +398,18 @@ export function GetExternalServices() {
   return window['go']['main']['App']['GetExternalServices']();
 }
 
+export function GetFlexState() {
+  return window['go']['main']['App']['GetFlexState']();
+}
+
 export function GetListsSettings() {
   return window['go']['main']['App']['GetListsSettings']();
 }
 
+export function GetLiveStatusEnabled() {
+  return window['go']['main']['App']['GetLiveStatusEnabled']();
+}
+
 export function GetLogFilePath() {
   return window['go']['main']['App']['GetLogFilePath']();
 }
@@ -598,6 +706,14 @@ export function ReplaceAwardReferences(arg1, arg2) {
   return window['go']['main']['App']['ReplaceAwardReferences'](arg1, arg2);
 }
 
+export function ReportLiveActivity(arg1, arg2, arg3) {
+  return window['go']['main']['App']['ReportLiveActivity'](arg1, arg2, arg3);
+}
+
+export function RescanAwards() {
+  return window['go']['main']['App']['RescanAwards']();
+}
+
 export function ResetAwardDefs() {
   return window['go']['main']['App']['ResetAwardDefs']();
 }
@@ -762,6 +878,10 @@ export function SetDVKLabel(arg1, arg2) {
   return window['go']['main']['App']['SetDVKLabel'](arg1, arg2);
 }
 
+export function SetLiveStatusEnabled(arg1) {
+  return window['go']['main']['App']['SetLiveStatusEnabled'](arg1);
+}
+
 export function SetPassphrase(arg1) {
   return window['go']['main']['App']['SetPassphrase'](arg1);
 }

frontend/wailsjs/go/models.ts

@@ -385,6 +385,30 @@ export namespace awardref {
 
 export namespace cat {
 	
+	export class FlexMeter {
+	    id: number;
+	    src?: string;
+	    name?: string;
+	    unit?: string;
+	    value: number;
+	    lo: number;
+	    hi: number;
+	
+	    static createFrom(source: any = {}) {
+	        return new FlexMeter(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.id = source["id"];
+	        this.src = source["src"];
+	        this.name = source["name"];
+	        this.unit = source["unit"];
+	        this.value = source["value"];
+	        this.lo = source["lo"];
+	        this.hi = source["hi"];
+	    }
+	}
 	export class FlexRadio {
 	    ip: string;
 	    port: number;
@@ -407,6 +431,96 @@ export namespace cat {
 	        this.callsign = source["callsign"];
 	    }
 	}
+	export class FlexTXState {
+	    available: boolean;
+	    model?: string;
+	    rf_power: number;
+	    tune_power: number;
+	    tune: boolean;
+	    transmitting: boolean;
+	    vox_enable: boolean;
+	    vox_level: number;
+	    vox_delay: number;
+	    proc_enable: boolean;
+	    proc_level: number;
+	    mon: boolean;
+	    mon_level: number;
+	    mic_level: number;
+	    atu_status?: string;
+	    atu_memories: boolean;
+	    rx_avail: boolean;
+	    agc_mode?: string;
+	    agc_threshold: number;
+	    audio_level: number;
+	    nb: boolean;
+	    nb_level: number;
+	    nr: boolean;
+	    nr_level: number;
+	    anf: boolean;
+	    anf_level: number;
+	    amp_available: boolean;
+	    amp_model?: string;
+	    amp_operate: boolean;
+	    amp_fault?: string;
+	    meters?: FlexMeter[];
+	
+	    static createFrom(source: any = {}) {
+	        return new FlexTXState(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.available = source["available"];
+	        this.model = source["model"];
+	        this.rf_power = source["rf_power"];
+	        this.tune_power = source["tune_power"];
+	        this.tune = source["tune"];
+	        this.transmitting = source["transmitting"];
+	        this.vox_enable = source["vox_enable"];
+	        this.vox_level = source["vox_level"];
+	        this.vox_delay = source["vox_delay"];
+	        this.proc_enable = source["proc_enable"];
+	        this.proc_level = source["proc_level"];
+	        this.mon = source["mon"];
+	        this.mon_level = source["mon_level"];
+	        this.mic_level = source["mic_level"];
+	        this.atu_status = source["atu_status"];
+	        this.atu_memories = source["atu_memories"];
+	        this.rx_avail = source["rx_avail"];
+	        this.agc_mode = source["agc_mode"];
+	        this.agc_threshold = source["agc_threshold"];
+	        this.audio_level = source["audio_level"];
+	        this.nb = source["nb"];
+	        this.nb_level = source["nb_level"];
+	        this.nr = source["nr"];
+	        this.nr_level = source["nr_level"];
+	        this.anf = source["anf"];
+	        this.anf_level = source["anf_level"];
+	        this.amp_available = source["amp_available"];
+	        this.amp_model = source["amp_model"];
+	        this.amp_operate = source["amp_operate"];
+	        this.amp_fault = source["amp_fault"];
+	        this.meters = this.convertValues(source["meters"], FlexMeter);
+	    }
+	
+		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 RigState {
 	    enabled: boolean;
 	    connected: boolean;

internal/cat/cat.go

@@ -226,6 +226,115 @@ func (m *Manager) SendSpot(s SpotInfo) {
 	}
 }
 
+// FlexTXState is the FlexRadio transmit/ATU state surfaced to the dedicated
+// FlexRadio control tab. Levels are 0-100. (Phase 1: controls + state pushed by
+// the radio over TCP; live meters arrive over a separate UDP stream later.)
+type FlexTXState struct {
+	Available    bool   `json:"available"`    // backend is Flex and handshaked
+	Model        string `json:"model,omitempty"`
+	RFPower      int    `json:"rf_power"`
+	TunePower    int    `json:"tune_power"`
+	Tune         bool   `json:"tune"`         // tune carrier active
+	Transmitting bool   `json:"transmitting"` // interlock state = TRANSMITTING
+	VoxEnable    bool   `json:"vox_enable"`
+	VoxLevel     int    `json:"vox_level"`
+	VoxDelay     int    `json:"vox_delay"`
+	ProcEnable   bool   `json:"proc_enable"`
+	ProcLevel    int    `json:"proc_level"`
+	Mon          bool   `json:"mon"`
+	MonLevel     int    `json:"mon_level"`
+	MicLevel     int    `json:"mic_level"`
+	ATUStatus    string `json:"atu_status,omitempty"`
+	ATUMemories  bool   `json:"atu_memories"`
+	// Active RX slice DSP controls.
+	RXAvail      bool   `json:"rx_avail"` // an RX slice exists
+	AGCMode      string `json:"agc_mode,omitempty"`
+	AGCThreshold int    `json:"agc_threshold"`
+	AudioLevel   int    `json:"audio_level"`
+	NB           bool   `json:"nb"`
+	NBLevel      int    `json:"nb_level"`
+	NR           bool   `json:"nr"`
+	NRLevel      int    `json:"nr_level"`
+	ANF          bool   `json:"anf"`
+	ANFLevel     int    `json:"anf_level"`
+	// External amplifier (PowerGenius XL).
+	AmpAvailable bool   `json:"amp_available"`
+	AmpModel     string `json:"amp_model,omitempty"`
+	AmpOperate   bool   `json:"amp_operate"`
+	AmpFault     string `json:"amp_fault,omitempty"`
+	// Live meters streamed over UDP (S-meter, PWR, SWR, temp, voltage…).
+	Meters []FlexMeter `json:"meters,omitempty"`
+}
+
+// FlexMeter is one live meter value (already scaled to real units).
+type FlexMeter struct {
+	ID    int     `json:"id"`
+	Src   string  `json:"src,omitempty"`  // SLC / TX- / RAD / AMP…
+	Name  string  `json:"name,omitempty"` // FWDPWR, SWR, LEVEL, PATEMP…
+	Unit  string  `json:"unit,omitempty"`
+	Value float64 `json:"value"`
+	Lo    float64 `json:"lo"`
+	Hi    float64 `json:"hi"`
+}
+
+// FlexController is an OPTIONAL backend capability (the FlexRadio backend): the
+// SmartSDR-style transmit controls. Backends that don't implement it are skipped
+// by the FlexRadio tab. FlexState() is mutex-guarded in the backend so it's safe
+// to read off the CAT goroutine; the setters are dispatched onto it via FlexDo.
+type FlexController interface {
+	FlexState() FlexTXState
+	SetRFPower(int) error
+	SetTunePower(int) error
+	SetTune(bool) error
+	SetVOX(bool) error
+	SetVOXLevel(int) error
+	SetVOXDelay(int) error
+	SetProcessor(bool) error
+	SetProcessorLevel(int) error
+	SetMon(bool) error
+	SetMonLevel(int) error
+	SetMic(int) error
+	ATUStart() error
+	ATUBypass() error
+	SetATUMemories(bool) error
+	// RX slice DSP controls (target the active receive slice).
+	SetAGCMode(string) error
+	SetAGCThreshold(int) error
+	SetAudioLevel(int) error
+	SetNB(bool) error
+	SetNBLevel(int) error
+	SetNR(bool) error
+	SetNRLevel(int) error
+	SetANF(bool) error
+	SetANFLevel(int) error
+	// External amplifier (PowerGenius XL) operate/standby.
+	SetAmpOperate(bool) error
+}
+
+// FlexState returns the current FlexRadio transmit state, or (zero, false) when
+// the active backend isn't a Flex. Safe to call from any goroutine.
+func (m *Manager) FlexState() (FlexTXState, bool) {
+	m.mu.RLock()
+	b := m.backend
+	m.mu.RUnlock()
+	if fc, ok := b.(FlexController); ok {
+		return fc.FlexState(), true
+	}
+	return FlexTXState{}, false
+}
+
+// FlexDo dispatches a FlexRadio control onto the CAT goroutine. Errors if the
+// active backend isn't a Flex.
+func (m *Manager) FlexDo(fn func(FlexController) error) error {
+	return m.exec(func(b Backend) error {
+		fc, ok := b.(FlexController)
+		if !ok {
+			return fmt.Errorf("active CAT backend is not a FlexRadio")
+		}
+		return fn(fc)
+	})
+}
+
 // exec marshals a backend operation onto the CAT goroutine. Returns the
 // operation's error or a "busy"/"not running" error if dispatch failed.
 func (m *Manager) exec(fn func(Backend) error) error {

internal/cat/flex.go

@@ -4,6 +4,7 @@ package cat
 
 import (
 	"bufio"
+	"encoding/binary"
 	"fmt"
 	"math"
 	"net"
@@ -33,12 +34,27 @@ type Flex struct {
 	gotHandle bool
 
 	slices       map[int]*flexSlice
+	tx           flexTX // transmit/ATU state pushed by the radio (FlexRadio tab)
+	amp          flexAmp // external amplifier (PowerGenius XL) state
+	txSetAt      map[string]time.Time // status field → when WE last set it (ignore the radio's lagging echo briefly)
 	lastStateSig string // last logged derived-state signature (log only on change)
 
+	// Live meters streamed over UDP (VITA-49). meterMeta is the definitions
+	// pushed over TCP; meterVal the latest scaled values keyed by meter id.
+	udpConn    *net.UDPConn
+	meterMeta  map[int]meterInfo
+	meterVal   map[int]float64
+	meterSub   map[int]bool // ids we've already sent "sub meter <id>" for
+	meterLogAt time.Time    // throttle for value logging
+	vitaSeen   int          // count of UDP datagrams (first few logged for diag)
+	meterRawLogged bool     // log the first raw meter-definition status once
+	txRawLogged    bool     // log the first raw transmit status once (field-name audit)
+
 	spotsEnabled bool           // push cluster spots + manage the panadapter overlay
 	spotIdx      map[int]bool   // panadapter spot indices currently known to the radio
 	pendingSpot  map[int]string // seq → callsign, awaiting the spot index in the R response
 	spotCall     map[int]string // spot index → callsign (to fill the call on a panadapter click)
+	sentCmds     map[int]string // seq → command text, so an R<seq> error names the command
 
 	// OnSpotClick is called (off the reader goroutine's hot path) when the user
 	// clicks one of our spots on the panadapter, with the spot's callsign and
@@ -52,6 +68,54 @@ type flexSlice struct {
 	active bool
 	tx     bool
 	inUse  bool
+	// RX DSP controls (SmartSDR slice object).
+	agcMode      string // off | slow | med | fast
+	agcThreshold int    // 0-100
+	audioLevel   int    // 0-100 (RX volume)
+	nb           bool   // noise blanker
+	nbLevel      int
+	nr           bool   // noise reduction
+	nrLevel      int
+	anf          bool   // auto notch filter
+	anfLevel     int
+}
+
+// flexTX mirrors the radio's transmit/ATU/interlock objects (the SmartSDR-style
+// controls). Populated from status pushes in handleStatus; read by FlexState().
+type flexTX struct {
+	rfPower      int
+	tunePower    int
+	tune         bool
+	transmitting bool // interlock state == TRANSMITTING
+	voxEnable    bool
+	voxLevel     int
+	voxDelay     int
+	procEnable   bool
+	procLevel    int
+	mon          bool
+	monLevel     int
+	micLevel     int
+	atuStatus    string
+	atuMemories  bool
+}
+
+// flexAmp mirrors the external amplifier object (PowerGenius XL). handle is the
+// hex id used to address SET commands; operate=true means OPERATE (vs STANDBY).
+type flexAmp struct {
+	handle  string
+	model   string
+	operate bool
+	fault   string
+}
+
+// meterInfo is a meter definition pushed by the radio over TCP. unit drives the
+// raw-int16 → real-value scaling; src/name identify what it measures.
+type meterInfo struct {
+	src  string // SLC (slice), TX-, COD, RAD, AMP…
+	name string // FWDPWR, SWR, LEVEL, PATEMP, +13.8B…
+	unit string // dbm, dbfs, swr, volts, degc, watts…
+	lo   float64
+	hi   float64
 }
 
 // flexTriggerRe matches the radio's "spot <index> triggered" notification, sent
@@ -69,6 +133,8 @@ func NewFlex(host string, port int, spotsEnabled bool) *Flex {
 		host: strings.TrimSpace(host), port: port,
 		slices: map[int]*flexSlice{}, spotsEnabled: spotsEnabled,
 		spotIdx: map[int]bool{}, pendingSpot: map[int]string{}, spotCall: map[int]string{},
+		meterMeta: map[int]meterInfo{}, meterVal: map[int]float64{}, meterSub: map[int]bool{},
+		sentCmds: map[int]string{}, txSetAt: map[string]time.Time{},
 	}
 }
 
@@ -96,16 +162,21 @@ func (f *Flex) Connect() error {
 	f.conn = conn
 	f.gotHandle = false
 	f.slices = map[int]*flexSlice{}
+	f.meterVal = map[int]float64{}
+	f.meterSub = map[int]bool{}
 	f.mu.Unlock()
 	debugLog.Printf("Flex: connected to %s:%d", host, port)
 
 	go f.reader(conn)
 	// Identify ourselves in SmartSDR's client list, then stream slice + transmit
 	// (TX/split) status. Command names per the SmartSDR TCP/IP API docs.
-	f.send("client program=OpsLog")
+	f.send("client program OpsLog")
-	f.send("sub slice all")
+	f.send("sub slice all") // slice/receiver: freq, mode, AGC, NB/NR/ANF, audio…
-	f.send("sub transmit all")
+	f.send("sub tx all")    // transmit: rfpower, tunepower, vox, processor, mon, mic
-	f.send("sub radio all")
+	f.send("sub atu all")       // antenna-tuner status + memories
+	f.send("sub amplifier all") // external amplifier (PowerGenius XL) operate/standby
+	f.send("sub radio all")     // radio-wide incl. interlock (TX/RX state)
+	f.startMeters(conn)         // open the UDP VITA-49 stream for live meters
 	if f.spotsEnabled {
 		// Subscribe so the radio pushes existing spots (we learn their indices),
 		// then wipe the panadapter so stale spots from a previous session or
@@ -119,9 +190,14 @@ func (f *Flex) Connect() error {
 func (f *Flex) Disconnect() {
 	f.mu.Lock()
 	c := f.conn
+	uc := f.udpConn
 	f.conn = nil
+	f.udpConn = nil
 	f.gotHandle = false
 	f.mu.Unlock()
+	if uc != nil {
+		_ = uc.Close() // unblocks udpReader
+	}
 	if c != nil {
 		_ = c.Close()
 		debugLog.Printf("Flex: disconnected")
@@ -136,6 +212,9 @@ func (f *Flex) send(cmd string) int {
 	c := f.conn
 	f.seq++
 	seq := f.seq
+	if f.sentCmds != nil {
+		f.sentCmds[seq] = cmd
+	}
 	f.mu.Unlock()
 	if c == nil {
 		return 0
@@ -196,8 +275,12 @@ func (f *Flex) reader(conn net.Conn) {
 			}
 			seq, _ := strconv.Atoi(parts[0])
 			ok := parts[1] == "0" || parts[1] == "00000000"
+			f.mu.Lock()
+			cmdText := f.sentCmds[seq]
+			delete(f.sentCmds, seq)
+			f.mu.Unlock()
 			if !ok {
-				debugLog.Printf("Flex: cmd error %s", line)
+				debugLog.Printf("Flex: cmd error R%d code=%s cmd=%q", seq, parts[1], cmdText)
 			}
 			// A successful "spot add" returns the new spot's index in the message;
 			// pair it with the callsign we stashed under this seq.
@@ -239,8 +322,190 @@ func (f *Flex) handleStatus(payload string) {
 				}
 			}
 		}
+		// Transmit object — RF/tune power, VOX, speech processor, monitor, mic,
+		// tune carrier. Field names per the SmartSDR API (logged so the exact set
+		// is auditable against a real radio).
 		if len(fields) >= 1 && fields[0] == "transmit" {
+			if !f.txRawLogged {
+				f.txRawLogged = true
+				debugLog.Printf("Flex: FIRST transmit status: %s", payload)
+			}
 			debugLog.Printf("Flex: status %s", payload)
+			f.mu.Lock()
+			for _, kv := range fields[1:] {
+				key, val, ok := splitKV(kv)
+				if !ok {
+					continue
+				}
+				// Ignore the radio's echo of a field we just set ourselves (it
+				// often re-pushes the OLD value for ~1s, which snapped the slider
+				// back). Our optimistic value stands until the guard expires.
+				if t, ok := f.txSetAt[key]; ok && time.Since(t) < 1200*time.Millisecond {
+					continue
+				}
+				switch key {
+				case "rfpower":
+					f.tx.rfPower = atoiDefault(val, f.tx.rfPower)
+				case "tunepower":
+					f.tx.tunePower = atoiDefault(val, f.tx.tunePower)
+				case "tune":
+					f.tx.tune = val == "1"
+				case "vox_enable":
+					f.tx.voxEnable = val == "1"
+				case "vox_level":
+					f.tx.voxLevel = atoiDefault(val, f.tx.voxLevel)
+				case "vox_delay":
+					f.tx.voxDelay = atoiDefault(val, f.tx.voxDelay)
+				case "speech_processor_enable":
+					f.tx.procEnable = val == "1"
+				case "speech_processor_level":
+					f.tx.procLevel = atoiDefault(val, f.tx.procLevel)
+				case "mon", "sb_monitor":
+					f.tx.mon = val == "1"
+				case "mon_gain_sb":
+					f.tx.monLevel = atoiDefault(val, f.tx.monLevel)
+				case "mic_level", "miclevel":
+					f.tx.micLevel = atoiDefault(val, f.tx.micLevel)
+				}
+			}
+			f.mu.Unlock()
+		}
+		// ATU object — auto-tuner status + memories.
+		if len(fields) >= 1 && fields[0] == "atu" {
+			debugLog.Printf("Flex: status %s", payload)
+			f.mu.Lock()
+			for _, kv := range fields[1:] {
+				key, val, ok := splitKV(kv)
+				if !ok {
+					continue
+				}
+				switch key {
+				case "status":
+					f.tx.atuStatus = val
+				case "memories_enabled":
+					f.tx.atuMemories = val == "1"
+				}
+			}
+			f.mu.Unlock()
+		}
+		// Interlock object — transmit state (RECEIVE / TRANSMITTING / …).
+		if len(fields) >= 1 && fields[0] == "interlock" {
+			f.mu.Lock()
+			for _, kv := range fields[1:] {
+				if key, val, ok := splitKV(kv); ok && key == "state" {
+					f.tx.transmitting = strings.EqualFold(val, "TRANSMITTING")
+				}
+			}
+			f.mu.Unlock()
+		}
+		// Amplifier object — "amplifier <handle> model=… operate=… …" (PowerGenius
+		// XL). The handle (hex) addresses the operate/standby SET command.
+		if len(fields) >= 2 && fields[0] == "amplifier" {
+			debugLog.Printf("Flex: status %s", payload)
+			f.mu.Lock()
+			if strings.HasPrefix(fields[1], "0x") {
+				f.amp.handle = fields[1]
+			}
+			removed := false
+			for _, kv := range fields[2:] {
+				if kv == "removed" || kv == "in_use=0" {
+					removed = true
+					continue
+				}
+				key, val, ok := splitKV(kv)
+				if !ok {
+					continue
+				}
+				switch key {
+				case "handle":
+					f.amp.handle = val
+				case "model":
+					f.amp.model = val
+				case "operate":
+					f.amp.operate = val == "1" || strings.EqualFold(val, "OPERATE")
+				case "mode":
+					f.amp.operate = strings.EqualFold(val, "OPERATE")
+				case "fault":
+					f.amp.fault = val
+				}
+			}
+			if removed {
+				f.amp = flexAmp{}
+			}
+			f.mu.Unlock()
+		}
+		// Meter definitions — "meter <num>.src=… <num>.nam=… <num>.unit=… …".
+		// The unit scales the UDP values, the name labels them; subscribe to each
+		// new id so the radio streams it.
+		if len(fields) >= 2 && fields[0] == "meter" {
+			if !f.meterRawLogged {
+				f.meterRawLogged = true
+				debugLog.Printf("Flex: meter status raw: %s", payload)
+			}
+			var newIDs []int
+			f.mu.Lock()
+			for _, tok := range fields[1:] {
+				// One meter per token; its fields are '#'-separated:
+				// "<n>.src=…#<n>.num=…#<n>.nam=…#<n>.low=…#<n>.hi=…#<n>.unit=…".
+				num := -1
+				var mi meterInfo
+				for _, sub := range strings.Split(tok, "#") {
+					key, val, ok := splitKV(sub)
+					if !ok {
+						continue
+					}
+					dot := strings.IndexByte(key, '.')
+					if dot <= 0 {
+						continue
+					}
+					n, err := strconv.Atoi(key[:dot])
+					if err != nil {
+						continue
+					}
+					num = n
+					switch key[dot+1:] {
+					case "src":
+						mi.src = val
+					case "nam":
+						mi.name = val
+					case "unit", "units":
+						mi.unit = val
+					case "low", "lo":
+						mi.lo = parseFloatDefault(val, mi.lo)
+					case "hi":
+						mi.hi = parseFloatDefault(val, mi.hi)
+					}
+				}
+				if num < 0 {
+					continue
+				}
+				old, seen := f.meterMeta[num]
+				if !seen {
+					newIDs = append(newIDs, num)
+				}
+				if mi.src != "" {
+					old.src = mi.src
+				}
+				if mi.name != "" {
+					old.name = mi.name
+				}
+				if mi.unit != "" {
+					old.unit = mi.unit
+				}
+				if mi.lo != 0 {
+					old.lo = mi.lo
+				}
+				if mi.hi != 0 {
+					old.hi = mi.hi
+				}
+				f.meterMeta[num] = old
+			}
+			f.mu.Unlock()
+			for _, id := range newIDs {
+				mi := f.meterMeta[id]
+				debugLog.Printf("Flex: meter def #%d %s/%s unit=%s → sub", id, mi.src, mi.name, mi.unit)
+				f.subscribeMeter(id)
+			}
 		}
 		// Spot status: "spot <index> …". Track the index so we can clear the
 		// panadapter, and log it verbatim — a click on a panadapter spot pushes a
@@ -299,6 +564,24 @@ func (f *Flex) handleStatus(payload string) {
 			s.tx = val == "1"
 		case "in_use":
 			s.inUse = val == "1"
+		case "agc_mode":
+			s.agcMode = val
+		case "agc_threshold":
+			s.agcThreshold = atoiDefault(val, s.agcThreshold)
+		case "audio_level":
+			s.audioLevel = atoiDefault(val, s.audioLevel)
+		case "nb":
+			s.nb = val == "1"
+		case "nb_level":
+			s.nbLevel = atoiDefault(val, s.nbLevel)
+		case "nr":
+			s.nr = val == "1"
+		case "nr_level":
+			s.nrLevel = atoiDefault(val, s.nrLevel)
+		case "anf":
+			s.anf = val == "1"
+		case "anf_level":
+			s.anfLevel = atoiDefault(val, s.anfLevel)
 		}
 	}
 	f.mu.Unlock()
@@ -547,6 +830,494 @@ func (f *Flex) SetPTT(on bool) error {
 	return nil
 }
 
+// splitKV splits a "key=value" token. ok is false when there's no '='.
+func splitKV(kv string) (key, val string, ok bool) {
+	eq := strings.IndexByte(kv, '=')
+	if eq <= 0 {
+		return "", "", false
+	}
+	return kv[:eq], kv[eq+1:], true
+}
+
+// atoiDefault parses an int (or a float like "20.0", truncated), else def.
+func atoiDefault(s string, def int) int {
+	s = strings.TrimSpace(s)
+	if n, err := strconv.Atoi(s); err == nil {
+		return n
+	}
+	if fl, err := strconv.ParseFloat(s, 64); err == nil {
+		return int(fl)
+	}
+	return def
+}
+
+func clampLevel(v int) int {
+	if v < 0 {
+		return 0
+	}
+	if v > 100 {
+		return 100
+	}
+	return v
+}
+
+// rxSliceLocked returns the active RX slice and its index (-1 when none), using
+// the same RX-selection rule as ReadState. Caller holds f.mu.
+func (f *Flex) rxSliceLocked() (int, *flexSlice) {
+	rx, _ := f.pickSlicesLocked()
+	if rx == nil {
+		return -1, nil
+	}
+	for i, s := range f.slices {
+		if s == rx {
+			return i, rx
+		}
+	}
+	return -1, rx
+}
+
+// FlexState returns a snapshot of the radio's transmit/ATU state plus the active
+// RX slice's DSP controls, for the FlexRadio control tab. Available is true once
+// the handshake has completed.
+func (f *Flex) FlexState() FlexTXState {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	st := FlexTXState{
+		Available:    f.gotHandle && f.conn != nil,
+		Model:        f.model,
+		RFPower:      f.tx.rfPower,
+		TunePower:    f.tx.tunePower,
+		Tune:         f.tx.tune,
+		Transmitting: f.tx.transmitting,
+		VoxEnable:    f.tx.voxEnable,
+		VoxLevel:     f.tx.voxLevel,
+		VoxDelay:     f.tx.voxDelay,
+		ProcEnable:   f.tx.procEnable,
+		ProcLevel:    f.tx.procLevel,
+		Mon:          f.tx.mon,
+		MonLevel:     f.tx.monLevel,
+		MicLevel:     f.tx.micLevel,
+		ATUStatus:    f.tx.atuStatus,
+		ATUMemories:  f.tx.atuMemories,
+	}
+	if _, rx := f.rxSliceLocked(); rx != nil {
+		st.RXAvail = true
+		st.AGCMode = rx.agcMode
+		st.AGCThreshold = rx.agcThreshold
+		st.AudioLevel = rx.audioLevel
+		st.NB = rx.nb
+		st.NBLevel = rx.nbLevel
+		st.NR = rx.nr
+		st.NRLevel = rx.nrLevel
+		st.ANF = rx.anf
+		st.ANFLevel = rx.anfLevel
+	}
+	if f.amp.handle != "" {
+		st.AmpAvailable = true
+		st.AmpModel = f.amp.model
+		st.AmpOperate = f.amp.operate
+		st.AmpFault = f.amp.fault
+	}
+	if len(f.meterVal) > 0 {
+		ids := make([]int, 0, len(f.meterVal))
+		for id := range f.meterVal {
+			ids = append(ids, id)
+		}
+		sort.Ints(ids) // stable order so the UI doesn't reshuffle each poll
+		for _, id := range ids {
+			mi := f.meterMeta[id]
+			st.Meters = append(st.Meters, FlexMeter{ID: id, Src: mi.src, Name: mi.name, Unit: mi.unit, Value: f.meterVal[id], Lo: mi.lo, Hi: mi.hi})
+		}
+	}
+	return st
+}
+
+// sendSlice sends a "slice s <rxIdx> <param>=<val>" to the active RX slice, and
+// optimistically updates our cached slice state — the radio doesn't reliably
+// echo every field back to the client that changed it (e.g. agc_mode), so
+// without this the UI would snap back to the stale value.
+func (f *Flex) sendSlice(param string, val any) error {
+	f.mu.Lock()
+	idx, rx := f.rxSliceLocked()
+	connected := f.conn != nil
+	if rx != nil {
+		switch param {
+		case "agc_mode":
+			rx.agcMode = fmt.Sprint(val)
+		case "agc_threshold":
+			rx.agcThreshold = toInt(val)
+		case "audio_level":
+			rx.audioLevel = toInt(val)
+		case "nb":
+			rx.nb = val == "1"
+		case "nb_level":
+			rx.nbLevel = toInt(val)
+		case "nr":
+			rx.nr = val == "1"
+		case "nr_level":
+			rx.nrLevel = toInt(val)
+		case "anf":
+			rx.anf = val == "1"
+		case "anf_level":
+			rx.anfLevel = toInt(val)
+		}
+	}
+	f.mu.Unlock()
+	if !connected {
+		return fmt.Errorf("flex: not connected")
+	}
+	if rx == nil || idx < 0 {
+		return fmt.Errorf("flex: no receive slice")
+	}
+	f.send(fmt.Sprintf("slice s %d %s=%v", idx, param, val))
+	return nil
+}
+
+// toInt coerces an int or numeric string to int (for the optimistic cache).
+func toInt(v any) int {
+	switch t := v.(type) {
+	case int:
+		return t
+	case string:
+		return atoiDefault(t, 0)
+	}
+	return 0
+}
+
+func (f *Flex) SetAGCMode(m string) error {
+	switch m {
+	case "off", "slow", "med", "fast":
+	default:
+		return fmt.Errorf("flex: invalid agc mode %q", m)
+	}
+	return f.sendSlice("agc_mode", m)
+}
+func (f *Flex) SetAGCThreshold(l int) error { return f.sendSlice("agc_threshold", clampLevel(l)) }
+func (f *Flex) SetAudioLevel(l int) error   { return f.sendSlice("audio_level", clampLevel(l)) }
+func (f *Flex) SetNB(on bool) error         { return f.sendSlice("nb", boolFlex(on)) }
+func (f *Flex) SetNBLevel(l int) error      { return f.sendSlice("nb_level", clampLevel(l)) }
+func (f *Flex) SetNR(on bool) error         { return f.sendSlice("nr", boolFlex(on)) }
+func (f *Flex) SetNRLevel(l int) error      { return f.sendSlice("nr_level", clampLevel(l)) }
+func (f *Flex) SetANF(on bool) error        { return f.sendSlice("anf", boolFlex(on)) }
+func (f *Flex) SetANFLevel(l int) error     { return f.sendSlice("anf_level", clampLevel(l)) }
+
+// connected reports whether the TCP link is up (commands are no-ops otherwise).
+func (f *Flex) connected() bool {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	return f.conn != nil
+}
+
+// --- FlexController controls (SmartSDR transmit object). ---
+//
+// txSet sends a command AND optimistically updates our cached transmit state.
+// The radio doesn't reliably echo a changed field back to the client that set
+// it, so without the optimistic update the UI would snap back to the stale
+// cached value (a real echo, e.g. a change from SmartSDR, still overrides it).
+// txSet sends a command, optimistically updates our cached transmit state, and
+// records `field` (the STATUS field name) so the radio's lagging echo of the old
+// value is ignored for a moment (see handleStatus) — otherwise the slider snaps
+// back. `field` may be "" for non-guarded commands.
+func (f *Flex) txSet(cmd, field string, apply func(*flexTX)) error {
+	f.mu.Lock()
+	connected := f.conn != nil
+	if connected && apply != nil {
+		apply(&f.tx)
+		if field != "" {
+			f.txSetAt[field] = time.Now()
+		}
+	}
+	f.mu.Unlock()
+	if !connected {
+		return fmt.Errorf("flex: not connected")
+	}
+	f.send(cmd)
+	return nil
+}
+
+func (f *Flex) SetRFPower(p int) error {
+	p = clampLevel(p)
+	return f.txSet(fmt.Sprintf("transmit set rfpower=%d", p), "rfpower", func(t *flexTX) { t.rfPower = p })
+}
+
+func (f *Flex) SetTunePower(p int) error {
+	p = clampLevel(p)
+	return f.txSet(fmt.Sprintf("transmit set tunepower=%d", p), "tunepower", func(t *flexTX) { t.tunePower = p })
+}
+
+func (f *Flex) SetTune(on bool) error {
+	cmd := "transmit tune off"
+	if on {
+		cmd = "transmit tune on"
+	}
+	return f.txSet(cmd, "tune", func(t *flexTX) { t.tune = on })
+}
+
+func (f *Flex) SetVOX(on bool) error {
+	return f.txSet("transmit set vox_enable="+boolFlex(on), "vox_enable", func(t *flexTX) { t.voxEnable = on })
+}
+
+func (f *Flex) SetVOXLevel(l int) error {
+	l = clampLevel(l)
+	return f.txSet(fmt.Sprintf("transmit set vox_level=%d", l), "vox_level", func(t *flexTX) { t.voxLevel = l })
+}
+
+// SetVOXDelay sets the VOX hang time (0-100, a percentage scale in SmartSDR).
+func (f *Flex) SetVOXDelay(l int) error {
+	l = clampLevel(l)
+	return f.txSet(fmt.Sprintf("transmit set vox_delay=%d", l), "vox_delay", func(t *flexTX) { t.voxDelay = l })
+}
+
+func (f *Flex) SetProcessor(on bool) error {
+	return f.txSet("transmit set speech_processor_enable="+boolFlex(on), "speech_processor_enable", func(t *flexTX) { t.procEnable = on })
+}
+
+// SetProcessorLevel sets the speech-processor preset: 0=NOR, 1=DX, 2=DX+ (NOT a
+// 0-100 level — per the SmartSDR transmit API).
+func (f *Flex) SetProcessorLevel(l int) error {
+	if l < 0 {
+		l = 0
+	}
+	if l > 2 {
+		l = 2
+	}
+	return f.txSet(fmt.Sprintf("transmit set speech_processor_level=%d", l), "speech_processor_level", func(t *flexTX) { t.procLevel = l })
+}
+
+func (f *Flex) SetMon(on bool) error {
+	return f.txSet("transmit set mon="+boolFlex(on), "mon", func(t *flexTX) { t.mon = on })
+}
+
+func (f *Flex) SetMonLevel(l int) error {
+	l = clampLevel(l)
+	return f.txSet(fmt.Sprintf("transmit set mon_gain_sb=%d", l), "mon_gain_sb", func(t *flexTX) { t.monLevel = l })
+}
+
+// SetMic sets the mic gain. The SET token is "miclevel" (one word) even though
+// the radio reports it back as "mic_level" in the transmit status.
+func (f *Flex) SetMic(l int) error {
+	l = clampLevel(l)
+	return f.txSet(fmt.Sprintf("transmit set miclevel=%d", l), "mic_level", func(t *flexTX) { t.micLevel = l })
+}
+
+func (f *Flex) ATUStart() error {
+	if !f.connected() {
+		return fmt.Errorf("flex: not connected")
+	}
+	f.send("atu start")
+	return nil
+}
+
+func (f *Flex) ATUBypass() error {
+	if !f.connected() {
+		return fmt.Errorf("flex: not connected")
+	}
+	f.send("atu bypass")
+	return nil
+}
+
+func (f *Flex) SetATUMemories(on bool) error {
+	return f.txSet("atu set memories_enabled="+boolFlex(on), "", func(t *flexTX) { t.atuMemories = on })
+}
+
+// SetAmpOperate switches the external amplifier between OPERATE (on=true) and
+// STANDBY. Needs the amplifier handle learned from its status push.
+func (f *Flex) SetAmpOperate(on bool) error {
+	f.mu.Lock()
+	handle := f.amp.handle
+	connected := f.conn != nil
+	if handle != "" {
+		f.amp.operate = on // optimistic (radio may not echo to us)
+	}
+	f.mu.Unlock()
+	if !connected {
+		return fmt.Errorf("flex: not connected")
+	}
+	if handle == "" {
+		return fmt.Errorf("flex: no amplifier detected")
+	}
+	f.send(fmt.Sprintf("amplifier set %s operate=%s", handle, boolFlex(on)))
+	return nil
+}
+
+func boolFlex(b bool) string {
+	if b {
+		return "1"
+	}
+	return "0"
+}
+
+// --- Live meters over UDP (VITA-49) ---
+
+// flexMeterClass is the VITA-49 packet class code FlexRadio uses for meter
+// extension packets. The payload is 32-bit words: upper 16 bits = meter id,
+// lower 16 bits = signed value (scaled per the meter's unit).
+const flexMeterClass = 0x8002
+
+// startMeters opens a UDP socket for the radio's VITA-49 realtime stream (sent
+// from the radio's :4991), tells the radio which local port to stream to, and
+// starts the reader. The socket is DIALED to radio:4991 and we send a "punch"
+// datagram + periodic keepalives so Windows Firewall accepts the inbound stream
+// (an unsolicited inbound UDP to our ephemeral port would otherwise be dropped).
+func (f *Flex) startMeters(conn net.Conn) {
+	raddr, err := net.ResolveUDPAddr("udp4", net.JoinHostPort(f.host, "4991"))
+	if err != nil {
+		debugLog.Printf("Flex: meters resolve %s:4991: %v", f.host, err)
+		return
+	}
+	// Unconnected socket: accept the stream from ANY source (the radio's source
+	// port can change across NAT), while we still punch/keepalive toward :4991.
+	uc, err := net.ListenUDP("udp4", &net.UDPAddr{IP: net.IPv4zero, Port: 0})
+	if err != nil {
+		debugLog.Printf("Flex: meters UDP listen failed: %v", err)
+		return
+	}
+	port := uc.LocalAddr().(*net.UDPAddr).Port
+	f.mu.Lock()
+	f.udpConn = uc
+	f.vitaSeen = 0
+	f.mu.Unlock()
+	f.send(fmt.Sprintf("client udpport %d", port)) // route VITA-49 to our port
+	f.send("sub meter all")                        // stream all meter values
+	_, _ = uc.WriteToUDP([]byte{0}, raddr)         // firewall/NAT punch
+	debugLog.Printf("Flex: meters UDP local=:%d punch→%s", port, raddr)
+	go f.udpReader(uc)
+	go f.udpKeepalive(uc, raddr)
+}
+
+func (f *Flex) udpReader(uc *net.UDPConn) {
+	buf := make([]byte, 16*1024)
+	for {
+		n, src, err := uc.ReadFromUDP(buf)
+		if err != nil {
+			return // socket closed on disconnect
+		}
+		f.mu.Lock()
+		f.vitaSeen++
+		seen := f.vitaSeen
+		f.mu.Unlock()
+		if seen <= 3 {
+			debugLog.Printf("Flex: UDP datagram #%d %d bytes from %s", seen, n, src)
+		}
+		f.parseVita(buf[:n], seen)
+	}
+}
+
+// udpKeepalive keeps the firewall/NAT mapping open by pinging the radio's :4991.
+func (f *Flex) udpKeepalive(uc *net.UDPConn, raddr *net.UDPAddr) {
+	t := time.NewTicker(10 * time.Second)
+	defer t.Stop()
+	for range t.C {
+		f.mu.Lock()
+		cur := f.udpConn
+		f.mu.Unlock()
+		if cur != uc {
+			return
+		}
+		if _, err := uc.WriteToUDP([]byte{0}, raddr); err != nil {
+			return
+		}
+	}
+}
+
+// parseVita decodes a VITA-49 datagram and, if it's a meter packet, updates the
+// cached meter values. Header flags are honoured so the payload offset is right.
+func (f *Flex) parseVita(p []byte, seen int) {
+	if len(p) < 4 {
+		return
+	}
+	w0 := binary.BigEndian.Uint32(p[0:4])
+	off := 4
+	pktType := (w0 >> 28) & 0xF
+	hasClass := (w0>>27)&0x1 == 1
+	tsi := (w0 >> 22) & 0x3
+	tsf := (w0 >> 20) & 0x3
+	if pktType == 0x1 || pktType == 0x3 { // packet types carrying a Stream ID
+		off += 4
+	}
+	var packetClass uint16
+	if hasClass {
+		if off+8 > len(p) {
+			return
+		}
+		packetClass = uint16(binary.BigEndian.Uint32(p[off+4 : off+8]))
+		off += 8
+	}
+	if tsi != 0 {
+		off += 4
+	}
+	if tsf != 0 {
+		off += 8
+	}
+	// Diagnostics: log the first few datagrams's parsed header so we can confirm
+	// the class code (in case 0x8002 / offsets differ on a real radio).
+	if seen <= 3 {
+		debugLog.Printf("Flex: VITA #%d len=%d type=%d class=0x%04x off=%d", seen, len(p), pktType, packetClass, off)
+	}
+	if packetClass != flexMeterClass || off > len(p) {
+		return
+	}
+	payload := p[off:]
+	f.mu.Lock()
+	for i := 0; i+4 <= len(payload); i += 4 {
+		id := int(binary.BigEndian.Uint16(payload[i : i+2]))
+		raw := int16(binary.BigEndian.Uint16(payload[i+2 : i+4]))
+		f.meterVal[id] = scaleMeter(raw, f.meterMeta[id].unit)
+	}
+	if time.Since(f.meterLogAt) > 5*time.Second { // throttled dump to validate names
+		f.meterLogAt = time.Now()
+		var b strings.Builder
+		for id, v := range f.meterVal {
+			mi := f.meterMeta[id]
+			fmt.Fprintf(&b, "%s=%.1f%s ", nonEmpty(mi.name, strconv.Itoa(id)), v, mi.unit)
+		}
+		debugLog.Printf("Flex: meters %s", strings.TrimSpace(b.String()))
+	}
+	f.mu.Unlock()
+}
+
+// scaleMeter converts the raw int16 to its real value per the meter's unit.
+func scaleMeter(raw int16, unit string) float64 {
+	switch strings.ToUpper(unit) {
+	case "DB", "DBM", "DBFS":
+		return float64(raw) / 128.0
+	case "VOLTS", "AMPS":
+		return float64(raw) / 256.0
+	case "DEGC", "DEGF", "TEMPC", "TEMPF":
+		return float64(raw) / 64.0
+	case "SWR":
+		return float64(raw) / 128.0 // raw 128 = SWR 1.0 at idle
+	default:
+		return float64(raw)
+	}
+}
+
+// subscribeMeter asks the radio to stream a meter's values (once per id).
+func (f *Flex) subscribeMeter(id int) {
+	f.mu.Lock()
+	if f.meterSub[id] || f.conn == nil {
+		f.mu.Unlock()
+		return
+	}
+	f.meterSub[id] = true
+	f.mu.Unlock()
+	f.send(fmt.Sprintf("sub meter %d", id))
+}
+
+func nonEmpty(s, def string) string {
+	if s == "" {
+		return def
+	}
+	return s
+}
+
+func parseFloatDefault(s string, def float64) float64 {
+	if v, err := strconv.ParseFloat(strings.TrimSpace(s), 64); err == nil {
+		return v
+	}
+	return def
+}
+
 // flexModeToADIF maps a Flex slice mode to a generic ADIF mode.
 func flexModeToADIF(m string) string {
 	switch strings.ToUpper(strings.TrimSpace(m)) {

internal/dxcc/dxcc_test.go

@@ -214,8 +214,8 @@ func TestNormalize(t *testing.T) {
 		"f4bpo":      "F4BPO",
 		" F4BPO ":    "F4BPO",
 		"F4BPO/P":    "F4BPO",
-		"F4BPO/MM":   "",      // maritime mobile → no DXCC entity
+		"F4BPO/MM":   "F4BPO", // maritime mobile → strip, keep home entity for the log
-		"F4BPO/AM":   "",      // aeronautical mobile → no DXCC entity
+		"F4BPO/AM":   "F4BPO", // aeronautical mobile → strip, keep home entity for the log
 		"F4BPO/M":    "F4BPO", // plain mobile keeps the home entity
 		"F4BPO/5":    "F5BPO", // "/5" re-homes to call area 5
 		"HD5MW/8":    "HD8MW", // "/8" → Galápagos call area (HD8)

livestatus.go

@@ -0,0 +1,175 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"hamlog/internal/applog"
+)
+
+// Live operator status — for multi-operator events on a SHARED MySQL logbook
+// (e.g. a special-event call like TM74FR with several ops on different bands).
+// Each OpsLog instance heartbeats its current activity (operator call + station
+// call + freq/band/mode from CAT) into a `live_status` table every ~15s. A tiny
+// web script on the operator's own server reads that table and renders a live
+// page/image that the QRZ.com bio can embed (`<img src=…>`). OpsLog only WRITES
+// to the DB — it is not a web server. Rows older than a couple of minutes are
+// "stale" (operator went offline); the web side ignores them.
+
+const keyLiveStatusEnabled = "livestatus.enabled"
+
+// GetLiveStatusEnabled reports whether this operator publishes live status.
+func (a *App) GetLiveStatusEnabled() bool {
+	if a.settings == nil {
+		return false
+	}
+	v, _ := a.settings.Get(a.ctx, keyLiveStatusEnabled)
+	return strings.TrimSpace(v) == "1"
+}
+
+// SetLiveStatusEnabled turns live-status publishing on or off (off also removes
+// this operator's row immediately).
+func (a *App) SetLiveStatusEnabled(on bool) error {
+	if a.settings == nil {
+		return fmt.Errorf("db not initialized")
+	}
+	val := "0"
+	if on {
+		val = "1"
+	}
+	if err := a.settings.Set(a.ctx, keyLiveStatusEnabled, val); err != nil {
+		return err
+	}
+	if on {
+		applog.Printf("livestatus: enabled (logbook backend=%q, mysql conn=%v)", a.dbBackend, a.logDb != nil)
+		go a.publishLiveStatus() // show up right away
+	} else {
+		a.clearLiveStatus()
+	}
+	return nil
+}
+
+// liveStatusLoop heartbeats the current activity while enabled. Started once at
+// startup; cheap no-op when disabled or not on MySQL.
+func (a *App) liveStatusLoop() {
+	defer func() { _ = recover() }() // never crash the app from here
+	applog.Printf("livestatus: loop started")
+	a.publishLiveStatus() // attempt immediately, don't wait the first tick
+	t := time.NewTicker(15 * time.Second)
+	defer t.Stop()
+	for range t.C {
+		a.publishLiveStatus()
+	}
+}
+
+// liveStatusActive reports whether publishing should run (MySQL logbook + on).
+func (a *App) liveStatusActive() bool {
+	return a.logDb != nil && a.dbBackend == "mysql" && a.GetLiveStatusEnabled()
+}
+
+// liveStatusOperator returns this instance's operator id (the operator callsign,
+// falling back to the station callsign for a single-op setup). The callsign and
+// operator live on the ACTIVE PROFILE (station_profiles table), NOT in the
+// settings KV — read them there.
+func (a *App) liveStatusOperator() (op, station string) {
+	if a.profiles == nil {
+		return "", ""
+	}
+	p, err := a.profiles.Active(a.ctx)
+	if err != nil {
+		return "", ""
+	}
+	station = strings.ToUpper(strings.TrimSpace(p.Callsign))
+	op = strings.ToUpper(strings.TrimSpace(p.Operator))
+	if op == "" {
+		op = station
+	}
+	return op, station
+}
+
+// ReportLiveActivity is called by the UI with the current entry-strip freq/band/
+// mode, used as a fallback for live status when the CAT isn't connected.
+func (a *App) ReportLiveActivity(freqHz int64, band, mode string) {
+	a.liveActMu.Lock()
+	a.liveFreqHz = freqHz
+	a.liveBand = strings.ToUpper(strings.TrimSpace(band))
+	a.liveMode = strings.ToUpper(strings.TrimSpace(mode))
+	a.liveActMu.Unlock()
+}
+
+// publishLiveStatus upserts this operator's current activity. Best effort, with
+// explicit logging so a silent no-op is diagnosable.
+func (a *App) publishLiveStatus() {
+	if a.logDb == nil || a.dbBackend != "mysql" {
+		return // not a MySQL logbook — nothing to do (silent, runs every 15s)
+	}
+	if !a.GetLiveStatusEnabled() {
+		return // disabled (silent)
+	}
+	op, station := a.liveStatusOperator()
+	if op == "" {
+		applog.Printf("livestatus: nothing published — no operator/callsign set (Settings → Station)")
+		return
+	}
+	var freqHz int64
+	var band, mode string
+	if a.cat != nil {
+		st := a.cat.State()
+		if st.Connected {
+			freqHz, band, mode = st.FreqHz, st.Band, st.Mode
+		}
+	}
+	// Fall back to whatever the entry strip last reported (so band/mode/freq are
+	// published even when the CAT isn't connected).
+	a.liveActMu.Lock()
+	if freqHz == 0 {
+		freqHz = a.liveFreqHz
+	}
+	if band == "" {
+		band = a.liveBand
+	}
+	if mode == "" {
+		mode = a.liveMode
+	}
+	a.liveActMu.Unlock()
+	if err := a.ensureLiveStatusTable(); err != nil {
+		applog.Printf("livestatus: CREATE TABLE failed: %v", err)
+		return
+	}
+	_, err := a.logDb.ExecContext(a.ctx,
+		"INSERT INTO live_status (operator, station, freq_hz, band, mode, updated_at) "+
+			"VALUES (?, ?, ?, ?, ?, UTC_TIMESTAMP()) "+
+			"ON DUPLICATE KEY UPDATE station=VALUES(station), freq_hz=VALUES(freq_hz), "+
+			"band=VALUES(band), mode=VALUES(mode), updated_at=UTC_TIMESTAMP()",
+		op, station, freqHz, band, mode)
+	if err != nil {
+		applog.Printf("livestatus: INSERT failed: %v", err)
+		return
+	}
+	applog.Printf("livestatus: published op=%s station=%s %dHz %s %s", op, station, freqHz, band, mode)
+}
+
+func (a *App) ensureLiveStatusTable() error {
+	_, err := a.logDb.ExecContext(a.ctx,
+		"CREATE TABLE IF NOT EXISTS live_status ("+
+			"operator VARCHAR(32) PRIMARY KEY, "+
+			"station VARCHAR(32), "+
+			"freq_hz BIGINT, "+
+			"band VARCHAR(16), "+
+			"mode VARCHAR(16), "+
+			"updated_at DATETIME)")
+	return err
+}
+
+// clearLiveStatus removes this operator's row (on disable / shutdown).
+func (a *App) clearLiveStatus() {
+	if a.logDb == nil || a.dbBackend != "mysql" {
+		return
+	}
+	op, _ := a.liveStatusOperator()
+	if op == "" {
+		return
+	}
+	_, _ = a.logDb.ExecContext(a.ctx, "DELETE FROM live_status WHERE operator=?", op)
+}

telemetry.go

@@ -1,4 +1,4 @@
-package main
+package main
 
 import (
 	"bytes"
@@ -13,15 +13,15 @@ import (
 	"hamlog/internal/applog"
 )
 
-// Anonymous usage telemetry — a once-a-day "app_opened" heartbeat to PostHog so
+// Anonymous usage telemetry - a once-a-day "app_opened" heartbeat to PostHog so
 // the OpsLog author can see how many people actively use it. Privacy by design:
 // only a random install ID + app version + OS are sent (no callsign, no QSO
 // data, no IP beyond what any HTTP request reveals). Users can disable it in
-// Preferences → General. See [[user-analytics-posthog]] notes in MEMORY.
+// Preferences -> General. See [[user-analytics-posthog]] notes in MEMORY.
 
 const (
 	// appVersion is stamped on every heartbeat (and could feed the About box).
-	appVersion = "0.11"
+	appVersion = "0.11.2"
 
 	// posthogHost is the PostHog ingestion endpoint. EU cloud by default; change
 	// to https://us.i.posthog.com for a US project.