chore: release v0.22.0

The byte trace from a real WK2 settled in one line what no amount of reading
could: "TX 11 32". Command 0x11 is SET KEY COMPENSATION in milliseconds, not the
dit/dah ratio — that is 0x17. So a neutral ratio of 50 asked for 50 ms of extra
key-down on EVERY element. At 25 wpm a dit is 48 ms, so elements more than
doubled and ran into each other: the reported "it sends one element, then a long
pause".

The ratio now goes out as 0x17, and the compensation is explicitly set to 0 —
merely stopping the wrong command would leave an affected keyer misbehaving,
since it keeps the value in EEPROM until something writes over it.

The init sequence is now built by a separate function so the BYTES are testable,
and a test pins each command number. These numbers are the contract with the
hardware, and a wrong one produces a fault that cannot be diagnosed from the UI
at all — this one cost the operator weeks and needed a trace to find.

This is why the fix waited for the trace rather than being guessed: the plausible
guesses (mode register, sidetone, WK1-vs-WK2 differences) were all wrong, and any
of them shipped blind would have broken the keyers that work today.

app.go

@@ -51,6 +51,7 @@ import (
 	"hamlog/internal/qslcard"
 	"hamlog/internal/qso"
 	"hamlog/internal/relaydev"
+	"hamlog/internal/rigctld"
 	"hamlog/internal/rotator/gs232"
 	"hamlog/internal/rotator/pst"
 	"hamlog/internal/rotgenius"
@@ -108,6 +109,13 @@ const (
 	keyCATPollMs          = "cat.poll_ms"
 	keyCATDelayMs         = "cat.delay_ms"        // pause between commands
 	keyCATDigitalDefault  = "cat.digital_default" // mode to use when CAT reports DATA
+	keyCATShareEnabled    = "cat.share.enabled"   // expose CAT to other programs (Hamlib NET rigctl)
+	keyCATSharePort       = "cat.share.port"      // TCP port for that server (rigctld default 4532)
+	keyCATXieguPort       = "cat.xiegu.port"      // Xiegu CI-V serial port (G90/X6100…)
+	keyCATXieguBaud       = "cat.xiegu.baud"      // Xiegu CI-V baud (G90 default 19200)
+	keyCATXieguAddr       = "cat.xiegu.addr"      // Xiegu CI-V address (factory 0x70)
+	keyCATYaesuPort       = "cat.yaesu.port"      // Yaesu CAT serial port (e.g. COM4)
+	keyCATYaesuBaud       = "cat.yaesu.baud"      // Yaesu CAT baud (FTDX10/101 default 38400)
 	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)
@@ -129,6 +137,7 @@ const (
 	keyAudioQSORecord    = "audio.qso_record"      // "1" → auto-record every QSO
 	keyAudioQSODir       = "audio.qso_dir"         // folder for QSO recordings
 	keyAudioPreroll      = "audio.preroll_seconds" // rolling-buffer pre-roll length
+	keyAudioTXGain       = "audio.tx_gain"         // voice-keyer playback level % (100 = as recorded)
 	keyAudioPTTMethod    = "audio.ptt_method"      // "none" (VOX) | "rts" | "dtr"
 	keyAudioPTTPort      = "audio.ptt_port"        // COM port for serial PTT
 	keyAudioFormat       = "audio.qso_format"      // "wav" | "mp3"
@@ -342,6 +351,11 @@ type CATSettings struct {
 	FlexSpots       bool   `json:"flex_spots"`        // push cluster spots to the panadapter
 	FlexDecodeSpots bool   `json:"flex_decode_spots"` // push WSJT-X decodes (heard stations) to the panadapter
 	FlexDecodeSecs  int    `json:"flex_decode_secs"`  // decode spot display duration (s) before removal (default 120)
+	XieguPort       string `json:"xiegu_port"`        // Xiegu CI-V serial port (G90/X6100…)
+	XieguBaud       int    `json:"xiegu_baud"`        // Xiegu CI-V baud (G90 default 19200)
+	XieguAddr       int    `json:"xiegu_addr"`        // Xiegu CI-V address (factory 0x70)
+	YaesuPort       string `json:"yaesu_port"`        // Yaesu CAT serial port (e.g. COM4)
+	YaesuBaud       int    `json:"yaesu_baud"`        // Yaesu CAT baud (FTDX10/101 default 38400)
 	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)
@@ -355,6 +369,8 @@ type CATSettings struct {
 	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/…)
+	ShareEnabled    bool   `json:"share_enabled"`     // serve CAT to other programs (Hamlib NET rigctl)
+	SharePort       int    `json:"share_port"`        // TCP port for it (default 4532)
 }
 
 // ModePreset is a mode entry with default RST values to auto-populate
@@ -470,6 +486,11 @@ type App struct {
 	lookup   *lookup.Manager
 	cache    *lookup.Cache
 	cat      *cat.Manager
+	// catShare serves OpsLog's CAT link to other programs over the Hamlib NET
+	// rigctl protocol. It exists because a native backend OWNS the rig's serial
+	// port: without it, choosing native CAT locks WSJT-X and friends out of the
+	// radio entirely. nil when the operator has not enabled sharing.
+	catShare *rigctld.Server
 	dxcc     *dxcc.Manager
 	cluster  *cluster.Manager
 	// Cluster spots/lines are processed OFF the socket-read goroutine. Enriching a
@@ -1427,6 +1448,12 @@ func (a *App) shutdown(ctx context.Context) {
 	// backend: without this the rig never gets a disconnect and holds its single
 	// control session for minutes, refusing every new login (even from the Icom
 	// Remote Utility) until it times out on its own.
+	if a.catShare != nil {
+		// Before the CAT stop, so no client is mid-command against a backend that
+		// is disconnecting — and so the port is free for the next launch.
+		a.catShare.Stop()
+		a.catShare = nil
+	}
 	if a.cat != nil {
 		a.cat.Stop()
 	}
@@ -5648,6 +5675,7 @@ var bulkFieldColumns = map[string]string{
 	"sat_name":  "sat_name",
 	"sat_mode":  "sat_mode",
 	// Contacted station location + activation refs / SIG
+	"grid":     "grid",
 	"state":    "state",
 	"cnty":     "cnty",
 	"pota_ref": "pota_ref",
@@ -6370,9 +6398,75 @@ func (a *App) lookupCallsign(callsign string, force bool) (lookup.Result, error)
 			}
 		}
 	}
+	a.enrichFromULS(&r, callsign)
 	return r, err
 }
 
+// enrichFromULS fills a US station's state, county and grid from the offline FCC
+// database while the operator is still typing.
+//
+// The ULS data was only ever applied at SAVE time (applyULSCounty), so an
+// operator with the database downloaded and no QRZ.com/HamQTH account saw
+// nothing but cty.dat during entry — country, zones, and a 4-character grid that
+// is the ENTITY centroid, thousands of km off. The county and a 6-character grid
+// were stamped silently after logging, too late to steer an antenna by.
+//
+// It runs LAST and only fills blanks, so an online provider always wins: ULS
+// holds no name and no address, so it can complete a QRZ record but never
+// replace one. The grid goes through refineGrid, which accepts the ULS square
+// only when it EXTENDS what is already there (JN → JN05JG) and never when it
+// would contradict it.
+func (a *App) enrichFromULS(r *lookup.Result, callsign string) {
+	if a.uls == nil {
+		return
+	}
+	switch r.DXCC {
+	case 291, 110, 6: // United States, Hawaii, Alaska
+	default:
+		return
+	}
+	call := strings.ToUpper(strings.TrimSpace(callsign))
+	if r.Callsign != "" {
+		call = strings.ToUpper(strings.TrimSpace(r.Callsign))
+	}
+	if call == "" || strings.Contains(call, "/") {
+		// A portable call is not what the FCC licensed — W1AW/4 is not a row.
+		return
+	}
+	loc, ok := a.uls.Resolve(call)
+	if !ok {
+		return
+	}
+	if strings.TrimSpace(r.State) == "" {
+		r.State = loc.State
+	}
+	if strings.TrimSpace(r.County) == "" {
+		r.County = loc.CNTY()
+	}
+	// Grid. refineGrid keeps the ULS square when it extends what is there. It
+	// does NOT cover the case this feature exists for: cty.dat's 4-character
+	// square is the ENTITY centroid, so for a US call it is usually a different
+	// square altogether — refineGrid would keep it, and the operator would go on
+	// pointing an antenna at the middle of the country. A per-callsign ULS square
+	// beats any 4-character one, whatever its letters; a 6-character grid already
+	// present (QRZ) is left alone.
+	newGrid := ""
+	if g := refineGrid(r.Grid, loc.Grid); g != "" && g != r.Grid {
+		newGrid = g
+	} else if len(strings.TrimSpace(r.Grid)) <= 4 && len(strings.TrimSpace(loc.Grid)) >= 6 {
+		newGrid = loc.Grid
+	}
+	if newGrid != "" {
+		r.Grid = newGrid
+		// Lat/lon follow, or distance and azimuth would still be computed from the
+		// centroid the grid no longer says. Only when WE changed the grid: a
+		// provider's own coordinates are more precise than a square's centre.
+		if lat, lon, ok := gridToLatLon(newGrid); ok {
+			r.Lat, r.Lon = lat, lon
+		}
+	}
+}
+
 // OpenExternalURL opens a URL in the user's default browser. Wails ships
 // runtime.BrowserOpenURL for exactly this — used by the QRZ.com icon
 // next to the callsign field, the future Clublog/HamQTH shortcuts, etc.
@@ -6495,7 +6589,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, keyCATOmniRigVFO, keyCATFlexHost, keyCATFlexPort, keyCATFlexSpots, keyCATFlexDecodeSpots, keyCATFlexDecodeSecs, keyCATIcomPort, keyCATIcomBaud, keyCATIcomAddr, keyCATIcomNetHost, keyCATIcomNetUser, keyCATIcomNetPass, keyCATIcomNetAudio, keyCATTCIHost, keyCATTCIPort, keyCATTCISpots, keyCATPollMs, keyCATDelayMs, keyCATDigitalDefault)
+	m, err := a.settings.GetMany(a.ctx, keyCATEnabled, keyCATBackend, keyCATOmniRigNum, keyCATOmniRigVFO, keyCATFlexHost, keyCATFlexPort, keyCATFlexSpots, keyCATFlexDecodeSpots, keyCATFlexDecodeSecs, keyCATXieguPort, keyCATXieguBaud, keyCATXieguAddr, keyCATYaesuPort, keyCATYaesuBaud, keyCATIcomPort, keyCATIcomBaud, keyCATIcomAddr, keyCATIcomNetHost, keyCATIcomNetUser, keyCATIcomNetPass, keyCATIcomNetAudio, keyCATTCIHost, keyCATTCIPort, keyCATTCISpots, keyCATPollMs, keyCATDelayMs, keyCATDigitalDefault, keyCATShareEnabled, keyCATSharePort)
 	if err != nil {
 		return CATSettings{}, err
 	}
