chore: release v0.27.9

Only Kenwood implements it — TX1 is that family's second transmit
command — and every other backend keys the one way it knows. A checkbox
offered to all of them would change nothing on most, which is the same
dead furniture as ANT2 on a radio with one socket. Gated on the Kenwood
backend, and the label says so.

app.go

@@ -195,6 +195,7 @@ const (
 	keyAudioQSOPlayGain = "audio.qso_play_gain" // QSO-recording playback level %
 	keyAudioPTTMethod   = "audio.ptt_method"    // "none" (VOX) | "rts" | "dtr"
 	keyAudioPTTPort     = "audio.ptt_port"      // COM port for serial PTT
+	keyAudioPTTData     = "audio.ptt_data"      // keyer audio arrives on the rig DATA/USB input
 	keyAudioFormat      = "audio.qso_format"    // "wav" | "mp3"
 	keyAudioFromGain    = "audio.from_gain"     // From Radio (RX) mix level, percent
 	keyAudioMicGain     = "audio.mic_gain"      // mic mix level, percent
@@ -8330,8 +8331,15 @@ func (a *App) GetCATSettings() (CATSettings, error) {
 	if n, _ := strconv.Atoi(m[keyCATIcomBaud]); n > 0 {
 		out.IcomBaud = n
 	}
-	if n, _ := strconv.Atoi(m[keyCATIcomAddr]); n > 0 && n <= 0xFF {
-		out.IcomAddr = n
+	// 0x00 is a real CI-V address an operator may need (a bare interface, a rig
+	// left at its factory broadcast address), and "> 0" silently sent them back
+	// to the IC-7610 default with no way to say what they meant. An EMPTY
+	// setting is what means "never configured" — so the error is what decides,
+	// not the value.
+	if v := strings.TrimSpace(m[keyCATIcomAddr]); v != "" {
+		if n, err := strconv.Atoi(v); err == nil && n >= 0 && n <= 0xFF {
+			out.IcomAddr = n
+		}
 	}
 	if out.Backend == "" {
 		out.Backend = "omnirig"
@@ -8522,11 +8530,15 @@ type AudioSettings struct {
 	PrerollSeconds  int    `json:"preroll_seconds"`  // rolling pre-roll (default 8)
 	PTTMethod       string `json:"ptt_method"`       // "none" (VOX) | "rts" | "dtr"
 	PTTPort         string `json:"ptt_port"`         // COM port for serial PTT
-	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
-	QSOPlayGain     int    `json:"qso_play_gain"`    // QSO-recording playback level %, default 100
+	// PTTData: the keyer's audio reaches the radio on its DATA/USB input, not
+	// the microphone socket. CAT keying only — it changes which transmit
+	// command is sent (a Kenwood TS-590 takes TX1 instead of TX).
+	PTTData     bool   `json:"ptt_data"`
+	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
+	QSOPlayGain int    `json:"qso_play_gain"` // QSO-recording playback level %, default 100
 }
 
 // ListAudioInputDevices / ListAudioOutputDevices enumerate WASAPI endpoints
@@ -8583,7 +8595,7 @@ func (a *App) GetAudioSettings() (AudioSettings, error) {
 	}
 	m, err := a.settings.GetMany(a.ctx,
 		keyAudioFromRadio, keyAudioToRadio, keyAudioRecDevice, keyAudioListenDevice,
-		keyAudioQSORecord, keyAudioQSODir, keyAudioPreroll, keyAudioPTTMethod, keyAudioPTTPort, keyAudioFormat,
+		keyAudioQSORecord, keyAudioQSODir, keyAudioPreroll, keyAudioPTTMethod, keyAudioPTTPort, keyAudioPTTData, keyAudioFormat,
 		keyAudioFromGain, keyAudioMicGain, keyAudioTXGain, keyAudioQSOPlayGain)
 	if err != nil {
 		return out, err
@@ -8595,6 +8607,7 @@ func (a *App) GetAudioSettings() (AudioSettings, error) {
 		out.PTTMethod = v
 	}
 	out.PTTPort = m[keyAudioPTTPort]
+	out.PTTData = m[keyAudioPTTData] == "1"
 	out.FromRadio = m[keyAudioFromRadio]
 	out.ToRadio = m[keyAudioToRadio]
 	out.RecordingDevice = m[keyAudioRecDevice]
@@ -8665,6 +8678,7 @@ func (a *App) SaveAudioSettings(s AudioSettings) error {
 		keyAudioPreroll:      strconv.Itoa(s.PrerollSeconds),
 		keyAudioPTTMethod:    pttMethod,
 		keyAudioPTTPort:      strings.TrimSpace(s.PTTPort),
+		keyAudioPTTData:      boolStr(s.PTTData),
 		keyAudioFormat:       format,
 		keyAudioFromGain:     strconv.Itoa(s.FromGain),
 		keyAudioMicGain:      strconv.Itoa(s.MicGain),
@@ -10592,7 +10606,7 @@ func (a *App) pttKey(cfg AudioSettings) error {
 		if a.cat == nil {
 			return fmt.Errorf("CAT not initialized")
 		}
-		if err := a.cat.SetPTT(true); err != nil {
+		if err := a.cat.SetPTTSource(true, cfg.PTTData); err != nil {
 			applog.Printf("ptt: CAT SetPTT failed: %v", err)
 			return err
 		}

changelog.json

@@ -1,4 +1,34 @@
 [
+  {
+    "version": "0.27.9",
+    "date": "",
+    "en": [
+      "FT decodes warn when the decoding application announces a band the radio is not on — the signature of a lost CAT link, where it repeats the last frequency it knew and every decode after that carries a stale band. Nothing downstream could tell, so NEW BAND was being judged against a band the operator had left. OpsLog says it rather than deciding: a second receiver on another band is a real setup, and it costs that one only a line to read past.",
+      "Voice keyer with CAT keying: an option saying the keyer’s audio arrives on the radio’s DATA / USB input rather than the microphone socket. A Kenwood TS-590 has two transmit commands — TX opens the front mic, TX1 the rear ACC2/USB — so a keyer playing through the rig’s own sound card was transmitting dead air while the radio listened to a microphone nobody was speaking into. Shown on the Kenwood backend only — no other radio family draws the distinction — and the Test PTT button exercises the same path."
+    ],
+    "fr": [
+      "Les FT decodes signalent quand le logiciel de décodage annonce une bande sur laquelle la radio n’est pas — la signature d’une liaison CAT perdue, où il répète la dernière fréquence connue et où tous les décodages suivants portent une bande périmée. Rien en aval ne pouvait s’en apercevoir : NOUVELLE BANDE était donc jugé sur une bande quittée. OpsLog le dit sans décider à votre place : un second récepteur sur une autre bande est une configuration légitime, et il ne lui en coûte qu’une ligne à ignorer.",
+      "Voice keyer avec PTT CAT : une option indiquant que l’audio du keyer arrive sur l’entrée DATA / USB de la radio et non sur la prise micro. Un Kenwood TS-590 a deux commandes d’émission — TX ouvre le micro de face avant, TX1 l’ACC2/USB — si bien qu’un keyer jouant par la carte son du poste émettait dans le vide pendant que la radio écoutait un micro devant lequel personne ne parlait. Affichée sur le backend Kenwood uniquement — aucune autre famille de postes ne fait cette distinction — et le bouton Test PTT emprunte le même chemin."
+    ]
+  },
+  {
+    "version": "0.27.8",
+    "date": "",
+    "en": [
+      "The band matrix’s DIG row is now a rotation: click it and it answers for FT8, then FT4, then each digital mode your mode list holds — in YOUR order — then back to DIG. One row per digital mode would be the honest layout and there is no height for it beside the other widgets, so the row keeps its place and changes what it says. The label column is sized once for the longest mode it can show, so the matrix never shifts as the rotation comes round to RTTY.",
+      "Icom console: LSB and USB are separate buttons and can finally be commanded by name — the single SSB button resolved the sideband from the band, so there was no way to ask an IC-7300 for USB on 40 m. A rig reporting the folded “SSB” still lights the side its frequency implies.",
+      "Icom console: a 60 m band button, and the antenna and PSK controls only appear on radios that have them. An IC-7300 has one antenna socket and no native PSK mode, so ANT1/ANT2 could only ever disagree with its front panel and the PSK button was dead furniture.",
+      "Icom console: the mic gain is no longer hidden outside phone modes — on USB-D it still sets what the radio transmits at, and an operator who lives in FT8 had none at all.",
+      "Icom CI-V: address 0x00 can be chosen. It was silently refused and replaced by the IC-7610 default, with no way to say what was meant."
+    ],
+    "fr": [
+      "La ligne DIG de la matrice devient une rotation : un clic et elle répond pour FT8, puis FT4, puis chaque mode numérique de votre liste — dans VOTRE ordre — puis retour à DIG. Une ligne par mode numérique serait la mise en page honnête et la hauteur manque à côté des autres widgets : la ligne garde donc sa place et change ce qu’elle dit. La colonne des libellés est dimensionnée une fois pour le plus long mode qu’elle peut afficher : la matrice ne bouge donc plus quand la rotation arrive sur RTTY.",
+      "Console Icom : LSB et USB sont deux boutons distincts et peuvent enfin être demandés par leur nom — le bouton SSB unique déduisait la bande latérale de la fréquence, impossible donc de demander l’USB à un IC-7300 sur 40 m. Une radio qui annonce le « SSB » générique allume malgré tout le côté que sa fréquence implique.",
+      "Console Icom : un bouton de bande 60 m, et les commandes antenne et PSK n’apparaissent que sur les radios qui en disposent. Un IC-7300 n’a qu’une prise d’antenne et pas de mode PSK natif : ANT1/ANT2 ne pouvait que contredire sa face avant, et le bouton PSK était un meuble mort.",
+      "Console Icom : le gain micro n’est plus masqué hors des modes phonie — en USB-D il règle toujours le niveau d’émission, et un opérateur qui vit en FT8 n’en avait aucun.",
+      "CI-V Icom : l’adresse 0x00 peut être choisie. Elle était refusée en silence et remplacée par le défaut IC-7610, sans moyen de dire ce que l’on voulait."
+    ]
+  },
   {
     "version": "0.27.7",
     "date": "",

frontend/src/App.tsx

@@ -6328,6 +6328,9 @@ export default function App() {
       txState={txState}
       txStates={txStates}
       spotStatus={spotStatus as any}
+      // Only while CAT is actually connected: an empty band means "nothing to
+      // compare with", never "the rig is on no band".
+      rigBand={catState.connected ? (catState.band || '') : ''}
       myCall={station.callsign}
       // A click ANSWERS the station: it hands the decode back to WSJT-X/MSHV as
       // a Reply, which is the same thing as double-clicking the line in their
@@ -7411,6 +7414,7 @@ export default function App() {
             band={band}
             mode={mode}
             bands={bands}
+            modes={modes}
             satellites={satellites}
             onEditQso={openEdit}
             {...(!callsign.trim() && selQso ? {

frontend/src/components/BandSlotGrid.tsx

@@ -15,7 +15,10 @@ interface Props {
   busy: boolean;
   currentBand: string;
   currentMode: string;
-  bands?: string[]; // operator's configured bands; falls back to DEFAULT_BANDS
+  bands?: string[];
+  // The operator's configured mode list, in THEIR order: the digital row
+  // rotates through it.
+  modes?: string[]; // operator's configured bands; falls back to DEFAULT_BANDS
   hasCall?: boolean; // a callsign is being entered — only then highlight the "current entry" cell
   // DX station coordinates, for its sunrise/sunset. Optional: many spots resolve
   // to an entity with no position at all, and the block simply does not appear.
@@ -121,10 +124,31 @@ function cellTitle(t: (k: string) => string, band: string, cls: string, status:
   return `${band} ${cls}: ${desc}${mine ? ' — ' + mine : ''}${current ? ' — ' + t('mx.current') : ''}`;
 }
 
-export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, hasCall = true, lat, lon, forCall, onEditQso }: Props) {
+export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, modes, hasCall = true, lat, lon, forCall, onEditQso }: Props) {
   const { t } = useI18n();
   // Cell drill-down: which band+class the operator clicked, or null.
   const [slot, setSlot] = useState<{ band: string; cls: string } | null>(null);
+
+  // The DIGITAL row is a rotation, not a fixed row.
+  //
+  // One row for every digital mode would be the honest layout and there is no
+  // height for it — the matrix sits in a fixed panel beside a dozen widgets.
+  // So the row keeps its place and changes what it answers: DIG (all of them),
+  // then each digital mode the operator actually uses, in the order their mode
+  // list gives, then back to DIG. The backend publishes the same cells under
+  // both the class name and the raw mode, so a rotation costs no round trip.
+  const digModes = useMemo(
+    () => (modes ?? [])
+      .map((m) => (m || '').toUpperCase().trim())
+      .filter((m) => m !== '' && m !== 'CW' && !PHONE_MODES.has(m)),
+    [modes],
+  );
+  const [digIdx, setDigIdx] = useState(0); // 0 = the DIG group itself
+  // A shorter mode list (the operator edited it) must not strand the rotation
+  // on a row that no longer exists.
+  const digPos = digModes.length ? digIdx % (digModes.length + 1) : 0;
+  const digRow = digPos === 0 ? 'DIG' : digModes[digPos - 1];
+  const cycleDig = () => setDigIdx((i) => (digModes.length ? (i + 1) % (digModes.length + 1) : 0));
   // Columns from the operator's configured bands (so the matrix shows only the
   // bands they actually use), falling back to the built-in default set.
   const cols = useMemo(
@@ -310,7 +334,7 @@ export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, hasCal
       <table className="border-separate" style={{ borderSpacing: 3 }}>
         <thead>
           <tr>
-            <th className="w-[26px]" />
+            <th className="w-[38px] min-w-[38px] max-w-[38px]" />
             {cols.map((b) => (
               <th
                 key={b.tag}
@@ -325,13 +349,29 @@ export function BandSlotGrid({ wb, busy, currentBand, currentMode, bands, hasCal
           </tr>
         </thead>
         <tbody>
-          {CLASSES.map((cls) => {
-            const classCurrent = classMatchesMode(cls, currentMode);
+          {CLASSES.map((clsBase) => {
+            const cls = clsBase === 'DIG' ? digRow : clsBase;
+            // On a specific digital mode the "you are here" mark has to be that
+            // mode, not any digital one — otherwise every FT4 entry lights the
+            // FT8 row it happens to be cycled to.
+            const classCurrent = cls === clsBase
+              ? classMatchesMode(cls, currentMode)
+              : (currentMode || '').toUpperCase() === cls;
             return (
               <tr key={cls}>
                 <th
+                  onClick={clsBase === 'DIG' && digModes.length ? cycleDig : undefined}
+                  title={clsBase === 'DIG' && digModes.length ? t('bsg.digCycle') : undefined}
                   className={cn(
-                    'font-mono text-[11px] font-semibold pr-1.5 text-right w-[26px]',
+                    // Sized once for the LONGEST label the rotation can show,
+                    // and pinned there: a column that grows when RTTY comes
+                    // round shifts every band beneath it, and the eye reads
+                    // that as the matrix moving rather than the row changing.
+                    'font-mono font-semibold pr-1.5 text-right w-[38px] min-w-[38px] max-w-[38px] overflow-hidden',
+                    // Beyond four characters (PSK31, MSK144) the type gives way
+                    // instead of the column.
+                    cls.length > 4 ? 'text-[9px]' : 'text-[11px]',
+                    clsBase === 'DIG' && digModes.length ? 'cursor-pointer hover:text-foreground' : '',
                     classCurrent ? 'text-primary font-extrabold' : 'text-muted-foreground',
                   )}
                 >

frontend/src/components/DecodesPanel.tsx

@@ -13,7 +13,7 @@
 // come from the same resolver the cluster uses, so a call means the same thing in
 // both panels rather than being judged twice by two rules.
 import { useEffect, useMemo, useState } from 'react';
-import { Radio, Search, X, Signal, ArrowUpRight, Timer, Trash2, Ban, Columns2, Bot } from 'lucide-react';
+import { AlertTriangle, Radio, Search, X, Signal, ArrowUpRight, Timer, Trash2, Ban, Columns2, Bot } from 'lucide-react';
 import { cn } from '@/lib/utils';
 import { useI18n } from '@/lib/i18n';
 import { chaseAllows } from '@/lib/spotDisplay';
@@ -95,6 +95,9 @@ interface Props {
   // receiver reported last, which is a coin toss — each pane needs its own.
   txStates?: Record<string, TxMsg>;
   spotStatus: Record<string, StatusEntry>;
+  // The band the RIG is on, when CAT is connected. Only ever compared with what
+  // the decoder announces — see the drift warning.
+  rigBand?: string;
   onCall: (d: Decode) => void;
   myCall?: string;
   // Drop every decode and transmit message held for this panel. The list is a
@@ -539,7 +542,7 @@ function buildPeriods(filtered: Decode[], txMsgs: TxMsg[]) {
     }));
 }
 
-export function DecodesPanel({ decodes, txMsgs, txState, txStates, spotStatus, onCall, myCall, onClear, onHalt, autoCallOn, onToggleAutoCall }: Props) {
+export function DecodesPanel({ decodes, txMsgs, txState, txStates, spotStatus, rigBand, onCall, myCall, onClear, onHalt, autoCallOn, onToggleAutoCall }: Props) {
   const { t } = useI18n();
   // Column widths, dragged in the header and shared by every row. Persisted
   // through writeUiPref (not raw localStorage) so the layout travels with data/
@@ -597,6 +600,21 @@ export function DecodesPanel({ decodes, txMsgs, txState, txStates, spotStatus, o
 
   // The mode currently on the air, for the slot clock. The newest decode knows
   // best; between overs the transmit state still does.
+  // A decoder that has lost its CAT link keeps announcing the last dial
+  // frequency it knew, and every decode after that carries a stale band. Nothing
+  // downstream can tell: the entity verdicts, the band filter and the FT map all
+  // believe what the decoder said, and an operator ends up reading NEW BAND for a
+  // band they are not on. (Seen for real: MSHV lost CAT, kept saying 80 m, and
+  // Korea showed as a new band because on 80 m it would have been.)
+  //
+  // Said, not decided. Using the rig's band instead would be wrong for anyone
+  // decoding a second receiver on another band, and a warning costs that setup
+  // nothing but a line it can read past.
+  const decoderBand = decodes.length ? (decodes[decodes.length - 1].band ?? '') : '';
+  const bandDrift = !!rigBand && !!decoderBand
+    && rigBand.toLowerCase() !== decoderBand.toLowerCase();
+  const driftInstance = decodes.length ? (decodes[decodes.length - 1].instance ?? '') : '';
+
   const liveMode = decodes.length ? decodes[decodes.length - 1].mode : txState?.mode;
   const liveTr = trSeconds(liveMode, decodes.length ? decodes[decodes.length - 1].tr_period : undefined);
 
@@ -733,6 +751,18 @@ export function DecodesPanel({ decodes, txMsgs, txState, txStates, spotStatus, o
             what the transmit state reports, so it is right the moment anything
             is heard and keeps running when the band goes quiet. */}
         <PeriodClock trSec={liveTr} mode={liveMode} />
+        {bandDrift && (
+          <span
+            title={t('dec.bandDriftTip')}
+            className="inline-flex items-center gap-1 rounded-full border border-warning px-2 py-0.5 text-[11px] font-semibold text-warning">
+            <AlertTriangle className="size-3.5" />
+            {t('dec.bandDrift', {
+              app: driftInstance || t('dec.bandDriftApp'),
+              dec: decoderBand.toUpperCase(),
+              rig: (rigBand ?? '').toUpperCase(),
+            })}
+          </span>
+        )}
         <span className="w-px h-5 bg-border/60 mx-1" />
 
         <button type="button" className={chip(cqOnly, 'success')} onClick={() => setCqOnly(!cqOnly)}>

frontend/src/components/DetailsPanel.tsx

@@ -71,6 +71,7 @@ interface Props {
   band: string;
   mode: string;
   bands?: string[]; // configured bands for the worked-before matrix columns
+  modes?: string[]; // configured modes, in order — the matrix cycles its digital row through them
   // The station's satellites, for the SAT_NAME dropdown. Passed in rather than
   // read here: the list lives in Preferences, and App already reloads it when
   // Preferences close — a panel reading it once at mount would need a restart.
@@ -155,7 +156,7 @@ function Field({ label, span = 1, className, children }: { label: string; span?:
   );
 }
 
-export function DetailsPanel({ callsign, prefix, operatorGrid, remoteGrid, qth, name, country, comment, note, details, onChange, wb, wbBusy, band, mode, bands, satellites = [], slotCall, slotBand, slotMode, slotWb, slotWbBusy, tab, onTab, keyerActive, onEditQso }: Props) {
+export function DetailsPanel({ callsign, prefix, operatorGrid, remoteGrid, qth, name, country, comment, note, details, onChange, wb, wbBusy, band, mode, bands, modes, satellites = [], slotCall, slotBand, slotMode, slotWb, slotWbBusy, tab, onTab, keyerActive, onEditQso }: Props) {
   const { t } = useI18n();
   const [internalOpen, setInternalOpen] = useState<TabName>('stats');
   const open = tab ?? internalOpen; // controlled when `tab` is provided
@@ -294,6 +295,7 @@ export function DetailsPanel({ callsign, prefix, operatorGrid, remoteGrid, qth,
             currentBand={slotCall ? (slotBand ?? '') : band}
             currentMode={slotCall ? (slotMode ?? '') : mode}
             bands={bands}
+            modes={modes}
             hasCall={slotCall ? true : callsign.trim() !== ''}
             forCall={slotCall}
             onEditQso={onEditQso}

frontend/src/components/IcomPanel.tsx

@@ -53,7 +53,13 @@ const ZERO: IcomState = {
 type Band = { l: string; hz: number };
 
 const HF_BANDS: Band[] = [
-  { l: '160', hz: 1_840_000 }, { l: '80', hz: 3_750_000 }, { l: '40', hz: 7_100_000 },
+  { l: '160', hz: 1_840_000 }, { l: '80', hz: 3_750_000 },
+  // 60 m: the middle of the IARU Region 1 allocation (5351.5-5366.5 kHz), which
+  // every 60 m-capable rig can display. Where the band is channelised (the US)
+  // the operator moves to their channel from here — the button is a way onto
+  // the band, not a claim about what may be transmitted on it.
+  { l: '60', hz: 5_354_000 },
+  { l: '40', hz: 7_100_000 },
   { l: '30', hz: 10_130_000 }, { l: '20', hz: 14_150_000 }, { l: '17', hz: 18_130_000 },
   { l: '15', hz: 21_250_000 }, { l: '12', hz: 24_950_000 }, { l: '10', hz: 28_400_000 },
 ];
@@ -78,9 +84,36 @@ function bandsFor(model?: string): Band[] {
   return [...HF_BANDS, B6];
 }
 
-// Mode buttons for the console (like RS-BA1's row). SetCATMode picks USB/LSB for
-// SSB by frequency and the rig's data variant for digital modes.
-const MODES = ['SSB', 'CW', 'RTTY', 'PSK', 'AM', 'FM', 'DATA'];
+// Mode buttons for the console (like RS-BA1's row).
+//
+// LSB and USB by NAME, not one "SSB" button that resolves by band: the band
+// convention is right for a logged mode and useless when the operator means
+// "put this radio in USB on 40 m", which the console could not express at all.
+//
+// PSK is native only on the 7610/7760/7851 class; every other rig NAKs 0x12, so
+// there the button is dead furniture — see modesFor. Soundcard PSK31 rides on
+// DATA, which every rig can do.
+const MODES_BASE = ['LSB', 'USB', 'CW', 'RTTY', 'AM', 'FM', 'DATA'];
+
+function hasNativePSK(model?: string): boolean {
+  const m = (model ?? '').toUpperCase();
+  return m.includes('7610') || m.includes('7760') || m.includes('7851') ||
+    m.includes('7800') || m.includes('7700');
+}
+
+function modesFor(model?: string): string[] {
+  if (!hasNativePSK(model)) return MODES_BASE;
+  return [...MODES_BASE.slice(0, 4), 'PSK', ...MODES_BASE.slice(4)];
+}
+
+// Which radios actually have an antenna selector on the CI-V command (0x12).
+// An IC-7300 has ONE socket: offering it ANT1/ANT2 was two buttons that could
+// only ever disagree with the front panel.
+function hasAntennaSelector(model?: string): boolean {
+  const m = (model ?? '').toUpperCase();
+  return m.includes('7610') || m.includes('7760') || m.includes('7851') ||
+    m.includes('7800') || m.includes('7700') || m.includes('9700');
+}
 
 // Attenuator steps are MODEL-dependent even though the CI-V command (0x11) is the
 // same: the value byte is the dB. The IC-7610 (and 7700/7800/7851) have a 6/12/18
@@ -155,9 +188,21 @@ function icomWatts(pct: number): { w: number; defl: number } {
   return { w: Math.round(w), defl };
 }
 
-function modeMatches(btn: string, cur?: string): boolean {
+// Which sideband a bare "SSB" means at this frequency — the same convention the
+// backend applies when it resolves the mode for the radio.
+function sideForHz(hz?: number): string | null {
+  if (!hz || hz <= 0) return null;
+  return hz < 10_000_000 ? 'LSB' : 'USB';
+}
+
+function modeMatches(btn: string, cur?: string, hz?: number): boolean {
   if (!cur) return false;
-  if (btn === 'SSB') return cur === 'SSB' || cur === 'USB' || cur === 'LSB';
+  // A rig that reports the folded ADIF "SSB" still lights the side its
+  // frequency implies, so the row is never blank on a phone contact.
+  if (btn === 'USB' || btn === 'LSB') {
+    if (cur === btn) return true;
+    return cur === 'SSB' && btn === (sideForHz(hz) ?? '');
+  }
   // The backend surfaces USB-D as the operator's digital default (FT8…), or as
   // plain DATA — either way it is the DATA button that should light.
   if (btn === 'DATA') return ['DATA', 'FT8', 'FT4', 'JS8', 'JT65', 'JT9', 'MFSK', 'OLIVIA'].includes(cur);
@@ -507,9 +552,10 @@ export function IcomPanel({ onReportRST, isNetwork = false }: { onReportRST?: (r
           </div>
         </div>
         {/* Mode selector row (RS-BA1's SSB/CW/RTTY/PSK/AM/FM). */}
-        <div className="grid grid-cols-7 border-t border-border/60 divide-x divide-border/60">
-          {MODES.map((m) => {
-            const on = modeMatches(m, curMode);
+        <div className="grid border-t border-border/60 divide-x divide-border/60"
+          style={{ gridTemplateColumns: `repeat(${modesFor(st.model).length}, minmax(0, 1fr))` }}>
+          {modesFor(st.model).map((m) => {
+            const on = modeMatches(m, curMode, mainHz);
             return (
               <button key={m} type="button" onClick={() => setMode(m)}
                 className={cn('py-1.5 text-[11px] font-bold tracking-wide transition-colors',
@@ -561,10 +607,12 @@ export function IcomPanel({ onReportRST, isNetwork = false }: { onReportRST?: (r
             );
           })}
         </div>
-        <Row label={t('icmp.antenna')}>
-          <Segmented value={String(st.antenna)} options={[{ v: '1', l: 'ANT1' }, { v: '2', l: 'ANT2' }]}
-            onChange={(v) => set({ antenna: parseInt(v) }, () => IcomSetAntenna(parseInt(v)))} />
-        </Row>
+        {hasAntennaSelector(st.model) && (
+          <Row label={t('icmp.antenna')}>
+            <Segmented value={String(st.antenna)} options={[{ v: '1', l: 'ANT1' }, { v: '2', l: 'ANT2' }]}
+              onChange={(v) => set({ antenna: parseInt(v) }, () => IcomSetAntenna(parseInt(v)))} />
+          </Row>
+        )}
       </Card>
 
       {/* Clarifiers: RIT & ΔTX (XIT) — wheel or ± to shift, Ctrl+←/→ shifts RIT. */}
@@ -588,7 +636,10 @@ export function IcomPanel({ onReportRST, isNetwork = false }: { onReportRST?: (r
             {(st.model ?? '').includes('7760') ? `${st.rf_power * 2} W` : st.rf_power}
           </span>
         </Row>
-        {isPhone && (
+        {/* Not phone-only: on USB-D the same control still sets what the radio
+            transmits at, and hiding it left an operator who lives in FT8 with
+            no mic gain at all. */}
+        {(
           <Row label={t('icmp.mic')}>
             <Slider value={st.mic_gain} accent="#ef4444" onChange={(v) => set({ mic_gain: v }, () => IcomSetMicGain(v))} />
             <span className="w-8 text-right text-xs font-mono tabular-nums text-muted-foreground">{st.mic_gain}</span>

frontend/src/components/SettingsModal.tsx

@@ -1702,13 +1702,13 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
   type AudioSettings = {
     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';
+    ptt_method: 'none' | 'cat' | 'rts' | 'dtr'; ptt_port: string; ptt_data?: boolean; format: 'wav' | 'mp3';
     from_gain: number; mic_gain: number; tx_gain: number; qso_play_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',
+    qso_record: false, qso_dir: '', preroll_seconds: 8, ptt_method: 'none', ptt_port: '', ptt_data: false, format: 'wav',
     from_gain: 100, mic_gain: 100, tx_gain: 100, qso_play_gain: 100,
   });
   const [audioInputs, setAudioInputs] = useState<AudioDev[]>([]);
@@ -7251,6 +7251,21 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
                   </Button>
                 )}
               </div>
+              {/* Kenwood only, because only a Kenwood acts on it: TX1 is that
+                  family's second transmit command. Every other backend keys the
+                  one way it knows, so showing the box there would be a switch
+                  that changes nothing — the same dead furniture as ANT2 on a
+                  radio with one socket. */}
+              {audioCfg.ptt_method === 'cat' && catCfg.backend === 'kenwood' && (
+                <>
+                  <span />
+                  <label className="flex items-start gap-2 text-sm cursor-pointer" title={t('aud.pttDataHint')}>
+                    <Checkbox className="mt-0.5" checked={!!audioCfg.ptt_data}
+                      onCheckedChange={(c) => setAudioField({ ptt_data: !!c })} />
+                    <span>{t('aud.pttData')}</span>
+                  </label>
+                </>
+              )}
               {(audioCfg.ptt_method === 'rts' || audioCfg.ptt_method === 'dtr') && (
                 <>
                   <Label className="text-sm">{t('aud.pttPort')}</Label>

frontend/src/lib/i18n.tsx

@@ -162,7 +162,7 @@ const en: Dict = {
   'mx.tipThisCall': 'already worked with this callsign',
   'mx.tipThisCallConf': 'already confirmed with this callsign',
   // FTx decodes panel (Tools -> FT decodes)
-  'ftmap.tab': 'FT Map', 'ftmap.noGrid': 'Set your station grid in Preferences to place the map.', 'dec.tab': 'FT decodes', 'dec.title': 'Decodes', 'dec.cqOnly': 'CQ only',
+  'ftmap.tab': 'FT Map', 'ftmap.noGrid': 'Set your station grid in Preferences to place the map.', 'dec.tab': 'FT decodes', 'dec.title': 'Decodes', 'dec.bandDrift': '{app} says {dec}, the rig is on {rig}', 'dec.bandDriftApp': 'the decoder', 'dec.bandDriftTip': 'The decoding application is announcing a band the radio is not on — it has most likely lost its CAT link and is repeating the last frequency it knew. Every decode below carries that band, so the NEW / NEW BAND verdicts are judged against it.', 'dec.cqOnly': 'CQ only',
   'dec.allBands': 'All bands', 'dec.allModes': 'All modes', 'toast.qsoLogged': 'QSO logged', 'dec.contsHint': 'Continents: click to keep one or several', 'dec.allConts': 'All continents',
   'dec.minSnrTitle': 'Hide anything weaker than this SNR', 'dec.searchPh': 'Call, grid or message',
   'dec.clearFilters': 'Clear', 'dec.live': 'live', 'dec.tx': 'TX',
@@ -183,7 +183,7 @@ const en: Dict = {
   'dec.emptyFiltered': 'No decode matches these filters.',
   'sec.email': 'E-mail (SMTP)', 'sec.lookup': 'Callsign Lookup',
   'sec.ftx': 'FTx decodes', 'ftx.hint': 'What OpsLog does on its own with the digital decode stream.', 'ftx.enable': 'Auto-call', 'ftx.enableHint': 'answer a decode without clicking it', 'ftx.callWhen': 'Call a station that is:', 'ftx.watch': 'Watch list', 'ftx.watchHint': 'One callsign per line, wildcards allowed (4S7*, */P). A watched station is answered ahead of the criteria above.', 'ftx.watchOnlyIf': 'but only if it is also:', 'ftx.cooldown': 'Ignore a callsign for', 'ftx.warn': 'This keys your transmitter without asking. It answers CQ only, never while you are already transmitting, one station at a time, and every call is written to the log file with its reason. Halt stops it.', 'ftx.c_dxcc': 'a new DXCC entity', 'ftx.c_bandmode': 'a new band AND a new mode for the entity', 'ftx.c_band': 'a new band for the entity', 'ftx.c_mode': 'a new mode for the entity', 'ftx.c_slot': 'a new slot (band+mode never worked together)', 'ftx.c_grid': 'a new grid square', 'ftx.c_county': 'a new US county', 'ftx.c_pota': 'a new POTA park', 'ftx.c_pfx': 'a new WPX prefix',
-  'sec.bands': 'Bands', 'sec.satellites': 'Satellites', 'sat.hint': 'The satellites this station works. They are offered as a dropdown on the satellite fields, in alphabetical order.', 'sat.listLabel': 'One satellite per line', 'sat.listHint': 'Written into SAT_NAME exactly as spelled here, so use the name LoTW and the awards expect — AO-91, not AO91. Leaving the list empty simply keeps the field a plain text box.', 'sec.modes': 'Modes & default RST', 'sec.dxhunter': 'DXHunter', 'dxh.intro': 'What you hunt — it decides the badges in the DX Cluster, the FT decodes and Chase new alike.', 'sec.cluster': 'DX Cluster',
+  'sec.bands': 'Bands', 'sec.satellites': 'Satellites', 'sat.hint': 'The satellites this station works. They are offered as a dropdown on the satellite fields, in alphabetical order.', 'sat.listLabel': 'One satellite per line', 'sat.listHint': 'Written into SAT_NAME exactly as spelled here, so use the name LoTW and the awards expect — AO-91, not AO91. Leaving the list empty simply keeps the field a plain text box.', 'sec.modes': 'Modes & default RST', 'bsg.digCycle': 'Click to cycle through your digital modes', 'sec.dxhunter': 'DXHunter', 'dxh.intro': 'What you hunt — it decides the badges in the DX Cluster, the FT decodes and Chase new alike.', 'sec.cluster': 'DX Cluster',
   'sec.udp': 'Connections', 'sec.database': 'Database', 'sec.autostart': 'Autostart', 'sec.backup': 'Database backup', 'sec.uscounties': 'US Counties', 'nav.maintenance': 'Maintenance', 'sec.databases': 'Databases', 'db.hint': 'The reference data OpsLog keeps on disk. One line each, with what it holds and when it was last refreshed.', 'db.update': 'Update', 'db.never': 'never downloaded', 'db.cty': 'Country file (cty.dat)', 'db.ctyDetail': '{n} entities · file dated {d}', 'db.clublog': 'Club Log country exceptions', 'db.clublogDetail': '{n} exceptions · {d}', 'db.lotwUsers': 'LoTW users', 'db.lotwDetail': '{n} callsigns · {d}', 'db.scp': 'Super Check Partial (MASTER.SCP)', 'db.scpDetail': '{n} callsigns · {d}', 'db.uls': 'US counties (FCC ULS)', 'db.ulsDetail': '{n} callsigns · {d}', 'db.rda': 'Russian districts (RDA)', 'db.rdaDetail': '{n} callsigns, with their dated activity periods', 'db.rdaNote': 'built in', 'db.refLists': 'Award reference lists', 'db.refListsHint': 'Only the awards with an online source appear here; the others are shipped or edited by hand.', 'db.refDetail': '{n} references · {d}', 'db.refUpdated': '{code}: {n} references.', 'db.noRefLists': 'No award has an online reference list.', 'sec.rda': 'Russian districts (RDA)', 'rda.hint': 'The offline district database, and the one bulk operation it feeds.', 'rda.dbTitle': 'District database', 'rda.dbCount': '{n} Russian callsigns, each with the district it operates from and, where it moved, the dated periods it operated from each one. Built into OpsLog — nothing to download.', 'rda.backfillTitle': 'Fill the district on existing QSOs', 'rda.backfillIntro': 'Goes through every contact with a Russian entity and assigns its RDA reference, using the district the station was in ON THE DAY of the contact.', 'rda.useCurrent': 'Also use the current district for stations with no recorded history', 'rda.useCurrentHint': '(true for the great majority — the database records a history precisely for the callsigns that moved — but it is an assumption, not a dated fact)', 'rda.backfillRun': 'Fill districts', 'rda.backfillDone': '{s} Russian QSOs — {d} from a dated record, {c} from the current district, {u} unknown, {k} already had one.', 'rda.cmpTitle': 'Compare the two district sources', 'rda.cmpRunning': 'Comparing…', 'rda.cmpNoConflict': 'No disagreement — both sources say the same district everywhere.', 'rda.cmpNoRussian': 'No Russian contacts to compare.', 'rda.backfillRunning': 'Filling…', 'rda.cmpRun': 'Compare', 'rda.cmpDone': '{s} Russian QSOs — {a} identical, {d} differ, {l} only in the log, {b} only in the database', 'rda.cmpCall': 'Callsign', 'rda.cmpDate': 'Date', 'rda.cmpFromLog': 'Log (CNTY)', 'rda.cmpFromDb': 'RDA database', 'rda.cmpListHint': 'Showing {n} of {d} — click a callsign to open the contact.', 'rda.cmpOpen': 'Open this QSO', 'rda.cmpKind': 'Database', 'rda.cmpDated': 'dated', 'rda.cmpCurrent': 'current', 'rda.neverOverwrites': 'A reference you assigned by hand is never overwritten.', 'rda.cmpKeep': "Keep", 'rda.cmpKeepLog': "Keep the log's district for this contact", 'rda.cmpKeepDb': "Keep the database's district for this contact", 'rda.cmpApply': "Apply {n} decisions", 'rda.cmpAllDb': "keep the database everywhere", 'rda.cmpAllLog': "keep the log everywhere", 'rda.cmpClear': "clear the decisions", 'rda.cmpApplyHint': 'The chosen district is written into the contact — into CNTY and as its award reference — so the disagreement is settled and the contact counts for that district. Settled rows leave the list.',
   'sec.webpublish': 'Web publishing', 'wpub.hint': 'Publishes your log as a file for a website: a standalone HTML page or a CSV, written locally and optionally uploaded by FTP. It is refreshed when you log a QSO and, if you set an interval, on a timer.', 'wpub.enable': 'Publish the log to a file', 'wpub.fileSection': 'The file', 'wpub.format': 'Format', 'wpub.formatHtml': 'HTML page', 'wpub.formatCsv': 'CSV', 'wpub.folder': 'Output folder', 'wpub.browse': 'Browse…', 'wpub.fileName': 'File name', 'wpub.title': 'Page title', 'wpub.titlePh': 'blank = your callsign', 'wpub.count': 'Last N QSOs', 'wpub.every': 'Refresh every', 'wpub.everyHint': 'minutes — 0 = only when a QSO is logged', 'wpub.columns': 'Columns', 'wpub.columnsCount': '{n} of {total} chosen', 'wpub.columnsPick': 'Choose columns…', 'wpub.columnsSearch': 'Search a field…', 'wpub.removeColumn': 'Click to remove', 'wpub.columnsHint': 'Click to add or remove. The order shown here is the order in the file.', 'wpub.ftpEnable': 'Upload by FTP', 'wpub.ftpHost': 'Server / port', 'wpub.ftpUser': 'User', 'wpub.ftpPassword': 'Password', 'wpub.ftpFolder': 'Remote folder', 'wpub.ftpFileName': 'Remote file name', 'wpub.ftpTls': 'Use TLS (FTPS)', 'wpub.publishNow': 'Publish now', 'wpub.testFtp': 'Test connection', 'wpub.lastRun': 'Last run:', 'sec.adifmon': 'ADIF monitor',
   'sec.foldersync': 'Sync across PCs', 'sync.hint': 'Point every OpsLog at the SAME folder — one your PCs already synchronise (Seafile, OneDrive, Dropbox, a NAS share). Each machine writes what it logs there and reads the others; the databases themselves are never shared.', 'sync.enable': 'Keep my contacts in step across my PCs', 'sync.machine': 'This PC', 'sync.folder': 'Folder', 'sync.choose': 'Choose…', 'sync.state': 'State', 'sync.thisPc': 'This PC', 'sync.lastSync': 'Last check', 'sync.sent': 'Sent', 'sync.received': 'Received', 'sync.never': 'never', 'sync.noPeers': 'No other PC has written to this folder yet.', 'sync.behind': 'new contacts waiting', 'sync.now': 'Synchronise now', 'sync.applied': '{n} change(s) taken from the folder.', 'sync.saved': 'Saved.',
@@ -535,7 +535,7 @@ const en: Dict = {
   'aud.preroll': 'Pre-roll (seconds)', 'aud.format': 'File format', 'aud.wav': 'WAV (lossless, larger)', 'aud.mp3': 'MP3 (compressed, small)',
   'aud.fromLevel': 'From Radio level', 'aud.txLevel': 'Voice keyer level', 'aud.txLevelHint': 'Level of the recorded messages sent to the radio. Raise it if your voice keyer is much quieter than your microphone; Play previews at this same level. If the radio transmits almost nothing, its modulation source is still the front microphone: on an FTDX10 set MENU → SSB MOD SOURCE to REAR (the USB input).', 'aud.micLevel': 'Mic level', 'aud.qsoPlayLevel': 'QSO playback level', 'aud.levelHint': 'If your voice is louder than the station, lower Mic level.',
   'aud.autoSend': 'Auto-send the recording to the station by e-mail when I log a QSO',
-  'aud.dvkTitle': 'Voice keyer messages (F1–F12)', 'aud.deleteMsg': 'Delete this message', 'aud.pttMethod': 'PTT method', 'aud.pttNone': 'None (VOX)', 'aud.pttCat': 'CAT (the radio link)', 'aud.pttRts': 'Serial RTS', 'aud.pttDtr': 'Serial DTR',
+  'aud.dvkTitle': 'Voice keyer messages (F1–F12)', 'aud.deleteMsg': 'Delete this message', 'aud.pttData': 'Kenwood: the keyer’s audio arrives on the DATA / USB input', 'aud.pttDataHint': 'Sends TX1 (ACC2/USB) instead of TX (front microphone) — the TS-590 family’s second transmit command. Without it the radio transmits while listening to a microphone nobody is speaking into. Kenwood only: no other backend has the distinction.', 'aud.pttMethod': 'PTT method', 'aud.pttNone': 'None (VOX)', 'aud.pttCat': 'CAT (the radio link)', 'aud.pttRts': 'Serial RTS', 'aud.pttDtr': 'Serial DTR',
   'aud.testPtt': 'Test PTT', 'aud.pttPort': 'PTT COM port', 'aud.pickPort': 'Pick a COM port', 'aud.selectPort': '— select —', 'aud.refresh': 'Refresh',
   'aud.msgPlaceholder': 'Message {n} label (CQ, report, 73…)', 'aud.holdRec': '● Hold to rec', 'aud.recordingNow': '● Recording…', 'aud.play': '▶ Play', 'aud.stop': '■ Stop',
   'aud.errPttTest': 'PTT test: ', 'aud.errRecord': 'Record: ', 'aud.errSave': 'Save: ', 'aud.errPlay': 'Play: ',
@@ -682,7 +682,7 @@ const fr: Dict = {
   'mx.tipThisCall': 'déjà contacté avec cet indicatif',
   'mx.tipThisCallConf': 'déjà confirmé avec cet indicatif',
   // Panneau des decodes FTx (Outils -> Decodes FT)
-  'ftmap.tab': 'FT Map', 'ftmap.noGrid': 'Renseigne ton locator dans les Préférences pour placer la carte.', 'dec.tab': 'Decodes FT', 'dec.title': 'Decodes', 'dec.cqOnly': 'CQ seulement',
+  'ftmap.tab': 'FT Map', 'ftmap.noGrid': 'Renseigne ton locator dans les Préférences pour placer la carte.', 'dec.tab': 'Decodes FT', 'dec.title': 'Decodes', 'dec.bandDrift': '{app} annonce {dec}, le poste est sur {rig}', 'dec.bandDriftApp': 'le décodeur', 'dec.bandDriftTip': 'Le logiciel de décodage annonce une bande sur laquelle la radio n’est pas — il a très probablement perdu sa liaison CAT et répète la dernière fréquence connue. Tous les décodages ci-dessous portent cette bande, et les verdicts NOUVEAU / NOUVELLE BANDE sont jugés dessus.', 'dec.cqOnly': 'CQ seulement',
   'dec.allBands': 'Toutes bandes', 'dec.allModes': 'Tous modes', 'toast.qsoLogged': 'QSO enregistré', 'dec.contsHint': 'Continents : clique pour en garder un ou plusieurs', 'dec.allConts': 'Tous continents',
   'dec.minSnrTitle': 'Masquer tout ce qui est plus faible que ce rapport', 'dec.searchPh': 'Indicatif, locator ou message',
   'dec.clearFilters': 'Effacer', 'dec.live': 'en direct', 'dec.tx': 'TX',
@@ -703,7 +703,7 @@ const fr: Dict = {
   'dec.emptyFiltered': 'Aucun decode ne correspond a ces filtres.',
   'sec.email': 'E-mail (SMTP)', 'sec.lookup': "Recherche d'indicatif",
   'sec.ftx': 'Décodages FTx', 'ftx.hint': 'Ce qu’OpsLog fait de lui-même avec le flux de décodages numériques.', 'ftx.enable': 'Appel automatique', 'ftx.enableHint': 'répondre à un décodage sans cliquer', 'ftx.callWhen': 'Appeler une station qui est :', 'ftx.watch': 'Liste de surveillance', 'ftx.watchHint': 'Un indicatif par ligne, jokers acceptés (4S7*, */P). Une station surveillée est appelée avant les critères ci-dessus.', 'ftx.watchOnlyIf': 'mais seulement si elle est aussi :', 'ftx.cooldown': 'Ignorer un indicatif pendant', 'ftx.warn': 'Ceci met ton émetteur en marche sans te demander. Uniquement sur un CQ, jamais pendant que tu émets déjà, une station à la fois, et chaque appel est écrit dans le journal avec sa raison. Stop l’interrompt.', 'ftx.c_dxcc': 'une nouvelle entité DXCC', 'ftx.c_bandmode': 'une nouvelle bande ET un nouveau mode pour l’entité', 'ftx.c_band': 'une nouvelle bande pour l’entité', 'ftx.c_mode': 'un nouveau mode pour l’entité', 'ftx.c_slot': 'un nouveau slot (bande+mode jamais faits ensemble)', 'ftx.c_grid': 'un nouveau carré locator', 'ftx.c_county': 'un nouveau comté US', 'ftx.c_pota': 'un nouveau parc POTA', 'ftx.c_pfx': 'un nouveau préfixe WPX',
-  'sec.bands': 'Bandes', 'sec.satellites': 'Satellites', 'sat.hint': "Les satellites que cette station travaille. Ils sont proposés en liste déroulante sur les champs satellite, par ordre alphabétique.", 'sat.listLabel': 'Un satellite par ligne', 'sat.listHint': "Inscrit dans SAT_NAME exactement tel qu'écrit ici : utilise le nom attendu par LoTW et les diplômes — AO-91, pas AO91. Une liste vide laisse simplement le champ en saisie libre.", 'sec.modes': 'Modes & RST par défaut', 'sec.dxhunter': 'DXHunter', 'dxh.intro': 'Ce que vous chassez — cela commande les badges du DX Cluster, des FT decodes et de Chase new.', 'sec.cluster': 'DX Cluster',
+  'sec.bands': 'Bandes', 'sec.satellites': 'Satellites', 'sat.hint': "Les satellites que cette station travaille. Ils sont proposés en liste déroulante sur les champs satellite, par ordre alphabétique.", 'sat.listLabel': 'Un satellite par ligne', 'sat.listHint': "Inscrit dans SAT_NAME exactement tel qu'écrit ici : utilise le nom attendu par LoTW et les diplômes — AO-91, pas AO91. Une liste vide laisse simplement le champ en saisie libre.", 'sec.modes': 'Modes & RST par défaut', 'bsg.digCycle': 'Cliquer pour faire défiler vos modes numériques', 'sec.dxhunter': 'DXHunter', 'dxh.intro': 'Ce que vous chassez — cela commande les badges du DX Cluster, des FT decodes et de Chase new.', 'sec.cluster': 'DX Cluster',
   'sec.udp': 'Connexions', 'sec.database': 'Base de données', 'sec.autostart': 'Démarrage auto', 'sec.backup': 'Sauvegarde base', 'sec.uscounties': 'Comtés US', 'nav.maintenance': 'Maintenance', 'sec.databases': 'Bases de données', 'db.hint': 'Les données de référence qu’OpsLog garde sur disque. Une ligne chacune, avec ce qu’elle contient et sa dernière actualisation.', 'db.update': 'Mettre à jour', 'db.never': 'jamais téléchargée', 'db.cty': 'Fichier pays (cty.dat)', 'db.ctyDetail': '{n} entités · fichier daté du {d}', 'db.clublog': 'Exceptions pays Club Log', 'db.clublogDetail': '{n} exceptions · {d}', 'db.lotwUsers': 'Utilisateurs LoTW', 'db.lotwDetail': '{n} indicatifs · {d}', 'db.scp': 'Super Check Partial (MASTER.SCP)', 'db.scpDetail': '{n} indicatifs · {d}', 'db.uls': 'Comtés US (FCC ULS)', 'db.ulsDetail': '{n} indicatifs · {d}', 'db.rda': 'Districts russes (RDA)', 'db.rdaDetail': '{n} indicatifs, avec leurs périodes d’activité datées', 'db.rdaNote': 'intégrée', 'db.refLists': 'Listes de références des diplômes', 'db.refListsHint': 'Seuls les diplômes ayant une source en ligne apparaissent ici ; les autres sont livrés ou édités à la main.', 'db.refDetail': '{n} références · {d}', 'db.refUpdated': '{code} : {n} références.', 'db.noRefLists': 'Aucun diplôme n’a de liste de références en ligne.', 'sec.rda': 'Districts russes (RDA)', 'rda.hint': 'La base de districts hors ligne, et l’unique opération de masse qu’elle alimente.', 'rda.dbTitle': 'Base des districts', 'rda.dbCount': '{n} indicatifs russes, chacun avec le district d’où il émet et, pour ceux qui ont déménagé, les périodes datées passées dans chacun. Intégrée à OpsLog — rien à télécharger.', 'rda.backfillTitle': 'Renseigner le district sur les QSO existants', 'rda.backfillIntro': 'Parcourt tous les contacts avec une entité russe et attribue leur référence RDA, en utilisant le district où se trouvait la station LE JOUR du contact.', 'rda.useCurrent': 'Utiliser aussi le district actuel pour les stations sans historique connu', 'rda.useCurrentHint': '(vrai pour la grande majorité — la base enregistre un historique justement pour les indicatifs qui ont bougé — mais c’est une supposition, pas un fait daté)', 'rda.backfillRun': 'Renseigner les districts', 'rda.backfillDone': '{s} QSO russes — {d} depuis une période datée, {c} depuis le district actuel, {u} inconnus, {k} en avaient déjà un.', 'rda.cmpTitle': 'Comparer les deux sources de district', 'rda.cmpRunning': 'Comparaison…', 'rda.cmpNoConflict': 'Aucune divergence — les deux sources donnent partout le même district.', 'rda.cmpNoRussian': 'Aucun contact russe à comparer.', 'rda.backfillRunning': 'Remplissage…', 'rda.cmpRun': 'Comparer', 'rda.cmpDone': '{s} QSO russes — {a} identiques, {d} divergents, {l} seulement dans le log, {b} seulement dans la base', 'rda.cmpCall': 'Indicatif', 'rda.cmpDate': 'Date', 'rda.cmpFromLog': 'Log (CNTY)', 'rda.cmpFromDb': 'Base RDA', 'rda.cmpListHint': '{n} affichés sur {d} — cliquer un indicatif ouvre le contact.', 'rda.cmpOpen': 'Ouvrir ce QSO', 'rda.cmpKind': 'Base', 'rda.cmpDated': 'daté', 'rda.cmpCurrent': 'courant', 'rda.neverOverwrites': 'Une référence attribuée à la main n’est jamais écrasée.', 'rda.cmpKeep': "Garder", 'rda.cmpKeepLog': "Garder le district du log pour ce contact", 'rda.cmpKeepDb': "Garder le district de la base pour ce contact", 'rda.cmpApply': "Appliquer {n} décisions", 'rda.cmpAllDb': "garder la base partout", 'rda.cmpAllLog': "garder le log partout", 'rda.cmpClear': "effacer les décisions", 'rda.cmpApplyHint': "Le district choisi est écrit dans le contact — dans CNTY et comme référence de diplôme — donc la divergence est réglée et le contact compte pour ce district. Les lignes réglées quittent la liste.",
   'sec.webpublish': 'Publication web', 'wpub.hint': "Publie ton journal dans un fichier destiné à un site web : une page HTML autonome ou un CSV, écrit en local et envoyé par FTP si tu le souhaites. Il est rafraîchi à chaque QSO enregistré et, si tu règles un intervalle, périodiquement.", 'wpub.enable': 'Publier le journal dans un fichier', 'wpub.fileSection': 'Le fichier', 'wpub.format': 'Format', 'wpub.formatHtml': 'Page HTML', 'wpub.formatCsv': 'CSV', 'wpub.folder': 'Dossier de sortie', 'wpub.browse': 'Parcourir…', 'wpub.fileName': 'Nom du fichier', 'wpub.title': 'Titre de la page', 'wpub.titlePh': 'vide = ton indicatif', 'wpub.count': 'N derniers QSO', 'wpub.every': 'Rafraîchir toutes les', 'wpub.everyHint': 'minutes — 0 = seulement à chaque QSO', 'wpub.columns': 'Colonnes', 'wpub.columnsCount': '{n} sur {total} choisis', 'wpub.columnsPick': 'Choisir les colonnes…', 'wpub.columnsSearch': 'Chercher un champ…', 'wpub.removeColumn': 'Cliquer pour retirer', 'wpub.columnsHint': 'Clique pour ajouter ou retirer. L ordre affiché ici est celui du fichier.', 'wpub.ftpEnable': 'Envoyer par FTP', 'wpub.ftpHost': 'Serveur / port', 'wpub.ftpUser': 'Utilisateur', 'wpub.ftpPassword': 'Mot de passe', 'wpub.ftpFolder': 'Dossier distant', 'wpub.ftpFileName': 'Nom du fichier distant', 'wpub.ftpTls': 'Utiliser TLS (FTPS)', 'wpub.publishNow': 'Publier maintenant', 'wpub.testFtp': 'Tester la connexion', 'wpub.lastRun': 'Dernière exécution :', 'sec.adifmon': 'Moniteur ADIF',
   'sec.foldersync': 'Synchro entre PC', 'sync.hint': 'Fais pointer chaque OpsLog vers le MÊME dossier — un dossier que tes PC synchronisent déjà (Seafile, OneDrive, Dropbox, un partage NAS). Chaque machine y écrit ce qu’elle enregistre et lit celui des autres ; les bases de données, elles, ne sont jamais partagées.', 'sync.enable': 'Garder mes contacts à jour sur tous mes PC', 'sync.machine': 'Ce PC', 'sync.folder': 'Dossier', 'sync.choose': 'Choisir…', 'sync.state': 'État', 'sync.thisPc': 'Ce PC', 'sync.lastSync': 'Dernière vérification', 'sync.sent': 'Envoyés', 'sync.received': 'Reçus', 'sync.never': 'jamais', 'sync.noPeers': 'Aucun autre PC n’a encore écrit dans ce dossier.', 'sync.behind': 'nouveaux contacts en attente', 'sync.now': 'Synchroniser maintenant', 'sync.applied': '{n} changement(s) repris du dossier.', 'sync.saved': 'Enregistré.',
@@ -1037,7 +1037,7 @@ const fr: Dict = {
   'aud.preroll': 'Pré-enregistrement (secondes)', 'aud.format': 'Format de fichier', 'aud.wav': 'WAV (sans perte, plus volumineux)', 'aud.mp3': 'MP3 (compressé, léger)',
   'aud.fromLevel': 'Niveau depuis la radio', 'aud.txLevel': 'Niveau du voice keyer', 'aud.txLevelHint': "Niveau des messages enregistrés envoyés à la radio. Augmentez-le si votre voice keyer est bien plus faible que votre micro ; Lire fait entendre ce même niveau. Si la radio n'émet presque rien, c'est que sa source de modulation est restée le micro de façade : sur un FTDX10, réglez MENU → SSB MOD SOURCE sur REAR (l'entrée USB).", 'aud.micLevel': 'Niveau micro', 'aud.qsoPlayLevel': 'Niveau de relecture QSO', 'aud.levelHint': 'Si votre voix est plus forte que la station, baissez le niveau micro.',
   'aud.autoSend': "Envoyer automatiquement l'enregistrement à la station par e-mail lorsque j'enregistre un QSO",
-  'aud.dvkTitle': 'Messages du manipulateur vocal (F1–F12)', 'aud.deleteMsg': 'Supprimer ce message', 'aud.pttMethod': 'Méthode PTT', 'aud.pttNone': 'Aucune (VOX)', 'aud.pttCat': 'CAT (la liaison radio)', 'aud.pttRts': 'RTS série', 'aud.pttDtr': 'DTR série',
+  'aud.dvkTitle': 'Messages du manipulateur vocal (F1–F12)', 'aud.deleteMsg': 'Supprimer ce message', 'aud.pttData': 'Kenwood : l’audio du keyer arrive sur l’entrée DATA / USB', 'aud.pttDataHint': 'Envoie TX1 (ACC2/USB) au lieu de TX (micro de face avant) — la seconde commande d’émission de la famille TS-590. Sans cela la radio émet en écoutant un micro devant lequel personne ne parle. Kenwood uniquement : aucun autre backend n’a cette distinction.', 'aud.pttMethod': 'Méthode PTT', 'aud.pttNone': 'Aucune (VOX)', 'aud.pttCat': 'CAT (la liaison radio)', 'aud.pttRts': 'RTS série', 'aud.pttDtr': 'DTR série',
   'aud.testPtt': 'Tester le PTT', 'aud.pttPort': 'Port COM du PTT', 'aud.pickPort': 'Choisir un port COM', 'aud.selectPort': '— choisir —', 'aud.refresh': 'Actualiser',
   'aud.msgPlaceholder': 'Libellé du message {n} (CQ, report, 73…)', 'aud.holdRec': '● Maintenir pour enreg.', 'aud.recordingNow': '● Enregistrement…', 'aud.play': '▶ Lire', 'aud.stop': '■ Arrêter',
   'aud.errPttTest': 'Test PTT : ', 'aud.errRecord': 'Enregistrement : ', 'aud.errSave': 'Sauvegarde : ', 'aud.errPlay': 'Lecture : ',

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

frontend/wailsjs/go/models.ts

@@ -1924,6 +1924,7 @@ export namespace main {
 	    preroll_seconds: number;
 	    ptt_method: string;
 	    ptt_port: string;
+	    ptt_data: boolean;
 	    format: string;
 	    from_gain: number;
 	    mic_gain: number;
@@ -1945,6 +1946,7 @@ export namespace main {
 	        this.preroll_seconds = source["preroll_seconds"];
 	        this.ptt_method = source["ptt_method"];
 	        this.ptt_port = source["ptt_port"];
+	        this.ptt_data = source["ptt_data"];
 	        this.format = source["format"];
 	        this.from_gain = source["from_gain"];
 	        this.mic_gain = source["mic_gain"];

internal/cat/cat.go

@@ -256,6 +256,33 @@ func (m *Manager) SetPTT(on bool) error {
 	return m.exec(func(b Backend) error { return b.SetPTT(on) })
 }
 
+// dataPTTSetter is implemented by a backend that can key the DATA input rather
+// than the microphone. A Kenwood TS-590 has two transmit commands and takes its
+// audio from a different socket for each: TX (or TX0) opens the front mic, TX1
+// the rear ACC2/USB. Send the wrong one and the radio transmits in silence,
+// because the audio arriving on USB is simply not the input it is listening to.
+type dataPTTSetter interface {
+	SetPTTData(on bool) error
+}
+
+// SetPTTSource keys the transmitter, saying WHERE the audio is coming from.
+//
+// data=true means "the audio reaches the radio on its data/USB input" — what a
+// voice keyer playing through the rig's own sound card needs. A backend that
+// draws no distinction (every rig where one PTT is all there is) falls back to
+// the ordinary key, so nothing changes for it.
+func (m *Manager) SetPTTSource(on, data bool) error {
+	if !data {
+		return m.SetPTT(on)
+	}
+	return m.exec(func(b Backend) error {
+		if d, ok := b.(dataPTTSetter); ok {
+			return d.SetPTTData(on)
+		}
+		return b.SetPTT(on)
+	})
+}
+
 // splitSetter is implemented by the backends that can arm split AND place the
 // transmit frequency. Both together: arming without setting the dial transmits
 // on whatever the transmit VFO happened to hold, which is worse than refusing.

internal/cat/icomserial.go

@@ -1543,6 +1543,14 @@ func (b *IcomSerial) modeCode(mode string) (code byte, data bool, err error) {
 		return civ.ModeCW, false, nil
 	case "SSB":
 		return usb, false, nil
+	case "USB":
+		// The SIDEBAND, asked for by name. "SSB" resolves to whichever side the
+		// band convention wants, which is right for a logged mode and useless
+		// when the operator means "put this radio in USB" — on 40 m there was no
+		// way to say it at all, and the console's own button could not either.
+		return civ.ModeUSB, false, nil
+	case "LSB":
+		return civ.ModeLSB, false, nil
 	case "AM":
 		return civ.ModeAM, false, nil
 	case "FM":

internal/cat/kenwood.go

@@ -632,6 +632,28 @@ func (k *Kenwood) SetPTT(on bool) error {
 	return k.write("RX;")
 }
 
+// SetPTTData keys the transmitter on the DATA input: TX1 on a TS-590, which is
+// ACC2/USB rather than the front microphone. The radio's own manual is explicit
+// that the parameter chooses the input — "0: SEND (normal transmission using
+// the MIC input), 1: DATA SEND (ACC2/USB input)" — so a voice keyer playing
+// into the rig's USB codec has to say TX1 or it transmits dead air while the
+// radio listens to a microphone nobody is speaking into.
+//
+// Unkeying is the same RX either way; there is no data-flavoured stop.
+func (k *Kenwood) SetPTTData(on bool) error {
+	k.mu.Lock()
+	defer k.mu.Unlock()
+	if k.port == nil {
+		return fmt.Errorf("kenwood: not connected")
+	}
+	k.tx = on
+	if on {
+		k.txAt = time.Now()
+		return k.write("TX1;")
+	}
+	return k.write("RX;")
+}
+
 func (k *Kenwood) write(cmd string) error {
 	if k.port == nil {
 		return fmt.Errorf("kenwood: not connected")

internal/qso/qso.go

@@ -2013,7 +2013,7 @@ type WorkedBefore struct {
 // at all about yesterday.
 type BandStatus struct {
 	Band   string `json:"band"`   // ADIF lowercase band, e.g. "20m"
-	Class  string `json:"class"`  // "PH" | "CW" | "DIG"
+	Class  string `json:"class"`  // "PH" | "CW" | "DIG", or a raw digital mode ("FT8", "RTTY"…)
 	Status string `json:"status"` // "call_c" | "call_w" | "dxcc_c" | "dxcc_w"
 	// Call is "", "w" (worked with this callsign) or "c" (confirmed with it).
 	Call string `json:"call,omitempty"`
@@ -2402,17 +2402,32 @@ func (r *Repo) WorkedBefore(ctx context.Context, callsign string, dxccHint int,
 			return wb, fmt.Errorf("scan band status: %w", err)
 		}
 		code := bandStatusCode(callW == 1, callC == 1, dxccConfirmed == 1)
-		k := cellKey{band: band, class: modeClass(mode)}
-		if cur, ok := best[k]; !ok || code > cur {
-			best[k] = code
+		keys := []cellKey{{band: band, class: modeClass(mode)}}
+		// The DIGITAL row can be cycled through the individual modes in the UI —
+		// FT8, then FT4, then RTTY — so the same cell is also published under the
+		// raw mode name. The query already grouped by mode; only the collapse to
+		// a class threw that away, and re-asking the database for it would be a
+		// second scan to learn what we had just read.
+		//
+		// Digital only: PH and CW have nothing to cycle through, and publishing
+		// "SSB" beside "PH" would just double the payload.
+		if um := strings.ToUpper(mode); modeClass(mode) == "DIG" && um != "" {
+			keys = append(keys, cellKey{band: band, class: um})
+		}
+		for _, k := range keys {
+			if cur, ok := best[k]; !ok || code > cur {
+				best[k] = code
+			}
 		}
 		// Confirmed beats worked here too, and neither is ever erased by the
 		// entity: this is only ever about the callsign.
-		switch {
-		case callC == 1:
-			callByCell[k] = "c"
-		case callW == 1 && callByCell[k] == "":
-			callByCell[k] = "w"
+		for _, k := range keys {
+			switch {
+			case callC == 1:
+				callByCell[k] = "c"
+			case callW == 1 && callByCell[k] == "":
+				callByCell[k] = "w"
+			}
 		}
 	}
 	statusRows.Close()

telemetry.go

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