feat(map): the world map opens on the operator's own longitude

Centred on 0 degrees it left an Australian looking at their own country
in the bottom-right corner, with the paths to everywhere they work
running off both edges. Centred on their own longitude the same map reads
the way their antenna does: the Americas to the east, Europe and Africa
to the west. Leaflet repeats the world horizontally, so this is a choice
of viewpoint and costs nothing — the tiles either side are the same
world, and unwrapLon already draws the arcs across the seam.

The latitude is damped rather than followed (a station at 69 north
centred on itself would spend half the map on the Arctic), the station's
square arrives after the map is built so it re-centres once when it
lands, and a view the operator has panned to themselves still wins.

app.go

@@ -789,6 +789,11 @@ type App struct {
 	acLastJudge time.Time
 	// acTXPeriod is the last transmit period already counted — see autoCallNoteTX.
 	acTXPeriod string
+	// acJudged is the last period key each receiver has been judged on, and
+	// acDirty says decodes have arrived for it since. Together they let a period
+	// be judged AGAIN when a straggler turns up, with the whole period in hand.
+	acJudged map[string]string
+	acDirty  map[string]bool
 	// What the decodes panel is SHOWING, and whether it is publishing at all.
 	// The panel owns the filters; this is its answer, not a second copy of them.
 	acVisible   map[string]bool
@@ -3149,7 +3154,7 @@ func (a *App) AddQSO(q qso.QSO) (id int64, err error) {
 			// a few lines above and is not on the copy taken at insert time.
 			a.syncPublishAsync(syncfolder.OpAdd, id, nil)
 			if a.udp != nil {
-				rec := adif.SingleRecordADIF(qc)
+				rec := adif.ForwardRecordADIF(qc)
 				a.udp.EmitLoggedADIF(rec)
 				a.udp.EmitLoggedQSOWSJT(wsjtLoggedQSO(qc), rec)
 				a.udpTriggerQSOLogged(qc)
@@ -8470,7 +8475,11 @@ func (a *App) SaveCATSettings(s CATSettings) error {
 	if s.IcomBaud <= 0 {
 		s.IcomBaud = 115200
 	}
-	if s.IcomAddr <= 0 || s.IcomAddr > 0xFF {
+	// 0x00 IS an address. Rejecting it as "unset" is what sent an operator's
+	// custom-address rig straight back to the IC-7610's 0x98 every time the
+	// settings were saved — the model dropdown snapping back with it, since it
+	// reads the address rather than a stored model.
+	if s.IcomAddr < 0 || s.IcomAddr > 0xFF {
 		s.IcomAddr = 0x98
 	}
 	if s.PollMs < 50 || s.PollMs > 2000 {
@@ -11811,10 +11820,58 @@ func (a *App) UploadQSOsManual(service string, ids []int64) error {
 		return fmt.Errorf("unknown service %q", service)
 	}
 	cfg := a.loadExternalServices()
+	// NOT CONFIGURED IS AN ANSWER, AND IT BELONGS HERE.
+	//
+	// The upload runs on its own goroutine and reports through the QSL Manager's
+	// console, which is not open when the command was given from a right-click in
+	// the QSO list: an upload to a service with no credentials looked exactly
+	// like one that worked. Refused synchronously instead, where the caller can
+	// show it.
+	if err := uploadConfigured(svc, cfg); err != nil {
+		return err
+	}
 	go a.runManualUpload(svc, ids, cfg)
 	return nil
 }
 
+// uploadConfigured reports whether a service has what it needs to be uploaded
+// to at all — the credentials it cannot work without, not a guarantee they are
+// correct. The service says whether they are; this says whether to ask.
+func uploadConfigured(svc extsvc.Service, cfg extsvc.ExternalServices) error {
+	has := func(v string) bool { return strings.TrimSpace(v) != "" }
+	switch svc {
+	case extsvc.ServiceCloudlog:
+		if !has(cfg.Cloudlog.URL) || !has(cfg.Cloudlog.APIKey) {
+			return fmt.Errorf("Cloudlog / Wavelog is not configured — set its URL and API key in Settings → External services")
+		}
+	case extsvc.ServiceQRZ:
+		if !has(cfg.QRZ.APIKey) {
+			return fmt.Errorf("QRZ.com is not configured — set the logbook API key in Settings → External services")
+		}
+	case extsvc.ServiceClublog:
+		if !has(cfg.Clublog.Email) || !has(cfg.Clublog.Password) || !has(cfg.Clublog.APIKey) {
+			return fmt.Errorf("Club Log is not configured — set the account email, password and API key in Settings → External services")
+		}
+	case extsvc.ServiceHRDLog:
+		if !has(cfg.HRDLog.Callsign) || !has(cfg.HRDLog.Code) {
+			return fmt.Errorf("HRDLog.net is not configured — set the callsign and upload code in Settings → External services")
+		}
+	case extsvc.ServiceEQSL:
+		if !has(cfg.EQSL.Username) || !has(cfg.EQSL.Password) {
+			return fmt.Errorf("eQSL.cc is not configured — set the username and password in Settings → External services")
+		}
+	case extsvc.ServiceHamQTH:
+		if !has(cfg.HamQTH.Username) || !has(cfg.HamQTH.Password) {
+			return fmt.Errorf("HamQTH is not configured — set the username and password in Settings → External services")
+		}
+	case extsvc.ServiceLoTW:
+		if !has(cfg.LoTW.StationLocation) {
+			return fmt.Errorf("LoTW is not configured — set the TQSL station location in Settings → External services")
+		}
+	}
+	return nil
+}
+
 func (a *App) runManualUpload(svc extsvc.Service, ids []int64, cfg extsvc.ExternalServices) {
 	emit := func(line string) {
 		if a.ctx != nil {
@@ -14314,7 +14371,7 @@ func (a *App) LogUDPLoggedADIF(adifText string) (int64, error) {
 		// path — otherwise a QSO logged FROM WSJT-X/JTDX/MSHV was never re-emitted
 		// to the outbound ADIF listeners (Log4OM, N1MM, gridtracker…).
 		if a.udp != nil {
-			rec := adif.SingleRecordADIF(qc)
+			rec := adif.ForwardRecordADIF(qc)
 			a.udp.EmitLoggedADIF(rec)
 			a.udp.EmitLoggedQSOWSJT(wsjtLoggedQSO(qc), rec)
 			a.udpTriggerQSOLogged(qc)

autocall.go

@@ -160,6 +160,7 @@ func (a *App) applyAutoCall() {
 		e.Reset()
 		a.acMu.Lock()
 		a.acPeriod, a.acBuf = nil, nil
+		a.acJudged, a.acDirty = nil, nil
 		a.acMu.Unlock()
 	}
 	a.emitAutoCall()
@@ -279,17 +280,37 @@ func (a *App) autoCallFeed(d autocall.Decode) {
 	if a.acPeriod == nil {
 		a.acPeriod, a.acAt, a.acTR, a.acBuf = map[string]string{}, map[string]time.Time{}, map[string]int{}, map[string][]acDecode{}
 		a.acFed = map[string]time.Time{}
+		a.acJudged, a.acDirty = map[string]string{}, map[string]bool{}
 	}
 	if prev := a.acPeriod[inst]; prev != "" && prev != key {
 		prevAt, prevTR, buf := a.acAt[inst], a.acTR[inst], a.acBuf[inst]
+		// Only if something in it has NOT been judged. The buffer now outlives
+		// the judgement (see below), so without this the arrival of the next
+		// period would judge the previous one a second time on the very same
+		// decodes — and act on them, a slot late.
+		pending := a.acDirty[inst] || a.acJudged[inst] != prev
 		a.acPeriod[inst], a.acAt[inst], a.acTR[inst] = key, d.At, d.TRPeriod
 		a.acBuf[inst] = []acDecode{{d: d}}
+		a.acFed[inst], a.acDirty[inst] = time.Now(), true
 		a.acMu.Unlock()
+		// The previous period ends here whatever the sweeper was going to do: a
+		// decode stamped with the next slot is proof the old one is over.
+		if pending {
 			a.autoCallJudge(inst, prev, prevAt, prevTR, buf)
+		}
 		return
 	}
+	// APPENDED, never restarted. The buffer survives the period being judged,
+	// so a decode that arrives after the others belongs to the same period and
+	// is weighed against all of them.
+	//
+	// It used to be dropped and then judged on its own: the sweeper cleared the
+	// buffer, a straggler opened a "new" one under the same key, and the ladder
+	// was applied to whatever handful had come late — with the other thirty
+	// stations of that period nowhere in sight. A deep decode arriving a second
+	// after the burst is exactly the station worth calling.
 	a.acPeriod[inst], a.acAt[inst], a.acTR[inst] = key, d.At, d.TRPeriod
-	a.acFed[inst] = time.Now()
+	a.acFed[inst], a.acDirty[inst] = time.Now(), true
 	a.acBuf[inst] = append(a.acBuf[inst], acDecode{d: d})
 	a.acMu.Unlock()
 }
@@ -344,9 +365,14 @@ func (a *App) autoCallSweep() {
 		if time.Since(a.acFed[inst]) < acQuiet {
 			continue
 		}
+		// Judged once per period, and again only when something new has come in
+		// for it. The period itself is kept open until a decode from the NEXT one
+		// arrives, so a straggler is judged with the whole period behind it.
+		if a.acJudged[inst] == key && !a.acDirty[inst] {
+			continue
+		}
 		ready = append(ready, due{inst, key, a.acAt[inst], tr, a.acBuf[inst]})
-		delete(a.acPeriod, inst)
-		delete(a.acBuf, inst)
+		a.acJudged[inst], a.acDirty[inst] = key, false
 	}
 	a.acMu.Unlock()
 	for _, d := range ready {
@@ -369,7 +395,9 @@ func (a *App) autoCallSilence() {
 		return
 	}
 	a.acMu.Lock()
-	quiet := a.acPeriod[inst] == "" && time.Since(a.acLastJudge) > 20*time.Second
+	// Nothing pending for this receiver, and nothing judged for a while: the
+	// band has gone quiet under it.
+	quiet := !a.acDirty[inst] && time.Since(a.acLastJudge) > 20*time.Second
 	tr := a.acTR[inst]
 	a.acMu.Unlock()
 	if !quiet {

changelog.json

@@ -1,4 +1,32 @@
 [
+  {
+    "version": "0.27.14",
+    "date": "",
+    "en": [
+      "Auto-call sees a decode that arrives after the others. A decoder sends a period in a burst and stragglers follow — a deep decode a second behind the rest — and the straggler was judged on its own, with the thirty stations of its own period nowhere in sight. The period now stays open until the next one starts, and a late arrival is weighed against all of it.",
+      "Icom CI-V: address 00 can be set, and “Other (custom address)” stays chosen. Zero was treated as “not configured” and every save put the rig back to the IC-7610’s 98 — the model list following it, since it is derived from the address rather than stored.",
+      "Cloudlog / Wavelog upload: a simplex contact is no longer uploaded as split. Every QSO carried a receive band and frequency equal to the transmit side, and Wavelog draws both — an ordinary FT8 contact read “17m/17m”. In ADIF an absent BAND_RX means “same as transmit”, so they are now written only when they differ. The record forwarded to another logger on the UDP link still carries them in full (Log4OM reads BAND_RX).",
+      "Cluster: “S/F” in a spot comment is read as FT8, alongside “superfox”, “sfox” and “F/H”. They are all the same DXpedition transmit mode, and the comment was falling through to the band plan and coming out DATA.",
+      "Auto-call never parks a watched callsign. After a few series of unanswered calls a station is set aside for the session — the right answer for one the LOG picked out, the wrong one for a station YOU named: a DXpedition running a pileup takes more than two series to get through to, which is exactly why it is on the list. The rest between series still applies.",
+      "Right-click → Send to: an upload to a service with no credentials is refused, and says which ones are missing and where. It used to run on its own and report into the QSL Manager’s console, which is not open when the command came from the QSO list — so it looked exactly like an upload that worked. Cloudlog / Wavelog and HamQTH also name themselves properly in the toast.",
+      "[NEW] The mouse wheel steps the RST fields, in the entry strip and in the QSO editor. It counts the way an operator does — 57, 58, 59, 59+5, 59+10, 59+15, 59+20 — one S-unit up to nine and then five decibels at a time, and one decibel on a digital report. R and T do not move. The dropdown beside them lists the reports worth having to hand, not every legal one, so the wheel works on the value rather than walking the list.",
+      "PSK Reporter panel: with the whole-band scope, clicking a decode no longer resets the report count to zero. The window there belongs to the BAND — every FTx report on it, filtered by target only when the analysis is drawn — and it was being emptied on every target change, throwing away an hour of evidence at the exact moment it was worth something. The narrow scope still clears it, because there the window is one station’s.",
+      "Changing mode with a callsign in the field now fixes the report. The “the operator chose this report” flag was holding across a change of mode, where it means nothing — “+00” is not a weak SSB report, it is not a report at all — and anything that fills the field from the rig (the S-meter readouts in the rig consoles) sets that flag too, so it could stay in the wrong notation for the whole QSO. A judgement that can be carried across is carried (57 → 579, 599 → 59); otherwise the mode’s preset answers.",
+      "[NEW] The world map opens centred on YOUR square, not on Greenwich. Centred on 0° it left an Australian looking at their own country in the bottom-right corner with every path running off both edges; centred on their own longitude the same map reads the way their antenna does — the Americas to the east, Europe and Africa to the west. The latitude leans towards your hemisphere without following you to the pole, and a view you have panned to yourself still wins."
+    ],
+    "fr": [
+      "L’auto-call voit un décodage qui arrive après les autres. Un décodeur envoie une période en rafale, puis les retardataires — un décodage « deep » une seconde plus tard — et le retardataire était jugé tout seul, sans les trente stations de sa propre période. La période reste maintenant ouverte jusqu’au début de la suivante, et un arrivant tardif est pesé face à l’ensemble.",
+      "Icom CI-V : l’adresse 00 peut être saisie, et « Other (custom address) » reste sélectionné. Le zéro était pris pour « non configuré » et chaque enregistrement remettait le poste sur le 98 de l’IC-7610 — la liste des modèles suivant, puisqu’elle est déduite de l’adresse et non enregistrée.",
+      "Upload Cloudlog / Wavelog : un contact simplex n’est plus envoyé comme un split. Chaque QSO portait une bande et une fréquence de réception égales à l’émission, et Wavelog affiche les deux — un FT8 ordinaire se lisait « 17m/17m ». En ADIF, un BAND_RX absent signifie « identique à l’émission » : ils ne sont donc écrits que s’ils diffèrent. L’enregistrement transmis à un autre logiciel par UDP les porte toujours en entier (Log4OM lit BAND_RX).",
+      "Cluster : « S/F » dans un commentaire de spot est lu comme du FT8, au même titre que « superfox », « sfox » et « F/H ». C’est le même mode d’émission DXpédition, et le commentaire retombait sur le plan de bande pour ressortir en DATA.",
+      "L’auto-call ne met jamais de côté un indicatif de la watchlist. Après quelques séries d’appels sans réponse, une station est écartée pour la session — la bonne réponse pour une station choisie par le CARNET, la mauvaise pour une station que VOUS avez nommée : un DX en pile-up demande plus de deux séries pour passer, et c’est précisément pour ça qu’il est sur la liste. Le repos entre séries s’applique toujours.",
+      "Clic droit → Envoyer vers : un envoi vers un service non configuré est refusé, en disant ce qui manque et où. Il partait tout seul et rendait compte dans la console du gestionnaire QSL, qui n’est pas ouverte quand la commande vient de la liste des QSO — ça ressemblait donc exactement à un envoi réussi. Cloudlog / Wavelog et HamQTH s’annoncent aussi sous leur nom dans le message.",
+      "[NEW] La molette fait défiler les champs RST, dans la barre de saisie comme dans l’éditeur de QSO. Elle compte comme un opérateur — 57, 58, 59, 59+5, 59+10, 59+15, 59+20 — un point S jusqu’à neuf puis cinq décibels à la fois, et un décibel sur un report numérique. R et T ne bougent pas. La liste déroulante à côté contient les reports qu’on veut sous la main, pas tous les reports légaux : la molette agit donc sur la valeur plutôt que de parcourir la liste.",
+      "Panneau PSK Reporter : en portée « toute la bande », cliquer sur un décodage ne remet plus le nombre de reports à zéro. La fenêtre appartient là à la BANDE — tous les reports FTx qui y circulent, filtrés par cible seulement à l’affichage — et elle était vidée à chaque changement de cible, jetant une heure d’observations au moment précis où elles servent. La portée étroite continue de la vider : là, la fenêtre est celle d’une seule station.",
+      "Changer de mode avec un indicatif dans le champ corrige désormais le report. Le drapeau « l’opérateur a choisi ce report » tenait au travers d’un changement de mode, où il ne veut rien dire — « +00 » n’est pas un report SSB faible, ce n’est pas un report du tout — et tout ce qui remplit le champ depuis le poste (les lectures S-mètre des consoles) lève ce drapeau aussi : la notation pouvait rester fausse pour tout le QSO. Un jugement transposable l’est (57 → 579, 599 → 59) ; sinon le préréglage du mode répond.",
+      "[NEW] La carte du monde s’ouvre centrée sur VOTRE locator, plus sur Greenwich. Centrée sur 0°, elle laissait un Australien avec son pays dans le coin en bas à droite et tous les trajets qui sortaient des deux bords ; centrée sur sa longitude, la même carte se lit comme son antenne travaille — les Amériques à l’est, l’Europe et l’Afrique à l’ouest. La latitude penche vers votre hémisphère sans vous suivre jusqu’au pôle, et une vue que vous avez déplacée vous-même reste prioritaire."
+    ]
+  },
   {
     "version": "0.27.13",
     "date": "",

frontend/src/App.tsx

@@ -150,6 +150,7 @@ import { cn } from '@/lib/utils';
 import { pathBetween, pathBetweenLatLon, gridToLatLon, latLonToGrid } from '@/lib/maidenhead';
 import { flagURL } from '@/lib/flags';
 import { LogViewer } from '@/components/LogViewer';
+import { convertRST, rstFitsMode, stepRST } from '@/lib/rst';
 
 type QSO = QSOForm;
 type ImportResult = adifModels.ImportResult;
@@ -657,6 +658,11 @@ export default function App() {
   useEffect(() => { rstListsRef.current = rstLists; }, [rstLists]);
   const [rstSent, setRstSent] = useState('59');
   const [rstRcvd, setRstRcvd] = useState('59');
+  // Read by applyModePreset, which runs from those same long-lived closures.
+  const rstSentRef = useRef(rstSent);
+  const rstRcvdRef = useRef(rstRcvd);
+  useEffect(() => { rstSentRef.current = rstSent; }, [rstSent]);
+  useEffect(() => { rstRcvdRef.current = rstRcvd; }, [rstRcvd]);
   const [grid, setGrid] = useState('');
   const [name, setName] = useState('');
   const [qth, setQth] = useState('');
@@ -3340,15 +3346,31 @@ export default function App() {
     return m;
   }
   function applyModePreset(m: string) {
-    if (rstUserEditedRef.current) return;
+    // AN EDIT IS ABOUT A SIGNAL, NOT ABOUT A NOTATION.
+    //
+    // The edited flag protects a report the operator chose — 57 rather than 59 —
+    // and it used to protect it across a change of mode as well, where it means
+    // nothing: "+00" is not a weak SSB report, it is not a report at all. An
+    // operator with a callsign in the field, switching from FT8 to SSB, was left
+    // with a decibel figure to log, and anything that fills the report from the
+    // rig (the S-meter readouts in the rig consoles) sets that flag too — so the
+    // field could be stuck in the wrong notation for the rest of the QSO.
+    //
+    // So the flag holds only while the report still belongs to the mode. When it
+    // does not, the judgement is carried across where it can be (57 → 579,
+    // 599 → 59) and the preset answers where it cannot.
+    const fits = rstFitsMode(rstSentRef.current, m) && rstFitsMode(rstRcvdRef.current, m);
+    if (rstUserEditedRef.current && fits) return;
     // Prefer the user's configured preset RST; otherwise fall back to the mode
     // category default (CW/RTTY/PSK → 599, phone → 59, digital → first option)
     // so switching SSB→CW flips 59→599 even without a configured preset.
     // Read through the refs, never the state: see their declaration.
     const p = modePresetsRef.current.find((x) => x.name === m);
     const fallback = rstOptions(m, rstListsRef.current)[0] || '';
-    setRstSent(p?.default_rst_sent || fallback);
-    setRstRcvd(p?.default_rst_rcvd || fallback);
+    const keep = (cur: string, preset: string) =>
+      (rstUserEditedRef.current && convertRST(cur, m)) || preset || fallback;
+    setRstSent(keep(rstSentRef.current, p?.default_rst_sent || ''));
+    setRstRcvd(keep(rstRcvdRef.current, p?.default_rst_rcvd || ''));
   }
   // Clicking a spot (cluster grid or any band map): tune the rig, set the mode,
   // fill the call, pre-fill POTA, (re)start the recording. Shared so every spot
@@ -4559,11 +4581,16 @@ export default function App() {
     const LABELS: Record<string, string> = {
       qrz: 'QRZ.com', clublog: 'Club Log', lotw: 'LoTW',
       hrdlog: 'HRDLog.net', eqsl: 'eQSL.cc', hamlog: 'HAMLOG.online',
+      hamqth: 'HamQTH', cloudlog: 'Cloudlog / Wavelog',
     };
     const label = LABELS[service] ?? service;
+    try {
+      // Awaited BEFORE the toast: the backend refuses a service with no
+      // credentials, and announcing an upload that was never started is how an
+      // operator concludes their QSOs are on a site they never signed up to.
+      await UploadQSOsManual(service, ids as any);
       showToast(`Uploading ${ids.length} QSO${ids.length > 1 ? 's' : ''} to ${label}…`);
-    try { await UploadQSOsManual(service, ids as any); }
-    catch (e: any) { setError(String(e?.message ?? e)); }
+    } catch (e: any) { setError(String(e?.message ?? e)); }
   }
   // Right-click "Export filtered to ADIF (no limit)": exports every QSO that
   // matches the current filter, bypassing the on-screen row threshold.
@@ -5475,12 +5502,19 @@ export default function App() {
   );
   const rstTxBlock = (
     <div className="flex flex-col w-20" data-esm="rsttx"><Label className="mb-1 h-3.5">{t('field.rstTx')}</Label>
-      <Combobox value={rstSent} options={rstOptions(mode, rstLists)} commitOnType onChange={(v) => { setRstSent(v); rstUserEditedRef.current = true; }} />
+      {/* The wheel steps the report — an S-unit on RST, a decibel on a digital
+          one. Wheeling is the same gesture as saying "he is a bit stronger than
+          that", and it beats retyping three characters between overs. */}
+      <Combobox value={rstSent} options={rstOptions(mode, rstLists)} commitOnType
+        onChange={(v) => { setRstSent(v); rstUserEditedRef.current = true; }}
+        onWheelStep={(d) => { setRstSent((v) => stepRST(v, d, mode)); rstUserEditedRef.current = true; }} />
     </div>
   );
   const rstRxBlock = (
     <div className="flex flex-col w-20" data-esm="rstrx"><Label className="mb-1 h-3.5">{t('field.rstRx')}</Label>
-      <Combobox value={rstRcvd} options={rstOptions(mode, rstLists)} commitOnType onChange={(v) => { setRstRcvd(v); rstUserEditedRef.current = true; }} />
+      <Combobox value={rstRcvd} options={rstOptions(mode, rstLists)} commitOnType
+        onChange={(v) => { setRstRcvd(v); rstUserEditedRef.current = true; }}
+        onWheelStep={(d) => { setRstRcvd((v) => stepRST(v, d, mode)); rstUserEditedRef.current = true; }} />
     </div>
   );
   // DX country flag, shown large next to RST (moved here from the Country field).

frontend/src/components/MainMap.tsx

@@ -28,6 +28,26 @@ function saveMapView(m: L.Map) {
 // unwrapLon makes a lat/lon ring continuous in longitude (each point within
 // 180° of the previous) so a polygon crossing the antimeridian doesn't snap
 // across the whole map. Coords may exceed ±180; Leaflet (worldCopyJump) is fine.
+// homeView is where a world map should open for THIS station.
+//
+// Centred on 0° a world map puts Europe in the middle and leaves an Australian
+// looking at their own country in the bottom-right corner, with the paths to
+// everywhere they work running off both edges. Centred on their own longitude
+// the same map reads the way their antenna does: the Americas to the east,
+// Europe and Africa to the west. Leaflet repeats the world horizontally
+// (worldCopyJump), so this is a choice of viewpoint and costs nothing — the
+// tiles either side are the same world, and the great-circle code already draws
+// across the seam (see unwrapLon).
+//
+// The latitude is damped, not followed: a station at 69° north centred on itself
+// would spend half the map on the Arctic. It leans towards the operator's
+// hemisphere and stops well short of the pole.
+function homeView(grid: string): [number, number] {
+  const home = gridToLatLon(grid);
+  if (!home) return [20, 0];
+  return [Math.max(-35, Math.min(45, home.lat * 0.6 + 8)), home.lon];
+}
+
 function unwrapLon(ring: [number, number][]): [number, number][] {
   const out: [number, number][] = [];
   let prev = NaN;
@@ -178,6 +198,18 @@ export function WorldMap({ fromGrid, toGrid, fromLabel, toLabel, beamAzimuths, b
   const autoZoomRef = useRef(autoZoom);
   useEffect(() => { autoZoomRef.current = autoZoom; }, [autoZoom]);
 
+  // The station's own square arrives from the profile a moment AFTER this map is
+  // built, so the first view is drawn without it. Re-centred once when it lands —
+  // and never again, nor over a view the operator has panned to themselves.
+  const homeCentred = useRef(false);
+  useEffect(() => {
+    const m = worldMap.current;
+    if (!m || homeCentred.current || !gridToLatLon(fromGrid)) return;
+    homeCentred.current = true;
+    if (loadMapView()) return; // their own view wins
+    m.setView(homeView(fromGrid), m.getZoom());
+  }, [fromGrid]);
+
   // One-time map creation.
   useEffect(() => {
     if (worldRef.current && !worldMap.current) {
@@ -187,7 +219,7 @@ export function WorldMap({ fromGrid, toGrid, fromLabel, toLabel, beamAzimuths, b
       // enough to blow WebView2's raster budget and leave the window painting in
       // patches. On canvas it is a single layer.
       const m = L.map(worldRef.current, { zoomControl: true, attributionControl: true, worldCopyJump: true, preferCanvas: true })
-        .setView([20, 0], 1);
+        .setView(homeView(fromGrid), 1);
       addBasemap(m, basemap, baseLayer, labelsLayer);
       worldOverlay.current = L.layerGroup().addTo(m);
       worldMap.current = m;
@@ -196,6 +228,7 @@ export function WorldMap({ fromGrid, toGrid, fromLabel, toLabel, beamAzimuths, b
       m.on('moveend', () => { if (!autoZoomRef.current) saveMapView(m); });
     }
     const t = window.setTimeout(() => { worldMap.current?.invalidateSize(); }, 80);
+
     // Resizing the pane is the ONLY thing that needs invalidateSize. Calling it on
     // every overlay redraw (as before) forced a full repaint of the map each time
     // the rotor moved a degree.

frontend/src/components/QSOEditModal.tsx

@@ -1,7 +1,7 @@
 import { useEffect, useMemo, useRef, useState } from 'react';
 import { Trash2, Search, Loader2, CalendarDays } from 'lucide-react';
 import { LookupCallsign, LookupCallsignFresh, DXCCForCountry, GetAwardDefs, ComputeQSOAwardRefs, GetListsSettings, OpenExternalURL, SetOpsLogQSLReceived } from '../../wailsjs/go/main/App';
-import { rstOptions, type RSTLists } from '@/lib/rst';
+import { rstOptions, stepRST, type RSTLists } from '@/lib/rst';
 import { AwardRefSelector } from '@/components/AwardRefSelector';
 import { AdifExtrasEditor } from '@/components/AdifExtrasEditor';
 import { applyAwardRefs } from '@/lib/awardRefs';
@@ -598,9 +598,13 @@ export function QSOEditModal({ qso, onSave, onDelete, onClose, countries = [], b
                     value={draft.callsign ?? ''} onChange={(e) => set('callsign', e.target.value)} />
                 </div>
                 <div className="flex flex-col w-20"><Label>S</Label>
-                  <Combobox value={draft.rst_sent ?? ''} options={rstOptions(draft.mode ?? '', rstLists)} commitOnType onChange={(v) => set('rst_sent', v)} /></div>
+                  <Combobox value={draft.rst_sent ?? ''} options={rstOptions(draft.mode ?? '', rstLists)} commitOnType
+                    onChange={(v) => set('rst_sent', v)}
+                    onWheelStep={(d) => set('rst_sent', stepRST(draft.rst_sent ?? '', d, draft.mode ?? ''))} /></div>
                 <div className="flex flex-col w-20"><Label>R</Label>
-                  <Combobox value={draft.rst_rcvd ?? ''} options={rstOptions(draft.mode ?? '', rstLists)} commitOnType onChange={(v) => set('rst_rcvd', v)} /></div>
+                  <Combobox value={draft.rst_rcvd ?? ''} options={rstOptions(draft.mode ?? '', rstLists)} commitOnType
+                    onChange={(v) => set('rst_rcvd', v)}
+                    onWheelStep={(d) => set('rst_rcvd', stepRST(draft.rst_rcvd ?? '', d, draft.mode ?? ''))} /></div>
                 <Button type="button" variant="outline" className="h-10" onClick={fetchLookup} disabled={looking}
                   title={t('qedit.fetchTitle')}>
                   {looking ? <Loader2 className="size-4 animate-spin" /> : <Search className="size-4" />} {t('qedit.fetch')}

frontend/src/components/SettingsModal.tsx

@@ -1621,6 +1621,11 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
   const [listenPref, setListenPref] = useState(true);
   const [activeRadio, setActiveRadioId] = useState('');
   const [radioBusy, setRadioBusy] = useState(false);
+  // "Other (custom address)" has to STAY chosen. The dropdown is derived from
+  // the address, so picking Other while the address still matched a listed rig
+  // put the list straight back on that rig — the operator saw it jump back to
+  // IC-7610 the moment they chose Other.
+  const [icomCustom, setIcomCustom] = useState(false);
   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, flex_dvk_dax: false,
     yaesu_port: '', yaesu_baud: 38400, yaesu_low_lines: false, kenwood_low_lines: false, kenwood_port: '', kenwood_baud: 9600, kenwood_host: '', kenwood_link: 'usb', kenwood_data_mode: 'usb', xiegu_port: '', xiegu_baud: 19200, xiegu_addr: 0x70, xiegu_ptt_line: '',
@@ -3628,8 +3633,12 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
               <div className="space-y-1">
                 <Label>{t('cat.icomModel')}</Label>
                 <Select
-                  value={ICOM_MODELS.find((m) => m.addr === (catCfg.icom_addr ?? 0x98))?.name ?? '_custom'}
-                  onValueChange={(v) => { const m = ICOM_MODELS.find((x) => x.name === v); if (m) setCatCfg((s) => ({ ...s, icom_addr: m.addr })); }}>
+                  value={icomCustom ? '_custom' : (ICOM_MODELS.find((m) => m.addr === (catCfg.icom_addr ?? 0x98))?.name ?? '_custom')}
+                  onValueChange={(v) => {
+                    const m = ICOM_MODELS.find((x) => x.name === v);
+                    setIcomCustom(!m);
+                    if (m) setCatCfg((s) => ({ ...s, icom_addr: m.addr }));
+                  }}>
                   <SelectTrigger><SelectValue /></SelectTrigger>
                   <SelectContent>
                     {ICOM_MODELS.map((m) => <SelectItem key={m.name} value={m.name}>{m.name}</SelectItem>)}
@@ -3655,8 +3664,12 @@ function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged
               <div className="space-y-1">
                 <Label>{t('cat.icomModel')}</Label>
                 <Select
-                  value={ICOM_MODELS.find((m) => m.addr === (catCfg.icom_addr ?? 0x98))?.name ?? '_custom'}
-                  onValueChange={(v) => { const m = ICOM_MODELS.find((x) => x.name === v); if (m) setCatCfg((s) => ({ ...s, icom_addr: m.addr })); }}>
+                  value={icomCustom ? '_custom' : (ICOM_MODELS.find((m) => m.addr === (catCfg.icom_addr ?? 0x98))?.name ?? '_custom')}
+                  onValueChange={(v) => {
+                    const m = ICOM_MODELS.find((x) => x.name === v);
+                    setIcomCustom(!m);
+                    if (m) setCatCfg((s) => ({ ...s, icom_addr: m.addr }));
+                  }}>
                   <SelectTrigger><SelectValue /></SelectTrigger>
                   <SelectContent>
                     {ICOM_MODELS.map((m) => <SelectItem key={m.name} value={m.name}>{m.name}</SelectItem>)}

frontend/src/components/ui/combobox.tsx

@@ -9,7 +9,7 @@ import { cn } from '@/lib/utils';
 // can't hold a typo'd value that isn't in the list.
 export function Combobox({
   value, onChange, options, placeholder, className, allowFreeText = false, commitOnType = false,
-  showToggle = false,
+  showToggle = false, onWheelStep,
 }: {
   value: string;
   onChange: (v: string) => void;
@@ -21,6 +21,10 @@ export function Combobox({
   // fields read live by other actions — e.g. RST, so a CW macro sent without
   // leaving the field uses the value just typed.
   commitOnType?: boolean;
+  // Wheel over the field steps the value. The control cannot know what a step
+  // means — a decibel here, an S-unit there — so it reports the direction and
+  // the owner decides.
+  onWheelStep?: (dir: 1 | -1) => void;
   // Draw a chevron that opens the full list on click.
   //
   // Without it this control is indistinguishable from a plain text box: it opens
@@ -42,6 +46,21 @@ export function Combobox({
   // leave the list floating over the wrong row.
   const [menuPos, setMenuPos] = useState({ top: 0, left: 0, width: 0 });
 
+  // A NATIVE, non-passive listener: React attaches onWheel passively, where
+  // preventDefault does nothing at all and the panel scrolls away under the
+  // field being adjusted.
+  useEffect(() => {
+    const el = ref.current;
+    if (!el || !onWheelStep) return;
+    const onWheel = (e: WheelEvent) => {
+      if (e.deltaY === 0) return;
+      e.preventDefault();
+      onWheelStep(e.deltaY < 0 ? 1 : -1); // up is a better report
+    };
+    el.addEventListener('wheel', onWheel, { passive: false });
+    return () => el.removeEventListener('wheel', onWheel);
+  }, [onWheelStep]);
+
   useEffect(() => {
     function onDoc(e: MouseEvent) {
       if (ref.current && !ref.current.contains(e.target as Node)) setOpen(false);

frontend/src/lib/rst.ts

@@ -36,3 +36,85 @@ export function rstOptions(mode: string, lists: RSTLists): string[] {
   if (l && l.length) return l;
   return cat === 'phone' ? ['59', '58', '57'] : cat === 'cw' ? ['599', '589', '579'] : ['+00', '-10', '-20'];
 }
+
+// stepRST moves a report one step up or down, the way an operator would say it.
+//
+// The dropdown beside these fields is a list of the values worth having to hand,
+// not of every legal report: nobody keeps 41 dB figures in it. So the wheel
+// works on the VALUE, not on the list — a digital report moves by a decibel and
+// an RST by one S-unit, which is what the hand on the wheel is asking for.
+//
+// dir is +1 for wheel up (a better report) and -1 for down.
+export function stepRST(value: string, dir: number, mode: string): string {
+  const v = (value || '').trim();
+  if (v === '') return v;
+  if (rstCategory(mode) === 'digital') {
+    // A dB report: "-12", "+05", "0". Kept in its own shape — signed and two
+    // digits — because that is how every decoder writes it and how the operator
+    // reads it back off the screen.
+    const n = parseInt(v, 10);
+    if (!Number.isFinite(n)) return v;
+    // The range WSJT-X itself reports in, with room either side. Beyond it the
+    // number stops meaning anything.
+    const next = Math.max(-30, Math.min(35, n + dir));
+    return (next < 0 ? '-' : '+') + String(Math.abs(next)).padStart(2, '0');
+  }
+  // RST/RS, and the S9+ ladder above it. What an operator counts through is
+  //
+  //   … 57  58  59  59+5  59+10  59+15  59+20 …
+  //
+  // — one S-unit up to nine, then five decibels at a time, because that is how
+  // a strong signal is reported and how the S-meter is read (see sMeterRST).
+  // Stepping the S digit and leaving the "+20" where it was would have gone
+  // from 59+20 to 58+20, which nobody has ever said on the air.
+  //
+  // R and T do not move: they are judgements about readability and tone, and a
+  // wheel has no business changing them.
+  const m = /^(\d)(\d)(\d?)(?:\+(\d+))?$/.exec(v);
+  if (!m) return v;
+  const head = m[1];
+  const tone = m[3];
+  let sUnit = parseInt(m[2], 10);
+  let over = m[4] === undefined ? 0 : parseInt(m[4], 10);
+  if (over > 0) {
+    // Above S9: five at a time, and back down through +5 to a plain 59.
+    over = Math.max(0, Math.min(60, over + dir * 5));
+  } else if (sUnit >= 9 && dir > 0) {
+    over = 5; // 59 → 59+5
+  } else {
+    sUnit = Math.max(1, Math.min(9, sUnit + dir));
+  }
+  return head + String(sUnit) + tone + (over > 0 ? '+' + over : '');
+}
+
+// rstFitsMode says whether a report belongs to the family a mode reports in.
+//
+// The three families are written differently and are not interchangeable: a
+// signed decibel figure ("+00"), a three-figure RST ("599"), a two-figure RS
+// ("59", with an optional "+20" above S9). "+00" on SSB is not a weak report,
+// it is not a report at all.
+export function rstFitsMode(value: string, mode: string): boolean {
+  const v = (value || '').trim();
+  if (v === '') return false;
+  switch (rstCategory(mode)) {
+    case 'digital': return /^[+-]\d{1,2}$/.test(v);
+    case 'cw': return /^\d{3}(\+\d+)?$/.test(v);
+    default: return /^\d{2}(\+\d+)?$/.test(v);
+  }
+}
+
+// convertRST carries a report across the CW/phone divide, keeping the operator's
+// own judgement of the signal: 57 becomes 579, 599 becomes 59.
+//
+// Only between those two — a decibel figure says nothing about readability and
+// an RST says nothing in decibels, so there the preset is the honest answer.
+// Returns '' when it cannot be done.
+export function convertRST(value: string, toMode: string): string {
+  const v = (value || '').trim();
+  const to = rstCategory(toMode);
+  if (to === 'digital') return '';
+  const m = /^(\d)(\d)(\d?)((?:\+\d+)?)$/.exec(v);
+  if (!m) return '';
+  if (to === 'cw') return m[1] + m[2] + '9' + m[4];  // RS → RST, tone 9
+  return m[1] + m[2] + m[4];                        // RST → RS, tone dropped
+}

frontend/src/lib/spot.ts

@@ -15,12 +15,15 @@ export function cleanSpotter(s: string): string {
 // alone instead of guessing wrong.
 export function inferSpotMode(comment: string, freqHz: number): string {
   const c = (comment || '').toUpperCase();
-  // SuperFox and Fox/Hound are FT8 — they are WSJT-X's DXpedition transmit
-  // modes, not modes of their own. A spot commented "super fox" fell through to
-  // the band plan and came out DATA, and that verdict is not cosmetic: the
+  // SuperFox and Fox/Hound are FT8 — they are WSJT-X's DXpedition transmit modes,
+  // not modes of their own, and they turn up in a comment written every way an
+  // operator can shorten them: "super fox", SFOX, S/F, F/H.
+  //
+  // A spot commented "super fox" fell through to the band plan and came out
+  // DATA, and that verdict is not cosmetic: the
   // band+mode status is computed from this answer, so a ZD8 on 21.071 read as a
   // new DATA slot rather than the new FT8 one it is.
-  if (/\bSUPER\s*FOX\b|\bSFOX\b|\bFOX\s*\/?\s*HOUND\b|\bF\/H\b/.test(c)) return 'FT8';
+  if (/\bSUPER\s*FOX\b|\bSFOX\b|\bS\/F\b|\bFOX\s*\/?\s*HOUND\b|\bF\/H\b/.test(c)) return 'FT8';
   if (/\bFT8\b/.test(c))   return 'FT8';
   if (/\bFT4\b/.test(c))   return 'FT4';
   if (/\bJS8\b/.test(c))   return 'JS8';

internal/adif/export.go

@@ -120,12 +120,36 @@ func (e *Exporter) writeDoc(ctx context.Context, w io.Writer, iter iterator) (in
 func SingleRecordADIF(q qso.QSO) string {
 	var b strings.Builder
 	bw := bufio.NewWriter(&b)
-	// Uploads target other services — keep it standard (no app-specific tags).
+	// Uploads target other services — keep it standard (no app-specific tags),
+	// and say nothing about the receive side when there is nothing to say: in
+	// ADIF an absent BAND_RX/FREQ_RX means "same as transmit", and a logger
+	// given both draws both. Wavelog reads a simplex FT8 contact uploaded with
+	// BAND_RX filled in as split and shows it as "17m/17m".
 	writeRecord(bw, q, false, nil)
 	bw.Flush()
 	return b.String()
 }
 
+// ForwardRecordADIF is the record sent to ANOTHER LOGGER on the UDP link.
+//
+// The receive side is written even when it repeats the transmit side, which is
+// the opposite of the upload rule above and is deliberate: Log4OM reads BAND_RX
+// and found nothing there for contacts logged by a path that left it blank. A
+// logger on the same desk is being handed a copy of our record, not published
+// to a service that will draw conclusions from every tag present.
+func ForwardRecordADIF(q qso.QSO) string {
+	var b strings.Builder
+	bw := bufio.NewWriter(&b)
+	writeRecord(bw, q, false, nil, keepRX)
+	bw.Flush()
+	return b.String()
+}
+
+// keepRX marks a record whose receive side must be written out in full.
+type rxMode int
+
+const keepRX rxMode = 1
+
 // FullRecordADIF serialises one QSO LOSSLESSLY — including the APP_* extras —
 // so it can be written out and read back with nothing dropped. Used by the
 // offline queue: a QSO parked in the safety file must come back identical
@@ -161,7 +185,18 @@ func BatchRecordsADIF(records []string) string {
 // Empty fields are omitted. MODE/SUBMODE are massaged so a "promoted"
 // mode (e.g. FT4 stored without a parent) is exported as the canonical
 // pair MODE=MFSK SUBMODE=FT4 — round-trips cleanly with strict loggers.
-func writeRecord(bw *bufio.Writer, q qso.QSO, includeApp bool, allow map[string]bool) {
+func writeRecord(bw *bufio.Writer, q qso.QSO, includeApp bool, allow map[string]bool, rx ...rxMode) {
+	// The receive side, unless it merely repeats the transmit side. See
+	// SingleRecordADIF and ForwardRecordADIF.
+	bandRX, freqRX := q.BandRX, q.FreqRXHz
+	if len(rx) == 0 || rx[0] != keepRX {
+		if strings.EqualFold(strings.TrimSpace(bandRX), strings.TrimSpace(q.Band)) {
+			bandRX = ""
+		}
+		if freqRX != nil && q.FreqHz != nil && *freqRX == *q.FreqHz {
+			freqRX = nil
+		}
+	}
 	// allow == nil → write every promoted field (standard/full behaviour).
 	// Otherwise a promoted tag is written only when it's in the chosen set.
 	// w/wi/wf wrap the raw writers with that gate so the ~150 field lines below
@@ -194,7 +229,7 @@ func writeRecord(bw *bufio.Writer, q qso.QSO, includeApp bool, allow map[string]
 		w("TIME_OFF", q.QSODateOff.UTC().Format("150405"))
 	}
 	w("BAND", q.Band)
-	w("BAND_RX", q.BandRX)
+	w("BAND_RX", bandRX)
 
 	mode, submode := modeForExport(q.Mode, q.Submode)
 	w("MODE", mode)
@@ -203,8 +238,8 @@ func writeRecord(bw *bufio.Writer, q qso.QSO, includeApp bool, allow map[string]
 	if q.FreqHz != nil && *q.FreqHz > 0 {
 		w("FREQ", strconv.FormatFloat(float64(*q.FreqHz)/1_000_000, 'f', 6, 64))
 	}
-	if q.FreqRXHz != nil && *q.FreqRXHz > 0 {
-		w("FREQ_RX", strconv.FormatFloat(float64(*q.FreqRXHz)/1_000_000, 'f', 6, 64))
+	if freqRX != nil && *freqRX > 0 {
+		w("FREQ_RX", strconv.FormatFloat(float64(*freqRX)/1_000_000, 'f', 6, 64))
 	}
 
 	w("RST_SENT", q.RSTSent)

internal/autocall/autocall.go

@@ -1000,7 +1000,19 @@ func (e *Engine) judge(c Candidate, p Period, only []string) (bool, string) {
 	if rank(c) == 0 {
 		return false, "nothing-needed"
 	}
-	if e.rounds[call] >= e.set.MaxRounds {
+	// A WATCHED callsign is never parked.
+	//
+	// Parking is the answer to "it will not answer, stop wasting the evening on
+	// it" — a fair verdict about a station the LOG picked out, and the wrong one
+	// about a station the OPERATOR did. A DXpedition running a pileup takes more
+	// than two series of calls to get through to, which is precisely why it was
+	// put on the list; watched ZD8GB was refused for the rest of the session
+	// after fourteen unanswered calls, while it went on transmitting six streams
+	// a period.
+	//
+	// The rest between series still applies, so it does not monopolise the
+	// transmitter — it simply never becomes ineligible.
+	if e.rounds[call] >= e.set.MaxRounds && !c.Watched {
 		return false, "parked" // its series are spent for the session
 	}
 	// RESTING. A series that ended in a brake is followed by a real pause,

internal/autocall/autocall_test.go

@@ -922,3 +922,27 @@ func TestTheFirstCallStartsWithNoMisses(t *testing.T) {
 		t.Fatalf("misses=%d — the station's own silent period was not counted", e.misses)
 	}
 }
+
+// Parking answers "it will not answer, stop wasting the evening on it" — which
+// is a verdict about a station the LOG picked out, not about one the OPERATOR
+// did. From the air: a watched ZD8GB, six streams a period, refused for the
+// rest of the session after two series of unanswered calls.
+func TestAWatchedCallsignIsNeverParked(t *testing.T) {
+	spent := func(c Candidate) *Engine {
+		e := New(Settings{Enabled: true, MaxRounds: 2, Rest: 0})
+		for i := 0; i < 2; i++ {
+			e.giveUp(strings.ToUpper(c.Call), c) // a series ended by a brake
+		}
+		return e
+	}
+
+	plain := cq("PLAIN", NeedDXCC, 0)
+	if a := spent(plain).OnPeriod(period(0, plain)); a.Kind == DoReply {
+		t.Errorf("%+v — a station whose series are spent was called again", a)
+	}
+
+	dx := cq("ZD8GB", NeedDXCC, 0, watched)
+	if a := spent(dx).OnPeriod(period(0, dx)); a.Kind != DoReply {
+		t.Errorf("%+v — a watched DXpedition was parked for the session", a)
+	}
+}

internal/cat/icomnet.go

@@ -43,7 +43,7 @@ var icnBE = binary.BigEndian
 // = CI-V only (the proven default). The audio stream is fully separate from CAT,
 // so enabling it can't affect freq/mode/DSP control.
 func NewIcomNet(host, user, pass string, civAddr int, digitalDefault string, audioSink func([]byte)) *IcomSerial {
-	if civAddr <= 0 || civAddr > 0xFF {
+	if civAddr < 0 || civAddr > 0xFF {
 		civAddr = 0x98 // IC-7610
 	}
 	if digitalDefault == "" {

internal/cat/icomserial.go

@@ -172,12 +172,13 @@ const (
 )
 
 // NewIcomSerial builds an (unconnected) Icom serial backend. baud defaults to
-// 115200, rig address to the IC-7610's 0x98 when out of range.
+// 115200, rig address to the IC-7610's 0x98 when out of range — and 0x00 is in
+// range: it is a valid CI-V address that some rigs and interfaces are set to.
 func NewIcomSerial(portName string, baud, civAddr int, digitalDefault string) *IcomSerial {
 	if baud <= 0 {
 		baud = 115200
 	}
-	if civAddr <= 0 || civAddr > 0xFF {
+	if civAddr < 0 || civAddr > 0xFF {
 		civAddr = 0x98 // IC-7610
 	}
 	if digitalDefault == "" {

internal/pskrtgt/pskrtgt.go

@@ -279,13 +279,9 @@ func (w *Watcher) Watch(target, mode string, dialHz int64) error {
 		return nil
 	}
 
-	w.mu.Lock()
-	// The window belongs to the target it was collected for. Keeping it across a
-	// change would answer the new question with the old station's evidence.
 	if changed {
-		w.spots = w.spots[:0]
+		w.dropWindowOfPreviousTarget()
 	}
-	w.mu.Unlock()
 
 	if err := w.resubscribe(client); err != nil {
 		return err
@@ -301,6 +297,28 @@ func (w *Watcher) Watch(target, mode string, dialHz int64) error {
 	return nil
 }
 
+// dropWindowOfPreviousTarget empties the collected window when it belonged to
+// the station being left behind.
+//
+// WHOSE WINDOW IS IT? Under the narrow scope the subscription IS the target —
+// three filters about one station — so the window is his, and keeping it across
+// a change would answer the new question with the old station's evidence.
+//
+// Under the band-wide scope it is the BAND's: every FTx report on it, filtered
+// by target only when the analysis is drawn. Clearing it there threw away an
+// hour of accumulated evidence on every click, and a panel that had been showing
+// hundreds of reports read zero — the operator clicking a decode to ask "can he
+// hear me" is the very moment that history is worth something, and it was being
+// deleted in order to answer the question.
+func (w *Watcher) dropWindowOfPreviousTarget() {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	if w.cfg.Scope == ScopeBand {
+		return
+	}
+	w.spots = w.spots[:0]
+}
+
 // resubscribe replaces every filter with the ones the current target and scope
 // want. Takes the old ones down first: a target change that only ADDED filters
 // would leave the previous station's reports arriving for ever.

internal/pskrtgt/pskrtgt_test.go

@@ -156,3 +156,26 @@ func TestACrowdedPassbandStillGetsAnAnswer(t *testing.T) {
 		t.Errorf("suggested %d Hz, want the quietest slot around 2400", got)
 	}
 }
+
+// Under the band-wide scope the window is the BAND's, not the target's: it is
+// every FTx report on it, filtered by target only when the analysis is drawn.
+// Clearing it on a target change threw away an hour of accumulated evidence at
+// the exact moment it was worth something — the operator clicking a decode to
+// ask "can he hear me" saw the report count drop to zero.
+func TestBandScopeKeepsItsWindowAcrossATargetChange(t *testing.T) {
+	for _, tc := range []struct {
+		scope Scope
+		keep  bool
+	}{{ScopeBand, true}, {ScopeTarget, false}} {
+		w := &Watcher{cfg: Config{Scope: tc.scope, Logf: func(string, ...any) {}}}
+		w.target, w.mode = "OLD", "FT8"
+		w.spots = []spot{{TxCall: "OLD", RxCall: "F4BPO", at: time.Now()}}
+
+		w.dropWindowOfPreviousTarget()
+		w.target = "NEW"
+
+		if got := len(w.spots) > 0; got != tc.keep {
+			t.Errorf("%s scope: window kept = %v, want %v", tc.scope, got, tc.keep)
+		}
+	}
+}

rxdefaults_test.go

@@ -10,6 +10,10 @@ import (
 
 // A contact that was not split still has a receive side, and the record
 // forwarded to another logger has to carry it: Log4OM reads BAND_RX.
+//
+// The record UPLOADED to a service must not: in ADIF an absent BAND_RX means
+// "same as transmit", and Wavelog shown both draws "17m/17m" on a simplex FT8
+// contact — reported by OE6CLD, who had never logged a split QSO in his life.
 func TestFillRXDefaults(t *testing.T) {
 	hz := int64(14074000)
 	q := qso.QSO{Callsign: "F4BPO", Band: "20m", FreqHz: &hz}
@@ -22,7 +26,7 @@ func TestFillRXDefaults(t *testing.T) {
 	}
 	// Assert on the RECORD another logger reads, not merely on the struct:
 	// both halves of the receive side have to reach it.
-	rec := strings.ToUpper(adif.SingleRecordADIF(q))
+	rec := strings.ToUpper(adif.ForwardRecordADIF(q))
 	if !strings.Contains(rec, "<BAND_RX:3>20M") {
 		t.Errorf("BAND_RX missing from the forwarded record:\n%s", rec)
 	}
@@ -40,3 +44,14 @@ func TestFillRXDefaultsKeepsSplit(t *testing.T) {
 		t.Errorf("split QSO was overwritten: band_rx=%q freq_rx=%v", q.BandRX, q.FreqRXHz)
 	}
 }
+
+// A genuine split contact is uploaded AS split: the rule above is about a
+// receive side that repeats the transmit side, not about dropping one.
+func TestSplitIsUploadedWithItsReceiveSide(t *testing.T) {
+	tx, rx := int64(14195000), int64(18100000)
+	q := qso.QSO{Callsign: "F4BPO", Band: "20m", BandRX: "17m", FreqHz: &tx, FreqRXHz: &rx}
+	up := strings.ToUpper(adif.SingleRecordADIF(q))
+	if !strings.Contains(up, "<BAND_RX:3>17M") || !strings.Contains(up, "<FREQ_RX:9>18.100000") {
+		t.Errorf("a cross-band contact lost its receive side:\n%s", up)
+	}
+}

uploadconfigured_test.go

@@ -0,0 +1,35 @@
+package main
+
+import (
+	"strings"
+	"testing"
+
+	"hamlog/internal/extsvc"
+)
+
+// An upload to a service with no credentials used to look exactly like one that
+// worked: it ran on its own goroutine and reported into the QSL Manager's
+// console, which is not open when the command came from the QSO list.
+func TestUploadRefusesAnUnconfiguredService(t *testing.T) {
+	var empty extsvc.ExternalServices
+	for _, svc := range []extsvc.Service{
+		extsvc.ServiceCloudlog, extsvc.ServiceQRZ, extsvc.ServiceClublog,
+		extsvc.ServiceHRDLog, extsvc.ServiceEQSL, extsvc.ServiceHamQTH, extsvc.ServiceLoTW,
+	} {
+		err := uploadConfigured(svc, empty)
+		if err == nil {
+			t.Errorf("%s: an unconfigured service was accepted", svc)
+			continue
+		}
+		if !strings.Contains(err.Error(), "Settings") {
+			t.Errorf("%s: %q does not say where to fix it", svc, err)
+		}
+	}
+
+	// Configured: nothing in the way.
+	cfg := extsvc.ExternalServices{}
+	cfg.Cloudlog.URL, cfg.Cloudlog.APIKey = "https://log.f4bpo.fr", "cl123"
+	if err := uploadConfigured(extsvc.ServiceCloudlog, cfg); err != nil {
+		t.Errorf("a configured Cloudlog was refused: %v", err)
+	}
+}