chore: release v0.16.1

feat: New settings flexradio to select antennas per band

app.go

@@ -18,6 +18,7 @@ import (
 	"time"
 
 	"hamlog/internal/adif"
+	"hamlog/internal/antgenius"
 	"hamlog/internal/applog"
 	"hamlog/internal/audio"
 	"hamlog/internal/award"
@@ -25,23 +26,23 @@ import (
 	"hamlog/internal/backup"
 	"hamlog/internal/cat"
 	"hamlog/internal/clublog"
-	"hamlog/internal/cwdecode"
 	"hamlog/internal/cluster"
+	"hamlog/internal/cwdecode"
 	"hamlog/internal/db"
 	"hamlog/internal/dxcc"
 	"hamlog/internal/email"
 	"hamlog/internal/extsvc"
 	"hamlog/internal/integrations/udp"
 	"hamlog/internal/lookup"
+	"hamlog/internal/netctl"
 	"hamlog/internal/operating"
 	"hamlog/internal/pota"
+	"hamlog/internal/powergenius"
 	"hamlog/internal/profile"
 	"hamlog/internal/qslcard"
 	"hamlog/internal/qso"
 	"hamlog/internal/rotator/pst"
 	"hamlog/internal/settings"
-	"hamlog/internal/antgenius"
-	"hamlog/internal/powergenius"
 	"hamlog/internal/ultrabeam"
 	"hamlog/internal/winkeyer"
 
@@ -88,6 +89,9 @@ const (
 	keyCATIcomPort       = "cat.icom.port"       // Icom USB CI-V serial port (e.g. COM5)
 	keyCATIcomBaud       = "cat.icom.baud"       // Icom CI-V baud (default 115200)
 	keyCATIcomAddr       = "cat.icom.addr"       // Icom CI-V address, decimal (IC-7610 = 152 / 0x98)
+	keyCATTCIHost        = "cat.tci.host"        // TCI host (Expert Electronics SunSDR / ExpertSDR2)
+	keyCATTCIPort        = "cat.tci.port"        // TCI WebSocket port (default 40001)
+	keyCATTCISpots       = "cat.tci.spots"       // push cluster spots to the TCI panorama
 
 	// Audio (Digital Voice Keyer + QSO recorder). Machine-local hardware, so
 	// global (not per-profile) like CAT/rotator. Device fields store the
@@ -223,8 +227,8 @@ const (
 	keyExtLoTWStationLoc   = "extsvc.lotw.station_location"
 	keyExtLoTWForceCall    = "extsvc.lotw.force_station_callsign" // override STATION_CALLSIGN at sign time (e.g. F4BPO/P on the F4BPO cert)
 	keyExtLoTWKeyPassword  = "extsvc.lotw.key_password"
-	keyExtLoTWUploadFlag   = "extsvc.lotw.upload_flag"   // legacy single flag (migrated to upload_flags)
-	keyExtLoTWUploadFlags  = "extsvc.lotw.upload_flags"  // CSV set of lotw_sent values to upload (e.g. "N,R")
+	keyExtLoTWUploadFlag   = "extsvc.lotw.upload_flag"  // legacy single flag (migrated to upload_flags)
+	keyExtLoTWUploadFlags  = "extsvc.lotw.upload_flags" // CSV set of lotw_sent values to upload (e.g. "N,R")
 	keyExtLoTWWriteLog     = "extsvc.lotw.write_log"
 	keyExtLoTWAutoUpload   = "extsvc.lotw.auto_upload"
 	keyExtLoTWUploadMode   = "extsvc.lotw.upload_mode"
@@ -264,6 +268,9 @@ type CATSettings struct {
 	IcomPort       string `json:"icom_port"`       // Icom USB CI-V serial port (e.g. COM5)
 	IcomBaud       int    `json:"icom_baud"`       // Icom CI-V baud (default 115200)
 	IcomAddr       int    `json:"icom_addr"`       // Icom CI-V address, decimal (IC-7610 = 152)
+	TCIHost        string `json:"tci_host"`        // TCI host (Expert Electronics SunSDR)
+	TCIPort        int    `json:"tci_port"`        // TCI WebSocket port (default 40001)
+	TCISpots       bool   `json:"tci_spots"`       // push cluster spots to the TCI panorama
 	PollMs         int    `json:"poll_ms"`         // poll interval in ms (default 250)
 	DelayMs        int    `json:"delay_ms"`        // pause between commands (default 0)
 	DigitalDefault string `json:"digital_default"` // when CAT says DATA, surface this mode (FT8/FT4/RTTY/…)
@@ -374,57 +381,66 @@ type LookupSettings struct {
 
 // App is the application context bound to the Wails runtime.
 type App struct {
-	ctx                 context.Context
-	db                  *sql.DB
-	qso                 *qso.Repo
-	settings            *settings.Store
-	profiles            *profile.Repo
-	lookup              *lookup.Manager
-	cache               *lookup.Cache
-	cat                 *cat.Manager
-	dxcc                *dxcc.Manager
-	cluster             *cluster.Manager
-	pota                *pota.Cache
-	awardRefs           *awardref.Repo
-	qslTemplates        *qslcard.Repo
-	operating           *operating.Repo
-	udp                 *udp.Manager
-	udpRepo             *udp.Repo
-	extsvc              *extsvc.Manager
-	winkeyer            *winkeyer.Manager
-	clublog             *clublog.Manager
-	ultrabeam           *ultrabeam.Client // Ultrabeam antenna (TCP); nil when disabled
-	ubFollowStop        chan struct{}     // stops the "follow frequency" loop; nil when off
-	antgenius           *antgenius.Client   // Antenna Genius (4O3A) switch (TCP); nil when disabled
-	pgxl                *powergenius.Client // PowerGenius XL (4O3A) amp fan control (TCP); nil when disabled
-	audioMgr            *audio.Manager
-	qsoRec              *audio.Recorder // continuous QSO recorder (rolling pre-roll)
-	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)
-	cwPitchHz           int                 // manual pitch override (0 = auto / follow Flex)
-	startupProfile      string              // --profile <name> from the command line (activate at startup)
-	dvkRecSlot          int             // slot currently being recorded (DVKStartRecord → DVKStopRecord)
-	dvkPttKeyed         bool            // we keyed PTT for a voice message; unkey when it ends
-	pttMu               sync.Mutex
-	udpLogMu            sync.Mutex  // serialises UDP auto-log so concurrent packets can't both pass the dedup check
-	pttPort             serial.Port // open serial port while PTT (RTS/DTR) is asserted
-	pttKeyedMethod      string      // "cat" | "rts" | "dtr" while keyed; "" when idle
-	pttGen              int64       // bumped on every key; a delayed unkey only fires if unchanged (guards against a stale release cutting a new transmission)
-	startupErr          string      // captured for surfacing to the frontend
-	dbPath              string      // active database file (may be a user-chosen location)
-	logDb               *sql.DB     // QSO logbook connection — MySQL when the shared backend is enabled, else == db (local SQLite)
-	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)
-	dataDir             string      // <exeDir>/data — holds config.json, logs, cty.dat
+	ctx          context.Context
+	db           *sql.DB
+	qso          *qso.Repo
+	settings     *settings.Store
+	profiles     *profile.Repo
+	lookup       *lookup.Manager
+	cache        *lookup.Cache
+	cat          *cat.Manager
+	dxcc         *dxcc.Manager
+	cluster      *cluster.Manager
+	pota         *pota.Cache
+	awardRefs    *awardref.Repo
+	qslTemplates *qslcard.Repo
+	operating    *operating.Repo
+	udp          *udp.Manager
+	udpRepo      *udp.Repo
+	extsvc       *extsvc.Manager
+	winkeyer     *winkeyer.Manager
+	clublog      *clublog.Manager
+	ultrabeam    *ultrabeam.Client   // Ultrabeam antenna (TCP); nil when disabled
+	ubFollowStop chan struct{}       // stops the "follow frequency" loop; nil when off
+	antgenius    *antgenius.Client   // Antenna Genius (4O3A) switch (TCP); nil when disabled
+	pgxl         *powergenius.Client // PowerGenius XL (4O3A) amp fan control (TCP); nil when disabled
+	audioMgr     *audio.Manager
+	qsoRec       *audio.Recorder // continuous QSO recorder (rolling pre-roll)
+
+	// NET Control: persistent net definitions/rosters (global JSON) + the live
+	// session (in-memory only — active stations currently in QSO).
+	netStore  *netctl.Store
+	netMu     sync.Mutex
+	netOpenID string     // id of the currently open net ("" = none)
+	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, …)
+
+	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)
+	cwPitchHz      int               // manual pitch override (0 = auto / follow Flex)
+	startupProfile string            // --profile <name> from the command line (activate at startup)
+	dvkRecSlot     int               // slot currently being recorded (DVKStartRecord → DVKStopRecord)
+	dvkPttKeyed    bool              // we keyed PTT for a voice message; unkey when it ends
+	pttMu          sync.Mutex
+	udpLogMu       sync.Mutex  // serialises UDP auto-log so concurrent packets can't both pass the dedup check
+	pttPort        serial.Port // open serial port while PTT (RTS/DTR) is asserted
+	pttKeyedMethod string      // "cat" | "rts" | "dtr" while keyed; "" when idle
+	pttGen         int64       // bumped on every key; a delayed unkey only fires if unchanged (guards against a stale release cutting a new transmission)
+	startupErr     string      // captured for surfacing to the frontend
+	dbPath         string      // active database file (may be a user-chosen location)
+	logDb          *sql.DB     // QSO logbook connection — MySQL when the shared backend is enabled, else == db (local SQLite)
+	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)
+	dataDir        string     // <exeDir>/data — holds config.json, logs, cty.dat
 
 	// shuttingDown gates beforeClose re-entry: the first user attempt to
 	// close fires shutdown tasks (backup, future LoTW upload, ...) while
@@ -598,7 +614,8 @@ func (a *App) startup(ctx context.Context) {
 	// Route CAT/OmniRig debug lines into the unified app log (they used to go
 	// to a separate cat.log in the old HamLog folder, which users couldn't find).
 	cat.LogSink = applog.Printf
-	audio.LogSink = applog.Printf // capture audio-goroutine panics in the app log
+	audio.LogSink = applog.Printf  // capture audio-goroutine panics in the app log
+	extsvc.LogSink = applog.Printf // log raw QRZ (and other) service responses for diagnosis
 	applog.Printf("startup: data dir = %s", dataDir)
 	// The local SQLite file ALWAYS holds per-operator configuration — settings,
 	// station profiles, rigs/antennas, cluster nodes, UDP, QSL templates, award
@@ -827,6 +844,13 @@ func (a *App) startup(ctx context.Context) {
 	a.qsoRec = audio.NewRecorder()
 	a.startQSORecorderIfEnabled()
 
+	// NET Control store (global JSON, shared across logbooks).
+	if ns, err := netctl.Open(filepath.Join(a.dataDir, "nets.json")); err != nil {
+		applog.Printf("netctl: open failed: %v", err)
+	} else {
+		a.netStore = ns
+	}
+
 	// Ultrabeam antenna: connect in the background if enabled.
 	a.startUltrabeam()
 	// Antenna Genius switch: connect in the background if enabled.
@@ -1055,7 +1079,6 @@ func userDataDir() (string, error) {
 	return filepath.Join(filepath.Dir(exe), "data"), nil
 }
 
-
 // fileExists reports whether path exists and is a regular file.
 func fileExists(path string) bool {
 	fi, err := os.Stat(path)
@@ -1114,8 +1137,8 @@ func copyFileData(src, dst string) error {
 // (MySQL). The MySQL connection lives here — not in the settings table — for
 // the same reason: we need it to choose and open the backend at startup.
 type dbPointer struct {
-	DBPath string          `json:"db_path"`
-	MySQL  *MySQLSettings  `json:"mysql,omitempty"`
+	DBPath string         `json:"db_path"`
+	MySQL  *MySQLSettings `json:"mysql,omitempty"`
 }
 
 func dbPointerPath(dataDir string) string { return filepath.Join(dataDir, "config.json") }
@@ -1181,9 +1204,9 @@ type MySQLSettings struct {
 // the Settings UI can confirm the shared MySQL connection (or explain a
 // fallback to SQLite when the configured server was unreachable).
 type DBBackendStatus struct {
-	Active   string `json:"active"`    // "sqlite" | "mysql"
-	Fallback bool   `json:"fallback"`  // MySQL was enabled but failed, so we used SQLite
-	Error    string `json:"error"`     // the MySQL open error, when Fallback is true
+	Active   string `json:"active"`   // "sqlite" | "mysql"
+	Fallback bool   `json:"fallback"` // MySQL was enabled but failed, so we used SQLite
+	Error    string `json:"error"`    // the MySQL open error, when Fallback is true
 }
 
 // GetDBBackendStatus returns the active backend and any MySQL fallback error.
@@ -1703,6 +1726,20 @@ func (a *App) applyStationDefaults(q *qso.QSO, includeIdentity bool) {
 	if q.MyPOTARef == "" {
 		q.MyPOTARef = p.MyPOTARef
 	}
+	// Per-band rig/antenna from Operating conditions (the antenna ticked as
+	// DEFAULT for this band) — the same auto-fill the entry strip does, applied
+	// here so imported QSOs get MY_RIG / MY_ANTENNA from the band defaults.
+	if a.operating != nil && q.Band != "" && (q.MyRig == "" || q.MyAntenna == "") {
+		if d, ok, _ := a.operating.BandDefault(a.ctx, p.ID, q.Band); ok {
+			if q.MyRig == "" {
+				q.MyRig = d.StationName
+			}
+			if q.MyAntenna == "" {
+				q.MyAntenna = d.AntennaName
+			}
+		}
+	}
+	// Fall back to the profile's static rig/antenna for anything still empty.
 	if q.MyRig == "" {
 		q.MyRig = p.MyRig
 	}
@@ -3326,6 +3363,8 @@ type QSLBulkUpdate struct {
 	SentDate   string `json:"sent_date"`   // YYYYMMDD — "" = unchanged
 	RcvdDate   string `json:"rcvd_date"`   // YYYYMMDD — "" = unchanged
 	Via        string `json:"via"`         // QSL_VIA — "" = unchanged
+	Notes      string `json:"notes"`       // NOTES — "" = unchanged
+	Comment    string `json:"comment"`     // COMMENT — "" = unchanged
 }
 
 // BulkUpdateQSL applies paper-QSL sent/received status, dates and via to the
@@ -3358,6 +3397,12 @@ func (a *App) BulkUpdateQSL(ids []int64, u QSLBulkUpdate) (int, error) {
 		if v := strings.TrimSpace(u.Via); v != "" {
 			q.QSLVia, changed = v, true
 		}
+		if v := strings.TrimSpace(u.Notes); v != "" {
+			q.Notes, changed = v, true
+		}
+		if v := strings.TrimSpace(u.Comment); v != "" {
+			q.Comment, changed = v, true
+		}
 		if changed {
 			if a.qso.Update(a.ctx, q) == nil {
 				n++
@@ -3569,6 +3614,9 @@ func (a *App) ImportADIF(path string, dupMode string, applyCty bool, applyStatio
 				// Backfill empty MY_* descriptive fields from the active profile
 				// (identity fields left alone to keep mixed-call routing intact).
 				a.applyStationDefaults(q, false)
+				// Also stamp the default QSL/LoTW/eQSL confirmation statuses on
+				// any that are still empty (same defaults new QSOs get).
+				a.applyQSLDefaults(q)
 			}
 		}
 	}
@@ -3810,7 +3858,7 @@ func (a *App) GetCATSettings() (CATSettings, error) {
 	if a.settings == nil {
 		return CATSettings{Backend: "omnirig", OmniRigNum: 1, PollMs: 250}, fmt.Errorf("db not initialized")
 	}
-	m, err := a.settings.GetMany(a.ctx, keyCATEnabled, keyCATBackend, keyCATOmniRigNum, keyCATFlexHost, keyCATFlexPort, keyCATFlexSpots, keyCATIcomPort, keyCATIcomBaud, keyCATIcomAddr, keyCATPollMs, keyCATDelayMs, keyCATDigitalDefault)
+	m, err := a.settings.GetMany(a.ctx, keyCATEnabled, keyCATBackend, keyCATOmniRigNum, keyCATFlexHost, keyCATFlexPort, keyCATFlexSpots, keyCATIcomPort, keyCATIcomBaud, keyCATIcomAddr, keyCATTCIHost, keyCATTCIPort, keyCATTCISpots, keyCATPollMs, keyCATDelayMs, keyCATDigitalDefault)
 	if err != nil {
 		return CATSettings{}, err
 	}
@@ -3824,6 +3872,9 @@ func (a *App) GetCATSettings() (CATSettings, error) {
 		IcomPort:       m[keyCATIcomPort],
 		IcomBaud:       115200,
 		IcomAddr:       0x98, // IC-7610 default
+		TCIHost:        m[keyCATTCIHost],
+		TCIPort:        40001,
+		TCISpots:       m[keyCATTCISpots] == "1",
 		PollMs:         250,
 		DelayMs:        0,
 		DigitalDefault: m[keyCATDigitalDefault],
@@ -3831,6 +3882,9 @@ func (a *App) GetCATSettings() (CATSettings, error) {
 	if n, _ := strconv.Atoi(m[keyCATFlexPort]); n > 0 && n <= 65535 {
 		out.FlexPort = n
 	}
+	if n, _ := strconv.Atoi(m[keyCATTCIPort]); n > 0 && n <= 65535 {
+		out.TCIPort = n
+	}
 	if n, _ := strconv.Atoi(m[keyCATIcomBaud]); n > 0 {
 		out.IcomBaud = n
 	}
@@ -3889,6 +3943,10 @@ func (a *App) SaveCATSettings(s CATSettings) error {
 	if s.FlexSpots {
 		flexSpots = "1"
 	}
+	tciSpots := "0"
+	if s.TCISpots {
+		tciSpots = "1"
+	}
 	if s.DigitalDefault == "" {
 		s.DigitalDefault = "FT8"
 	}
@@ -3902,6 +3960,9 @@ func (a *App) SaveCATSettings(s CATSettings) error {
 		keyCATIcomPort:       strings.TrimSpace(s.IcomPort),
 		keyCATIcomBaud:       strconv.Itoa(s.IcomBaud),
 		keyCATIcomAddr:       strconv.Itoa(s.IcomAddr),
+		keyCATTCIHost:        strings.TrimSpace(s.TCIHost),
+		keyCATTCIPort:        strconv.Itoa(s.TCIPort),
+		keyCATTCISpots:       tciSpots,
 		keyCATPollMs:         strconv.Itoa(s.PollMs),
 		keyCATDelayMs:        strconv.Itoa(s.DelayMs),
 		keyCATDigitalDefault: strings.ToUpper(strings.TrimSpace(s.DigitalDefault)),
@@ -4174,13 +4235,33 @@ func (a *App) saveQSORecording(q *qso.QSO) {
 			return
 		}
 		applog.Printf("qso-rec: saved %s", path)
-		// Auto-send the recording once the file exists.
-		if es, _ := a.GetEmailSettings(); es.Enabled && es.AutoSend && strings.TrimSpace(qc.Email) != "" {
-			_ = a.sendRecordingEmail(qc, path)
+		// Auto-send the recording once the file exists. Gated ONLY on its own
+		// "auto-send recording" toggle (email.auto_send) — NOT the SMTP panel's
+		// master "Enabled" flag, mirroring the eQSL-card auto-send. (Requiring
+		// Enabled silently skipped sending with no log when only this box was on.)
+		// Give the operator visible feedback either way.
+		if es, _ := a.GetEmailSettings(); es.AutoSend {
+			if strings.TrimSpace(qc.Email) == "" {
+				applog.Printf("qso-rec: %s not e-mailed — no recipient address known", qc.Callsign)
+				a.toast(fmt.Sprintf("Recording saved — no e-mail for %s, not sent", qc.Callsign))
+			} else if err := a.sendRecordingEmail(qc, path); err != nil {
+				a.toast(fmt.Sprintf("Recording e-mail to %s failed", qc.Callsign))
+			} else {
+				a.toast(fmt.Sprintf("Recording e-mailed to %s", qc.Callsign))
+				a.markRecordingSent(qc.ID)
+			}
 		}
 	}()
 }
 
+// toast emits a transient message the frontend shows as a toast notification.
+// Used for background events (auto-send results) the UI can't otherwise surface.
+func (a *App) toast(msg string) {
+	if a.ctx != nil {
+		wruntime.EventsEmit(a.ctx, "toast", msg)
+	}
+}
+
 // sanitizeFilename makes a callsign safe for a filename (slashes etc.).
 func sanitizeFilename(s string) string {
 	s = strings.ToUpper(strings.TrimSpace(s))
@@ -4220,6 +4301,18 @@ func (a *App) QSOAudioRestart() bool {
 	return a.qsoRec.Active()
 }
 
+// QSOAudioResetClock restarts the in-progress recording from zero, dropping
+// everything captured so far (pre-roll included). Lets the operator click the
+// REC timer to record only their own exchange when the station was already in a
+// long QSO before they entered the call. Returns whether a recording is active.
+func (a *App) QSOAudioResetClock() bool {
+	if a.qsoRec == nil {
+		return false
+	}
+	a.qsoRec.ResetQSOClock()
+	return a.qsoRec.Active()
+}
+
 // QSOAudioCancel drops the in-progress recording (callsign cleared, QSO
 // abandoned without logging).
 func (a *App) QSOAudioCancel() {
@@ -4231,6 +4324,284 @@ func (a *App) QSOAudioCancel() {
 // RestartQSORecorder applies new audio settings to the running recorder.
 func (a *App) RestartQSORecorder() { a.startQSORecorderIfEnabled() }
 
+// ── NET Control ────────────────────────────────────────────────────────────
+//
+// A NET is a named net with a station roster (persisted globally in nets.json).
+// Opening a net starts an in-memory live session: stations moved "on the air"
+// (NetActivate) accumulate a time_on; moving one back off (NetDeactivate) logs
+// the QSO into the active logbook with live CAT freq/mode and removes it from
+// the session. The session is RAM-only — closing the app mid-net drops any
+// active stations that were never logged.
+
+// NetList returns all nets (with rosters), ordered by name.
+func (a *App) NetList() []netctl.Net {
+	if a.netStore == nil {
+		return nil
+	}
+	return a.netStore.List()
+}
+
+// NetCreate adds a new named net (defaults 59/59).
+func (a *App) NetCreate(name string) (netctl.Net, error) {
+	if a.netStore == nil {
+		return netctl.Net{}, fmt.Errorf("net store unavailable")
+	}
+	return a.netStore.Create(name)
+}
+
+// NetRename renames a net.
+func (a *App) NetRename(id, name string) error {
+	if a.netStore == nil {
+		return fmt.Errorf("net store unavailable")
+	}
+	return a.netStore.Rename(id, name)
+}
+
+// NetSetDefaults updates a net's default report/comment values.
+func (a *App) NetSetDefaults(id, rstSent, rstRcvd, comment string) error {
+	if a.netStore == nil {
+		return fmt.Errorf("net store unavailable")
+	}
+	return a.netStore.SetDefaults(id, rstSent, rstRcvd, comment)
+}
+
+// NetDelete removes a net and its roster (closing it first if it's open).
+func (a *App) NetDelete(id string) error {
+	if a.netStore == nil {
+		return fmt.Errorf("net store unavailable")
+	}
+	a.netMu.Lock()
+	if a.netOpenID == id {
+		a.netOpenID, a.netActive = "", nil
+	}
+	a.netMu.Unlock()
+	return a.netStore.Delete(id)
+}
+
+// NetRoster returns a net's roster, sorted by callsign.
+func (a *App) NetRoster(id string) ([]netctl.Station, error) {
+	if a.netStore == nil {
+		return nil, fmt.Errorf("net store unavailable")
+	}
+	return a.netStore.Roster(id)
+}
+
+// NetRosterUpsert adds or updates a roster station.
+func (a *App) NetRosterUpsert(id string, s netctl.Station) error {
+	if a.netStore == nil {
+		return fmt.Errorf("net store unavailable")
+	}
+	return a.netStore.RosterUpsert(id, s)
+}
+
+// NetRosterRemove deletes a callsign from a net's roster.
+func (a *App) NetRosterRemove(id, callsign string) error {
+	if a.netStore == nil {
+		return fmt.Errorf("net store unavailable")
+	}
+	return a.netStore.RosterRemove(id, callsign)
+}
+
+// NetLookup resolves a callsign via the configured provider (QRZ) so the
+// Add-contact dialog can pre-fill name/QTH/country/zones. Best-effort — returns
+// just the callsign if no provider or no match.
+func (a *App) NetLookup(callsign string) netctl.Station {
+	st := netctl.Station{Callsign: strings.ToUpper(strings.TrimSpace(callsign))}
+	if a.lookup == nil || st.Callsign == "" {
+		return st
+	}
+	if lr, err := a.lookup.Lookup(a.ctx, st.Callsign); err == nil {
+		st.Name, st.QTH, st.Country = lr.Name, lr.QTH, lr.Country
+		st.DXCC, st.CQ, st.ITU = lr.DXCC, lr.CQZ, lr.ITUZ
+	}
+	return st
+}
+
+// NetOpen starts a live session for the given net (clears any prior session).
+func (a *App) NetOpen(id string) error {
+	if a.netStore == nil {
+		return fmt.Errorf("net store unavailable")
+	}
+	if _, ok := a.netStore.Get(id); !ok {
+		return fmt.Errorf("net not found")
+	}
+	a.netMu.Lock()
+	a.netOpenID, a.netActive = id, nil
+	a.netMu.Unlock()
+	return nil
+}
+
+// NetClose ends the live session (does NOT log remaining actives — the operator
+// moves each station back to the roster side to log it before closing).
+func (a *App) NetClose() {
+	a.netMu.Lock()
+	a.netOpenID, a.netActive = "", nil
+	a.netMu.Unlock()
+}
+
+// NetOpenID returns the id of the currently open net ("" = none).
+func (a *App) NetOpenID() string {
+	a.netMu.Lock()
+	defer a.netMu.Unlock()
+	return a.netOpenID
+}
+
+// NetActiveList returns the stations currently on the air, in check-in order.
+// Each is a full QSO *draft* (not yet in the DB) carrying a negative transient
+// id so the same QSOEditModal as Recent QSOs can edit every field.
+func (a *App) NetActiveList() []qso.QSO {
+	a.netMu.Lock()
+	defer a.netMu.Unlock()
+	out := make([]qso.QSO, len(a.netActive))
+	for i, e := range a.netActive {
+		out[i] = *e
+	}
+	return out
+}
+
+// netLiveFreq returns the rig's live freq/band/mode, falling back to the last
+// UI-reported values when CAT is off.
+func (a *App) netLiveFreq() (freq int64, band, mode string) {
+	var st cat.RigState
+	if a.cat != nil {
+		st = a.cat.State()
+	}
+	freq, band, mode = st.FreqHz, st.Band, st.Mode
+	if freq == 0 {
+		a.liveActMu.Lock()
+		freq, band, mode = a.liveFreqHz, a.liveBand, a.liveMode
+		a.liveActMu.Unlock()
+	}
+	if band == "" && freq > 0 {
+		band = bandForHz(freq)
+	}
+	return
+}
+
+// NetActivate puts a station on the air: it builds a QSO draft (time_on now,
+// live freq/mode, defaults + roster info) with a transient negative id and
+// returns it. No-op (returns the existing draft) if already active.
+func (a *App) NetActivate(callsign string) (qso.QSO, error) {
+	call := strings.ToUpper(strings.TrimSpace(callsign))
+	if call == "" {
+		return qso.QSO{}, fmt.Errorf("callsign required")
+	}
+	a.netMu.Lock()
+	defer a.netMu.Unlock()
+	if a.netOpenID == "" {
+		return qso.QSO{}, fmt.Errorf("no net open")
+	}
+	for _, e := range a.netActive {
+		if strings.EqualFold(e.Callsign, call) {
+			return *e, nil // already on the air
+		}
+	}
+	a.netSeq--
+	q := &qso.QSO{ID: a.netSeq, Callsign: call, QSODate: time.Now().UTC()}
+	if net, ok := a.netStore.Get(a.netOpenID); ok {
+		q.RSTSent, q.RSTRcvd, q.Comment = net.DefaultRSTSent, net.DefaultRSTRcvd, net.DefaultComment
+		for _, st := range net.Stations {
+			if strings.EqualFold(st.Callsign, call) {
+				q.Name, q.QTH, q.Country = st.Name, st.QTH, st.Country
+				if st.DXCC != 0 {
+					d := st.DXCC
+					q.DXCC = &d
+				}
+				if st.CQ != 0 {
+					c := st.CQ
+					q.CQZ = &c
+				}
+				if st.ITU != 0 {
+					i := st.ITU
+					q.ITUZ = &i
+				}
+				break
+			}
+		}
+	}
+	if q.RSTSent == "" {
+		q.RSTSent = "59"
+	}
+	if q.RSTRcvd == "" {
+		q.RSTRcvd = "59"
+	}
+	freq, band, mode := a.netLiveFreq()
+	q.Band, q.Mode = band, mode
+	if freq > 0 {
+		f := freq
+		q.FreqHz = &f
+	}
+	a.applyDXCCNumber(q) // fill country/dxcc/zones for display
+	a.refineDistrictZones(q)
+	a.netActive = append(a.netActive, q)
+	return *q, nil
+}
+
+// NetUpdateActive replaces an on-air QSO draft (matched by its transient id)
+// with the edited version from the QSOEditModal. Lets the operator change every
+// field of a station before it's logged.
+func (a *App) NetUpdateActive(q qso.QSO) error {
+	a.netMu.Lock()
+	defer a.netMu.Unlock()
+	for i, cur := range a.netActive {
+		if cur.ID == q.ID {
+			qq := q
+			a.netActive[i] = &qq
+			return nil
+		}
+	}
+	return fmt.Errorf("station not active")
+}
+
+// NetDiscardActive removes an on-air draft (by transient id) WITHOUT logging it
+// — i.e. cancel a station added by mistake (the modal's Delete button).
+func (a *App) NetDiscardActive(id int64) error {
+	a.netMu.Lock()
+	defer a.netMu.Unlock()
+	for i, e := range a.netActive {
+		if e.ID == id {
+			a.netActive = append(a.netActive[:i], a.netActive[i+1:]...)
+			return nil
+		}
+	}
+	return nil
+}
+
+// NetDeactivate ends a station's QSO (by transient id): it logs the draft to the
+// active logbook (time_off = now; freq/mode refreshed from the rig only if the
+// draft still has none, so manual edits are respected) and removes it from the
+// session. Returns the new QSO id.
+func (a *App) NetDeactivate(id int64) (int64, error) {
+	a.netMu.Lock()
+	var draft *qso.QSO
+	idx := -1
+	for i, e := range a.netActive {
+		if e.ID == id {
+			draft, idx = e, i
+			break
+		}
+	}
+	if draft == nil {
+		a.netMu.Unlock()
+		return 0, fmt.Errorf("station not active")
+	}
+	a.netActive = append(a.netActive[:idx], a.netActive[idx+1:]...)
+	a.netMu.Unlock()
+
+	q := *draft
+	q.ID = 0 // transient id must not reach the DB (AddQSO inserts a fresh row)
+	q.QSODateOff = time.Now().UTC()
+	if q.FreqHz == nil && q.Band == "" {
+		freq, band, mode := a.netLiveFreq()
+		q.Band, q.Mode = band, mode
+		if freq > 0 {
+			f := freq
+			q.FreqHz = &f
+		}
+	}
+	return a.AddQSO(q)
+}
+
 // ── E-mail / SMTP (send QSO recordings) ───────────────────────────────
 
 const (
@@ -4364,6 +4735,28 @@ func (a *App) fillTemplate(tmpl string, q qso.QSO) string {
 	return r.Replace(tmpl)
 }
 
+// markRecordingSent stamps the QSO so the UI (and the operator) knows its audio
+// recording was e-mailed — exposed as the APP_OPSLOG_RECORDING_SENT extra and a
+// "Recording sent" column in Recent QSOs. Re-reads the row first so a concurrent
+// status update (eQSL/upload) isn't clobbered by writing back the whole row.
+func (a *App) markRecordingSent(id int64) {
+	if a.qso == nil || id == 0 {
+		return
+	}
+	q, err := a.qso.GetByID(a.ctx, id)
+	if err != nil {
+		applog.Printf("qso-rec: mark sent: load %d: %v", id, err)
+		return
+	}
+	if q.Extras == nil {
+		q.Extras = map[string]string{}
+	}
+	q.Extras["APP_OPSLOG_RECORDING_SENT"] = time.Now().UTC().Format("2006-01-02")
+	if err := a.qso.Update(a.ctx, q); err != nil {
+		applog.Printf("qso-rec: mark sent: update %d: %v", id, err)
+	}
+}
+
 // sendRecordingEmail e-mails a QSO recording to the contacted operator.
 func (a *App) sendRecordingEmail(q qso.QSO, attachPath string) error {
 	s, _ := a.GetEmailSettings()
@@ -4409,7 +4802,11 @@ func (a *App) SendQSORecordingEmail(id int64) error {
 	if _, e := os.Stat(path); e != nil {
 		return fmt.Errorf("recording file missing: %s", name)
 	}
-	return a.sendRecordingEmail(q, path)
+	if err := a.sendRecordingEmail(q, path); err != nil {
+		return err
+	}
+	a.markRecordingSent(id)
+	return nil
 }
 
 // ── ClubLog Country File (cty.xml) exceptions ─────────────────────────
@@ -5303,7 +5700,9 @@ func uploadColumnFor(service string) string {
 
 // FindQSOsForUpload returns QSOs whose sent status for the given service
 // matches sentStatus ("" = blank). Powers the QSL Manager's Select required.
-func (a *App) FindQSOsForUpload(service, sentStatus string) ([]qso.UploadRow, error) {
+// FindQSOsForUpload returns FULL QSO rows eligible for upload to a service, so
+// the QSL Manager shows the same rich, column-pickable table as Recent QSOs.
+func (a *App) FindQSOsForUpload(service, sentStatus string) ([]qso.QSO, error) {
 	if a.qso == nil {
 		return nil, fmt.Errorf("db not initialized")
 	}
@@ -5311,7 +5710,7 @@ func (a *App) FindQSOsForUpload(service, sentStatus string) ([]qso.UploadRow, er
 	if col == "" {
 		return nil, fmt.Errorf("unknown service %q", service)
 	}
-	return a.qso.ListForUpload(a.ctx, col, strings.ToUpper(strings.TrimSpace(sentStatus)))
+	return a.qso.ListForUploadFull(a.ctx, col, strings.ToUpper(strings.TrimSpace(sentStatus)))
 }
 
 // UploadQSOsManual uploads the given QSO ids to a service on demand
@@ -7040,6 +7439,97 @@ func (a *App) FlexSetAudioLevel(l int) error {
 	return a.cat.FlexDo(func(fc cat.FlexController) error { return fc.SetAudioLevel(l) })
 }
 
+func (a *App) FlexSetMute(on bool) error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	return a.cat.FlexDo(func(fc cat.FlexController) error { return fc.SetMute(on) })
+}
+
+func (a *App) FlexSetRXAntenna(ant string) error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	return a.cat.FlexDo(func(fc cat.FlexController) error { return fc.SetRXAntenna(ant) })
+}
+
+func (a *App) FlexSetTXAntenna(ant string) error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	return a.cat.FlexDo(func(fc cat.FlexController) error { return fc.SetTXAntenna(ant) })
+}
+
+func (a *App) FlexSetSplit(on bool) error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	return a.cat.FlexDo(func(fc cat.FlexController) error { return fc.SetSplit(on) })
+}
+
+// keyFlexBandAnt stores the per-band RX/TX antenna map (global, machine-local).
+const keyFlexBandAnt = "flex.band_antennas"
+
+// FlexBandAnt is the antenna pair to select on a given band.
+type FlexBandAnt struct {
+	RX string `json:"rx"`
+	TX string `json:"tx"`
+}
+
+// GetFlexBandAntennas returns the band→{rx,tx} antenna map (band key uppercased,
+// e.g. "20M").
+func (a *App) GetFlexBandAntennas() (map[string]FlexBandAnt, error) {
+	out := map[string]FlexBandAnt{}
+	if a.settings == nil {
+		return out, nil
+	}
+	v, _ := a.settings.GetGlobal(a.ctx, keyFlexBandAnt)
+	if strings.TrimSpace(v) == "" {
+		return out, nil
+	}
+	_ = json.Unmarshal([]byte(v), &out)
+	return out, nil
+}
+
+// SaveFlexBandAntennas persists the band→antenna map.
+func (a *App) SaveFlexBandAntennas(m map[string]FlexBandAnt) error {
+	if a.settings == nil {
+		return fmt.Errorf("db not initialized")
+	}
+	b, err := json.Marshal(m)
+	if err != nil {
+		return err
+	}
+	return a.settings.SetGlobal(a.ctx, keyFlexBandAnt, string(b))
+}
+
+// FlexApplyBandAntenna selects the configured RX/TX antennas for the given band
+// (no-op if the backend isn't a Flex or the band has no mapping). Called on band
+// changes and spot clicks so the right antennas follow the frequency.
+func (a *App) FlexApplyBandAntenna(band string) error {
+	if a.cat == nil {
+		return nil
+	}
+	band = strings.ToUpper(strings.TrimSpace(band))
+	if band == "" {
+		return nil
+	}
+	m, _ := a.GetFlexBandAntennas()
+	ant, ok := m[band]
+	if !ok {
+		return nil
+	}
+	return a.cat.FlexDo(func(fc cat.FlexController) error {
+		if strings.TrimSpace(ant.RX) != "" {
+			_ = fc.SetRXAntenna(ant.RX)
+		}
+		if strings.TrimSpace(ant.TX) != "" {
+			_ = fc.SetTXAntenna(ant.TX)
+		}
+		return nil
+	})
+}
+
 func (a *App) FlexSetNB(on bool) error {
 	if a.cat == nil {
 		return fmt.Errorf("cat not initialized")
@@ -7166,7 +7656,7 @@ func (a *App) reloadCAT() {
 	}
 	a.cat.SetPollInterval(time.Duration(s.PollMs) * time.Millisecond)
 	a.cat.SetCommandDelay(time.Duration(s.DelayMs) * time.Millisecond)
-	a.catFlexSpots = s.Enabled && s.Backend == "flex" && s.FlexSpots
+	a.catFlexSpots = s.Enabled && ((s.Backend == "flex" && s.FlexSpots) || (s.Backend == "tci" && s.TCISpots))
 	if !s.Enabled {
 		a.cat.Stop()
 		return
@@ -7193,6 +7683,10 @@ func (a *App) reloadCAT() {
 		// Native Icom CI-V over the radio's USB serial port (local control).
 		// Same civ protocol a future network backend will reuse for remote.
 		a.cat.Start(cat.NewIcomSerial(s.IcomPort, s.IcomBaud, s.IcomAddr, s.DigitalDefault))
+	case "tci":
+		// Expert Electronics TCI (WebSocket) — SunSDR / ExpertSDR2, or any
+		// TCI-compatible server.
+		a.cat.Start(cat.NewTCI(s.TCIHost, s.TCIPort, s.DigitalDefault, s.TCISpots))
 	default:
 		// Unknown backend → stop and emit a dummy state so the UI shows it.
 		a.cat.Stop()
@@ -8480,7 +8974,8 @@ type SpotQuery struct {
 //
 //	"new"        — entity never worked
 //	"new-band"   — entity worked but never on this band
-//	"new-slot"   — entity worked on this band but not in this mode
+//	"new-mode"   — band worked, but this MODE never worked on the entity (any band)
+//	"new-slot"   — band & mode each worked before, but not this band+mode together
 //	"worked"     — exact band+mode already in the log
 //	""           — couldn't resolve the entity (no cty.dat match)
 type SpotStatus struct {
@@ -8569,12 +9064,19 @@ func (a *App) ClusterSpotStatuses(spots []SpotQuery) []SpotStatus {
 			out[i].Status = "new-band"
 			continue
 		}
-		// Without a mode we can't distinguish "new slot" from "worked";
+		// Without a mode we can't distinguish the rest from "worked";
 		// the safer default is "worked" so we never falsely claim "new".
 		if out[i].Mode == "" {
 			out[i].Status = "worked"
 			continue
 		}
+		// Band already worked. If this MODE was never worked on the entity (any
+		// band) → new-mode. If the mode was worked elsewhere but not on THIS
+		// band+mode → new-slot. Otherwise → worked.
+		if _, m := e.Modes[out[i].Mode]; !m {
+			out[i].Status = "new-mode"
+			continue
+		}
 		if _, ok := e.Slots[out[i].Band][out[i].Mode]; !ok {
 			out[i].Status = "new-slot"
 			continue

frontend/src/App.tsx

@@ -13,7 +13,7 @@ import {
   GetStartupStatus, CheckForUpdate,
   WorkedBefore,
   SetCompactMode,
-  GetCATState, SetCATFrequency, SetCATMode, SwitchCATRig,
+  GetCATState, SetCATFrequency, SetCATMode, SwitchCATRig, FlexApplyBandAntenna,
   GetSecretStatus, UnlockSecrets,
   RefreshCtyDat, DownloadAllReferenceLists,
   RotatorGoTo, RotatorStop, GetRotatorHeading,
@@ -32,7 +32,7 @@ import {
   GetDVKMessages, GetDVKStatus, DVKPlay, DVKStop,
   StartCWDecoder, StopCWDecoder, SetCWDecoderPitch,
   ChatAvailable, GetChatHistory, SendChatMessage, GetOnlineOperators,
-  QSOAudioBegin, QSOAudioCancel, QSOAudioRestart,
+  QSOAudioBegin, QSOAudioCancel, QSOAudioRestart, QSOAudioResetClock,
   GetAwardDefs,
   GetUIPref,
   ReportLiveActivity,
@@ -66,6 +66,7 @@ import { ShutdownProgress } from '@/components/ShutdownProgress';
 import { ClusterGrid } from '@/components/ClusterGrid';
 import { cleanSpotter, inferSpotMode, spotModeCategory, spotStatusKey } from '@/lib/spot';
 import { WorkedBeforeGrid } from '@/components/WorkedBeforeGrid';
+import { NetControlPanel } from '@/components/NetControlPanel';
 import { BulkEditModal } from '@/components/BulkEditModal';
 import { ChatPanel, type ChatMsg, type ChatPresence } from '@/components/ChatPopover';
 import { DetailsPanel, type DetailsState } from '@/components/DetailsPanel';
@@ -116,7 +117,7 @@ const emptyDetails: DetailsState = {
   prop_mode: '', my_rig: '', my_antenna: '',
   tx_pwr: undefined,
   sat_name: '', sat_mode: '',
-  contest_id: '', srx: undefined, stx: undefined,
+  contest_id: '', srx_string: '', stx_string: '',
   email: '',
   award_refs: '',
 };
@@ -205,6 +206,24 @@ function rstCategory(mode: string): keyof RSTLists {
   if (['CW', 'RTTY', 'PSK31', 'PSK63', 'PSK', 'PSK125'].includes(m)) return 'cw';
   return 'phone';
 }
+// estimateCwMs roughly estimates how long the resolved text takes to send in CW
+// at wpm: ~10 dot-units per character + ~4 extra per word gap, 1 unit = 1200/wpm
+// ms (PARIS standard). Used to cap waits on the keyer's "busy" status, which can
+// lag by tens of seconds over a remote/serial-over-IP link.
+function estimateCwMs(resolved: string, wpm: number): number {
+  const w = Math.max(5, wpm || 25);
+  const chars = resolved.replace(/\s/g, '').length;
+  const spaces = (resolved.match(/\s/g) || []).length;
+  return ((chars * 10 + spaces * 4) * 1200) / w;
+}
+// exchangeFields splits a contest exchange the operator typed as free text into
+// the ADIF numeric field (SRX/STX, when it's all digits) or the string field
+// (SRX_STRING/STX_STRING, when it's alphanumeric like a section/zone).
+function exchangeFields(raw?: string): { num?: number; str: string } {
+  const t = (raw || '').trim();
+  if (t === '') return { str: '' };
+  return /^\d+$/.test(t) ? { num: parseInt(t, 10), str: '' } : { str: t };
+}
 // rstOptions returns the valid report choices for a mode from the user's
 // editable lists (Settings → Modes), with a tiny fallback before they load.
 function rstOptions(mode: string, lists: RSTLists): string[] {
@@ -402,10 +421,12 @@ export default function App() {
 
   // User changed band/mode in the entry strip → push to the rig if CAT is up.
   // Both calls are fire-and-forget; CAT will reflect back via cat:state.
+  // When the field is LOCKED (🔒, e.g. logging an old QSO off-frequency), we do
+  // NOT drive the radio — the lock means "this value is decoupled from the rig".
   function onBandUserChange(v: string) {
     setBand(v);
     noteManualEdit();
-    if (catState.enabled && catState.connected) {
+    if (catState.enabled && catState.connected && !locks.band && !locks.freq) {
       const hz = qsyFreqHz(v, mode);
       if (hz > 0) SetCATFrequency(hz).catch(() => {});
     }
@@ -414,7 +435,7 @@ export default function App() {
     setMode(v);
     applyModePreset(v);
     noteManualEdit();
-    if (catState.enabled && catState.connected) {
+    if (catState.enabled && catState.connected && !locks.mode) {
       SetCATMode(v).catch(() => {});
     }
   }
@@ -469,11 +490,25 @@ export default function App() {
   };
   // Transient success toast (bottom-right, auto-dismiss). Used for things
   // like "spot sent" where a blocking error banner would be overkill.
+  // Toasts are QUEUED so two firing at once don't clobber each other: each shows
+  // for 3s, then the next takes over (no gap). `toast` is the one on screen now.
   const [toast, setToast] = useState('');
-  const showToast = useCallback((msg: string) => {
-    setToast(msg);
-    window.setTimeout(() => setToast((t) => (t === msg ? '' : t)), 3500);
+  const toastQueue = useRef<string[]>([]);
+  const toastTimer = useRef<number | undefined>(undefined);
+  const advanceToast = useCallback(() => {
+    const next = toastQueue.current.shift();
+    if (next === undefined) { toastTimer.current = undefined; setToast(''); return; }
+    setToast(next);
+    toastTimer.current = window.setTimeout(advanceToast, 3000);
   }, []);
+  const showToast = useCallback((msg: string) => {
+    toastQueue.current.push(msg);
+    if (toastTimer.current === undefined) advanceToast(); // nothing showing → start now
+  }, [advanceToast]);
+  const dismissToast = useCallback(() => {
+    if (toastTimer.current !== undefined) { window.clearTimeout(toastTimer.current); toastTimer.current = undefined; }
+    advanceToast(); // skip to the next queued toast (or clear if none)
+  }, [advanceToast]);
   // Error banners auto-dismiss after a few seconds (longer than toasts since
   // they may be multi-line). The X button still closes them immediately.
   useEffect(() => {
@@ -507,6 +542,12 @@ export default function App() {
     if (forCall !== undefined) recordingCallRef.current = forCall.trim().toUpperCase();
     QSOAudioRestart().then((active) => { setRecording(active); setRecTick((t) => t + 1); }).catch(() => {});
   };
+  // Reset the recording to zero (drop everything so far, pre-roll included) —
+  // bound to clicking the REC timer. Use when the station was already in a long
+  // QSO and you only want your own exchange in the file.
+  const resetRecordingClock = () => {
+    QSOAudioResetClock().then((active) => { setRecording(active); setRecTick((t) => t + 1); }).catch(() => {});
+  };
   const [saving, setSaving] = useState(false);
   const [filterCallsign, setFilterCallsign] = useState('');
   // Advanced filter builder (replaces the old band/mode dropdowns).
@@ -689,6 +730,10 @@ export default function App() {
   }
   const chatShown = chatOpen && chatAvailable;
 
+  // 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]);
+
   const [dvkEnabled, setDvkEnabled] = useState(false);
   const [dvkMsgs, setDvkMsgs] = useState<DVKMsg[]>([]);
   const [dvkStat, setDvkStat] = useState<DVKStat>({ recording: false, playing: false, rec_slot: 0 });
@@ -729,7 +774,7 @@ export default function App() {
   const [clusterLockMode, setClusterLockMode] = useState(false);
   // Status filter chips. Empty set = show every status (including
   // already-worked). Otherwise only matching spots pass.
-  type SpotStatusKey = 'new' | 'new-band' | 'new-slot' | 'worked';
+  type SpotStatusKey = 'new' | 'new-band' | 'new-mode' | 'new-slot' | 'worked';
   const [clusterStatusFilter, setClusterStatusFilter] = useState<Set<SpotStatusKey>>(new Set());
   // Mode filter chips. Empty set = show every mode. Categories map the
   // inferred per-spot mode onto SSB (phone) / CW / DATA (digital).
@@ -772,11 +817,12 @@ export default function App() {
   // map ("map1"), the locator street map ("map2"), the cluster grid or the
   // worked-before grid. Per-profile (stored via SetUIPref → profile-prefixed),
   // so it's loaded async on mount and re-read on profile:changed below.
-  type MainPaneKind = 'map1' | 'map2' | 'cluster' | 'worked' | 'flex';
+  type MainPaneKind = 'map1' | 'map2' | 'cluster' | 'worked' | 'flex' | 'recent';
+  const [mapZoomSignal, setMapZoomSignal] = useState(0); // bump → world map auto-zooms now
   const [mainPaneLeft, setMainPaneLeft] = useState<MainPaneKind>('map1');
   const [mainPaneRight, setMainPaneRight] = useState<MainPaneKind>('map2');
   const loadMainPanes = useCallback(async () => {
-    const valid = (v: string): v is MainPaneKind => v === 'map1' || v === 'map2' || v === 'cluster' || v === 'worked' || v === 'flex';
+    const valid = (v: string): v is MainPaneKind => v === 'map1' || v === 'map2' || v === 'cluster' || v === 'worked' || v === 'flex' || v === 'recent';
     const [l, r] = await Promise.all([
       GetUIPref('mainPaneLeft').catch(() => ''),
       GetUIPref('mainPaneRight').catch(() => ''),
@@ -1048,6 +1094,12 @@ export default function App() {
     return () => { offUploaded(); offDone(); offEqsl(); if (t) window.clearTimeout(t); };
   }, [refresh]);
 
+  // Backend-emitted toast messages (e.g. recording auto-send result/skip).
+  useEffect(() => {
+    const off = EventsOn('toast', (msg: any) => { if (msg) showToast(String(msg)); });
+    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(() => {
@@ -1235,12 +1287,20 @@ export default function App() {
   // source behaves identically.
   function handleSpotClick(s: any) {
     const m = inferSpotMode(s.comment ?? '', s.freq_hz);
-    if (catState.connected) {
-      tuneRigCAT(s.freq_hz, m);
-    } else {
-      setFreqMhz((s.freq_hz / 1_000_000).toFixed(5));
-      if (s.band) setBand(s.band);
+    // Reflect the spot's freq/band in the entry strip IMMEDIATELY (optimistic),
+    // then tune the rig if CAT is connected. We must not wait for the CAT status
+    // echo to update the display: on a remote Flex link that echo lags by seconds,
+    // so the frequency used to only catch up once you nudged the VFO. noteManualEdit()
+    // freezes the CAT-driven overwrite for 1.5s so a stale in-flight status can't
+    // revert the optimistic value before the new freq is reported back.
+    if (s.freq_hz && s.freq_hz > 0) {
+      const mhz = (s.freq_hz / 1_000_000).toFixed(5);
+      setFreqMhz(mhz);
+      setRxFreqMhz(mhz);
+      noteManualEdit();
     }
+    if (s.band) setBand(s.band);
+    if (catState.connected) tuneRigCAT(s.freq_hz, m);
     if (m) applyModeFromSpot(m);
     onCallsignInput(s.dx_call, { force: true });
     applySpotPOTA((s as any).pota_ref);
@@ -1372,6 +1432,19 @@ export default function App() {
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 
+  // FlexRadio: apply the per-band RX/TX antennas whenever the band changes (rig
+  // QSY, spot click, manual band) — so the right antennas follow the frequency.
+  // Skipped while the band is LOCKED (entering an old QSO off-air) and for non-Flex
+  // backends. The backend no-ops if the band has no configured mapping.
+  const lastAntBandRef = useRef('');
+  useEffect(() => {
+    if (catState.backend !== 'flex' || locks.band) return;
+    const b = band.trim();
+    if (!b || b === lastAntBandRef.current) return;
+    lastAntBandRef.current = b;
+    FlexApplyBandAntenna(b).catch(() => {});
+  }, [band, catState.backend, locks.band]);
+
   // Cluster live wiring: hydrate per-server status + saved server list,
   // then subscribe to push events.
   async function reloadClusterMeta() {
@@ -1430,30 +1503,38 @@ export default function App() {
     // typing: only update when the field is empty, already shows this call, or
     // still shows the previous broadcast (i.e. the field content is ours, not
     // a different call the user typed). Returns true if it actually changed.
-    const applyUdpCall = (raw: string): boolean => {
+    // force = true means an EXPLICIT action (a panadapter/spot click, a remote
+    // "set call" command) that should always win, even over a call the operator
+    // already typed. Only WSJT-X's CONTINUOUS DX-call stream keeps the no-clobber
+    // guard (it re-broadcasts constantly and must not fight what you typed).
+    const applyUdpCall = (raw: string, force = false): boolean => {
       const call = String(raw ?? '').trim();
       if (!call) return false;
       const upper = call.toUpperCase();
       const current = callsignValRef.current.trim().toUpperCase();
       const prev = lastUdpCallRef.current;
       lastUdpCallRef.current = upper; // remember this broadcast either way
-      if (current === upper) return false;                       // already shown → no-op
-      if (current !== '' && current !== prev) return false;      // user typed a different call → leave it
+      if (current === upper) return false;                              // already shown → no-op
+      if (!force && current !== '' && current !== prev) return false;   // user typed a different call → leave it
       onCallsignInput(call, { force: true }); // programmatic → always look up
       return true;
     };
     const unsubDX = EventsOn('udp:dx_call', (p: any) => {
+      // Anything that isn't WSJT-X (N1MM, ADIF, a panadapter/cluster click relayed
+      // over UDP…) is an explicit pick → force it over an existing call.
+      const force = String(p?.service ?? '').toLowerCase() !== 'wsjt';
       // External app moved to a new station → fresh recording for the new target.
-      if (applyUdpCall(p?.call)) restartRecordingForNewTarget(String(p?.call ?? ''));
+      if (applyUdpCall(p?.call, force)) restartRecordingForNewTarget(String(p?.call ?? ''));
     });
     const unsubRC = EventsOn('udp:remote_call', (raw: string) => {
-      if (applyUdpCall(raw)) restartRecordingForNewTarget(String(raw ?? ''));
+      if (applyUdpCall(raw, true)) restartRecordingForNewTarget(String(raw ?? '')); // explicit remote pick
     });
     // Clicked one of OpsLog's spots on the FlexRadio panadapter → fill the call
     // (the radio already tuned via trigger_action=Tune, and CAT reads the freq).
+    // An explicit click always wins over whatever call is currently in the field.
     const unsubFlexSpot = EventsOn('flex:spot_clicked', (p: any) => {
       const call = String(p?.call ?? '');
-      if (applyUdpCall(call)) restartRecordingForNewTarget(call);
+      if (applyUdpCall(call, true)) restartRecordingForNewTarget(call);
     });
     const unsubProg = EventsOn('import:progress', (p: any) => {
       setImportProgress({ processed: Number(p?.processed ?? 0), total: Number(p?.total ?? 0) });
@@ -1550,7 +1631,7 @@ export default function App() {
       GRID: station.my_grid || '', COUNTRY: (station as any).my_country || '',
       MY_QTH: (station as any).my_city || '', MY_RIG: details.my_rig || '', MY_ANTENNA: details.my_antenna || '',
       MY_IOTA: (station as any).my_iota || '', MY_SOTA: (station as any).my_sota_ref || '',
-      CONT_RX: details.srx != null ? String(details.srx) : '', CONT_TX: details.stx != null ? String(details.stx) : '',
+      CONT_RX: details.srx_string || '', CONT_TX: details.stx_string || '',
     };
     let out = text.replace(/<([A-Z_]+)>/g, (_m, k) => vars[k] ?? '');
     out = out.replace(/\*/g, myCall).replace(/!/g, his);
@@ -1565,15 +1646,22 @@ export default function App() {
   }
   async function wkSend(rawText: string) {
     setWkSent('');
+    const resolved = resolveCW(rawText);
     const doLog = /<LOGQSO>/i.test(rawText); // resolveCW strips the token (unknown var → "")
-    await WinkeyerSend(resolveCW(rawText)).catch((e) => setError(String(e?.message ?? e)));
+    await WinkeyerSend(resolved).catch((e) => setError(String(e?.message ?? e)));
     // <LOGQSO> (e.g. "BK 73 TU <LOGQSO>") logs the contact AFTER the keyer has
-    // finished sending — wait for the busy flag to rise then fall, so the QSO
-    // isn't logged (and the form cleared) while the CW is still going out.
+    // finished sending — so the QSO isn't logged (and the form cleared) while CW
+    // is still going out. We'd like to wait for the busy flag to rise then fall,
+    // but over a remote/serial-over-IP link that status echo can lag by tens of
+    // seconds, which used to delay logging ~50s. So cap the wait at the ESTIMATED
+    // send duration (text length × WPM) plus slack: log when busy clears OR the
+    // estimate elapses, whichever comes first.
     if (!doLog) return;
     const sleep = (ms: number) => new Promise((r) => window.setTimeout(r, ms));
+    const capMs = Math.round(estimateCwMs(resolved, wkWpm) * 1.4) + 2500; // slack for keyer buffering/lag
     for (let i = 0; i < 20 && !wkBusyRef.current; i++) await sleep(50); // ≤1s for sending to start
-    for (let i = 0; i < 1200 && wkBusyRef.current; i++) await sleep(50); // ≤60s for it to finish
+    const deadline = Date.now() + capMs;
+    while (wkBusyRef.current && Date.now() < deadline) await sleep(50);
     void save();
   }
   // stopAutoCall cancels any running auto-call loop.
@@ -1588,8 +1676,14 @@ export default function App() {
       const m = wkMacros[i];
       if (!m) break;
       await wkSend(m.text);
-      for (let k = 0; k < 20 && !wkBusyRef.current && gen === autoCallGenRef.current; k++) await sleep(50);   // ≤1s to start
-      for (let k = 0; k < 2400 && wkBusyRef.current && gen === autoCallGenRef.current; k++) await sleep(50);  // ≤120s to finish
+      // Wait for the message to finish before the gap+resend. Cap the wait at the
+      // ESTIMATED send time (not the busy flag alone): over a remote/serial-over-IP
+      // link the keyer's "busy" status lags badly and stays stuck true for tens of
+      // seconds, which made the next CQ fire ~120s late — i.e. auto-call looked dead.
+      const capMs = Math.round(estimateCwMs(resolveCW(m.text), wkWpm) * 1.4) + 2500;
+      for (let k = 0; k < 20 && !wkBusyRef.current && gen === autoCallGenRef.current; k++) await sleep(50); // ≤1s to start
+      const deadline = Date.now() + capMs;
+      while (wkBusyRef.current && gen === autoCallGenRef.current && Date.now() < deadline) await sleep(50);
       if (gen !== autoCallGenRef.current) break;
       await sleep(Math.max(0, wkAutoCallSecsRef.current) * 1000); // the gap before the next call
     }
@@ -1680,6 +1774,10 @@ export default function App() {
       // when you first entered the call (minutes early) and won't match LoTW.
       const startEqualsEnd = localStorage.getItem('opslog.startEqualsEnd') === '1';
       const start = (startEqualsEnd && !locks.start) ? end : baseStart;
+      // Contest exchanges: a purely-numeric exchange → ADIF SRX/STX (int); an
+      // alphanumeric one (e.g. a section/zone) → SRX_STRING/STX_STRING.
+      const srxE = exchangeFields(details.srx_string);
+      const stxE = exchangeFields(details.stx_string);
       const payload: any = {
         callsign: callsign.trim().toUpperCase(),
         qso_date: start.toISOString(),
@@ -1698,13 +1796,11 @@ export default function App() {
         tx_pwr: details.tx_pwr,
         sat_name: details.sat_name, sat_mode: details.sat_mode,
         contest_id: details.contest_id,
-        srx: details.srx, stx: details.stx,
+        srx: srxE.num, stx: stxE.num, srx_string: srxE.str, stx_string: stxE.str,
         email: details.email,
       };
       applyAwardRefs(payload, details.award_refs ?? '', awardFieldRef.current);
       await AddQSO(payload);
-      // Same green toast as a QSL upload, so the op gets visual confirmation.
-      showToast(`QSO logged — ${payload.callsign}${band ? ` · ${band}` : ''}${mode ? ` ${mode}` : ''}`);
       resetEntry(); // clears the call AND the Worked-before matrix
       callsignRef.current?.focus(); // return focus to the call field, wherever it was (e.g. Name)
       await refresh();
@@ -1896,6 +1992,11 @@ export default function App() {
     setLookupBusy(true);
     try {
       const r = await LookupCallsign(call);
+      // Discard a STALE result: the operator already moved to another call
+      // (clicked a new spot / typed) while this lookup was in flight. Applying it
+      // would clobber the current call's fields and zoom the map to the wrong
+      // station — the bug where replacing a call didn't re-zoom the map.
+      if (call !== callsignValRef.current.trim().toUpperCase()) return;
       lastLookedUpRef.current = call;
       // cty.dat carries ONLY DXCC-entity data (country / CQ / ITU zones / continent).
       // A QRZ/HamQTH hit is far richer (name, QTH, grid, address, image). When the
@@ -1933,6 +2034,9 @@ export default function App() {
         qsl_via: d.qsl_via || (r.qsl_via ?? ''),
       }));
       if (r.dxcc && r.dxcc > 0) runWorkedBefore(call, r.dxcc);
+      // The DX location is now known (grid set above) — force the world map to
+      // auto-zoom right away, so it doesn't lag behind the resolved QSO.
+      setMapZoomSignal((n) => n + 1);
       // Recording: tie it to the resolved callsign. Start once a real (≥3-char)
       // call resolves — covers the fast CW workflow (type → Enter, no blur). If
       // we're already recording a DIFFERENT call (the operator edited the
@@ -1983,8 +2087,14 @@ export default function App() {
     // applyUdpCall saw current != lastUdpCall and refused every later UDP call.
     if (opts?.force) lastUdpCallRef.current = v.trim().toUpperCase();
     // A callsign appeared (someone answered the CQ, or a spot was clicked) →
-    // stop auto-calling so we don't key over the contact.
-    if (v.trim() !== '') stopAutoCall();
+    // stop auto-calling so we don't key over the contact. If a CQ was actually
+    // in flight, abort the current transmission too so it stops IMMEDIATELY
+    // rather than finishing the buffered call. (autoCallMacroRef flips to -1 on
+    // the first keystroke, so we only abort once.)
+    if (v.trim() !== '') {
+      if (autoCallMacroRef.current !== -1) WinkeyerStop().catch(() => {});
+      stopAutoCall();
+    }
     // No-op guard: external apps (MSHV/WSJT-X) re-broadcast the same DX call
     // on every status packet. If it matches what's already in the entry,
     // do nothing — otherwise we'd re-run the QRZ lookup, hit the cache and
@@ -2098,6 +2208,8 @@ export default function App() {
       { type: 'item', label: dvkEnabled ? '✓ Digital Voice Keyer' : 'Digital Voice Keyer', action: 'tools.dvk' },
       { 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: 'separator' },
       // Maintenance — bumped here while we only have one entry. Will move
       // to a Tools → Maintenance submenu once Clublog + LoTW refresh land.
       { type: 'item', label: ctyRefreshing ? 'Refreshing cty.dat…' : 'Refresh cty.dat', action: 'tools.refreshCty', disabled: ctyRefreshing },
@@ -2106,7 +2218,7 @@ export default function App() {
     { name: 'help', label: 'Help', items: [
       { type: 'item', label: 'About OpsLog', action: 'help.about' },
     ]},
-  ], [total, selectedId, selectedIds, ctyRefreshing, refsDownloading, exporting, wkEnabled, dvkEnabled, cwEnabled]);
+  ], [total, selectedId, selectedIds, ctyRefreshing, refsDownloading, exporting, wkEnabled, dvkEnabled, cwEnabled, netEnabled]);
 
   function handleMenu(action: string) {
     switch (action) {
@@ -2124,6 +2236,7 @@ export default function App() {
       case 'tools.winkeyer':    wkSetEnabled(!wkEnabled); break;
       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.refreshCty':  refreshCtyDat(); break;
       case 'tools.downloadRefs': downloadRefs(); break;
       case 'help.about':        setShowAbout(true); break;
@@ -2247,10 +2360,16 @@ export default function App() {
       </Label>
       <div className="relative">
       {recording && RECORDABLE_MODES.has(mode.toUpperCase()) && (
-        <span className="absolute right-2 top-1/2 -translate-y-1/2 z-10 inline-flex items-center gap-1 text-[10px] font-semibold tabular-nums text-red-600 whitespace-nowrap pointer-events-none">
+        <button
+          type="button"
+          onMouseDown={(e) => e.preventDefault()}
+          onClick={resetRecordingClock}
+          title="Click to restart the recording from 0 — drops everything captured so far (incl. pre-roll) so the file holds only your exchange"
+          className="absolute right-2 top-1/2 -translate-y-1/2 z-10 inline-flex items-center gap-1 text-[10px] font-semibold tabular-nums text-red-600 whitespace-nowrap cursor-pointer rounded px-1 hover:bg-red-50"
+        >
           <span className="size-2 rounded-full bg-red-600 animate-pulse" />
           {String(Math.floor(recSeconds / 60)).padStart(2, '0')}:{String(recSeconds % 60).padStart(2, '0')}
-        </span>
+        </button>
       )}
       <Input
         ref={callsignRef}
@@ -2638,8 +2757,9 @@ export default function App() {
             {([
               { 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-mode' as SpotStatusKey, label: 'NEW MODE',  cls: 'bg-yellow-100 text-yellow-800 border-yellow-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' },
+              // (no WORKED chip — use the "Hide worked" checkbox to drop dupes.)
             ]).map((s) => {
               const on = clusterStatusFilter.has(s.k);
               return (
@@ -2712,6 +2832,7 @@ export default function App() {
             toLabel={callsign}
             beamAzimuths={showBeamOnMap ? beamHeadings : []}
             boomAzimuth={showBeamOnMap && ubPattern && ubPattern !== 'normal' ? boomHeading : null}
+            zoomSignal={mapZoomSignal}
           />
         );
       case 'map2':
@@ -2736,13 +2857,35 @@ export default function App() {
           <div className="h-full w-full min-h-0 flex flex-col bg-card border border-border rounded-lg overflow-hidden">
             <WorkedBeforeGrid wb={wbWithAwards as any} awardCols={awardCols} 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)} />
+              onSendTo={bulkSendTo} onSendRecording={bulkSendRecording} onSendEQSL={(ids) => setEqslQsoId(ids[0] ?? null)} onDelete={(ids) => setDeletingIds(ids)} />
           </div>
         );
       case 'flex':
         return (
           <div className="h-full w-full min-h-0 rounded-lg overflow-hidden border border-border">
-            <FlexPanel />
+            <FlexPanel onCWSpeed={(w) => { setWkWpm(w); WinkeyerSetSpeed(w).catch(() => {}); saveWk({ wpm: w }); }} />
+          </div>
+        );
+      case 'recent':
+        return (
+          <div className="h-full w-full min-h-0 flex flex-col bg-card border border-border rounded-lg overflow-hidden">
+            <RecentQSOsGrid
+              rows={qsosWithAwards as any}
+              total={total}
+              awardCols={awardCols}
+              onRowDoubleClicked={(q) => openEdit(q.id as number)}
+              onUpdateFromCty={bulkUpdateFromCty}
+              onUpdateFromQRZ={bulkUpdateFromQRZ}
+              onUpdateFromClublog={bulkUpdateFromClublog}
+              onSendTo={bulkSendTo}
+              onSendRecording={bulkSendRecording}
+              onSendEQSL={(ids) => setEqslQsoId(ids[0] ?? null)}
+              onBulkEdit={openBulkEdit}
+              onExportSelected={exportSelectedADIF}
+              onExportFiltered={exportFilteredADIF}
+              onDelete={(ids) => setDeletingIds(ids)}
+              onRowSelected={(ids) => { setSelectedIds(ids); setSelectedId(ids[0] ?? null); }}
+            />
           </div>
         );
     }
@@ -2800,7 +2943,7 @@ export default function App() {
                   <div className="flex items-center gap-1.5 rounded-md border border-emerald-300 bg-emerald-50 text-emerald-800 px-2.5 py-1 text-xs shadow min-w-0 animate-in fade-in">
                     <Satellite className="size-3.5 shrink-0" />
                     <span className="truncate" title={toast}>{toast}</span>
-                    <button className="shrink-0 text-emerald-600 hover:text-emerald-800" onClick={() => setToast('')}><X className="size-3" /></button>
+                    <button className="shrink-0 text-emerald-600 hover:text-emerald-800" onClick={dismissToast}><X className="size-3" /></button>
                   </div>
                 )}
               </div>
@@ -3448,6 +3591,21 @@ export default function App() {
               </TabsTrigger>
               <TabsTrigger value="awards">Awards</TabsTrigger>
               <TabsTrigger value="bandmap">Band Map</TabsTrigger>
+              {netEnabled && (
+                <TabsTrigger value="net" className="gap-1.5">
+                  Net
+                  <span
+                    role="button"
+                    aria-label="Close Net"
+                    title="Close"
+                    className="inline-flex items-center justify-center size-4 rounded hover:bg-foreground/10 text-muted-foreground hover:text-foreground"
+                    onPointerDown={(e) => { e.stopPropagation(); }}
+                    onClick={(e) => { e.stopPropagation(); setNetEnabled(false); setActiveTab((t) => (t === 'net' ? 'recent' : t)); }}
+                  >
+                    <X className="size-3" />
+                  </span>
+                </TabsTrigger>
+              )}
               {catState.backend === 'flex' && <TabsTrigger value="flex">FlexRadio</TabsTrigger>}
               {catState.backend === 'icom' && <TabsTrigger value="icom">Icom</TabsTrigger>}
               {/* Not a tab — QRZ blocks embedding, so this opens the call's
@@ -3554,6 +3712,7 @@ export default function App() {
                 onBulkEdit={openBulkEdit}
                 onExportSelected={exportSelectedADIF}
                 onExportFiltered={exportFilteredADIF}
+                onDelete={(ids) => setDeletingIds(ids)}
                 onRowSelected={(ids) => { setSelectedIds(ids); setSelectedId(ids[0] ?? null); }}
               />
               <div className="px-3 py-1.5 border-t border-border/60 text-[11px] text-muted-foreground flex items-center justify-between gap-3 bg-muted/30">
@@ -3729,7 +3888,7 @@ export default function App() {
             <TabsContent value="worked" className="mt-0 flex flex-col min-h-0 flex-1">
               <WorkedBeforeGrid wb={wbWithAwards as any} awardCols={awardCols} 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)} />
+                onSendEQSL={(ids) => setEqslQsoId(ids[0] ?? null)} onDelete={(ids) => setDeletingIds(ids)} />
             </TabsContent>
 
             {/* Opened on demand from Tools → QSL Manager; closable via the
@@ -3759,7 +3918,7 @@ export default function App() {
                 backend is a FlexRadio. */}
             {catState.backend === 'flex' && (
               <TabsContent value="flex" className="flex-1 min-h-0 p-0">
-                <FlexPanel />
+                <FlexPanel onCWSpeed={(w) => { setWkWpm(w); WinkeyerSetSpeed(w).catch(() => {}); saveWk({ wpm: w }); }} />
               </TabsContent>
             )}
 
@@ -3774,6 +3933,12 @@ export default function App() {
             {/* Band Map: several bands shown side-by-side (panadapter-style
                 strips). Pick bands with the chips; each strip is clickable to
                 tune the rig. */}
+            {netEnabled && (
+              <TabsContent value="net" className="mt-0 flex flex-col min-h-0 flex-1">
+                <NetControlPanel onLogged={refresh} countries={countries} bands={bands} modes={modes} />
+              </TabsContent>
+            )}
+
             <TabsContent value="bandmap" className="mt-0 flex flex-col min-h-0 flex-1">
               <div className="flex items-center gap-1 px-3 py-1.5 border-b border-border/60 shrink-0 flex-wrap">
                 <span className="text-xs text-muted-foreground mr-1">Bands:</span>

frontend/src/components/ClusterGrid.tsx

@@ -1,4 +1,4 @@
-import { useCallback, useMemo, useRef, useState } from 'react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import {
   AllCommunityModule, ModuleRegistry, themeQuartz,
   type ColDef, type ColumnState, type GridReadyEvent, type RowClickedEvent,
@@ -121,6 +121,7 @@ function statusBadge(s: SpotStatusEntry | undefined): { text: string; fg: string
   switch (s?.status) {
     case 'new':      return { text: 'NEW DXCC', fg: '#be123c', bg: '#ffe4e6' };
     case 'new-band': return { text: 'NEW BAND', fg: '#92400e', bg: '#fde68a' };
+    case 'new-mode': return { text: 'NEW MODE', fg: '#854d0e', bg: '#fef08a' };
     case 'new-slot': return { text: 'NEW SLOT', fg: '#854d0e', bg: '#fef08a' };
     default:         return s?.worked_call ? { text: 'WKD CALL', fg: '#0369a1', bg: '#e0f2fe' } : null;
   }
@@ -159,6 +160,7 @@ const COL_CATALOG: ColEntry[] = [
       const s = statusFor(p);
       if (s?.status === 'new') return 'NEW DXCC';
       if (s?.status === 'new-band') return 'NEW BAND';
+      if (s?.status === 'new-mode') return 'NEW MODE';
       if (s?.status === 'new-slot') return 'NEW SLOT';
       return s?.worked_call ? 'WKD CALL' : '';
     },
@@ -212,12 +214,22 @@ const COL_CATALOG: ColEntry[] = [
     defaultVisible: true,
     cellClass: 'font-mono',
     valueGetter: (p: any) => p.data ? inferSpotMode(p.data.comment ?? '', p.data.freq_hz) : '',
-    // NEW SLOT (mode not yet worked on this band) → fill the cell.
-    cellStyle: (p: any) => (statusFor(p)?.status === 'new-slot'
-      ? { backgroundColor: '#fef08a', color: '#854d0e', fontWeight: 700 }
-      : undefined),
+    // Fill the mode cell: teal = NEW MODE (mode never worked on this entity),
+    // yellow = NEW SLOT (this band+mode combo new, but the mode was worked elsewhere).
+    cellStyle: (p: any) => {
+      const st = statusFor(p)?.status;
+      // Both NEW MODE and NEW SLOT highlight the mode cell (same yellow); the
+      // Status badge text tells them apart.
+      if (st === 'new-mode' || st === 'new-slot') return { backgroundColor: '#fef08a', color: '#854d0e', fontWeight: 700 };
+      return undefined;
+    },
     cellRenderer: (p: any) => p.value ? p.value : <span style={{ color: '#a8a29e', fontSize: 10 }}>—</span>,
-    tooltipValueGetter: (p: any) => (statusFor(p)?.status === 'new-slot' ? 'NEW SLOT (mode not yet worked on this band)' : undefined),
+    tooltipValueGetter: (p: any) => {
+      const st = statusFor(p)?.status;
+      if (st === 'new-mode') return 'NEW MODE (this mode never worked on this entity)';
+      if (st === 'new-slot') return 'NEW SLOT (this band+mode not yet worked)';
+      return undefined;
+    },
   },
   {
     group: 'Spot', label: 'Pfx', colId: 'pfx',
@@ -327,6 +339,14 @@ export function ClusterGrid({ rows, spotStatus, onSpotClick }: Props) {
   // change below.
   const context = useMemo(() => ({ spotStatus }), [spotStatus]);
 
+  // Spot statuses arrive asynchronously (~after the rows render). The Call/Band/
+  // Mode cellStyles depend on them but their cell VALUE doesn't change, so ag-grid
+  // won't re-render those cells on its own — force a refresh so e.g. a worked call
+  // turns blue once its status loads.
+  useEffect(() => {
+    gridRef.current?.api?.refreshCells({ force: true });
+  }, [spotStatus]);
+
   function onGridReady(e: GridReadyEvent) {
     const local = loadLocal(COL_STATE_KEY);
     if (local) e.api.applyColumnState({ state: local as ColumnState[], applyOrder: true });

frontend/src/components/DetailsPanel.tsx

@@ -35,8 +35,11 @@ export interface DetailsState {
   sat_name: string;
   sat_mode: string;
   contest_id: string;
-  srx?: number;
-  stx?: number;
+  // Contest exchanges as free text — most are serials (001) but some are
+  // alphanumeric (e.g. a section/zone like "ON4"). Stored to ADIF SRX/STX when
+  // purely numeric, else to SRX_STRING/STX_STRING (handled in App on save).
+  srx_string?: string;
+  stx_string?: string;
   email: string;
   // Award references for the contacted station (set via the Awards tab picker).
   // Semicolon-delimited "AWARD@REF" entries, e.g. "POTA@FR-11553;IOTA@EU-064".
@@ -371,10 +374,10 @@ export function DetailsPanel({ callsign, prefix, operatorGrid, remoteGrid, detai
             <Input value={details.contest_id} onChange={(e) => onChange({ contest_id: e.target.value })} />
           </Field>
           <Field label="SRX">
-            <Input type="number" value={details.srx ?? ''} onChange={(e) => onChange({ srx: numOrUndef(e.target.value) })} />
+            <Input value={details.srx_string ?? ''} placeholder="rcvd exchange" onChange={(e) => onChange({ srx_string: e.target.value })} />
           </Field>
           <Field label="STX">
-            <Input type="number" value={details.stx ?? ''} onChange={(e) => onChange({ stx: numOrUndef(e.target.value) })} />
+            <Input value={details.stx_string ?? ''} placeholder="sent exchange" onChange={(e) => onChange({ stx_string: e.target.value })} />
           </Field>
           <Field label="Contacted email" span={3}>
             <Input value={details.email} placeholder="[email protected]" onChange={(e) => onChange({ email: e.target.value })} />

frontend/src/components/FlexPanel.tsx

@@ -1,11 +1,11 @@
 import { useEffect, useRef, useState } from 'react';
-import { Radio, Zap, Power, AudioLines, Flame, Gauge } from 'lucide-react';
+import { Radio, Zap, Power, AudioLines, Flame, Gauge, Volume2, VolumeX } from 'lucide-react';
 import {
   GetFlexState, FlexSetPower, FlexSetTunePower, FlexTune, FlexSetVox, FlexSetVoxLevel, FlexSetVoxDelay,
   FlexSetProcessor, FlexSetProcessorLevel, FlexSetMon, FlexSetMonLevel, FlexSetMic,
   FlexMox, FlexAmpOperate,
   GetPGXLStatus, PGXLSetFanMode,
-  FlexSetAGCMode, FlexSetAGCThreshold, FlexSetAudioLevel,
+  FlexSetAGCMode, FlexSetAGCThreshold, FlexSetAudioLevel, FlexSetMute, FlexSetRXAntenna, FlexSetTXAntenna, FlexSetSplit,
   FlexSetNB, FlexSetNBLevel, FlexSetNR, FlexSetNRLevel, FlexSetANF, FlexSetANFLevel,
   FlexSetAPF, FlexSetAPFLevel, FlexSetCWSpeed, FlexSetCWPitch, FlexSetCWBreakInDelay,
   FlexSetCWSidetone, FlexSetSidetoneLevel, FlexSetCWFilter, FlexSetFilter,
@@ -19,7 +19,9 @@ type FlexState = {
   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;
+  rx_avail: boolean; agc_mode?: string; agc_threshold: number; audio_level: number; mute: boolean;
+  rx_ant?: string; tx_ant?: string; ant_list?: string[]; tx_ant_list?: string[];
+  split: boolean; rx_freq_hz?: number; tx_freq_hz?: number;
   nb: boolean; nb_level: number; nr: boolean; nr_level: number; anf: boolean; anf_level: number;
   mode?: string;
   cw_speed: number; cw_pitch: number; cw_break_in_delay: number; cw_sidetone: boolean; cw_mon_level: number;
@@ -34,7 +36,7 @@ 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,
+  rx_avail: false, agc_threshold: 0, audio_level: 0, mute: false, split: false,
   nb: false, nb_level: 0, nr: false, nr_level: 0, anf: false, anf_level: 0,
   cw_speed: 25, cw_pitch: 600, cw_break_in_delay: 30, cw_sidetone: true, cw_mon_level: 0,
   apf: false, apf_level: 0, filter_lo: 0, filter_hi: 0,
@@ -110,8 +112,11 @@ function Chip({ on, onClick, label, disabled, accent = 'emerald' }: {
   }[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')}>
+      className={cn(
+        // min width (not fixed) so a longer label like STONE keeps symmetric
+        // padding instead of overflowing; short labels (NB/NR/APF) stay aligned.
+        'min-w-[3.5rem] shrink-0 px-2.5 py-1 rounded-md text-[11px] font-bold border text-center tracking-wide transition-all disabled:opacity-30',
+        on ? cn(onCls, 'shadow-sm') : 'bg-card text-muted-foreground border-border hover:bg-muted hover:border-muted-foreground/30')}>
       {label}
     </button>
   );
@@ -182,7 +187,9 @@ function Card({ icon: Icon, title, accent, children }: { icon: any; title: strin
   );
 }
 
-export function FlexPanel() {
+// onCWSpeed (optional): notified when the operator changes CW speed here, so the
+// host can keep the WinKeyer (which actually sends the macros) in sync.
+export function FlexPanel({ onCWSpeed }: { onCWSpeed?: (wpm: number) => void } = {}) {
   const [st, setSt] = useState<FlexState>(ZERO);
   const hold = useRef<Record<string, number>>({});
   // Peak-hold: keep the highest reading for ~2 s so the jittery VITA-49 meters
@@ -238,8 +245,15 @@ export function FlexPanel() {
   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' }];
   const CW_BW = [100, 200, 300, 400, 500];
-  const SSB_BW = [1800, 2100, 2400, 2800, 3000, 4000, 6000];
+  const SSB_BW = [1800, 2100, 2400, 2700, 3000, 4000, 6000];
   const curBW = Math.max(0, (st.filter_hi || 0) - (st.filter_lo || 0));
+  // Highlight the preset CLOSEST to the radio's actual filter width. The rig
+  // rarely reports a width that lands exactly on a preset (e.g. 2.7k presets as
+  // 100–2790), so an exact/±50 match would leave nothing lit — "doesn't pick up
+  // the current filter". Snapping to the nearest preset always reflects the rig.
+  const ssbActiveBW = curBW > 0
+    ? SSB_BW.reduce((best, bw) => (Math.abs(bw - curBW) < Math.abs(best - curBW) ? bw : best), SSB_BW[0])
+    : -1;
 
   return (
     <div className="h-full min-h-0 overflow-auto bg-background">
@@ -295,6 +309,21 @@ export function FlexPanel() {
                 <Power className="size-4 inline mr-1 -mt-0.5" /> MOX
               </button>
             </div>
+            <div className="flex items-center gap-2">
+              <button type="button" disabled={off}
+                title="Split: RX/TX on separate slices. ON creates a TX slice +1 kHz (CW) / +5 kHz (SSB) up, like SmartSDR."
+                onClick={() => change('split', !st.split, () => FlexSetSplit(!st.split))}
+                className={cn('px-3 py-1.5 rounded-lg text-sm font-extrabold tracking-wide border-2 transition-all disabled:opacity-30',
+                  st.split ? 'bg-sky-600 text-white border-sky-600 shadow-[0_0_12px] shadow-sky-600/50' : 'bg-card text-sky-700 border-sky-400 hover:bg-sky-50')}>
+                SPLIT
+              </button>
+              {st.split && !!st.tx_freq_hz && (
+                <span className="text-[11px] font-mono text-muted-foreground whitespace-nowrap">
+                  TX {(st.tx_freq_hz / 1e6).toFixed(3)}
+                  {!!st.rx_freq_hz && ` (${(st.tx_freq_hz - st.rx_freq_hz) >= 0 ? '+' : ''}${((st.tx_freq_hz - st.rx_freq_hz) / 1000).toFixed(1)} kHz)`}
+                </span>
+              )}
+            </div>
 
             {!isCW ? (
             <div className="border-t border-border/60 pt-3 space-y-3">
@@ -328,7 +357,7 @@ export function FlexPanel() {
             <div className="border-t border-border/60 pt-3 space-y-3">
               <div className="flex items-center gap-2">
                 <span className="w-16 shrink-0 text-[11px] font-bold text-muted-foreground">Speed</span>
-                <Slider value={st.cw_speed} disabled={off} max={60} accent="#0d9488" onChange={(v) => change('cw_speed', v, () => FlexSetCWSpeed(v))} />
+                <Slider value={st.cw_speed} disabled={off} max={60} accent="#0d9488" onChange={(v) => { change('cw_speed', v, () => FlexSetCWSpeed(v)); onCWSpeed?.(v); }} />
                 <span className="w-12 text-right text-xs font-mono tabular-nums text-muted-foreground">{st.cw_speed} wpm</span>
               </div>
               <div className="flex items-center gap-2">
@@ -350,20 +379,46 @@ export function FlexPanel() {
 
           {/* RECEIVE */}
           <Card icon={AudioLines} title="Receive (active slice)" accent="#0891b2">
+            {((st.ant_list?.length ?? 0) > 0 || (st.tx_ant_list?.length ?? 0) > 0) && (
+              <div className="flex items-center gap-2">
+                <span className="w-14 shrink-0 text-[11px] font-bold text-muted-foreground">Ant</span>
+                <div className="flex items-center gap-1.5 flex-1 min-w-0">
+                  <span className="text-[10px] text-muted-foreground">RX</span>
+                  <select disabled={rxOff} value={st.rx_ant ?? ''}
+                    onChange={(e) => change('rx_ant', e.target.value, () => FlexSetRXAntenna(e.target.value))}
+                    className="h-7 flex-1 min-w-0 rounded-md border border-input bg-background px-1.5 text-xs font-mono disabled:opacity-40">
+                    {(st.ant_list ?? []).map((a) => <option key={a} value={a}>{a}</option>)}
+                  </select>
+                  <span className="text-[10px] text-muted-foreground">TX</span>
+                  <select disabled={rxOff} value={st.tx_ant ?? ''}
+                    onChange={(e) => change('tx_ant', e.target.value, () => FlexSetTXAntenna(e.target.value))}
+                    className="h-7 flex-1 min-w-0 rounded-md border border-input bg-background px-1.5 text-xs font-mono disabled:opacity-40">
+                    {((st.tx_ant_list?.length ? st.tx_ant_list : st.ant_list) ?? []).map((a) => <option key={a} value={a}>{a}</option>)}
+                  </select>
+                </div>
+              </div>
+            )}
             <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>
+              <span className="w-14 shrink-0 text-[11px] font-bold text-muted-foreground">AF</span>
+              <button type="button" disabled={rxOff}
+                title={st.mute ? 'Muted — click to unmute' : 'Mute RX audio'}
+                onClick={() => change('mute', !st.mute, () => FlexSetMute(!st.mute))}
+                className={cn('shrink-0 rounded p-1 transition-colors disabled:opacity-30',
+                  st.mute ? 'bg-red-600 text-white' : 'text-muted-foreground hover:bg-muted')}>
+                {st.mute ? <VolumeX className="size-3.5" /> : <Volume2 className="size-3.5" />}
+              </button>
+              <Slider value={st.audio_level} disabled={rxOff || st.mute} 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.mute ? '—' : st.audio_level}</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>
+              <span className="w-14 shrink-0 text-[11px] font-bold text-muted-foreground">AGC-T</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="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"
@@ -416,7 +471,7 @@ export function FlexPanel() {
                           FlexSetFilter(lo, hi).catch(() => {});
                         }}
                         className={cn('px-1.5 py-1 text-[11px] font-bold tracking-wide transition-colors disabled:opacity-30 border-l border-border first:border-l-0',
-                          Math.abs(curBW - bw) <= 50 ? 'bg-primary text-primary-foreground' : 'bg-card text-muted-foreground hover:bg-muted')}>
+                          bw === ssbActiveBW ? 'bg-primary text-primary-foreground' : 'bg-card text-muted-foreground hover:bg-muted')}>
                         {(bw / 1000).toFixed(1)}
                       </button>
                     ))}

frontend/src/components/MainMap.tsx

@@ -81,10 +81,11 @@ interface WorldProps {
   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
+  zoomSignal?: number;         // bump to force an auto-zoom now (e.g. QRZ lookup finished)
 }
 
 // WorldMap — great-circle path + beam lobe(s), the "map1" pane.
-export function WorldMap({ fromGrid, toGrid, fromLabel, toLabel, beamAzimuths, beamWidth, boomAzimuth }: WorldProps) {
+export function WorldMap({ fromGrid, toGrid, fromLabel, toLabel, beamAzimuths, beamWidth, boomAzimuth, zoomSignal }: WorldProps) {
   const worldRef = useRef<HTMLDivElement>(null);
   const worldMap = useRef<L.Map | null>(null);
   const worldOverlay = useRef<L.LayerGroup | null>(null);
@@ -139,18 +140,13 @@ export function WorldMap({ fromGrid, toGrid, fromLabel, toLabel, beamAzimuths, b
     const from = gridToLatLon(fromGrid);
     const to = gridToLatLon(toGrid);
 
-    if (from && to) {
+    // Station marker + antenna beam/boom are drawn whenever the station grid is
+    // known — independent of any DX. The antenna is always pointed somewhere, so
+    // the beam heading should show even before a callsign is entered.
+    if (from) {
       L.marker([from.lat, from.lon], { icon: dot('#2563eb'), title: fromLabel || 'QTH' })
         .bindTooltip(`${fromLabel ? fromLabel + ' · ' : ''}${fromGrid.toUpperCase()}`, { permanent: false, direction: 'top' })
         .addTo(wo);
-      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) {
@@ -169,21 +165,20 @@ export function WorldMap({ fromGrid, toGrid, fromLabel, toLabel, beamAzimuths, b
           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) {
+          // Draw the lobe as a DENSE fan of translucent great-circle radials, not
+          // a filled polygon: a polygon smears badly near the poles on Mercator
+          // (a poleward beam degenerates into a giant triangle), while each radial
+          // LINE stays clean at any azimuth. A small angular step makes the lines
+          // overlap into a solid-looking lobe (no separate strokes), darker near
+          // the antenna and fanning out toward the front.
+          for (let b = az - half; b <= az + half + 0.001; b += 0.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);
+            L.polyline(line as L.LatLngExpression[], { color: '#ff2d2d', weight: 6, opacity: 0.10, 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.
+          // readable on any basemap. Same dashArray so the casing tracks each dash.
           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);
@@ -204,20 +199,34 @@ export function WorldMap({ fromGrid, toGrid, fromLabel, toLabel, beamAzimuths, b
         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) {
+    // DX marker + great-circle arc — only when a DX grid is known (callsign entered).
+    let arcPts: [number, number][] | null = null;
+    if (from && to) {
+      L.marker([to.lat, to.lon], { icon: dot('#dc2626'), title: toLabel || 'DX' })
+        .bindTooltip(`${toLabel ? toLabel + ' · ' : ''}${toGrid.toUpperCase()}`, { permanent: false, direction: 'top' })
+        .addTo(wo);
+      arcPts = greatCirclePoints(from.lat, from.lon, to.lat, to.lon, 128);
+      // smoothFactor: 0 keeps every vertex (Leaflet otherwise simplifies the line).
+      L.polyline(unwrapLon(arcPts) as L.LatLngExpression[],
+        { color: '#2563eb', weight: 2, opacity: 0.85, smoothFactor: 0 }).addTo(wo);
+    }
+
+    if (autoZoom) {
+      if (from && to && arcPts) {
         const bounds = L.latLngBounds([[from.lat, from.lon], [to.lat, to.lon]]);
-        pts.forEach((p) => bounds.extend(p as L.LatLngExpression));
+        arcPts.forEach((p) => bounds.extend(p as L.LatLngExpression));
         wm.fitBounds(bounds, { padding: [30, 30], maxZoom: 6 });
+      } else if (to) {
+        wm.setView([to.lat, to.lon], 3);
+      } else if (from) {
+        wm.setView([from.lat, from.lon], 3);
       }
-    } else if (autoZoom && to) {
-      wm.setView([to.lat, to.lon], 3);
-    } 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]);
+  }, [fromGrid, toGrid, fromLabel, toLabel, (beamAzimuths ?? []).map((a) => Math.round(a)).join(','), beamWidth, boomAzimuth, autoZoom, zoomSignal]);
 
   const path = pathBetween(fromGrid, toGrid);
 

frontend/src/components/NetControlPanel.tsx

@@ -0,0 +1,397 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import {
+  AllCommunityModule, ModuleRegistry, themeQuartz,
+  type ColDef,
+} from 'ag-grid-community';
+import { AgGridReact } from 'ag-grid-react';
+import { Plus, Trash2, Radio, PlusCircle, MinusCircle, Search, UserPlus } from 'lucide-react';
+import {
+  Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter, DialogDescription,
+} from '@/components/ui/dialog';
+import { Button } from '@/components/ui/button';
+import { Input } from '@/components/ui/input';
+import { Label } from '@/components/ui/label';
+import { Badge } from '@/components/ui/badge';
+import { QSOEditModal } from '@/components/QSOEditModal';
+import type { QSOForm } from '@/types';
+import {
+  NetList, NetCreate, NetRename, NetDelete, NetOpen, NetClose, NetOpenID,
+  NetRoster, NetRosterUpsert, NetRosterRemove, NetLookup,
+  NetActiveList, NetActivate, NetDeactivate, NetUpdateActive, NetDiscardActive,
+} from '@/../wailsjs/go/main/App';
+import { netctl } from '@/../wailsjs/go/models';
+
+ModuleRegistry.registerModules([AllCommunityModule]);
+
+const hamlogTheme = themeQuartz.withParams({
+  fontFamily: 'inherit',
+  fontSize: 12.5,
+  backgroundColor: '#faf6ea',
+  foregroundColor: '#2a2419',
+  headerBackgroundColor: '#e8dfc9',
+  headerTextColor: '#5a4f3a',
+  headerFontWeight: 600,
+  oddRowBackgroundColor: '#f5efe0',
+  rowHoverColor: '#ecdcb4',
+  selectedRowBackgroundColor: '#f0d9a8',
+  borderColor: '#c8b994',
+  rowBorder: { color: '#d8c9a8', width: 1 },
+  columnBorder: { color: '#d8c9a8', width: 1 },
+  cellHorizontalPadding: 10,
+  rowHeight: 30,
+  headerHeight: 32,
+  spacing: 4,
+  accentColor: '#b8410c',
+  iconSize: 12,
+});
+
+type Net = netctl.Net;
+type Station = netctl.Station;
+
+function fmtTimeOn(s: any): string {
+  if (!s) return '';
+  const d = new Date(s);
+  if (isNaN(d.getTime())) return '';
+  const p = (n: number) => String(n).padStart(2, '0');
+  return `${p(d.getUTCHours())}:${p(d.getUTCMinutes())}:${p(d.getUTCSeconds())}Z`;
+}
+
+const emptyStation = (): Station => netctl.Station.createFrom({ callsign: '' });
+
+type Props = {
+  onLogged?: () => void;
+  countries?: string[];
+  bands?: string[];
+  modes?: string[];
+};
+
+export function NetControlPanel({ onLogged, countries, bands, modes }: Props) {
+  const [nets, setNets] = useState<Net[]>([]);
+  const [selId, setSelId] = useState<string>('');
+  const [openId, setOpenId] = useState<string>('');
+  const [roster, setRoster] = useState<Station[]>([]);
+  const [active, setActive] = useState<QSOForm[]>([]);
+  const [error, setError] = useState('');
+
+  // Full-QSO edit modal for an on-air draft (same one Recent QSOs uses).
+  const [editingDraft, setEditingDraft] = useState<QSOForm | null>(null);
+
+  // Add/edit-contact dialog.
+  const [contactOpen, setContactOpen] = useState(false);
+  const [contact, setContact] = useState<Station>(emptyStation());
+  const [looking, setLooking] = useState(false);
+
+  const activeGrid = useRef<any>(null);
+  const rosterGrid = useRef<any>(null);
+
+  const isOpen = openId !== '' && openId === selId;
+
+  const refreshNets = useCallback(async () => {
+    try {
+      const [list, oid] = await Promise.all([NetList(), NetOpenID()]);
+      const arr = (list ?? []) as Net[];
+      setNets(arr);
+      setOpenId(oid ?? '');
+      setSelId((cur) => cur || (oid ?? '') || (arr[0]?.id ?? ''));
+    } catch (e: any) { setError(String(e?.message ?? e)); }
+  }, []);
+
+  const refreshRoster = useCallback(async (id: string) => {
+    if (!id) { setRoster([]); return; }
+    try { setRoster(((await NetRoster(id)) ?? []) as Station[]); }
+    catch (e: any) { setError(String(e?.message ?? e)); }
+  }, []);
+
+  const refreshActive = useCallback(async () => {
+    try { setActive(((await NetActiveList()) ?? []) as unknown as QSOForm[]); }
+    catch { /* ignore */ }
+  }, []);
+
+  useEffect(() => { refreshNets(); }, [refreshNets]);
+  useEffect(() => { refreshRoster(selId); }, [selId, refreshRoster]);
+  useEffect(() => { if (isOpen) refreshActive(); else setActive([]); }, [isOpen, refreshActive]);
+
+  // The roster side hides callsigns currently on the air (they live in the left
+  // grid until logged), mirroring Log4OM's two-list behaviour.
+  const activeCalls = useMemo(
+    () => new Set(active.map((a) => (a.callsign ?? '').toUpperCase())),
+    [active],
+  );
+  const rosterShown = useMemo(
+    () => roster.filter((s) => !activeCalls.has((s.callsign ?? '').toUpperCase())),
+    [roster, activeCalls],
+  );
+
+  async function newNet() {
+    const name = window.prompt('New NET name:');
+    if (!name?.trim()) return;
+    try { const n = await NetCreate(name.trim()); await refreshNets(); setSelId(n.id); }
+    catch (e: any) { setError(String(e?.message ?? e)); }
+  }
+  async function renameNet() {
+    if (!selId) return;
+    const cur = nets.find((n) => n.id === selId);
+    const name = window.prompt('Rename NET:', cur?.name ?? '');
+    if (!name?.trim()) return;
+    try { await NetRename(selId, name.trim()); await refreshNets(); }
+    catch (e: any) { setError(String(e?.message ?? e)); }
+  }
+  async function deleteNet() {
+    if (!selId) return;
+    const cur = nets.find((n) => n.id === selId);
+    if (!window.confirm(`Delete NET "${cur?.name}" and its roster? This cannot be undone.`)) return;
+    try { await NetDelete(selId); setSelId(''); await refreshNets(); }
+    catch (e: any) { setError(String(e?.message ?? e)); }
+  }
+  async function toggleOpen() {
+    try {
+      if (isOpen) {
+        if (active.length > 0 &&
+          !window.confirm(`${active.length} station(s) still on the air will be dropped WITHOUT logging. Close anyway?`)) return;
+        await NetClose(); setOpenId('');
+      } else {
+        await NetOpen(selId); setOpenId(selId); await refreshActive();
+      }
+    } catch (e: any) { setError(String(e?.message ?? e)); }
+  }
+
+  // Roster → active (start QSO).
+  async function activate(call: string) {
+    if (!isOpen || !call) return;
+    try { await NetActivate(call); await refreshActive(); }
+    catch (e: any) { setError(String(e?.message ?? e)); }
+  }
+  // Active → logged (end QSO, removed from session, written to the logbook).
+  async function deactivate(id?: number) {
+    if (id == null) return;
+    try { await NetDeactivate(id); await refreshActive(); onLogged?.(); }
+    catch (e: any) { setError(String(e?.message ?? e)); }
+  }
+
+  // Edit-modal handlers (operate on the in-memory draft, not the DB).
+  async function saveDraft(q: QSOForm) {
+    try { await NetUpdateActive(q as any); setEditingDraft(null); await refreshActive(); }
+    catch (e: any) { setError(String(e?.message ?? e)); }
+  }
+  async function discardDraft(id: number) {
+    try { await NetDiscardActive(id); setEditingDraft(null); await refreshActive(); }
+    catch (e: any) { setError(String(e?.message ?? e)); }
+  }
+
+  // Add-contact dialog.
+  function openAddContact() { setContact(emptyStation()); setContactOpen(true); }
+  async function lookupContact() {
+    const call = (contact.callsign ?? '').trim();
+    if (!call) return;
+    setLooking(true);
+    try {
+      const r = await NetLookup(call);
+      setContact((c) => netctl.Station.createFrom({
+        ...c, callsign: (r.callsign || call).toUpperCase(),
+        name: r.name || c.name, qth: r.qth || c.qth, country: r.country || c.country,
+        dxcc: r.dxcc || c.dxcc, itu: r.itu || c.itu, cq: r.cq || c.cq,
+      }));
+    } catch (e: any) { setError(String(e?.message ?? e)); }
+    finally { setLooking(false); }
+  }
+  async function saveContact() {
+    const call = (contact.callsign ?? '').trim().toUpperCase();
+    if (!call || !selId) return;
+    try {
+      await NetRosterUpsert(selId, netctl.Station.createFrom({ ...contact, callsign: call }));
+      setContactOpen(false);
+      await refreshRoster(selId);
+    } catch (e: any) { setError(String(e?.message ?? e)); }
+  }
+  async function removeSelectedRoster() {
+    const sel = (rosterGrid.current?.api?.getSelectedRows() ?? []) as Station[];
+    if (sel.length === 0) return;
+    if (!window.confirm(`Remove ${sel.length} station(s) from this NET's roster?`)) return;
+    try {
+      for (const s of sel) await NetRosterRemove(selId, s.callsign);
+      await refreshRoster(selId);
+    } catch (e: any) { setError(String(e?.message ?? e)); }
+  }
+
+  const activeCols = useMemo<ColDef<QSOForm>[]>(() => [
+    { headerName: 'Callsign', field: 'callsign', width: 110, cellClass: 'font-mono font-semibold' },
+    { headerName: 'Name', field: 'name', flex: 1 },
+    { headerName: 'QTH', field: 'qth', flex: 1 },
+    { headerName: 'Time on', valueGetter: (p) => fmtTimeOn((p.data as any)?.qso_date), width: 90, cellClass: 'font-mono text-[11px]' },
+    { headerName: 'Band', field: 'band', width: 70, cellClass: 'font-mono' },
+    { headerName: 'Mode', field: 'mode', width: 70, cellClass: 'font-mono' },
+    { headerName: 'RST S', field: 'rst_sent', width: 70, cellClass: 'font-mono' },
+    { headerName: 'RST R', field: 'rst_rcvd', width: 70, cellClass: 'font-mono' },
+    { headerName: 'Comment', field: 'comment', flex: 1.5 },
+  ], []);
+
+  const rosterCols = useMemo<ColDef<Station>[]>(() => [
+    { headerName: 'Callsign', field: 'callsign', width: 110, cellClass: 'font-mono font-semibold' },
+    { headerName: 'Name', field: 'name', flex: 1 },
+    { headerName: 'QTH', field: 'qth', flex: 1 },
+    { headerName: 'Country', field: 'country', width: 130 },
+  ], []);
+
+  const defaultColDef = useMemo<ColDef>(() => ({ sortable: true, resizable: true, suppressMovable: false }), []);
+
+  return (
+    <div className="flex flex-col min-h-0 flex-1">
+      {/* Toolbar */}
+      <div className="flex items-center gap-2 px-3 py-2 border-b border-border/60 bg-muted/30">
+        <Button variant="outline" size="sm" className="h-8" onClick={newNet}>
+          <Plus className="size-3.5" /> New NET
+        </Button>
+        <select
+          className="h-8 rounded-md border border-input bg-background px-2 text-sm min-w-[180px]"
+          value={selId}
+          disabled={isOpen}
+          onChange={(e) => setSelId(e.target.value)}
+          title={isOpen ? 'Close the NET to switch' : 'Select a NET'}
+        >
+          <option value="">— select a NET —</option>
+          {nets.map((n) => <option key={n.id} value={n.id}>{n.name}</option>)}
+        </select>
+        <Button variant={isOpen ? 'destructive' : 'default'} size="sm" className="h-8" disabled={!selId} onClick={toggleOpen}>
+          <Radio className="size-3.5" /> {isOpen ? 'Close NET' : 'Open NET'}
+        </Button>
+        <Button variant="ghost" size="sm" className="h-8" disabled={!selId || isOpen} onClick={renameNet}>Rename</Button>
+        <Button variant="ghost" size="sm" className="h-8 text-rose-700" disabled={!selId || isOpen} onClick={deleteNet}>
+          <Trash2 className="size-3.5" /> Delete
+        </Button>
+
+        <div className="flex-1" />
+        {isOpen && <Badge className="bg-emerald-600 text-white tracking-wider">NET OPEN</Badge>}
+        <span className="text-[11px] text-muted-foreground">
+          On air: <strong className="text-foreground">{active.length}</strong> ·
+          Roster: <strong className="text-foreground">{roster.length}</strong>
+        </span>
+        {error && <Badge variant="destructive" className="max-w-[280px] truncate" title={error}>{error}</Badge>}
+      </div>
+
+      <div className="flex min-h-0 flex-1">
+        {/* ACTIVE USERS (left) */}
+        <div className="flex flex-col min-h-0 flex-1 border-r border-border/60">
+          <div className="flex items-center gap-2 px-3 py-1.5 bg-red-600 text-white text-[11px] font-semibold uppercase tracking-wider">
+            On air — active QSOs
+            <span className="ml-auto font-normal normal-case opacity-90">double-click → edit all fields · "Log &amp; end" to save</span>
+          </div>
+          <div style={{ flex: 1, minHeight: 0, position: 'relative' }}>
+            <div style={{ position: 'absolute', inset: 0 }}>
+              <AgGridReact<QSOForm>
+                ref={activeGrid}
+                theme={hamlogTheme}
+                rowData={active}
+                columnDefs={activeCols}
+                defaultColDef={defaultColDef}
+                onRowDoubleClicked={(e) => e.data && setEditingDraft(e.data)}
+                rowSelection={{ mode: 'singleRow', checkboxes: false, enableClickSelection: true }}
+                animateRows={false}
+                getRowId={(p) => String((p.data as any).id)}
+              />
+            </div>
+          </div>
+          {isOpen && active.length > 0 && (
+            <div className="px-3 py-1.5 border-t border-border/60 bg-muted/30 flex items-center gap-2">
+              <Button variant="ghost" size="sm" className="h-7 text-[11px]"
+                onClick={() => { const r = activeGrid.current?.api?.getSelectedRows?.()?.[0] as QSOForm; if (r) deactivate(r.id as number); }}>
+                <MinusCircle className="size-3.5" /> Log &amp; end selected
+              </Button>
+            </div>
+          )}
+        </div>
+
+        {/* NET USERS / roster (right) */}
+        <div className="flex flex-col min-h-0 w-[40%] max-w-[560px]">
+          <div className="flex items-center gap-2 px-3 py-1.5 bg-emerald-700 text-white text-[11px] font-semibold uppercase tracking-wider">
+            NET users — roster
+            <span className="ml-auto font-normal normal-case opacity-90">double-click → put on air</span>
+          </div>
+          <div style={{ flex: 1, minHeight: 0, position: 'relative' }}>
+            <div style={{ position: 'absolute', inset: 0 }}>
+              <AgGridReact<Station>
+                ref={rosterGrid}
+                theme={hamlogTheme}
+                rowData={rosterShown}
+                columnDefs={rosterCols}
+                defaultColDef={defaultColDef}
+                rowSelection={{ mode: 'multiRow', checkboxes: false, headerCheckbox: false, enableClickSelection: true }}
+                onRowDoubleClicked={(e) => e.data && activate(e.data.callsign)}
+                animateRows={false}
+                getRowId={(p) => String((p.data as any).callsign)}
+              />
+            </div>
+          </div>
+          <div className="px-3 py-1.5 border-t border-border/60 bg-muted/30 flex items-center gap-2">
+            <Button variant="ghost" size="sm" className="h-7 text-[11px]" disabled={!selId} onClick={openAddContact}>
+              <UserPlus className="size-3.5" /> Add contact
+            </Button>
+            <Button variant="ghost" size="sm" className="h-7 text-[11px] text-rose-700" disabled={!selId} onClick={removeSelectedRoster}>
+              <MinusCircle className="size-3.5" /> Remove
+            </Button>
+            {isOpen && (
+              <Button variant="ghost" size="sm" className="h-7 text-[11px] ml-auto"
+                onClick={() => { const r = rosterGrid.current?.api?.getSelectedRows?.()?.[0] as Station; if (r) activate(r.callsign); }}>
+                <PlusCircle className="size-3.5" /> Put selected on air
+              </Button>
+            )}
+          </div>
+        </div>
+      </div>
+
+      {/* Full-QSO edit modal for the selected on-air draft. Save writes back to
+          the in-memory draft (NetUpdateActive); Delete cancels it (no log). */}
+      {editingDraft && (
+        <QSOEditModal
+          qso={editingDraft}
+          onSave={saveDraft}
+          onDelete={discardDraft}
+          onClose={() => setEditingDraft(null)}
+          countries={countries}
+          bands={bands}
+          modes={modes}
+        />
+      )}
+
+      {/* Add / edit contact dialog */}
+      <Dialog open={contactOpen} onOpenChange={setContactOpen}>
+        <DialogContent className="max-w-md">
+          <DialogHeader>
+            <DialogTitle>Add contact to NET</DialogTitle>
+            <DialogDescription>Saved in this NET's roster (reused next time you open it).</DialogDescription>
+          </DialogHeader>
+          <div className="grid gap-3 px-5 py-2">
+            <div className="flex items-end gap-2">
+              <div className="flex-1">
+                <Label className="text-[11px]">Callsign</Label>
+                <Input className="font-mono uppercase" value={contact.callsign ?? ''}
+                  onChange={(e) => setContact((c) => netctl.Station.createFrom({ ...c, callsign: e.target.value.toUpperCase() }))}
+                  onKeyDown={(e) => { if (e.key === 'Enter') lookupContact(); }} />
+              </div>
+              <Button variant="outline" size="sm" className="h-9" onClick={lookupContact} disabled={looking || !(contact.callsign ?? '').trim()}>
+                <Search className="size-3.5" /> {looking ? '…' : 'Search'}
+              </Button>
+            </div>
+            <div>
+              <Label className="text-[11px]">Name</Label>
+              <Input value={contact.name ?? ''} onChange={(e) => setContact((c) => netctl.Station.createFrom({ ...c, name: e.target.value }))} />
+            </div>
+            <div>
+              <Label className="text-[11px]">QTH</Label>
+              <Input value={contact.qth ?? ''} onChange={(e) => setContact((c) => netctl.Station.createFrom({ ...c, qth: e.target.value }))} />
+            </div>
+            <div>
+              <Label className="text-[11px]">Country</Label>
+              <Input value={contact.country ?? ''} onChange={(e) => setContact((c) => netctl.Station.createFrom({ ...c, country: e.target.value }))} />
+            </div>
+          </div>
+          <DialogFooter>
+            <Button variant="ghost" size="sm" onClick={() => setContactOpen(false)}>Cancel</Button>
+            <Button size="sm" onClick={saveContact} disabled={!(contact.callsign ?? '').trim()}>
+              <PlusCircle className="size-3.5" /> Save in NET
+            </Button>
+          </DialogFooter>
+        </DialogContent>
+      </Dialog>
+    </div>
+  );
+}

frontend/src/components/QSLManagerModal.tsx

@@ -10,6 +10,7 @@ import {
 import { cn } from '@/lib/utils';
 import { FindQSOsForUpload, UploadQSOsManual, DownloadConfirmations, SyncPOTAHunterLog, ListQSO, BulkUpdateQSL, UploadCallsign } from '../../wailsjs/go/main/App';
 import { Input } from '@/components/ui/input';
+import { RecentQSOsGrid } from '@/components/RecentQSOsGrid';
 import { EventsOn } from '../../wailsjs/runtime/runtime';
 
 ModuleRegistry.registerModules([AllCommunityModule]);
@@ -60,6 +61,14 @@ const QSL_STATUSES = [
   { v: 'I', label: 'Ignore' },
 ];
 
+// QSL routing methods for the paper-QSL "Via" dropdown (was free text).
+const QSL_VIA_OPTIONS = [
+  { v: '_', label: '— leave —' },
+  { v: 'Bureau', label: 'Bureau' },
+  { v: 'Direct', label: 'Direct' },
+  { v: 'Electronic', label: 'Electronic' },
+];
+
 type LogQSO = {
   id: number; qso_date: string; callsign: string; band: string; mode: string; country?: string;
   qsl_sent?: string; qsl_rcvd?: string; qsl_via?: string; qsl_sent_date?: string; qsl_rcvd_date?: string;
@@ -127,13 +136,16 @@ export function QSLManagerPanel({ onEditQSO }: { onEditQSO?: (id: number) => voi
   const [paperCall, setPaperCall] = useState('');
   const [paperRows, setPaperRows] = useState<LogQSO[]>([]);
   const [paperSel, setPaperSel] = useState<Set<number>>(new Set());
+  const [paperSelAllSig, setPaperSelAllSig] = useState(0); // bump → grid selects all
   const [paperBusy, setPaperBusy] = useState(false);
   const [paperMsg, setPaperMsg] = useState('');
-  const [qslRcvd, setQslRcvd] = useState('Y');
+  const [qslRcvd, setQslRcvd] = useState('N');
   const [qslSent, setQslSent] = useState('_');
   const [qslRcvdDate, setQslRcvdDate] = useState('');
   const [qslSentDate, setQslSentDate] = useState('');
-  const [qslVia, setQslVia] = useState('');
+  const [qslVia, setQslVia] = useState('_');
+  const [qslNotes, setQslNotes] = useState('');
+  const [qslComment, setQslComment] = useState('');
 
   const searchPaper = useCallback(async () => {
     const c = paperCall.trim().toUpperCase();
@@ -144,14 +156,12 @@ export function QSLManagerPanel({ onEditQSO }: { onEditQSO?: (id: number) => voi
       const list = (r ?? []) as LogQSO[];
       setPaperRows(list);
       setPaperSel(new Set(list.map((x) => x.id)));
+      setPaperSelAllSig((n) => n + 1); // tell the grid to select every row
+
     } catch (e: any) { setPaperMsg(String(e?.message ?? e)); setPaperRows([]); }
     finally { setPaperBusy(false); }
   }, [paperCall]);
 
-  function togglePaper(id: number) {
-    setPaperSel((s) => { const n = new Set(s); n.has(id) ? n.delete(id) : n.add(id); return n; });
-  }
-  const paperAllSel = paperRows.length > 0 && paperSel.size === paperRows.length;
 
   async function applyPaper() {
     const ids = paperRows.filter((r) => paperSel.has(r.id)).map((r) => r.id);
@@ -164,7 +174,9 @@ export function QSLManagerPanel({ onEditQSO }: { onEditQSO?: (id: number) => voi
         rcvd_status: qslRcvd === '_' ? '' : qslRcvd,
         sent_date: ymd(qslSentDate),
         rcvd_date: ymd(qslRcvdDate),
-        via: qslVia,
+        via: qslVia === '_' ? '' : qslVia,
+        notes: qslNotes,
+        comment: qslComment,
       } as any);
       setPaperMsg(`${n} QSO updated.`);
       await searchPaper();
@@ -172,11 +184,11 @@ export function QSLManagerPanel({ onEditQSO }: { onEditQSO?: (id: number) => voi
     finally { setPaperBusy(false); }
   }
   const [sent, setSent] = useState('R');
-  const [rows, setRows] = useState<UploadRow[]>([]);
-  // Selection lives in the (virtualized) ag-grid — it handles 25k rows smoothly.
-  const gridRef = useRef<AgGridReact<UploadRow>>(null);
+  // Full QSO rows (so the upload view uses the same rich grid as Recent QSOs).
+  const [rows, setRows] = useState<any[]>([]);
   const [selectedCount, setSelectedCount] = useState(0);
-  const selectAllNext = useRef(false); // selectAll once after the next data load
+  const [uploadSelIds, setUploadSelIds] = useState<number[]>([]); // selected QSO ids → upload
+  const [uploadSelAllSig, setUploadSelAllSig] = useState(0);      // bump → grid selects all
   const [searching, setSearching] = useState(false);
   const [error, setError] = useState('');
   const [addNotFound, setAddNotFound] = useState(false);
@@ -210,15 +222,9 @@ export function QSLManagerPanel({ onEditQSO }: { onEditQSO?: (id: number) => voi
   const serviceLabel = useMemo(() => SERVICES.find((s) => s.v === service)?.label ?? service, [service]);
 
   // Grid selection → just track the count; ids are read from the grid at upload.
-  function onUploadSelChanged() {
-    setSelectedCount(gridRef.current?.api?.getSelectedNodes()?.length ?? 0);
-  }
-  // After "Select required" loads new rows, select them all (the old default).
-  function onUploadRowsLoaded() {
-    if (selectAllNext.current) {
-      selectAllNext.current = false;
-      gridRef.current?.api?.selectAll();
-    }
+  function onUploadRowSelected(ids: number[]) {
+    setUploadSelIds(ids);
+    setSelectedCount(ids.length);
   }
 
   const shownConfs = useMemo(() => confirmations.filter((c) => {
@@ -236,10 +242,11 @@ export function QSLManagerPanel({ onEditQSO }: { onEditQSO?: (id: number) => voi
     setError('');
     try {
       const r: any = await FindQSOsForUpload(service, sent === '_' ? '' : sent);
-      const list = (r ?? []) as UploadRow[];
-      selectAllNext.current = true; // pre-select everything once the grid renders
+      const list = (r ?? []) as any[];
       setRows(list);
+      setUploadSelIds(list.map((x) => x.id));
       setSelectedCount(list.length);
+      setUploadSelAllSig((n) => n + 1); // pre-select everything once the grid renders
       setViewMode('upload');
       setShowLog(false);
     } catch (e: any) {
@@ -252,7 +259,7 @@ export function QSLManagerPanel({ onEditQSO }: { onEditQSO?: (id: number) => voi
   }, [service, sent]);
 
   async function upload() {
-    const ids = ((gridRef.current?.api?.getSelectedRows() as UploadRow[] | undefined) ?? []).map((r) => r.id);
+    const ids = uploadSelIds;
     if (ids.length === 0) return;
     setLogLines([]); setBusy(true); setLogAction('upload'); setShowLog(true);
     try { await UploadQSOsManual(service, ids); }
@@ -283,7 +290,7 @@ export function QSLManagerPanel({ onEditQSO }: { onEditQSO?: (id: number) => voi
           <label className="text-[10px] uppercase tracking-wider text-muted-foreground">Service</label>
           <Select value={service} onValueChange={setService}>
             <SelectTrigger className="h-8 w-36"><SelectValue /></SelectTrigger>
-            <SelectContent>{SERVICES.map((s) => <SelectItem key={s.v} value={s.v}>{s.label}</SelectItem>)}</SelectContent>
+            <SelectContent>{[...SERVICES].sort((a, b) => a.label.localeCompare(b.label)).map((s) => <SelectItem key={s.v} value={s.v}>{s.label}</SelectItem>)}</SelectContent>
           </Select>
         </div>
         {uploadCall && (
@@ -387,32 +394,16 @@ export function QSLManagerPanel({ onEditQSO }: { onEditQSO?: (id: number) => voi
           paperRows.length === 0 ? (
             <div className="text-sm text-muted-foreground py-10 text-center">Search a callsign to list its QSOs, then set QSL status below.</div>
           ) : (
-            <table className="w-full text-xs border-collapse">
-              <thead className="sticky top-0 bg-card">
-                <tr className="text-left text-muted-foreground border-b border-border">
-                  <th className="py-1.5 px-2 w-8"><Checkbox checked={paperAllSel} onCheckedChange={() => setPaperSel(paperAllSel ? new Set() : new Set(paperRows.map((r) => r.id)))} /></th>
-                  <th className="py-1.5 px-2">Date UTC</th><th className="py-1.5 px-2">Callsign</th>
-                  <th className="py-1.5 px-2">Band</th><th className="py-1.5 px-2">Mode</th>
-                  <th className="py-1.5 px-2">QSL Sent</th><th className="py-1.5 px-2">QSL Rcvd</th><th className="py-1.5 px-2">Via</th>
-                </tr>
-              </thead>
-              <tbody>
-                {paperRows.map((r) => (
-                  <tr key={r.id}
-                    className={cn('border-b border-border/40 cursor-pointer hover:bg-accent/30', paperSel.has(r.id) && 'bg-primary/5')}
-                    onClick={() => togglePaper(r.id)}>
-                    <td className="py-1 px-2" onClick={(e) => e.stopPropagation()}><Checkbox checked={paperSel.has(r.id)} onCheckedChange={() => togglePaper(r.id)} /></td>
-                    <td className="py-1 px-2 font-mono">{fmtDate(r.qso_date)}</td>
-                    <td className="py-1 px-2 font-mono font-bold">{r.callsign}</td>
-                    <td className="py-1 px-2">{r.band}</td>
-                    <td className="py-1 px-2">{r.mode}</td>
-                    <td className="py-1 px-2 font-mono">{r.qsl_sent || '—'}{r.qsl_sent_date ? ` ${fmtQslDate(r.qsl_sent_date)}` : ''}</td>
-                    <td className="py-1 px-2 font-mono">{r.qsl_rcvd || '—'}{r.qsl_rcvd_date ? ` ${fmtQslDate(r.qsl_rcvd_date)}` : ''}</td>
-                    <td className="py-1 px-2 text-muted-foreground truncate max-w-[160px]">{r.qsl_via}</td>
-                  </tr>
-                ))}
-              </tbody>
-            </table>
+            // Same grid as Recent QSOs (full columns + column picker). Selection
+            // drives which QSOs the apply-form below updates; a search selects all.
+            <div className="flex flex-col h-full min-h-0 -mx-3 -my-2">
+              <RecentQSOsGrid
+                rows={paperRows as any}
+                total={paperRows.length}
+                selectAllSignal={paperSelAllSig}
+                onRowSelected={(ids) => setPaperSel(new Set(ids))}
+              />
+            </div>
           )
         ) : service === 'pota' ? (
           <div className="space-y-3">
@@ -509,19 +500,12 @@ export function QSLManagerPanel({ onEditQSO }: { onEditQSO?: (id: number) => voi
         ) : rows.length === 0 ? (
           <div className="text-sm text-muted-foreground py-10 text-center">Pick a service + sent status, then “Select required”.</div>
         ) : (
-          <div className="h-full w-full">
-            <AgGridReact<UploadRow>
-              ref={gridRef}
-              theme={qslTheme}
-              rowData={rows}
-              columnDefs={UPLOAD_COLS}
-              defaultColDef={{ sortable: true, resizable: true, filter: true }}
-              rowSelection={{ mode: 'multiRow', checkboxes: true, headerCheckbox: true }}
-              onSelectionChanged={onUploadSelChanged}
-              onRowDataUpdated={onUploadRowsLoaded}
-              animateRows={false}
-              suppressCellFocus
-              getRowId={(p) => String((p.data as any).id)}
+          <div className="flex flex-col h-full min-h-0 -mx-3 -my-2">
+            <RecentQSOsGrid
+              rows={rows as any}
+              total={rows.length}
+              selectAllSignal={uploadSelAllSig}
+              onRowSelected={onUploadRowSelected}
             />
           </div>
         )}
@@ -552,7 +536,18 @@ export function QSLManagerPanel({ onEditQSO }: { onEditQSO?: (id: number) => voi
           </div>
           <div className="flex flex-col gap-1">
             <label className="text-[10px] uppercase tracking-wider text-muted-foreground">Via</label>
-            <Input className="h-8 w-40" value={qslVia} onChange={(e) => setQslVia(e.target.value)} placeholder="BUREAU / DIRECT / manager" />
+            <Select value={qslVia} onValueChange={setQslVia}>
+              <SelectTrigger className="h-8 w-32"><SelectValue /></SelectTrigger>
+              <SelectContent>{QSL_VIA_OPTIONS.map((o) => <SelectItem key={o.v} value={o.v}>{o.label}</SelectItem>)}</SelectContent>
+            </Select>
+          </div>
+          <div className="flex flex-col gap-1">
+            <label className="text-[10px] uppercase tracking-wider text-muted-foreground">Notes</label>
+            <Input className="h-8 w-40" value={qslNotes} onChange={(e) => setQslNotes(e.target.value)} placeholder="e.g. paid 3€" />
+          </div>
+          <div className="flex flex-col gap-1">
+            <label className="text-[10px] uppercase tracking-wider text-muted-foreground">Comment</label>
+            <Input className="h-8 w-40" value={qslComment} onChange={(e) => setQslComment(e.target.value)} placeholder="comment" />
           </div>
           <div className="flex-1" />
           {paperMsg && <span className="text-[11px] text-muted-foreground self-center">{paperMsg}</span>}

frontend/src/components/QSOContextMenu.tsx

@@ -1,5 +1,5 @@
 import { useEffect } from 'react';
-import { Globe2, RefreshCw, Upload, BadgeCheck, Mail, FileDown, PencilLine } from 'lucide-react';
+import { Globe2, RefreshCw, Upload, BadgeCheck, Mail, FileDown, PencilLine, Trash2 } from 'lucide-react';
 
 export type QSOMenuState = { x: number; y: number; ids: number[] } | null;
 
@@ -15,6 +15,7 @@ type Props = {
   onBulkEdit?: (ids: number[]) => void;
   onExportSelected?: (ids: number[]) => void;
   onExportFiltered?: () => void;
+  onDelete?: (ids: number[]) => void;
 };
 
 const UPLOAD_TARGETS: { service: string; label: string }[] = [
@@ -31,7 +32,7 @@ const UPLOAD_TARGETS: { service: string; label: string }[] = [
 // or picks a command. (We deliberately do NOT close on scroll/resize: the QSO
 // list auto-refreshes and AG Grid fires internal scroll events on refresh,
 // which used to dismiss the menu the instant it appeared.)
-export function QSOContextMenu({ menu, onClose, onUpdateFromCty, onUpdateFromQRZ, onUpdateFromClublog, onSendTo, onSendRecording, onSendEQSL, onBulkEdit, onExportSelected, onExportFiltered }: Props) {
+export function QSOContextMenu({ menu, onClose, onUpdateFromCty, onUpdateFromQRZ, onUpdateFromClublog, onSendTo, onSendRecording, onSendEQSL, onBulkEdit, onExportSelected, onExportFiltered, onDelete }: Props) {
   useEffect(() => {
     if (!menu) return;
     const close = () => onClose();
@@ -159,6 +160,19 @@ export function QSOContextMenu({ menu, onClose, onUpdateFromCty, onUpdateFromQRZ
           ))}
         </>
       )}
+
+      {onDelete && (
+        <>
+          <div className="my-1 border-t border-border" />
+          <button
+            className="flex w-full items-center gap-2 px-3 py-1.5 text-left text-rose-700 hover:bg-rose-50"
+            onClick={() => { onDelete(menu.ids); onClose(); }}
+          >
+            <Trash2 className="size-4" />
+            <span>Delete {n} QSO{n > 1 ? 's' : ''}…</span>
+          </button>
+        </>
+      )}
     </div>
   );
 }

frontend/src/components/QSOEditModal.tsx

@@ -215,6 +215,14 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
     return () => window.clearTimeout(t);
   }, [draft.dxcc, draft.cqz, draft.ituz, draft.cont, draft.state, draft.callsign, draft.notes, draft.band]);
 
+  // Contest exchange typed as free text → numeric SRX/STX when all-digits, else
+  // the SRX_STRING/STX_STRING field. Mirrors the entry strip (F5) so the field
+  // accepts letters (sections/zones), not just numbers.
+  function setExchange(which: 'srx' | 'stx', raw: string) {
+    const t = raw.trim();
+    const num = /^\d+$/.test(t) ? parseInt(t, 10) : undefined;
+    setDraft((d) => ({ ...d, [which]: num, [`${which}_string`]: num != null ? '' : t } as any));
+  }
   function set<K extends keyof QSO>(key: K, value: QSO[K]) {
     setDraft((d) => ({ ...d, [key]: value }));
   }
@@ -561,7 +569,7 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
                         </thead>
                         <tbody>
                           {CONFIRMATIONS.map((c) => (
-                            <tr key={c.key} className={cn('text-xs', c.key === confSel && 'bg-accent/40')}>
+                            <tr key={c.key} className="text-xs">
                               <td className="font-medium pr-2 py-0.5">{c.label}</td>
                               <td className="w-24"><StatusCell value={val(c.sent)} /></td>
                               <td className="w-24">{c.rcvd ? <StatusCell value={val(c.rcvd)} /> : <span className="block text-center text-[11px] text-muted-foreground">—</span>}</td>
@@ -578,10 +586,8 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
             <TabsContent value="contest" className="mt-0">
               <div className="grid grid-cols-6 gap-3">
                 <F label="Contest ID" span={2}><Input value={draft.contest_id ?? ''} onChange={(e) => set('contest_id', e.target.value)} /></F>
-                <F label="SRX"><Input type="number" value={draft.srx ?? ''} onChange={(e) => set('srx', intOrUndef(e.target.value) as any)} /></F>
-                <F label="STX"><Input type="number" value={draft.stx ?? ''} onChange={(e) => set('stx', intOrUndef(e.target.value) as any)} /></F>
-                <F label="SRX string" span={3}><Input value={draft.srx_string ?? ''} onChange={(e) => set('srx_string', e.target.value)} /></F>
-                <F label="STX string" span={3}><Input value={draft.stx_string ?? ''} onChange={(e) => set('stx_string', e.target.value)} /></F>
+                <F label="SRX" span={2}><Input value={draft.srx_string || (draft.srx ?? '')} placeholder="rcvd exchange" onChange={(e) => setExchange('srx', e.target.value)} /></F>
+                <F label="STX" span={2}><Input value={draft.stx_string || (draft.stx ?? '')} placeholder="sent exchange" onChange={(e) => setExchange('stx', e.target.value)} /></F>
                 <F label="Check"><Input value={draft.check ?? ''} onChange={(e) => set('check', e.target.value)} /></F>
                 <F label="Precedence"><Input value={draft.precedence ?? ''} onChange={(e) => set('precedence', e.target.value)} /></F>
                 <F label="ARRL section"><Input value={draft.arrl_sect ?? ''} onChange={(e) => set('arrl_sect', e.target.value)} /></F>

frontend/src/components/RecentQSOsGrid.tsx

@@ -45,6 +45,9 @@ const hamlogTheme = themeQuartz.withParams({
 type Props = {
   rows: QSOForm[];
   total: number;
+  // Bump this number to programmatically select every row (e.g. after a search
+  // in the QSL Manager, where the default is "all selected").
+  selectAllSignal?: number;
   onRowDoubleClicked?: (q: QSOForm) => void;
   onRowSelected?: (ids: number[]) => void;
   onUpdateFromCty?: (ids: number[]) => void;
@@ -56,6 +59,7 @@ type Props = {
   onBulkEdit?: (ids: number[]) => void;
   onExportSelected?: (ids: number[]) => void;
   onExportFiltered?: () => void;
+  onDelete?: (ids: number[]) => void;
   // One column per defined award; the cell shows the reference this QSO counts
   // for (from row.award_refs[CODE], attached by the parent). Hidden by default.
   awardCols?: { code: string; name: string }[];
@@ -156,6 +160,8 @@ export const COL_CATALOG: ColEntry[] = [
   { group: 'eQSL', label: 'eQSL rcvd date', colId: 'eqsl_rcvd_date', headerName: 'eQSL R date', field: 'eqsl_rcvd_date' as any, width: 120, valueFormatter: (p) => fmtDateOnly(p.value) },
   // App-specific: when OpsLog e-mailed its own QSL card. Distinct from eQSL.cc.
   { group: 'QSL', label: 'OpsLog QSL', colId: 'opslog_qsl_card_sent', headerName: 'OpsLog QSL', width: 100, cellClass: 'font-mono', valueGetter: (p) => { const e = (p.data as any)?.extras ?? {}; return (e['APP_OPSLOG_QSL_SENT'] || e['APP_OPSLOG_QSL_CARD_SENT']) ? 'Y' : 'N'; }, defaultVisible: true },
+  // App-specific: when the QSO's audio recording was e-mailed to the station.
+  { group: 'QSL', label: 'Recording sent', colId: 'opslog_recording_sent', headerName: 'Rec sent', width: 100, cellClass: 'font-mono', valueGetter: (p) => { const e = (p.data as any)?.extras ?? {}; return e['APP_OPSLOG_RECORDING_SENT'] ? 'Y' : 'N'; }, defaultVisible: false },
 
   // ── Uploads (online logbooks) ──
   // ADIF models these as an "upload status/date" (= YOU pushed the QSO) and,
@@ -222,7 +228,7 @@ export const GROUP_ORDER = [
   'Contest', 'Propagation', 'My station', 'Misc',
 ];
 
-export function RecentQSOsGrid({ rows, onRowDoubleClicked, onRowSelected, onUpdateFromCty, onUpdateFromQRZ, onUpdateFromClublog, onSendTo, onSendRecording, onSendEQSL, onBulkEdit, onExportSelected, onExportFiltered, awardCols }: Props) {
+export function RecentQSOsGrid({ rows, selectAllSignal, onRowDoubleClicked, onRowSelected, onUpdateFromCty, onUpdateFromQRZ, onUpdateFromClublog, onSendTo, onSendRecording, onSendEQSL, onBulkEdit, onExportSelected, onExportFiltered, onDelete, awardCols }: Props) {
   const gridRef = useRef<any>(null);
   const [pickerOpen, setPickerOpen] = useState(false);
   const [menu, setMenu] = useState<QSOMenuState>(null);
@@ -248,7 +254,14 @@ export function RecentQSOsGrid({ rows, onRowDoubleClicked, onRowSelected, onUpda
   // Compute initial column defs: all columns defined, but those not marked
   // defaultVisible start hidden. The user's saved state (loaded onGridReady)
   // overrides this so a previously toggled column wins.
+  // While AG Grid rebuilds columns (award columns load async), it fires column
+  // events that would otherwise trigger a save of the DEFAULT visibility before
+  // we re-apply the user's saved state — clobbering it. This flag suppresses the
+  // auto-save during that window. Set in the memo (runs at render, before the
+  // column events) and cleared by the re-apply effect below.
+  const restoringRef = useRef(true);
   const columnDefs = useMemo<ColDef<QSOForm>[]>(() => {
+    restoringRef.current = true;
     const base = COL_CATALOG.map((c) => {
       const { group: _g, label: _l, defaultVisible, ...rest } = c;
       return { ...rest, hide: !defaultVisible };
@@ -284,6 +297,7 @@ export function RecentQSOsGrid({ rows, onRowDoubleClicked, onRowSelected, onUpda
     });
   }
   const saveColumnState = useCallback(() => {
+    if (restoringRef.current) return; // ignore the events fired by a column rebuild
     const state = gridRef.current?.api?.getColumnState();
     if (state) saveState(COL_STATE_KEY, state);
   }, []);
@@ -295,9 +309,11 @@ export function RecentQSOsGrid({ rows, onRowDoubleClicked, onRowSelected, onUpda
   // every rebuild so the user's choices win. No-op before the grid is ready.
   useEffect(() => {
     const api = gridRef.current?.api;
-    if (!api) return;
     const local = loadLocal(COL_STATE_KEY);
-    if (local) api.applyColumnState({ state: local as ColumnState[], applyOrder: true });
+    if (api && local) api.applyColumnState({ state: local as ColumnState[], applyOrder: true });
+    // Re-enable saving once AG Grid has settled the column events from the rebuild.
+    const t = window.setTimeout(() => { restoringRef.current = false; }, 0);
+    return () => window.clearTimeout(t);
   }, [awardCols]);
 
   function handleRowDoubleClicked(e: RowDoubleClickedEvent<QSOForm>) {
@@ -307,6 +323,11 @@ export function RecentQSOsGrid({ rows, onRowDoubleClicked, onRowSelected, onUpda
     const sel = (gridRef.current?.api?.getSelectedRows() as QSOForm[] | undefined) ?? [];
     onRowSelected?.(sel.map((r) => r.id as number).filter((id) => id != null));
   }
+  // Select every row when the caller bumps selectAllSignal (QSL Manager search).
+  useEffect(() => {
+    if (selectAllSignal === undefined) return;
+    gridRef.current?.api?.selectAll();
+  }, [selectAllSignal]);
 
   // ── Column picker (visibility) ──
   // Drives AG Grid via setColumnsVisible(). We don't keep a parallel React
@@ -395,6 +416,7 @@ export function RecentQSOsGrid({ rows, onRowDoubleClicked, onRowSelected, onUpda
         onBulkEdit={onBulkEdit}
         onExportSelected={onExportSelected}
         onExportFiltered={onExportFiltered}
+        onDelete={onDelete}
       />
 
       <Dialog open={pickerOpen} onOpenChange={setPickerOpen}>

frontend/src/components/SettingsModal.tsx

@@ -38,6 +38,7 @@ import {
   TestLoTWUpload, ListTQSLStationLocations,
   ComputeStationInfo,
   GetUIPref, SetUIPref,
+  GetFlexState, GetFlexBandAntennas, SaveFlexBandAntennas,
 } from '../../wailsjs/go/main/App';
 import type { profile as profileModels } from '../../wailsjs/go/models';
 import type { LookupSettingsForm, StationSettingsForm, ListsSettingsForm, ModePresetForm } from '@/types';
@@ -132,8 +133,10 @@ const emptyProfile = (): Profile => ({
   is_active: false,
   sort_order: 0,
   db: { backend: '', host: '', port: 3306, user: '', password: '', database: '' },
-  created_at: '' as any,
-  updated_at: '' as any,
+  // Server-managed timestamps — send null (NOT "") so Go's time.Time unmarshal
+  // leaves the zero value instead of failing to parse an empty RFC3339 string.
+  created_at: null as any,
+  updated_at: null as any,
 });
 
 interface Props {
@@ -174,13 +177,27 @@ type SectionId =
   | 'antenna'
   | 'antgenius'
   | 'pgxl'
+  | 'flex'
   | 'audio';
 
 type TreeNode =
   | { kind: 'group'; label: string; icon?: any; defaultOpen?: boolean; children: TreeNode[] }
   | { kind: 'item';  label: string; id: SectionId; disabled?: boolean };
 
-const TREE: TreeNode[] = [
+// buildTree returns the settings sidebar. The FlexRadio item only appears when
+// the active CAT backend is a Flex (per-band antenna config is Flex-specific).
+function buildTree(flexAvailable: boolean): TreeNode[] {
+  const hardware: TreeNode[] = [
+    { kind: 'item', label: 'CAT interface',          id: 'cat' },
+    { kind: 'item', label: 'PstRotator',            id: 'rotator' },
+    { kind: 'item', label: 'CW Keyer',             id: 'winkeyer' },
+    { kind: 'item', label: 'UltraBeam',             id: 'antenna' },
+    { kind: 'item', label: 'Antenna Genius',      id: 'antgenius' },
+    { kind: 'item', label: 'Power Genius',         id: 'pgxl' },
+    ...(flexAvailable ? [{ kind: 'item', label: 'FlexRadio', id: 'flex' } as TreeNode] : []),
+    { kind: 'item', label: 'Audio devices',     id: 'audio' },
+  ];
+  return [
   {
     kind: 'group', label: 'User Configuration', icon: User, defaultOpen: true, children: [
       { kind: 'item', label: 'Station Information', id: 'station' },
@@ -206,17 +223,10 @@ const TREE: TreeNode[] = [
     ],
   },
   {
-    kind: 'group', label: 'Hardware Configuration', icon: Server, defaultOpen: true, children: [
-      { kind: 'item', label: 'CAT interface',          id: 'cat' },
-      { kind: 'item', label: 'PstRotator',            id: 'rotator' },
-      { kind: 'item', label: 'CW Keyer',             id: 'winkeyer' },
-      { kind: 'item', label: 'UltraBeam',             id: 'antenna' },
-      { kind: 'item', label: 'Antenna Genius',      id: 'antgenius' },
-      { kind: 'item', label: 'Power Genius',         id: 'pgxl' },
-      { kind: 'item', label: 'Audio devices',     id: 'audio' },
-    ],
+    kind: 'group', label: 'Hardware Configuration', icon: Server, defaultOpen: true, children: hardware,
   },
-];
+  ];
+}
 
 // Map section id → friendly name (used in breadcrumb / placeholders).
 const SECTION_LABELS: Partial<Record<SectionId, string>> = {
@@ -240,6 +250,7 @@ const SECTION_LABELS: Partial<Record<SectionId, string>> = {
   antenna: 'UltraBeam',
   antgenius: 'Antenna Genius',
   pgxl: 'Power Genius',
+  flex: 'FlexRadio',
   audio: 'Audio devices',
 };
 
@@ -248,12 +259,13 @@ const SECTION_LABELS: Partial<Record<SectionId, string>> = {
 interface TreeProps {
   selected: SectionId;
   onSelect: (id: SectionId) => void;
+  flexAvailable?: boolean;
 }
 
-function Tree({ selected, onSelect }: TreeProps) {
+function Tree({ selected, onSelect, flexAvailable }: TreeProps) {
   return (
     <nav className="text-sm">
-      {TREE.map((node, i) => (
+      {buildTree(!!flexAvailable).map((node, i) => (
         <TreeNodeView key={i} node={node} depth={0} selected={selected} onSelect={onSelect} />
       ))}
     </nav>
@@ -485,14 +497,16 @@ const MAIN_PANE_OPTIONS: { value: string; label: string }[] = [
   { value: 'map2', label: 'Map — locator (street)' },
   { value: 'cluster', label: 'Cluster spots' },
   { value: 'worked', label: 'Worked before' },
+  { value: 'recent', label: 'Recent QSOs' },
 ];
 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
+  // FlexRadio is only offered when the CAT backend is a Flex. Sorted A→Z.
+  const options = (flexAvailable
     ? [...MAIN_PANE_OPTIONS, { value: 'flex', label: 'FlexRadio controls' }]
-    : MAIN_PANE_OPTIONS;
+    : [...MAIN_PANE_OPTIONS]
+  ).sort((a, b) => a.label.localeCompare(b.label));
   useEffect(() => {
     const valid = (v: string) => v === 'flex' || MAIN_PANE_OPTIONS.some((o) => o.value === v);
     Promise.all([GetUIPref('mainPaneLeft').catch(() => ''), GetUIPref('mainPaneRight').catch(() => '')])
@@ -583,6 +597,90 @@ function ComingSoon({ id, icon: Icon }: { id: SectionId; icon?: any }) {
   );
 }
 
+// FlexBandAntennasPanel — pick the RX/TX antenna per band. Applied automatically
+// when the band changes (frequency change / spot click). Antennas come live from
+// the connected FlexRadio; bands come from Lists → Bands.
+function FlexBandAntennasPanel({ bands }: { bands: string[] }) {
+  const [rxList, setRxList] = useState<string[]>([]);
+  const [txList, setTxList] = useState<string[]>([]);
+  const [map, setMap] = useState<Record<string, { rx: string; tx: string }>>({});
+  const [msg, setMsg] = useState('');
+  useEffect(() => {
+    GetFlexState().then((s: any) => {
+      setRxList((s?.ant_list ?? []) as string[]);
+      setTxList(((s?.tx_ant_list?.length ? s.tx_ant_list : s?.ant_list) ?? []) as string[]);
+    }).catch(() => {});
+    GetFlexBandAntennas().then((m: any) => setMap(m ?? {})).catch(() => {});
+  }, []);
+  const set = (band: string, side: 'rx' | 'tx', v: string) => {
+    const key = band.toUpperCase();
+    setMap((m) => {
+      const cur = m[key] ?? { rx: '', tx: '' };
+      const next = { ...m, [key]: { ...cur, [side]: v } };
+      SaveFlexBandAntennas(next as any)
+        .then(() => { setMsg('Saved'); window.setTimeout(() => setMsg(''), 1200); })
+        .catch((e: any) => setMsg(String(e?.message ?? e)));
+      return next;
+    });
+  };
+  return (
+    <div className="space-y-3">
+      <div>
+        <h3 className="text-base font-semibold text-foreground">FlexRadio — per-band antennas</h3>
+        <p className="text-xs text-muted-foreground">
+          Choose the RX and TX antenna for each band. They're applied automatically when the band
+          changes (frequency change or clicking a spot).
+        </p>
+      </div>
+      {rxList.length === 0 && (
+        <div className="text-xs text-amber-700 bg-amber-50 border border-amber-200 rounded-md px-3 py-2 max-w-xl">
+          No antennas reported yet — make sure the FlexRadio is connected (CAT interface), then reopen this panel.
+        </div>
+      )}
+      {bands.length === 0 ? (
+        <p className="text-xs text-muted-foreground">No bands configured — add them in Lists → Bands.</p>
+      ) : (
+        <div className="rounded-md border border-border overflow-hidden max-w-xl">
+          <table className="w-full text-sm">
+            <thead className="bg-muted/40 text-muted-foreground text-xs">
+              <tr>
+                <th className="text-left px-3 py-1.5 font-semibold">Band</th>
+                <th className="text-left px-3 py-1.5 font-semibold">RX antenna</th>
+                <th className="text-left px-3 py-1.5 font-semibold">TX antenna</th>
+              </tr>
+            </thead>
+            <tbody>
+              {bands.map((b) => {
+                const e = map[b.toUpperCase()] ?? { rx: '', tx: '' };
+                return (
+                  <tr key={b} className="border-t border-border/50">
+                    <td className="px-3 py-1.5 font-mono font-semibold">{b}</td>
+                    <td className="px-3 py-1.5">
+                      <select value={e.rx ?? ''} onChange={(ev) => set(b, 'rx', ev.target.value)}
+                        className="h-8 w-32 rounded-md border border-input bg-background px-1.5 text-xs font-mono">
+                        <option value="">— none —</option>
+                        {rxList.map((a) => <option key={a} value={a}>{a}</option>)}
+                      </select>
+                    </td>
+                    <td className="px-3 py-1.5">
+                      <select value={e.tx ?? ''} onChange={(ev) => set(b, 'tx', ev.target.value)}
+                        className="h-8 w-32 rounded-md border border-input bg-background px-1.5 text-xs font-mono">
+                        <option value="">— none —</option>
+                        {txList.map((a) => <option key={a} value={a}>{a}</option>)}
+                      </select>
+                    </td>
+                  </tr>
+                );
+              })}
+            </tbody>
+          </table>
+        </div>
+      )}
+      {msg && <span className="text-[11px] text-muted-foreground">{msg}</span>}
+    </div>
+  );
+}
+
 export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChanged, flexAvailable }: Props) {
   const [selected, setSelected] = useState<SectionId>((initialSection as SectionId) || 'station');
   const [loading, setLoading] = useState(true);
@@ -619,7 +717,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   const [modeDraft, setModeDraft] = useState('');
   const [catCfg, setCatCfg] = useState<CATSettings>({
     enabled: false, backend: 'omnirig', omnirig_rig: 1, flex_host: '', flex_port: 4992, flex_spots: false,
-    icom_port: '', icom_baud: 115200, icom_addr: 0x98, poll_ms: 250, delay_ms: 0,
+    icom_port: '', icom_baud: 115200, icom_addr: 0x98, tci_host: '', tci_port: 40001, tci_spots: false, poll_ms: 250, delay_ms: 0,
     digital_default: 'FT8',
   });
   const [rotator, setRotator] = useState<RotatorSettings>({
@@ -1796,6 +1894,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                   <SelectItem value="omnirig">OmniRig (any rig, Windows COM)</SelectItem>
                   <SelectItem value="flex">FlexRadio / SmartSDR (native)</SelectItem>
                   <SelectItem value="icom">Icom CI-V (USB serial)</SelectItem>
+                  <SelectItem value="tci">TCI (Expert Electronics / SunSDR)</SelectItem>
                 </SelectContent>
               </Select>
             </div>
@@ -1865,6 +1964,27 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
               </div>
             </>
             )}
+            {catCfg.backend === 'tci' && (
+            <>
+              <div className="space-y-1">
+                <Label>TCI host</Label>
+                <Input placeholder="127.0.0.1" value={catCfg.tci_host ?? ''}
+                  onChange={(e) => setCatCfg((s) => ({ ...s, tci_host: e.target.value }))} />
+              </div>
+              <div className="space-y-1">
+                <Label>Port</Label>
+                <Input type="number" value={catCfg.tci_port || 40001}
+                  onChange={(e) => setCatCfg((s) => ({ ...s, tci_port: parseInt(e.target.value) || 40001 }))} />
+              </div>
+              <p className="col-span-2 text-xs text-muted-foreground">
+                Enable the TCI server in ExpertSDR2/EESDR (Options → TCI). Default port 40001. Use 127.0.0.1 when OpsLog runs on the same PC.
+              </p>
+              <label className="col-span-2 flex items-center gap-2 text-sm cursor-pointer">
+                <Checkbox checked={!!catCfg.tci_spots} onCheckedChange={(c) => setCatCfg((s) => ({ ...s, tci_spots: !!c }))} />
+                Show cluster spots on the panorama <span className="text-xs text-muted-foreground">(spots from OpsLog's DX cluster appear on the SDR panadapter)</span>
+              </label>
+            </>
+            )}
             {(catCfg.backend === 'omnirig' || catCfg.backend === 'icom') && (
             <>
             <div className="space-y-1">
@@ -3846,6 +3966,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     antenna:        UltrabeamPanel,
     antgenius:      AntGeniusPanelSettings,
     pgxl:           PGXLPanelSettings,
+    flex:           () => <FlexBandAntennasPanel bands={lists.bands ?? []} />,
     audio:          AudioPanel,
   };
 
@@ -3863,7 +3984,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
           <div className="grid grid-cols-[320px_1fr] min-h-0 overflow-hidden">
             {/* Left sidebar tree */}
             <aside className="border-r border-border bg-muted/30 overflow-y-auto p-2">
-              <Tree selected={selected} onSelect={setSelected} />
+              <Tree selected={selected} onSelect={setSelected} flexAvailable={flexAvailable} />
             </aside>
 
             {/* Right content pane */}

frontend/src/components/WorkedBeforeGrid.tsx

@@ -1,4 +1,4 @@
-import { useCallback, useMemo, useRef, useState } from 'react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import {
   AllCommunityModule, ModuleRegistry, themeQuartz,
   type ColDef, type ColumnState, type GridReadyEvent, type RowDoubleClickedEvent,
@@ -53,6 +53,7 @@ type Props = {
   onSendTo?: (service: string, ids: number[]) => void;
   onSendRecording?: (ids: number[]) => void;
   onSendEQSL?: (ids: number[]) => void;
+  onDelete?: (ids: number[]) => void;
   // One column per defined award (cell = the reference this QSO counts for).
   awardCols?: { code: string; name: string }[];
 };
@@ -67,7 +68,7 @@ function fmtDate(s: any): string {
   return `${d.getUTCFullYear()}-${p(d.getUTCMonth() + 1)}-${p(d.getUTCDate())}`;
 }
 
-export function WorkedBeforeGrid({ wb, busy, currentCall, onRowDoubleClicked, onUpdateFromCty, onUpdateFromQRZ, onUpdateFromClublog, onSendTo, onSendRecording, onSendEQSL, awardCols }: Props) {
+export function WorkedBeforeGrid({ wb, busy, currentCall, onRowDoubleClicked, onUpdateFromCty, onUpdateFromQRZ, onUpdateFromClublog, onSendTo, onSendRecording, onSendEQSL, onDelete, awardCols }: Props) {
   const gridRef = useRef<any>(null);
   const [pickerOpen, setPickerOpen] = useState(false);
   const [menu, setMenu] = useState<QSOMenuState>(null);
@@ -95,7 +96,12 @@ export function WorkedBeforeGrid({ wb, busy, currentCall, onRowDoubleClicked, on
   const count = wb?.count ?? 0;
   const entries = wb?.entries ?? [];
 
+  // Suppress auto-save while AG Grid rebuilds columns (award columns load async),
+  // so the default visibility doesn't clobber the user's saved state. See the
+  // matching note in RecentQSOsGrid.
+  const restoringRef = useRef(true);
   const columnDefs = useMemo<ColDef<WorkedEntry>[]>(() => {
+    restoringRef.current = true;
     const base = COL_CATALOG.map((c) => {
       const { group: _g, label: _l, defaultVisible, ...rest } = c;
       return { ...rest, hide: !defaultVisible };
@@ -126,10 +132,21 @@ export function WorkedBeforeGrid({ wb, busy, currentCall, onRowDoubleClicked, on
     });
   }
   const saveColumnState = useCallback(() => {
+    if (restoringRef.current) return; // ignore events fired by a column rebuild
     const state = gridRef.current?.api?.getColumnState();
     if (state) saveState(COL_STATE_KEY, state);
   }, []);
 
+  // Re-apply the saved column state after the award columns load (they rebuild
+  // the column set), so the user's visibility choices win over the defaults.
+  useEffect(() => {
+    const api = gridRef.current?.api;
+    const local = loadLocal(COL_STATE_KEY);
+    if (api && local) api.applyColumnState({ state: local as ColumnState[], applyOrder: true });
+    const t = window.setTimeout(() => { restoringRef.current = false; }, 0);
+    return () => window.clearTimeout(t);
+  }, [awardCols]);
+
   function isColVisible(colId: string): boolean {
     const col = gridRef.current?.api?.getColumn(colId);
     return col ? col.isVisible() : !!COL_CATALOG.find((c) => c.colId === colId)?.defaultVisible;
@@ -253,6 +270,7 @@ export function WorkedBeforeGrid({ wb, busy, currentCall, onRowDoubleClicked, on
         onSendTo={onSendTo}
         onSendRecording={onSendRecording}
         onSendEQSL={onSendEQSL}
+        onDelete={onDelete}
       />
 
       {count > entries.length && (

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

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

@@ -16,6 +16,7 @@ import {audio} from '../models';
 import {operating} from '../models';
 import {udp} from '../models';
 import {lookup} from '../models';
+import {netctl} from '../models';
 
 export function ADIFFields():Promise<Array<adif.FieldDef>>;
 
@@ -129,7 +130,7 @@ export function ExportAwards():Promise<string>;
 
 export function FilterFields():Promise<Array<string>>;
 
-export function FindQSOsForUpload(arg1:string,arg2:string):Promise<Array<qso.UploadRow>>;
+export function FindQSOsForUpload(arg1:string,arg2:string):Promise<Array<qso.QSO>>;
 
 export function FlexATUBypass():Promise<void>;
 
@@ -137,6 +138,8 @@ export function FlexATUStart():Promise<void>;
 
 export function FlexAmpOperate(arg1:boolean):Promise<void>;
 
+export function FlexApplyBandAntenna(arg1:string):Promise<void>;
+
 export function FlexMox(arg1:boolean):Promise<void>;
 
 export function FlexSetAGCMode(arg1:string):Promise<void>;
@@ -173,6 +176,8 @@ export function FlexSetMon(arg1:boolean):Promise<void>;
 
 export function FlexSetMonLevel(arg1:number):Promise<void>;
 
+export function FlexSetMute(arg1:boolean):Promise<void>;
+
 export function FlexSetNB(arg1:boolean):Promise<void>;
 
 export function FlexSetNBLevel(arg1:number):Promise<void>;
@@ -187,8 +192,14 @@ export function FlexSetProcessor(arg1:boolean):Promise<void>;
 
 export function FlexSetProcessorLevel(arg1:number):Promise<void>;
 
+export function FlexSetRXAntenna(arg1:string):Promise<void>;
+
 export function FlexSetSidetoneLevel(arg1:number):Promise<void>;
 
+export function FlexSetSplit(arg1:boolean):Promise<void>;
+
+export function FlexSetTXAntenna(arg1:string):Promise<void>;
+
 export function FlexSetTunePower(arg1:number):Promise<void>;
 
 export function FlexSetVox(arg1:boolean):Promise<void>;
@@ -255,6 +266,8 @@ export function GetEmailSettings():Promise<main.EmailSettings>;
 
 export function GetExternalServices():Promise<extsvc.ExternalServices>;
 
+export function GetFlexBandAntennas():Promise<Record<string, main.FlexBandAnt>>;
+
 export function GetFlexState():Promise<cat.FlexTXState>;
 
 export function GetIcomState():Promise<cat.IcomTXState>;
@@ -371,6 +384,40 @@ export function LookupCallsign(arg1:string):Promise<lookup.Result>;
 
 export function MoveDatabase(arg1:string):Promise<void>;
 
+export function NetActivate(arg1:string):Promise<qso.QSO>;
+
+export function NetActiveList():Promise<Array<qso.QSO>>;
+
+export function NetClose():Promise<void>;
+
+export function NetCreate(arg1:string):Promise<netctl.Net>;
+
+export function NetDeactivate(arg1:number):Promise<number>;
+
+export function NetDelete(arg1:string):Promise<void>;
+
+export function NetDiscardActive(arg1:number):Promise<void>;
+
+export function NetList():Promise<Array<netctl.Net>>;
+
+export function NetLookup(arg1:string):Promise<netctl.Station>;
+
+export function NetOpen(arg1:string):Promise<void>;
+
+export function NetOpenID():Promise<string>;
+
+export function NetRename(arg1:string,arg2:string):Promise<void>;
+
+export function NetRoster(arg1:string):Promise<Array<netctl.Station>>;
+
+export function NetRosterRemove(arg1:string,arg2:string):Promise<void>;
+
+export function NetRosterUpsert(arg1:string,arg2:netctl.Station):Promise<void>;
+
+export function NetSetDefaults(arg1:string,arg2:string,arg3:string,arg4:string):Promise<void>;
+
+export function NetUpdateActive(arg1:qso.QSO):Promise<void>;
+
 export function OpenADIFFile():Promise<string>;
 
 export function OpenDatabase(arg1:string):Promise<void>;
@@ -429,6 +476,8 @@ export function QSOAudioBegin():Promise<boolean>;
 
 export function QSOAudioCancel():Promise<void>;
 
+export function QSOAudioResetClock():Promise<boolean>;
+
 export function QSOAudioRestart():Promise<boolean>;
 
 export function QuitApp():Promise<void>;
@@ -483,6 +532,8 @@ export function SaveEmailSettings(arg1:main.EmailSettings):Promise<void>;
 
 export function SaveExternalServices(arg1:extsvc.ExternalServices):Promise<void>;
 
+export function SaveFlexBandAntennas(arg1:Record<string, main.FlexBandAnt>):Promise<void>;
+
 export function SaveListsSettings(arg1:main.ListsSettings):Promise<void>;
 
 export function SaveLookupSettings(arg1:main.LookupSettings):Promise<void>;

frontend/wailsjs/go/main/App.js

@@ -242,6 +242,10 @@ export function FlexAmpOperate(arg1) {
   return window['go']['main']['App']['FlexAmpOperate'](arg1);
 }
 
+export function FlexApplyBandAntenna(arg1) {
+  return window['go']['main']['App']['FlexApplyBandAntenna'](arg1);
+}
+
 export function FlexMox(arg1) {
   return window['go']['main']['App']['FlexMox'](arg1);
 }
@@ -314,6 +318,10 @@ export function FlexSetMonLevel(arg1) {
   return window['go']['main']['App']['FlexSetMonLevel'](arg1);
 }
 
+export function FlexSetMute(arg1) {
+  return window['go']['main']['App']['FlexSetMute'](arg1);
+}
+
 export function FlexSetNB(arg1) {
   return window['go']['main']['App']['FlexSetNB'](arg1);
 }
@@ -342,10 +350,22 @@ export function FlexSetProcessorLevel(arg1) {
   return window['go']['main']['App']['FlexSetProcessorLevel'](arg1);
 }
 
+export function FlexSetRXAntenna(arg1) {
+  return window['go']['main']['App']['FlexSetRXAntenna'](arg1);
+}
+
 export function FlexSetSidetoneLevel(arg1) {
   return window['go']['main']['App']['FlexSetSidetoneLevel'](arg1);
 }
 
+export function FlexSetSplit(arg1) {
+  return window['go']['main']['App']['FlexSetSplit'](arg1);
+}
+
+export function FlexSetTXAntenna(arg1) {
+  return window['go']['main']['App']['FlexSetTXAntenna'](arg1);
+}
+
 export function FlexSetTunePower(arg1) {
   return window['go']['main']['App']['FlexSetTunePower'](arg1);
 }
@@ -478,6 +498,10 @@ export function GetExternalServices() {
   return window['go']['main']['App']['GetExternalServices']();
 }
 
+export function GetFlexBandAntennas() {
+  return window['go']['main']['App']['GetFlexBandAntennas']();
+}
+
 export function GetFlexState() {
   return window['go']['main']['App']['GetFlexState']();
 }
@@ -710,6 +734,74 @@ export function MoveDatabase(arg1) {
   return window['go']['main']['App']['MoveDatabase'](arg1);
 }
 
+export function NetActivate(arg1) {
+  return window['go']['main']['App']['NetActivate'](arg1);
+}
+
+export function NetActiveList() {
+  return window['go']['main']['App']['NetActiveList']();
+}
+
+export function NetClose() {
+  return window['go']['main']['App']['NetClose']();
+}
+
+export function NetCreate(arg1) {
+  return window['go']['main']['App']['NetCreate'](arg1);
+}
+
+export function NetDeactivate(arg1) {
+  return window['go']['main']['App']['NetDeactivate'](arg1);
+}
+
+export function NetDelete(arg1) {
+  return window['go']['main']['App']['NetDelete'](arg1);
+}
+
+export function NetDiscardActive(arg1) {
+  return window['go']['main']['App']['NetDiscardActive'](arg1);
+}
+
+export function NetList() {
+  return window['go']['main']['App']['NetList']();
+}
+
+export function NetLookup(arg1) {
+  return window['go']['main']['App']['NetLookup'](arg1);
+}
+
+export function NetOpen(arg1) {
+  return window['go']['main']['App']['NetOpen'](arg1);
+}
+
+export function NetOpenID() {
+  return window['go']['main']['App']['NetOpenID']();
+}
+
+export function NetRename(arg1, arg2) {
+  return window['go']['main']['App']['NetRename'](arg1, arg2);
+}
+
+export function NetRoster(arg1) {
+  return window['go']['main']['App']['NetRoster'](arg1);
+}
+
+export function NetRosterRemove(arg1, arg2) {
+  return window['go']['main']['App']['NetRosterRemove'](arg1, arg2);
+}
+
+export function NetRosterUpsert(arg1, arg2) {
+  return window['go']['main']['App']['NetRosterUpsert'](arg1, arg2);
+}
+
+export function NetSetDefaults(arg1, arg2, arg3, arg4) {
+  return window['go']['main']['App']['NetSetDefaults'](arg1, arg2, arg3, arg4);
+}
+
+export function NetUpdateActive(arg1) {
+  return window['go']['main']['App']['NetUpdateActive'](arg1);
+}
+
 export function OpenADIFFile() {
   return window['go']['main']['App']['OpenADIFFile']();
 }
@@ -826,6 +918,10 @@ export function QSOAudioCancel() {
   return window['go']['main']['App']['QSOAudioCancel']();
 }
 
+export function QSOAudioResetClock() {
+  return window['go']['main']['App']['QSOAudioResetClock']();
+}
+
 export function QSOAudioRestart() {
   return window['go']['main']['App']['QSOAudioRestart']();
 }
@@ -934,6 +1030,10 @@ export function SaveExternalServices(arg1) {
   return window['go']['main']['App']['SaveExternalServices'](arg1);
 }
 
+export function SaveFlexBandAntennas(arg1) {
+  return window['go']['main']['App']['SaveFlexBandAntennas'](arg1);
+}
+
 export function SaveListsSettings(arg1) {
   return window['go']['main']['App']['SaveListsSettings'](arg1);
 }

frontend/wailsjs/go/models.ts

@@ -512,9 +512,17 @@ export namespace cat {
 	    atu_status?: string;
 	    atu_memories: boolean;
 	    rx_avail: boolean;
+	    split: boolean;
+	    rx_freq_hz?: number;
+	    tx_freq_hz?: number;
 	    agc_mode?: string;
 	    agc_threshold: number;
 	    audio_level: number;
+	    mute: boolean;
+	    rx_ant?: string;
+	    tx_ant?: string;
+	    ant_list?: string[];
+	    tx_ant_list?: string[];
 	    nb: boolean;
 	    nb_level: number;
 	    nr: boolean;
@@ -560,9 +568,17 @@ export namespace cat {
 	        this.atu_status = source["atu_status"];
 	        this.atu_memories = source["atu_memories"];
 	        this.rx_avail = source["rx_avail"];
+	        this.split = source["split"];
+	        this.rx_freq_hz = source["rx_freq_hz"];
+	        this.tx_freq_hz = source["tx_freq_hz"];
 	        this.agc_mode = source["agc_mode"];
 	        this.agc_threshold = source["agc_threshold"];
 	        this.audio_level = source["audio_level"];
+	        this.mute = source["mute"];
+	        this.rx_ant = source["rx_ant"];
+	        this.tx_ant = source["tx_ant"];
+	        this.ant_list = source["ant_list"];
+	        this.tx_ant_list = source["tx_ant_list"];
 	        this.nb = source["nb"];
 	        this.nb_level = source["nb_level"];
 	        this.nr = source["nr"];
@@ -1160,6 +1176,9 @@ export namespace main {
 	    icom_port: string;
 	    icom_baud: number;
 	    icom_addr: number;
+	    tci_host: string;
+	    tci_port: number;
+	    tci_spots: boolean;
 	    poll_ms: number;
 	    delay_ms: number;
 	    digital_default: string;
@@ -1179,6 +1198,9 @@ export namespace main {
 	        this.icom_port = source["icom_port"];
 	        this.icom_baud = source["icom_baud"];
 	        this.icom_addr = source["icom_addr"];
+	        this.tci_host = source["tci_host"];
+	        this.tci_port = source["tci_port"];
+	        this.tci_spots = source["tci_spots"];
 	        this.poll_ms = source["poll_ms"];
 	        this.delay_ms = source["delay_ms"];
 	        this.digital_default = source["digital_default"];
@@ -1562,6 +1584,8 @@ export namespace main {
 	    sent_date: string;
 	    rcvd_date: string;
 	    via: string;
+	    notes: string;
+	    comment: string;
 	
 	    static createFrom(source: any = {}) {
 	        return new QSLBulkUpdate(source);
@@ -1574,6 +1598,8 @@ export namespace main {
 	        this.sent_date = source["sent_date"];
 	        this.rcvd_date = source["rcvd_date"];
 	        this.via = source["via"];
+	        this.notes = source["notes"];
+	        this.comment = source["comment"];
 	    }
 	}
 	export class QSLDefaults {
@@ -2007,6 +2033,81 @@ export namespace main {
 
 }
 
+export namespace netctl {
+	
+	export class Station {
+	    callsign: string;
+	    name?: string;
+	    qth?: string;
+	    country?: string;
+	    dxcc?: number;
+	    itu?: number;
+	    cq?: number;
+	    groups?: string;
+	    sig?: string;
+	    sig_info?: string;
+	
+	    static createFrom(source: any = {}) {
+	        return new Station(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.callsign = source["callsign"];
+	        this.name = source["name"];
+	        this.qth = source["qth"];
+	        this.country = source["country"];
+	        this.dxcc = source["dxcc"];
+	        this.itu = source["itu"];
+	        this.cq = source["cq"];
+	        this.groups = source["groups"];
+	        this.sig = source["sig"];
+	        this.sig_info = source["sig_info"];
+	    }
+	}
+	export class Net {
+	    id: string;
+	    name: string;
+	    default_rst_sent?: string;
+	    default_rst_rcvd?: string;
+	    default_comment?: string;
+	    stations?: Station[];
+	
+	    static createFrom(source: any = {}) {
+	        return new Net(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.id = source["id"];
+	        this.name = source["name"];
+	        this.default_rst_sent = source["default_rst_sent"];
+	        this.default_rst_rcvd = source["default_rst_rcvd"];
+	        this.default_comment = source["default_comment"];
+	        this.stations = this.convertValues(source["stations"], Station);
+	    }
+	
+		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 namespace operating {
 	
 	export class AntennaBand {
@@ -2820,30 +2921,6 @@ export namespace qso {
 		    return a;
 		}
 	}
-	export class UploadRow {
-	    id: number;
-	    qso_date: string;
-	    callsign: string;
-	    band: string;
-	    mode: string;
-	    country: string;
-	    status: string;
-	
-	    static createFrom(source: any = {}) {
-	        return new UploadRow(source);
-	    }
-	
-	    constructor(source: any = {}) {
-	        if ('string' === typeof source) source = JSON.parse(source);
-	        this.id = source["id"];
-	        this.qso_date = source["qso_date"];
-	        this.callsign = source["callsign"];
-	        this.band = source["band"];
-	        this.mode = source["mode"];
-	        this.country = source["country"];
-	        this.status = source["status"];
-	    }
-	}
 	export class WorkedBefore {
 	    callsign: string;
 	    count: number;

go.mod

@@ -6,6 +6,7 @@ require (
 	github.com/braheezy/shine-mp3 v0.1.0
 	github.com/go-ole/go-ole v1.3.0
 	github.com/go-sql-driver/mysql v1.10.0
+	github.com/gorilla/websocket v1.5.3
 	github.com/moutend/go-wca v0.3.0
 	github.com/wailsapp/wails/v2 v2.11.0
 	github.com/wneessen/go-mail v0.7.3
@@ -22,7 +23,6 @@ require (
 	github.com/dustin/go-humanize v1.0.1 // indirect
 	github.com/godbus/dbus/v5 v5.1.0 // indirect
 	github.com/google/uuid v1.6.0 // indirect
-	github.com/gorilla/websocket v1.5.3 // indirect
 	github.com/jchv/go-winloader v0.0.0-20210711035445-715c2860da7e // indirect
 	github.com/labstack/echo/v4 v4.13.3 // indirect
 	github.com/labstack/gommon v0.4.2 // indirect

internal/antgenius/antgenius.go

@@ -116,7 +116,11 @@ func (c *Client) Activate(port, antenna int) error {
 	if antenna < 0 {
 		return fmt.Errorf("antgenius: invalid antenna %d", antenna)
 	}
-	if err := c.send(fmt.Sprintf("port set %d rxant=%d txant=%d", port, antenna, antenna)); err != nil {
+	// Set only rxant (like the reference ShackMaster client): the AG mirrors it
+	// to the TX antenna automatically. Forcing txant too can be rejected on the
+	// 8x2 (an antenna can't be TX on both ports at once), which broke port-B
+	// selection and deselection.
+	if err := c.send(fmt.Sprintf("port set %d rxant=%d", port, antenna)); err != nil {
 		return err
 	}
 	// Ask for the new port state so the snapshot reflects it promptly (the

internal/applog/applog.go

@@ -11,14 +11,16 @@ import (
 	"log"
 	"os"
 	"path/filepath"
+	"runtime/debug"
 	"sync"
 	"time"
 )
 
 var (
-	mu     sync.Mutex
-	file   *os.File
-	path   string
+	mu        sync.Mutex
+	file      *os.File
+	path      string
+	crashFile *os.File // kept open so the runtime can write a crash traceback to it
 )
 
 // Init opens (creates) the log file in dataDir. On rotation we truncate
@@ -57,6 +59,17 @@ func Init(dataDir string) (string, error) {
 	file = f
 	path = logPath
 
+	// Capture a full traceback on a FATAL crash (a Go panic that escapes our
+	// recover()s, or a runtime-fatal error like a concurrent map write, or a
+	// Windows access violation routed through the Go signal handler) into a
+	// dedicated file the runtime writes directly — so otherwise-silent process
+	// deaths leave a stack we can read.
+	if cf, cerr := os.OpenFile(filepath.Join(dataDir, "opslog-crash.log"),
+		os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0o644); cerr == nil {
+		crashFile = cf
+		_ = debug.SetCrashOutput(cf, debug.CrashOptions{})
+	}
+
 	// Redirect log.Print* and the standard logger to the file too, so
 	// any third-party output stays consistent.
 	log.SetOutput(io.MultiWriter(file, os.Stderr))

internal/audio/mp3.go

@@ -32,6 +32,20 @@ func writeMP3(path string, pcm []byte) error {
 	for i, v := range mono32 {
 		stereo[2*i], stereo[2*i+1] = v, v
 	}
+	// Shine's Write() reads a WHOLE frame (samplesPerPass × channels = 1152 × 2 =
+	// 2304 interleaved samples for MPEG-1) per pass via unsafe pointer arithmetic,
+	// regardless of how short the trailing chunk is. If the buffer isn't an exact
+	// multiple of a frame, the final pass reads past the slice and the process
+	// dies with an access violation (0xc0000005) inside windowFilterSubband.
+	// Pad with trailing silence to a whole number of frames so no partial pass
+	// exists. (~36 ms of silence at most — inaudible.)
+	const frameInterleaved = 1152 * 2 // samplesPerPass(MPEG-1) × 2 channels
+	if rem := len(stereo) % frameInterleaved; rem != 0 {
+		stereo = append(stereo, make([]int16, frameInterleaved-rem)...)
+	}
+	if len(stereo) == 0 {
+		return nil // nothing to encode (empty recording)
+	}
 	enc := mp3.NewEncoder(mp3Rate, 2)
 	return enc.Write(f, stereo)
 }

internal/audio/recorder.go

@@ -239,6 +239,22 @@ func (r *Recorder) RestartQSO() {
 	r.active = true
 }
 
+// ResetQSOClock restarts the active accumulation from ZERO — discarding
+// everything captured so far INCLUDING the pre-roll. Unlike RestartQSO (which
+// re-seeds from the pre-roll ring), this keeps nothing: the saved file will
+// contain only audio from this moment onward. Used when the contact you entered
+// was already in a long QSO and you want to record just your own exchange.
+// No-op if not running; if no take is active it begins one (empty).
+func (r *Recorder) ResetQSOClock() {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	if !r.running {
+		return
+	}
+	r.acc = nil
+	r.active = true
+}
+
 // TakeQSO snapshots the accumulated recording as raw 16 kHz mono PCM bytes and
 // stops accumulating — fast, no encoding. The next BeginQSO can safely start a
 // new take immediately. Pair with WritePCM to encode/write off the hot path so

internal/cat/cat.go

@@ -39,18 +39,18 @@ type Backend interface {
 // and RxFreqHz is the active VFO (where they listen). When not split,
 // RxFreqHz is 0 — the UI shouldn't show a redundant RX field.
 type RigState struct {
-	Enabled   bool      `json:"enabled"`               // user toggled CAT on
-	Connected bool      `json:"connected"`             // backend says rig is online
-	Backend   string    `json:"backend,omitempty"`     // active backend name
-	RigNum    int       `json:"rig_num,omitempty"`     // OmniRig slot 1 or 2 (when applicable)
-	Rig       string    `json:"rig,omitempty"`         // rig model (best-effort)
-	FreqHz    int64     `json:"freq_hz,omitempty"`     // TX freq (= active VFO when not split)
-	RxFreqHz  int64     `json:"freq_rx_hz,omitempty"`  // RX freq, only set when Split
-	Split     bool      `json:"split,omitempty"`       // rig is in split mode
-	Mode      string    `json:"mode,omitempty"`        // ADIF mode (SSB/CW/DATA/AM/FM/RTTY)
-	Band      string    `json:"band,omitempty"`        // computed from FreqHz
-	Vfo       string    `json:"vfo,omitempty"`         // "A" | "B" | "AA" | "AB" | "BA" | "BB"
-	Error     string    `json:"error,omitempty"`       // last connect/poll error if any
+	Enabled   bool      `json:"enabled"`              // user toggled CAT on
+	Connected bool      `json:"connected"`            // backend says rig is online
+	Backend   string    `json:"backend,omitempty"`    // active backend name
+	RigNum    int       `json:"rig_num,omitempty"`    // OmniRig slot 1 or 2 (when applicable)
+	Rig       string    `json:"rig,omitempty"`        // rig model (best-effort)
+	FreqHz    int64     `json:"freq_hz,omitempty"`    // TX freq (= active VFO when not split)
+	RxFreqHz  int64     `json:"freq_rx_hz,omitempty"` // RX freq, only set when Split
+	Split     bool      `json:"split,omitempty"`      // rig is in split mode
+	Mode      string    `json:"mode,omitempty"`       // ADIF mode (SSB/CW/DATA/AM/FM/RTTY)
+	Band      string    `json:"band,omitempty"`       // computed from FreqHz
+	Vfo       string    `json:"vfo,omitempty"`        // "A" | "B" | "AA" | "AB" | "BA" | "BB"
+	Error     string    `json:"error,omitempty"`      // last connect/poll error if any
 	UpdatedAt time.Time `json:"updated_at,omitempty"`
 }
 
@@ -230,7 +230,7 @@ func (m *Manager) SendSpot(s SpotInfo) {
 // 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
+	Available    bool   `json:"available"` // backend is Flex and handshaked
 	Model        string `json:"model,omitempty"`
 	RFPower      int    `json:"rf_power"`
 	TunePower    int    `json:"tune_power"`
@@ -247,16 +247,24 @@ type FlexTXState struct {
 	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"`
+	RXAvail      bool     `json:"rx_avail"`             // an RX slice exists
+	Split        bool     `json:"split"`                // RX/TX on separate slices
+	RXFreqHz     int64    `json:"rx_freq_hz,omitempty"` // RX slice freq when split
+	TXFreqHz     int64    `json:"tx_freq_hz,omitempty"` // TX slice freq when split
+	AGCMode      string   `json:"agc_mode,omitempty"`
+	AGCThreshold int      `json:"agc_threshold"`
+	AudioLevel   int      `json:"audio_level"`
+	Mute         bool     `json:"mute"`
+	RXAnt        string   `json:"rx_ant,omitempty"`      // selected RX antenna
+	TXAnt        string   `json:"tx_ant,omitempty"`      // selected TX antenna
+	AntList      []string `json:"ant_list,omitempty"`    // antennas selectable for RX
+	TXAntList    []string `json:"tx_ant_list,omitempty"` // antennas selectable for TX
+	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"`
 	// CW / mode-specific controls.
 	Mode           string `json:"mode,omitempty"` // active slice mode (CW/USB/LSB/DIGU…)
 	CWSpeed        int    `json:"cw_speed"`
@@ -312,6 +320,10 @@ type FlexController interface {
 	SetAGCMode(string) error
 	SetAGCThreshold(int) error
 	SetAudioLevel(int) error
+	SetMute(bool) error
+	SetRXAntenna(string) error
+	SetTXAntenna(string) error
+	SetSplit(bool) error
 	SetNB(bool) error
 	SetNBLevel(int) error
 	SetNR(bool) error

internal/cat/flex.go

@@ -33,27 +33,28 @@ type Flex struct {
 	model     string
 	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)
-	boundClientID string // GUI client (SmartSDR) we bound to; "" until bound. Binding lets this non-GUI client receive GUI-tied data (CW pitch/speed, break-in delay, RF power).
+	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)
+	boundClientID string               // GUI client (SmartSDR) we bound to; "" until bound. Binding lets this non-GUI client receive GUI-tied data (CW pitch/speed, break-in delay, RF power).
 
 	// 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)
+	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
+	pendingSplit map[int]bool   // seq → awaiting the new TX slice's index (split create)
 	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
 
@@ -73,16 +74,21 @@ type flexSlice struct {
 	agcMode      string // off | slow | med | fast
 	agcThreshold int    // 0-100
 	audioLevel   int    // 0-100 (RX volume)
+	mute         bool   // RX audio muted
 	nb           bool   // noise blanker
 	nbLevel      int
-	nr           bool   // noise reduction
+	nr           bool // noise reduction
 	nrLevel      int
-	anf          bool   // auto notch filter
+	anf          bool // auto notch filter
 	anfLevel     int
-	apf          bool   // CW audio peaking filter
+	apf          bool // CW audio peaking filter
 	apfLevel     int
-	filterLo     int // slice filter low cut (Hz)
-	filterHi     int // slice filter high cut (Hz)
+	filterLo     int      // slice filter low cut (Hz)
+	filterHi     int      // slice filter high cut (Hz)
+	rxAnt        string   // selected RX antenna (e.g. ANT1, ANT2, RX_A)
+	txAnt        string   // selected TX antenna
+	antList      []string // antennas valid for this slice (RX side)
+	txAntList    []string // antennas valid for TX
 }
 
 // flexTX mirrors the radio's transmit/ATU/interlock objects (the SmartSDR-style
@@ -143,7 +149,7 @@ func NewFlex(host string, port int, spotsEnabled bool) *Flex {
 	return &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{},
+		spotIdx: map[int]bool{}, pendingSpot: map[int]string{}, spotCall: map[int]string{}, pendingSplit: map[int]bool{},
 		meterMeta: map[int]meterInfo{}, meterVal: map[int]float64{}, meterSub: map[int]bool{},
 		sentCmds: map[int]string{}, txSetAt: map[string]time.Time{},
 	}
@@ -183,8 +189,8 @@ func (f *Flex) Connect() error {
 	// 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("sub slice all") // slice/receiver: freq, mode, AGC, NB/NR/ANF, audio…
-	f.send("sub tx all")    // transmit: rfpower, tunepower, vox, processor, mon, mic
+	f.send("sub slice all")     // slice/receiver: freq, mode, AGC, NB/NR/ANF, audio…
+	f.send("sub tx all")        // transmit: rfpower, tunepower, vox, processor, mon, mic
 	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)
@@ -309,7 +315,18 @@ func (f *Flex) reader(conn net.Conn) {
 					f.spotIdx[idx] = true
 				}
 			}
+			// A successful "slice create" for split returns the new slice's index;
+			// make that slice the transmitter so RX/TX are on separate slices.
+			splitSeq := f.pendingSplit[seq]
+			if splitSeq {
+				delete(f.pendingSplit, seq)
+			}
 			f.mu.Unlock()
+			if splitSeq && ok && len(parts) >= 3 {
+				if idx, e := strconv.Atoi(strings.TrimSpace(parts[2])); e == nil {
+					f.send(fmt.Sprintf("slice s %d tx=1", idx))
+				}
+			}
 		}
 	}
 	// Connection ended.
@@ -670,6 +687,16 @@ func (f *Flex) handleStatus(payload string) {
 			s.agcThreshold = atoiDefault(val, s.agcThreshold)
 		case "audio_level":
 			s.audioLevel = atoiDefault(val, s.audioLevel)
+		case "audio_mute", "mute":
+			s.mute = val == "1"
+		case "rxant":
+			s.rxAnt = val
+		case "txant":
+			s.txAnt = val
+		case "ant_list":
+			s.antList = splitCSV(val)
+		case "tx_ant_list":
+			s.txAntList = splitCSV(val)
 		case "nb":
 			s.nb = val == "1"
 		case "nb_level":
@@ -957,6 +984,18 @@ func splitKV(kv string) (key, val string, ok bool) {
 }
 
 // atoiDefault parses an int (or a float like "20.0", truncated), else def.
+// splitCSV splits a comma-separated antenna list (e.g. "ANT1,ANT2,RX_A") into a
+// trimmed slice, dropping empties.
+func splitCSV(s string) []string {
+	out := []string{}
+	for _, p := range strings.Split(s, ",") {
+		if p = strings.TrimSpace(p); p != "" {
+			out = append(out, p)
+		}
+	}
+	return out
+}
+
 func atoiDefault(s string, def int) int {
 	s = strings.TrimSpace(s)
 	if n, err := strconv.Atoi(s); err == nil {
@@ -1023,12 +1062,18 @@ func (f *Flex) FlexState() FlexTXState {
 		CWSidetone:     f.tx.cwSidetone,
 		CWMonLevel:     f.tx.cwMonLevel,
 	}
+	if rx, tx := f.pickSlicesLocked(); rx != nil && tx != nil && rx != tx && rx.freqHz != tx.freqHz {
+		st.Split = true
+		st.RXFreqHz = rx.freqHz
+		st.TXFreqHz = tx.freqHz
+	}
 	if _, rx := f.rxSliceLocked(); rx != nil {
 		st.RXAvail = true
 		st.Mode = strings.ToUpper(rx.mode)
 		st.AGCMode = rx.agcMode
 		st.AGCThreshold = rx.agcThreshold
 		st.AudioLevel = rx.audioLevel
+		st.Mute = rx.mute
 		st.NB = rx.nb
 		st.NBLevel = rx.nbLevel
 		st.NR = rx.nr
@@ -1039,6 +1084,13 @@ func (f *Flex) FlexState() FlexTXState {
 		st.APFLevel = rx.apfLevel
 		st.FilterLo = rx.filterLo
 		st.FilterHi = rx.filterHi
+		st.RXAnt = rx.rxAnt
+		st.TXAnt = rx.txAnt
+		st.AntList = rx.antList
+		st.TXAntList = rx.txAntList
+		if len(st.TXAntList) == 0 {
+			st.TXAntList = rx.antList // many configs share one antenna list
+		}
 	}
 	if f.amp.handle != "" {
 		st.AmpAvailable = true
@@ -1076,6 +1128,8 @@ func (f *Flex) sendSlice(param string, val any) error {
 			rx.agcThreshold = toInt(val)
 		case "audio_level":
 			rx.audioLevel = toInt(val)
+		case "audio_mute", "mute":
+			rx.mute = fmt.Sprint(val) == "1"
 		case "nb":
 			rx.nb = val == "1"
 		case "nb_level":
@@ -1092,6 +1146,10 @@ func (f *Flex) sendSlice(param string, val any) error {
 			rx.apf = val == "1"
 		case "apf_level":
 			rx.apfLevel = toInt(val)
+		case "rxant":
+			rx.rxAnt = fmt.Sprint(val)
+		case "txant":
+			rx.txAnt = fmt.Sprint(val)
 		}
 	}
 	f.mu.Unlock()
@@ -1126,14 +1184,76 @@ func (f *Flex) SetAGCMode(m string) error {
 }
 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)) }
-func (f *Flex) SetAPF(on bool) error        { return f.sendSlice("apf", boolFlex(on)) }
-func (f *Flex) SetAPFLevel(l int) error     { return f.sendSlice("apf_level", clampLevel(l)) }
+func (f *Flex) SetMute(on bool) error       { return f.sendSlice("audio_mute", boolFlex(on)) }
+func (f *Flex) SetRXAntenna(a string) error { return f.sendSlice("rxant", a) }
+func (f *Flex) SetTXAntenna(a string) error { return f.sendSlice("txant", a) }
+
+// SetSplit toggles 2-slice split like SmartSDR's SPLIT button. ON creates a TX
+// slice at RX freq + offset (+1 kHz on CW, +5 kHz otherwise) and makes it the
+// transmitter; OFF removes the extra TX slice and returns to simplex (RX slice
+// transmits again).
+func (f *Flex) SetSplit(on bool) error {
+	f.mu.Lock()
+	if f.conn == nil {
+		f.mu.Unlock()
+		return fmt.Errorf("flex: not connected")
+	}
+	rx, tx := f.pickSlicesLocked()
+	rxIdx, txIdx := -1, -1
+	for i, s := range f.slices {
+		if s == rx {
+			rxIdx = i
+		}
+		if s == tx {
+			txIdx = i
+		}
+	}
+	alreadySplit := rx != nil && tx != nil && rx != tx
+	var rxFreq int64
+	var rxMode, rxAnt string
+	if rx != nil {
+		rxFreq, rxMode, rxAnt = rx.freqHz, rx.mode, rx.rxAnt
+	}
+	f.mu.Unlock()
+
+	if on {
+		if alreadySplit || rx == nil {
+			return nil // already split (or no slice)
+		}
+		offset := int64(5000)
+		if strings.HasPrefix(strings.ToUpper(rxMode), "CW") {
+			offset = 1000
+		}
+		cmd := fmt.Sprintf("slice create freq=%.6f mode=%s", float64(rxFreq+offset)/1e6, rxMode)
+		if rxAnt != "" {
+			cmd += " ant=" + rxAnt
+		}
+		if seq := f.send(cmd); seq > 0 {
+			f.mu.Lock()
+			f.pendingSplit[seq] = true // mark the new slice TX once its index returns
+			f.mu.Unlock()
+		}
+		return nil
+	}
+	if !alreadySplit {
+		return nil
+	}
+	if txIdx >= 0 {
+		f.send(fmt.Sprintf("slice remove %d", txIdx))
+	}
+	if rxIdx >= 0 {
+		f.send(fmt.Sprintf("slice s %d tx=1", rxIdx))
+	}
+	return nil
+}
+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)) }
+func (f *Flex) SetAPF(on bool) error    { return f.sendSlice("apf", boolFlex(on)) }
+func (f *Flex) SetAPFLevel(l int) error { return f.sendSlice("apf_level", clampLevel(l)) }
 
 // ── CW keyer controls (top-level "cw" commands) ──
 

internal/cat/tci.go

@@ -0,0 +1,321 @@
+//go:build windows
+
+package cat
+
+import (
+	"fmt"
+	"net"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/gorilla/websocket"
+)
+
+// TCI is a native backend for Expert Electronics' TCI protocol (SunSDR2/MB1/
+// ColibriNANO via ExpertSDR2/EESDR, and TCI-compatible apps). TCI is a text
+// protocol over a WebSocket: the server streams state ("vfo:0,0,14100000;",
+// "modulation:0,cw;", "trx:0,true;") and accepts the same commands to control
+// the rig. We keep the pushed state cached so ReadState is instant, like Flex.
+//
+// Pure Go (gorilla/websocket, no CGO). Default port 40001.
+type TCI struct {
+	host string
+	port int
+
+	digitalDefault string // surfaced when the rig reports a digital mode (FT8/…)
+	spotsEnabled   bool   // mirror cluster spots onto the TCI panorama
+
+	mu    sync.Mutex // guards conn + writes + state
+	conn  *websocket.Conn
+	ready bool
+
+	// Cached state pushed by the radio.
+	device string
+	freqA  int64 // VFO A (RX) frequency, Hz  (vfo:0,0)
+	freqB  int64 // VFO B (TX in split), Hz    (vfo:0,1)
+	mode   string
+	split  bool
+	tx     bool
+
+	lastSig string // last logged state signature (log only on change)
+}
+
+const tciDefaultPort = 40001
+
+// NewTCI builds a TCI backend for the given host/port. digitalDefault is the
+// mode surfaced when the radio reports a generic digital modulation; spots turns
+// on mirroring OpsLog's cluster spots onto the TCI panorama.
+func NewTCI(host string, port int, digitalDefault string, spots bool) *TCI {
+	if port <= 0 || port > 65535 {
+		port = tciDefaultPort
+	}
+	return &TCI{host: strings.TrimSpace(host), port: port, digitalDefault: strings.TrimSpace(digitalDefault), spotsEnabled: spots}
+}
+
+func (t *TCI) Name() string { return "tci" }
+
+// Connect opens the WebSocket and starts the reader goroutine. The reader keeps
+// our cached state current from the radio's push messages.
+func (t *TCI) Connect() error {
+	t.mu.Lock()
+	already := t.conn != nil
+	host, port := t.host, t.port
+	t.mu.Unlock()
+	if already {
+		return nil
+	}
+	if host == "" {
+		return fmt.Errorf("tci: no host configured")
+	}
+	url := fmt.Sprintf("ws://%s", net.JoinHostPort(host, strconv.Itoa(port)))
+	dialer := websocket.Dialer{HandshakeTimeout: 5 * time.Second}
+	conn, _, err := dialer.Dial(url, nil)
+	if err != nil {
+		return fmt.Errorf("tci: connect %s: %w", url, err)
+	}
+	t.mu.Lock()
+	t.conn = conn
+	t.ready = false
+	t.mu.Unlock()
+	debugLog.Printf("TCI: connected to %s", url)
+	go t.reader(conn)
+	if t.spotsEnabled {
+		_ = t.send("spot_clear;") // drop any leftover spots from a previous session
+	}
+	return nil
+}
+
+// SendSpot mirrors a cluster spot onto the TCI panorama (implements Spotter).
+// The radio replaces a spot that has the same callsign, so re-spotting updates
+// it in place. No-op when spot mirroring is disabled.
+func (t *TCI) SendSpot(s SpotInfo) error {
+	if !t.spotsEnabled {
+		return nil
+	}
+	call := strings.TrimSpace(s.Callsign)
+	if call == "" || s.FreqHz <= 0 {
+		return nil
+	}
+	color := strings.TrimSpace(s.Color)
+	if color == "" {
+		color = "#FFFFA500" // opaque orange default
+	}
+	color = "0x" + strings.TrimPrefix(color, "#")
+	mode := strings.ToLower(strings.TrimSpace(s.Mode))
+	// Commas/semicolons would break TCI's comma-separated argument parsing.
+	text := strings.NewReplacer(",", " ", ";", " ").Replace(s.Comment)
+	return t.send(fmt.Sprintf("spot:%s,%s,%d,%s,%s;", call, mode, s.FreqHz, color, text))
+}
+
+// Disconnect closes the WebSocket; the reader goroutine then exits.
+func (t *TCI) Disconnect() {
+	t.mu.Lock()
+	c := t.conn
+	t.conn = nil
+	t.ready = false
+	t.mu.Unlock()
+	if c != nil {
+		_ = c.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
+		_ = c.Close()
+	}
+}
+
+// ReadState returns the cached state pushed by the radio.
+func (t *TCI) ReadState() (RigState, error) {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	if t.conn == nil {
+		return RigState{}, fmt.Errorf("tci: not connected")
+	}
+	st := RigState{Connected: t.ready, Rig: t.device}
+	if !t.ready {
+		return st, nil
+	}
+	// ADIF convention: FreqHz is the TX freq. In split, TX is VFO B.
+	if t.split && t.freqB > 0 {
+		st.FreqHz = t.freqB
+		st.RxFreqHz = t.freqA
+		st.Split = true
+	} else {
+		st.FreqHz = t.freqA
+	}
+	st.Mode = tciModeToADIF(t.mode, t.digitalDefault)
+	if st.FreqHz > 0 {
+		st.Band = BandFromHz(st.FreqHz)
+	}
+	sig := fmt.Sprintf("%d/%d/%v/%s", st.FreqHz, st.RxFreqHz, st.Split, st.Mode)
+	if sig != t.lastSig {
+		t.lastSig = sig
+		debugLog.Printf("TCI: state tx=%d rx=%d split=%v mode=%s", st.FreqHz, st.RxFreqHz, st.Split, st.Mode)
+	}
+	return st, nil
+}
+
+// SetFrequency tunes VFO A (the main/RX VFO).
+func (t *TCI) SetFrequency(hz int64) error {
+	return t.send(fmt.Sprintf("vfo:0,0,%d;", hz))
+}
+
+// SetMode maps an ADIF mode to a TCI modulation and sets it. USB vs LSB is
+// chosen from the current VFO-A frequency (< 10 MHz → LSB).
+func (t *TCI) SetMode(mode string) error {
+	t.mu.Lock()
+	freq := t.freqA
+	t.mu.Unlock()
+	m := adifToTCIMode(mode, freq)
+	if m == "" {
+		return nil
+	}
+	return t.send(fmt.Sprintf("modulation:0,%s;", m))
+}
+
+// SetPTT keys or unkeys the transmitter (VFO 0).
+func (t *TCI) SetPTT(on bool) error {
+	return t.send(fmt.Sprintf("trx:0,%t;", on))
+}
+
+// send writes a command to the WebSocket (one writer at a time).
+func (t *TCI) send(cmd string) error {
+	t.mu.Lock()
+	c := t.conn
+	t.mu.Unlock()
+	if c == nil {
+		return fmt.Errorf("tci: not connected")
+	}
+	_ = c.SetWriteDeadline(time.Now().Add(3 * time.Second))
+	if err := c.WriteMessage(websocket.TextMessage, []byte(cmd)); err != nil {
+		debugLog.Printf("TCI: send %q failed: %v", cmd, err)
+		return err
+	}
+	debugLog.Printf("TCI: → %s", cmd)
+	return nil
+}
+
+// reader drains push messages and keeps the cached state current until the
+// connection closes.
+func (t *TCI) reader(conn *websocket.Conn) {
+	for {
+		_, data, err := conn.ReadMessage()
+		if err != nil {
+			break
+		}
+		// A frame may carry several ";"-terminated commands.
+		for _, cmd := range strings.Split(string(data), ";") {
+			t.handle(strings.TrimSpace(cmd))
+		}
+	}
+	t.mu.Lock()
+	if t.conn == conn {
+		t.conn = nil
+		t.ready = false
+	}
+	t.mu.Unlock()
+	debugLog.Printf("TCI: reader ended")
+}
+
+// handle parses one "command:args" message and updates the cache.
+func (t *TCI) handle(msg string) {
+	if msg == "" {
+		return
+	}
+	name, args := msg, ""
+	if i := strings.IndexByte(msg, ':'); i >= 0 {
+		name, args = msg[:i], msg[i+1:]
+	}
+	f := strings.Split(args, ",")
+	get := func(i int) string {
+		if i < len(f) {
+			return strings.TrimSpace(f[i])
+		}
+		return ""
+	}
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	switch strings.ToLower(name) {
+	case "device":
+		t.device = strings.TrimSpace(args)
+	case "ready", "start":
+		t.ready = true
+	case "stop":
+		t.ready = false
+	case "vfo":
+		// vfo:<rx>,<channel>,<freq>
+		if get(0) == "0" {
+			hz, _ := strconv.ParseInt(get(2), 10, 64)
+			if hz > 0 {
+				t.ready = true // receiving live state → treat as ready even without an explicit "ready;"
+				switch get(1) {
+				case "0":
+					t.freqA = hz
+				case "1":
+					t.freqB = hz
+				}
+			}
+		}
+	case "modulation":
+		if get(0) == "0" {
+			t.mode = strings.ToLower(get(1))
+		}
+	case "split_enable":
+		if get(0) == "0" {
+			t.split = get(1) == "true"
+		}
+	case "trx":
+		if get(0) == "0" {
+			t.tx = get(1) == "true"
+		}
+	}
+}
+
+// tciModeToADIF converts a TCI modulation to an ADIF mode. Generic digital
+// modulations surface the operator's chosen digital default (FT8/FT4/RTTY…).
+func tciModeToADIF(m, digitalDefault string) string {
+	switch strings.ToLower(strings.TrimSpace(m)) {
+	case "usb", "lsb", "dsb":
+		return "SSB"
+	case "cw":
+		return "CW"
+	case "am", "sam":
+		return "AM"
+	case "nfm", "wfm", "fm":
+		return "FM"
+	case "digu", "digl":
+		if digitalDefault != "" {
+			return strings.ToUpper(digitalDefault)
+		}
+		return "DATA"
+	case "drm":
+		return "DIGITALVOICE"
+	case "":
+		return ""
+	default:
+		return strings.ToUpper(m)
+	}
+}
+
+// adifToTCIMode maps an ADIF mode to a TCI modulation. USB/LSB is chosen from
+// the frequency (< 10 MHz → LSB) as usual. Digital modes → digu.
+func adifToTCIMode(mode string, freqHz int64) string {
+	switch strings.ToUpper(strings.TrimSpace(mode)) {
+	case "SSB", "USB", "LSB":
+		if freqHz > 0 && freqHz < 10_000_000 {
+			return "lsb"
+		}
+		return "usb"
+	case "CW", "CWR", "CW-R":
+		return "cw"
+	case "AM":
+		return "am"
+	case "FM", "NFM":
+		return "nfm"
+	case "RTTY":
+		return "digl"
+	case "":
+		return ""
+	default:
+		// FT8/FT4/PSK/DATA/JT… → upper-sideband digital.
+		return "digu"
+	}
+}

internal/extsvc/qrz.go

@@ -16,6 +16,10 @@ import (
 // subscription used elsewhere for callsign data — they're different keys.
 const qrzAPIURL = "https://logbook.qrz.com/api"
 
+// LogSink receives diagnostics such as raw QRZ responses. Set to applog.Printf
+// at startup; defaults to a no-op so the package is usable without wiring.
+var LogSink = func(string, ...any) {}
+
 // UploadQRZ pushes one ADIF record to the QRZ.com logbook identified by
 // apiKey. It returns OK when the QSO is inserted or already present
 // (QRZ reports a duplicate as a FAIL with a "duplicate" reason, which we
@@ -67,6 +71,7 @@ func UploadQRZ(ctx context.Context, client *http.Client, apiKey, adifRecord stri
 	if resp.StatusCode != http.StatusOK {
 		return UploadResult{}, fmt.Errorf("qrz: http %d: %s", resp.StatusCode, strings.TrimSpace(string(body)))
 	}
+	LogSink("qrz: INSERT raw response: %s", strings.TrimSpace(string(body)))
 
 	return parseQRZResponse(string(body))
 }
@@ -171,6 +176,7 @@ func TestQRZ(ctx context.Context, client *http.Client, apiKey string) (string, e
 	}
 	defer resp.Body.Close()
 	body, _ := io.ReadAll(io.LimitReader(resp.Body, 64*1024))
+	LogSink("qrz: STATUS raw response: %s", strings.TrimSpace(string(body)))
 	vals, err := url.ParseQuery(strings.TrimSpace(string(body)))
 	if err != nil {
 		return "", fmt.Errorf("qrz: bad response: %w", err)

internal/netctl/netctl.go

@@ -0,0 +1,234 @@
+// Package netctl persists "NET" definitions and their station rosters for the
+// NET Control feature (managing a directed net / round-table on a frequency).
+//
+// A NET is a named net (e.g. "French QSO", "QSO des Brasses") with a roster of
+// stations that habitually check in. The roster grows over time as you add new
+// callsigns. Storage is a single JSON file in the data dir — global/shared
+// across all logbooks (a net like "French QSO" is reused whatever logbook is
+// open). The QSOs themselves are logged into the active logbook by the caller;
+// this package only owns the net definitions + rosters, not the live session.
+package netctl
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+)
+
+// Station is one roster entry: a station registered in a net.
+type Station struct {
+	Callsign string `json:"callsign"`
+	Name     string `json:"name,omitempty"`
+	QTH      string `json:"qth,omitempty"`
+	Country  string `json:"country,omitempty"`
+	DXCC     int    `json:"dxcc,omitempty"`
+	ITU      int    `json:"itu,omitempty"`
+	CQ       int    `json:"cq,omitempty"`
+	Groups   string `json:"groups,omitempty"`
+	SIG      string `json:"sig,omitempty"`
+	SIGInfo  string `json:"sig_info,omitempty"`
+}
+
+// Net is a named net with default report values and a station roster.
+type Net struct {
+	ID             string    `json:"id"`
+	Name           string    `json:"name"`
+	DefaultRSTSent string    `json:"default_rst_sent,omitempty"`
+	DefaultRSTRcvd string    `json:"default_rst_rcvd,omitempty"`
+	DefaultComment string    `json:"default_comment,omitempty"`
+	Stations       []Station `json:"stations,omitempty"`
+}
+
+// Store is the persistent collection of nets, backed by a JSON file.
+type Store struct {
+	mu   sync.Mutex
+	path string
+	nets []Net
+}
+
+// Open loads the store from path (creating an empty one if the file is absent).
+func Open(path string) (*Store, error) {
+	s := &Store{path: path}
+	b, err := os.ReadFile(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return s, nil
+		}
+		return nil, err
+	}
+	if len(b) > 0 {
+		if err := json.Unmarshal(b, &s.nets); err != nil {
+			// Corrupt file: start empty rather than failing the whole app.
+			s.nets = nil
+		}
+	}
+	return s, nil
+}
+
+// save writes the current state to disk. Caller must hold s.mu.
+func (s *Store) save() error {
+	b, err := json.MarshalIndent(s.nets, "", "  ")
+	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)
+}
+
+func newID() string { return strconv.FormatInt(time.Now().UnixNano(), 36) }
+
+// List returns a copy of all nets (with rosters), ordered by name.
+func (s *Store) List() []Net {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	out := make([]Net, len(s.nets))
+	copy(out, s.nets)
+	sort.Slice(out, func(i, j int) bool {
+		return strings.ToLower(out[i].Name) < strings.ToLower(out[j].Name)
+	})
+	return out
+}
+
+// find returns the index of the net with id, or -1. Caller must hold s.mu.
+func (s *Store) find(id string) int {
+	for i := range s.nets {
+		if s.nets[i].ID == id {
+			return i
+		}
+	}
+	return -1
+}
+
+// Create adds a new net with default reports of 59/59 and returns it.
+func (s *Store) Create(name string) (Net, error) {
+	name = strings.TrimSpace(name)
+	if name == "" {
+		return Net{}, fmt.Errorf("net name required")
+	}
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	for i := range s.nets {
+		if strings.EqualFold(s.nets[i].Name, name) {
+			return Net{}, fmt.Errorf("a net named %q already exists", name)
+		}
+	}
+	n := Net{ID: newID(), Name: name, DefaultRSTSent: "59", DefaultRSTRcvd: "59"}
+	s.nets = append(s.nets, n)
+	return n, s.save()
+}
+
+// Rename changes a net's name.
+func (s *Store) Rename(id, name string) error {
+	name = strings.TrimSpace(name)
+	if name == "" {
+		return fmt.Errorf("net name required")
+	}
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	i := s.find(id)
+	if i < 0 {
+		return fmt.Errorf("net not found")
+	}
+	s.nets[i].Name = name
+	return s.save()
+}
+
+// SetDefaults updates the per-net default report/comment values.
+func (s *Store) SetDefaults(id, rstSent, rstRcvd, comment string) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	i := s.find(id)
+	if i < 0 {
+		return fmt.Errorf("net not found")
+	}
+	s.nets[i].DefaultRSTSent = rstSent
+	s.nets[i].DefaultRSTRcvd = rstRcvd
+	s.nets[i].DefaultComment = comment
+	return s.save()
+}
+
+// Delete removes a net and its roster.
+func (s *Store) Delete(id string) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	i := s.find(id)
+	if i < 0 {
+		return fmt.Errorf("net not found")
+	}
+	s.nets = append(s.nets[:i], s.nets[i+1:]...)
+	return s.save()
+}
+
+// Get returns a copy of one net by id.
+func (s *Store) Get(id string) (Net, bool) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	i := s.find(id)
+	if i < 0 {
+		return Net{}, false
+	}
+	return s.nets[i], true
+}
+
+// Roster returns a net's stations, sorted by callsign.
+func (s *Store) Roster(id string) ([]Station, error) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	i := s.find(id)
+	if i < 0 {
+		return nil, fmt.Errorf("net not found")
+	}
+	out := make([]Station, len(s.nets[i].Stations))
+	copy(out, s.nets[i].Stations)
+	sort.Slice(out, func(a, b int) bool { return out[a].Callsign < out[b].Callsign })
+	return out, nil
+}
+
+// RosterUpsert adds st to the net's roster, or updates it if the callsign is
+// already present (matched case-insensitively; the callsign is stored upper).
+func (s *Store) RosterUpsert(id string, st Station) error {
+	st.Callsign = strings.ToUpper(strings.TrimSpace(st.Callsign))
+	if st.Callsign == "" {
+		return fmt.Errorf("callsign required")
+	}
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	i := s.find(id)
+	if i < 0 {
+		return fmt.Errorf("net not found")
+	}
+	for j := range s.nets[i].Stations {
+		if strings.EqualFold(s.nets[i].Stations[j].Callsign, st.Callsign) {
+			s.nets[i].Stations[j] = st
+			return s.save()
+		}
+	}
+	s.nets[i].Stations = append(s.nets[i].Stations, st)
+	return s.save()
+}
+
+// RosterRemove deletes a callsign from a net's roster.
+func (s *Store) RosterRemove(id, callsign string) error {
+	callsign = strings.ToUpper(strings.TrimSpace(callsign))
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	i := s.find(id)
+	if i < 0 {
+		return fmt.Errorf("net not found")
+	}
+	for j := range s.nets[i].Stations {
+		if strings.EqualFold(s.nets[i].Stations[j].Callsign, callsign) {
+			s.nets[i].Stations = append(s.nets[i].Stations[:j], s.nets[i].Stations[j+1:]...)
+			return s.save()
+		}
+	}
+	return nil // not present → nothing to do
+}

internal/powergenius/powergenius.go

@@ -45,6 +45,10 @@ type Client struct {
 
 	statusMu sync.RWMutex
 	status   Status
+	// Optimistic fan mode kept until the amp's status poll confirms it (or it
+	// ages out) — otherwise a stale poll right after a change reverts the UI.
+	fanPending   string
+	fanPendingAt time.Time
 
 	cmdID   atomic.Int64
 	stop    chan struct{}
@@ -102,7 +106,10 @@ func (c *Client) SetFanMode(mode string) error {
 	if _, err := c.command("setup fanmode=" + m); err != nil {
 		return err
 	}
-	c.setStatus(func(s *Status) { s.FanMode = m }) // optimistic
+	c.statusMu.Lock()
+	c.status.FanMode = m // optimistic
+	c.fanPending, c.fanPendingAt = m, time.Now()
+	c.statusMu.Unlock()
 	return nil
 }
 
@@ -217,7 +224,13 @@ func (c *Client) parse(resp string) {
 		case "state":
 			c.status.State = kv[1]
 		case "fanmode":
-			c.status.FanMode = strings.ToUpper(kv[1])
+			dev := strings.ToUpper(kv[1])
+			// Honour a recent optimistic change until the amp confirms it.
+			if c.fanPending != "" && time.Since(c.fanPendingAt) < 3*time.Second && dev != c.fanPending {
+				break
+			}
+			c.fanPending = ""
+			c.status.FanMode = dev
 		case "temp":
 			c.status.Temperature, _ = strconv.ParseFloat(kv[1], 64)
 		}

internal/qso/qso.go

@@ -497,6 +497,31 @@ var uploadStatusCols = map[string]bool{
 
 // ListForUpload returns QSOs whose per-service sent-status column equals
 // value ("" matches blank/NULL). Used by the QSL Manager's "Select required".
+// ListForUploadFull is like ListForUpload but returns FULL QSO rows so the UI
+// can show the same rich, column-pickable table as Recent QSOs. column is an
+// upload-status column (validated); value is the status to match ("" = not yet
+// uploaded).
+func (r *Repo) ListForUploadFull(ctx context.Context, column, value string) ([]QSO, error) {
+	if !uploadStatusCols[column] {
+		return nil, fmt.Errorf("invalid upload column %q", column)
+	}
+	rows, err := r.db.QueryContext(ctx,
+		`SELECT `+selectCols+` FROM qso WHERE COALESCE(`+column+`,'') = ? ORDER BY qso_date DESC, id DESC`, value)
+	if err != nil {
+		return nil, fmt.Errorf("list for upload: %w", err)
+	}
+	defer rows.Close()
+	out := make([]QSO, 0, 64)
+	for rows.Next() {
+		q, err := scanQSO(rows)
+		if err != nil {
+			return nil, err
+		}
+		out = append(out, q)
+	}
+	return out, rows.Err()
+}
+
 func (r *Repo) ListForUpload(ctx context.Context, column, value string) ([]UploadRow, error) {
 	if !uploadStatusCols[column] {
 		return nil, fmt.Errorf("invalid upload column %q", column)
@@ -1621,8 +1646,9 @@ func scanAwardQSO(s scanner) (QSO, error) {
 // NEW / NEW SLOT / WORKED in constant time after one batched query.
 type EntitySlot struct {
 	Country string
-	Bands   map[string]struct{}                // bands worked, any mode
-	Slots   map[string]map[string]struct{}     // band → modes worked
+	Bands   map[string]struct{}            // bands worked, any mode
+	Modes   map[string]struct{}            // modes worked, any band
+	Slots   map[string]map[string]struct{} // band → modes worked
 }
 
 // EntitySlotMap returns slot data for every QSO, grouped by DXCC entity NUMBER.
@@ -1667,11 +1693,13 @@ func (r *Repo) EntitySlotMap(ctx context.Context, keyFor func(call string, store
 			e = &EntitySlot{
 				Country: country,
 				Bands:   make(map[string]struct{}),
+				Modes:   make(map[string]struct{}),
 				Slots:   make(map[string]map[string]struct{}),
 			}
 			out[key] = e
 		}
 		e.Bands[band] = struct{}{}
+		e.Modes[mode] = struct{}{}
 		bandSlots, ok := e.Slots[band]
 		if !ok {
 			bandSlots = make(map[string]struct{})

internal/ultrabeam/ultrabeam.go

@@ -68,6 +68,13 @@ type Client struct {
 	running    bool
 	seqNum     byte
 	seqMu      sync.Mutex
+
+	// Optimistic pattern direction kept until the antenna's status poll reports
+	// it (or it ages out) — the motors take a second or two, and a stale poll in
+	// between would otherwise snap the UI back to the old direction.
+	pendingDir    int
+	pendingDirAt  time.Time
+	pendingDirSet bool
 }
 
 type Status struct {
@@ -199,6 +206,14 @@ func (c *Client) pollLoop() {
 			}
 
 			c.statusMu.Lock()
+			// Keep a just-commanded direction until the antenna reports it.
+			if c.pendingDirSet {
+				if time.Since(c.pendingDirAt) > 4*time.Second || status.Direction == c.pendingDir {
+					c.pendingDirSet = false
+				} else {
+					status.Direction = c.pendingDir
+				}
+			}
 			c.lastStatus = status
 			c.statusMu.Unlock()
 
@@ -449,6 +464,14 @@ func (c *Client) SetFrequency(freqKhz int, direction int) error {
 	}
 
 	_, err := c.sendCommand(CMD_FREQ, data)
+	if err == nil {
+		c.statusMu.Lock()
+		c.pendingDir, c.pendingDirAt, c.pendingDirSet = direction, time.Now(), true
+		if c.lastStatus != nil {
+			c.lastStatus.Direction = direction // reflect immediately
+		}
+		c.statusMu.Unlock()
+	}
 	return err
 }
 

telemetry.go

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