chore: release v0.16.2

app.go

@@ -18,6 +18,7 @@ import (
 	"time"
 
 	"hamlog/internal/adif"
+	"hamlog/internal/alerts"
 	"hamlog/internal/antgenius"
 	"hamlog/internal/applog"
 	"hamlog/internal/audio"
@@ -415,6 +416,8 @@ type App struct {
 	netActive []*qso.QSO // on-air QSO drafts (transient negative ids), check-in order
 	netSeq    int64      // transient-id counter for on-air drafts (decrements: -1, -2, …)
 
+	alertStore *alerts.Store // DX-cluster spot alert rules (global JSON)
+
 	cwMu           sync.Mutex        // guards the CW decoder lifecycle
 	cwStop         chan struct{}     // stops the CW decoder capture loop; nil when off
 	cwDecoder      *cwdecode.Decoder // live decoder (for retargeting the pitch)
@@ -764,6 +767,8 @@ func (a *App) startup(ctx context.Context) {
 			if a.ctx != nil {
 				wruntime.EventsEmit(a.ctx, "cluster:spot", s)
 			}
+			// Fire any matching alert rules (sound / visual / e-mail).
+			a.evaluateAlerts(s)
 			// Mirror the spot onto the FlexRadio panadapter when enabled. The
 			// Color is left to the backend default for now — status-based
 			// colouring can be filled in here later (new entity / worked / …).
@@ -851,6 +856,13 @@ func (a *App) startup(ctx context.Context) {
 		a.netStore = ns
 	}
 
+	// DX-cluster spot alert rules (global JSON).
+	if as, err := alerts.Open(filepath.Join(a.dataDir, "alerts.json")); err != nil {
+		applog.Printf("alerts: open failed: %v", err)
+	} else {
+		a.alertStore = as
+	}
+
 	// Ultrabeam antenna: connect in the background if enabled.
 	a.startUltrabeam()
 	// Antenna Genius switch: connect in the background if enabled.
@@ -4262,6 +4274,136 @@ func (a *App) toast(msg string) {
 	}
 }
 
+// ── DX-cluster spot alerts ─────────────────────────────────────────────────
+
+const keyAlertEmailTo = "alerts.email_to" // where alert e-mails are sent (default: SMTP from)
+
+// ListAlertRules returns every alert rule.
+func (a *App) ListAlertRules() []alerts.Rule {
+	if a.alertStore == nil {
+		return nil
+	}
+	return a.alertStore.List()
+}
+
+// SaveAlertRule upserts a rule (empty id → create) and returns it.
+func (a *App) SaveAlertRule(r alerts.Rule) (alerts.Rule, error) {
+	if a.alertStore == nil {
+		return alerts.Rule{}, fmt.Errorf("alert store unavailable")
+	}
+	return a.alertStore.Save(r)
+}
+
+// DeleteAlertRule removes a rule by id.
+func (a *App) DeleteAlertRule(id string) error {
+	if a.alertStore == nil {
+		return fmt.Errorf("alert store unavailable")
+	}
+	return a.alertStore.Delete(id)
+}
+
+// GetAlertEmailTo returns the address alert e-mails go to (empty = use SMTP from).
+func (a *App) GetAlertEmailTo() string {
+	if a.settings == nil {
+		return ""
+	}
+	v, _ := a.settings.GetGlobal(a.ctx, keyAlertEmailTo)
+	return v
+}
+
+// SetAlertEmailTo stores the alert e-mail recipient.
+func (a *App) SetAlertEmailTo(addr string) error {
+	if a.settings == nil {
+		return fmt.Errorf("db not initialized")
+	}
+	return a.settings.SetGlobal(a.ctx, keyAlertEmailTo, strings.TrimSpace(addr))
+}
+
+// evaluateAlerts runs a spot through the rules and fires notifications for every
+// match (visual/sound via a frontend event, e-mail via SMTP). Cheap when no
+// rules exist; the worked-before check only runs for rules that opt into it and
+// already matched, so it's off the hot path.
+func (a *App) evaluateAlerts(s cluster.Spot) {
+	if a.alertStore == nil {
+		return
+	}
+	sp := alerts.Spot{
+		DXCall:    s.DXCall,
+		Band:      s.Band,
+		Mode:      alerts.InferMode(s.Comment, s.FreqHz),
+		Country:   s.Country,
+		Continent: s.Continent,
+		Spotter:   s.Spotter,
+	}
+	// The spotter's country/continent (cty.dat) — resolved lazily for Origin rules.
+	if a.dxcc != nil && s.Spotter != "" {
+		if m, ok := a.dxcc.Lookup(s.Spotter); ok && m.Entity != nil {
+			sp.SpotterCountry = m.Entity.Name
+			sp.SpotterContinent = m.Continent
+		}
+	}
+	matches := a.alertStore.Evaluate(sp, time.Now(), a.isWorkedBandMode)
+	for _, mt := range matches {
+		if a.ctx != nil && (mt.Rule.Visual || mt.Rule.Sound) {
+			wruntime.EventsEmit(a.ctx, "alert:fired", map[string]any{
+				"rule":    mt.Rule.Name,
+				"call":    s.DXCall,
+				"band":    s.Band,
+				"mode":    sp.Mode,
+				"freq_hz": s.FreqHz,
+				"country": s.Country,
+				"comment": s.Comment,
+				"sound":   mt.Rule.Sound,
+				"visual":  mt.Rule.Visual,
+			})
+		}
+		if mt.Rule.Email {
+			go a.sendAlertEmail(mt.Rule, s, sp.Mode)
+		}
+	}
+}
+
+// isWorkedBandMode reports whether the exact callsign is already logged on the
+// given band+mode (used by rules with "skip worked before").
+func (a *App) isWorkedBandMode(call, band, mode string) bool {
+	if a.qso == nil || strings.TrimSpace(call) == "" {
+		return false
+	}
+	rows, err := a.qso.List(a.ctx, qso.ListFilter{Callsign: call, Band: band, Mode: mode, Limit: 5})
+	if err != nil {
+		return false
+	}
+	call = strings.ToUpper(strings.TrimSpace(call))
+	for _, q := range rows {
+		if strings.ToUpper(strings.TrimSpace(q.Callsign)) == call {
+			return true
+		}
+	}
+	return false
+}
+
+// sendAlertEmail notifies the operator by e-mail that a wanted station was
+// spotted. Best effort; requires SMTP configured (E-mail settings).
+func (a *App) sendAlertEmail(r alerts.Rule, s cluster.Spot, mode string) {
+	es, _ := a.GetEmailSettings()
+	to := strings.TrimSpace(a.GetAlertEmailTo())
+	if to == "" {
+		to = strings.TrimSpace(es.From)
+	}
+	if to == "" {
+		applog.Printf("alert: e-mail skipped (no recipient / SMTP from) for rule %q", r.Name)
+		return
+	}
+	subject := fmt.Sprintf("OpsLog alert: %s spotted on %s", s.DXCall, s.Band)
+	body := fmt.Sprintf("Rule: %s\n\nCall: %s\nBand: %s\nMode: %s\nFreq: %.1f kHz\nCountry: %s\nSpotter: %s\nComment: %s\n",
+		r.Name, s.DXCall, s.Band, mode, float64(s.FreqHz)/1000, s.Country, s.Spotter, s.Comment)
+	if err := email.Send(a.emailConfig(es), to, subject, body, ""); err != nil {
+		applog.Printf("alert: e-mail to %s failed: %v", to, err)
+	} else {
+		applog.Printf("alert: e-mailed %s (rule %q) to %s", s.DXCall, r.Name, to)
+	}
+}
+
 // sanitizeFilename makes a callsign safe for a filename (slashes etc.).
 func sanitizeFilename(s string) string {
 	s = strings.ToUpper(strings.TrimSpace(s))

frontend/src/App.tsx

@@ -67,6 +67,7 @@ import { ClusterGrid } from '@/components/ClusterGrid';
 import { cleanSpotter, inferSpotMode, spotModeCategory, spotStatusKey } from '@/lib/spot';
 import { WorkedBeforeGrid } from '@/components/WorkedBeforeGrid';
 import { NetControlPanel } from '@/components/NetControlPanel';
+import { AlertsModal } from '@/components/AlertsModal';
 import { BulkEditModal } from '@/components/BulkEditModal';
 import { ChatPanel, type ChatMsg, type ChatPresence } from '@/components/ChatPopover';
 import { DetailsPanel, type DetailsState } from '@/components/DetailsPanel';
@@ -730,6 +731,8 @@ export default function App() {
   }
   const chatShown = chatOpen && chatAvailable;
 
+  const [alertsOpen, setAlertsOpen] = useState(false); // Alert management modal
+
   // NET Control tab — enabled from Tools (persisted; once on it's a tab like Cluster).
   const [netEnabled, setNetEnabled] = useState(() => localStorage.getItem('opslog.netEnabled') === '1');
   useEffect(() => { localStorage.setItem('opslog.netEnabled', netEnabled ? '1' : '0'); }, [netEnabled]);
@@ -1100,6 +1103,35 @@ export default function App() {
     return () => { off(); };
   }, [showToast]);
 
+  // DX-cluster spot alerts: a matched rule fires here. Play a beep (WebAudio, no
+  // asset needed — CSP-safe) and/or show a toast, per the rule's chosen actions.
+  useEffect(() => {
+    const off = EventsOn('alert:fired', (p: any) => {
+      if (p?.sound) {
+        try {
+          const AC = (window as any).AudioContext || (window as any).webkitAudioContext;
+          const ctx = new AC();
+          const beep = (freq: number, at: number, dur: number) => {
+            const o = ctx.createOscillator(); const g = ctx.createGain();
+            o.type = 'sine'; o.frequency.value = freq;
+            o.connect(g); g.connect(ctx.destination);
+            g.gain.setValueAtTime(0.0001, ctx.currentTime + at);
+            g.gain.exponentialRampToValueAtTime(0.25, ctx.currentTime + at + 0.01);
+            g.gain.exponentialRampToValueAtTime(0.0001, ctx.currentTime + at + dur);
+            o.start(ctx.currentTime + at); o.stop(ctx.currentTime + at + dur + 0.02);
+          };
+          beep(880, 0, 0.14); beep(1320, 0.16, 0.18); // two-tone chirp
+          window.setTimeout(() => ctx.close().catch(() => {}), 600);
+        } catch { /* audio blocked — ignore */ }
+      }
+      if (p?.visual) {
+        const call = String(p?.call ?? ''); const band = String(p?.band ?? ''); const rule = String(p?.rule ?? 'alert');
+        showToast(`🔔 ${rule}: ${call}${band ? ` on ${band}` : ''}${p?.country ? ` — ${p.country}` : ''}`);
+      }
+    });
+    return () => { off(); };
+  }, [showToast]);
+
   // Poll PstRotator for the live antenna heading (status bar). Cheap when the
   // rotator is disabled (the backend just reads settings and returns).
   useEffect(() => {
@@ -2209,6 +2241,7 @@ export default function App() {
       { type: 'item', label: cwEnabled ? '✓ CW decoder (RX audio)' : 'CW decoder (RX audio)', action: 'tools.cwdecoder' },
       { type: 'separator' },
       { type: 'item', label: netEnabled ? '✓ NET Control' : 'NET Control', action: 'tools.net' },
+      { type: 'item', label: 'Alert management…', action: 'tools.alerts' },
       { type: 'separator' },
       // Maintenance — bumped here while we only have one entry. Will move
       // to a Tools → Maintenance submenu once Clublog + LoTW refresh land.
@@ -2237,6 +2270,7 @@ export default function App() {
       case 'tools.dvk':         setDvkEnabled((v) => !v); break;
       case 'tools.cwdecoder':   toggleCwDecoder(); break;
       case 'tools.net':         setNetEnabled((v) => { const nv = !v; if (nv) setActiveTab('net'); return nv; }); break;
+      case 'tools.alerts':      setAlertsOpen(true); break;
       case 'tools.refreshCty':  refreshCtyDat(); break;
       case 'tools.downloadRefs': downloadRefs(); break;
       case 'help.about':        setShowAbout(true); break;
@@ -4101,6 +4135,10 @@ export default function App() {
         />
       )}
 
+      {alertsOpen && (
+        <AlertsModal onClose={() => setAlertsOpen(false)} bands={bands} modes={modes} countries={countries} />
+      )}
+
       <AutoEQSL
         onSent={(call) => showToast(`OpsLog QSL sent to ${call}`)}
         onError={(msg) => showToast(msg)}

frontend/src/components/AlertsModal.tsx

@@ -0,0 +1,256 @@
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { Bell, Plus, Trash2, Volume2, Mail, Eye, X, Search } from 'lucide-react';
+import {
+  Dialog, DialogContent, DialogHeader, DialogTitle, DialogDescription,
+} from '@/components/ui/dialog';
+import { Button } from '@/components/ui/button';
+import { Input } from '@/components/ui/input';
+import { Label } from '@/components/ui/label';
+import { Checkbox } from '@/components/ui/checkbox';
+import { Tabs, TabsList, TabsTrigger, TabsContent } from '@/components/ui/tabs';
+import { cn } from '@/lib/utils';
+import {
+  ListAlertRules, SaveAlertRule, DeleteAlertRule, GetAlertEmailTo, SetAlertEmailTo,
+} from '@/../wailsjs/go/main/App';
+import { alerts } from '@/../wailsjs/go/models';
+
+type Rule = alerts.Rule;
+
+const CONTINENTS = ['AF', 'AN', 'AS', 'EU', 'NA', 'OC', 'SA'];
+
+function emptyRule(): Rule {
+  return alerts.Rule.createFrom({
+    id: '', name: 'New alert', enabled: true,
+    calls: [], countries: [], continents: [], bands: [], modes: [],
+    spotter_call: '', spotter_continents: [], spotter_countries: [],
+    sound: true, visual: true, email: false, again_after_min: 0, skip_worked: false,
+  });
+}
+
+// MultiCheck — a scrollable checkbox list for a set of options with an optional
+// search box (used for the long country list). Empty selection = ALL.
+function MultiCheck({ options, selected, onToggle, searchable, height = 'h-52' }: {
+  options: string[]; selected: string[]; onToggle: (v: string) => void; searchable?: boolean; height?: string;
+}) {
+  const [q, setQ] = useState('');
+  const shown = useMemo(
+    () => (q ? options.filter((o) => o.toLowerCase().includes(q.toLowerCase())) : options),
+    [options, q],
+  );
+  const sel = new Set((selected ?? []).map((s) => s.toLowerCase()));
+  return (
+    <div className="rounded-md border border-border">
+      {searchable && (
+        <div className="flex items-center gap-1.5 px-2 py-1 border-b border-border/60">
+          <Search className="size-3 text-muted-foreground" />
+          <input className="flex-1 bg-transparent text-xs outline-none" placeholder="Filter…" value={q} onChange={(e) => setQ(e.target.value)} />
+        </div>
+      )}
+      <div className={cn('overflow-y-auto p-1', height)}>
+        {shown.map((o) => (
+          <label key={o} className="flex items-center gap-2 text-xs px-1.5 py-0.5 rounded hover:bg-accent/40 cursor-pointer">
+            <Checkbox checked={sel.has(o.toLowerCase())} onCheckedChange={() => onToggle(o)} />
+            <span className="truncate">{o}</span>
+          </label>
+        ))}
+        {shown.length === 0 && <div className="text-[11px] text-muted-foreground px-2 py-3 text-center">no match</div>}
+      </div>
+      <div className="px-2 py-1 border-t border-border/60 text-[10px] text-muted-foreground">
+        {(selected?.length ?? 0) === 0 ? 'none selected = ALL' : `${selected!.length} selected`}
+      </div>
+    </div>
+  );
+}
+
+export function AlertsModal({ onClose, bands, modes, countries }: {
+  onClose: () => void; bands: string[]; modes: string[]; countries: string[];
+}) {
+  const [rules, setRules] = useState<Rule[]>([]);
+  const [draft, setDraft] = useState<Rule | null>(null);
+  const [tab, setTab] = useState('def'); // active editor tab (reset to Definition on new/select)
+  const [emailTo, setEmailTo] = useState('');
+  const [err, setErr] = useState('');
+
+  const refresh = useCallback(async () => {
+    try { setRules(((await ListAlertRules()) ?? []) as Rule[]); }
+    catch (e: any) { setErr(String(e?.message ?? e)); }
+  }, []);
+  useEffect(() => { refresh(); GetAlertEmailTo().then((v) => setEmailTo(v || '')).catch(() => {}); }, [refresh]);
+
+  const patch = (p: Partial<Rule>) => setDraft((d) => (d ? alerts.Rule.createFrom({ ...d, ...p }) : d));
+  const toggleIn = (key: keyof Rule, v: string) => setDraft((d) => {
+    if (!d) return d;
+    const cur = ((d as any)[key] as string[]) ?? [];
+    const has = cur.some((x) => x.toLowerCase() === v.toLowerCase());
+    const next = has ? cur.filter((x) => x.toLowerCase() !== v.toLowerCase()) : [...cur, v];
+    return alerts.Rule.createFrom({ ...d, [key]: next });
+  });
+
+  async function save() {
+    if (!draft) return;
+    if (!draft.name.trim()) { setErr('Give the rule a name'); return; }
+    try { const saved = await SaveAlertRule(draft); await refresh(); setDraft(saved as Rule); setErr(''); }
+    catch (e: any) { setErr(String(e?.message ?? e)); }
+  }
+  async function del() {
+    if (!draft) return;
+    if (!draft.id) { setDraft(null); return; }
+    if (!window.confirm(`Delete alert "${draft.name}"?`)) return;
+    try { await DeleteAlertRule(draft.id); setDraft(null); await refresh(); }
+    catch (e: any) { setErr(String(e?.message ?? e)); }
+  }
+
+  return (
+    <Dialog open onOpenChange={(o) => { if (!o) onClose(); }}>
+      <DialogContent className="max-w-4xl">
+        <DialogHeader>
+          <DialogTitle className="flex items-center gap-2"><Bell className="size-4 text-primary" /> Alert management</DialogTitle>
+          <DialogDescription>Alert when a spot matches a rule. Empty filters = ANY; the filters you set are ANDed (e.g. France + 20m = French stations on 20m).</DialogDescription>
+        </DialogHeader>
+
+        <div className="flex gap-3 min-h-0 px-5" style={{ height: '60vh' }}>
+          {/* Rule list */}
+          <div className="w-56 shrink-0 flex flex-col border border-border rounded-md">
+            <div className="flex items-center gap-1 px-2 py-1.5 border-b border-border/60">
+              <span className="text-[11px] font-semibold uppercase tracking-wider text-muted-foreground flex-1">Rules</span>
+              <Button variant="ghost" size="sm" className="h-6 px-1.5" onClick={() => { setDraft(emptyRule()); setTab('def'); }}><Plus className="size-3.5" /></Button>
+            </div>
+            <div className="flex-1 overflow-y-auto p-1">
+              {rules.length === 0 && <div className="text-[11px] text-muted-foreground px-2 py-4 text-center">No rules yet — click +</div>}
+              {rules.map((r) => (
+                <button key={r.id} onClick={() => { setDraft(alerts.Rule.createFrom(r)); setTab('def'); }}
+                  className={cn('w-full text-left px-2 py-1.5 rounded text-xs flex items-center gap-1.5',
+                    draft?.id === r.id ? 'bg-accent text-accent-foreground font-semibold' : 'hover:bg-muted/60')}>
+                  <span className={cn('size-1.5 rounded-full shrink-0', r.enabled ? 'bg-emerald-500' : 'bg-muted-foreground/40')} />
+                  <span className="truncate flex-1">{r.name}</span>
+                  {r.sound && <Volume2 className="size-3 text-muted-foreground shrink-0" />}
+                  {r.email && <Mail className="size-3 text-muted-foreground shrink-0" />}
+                </button>
+              ))}
+            </div>
+            <div className="px-2 py-1.5 border-t border-border/60">
+              <Label className="text-[10px] text-muted-foreground">Alert e-mail to</Label>
+              <Input className="h-7 text-xs mt-0.5" placeholder="[email protected]" value={emailTo}
+                onChange={(e) => setEmailTo(e.target.value)}
+                onBlur={() => SetAlertEmailTo(emailTo).catch(() => {})} />
+            </div>
+          </div>
+
+          {/* Editor */}
+          <div className="flex-1 min-w-0 border border-border rounded-md flex flex-col">
+            {!draft ? (
+              <div className="flex-1 flex items-center justify-center text-sm text-muted-foreground">Select or create a rule.</div>
+            ) : (
+              <Tabs value={tab} onValueChange={setTab} className="flex flex-col flex-1 min-h-0">
+                <div className="flex items-center gap-2 px-2 pt-2">
+                  <TabsList>
+                    <TabsTrigger value="def">Definition</TabsTrigger>
+                    <TabsTrigger value="call">Call / DXCC</TabsTrigger>
+                    <TabsTrigger value="bm">Band / Mode</TabsTrigger>
+                    <TabsTrigger value="orig">Origin</TabsTrigger>
+                  </TabsList>
+                </div>
+
+                <div className="flex-1 min-h-0 overflow-y-auto p-3">
+                  <TabsContent value="def" className="mt-0 space-y-3">
+                    <div>
+                      <Label className="text-xs">Rule name</Label>
+                      <Input value={draft.name} onChange={(e) => patch({ name: e.target.value })} />
+                    </div>
+                    <label className="flex items-center gap-2 text-sm cursor-pointer">
+                      <Checkbox checked={draft.enabled} onCheckedChange={(c) => patch({ enabled: !!c })} /> Alert enabled
+                    </label>
+                    <div className="flex items-center gap-2">
+                      <Label className="text-xs w-40 shrink-0">Alert again after (min)</Label>
+                      <Input type="number" className="h-8 w-24" value={draft.again_after_min}
+                        onChange={(e) => patch({ again_after_min: parseInt(e.target.value) || 0 })} />
+                      <span className="text-[11px] text-muted-foreground">0 = once/session · -1 = always</span>
+                    </div>
+                    <div className="border-t border-border/60 pt-3 space-y-2">
+                      <Label className="text-xs font-semibold">Actions</Label>
+                      <div className="flex gap-4">
+                        <label className="flex items-center gap-1.5 text-sm cursor-pointer"><Checkbox checked={draft.visual} onCheckedChange={(c) => patch({ visual: !!c })} /><Eye className="size-3.5" /> Visual</label>
+                        <label className="flex items-center gap-1.5 text-sm cursor-pointer"><Checkbox checked={draft.sound} onCheckedChange={(c) => patch({ sound: !!c })} /><Volume2 className="size-3.5" /> Sound</label>
+                        <label className="flex items-center gap-1.5 text-sm cursor-pointer"><Checkbox checked={draft.email} onCheckedChange={(c) => patch({ email: !!c })} /><Mail className="size-3.5" /> E-mail</label>
+                      </div>
+                    </div>
+                    <label className="flex items-center gap-2 text-sm cursor-pointer border-t border-border/60 pt-3">
+                      <Checkbox checked={draft.skip_worked} onCheckedChange={(c) => patch({ skip_worked: !!c })} /> Skip calls already worked (same band + mode)
+                    </label>
+                  </TabsContent>
+
+                  <TabsContent value="call" className="mt-0 grid grid-cols-2 gap-3">
+                    <div className="space-y-1">
+                      <Label className="text-xs">Callsigns (one per line, wildcards: IW3*, */P)</Label>
+                      <textarea className="w-full h-52 rounded-md border border-border bg-background p-2 text-xs font-mono resize-none"
+                        placeholder={'DL1ABC\nIW3*\n*/P'}
+                        value={(draft.calls ?? []).join('\n')}
+                        onChange={(e) => patch({ calls: e.target.value.split('\n').map((x) => x.trim()).filter(Boolean) })} />
+                    </div>
+                    <div className="space-y-1">
+                      <Label className="text-xs">Countries (DXCC)</Label>
+                      <MultiCheck options={countries} selected={draft.countries ?? []} onToggle={(v) => toggleIn('countries', v)} searchable />
+                    </div>
+                    <div className="space-y-1 col-span-2">
+                      <Label className="text-xs">Continents</Label>
+                      <div className="flex gap-3 flex-wrap">
+                        {CONTINENTS.map((c) => (
+                          <label key={c} className="flex items-center gap-1.5 text-xs cursor-pointer">
+                            <Checkbox checked={(draft.continents ?? []).includes(c)} onCheckedChange={() => toggleIn('continents', c)} /> {c}
+                          </label>
+                        ))}
+                      </div>
+                    </div>
+                  </TabsContent>
+
+                  <TabsContent value="bm" className="mt-0 grid grid-cols-2 gap-3">
+                    <div className="space-y-1">
+                      <Label className="text-xs">Bands</Label>
+                      <MultiCheck options={bands} selected={draft.bands ?? []} onToggle={(v) => toggleIn('bands', v)} />
+                    </div>
+                    <div className="space-y-1">
+                      <Label className="text-xs">Modes</Label>
+                      <MultiCheck options={modes} selected={draft.modes ?? []} onToggle={(v) => toggleIn('modes', v)} />
+                    </div>
+                  </TabsContent>
+
+                  <TabsContent value="orig" className="mt-0 grid grid-cols-2 gap-3">
+                    <div className="space-y-1">
+                      <Label className="text-xs">Spotter callsign (wildcard)</Label>
+                      <Input className="font-mono" placeholder="e.g. F* or DL1ABC" value={draft.spotter_call ?? ''}
+                        onChange={(e) => patch({ spotter_call: e.target.value })} />
+                      <Label className="text-xs mt-2 block">Spotter continents</Label>
+                      <div className="flex gap-3 flex-wrap">
+                        {CONTINENTS.map((c) => (
+                          <label key={c} className="flex items-center gap-1.5 text-xs cursor-pointer">
+                            <Checkbox checked={(draft.spotter_continents ?? []).includes(c)} onCheckedChange={() => toggleIn('spotter_continents', c)} /> {c}
+                          </label>
+                        ))}
+                      </div>
+                    </div>
+                    <div className="space-y-1">
+                      <Label className="text-xs">Spotter countries</Label>
+                      <MultiCheck options={countries} selected={draft.spotter_countries ?? []} onToggle={(v) => toggleIn('spotter_countries', v)} searchable />
+                    </div>
+                  </TabsContent>
+                </div>
+
+                {/* Editor actions */}
+                <div className="flex items-center gap-2 px-3 py-2 border-t border-border/60">
+                  {err && <span className="text-[11px] text-rose-600 flex-1 truncate">{err}</span>}
+                  <div className="flex-1" />
+                  <Button variant="ghost" size="sm" className="text-rose-700" onClick={del}><Trash2 className="size-3.5" /> Delete</Button>
+                  <Button size="sm" onClick={save}>Save rule</Button>
+                </div>
+              </Tabs>
+            )}
+          </div>
+        </div>
+
+        <div className="flex justify-end px-5 pb-4">
+          <Button variant="outline" size="sm" onClick={onClose}><X className="size-3.5" /> Close</Button>
+        </div>
+      </DialogContent>
+    </Dialog>
+  );
+}

frontend/src/version.ts

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

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

@@ -12,6 +12,7 @@ import {cluster} from '../models';
 import {extsvc} from '../models';
 import {powergenius} from '../models';
 import {winkeyer} from '../models';
+import {alerts} from '../models';
 import {audio} from '../models';
 import {operating} from '../models';
 import {udp} from '../models';
@@ -88,6 +89,8 @@ export function DXCCForCountry(arg1:string):Promise<number>;
 
 export function DXCCName(arg1:number):Promise<string>;
 
+export function DeleteAlertRule(arg1:string):Promise<void>;
+
 export function DeleteAllQSO():Promise<number>;
 
 export function DeleteAwardReference(arg1:string,arg2:string):Promise<void>;
@@ -212,6 +215,8 @@ export function FlexTune(arg1:boolean):Promise<void>;
 
 export function GetActiveProfile():Promise<profile.Profile>;
 
+export function GetAlertEmailTo():Promise<string>;
+
 export function GetAntGeniusSettings():Promise<main.AntGeniusSettings>;
 
 export function GetAntGeniusStatus():Promise<antgenius.Status>;
@@ -354,6 +359,8 @@ export function LaunchAutostartProgram(arg1:string):Promise<main.AutostartLaunch
 
 export function LaunchAutostartPrograms():Promise<Array<main.AutostartLaunchResult>>;
 
+export function ListAlertRules():Promise<Array<alerts.Rule>>;
+
 export function ListAudioInputDevices():Promise<Array<audio.Device>>;
 
 export function ListAudioOutputDevices():Promise<Array<audio.Device>>;
@@ -512,6 +519,8 @@ export function RunBackupNow():Promise<string>;
 
 export function SaveADIFFile():Promise<string>;
 
+export function SaveAlertRule(arg1:alerts.Rule):Promise<alerts.Rule>;
+
 export function SaveAntGeniusSettings(arg1:main.AntGeniusSettings):Promise<void>;
 
 export function SaveAudioSettings(arg1:main.AudioSettings):Promise<void>;
@@ -574,6 +583,8 @@ export function SendEQSL(arg1:number,arg2:number,arg3:string):Promise<void>;
 
 export function SendQSORecordingEmail(arg1:number):Promise<void>;
 
+export function SetAlertEmailTo(arg1:string):Promise<void>;
+
 export function SetCATFrequency(arg1:number):Promise<void>;
 
 export function SetCATMode(arg1:string):Promise<void>;

frontend/wailsjs/go/main/App.js

@@ -142,6 +142,10 @@ export function DXCCName(arg1) {
   return window['go']['main']['App']['DXCCName'](arg1);
 }
 
+export function DeleteAlertRule(arg1) {
+  return window['go']['main']['App']['DeleteAlertRule'](arg1);
+}
+
 export function DeleteAllQSO() {
   return window['go']['main']['App']['DeleteAllQSO']();
 }
@@ -390,6 +394,10 @@ export function GetActiveProfile() {
   return window['go']['main']['App']['GetActiveProfile']();
 }
 
+export function GetAlertEmailTo() {
+  return window['go']['main']['App']['GetAlertEmailTo']();
+}
+
 export function GetAntGeniusSettings() {
   return window['go']['main']['App']['GetAntGeniusSettings']();
 }
@@ -674,6 +682,10 @@ export function LaunchAutostartPrograms() {
   return window['go']['main']['App']['LaunchAutostartPrograms']();
 }
 
+export function ListAlertRules() {
+  return window['go']['main']['App']['ListAlertRules']();
+}
+
 export function ListAudioInputDevices() {
   return window['go']['main']['App']['ListAudioInputDevices']();
 }
@@ -990,6 +1002,10 @@ export function SaveADIFFile() {
   return window['go']['main']['App']['SaveADIFFile']();
 }
 
+export function SaveAlertRule(arg1) {
+  return window['go']['main']['App']['SaveAlertRule'](arg1);
+}
+
 export function SaveAntGeniusSettings(arg1) {
   return window['go']['main']['App']['SaveAntGeniusSettings'](arg1);
 }
@@ -1114,6 +1130,10 @@ export function SendQSORecordingEmail(arg1) {
   return window['go']['main']['App']['SendQSORecordingEmail'](arg1);
 }
 
+export function SetAlertEmailTo(arg1) {
+  return window['go']['main']['App']['SetAlertEmailTo'](arg1);
+}
+
 export function SetCATFrequency(arg1) {
   return window['go']['main']['App']['SetCATFrequency'](arg1);
 }

frontend/wailsjs/go/models.ts

@@ -65,6 +65,53 @@ export namespace adif {
 
 }
 
+export namespace alerts {
+	
+	export class Rule {
+	    id: string;
+	    name: string;
+	    enabled: boolean;
+	    calls?: string[];
+	    countries?: string[];
+	    continents?: string[];
+	    bands?: string[];
+	    modes?: string[];
+	    spotter_call?: string;
+	    spotter_continents?: string[];
+	    spotter_countries?: string[];
+	    sound: boolean;
+	    visual: boolean;
+	    email: boolean;
+	    again_after_min: number;
+	    skip_worked: boolean;
+	
+	    static createFrom(source: any = {}) {
+	        return new Rule(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.id = source["id"];
+	        this.name = source["name"];
+	        this.enabled = source["enabled"];
+	        this.calls = source["calls"];
+	        this.countries = source["countries"];
+	        this.continents = source["continents"];
+	        this.bands = source["bands"];
+	        this.modes = source["modes"];
+	        this.spotter_call = source["spotter_call"];
+	        this.spotter_continents = source["spotter_continents"];
+	        this.spotter_countries = source["spotter_countries"];
+	        this.sound = source["sound"];
+	        this.visual = source["visual"];
+	        this.email = source["email"];
+	        this.again_after_min = source["again_after_min"];
+	        this.skip_worked = source["skip_worked"];
+	    }
+	}
+
+}
+
 export namespace antgenius {
 	
 	export class Antenna {

internal/alerts/alerts.go

@@ -0,0 +1,309 @@
+// Package alerts evaluates incoming DX-cluster spots against user-defined rules
+// and reports which rules fire, so the app can notify the operator (sound /
+// visual / e-mail) when a wanted station is spotted — like Log4OM's Alert
+// Management. Rules are persisted as JSON (global, machine-local).
+package alerts
+
+import (
+	"encoding/json"
+	"os"
+	"regexp"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+)
+
+// Rule is one alert definition. Every filter dimension is optional: an empty
+// list/string matches ANY value, and the dimensions are ANDed together, so a
+// rule with Countries=[France] and Bands=[20m] fires only for French stations
+// on 20m. Calls / SpotterCall accept wildcards (IW3*, */P).
+type Rule struct {
+	ID      string `json:"id"`
+	Name    string `json:"name"`
+	Enabled bool   `json:"enabled"`
+
+	// DX filters.
+	Calls      []string `json:"calls,omitempty"`      // wildcard patterns on the DX call
+	Countries  []string `json:"countries,omitempty"`  // DXCC entity names
+	Continents []string `json:"continents,omitempty"` // AF/AN/AS/EU/NA/OC/SA
+
+	// Band / mode filters.
+	Bands []string `json:"bands,omitempty"`
+	Modes []string `json:"modes,omitempty"`
+
+	// Spotter (origin) filters.
+	SpotterCall       string   `json:"spotter_call,omitempty"` // wildcard
+	SpotterContinents []string `json:"spotter_continents,omitempty"`
+	SpotterCountries  []string `json:"spotter_countries,omitempty"`
+
+	// Actions.
+	Sound  bool `json:"sound"`
+	Visual bool `json:"visual"`
+	Email  bool `json:"email"`
+
+	// Throttling: minutes to wait before re-alerting the same callsign. 0 = only
+	// once per session, -1 = always, >0 = that many minutes.
+	AgainAfterMin int `json:"again_after_min"`
+
+	// Skip a spot whose DX call is already worked on this band+mode.
+	SkipWorked bool `json:"skip_worked"`
+}
+
+// Spot is the subset of a cluster spot the engine matches against.
+type Spot struct {
+	DXCall           string
+	Band             string
+	Mode             string // inferred (see InferMode)
+	Country          string // DXCC entity name
+	Continent        string
+	Spotter          string
+	SpotterCountry   string
+	SpotterContinent string
+}
+
+// Store persists the rule set as a JSON file.
+type Store struct {
+	mu    sync.Mutex
+	path  string
+	rules []Rule
+	// last fired time per (ruleID|call), for the AgainAfter throttle.
+	lastFired map[string]time.Time
+}
+
+// Open loads the store (empty when the file is absent).
+func Open(path string) (*Store, error) {
+	s := &Store{path: path, lastFired: map[string]time.Time{}}
+	b, err := os.ReadFile(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return s, nil
+		}
+		return nil, err
+	}
+	if len(b) > 0 {
+		_ = json.Unmarshal(b, &s.rules) // corrupt file → start empty
+	}
+	return s, nil
+}
+
+func (s *Store) save() error {
+	b, err := json.MarshalIndent(s.rules, "", "  ")
+	if err != nil {
+		return err
+	}
+	tmp := s.path + ".tmp"
+	if err := os.WriteFile(tmp, b, 0o644); err != nil {
+		return err
+	}
+	return os.Rename(tmp, s.path)
+}
+
+// List returns a copy of all rules.
+func (s *Store) List() []Rule {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	out := make([]Rule, len(s.rules))
+	copy(out, s.rules)
+	return out
+}
+
+func newID() string { return strconv.FormatInt(time.Now().UnixNano(), 36) }
+
+// Save upserts a rule (creating an id when empty) and returns it.
+func (s *Store) Save(r Rule) (Rule, error) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if strings.TrimSpace(r.ID) == "" {
+		r.ID = newID()
+		s.rules = append(s.rules, r)
+	} else {
+		found := false
+		for i := range s.rules {
+			if s.rules[i].ID == r.ID {
+				s.rules[i] = r
+				found = true
+				break
+			}
+		}
+		if !found {
+			s.rules = append(s.rules, r)
+		}
+	}
+	return r, s.save()
+}
+
+// Delete removes a rule by id.
+func (s *Store) Delete(id string) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	for i := range s.rules {
+		if s.rules[i].ID == id {
+			s.rules = append(s.rules[:i], s.rules[i+1:]...)
+			return s.save()
+		}
+	}
+	return nil
+}
+
+// Match is a rule that fired for a spot (returned by Evaluate).
+type Match struct {
+	Rule Rule
+	Spot Spot
+}
+
+// Evaluate returns every enabled rule that matches the spot AND isn't currently
+// throttled. It records the fire time for matched rules so the AgainAfter window
+// is honoured. workedFn (may be nil) reports whether the DX call is already
+// worked on this band+mode — used by rules with SkipWorked.
+func (s *Store) Evaluate(sp Spot, now time.Time, workedFn func(call, band, mode string) bool) []Match {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	var out []Match
+	for _, r := range s.rules {
+		if !r.Enabled || !ruleMatches(r, sp) {
+			continue
+		}
+		if r.SkipWorked && workedFn != nil && workedFn(sp.DXCall, sp.Band, sp.Mode) {
+			continue
+		}
+		key := r.ID + "|" + strings.ToUpper(sp.DXCall)
+		if r.AgainAfterMin >= 0 {
+			last, seen := s.lastFired[key]
+			if seen {
+				if r.AgainAfterMin == 0 {
+					continue // once per session
+				}
+				if now.Sub(last) < time.Duration(r.AgainAfterMin)*time.Minute {
+					continue
+				}
+			}
+		}
+		s.lastFired[key] = now
+		out = append(out, Match{Rule: r, Spot: sp})
+	}
+	return out
+}
+
+// ruleMatches reports whether every specified filter dimension matches the spot.
+func ruleMatches(r Rule, sp Spot) bool {
+	if len(r.Calls) > 0 && !anyWildcard(r.Calls, sp.DXCall) {
+		return false
+	}
+	if len(r.Countries) > 0 && !containsFold(r.Countries, sp.Country) {
+		return false
+	}
+	if len(r.Continents) > 0 && !containsFold(r.Continents, sp.Continent) {
+		return false
+	}
+	if len(r.Bands) > 0 && !containsFold(r.Bands, sp.Band) {
+		return false
+	}
+	if len(r.Modes) > 0 && !containsFold(r.Modes, sp.Mode) {
+		return false
+	}
+	if strings.TrimSpace(r.SpotterCall) != "" && !matchWildcard(r.SpotterCall, sp.Spotter) {
+		return false
+	}
+	if len(r.SpotterContinents) > 0 && !containsFold(r.SpotterContinents, sp.SpotterContinent) {
+		return false
+	}
+	if len(r.SpotterCountries) > 0 && !containsFold(r.SpotterCountries, sp.SpotterCountry) {
+		return false
+	}
+	return true
+}
+
+func containsFold(list []string, v string) bool {
+	v = strings.TrimSpace(v)
+	if v == "" {
+		return false
+	}
+	for _, x := range list {
+		if strings.EqualFold(strings.TrimSpace(x), v) {
+			return true
+		}
+	}
+	return false
+}
+
+func anyWildcard(patterns []string, v string) bool {
+	for _, p := range patterns {
+		if matchWildcard(p, v) {
+			return true
+		}
+	}
+	return false
+}
+
+// matchWildcard does a case-insensitive full-string match where '*' matches any
+// run of characters and '?' matches one (e.g. "IW3*", "*/P", "F?BPO").
+func matchWildcard(pattern, v string) bool {
+	pattern = strings.TrimSpace(pattern)
+	v = strings.TrimSpace(v)
+	if pattern == "" {
+		return true
+	}
+	var b strings.Builder
+	b.WriteString("(?i)^")
+	for _, r := range pattern {
+		switch r {
+		case '*':
+			b.WriteString(".*")
+		case '?':
+			b.WriteString(".")
+		default:
+			b.WriteString(regexp.QuoteMeta(string(r)))
+		}
+	}
+	b.WriteString("$")
+	re, err := regexp.Compile(b.String())
+	if err != nil {
+		return strings.EqualFold(pattern, v)
+	}
+	return re.MatchString(v)
+}
+
+// InferMode guesses a spot's mode from its comment and frequency. Cluster spots
+// don't carry a mode field, so we read common tags (FT8/FT4/CW/RTTY/…) then fall
+// back to the digital watering holes and the band-plan CW/phone split.
+func InferMode(comment string, freqHz int64) string {
+	c := strings.ToUpper(comment)
+	switch {
+	case strings.Contains(c, "FT8"):
+		return "FT8"
+	case strings.Contains(c, "FT4"):
+		return "FT4"
+	case strings.Contains(c, "RTTY"):
+		return "RTTY"
+	case strings.Contains(c, "PSK"):
+		return "PSK"
+	case strings.Contains(c, "JS8"):
+		return "JS8"
+	case strings.Contains(c, "CW"):
+		return "CW"
+	case strings.Contains(c, "SSB") || strings.Contains(c, "USB") || strings.Contains(c, "LSB") || strings.Contains(c, "PH"):
+		return "SSB"
+	}
+	khz := float64(freqHz) / 1000
+	// FT8 watering holes (…074) and FT4 (…080/…140) as a fallback.
+	for _, f := range []float64{1840, 3573, 7074, 10136, 14074, 18100, 21074, 24915, 28074, 50313} {
+		if khz >= f-1 && khz <= f+3 {
+			return "FT8"
+		}
+	}
+	// Band-plan CW segments (bottom of each band).
+	switch {
+	case khz >= 1810 && khz <= 1840,
+		khz >= 3500 && khz <= 3570,
+		khz >= 7000 && khz <= 7040,
+		khz >= 10100 && khz <= 10130,
+		khz >= 14000 && khz <= 14070,
+		khz >= 18068 && khz <= 18095,
+		khz >= 21000 && khz <= 21070,
+		khz >= 24890 && khz <= 24910,
+		khz >= 28000 && khz <= 28070:
+		return "CW"
+	}
+	return "SSB"
+}

telemetry.go

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