@@ -6508,6 +6602,11 @@ func (a *App) GetCATSettings() (CATSettings, error) {
 		FlexSpots:       m[keyCATFlexSpots] == "1",
 		FlexDecodeSpots: m[keyCATFlexDecodeSpots] == "1",
 		FlexDecodeSecs:  120,
+		XieguPort:       m[keyCATXieguPort],
+		XieguBaud:       19200,
+		XieguAddr:       cat.XieguDefaultAddr,
+		YaesuPort:       m[keyCATYaesuPort],
+		YaesuBaud:       38400,
 		IcomPort:        m[keyCATIcomPort],
 		IcomBaud:        115200,
 		IcomAddr:        0x98, // IC-7610 default
@@ -6521,6 +6620,8 @@ func (a *App) GetCATSettings() (CATSettings, error) {
 		PollMs:          250,
 		DelayMs:         0,
 		DigitalDefault:  m[keyCATDigitalDefault],
+		ShareEnabled:    m[keyCATShareEnabled] == "1",
+		SharePort:       4532,
 	}
 	if n, _ := strconv.Atoi(m[keyCATFlexPort]); n > 0 && n <= 65535 {
 		out.FlexPort = n
@@ -6531,6 +6632,18 @@ func (a *App) GetCATSettings() (CATSettings, error) {
 	if n, _ := strconv.Atoi(m[keyCATTCIPort]); n > 0 && n <= 65535 {
 		out.TCIPort = n
 	}
+	if n, _ := strconv.Atoi(m[keyCATSharePort]); n > 0 && n <= 65535 {
+		out.SharePort = n
+	}
+	if n, _ := strconv.Atoi(m[keyCATXieguBaud]); n > 0 {
+		out.XieguBaud = n
+	}
+	if n, _ := strconv.Atoi(m[keyCATXieguAddr]); n > 0 && n <= 0xFF {
+		out.XieguAddr = n
+	}
+	if n, _ := strconv.Atoi(m[keyCATYaesuBaud]); n > 0 {
+		out.YaesuBaud = n
+	}
 	if n, _ := strconv.Atoi(m[keyCATIcomBaud]); n > 0 {
 		out.IcomBaud = n
 	}
@@ -6572,6 +6685,18 @@ func (a *App) SaveCATSettings(s CATSettings) error {
 	if s.FlexPort <= 0 || s.FlexPort > 65535 {
 		s.FlexPort = 4992
 	}
+	if s.SharePort <= 0 || s.SharePort > 65535 {
+		s.SharePort = 4532
+	}
+	if s.XieguBaud <= 0 {
+		s.XieguBaud = 19200
+	}
+	if s.XieguAddr <= 0 || s.XieguAddr > 0xFF {
+		s.XieguAddr = cat.XieguDefaultAddr
+	}
+	if s.YaesuBaud <= 0 {
+		s.YaesuBaud = 38400
+	}
 	if s.IcomBaud <= 0 {
 		s.IcomBaud = 115200
 	}
@@ -6610,6 +6735,10 @@ func (a *App) SaveCATSettings(s CATSettings) error {
 	if s.DigitalDefault == "" {
 		s.DigitalDefault = "FT8"
 	}
+	shareEnabled := "0"
+	if s.ShareEnabled {
+		shareEnabled = "1"
+	}
 	for k, v := range map[string]string{
 		keyCATEnabled:         enabled,
 		keyCATBackend:         s.Backend,
@@ -6620,6 +6749,11 @@ func (a *App) SaveCATSettings(s CATSettings) error {
 		keyCATFlexSpots:       flexSpots,
 		keyCATFlexDecodeSpots: flexDecodeSpots,
 		keyCATFlexDecodeSecs:  strconv.Itoa(s.FlexDecodeSecs),
+		keyCATXieguPort:       strings.TrimSpace(s.XieguPort),
+		keyCATXieguBaud:       strconv.Itoa(s.XieguBaud),
+		keyCATXieguAddr:       strconv.Itoa(s.XieguAddr),
+		keyCATYaesuPort:       strings.TrimSpace(s.YaesuPort),
+		keyCATYaesuBaud:       strconv.Itoa(s.YaesuBaud),
 		keyCATIcomPort:        strings.TrimSpace(s.IcomPort),
 		keyCATIcomBaud:        strconv.Itoa(s.IcomBaud),
 		keyCATIcomAddr:        strconv.Itoa(s.IcomAddr),
@@ -6633,6 +6767,8 @@ func (a *App) SaveCATSettings(s CATSettings) error {
 		keyCATPollMs:          strconv.Itoa(s.PollMs),
 		keyCATDelayMs:         strconv.Itoa(s.DelayMs),
 		keyCATDigitalDefault:  strings.ToUpper(strings.TrimSpace(s.DigitalDefault)),
+		keyCATShareEnabled:    shareEnabled,
+		keyCATSharePort:       strconv.Itoa(s.SharePort),
 	} {
 		if err := a.settings.Set(a.ctx, k, v); err != nil {
 			return err
@@ -6659,6 +6795,7 @@ type AudioSettings struct {
 	Format          string `json:"format"`           // "wav" | "mp3"
 	FromGain        int    `json:"from_gain"`        // From Radio (RX) mix level %, default 100
 	MicGain         int    `json:"mic_gain"`         // mic mix level %, default 100
+	TXGain          int    `json:"tx_gain"`          // voice-keyer playback level %, default 100
 }
 
 // ListAudioInputDevices / ListAudioOutputDevices enumerate WASAPI endpoints
@@ -6668,14 +6805,14 @@ func (a *App) ListAudioOutputDevices() ([]audio.Device, error) { return audio.Li
 
 // GetAudioSettings returns the stored audio config (preroll defaults to 8s).
 func (a *App) GetAudioSettings() (AudioSettings, error) {
-	out := AudioSettings{PrerollSeconds: 8, PTTMethod: "none", Format: "wav", FromGain: 100, MicGain: 100}
+	out := AudioSettings{PrerollSeconds: 8, PTTMethod: "none", Format: "wav", FromGain: 100, MicGain: 100, TXGain: 100}
 	if a.settings == nil {
 		return out, nil
 	}
 	m, err := a.settings.GetMany(a.ctx,
 		keyAudioFromRadio, keyAudioToRadio, keyAudioRecDevice, keyAudioListenDevice,
 		keyAudioQSORecord, keyAudioQSODir, keyAudioPreroll, keyAudioPTTMethod, keyAudioPTTPort, keyAudioFormat,
-		keyAudioFromGain, keyAudioMicGain)
+		keyAudioFromGain, keyAudioMicGain, keyAudioTXGain)
 	if err != nil {
 		return out, err
 	}
@@ -6703,6 +6840,9 @@ func (a *App) GetAudioSettings() (AudioSettings, error) {
 	if n, _ := strconv.Atoi(m[keyAudioMicGain]); n > 0 && n <= 400 {
 		out.MicGain = n
 	}
+	if n, _ := strconv.Atoi(m[keyAudioTXGain]); n > 0 && n <= 400 {
+		out.TXGain = n
+	}
 	return out, nil
 }
 
@@ -6732,6 +6872,11 @@ func (a *App) SaveAudioSettings(s AudioSettings) error {
 	if s.MicGain <= 0 || s.MicGain > 400 {
 		s.MicGain = 100
 	}
+	// Up to 400 %: a mic recorded quietly needs real amplification, and the
+	// clamp in the player keeps it from wrapping into noise.
+	if s.TXGain <= 0 || s.TXGain > 400 {
+		s.TXGain = 100
+	}
 	for k, v := range map[string]string{
 		keyAudioFromRadio:    s.FromRadio,
 		keyAudioToRadio:      s.ToRadio,
@@ -6745,6 +6890,7 @@ func (a *App) SaveAudioSettings(s AudioSettings) error {
 		keyAudioFormat:       format,
 		keyAudioFromGain:     strconv.Itoa(s.FromGain),
 		keyAudioMicGain:      strconv.Itoa(s.MicGain),
+		keyAudioTXGain:       strconv.Itoa(s.TXGain),
 	} {
 		if err := a.settings.Set(a.ctx, k, v); err != nil {
 			return err
@@ -8221,7 +8367,7 @@ func (a *App) DVKPlay(slot int) error {
 		a.dvkPttKeyed = true
 		a.pttMu.Unlock()
 	}
-	if err := a.audioMgr.Play(cfg.ToRadio, path); err != nil {
+	if err := a.audioMgr.Play(cfg.ToRadio, path, cfg.TXGain); err != nil {
 		a.pttMu.Lock()
 		keyed := a.dvkPttKeyed
 		gen := a.pttGen
@@ -8265,7 +8411,8 @@ func (a *App) unkeyIfCurrent(gen int64) {
 }
 
 // pttKey keys the transmitter using the configured method:
-//   - "cat" → OmniRig (sets the Tx parameter to PM_TX)
+//   - "cat" → whichever CAT backend is active (OmniRig, Flex, Icom, TCI,
+//     Yaesu, Xiegu — they all implement SetPTT)
 //   - "rts"/"dtr" → open the COM port and assert that line, held during TX
 //   - "none" → VOX, nothing to do
 func (a *App) pttKey(cfg AudioSettings) error {
@@ -8355,7 +8502,16 @@ func (a *App) TestPTT(cfg AudioSettings) error {
 	if cfg.PTTMethod == "rts" || cfg.PTTMethod == "dtr" {
 		applog.Printf("ptt: TestPTT method=%q port=%q", cfg.PTTMethod, cfg.PTTPort)
 	} else {
-		applog.Printf("ptt: TestPTT method=%q (CAT via OmniRig — serial port not used)", cfg.PTTMethod)
+		// Name the backend that will actually key — "via OmniRig" was left over
+		// from when that was the only one, and it sent operators on a native
+		// backend looking for a problem with OmniRig that they do not even run.
+		backend := "no CAT backend"
+		if a.cat != nil {
+			if st := a.cat.State(); st.Backend != "" {
+				backend = st.Backend
+			}
+		}
+		applog.Printf("ptt: TestPTT method=%q (CAT via %s — serial port not used)", cfg.PTTMethod, backend)
 	}
 	if cfg.PTTMethod == "" || cfg.PTTMethod == "none" {
 		return fmt.Errorf("PTT method is None (VOX) — pick CAT, RTS or DTR first")
@@ -8389,7 +8545,9 @@ func (a *App) DVKPreview(slot int) error {
 		return fmt.Errorf("audio not initialized")
 	}
 	cfg, _ := a.GetAudioSettings()
-	return a.audioMgr.Play(cfg.ListeningDevice, a.dvkPath(slot))
+	// Preview at the SAME level the rig will get, or the operator adjusts against
+	// a sound that is not the one going on the air.
+	return a.audioMgr.Play(cfg.ListeningDevice, a.dvkPath(slot), cfg.TXGain)
 }
 
 // DVKStop halts any voice-keyer playback.
@@ -11970,6 +12128,7 @@ func (a *App) reloadCAT() {
 	a.catFlexSpots = s.Enabled && ((s.Backend == "flex" && s.FlexSpots) || (s.Backend == "tci" && s.TCISpots))
 	a.catFlexDecodeSpots = s.Enabled && s.Backend == "flex" && s.FlexDecodeSpots
 	a.catFlexDecodeSecs = s.FlexDecodeSecs
+	a.reloadCATShare(s)
 	if !s.Enabled {
 		a.cat.Stop()
 		return
@@ -11992,6 +12151,17 @@ func (a *App) reloadCAT() {
 			}
 		}
 		a.cat.Start(fb)
+	case "xiegu":
+		// Xiegu G90/X6100/X6200/X5105 — CI-V, but a REDUCED command set: no scope,
+		// no DSP block, no data mode. Its own backend rather than the Icom one at
+		// another address, so we never poll a G90 for answers it cannot give.
+		a.cat.Start(cat.NewXiegu(s.XieguPort, s.XieguBaud, s.XieguAddr, s.DigitalDefault))
+	case "yaesu":
+		// Native Yaesu CAT over the rig's USB/serial port — no OmniRig. Every
+		// Yaesu fault reported so far came from OmniRig's interpretation layer
+		// (a rig file that hides the VFO, a Freq property meaning A on one model
+		// and B on another); talking to the radio directly removes it.
+		a.cat.Start(cat.NewYaesu(s.YaesuPort, s.YaesuBaud, s.DigitalDefault))
 	case "icom":
 		// Native Icom CI-V over the radio's USB serial port (local control).
 		// Same civ protocol the network backend reuses for remote.
@@ -14689,3 +14859,193 @@ func (a *App) ClusterSpotStatuses(spots []SpotQuery) []SpotStatus {
 	}
 	return out
 }
+
+// ── CAT sharing (Hamlib NET rigctl server) ────────────────────────────────
+
+// catShareRig adapts the CAT manager to what the rigctld server needs. A thin
+// interface rather than a direct dependency, so the protocol stays testable
+// without a radio — and so sharing works with EVERY backend, not just the
+// native ones: an operator on OmniRig or Flex gets the same server.
+type catShareRig struct{ a *App }
+
+func (r catShareRig) Freq() int64  { return r.a.cat.State().FreqHz }
+func (r catShareRig) Mode() string { return r.a.cat.State().Mode }
+
+// Split reports the flag and the OTHER VFO's frequency. RigState follows ADIF —
+// FreqHz is where we TRANSMIT and RxFreqHz where we listen — while a rigctl
+// client asks for the split TX frequency, which is FreqHz. Getting this pair
+// backwards would make a client transmit on the listening frequency.
+func (r catShareRig) Split() (bool, int64) {
+	st := r.a.cat.State()
+	if !st.Split {
+		return false, 0
+	}
+	return true, st.FreqHz
+}
+
+func (r catShareRig) SetFreq(hz int64) error { return r.a.cat.SetFrequency(hz) }
+func (r catShareRig) SetMode(m string) error { return r.a.cat.SetMode(m) }
+func (r catShareRig) SetPTT(on bool) error   { return r.a.cat.SetPTT(on) }
+
+// reloadCATShare starts, stops or restarts the sharing server to match the
+// settings. Called from reloadCAT so one "Save & Close" settles both.
+func (a *App) reloadCATShare(s CATSettings) {
+	want := s.Enabled && s.ShareEnabled
+	// Always tear down first: the port may have changed, and a listener bound to
+	// the old one would keep answering while the client is told to use the new.
+	if a.catShare != nil {
+		a.catShare.Stop()
+		a.catShare = nil
+	}
+	if !want {
+		return
+	}
+	srv := rigctld.New(s.SharePort, catShareRig{a: a}, applog.Printf)
+	if err := srv.Start(); err != nil {
+		// The usual cause is another rigctld — or a previous OpsLog — already on
+		// the port. Logged rather than surfaced: CAT itself is unaffected, and the
+		// operator finds it in the log the moment a client fails to connect.
+		applog.Printf("cat share: %v", err)
+		return
+	}
+	a.catShare = srv
+}
+
+// ── Yaesu control panel bindings ──────────────────────────────────────────
+//
+// One thin binding per control, mirroring the Icom set. Each dispatches onto the
+// CAT goroutine, so a click never races the poll loop for the serial port.
+
+func (a *App) GetYaesuState() cat.YaesuTXState {
+	if a.cat == nil {
+		return cat.YaesuTXState{}
+	}
+	st, _ := a.cat.YaesuState()
+	return st
+}
+
+func (a *App) RefreshYaesuPanel() error {
+	if a.cat == nil {
+		return fmt.Errorf("CAT not initialized")
+	}
+	return a.cat.YaesuDo(func(y cat.YaesuController) error { return y.RefreshYaesu() })
+}
+
+func (a *App) SetYaesuPower(w int) error {
+	return a.yaesuDo(func(y cat.YaesuController) error { return y.SetYaesuPower(w) })
+}
+
+func (a *App) SetYaesuMicGain(p int) error {
+	return a.yaesuDo(func(y cat.YaesuController) error { return y.SetYaesuMicGain(p) })
+}
+
+func (a *App) SetYaesuAFGain(p int) error {
+	return a.yaesuDo(func(y cat.YaesuController) error { return y.SetYaesuAFGain(p) })
+}
+
+func (a *App) SetYaesuRFGain(p int) error {
+	return a.yaesuDo(func(y cat.YaesuController) error { return y.SetYaesuRFGain(p) })
+}
+
+func (a *App) SetYaesuSquelch(p int) error {
+	return a.yaesuDo(func(y cat.YaesuController) error { return y.SetYaesuSquelch(p) })
+}
+
+func (a *App) SetYaesuAGC(mode string) error {
+	return a.yaesuDo(func(y cat.YaesuController) error { return y.SetYaesuAGC(mode) })
+}
+
+func (a *App) SetYaesuPreamp(n int) error {
+	return a.yaesuDo(func(y cat.YaesuController) error { return y.SetYaesuPreamp(n) })
+}
+
+func (a *App) SetYaesuAtt(db int) error {
+	return a.yaesuDo(func(y cat.YaesuController) error { return y.SetYaesuAtt(db) })
+}
+
+func (a *App) SetYaesuNB(on bool) error {
+	return a.yaesuDo(func(y cat.YaesuController) error { return y.SetYaesuNB(on) })
+}
+
+func (a *App) SetYaesuNR(on bool) error {
+	return a.yaesuDo(func(y cat.YaesuController) error { return y.SetYaesuNR(on) })
+}
+
+func (a *App) SetYaesuNRLevel(n int) error {
+	return a.yaesuDo(func(y cat.YaesuController) error { return y.SetYaesuNRLevel(n) })
+}
+
+func (a *App) SetYaesuNarrow(on bool) error {
+	return a.yaesuDo(func(y cat.YaesuController) error { return y.SetYaesuNarrow(on) })
+}
+
+func (a *App) SetYaesuVOX(on bool) error {
+	return a.yaesuDo(func(y cat.YaesuController) error { return y.SetYaesuVOX(on) })
+}
+
+func (a *App) SetYaesuSplit(on bool) error {
+	return a.yaesuDo(func(y cat.YaesuController) error { return y.SetYaesuSplit(on) })
+}
+
+func (a *App) SetYaesuBand(band string) error {
+	return a.yaesuDo(func(y cat.YaesuController) error { return y.SetYaesuBand(band) })
+}
+
+func (a *App) TuneYaesuATU() error {
+	return a.yaesuDo(func(y cat.YaesuController) error { return y.TuneYaesuATU() })
+}
+
+func (a *App) yaesuDo(fn func(cat.YaesuController) error) error {
+	if a.cat == nil {
+		return fmt.Errorf("CAT not initialized")
+	}
+	return a.cat.YaesuDo(fn)
+}
+
+// SetYaesuModeRaw picks an exact rig mode, sideband included ("CW-L", "DATA-U").
+// The panel's mode buttons use this rather than SetCATMode, which takes an ADIF
+// mode and can only choose a sideband by convention.
+func (a *App) SetYaesuModeRaw(mode string) error {
+	return a.yaesuDo(func(y cat.YaesuController) error { return y.SetYaesuModeRaw(mode) })
+}
+
+// SetYaesuSplitOffset turns split on with the TX VFO a fixed distance up — the
+// classic "listen down, transmit up 5" of a phone pile-up, or up 1 on CW.
+func (a *App) SetYaesuSplitOffset(offsetHz int64) error {
+	return a.yaesuDo(func(y cat.YaesuController) error { return y.SetYaesuSplitOffset(offsetHz) })
+}
+
+func (a *App) SetYaesuKeySpeed(wpm int) error {
+	return a.yaesuDo(func(y cat.YaesuController) error { return y.SetYaesuKeySpeed(wpm) })
+}
+
+func (a *App) SetYaesuBreakIn(on bool) error {
+	return a.yaesuDo(func(y cat.YaesuController) error { return y.SetYaesuBreakIn(on) })
+}
+
+// YaesuZeroIn retunes the rig so the received CW signal lands on the operator's
+// own pitch — the radio's ZIN key.
+func (a *App) YaesuZeroIn() error {
+	return a.yaesuDo(func(y cat.YaesuController) error { return y.YaesuZeroIn() })
+}
+
+// YaesuSendCW keys a CW message through the Yaesu's own keyer (CAT "KY"), so an
+// FTDX10 needs no WinKeyer and no second cable.
+func (a *App) YaesuSendCW(text string) error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	err := a.cat.YaesuDo(func(y cat.YaesuController) error { return y.SendCW(text) })
+	if err != nil {
+		applog.Printf("yaesu cw: YaesuSendCW(%q) failed: %v", text, err)
+	}
+	return err
+}
+
+// YaesuStopCW aborts the message being sent.
+func (a *App) YaesuStopCW() error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	return a.cat.YaesuDo(func(y cat.YaesuController) error { return y.StopCW() })
+}

changelog.json

@@ -1,4 +1,48 @@
 [
+  {
+    "version": "0.22.0",
+    "date": "2026-07-28",
+    "en": [
+      "WinKeyer 2: keying is fixed. The dit/dah ratio was sent on the command that sets KEY COMPENSATION, so every element got 50 ms of extra key-down — at 25 wpm a dit is 48 ms — and the keyer sent one element then stalled. The compensation is also cleared, since a keyer already set that way keeps it.",
+      "The voice keyer PTT list now names the Yaesu and Xiegu backends too — with a native backend selected it showed no CAT name, which read as \"CAT PTT is not available for my radio\".",
+      "Voice keyer: a level control for the messages sent to the radio (Settings → Audio). They went out exactly as recorded, so a quietly recorded microphone drove the rig quietly with nothing in OpsLog to fix it. Play previews at the same level, and the hint names the rig setting to check when it transmits almost nothing (on an FTDX10, SSB MOD SOURCE = REAR).",
+      "Yaesu console meters are right: power now reads the meter that follows the RF (in watts, on a curve measured against the rig own display, not the power setting) and SWR shows the ratio itself. Both were reading the wrong index — the SWR bar sat near 80 on a perfect match. The bars also hold their peak for a moment before falling back, so they stay readable through the gaps between words in a CQ, in CW as in SSB.",
+      "CW speed is now one setting wherever you change it: the Yaesu console slider and the CW panel drive the keyer that is actually sending, and the rig own keyer follows so its front panel agrees.",
+      "Antenna Genius: port A no longer jumps onto port B antenna a few seconds after a change. Only one port can hold the transmit antenna, so the switch reports the same one on both — the display now follows each port own receive antenna.",
+      "CW through the Yaesu keyer: a fifth CW engine sends your macros with the radio own keyer (CAT \"KY\") — no WinKeyer, no second cable. Pick \"Yaesu (rig keyer)\" in Settings → CW keyer. For the FTDX101 / FT-991A / FT-710 family: an FTDX10 does not accept it (DAKY included), and OpsLog says so, pointing to the serial DTR keyer on the rig second COM port, which works.",
+      "The Yaesu console follows the mode: in CW the microphone gain and VOX disappear and a CW card takes their place with keyer speed, break-in and ZIN (zero-in).",
+      "Native Xiegu CAT (G90, X6100, X6200, X5105): a new backend talks CI-V straight to the radio — frequency, mode, split and PTT. Pick \"Xiegu (native CI-V)\" in Settings → CAT. Untested on a radio so far, feedback welcome.",
+      "CAT sharing: OpsLog can now serve its rig connection to other programs (Settings → CAT → Share CAT). WSJT-X, JTDX, MSHV or Log4OM connect with rig model \"Hamlib NET rigctl\" at 127.0.0.1:4532 — needed because a native CAT backend holds the radio serial port on its own. Works with every backend, and with both Hamlib command dialects (JTDX names the VFO, MSHV does not).",
+      "Native Yaesu CAT: a new backend talks to an FTDX10/FTDX101 directly over its serial port, without OmniRig — frequency, mode, VFO A/B, split and PTT. Pick \"Yaesu (native CAT)\" in Settings → CAT. First release, feedback welcome.",
+      "Changing band from OpsLog now updates the displayed frequency straight away. The rig moved, but its answer arrived inside the short grace window that protects what you are typing and was discarded — so the frequency stayed on the old band until you nudged the VFO.",
+      "Bulk edit can now set the contacted station gridsquare, so a batch of QSOs imported without a locator can be corrected in one go.",
+      "Filter builder: a confirmation date typed into a condition showed an empty box. The value was stored correctly, only the calendar field failed to display it.",
+      "The Icom model list gains the IC-7300MKII (CI-V B6), plus the IC-7100, IC-7410, IC-7600 and IC-7851. The IC-7700 and IC-7800 were listed at the IC-7100's and IC-7410's addresses, so picking them set an address the rig never answers on.",
+      "Icom over the LAN: the frequency no longer stays frozen after another program (WSJT-X through OmniRig, the Remote Utility) takes the CI-V session. The rig kept answering pings while sending nothing, so OpsLog showed the last known frequency until it was restarted; it now reconnects on its own.",
+      "The offline FCC (ULS) database now answers while you type a US callsign, filling state, county and a 6-character grid. It was only applied when the QSO was saved, so without a QRZ.com or HamQTH account you saw nothing but the country and a coarse grid. Online lookups still win — ULS only fills what is blank.",
+      "CQ and ITU zones you correct by hand in your profile stay corrected. They are derived from cty.dat, which gives the zones of the whole entity — in a country spanning several, the automatic value is wrong and it came back at every restart. They now only fill in when empty, and recompute when the callsign or grid changes."
+    ],
+    "fr": [
+      "WinKeyer 2 : la manipulation est réparée. Le rapport point/trait était envoyé sur la commande qui règle la COMPENSATION DE MANIPULATION : chaque élément recevait donc 50 ms de fermeture supplémentaire — à 25 mots/minute un point dure 48 ms — et le keyer envoyait un élément puis se bloquait. La compensation est aussi remise à zéro, car un keyer déjà réglé ainsi la conserve.",
+      "La liste PTT du voice keyer nomme aussi les backends Yaesu et Xiegu — avec un backend natif sélectionné, aucun nom de CAT n'apparaissait, ce qui se lisait « il n'y a pas de PTT CAT pour ma radio ».",
+      "Voice keyer : un réglage de niveau pour les messages envoyés à la radio (Réglages → Audio). Ils partaient exactement tels qu'enregistrés : un micro capté faiblement attaquait donc la radio faiblement, sans rien dans OpsLog pour y remédier. Le bouton Lire fait entendre ce même niveau, et l'aide indique le réglage radio à vérifier quand elle n'émet presque rien (sur un FTDX10, SSB MOD SOURCE = REAR).",
+      "Les mesures de la console Yaesu sont justes : la puissance lit l'instrument qui suit la HF (en watts, sur une courbe relevée face à l'affichage de la radio, et non le réglage de puissance) et le ROS affiche le rapport lui-même. Les deux lisaient le mauvais index — la barre de ROS restait vers 80 sur une antenne parfaite. Les barres retiennent aussi leur crête un instant avant de redescendre : elles restent lisibles pendant les silences entre les mots d’un CQ, en CW comme en phonie.",
+      "La vitesse CW est désormais un réglage unique où que vous la changiez : le curseur de la console Yaesu et le panneau CW pilotent le manipulateur qui émet réellement, et le keyer interne de la radio suit pour que sa façade affiche la même valeur.",
+      "Antenna Genius : le port A ne bascule plus sur l'antenne du port B quelques secondes après un changement. Un seul port peut porter l'antenne d'émission, le switch renvoie donc la même sur les deux — l'affichage suit désormais l'antenne de réception propre à chaque port.",
+      "CW par le keyer Yaesu : un cinquième moteur CW envoie vos macros avec le keyer de la radio (CAT « KY ») — sans WinKeyer ni second câble. À choisir dans Réglages → Keyer CW sous « Yaesu (keyer de la radio) ». Pour la famille FTDX101 / FT-991A / FT-710 : un FTDX10 ne l'accepte pas (DAKY compris), et OpsLog le dit en renvoyant vers le keyer série DTR sur son second port COM, qui fonctionne.",
+      "La console Yaesu suit le mode : en CW, le gain micro et le VOX disparaissent au profit d'une carte CW avec la vitesse du manipulateur, le break-in et ZIN (zéro-in).",
+      "CAT Xiegu natif (G90, X6100, X6200, X5105) : un nouveau backend dialogue en CI-V directement avec la radio — fréquence, mode, split et PTT. À choisir dans Réglages → CAT sous « Xiegu (CI-V natif) ». Pas encore testé sur une radio, retours bienvenus.",
+      "Partage du CAT : OpsLog peut désormais servir sa liaison radio aux autres logiciels (Réglages → CAT → Partager le CAT). WSJT-X, JTDX, MSHV ou Log4OM s'y connectent avec le modèle « Hamlib NET rigctl » sur 127.0.0.1:4532 — nécessaire car un backend CAT natif occupe seul le port série. Fonctionne avec tous les backends, et avec les deux dialectes Hamlib (JTDX nomme le VFO, MSHV non).",
+      "CAT Yaesu natif : un nouveau backend dialogue directement avec un FTDX10/FTDX101 par son port série, sans OmniRig — fréquence, mode, VFO A/B, split et PTT. À choisir dans Réglages → CAT sous « Yaesu (CAT natif) ». Première version, retours bienvenus.",
+      "Changer de bande depuis OpsLog met désormais la fréquence affichée à jour immédiatement. La radio se déplaçait bien, mais sa réponse arrivait pendant le court délai qui protège votre saisie et était ignorée — la fréquence restait donc sur l'ancienne bande jusqu'à ce qu'on touche le VFO.",
+      "L'édition groupée peut désormais définir le locator de la station contactée : un lot de QSO importés sans locator se corrige en une fois.",
+      "Constructeur de filtres : une date de confirmation saisie dans une condition s'affichait dans une case vide. La valeur était bien enregistrée, seul le champ calendrier ne la montrait pas.",
+      "La liste des modèles Icom gagne l'IC-7300MKII (CI-V B6), ainsi que les IC-7100, IC-7410, IC-7600 et IC-7851. Les IC-7700 et IC-7800 y figuraient avec les adresses des IC-7100 et IC-7410 : les choisir réglait une adresse sur laquelle la radio ne répond jamais.",
+      "Icom via le réseau : la fréquence ne reste plus figée après qu'un autre programme (WSJT-X via OmniRig, la Remote Utility) a pris la session CI-V. La radio continuait de répondre aux pings sans rien émettre, si bien qu'OpsLog affichait la dernière fréquence connue jusqu'à son redémarrage ; il se reconnecte désormais tout seul.",
+      "La base FCC (ULS) hors ligne répond désormais pendant la saisie d'un indicatif américain, en remplissant l'état, le comté et un locator 6 caractères. Elle n'était appliquée qu'à l'enregistrement du QSO : sans compte QRZ.com ou HamQTH, vous ne voyiez que le pays et un locator approximatif. Les recherches en ligne restent prioritaires — l'ULS ne comble que ce qui est vide.",
+      "Les zones CQ et ITU corrigées à la main dans votre profil restent corrigées. Elles proviennent de cty.dat, qui donne les zones de l'entité entière — dans un pays qui en couvre plusieurs, la valeur automatique est fausse et revenait à chaque redémarrage. Elles ne se remplissent désormais que si le champ est vide, et se recalculent quand l'indicatif ou le locator change."
+    ]
+  },
   {
     "version": "0.21.8",
     "date": "2026-07-28",

frontend/src/App.tsx

@@ -38,7 +38,7 @@ import {
   ListCountries,
   GetWinkeyerSettings, SaveWinkeyerSettings, ListSerialPorts, GetWinkeyerStatus,
   WinkeyerConnect, WinkeyerDisconnect, WinkeyerSend, WinkeyerStop, WinkeyerSetSpeed, WinkeyerBackspace,
-  IcomSendCW, IcomStopCW, IcomSetKeySpeed, IcomSetBreakIn, GetIcomState,
+  IcomSendCW, YaesuSendCW, YaesuStopCW, SetYaesuKeySpeed, IcomStopCW, IcomSetKeySpeed, IcomSetBreakIn, GetIcomState,
   FlexSendCW, FlexStopCW, FlexSetKeySpeed, FlexBackspaceCW,
   GetDVKMessages, GetDVKStatus, DVKPlay, DVKStop,
   StartCWDecoder, StopCWDecoder, SetCWDecoderPitch,
@@ -73,6 +73,7 @@ import { BandMap } from '@/components/BandMap';
 import { WorldMap, LocatorMap } from '@/components/MainMap';
 import { FlexPanel } from '@/components/FlexPanel';
 import { IcomPanel } from '@/components/IcomPanel';
+import { YaesuPanel } from '@/components/YaesuPanel';
 import { AntGeniusPanel, type AGStatus } from '@/components/AntGeniusPanel';
 import { TunerGeniusPanel, type TGStatus } from '@/components/TunerGeniusPanel';
 import { ScpPanel, type ScpResult } from '@/components/ScpPanel';
@@ -502,6 +503,9 @@ export default function App() {
 
   // CAT — receives live rig state via Wails events.
   const [catState, setCatState] = useState<CATState>({ enabled: false, connected: false } as any);
+  // Live copy for callbacks that must not close over a stale snapshot.
+  const catStateRef = useRef(catState);
+  useEffect(() => { catStateRef.current = catState; }, [catState]);
   // Configured CAT backend ('icom' USB vs 'icom-net'): the live catState.backend
   // is "icom" for BOTH, so we track the settings value to tell them apart (used to
   // hide the rig ON/OFF buttons on USB, where the interface is unpowered when the
@@ -594,6 +598,10 @@ export default function App() {
   // window after manual edits and skip CAT updates during it.
   const catFreezeUntilRef = useRef<number>(0);
   function noteManualEdit() { catFreezeUntilRef.current = Date.now() + 1500; }
+  // The last CAT snapshot that arrived while the freeze was open, replayed when
+  // it closes — see applyCatState.
+  const pendingCatRef = useRef<CATState | null>(null);
+  const pendingCatTimerRef = useRef<number | undefined>(undefined);
 
   // Suggested QSY frequency (Hz) for a given band + mode. Common phone /
   // CW / FT8 watering holes per IARU practice. Fallback = mid-band SSB freq.
@@ -960,7 +968,26 @@ export default function App() {
   // CI-V 0x17 (no extra hardware — sends over the CAT connection). Macros,
   // auto-call and <LOGQSO> are shared; only the transport differs.
   const [wkEngine, setWkEngine] = useState<string>('winkeyer');
-  const cwSource: 'winkeyer' | 'icom' | 'flex' = wkEngine === 'icom' ? 'icom' : wkEngine === 'flex' ? 'flex' : 'winkeyer';
+  const cwSource: 'winkeyer' | 'icom' | 'flex' | 'yaesu' = wkEngine === 'icom' ? 'icom' : wkEngine === 'flex' ? 'flex' : wkEngine === 'yaesu' ? 'yaesu' : 'winkeyer';
+  // Setting the CW speed has to reach the keyer that is ACTUALLY sending, and
+  // both the CW panel and the Yaesu console can ask for it. With DTR/RTS line
+  // keying the PC does the timing, so the rig's internal keyer speed changes
+  // nothing audible — the Yaesu console's slider looked broken because it drove
+  // that one alone. It now drives both: the rig's keyer for its own front panel,
+  // and the engine doing the work.
+  const setCWSpeedEverywhere = useCallback((w: number) => {
+    setWkWpm(w); saveWk({ wpm: w });
+    const src = cwSourceRef.current;
+    if (src === 'icom') IcomSetKeySpeed(w).catch(() => {});
+    else if (src === 'flex') FlexSetKeySpeed(w).catch(() => {});
+    else if (src === 'yaesu') SetYaesuKeySpeed(w).catch(() => {});
+    else WinkeyerSetSpeed(w).catch(() => {});
+    // The rig's own keyer follows too whenever a Yaesu is on CAT, even when it is
+    // not the sending engine: its front panel and OpsLog then agree.
+    if (src !== 'yaesu' && catStateRef.current?.backend === 'yaesu') {
+      SetYaesuKeySpeed(w).catch(() => {});
+    }
+  }, []);
   const cwSourceRef = useRef(cwSource);
   useEffect(() => { cwSourceRef.current = cwSource; }, [cwSource]);
   // CW break-in (0=OFF, 1=SEMI, 2=FULL) — must be on for the rig's 0x17 keyer to
@@ -996,6 +1023,7 @@ export default function App() {
   useEffect(() => {
     const connected = cwSource === 'icom' ? (catState.backend === 'icom' && catState.connected)
       : cwSource === 'flex' ? (catState.backend === 'flex' && catState.connected)
+      : cwSource === 'yaesu' ? (catState.backend === 'yaesu' && catState.connected)
       : wkStatus.connected;
     wkActiveRef.current = wkEnabled && connected;
   }, [wkEnabled, wkStatus.connected, cwSource, catState.backend, catState.connected]);
@@ -1315,12 +1343,12 @@ export default function App() {
   // map ("map1"), the locator street map ("map2"), the cluster grid or the
   // worked-before grid. Per-profile (stored via SetUIPref → profile-prefixed),
   // so it's loaded async on mount and re-read on profile:changed below.
-  type MainPaneKind = 'map1' | 'map2' | 'cluster' | 'worked' | 'flex' | 'recent' | 'icom' | 'netcontrol';
+  type MainPaneKind = 'map1' | 'map2' | 'cluster' | 'worked' | 'flex' | 'recent' | 'icom' | 'yaesu' | 'netcontrol';
   const [mapZoomSignal, setMapZoomSignal] = useState(0); // bump → world map auto-zooms now
   const [mainPaneLeft, setMainPaneLeft] = useState<MainPaneKind>('map1');
   const [mainPaneRight, setMainPaneRight] = useState<MainPaneKind>('map2');
   const loadMainPanes = useCallback(async () => {
-    const valid = (v: string): v is MainPaneKind => v === 'map1' || v === 'map2' || v === 'cluster' || v === 'worked' || v === 'flex' || v === 'recent' || v === 'icom' || v === 'netcontrol';
+    const valid = (v: string): v is MainPaneKind => v === 'map1' || v === 'map2' || v === 'cluster' || v === 'worked' || v === 'flex' || v === 'recent' || v === 'icom' || v === 'yaesu' || v === 'netcontrol';
     const [l, r] = await Promise.all([
       GetUIPref('mainPaneLeft').catch(() => ''),
       GetUIPref('mainPaneRight').catch(() => ''),
@@ -2122,7 +2150,26 @@ export default function App() {
   function applyCatState(s: CATState) {
     setCatState(s);
     if (!s?.connected) return;
-    if (Date.now() < catFreezeUntilRef.current) return;
+    // A snapshot arriving during the freeze used to be DROPPED, and that lost the
+    // only one that mattered. Changing band from OpsLog does two things at once:
+    // it opens the 1.5 s freeze (noteManualEdit) and it commands the rig. The
+    // rig's answer comes back in ~170 ms — inside the freeze — so it was thrown
+    // away, and since the backend only emits on CHANGE, nothing followed: the
+    // frequency stayed on the old band until the operator nudged the VFO. From
+    // the radio it always worked, because no freeze was open. Confirmed on an
+    // FTDX10 (2026-07-29): the log showed the backend publishing the right
+    // frequency every time while the display did not move.
+    const now = Date.now();
+    if (now < catFreezeUntilRef.current) {
+      pendingCatRef.current = s;
+      if (pendingCatTimerRef.current) window.clearTimeout(pendingCatTimerRef.current);
+      pendingCatTimerRef.current = window.setTimeout(() => {
+        const p = pendingCatRef.current;
+        pendingCatRef.current = null;
+        if (p) applyCatState(p); // re-checks the freeze, so more typing just defers it again
+      }, catFreezeUntilRef.current - now + 50);
+      return;
+    }
     const lk = locksRef.current;
     if (!lk.freq && s.freq_hz && s.freq_hz > 0) {
       setFreqMhz((s.freq_hz / 1_000_000).toFixed(5));
@@ -2396,7 +2443,16 @@ export default function App() {
       setWkEscClears(s.esc_clears_call !== false);
       setWkSendOnType(!!s.send_on_type);
       setWkEsm(!!s.esm);
-      setWkEngine(s.engine === 'icom' ? 'icom' : s.engine === 'flex' ? 'flex' : s.engine === 'serial' ? 'serial' : 'winkeyer');
+      // Every engine has to be named here. Anything unlisted silently became
+      // "winkeyer", so choosing the Yaesu keyer in the settings still gave a
+      // WinKeyer panel asking for a COM port — the setting was saved correctly,
+      // it just never survived being read back.
+      setWkEngine(
+        s.engine === 'icom' ? 'icom'
+          : s.engine === 'flex' ? 'flex'
+            : s.engine === 'yaesu' ? 'yaesu'
+              : s.engine === 'serial' ? 'serial'
+                : 'winkeyer');
     } catch { /* keyer not configured */ }
   }, []);
 
@@ -2522,7 +2578,7 @@ export default function App() {
     // segment AFTER the <LOGQSO> (which logs and clears the form) still expands its
     // variables correctly.
     const parts = rawText.split(/<LOGQSO>/i).map((pt) => resolveCW(pt));
-    const isRig = cwSourceRef.current === 'icom' || cwSourceRef.current === 'flex';
+    const isRig = cwSourceRef.current === 'icom' || cwSourceRef.current === 'flex' || cwSourceRef.current === 'yaesu';
     for (let p = 0; p < parts.length; p++) {
       if (aborted()) return; // ESC / Stop before this segment → stop sending, don't log
       const resolved = parts[p];
@@ -2534,7 +2590,7 @@ export default function App() {
         // current WPM, so it scales automatically.
         const keyed = resolved + ' ';
         setWkSent(resolved);
-        const sendFn = cwSourceRef.current === 'flex' ? FlexSendCW : cwSourceRef.current === 'icom' ? IcomSendCW : null;
+        const sendFn = cwSourceRef.current === 'flex' ? FlexSendCW : cwSourceRef.current === 'icom' ? IcomSendCW : cwSourceRef.current === 'yaesu' ? YaesuSendCW : null;
         if (sendFn) await sendFn(keyed).catch((e) => setError(String(e?.message ?? e)));
         else await WinkeyerSend(keyed).catch((e) => setError(String(e?.message ?? e)));
         // Only WAIT for the CW to finish on the FINAL segment — auto-call needs the
@@ -2567,6 +2623,7 @@ export default function App() {
     wkSendGenRef.current++; // cancel any in-flight macro send (and its pending <LOGQSO> log)
     if (cwSourceRef.current === 'icom') IcomStopCW().catch(() => {});
     else if (cwSourceRef.current === 'flex') FlexStopCW().catch(() => {});
+    else if (cwSourceRef.current === 'yaesu') YaesuStopCW().catch(() => {});
     else WinkeyerStop().catch(() => {});
   }
   // runAutoCall sends macro i, waits for the keyer to finish, waits the chosen
@@ -3471,6 +3528,7 @@ export default function App() {
           stopAutoCall();
           wkSendGenRef.current++; // abort an in-flight macro send so a pending <LOGQSO> won't fire
           if (cwSourceRef.current === 'icom') IcomStopCW().catch(() => {});
+          else if (cwSourceRef.current === 'yaesu') YaesuStopCW().catch(() => {});
           else if (cwSourceRef.current === 'flex') FlexStopCW().catch(() => {});
           else WinkeyerStop().catch(() => {});
         }
@@ -4256,6 +4314,12 @@ export default function App() {
               onReportRST={(r) => { setRstSent(r); rstUserEditedRef.current = true; }} />
           </div>
         );
+      case 'yaesu':
+        return (
+          <div className="h-full w-full min-h-0 rounded-lg overflow-hidden border border-border">
+            <YaesuPanel onReportRST={(r) => { setRstSent(r); rstUserEditedRef.current = true; }} onKeySpeed={setCWSpeedEverywhere} />
+          </div>
+        );
       case 'icom':
         return (
           <div className="h-full w-full min-h-0 rounded-lg overflow-hidden border border-border">
@@ -5180,8 +5244,16 @@ export default function App() {
           {wkEnabled && (
             <div className="w-[380px] shrink-0 min-h-0">
               <WinkeyerPanel
-                status={cwSource === 'icom' || cwSource === 'flex'
-                  ? { connected: catState.backend === cwSource && catState.connected, busy: false, wpm: wkWpm, version: 0, port: cwSource === 'flex' ? 'CWX' : 'CI-V' }
+                // A rig keyer has no serial status of its own: it is connected
+                // exactly when its CAT backend is. Yaesu was missing from this
+                // list, so the panel fell back to the WinKeyer status — which
+                // reported disconnected, no WinKeyer being attached.
+                status={cwSource === 'icom' || cwSource === 'flex' || cwSource === 'yaesu'
+                  ? {
+                    connected: catState.backend === cwSource && catState.connected,
+                    busy: false, wpm: wkWpm, version: 0,
+                    port: cwSource === 'flex' ? 'CWX' : cwSource === 'yaesu' ? 'CAT' : 'CI-V',
+                  }
                   : wkStatus}
                 ports={wkPorts}
                 port={wkPort}
@@ -5195,12 +5267,7 @@ export default function App() {
                 onRefreshPorts={reloadWkPorts}
                 onConnect={() => WinkeyerConnect().catch((e) => setError(String(e?.message ?? e)))}
                 onDisconnect={() => WinkeyerDisconnect().catch(() => {})}
-                onSetSpeed={(w) => {
-                  setWkWpm(w); saveWk({ wpm: w });
-                  if (cwSource === 'icom') IcomSetKeySpeed(w).catch(() => {});
-                  else if (cwSource === 'flex') FlexSetKeySpeed(w).catch(() => {});
-                  else WinkeyerSetSpeed(w).catch(() => {});
-                }}
+                onSetSpeed={setCWSpeedEverywhere}
                 onSend={wkSend}
                 onSendMacro={wkSendMacro}
                 onStop={() => { stopAutoCall(); stopKeyerTx(); }}
@@ -5341,8 +5408,9 @@ export default function App() {
                   </span>
                 </TabsTrigger>
               )}
-              {catState.backend === 'flex' && <TabsTrigger value="flex">FlexRadio</TabsTrigger>}
-              {catState.backend === 'icom' && <TabsTrigger value="icom">Icom</TabsTrigger>}
+              {catState.backend === 'flex' && <TabsTrigger value="flex">Flex Console</TabsTrigger>}
+              {catState.backend === 'icom' && <TabsTrigger value="icom">Icom Console</TabsTrigger>}
+              {catState.backend === 'yaesu' && <TabsTrigger value="yaesu">Yaesu Console</TabsTrigger>}
               {statsTabOpen && (
                 <TabsTrigger value="stats" className="gap-1.5">
                   {t('stats.tab')}
@@ -5758,6 +5826,13 @@ export default function App() {
 
             {/* Icom CI-V receive-DSP control panel — only when the CAT backend
                 is an Icom. */}
+            {/* Yaesu CAT control panel — only when the CAT backend is a Yaesu. */}
+            {catState.backend === 'yaesu' && (
+              <TabsContent value="yaesu" className="flex-1 min-h-0 p-0">
+                <YaesuPanel onReportRST={(r) => { setRstSent(r); rstUserEditedRef.current = true; }} onKeySpeed={setCWSpeedEverywhere} />
+              </TabsContent>
+            )}
+
             {catState.backend === 'icom' && (
               <TabsContent value="icom" className="flex-1 min-h-0 p-0">
                 <IcomPanel isNetwork={catBackend === 'icom-net'} onReportRST={(r) => { setRstSent(r); rstUserEditedRef.current = true; }} />
@@ -6051,6 +6126,7 @@ export default function App() {
           onMainPaneChanged={(side, v) => { if (side === 'left') setMainPaneLeft(v as MainPaneKind); else setMainPaneRight(v as MainPaneKind); }}
           flexAvailable={catState.backend === 'flex'}
           icomAvailable={catState.backend === 'icom'}
+          yaesuAvailable={catState.backend === 'yaesu'}
         />
       )}
 

frontend/src/components/BulkEditModal.tsx

@@ -82,6 +82,7 @@ const FIELDS: FieldDef[] = [
   { id: 'sat_name',  label: 'bulk.fSatName',  group: 'Propagation', kind: 'text', upper: true },
   { id: 'sat_mode',  label: 'bulk.fSatMode',  group: 'Propagation', kind: 'text', upper: true },
   // Contacted station (location / activation refs / SIG)
+  { id: 'grid',     label: 'bulk.fGrid',    group: 'Contacted station', kind: 'text', upper: true },
   { id: 'state',    label: 'bulk.fState',   group: 'Contacted station', kind: 'text', upper: true },
   { id: 'cnty',     label: 'bulk.fCnty',    group: 'Contacted station', kind: 'text' },
   { id: 'pota_ref', label: 'bulk.fPotaRef', group: 'Contacted station', kind: 'text', upper: true },

frontend/src/components/FilterBuilder.tsx

@@ -278,7 +278,11 @@ export function FilterBuilder({ open, initial, onApply, onClose }: Props) {
                   className="h-8 flex-1 text-xs"
                   disabled={!needsValue}
                   placeholder={needsValue ? (fieldType === 'date' ? 'YYYY-MM-DD' : t('fltb.valuePh')) : '—'}
-                  value={fieldType === 'adifdate' && /^d{8}$/.test(c.value)
+                  // \d, not d: the escape was missing, so the test never matched
+                  // an 8-digit ADIF date and the calendar input was handed
+                  // "20260728" — which type=date rejects, showing an empty box
+                  // over a value that was really there.
+                  value={fieldType === 'adifdate' && /^\d{8}$/.test(c.value)
                     ? `${c.value.slice(0, 4)}-${c.value.slice(4, 6)}-${c.value.slice(6, 8)}`
                     : c.value}
                   onChange={(e) => setCond(i, {

frontend/src/components/SettingsModal.tsx

@@ -156,6 +156,7 @@ interface Props {
   onMainPaneChanged?: (side: 'left' | 'right', value: string) => void; // live Main-view layout update
   flexAvailable?: boolean; // CAT backend is FlexRadio → offer it as a Main pane
   icomAvailable?: boolean; // CAT backend is Icom → offer the Icom console as a Main pane
+  yaesuAvailable?: boolean; // CAT backend is Yaesu → offer the Yaesu console as a Main pane
 }
 
 // Pretty little card showing what OpsLog will stamp on each QSO based on
@@ -817,7 +818,7 @@ function RelayAutoPanel() {
 // cluster grid or the worked-before grid. Per-profile (stored via SetUIPref,
 // which is profile-prefixed). Self-contained so it owns its async-loaded state.
 const MAIN_PANE_VALUES = ['map1', 'map2', 'cluster', 'worked', 'recent', 'netcontrol'];
-function MainViewPanes({ onChanged, flexAvailable, icomAvailable }: { onChanged?: (side: 'left' | 'right', value: string) => void; flexAvailable?: boolean; icomAvailable?: boolean }) {
+function MainViewPanes({ onChanged, flexAvailable, icomAvailable, yaesuAvailable }: { onChanged?: (side: 'left' | 'right', value: string) => void; flexAvailable?: boolean; icomAvailable?: boolean; yaesuAvailable?: boolean }) {
   const { t } = useI18n();
   const [left, setLeft] = useState('map1');
   const [right, setRight] = useState('map2');
@@ -826,10 +827,11 @@ function MainViewPanes({ onChanged, flexAvailable, icomAvailable }: { onChanged?
     ...MAIN_PANE_VALUES,
     ...(flexAvailable ? ['flex'] : []),
     ...(icomAvailable ? ['icom'] : []),
+    ...(yaesuAvailable ? ['yaesu'] : []),
   ].map((value) => ({ value, label: t(`settings.pane.${value}`) }))
     .sort((a, b) => a.label.localeCompare(b.label));
   useEffect(() => {
-    const valid = (v: string) => v === 'flex' || v === 'icom' || MAIN_PANE_VALUES.includes(v);
+    const valid = (v: string) => v === 'flex' || v === 'icom' || v === 'yaesu' || MAIN_PANE_VALUES.includes(v);
     Promise.all([GetUIPref('mainPaneLeft').catch(() => ''), GetUIPref('mainPaneRight').catch(() => '')])
       .then(([l, r]) => { if (valid(l)) setLeft(l); if (valid(r)) setRight(r); });
   }, []);
@@ -1006,17 +1008,25 @@ function FlexBandAntennasPanel({ bands }: { bands: string[] }) {
 // model sets icom_addr so the backend identifies it (civ.ModelName) and the UI
 // adapts (e.g. the attenuator steps differ by model). Keep in lockstep with
 // civ.ModelName in internal/cat/civ/civ.go. `addr` is decimal.
+// The IC-7700 and IC-7800 were listed at 0x88 and 0x80 — which are the IC-7100's
+// and the IC-7410's. Picking one of them set an address the rig never answers on,
+// and the backend then named it as the other model.
 const ICOM_MODELS: { name: string; addr: number }[] = [
   { name: 'IC-705', addr: 0xA4 },
+  { name: 'IC-7100', addr: 0x88 },
   { name: 'IC-7300', addr: 0x94 },
+  { name: 'IC-7300MKII', addr: 0xB6 },
+  { name: 'IC-7410', addr: 0x80 },
+  { name: 'IC-7600', addr: 0x7A },
   { name: 'IC-7610', addr: 0x98 },
-  { name: 'IC-7700', addr: 0x88 },
-  { name: 'IC-7800', addr: 0x80 },
+  { name: 'IC-7700', addr: 0x74 },
+  { name: 'IC-7800', addr: 0x6A },
+  { name: 'IC-7851', addr: 0x8E },
   { name: 'IC-9100', addr: 0x7C },
   { name: 'IC-9700', addr: 0xA2 },
 ];
 
-export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChanged, flexAvailable, icomAvailable }: Props) {
+export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChanged, flexAvailable, icomAvailable, yaesuAvailable }: Props) {
   const { t } = useI18n();
   const [selected, setSelected] = useState<SectionId>((initialSection as SectionId) || 'station');
   const [loading, setLoading] = useState(true);
@@ -1053,9 +1063,10 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   const [modeDraft, setModeDraft] = useState('');
   const [catCfg, setCatCfg] = useState<CATSettings>({
     enabled: false, backend: 'omnirig', omnirig_rig: 1, omnirig_vfo: '', flex_host: '', flex_port: 4992, flex_spots: false, flex_decode_spots: false, flex_decode_secs: 120,
+    yaesu_port: '', yaesu_baud: 38400, xiegu_port: '', xiegu_baud: 19200, xiegu_addr: 0x70,
     icom_port: '', icom_baud: 115200, icom_addr: 0x98, icom_net_host: '', icom_net_user: '', icom_net_pass: '', icom_net_audio: false,
     tci_host: '', tci_port: 40001, tci_spots: false, poll_ms: 250, delay_ms: 0,
-    digital_default: 'FT8',
+    digital_default: 'FT8', share_enabled: false, share_port: 4532,
   });
   const [rotator, setRotator] = useState<RotatorSettings>({
     enabled: false, type: 'pst', host: '127.0.0.1', port: 12000, has_elevation: false, rotator_num: 1,
@@ -1103,13 +1114,13 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     from_radio: string; to_radio: string; recording_device: string; listening_device: string;
     qso_record: boolean; qso_dir: string; preroll_seconds: number;
     ptt_method: 'none' | 'cat' | 'rts' | 'dtr'; ptt_port: string; format: 'wav' | 'mp3';
-    from_gain: number; mic_gain: number;
+    from_gain: number; mic_gain: number; tx_gain: number;
   };
   type AudioDev = { id: string; name: string; default: boolean };
   const [audioCfg, setAudioCfg] = useState<AudioSettings>({
     from_radio: '', to_radio: '', recording_device: '', listening_device: '',
     qso_record: false, qso_dir: '', preroll_seconds: 8, ptt_method: 'none', ptt_port: '', format: 'wav',
-    from_gain: 100, mic_gain: 100,
+    from_gain: 100, mic_gain: 100, tx_gain: 100,
   });
   const [audioInputs, setAudioInputs] = useState<AudioDev[]>([]);
   const [audioOutputs, setAudioOutputs] = useState<AudioDev[]>([]);
@@ -1483,27 +1494,49 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     return () => { off(); };
   }, []);
 
+  // Which (profile, callsign, grid) the auto-fill below last derived from.
+  // Without it, simply OPENING the settings counted as "the source changed" and
+  // overwrote the operator's own values.
+  const derivedFrom = useRef<string>('');
+
   // Auto-fill the active profile's MY_* DXCC metadata from the station
-  // callsign (country, DXCC#, CQ/ITU zones) and the grid (lat/lon). These
-  // are derived values, so they always recompute when the callsign or grid
-  // changes — the user can still edit a field, it just re-populates when the
-  // source changes. Debounced so we don't hammer cty.dat while typing.
+  // callsign (country, DXCC#, CQ/ITU zones) and the grid (lat/lon).
+  //
+  // These are derived values, so they recompute when the callsign or grid
+  // changes. What they must NOT do is recompute on a plain load: cty.dat gives
+  // the zones of the ENTITY, and a large country spans several — an operator in
+  // CQ 14 / ITU 27 was handed 15 and 28 and corrected them by hand, and every
+  // restart put the wrong pair back. cty.dat is a starting point, not an
+  // authority, so on a load we only fill fields that are EMPTY; a value the
+  // operator typed stays until the callsign or grid itself changes.
+  // Debounced so we don't hammer cty.dat while typing.
   useEffect(() => {
     const call = (activeProfile?.callsign ?? '').trim();
     if (!call) return;
     const grid = (activeProfile?.my_grid ?? '').trim();
+    const source = `${activeProfile?.id ?? 0}|${call.toUpperCase()}|${grid.toUpperCase()}`;
+    // First sight of this profile — a load, not an edit.
+    const isLoad = derivedFrom.current === '' || derivedFrom.current.split('|')[0] !== String(activeProfile?.id ?? 0);
     const t = window.setTimeout(async () => {
       try {
         const i: any = await ComputeStationInfo(call, grid);
+        derivedFrom.current = source;
         setActiveProfile((p) => {
           if (!p) return p;
           const patch: any = {};
-          if (i.country) patch.my_country = i.country;
-          if (i.dxcc) patch.my_dxcc = i.dxcc;
-          if (i.cqz) patch.my_cqz = i.cqz;
-          if (i.ituz) patch.my_ituz = i.ituz;
-          if (i.lat) patch.my_lat = i.lat;
-          if (i.lon) patch.my_lon = i.lon;
+          // On a load, keep in patch only what the profile does not already have.
+          const put = (k: string, v: any) => {
+            if (!v) return;
+            const cur = (p as any)[k];
+            if (isLoad && cur !== undefined && cur !== null && cur !== '' && cur !== 0) return;
+            patch[k] = v;
+          };
+          put('my_country', i.country);
+          put('my_dxcc', i.dxcc);
+          put('my_cqz', i.cqz);
+          put('my_ituz', i.ituz);
+          put('my_lat', i.lat);
+          put('my_lon', i.lon);
           // Only re-render when a value actually changed (prevents loops).
           const changed = Object.keys(patch).some((k) => (p as any)[k] !== patch[k]);
           return changed ? { ...p, ...patch } : p;
@@ -2316,6 +2349,8 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                 <SelectContent>
                   <SelectItem value="omnirig">{t('cat.optOmnirig')}</SelectItem>
                   <SelectItem value="flex">{t('cat.optFlex')}</SelectItem>
+                  <SelectItem value="yaesu">{t('cat.optYaesu')}</SelectItem>
+                  <SelectItem value="xiegu">{t('cat.optXiegu')}</SelectItem>
                   <SelectItem value="icom">{t('cat.optIcom')}</SelectItem>
                   <SelectItem value="icom-net">{t('cat.optIcomNet')}</SelectItem>
                   <SelectItem value="tci">{t('cat.optTci')}</SelectItem>
@@ -2383,6 +2418,72 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
               )}
             </>
             )}
+            {catCfg.backend === 'xiegu' && (
+            <>
+              <div className="space-y-1">
+                <Label>{t('cat.xieguPort')}</Label>
+                <div className="flex gap-2">
+                  <Select value={catCfg.xiegu_port || ''} onValueChange={(v) => setCatCfg((s) => ({ ...s, xiegu_port: v }))}>
+                    <SelectTrigger><SelectValue placeholder={t('cat.selectCom')} /></SelectTrigger>
+                    <SelectContent>
+                      {wkPorts.length === 0 && <SelectItem value="_" disabled>{t('cat.noPorts')}</SelectItem>}
+                      {wkPorts.map((p) => <SelectItem key={p} value={p}>{p}</SelectItem>)}
+                    </SelectContent>
+                  </Select>
+                  <Button type="button" variant="outline" size="sm"
+                    onClick={() => ListSerialPorts().then((p) => setWkPorts((p ?? []) as string[])).catch(() => {})}>↻</Button>
+                </div>
+              </div>
+              <div className="space-y-1">
+                <Label>{t('cat.baud')}</Label>
+                <Select value={String(catCfg.xiegu_baud || 19200)} onValueChange={(v) => setCatCfg((s) => ({ ...s, xiegu_baud: parseInt(v) || 19200 }))}>
+                  <SelectTrigger><SelectValue /></SelectTrigger>
+                  <SelectContent>
+                    {[4800, 9600, 19200, 38400, 57600, 115200].map((r) => <SelectItem key={r} value={String(r)}>{r}</SelectItem>)}
+                  </SelectContent>
+                </Select>
+                <span className="text-xs text-muted-foreground">{t('cat.xieguBaudHint')}</span>
+              </div>
+              <div className="space-y-1">
+                <Label>{t('cat.civAddr')}</Label>
+                <Input value={'0x' + (catCfg.xiegu_addr || 0x70).toString(16).toUpperCase().padStart(2, '0')}
+                  onChange={(e) => {
+                    const n = parseInt(e.target.value.replace(/^0x/i, ''), 16);
+                    if (!isNaN(n) && n > 0 && n <= 0xFF) setCatCfg((s) => ({ ...s, xiegu_addr: n }));
+                  }} />
+                <span className="text-xs text-muted-foreground">{t('cat.xieguAddrHint')}</span>
+              </div>
+            </>
+            )}
+            {catCfg.backend === 'yaesu' && (
+            <>
+              <div className="space-y-1">
+                <Label>{t('cat.yaesuPort')}</Label>
+                <div className="flex gap-2">
+                  <Select value={catCfg.yaesu_port || ''} onValueChange={(v) => setCatCfg((s) => ({ ...s, yaesu_port: v }))}>
+                    <SelectTrigger><SelectValue placeholder={t('cat.selectCom')} /></SelectTrigger>
+                    <SelectContent>
+                      {wkPorts.length === 0 && <SelectItem value="_" disabled>{t('cat.noPorts')}</SelectItem>}
+                      {wkPorts.map((p) => <SelectItem key={p} value={p}>{p}</SelectItem>)}
+                    </SelectContent>
+                  </Select>
+                  <Button type="button" variant="outline" size="sm"
+                    onClick={() => ListSerialPorts().then((p) => setWkPorts((p ?? []) as string[])).catch(() => {})}>↻</Button>
+                </div>
+                <span className="text-xs text-muted-foreground">{t('cat.yaesuPortHint')}</span>
+              </div>
+              <div className="space-y-1">
+                <Label>{t('cat.baud')}</Label>
+                <Select value={String(catCfg.yaesu_baud || 38400)} onValueChange={(v) => setCatCfg((s) => ({ ...s, yaesu_baud: parseInt(v) || 38400 }))}>
+                  <SelectTrigger><SelectValue /></SelectTrigger>
+                  <SelectContent>
+                    {[4800, 9600, 19200, 38400, 57600, 115200].map((r) => <SelectItem key={r} value={String(r)}>{r}</SelectItem>)}
+                  </SelectContent>
+                </Select>
+                <span className="text-xs text-muted-foreground">{t('cat.yaesuBaudHint')}</span>
+              </div>
+            </>
+            )}
             {catCfg.backend === 'icom' && (
             <>
               <div className="space-y-1">
@@ -2529,6 +2630,28 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
               </Select>
             </div>
           </div>
+          {/* CAT sharing. A native backend owns the rig's serial port, so without
+              this WSJT-X and friends are locked out of the radio entirely. */}
+          <div className="border-t border-border/60 pt-3 space-y-2">
+            <label className="flex items-center gap-2 text-sm cursor-pointer">
+              <Checkbox
+                checked={!!catCfg.share_enabled}
+                onCheckedChange={(c) => setCatCfg((s) => ({ ...s, share_enabled: !!c }))}
+              />
+              {t('cat.share')}
+            </label>
+            <p className="text-[11px] text-muted-foreground">{t('cat.shareHint')}</p>
+            {catCfg.share_enabled && (
+              <div className="space-y-1 max-w-[200px]">
+                <Label>{t('cat.sharePort')}</Label>
+                <PortInput
+                  value={catCfg.share_port || 4532}
+                  fallback={4532}
+                  onChange={(n) => setCatCfg((s) => ({ ...s, share_port: n }))}
+                />
+              </div>
+            )}
+          </div>
           {catCfg.backend === 'omnirig' && (
           <>
           <label className="flex items-center gap-2 text-sm cursor-pointer">
@@ -2543,11 +2666,6 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
           </p>
           </>
           )}
-          {catCfg.backend === 'flex' && (
-            <p className="text-xs text-muted-foreground">
-              {t('cat.flexHint')}
-            </p>
-          )}
         </div>
       </>
     );
@@ -3191,6 +3309,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                   <SelectItem value="winkeyer">{t('wk.engWinkeyer')}</SelectItem>
                   <SelectItem value="serial">{t('wk.engSerial')}</SelectItem>
                   <SelectItem value="icom">{t('wk.engIcom')}</SelectItem>
+                  <SelectItem value="yaesu">{t('wk.engYaesu')}</SelectItem>
                   <SelectItem value="flex">{t('wk.engFlex')}</SelectItem>
                   <SelectItem value="tci" disabled>{t('wk.engTci')}</SelectItem>
                 </SelectContent>
@@ -3221,6 +3340,22 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                 </div>
               </div>
             </>
+          ) : wk.engine === 'yaesu' ? (
+            <>
+              {(!catCfg.enabled || catCfg.backend !== 'yaesu') && (
+                <p className="text-xs font-medium text-warning -mt-1 flex items-start gap-1.5">
+                  <span aria-hidden>⚠</span>
+                  <span>{t('wk.catWarnYaesu', { backend: catCfg.enabled ? (catCfg.backend || 'none') : 'disabled' })}</span>
+                </p>
+              )}
+              <p className="text-xs text-muted-foreground -mt-1">{t('wk.yaesuHint')}</p>
+              <div className="grid grid-cols-4 gap-3">
+                <div className="space-y-1">
+                  <Label>{t('wk.speed')}</Label>
+                  <Input type="number" min={4} max={60} value={wk.wpm} onChange={(e) => setWkField({ wpm: num(e.target.value, 25) })} className="font-mono" />
+                </div>
+              </div>
+            </>
           ) : wk.engine === 'flex' ? (
             <>
               {(!catCfg.enabled || catCfg.backend !== 'flex') && (
@@ -4714,6 +4849,8 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
       icom: t('cat.optIcom'),
       'icom-net': t('cat.optIcomNet'),
       tci: t('cat.optTci'),
+      yaesu: t('cat.optYaesu'),
+      xiegu: t('cat.optXiegu'),
     } as Record<string, string>)[catCfg.backend] ?? '';
 
     const deviceSelect = (
@@ -4887,6 +5024,19 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
               )}
             </div>
           </div>
+          {/* Playback level. Nothing else could raise it: the message went to the
+              rig exactly as recorded, so a quietly recorded mic drove the radio
+              quietly and the only remedies were the rig's own USB input menu or
+              the Windows mixer. */}
+          <div className="grid grid-cols-[auto_1fr] items-center gap-x-4 gap-y-2">
+            <Label className="text-sm">{t('aud.txLevel')}</Label>
+            <div className="flex items-center gap-2">
+              <input type="range" min={10} max={400} step={5} value={audioCfg.tx_gain}
+                onChange={(e) => setAudioField({ tx_gain: parseInt(e.target.value, 10) })} className="w-48 accent-primary" />
+              <span className="font-mono text-xs w-12 text-right">{audioCfg.tx_gain}%</span>
+            </div>
+          </div>
+          <p className="text-xs text-muted-foreground">{t('aud.txLevelHint')}</p>
           {dvkErr && <p className="text-[11px] text-destructive">{dvkErr}</p>}
           <div className="space-y-1.5">
             {dvkMsgs.map((m) => {
@@ -5012,7 +5162,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
           </label>
           <TelemetryToggle />
 
-          <MainViewPanes onChanged={onMainPaneChanged} flexAvailable={flexAvailable} icomAvailable={icomAvailable} />
+          <MainViewPanes onChanged={onMainPaneChanged} flexAvailable={flexAvailable} icomAvailable={icomAvailable} yaesuAvailable={yaesuAvailable} />
 
           <div className="border-t border-border/60 pt-4 space-y-2">
             <h4 className="text-sm font-semibold text-foreground">{t('gen.pwEnc')}</h4>

frontend/src/components/WinkeyerPanel.tsx

@@ -26,7 +26,7 @@ interface Props {
   wpm: number;
   macros: WKMacro[];
   sent: string; // text echoed back by the keyer as it transmits
-  source: 'winkeyer' | 'icom' | 'flex';      // CW output engine (chosen in Settings → CW Keyer)
+  source: 'winkeyer' | 'icom' | 'flex' | 'yaesu'; // CW output engine (chosen in Settings → CW Keyer)
   breakIn?: number;                          // Icom CW break-in: 0=OFF, 1=SEMI, 2=FULL
   onSetBreakIn?: (mode: number) => void;
   onSelectPort: (p: string) => void;
@@ -101,16 +101,18 @@ export function WinkeyerPanel({
         <Radio className="size-4 text-primary shrink-0" />
         {/* CW output engine (chosen in Settings → CW Keyer). */}
         <span className="text-xs font-semibold uppercase tracking-wider text-muted-foreground shrink-0">
-          {source === 'icom' ? 'Icom CW' : source === 'flex' ? 'Flex CWX' : 'WinKeyer'}
+          {source === 'icom' ? 'Icom CW' : source === 'flex' ? 'Flex CWX' : source === 'yaesu' ? 'Yaesu CW' : 'WinKeyer'}
         </span>
         <span className={cn('size-2 rounded-full', connected ? (status.busy ? 'bg-warning animate-pulse' : 'bg-success') : 'bg-muted-foreground/40')}
           title={connected ? (status.busy ? t('wkp.sending') : t('wkp.connectedV', { version: status.version })) : t('wkp.disconnected')} />
         <div className="flex-1" />
-        {source === 'icom' || source === 'flex' ? (
+        {source === 'icom' || source === 'flex' || source === 'yaesu' ? (
           <span className="text-[11px] font-medium text-muted-foreground">
             {source === 'flex'
               ? (connected ? t('wkp.cwxReady') : t('wkp.cwxOffline'))
-              : (connected ? t('wkp.civReady') : t('wkp.civOffline'))}
+              : source === 'yaesu'
+                ? (connected ? t('wkp.rigReady') : t('wkp.rigOffline'))
+                : (connected ? t('wkp.civReady') : t('wkp.civOffline'))}
           </span>
         ) : !connected ? (
           <>

frontend/src/components/YaesuPanel.tsx

@@ -0,0 +1,501 @@
+import { useEffect, useRef, useState } from 'react';
+import { Radio, AudioLines, Mic, Activity, SlidersHorizontal, Antenna } from 'lucide-react';
+import {
+  GetYaesuState, RefreshYaesuPanel,
+  SetYaesuPower, SetYaesuMicGain, SetYaesuAFGain, SetYaesuRFGain, SetYaesuSquelch,
+  SetYaesuAGC, SetYaesuPreamp, SetYaesuAtt, SetYaesuNB, SetYaesuNR, SetYaesuNRLevel,
+  SetYaesuNarrow, SetYaesuVOX, SetYaesuSplit, SetYaesuBand, TuneYaesuATU,
+  SetYaesuModeRaw, SetYaesuSplitOffset, SetYaesuKeySpeed, SetYaesuBreakIn, YaesuZeroIn, GetCATState,
+} from '../../wailsjs/go/main/App';
+import { cn } from '@/lib/utils';
+import { useI18n } from '@/lib/i18n';
+import { sMeterRST } from '@/lib/rst';
+import { MeterBar } from '@/components/MeterBar';
+
+type YaesuState = {
+  available: boolean; model?: string; mode?: string; raw_mode?: string;
+  transmitting: boolean; split: boolean;
+  s_meter: number; power_meter: number; swr_meter: number;
+  rf_power: number; mic_gain: number; af_gain: number; rf_gain: number; squelch: number;
+  agc?: string; preamp: number; att: number;
+  nb: boolean; nr: boolean; nr_level: number; narrow: boolean; vox: boolean;
+  split_tx_hz?: number; key_speed?: number; break_in?: boolean; swr?: number; power_w?: number;
+};
+
+const ZERO: YaesuState = {
+  available: false, transmitting: false, split: false,
+  s_meter: 0, power_meter: 0, swr_meter: 0,
+  rf_power: 0, mic_gain: 0, af_gain: 0, rf_gain: 0, squelch: 0,
+  preamp: 0, att: 0, nb: false, nr: false, nr_level: 0, narrow: false, vox: false,
+};
+
+// Band buttons use the rig's OWN band memory (CAT "BS"), not a frequency we
+// choose: pressing 20 m lands where the operator last was on 20 m, which is what
+// the radio's own band keys do. That is why these are band names, not Hz.
+const BANDS = ['160m', '80m', '40m', '30m', '20m', '17m', '15m', '12m', '10m', '6m'];
+
+// Mode buttons. CW, RTTY, DIGI and PSK exist on BOTH sidebands on a Yaesu and
+// the operator is the one who knows which they want, so each shows its sideband
+// and CLICKING AN ACTIVE BUTTON AGAIN flips it: CW-U → CW-L → CW-U. One button,
+// one finger, no hidden gesture. SSB takes its sideband from the frequency, as
+// the band plan dictates, and AM/FM have none.
+//
+// PSK rides on the rig's DATA mode, like the other digital modes — the button
+// exists because the operator thinks in modes, not in what the radio calls them.
+type ModeBtn = { id: string; label: string; sideband: boolean; rig: (side: 'U' | 'L') => string };
+const MODES: ModeBtn[] = [
+  { id: 'SSB', label: 'SSB', sideband: false, rig: () => 'SSB' },
+  { id: 'CW', label: 'CW', sideband: true, rig: (s) => 'CW-' + s },
+  { id: 'RTTY', label: 'RTTY', sideband: true, rig: (s) => 'RTTY-' + s },
+  { id: 'DIGI', label: 'DIGI', sideband: true, rig: (s) => 'DATA-' + s },
+  { id: 'PSK', label: 'PSK', sideband: true, rig: (s) => 'DATA-' + s },
+  { id: 'AM', label: 'AM', sideband: false, rig: () => 'AM' },
+  { id: 'FM', label: 'FM', sideband: false, rig: () => 'FM' },
+];
+
+// Which button the rig's current raw mode belongs to, and on which sideband.
+function activeMode(raw?: string): { id: string; side: 'U' | 'L' } | null {
+  switch ((raw || '').toUpperCase()) {
+    case 'USB': return { id: 'SSB', side: 'U' };
+    case 'LSB': return { id: 'SSB', side: 'L' };
+    case 'CW-U': return { id: 'CW', side: 'U' };
+    case 'CW-L': return { id: 'CW', side: 'L' };
+    case 'RTTY-U': return { id: 'RTTY', side: 'U' };
+    case 'RTTY-L': return { id: 'RTTY', side: 'L' };
+    case 'DATA-U': return { id: 'DIGI', side: 'U' };
+    case 'DATA-L': return { id: 'DIGI', side: 'L' };
+    case 'AM': return { id: 'AM', side: 'U' };
+    case 'FM': return { id: 'FM', side: 'U' };
+  }
+  return null;
+}
+
+// The FTDX10/FTDX101 preamp is a three-way front-end selector, not an on/off:
+// IPO bypasses the preamp entirely (best on a quiet, high-signal band), AMP1 and
+// AMP2 add gain. Presenting it as a toggle would hide the middle position.
+const PREAMPS = [{ v: '0', l: 'IPO' }, { v: '1', l: 'AMP1' }, { v: '2', l: 'AMP2' }];
+const AGCS = [{ v: 'FAST', l: 'FAST' }, { v: 'MID', l: 'MID' }, { v: 'SLOW', l: 'SLOW' }, { v: 'AUTO', l: 'AUTO' }];
+// The attenuator is a three-step pad on these rigs (6/12/18 dB), not a toggle.
+const ATTS = [{ v: '0', l: 'OFF' }, { v: '6', l: '6dB' }, { v: '12', l: '12dB' }, { v: '18', l: '18dB' }];
+
+function fmtVFO(hz?: number): string {
+  if (!hz || hz <= 0) return '––.–––.––';
+  const mhz = Math.floor(hz / 1_000_000);
+  const khz = Math.floor((hz % 1_000_000) / 1000);
+  const h2 = Math.floor((hz % 1000) / 10);
+  return `${mhz}.${String(khz).padStart(3, '0')}.${String(h2).padStart(2, '0')}`;
+}
+
+function bandOfHz(hz?: number): string {
+  if (!hz || hz <= 0) return '';
+  const mhz = hz / 1_000_000;
+  const bands: [string, number, number][] = [
+    ['160m', 1.8, 2.0], ['80m', 3.5, 4.0], ['60m', 5.25, 5.45], ['40m', 7.0, 7.3],
+    ['30m', 10.1, 10.15], ['20m', 14.0, 14.35], ['17m', 18.068, 18.168],
+    ['15m', 21.0, 21.45], ['12m', 24.89, 24.99], ['10m', 28.0, 29.7], ['6m', 50.0, 54.0],
+  ];
+  for (const [name, lo, hi] of bands) if (mhz >= lo && mhz <= hi) return name;
+  return '';
+}
+
+
+// Split the 0-100 S-meter reading into S units + dB over S9.
+//
+// The FTDX10 answers SM0 on a 0-255 scale and its manual does not say where S9
+// falls; the front panel puts it at roughly half travel, which is the 50 used
+// here. That figure is a HYPOTHESIS — if reports come out consistently one S
+// unit off on a radio, this is the number to correct, not the RST helper.
+const S9_PCT = 50;          // where S9 falls on the 0-100 reading (see above)
+const DB_PER_PCT = 60 / 50; // above S9 the scale runs to roughly +60 dB
+
+function sParts(v: number): { s: number; over: number; label: string } {
+  if (v >= S9_PCT) {
+    const over = Math.max(0, Math.round((v - S9_PCT) * DB_PER_PCT));
+    return { s: 9, over, label: over > 0 ? `S9+${over}` : 'S9' };
+  }
+  const s = Math.max(0, Math.min(9, Math.round(v / (S9_PCT / 9))));
+  return { s, over: 0, label: `S${s}` };
+}
+
+// Segment colour, the way a radio's own meter is printed: green up to S9, amber
+// through the S9+ range, red once the signal is strong enough to be reported as
+// 59+20 or more. Derived from the SAME S9 point as the label, so the colour
+// change always lands exactly where the numbers say it should — if the S9 point
+// is ever corrected, the colours follow on their own.
+const RED_OVER_DB = 20;
+function sSegColor(frac: number): string {
+  const pct = frac * 100;
+  if (pct < S9_PCT) return '#16a34a';
+  if ((pct - S9_PCT) * DB_PER_PCT < RED_OVER_DB) return '#f59e0b';
+  return '#dc2626';
+}
+
+function Slider({ value, onChange, disabled, accent = 'var(--primary)', min = 0, max = 100 }: {
+  value: number; onChange: (v: number) => void; disabled?: boolean; accent?: string; min?: number; max?: number;
+}) {
+  const v = Math.max(min, Math.min(max, value));
+  const pct = max > min ? ((v - min) / (max - min)) * 100 : 0;
+  const ref = useRef<HTMLInputElement>(null);
+  // React's onWheel is passive, so preventDefault is ignored there — attach a
+  // native non-passive listener, and read live values through refs so the
+  // handler never closes over a stale value.
+  const valRef = useRef(value); valRef.current = value;
+  const cbRef = useRef(onChange); cbRef.current = onChange;
+  const disRef = useRef(disabled); disRef.current = disabled;
+  const minRef = useRef(min); minRef.current = min;
+  const maxRef = useRef(max); maxRef.current = max;
+  useEffect(() => {
+    const el = ref.current;
+    if (!el) return;
+    const onWheel = (e: WheelEvent) => {
+      if (disRef.current) return;
+      e.preventDefault();
+      const nv = Math.max(minRef.current, Math.min(maxRef.current, valRef.current + (e.deltaY < 0 ? 1 : -1)));
+      if (nv !== valRef.current) cbRef.current(nv);
+    };
+    el.addEventListener('wheel', onWheel, { passive: false });
+    return () => el.removeEventListener('wheel', onWheel);
+  }, []);
+  return (
+    <input
+      ref={ref}
+      type="range" min={min} max={max} value={v} disabled={disabled}
+      onChange={(e) => onChange(parseInt(e.target.value, 10))}
+      className={cn('flex-1 h-2 rounded-full appearance-none cursor-pointer disabled:opacity-40 disabled:cursor-default',
+        '[&::-webkit-slider-thumb]:appearance-none [&::-webkit-slider-thumb]:size-4 [&::-webkit-slider-thumb]:rounded-full',
+        '[&::-webkit-slider-thumb]:bg-background [&::-webkit-slider-thumb]:border-2 [&::-webkit-slider-thumb]:shadow',
+        '[&::-webkit-slider-thumb]:cursor-grab [&::-webkit-slider-thumb]:active:cursor-grabbing')}
+      // The filled side was invisible against the dark theme: --muted is barely
+      // lighter than the card it sits on, so the whole track read as one bar.
+      // An explicit translucent track keeps both halves distinct in either theme.
+      style={{
+        background: `linear-gradient(to right, ${accent} 0%, ${accent} ${pct}%, color-mix(in srgb, var(--foreground) 18%, transparent) ${pct}%, color-mix(in srgb, var(--foreground) 18%, transparent) 100%)`,
+        borderColor: accent,
+      }}
+    />
+  );
+}
+
+function Segmented({ value, options, onChange }: {
+  value: string; options: { v: string; l: string }[]; onChange: (v: string) => void;
+}) {
+  return (
+    <div className="inline-flex rounded-md border border-border overflow-hidden shrink-0">
+      {options.map((o) => (
+        <button key={o.v} type="button" onClick={() => onChange(o.v)}
+          className={cn('px-2 py-1 text-[11px] font-bold tracking-wide transition-colors border-l border-border first:border-l-0',
+            value === o.v ? 'bg-primary text-primary-foreground' : 'bg-card text-muted-foreground hover:bg-muted')}>
+          {o.l}
+        </button>
+      ))}
+    </div>
+  );
+}
+
+function Chip({ on, onClick, label, title }: { on: boolean; onClick: () => void; label: string; title?: string }) {
+  return (
+    <button type="button" onClick={onClick} title={title}
+      className={cn('shrink-0 px-2 py-1 rounded-md text-[11px] font-bold border transition-colors',
+        on ? 'bg-success border-success text-success-foreground' : 'bg-card text-muted-foreground border-border hover:bg-muted')}>
+      {label}
+    </button>
+  );
+}
+
+function Card({ icon: Icon, title, accent, children }: { icon: any; title: string; accent?: string; children: React.ReactNode }) {
+  return (
+    <div className="rounded-xl border border-border bg-card shadow-sm overflow-hidden">
+      <div className="flex items-center gap-2 px-3 py-2 border-b border-border/60 bg-muted/30">
+        <Icon className="size-4" style={{ color: accent ?? 'var(--primary)' }} />
+        <span className="text-xs font-bold uppercase tracking-wider text-foreground/80">{title}</span>
+      </div>
+      <div className="p-3 space-y-3">{children}</div>
+    </div>
+  );
+}
+
+function Row({ label, children }: { label: string; children: React.ReactNode }) {
+  return (
+    <div className="flex items-center gap-2">
+      <span className="w-16 shrink-0 text-[11px] font-bold uppercase tracking-wider text-muted-foreground">{label}</span>
+      {children}
+    </div>
+  );
+}
+
+export function YaesuPanel({ onReportRST, onKeySpeed }: {
+  onReportRST?: (rst: string) => void;
+  // Told whenever the operator moves the CW speed here, so the app can keep the
+  // keyer that is ACTUALLY sending in step. With DTR/RTS line keying the PC does
+  // the timing and the rig's internal keyer speed changes nothing audible — the
+  // slider looked broken because it was driving the wrong keyer.
+  onKeySpeed?: (wpm: number) => void;
+}) {
+  const { t } = useI18n();
+  const [st, setSt] = useState<YaesuState>(ZERO);
+  // The frequency being LISTENED to. RigState follows ADIF, where freq_hz is the
+  // TRANSMIT frequency — under split that is the other VFO, so taking it as the
+  // main display showed the operator the frequency they transmit on and an
+  // offset of 0 kHz against itself.
+  const [freqHz, setFreqHz] = useState(0);
+  const [txHz, setTxHz] = useState(0);
+  const [err, setErr] = useState('');
+
+  // Optimistic local values for the sliders. Without them a drag fights the
+  // poll: the rig's older reading arrives mid-gesture and yanks the thumb back.
+  const [local, setLocal] = useState<Partial<YaesuState>>({});
+  const localAtRef = useRef(0);
+
+  useEffect(() => {
+    let alive = true;
+    const tick = async () => {
+      try {
+        const s = (await GetYaesuState()) as YaesuState;
+        const c = await GetCATState();
+        if (!alive) return;
+        setSt(s);
+        const cs = c as any;
+        const tx = cs?.freq_hz ?? 0;
+        const rx = cs?.split && cs?.freq_rx_hz > 0 ? cs.freq_rx_hz : tx;
+        setFreqHz(rx);
+        setTxHz(tx);
+        // Drop the optimistic overlay once the rig has had time to answer with
+        // the new value — 1.2 s covers the slow-beat settings read.
+        if (Date.now() - localAtRef.current > 1200) setLocal({});
+        setErr('');
+      } catch (e: any) {
+        if (alive) setErr(String(e?.message ?? e));
+      }
+    };
+    tick();
+    const id = window.setInterval(tick, 400);
+    return () => { alive = false; window.clearInterval(id); };
+  }, []);
+
+  const view = { ...st, ...local };
+
+  // Every setter follows the same shape: show the value at once, remember when,
+  // and let the poll take over. A rejected command surfaces as an error rather
+  // than as a control that silently springs back.
+  function push<K extends keyof YaesuState>(key: K, value: YaesuState[K], fn: () => Promise<void>) {
+    setLocal((l) => ({ ...l, [key]: value }));
+    localAtRef.current = Date.now();
+    fn().catch((e) => setErr(String(e?.message ?? e)));
+  }
+
+  const band = bandOfHz(freqHz);
+  // CW changes what belongs on the panel: no microphone, no VOX, but a keyer
+  // speed, break-in and ZIN. Driven by the RIG's mode, not the logged one.
+  const isCW = (view.raw_mode || '').toUpperCase().startsWith('CW');
+
+  if (!st.available) {
+    return (
+      <div className="h-full w-full flex items-center justify-center p-6 text-center">
+        <div className="space-y-1">
+          <Radio className="size-8 mx-auto text-muted-foreground/50" />
+          <p className="text-sm text-muted-foreground">{t('yaesu.notConnected')}</p>
+          {err && <p className="text-xs text-destructive">{err}</p>}
+        </div>
+      </div>
+    );
+  }
+
+  return (
+    <div className="h-full min-h-0 overflow-auto bg-background">
+      {/* Same wrapper as the Icom and Flex panels: capped width, CENTRED. Capping
+          it without mx-auto left the console pinned to the left edge with a
+          window of empty space beside it. */}
+      <div className="max-w-5xl mx-auto p-3 space-y-3">
+      {/* VFO + status */}
+      <div className="rounded-xl border border-border bg-card shadow-sm px-4 py-3 flex items-center justify-between gap-3 flex-wrap">
+        <div>
+          <div className="text-[10px] font-bold uppercase tracking-wider text-muted-foreground">{st.model || 'Yaesu'}</div>
+          <div className="text-2xl font-mono tabular-nums font-bold">{fmtVFO(freqHz)}</div>
+          {view.split && txHz > 0 && (
+            <div className="text-[11px] font-mono tabular-nums text-warning">
+              {t('yaesu.txOn')} {fmtVFO(txHz)}
+              {freqHz > 0 ? ' (' + (txHz > freqHz ? '+' : '') + Math.round((txHz - freqHz) / 100) / 10 + ' kHz)' : ''}
+            </div>
+          )}
+        </div>
+        <div className="flex items-center gap-2">
+          {st.transmitting && (
+            <span className="px-2 py-1 rounded-md text-[11px] font-bold bg-destructive text-destructive-foreground">TX</span>
+          )}
+          <Chip on={view.split} onClick={() => push('split', !view.split, () => SetYaesuSplit(!view.split))} label="SPLIT" />
+          {/* The usual pile-up offsets. Which one is idiomatic depends on the
+              mode — up 5 on phone, up 1 on CW — so both are offered rather than
+              guessed, and each turns split on in the same action. */}
+          <button type="button" onClick={() => SetYaesuSplitOffset(1000).catch((e) => setErr(String(e?.message ?? e)))}
+            title={t('yaesu.splitUpHint')}
+            className="px-2 py-1 rounded-md text-[11px] font-bold border border-border bg-card text-muted-foreground hover:bg-muted">+1k</button>
+          <button type="button" onClick={() => SetYaesuSplitOffset(5000).catch((e) => setErr(String(e?.message ?? e)))}
+            title={t('yaesu.splitUpHint')}
+            className="px-2 py-1 rounded-md text-[11px] font-bold border border-border bg-card text-muted-foreground hover:bg-muted">+5k</button>
+          <button type="button" onClick={() => TuneYaesuATU().catch((e) => setErr(String(e?.message ?? e)))}
+            title={t('yaesu.tuneHint')}
+            className="px-2 py-1 rounded-md text-[11px] font-bold border border-border bg-card text-muted-foreground hover:bg-muted">
+            TUNE
+          </button>
+        </div>
+      </div>
+
+      {err && <p className="text-xs text-destructive px-1">{err}</p>}
+
+      {/* Meters — the SHARED MeterBar the Flex and Icom panels use, so the three
+          consoles read alike instead of each having its own instrument style. */}
+      <Card icon={Activity} title={t('yaesu.meters')}>
+        <div className="grid grid-cols-1 sm:grid-cols-3 gap-2">
+          <MeterBar label="S-METER" value={view.s_meter} lo={0} hi={100} accent="#16a34a" segColor={sSegColor}
+            display={sParts(view.s_meter).label}
+            onClick={onReportRST ? () => { const sp = sParts(view.s_meter); onReportRST(sMeterRST(sp.s, sp.over, view.mode)); } : undefined}
+            title={onReportRST ? t('yaesu.sToRst') : undefined} />
+          {/* Watts as MEASURED, not the power setting scaled by a percentage:
+              the setting says what was asked for, the meter says what left. */}
+          <MeterBar label="PWR" value={view.transmitting ? (view.power_w ?? 0) : 0} unit="W" lo={0} hi={Math.max(100, view.rf_power || 100)} accent="#0ea5e9"
+            display={view.transmitting ? Math.round(view.power_w ?? 0) + 'W' : '—'} />
+          {/* The RATIO, as the rig shows it — a percentage of meter travel is
+              not something an operator can act on. The bar keeps the travel. */}
+          <MeterBar label="SWR" value={view.transmitting ? view.swr_meter : 0} lo={0} hi={100} accent="#f59e0b"
+            display={view.transmitting ? (view.swr && view.swr >= 1 ? view.swr.toFixed(1) : '1.0') : '—'} />
+        </div>
+      </Card>
+
+      {/* Bands + modes */}
+      <Card icon={Antenna} title={t('yaesu.bandMode')}>
+        <div className="flex flex-wrap gap-1">
+          {BANDS.map((b) => (
+            <button key={b} type="button"
+              onClick={() => SetYaesuBand(b).catch((e) => setErr(String(e?.message ?? e)))}
+              className={cn('px-2 py-1 rounded-md text-[11px] font-bold border transition-colors',
+                band === b ? 'bg-primary border-primary text-primary-foreground' : 'bg-card text-muted-foreground border-border hover:bg-muted')}>
+              {b.replace('m', '')}
+            </button>
+          ))}
+        </div>
+        <div className="flex flex-wrap gap-1">
+          {MODES.map((m) => {
+            const act = activeMode(view.raw_mode);
+            const on = act?.id === m.id;
+            // The sideband shown is the rig's when this mode is active, else the
+            // one the band plan implies — so a button says what pressing it will
+            // actually do rather than a stale letter.
+            const side: 'U' | 'L' = on && act ? act.side : (freqHz > 0 && freqHz < 10_000_000 ? 'L' : 'U');
+            const flip: 'U' | 'L' = side === 'U' ? 'L' : 'U';
+            return (
+              <button key={m.id} type="button"
+                onClick={() => {
+                  // Already on this mode → the click means "the other sideband".
+                  const target = m.id === 'SSB'
+                    ? (freqHz > 0 && freqHz < 10_000_000 ? 'LSB' : 'USB')
+                    : m.rig(on && m.sideband ? flip : side);
+                  SetYaesuModeRaw(target).catch((e) => setErr(String(e?.message ?? e)));
+                }}
+                title={m.sideband ? t('yaesu.sidebandHint') : undefined}
+                className={cn('px-2 py-1 rounded-md text-[11px] font-bold border transition-colors',
+                  on ? 'bg-primary border-primary text-primary-foreground' : 'bg-card text-muted-foreground border-border hover:bg-muted')}>
+                {m.sideband ? m.label + '-' + side : m.label}
+              </button>
+            );
+          })}
+        </div>
+      </Card>
+
+      {/* Receive */}
+      <Card icon={AudioLines} title={t('yaesu.receive')}>
+        <Row label="AF">
+          <Slider value={view.af_gain} onChange={(v) => push('af_gain', v, () => SetYaesuAFGain(v))} />
+          <span className="w-8 text-right text-xs font-mono tabular-nums text-muted-foreground">{view.af_gain}</span>
+        </Row>
+        <Row label="RF">
+          <Slider value={view.rf_gain} onChange={(v) => push('rf_gain', v, () => SetYaesuRFGain(v))} />
+          <span className="w-8 text-right text-xs font-mono tabular-nums text-muted-foreground">{view.rf_gain}</span>
+        </Row>
+        <Row label="SQL">
+          <Slider value={view.squelch} onChange={(v) => push('squelch', v, () => SetYaesuSquelch(v))} />
+          <span className="w-8 text-right text-xs font-mono tabular-nums text-muted-foreground">{view.squelch}</span>
+        </Row>
+        <Row label="AGC">
+          <Segmented value={view.agc ?? 'AUTO'} options={AGCS} onChange={(v) => push('agc', v, () => SetYaesuAGC(v))} />
+        </Row>
+        <Row label="FRONT">
+          <Segmented value={String(view.preamp)} options={PREAMPS} onChange={(v) => push('preamp', parseInt(v, 10), () => SetYaesuPreamp(parseInt(v, 10)))} />
+        </Row>
+        <Row label="ATT">
+          <Segmented value={String(view.att)} options={ATTS} onChange={(v) => push('att', parseInt(v, 10), () => SetYaesuAtt(parseInt(v, 10)))} />
+        </Row>
+      </Card>
+
+      {/* Noise + filter */}
+      <Card icon={SlidersHorizontal} title={t('yaesu.noiseFilter')}>
+        <div className="flex items-center gap-2 flex-wrap">
+          <Chip on={view.nb} onClick={() => push('nb', !view.nb, () => SetYaesuNB(!view.nb))} label="NB" />
+          <Chip on={view.nr} onClick={() => push('nr', !view.nr, () => SetYaesuNR(!view.nr))} label="DNR" />
+          <Chip on={view.narrow} onClick={() => push('narrow', !view.narrow, () => SetYaesuNarrow(!view.narrow))} label="NAR" />
+        </div>
+        <Row label="DNR">
+          {/* 1-15 on the rig, shown as-is rather than rescaled to a percentage:
+              the radio's own display counts 1-15, and matching it is what makes
+              the panel readable next to the front panel. */}
+          <Slider value={view.nr_level || 1} min={1} max={15} disabled={!view.nr}
+            onChange={(v) => push('nr_level', v, () => SetYaesuNRLevel(v))} />
+          <span className="w-8 text-right text-xs font-mono tabular-nums text-muted-foreground">{view.nr_level || 1}</span>
+        </Row>
+      </Card>
+
+      {/* Transmit */}
+      <Card icon={Mic} title={t('yaesu.transmit')}>
+        <Row label="PWR">
+          {/* Watts, not a percentage: the rig reports and takes watts, and a
+              percentage would be a second unit to reconcile every time. */}
+          <Slider value={view.rf_power || 5} min={5} max={100} accent="var(--destructive)"
+            onChange={(v) => push('rf_power', v, () => SetYaesuPower(v))} />
+          <span className="w-10 text-right text-xs font-mono tabular-nums text-muted-foreground">{view.rf_power}W</span>
+        </Row>
+        {/* Microphone gain and VOX are meaningless in CW — the rig ignores both
+            — so they are hidden rather than shown as dead controls. */}
+        {!isCW && (
+          <>
+            <Row label="MIC">
+              <Slider value={view.mic_gain} onChange={(v) => push('mic_gain', v, () => SetYaesuMicGain(v))} />
+              <span className="w-8 text-right text-xs font-mono tabular-nums text-muted-foreground">{view.mic_gain}</span>
+            </Row>
+            <Row label="VOX">
+              <Chip on={view.vox} onClick={() => push('vox', !view.vox, () => SetYaesuVOX(!view.vox))} label="VOX" />
+            </Row>
+          </>
+        )}
+        <Row label="">
+          <button type="button" onClick={() => RefreshYaesuPanel().catch((e) => setErr(String(e?.message ?? e)))}
+            className="ml-auto px-2 py-1 rounded-md text-[11px] font-bold border border-border bg-card text-muted-foreground hover:bg-muted">
+            {t('yaesu.refresh')}
+          </button>
+        </Row>
+      </Card>
+
+      {/* CW — only in CW, where these replace the phone controls above. */}
+      {isCW && (
+        <Card icon={Radio} title={t('yaesu.cw')}>
+          <Row label="SPEED">
+            <Slider value={view.key_speed || 20} min={4} max={60} accent="var(--primary)"
+              onChange={(v) => { push('key_speed', v, () => SetYaesuKeySpeed(v)); onKeySpeed?.(v); }} />
+            <span className="w-12 text-right text-xs font-mono tabular-nums text-muted-foreground">{view.key_speed || 20} wpm</span>
+          </Row>
+          <div className="flex items-center gap-2 flex-wrap">
+            <Chip on={!!view.break_in} onClick={() => push('break_in', !view.break_in, () => SetYaesuBreakIn(!view.break_in))}
+              label="BK-IN" title={t('yaesu.breakInHint')} />
+            {/* ZIN is a one-shot: the rig retunes so the station being received
+                lands on the operator's own CW pitch. Not a toggle, so it is a
+                plain button rather than a chip that would look latched. */}
+            <button type="button" onClick={() => YaesuZeroIn().catch((e) => setErr(String(e?.message ?? e)))}
+              title={t('yaesu.zinHint')}
+              className="px-2 py-1 rounded-md text-[11px] font-bold border border-border bg-card text-muted-foreground hover:bg-muted">
+              ZIN
+            </button>
+          </div>
+        </Card>
+      )}
+      </div>
+    </div>
+  );
+}

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

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

@@ -499,6 +499,8 @@ export function GetWinkeyerSettings():Promise<main.WinkeyerSettings>;
 
 export function GetWinkeyerStatus():Promise<winkeyer.Status>;
 
+export function GetYaesuState():Promise<cat.YaesuTXState>;
+
 export function HasBuiltinReferences(arg1:string):Promise<boolean>;
 
 export function IcomRefresh():Promise<void>;
@@ -755,6 +757,8 @@ export function RefreshCtyDat():Promise<main.CtyDatInfo>;
 
 export function RefreshSolar():Promise<void>;
 
+export function RefreshYaesuPanel():Promise<void>;
+
 export function ReloadUDPIntegrations():Promise<Array<string>>;
 
 export function RemovePassphrase(arg1:string):Promise<void>;
@@ -911,6 +915,44 @@ export function SetUltrabeamDirection(arg1:number):Promise<void>;
 
 export function SetWinkeyerTrace(arg1:boolean):Promise<void>;
 
+export function SetYaesuAFGain(arg1:number):Promise<void>;
+
+export function SetYaesuAGC(arg1:string):Promise<void>;
+
+export function SetYaesuAtt(arg1:number):Promise<void>;
+
+export function SetYaesuBand(arg1:string):Promise<void>;
+
+export function SetYaesuBreakIn(arg1:boolean):Promise<void>;
+
+export function SetYaesuKeySpeed(arg1:number):Promise<void>;
+
+export function SetYaesuMicGain(arg1:number):Promise<void>;
+
+export function SetYaesuModeRaw(arg1:string):Promise<void>;
+
+export function SetYaesuNB(arg1:boolean):Promise<void>;
+
+export function SetYaesuNR(arg1:boolean):Promise<void>;
+
+export function SetYaesuNRLevel(arg1:number):Promise<void>;
+
+export function SetYaesuNarrow(arg1:boolean):Promise<void>;
+
+export function SetYaesuPower(arg1:number):Promise<void>;
+
+export function SetYaesuPreamp(arg1:number):Promise<void>;
+
+export function SetYaesuRFGain(arg1:number):Promise<void>;
+
+export function SetYaesuSplit(arg1:boolean):Promise<void>;
+
+export function SetYaesuSplitOffset(arg1:number):Promise<void>;
+
+export function SetYaesuSquelch(arg1:number):Promise<void>;
+
+export function SetYaesuVOX(arg1:boolean):Promise<void>;
+
 export function StartCWDecoder():Promise<void>;
 
 export function StationSetRelay(arg1:string,arg2:number,arg3:boolean):Promise<void>;
@@ -947,6 +989,8 @@ export function TestStationDevice(arg1:main.StationDevice):Promise<main.StationT
 
 export function TestUltrabeam(arg1:main.UltrabeamSettings):Promise<void>;
 
+export function TuneYaesuATU():Promise<void>;
+
 export function TunerGeniusActivate(arg1:number):Promise<void>;
 
 export function TunerGeniusAutotune():Promise<void>;
@@ -990,3 +1034,9 @@ export function WinkeyerSetSpeed(arg1:number):Promise<void>;
 export function WinkeyerStop():Promise<void>;
 
 export function WorkedBefore(arg1:string,arg2:number):Promise<qso.WorkedBefore>;
+
+export function YaesuSendCW(arg1:string):Promise<void>;
+
+export function YaesuStopCW():Promise<void>;
+
+export function YaesuZeroIn():Promise<void>;

frontend/wailsjs/go/main/App.js

@@ -946,6 +946,10 @@ export function GetWinkeyerStatus() {
   return window['go']['main']['App']['GetWinkeyerStatus']();
 }
 
+export function GetYaesuState() {
+  return window['go']['main']['App']['GetYaesuState']();
+}
+
 export function HasBuiltinReferences(arg1) {
   return window['go']['main']['App']['HasBuiltinReferences'](arg1);
 }
@@ -1458,6 +1462,10 @@ export function RefreshSolar() {
   return window['go']['main']['App']['RefreshSolar']();
 }
 
+export function RefreshYaesuPanel() {
+  return window['go']['main']['App']['RefreshYaesuPanel']();
+}
+
 export function ReloadUDPIntegrations() {
   return window['go']['main']['App']['ReloadUDPIntegrations']();
 }
@@ -1770,6 +1778,82 @@ export function SetWinkeyerTrace(arg1) {
   return window['go']['main']['App']['SetWinkeyerTrace'](arg1);
 }
 
+export function SetYaesuAFGain(arg1) {
+  return window['go']['main']['App']['SetYaesuAFGain'](arg1);
+}
+
+export function SetYaesuAGC(arg1) {
+  return window['go']['main']['App']['SetYaesuAGC'](arg1);
+}
+
+export function SetYaesuAtt(arg1) {
+  return window['go']['main']['App']['SetYaesuAtt'](arg1);
+}
+
+export function SetYaesuBand(arg1) {
+  return window['go']['main']['App']['SetYaesuBand'](arg1);
+}
+
+export function SetYaesuBreakIn(arg1) {
+  return window['go']['main']['App']['SetYaesuBreakIn'](arg1);
+}
+
+export function SetYaesuKeySpeed(arg1) {
+  return window['go']['main']['App']['SetYaesuKeySpeed'](arg1);
+}
+
+export function SetYaesuMicGain(arg1) {
+  return window['go']['main']['App']['SetYaesuMicGain'](arg1);
+}
+
+export function SetYaesuModeRaw(arg1) {
+  return window['go']['main']['App']['SetYaesuModeRaw'](arg1);
+}
+
+export function SetYaesuNB(arg1) {
+  return window['go']['main']['App']['SetYaesuNB'](arg1);
+}
+
+export function SetYaesuNR(arg1) {
+  return window['go']['main']['App']['SetYaesuNR'](arg1);
+}
+
+export function SetYaesuNRLevel(arg1) {
+  return window['go']['main']['App']['SetYaesuNRLevel'](arg1);
+}
+
+export function SetYaesuNarrow(arg1) {
+  return window['go']['main']['App']['SetYaesuNarrow'](arg1);
+}
+
+export function SetYaesuPower(arg1) {
+  return window['go']['main']['App']['SetYaesuPower'](arg1);
+}
+
+export function SetYaesuPreamp(arg1) {
+  return window['go']['main']['App']['SetYaesuPreamp'](arg1);
+}
+
+export function SetYaesuRFGain(arg1) {
+  return window['go']['main']['App']['SetYaesuRFGain'](arg1);
+}
+
+export function SetYaesuSplit(arg1) {
+  return window['go']['main']['App']['SetYaesuSplit'](arg1);
+}
+
+export function SetYaesuSplitOffset(arg1) {
+  return window['go']['main']['App']['SetYaesuSplitOffset'](arg1);
+}
+
+export function SetYaesuSquelch(arg1) {
+  return window['go']['main']['App']['SetYaesuSquelch'](arg1);
+}
+
+export function SetYaesuVOX(arg1) {
+  return window['go']['main']['App']['SetYaesuVOX'](arg1);
+}
+
 export function StartCWDecoder() {
   return window['go']['main']['App']['StartCWDecoder']();
 }
@@ -1842,6 +1926,10 @@ export function TestUltrabeam(arg1) {
   return window['go']['main']['App']['TestUltrabeam'](arg1);
 }
 
+export function TuneYaesuATU() {
+  return window['go']['main']['App']['TuneYaesuATU']();
+}
+
 export function TunerGeniusActivate(arg1) {
   return window['go']['main']['App']['TunerGeniusActivate'](arg1);
 }
@@ -1929,3 +2017,15 @@ export function WinkeyerStop() {
 export function WorkedBefore(arg1, arg2) {
   return window['go']['main']['App']['WorkedBefore'](arg1, arg2);
 }
+
+export function YaesuSendCW(arg1) {
+  return window['go']['main']['App']['YaesuSendCW'](arg1);
+}
+
+export function YaesuStopCW() {
+  return window['go']['main']['App']['YaesuStopCW']();
+}
+
+export function YaesuZeroIn() {
+  return window['go']['main']['App']['YaesuZeroIn']();
+}

frontend/wailsjs/go/models.ts

@@ -1074,6 +1074,70 @@ export namespace cat {
 	        this.fixed = source["fixed"];
 	    }
 	}
+	export class YaesuTXState {
+	    available: boolean;
+	    model?: string;
+	    mode?: string;
+	    raw_mode?: string;
+	    transmitting: boolean;
+	    split: boolean;
+	    split_tx_hz: number;
+	    s_meter: number;
+	    power_meter: number;
+	    swr_meter: number;
+	    rf_power: number;
+	    mic_gain: number;
+	    af_gain: number;
+	    rf_gain: number;
+	    squelch: number;
+	    agc?: string;
+	    preamp: number;
+	    att: number;
+	    nb: boolean;
+	    nr: boolean;
+	    nr_level: number;
+	    narrow: boolean;
+	    swr: number;
+	    power_w: number;
+	    vox: boolean;
+	    key_speed: number;
+	    break_in: boolean;
+	
+	    static createFrom(source: any = {}) {
+	        return new YaesuTXState(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.available = source["available"];
+	        this.model = source["model"];
+	        this.mode = source["mode"];
+	        this.raw_mode = source["raw_mode"];
+	        this.transmitting = source["transmitting"];
+	        this.split = source["split"];
+	        this.split_tx_hz = source["split_tx_hz"];
+	        this.s_meter = source["s_meter"];
+	        this.power_meter = source["power_meter"];
+	        this.swr_meter = source["swr_meter"];
+	        this.rf_power = source["rf_power"];
+	        this.mic_gain = source["mic_gain"];
+	        this.af_gain = source["af_gain"];
+	        this.rf_gain = source["rf_gain"];
+	        this.squelch = source["squelch"];
+	        this.agc = source["agc"];
+	        this.preamp = source["preamp"];
+	        this.att = source["att"];
+	        this.nb = source["nb"];
+	        this.nr = source["nr"];
+	        this.nr_level = source["nr_level"];
+	        this.narrow = source["narrow"];
+	        this.swr = source["swr"];
+	        this.power_w = source["power_w"];
+	        this.vox = source["vox"];
+	        this.key_speed = source["key_speed"];
+	        this.break_in = source["break_in"];
+	    }
+	}
 
 }
 
@@ -1537,6 +1601,7 @@ export namespace main {
 	    format: string;
 	    from_gain: number;
 	    mic_gain: number;
+	    tx_gain: number;
 	
 	    static createFrom(source: any = {}) {
 	        return new AudioSettings(source);
@@ -1556,6 +1621,7 @@ export namespace main {
 	        this.format = source["format"];
 	        this.from_gain = source["from_gain"];
 	        this.mic_gain = source["mic_gain"];
+	        this.tx_gain = source["tx_gain"];
 	    }
 	}
 	export class AutostartLaunchResult {
@@ -1835,6 +1901,11 @@ export namespace main {
 	    flex_spots: boolean;
 	    flex_decode_spots: boolean;
 	    flex_decode_secs: number;
+	    xiegu_port: string;
+	    xiegu_baud: number;
+	    xiegu_addr: number;
+	    yaesu_port: string;
+	    yaesu_baud: number;
 	    icom_port: string;
 	    icom_baud: number;
 	    icom_addr: number;
@@ -1848,6 +1919,8 @@ export namespace main {
 	    poll_ms: number;
 	    delay_ms: number;
 	    digital_default: string;
+	    share_enabled: boolean;
+	    share_port: number;
 	
 	    static createFrom(source: any = {}) {
 	        return new CATSettings(source);
@@ -1864,6 +1937,11 @@ export namespace main {
 	        this.flex_spots = source["flex_spots"];
 	        this.flex_decode_spots = source["flex_decode_spots"];
 	        this.flex_decode_secs = source["flex_decode_secs"];
+	        this.xiegu_port = source["xiegu_port"];
+	        this.xiegu_baud = source["xiegu_baud"];
+	        this.xiegu_addr = source["xiegu_addr"];
+	        this.yaesu_port = source["yaesu_port"];
+	        this.yaesu_baud = source["yaesu_baud"];
 	        this.icom_port = source["icom_port"];
 	        this.icom_baud = source["icom_baud"];
 	        this.icom_addr = source["icom_addr"];
@@ -1877,6 +1955,8 @@ export namespace main {
 	        this.poll_ms = source["poll_ms"];
 	        this.delay_ms = source["delay_ms"];
 	        this.digital_default = source["digital_default"];
+	        this.share_enabled = source["share_enabled"];
+	        this.share_port = source["share_port"];
 	    }
 	}
 	export class CabrilloResult {

icom_models_test.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"os"
+	"regexp"
+	"strconv"
+	"testing"
+
+	"hamlog/internal/cat/civ"
+)
+
+// The Icom model picker in the settings and civ.ModelName are two hand-kept
+// copies of the same table, and they had drifted: the UI offered the IC-7700 at
+// 0x88 and the IC-7800 at 0x80, which are the IC-7100's and the IC-7410's
+// factory addresses. Picking either set an address the rig never answers on —
+// the symptom is a rig that simply never replies — and the backend then named it
+// as the other model.
+//
+// The list is read out of the .tsx itself, so a model added on one side alone
+// fails here rather than on someone's radio.
+func TestIcomModelAddressesMatch(t *testing.T) {
+	src, err := os.ReadFile("frontend/src/components/SettingsModal.tsx")
+	if err != nil {
+		t.Skipf("frontend source not available: %v", err)
+	}
+	re := regexp.MustCompile(`\{ name: '(IC-[A-Za-z0-9-]+)', addr: 0x([0-9A-Fa-f]{2}) \}`)
+	ms := re.FindAllStringSubmatch(string(src), -1)
+	if len(ms) < 5 {
+		t.Fatalf("only %d models found — the parse is wrong, not the data", len(ms))
+	}
+	for _, m := range ms {
+		name := m[1]
+		addr, err := strconv.ParseUint(m[2], 16, 8)
+		if err != nil {
+			t.Fatalf("bad address %q for %s", m[2], name)
+		}
+		if got := civ.ModelName(byte(addr)); got != name {
+			t.Errorf("settings offer %s at 0x%02X, but civ.ModelName(0x%02X) = %q",
+				name, addr, addr, got)
+		}
+	}
+}

internal/antgenius/antgenius.go

@@ -66,11 +66,12 @@ type Client struct {
 	authTries    int
 	ready        atomic.Bool // init commands sent → keepalive may run
 
-	statusMu sync.RWMutex
-	status   Status
-	antennas map[int]string // index → name (rebuilt into status.Antennas)
-	antBands map[int]int    // index → band bitmask (which bands the antenna covers)
-	antRawN  int            // one-shot: how many raw antenna lines we've logged
+	statusMu  sync.RWMutex
+	status    Status
+	antennas  map[int]string // index → name (rebuilt into status.Antennas)
+	antBands  map[int]int    // index → band bitmask (which bands the antenna covers)
+	antRawN   int            // one-shot: how many raw antenna lines we've logged
+	lastShown map[int]int    // port id → antenna last reported, so only CHANGES are logged
 
 	stop    chan struct{}
 	running bool
@@ -81,13 +82,14 @@ func New(host string, port int, password string) *Client {
 		port = defaultPort
 	}
 	return &Client{
-		host:     host,
-		port:     port,
-		password: strings.TrimSpace(password),
-		stop:     make(chan struct{}),
-		antennas: map[int]string{},
-		antBands: map[int]int{},
-		status:   Status{Host: host},
+		host:      host,
+		port:      port,
+		password:  strings.TrimSpace(password),
+		stop:      make(chan struct{}),
+		antennas:  map[int]string{},
+		antBands:  map[int]int{},
+		lastShown: map[int]int{},
+		status:    Status{Host: host},
 	}
 }
 
@@ -398,9 +400,27 @@ func (c *Client) parsePort(msg string) {
 	}
 	tx := kvInt(msg, "txant")
 	rx := kvInt(msg, "rxant")
-	active := tx
+	// The RX antenna is what identifies a port's selection, and it is the only
+	// thing Activate sets. Preferring the TX antenna made both ports converge on
+	// the same row a few seconds after a change: on an 8x2 only ONE port can hold
+	// the transmit antenna, so the device reports the same txant on both, and a
+	// port A genuinely on the 80 m vertical was redrawn as the beam that port B
+	// transmits through.
+	//
+	// TX remains the fallback for a port that reports no RX antenna at all.
+	active := rx
 	if active == 0 {
-		active = rx
+		active = tx
+	}
+	// Logged only when the shown antenna CHANGES: the device pushes port state
+	// every few seconds, and logging each one would bury everything else — but
+	// without any trace, "port A jumped to the wrong antenna" is unfalsifiable.
+	c.statusMu.Lock()
+	prev, seen := c.lastShown[id]
+	c.lastShown[id] = active
+	c.statusMu.Unlock()
+	if !seen || prev != active {
+		applog.Printf("antgenius: port %d → antenna %d (rxant=%d txant=%d) raw=%q", id, active, rx, tx, msg)
 	}
 	txOn := kvInt(msg, "tx") != 0 // the standalone "tx=0|1" transmit flag
 	c.setStatus(func(s *Status) {

internal/antgenius/port_test.go

@@ -0,0 +1,73 @@
+package antgenius
+
+import "testing"
+
+// Which antenna a port SHOWS.
+//
+// Reported on an 8x2: port A was correctly on the 80 m vertical, then a few
+// seconds later both A and B were drawn on the same beam. The cause is that only
+// ONE port can hold the transmit antenna, so the device reports the same txant
+// on both — and the display preferred txant. The RX antenna is the per-port
+// selection, and the only thing Activate sets, so it has to win.
+func TestPortShowsRXAntenna(t *testing.T) {
+	cases := []struct {
+		name     string
+		msg      string
+		wantPort int
+		wantAnt  int
+	}{
+		{
+			// The reported case: port A listening on antenna 2 while the shared TX
+			// antenna is 1. Before the fix this drew port A on antenna 1.
+			name:     "rx and tx disagree — rx wins",
+			msg:      "port 1 rxant=2 txant=1 tx=0",
+			wantPort: 1, wantAnt: 2,
+		},
+		{
+			name:     "they agree",
+			msg:      "port 2 rxant=3 txant=3 tx=0",
+			wantPort: 2, wantAnt: 3,
+		},
+		{
+			// A port with no RX antenna still shows something meaningful.
+			name:     "no rx antenna — fall back to tx",
+			msg:      "port 1 rxant=0 txant=4 tx=1",
+			wantPort: 1, wantAnt: 4,
+		},
+		{
+			name:     "nothing selected",
+			msg:      "port 2 rxant=0 txant=0 tx=0",
+			wantPort: 2, wantAnt: 0,
+		},
+	}
+	for _, c := range cases {
+		cl := New("host", 0, "")
+		cl.parsePort(c.msg)
+		st := cl.GetStatus()
+		got := st.PortA
+		if c.wantPort == 2 {
+			got = st.PortB
+		}
+		if got != c.wantAnt {
+			t.Errorf("%s: port %d shows antenna %d, want %d (%q)", c.name, c.wantPort, got, c.wantAnt, c.msg)
+		}
+	}
+}
+
+// The two ports must stay independent: a message about one must never move the
+// other, which is the shape the operator actually saw on screen.
+func TestPortsAreIndependent(t *testing.T) {
+	c := New("host", 0, "")
+	c.parsePort("port 1 rxant=2 txant=0 tx=0")
+	c.parsePort("port 2 rxant=1 txant=1 tx=1")
+	st := c.GetStatus()
+	if st.PortA != 2 {
+		t.Errorf("port A = %d, want 2 — port B's message moved it", st.PortA)
+	}
+	if st.PortB != 1 {
+		t.Errorf("port B = %d, want 1", st.PortB)
+	}
+	if !st.TxB || st.TxA {
+		t.Errorf("transmit flags crossed: TxA=%v TxB=%v", st.TxA, st.TxB)
+	}
+}

internal/audio/manager.go

@@ -104,11 +104,27 @@ func (m *Manager) IsPlaying() bool {
 
 // Play renders a WAV file to deviceID. Any current playback is stopped first.
 // Returns immediately; playback runs in the background.
-func (m *Manager) Play(deviceID, path string) error {
+// Play sends a recorded message to a device, amplified by gainPct (100 = as
+// recorded).
+//
+// The gain exists because nothing else could raise the level: the message went
+// out exactly as captured, so a mic recorded quietly drove the rig quietly and
+// the operator had no control anywhere in OpsLog — only the radio's own USB
+// input level, buried in its menus, and the Windows mixer.
+func (m *Manager) Play(deviceID, path string, gainPct int) error {
 	pcm, rate, ch, bits, err := readWAV(path)
 	if err != nil {
 		return err
 	}
+	if gainPct > 0 && gainPct != 100 && bits == 16 {
+		g := float64(gainPct) / 100
+		// In place: the buffer is this call's own copy of the file.
+		for i := 0; i+1 < len(pcm); i += 2 {
+			v := int16(uint16(pcm[i]) | uint16(pcm[i+1])<<8)
+			v = scalePCM(v, g)
+			pcm[i], pcm[i+1] = byte(uint16(v)), byte(uint16(v)>>8)
+		}
+	}
 	m.StopPlayback()
 	stop := make(chan struct{})
 	m.mu.Lock()
@@ -265,3 +281,16 @@ func (m *Manager) TXAudioActive() bool {
 	defer m.mu.Unlock()
 	return m.txStop != nil
 }
+
+// scalePCM applies a gain to one sample, clamping rather than wrapping — an
+// overflow that wraps turns loud speech into a burst of noise on the air.
+func scalePCM(s int16, g float64) int16 {
+	v := float64(s) * g
+	if v > 32767 {
+		return 32767
+	}
+	if v < -32768 {
+		return -32768
+	}
+	return int16(v)
+}

internal/cat/cat.go

@@ -845,3 +845,27 @@ func BandFromHz(hz int64) string {
 	}
 	return ""
 }
+
+// YaesuState returns the panel snapshot, or (zero, false) when the active
+// backend isn't a Yaesu — same shape as IcomState.
+func (m *Manager) YaesuState() (YaesuTXState, bool) {
+	m.mu.RLock()
+	b := m.backend
+	m.mu.RUnlock()
+	if yc, ok := b.(YaesuController); ok {
+		return yc.YaesuState(), true
+	}
+	return YaesuTXState{}, false
+}
+
+// YaesuDo dispatches a Yaesu control onto the CAT goroutine, so a panel click
+// and the poll loop never share the serial port at the same instant.
+func (m *Manager) YaesuDo(fn func(YaesuController) error) error {
+	return m.exec(func(b Backend) error {
+		yc, ok := b.(YaesuController)
+		if !ok {
+			return fmt.Errorf("active CAT backend is not a Yaesu")
+		}
+		return fn(yc)
+	})
+}

internal/cat/civ/civ.go

@@ -344,6 +344,8 @@ func ModelName(addr byte) string {
 		return "IC-9700"
 	case 0xA4:
 		return "IC-705"
+	case 0xB6:
+		return "IC-7300MKII"
 	}
 	return fmt.Sprintf("Icom (0x%02X)", addr)
 }

internal/cat/civ/civ_test.go

@@ -152,6 +152,7 @@ func TestModelNameAddresses(t *testing.T) {
 		0x98: "IC-7610",
 		0xA2: "IC-9700",
 		0xA4: "IC-705",
+		0xB6: "IC-7300MKII",
 	} {
 		if got := ModelName(addr); got != want {
 			t.Errorf("ModelName(0x%02X) = %q, want %q", addr, got, want)

internal/cat/icom_silence_test.go

@@ -0,0 +1,62 @@
+package cat
+
+import (
+	"testing"
+	"time"
+)
+
+// The rule that decides whether a silent-but-alive Icom network session is
+// tolerated or torn down. It was "always tolerate", and that is what froze the
+// frequency display for ever when another program took the CI-V session.
+//
+// The decision is pinned here rather than left implicit, because the two cases
+// it separates pull in opposite directions: a rig in standby must NOT be
+// reconnected every few seconds (the panel and its ON button would blink away),
+// while a hijacked session must recover without restarting OpsLog.
+func TestIcomSilenceTolerance(t *testing.T) {
+	// tolerate mirrors the condition in ReadState.
+	tolerate := func(alive, readerGone bool, lastGood time.Time, silentFor, grace time.Duration) bool {
+		return alive && !readerGone && (lastGood.IsZero() || silentFor < grace)
+	}
+	never := time.Time{}
+	some := time.Now()
+
+	cases := []struct {
+		name       string
+		alive      bool
+		readerGone bool
+		lastGood   time.Time
+		silentFor  time.Duration
+		want       bool
+	}{
+		{"never answered since connect — rig is off, keep the panel", true, false, never, time.Hour, true},
+		{"brief silence during a band change", true, false, some, 2 * time.Second, true},
+		{"silence past the grace — reconnect", true, false, some, icomSilentGrace + time.Second, false},
+		{"reader goroutine gone — dead however alive the link looks", true, true, some, time.Second, false},
+		{"control link itself dead", false, false, some, time.Second, false},
+	}
+	for _, c := range cases {
+		got := tolerate(c.alive, c.readerGone, c.lastGood, c.silentFor, icomSilentGrace)
+		if got != c.want {
+			t.Errorf("%s: tolerate = %v, want %v", c.name, got, c.want)
+		}
+	}
+}
+
+// The backoff must actually converge on the ceiling: a rig left switched off is
+// silent for hours, and a window that stayed at 30 s would re-tear its session
+// about a hundred times an hour.
+func TestIcomSilenceBackoff(t *testing.T) {
+	g := icomSilentGrace
+	for i := 0; i < 20; i++ {
+		if g < icomSilentGraceMax {
+			g *= 2
+		}
+	}
+	if g < icomSilentGraceMax {
+		t.Fatalf("backoff never reached the ceiling: %s < %s", g, icomSilentGraceMax)
+	}
+	if g > 2*icomSilentGraceMax {
+		t.Errorf("backoff overshot the ceiling: %s", g)
+	}
+}

internal/cat/icomserial.go

@@ -37,6 +37,19 @@ type aliveTransport interface {
 	Alive() bool
 }
 
+const (
+	// How long the network backend accepts "the control link answers but the rig
+	// sends no CI-V" before declaring the session lost. Long enough to cover a
+	// band change or a rig booting from standby; short enough that an operator
+	// whose CI-V session was stolen (WSJT-X via OmniRig, the Remote Utility) gets
+	// a live frequency back on his own rather than restarting OpsLog.
+	icomSilentGrace = 30 * time.Second
+	// Ceiling for the backoff applied when the silence persists — a rig switched
+	// OFF is silent for hours, and re-tearing its session every 30 s would blink
+	// the panel (and its ON button) away continuously.
+	icomSilentGraceMax = 4 * time.Minute
+)
+
 // scopeTransport is an OPTIONAL transport capability: deliver spectrum-scope
 // (0x27) frames on a SEPARATE channel from control replies. The network transport
 // implements it so the continuous panadapter stream can't crowd control replies
@@ -89,13 +102,17 @@ type IcomSerial struct {
 	scopeFixed bool // true = fixed-span mode (tracked optimistically)
 	scopeSeen  bool // logged the first sweep's structure once (on-rig verification)
 
-	curFreq     int64 // last frequency read (for sideband choice)
-	curModeByte byte  // last raw Icom mode byte (for filter re-send)
-	pollN       int   // ReadState cycle counter (staggers slow reads)
-	splitOn     bool  // last read split state (refreshed every few cycles)
-	splitTXFreq int64 // last read unselected/TX VFO freq while in split
-	readFails   int   // consecutive ReadState freq-read failures (transient tolerance)
-	dspLoaded   bool  // readDSP has run since the rig became responsive (loads all
+	curFreq     int64     // last frequency read (for sideband choice)
+	curModeByte byte      // last raw Icom mode byte (for filter re-send)
+	pollN       int       // ReadState cycle counter (staggers slow reads)
+	splitOn     bool      // last read split state (refreshed every few cycles)
+	splitTXFreq int64     // last read unselected/TX VFO freq while in split
+	readFails   int       // consecutive ReadState freq-read failures (transient tolerance)
+	lastGoodAt  time.Time // last SUCCESSFUL frequency read — bounds the network
+	//                       "alive but silent" tolerance below, which used to be
+	//                       unbounded and left the display frozen for ever
+	silentGrace time.Duration // current width of that tolerance (backs off, see ReadState)
+	dspLoaded   bool          // readDSP has run since the rig became responsive (loads all
 	//                     the panel's set-once controls once the rig actually answers)
 	lastSetFreq   int64 // last frequency commanded (spot click: freq then mode)
 	lastSetFreqAt time.Time
@@ -267,7 +284,34 @@ func (b *IcomSerial) ReadState() (RigState, error) {
 		// rig is switched on) rather than tearing the whole UDP session down and
 		// flapping every few seconds. The panel stays up so the ON button works.
 		if at, ok := b.port.(aliveTransport); ok {
-			if at.Alive() {
+			// The reader goroutine is what feeds every CI-V reply. If it has
+			// exited, no read can ever succeed again, however healthy the control
+			// link looks — that is not a silent rig, it is a dead connection.
+			readerGone := false
+			if b.readerDone != nil {
+				select {
+				case <-b.readerDone:
+					readerGone = true
+				default:
+				}
+			}
+			// "Alive but silent" is the rig in standby, or mid band-change. It was
+			// tolerated for ever, and that is the freeze: when ANOTHER program takes
+			// the CI-V session (WSJT-X through OmniRig, say) the rig keeps answering
+			// pings on the control stream while sending us no CI-V at all. Alive()
+			// stayed true, the cached frequency was re-published with a fresh
+			// timestamp on every poll, and the operator saw a confident, frozen
+			// number until OpsLog was restarted. Bounded now: past the grace period
+			// the error is reported so the Manager tears the session down and
+			// reconnects, which re-takes the CI-V stream.
+			silentFor := time.Duration(0)
+			if !b.lastGoodAt.IsZero() {
+				silentFor = time.Since(b.lastGoodAt)
+			}
+			if b.silentGrace <= 0 {
+				b.silentGrace = icomSilentGrace
+			}
+			if at.Alive() && !readerGone && (b.lastGoodAt.IsZero() || silentFor < b.silentGrace) {
 				b.readFails = 0
 				s.FreqHz = b.curFreq // 0 until the rig is powered on and first read
 				if b.curModeByte != 0 {
@@ -286,8 +330,25 @@ func (b *IcomSerial) ReadState() (RigState, error) {
 				b.dspMu.Unlock()
 				return s, nil
 			}
-			debugLog.Printf("icom net: control link went quiet (no rig packets for >6 s) → reconnecting. If this recurs every ~2-3 min, the rig is invalidating the session (token renewal rejected).")
-			return RigState{}, err // control link dead → let the Manager reconnect
+			switch {
+			case readerGone:
+				debugLog.Printf("icom net: the CI-V reader has exited — the connection is dead however alive the control link looks → reconnecting")
+			case at.Alive():
+				debugLog.Printf("icom net: control link answers but no CI-V reply for %s → reconnecting. Another program (WSJT-X/OmniRig, the Remote Utility) has most likely taken the CI-V session.", silentFor.Round(time.Second))
+			default:
+				debugLog.Printf("icom net: control link went quiet (no rig packets for >6 s) → reconnecting. If this recurs every ~2-3 min, the rig is invalidating the session (token renewal rejected).")
+			}
+			// Restart the clock, and widen the window each time it fires without a
+			// good read in between. A hijacked session recovers on the first shot;
+			// a rig simply switched OFF never will, and re-tearing its session every
+			// 30 s would make the panel — and its ON button — blink away
+			// continuously. Backing off to minutes keeps the standby case quiet
+			// while still recovering on its own.
+			b.lastGoodAt = time.Now()
+			if b.silentGrace < icomSilentGraceMax {
+				b.silentGrace *= 2
+			}
+			return RigState{}, err // let the Manager reconnect
 		}
 		// USB (no liveness signal): the rig briefly stops answering CI-V while it
 		// switches band/VFO. Tolerate a few consecutive misses as transient — keep
@@ -308,6 +369,8 @@ func (b *IcomSerial) ReadState() (RigState, error) {
 		return RigState{}, err
 	}
 	b.readFails = 0
+	b.lastGoodAt = time.Now()
+	b.silentGrace = icomSilentGrace // the rig answers: back to the short window
 	s.FreqHz = hz
 	b.curFreq = hz
 

internal/cat/xiegu.go

@@ -0,0 +1,289 @@
+package cat
+
+// Native Xiegu CAT (G90, X6100, X6200, X5105 and relatives) over the rig's
+// serial/USB port.
+//
+// Xiegu speaks CI-V — Icom's bus protocol — with a REDUCED command set. Frames,
+// BCD encoding, addressing and the opcodes for frequency (0x03/0x05), mode
+// (0x04/0x06), PTT (0x1C 0x00), split (0x0F) and the meters (0x15) are the same
+// as Icom's, which is why this backend reuses internal/cat/civ wholesale rather
+// than re-deriving it.
+//
+// It is a SEPARATE backend rather than the Icom one with another address,
+// because what the two rigs DON'T share is the important part. The Icom backend
+// reads the spectrum scope, the DSP block, data-mode via 0x1A 0x06, the model id
+// via 0x19 — none of which a Xiegu implements. Pointed at a G90 it would poll
+// for answers that never come on every cycle, and its silence tolerance would
+// spend itself on commands the radio was never going to support.
+//
+// Mode differences that matter: the Xiegu table lists LSB, USB, AM, CW and CWR
+// only — no FM, no RTTY, and no data mode. A digital QSO therefore runs in USB
+// (which is what the operator does on the radio anyway), and the mode is
+// reported as the operator's configured digital mode when they select one, not
+// invented from the rig.
+//
+// Verified on: nothing yet — written from the Xiegu CI-V command table. The
+// command table published by Xiegu has rows that clearly slipped during
+// typesetting (0x07 and 0x0F share a block), so where it contradicts itself the
+// Icom meaning is used, since the rest of the table matches Icom exactly. Every
+// unexpected reply is logged raw so a first on-air run settles it.
+
+import (
+	"fmt"
+	"strings"
+	"sync"
+	"time"
+
+	"go.bug.st/serial"
+
+	"hamlog/internal/cat/civ"
+)
+
+// XieguDefaultAddr is the factory CI-V address of the G90/X6100 family.
+const XieguDefaultAddr = 0x70
+
+type Xiegu struct {
+	portName string
+	baud     int
+	rigAddr  byte
+	digital  string
+
+	mu   sync.Mutex
+	port serial.Port
+
+	curFreq int64
+	// splitSupported is cleared when the rig ignores the split query, so we stop
+	// asking every cycle — a Xiegu that has no split must not cost a timeout per
+	// poll, which would slow the whole loop to a crawl.
+	splitSupported bool
+}
+
+func NewXiegu(portName string, baud int, addr int, digital string) *Xiegu {
+	if baud <= 0 {
+		baud = 19200 // G90 factory default
+	}
+	if addr <= 0 || addr > 0xFF {
+		addr = XieguDefaultAddr
+	}
+	if strings.TrimSpace(digital) == "" {
+		digital = "FT8"
+	}
+	return &Xiegu{
+		portName: strings.TrimSpace(portName), baud: baud,
+		rigAddr: byte(addr), digital: digital, splitSupported: true,
+	}
+}
+
+func (x *Xiegu) Name() string { return "xiegu" }
+
+func (x *Xiegu) Connect() error {
+	x.mu.Lock()
+	defer x.mu.Unlock()
+	if x.portName == "" {
+		return fmt.Errorf("xiegu: no serial port configured")
+	}
+	p, err := serial.Open(x.portName, &serial.Mode{BaudRate: x.baud})
+	if err != nil {
+		return fmt.Errorf("xiegu: open %s @ %d baud: %w", x.portName, x.baud, err)
+	}
+	p.SetReadTimeout(200 * time.Millisecond)
+	x.port = p
+	x.splitSupported = true
+
+	// Prove the link before declaring success: an open COM port says nothing
+	// about a radio being on the other end, and a backend that reports
+	// "connected" to a powered-off rig sends the operator hunting for a fault in
+	// the wrong place.
+	if _, err := x.readFreq(); err != nil {
+		_ = p.Close()
+		x.port = nil
+		return fmt.Errorf("xiegu: no answer on %s @ %d baud (address 0x%02X): %w", x.portName, x.baud, x.rigAddr, err)
+	}
+	debugLog.Printf("xiegu: connected on %s @ %d baud, CI-V address 0x%02X", x.portName, x.baud, x.rigAddr)
+	return nil
+}
+
+func (x *Xiegu) Disconnect() {
+	x.mu.Lock()
+	defer x.mu.Unlock()
+	if x.port != nil {
+		_ = x.port.Close()
+		x.port = nil
+	}
+}
+
+func (x *Xiegu) ReadState() (RigState, error) {
+	x.mu.Lock()
+	defer x.mu.Unlock()
+	if x.port == nil {
+		return RigState{}, fmt.Errorf("xiegu: not connected")
+	}
+	s := RigState{Backend: x.Name(), Connected: true, Rig: "Xiegu"}
+
+	hz, err := x.readFreq()
+	if err != nil {
+		return RigState{}, err // let the Manager reconnect
+	}
+	s.FreqHz = hz
+	x.curFreq = hz
+
+	if d, err := x.ask(civ.CmdReadMode); err == nil && len(d.Data) >= 1 {
+		s.Mode = civ.ModeToADIF(d.Data[0], false)
+		// The rig has no data mode, so it reports USB on the digital watering
+		// holes. Naming the operator's digital mode there is the frontend's job
+		// (it infers from frequency); reporting USB honestly is ours.
+	}
+
+	if x.splitSupported {
+		d, err := x.ask(civ.CmdSplit)
+		switch {
+		case err != nil:
+			debugLog.Printf("xiegu: split query got no answer (%v) — not asking again this session", err)
+			x.splitSupported = false
+		case len(d.Data) >= 1:
+			s.Split = d.Data[0] == 0x01
+		}
+	}
+	// Split TX frequency is deliberately NOT reported. Reading the unselected
+	// VFO needs 0x25, which the Xiegu table does not list — and a split flag with
+	// a wrong TX frequency is worse than a split flag alone, because it is the
+	// frequency that gets logged.
+	return s, nil
+}
+
+func (x *Xiegu) SetFrequency(hz int64) error {
+	x.mu.Lock()
+	defer x.mu.Unlock()
+	if x.port == nil {
+		return fmt.Errorf("xiegu: not connected")
+	}
+	if hz <= 0 {
+		return fmt.Errorf("xiegu: invalid frequency %d", hz)
+	}
+	payload := append([]byte{civ.CmdSetFreq}, civ.FreqToBCD(hz)...)
+	return x.send(payload...)
+}
+
+func (x *Xiegu) SetMode(mode string) error {
+	x.mu.Lock()
+	defer x.mu.Unlock()
+	if x.port == nil {
+		return fmt.Errorf("xiegu: not connected")
+	}
+	m, ok := xieguModeByte(mode, x.curFreq)
+	if !ok {
+		return fmt.Errorf("xiegu: no CAT mode for %q", mode)
+	}
+	return x.send(civ.CmdSetMode, m)
+}
+
+func (x *Xiegu) SetPTT(on bool) error {
+	x.mu.Lock()
+	defer x.mu.Unlock()
+	if x.port == nil {
+		return fmt.Errorf("xiegu: not connected")
+	}
+	v := byte(0x00)
+	if on {
+		v = 0x01
+	}
+	return x.send(civ.CmdPTT, 0x00, v)
+}
+
+// ── helpers ───────────────────────────────────────────────────────────────
+
+func (x *Xiegu) send(payload ...byte) error {
+	if x.port == nil {
+		return fmt.Errorf("xiegu: not connected")
+	}
+	_, err := x.port.Write(civ.Frame(x.rigAddr, civ.AddrController, payload...))
+	return err
+}
+
+// ask sends a query and returns the rig's answer frame.
+//
+// CI-V is a shared bus: the rig echoes back what we sent before answering, so
+// our own frame has to be skipped. Matching on the SENDER (From == the rig)
+// rather than on position is what makes this robust when an echo is dropped or
+// an unsolicited frame arrives from the dial being turned.
+func (x *Xiegu) ask(payload ...byte) (civ.Decoded, error) {
+	if err := x.send(payload...); err != nil {
+		return civ.Decoded{}, err
+	}
+	buf := make([]byte, 0, 64)
+	tmp := make([]byte, 64)
+	deadline := time.Now().Add(600 * time.Millisecond)
+	for time.Now().Before(deadline) {
+		n, err := x.port.Read(tmp)
+		if err != nil {
+			return civ.Decoded{}, err
+		}
+		if n == 0 {
+			continue
+		}
+		buf = append(buf, tmp[:n]...)
+		frames, consumed := civ.Scan(buf)
+		buf = buf[consumed:]
+		for _, f := range frames {
+			if f.From != x.rigAddr {
+				continue // our own echo on the bus
+			}
+			if f.Cmd == 0xFA {
+				return civ.Decoded{}, fmt.Errorf("xiegu: rig rejected command 0x%02X", payload[0])
+			}
+			if f.Cmd == payload[0] {
+				return f, nil
+			}
+			// An unsolicited update (the operator turning the dial) — useful, but
+			// not the answer we asked for.
+			debugLog.Printf("xiegu: unsolicited frame cmd=0x%02X data=% X", f.Cmd, f.Data)
+		}
+	}
+	return civ.Decoded{}, fmt.Errorf("xiegu: timeout answering 0x%02X", payload[0])
+}
+
+func (x *Xiegu) readFreq() (int64, error) {
+	d, err := x.ask(civ.CmdReadFreq)
+	if err != nil {
+		return 0, err
+	}
+	hz := civ.BCDToFreq(d.Data)
+	if hz <= 0 {
+		return 0, fmt.Errorf("xiegu: unusable frequency % X", d.Data)
+	}
+	return hz, nil
+}
+
+// xieguModeByte maps an ADIF mode to the Xiegu's mode byte.
+//
+// The rig has LSB, USB, AM, CW and CWR — nothing else. A digital mode therefore
+// becomes USB (or LSB below 10 MHz), which is what the operator selects on the
+// radio; claiming a DATA mode it does not have would just be refused.
+func xieguModeByte(mode string, freqHz int64) (byte, bool) {
+	lowBand := freqHz > 0 && freqHz < 10_000_000
+	switch strings.ToUpper(strings.TrimSpace(mode)) {
+	case "":
+		return 0, false
+	case "LSB":
+		return 0x00, true
+	case "USB":
+		return 0x01, true
+	case "SSB":
+		if lowBand {
+			return 0x00, true
+		}
+		return 0x01, true
+	case "AM":
+		return 0x02, true
+	case "CW":
+		return 0x03, true
+	case "CWR", "CW-R":
+		return 0x07, true
+	default:
+		// Every digital sub-mode rides on plain sideband here.
+		if lowBand {
+			return 0x00, true
+		}
+		return 0x01, true
+	}
+}

internal/cat/xiegu_test.go

@@ -0,0 +1,83 @@
+package cat
+
+import (
+	"testing"
+
+	"hamlog/internal/cat/civ"
+)
+
+// The Xiegu mode table is SHORTER than Icom's: LSB, USB, AM, CW, CWR and
+// nothing else. The interesting cases are the ones with no equivalent — a
+// digital mode must land on plain sideband rather than be refused, because
+// refusing it would leave the rig on whatever it was and silently log the wrong
+// mode.
+func TestXieguModeByte(t *testing.T) {
+	cases := []struct {
+		mode string
+		hz   int64
+		want byte
+		ok   bool
+	}{
+		{"SSB", 7150000, 0x00, true},  // LSB below 10 MHz
+		{"SSB", 14250000, 0x01, true}, // USB above
+		{"LSB", 14250000, 0x00, true}, // explicit beats the convention
+		{"USB", 7150000, 0x01, true},
+		{"AM", 7150000, 0x02, true},
+		{"CW", 7030000, 0x03, true},
+		{"CWR", 7030000, 0x07, true},
+		{"FT8", 7074000, 0x00, true},  // no data mode on this rig → LSB
+		{"FT8", 14074000, 0x01, true}, // → USB
+		{"RTTY", 14080000, 0x01, true},
+		{"FM", 145000000, 0x01, true}, // no FM either; sideband is the honest fallback
+		{"", 14074000, 0x00, false},
+	}
+	for _, c := range cases {
+		got, ok := xieguModeByte(c.mode, c.hz)
+		if got != c.want || ok != c.ok {
+			t.Errorf("xieguModeByte(%q, %d) = 0x%02X,%v — want 0x%02X,%v", c.mode, c.hz, got, ok, c.want, c.ok)
+		}
+	}
+}
+
+// The Xiegu mode bytes must decode through the shared Icom table, since that is
+// the whole reason this backend reuses internal/cat/civ instead of its own
+// codec. If the two ever disagree, the radio would be set to one mode and read
+// back as another.
+func TestXieguModesRoundTripThroughCIV(t *testing.T) {
+	cases := []struct {
+		mode string
+		adif string
+	}{
+		// ADIF has no LSB/USB distinction — both sidebands ARE the SSB mode, and
+		// that is what gets logged. The sideband still matters to the radio, which
+		// is why xieguModeByte picks it from the frequency.
+		{"LSB", "SSB"},
+		{"USB", "SSB"},
+		{"AM", "AM"},
+		{"CW", "CW"},
+	}
+	for _, c := range cases {
+		b, ok := xieguModeByte(c.mode, 14200000)
+		if !ok {
+			t.Fatalf("xieguModeByte(%q) refused", c.mode)
+		}
+		if got := civ.ModeToADIF(b, false); got != c.adif {
+			t.Errorf("%s → 0x%02X → %q, want %q", c.mode, b, got, c.adif)
+		}
+	}
+}
+
+// Frequency encoding is shared with Icom, and it is the one field where a byte
+// out of place mistunes the radio silently. Pinned here at the boundaries a
+// Xiegu actually covers (it is an HF rig, so the 5-byte BCD upper bytes are 0).
+func TestXieguFrequencyEncoding(t *testing.T) {
+	for _, hz := range []int64{1840000, 7074000, 14074000, 28500000, 50313000} {
+		b := civ.FreqToBCD(hz)
+		if len(b) != 5 {
+			t.Fatalf("FreqToBCD(%d) produced %d bytes, want 5", hz, len(b))
+		}
+		if got := civ.BCDToFreq(b); got != hz {
+			t.Errorf("round trip %d → % X → %d", hz, b, got)
+		}
+	}
+}

internal/cat/yaesu.go

@@ -0,0 +1,467 @@
+package cat
+
+// Native Yaesu CAT over the rig's serial/USB port — no OmniRig.
+//
+// Why this exists: OmniRig sits between OpsLog and the radio and adds its own
+// rig-description files, its own VFO/split interpretation and its own polling.
+// Every Yaesu problem reported so far came from that layer disagreeing with the
+// radio — a .ini that never exposes the VFO, a Freq property that means A on one
+// model and B on another, a split flag that alternates. Talking to the rig
+// directly removes the disagreement: what the radio answers is what we show.
+//
+// ── The protocol ──────────────────────────────────────────────────────────
+// Modern Yaesu CAT is plain ASCII: a command, its arguments, and a ';'
+// terminator. A query is the command with no argument; the rig echoes the same
+// command with the value. It is the same shape as Kenwood's, which is why an
+// FTDX10 answers a Kenwood-speaking logger for the basics.
+//
+//	FA;            → FA014074000;   VFO A frequency, 9 digits, Hz
+//	FB;            → FB014100000;   VFO B frequency
+//	MD0;           → MD02;          operating mode of the main receiver
+//	VS;            → VS0;           which VFO is selected (0=A, 1=B)
+//	ST;            → ST1;           split (FTDX10/FTDX101)
+//	FT;            → FT1;           TX VFO (FT-991A/FT-710/FT-891 family)
+//	TX1; / TX0;                     key / unkey
+//	ID;            → ID0761;        model identifier
+//
+// Two of these are genuinely uncertain across the family and are treated as
+// such rather than guessed at: SPLIT is read through ST and, if the rig does not
+// answer that, through FT — whichever replies wins, and the choice is
+// remembered. Every unrecognised reply is logged raw, because that log is the
+// only way to learn a model's real behaviour from an operator's shack.
+//
+// Verified on: FTDX10, 2026-07-29 — frequency, mode, VFO and split all correct
+// against the radio. The other models are still inference from the same CAT
+// reference; anything this file asserts about a rig it has not met should be
+// read as a hypothesis with a log line attached.
+
+import (
+	"errors"
+	"fmt"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"go.bug.st/serial"
+)
+
+// yaesuModels maps the ID reply to a display name. An unknown id is shown as
+// itself rather than guessed — a wrong model name would be worse than a number,
+// because it silently implies capabilities the rig may not have.
+var yaesuModels = map[string]string{
+	"0761": "FTDX10",
+	"0681": "FTDX101D",
+	"0682": "FTDX101MP",
+	"0800": "FT-710",
+	"0570": "FT-991A",
+	"0650": "FT-891",
+	"0670": "FT-DX3000",
+	"0460": "FT-450D",
+}
+
+// yaesuModeToADIF maps the MD digit to an ADIF mode. The DATA and RTTY variants
+// differ only by sideband, which ADIF does not record — they collapse to the
+// operator's configured digital mode and to RTTY respectively.
+var yaesuModeToADIF = map[byte]string{
+	'1': "LSB",
+	'2': "USB",
+	'3': "CW",
+	'4': "FM",
+	'5': "AM",
+	'6': "RTTY",
+	'7': "CW",
+	'8': "DATA",
+	'9': "RTTY",
+	'A': "FM",
+	'B': "FM",
+	'C': "DATA",
+	'D': "AM",
+	'E': "FM", // C4FM — digital voice, closest ADIF sense is FM
+}
+
+type Yaesu struct {
+	portName string
+	baud     int
+	digital  string // ADIF mode reported for DATA (FT8, RTTY…)
+
+	mu   sync.Mutex
+	port serial.Port
+
+	model string
+	// splitCmd is learned at connect: "ST" or "FT" depending on which the rig
+	// answers. Empty means the rig answered neither, and split is reported as
+	// off rather than invented.
+	splitCmd string
+
+	curFreq   int64
+	curRXFreq int64
+	curVFO    string // "A" or "B"
+
+	// Control-panel state and its slow-beat counter — see yaesu_panel.go.
+	panel       YaesuTXState
+	panelCycle  int
+	panelLoaded bool
+	// Commands this rig answered "?;" to — asked once, then never again.
+	unsupported map[string]bool
+	// Needle inertia for the TX meters — see meterPeak.
+	powerPeak  meterPeak
+	powerWPeak meterPeak
+	swrPeak    meterPeak
+	// metersLogged counts the RM1..RM6 samples taken during transmission, so the
+	// survey follows a real carrier instead of catching one instant of it.
+	metersLogged int
+}
+
+func NewYaesu(portName string, baud int, digital string) *Yaesu {
+	if baud <= 0 {
+		baud = 38400 // FTDX10/FTDX101 factory default
+	}
+	if strings.TrimSpace(digital) == "" {
+		digital = "FT8"
+	}
+	return &Yaesu{portName: strings.TrimSpace(portName), baud: baud, digital: digital, curVFO: "A"}
+}
+
+func (y *Yaesu) Name() string { return "yaesu" }
+
+func (y *Yaesu) Connect() error {
+	y.mu.Lock()
+	defer y.mu.Unlock()
+	if y.portName == "" {
+		return fmt.Errorf("yaesu: no serial port configured")
+	}
+	p, err := serial.Open(y.portName, &serial.Mode{BaudRate: y.baud})
+	if err != nil {
+		return fmt.Errorf("yaesu: open %s @ %d baud: %w", y.portName, y.baud, err)
+	}
+	p.SetReadTimeout(300 * time.Millisecond)
+	y.port = p
+
+	// Silence unsolicited status reports. The rig can push them on every knob
+	// movement (AI1), which interleaves with our request/response pairs and makes
+	// a reply impossible to attribute — we poll instead, so the traffic is ours.
+	_ = y.write("AI0;")
+
+	if id, err := y.ask("ID;"); err == nil {
+		code := strings.TrimSuffix(strings.TrimPrefix(id, "ID"), ";")
+		if name, ok := yaesuModels[code]; ok {
+			y.model = name
+		} else {
+			y.model = "Yaesu (" + code + ")"
+			debugLog.Printf("yaesu: unknown model id %q — add it to yaesuModels", code)
+		}
+	} else {
+		debugLog.Printf("yaesu: ID query failed (%v) — continuing, the model name is cosmetic", err)
+	}
+
+	// Which command carries split on THIS rig. Asking once at connect and
+	// remembering the answer keeps the poll loop from paying for two round trips
+	// per cycle, and makes "neither answered" an explicit, logged state instead
+	// of a silent assumption that split is off.
+	for _, c := range []string{"ST", "FT"} {
+		if r, err := y.ask(c + ";"); err == nil && strings.HasPrefix(r, c) {
+			y.splitCmd = c
+			debugLog.Printf("yaesu: split is read through %s (answered %q)", c, r)
+			break
+		}
+	}
+	if y.splitCmd == "" {
+		debugLog.Printf("yaesu: neither ST; nor FT; answered — split will be reported as OFF. Send this log if the rig does have split.")
+	}
+	debugLog.Printf("yaesu: connected on %s @ %d baud, model=%q", y.portName, y.baud, y.model)
+	return nil
+}
+
+func (y *Yaesu) Disconnect() {
+	y.mu.Lock()
+	defer y.mu.Unlock()
+	if y.port != nil {
+		_ = y.port.Close()
+		y.port = nil
+	}
+}
+
+func (y *Yaesu) ReadState() (RigState, error) {
+	y.mu.Lock()
+	defer y.mu.Unlock()
+	if y.port == nil {
+		return RigState{}, fmt.Errorf("yaesu: not connected")
+	}
+	s := RigState{Backend: y.Name(), Connected: true, Rig: y.model}
+
+	faRaw, err := y.ask("FA;")
+	if errors.Is(err, errYaesuUnsupported) {
+		// A "?;" here is almost never about FA — the rig answers frequency queries
+		// perfectly well. It is a rejection left over from the PREVIOUS command
+		// that our read then attributed to this one. Retrying once costs a few
+		// milliseconds; treating it as "lost the rig" tore the CAT link down and
+		// reconnected it, which is what the operator saw on every CW macro.
+		debugLog.Printf("yaesu: FA; got a stray rejection — retrying once")
+		faRaw, err = y.ask("FA;")
+	}
+	if err != nil {
+		return RigState{}, err // the rig stopped answering — let the Manager reconnect
+	}
+	freqA, ok := parseYaesuFreq(faRaw, "FA")
+	if !ok {
+		return RigState{}, fmt.Errorf("yaesu: unparsable FA reply %q", faRaw)
+	}
+	freqB := int64(0)
+	if r, err := y.ask("FB;"); err == nil {
+		freqB, _ = parseYaesuFreq(r, "FB")
+	}
+
+	// Which VFO the operator is listening on. Unlike OmniRig there is no
+	// interpretation to do: VS answers 0 or 1.
+	vfo := "A"
+	if r, err := y.ask("VS;"); err == nil && len(r) >= 3 && r[2] == '1' {
+		vfo = "B"
+	}
+	y.curVFO = vfo
+
+	split := false
+	if y.splitCmd != "" {
+		if r, err := y.ask(y.splitCmd + ";"); err == nil {
+			split = yaesuSplitOn(r, y.splitCmd)
+		}
+	}
+
+	s.Vfo = vfo
+	s.FreqHz, s.RxFreqHz, s.Split = resolveYaesuVFOs(freqA, freqB, vfo, split)
+	y.curFreq = s.FreqHz
+	// The frequency being LISTENED to, which is what a split offset is measured
+	// from — under split that is RxFreqHz, not FreqHz.
+	y.curRXFreq = s.FreqHz
+	if s.Split && s.RxFreqHz > 0 {
+		y.curRXFreq = s.RxFreqHz
+	}
+
+	if r, err := y.ask("MD0;"); err == nil && len(r) >= 4 {
+		// Keep the RAW mode too: ADIF folds CW-U/CW-L and DATA-U/DATA-L together,
+		// but the panel has to show which sideband the rig is actually on.
+		y.panel.RawMode = yaesuRawModeName(r[3])
+		if m, ok := yaesuModeToADIF[r[3]]; ok {
+			if m == "DATA" {
+				m = y.digital
+			}
+			s.Mode = m
+		} else {
+			debugLog.Printf("yaesu: unknown mode reply %q", r)
+		}
+	}
+	// s.FreqHz is the TX frequency by the ADIF convention, so it IS the split
+	// transmit frequency when split is on.
+	y.readPanel(s.Mode, s.Split, s.FreqHz)
+	return s, nil
+}
+
+func (y *Yaesu) SetFrequency(hz int64) error {
+	y.mu.Lock()
+	defer y.mu.Unlock()
+	if y.port == nil {
+		return fmt.Errorf("yaesu: not connected")
+	}
+	if hz <= 0 || hz > 999_999_999 {
+		return fmt.Errorf("yaesu: frequency %d out of the 9-digit CAT range", hz)
+	}
+	// Write to the VFO the operator is ACTUALLY on. Always writing FA is what
+	// makes a display disagree with the radio when the operator is on B.
+	cmd := "FA"
+	if y.curVFO == "B" {
+		cmd = "FB"
+	}
+	return y.write(fmt.Sprintf("%s%09d;", cmd, hz))
+}
+
+func (y *Yaesu) SetMode(mode string) error {
+	y.mu.Lock()
+	defer y.mu.Unlock()
+	if y.port == nil {
+		return fmt.Errorf("yaesu: not connected")
+	}
+	d := yaesuModeDigit(mode, y.curFreq)
+	if d == 0 {
+		return fmt.Errorf("yaesu: no CAT mode for %q", mode)
+	}
+	return y.write(fmt.Sprintf("MD0%c;", d))
+}
+
+func (y *Yaesu) SetPTT(on bool) error {
+	y.mu.Lock()
+	defer y.mu.Unlock()
+	if y.port == nil {
+		return fmt.Errorf("yaesu: not connected")
+	}
+	if on {
+		return y.write("TX1;")
+	}
+	return y.write("TX0;")
+}
+
+// ── helpers ───────────────────────────────────────────────────────────────
+
+// write sends one command. The caller holds the mutex.
+func (y *Yaesu) write(cmd string) error {
+	if y.port == nil {
+		return fmt.Errorf("yaesu: not connected")
+	}
+	_, err := y.port.Write([]byte(cmd))
+	return err
+}
+
+// ask sends a query and reads the reply up to its ';'. The caller holds the
+// mutex, so a command and its answer are never interleaved with another's.
+func (y *Yaesu) ask(cmd string) (string, error) {
+	if err := y.write(cmd); err != nil {
+		return "", err
+	}
+	// Match the reply to the COMMAND, and drop anything else.
+	//
+	// Returning the first ';'-terminated string whatever it was is what made a CW
+	// macro knock the CAT link over: KY produces no reply, so the next query —
+	// FA; from the poll loop — collected a leftover frame, failed to parse as a
+	// frequency, and the Manager treated that as "lost the rig" and reconnected.
+	// The operator saw the CAT drop for a few seconds on every macro click.
+	want := cmdPrefix(cmd)
+	buf := make([]byte, 0, 64)
+	tmp := make([]byte, 64)
+	deadline := time.Now().Add(600 * time.Millisecond)
+	for time.Now().Before(deadline) {
+		n, err := y.port.Read(tmp)
+		if err != nil {
+			return "", err
+		}
+		if n == 0 {
+			continue // read timeout — the rig may still be composing its answer
+		}
+		buf = append(buf, tmp[:n]...)
+		for {
+			i := strings.IndexByte(string(buf), ';')
+			if i < 0 {
+				break
+			}
+			frame := string(buf[:i+1])
+			buf = buf[i+1:]
+			// "?;" is the rig saying it does not know this command. Confirmed on an
+			// FTDX10, which answers it to KY; and MG;. Reporting it as such — rather
+			// than discarding it and waiting out the timeout — is what lets callers
+			// stop asking instead of paying 600 ms per poll for ever.
+			if strings.TrimSpace(frame) == "?;" {
+				return "", errYaesuUnsupported
+			}
+			if want == "" || strings.HasPrefix(strings.ToUpper(frame), want) {
+				return frame, nil
+			}
+			debugLog.Printf("yaesu: discarding %q while waiting for %s (asked %q)", frame, want, cmd)
+		}
+		if len(buf) > 512 {
+			return "", fmt.Errorf("yaesu: no ';' in %d bytes answering %q", len(buf), cmd)
+		}
+	}
+	return "", fmt.Errorf("yaesu: timeout answering %q", cmd)
+}
+
+// errYaesuUnsupported is returned when the rig answers "?;" — it does not know
+// the command. Different models implement different subsets, and the only
+// reliable way to learn which is to ask once and remember the refusal.
+var errYaesuUnsupported = errors.New("yaesu: command not supported by this rig")
+
+// cmdPrefix is the leading letters of a command — what its reply starts with.
+// "FA;" → "FA", "MD0;" → "MD", "KY;" → "KY".
+func cmdPrefix(cmd string) string {
+	c := strings.ToUpper(strings.TrimSpace(cmd))
+	for i := 0; i < len(c); i++ {
+		if c[i] < 'A' || c[i] > 'Z' {
+			return c[:i]
+		}
+	}
+	return c
+}
+
+// parseYaesuFreq reads "FA014074000;" into Hz.
+func parseYaesuFreq(reply, prefix string) (int64, bool) {
+	r := strings.TrimSpace(reply)
+	if !strings.HasPrefix(r, prefix) {
+		return 0, false
+	}
+	digits := strings.TrimSuffix(strings.TrimPrefix(r, prefix), ";")
+	if digits == "" {
+		return 0, false
+	}
+	hz, err := strconv.ParseInt(digits, 10, 64)
+	if err != nil || hz <= 0 {
+		return 0, false
+	}
+	return hz, true
+}
+
+// yaesuSplitOn reads the split reply for whichever command the rig answers.
+//
+// ST is a split flag: ST1 means split. FT names the TX VFO: FT1 means transmit
+// on VFO B, which IS split when the operator is listening on A. The two are not
+// the same statement, which is why the command in use is remembered rather than
+// both being tried and merged.
+func yaesuSplitOn(reply, cmd string) bool {
+	r := strings.TrimSpace(reply)
+	if !strings.HasPrefix(r, cmd) || len(r) < len(cmd)+1 {
+		return false
+	}
+	return r[len(cmd)] == '1'
+}
+
+// resolveYaesuVFOs turns the two frequencies plus the VFO and split flags into
+// the ADIF pair: FreqHz is where we TRANSMIT, RxFreqHz only when split.
+//
+// Kept pure and separate from ReadState so the rules can be tested without a
+// radio — the equivalent OmniRig function is where every Yaesu bug lived.
+func resolveYaesuVFOs(freqA, freqB int64, vfo string, split bool) (tx, rx int64, isSplit bool) {
+	listening, transmitting := freqA, freqB
+	if vfo == "B" {
+		listening, transmitting = freqB, freqA
+	}
+	if !split {
+		return listening, 0, false
+	}
+	// Split with a missing or identical other VFO is not split: reporting it
+	// would put a wrong TX frequency in the log, which is worse than ignoring a
+	// flag the rig may have left set.
+	if transmitting <= 0 || transmitting == listening {
+		return listening, 0, false
+	}
+	return transmitting, listening, true
+}
+
+// yaesuModeDigit maps an ADIF mode to the MD digit. SSB has no single digit —
+// the sideband follows the worldwide convention (LSB below 10 MHz, USB above),
+// which is why the current frequency is part of the decision.
+func yaesuModeDigit(mode string, freqHz int64) byte {
+	switch strings.ToUpper(strings.TrimSpace(mode)) {
+	case "SSB":
+		if freqHz > 0 && freqHz < 10_000_000 {
+			return '1' // LSB
+		}
+		return '2' // USB
+	case "LSB":
+		return '1'
+	case "USB":
+		return '2'
+	case "CW":
+		return '3'
+	case "FM":
+		return '4'
+	case "AM":
+		return '5'
+	case "RTTY":
+		return '6'
+	case "":
+		return 0
+	default:
+		// Everything else is a digital sub-mode (FT8, FT4, PSK31, JS8…). They all
+		// ride on the rig's DATA mode; the sideband follows the same convention.
+		if freqHz > 0 && freqHz < 10_000_000 {
+			return '8' // DATA-LSB
+		}
+		return 'C' // DATA-USB
+	}
+}

internal/cat/yaesu_cw.go

@@ -0,0 +1,290 @@
+package cat
+
+// CW keying through the Yaesu's own keyer — the KY command.
+//
+// This is the fifth CW engine, alongside WinKeyer, the DTR/RTS line keyer, the
+// Icom CI-V keyer and FlexRadio's CWX. The point is the same in each: no extra
+// hardware, no second cable. The radio holds the text and keys it with its own
+// timing, which is why the character spacing is perfect where a PC keying a line
+// through USB latency is not.
+//
+//	KY;           → KY0;  buffer has room / KY1; buffer full
+//	KY <text>;            queue up to 24 characters
+//
+// The leading SPACE after KY is part of the command, not padding.
+//
+// CONFIRMED on an FTDX10 (2026-07-29): it refuses this outright, answering "?;"
+// to both KY; and KY <text>; — including with PC KEYING on DAKY, the obvious
+// candidate, which does NOT help. That model keys from a PC only through the DTR
+// line of its second (standard) COM port, which is OpsLog's "serial" engine and
+// is confirmed working.
+//
+// The code stays because KY is documented for the FTDX101 / FT-991A / FT-710
+// family. On a rig that refuses it, the error now names the route that works.
+//
+// STOP is the other uncertain half: Yaesu documents no buffer-clear, see StopCW.
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"time"
+)
+
+// yaesuCWChunk is the most characters one KY command accepts. Longer text is
+// split and fed as the rig drains its buffer.
+const yaesuCWChunk = 24
+
+// cwStatusLogged makes the KY status reply appear in the log once per run: it
+// is a line we have no verified sample of, so the first one is worth keeping.
+var cwStatusLogged bool
+
+// yaesuCWAllowed is what the rig's keyer can actually send. Anything else is
+// dropped rather than passed through: an unsupported byte can abort the whole
+// buffer, losing the rest of the message with no error anywhere.
+const yaesuCWAllowed = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 /?.,-=+:;()"
+
+// SendCW queues a message on the rig's keyer.
+//
+// Text is filtered, upper-cased and fed in 24-character pieces, waiting for room
+// between pieces. Without that wait a long macro would silently lose its tail:
+// the rig drops what does not fit rather than reporting an error.
+func (y *Yaesu) SendCW(text string) error {
+	msg := filterYaesuCW(text)
+	if msg == "" {
+		return nil
+	}
+	for len(msg) > 0 {
+		n := yaesuCWChunk
+		if len(msg) < n {
+			n = len(msg)
+		}
+		chunk := msg[:n]
+		msg = msg[n:]
+		if err := y.waitCWBuffer(4 * time.Second); err != nil {
+			return err
+		}
+		y.mu.Lock()
+		err := y.write("KY " + chunk + ";")
+		if err == nil {
+			// KY produces no reply when it is accepted — but a rig that REJECTS it
+			// answers "?;", and that frame then sat in the buffer until the poll
+			// loop's next query picked it up, failed, and the Manager tore the link
+			// down. That is the CAT dropping for a few seconds on every macro click.
+			//
+			// Reading here does two things: it keeps the stray frame off the poll
+			// loop, and it turns a silent non-transmission into a stated reason.
+			err = y.drainCWReply()
+		}
+		y.mu.Unlock()
+		if err != nil {
+			return err
+		}
+		// When the rig will not tell us how full its buffer is (an FTDX10 answers
+		// "?;" to KY;), pace the next piece by how long this one takes to key.
+		// Sending everything at once overruns the 24-character buffer and the rig
+		// silently drops the rest.
+		if len(msg) > 0 && y.cwStatusUnsupported() {
+			time.Sleep(yaesuCWDuration(chunk, y.keyerWPM()))
+		}
+	}
+	return nil
+}
+
+// drainCWReply reads for a moment after a KY write.
+//
+// An accepted KY says nothing at all, so silence here is success. A rejection
+// answers "?;" — and left unread, that frame was picked up by the poll loop's
+// next query, which failed to parse it and took the whole CAT link down with it.
+// Reading it here keeps the link up AND turns "nothing was transmitted, no idea
+// why" into a stated reason.
+//
+// The caller holds the mutex.
+func (y *Yaesu) drainCWReply() error {
+	if y.port == nil {
+		return fmt.Errorf("yaesu: not connected")
+	}
+	deadline := time.Now().Add(200 * time.Millisecond)
+	buf := make([]byte, 0, 32)
+	tmp := make([]byte, 32)
+	for time.Now().Before(deadline) {
+		n, err := y.port.Read(tmp)
+		if err != nil {
+			return nil // a read problem here is the poll loop's business, not ours
+		}
+		if n == 0 {
+			continue
+		}
+		buf = append(buf, tmp[:n]...)
+		for {
+			i := strings.IndexByte(string(buf), ';')
+			if i < 0 {
+				break
+			}
+			frame := strings.TrimSpace(string(buf[:i+1]))
+			buf = buf[i+1:]
+			if frame == "?;" {
+				// An FTDX10 refuses KY whatever PC KEYING is set to — DAKY included,
+				// tested on the radio 2026-07-29. The message therefore points
+				// straight at what works, rather than at a setting that will not
+				// help.
+				return fmt.Errorf("this radio does not accept CW over CAT (it answered \"?;\" to KY). " +
+					"Switch the keyer engine to \"Serial port (DTR=CW / RTS=PTT)\" on the rig's OTHER " +
+					"COM port — the standard one, CAT keeping the enhanced one — with PC KEYING set " +
+					"to DTR in the rig's CW menu")
+			}
+			debugLog.Printf("yaesu cw: rig answered %q to KY — ignoring", frame)
+		}
+	}
+	return nil // silence = accepted
+}
+
+// cwStatusUnsupported reports whether this rig refused the KY status query.
+func (y *Yaesu) cwStatusUnsupported() bool {
+	y.mu.Lock()
+	defer y.mu.Unlock()
+	return y.unsupported["KY;"]
+}
+
+// keyerWPM is the speed the rig is keying at, for pacing. Falls back to a
+// middling 20 wpm when the rig does not report it: too slow only wastes a
+// moment, too fast overruns the buffer.
+func (y *Yaesu) keyerWPM() int {
+	y.mu.Lock()
+	defer y.mu.Unlock()
+	if y.panel.KeySpeed >= 4 {
+		return y.panel.KeySpeed
+	}
+	return 20
+}
+
+// yaesuCWDuration estimates how long a piece of text takes to key.
+//
+// PARIS timing: one word is 50 dit-lengths and a word is 5 characters, so a
+// character averages 10 dits and a dit is 1.2/wpm seconds.
+func yaesuCWDuration(text string, wpm int) time.Duration {
+	if wpm < 4 {
+		wpm = 20
+	}
+	ditMs := 1200.0 / float64(wpm)
+	return time.Duration(float64(len(text))*10*ditMs) * time.Millisecond
+}
+
+// StopCW aborts the message being sent.
+//
+// Yaesu documents no buffer-clear, so this drops the transmitter instead: TX0
+// takes the rig out of transmit, which is what an operator pressing Escape
+// actually wants. Anything still queued is not keyed on the air.
+//
+// It deliberately does NOT send "KY0;" — a plausible-looking clear that the rig
+// would read as the CHARACTER zero and dutifully send. A wrong guess here
+// transmits, which is worse than an imperfect abort.
+func (y *Yaesu) StopCW() error {
+	y.mu.Lock()
+	defer y.mu.Unlock()
+	if y.port == nil {
+		return fmt.Errorf("yaesu: not connected")
+	}
+	return y.write("TX0;")
+}
+
+// waitCWBuffer blocks until the keyer reports room, or the deadline passes.
+// A rig that never answers the status query is not a reason to refuse to send —
+// we go ahead once, and the worst case is the truncation we were avoiding.
+func (y *Yaesu) waitCWBuffer(within time.Duration) error {
+	deadline := time.Now().Add(within)
+	for {
+		y.mu.Lock()
+		if y.port == nil {
+			y.mu.Unlock()
+			return fmt.Errorf("yaesu: not connected")
+		}
+		if y.unsupported["KY;"] {
+			y.mu.Unlock()
+			return nil // this rig does not report buffer state — pacing covers it
+		}
+		r, err := y.ask("KY;")
+		if err != nil {
+			if errors.Is(err, errYaesuUnsupported) {
+				if y.unsupported == nil {
+					y.unsupported = map[string]bool{}
+				}
+				y.unsupported["KY;"] = true
+				debugLog.Printf("yaesu cw: this rig does not answer KY; — pacing the send by keying time instead")
+			} else {
+				debugLog.Printf("yaesu cw: KY status query failed (%v) — sending anyway", err)
+			}
+			y.mu.Unlock()
+			return nil
+		}
+		y.mu.Unlock()
+		// Only an explicit "full" holds us back.
+		//
+		// The first version required the reply to be exactly "KY0;" at byte 2, and
+		// on a real FTDX10 that refused to send at all: anything the rig phrases
+		// differently — a space before the digit, a longer status — read as "still
+		// full" and the send died after four seconds having keyed nothing. The rig
+		// is the one that knows; when its answer is not a clear "1", the right move
+		// is to go ahead rather than to sit and time out.
+		// Log the shape once per session: this is a reply we have no verified
+		// sample of, and the log is what turns the next surprise into a fact.
+		if !cwStatusLogged {
+			cwStatusLogged = true
+			debugLog.Printf("yaesu cw: KY status reply is %q (full=%v)", r, yaesuCWBufferFull(r))
+		}
+		if !yaesuCWBufferFull(r) {
+			return nil
+		}
+		if time.Now().After(deadline) {
+			return fmt.Errorf("yaesu: the keyer buffer stayed full for %s (last reply %q)", within, r)
+		}
+		time.Sleep(50 * time.Millisecond)
+	}
+}
+
+// yaesuCWBufferFull reads the KY status reply.
+//
+// Deliberately asymmetric: only a clear "1" means full. Anything else — an
+// unexpected shape, a reply from another command that arrived first, an empty
+// string — is treated as "go ahead". Refusing to send because a status line was
+// phrased unexpectedly is the worse failure: the operator gets silence with no
+// explanation, where at worst sending early truncates a long message.
+func yaesuCWBufferFull(reply string) bool {
+	r := strings.TrimSpace(reply)
+	if !strings.HasPrefix(strings.ToUpper(r), "KY") {
+		return false
+	}
+	for _, c := range r[2:] {
+		switch c {
+		case '0':
+			return false
+		case '1':
+			return true
+		case ' ', ';':
+			continue
+		default:
+			return false // not a status digit — don't block on it
+		}
+	}
+	return false
+}
+
+// filterYaesuCW upper-cases and strips what the keyer cannot send.
+func filterYaesuCW(text string) string {
+	var b strings.Builder
+	for _, r := range strings.ToUpper(text) {
+		// Any whitespace becomes a word gap FIRST. Dropping tabs and newlines as
+		// "not in the allowed set" glued the words either side together: a macro
+		// written on two lines went out as CQCQ.
+		if r == '\t' || r == '\n' || r == '\r' {
+			b.WriteByte(' ')
+			continue
+		}
+		if strings.ContainsRune(yaesuCWAllowed, r) {
+			b.WriteRune(r)
+		}
+	}
+	// Runs of spaces become one: the rig sends each as a word gap, so three in a
+	// row is three gaps and the message crawls.
+	return strings.Join(strings.Fields(b.String()), " ")
+}

internal/cat/yaesu_cw_test.go

@@ -0,0 +1,122 @@
+package cat
+
+import (
+	"strings"
+	"testing"
+	"time"
+)
+
+// What reaches the rig's keyer.
+//
+// An unsupported byte does not produce an error on a Yaesu — it can abort the
+// whole buffer, so the rest of the message is lost silently. Filtering is
+// therefore part of correctness, not tidiness.
+func TestFilterYaesuCW(t *testing.T) {
+	cases := []struct{ in, want string }{
+		{"cq cq de f4bpo", "CQ CQ DE F4BPO"},
+		{"F4BPO/P", "F4BPO/P"},
+		{"599 tu 73", "599 TU 73"},
+		// Accents and symbols the keyer has no code for.
+		{"héllo", "HLLO"},
+		{"a*b#c", "ABC"},
+		// Runs of whitespace collapse: the rig sends each space as a word gap, so
+		// three in a row is three gaps and the message crawls.
+		{"cq    cq", "CQ CQ"},
+		{"  padded  ", "PADDED"},
+		{"\tcq\ncq\t", "CQ CQ"},
+		{"", ""},
+		{"   ", ""},
+	}
+	for _, c := range cases {
+		if got := filterYaesuCW(c.in); got != c.want {
+			t.Errorf("filterYaesuCW(%q) = %q, want %q", c.in, got, c.want)
+		}
+	}
+}
+
+// Long macros have to be split: one KY command carries 24 characters and the rig
+// DROPS what does not fit rather than reporting an error, so a contest CQ would
+// lose its tail with no sign anywhere.
+func TestYaesuCWChunking(t *testing.T) {
+	msg := filterYaesuCW("cq cq cq de f4bpo f4bpo f4bpo pse k")
+	if len(msg) <= yaesuCWChunk {
+		t.Fatalf("test message is %d chars — too short to exercise chunking", len(msg))
+	}
+	var chunks []string
+	for rest := msg; len(rest) > 0; {
+		n := yaesuCWChunk
+		if len(rest) < n {
+			n = len(rest)
+		}
+		chunks = append(chunks, rest[:n])
+		rest = rest[n:]
+	}
+	for i, c := range chunks {
+		if len(c) > yaesuCWChunk {
+			t.Errorf("chunk %d is %d chars, over the %d limit", i, len(c), yaesuCWChunk)
+		}
+	}
+	// Nothing added, nothing lost: the message the operator typed is what the
+	// keyer receives.
+	if joined := strings.Join(chunks, ""); joined != msg {
+		t.Errorf("chunks rejoin to %q, want %q", joined, msg)
+	}
+}
+
+// Reading the KY status reply.
+//
+// The first version demanded exactly "KY0;" with the digit at byte 2, and on a
+// real FTDX10 that refused to send at all: the reply was phrased differently,
+// every poll read as "still full", and after four seconds the send gave up
+// having keyed nothing. Hence the asymmetry — only a clear "1" blocks.
+func TestYaesuCWBufferFull(t *testing.T) {
+	cases := []struct {
+		reply string
+		full  bool
+	}{
+		{"KY0;", false},
+		{"KY1;", true},
+		{"KY 0;", false}, // a space before the digit
+		{"KY 1;", true},
+		{"ky1;", true}, // lower case
+		{" KY0; ", false},
+		// Shapes we have no sample of must NOT block: silence with no explanation
+		// is a worse failure than sending a moment early.
+		{"KY;", false},
+		{"", false},
+		{"FA014074000;", false}, // another command's reply arriving first
+		{"KYX;", false},
+	}
+	for _, c := range cases {
+		if got := yaesuCWBufferFull(c.reply); got != c.full {
+			t.Errorf("yaesuCWBufferFull(%q) = %v, want %v", c.reply, got, c.full)
+		}
+	}
+}
+
+// Pacing when the rig will not report its buffer.
+//
+// An FTDX10 answers "?;" to KY;, so there is nothing to wait on and the send has
+// to be spaced by how long the text takes to key — otherwise the second piece
+// overruns the 24-character buffer and the rig drops it silently.
+func TestYaesuCWDuration(t *testing.T) {
+	// PARIS: at 20 wpm a dit is 60 ms and a character averages 10 dits, so 24
+	// characters take about 14.4 s.
+	got := yaesuCWDuration("ABCDEFGHIJKLMNOPQRSTUVWX", 20)
+	if got < 13*time.Second || got > 16*time.Second {
+		t.Errorf("24 chars at 20 wpm = %s, expected about 14.4s", got)
+	}
+	// Twice the speed, half the time.
+	fast := yaesuCWDuration("ABCDEFGHIJKLMNOPQRSTUVWX", 40)
+	if fast >= got || fast < got/3 {
+		t.Errorf("40 wpm = %s vs 20 wpm = %s — should be about half", fast, got)
+	}
+	// A nonsense speed must not produce a zero wait (send everything at once) nor
+	// an absurd one (the operator waiting minutes).
+	if d := yaesuCWDuration("TEST", 0); d <= 0 || d > 10*time.Second {
+		t.Errorf("4 chars at an unknown speed = %s, want a sane fallback", d)
+	}
+	if d := yaesuCWDuration("", 20); d != 0 {
+		t.Errorf("empty text = %s, want 0", d)
+	}
+}

internal/cat/yaesu_panel.go

@@ -0,0 +1,810 @@
+package cat
+
+// The Yaesu control panel: meters and the settings an operator reaches for
+// mid-QSO. Split out from yaesu.go, which stays the small fast path the whole
+// application depends on — a panel read that hangs must never delay the
+// frequency display.
+//
+// Reads are STAGGERED. Meters change constantly and are polled every cycle;
+// settings (power, gains, AGC, filters) only change when someone turns a knob,
+// so they are refreshed every 8th cycle and immediately after any set. At the
+// default 250 ms cycle that is a two-second worst case for a knob turned on the
+// radio, against a serial link that would otherwise carry twenty queries a
+// second and starve the frequency poll it shares.
+//
+// Verified on: FTDX10. Commands come from its CAT reference; a control a model
+// does not implement simply never answers, and askNum keeps the previous value
+// rather than showing a zero that reads as "it reset itself".
+
+import (
+	"errors"
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// YaesuTXState is the panel snapshot handed to the frontend.
+type YaesuTXState struct {
+	Available bool   `json:"available"`
+	Model     string `json:"model,omitempty"`
+	Mode      string `json:"mode,omitempty"`
+	// RawMode is the rig mode with its sideband (CW-U, DATA-L…), which ADIF
+	// deliberately does not record but the panel has to show.
+	RawMode string `json:"raw_mode,omitempty"`
+
+	Transmitting bool `json:"transmitting"`
+	Split        bool `json:"split"`
+	// SplitTXHz is where the rig will TRANSMIT while split — the panel showed a
+	// lit SPLIT button and nothing else, which does not tell an operator whether
+	// they are up 1 or up 5.
+	SplitTXHz  int64 `json:"split_tx_hz"`
+	SMeter     int   `json:"s_meter"`     // 0-100 (raw 0-255)
+	PowerMeter int   `json:"power_meter"` // 0-100, TX only
+	SWRMeter   int   `json:"swr_meter"`   // 0-100, TX only
+
+	RFPower int    `json:"rf_power"` // watts
+	MicGain int    `json:"mic_gain"` // 0-100
+	AFGain  int    `json:"af_gain"`  // 0-100
+	RFGain  int    `json:"rf_gain"`  // 0-100
+	Squelch int    `json:"squelch"`  // 0-100
+	AGC     string `json:"agc,omitempty"`
+	Preamp  int    `json:"preamp"` // 0=IPO, 1=AMP1, 2=AMP2
+	Att     int    `json:"att"`    // 0=off, else dB
+	NB      bool   `json:"nb"`
+	NR      bool   `json:"nr"`
+	NRLevel int    `json:"nr_level"` // 1-15
+	Narrow  bool   `json:"narrow"`   // NAR filter
+	// SWR is the RATIO (1.0, 1.5…), computed from the reflection coefficient —
+	// what an operator reads on the rig, not a percentage of meter travel.
+	SWR float64 `json:"swr"`
+	// PowerW is the output in WATTS, taken from the METER rather than from the
+	// power setting — the setting says what was asked for, not what came out.
+	PowerW float64 `json:"power_w"`
+	VOX    bool    `json:"vox"`
+	// CW-only controls. Read (and shown) only in CW, where MIC and VOX mean
+	// nothing and these are what an operator reaches for.
+	KeySpeed int  `json:"key_speed"` // WPM
+	BreakIn  bool `json:"break_in"`
+}
+
+// YaesuController is the typed escape the Manager exposes for the panel, in the
+// same shape as FlexController and IcomController.
+type YaesuController interface {
+	YaesuState() YaesuTXState
+	RefreshYaesu() error
+	SetYaesuPower(int) error
+	SetYaesuMicGain(int) error
+	SetYaesuAFGain(int) error
+	SetYaesuRFGain(int) error
+	SetYaesuSquelch(int) error
+	SetYaesuAGC(string) error
+	SetYaesuPreamp(int) error
+	SetYaesuAtt(int) error
+	SetYaesuNB(bool) error
+	SetYaesuNR(bool) error
+	SetYaesuNRLevel(int) error
+	SetYaesuNarrow(bool) error
+	SetYaesuVOX(bool) error
+	SetYaesuKeySpeed(int) error
+	SetYaesuBreakIn(bool) error
+	YaesuZeroIn() error
+	// CW keying through the rig's own keyer (KY) — the fifth CW engine.
+	SendCW(string) error
+	StopCW() error
+	SetYaesuSplit(bool) error
+	SetYaesuSplitOffset(int64) error
+	SetYaesuBand(string) error
+	SetYaesuModeRaw(string) error
+	TuneYaesuATU() error
+}
+
+func (y *Yaesu) YaesuState() YaesuTXState {
+	y.mu.Lock()
+	defer y.mu.Unlock()
+	st := y.panel
+	st.Available = y.port != nil
+	st.Model = y.model
+	return st
+}
+
+// readPanel refreshes the meters, and the settings on the slower beat. Called
+// from ReadState with the mutex HELD, so it shares the same serialised link.
+func (y *Yaesu) readPanel(mode string, split bool, txHz int64) {
+	y.panel.Mode = mode
+	y.panel.Split = split
+	y.panel.SplitTXHz = 0
+	if split {
+		y.panel.SplitTXHz = txHz
+	}
+
+	// TX state first: which meters mean anything depends on it, and a power
+	// reading shown while receiving is how a panel lies.
+	if r, err := y.ask("TX;"); err == nil && len(r) >= 3 {
+		y.panel.Transmitting = r[2] != '0'
+	}
+	if v, ok := y.askNum("SM0;", "SM0", 3); ok {
+		y.panel.SMeter = scale255(v)
+	}
+	if y.panel.Transmitting {
+		// One-shot survey of every meter while transmitting.
+		//
+		// Which RM index carries which meter is NOT the same across the family, and
+		// an operator reported an SWR bar at 80 with a real SWR of 1.1 — the shape
+		// of reading the wrong index (ALC, say) rather than of a scaling error.
+		// Guessing again would just move the wrong number; this prints all six
+		// once, and the log then says which is which on THIS radio.
+		// Sampled on EVERY poll while transmitting, capped — one snapshot taken as
+		// the transmission starts catches the meters still at rest (RM4=13, the
+		// rest zero), which says nothing. What identifies a meter is which index
+		// TRACKS the power over a few seconds of steady carrier.
+		if y.metersLogged < 40 {
+			y.metersLogged++
+			raw := make([]string, 0, 6)
+			for i := 1; i <= 6; i++ {
+				cmd := fmt.Sprintf("RM%d;", i)
+				if v, ok := y.askNum(cmd, fmt.Sprintf("RM%d", i), 3); ok {
+					raw = append(raw, fmt.Sprintf("RM%d=%d", i, v))
+				} else {
+					raw = append(raw, fmt.Sprintf("RM%d=-", i))
+				}
+			}
+			// The POWER SETTING goes on the same line. Which index is the wattmeter
+			// cannot be read off one transmission — RM4 rose while RM5 sat still,
+			// but RM5 differed BETWEEN transmissions (208 then 105), so both are
+			// candidates. What settles it is transmitting at two different power
+			// settings and seeing which index follows: printing the setting here
+			// makes that a one-line comparison instead of a memory exercise.
+			debugLog.Printf("yaesu: meters at PC=%dW: %s (compare two different power settings)",
+				y.panel.RFPower, strings.Join(raw, " "))
+		}
+		// Measured on an FTDX10 (2026-07-29). The FM carrier was inconclusive —
+		// constant by definition — so the answer came from CW at 100 W, where the
+		// keying itself is the experiment:
+		//
+		//   key down: RM4=25 RM5=207 RM6=13
+		//   key up:   RM4=25 RM5=0   RM6=0
+		//
+		// RM5 follows the RF envelope exactly, so RM5 is the POWER meter. RM4 sits
+		// near 25 whether the key is down or up, so it is not measuring output at
+		// all — reading it as power is what showed 8 W on a 100 W transmission.
+		// Peak-hold. In CW the key is up between elements and the meters genuinely
+		// read 0 there — the log shows RM5 alternating 207, 0, 207 — so following
+		// the raw value makes the bars flicker to nothing several times a second
+		// and the number unreadable. A real meter has needle inertia; this is the
+		// same idea, and it only ever holds a value the radio actually reported.
+		now := time.Now()
+		if v, ok := y.askNum("RM5;", "RM5", 3); ok {
+			y.panel.PowerMeter = y.powerPeak.update(scale255(v), now)
+			y.panel.PowerW = float64(y.powerWPeak.update(int(yaesuWatts(v)+0.5), now))
+		}
+		// SWR is RM6, and a second measurement at a KNOWN mismatch settled both the
+		// index and the scale: 0 at SWR 1.1, then 52 at SWR 1.5. 52/255 = 0.204,
+		// which is the reflection coefficient of a 1.5 SWR to three decimals — so
+		// the raw value is rho scaled to 255, and the ratio follows from physics
+		// rather than from a fitted curve.
+		if v, ok := y.askNum("RM6;", "RM6", 3); ok {
+			y.panel.SWRMeter = y.swrPeak.update(scale255(v), now)
+			// The RATIO is only meaningful while power is going out: between words
+			// the reading is 0, which would display as a perfect 1.0 match — worse
+			// than a stale figure, because it looks like good news.
+			if v > 0 {
+				y.panel.SWR = swrFromReflection(v)
+			}
+		}
+	} else {
+		// Zeroed rather than frozen: a stale reading from the last transmission
+		// reads as a live one.
+		//
+		// EVERY transmit value has to be cleared here, and the peak-hold state with
+		// them. Clearing only the two bar percentages left the watts and the SWR
+		// ratio standing — the PWR bar stayed at full scale after the operator
+		// stopped transmitting — and a peak left in the holder would have carried
+		// the old reading into the next transmission.
+		y.panel.PowerMeter, y.panel.SWRMeter = 0, 0
+		y.panel.PowerW, y.panel.SWR = 0, 0
+		y.powerPeak, y.powerWPeak, y.swrPeak = meterPeak{}, meterPeak{}, meterPeak{}
+	}
+
+	y.panelCycle++
+	if y.panelLoaded && y.panelCycle < 8 {
+		return
+	}
+	y.panelCycle = 0
+	y.panelLoaded = true
+	y.readPanelSettings()
+}
+
+// readPanelSettings re-reads everything a knob can change. Separate so a set can
+// force it without waiting for the slow beat.
+func (y *Yaesu) readPanelSettings() {
+	if v, ok := y.askNum("PC;", "PC", 3); ok {
+		y.panel.RFPower = v // watts, not a 0-255 scale
+	}
+	if v, ok := y.askNum("MG;", "MG", 3); ok {
+		y.panel.MicGain = scale255(v)
+	}
+	if v, ok := y.askNum("AG0;", "AG0", 3); ok {
+		y.panel.AFGain = scale255(v)
+	}
+	if v, ok := y.askNum("RG0;", "RG0", 3); ok {
+		y.panel.RFGain = scale255(v)
+	}
+	if v, ok := y.askNum("SQ0;", "SQ0", 3); ok {
+		y.panel.Squelch = scale255(v)
+	}
+	if v, ok := y.askNum("GT0;", "GT0", 1); ok {
+		y.panel.AGC = yaesuAGCName(v)
+	}
+	if v, ok := y.askNum("PA0;", "PA0", 1); ok {
+		y.panel.Preamp = v
+	}
+	if v, ok := y.askNum("RA0;", "RA0", 1); ok {
+		y.panel.Att = yaesuAttDB(v)
+	}
+	if v, ok := y.askNum("NB0;", "NB0", 1); ok {
+		y.panel.NB = v != 0
+	}
+	if v, ok := y.askNum("NR0;", "NR0", 1); ok {
+		y.panel.NR = v != 0
+	}
+	if v, ok := y.askNum("RL0;", "RL0", 2); ok {
+		y.panel.NRLevel = v
+	}
+	if v, ok := y.askNum("NA0;", "NA0", 1); ok {
+		y.panel.Narrow = v != 0
+	}
+	if v, ok := y.askNum("VX;", "VX", 1); ok {
+		y.panel.VOX = v != 0
+	}
+	// CW keyer. Read unconditionally — it is two more queries on the SLOW beat,
+	// and having the value ready means the CW card is populated the instant the
+	// operator switches mode rather than a poll cycle later.
+	if v, ok := y.askNum("KS;", "KS", 3); ok {
+		y.panel.KeySpeed = v
+	}
+	if v, ok := y.askNum("BI;", "BI", 1); ok {
+		y.panel.BreakIn = v != 0
+	}
+}
+
+// askNum sends a query and reads a fixed-width decimal field out of the reply.
+// ok=false when the rig does not answer, or answers something else — a control
+// this model lacks then keeps its previous value instead of dropping to zero,
+// which would look like a setting that reset itself.
+func (y *Yaesu) askNum(cmd, prefix string, digits int) (int, bool) {
+	// A command this model refused once is never asked again. Models implement
+	// different subsets — an FTDX10 answers "?;" to MG; — and re-asking costs a
+	// 600 ms timeout on every slow beat, for a control that will never answer.
+	if y.unsupported[cmd] {
+		return 0, false
+	}
+	r, err := y.ask(cmd)
+	if err != nil {
+		if errors.Is(err, errYaesuUnsupported) {
+			if y.unsupported == nil {
+				y.unsupported = map[string]bool{}
+			}
+			y.unsupported[cmd] = true
+			debugLog.Printf("yaesu: this rig does not support %q — not asking again", cmd)
+		}
+		return 0, false
+	}
+	if !strings.HasPrefix(r, prefix) || len(r) < len(prefix)+digits {
+		debugLog.Printf("yaesu: unexpected reply %q to %q", r, cmd)
+		return 0, false
+	}
+	n, err := strconv.Atoi(r[len(prefix) : len(prefix)+digits])
+	if err != nil {
+		return 0, false
+	}
+	return n, true
+}
+
+// setAndRefresh writes a command then re-reads the settings, so the panel shows
+// what the RIG ended up with rather than what we asked for — the two differ
+// whenever a value is out of range or the current mode forbids the control.
+func (y *Yaesu) setAndRefresh(cmd string) error {
+	y.mu.Lock()
+	defer y.mu.Unlock()
+	if y.port == nil {
+		return fmt.Errorf("yaesu: not connected")
+	}
+	if err := y.write(cmd); err != nil {
+		return err
+	}
+	time.Sleep(30 * time.Millisecond) // let the rig apply it before reading back
+	y.readPanelSettings()
+	return nil
+}
+
+func (y *Yaesu) RefreshYaesu() error {
+	y.mu.Lock()
+	defer y.mu.Unlock()
+	if y.port == nil {
+		return fmt.Errorf("yaesu: not connected")
+	}
+	y.readPanelSettings()
+	return nil
+}
+
+func (y *Yaesu) SetYaesuPower(w int) error {
+	return y.setAndRefresh(fmt.Sprintf("PC%03d;", clampInt(w, 5, 100)))
+}
+
+func (y *Yaesu) SetYaesuMicGain(p int) error {
+	return y.setAndRefresh(fmt.Sprintf("MG%03d;", from100(p)))
+}
+
+func (y *Yaesu) SetYaesuAFGain(p int) error {
+	return y.setAndRefresh(fmt.Sprintf("AG0%03d;", from100(p)))
+}
+
+func (y *Yaesu) SetYaesuRFGain(p int) error {
+	return y.setAndRefresh(fmt.Sprintf("RG0%03d;", from100(p)))
+}
+
+func (y *Yaesu) SetYaesuSquelch(p int) error {
+	return y.setAndRefresh(fmt.Sprintf("SQ0%03d;", from100(p)))
+}
+
+func (y *Yaesu) SetYaesuAGC(name string) error {
+	return y.setAndRefresh(fmt.Sprintf("GT0%d;", yaesuAGCCode(name)))
+}
+
+func (y *Yaesu) SetYaesuPreamp(n int) error {
+	return y.setAndRefresh(fmt.Sprintf("PA0%d;", clampInt(n, 0, 2)))
+}
+
+func (y *Yaesu) SetYaesuAtt(db int) error {
+	return y.setAndRefresh(fmt.Sprintf("RA0%d;", yaesuAttCode(db)))
+}
+
+func (y *Yaesu) SetYaesuNB(on bool) error {
+	return y.setAndRefresh(fmt.Sprintf("NB0%d;", boolDigit(on)))
+}
+
+func (y *Yaesu) SetYaesuNR(on bool) error {
+	return y.setAndRefresh(fmt.Sprintf("NR0%d;", boolDigit(on)))
+}
+
+func (y *Yaesu) SetYaesuNRLevel(n int) error {
+	return y.setAndRefresh(fmt.Sprintf("RL0%02d;", clampInt(n, 1, 15)))
+}
+
+func (y *Yaesu) SetYaesuNarrow(on bool) error {
+	return y.setAndRefresh(fmt.Sprintf("NA0%d;", boolDigit(on)))
+}
+
+func (y *Yaesu) SetYaesuVOX(on bool) error {
+	return y.setAndRefresh(fmt.Sprintf("VX%d;", boolDigit(on)))
+}
+
+// SetYaesuSplit uses whichever command this rig answered at connect. Sending the
+// other one would be silently ignored, and the operator would get a split button
+// that does nothing.
+func (y *Yaesu) SetYaesuSplit(on bool) error {
+	// Turning split ON also PLACES the transmit VFO. Flipping the flag alone
+	// transmits wherever the other VFO happens to sit — it held 18.115 from an
+	// earlier session while the operator was listening on 14.244, so pressing
+	// SPLIT threw them onto another band entirely. The other VFO is stale by
+	// nature; the only frequency that makes sense is one derived from where the
+	// operator is listening NOW.
+	//
+	// The distance is the mode's usual one: 1 kHz on CW and the data modes,
+	// 5 kHz on phone. The +1k / +5k buttons remain for anything else.
+	if on {
+		return y.SetYaesuSplitOffset(y.defaultSplitOffset())
+	}
+	y.mu.Lock()
+	cmd := y.splitCmd
+	y.mu.Unlock()
+	if cmd == "" {
+		return fmt.Errorf("yaesu: this rig answered neither ST; nor FT; — split cannot be set")
+	}
+	return y.setAndRefresh(fmt.Sprintf("%s0;", cmd))
+}
+
+// defaultSplitOffset is what SPLIT means on this mode: up 1 kHz on CW and the
+// data modes, up 5 kHz on phone — the offsets operators actually call.
+func (y *Yaesu) defaultSplitOffset() int64 {
+	y.mu.Lock()
+	raw := strings.ToUpper(y.panel.RawMode)
+	y.mu.Unlock()
+	switch {
+	case strings.HasPrefix(raw, "CW"), strings.HasPrefix(raw, "RTTY"), strings.HasPrefix(raw, "DATA"):
+		return 1000
+	}
+	return 5000
+}
+
+// SetYaesuBand switches band with BS, which lands the rig on ITS OWN last-used
+// frequency for that band — the radio's band memory, not a frequency we choose.
+// SetYaesuModeRaw selects an exact rig mode, sideband included — "CW-U",
+// "DATA-L", "RTTY-U"… The plain SetMode path takes an ADIF mode and can only
+// choose a sideband by convention, but CW, RTTY and the data modes are routinely
+// run on EITHER sideband and the operator is the one who knows which. This is
+// what the panel's mode buttons use.
+func (y *Yaesu) SetYaesuModeRaw(name string) error {
+	d, ok := yaesuRawModeDigit(name)
+	if !ok {
+		return fmt.Errorf("yaesu: unknown rig mode %q", name)
+	}
+	return y.setAndRefresh(fmt.Sprintf("MD0%c;", d))
+}
+
+// yaesuRawModeDigit maps a rig-mode name to its MD digit.
+func yaesuRawModeDigit(name string) (byte, bool) {
+	switch strings.ToUpper(strings.TrimSpace(name)) {
+	case "LSB":
+		return '1', true
+	case "USB":
+		return '2', true
+	case "CW-U", "CWU":
+		return '3', true
+	case "CW-L", "CWL":
+		return '7', true
+	case "FM":
+		return '4', true
+	case "AM":
+		return '5', true
+	case "RTTY-L", "RTTYL":
+		return '6', true
+	case "RTTY-U", "RTTYU":
+		return '9', true
+	case "DATA-L", "DATAL", "DIGI-L":
+		return '8', true
+	case "DATA-U", "DATAU", "DIGI-U":
+		return 'C', true
+	}
+	return 0, false
+}
+
+func (y *Yaesu) SetYaesuBand(band string) error {
+	code, ok := yaesuBandCode(band)
+	if !ok {
+		return fmt.Errorf("yaesu: no band code for %q", band)
+	}
+	return y.setAndRefresh(fmt.Sprintf("BS%02d;", code))
+}
+
+// TuneYaesuATU starts a tuning cycle. Deliberately not followed by a settings
+// read: the rig is transmitting into the tuner for several seconds and answers
+// little, so the reads would just time out one after another.
+func (y *Yaesu) TuneYaesuATU() error {
+	y.mu.Lock()
+	defer y.mu.Unlock()
+	if y.port == nil {
+		return fmt.Errorf("yaesu: not connected")
+	}
+	return y.write("AC002;")
+}
+
+// ── small mappings ────────────────────────────────────────────────────────
+
+func scale255(v int) int {
+	if v <= 0 {
+		return 0
+	}
+	if v >= 255 {
+		return 100
+	}
+	return v * 100 / 255
+}
+
+func from100(p int) int { return clampInt(p, 0, 100) * 255 / 100 }
+
+func clampInt(v, lo, hi int) int {
+	if v < lo {
+		return lo
+	}
+	if v > hi {
+		return hi
+	}
+	return v
+}
+
+func boolDigit(b bool) int {
+	if b {
+		return 1
+	}
+	return 0
+}
+
+func yaesuAGCName(code int) string {
+	switch code {
+	case 0:
+		return "OFF"
+	case 1:
+		return "FAST"
+	case 2:
+		return "MID"
+	case 3:
+		return "SLOW"
+	case 4:
+		return "AUTO"
+	}
+	return ""
+}
+
+func yaesuAGCCode(name string) int {
+	switch strings.ToUpper(strings.TrimSpace(name)) {
+	case "OFF":
+		return 0
+	case "FAST":
+		return 1
+	case "MID", "MEDIUM":
+		return 2
+	case "SLOW":
+		return 3
+	}
+	return 4 // AUTO — the safe default for anything unrecognised
+}
+
+// The FTDX10/FTDX101 attenuator is a THREE-step pad (RA00..RA03 = off, 6, 12,
+// 18 dB), not the single step this first assumed — a panel offering only one
+// step hides two thirds of the control. Reporting the dB rather than the raw
+// code lets the buttons label themselves honestly.
+func yaesuAttDB(code int) int {
+	switch code {
+	case 1:
+		return 6
+	case 2:
+		return 12
+	case 3:
+		return 18
+	}
+	return 0
+}
+
+func yaesuAttCode(db int) int {
+	switch {
+	case db >= 18:
+		return 3
+	case db >= 12:
+		return 2
+	case db >= 6:
+		return 1
+	}
+	return 0
+}
+
+// yaesuBandCode maps an ADIF band to the BS command's band number.
+func yaesuBandCode(band string) (int, bool) {
+	switch strings.ToLower(strings.TrimSpace(band)) {
+	case "160m":
+		return 0, true
+	case "80m":
+		return 1, true
+	case "60m":
+		return 2, true
+	case "40m":
+		return 3, true
+	case "30m":
+		return 4, true
+	case "20m":
+		return 5, true
+	case "17m":
+		return 6, true
+	case "15m":
+		return 7, true
+	case "12m":
+		return 8, true
+	case "10m":
+		return 9, true
+	case "6m":
+		return 10, true
+	}
+	return 0, false
+}
+
+// yaesuRawModeName is the inverse of yaesuRawModeDigit: what the rig is on,
+// sideband included, for the panel's mode buttons to highlight.
+func yaesuRawModeName(d byte) string {
+	switch d {
+	case '1':
+		return "LSB"
+	case '2':
+		return "USB"
+	case '3':
+		return "CW-U"
+	case '4':
+		return "FM"
+	case '5':
+		return "AM"
+	case '6':
+		return "RTTY-L"
+	case '7':
+		return "CW-L"
+	case '8':
+		return "DATA-L"
+	case '9':
+		return "RTTY-U"
+	case 'C':
+		return "DATA-U"
+	}
+	return ""
+}
+
+// SetYaesuSplitOffset puts the transmit VFO a fixed distance above the receive
+// one and turns split on, in a single action.
+//
+// This is the split an operator actually uses when working a pile-up: listen on
+// the DX, transmit up 5 kHz on phone or up 1 kHz on CW. Doing it by hand means
+// swapping VFOs, retuning and swapping back, which is exactly the fumbling a
+// panel should remove.
+//
+// The offset is applied to the RECEIVE frequency and written to the OTHER VFO —
+// whichever that is. On VFO B the roles are mirrored, so listening on B writes A.
+func (y *Yaesu) SetYaesuSplitOffset(offsetHz int64) error {
+	y.mu.Lock()
+	defer y.mu.Unlock()
+	if y.port == nil {
+		return fmt.Errorf("yaesu: not connected")
+	}
+	rx := y.curRXFreq
+	if rx <= 0 {
+		return fmt.Errorf("yaesu: no receive frequency read yet")
+	}
+	tx := rx + offsetHz
+	if tx <= 0 || tx > 999_999_999 {
+		return fmt.Errorf("yaesu: split frequency %d out of the CAT range", tx)
+	}
+	// Write the VFO we are NOT listening on.
+	cmd := "FB"
+	if y.curVFO == "B" {
+		cmd = "FA"
+	}
+	if err := y.write(fmt.Sprintf("%s%09d;", cmd, tx)); err != nil {
+		return err
+	}
+	if y.splitCmd == "" {
+		return fmt.Errorf("yaesu: this rig answered neither ST; nor FT; — split cannot be set")
+	}
+	time.Sleep(30 * time.Millisecond)
+	if err := y.write(fmt.Sprintf("%s1;", y.splitCmd)); err != nil {
+		return err
+	}
+	y.panel.Split = true
+	y.panel.SplitTXHz = tx
+	return nil
+}
+
+// SetYaesuKeySpeed sets the internal keyer speed in words per minute. The rig
+// clamps to its own 4-60 range; clamping here too keeps a slider from sending a
+// value that would simply be ignored, which reads as a dead control.
+func (y *Yaesu) SetYaesuKeySpeed(wpm int) error {
+	return y.setAndRefresh(fmt.Sprintf("KS%03d;", clampInt(wpm, 4, 60)))
+}
+
+// SetYaesuBreakIn toggles CW break-in (BK).
+func (y *Yaesu) SetYaesuBreakIn(on bool) error {
+	return y.setAndRefresh(fmt.Sprintf("BI%d;", boolDigit(on)))
+}
+
+// YaesuZeroIn is the CW ZIN function: the rig retunes itself so the station
+// being received lands exactly on the operator's CW pitch. It is a one-shot
+// action with no state to read back, so no settings refresh follows — and the
+// frequency change arrives through the normal poll like any other.
+func (y *Yaesu) YaesuZeroIn() error {
+	y.mu.Lock()
+	defer y.mu.Unlock()
+	if y.port == nil {
+		return fmt.Errorf("yaesu: not connected")
+	}
+	return y.write("ZI;")
+}
+
+// swrFromReflection turns the rig's SWR meter reading into the ratio itself.
+//
+// The raw value is the reflection coefficient scaled to 255 — established on an
+// FTDX10 by measuring at two known matches (0 at 1.1, 52 at 1.5; 52/255 = 0.204,
+// which is rho for a 1.5 SWR). So SWR = (1+rho)/(1-rho), physics rather than a
+// curve fitted to two points.
+//
+// Capped at 9.9: past that the number stops meaning anything to an operator, and
+// rho approaching 1 sends the ratio to infinity.
+func swrFromReflection(raw int) float64 {
+	if raw <= 0 {
+		return 1.0
+	}
+	rho := float64(raw) / 255.0
+	if rho >= 0.98 {
+		return 9.9
+	}
+	swr := (1 + rho) / (1 - rho)
+	if swr > 9.9 {
+		return 9.9
+	}
+	return swr
+}
+
+// yaesuWatts converts the power-meter reading to watts.
+//
+// The meter is NOT linear in power, which one calibration point could never
+// reveal: scaling 207 = 100 W straight down read 30 W where the rig showed 10,
+// and 75 where it showed 50. Three points measured against the radio's own
+// display settle the curve:
+//
+//	raw  62 → 10 W
+//	raw 155 → 50 W
+//	raw 207 → 100 W
+//
+// Interpolating between them reproduces the rig exactly at those points and
+// stays close in between — better than fitting a formula to three samples and
+// pretending it holds everywhere. Above the last point it keeps the final
+// segment's slope, so an amplifier-driving rig does not flatten at 100 W.
+//
+// Measured on an FTDX10 (2026-07-29). Another model may well need its own row.
+var yaesuPowerCurve = []struct {
+	raw   int
+	watts float64
+}{
+	{0, 0},
+	{62, 10},
+	{155, 50},
+	{207, 100},
+}
+
+func yaesuWatts(raw int) float64 {
+	if raw <= 0 {
+		return 0
+	}
+	for i := 1; i < len(yaesuPowerCurve); i++ {
+		hi := yaesuPowerCurve[i]
+		if raw <= hi.raw {
+			lo := yaesuPowerCurve[i-1]
+			span := float64(hi.raw - lo.raw)
+			if span <= 0 {
+				return hi.watts
+			}
+			f := float64(raw-lo.raw) / span
+			return lo.watts + f*(hi.watts-lo.watts)
+		}
+	}
+	// Past the top of the curve: extend the last segment rather than clamp.
+	n := len(yaesuPowerCurve)
+	lo, hi := yaesuPowerCurve[n-2], yaesuPowerCurve[n-1]
+	slope := (hi.watts - lo.watts) / float64(hi.raw-lo.raw)
+	return hi.watts + float64(raw-hi.raw)*slope
+}
+
+// meterPeak gives a meter the inertia a needle has: it jumps to a higher reading
+// at once, HOLDS it for a moment, then falls back gradually.
+//
+// The hold is the part that matters on the air. Between CW elements the gap is
+// milliseconds, but between the words of a CQ — in CW as in SSB — it is most of
+// a second, and a meter that decays straight away reads 0 in every one of those
+// gaps: the operator sees a bar flashing rather than the power they are running.
+type meterPeak struct {
+	val int
+	at  time.Time
+}
+
+const (
+	meterHold  = 1500 * time.Millisecond // how long a peak stands before it starts to fall
+	meterDecay = 4                       // then a quarter of the remaining gap per poll
+)
+
+// update returns the value to show for this sample.
+func (m *meterPeak) update(sample int, now time.Time) int {
+	if sample >= m.val {
+		m.val, m.at = sample, now
+		return m.val
+	}
+	if now.Sub(m.at) < meterHold {
+		return m.val // still inside the hold — the needle has not started to fall
+	}
+	// At least one step down, always. A proportional decay on integers stalls
+	// near the end: with the needle at 13 and the truth at 10, a quarter of the
+	// gap rounds to zero and the meter sits three units high for ever.
+	step := (m.val - sample) / meterDecay
+	if step < 1 {
+		step = 1
+	}
+	m.val -= step
+	if m.val <= sample {
+		m.val = sample
+	}
+	return m.val
+}

internal/cat/yaesu_split_test.go

@@ -0,0 +1,163 @@
+package cat
+
+import (
+	"testing"
+	"time"
+)
+
+// What SPLIT means when the operator presses it.
+//
+// Flipping the rig's split flag alone transmits wherever the OTHER VFO happens
+// to sit — reported from a real FTDX10: listening on 14.244 with VFO B left on
+// 18.115 from an earlier session, pressing SPLIT threw the transmitter onto
+// another band. The other VFO is stale by nature, so the transmit frequency has
+// to be derived from where the operator is listening now.
+func TestYaesuDefaultSplitOffset(t *testing.T) {
+	cases := []struct {
+		raw  string
+		want int64
+	}{
+		// CW and the data modes work 1 kHz up.
+		{"CW-U", 1000},
+		{"CW-L", 1000},
+		{"RTTY-U", 1000},
+		{"RTTY-L", 1000},
+		{"DATA-U", 1000},
+		{"DATA-L", 1000},
+		// Phone works 5 kHz up.
+		{"USB", 5000},
+		{"LSB", 5000},
+		{"AM", 5000},
+		{"FM", 5000},
+		// Unknown or not yet read: the phone offset is the safer default — too
+		// wide is audible and obvious, too narrow lands on top of the DX.
+		{"", 5000},
+	}
+	for _, c := range cases {
+		y := &Yaesu{}
+		y.panel.RawMode = c.raw
+		if got := y.defaultSplitOffset(); got != c.want {
+			t.Errorf("mode %q → split offset %d Hz, want %d", c.raw, got, c.want)
+		}
+	}
+}
+
+// The SWR scale, pinned to the two measurements it was derived from.
+//
+// Taken on an FTDX10 (2026-07-29) against an operator watching the rig's own
+// meter: raw 0 at SWR 1.1, raw 52 at SWR 1.5. The second point is what proved
+// the raw value is the reflection coefficient scaled to 255 — 52/255 = 0.204,
+// rho for a 1.5 SWR — rather than a percentage of meter travel, which is how the
+// bar came to read 81 on a perfect antenna.
+func TestSWRFromReflection(t *testing.T) {
+	cases := []struct {
+		raw  int
+		want float64
+		tol  float64
+	}{
+		{0, 1.0, 0.01},   // no reflected power
+		{52, 1.5, 0.02},  // the measured mismatch
+		{85, 2.0, 0.05},  // rho = 1/3
+		{128, 3.0, 0.1},  // rho = 0.5
+		{-5, 1.0, 0.01},  // nonsense reading — never below 1.0, which is physical
+		{255, 9.9, 0.01}, // full scale is capped rather than infinite
+	}
+	for _, c := range cases {
+		got := swrFromReflection(c.raw)
+		if got < c.want-c.tol || got > c.want+c.tol {
+			t.Errorf("swrFromReflection(%d) = %.2f, want %.2f ±%.2f", c.raw, got, c.want, c.tol)
+		}
+	}
+	// It must rise with the reflected power, or a worsening match would read
+	// better on the panel than on the rig.
+	prev := 0.0
+	for raw := 0; raw <= 200; raw += 20 {
+		v := swrFromReflection(raw)
+		if v < prev {
+			t.Fatalf("SWR fell from %.2f to %.2f at raw=%d", prev, v, raw)
+		}
+		prev = v
+	}
+}
+
+// Needle inertia on the TX meters.
+//
+// The gaps are what this is for: milliseconds between CW elements, but most of a
+// second between the words of a CQ — in CW as in SSB. A meter that decays
+// immediately reads 0 in every one of those gaps, so the operator sees a bar
+// flashing instead of the power they are running.
+func TestMeterPeakHold(t *testing.T) {
+	var m meterPeak
+	t0 := time.Now()
+
+	if got := m.update(80, t0); got != 80 {
+		t.Fatalf("first sample = %d, want 80 — a meter must show a reading at once", got)
+	}
+	// A gap between two words: still inside the hold, so the reading stands.
+	if got := m.update(0, t0.Add(400*time.Millisecond)); got != 80 {
+		t.Errorf("during a word gap = %d, want 80 held", got)
+	}
+	if got := m.update(0, t0.Add(1400*time.Millisecond)); got != 80 {
+		t.Errorf("just before the hold expires = %d, want 80 held", got)
+	}
+	// Past the hold it falls — but gradually, not to zero in one step.
+	after := m.update(0, t0.Add(1600*time.Millisecond))
+	if after >= 80 || after <= 0 {
+		t.Errorf("after the hold = %d, want a value falling between 80 and 0", after)
+	}
+	// A HIGHER reading is taken immediately: a needle rises fast and falls slow.
+	if got := m.update(95, t0.Add(1700*time.Millisecond)); got != 95 {
+		t.Errorf("rising sample = %d, want 95 straight away", got)
+	}
+	// And it does reach the real value eventually, or a power drop would never show.
+	v := 0
+	for i := 0; i < 60; i++ {
+		v = m.update(10, t0.Add(time.Duration(2000+i*250)*time.Millisecond))
+	}
+	if v != 10 {
+		t.Errorf("settled at %d, want 10 — the meter must converge on the truth", v)
+	}
+}
+
+// The power curve, pinned to the readings taken against the rig's own display.
+//
+// It is NOT linear, and one calibration point could not show that: scaling
+// 207 = 100 W straight down read 30 W where the radio showed 10, and 75 where it
+// showed 50. These are the three measured pairs, so a change to the curve that
+// breaks them is a regression against the radio, not against a preference.
+func TestYaesuPowerCurve(t *testing.T) {
+	cases := []struct {
+		raw   int
+		watts float64
+		tol   float64
+	}{
+		{0, 0, 0.1},
+		{62, 10, 0.5},   // measured
+		{155, 50, 0.5},  // measured
+		{207, 100, 0.5}, // measured
+		// Between the measured points it interpolates, so it must land inside the
+		// bracket rather than shooting past it.
+		{100, 30, 10},
+		{180, 75, 10},
+	}
+	for _, c := range cases {
+		got := yaesuWatts(c.raw)
+		if got < c.watts-c.tol || got > c.watts+c.tol {
+			t.Errorf("yaesuWatts(%d) = %.1f W, want %.1f ±%.1f", c.raw, got, c.watts, c.tol)
+		}
+	}
+	// Monotonic: more meter must never mean less power.
+	prev := -1.0
+	for raw := 0; raw <= 255; raw++ {
+		v := yaesuWatts(raw)
+		if v < prev {
+			t.Fatalf("power fell from %.1f to %.1f at raw=%d", prev, v, raw)
+		}
+		prev = v
+	}
+	// Above the top of the curve it keeps rising rather than flattening at 100 W —
+	// a rig driving an amplifier can read past its own full scale.
+	if v := yaesuWatts(230); v <= 100 {
+		t.Errorf("yaesuWatts(230) = %.1f, want more than 100 — the curve should extend", v)
+	}
+}

internal/cat/yaesu_test.go

@@ -0,0 +1,132 @@
+package cat
+
+import "testing"
+
+func TestParseYaesuFreq(t *testing.T) {
+	cases := []struct {
+		reply, prefix string
+		want          int64
+		ok            bool
+	}{
+		{"FA014074000;", "FA", 14074000, true},
+		{"FB007100000;", "FB", 7100000, true},
+		{"FA000474000;", "FA", 474000, true}, // 630 m — leading zeros must not truncate
+		{"FA010368000000;", "FA", 10368000000, true},
+		{"FB;", "FB", 0, false},          // query echoed back with no value
+		{"FA014074000;", "FB", 0, false}, // wrong VFO — never silently accepted
+		{"", "FA", 0, false},
+		{"FAxxxxxxxxx;", "FA", 0, false},
+	}
+	for _, c := range cases {
+		got, ok := parseYaesuFreq(c.reply, c.prefix)
+		if got != c.want || ok != c.ok {
+			t.Errorf("parseYaesuFreq(%q,%q) = %d,%v — want %d,%v", c.reply, c.prefix, got, ok, c.want, c.ok)
+		}
+	}
+}
+
+// The split rules. Getting these wrong writes a WRONG TX frequency into the log,
+// which is why an ambiguous state resolves to "not split" rather than to a
+// guess — the same principle the OmniRig backend arrived at the hard way.
+func TestResolveYaesuVFOs(t *testing.T) {
+	const a, b = 14074000, 14100000
+	cases := []struct {
+		name           string
+		fa, fb         int64
+		vfo            string
+		split          bool
+		wantTX, wantRX int64
+		wantSplit      bool
+	}{
+		{"simplex on A", a, b, "A", false, a, 0, false},
+		{"simplex on B", a, b, "B", false, b, 0, false},
+		{"split, listening on A → TX on B", a, b, "A", true, b, a, true},
+		{"split, listening on B → TX on A", a, b, "B", true, a, b, true},
+		{"split flag but the other VFO is unread", a, 0, "A", true, a, 0, false},
+		{"split flag but both VFOs identical", a, a, "A", true, a, 0, false},
+	}
+	for _, c := range cases {
+		tx, rx, sp := resolveYaesuVFOs(c.fa, c.fb, c.vfo, c.split)
+		if tx != c.wantTX || rx != c.wantRX || sp != c.wantSplit {
+			t.Errorf("%s: got tx=%d rx=%d split=%v — want tx=%d rx=%d split=%v",
+				c.name, tx, rx, sp, c.wantTX, c.wantRX, c.wantSplit)
+		}
+	}
+}
+
+// ST and FT say different things and must not be read the same way — see the
+// comment on yaesuSplitOn.
+func TestYaesuSplitReply(t *testing.T) {
+	cases := []struct {
+		reply, cmd string
+		want       bool
+	}{
+		{"ST1;", "ST", true},
+		{"ST0;", "ST", false},
+		{"FT1;", "FT", true},
+		{"FT0;", "FT", false},
+		{"ST1;", "FT", false}, // reply for the other command — not accepted
+		{"ST", "ST", false},   // truncated
+		{"", "ST", false},
+	}
+	for _, c := range cases {
+		if got := yaesuSplitOn(c.reply, c.cmd); got != c.want {
+			t.Errorf("yaesuSplitOn(%q,%q) = %v, want %v", c.reply, c.cmd, got, c.want)
+		}
+	}
+}
+
+// The sideband follows the frequency, worldwide convention — a CAT backend that
+// puts USB on 40 m makes every SSB QSO wrong.
+func TestYaesuModeDigit(t *testing.T) {
+	cases := []struct {
+		mode string
+		hz   int64
+		want byte
+	}{
+		{"SSB", 7150000, '1'},  // LSB below 10 MHz
+		{"SSB", 14250000, '2'}, // USB above
+		{"LSB", 14250000, '1'}, // explicit wins over the convention
+		{"USB", 7150000, '2'},
+		{"CW", 7030000, '3'},
+		{"RTTY", 14080000, '6'},
+		{"AM", 7150000, '5'},
+		{"FM", 145000000, '4'},
+		{"FT8", 7074000, '8'},  // DATA-LSB
+		{"FT8", 14074000, 'C'}, // DATA-USB
+		{"JS8", 14078000, 'C'}, // any unknown digital rides on DATA
+		{"", 14074000, 0},      // nothing to set
+	}
+	for _, c := range cases {
+		if got := yaesuModeDigit(c.mode, c.hz); got != c.want {
+			t.Errorf("yaesuModeDigit(%q, %d) = %q, want %q", c.mode, c.hz, got, c.want)
+		}
+	}
+}
+
+// A reply belongs to the command that asked for it.
+//
+// Without this, a CW macro knocked the CAT link over: KY produces no reply, so
+// the poll loop's next FA; collected a leftover frame, failed to parse it as a
+// frequency, and the Manager treated that as "lost the rig" and reconnected —
+// the CAT dropping for a few seconds on every macro click.
+func TestYaesuCmdPrefix(t *testing.T) {
+	cases := []struct{ cmd, want string }{
+		{"FA;", "FA"},
+		{"FB;", "FB"},
+		{"MD0;", "MD"},
+		{"KY;", "KY"},
+		{"KY CQ TEST;", "KY"},
+		{"SM0;", "SM"},
+		{"RM4;", "RM"},
+		{"AG0;", "AG"},
+		{"TX;", "TX"},
+		{"", ""},
+		{";", ""},
+	}
+	for _, c := range cases {
+		if got := cmdPrefix(c.cmd); got != c.want {
+			t.Errorf("cmdPrefix(%q) = %q, want %q", c.cmd, got, c.want)
+		}
+	}
+}

internal/qso/filter_status_test.go

@@ -0,0 +1,74 @@
+package qso
+
+import (
+	"context"
+	"path/filepath"
+	"testing"
+
+	"hamlog/internal/db"
+)
+
+// End-to-end proof that filtering a confirmation STATUS actually filters.
+//
+// Reported from the field: "QRZ.com received status = N" returned rows showing
+// both N and Y. The SQL is a plain `col = ?`, so either the query is right and
+// the fault is elsewhere (the UI keeping the previous rows on an error, say), or
+// it is wrong here. Reading the code cannot tell those apart — running it can.
+func TestFilterOnConfirmationStatus(t *testing.T) {
+	conn, err := db.Open(filepath.Join(t.TempDir(), "logbook.db"))
+	if err != nil {
+		t.Fatalf("open: %v", err)
+	}
+	defer conn.Close()
+	r := NewRepo(conn)
+	ctx := context.Background()
+
+	for _, c := range []struct{ call, status string }{
+		{"W1AAA", "Y"},
+		{"W1BBB", "N"},
+		{"W1CCC", "Y"},
+		{"W1DDD", "N"},
+		{"W1EEE", ""}, // never touched by a download — NULL/empty, neither Y nor N
+	} {
+		q := QSO{Callsign: c.call, Band: "20m", Mode: "SSB", QRZComDownloadStatus: c.status}
+		if _, err := r.Add(ctx, q); err != nil {
+			t.Fatalf("insert %s: %v", c.call, err)
+		}
+	}
+
+	got, err := r.ListFiltered(ctx, QueryFilter{
+		Conditions: []Condition{{Field: "qrzcom_qso_download_status", Op: "eq", Value: "N"}},
+		Match:      "AND",
+	})
+	if err != nil {
+		t.Fatalf("ListFiltered: %v", err)
+	}
+	if len(got) != 2 {
+		t.Fatalf("filter = N returned %d rows, want 2", len(got))
+	}
+	for _, q := range got {
+		if q.QRZComDownloadStatus != "N" {
+			t.Errorf("filter = N returned %s with status %q", q.Callsign, q.QRZComDownloadStatus)
+		}
+	}
+
+	// A count that disagreed with the list would show "2 matches" above a grid of
+	// five rows — the exact shape of the report.
+	n, err := r.CountFiltered(ctx, QueryFilter{
+		Conditions: []Condition{{Field: "qrzcom_qso_download_status", Op: "eq", Value: "N"}},
+	})
+	if err != nil {
+		t.Fatalf("CountFiltered: %v", err)
+	}
+	if n != 2 {
+		t.Errorf("CountFiltered = %d, want 2", n)
+	}
+}
+
+// An unknown field must ERROR rather than be silently dropped: a dropped
+// condition returns the whole logbook, which reads as "the filter did nothing".
+func TestFilterRejectsUnknownField(t *testing.T) {
+	if _, _, err := conditionSQL(Condition{Field: "not_a_column", Op: "eq", Value: "N"}); err == nil {
+		t.Error("unknown filter field accepted — it would silently return every QSO")
+	}
+}

internal/qso/qso.go

@@ -793,6 +793,11 @@ var bulkEditableCols = map[string]bool{
 	// here, so choosing one failed at Apply. The rest of the contacted station
 	// (callsign, name, RST…) stays deliberately out: bulk-setting those would
 	// corrupt the log.
+	// grid: the locator an import loses wholesale. Correcting it one QSO at a
+	// time is what the operator is trying to avoid, and unlike the callsign it
+	// carries no risk of confusing two stations — a wrong value is simply
+	// overwritten again.
+	"grid":  true,
 	"state": true,
 	"cnty":  true,
 	// Contest — the exchange/label fields that are constant across a run.

internal/rigctld/rigctld.go

@@ -0,0 +1,424 @@
+// Package rigctld shares OpsLog's CAT link with other programs.
+//
+// A native CAT backend owns the rig's serial port, and Windows gives a COM port
+// to ONE process. So the moment OpsLog talks to the radio directly, WSJT-X,
+// MSHV or JTDX can no longer reach it — the cost of dropping OmniRig, which was
+// itself a sharing layer.
+//
+// The answer is the one wfview uses: OpsLog becomes the server. It speaks the
+// Hamlib "net rigctl" protocol, which WSJT-X, JTDX, MSHV, Log4OM and CQRLOG all
+// support natively (rig model "Hamlib NET rigctl", host:4532) with no driver to
+// install. The other program asks us, and we relay to whichever backend is
+// connected — OmniRig, Flex, Icom, TCI or Yaesu alike.
+//
+// ── The protocol ──────────────────────────────────────────────────────────
+// Line-based ASCII. A lowercase letter reads, its uppercase counterpart writes,
+// and long names are prefixed with a backslash. A write answers "RPRT 0" for
+// success or "RPRT -n" for an error; a read answers the value(s), one per line.
+//
+//	f            → 14074000          get_freq
+//	F 14074000   → RPRT 0            set_freq
+//	m            → USB\n2400         get_mode (mode + passband)
+//	M USB 2400   → RPRT 0            set_mode
+//	t / T 1      → 0                 get/set PTT
+//	s            → 0\nVFOB           get_split_vfo
+//	v            → VFOA              get_vfo
+//	\dump_state  → capability block  asked once by WSJT-X at connect
+//
+// WSJT-X will not proceed past connect without a well-formed dump_state, which
+// is why that block is written out in full rather than stubbed.
+package rigctld
+
+import (
+	"bufio"
+	"fmt"
+	"net"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+)
+
+// Rig is what the server needs from OpsLog's CAT manager. An interface, so this
+// package stays testable without a radio and without importing internal/cat.
+type Rig interface {
+	Freq() int64          // current TX frequency in Hz, 0 if unknown
+	Mode() string         // ADIF mode (SSB, CW, FT8…)
+	Split() (bool, int64) // split on?, and the other VFO's frequency
+	SetFreq(hz int64) error
+	SetMode(mode string) error
+	SetPTT(on bool) error
+}
+
+type Server struct {
+	port int
+	rig  Rig
+	log  func(string, ...any)
+
+	mu     sync.Mutex
+	ln     net.Listener
+	conns  map[net.Conn]struct{}
+	closed bool
+}
+
+func New(port int, rig Rig, logf func(string, ...any)) *Server {
+	if port <= 0 || port > 65535 {
+		port = 4532 // the rigctld default every client pre-fills
+	}
+	if logf == nil {
+		logf = func(string, ...any) {}
+	}
+	return &Server{port: port, rig: rig, log: logf, conns: map[net.Conn]struct{}{}}
+}
+
+func (s *Server) Start() error {
+	s.mu.Lock()
+	if s.ln != nil {
+		s.mu.Unlock()
+		return nil // already listening
+	}
+	s.closed = false
+	s.mu.Unlock()
+
+	ln, err := net.Listen("tcp", fmt.Sprintf(":%d", s.port))
+	if err != nil {
+		return fmt.Errorf("rigctld: listen on %d: %w", s.port, err)
+	}
+	s.mu.Lock()
+	s.ln = ln
+	s.mu.Unlock()
+	s.log("rigctld: sharing CAT on port %d (Hamlib NET rigctl)", s.port)
+
+	go func() {
+		for {
+			c, err := ln.Accept()
+			if err != nil {
+				s.mu.Lock()
+				closed := s.closed
+				s.mu.Unlock()
+				if !closed {
+					s.log("rigctld: accept failed: %v", err)
+				}
+				return
+			}
+			s.mu.Lock()
+			s.conns[c] = struct{}{}
+			s.mu.Unlock()
+			go s.serve(c)
+		}
+	}()
+	return nil
+}
+
+func (s *Server) Stop() {
+	s.mu.Lock()
+	s.closed = true
+	ln := s.ln
+	s.ln = nil
+	conns := make([]net.Conn, 0, len(s.conns))
+	for c := range s.conns {
+		conns = append(conns, c)
+	}
+	s.conns = map[net.Conn]struct{}{}
+	s.mu.Unlock()
+
+	if ln != nil {
+		_ = ln.Close()
+	}
+	// Close the live sessions too. Leaving them open would keep a client happily
+	// talking to a server the operator has switched off.
+	for _, c := range conns {
+		_ = c.Close()
+	}
+}
+
+func (s *Server) serve(c net.Conn) {
+	defer func() {
+		s.mu.Lock()
+		delete(s.conns, c)
+		s.mu.Unlock()
+		_ = c.Close()
+	}()
+	s.log("rigctld: client connected from %s", c.RemoteAddr())
+	r := bufio.NewReader(c)
+	w := bufio.NewWriter(c)
+	for {
+		// No deadline: WSJT-X polls every few seconds but a client may legitimately
+		// sit idle between band changes, and dropping it would look like a fault.
+		line, err := r.ReadString('\n')
+		if err != nil {
+			s.log("rigctld: client %s disconnected", c.RemoteAddr())
+			return
+		}
+		resp, quit := s.handle(strings.TrimSpace(line))
+		if resp != "" {
+			if _, err := w.WriteString(resp); err != nil {
+				return
+			}
+			if err := w.Flush(); err != nil {
+				return
+			}
+		}
+		if quit {
+			return
+		}
+	}
+}
+
+// handle answers one command line. Pure apart from the Rig calls, so the whole
+// protocol is testable with a fake rig.
+func (s *Server) handle(line string) (resp string, quit bool) {
+	if line == "" {
+		return "", false
+	}
+	// Extended mode: clients may prefix a command with '+' or '-' to ask for a
+	// verbose reply. We answer in the plain format, which every client also
+	// accepts, so the prefix is simply stripped.
+	line = strings.TrimLeft(line, "+-")
+	fields := strings.Fields(line)
+	if len(fields) == 0 {
+		return "", false
+	}
+	cmd, args := fields[0], stripVFOArg(fields[1:])
+
+	switch cmd {
+	case "\\dump_state", "dump_state":
+		return dumpState, false
+	case "\\chk_vfo", "chk_vfo":
+		// "is VFO mode on?" — we answer for one VFO at a time, so: no.
+		return "CHKVFO 0\n", false
+	case "\\get_powerstat", "get_powerstat":
+		return "1\n", false
+	case "q", "Q", "\\quit":
+		return "", true
+
+	case "f", "\\get_freq":
+		return fmt.Sprintf("%d\n", s.rig.Freq()), false
+	case "F", "\\set_freq":
+		if len(args) < 1 {
+			return rprt(-1), false
+		}
+		hz, err := parseFreq(args[0])
+		if err != nil {
+			// Logged with the RAW line: a client that phrases a command in a
+			// dialect we don't accept shows only "Invalid parameter" on its side,
+			// which says nothing about what it actually sent.
+			s.log("rigctld: cannot read a frequency from %q — client dialect not handled", line)
+			return rprt(-1), false
+		}
+		if err := s.rig.SetFreq(hz); err != nil {
+			s.log("rigctld: set_freq %d failed: %v", hz, err)
+			return rprt(-9), false
+		}
+		return rprt(0), false
+
+	case "m", "\\get_mode":
+		// Passband width is required by the protocol. We do not read the rig's
+		// filter, and a made-up number is harmless here: clients use it to display
+		// a bandwidth, never to decide anything.
+		return fmt.Sprintf("%s\n%d\n", adifToHamlib(s.rig.Mode()), passbandFor(s.rig.Mode())), false
+	case "M", "\\set_mode":
+		if len(args) < 1 {
+			return rprt(-1), false
+		}
+		if err := s.rig.SetMode(hamlibToADIF(args[0])); err != nil {
+			s.log("rigctld: set_mode %q failed: %v", args[0], err)
+			return rprt(-9), false
+		}
+		return rprt(0), false
+
+	case "t", "\\get_ptt":
+		// We do not read PTT back from every backend, and answering "transmitting"
+		// wrongly would make a client hold off for ever. Reporting RX is the safe
+		// direction: the worst case is a client that transmits when we said it
+		// could, which is what it was going to do anyway.
+		return "0\n", false
+	case "T", "\\set_ptt":
+		if len(args) < 1 {
+			return rprt(-1), false
+		}
+		on := args[0] != "0"
+		if err := s.rig.SetPTT(on); err != nil {
+			s.log("rigctld: set_ptt %v failed: %v", on, err)
+			return rprt(-9), false
+		}
+		return rprt(0), false
+
+	case "v", "\\get_vfo":
+		return "VFOA\n", false
+	case "V", "\\set_vfo":
+		// Accepted and ignored: OpsLog follows the rig's own VFO selection, and
+		// answering an error here makes WSJT-X abandon the connection entirely.
+		return rprt(0), false
+
+	case "s", "\\get_split_vfo":
+		on, _ := s.rig.Split()
+		n := 0
+		if on {
+			n = 1
+		}
+		return fmt.Sprintf("%d\nVFOB\n", n), false
+	case "S", "\\set_split_vfo":
+		return rprt(0), false // see set_vfo — split is driven from the rig
+	case "i", "\\get_split_freq":
+		_, tx := s.rig.Split()
+		if tx <= 0 {
+			tx = s.rig.Freq()
+		}
+		return fmt.Sprintf("%d\n", tx), false
+	case "I", "\\set_split_freq":
+		return rprt(0), false
+
+	default:
+		// RPRT -11 is "command not implemented". Answering something is essential:
+		// a client waiting on a silent socket hangs rather than degrading.
+		s.log("rigctld: unimplemented command %q", line)
+		return rprt(-11), false
+	}
+}
+
+func rprt(code int) string { return fmt.Sprintf("RPRT %d\n", code) }
+
+// stripVFOArg drops a leading VFO name from a command's arguments.
+//
+// Hamlib has two dialects. In the plain one a client sends "F 14074000"; in VFO
+// mode it names the target first — "F VFOA 14074000". MSHV uses the first and
+// worked immediately; JTDX uses the second, so the frequency landed in the
+// argument slot where a VFO was expected, the parse failed, and JTDX showed
+// "Hamlib error: Invalid parameter while setting frequency" (our RPRT -1).
+//
+// Accepting both costs nothing here: OpsLog follows the rig's own VFO
+// selection, so the name carries no information we act on — dropping it is not
+// losing anything, and refusing it locks out a whole family of clients.
+func stripVFOArg(args []string) []string {
+	if len(args) == 0 {
+		return args
+	}
+	switch strings.ToUpper(args[0]) {
+	case "VFOA", "VFOB", "VFOC", "VFO", "CURRVFO", "CURR", "MAIN", "SUB", "MEM", "A", "B":
+		return args[1:]
+	}
+	return args
+}
+
+// parseFreq accepts both the integer Hz and the "14074000.000000" form clients
+// send interchangeably.
+func parseFreq(s string) (int64, error) {
+	s = strings.TrimSpace(s)
+	if i := strings.IndexByte(s, '.'); i >= 0 {
+		s = s[:i]
+	}
+	hz, err := strconv.ParseInt(s, 10, 64)
+	if err != nil || hz <= 0 {
+		return 0, fmt.Errorf("rigctld: bad frequency %q", s)
+	}
+	return hz, nil
+}
+
+// adifToHamlib maps our mode vocabulary to Hamlib's. Every digital sub-mode
+// becomes PKTUSB: that is what a client expects to see when the rig is in DATA,
+// and it is what WSJT-X sets when it takes control.
+func adifToHamlib(mode string) string {
+	switch strings.ToUpper(strings.TrimSpace(mode)) {
+	case "SSB", "USB":
+		return "USB"
+	case "LSB":
+		return "LSB"
+	case "CW":
+		return "CW"
+	case "AM":
+		return "AM"
+	case "FM":
+		return "FM"
+	case "RTTY":
+		return "RTTY"
+	case "":
+		return "USB"
+	default:
+		return "PKTUSB"
+	}
+}
+
+// hamlibToADIF is the reverse. PKTUSB/PKTLSB/DATA become "DATA": the CAT backend
+// then applies the operator's configured digital mode, so a client switching the
+// rig to data does not silently relabel their QSOs as FT8 when they run JS8.
+func hamlibToADIF(mode string) string {
+	switch strings.ToUpper(strings.TrimSpace(mode)) {
+	case "USB":
+		return "USB"
+	case "LSB":
+		return "LSB"
+	case "CW", "CWR":
+		return "CW"
+	case "AM":
+		return "AM"
+	case "FM", "FMN", "WFM":
+		return "FM"
+	case "RTTY", "RTTYR":
+		return "RTTY"
+	case "PKTUSB", "PKTLSB", "PKTFM", "DATA", "DIGU", "DIGL":
+		return "DATA"
+	default:
+		return strings.ToUpper(strings.TrimSpace(mode))
+	}
+}
+
+func passbandFor(mode string) int {
+	switch adifToHamlib(mode) {
+	case "CW":
+		return 500
+	case "RTTY", "PKTUSB":
+		return 3000
+	case "AM":
+		return 6000
+	case "FM":
+		return 15000
+	default:
+		return 2400
+	}
+}
+
+// dumpState is the capability block Hamlib clients read once at connect. WSJT-X
+// refuses to go further without it, and parses it positionally — the field
+// ORDER is the contract, so this is kept as one literal rather than assembled.
+//
+// It declares protocol version 0, a generic rig, and one 150 kHz–1500 MHz range
+// with the common modes. The numbers are deliberately permissive: they say what
+// a client may ASK for, and OpsLog's backend refuses anything the radio cannot
+// really do.
+const dumpState = `0
+1
+2
+150000.000000 1500000000.000000 0x1ff -1 -1 0x10000003 0x3
+0 0 0 0 0 0 0
+150000.000000 1500000000.000000 0x1ff -1 -1 0x10000003 0x3
+0 0 0 0 0 0 0
+0 0
+0 0
+0x1ff 1
+0x1ff 0
+0 0
+0x1e 2400
+0x2 500
+0x1 8000
+0x1 2400
+0x20 15000
+0x20 8000
+0x40 230000
+0 0
+9990
+9990
+10000
+0
+10
+10 20 30
+0x3effffff
+0x3effffff
+0x7fffffff
+0x7fffffff
+0x7fffffff
+0x7fffffff
+`
+
+// dialTimeout is only used by tests, kept here so the value is one place.
+const dialTimeout = 2 * time.Second

internal/rigctld/rigctld_test.go

@@ -0,0 +1,235 @@
+package rigctld
+
+import (
+	"bufio"
+	"fmt"
+	"net"
+	"strings"
+	"sync"
+	"testing"
+)
+
+// fakeRig stands in for the CAT manager.
+type fakeRig struct {
+	mu       sync.Mutex
+	freq     int64
+	mode     string
+	split    bool
+	txFreq   int64
+	ptt      bool
+	setFreqs []int64
+	setModes []string
+	failSet  bool
+}
+
+func (f *fakeRig) Freq() int64          { f.mu.Lock(); defer f.mu.Unlock(); return f.freq }
+func (f *fakeRig) Mode() string         { f.mu.Lock(); defer f.mu.Unlock(); return f.mode }
+func (f *fakeRig) Split() (bool, int64) { f.mu.Lock(); defer f.mu.Unlock(); return f.split, f.txFreq }
+func (f *fakeRig) SetFreq(hz int64) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	if f.failSet {
+		return fmt.Errorf("rig refused")
+	}
+	f.freq = hz
+	f.setFreqs = append(f.setFreqs, hz)
+	return nil
+}
+func (f *fakeRig) SetMode(m string) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	if f.failSet {
+		return fmt.Errorf("rig refused")
+	}
+	f.mode = m
+	f.setModes = append(f.setModes, m)
+	return nil
+}
+func (f *fakeRig) SetPTT(on bool) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	if f.failSet {
+		return fmt.Errorf("rig refused")
+	}
+	f.ptt = on
+	return nil
+}
+
+// The command table. These exact strings are what WSJT-X and MSHV put on the
+// wire, so they are the contract — a reply in the wrong shape does not degrade
+// gracefully, the client simply refuses to work with the rig.
+func TestHandleCommands(t *testing.T) {
+	rig := &fakeRig{freq: 14074000, mode: "FT8", split: true, txFreq: 14100000}
+	s := New(0, rig, nil)
+
+	cases := []struct{ in, want string }{
+		{"f", "14074000\n"},
+		{"\\get_freq", "14074000\n"},
+		{"m", "PKTUSB\n3000\n"}, // a digital mode reads as PKTUSB
+		{"t", "0\n"},            // PTT always reads RX — see the comment
+		{"v", "VFOA\n"},
+		{"s", "1\nVFOB\n"},  // split on, TX on B
+		{"i", "14100000\n"}, // split TX frequency
+		{"F 14200000", "RPRT 0\n"},
+		{"F 14200000.000000", "RPRT 0\n"}, // the float form clients also send
+		{"M USB 2400", "RPRT 0\n"},
+		{"T 1", "RPRT 0\n"},
+		{"V VFOB", "RPRT 0\n"}, // accepted and ignored, never an error
+		{"S 1 VFOB", "RPRT 0\n"},
+		{"\\chk_vfo", "CHKVFO 0\n"},
+		{"F", "RPRT -1\n"}, // missing argument
+		{"F not_a_number", "RPRT -1\n"},
+		{"Z", "RPRT -11\n"}, // unknown → answered, never silence
+		{"", ""},
+	}
+	for _, c := range cases {
+		got, _ := s.handle(c.in)
+		if got != c.want {
+			t.Errorf("handle(%q) = %q, want %q", c.in, got, c.want)
+		}
+	}
+	if q := func() bool { _, q := s.handle("q"); return q }(); !q {
+		t.Error("q must end the session")
+	}
+}
+
+// Hamlib's VFO dialect. JTDX names the target VFO before the value — "F VFOA
+// 14074000" — where MSHV sends "F 14074000". Reading the VFO name as the
+// frequency is what produced "Hamlib error: Invalid parameter while setting
+// frequency" on JTDX while MSHV worked perfectly.
+func TestHandleAcceptsVFOPrefixedCommands(t *testing.T) {
+	rig := &fakeRig{freq: 7074000, mode: "SSB"}
+	s := New(0, rig, nil)
+
+	if got, _ := s.handle("F VFOA 14074000"); got != "RPRT 0\n" {
+		t.Fatalf("handle(\"F VFOA 14074000\") = %q, want RPRT 0", got)
+	}
+	if got := rig.Freq(); got != 14074000 {
+		t.Errorf("frequency = %d, want 14074000 — the VFO name swallowed the value", got)
+	}
+	if got, _ := s.handle("M VFOA USB 2400"); got != "RPRT 0\n" {
+		t.Errorf("handle(\"M VFOA USB 2400\") = %q, want RPRT 0", got)
+	}
+	if got, _ := s.handle("T VFOA 1"); got != "RPRT 0\n" {
+		t.Errorf("handle(\"T VFOA 1\") = %q, want RPRT 0", got)
+	}
+	// A read with the VFO named must still answer the value, not an error.
+	if got, _ := s.handle("f VFOA"); got != "14074000\n" {
+		t.Errorf("handle(\"f VFOA\") = %q, want the frequency", got)
+	}
+	// And the plain dialect must keep working — this is an ADDITION, not a swap.
+	if got, _ := s.handle("F 21074000"); got != "RPRT 0\n" {
+		t.Errorf("plain set_freq broke: %q", got)
+	}
+	// "S 1 VFOB" starts with the split flag, not a VFO: nothing must be eaten.
+	if got, _ := s.handle("S 1 VFOB"); got != "RPRT 0\n" {
+		t.Errorf("handle(\"S 1 VFOB\") = %q, want RPRT 0", got)
+	}
+}
+
+// A rig that refuses must produce an error report, not a success — a client told
+// "RPRT 0" believes the radio moved and will log the wrong frequency.
+func TestHandleReportsBackendFailure(t *testing.T) {
+	s := New(0, &fakeRig{failSet: true}, nil)
+	for _, in := range []string{"F 14200000", "M USB 2400", "T 1"} {
+		if got, _ := s.handle(in); got != "RPRT -9\n" {
+			t.Errorf("handle(%q) with a failing rig = %q, want RPRT -9", in, got)
+		}
+	}
+}
+
+// dump_state is parsed POSITIONALLY by Hamlib clients: WSJT-X reads the first
+// line as the protocol version and refuses to continue if the block is short or
+// misshapen. Pinning its shape is what stops a well-meaning edit from silently
+// breaking every client.
+func TestDumpStateShape(t *testing.T) {
+	lines := strings.Split(strings.TrimRight(dumpState, "\n"), "\n")
+	if len(lines) < 20 {
+		t.Fatalf("dump_state has %d lines — clients expect the full capability block", len(lines))
+	}
+	if lines[0] != "0" {
+		t.Errorf("dump_state protocol version = %q, want \"0\"", lines[0])
+	}
+	// The frequency-range lines must carry seven fields, or the client's parse
+	// slides and every later capability is read from the wrong place.
+	for _, i := range []int{3, 5} {
+		if n := len(strings.Fields(lines[i])); n != 7 {
+			t.Errorf("dump_state line %d has %d fields, want 7: %q", i, n, lines[i])
+		}
+	}
+}
+
+// End to end over a real socket, because the framing (one reply per line,
+// flushed immediately) is as much a part of the contract as the text.
+func TestServerOverTCP(t *testing.T) {
+	rig := &fakeRig{freq: 7074000, mode: "SSB"}
+	s := New(0, rig, nil)
+	ln, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatalf("listen: %v", err)
+	}
+	s.mu.Lock()
+	s.ln = ln
+	s.mu.Unlock()
+	go func() {
+		for {
+			c, err := ln.Accept()
+			if err != nil {
+				return
+			}
+			go s.serve(c)
+		}
+	}()
+	defer s.Stop()
+
+	c, err := net.DialTimeout("tcp", ln.Addr().String(), dialTimeout)
+	if err != nil {
+		t.Fatalf("dial: %v", err)
+	}
+	defer c.Close()
+	r := bufio.NewReader(c)
+
+	if _, err := c.Write([]byte("f\n")); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+	line, err := r.ReadString('\n')
+	if err != nil {
+		t.Fatalf("read: %v", err)
+	}
+	if strings.TrimSpace(line) != "7074000" {
+		t.Errorf("get_freq over TCP = %q, want 7074000", strings.TrimSpace(line))
+	}
+
+	if _, err := c.Write([]byte("F 14074000\n")); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+	line, _ = r.ReadString('\n')
+	if strings.TrimSpace(line) != "RPRT 0" {
+		t.Errorf("set_freq over TCP = %q, want RPRT 0", strings.TrimSpace(line))
+	}
+	if got := rig.Freq(); got != 14074000 {
+		t.Errorf("rig frequency = %d, want 14074000 — the command never reached it", got)
+	}
+}
+
+func TestModeMapping(t *testing.T) {
+	for _, c := range []struct{ adif, hamlib string }{
+		{"SSB", "USB"}, {"LSB", "LSB"}, {"CW", "CW"}, {"RTTY", "RTTY"},
+		{"FT8", "PKTUSB"}, {"JS8", "PKTUSB"}, {"", "USB"},
+	} {
+		if got := adifToHamlib(c.adif); got != c.hamlib {
+			t.Errorf("adifToHamlib(%q) = %q, want %q", c.adif, got, c.hamlib)
+		}
+	}
+	// Digital comes back as DATA, never as a specific sub-mode: the CAT backend
+	// applies the operator's own digital default, so a client that switches the
+	// rig to data does not relabel a JS8 operator's QSOs as FT8.
+	for _, c := range []struct{ hamlib, adif string }{
+		{"PKTUSB", "DATA"}, {"PKTLSB", "DATA"}, {"DIGU", "DATA"},
+		{"USB", "USB"}, {"CWR", "CW"}, {"FMN", "FM"},
+	} {
+		if got := hamlibToADIF(c.hamlib); got != c.adif {
+			t.Errorf("hamlibToADIF(%q) = %q, want %q", c.hamlib, got, c.adif)
+		}
+	}
+}

internal/winkeyer/config_test.go

@@ -0,0 +1,71 @@
+package winkeyer
+
+import "testing"
+
+// The init sequence sent to a K1EL keyer, byte for byte.
+//
+// This exists because of a bug that no amount of reading caught and that a
+// byte-level trace from a real WK2 settled in one line: the dit/dah ratio was
+// sent as command 0x11, which is SET KEY COMPENSATION in milliseconds. A
+// neutral ratio of 50 therefore asked for 50 ms of extra key-down on every
+// element — at 25 wpm a dit is 48 ms — so elements more than doubled and ran
+// into each other. The operator saw "one element, then it stalls".
+//
+// The command NUMBERS are the contract with the hardware. A test on the values
+// is the only thing standing between a typo here and a keyer that misbehaves in
+// a way nobody can debug from the UI.
+func TestApplyConfigCommands(t *testing.T) {
+	cmds := configCommands(Config{
+		WPM: 25, Weight: 50, Ratio: 50, LeadInMs: 0, TailMs: 0, Sidetone: 0,
+	})
+
+	// Every command that must be present, with the value it must carry.
+	want := map[byte][]byte{
+		0x02: {25},   // speed
+		0x03: {50},   // weighting — 50 is neutral, and this one WAS right
+		0x17: {50},   // dit/dah ratio — the corrected opcode
+		0x11: {0x00}, // key compensation explicitly cleared
+	}
+	seen := map[byte][]byte{}
+	for _, c := range cmds {
+		if len(c) < 2 {
+			t.Fatalf("command %X has no argument", c)
+		}
+		seen[c[0]] = c[1:]
+	}
+	for op, args := range want {
+		got, ok := seen[op]
+		if !ok {
+			t.Errorf("command 0x%02X is not sent at all", op)
+			continue
+		}
+		if len(got) != len(args) || (len(args) > 0 && got[0] != args[0]) {
+			t.Errorf("command 0x%02X carries % X, want % X", op, got, args)
+		}
+	}
+
+	// The ratio must NEVER go out as 0x11 again: that is the whole bug.
+	if v, ok := seen[0x11]; ok && len(v) > 0 && v[0] != 0 {
+		t.Errorf("0x11 (key compensation) carries %d — it must be 0, not the ratio", v[0])
+	}
+}
+
+// A keyer left with compensation by an earlier version keeps it in EEPROM, so
+// the fix has to CLEAR it rather than merely stop setting it.
+func TestKeyCompensationIsCleared(t *testing.T) {
+	for _, ratio := range []int{33, 50, 66} {
+		cmds := configCommands(Config{WPM: 20, Weight: 50, Ratio: ratio})
+		found := false
+		for _, c := range cmds {
+			if c[0] == 0x11 {
+				found = true
+				if c[1] != 0 {
+					t.Errorf("ratio %d: key compensation sent as %d, want 0", ratio, c[1])
+				}
+			}
+		}
+		if !found {
+			t.Errorf("ratio %d: key compensation is never cleared", ratio)
+		}
+	}
+}

internal/winkeyer/winkeyer.go

@@ -243,21 +243,39 @@ func (m *Manager) connectSerial(cfg Config) error {
 	return nil
 }
 
-// applyConfig pushes the keying parameters to the device.
-func (m *Manager) applyConfig(c Config) error {
+// configCommands is the init sequence for a config — separated from the sending
+// so the BYTES can be tested. The command numbers are the contract with the
+// hardware, and a wrong one produces a keyer that misbehaves in a way no amount
+// of reading the UI explains.
+func configCommands(c Config) [][]byte {
 	cmds := [][]byte{
 		{0x0E, modeRegister(c)},                            // set mode register (paddle mode, swap, autospace…)
 		{0x02, byte(c.WPM)},                                // set speed (WPM)
 		{0x03, byte(c.Weight)},                             // set weighting
 		{0x04, byte(c.LeadInMs / 10), byte(c.TailMs / 10)}, // PTT lead-in / tail (10 ms units)
-		{0x11, byte(c.Ratio)},                              // set dit/dah ratio
+		// Dit/dah ratio is 0x17. It was being sent as 0x11, which on a WinKeyer 2
+		// is SET KEY COMPENSATION — in milliseconds. So a neutral ratio of 50 was
+		// read as 50 ms of extra key-down on every element: at 25 wpm a dit is
+		// 48 ms, so each element more than doubled and ran into the next. That is
+		// the reported "it sends one element then stalls", and it was in the trace
+		// as "TX 11 32".
+		{0x17, byte(c.Ratio)},
+		// And clear the compensation explicitly. A keyer left at 50 ms by the
+		// previous version — or by another program — keeps it in EEPROM, so
+		// merely stopping the wrong command would not fix an affected keyer.
+		{0x11, 0x00},
 	}
 	// Sidetone: <0x01 n>. Bit6 enables, low nibble selects the pitch divisor.
 	cmds = append(cmds, []byte{0x01, sidetoneCode(c.Sidetone)})
 	if c.Farnsworth > 0 {
 		cmds = append(cmds, []byte{0x0D, byte(c.Farnsworth)}) // Farnsworth WPM
 	}
-	for _, cmd := range cmds {
+	return cmds
+}
+
+// applyConfig pushes the keying parameters to the device.
+func (m *Manager) applyConfig(c Config) error {
+	for _, cmd := range configCommands(c) {
 		if err := m.write(cmd); err != nil {
 			return err
 		}
@@ -478,10 +496,12 @@ func cmdName(b []byte) string {
 		return "clear buffer"
 	case 0x0D:
 		return "farnsworth wpm"
+	case 0x17:
+		return "set dit/dah ratio"
 	case 0x0E:
 		return "set mode register"
 	case 0x11:
-		return "0x11 (WK2: key compensation / WK3: see datasheet)"
+		return "set key compensation (ms)"
 	case 0x15:
 		return "request status"
 	default:

telemetry.go

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

uls_lookup_test.go

@@ -0,0 +1,60 @@
+package main
+
+import (
+	"testing"
+
+	"hamlog/internal/uls"
+)
+
+// The ULS grid rules, which are NOT the same as refineGrid's.
+//
+// cty.dat answers a US call with the ENTITY centroid — a 4-character square in
+// the middle of the country. refineGrid keeps it (the ULS square is not an
+// extension of it, it is a different square), which is right for a QRZ grid and
+// wrong here: a per-callsign FCC square beats any entity centroid. But a
+// 6-character grid already present came from a provider and must survive.
+func TestULSGridPreference(t *testing.T) {
+	cases := []struct {
+		name string
+		have string // grid already on the result
+		uls  string // grid from the FCC database
+		want string
+	}{
+		{"nothing known → take ULS", "", "EM12AB", "EM12AB"},
+		{"cty.dat entity centroid → ULS wins", "EN90", "EM12AB", "EM12AB"},
+		{"4-char square, same square → ULS extends it", "EM12", "EM12AB", "EM12AB"},
+		{"provider gave 6 chars → untouched", "FN31PR", "EM12AB", "FN31PR"},
+		{"ULS has only 4 chars, provider has 6 → untouched", "FN31PR", "EM12", "FN31PR"},
+		{"ULS empty → untouched", "EN90", "", "EN90"},
+	}
+	for _, c := range cases {
+		got := c.have
+		if g := refineGrid(got, c.uls); g != "" && g != got {
+			got = g
+		} else if len(got) <= 4 && len(c.uls) >= 6 {
+			got = c.uls
+		}
+		if got != c.want {
+			t.Errorf("%s: have=%q uls=%q → %q, want %q", c.name, c.have, c.uls, got, c.want)
+		}
+	}
+}
+
+// CNTY is what gets written to the QSO's county field, so its shape is part of
+// the contract: ADIF wants "State,County" and nothing when either half is
+// missing — a lone county name would be an invalid CNTY on export.
+func TestULSCountyFormat(t *testing.T) {
+	cases := []struct {
+		loc  uls.Location
+		want string
+	}{
+		{uls.Location{State: "MA", County: "Middlesex"}, "MA,Middlesex"},
+		{uls.Location{State: "", County: "Middlesex"}, ""},
+		{uls.Location{State: "MA", County: ""}, ""},
+	}
+	for _, c := range cases {
+		if got := c.loc.CNTY(); got != c.want {
+			t.Errorf("Location%+v.CNTY() = %q, want %q", c.loc, got, c.want)
+		}
+	}
+}