chore: release v2.23.0

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

.claude/CLAUDE.md

@@ -0,0 +1,42 @@
+## Workflow Orchestration
+### 1. Plan Node Default
+- Enter plan mode for ANY non-trivial task (3+ steps or architectural decisions)
+- If something goes sideways, STOP and re-plan immediately - don't keep pushing
+- Use plan mode for verification steps, not just building
+- Write detailed specs upfront to reduce ambiguity
+### 2. Subagent Strategy
+- Use subagents liberally to keep main context window clean
+- Offload research, exploration, and parallel analysis to subagents
+- For complex problems, throw more compute at it via subagents
+- One tack per subagent for focused execution
+### 3. Self-Improvement Loop
+- After ANY correction from the user: update 'tasks/lessons.md" with the pattern
+- Write rules for yourself that prevent the same mistake
+- Ruthlessly iterate on these lessons until mistake rate drops
+- Review lessons at session start for relevant project
+### 4. Verification Before Done
+- Never mark a task complete without proving it works
+- Diff behavior between main and your changes when relevant
+- Ask yourself: "Would a staff engineer approve this?"
+- Run tests, check logs, demonstrate correctness
+### 5. Demand Elegance (Balanced)
+- For non-trivial changes: pause and ask "is there a more elegant way?"
+- If a fix feels hacky: "Knowing everything I know now, implement the elegant solution"
+- Skip this for simple, obvious fixes - don't over-engineer
+-Challenge your own work before presenting it
+### 6. Autonomous Bug Fizing
+- When given a bug report: just fix it. Don't ask for hand-holding
+- Point at logs, errors, failing tests - then resolve them
+- Zero context switching required from the user
+- Go fix failing CI tests without being told how
+## Task Management
+1. **Plan First**: Write plan to "tasks/todo.md" with checkable items
+2. **Verify Plan**: Check in before starting implementation
+3. **Track Progress**: Mark items complete as you go
+4. **Explain Changes**: High-level summary at each step
+5. **Document Results**: Add review section to 'tasks/todo.md"
+6. **Capture Lessons**: Update 'tasks/lessons.md' after corrections
+## Core Principles
+- **Simplicity First**: Make every change as simple as possible. Impact minimal code.
+- **No Laziness**: Find root causes. No temporary fixes. Senior developer standards.
+- **Minimat Impact**: Changes should only touch what's necessary. Avoid introducing bugs.

CHANGELOG.md

@@ -2,6 +2,111 @@
 
 All notable changes to iNTERCEPT will be documented in this file.
 
+## [2.23.0] - 2026-02-27
+
+### Added
+- **Radiosonde Weather Balloon Tracking** - 400-406 MHz reception via radiosonde_auto_rx with telemetry, map, and station distance tracking
+- **CW/Morse Code Decoder** - Custom Goertzel tone detection with OOK/AM envelope detection mode for ISM bands
+- **WeFax (Weather Fax) Decoder** - HF weather fax reception with auto-scheduler, broadcast timeline, and image gallery
+- **System Health Monitoring** - Telemetry dashboard with process monitoring and system metrics
+- **HTTPS Support** - TLS via `INTERCEPT_HTTPS` configuration
+- **ADS-B Voice Alerts** - Text-to-speech notifications for military and emergency aircraft detections
+- **HackRF TSCM RF Scan** - HackRF support added to TSCM counter-surveillance RF sweep
+- **Multi-SDR WeFax** - Multiple SDR hardware support for WeFax decoder
+- **Tool Path Overrides** - `INTERCEPT_*_PATH` environment variables for custom tool locations
+- **Homebrew Tool Detection** - Native path detection for Apple Silicon Homebrew installations
+
+### Changed
+- Morse decoder rebuilt with custom Goertzel decoder, replacing multimon-ng dependency
+- GPS mode upgraded to textured 3D globe visualization
+- Destroy lifecycle added to all mode modules to prevent resource leaks
+
+### Fixed
+- ADS-B device release leak and startup performance regression
+- ADS-B probe incorrectly treating "No devices found" as success
+- USB claim race condition after SDR probe
+- SDR device registry collision when multiple SDR types present
+- APRS 15-minute startup delay caused by pipe buffering
+- APRS map centering at [0,0] when GPS unavailable
+- DSC decoder ITU-R M.493 compliance issues
+- Weather satellite 0dB SNR — increased sample rate for Meteor LRPT
+- SSE fanout backlog causing delayed updates across all modes
+- SSE reconnect packet loss during client reconnection
+- Waterfall monitor tuning race conditions
+- Mode FOUC (flash of unstyled content) on initial navigation
+- Various Morse decoder stability and lifecycle fixes
+
+---
+
+## [2.22.3] - 2026-02-23
+
+### Fixed
+- Waterfall control panel rendered as unstyled text for up to 20 seconds on first visit — CSS is now loaded eagerly with the rest of the page assets
+- WebSDR globe failed to render on first page load — initialization now waits for a layout frame before mounting the WebGL renderer, ensuring the container has non-zero dimensions
+- Waterfall monitor audio took minutes to start — `_waitForPlayback` now only reports success on actual audio playback (`playing`/`timeupdate`), not from the WAV header alone (`loadeddata`/`canplay`)
+- Waterfall monitor could not be stopped — `stopMonitor()` now pauses audio and updates the UI immediately instead of waiting for the backend stop request (which blocked for 1+ seconds during SDR process cleanup)
+- Stopping the waterfall no longer shows a stale "WebSocket closed before ready" message — the `onclose` handler now detects intentional closes
+
+---
+
+## [2.22.1] - 2026-02-23
+
+### Fixed
+- PWA install prompt not appearing — manifest now includes required PNG icons (192×192, 512×512)
+- Apple touch icon updated to PNG for iOS Safari compatibility
+- Service worker cache bumped to bust stale cached assets
+
+---
+
+## [2.22.0] - 2026-02-23
+
+### Added
+- **Waterfall Receiver Overhaul** - WebSocket-based I/Q streaming with server-side FFT, click-to-tune, zoom controls, and auto-scaling
+- **Voice Alerts** - Configurable text-to-speech event notifications across modes
+- **Signal Fingerprinting** - RF device identification and pattern analysis mode
+- **SignalID** - Automatic signal classification via SigIDWiki API integration
+- **PWA Support** - Installable web app with service worker caching and manifest
+- **Real-time Signal Scope** - Live signal visualization for pager, sensor, and SSTV modes
+- **ADS-B MSG2 Surface Parsing** - Ground vehicle movement tracking from MSG2 frames
+- **Cheat Sheets** - Quick reference overlays for keyboard shortcuts and mode controls
+- App icon (SVG) for PWA and browser tab
+
+### Changed
+- **WebSDR overhaul** - Improved receiver management, audio streaming, and UI
+- **Mode stop responsiveness** - Faster timeout handling and improved WiFi/Bluetooth scanner shutdown
+- **Mode transitions** - Smoother navigation with performance instrumentation
+- **BT Locate** - Refactored JS engine with improved trail management and signal smoothing
+- **Listening Post** - Refactored with cross-module frequency routing
+- **SSTV decoder** - State machine improvements and partial image streaming
+- Analytics mode removed; per-mode analytics panels integrated into existing dashboards
+
+### Fixed
+- ADS-B SSE multi-client fanout stability and update flush timing
+- WiFi scanner robustness and monitor mode teardown reliability
+- Agent client reliability improvements for remote sensor nodes
+- SSTV VIS detector state reporting in signal monitor diagnostics
+
+### Documentation
+- Complete documentation audit across README, FEATURES, USAGE, help modal, and GitHub Pages
+- Fixed license badge (MIT → Apache 2.0) to match actual LICENSE file
+- Fixed tool name `rtl_amr` → `rtlamr` throughout all docs
+- Fixed incorrect entry point examples (`python app.py` → `sudo -E venv/bin/python intercept.py`)
+- Removed duplicate AIS Vessel Tracking section from FEATURES.md
+- Updated SSTV requirements: pure Python decoder, no external `slowrx` needed
+- Added ACARS and VDL2 mode descriptions to in-app help modal
+- GitHub Pages site: corrected Docker command, license, and tool name references
+
+---
+
+## [2.21.1] - 2026-02-20
+
+### Fixed
+- BT Locate map first-load rendering race that could cause blank/late map initialization
+- BT Locate mode switch timing so Leaflet invalidation runs after panel visibility settles
+- BT Locate trail restore startup latency by batching historical GPS point rendering
+
+---
+
 ## [2.21.0] - 2026-02-20
 
 ### Added

Dockerfile

@@ -57,7 +57,6 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     soapysdr-module-airspy \
     airspy \
     limesuite \
-    hackrf \
     # Utilities
     curl \
     procps \
@@ -94,7 +93,6 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     libpulse-dev \
     libfftw3-dev \
     liblapack-dev \
-    libcodec2-dev \
     libglib2.0-dev \
     libxml2-dev \
     # Build dump1090
@@ -191,6 +189,28 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     fi \
     && cd /tmp \
     && rm -rf /tmp/SatDump \
+    # Build hackrf CLI tools from source — avoids libhackrf0 version conflict
+    # between the 'hackrf' apt package and soapysdr-module-hackrf's newer libhackrf0
+    && cd /tmp \
+    && git clone --depth 1 https://github.com/greatscottgadgets/hackrf.git \
+    && cd hackrf/host \
+    && mkdir build && cd build \
+    && cmake .. \
+    && make \
+    && make install \
+    && ldconfig \
+    && rm -rf /tmp/hackrf \
+    # Install radiosonde_auto_rx (weather balloon decoder)
+    && cd /tmp \
+    && git clone --depth 1 https://github.com/projecthorus/radiosonde_auto_rx.git \
+    && cd radiosonde_auto_rx/auto_rx \
+    && pip install --no-cache-dir -r requirements.txt \
+    && bash build.sh \
+    && mkdir -p /opt/radiosonde_auto_rx/auto_rx \
+    && cp -r . /opt/radiosonde_auto_rx/auto_rx/ \
+    && chmod +x /opt/radiosonde_auto_rx/auto_rx/auto_rx.py \
+    && cd /tmp \
+    && rm -rf /tmp/radiosonde_auto_rx \
     # Build rtlamr (utility meter decoder - requires Go)
     && cd /tmp \
     && curl -fsSL "https://go.dev/dl/go1.22.5.linux-$(dpkg --print-architecture).tar.gz" | tar -C /usr/local -xz \
@@ -199,27 +219,6 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     && go install github.com/bemasher/rtlamr@latest \
     && cp /tmp/gopath/bin/rtlamr /usr/bin/rtlamr \
     && rm -rf /usr/local/go /tmp/gopath \
-    # Build mbelib (required by DSD)
-    && cd /tmp \
-    && git clone https://github.com/lwvmobile/mbelib.git \
-    && cd mbelib \
-    && (git checkout ambe_tones || true) \
-    && mkdir build && cd build \
-    && cmake .. \
-    && make -j$(nproc) \
-    && make install \
-    && ldconfig \
-    && rm -rf /tmp/mbelib \
-    # Build DSD-FME (Digital Speech Decoder for DMR/P25)
-    && cd /tmp \
-    && git clone --depth 1 https://github.com/lwvmobile/dsd-fme.git \
-    && cd dsd-fme \
-    && mkdir build && cd build \
-    && cmake .. \
-    && make -j$(nproc) \
-    && make install \
-    && ldconfig \
-    && rm -rf /tmp/dsd-fme \
     # Cleanup build tools to reduce image size
     # libgtk-3-dev is explicitly removed; runtime GTK libs remain for slowrx
     && apt-get remove -y \
@@ -247,7 +246,6 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     libpulse-dev \
     libfftw3-dev \
     liblapack-dev \
-    libcodec2-dev \
     && apt-get autoremove -y \
     && rm -rf /var/lib/apt/lists/*
 
@@ -259,10 +257,11 @@ RUN pip install --no-cache-dir -r requirements.txt
 COPY . .
 
 # Create data directory for persistence
-RUN mkdir -p /app/data /app/data/weather_sat
+RUN mkdir -p /app/data /app/data/weather_sat /app/data/radiosonde/logs
 
 # Expose web interface port
 EXPOSE 5050
+EXPOSE 5443
 
 # Environment variables with defaults
 ENV INTERCEPT_HOST=0.0.0.0 \

README.md

@@ -2,7 +2,7 @@
 
 <p align="center">
   <img src="https://img.shields.io/badge/python-3.9+-blue.svg" alt="Python 3.9+">
-  <img src="https://img.shields.io/badge/license-MIT-green.svg" alt="MIT License">
+  <img src="https://img.shields.io/badge/license-Apache--2.0-green.svg" alt="Apache 2.0 License">
   <img src="https://img.shields.io/badge/platform-macOS%20%7C%20Linux-lightgrey.svg" alt="Platform">
 </p>
 
@@ -40,7 +40,7 @@ Support the developer of this open-source project
 - **HF SSTV** - Terrestrial SSTV on shortwave frequencies (80m-10m, VHF, UHF)
 - **APRS** - Amateur packet radio position reports and telemetry via direwolf
 - **Satellite Tracking** - Pass prediction with polar plot and ground track map
-- **Utility Meters** - Electric, gas, and water meter reading via rtl_amr
+- **Utility Meters** - Electric, gas, and water meter reading via rtlamr
 - **ADS-B History** - Persistent aircraft history with reporting dashboard (Postgres optional)
 - **WiFi Scanning** - Monitor mode reconnaissance via aircrack-ng
 - **Bluetooth Scanning** - Device discovery and tracker detection (with Ubertooth support)
@@ -55,9 +55,33 @@ Support the developer of this open-source project
 
 ---
 
-## Installation / Debian / Ubuntu / MacOS
+## CW / Morse Decoder Notes
 
-```
+Live backend:
+- Uses `rtl_fm` piped into `multimon-ng` (`MORSE_CW`) for real-time decode.
+
+Recommended baseline settings:
+- **Tone**: `700 Hz`
+- **Bandwidth**: `200 Hz` (use `100 Hz` for crowded bands, `400 Hz` for drifting signals)
+- **Threshold Mode**: `Auto`
+- **WPM Mode**: `Auto`
+
+Auto Tone Track behavior:
+- Continuously measures nearby tone energy around the configured CW pitch.
+- Steers the detector toward the strongest valid CW tone when signal-to-noise is sufficient.
+- Use **Hold Tone Lock** to freeze tracking once the desired signal is centered.
+
+Troubleshooting (no decode / noisy decode):
+- Confirm demod path is **USB/CW-compatible** and frequency is tuned correctly.
+- If multiple SDRs are connected and the selected one has no PCM output, Morse startup now auto-tries other detected SDR devices and reports the active device/serial in status logs.
+- Match **tone** and **bandwidth** to the actual sidetone/pitch.
+- Try **Threshold Auto** first; if needed, switch to manual threshold and recalibrate.
+- Use **Reset/Calibrate** after major frequency or band condition changes.
+- Raise **Minimum Signal Gate** to suppress random noise keying.
+
+---
+
+## Installation / Debian / Ubuntu / MacOS
 
 **1. Clone and run:**
 ```bash
@@ -150,7 +174,7 @@ Set these as environment variables for either local installs or Docker:
 ```bash
 INTERCEPT_ADSB_AUTO_START=true \
 INTERCEPT_SHARED_OBSERVER_LOCATION=false \
-python app.py
+sudo -E venv/bin/python intercept.py
 ```
 
 **Docker example (.env)**
@@ -172,7 +196,7 @@ Then open **/adsb/history** for the reporting dashboard.
 
 After starting, open **http://localhost:5050** in your browser. The username and password is <b>admin</b>:<b>admin</b> 
 
-The credentials can be change in the ADMIN_USERNAME & ADMIN_PASSWORD variables in config.py
+The credentials can be changed in the ADMIN_USERNAME & ADMIN_PASSWORD variables in config.py
 
 ---
 
@@ -245,7 +269,7 @@ Created by **smittix** - [GitHub](https://github.com/smittix)
 [AIS-catcher](https://github.com/jvde-github/AIS-catcher) |
 [acarsdec](https://github.com/TLeconte/acarsdec) |
 [direwolf](https://github.com/wb2osz/direwolf) |
-[rtl_amr](https://github.com/bemasher/rtlamr) |
+[rtlamr](https://github.com/bemasher/rtlamr) |
 [dumpvdl2](https://github.com/szpajder/dumpvdl2) |
 [aircrack-ng](https://www.aircrack-ng.org/) |
 [Leaflet.js](https://leafletjs.com/) |

aircraft_db_meta.json

@@ -1,4 +1,4 @@
 {
-  "version": "2026-02-15_ae16bb62",
+  "version": "2026-02-22_17194a71",
-  "downloaded": "2026-02-20T00:29:06.228007Z"
+  "downloaded": "2026-02-27T10:41:04.872620Z"
 }

app.py

@@ -25,7 +25,7 @@ import subprocess
 
 from typing import Any
 
-from flask import Flask, render_template, jsonify, send_file, Response, request,redirect, url_for, flash, session
+from flask import Flask, render_template, jsonify, send_file, Response, request,redirect, url_for, flash, session, send_from_directory
 from werkzeug.security import check_password_hash
 from config import VERSION, CHANGELOG, SHARED_OBSERVER_LOCATION_ENABLED, DEFAULT_LATITUDE, DEFAULT_LONGITUDE
 from utils.dependencies import check_tool, check_all_dependencies, TOOL_DEPENDENCIES
@@ -100,11 +100,24 @@ def add_security_headers(response):
 def inject_offline_settings():
     """Inject offline settings into all templates."""
     from utils.database import get_setting
+
+    # Privacy-first defaults: keep dashboard assets/fonts local to avoid
+    # third-party tracker/storage defenses in strict browsers.
+    assets_source = str(get_setting('offline.assets_source', 'local') or 'local').lower()
+    fonts_source = str(get_setting('offline.fonts_source', 'local') or 'local').lower()
+    if assets_source not in ('local', 'cdn'):
+        assets_source = 'local'
+    if fonts_source not in ('local', 'cdn'):
+        fonts_source = 'local'
+    # Force local delivery for core dashboard pages.
+    assets_source = 'local'
+    fonts_source = 'local'
+
     return {
         'offline_settings': {
             'enabled': get_setting('offline.enabled', False),
-            'assets_source': get_setting('offline.assets_source', 'cdn'),
+            'assets_source': assets_source,
-            'fonts_source': get_setting('offline.fonts_source', 'cdn'),
+            'fonts_source': fonts_source,
             'tile_provider': get_setting('offline.tile_provider', 'cartodb_dark_cyan'),
             'tile_server_url': get_setting('offline.tile_server_url', '')
         }
@@ -177,12 +190,6 @@ dsc_rtl_process = None
 dsc_queue = queue.Queue(maxsize=QUEUE_MAX_SIZE)
 dsc_lock = threading.Lock()
 
-# DMR / Digital Voice
-dmr_process = None
-dmr_rtl_process = None
-dmr_queue = queue.Queue(maxsize=QUEUE_MAX_SIZE)
-dmr_lock = threading.Lock()
-
 # TSCM (Technical Surveillance Countermeasures)
 tscm_queue = queue.Queue(maxsize=QUEUE_MAX_SIZE)
 tscm_lock = threading.Lock()
@@ -191,6 +198,16 @@ tscm_lock = threading.Lock()
 subghz_queue = queue.Queue(maxsize=QUEUE_MAX_SIZE)
 subghz_lock = threading.Lock()
 
+# Radiosonde weather balloon tracking
+radiosonde_process = None
+radiosonde_queue = queue.Queue(maxsize=QUEUE_MAX_SIZE)
+radiosonde_lock = threading.Lock()
+
+# CW/Morse code decoder
+morse_process = None
+morse_queue = queue.Queue(maxsize=QUEUE_MAX_SIZE)
+morse_lock = threading.Lock()
+
 # Deauth Attack Detection
 deauth_detector = None
 deauth_detector_queue = queue.Queue(maxsize=QUEUE_MAX_SIZE)
@@ -245,12 +262,12 @@ cleanup_manager.register(deauth_alerts)
 # SDR DEVICE REGISTRY
 # ============================================
 # Tracks which mode is using which SDR device to prevent conflicts
-# Key: device_index (int), Value: mode_name (str)
+# Key: "sdr_type:device_index" (str), Value: mode_name (str)
-sdr_device_registry: dict[int, str] = {}
+sdr_device_registry: dict[str, str] = {}
 sdr_device_registry_lock = threading.Lock()
 
 
-def claim_sdr_device(device_index: int, mode_name: str) -> str | None:
+def claim_sdr_device(device_index: int, mode_name: str, sdr_type: str = 'rtlsdr') -> str | None:
     """Claim an SDR device for a mode.
 
     Checks the in-app registry first, then probes the USB device to
@@ -260,16 +277,19 @@ def claim_sdr_device(device_index: int, mode_name: str) -> str | None:
     Args:
         device_index: The SDR device index to claim
         mode_name: Name of the mode claiming the device (e.g., 'sensor', 'rtlamr')
+        sdr_type: SDR type string (e.g., 'rtlsdr', 'hackrf', 'limesdr')
 
     Returns:
         Error message if device is in use, None if successfully claimed
     """
+    key = f"{sdr_type}:{device_index}"
     with sdr_device_registry_lock:
-        if device_index in sdr_device_registry:
+        if key in sdr_device_registry:
-            in_use_by = sdr_device_registry[device_index]
+            in_use_by = sdr_device_registry[key]
-            return f'SDR device {device_index} is in use by {in_use_by}. Stop {in_use_by} first or use a different device.'
+            return f'SDR device {sdr_type}:{device_index} is in use by {in_use_by}. Stop {in_use_by} first or use a different device.'
 
         # Probe the USB device to catch external processes holding the handle
+        if sdr_type == 'rtlsdr':
             try:
                 from utils.sdr.detection import probe_rtlsdr_device
                 usb_error = probe_rtlsdr_device(device_index)
@@ -278,25 +298,27 @@ def claim_sdr_device(device_index: int, mode_name: str) -> str | None:
             except Exception:
                 pass  # If probe fails, let the caller proceed normally
 
-        sdr_device_registry[device_index] = mode_name
+        sdr_device_registry[key] = mode_name
         return None
 
 
-def release_sdr_device(device_index: int) -> None:
+def release_sdr_device(device_index: int, sdr_type: str = 'rtlsdr') -> None:
     """Release an SDR device from the registry.
 
     Args:
         device_index: The SDR device index to release
+        sdr_type: SDR type string (e.g., 'rtlsdr', 'hackrf', 'limesdr')
     """
+    key = f"{sdr_type}:{device_index}"
     with sdr_device_registry_lock:
-        sdr_device_registry.pop(device_index, None)
+        sdr_device_registry.pop(key, None)
 
 
-def get_sdr_device_status() -> dict[int, str]:
+def get_sdr_device_status() -> dict[str, str]:
     """Get current SDR device allocations.
 
     Returns:
-        Dictionary mapping device indices to mode names
+        Dictionary mapping 'sdr_type:device_index' keys to mode names
     """
     with sdr_device_registry_lock:
         return dict(sdr_device_registry)
@@ -389,6 +411,18 @@ def favicon() -> Response:
     return send_file('favicon.svg', mimetype='image/svg+xml')
 
 
+@app.route('/sw.js')
+def service_worker() -> Response:
+    resp = send_from_directory('static', 'sw.js', mimetype='application/javascript')
+    resp.headers['Service-Worker-Allowed'] = '/'
+    return resp
+
+
+@app.route('/manifest.json')
+def pwa_manifest() -> Response:
+    return send_from_directory('static', 'manifest.json', mimetype='application/manifest+json')
+
+
 @app.route('/devices')
 def get_devices() -> Response:
     """Get all detected SDR devices with hardware type info."""
@@ -405,8 +439,9 @@ def get_devices_status() -> Response:
     result = []
     for device in devices:
         d = device.to_dict()
-        d['in_use'] = device.index in registry
+        key = f"{device.sdr_type.value}:{device.index}"
-        d['used_by'] = registry.get(device.index)
+        d['in_use'] = key in registry
+        d['used_by'] = registry.get(key)
         result.append(d)
 
     return jsonify(result)
@@ -661,16 +696,6 @@ def _get_subghz_active() -> bool:
         return False
 
 
-def _get_dmr_active() -> bool:
-    """Check if Digital Voice decoder has an active process."""
-    try:
-        from routes import dmr as dmr_module
-        proc = dmr_module.dmr_dsd_process
-        return bool(dmr_module.dmr_running and proc and proc.poll() is None)
-    except Exception:
-        return False
-
-
 def _get_bluetooth_health() -> tuple[bool, int]:
     """Return Bluetooth active state and best-effort device count."""
     legacy_running = bt_process is not None and (bt_process.poll() is None if bt_process else False)
@@ -746,7 +771,8 @@ def health_check() -> Response:
             'wifi': wifi_active,
             'bluetooth': bt_active,
             'dsc': dsc_process is not None and (dsc_process.poll() is None if dsc_process else False),
-            'dmr': _get_dmr_active(),
+            'radiosonde': radiosonde_process is not None and (radiosonde_process.poll() is None if radiosonde_process else False),
+            'morse': morse_process is not None and (morse_process.poll() is None if morse_process else False),
             'subghz': _get_subghz_active(),
         },
         'data': {
@@ -764,13 +790,13 @@ def health_check() -> Response:
 def kill_all() -> Response:
     """Kill all decoder, WiFi, and Bluetooth processes."""
     global current_process, sensor_process, wifi_process, adsb_process, ais_process, acars_process
-    global vdl2_process
+    global vdl2_process, morse_process, radiosonde_process
     global aprs_process, aprs_rtl_process, dsc_process, dsc_rtl_process, bt_process
-    global dmr_process, dmr_rtl_process
 
-    # Import adsb and ais modules to reset their state
+    # Import modules to reset their state
     from routes import adsb as adsb_module
     from routes import ais as ais_module
+    from routes import radiosonde as radiosonde_module
     from utils.bluetooth import reset_bluetooth_scanner
 
     killed = []
@@ -778,9 +804,10 @@ def kill_all() -> Response:
         'rtl_fm', 'multimon-ng', 'rtl_433',
         'airodump-ng', 'aireplay-ng', 'airmon-ng',
         'dump1090', 'acarsdec', 'dumpvdl2', 'direwolf', 'AIS-catcher',
-        'hcitool', 'bluetoothctl', 'satdump', 'dsd',
+        'hcitool', 'bluetoothctl', 'satdump',
         'rtl_tcp', 'rtl_power', 'rtlamr', 'ffmpeg',
-        'hackrf_transfer', 'hackrf_sweep'
+        'hackrf_transfer', 'hackrf_sweep',
+        'auto_rx'
     ]
 
     for proc in processes_to_kill:
@@ -810,6 +837,11 @@ def kill_all() -> Response:
         ais_process = None
         ais_module.ais_running = False
 
+    # Reset Radiosonde state
+    with radiosonde_lock:
+        radiosonde_process = None
+        radiosonde_module.radiosonde_running = False
+
     # Reset ACARS state
     with acars_lock:
         acars_process = None
@@ -818,6 +850,10 @@ def kill_all() -> Response:
     with vdl2_lock:
         vdl2_process = None
 
+    # Reset Morse state
+    with morse_lock:
+        morse_process = None
+
     # Reset APRS state
     with aprs_lock:
         aprs_process = None
@@ -828,11 +864,6 @@ def kill_all() -> Response:
         dsc_process = None
         dsc_rtl_process = None
 
-    # Reset DMR state
-    with dmr_lock:
-        dmr_process = None
-        dmr_rtl_process = None
-
     # Reset Bluetooth state (legacy)
     with bt_lock:
         if bt_process:
@@ -867,6 +898,36 @@ def kill_all() -> Response:
     return jsonify({'status': 'killed', 'processes': killed})
 
 
+def _ensure_self_signed_cert(cert_dir: str) -> tuple:
+    """Generate a self-signed certificate if one doesn't already exist.
+
+    Returns (cert_path, key_path) tuple.
+    """
+    cert_path = os.path.join(cert_dir, 'intercept.crt')
+    key_path = os.path.join(cert_dir, 'intercept.key')
+
+    if os.path.exists(cert_path) and os.path.exists(key_path):
+        print(f"Using existing SSL certificate: {cert_path}")
+        return cert_path, key_path
+
+    os.makedirs(cert_dir, exist_ok=True)
+    print("Generating self-signed SSL certificate...")
+
+    import subprocess
+    result = subprocess.run([
+        'openssl', 'req', '-x509', '-newkey', 'rsa:2048',
+        '-keyout', key_path, '-out', cert_path,
+        '-days', '365', '-nodes',
+        '-subj', '/CN=intercept/O=INTERCEPT/C=US',
+    ], capture_output=True, text=True)
+
+    if result.returncode != 0:
+        raise RuntimeError(f"Failed to generate SSL certificate: {result.stderr}")
+
+    print(f"SSL certificate generated: {cert_path}")
+    return cert_path, key_path
+
+
 def main() -> None:
     """Main entry point."""
     import argparse
@@ -893,6 +954,12 @@ def main() -> None:
         default=config.DEBUG,
         help='Enable debug mode'
     )
+    parser.add_argument(
+        '--https',
+        action='store_true',
+        default=config.HTTPS,
+        help='Enable HTTPS with self-signed certificate'
+    )
     parser.add_argument(
         '--check-deps',
         action='store_true',
@@ -1018,7 +1085,18 @@ def main() -> None:
     except ImportError as e:
         print(f"WebSocket waterfall disabled: {e}")
 
-    print(f"Open http://localhost:{args.port} in your browser")
+    # Configure SSL if HTTPS is enabled
+    ssl_context = None
+    if args.https:
+        cert_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'data', 'certs')
+        if config.SSL_CERT and config.SSL_KEY:
+            ssl_context = (config.SSL_CERT, config.SSL_KEY)
+            print(f"Using provided SSL certificate: {config.SSL_CERT}")
+        else:
+            ssl_context = _ensure_self_signed_cert(cert_dir)
+
+    protocol = 'https' if ssl_context else 'http'
+    print(f"Open {protocol}://localhost:{args.port} in your browser")
     print()
     print("Press Ctrl+C to stop")
     print()
@@ -1030,4 +1108,5 @@ def main() -> None:
         debug=args.debug,
         threaded=True,
         load_dotenv=False,
+        ssl_context=ssl_context,
     )

config.py

@@ -7,10 +7,63 @@ import os
 import sys
 
 # Application version
-VERSION = "2.21.0"
+VERSION = "2.23.0"
 
 # Changelog - latest release notes (shown on welcome screen)
 CHANGELOG = [
+    {
+        "version": "2.23.0",
+        "date": "February 2026",
+        "highlights": [
+            "Radiosonde weather balloon tracking mode with telemetry, map, and station distance",
+            "CW/Morse code decoder with Goertzel tone detection and OOK envelope mode",
+            "WeFax (Weather Fax) decoder with auto-scheduler and broadcast timeline",
+            "System Health monitoring mode with telemetry dashboard",
+            "HTTPS support, HackRF TSCM RF scan, ADS-B voice alerts",
+            "Multi-SDR support for WeFax, tool path overrides, native Homebrew detection",
+            "GPS mode upgraded to textured 3D globe",
+            "Destroy lifecycle added to all mode modules to prevent resource leaks",
+            "Dozens of bug fixes across ADS-B, APRS, SSE, Morse, waterfall, and more",
+        ]
+    },
+    {
+        "version": "2.22.3",
+        "date": "February 2026",
+        "highlights": [
+            "Waterfall control panel no longer shows as unstyled text on first visit",
+            "WebSDR globe renders correctly on first page load without requiring a refresh",
+            "Waterfall monitor audio no longer takes minutes to start — playback detection now waits for real audio data instead of just the WAV header",
+            "Waterfall monitor stop is now instant — audio pauses and UI updates immediately instead of waiting for backend cleanup",
+            "Stopping the waterfall no longer shows a stale 'WebSocket closed before ready' message",
+        ]
+    },
+    {
+        "version": "2.22.1",
+        "date": "February 2026",
+        "highlights": [
+            "Waterfall receiver overhaul: WebSocket I/Q streaming with server-side FFT, click-to-tune, and zoom controls",
+            "Voice alerts for configurable event notifications across modes",
+            "Signal fingerprinting mode for RF device identification and pattern analysis",
+            "SignalID integration via SigIDWiki API for automatic signal classification",
+            "PWA support: installable web app with service worker and manifest",
+            "Mode stop responsiveness improvements with faster timeout handling",
+            "Navigation performance instrumentation and smoother mode transitions",
+            "Pager, sensor, and SSTV real-time signal scope visualization",
+            "ADS-B MSG2 surface movement parsing for ground vehicle tracking",
+            "WebSDR major overhaul with improved receiver management and audio streaming",
+            "Documentation audit: fixed license, tool names, entry points, and SSTV decoder references",
+            "Help modal updated with ACARS and VDL2 mode descriptions",
+        ]
+    },
+    {
+        "version": "2.21.1",
+        "date": "February 2026",
+        "highlights": [
+            "BT Locate map first-load fix with render stabilization retries during initial mode open",
+            "BT Locate trail restore optimization for faster startup when historical GPS points exist",
+            "BT Locate mode-switch map invalidation timing fix to prevent delayed/blank map render",
+        ]
+    },
     {
         "version": "2.21.0",
         "date": "February 2026",
@@ -90,7 +143,6 @@ CHANGELOG = [
             "Pure Python SSTV decoder replacing broken slowrx dependency",
             "Real-time signal scope for pager, sensor, and SSTV modes",
             "USB-level device probe to prevent cryptic rtl_fm crashes",
-            "DMR dsd-fme protocol fixes, tuning controls, and state sync",
             "SDR device lock-up fix from unreleased device registry on crash",
         ]
     },
@@ -98,8 +150,6 @@ CHANGELOG = [
         "version": "2.14.0",
         "date": "February 2026",
         "highlights": [
-            "DMR/P25/NXDN/D-STAR digital voice decoder with dsd-fme",
-            "DMR visual synthesizer with event-driven spring-physics bars",
             "HF SSTV general mode with predefined shortwave frequencies",
             "WebSDR integration for remote HF/shortwave listening",
             "Listening Post signal scanner and audio pipeline improvements",
@@ -245,6 +295,11 @@ PORT = _get_env_int('PORT', 5050)
 DEBUG = _get_env_bool('DEBUG', False)
 THREADED = _get_env_bool('THREADED', True)
 
+# HTTPS / SSL settings
+HTTPS = _get_env_bool('HTTPS', False)
+SSL_CERT = _get_env('SSL_CERT', '')
+SSL_KEY = _get_env('SSL_KEY', '')
+
 # Default RTL-SDR settings
 DEFAULT_GAIN = _get_env('DEFAULT_GAIN', '40')
 DEFAULT_DEVICE = _get_env('DEFAULT_DEVICE', '0')
@@ -291,12 +346,20 @@ SATELLITE_ORBIT_MINUTES = _get_env_int('SATELLITE_ORBIT_MINUTES', 45)
 
 # Weather satellite settings
 WEATHER_SAT_DEFAULT_GAIN = _get_env_float('WEATHER_SAT_GAIN', 40.0)
-WEATHER_SAT_SAMPLE_RATE = _get_env_int('WEATHER_SAT_SAMPLE_RATE', 1000000)
+WEATHER_SAT_SAMPLE_RATE = _get_env_int('WEATHER_SAT_SAMPLE_RATE', 2400000)
 WEATHER_SAT_MIN_ELEVATION = _get_env_float('WEATHER_SAT_MIN_ELEVATION', 15.0)
 WEATHER_SAT_PREDICTION_HOURS = _get_env_int('WEATHER_SAT_PREDICTION_HOURS', 24)
 WEATHER_SAT_SCHEDULE_REFRESH_MINUTES = _get_env_int('WEATHER_SAT_SCHEDULE_REFRESH_MINUTES', 30)
 WEATHER_SAT_CAPTURE_BUFFER_SECONDS = _get_env_int('WEATHER_SAT_CAPTURE_BUFFER_SECONDS', 30)
 
+# WeFax (Weather Fax) settings
+WEFAX_DEFAULT_GAIN = _get_env_float('WEFAX_GAIN', 40.0)
+WEFAX_SAMPLE_RATE = _get_env_int('WEFAX_SAMPLE_RATE', 22050)
+WEFAX_DEFAULT_IOC = _get_env_int('WEFAX_IOC', 576)
+WEFAX_DEFAULT_LPM = _get_env_int('WEFAX_LPM', 120)
+WEFAX_SCHEDULE_REFRESH_MINUTES = _get_env_int('WEFAX_SCHEDULE_REFRESH_MINUTES', 30)
+WEFAX_CAPTURE_BUFFER_SECONDS = _get_env_int('WEFAX_CAPTURE_BUFFER_SECONDS', 30)
+
 # SubGHz transceiver settings (HackRF)
 SUBGHZ_DEFAULT_FREQUENCY = _get_env_float('SUBGHZ_FREQUENCY', 433.92)
 SUBGHZ_DEFAULT_SAMPLE_RATE = _get_env_int('SUBGHZ_SAMPLE_RATE', 2000000)
@@ -307,6 +370,12 @@ SUBGHZ_MAX_TX_DURATION = _get_env_int('SUBGHZ_MAX_TX_DURATION', 10)
 SUBGHZ_SWEEP_START_MHZ = _get_env_float('SUBGHZ_SWEEP_START', 300.0)
 SUBGHZ_SWEEP_END_MHZ = _get_env_float('SUBGHZ_SWEEP_END', 928.0)
 
+# Radiosonde settings
+RADIOSONDE_FREQ_MIN = _get_env_float('RADIOSONDE_FREQ_MIN', 400.0)
+RADIOSONDE_FREQ_MAX = _get_env_float('RADIOSONDE_FREQ_MAX', 406.0)
+RADIOSONDE_DEFAULT_GAIN = _get_env_float('RADIOSONDE_GAIN', 40.0)
+RADIOSONDE_UDP_PORT = _get_env_int('RADIOSONDE_UDP_PORT', 55673)
+
 # Update checking
 GITHUB_REPO = _get_env('GITHUB_REPO', 'smittix/intercept')
 UPDATE_CHECK_ENABLED = _get_env_bool('UPDATE_CHECK_ENABLED', True)

data/wefax_stations.json

@@ -0,0 +1,733 @@
+{
+  "stations": [
+    {
+      "name": "USCG Kodiak",
+      "callsign": "NOJ",
+      "country": "US",
+      "city": "Kodiak, AK",
+      "coordinates": [57.78, -152.50],
+      "frequencies": [
+        {"khz": 2054, "description": "Night"},
+        {"khz": 4298, "description": "Primary"},
+        {"khz": 8459, "description": "Day"},
+        {"khz": 12412.5, "description": "Extended"}
+      ],
+      "ioc": 576,
+      "lpm": 120,
+      "schedule": [
+        {"utc": "03:40", "duration_min": 148, "content": "Chart Series 1"},
+        {"utc": "09:50", "duration_min": 138, "content": "Chart Series 2"},
+        {"utc": "15:40", "duration_min": 148, "content": "Chart Series 3"},
+        {"utc": "21:50", "duration_min": 98, "content": "Chart Series 4"}
+      ]
+    },
+    {
+      "name": "USCG Boston",
+      "callsign": "NMF",
+      "country": "US",
+      "city": "Boston, MA",
+      "coordinates": [42.36, -71.04],
+      "frequencies": [
+        {"khz": 4235, "description": "Night"},
+        {"khz": 6340.5, "description": "Primary"},
+        {"khz": 9110, "description": "Day"},
+        {"khz": 12750, "description": "Extended"}
+      ],
+      "ioc": 576,
+      "lpm": 120,
+      "schedule": [
+        {"utc": "00:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "02:30", "duration_min": 20, "content": "Wind/Wave Analysis"},
+        {"utc": "04:38", "duration_min": 20, "content": "Sea State Analysis"},
+        {"utc": "06:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "09:30", "duration_min": 20, "content": "48-Hour Surface Prog"},
+        {"utc": "12:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "14:00", "duration_min": 20, "content": "24-Hour Surface Prog"},
+        {"utc": "16:00", "duration_min": 20, "content": "Sea State Analysis"},
+        {"utc": "18:10", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "22:00", "duration_min": 20, "content": "Satellite Image"}
+      ]
+    },
+    {
+      "name": "USCG New Orleans",
+      "callsign": "NMG",
+      "country": "US",
+      "city": "New Orleans, LA",
+      "coordinates": [29.95, -90.07],
+      "frequencies": [
+        {"khz": 4317.9, "description": "Night"},
+        {"khz": 8503.9, "description": "Primary"},
+        {"khz": 12789.9, "description": "Day"},
+        {"khz": 17146.4, "description": "Extended"}
+      ],
+      "ioc": 576,
+      "lpm": 120,
+      "schedule": [
+        {"utc": "00:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "03:00", "duration_min": 20, "content": "24-Hour Surface Prog"},
+        {"utc": "06:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "09:00", "duration_min": 20, "content": "Sea State Analysis"},
+        {"utc": "12:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "15:00", "duration_min": 20, "content": "48-Hour Surface Prog"},
+        {"utc": "18:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "21:00", "duration_min": 20, "content": "Tropical Analysis"}
+      ]
+    },
+    {
+      "name": "USCG Pt. Reyes",
+      "callsign": "NMC",
+      "country": "US",
+      "city": "Pt. Reyes, CA",
+      "coordinates": [38.07, -122.97],
+      "frequencies": [
+        {"khz": 4346, "description": "Night"},
+        {"khz": 8682, "description": "Primary"},
+        {"khz": 12786, "description": "Day"},
+        {"khz": 17151.2, "description": "Extended"},
+        {"khz": 22527, "description": "DX"}
+      ],
+      "ioc": 576,
+      "lpm": 120,
+      "schedule": [
+        {"utc": "00:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "01:40", "duration_min": 20, "content": "Wind/Wave Analysis"},
+        {"utc": "06:55", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "11:20", "duration_min": 20, "content": "48-Hour Surface Prog"},
+        {"utc": "14:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "18:40", "duration_min": 20, "content": "Sea State Analysis"},
+        {"utc": "23:20", "duration_min": 20, "content": "Satellite Image"}
+      ]
+    },
+    {
+      "name": "USCG Honolulu",
+      "callsign": "KVM70",
+      "country": "US",
+      "city": "Honolulu, HI",
+      "coordinates": [21.31, -157.86],
+      "frequencies": [
+        {"khz": 9982.5, "description": "Primary"},
+        {"khz": 11090, "description": "Day"},
+        {"khz": 16135, "description": "Extended"}
+      ],
+      "ioc": 576,
+      "lpm": 120,
+      "schedule": [
+        {"utc": "00:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "05:19", "duration_min": 20, "content": "Surface Prog"},
+        {"utc": "12:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "17:19", "duration_min": 20, "content": "Sea State Analysis"}
+      ]
+    },
+    {
+      "name": "RN Northwood",
+      "callsign": "GYA",
+      "country": "GB",
+      "city": "Northwood, London",
+      "coordinates": [51.63, -0.42],
+      "frequencies": [
+        {"khz": 2618.5, "description": "Night"},
+        {"khz": 3280.5, "description": "Night Alt"},
+        {"khz": 4610, "description": "Primary"},
+        {"khz": 6834, "description": "Day Alt"},
+        {"khz": 8040, "description": "Day"},
+        {"khz": 11086.5, "description": "Extended"},
+        {"khz": 12390, "description": "Persian Gulf"},
+        {"khz": 18261, "description": "DX"}
+      ],
+      "ioc": 576,
+      "lpm": 120,
+      "schedule": [
+        {"utc": "00:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "03:30", "duration_min": 20, "content": "24-Hour Surface Prog"},
+        {"utc": "06:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "08:00", "duration_min": 20, "content": "Sea State Forecast"},
+        {"utc": "09:30", "duration_min": 20, "content": "Extended Forecast"},
+        {"utc": "12:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "15:30", "duration_min": 20, "content": "48-Hour Surface Prog"},
+        {"utc": "18:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "19:00", "duration_min": 20, "content": "Wave Period Forecast"},
+        {"utc": "21:30", "duration_min": 20, "content": "Extended Forecast"}
+      ]
+    },
+    {
+      "name": "DWD Hamburg/Pinneberg",
+      "callsign": "DDH",
+      "country": "DE",
+      "city": "Pinneberg",
+      "coordinates": [53.66, 9.80],
+      "frequencies": [
+        {"khz": 3855, "description": "Night (DDH3, 10kW)"},
+        {"khz": 7880, "description": "Primary (DDK3, 20kW)"},
+        {"khz": 13882.5, "description": "Day (DDK6, 20kW)"}
+      ],
+      "ioc": 576,
+      "lpm": 120,
+      "schedule": [
+        {"utc": "04:30", "duration_min": 20, "content": "Surface Analysis N. Atlantic"},
+        {"utc": "07:15", "duration_min": 20, "content": "Surface Prog"},
+        {"utc": "09:30", "duration_min": 20, "content": "Surface Analysis Europe"},
+        {"utc": "10:07", "duration_min": 20, "content": "Sea State North Sea"},
+        {"utc": "13:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "15:20", "duration_min": 20, "content": "Extended Prog"},
+        {"utc": "15:40", "duration_min": 20, "content": "Sea Ice Chart"},
+        {"utc": "16:30", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "21:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "21:15", "duration_min": 20, "content": "Surface Prog"}
+      ]
+    },
+    {
+      "name": "JMA Tokyo",
+      "callsign": "JMH",
+      "country": "JP",
+      "city": "Tokyo",
+      "coordinates": [35.69, 139.69],
+      "frequencies": [
+        {"khz": 3622.5, "description": "Night"},
+        {"khz": 7795, "description": "Primary"},
+        {"khz": 13988.5, "description": "Day"}
+      ],
+      "ioc": 576,
+      "lpm": 120,
+      "schedule": [
+        {"utc": "00:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "01:30", "duration_min": 20, "content": "24-Hour Prog"},
+        {"utc": "03:00", "duration_min": 20, "content": "Satellite Image"},
+        {"utc": "06:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "07:30", "duration_min": 20, "content": "Wave Analysis"},
+        {"utc": "09:00", "duration_min": 20, "content": "Satellite Image"},
+        {"utc": "10:19", "duration_min": 20, "content": "Tropical Cyclone Info"},
+        {"utc": "12:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "15:00", "duration_min": 20, "content": "Satellite Image"},
+        {"utc": "18:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "21:00", "duration_min": 20, "content": "48-Hour Prog"}
+      ]
+    },
+    {
+      "name": "Kyodo News Tokyo",
+      "callsign": "JJC",
+      "country": "JP",
+      "city": "Tokyo",
+      "coordinates": [35.69, 139.69],
+      "frequencies": [
+        {"khz": 4316, "description": "Night"},
+        {"khz": 8467.5, "description": "Primary"},
+        {"khz": 12745.5, "description": "Day"},
+        {"khz": 16971, "description": "Extended"},
+        {"khz": 17069.6, "description": "DX"},
+        {"khz": 22542, "description": "DX 2"}
+      ],
+      "ioc": 576,
+      "lpm": 120,
+      "schedule": [
+        {"utc": "00:00", "duration_min": 20, "content": "Press Photo/News Fax"},
+        {"utc": "04:00", "duration_min": 20, "content": "Press Photo/News Fax"},
+        {"utc": "08:00", "duration_min": 20, "content": "Press Photo/News Fax"},
+        {"utc": "12:00", "duration_min": 20, "content": "Press Photo/News Fax"},
+        {"utc": "16:00", "duration_min": 20, "content": "Press Photo/News Fax"},
+        {"utc": "20:00", "duration_min": 20, "content": "Press Photo/News Fax"}
+      ]
+    },
+    {
+      "name": "Kagoshima Fisheries",
+      "callsign": "JFX",
+      "country": "JP",
+      "city": "Kagoshima",
+      "coordinates": [31.60, 130.56],
+      "frequencies": [
+        {"khz": 4274, "description": "Night"},
+        {"khz": 8658, "description": "Primary"},
+        {"khz": 13074, "description": "Day"},
+        {"khz": 16907.5, "description": "Extended"},
+        {"khz": 22559.6, "description": "DX"}
+      ],
+      "ioc": 576,
+      "lpm": 120,
+      "schedule": [
+        {"utc": "00:00", "duration_min": 20, "content": "Sea Surface Temp"},
+        {"utc": "04:00", "duration_min": 20, "content": "Fishing Forecast"},
+        {"utc": "08:00", "duration_min": 20, "content": "Sea Surface Temp"},
+        {"utc": "12:00", "duration_min": 20, "content": "Current Chart"},
+        {"utc": "16:00", "duration_min": 20, "content": "Fishing Forecast"},
+        {"utc": "20:00", "duration_min": 20, "content": "Sea Surface Temp"}
+      ]
+    },
+    {
+      "name": "KMA Seoul",
+      "callsign": "HLL2",
+      "country": "KR",
+      "city": "Seoul",
+      "coordinates": [37.57, 126.98],
+      "frequencies": [
+        {"khz": 3585, "description": "Night"},
+        {"khz": 5857.5, "description": "Primary"},
+        {"khz": 7433.5, "description": "Day"},
+        {"khz": 9165, "description": "Extended"},
+        {"khz": 13570, "description": "DX"}
+      ],
+      "ioc": 576,
+      "lpm": 120,
+      "schedule": [
+        {"utc": "00:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "03:00", "duration_min": 20, "content": "24-Hour Prog"},
+        {"utc": "06:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "09:00", "duration_min": 20, "content": "Satellite Image"},
+        {"utc": "12:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "15:00", "duration_min": 20, "content": "Sea State Analysis"},
+        {"utc": "18:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "21:00", "duration_min": 20, "content": "48-Hour Prog"}
+      ]
+    },
+    {
+      "name": "Taipei Met",
+      "callsign": "BMF",
+      "country": "TW",
+      "city": "Taipei",
+      "coordinates": [25.03, 121.57],
+      "frequencies": [
+        {"khz": 4616, "description": "Primary"},
+        {"khz": 8140, "description": "Day"},
+        {"khz": 13900, "description": "Extended"}
+      ],
+      "ioc": 576,
+      "lpm": 120,
+      "schedule": [
+        {"utc": "00:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "06:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "12:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "18:00", "duration_min": 20, "content": "Surface Analysis"}
+      ]
+    },
+    {
+      "name": "Bangkok Met",
+      "callsign": "HSW64",
+      "country": "TH",
+      "city": "Bangkok",
+      "coordinates": [13.76, 100.50],
+      "frequencies": [
+        {"khz": 7396.8, "description": "Primary"}
+      ],
+      "ioc": 576,
+      "lpm": 120,
+      "schedule": [
+        {"utc": "00:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "06:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "12:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "18:00", "duration_min": 20, "content": "Surface Analysis"}
+      ]
+    },
+    {
+      "name": "Shanghai Met",
+      "callsign": "XSG",
+      "country": "CN",
+      "city": "Shanghai",
+      "coordinates": [31.23, 121.47],
+      "frequencies": [
+        {"khz": 4170, "description": "Night"},
+        {"khz": 8302, "description": "Primary"},
+        {"khz": 12382, "description": "Day"},
+        {"khz": 16559, "description": "Extended"}
+      ],
+      "ioc": 576,
+      "lpm": 120,
+      "schedule": [
+        {"utc": "00:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "06:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "12:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "18:00", "duration_min": 20, "content": "Surface Analysis"}
+      ]
+    },
+    {
+      "name": "Guangzhou Radio",
+      "callsign": "XSQ",
+      "country": "CN",
+      "city": "Guangzhou",
+      "coordinates": [23.13, 113.26],
+      "frequencies": [
+        {"khz": 4199.8, "description": "Night"},
+        {"khz": 8412.5, "description": "Primary"},
+        {"khz": 12629.3, "description": "Day"},
+        {"khz": 16826.3, "description": "Extended"}
+      ],
+      "ioc": 576,
+      "lpm": 120,
+      "schedule": [
+        {"utc": "00:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "06:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "12:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "18:00", "duration_min": 20, "content": "Surface Analysis"}
+      ]
+    },
+    {
+      "name": "Singapore Met",
+      "callsign": "9VF",
+      "country": "SG",
+      "city": "Singapore",
+      "coordinates": [1.35, 103.82],
+      "frequencies": [
+        {"khz": 16035, "description": "Primary"},
+        {"khz": 17430, "description": "Alternate"}
+      ],
+      "ioc": 576,
+      "lpm": 120,
+      "schedule": [
+        {"utc": "00:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "06:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "12:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "18:00", "duration_min": 20, "content": "Surface Analysis"}
+      ]
+    },
+    {
+      "name": "New Delhi Met",
+      "callsign": "ATP",
+      "country": "IN",
+      "city": "New Delhi",
+      "coordinates": [28.61, 77.21],
+      "frequencies": [
+        {"khz": 7405, "description": "Night"},
+        {"khz": 14842, "description": "Day"}
+      ],
+      "ioc": 576,
+      "lpm": 120,
+      "schedule": [
+        {"utc": "00:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "06:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "12:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "18:00", "duration_min": 20, "content": "Surface Analysis"}
+      ]
+    },
+    {
+      "name": "Murmansk Met",
+      "callsign": "RBW",
+      "country": "RU",
+      "city": "Murmansk",
+      "coordinates": [68.97, 33.09],
+      "frequencies": [
+        {"khz": 6445.5, "description": "Night"},
+        {"khz": 7907, "description": "Primary"},
+        {"khz": 8444, "description": "Day"}
+      ],
+      "ioc": 576,
+      "lpm": 120,
+      "schedule": [
+        {"utc": "07:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "08:00", "duration_min": 20, "content": "Ice Chart"},
+        {"utc": "14:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "14:30", "duration_min": 20, "content": "Surface Prog"},
+        {"utc": "20:00", "duration_min": 20, "content": "Surface Analysis"}
+      ]
+    },
+    {
+      "name": "St. Petersburg Met",
+      "callsign": "RDD78",
+      "country": "RU",
+      "city": "St. Petersburg",
+      "coordinates": [59.93, 30.32],
+      "frequencies": [
+        {"khz": 2640, "description": "Night"},
+        {"khz": 4212, "description": "Primary"}
+      ],
+      "ioc": 576,
+      "lpm": 120,
+      "schedule": [
+        {"utc": "06:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "12:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "18:00", "duration_min": 20, "content": "Surface Analysis"}
+      ]
+    },
+    {
+      "name": "Athens Met",
+      "callsign": "SVJ4",
+      "country": "GR",
+      "city": "Athens",
+      "coordinates": [37.97, 23.73],
+      "frequencies": [
+        {"khz": 4482.9, "description": "Night"},
+        {"khz": 8106.9, "description": "Primary"}
+      ],
+      "ioc": 576,
+      "lpm": 120,
+      "schedule": [
+        {"utc": "06:00", "duration_min": 20, "content": "Surface Analysis Med"},
+        {"utc": "09:00", "duration_min": 20, "content": "Surface Prog"},
+        {"utc": "12:00", "duration_min": 20, "content": "Surface Analysis Med"},
+        {"utc": "18:00", "duration_min": 20, "content": "Surface Analysis Med"}
+      ]
+    },
+    {
+      "name": "Charleville Met",
+      "callsign": "VMC",
+      "country": "AU",
+      "city": "Charleville, QLD",
+      "coordinates": [-26.41, 146.24],
+      "frequencies": [
+        {"khz": 2628, "description": "Night"},
+        {"khz": 5100, "description": "Primary"},
+        {"khz": 11030, "description": "Day"},
+        {"khz": 13920, "description": "Extended"},
+        {"khz": 20469, "description": "DX"}
+      ],
+      "ioc": 576,
+      "lpm": 120,
+      "schedule": [
+        {"utc": "00:00", "duration_min": 20, "content": "MSLP Analysis"},
+        {"utc": "03:00", "duration_min": 20, "content": "Prognosis"},
+        {"utc": "06:00", "duration_min": 20, "content": "MSLP Analysis"},
+        {"utc": "09:00", "duration_min": 20, "content": "Sea/Swell Chart"},
+        {"utc": "12:00", "duration_min": 20, "content": "MSLP Analysis"},
+        {"utc": "18:00", "duration_min": 20, "content": "MSLP Analysis"},
+        {"utc": "19:00", "duration_min": 20, "content": "Prognosis"}
+      ]
+    },
+    {
+      "name": "Wiluna Met",
+      "callsign": "VMW",
+      "country": "AU",
+      "city": "Wiluna, WA",
+      "coordinates": [-26.59, 120.23],
+      "frequencies": [
+        {"khz": 5755, "description": "Night"},
+        {"khz": 7535, "description": "Primary"},
+        {"khz": 10555, "description": "Day"},
+        {"khz": 15615, "description": "Extended"},
+        {"khz": 18060, "description": "DX"}
+      ],
+      "ioc": 576,
+      "lpm": 120,
+      "schedule": [
+        {"utc": "00:00", "duration_min": 20, "content": "MSLP Analysis"},
+        {"utc": "06:00", "duration_min": 20, "content": "MSLP Analysis"},
+        {"utc": "11:00", "duration_min": 20, "content": "Prognosis"},
+        {"utc": "18:00", "duration_min": 20, "content": "MSLP Analysis"},
+        {"utc": "21:00", "duration_min": 20, "content": "Sea/Swell Chart"}
+      ]
+    },
+    {
+      "name": "NZ MetService",
+      "callsign": "ZKLF",
+      "country": "NZ",
+      "city": "Auckland",
+      "coordinates": [-36.85, 174.76],
+      "frequencies": [
+        {"khz": 3247.4, "description": "Night"},
+        {"khz": 5807, "description": "Primary"},
+        {"khz": 9459, "description": "Day"},
+        {"khz": 13550.5, "description": "Extended"},
+        {"khz": 16340.1, "description": "DX"}
+      ],
+      "ioc": 576,
+      "lpm": 120,
+      "schedule": [
+        {"utc": "00:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "06:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "12:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "18:00", "duration_min": 20, "content": "Surface Analysis"}
+      ]
+    },
+    {
+      "name": "CFH Halifax",
+      "callsign": "CFH",
+      "country": "CA",
+      "city": "Halifax, NS",
+      "coordinates": [44.65, -63.57],
+      "frequencies": [
+        {"khz": 4271, "description": "Night"},
+        {"khz": 6496.4, "description": "Primary"},
+        {"khz": 10536, "description": "Day"},
+        {"khz": 13510, "description": "Extended"}
+      ],
+      "ioc": 576,
+      "lpm": 120,
+      "schedule": [
+        {"utc": "00:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "03:00", "duration_min": 20, "content": "Surface Prog"},
+        {"utc": "06:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "12:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "18:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "22:22", "duration_min": 20, "content": "Ice Chart"},
+        {"utc": "23:01", "duration_min": 20, "content": "Surface Analysis"}
+      ]
+    },
+    {
+      "name": "CCG Iqaluit",
+      "callsign": "VFF",
+      "country": "CA",
+      "city": "Iqaluit, NU",
+      "coordinates": [63.75, -68.52],
+      "frequencies": [
+        {"khz": 3253, "description": "Night"},
+        {"khz": 7710, "description": "Day"}
+      ],
+      "ioc": 576,
+      "lpm": 120,
+      "schedule": [
+        {"utc": "00:10", "duration_min": 20, "content": "Ice Chart"},
+        {"utc": "05:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "07:00", "duration_min": 20, "content": "Ice Chart"},
+        {"utc": "10:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "11:00", "duration_min": 20, "content": "Ice Chart"},
+        {"utc": "21:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "23:30", "duration_min": 20, "content": "Ice Chart"}
+      ]
+    },
+    {
+      "name": "CCG Inuvik",
+      "callsign": "VFA",
+      "country": "CA",
+      "city": "Inuvik, NT",
+      "coordinates": [68.36, -133.72],
+      "frequencies": [
+        {"khz": 4292, "description": "Night"},
+        {"khz": 8457.8, "description": "Primary"}
+      ],
+      "ioc": 576,
+      "lpm": 120,
+      "schedule": [
+        {"utc": "02:00", "duration_min": 20, "content": "Ice Chart"},
+        {"utc": "16:30", "duration_min": 20, "content": "Ice Chart"}
+      ]
+    },
+    {
+      "name": "CCG Sydney",
+      "callsign": "VCO",
+      "country": "CA",
+      "city": "Sydney, NS",
+      "coordinates": [46.14, -60.19],
+      "frequencies": [
+        {"khz": 4416, "description": "Night"},
+        {"khz": 6915.1, "description": "Primary"}
+      ],
+      "ioc": 576,
+      "lpm": 120,
+      "schedule": [
+        {"utc": "11:21", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "11:42", "duration_min": 20, "content": "Surface Prog"},
+        {"utc": "17:41", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "22:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "23:31", "duration_min": 20, "content": "Surface Prog"}
+      ]
+    },
+    {
+      "name": "Cape Naval",
+      "callsign": "ZSJ",
+      "country": "ZA",
+      "city": "Cape Town",
+      "coordinates": [-33.92, 18.42],
+      "frequencies": [
+        {"khz": 4014, "description": "Night"},
+        {"khz": 7508, "description": "Primary"},
+        {"khz": 13538, "description": "Day"},
+        {"khz": 18238, "description": "Extended"}
+      ],
+      "ioc": 576,
+      "lpm": 120,
+      "schedule": [
+        {"utc": "04:30", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "05:00", "duration_min": 20, "content": "Sea State"},
+        {"utc": "06:30", "duration_min": 20, "content": "Surface Prog"},
+        {"utc": "07:30", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "08:00", "duration_min": 20, "content": "Satellite Image"},
+        {"utc": "10:30", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "11:00", "duration_min": 20, "content": "Sea State"},
+        {"utc": "15:30", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "15:40", "duration_min": 20, "content": "Surface Prog"},
+        {"utc": "22:30", "duration_min": 20, "content": "Surface Analysis"}
+      ]
+    },
+    {
+      "name": "Valparaiso Naval",
+      "callsign": "CBV",
+      "country": "CL",
+      "city": "Valparaiso",
+      "coordinates": [-33.05, -71.62],
+      "frequencies": [
+        {"khz": 4228, "description": "Night"},
+        {"khz": 8677, "description": "Primary"},
+        {"khz": 17146.4, "description": "Day"}
+      ],
+      "ioc": 576,
+      "lpm": 120,
+      "schedule": [
+        {"utc": "11:15", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "11:30", "duration_min": 20, "content": "Surface Prog"},
+        {"utc": "16:30", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "16:45", "duration_min": 20, "content": "Sea State"},
+        {"utc": "19:15", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "19:30", "duration_min": 20, "content": "Surface Prog"},
+        {"utc": "22:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "23:10", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "23:25", "duration_min": 20, "content": "Sea State"}
+      ]
+    },
+    {
+      "name": "Magallanes Naval",
+      "callsign": "CBM",
+      "country": "CL",
+      "city": "Punta Arenas",
+      "coordinates": [-53.16, -70.91],
+      "frequencies": [
+        {"khz": 4322, "description": "Night"},
+        {"khz": 8696, "description": "Primary"}
+      ],
+      "ioc": 576,
+      "lpm": 120,
+      "schedule": [
+        {"utc": "01:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "13:00", "duration_min": 20, "content": "Surface Analysis"}
+      ]
+    },
+    {
+      "name": "Rio de Janeiro Naval",
+      "callsign": "PWZ33",
+      "country": "BR",
+      "city": "Rio de Janeiro",
+      "coordinates": [-22.91, -43.17],
+      "frequencies": [
+        {"khz": 12665, "description": "Primary"},
+        {"khz": 16978, "description": "Day"}
+      ],
+      "ioc": 576,
+      "lpm": 120,
+      "schedule": [
+        {"utc": "07:45", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "16:30", "duration_min": 20, "content": "Surface Analysis"}
+      ]
+    },
+    {
+      "name": "Dakar Met",
+      "callsign": "6VU",
+      "country": "SN",
+      "city": "Dakar",
+      "coordinates": [14.69, -17.44],
+      "frequencies": [
+        {"khz": 13667.5, "description": "Primary"},
+        {"khz": 19750, "description": "Day"}
+      ],
+      "ioc": 576,
+      "lpm": 120,
+      "schedule": [
+        {"utc": "00:00", "duration_min": 20, "content": "Surface Analysis"},
+        {"utc": "12:00", "duration_min": 20, "content": "Surface Analysis"}
+      ]
+    },
+    {
+      "name": "Misaki Fisheries",
+      "callsign": "JFC",
+      "country": "JP",
+      "city": "Miura",
+      "coordinates": [35.14, 139.62],
+      "frequencies": [
+        {"khz": 8616, "description": "Primary"},
+        {"khz": 13074, "description": "Day"},
+        {"khz": 17231, "description": "Extended"}
+      ],
+      "ioc": 576,
+      "lpm": 120,
+      "schedule": [
+        {"utc": "00:00", "duration_min": 20, "content": "Sea Surface Temp"},
+        {"utc": "06:00", "duration_min": 20, "content": "Current Chart"},
+        {"utc": "12:00", "duration_min": 20, "content": "Fishing Forecast"},
+        {"utc": "18:00", "duration_min": 20, "content": "Sea Surface Temp"}
+      ]
+    }
+  ]
+}

docker-compose.yml

@@ -18,6 +18,8 @@ services:
     container_name: intercept
     ports:
       - "5050:5050"
+      # Uncomment for HTTPS support (set INTERCEPT_HTTPS=true below)
+      # - "5443:5443"
     # Privileged mode required for USB SDR device access
     privileged: true
     # USB device mapping for all USB devices
@@ -32,6 +34,9 @@ services:
       - INTERCEPT_HOST=0.0.0.0
       - INTERCEPT_PORT=5050
       - INTERCEPT_LOG_LEVEL=INFO
+      # HTTPS support (auto-generates self-signed cert)
+      # - INTERCEPT_HTTPS=true
+      # - INTERCEPT_PORT=5443
       # ADS-B history is disabled by default
       # To enable, use: docker compose --profile history up -d
       # - INTERCEPT_ADSB_HISTORY_ENABLED=true
@@ -70,6 +75,8 @@ services:
       - adsb_db
     ports:
       - "5050:5050"
+      # Uncomment for HTTPS support (set INTERCEPT_HTTPS=true below)
+      # - "5443:5443"
     # Privileged mode required for USB SDR device access
     privileged: true
     # USB device mapping for all USB devices
@@ -81,6 +88,9 @@ services:
       - INTERCEPT_HOST=0.0.0.0
       - INTERCEPT_PORT=5050
       - INTERCEPT_LOG_LEVEL=INFO
+      # HTTPS support (auto-generates self-signed cert)
+      # - INTERCEPT_HTTPS=true
+      # - INTERCEPT_PORT=5443
       - INTERCEPT_ADSB_HISTORY_ENABLED=true
       - INTERCEPT_ADSB_DB_HOST=adsb_db
       - INTERCEPT_ADSB_DB_PORT=5432

docs/FEATURES.md

@@ -24,17 +24,6 @@ Complete feature list for all modules.
 - **Wideband spectrum analysis** with real-time visualization
 - **I/Q capture** - record raw samples for offline analysis
 
-## AIS Vessel Tracking
-
-- **Real-time vessel tracking** via AIS-catcher on 161.975/162.025 MHz
-- **Full-screen dashboard** - dedicated popout with interactive map
-- **Interactive Leaflet map** with OpenStreetMap tiles (dark-themed)
-- **Vessel details popup** - name, MMSI, callsign, destination, ETA
-- **Navigation data** - speed, course, heading, rate of turn
-- **Ship type classification** - cargo, tanker, passenger, fishing, etc.
-- **Vessel dimensions** - length, width, draught
-- **Multi-SDR support** - RTL-SDR, HackRF, LimeSDR, Airspy, SDRplay
-
 ## Spy Stations (Number Stations)
 
 - **Comprehensive database** of active number stations and diplomatic networks
@@ -111,11 +100,30 @@ Digital Selective Calling (DSC) monitoring on the international maritime distres
 - **CSV/JSON export** - export captured messages for offline analysis
 - **Integrated with ADS-B dashboard** - VDL2 messages linked to aircraft tracking
 
+## CW/Morse Code Decoder
+
+- **Custom Goertzel tone detection** for CW (continuous wave) Morse decoding
+- **OOK/AM envelope detection** mode for on-off keying signals in ISM bands
+- **HF frequency presets** for amateur CW bands (160m-10m)
+- **ISM band presets** for OOK envelope mode (315 MHz, 433 MHz, 868 MHz, 915 MHz)
+- **Real-time character and word output** with WPM estimation
+- **Multi-SDR support** - RTL-SDR, HackRF, LimeSDR, Airspy, SDRplay
+
+## WeFax (Weather Fax)
+
+- **HF weather fax reception** from marine and meteorological broadcast stations
+- **Broadcast timeline** with scheduled transmission times by station
+- **Auto-scheduler** for unattended capture of scheduled broadcasts
+- **Image gallery** with timestamped decoded weather charts
+- **Station presets** for major WeFax broadcasters worldwide
+- **Multi-SDR support** - RTL-SDR, HackRF, LimeSDR, Airspy, SDRplay
+
 ## Listening Post
 
 - **Wideband frequency scanning** via rtl_power sweep with SNR filtering
 - **Real-time audio monitoring** with FM and SSB demodulation
 - **Cross-module frequency routing** from scanner to decoders
+- **Waterfall spectrum display** for visual signal identification
 - **Customizable frequency presets** and band bookmarks
 - **Multi-SDR support** - RTL-SDR, LimeSDR, HackRF, Airspy, SDRplay
 
@@ -181,6 +189,16 @@ Digital Selective Calling (DSC) monitoring on the international maritime distres
 - **Auto-refresh** - 5-minute polling with manual refresh option
 - **No SDR required** - Data fetched from NOAA SWPC, NASA SDO, and HamQSL public APIs
 
+## Radiosonde Weather Balloon Tracking
+
+- **400-406 MHz reception** via radiosonde_auto_rx for weather balloon telemetry
+- **Frequency presets** for common radiosonde bands
+- **Real-time telemetry** - altitude, temperature, humidity, pressure, GPS position
+- **Interactive map** with balloon trajectory and burst point prediction
+- **Station location** with configurable observer position
+- **Distance tracking** - real-time distance-to-balloon calculation
+- **Multi-SDR support** - RTL-SDR, HackRF, LimeSDR, Airspy, SDRplay
+
 ## Satellite Tracking
 
 - **Full-screen dashboard** - dedicated popout with polar plot and ground track
@@ -281,7 +299,7 @@ Technical Surveillance Countermeasures (TSCM) screening for detecting wireless s
 ### Wireless Sweep Features
 - **BLE scanning** with manufacturer data detection (AirTags, Tile, SmartTags, ESP32)
 - **WiFi scanning** for rogue APs, hidden SSIDs, camera devices
-- **RF spectrum analysis** (requires RTL-SDR) - FM bugs, ISM bands, video transmitters
+- **RF spectrum analysis** (RTL-SDR or HackRF) - FM bugs, ISM bands, video transmitters
 - **Cross-protocol correlation** - links devices across BLE/WiFi/RF
 - **Baseline comparison** - detect new/unknown devices vs known environment
 
@@ -380,6 +398,14 @@ Deploy lightweight sensor nodes across multiple locations and aggregate data to
 - **Redundancy** - Multiple nodes for reliable coverage
 - **Triangulation** - Use multiple GPS-enabled agents for signal location
 
+## System Health
+
+- **Telemetry dashboard** with real-time system metrics
+- **Process monitoring** for all running SDR tools and decoders
+- **CPU, memory, and disk usage** tracking
+- **SDR device status** overview
+- **No SDR required** - monitors system health independently
+
 ## User Interface
 
 - **Mode-specific header stats** - real-time badges showing key metrics per mode
@@ -445,9 +471,13 @@ The settings modal shows availability status for each bundled asset:
 - **Message export** to CSV/JSON
 - **Signal activity meter** and waterfall display
 - **Message logging** to file with timestamps
-- **Multi-SDR hardware support** - RTL-SDR, LimeSDR, HackRF
+- **HTTPS support** via `INTERCEPT_HTTPS` configuration for secure deployments
+- **Voice alerts** for configurable event notifications across modes
+- **Multi-SDR hardware support** - RTL-SDR, LimeSDR, HackRF, Airspy, SDRplay
 - **Automatic device detection** across all supported hardware
 - **Hardware-specific validation** - frequency/gain ranges per device type
+- **Tool path overrides** via `INTERCEPT_*_PATH` environment variables
+- **Native Homebrew detection** for Apple Silicon tool paths
 - **Configurable gain and PPM correction**
 - **Device intelligence** dashboard with tracking
 - **GPS dongle support** - USB GPS receivers for precise observer location

docs/UI_GUIDE.md

@@ -214,8 +214,6 @@ Extended base for full-screen dashboards (maps, visualizations).
 | `bt_locate` | BT Locate |
 | `analytics` | Analytics dashboard |
 | `spaceweather` | Space weather |
-| `dmr` | DMR/P25 digital voice |
-
 ### Navigation Groups
 
 The navigation is organized into groups:

docs/USAGE.md

@@ -172,7 +172,7 @@ Set the following environment variables (Docker recommended):
 ```bash
 INTERCEPT_ADSB_AUTO_START=true \
 INTERCEPT_SHARED_OBSERVER_LOCATION=false \
-python app.py
+sudo -E venv/bin/python intercept.py
 ```
 
 **Docker example (.env)**

docs/index.html

@@ -36,7 +36,7 @@
             </div>
             <div class="hero-stats">
                 <div class="stat">
-                    <span class="stat-value">25+</span>
+                    <span class="stat-value">30+</span>
                     <span class="stat-label">Modes</span>
                 </div>
                 <div class="stat">
@@ -92,6 +92,11 @@
                         <h3>Listening Post</h3>
                         <p>Frequency scanner with real-time audio monitoring, fine-tuning controls, and customizable frequency presets.</p>
                     </div>
+                    <div class="feature-card" data-category="signals">
+                        <div class="feature-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M4 12h2"/><path d="M8 12h1"/><path d="M11 12h2"/><path d="M15 12h1"/><path d="M18 12h2"/><circle cx="6" cy="12" r="1"/><circle cx="12" cy="12" r="1"/><circle cx="18" cy="12" r="1"/><path d="M4 8h16"/><path d="M4 16h16"/></svg></div>
+                        <h3>CW/Morse Decoder</h3>
+                        <p>Morse code decoding with custom Goertzel tone detection for CW and OOK/AM envelope detection for ISM band signals.</p>
+                    </div>
                     <div class="feature-card" data-category="intel">
                         <div class="feature-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><line x1="2" y1="12" x2="22" y2="12"/><path d="M12 2a15.3 15.3 0 0 1 4 10 15.3 15.3 0 0 1-4 10 15.3 15.3 0 0 1-4-10 15.3 15.3 0 0 1 4-10z"/></svg></div>
                         <h3>WebSDR</h3>
@@ -110,7 +115,7 @@
                     <div class="feature-card" data-category="signals">
                         <div class="feature-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M13 2L3 14h9l-1 8 10-12h-9l1-8z"/></svg></div>
                         <h3>Utility Meters</h3>
-                        <p>Smart meter monitoring via rtl_amr. Receive electric, gas, and water meter broadcasts in real time.</p>
+                        <p>Smart meter monitoring via rtlamr. Receive electric, gas, and water meter broadcasts in real time.</p>
                     </div>
                     <div class="feature-card" data-category="tracking">
                         <div class="feature-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M17.8 19.2L16 11l3.5-3.5C21 6 21.5 4 21 3c-1-.5-3 0-4.5 1.5L13 8 4.8 6.2c-.5-.1-.9.1-1.1.5l-.3.5c-.2.5-.1 1 .3 1.3L9 12l-2 3H4l-1 1 3 2 2 3 1-1v-3l3-2 3.5 5.3c.3.4.8.5 1.3.3l.5-.2c.4-.3.6-.7.5-1.2z"/></svg></div>
@@ -152,11 +157,21 @@
                         <h3>HF SSTV</h3>
                         <p>Terrestrial SSTV on shortwave frequencies. Decode amateur radio image transmissions across HF, VHF, and UHF bands.</p>
                     </div>
+                    <div class="feature-card" data-category="space">
+                        <div class="feature-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><rect x="3" y="3" width="18" height="18" rx="2"/><path d="M3 15h18"/><path d="M3 9h18"/><path d="M6 3v18"/><path d="M18 3v18"/><path d="M9 6h6"/></svg></div>
+                        <h3>WeFax</h3>
+                        <p>HF weather fax decoder with broadcast timeline, auto-scheduler, and image gallery for marine weather charts.</p>
+                    </div>
                     <div class="feature-card" data-category="tracking">
                         <div class="feature-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><path d="M12 2a14.5 14.5 0 0 0 0 20 14.5 14.5 0 0 0 0-20"/><path d="M2 12h20"/><path d="M12 8l4 4-4 4"/></svg></div>
                         <h3>GPS Tracking</h3>
                         <p>Real-time GPS position tracking with live map, speed, heading, altitude, satellite info, and track recording.</p>
                     </div>
+                    <div class="feature-card" data-category="tracking">
+                        <div class="feature-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M12 2v6"/><path d="M12 22v-6"/><circle cx="12" cy="12" r="4"/><path d="M8 12H2"/><path d="M22 12h-6"/><path d="M12 8a20 20 0 0 1 0 8"/><path d="M7 4l2 3"/><path d="M17 20l-2-3"/></svg></div>
+                        <h3>Radiosonde</h3>
+                        <p>Weather balloon tracking on 400-406 MHz via radiosonde_auto_rx. Real-time telemetry, trajectory map, and station distance.</p>
+                    </div>
                     <div class="feature-card" data-category="space">
                         <div class="feature-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="5"/><line x1="12" y1="1" x2="12" y2="3"/><line x1="12" y1="21" x2="12" y2="23"/><line x1="4.22" y1="4.22" x2="5.64" y2="5.64"/><line x1="18.36" y1="18.36" x2="19.78" y2="19.78"/><line x1="1" y1="12" x2="3" y2="12"/><line x1="21" y1="12" x2="23" y2="12"/><line x1="4.22" y1="19.78" x2="5.64" y2="18.36"/><line x1="18.36" y1="5.64" x2="19.78" y2="4.22"/></svg></div>
                         <h3>Space Weather</h3>
@@ -197,6 +212,11 @@
                         <h3>Offline Mode</h3>
                         <p>Run without internet using bundled assets. Choose from multiple map tile providers or use your own local tile server.</p>
                     </div>
+                    <div class="feature-card" data-category="platform">
+                        <div class="feature-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M22 12h-4l-3 9L9 3l-3 9H2"/></svg></div>
+                        <h3>System Health</h3>
+                        <p>Real-time telemetry dashboard with process monitoring, system metrics, and SDR device status overview.</p>
+                    </div>
                 </div>
                 <button class="carousel-arrow carousel-arrow-right" aria-label="Scroll right">&#8250;</button>
             </div>
@@ -321,7 +341,7 @@ sudo -E venv/bin/python intercept.py</code></pre>
                     <div class="code-block">
                         <pre><code>git clone https://github.com/smittix/intercept.git
 cd intercept
-docker compose up -d</code></pre>
+docker compose --profile basic up -d --build</code></pre>
                     </div>
                     <p class="install-note">Requires privileged mode for USB SDR access</p>
                 </div>
@@ -422,7 +442,7 @@ docker compose up -d</code></pre>
                 </div>
             </div>
             <div class="footer-bottom">
-                <p>Created by <a href="https://github.com/smittix" target="_blank">smittix</a> · MIT License</p>
+                <p>Created by <a href="https://github.com/smittix" target="_blank">smittix</a> · Apache 2.0 License</p>
                 <p class="disclaimer">For educational and authorized testing purposes only.</p>
             </div>
         </div>

intercept_agent.py

@@ -2862,6 +2862,17 @@ class ModeManager:
 
     def _parse_aprs_packet(self, line: str) -> dict | None:
         """Parse APRS packet from direwolf or multimon-ng."""
+        if not line:
+            return None
+
+        # Normalize common decoder prefixes before parsing.
+        # multimon-ng: "AFSK1200: ..."
+        # direwolf: "[0.4] ...", "[0L] ..."
+        line = line.strip()
+        if line.startswith('AFSK1200:'):
+            line = line[9:].strip()
+        line = re.sub(r'^(?:\[[^\]]+\]\s*)+', '', line)
+
         match = re.match(r'([A-Z0-9-]+)>([^:]+):(.+)', line)
         if not match:
             return None

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "intercept"
-version = "2.21.0"
+version = "2.23.0"
 description = "Signal Intelligence Platform - Pager/433MHz/ADS-B/Satellite/WiFi/Bluetooth"
 readme = "README.md"
 requires-python = ">=3.9"

requirements.txt

@@ -44,3 +44,6 @@ cryptography>=41.0.0
 # WebSocket support for in-app audio streaming (KiwiSDR, Listening Post)
 flask-sock
 websocket-client>=1.6.0
+
+# System health monitoring (optional - graceful fallback if unavailable)
+psutil>=5.9.0

routes/__init__.py

@@ -2,41 +2,44 @@
 
 def register_blueprints(app):
     """Register all route blueprints with the Flask app."""
-    from .pager import pager_bp
+    from .acars import acars_bp
-    from .sensor import sensor_bp
-    from .rtlamr import rtlamr_bp
-    from .wifi import wifi_bp
-    from .wifi_v2 import wifi_v2_bp
-    from .bluetooth import bluetooth_bp
-    from .bluetooth_v2 import bluetooth_v2_bp
     from .adsb import adsb_bp
     from .ais import ais_bp
-    from .dsc import dsc_bp
-    from .acars import acars_bp
-    from .vdl2 import vdl2_bp
-    from .aprs import aprs_bp
-    from .satellite import satellite_bp
-    from .gps import gps_bp
-    from .settings import settings_bp
-    from .correlation import correlation_bp
-    from .listening_post import listening_post_bp
-    from .meshtastic import meshtastic_bp
-    from .tscm import tscm_bp, init_tscm_state
-    from .spy_stations import spy_stations_bp
-    from .controller import controller_bp
-    from .offline import offline_bp
-    from .updater import updater_bp
-    from .sstv import sstv_bp
-    from .weather_sat import weather_sat_bp
-    from .sstv_general import sstv_general_bp
-    from .dmr import dmr_bp
-    from .websdr import websdr_bp
     from .alerts import alerts_bp
-    from .recordings import recordings_bp
+    from .aprs import aprs_bp
-    from .subghz import subghz_bp
+    from .bluetooth import bluetooth_bp
+    from .bluetooth_v2 import bluetooth_v2_bp
     from .bt_locate import bt_locate_bp
-    from .analytics import analytics_bp
+    from .controller import controller_bp
+    from .correlation import correlation_bp
+    from .dsc import dsc_bp
+    from .gps import gps_bp
+    from .listening_post import receiver_bp
+    from .meshtastic import meshtastic_bp
+    from .morse import morse_bp
+    from .offline import offline_bp
+    from .pager import pager_bp
+    from .radiosonde import radiosonde_bp
+    from .recordings import recordings_bp
+    from .rtlamr import rtlamr_bp
+    from .satellite import satellite_bp
+    from .sensor import sensor_bp
+    from .settings import settings_bp
+    from .signalid import signalid_bp
     from .space_weather import space_weather_bp
+    from .spy_stations import spy_stations_bp
+    from .sstv import sstv_bp
+    from .sstv_general import sstv_general_bp
+    from .subghz import subghz_bp
+    from .system import system_bp
+    from .tscm import init_tscm_state, tscm_bp
+    from .updater import updater_bp
+    from .vdl2 import vdl2_bp
+    from .weather_sat import weather_sat_bp
+    from .wefax import wefax_bp
+    from .websdr import websdr_bp
+    from .wifi import wifi_bp
+    from .wifi_v2 import wifi_v2_bp
 
     app.register_blueprint(pager_bp)
     app.register_blueprint(sensor_bp)
@@ -55,7 +58,7 @@ def register_blueprints(app):
     app.register_blueprint(gps_bp)
     app.register_blueprint(settings_bp)
     app.register_blueprint(correlation_bp)
-    app.register_blueprint(listening_post_bp)
+    app.register_blueprint(receiver_bp)
     app.register_blueprint(meshtastic_bp)
     app.register_blueprint(tscm_bp)
     app.register_blueprint(spy_stations_bp)
@@ -65,14 +68,17 @@ def register_blueprints(app):
     app.register_blueprint(sstv_bp)  # ISS SSTV decoder
     app.register_blueprint(weather_sat_bp)  # NOAA/Meteor weather satellite decoder
     app.register_blueprint(sstv_general_bp)  # General terrestrial SSTV
-    app.register_blueprint(dmr_bp)  # DMR / P25 / Digital Voice
     app.register_blueprint(websdr_bp)  # HF/Shortwave WebSDR
     app.register_blueprint(alerts_bp)  # Cross-mode alerts
     app.register_blueprint(recordings_bp)  # Session recordings
     app.register_blueprint(subghz_bp)  # SubGHz transceiver (HackRF)
     app.register_blueprint(bt_locate_bp)  # BT Locate SAR device tracking
-    app.register_blueprint(analytics_bp)  # Cross-mode analytics dashboard
     app.register_blueprint(space_weather_bp)  # Space weather monitoring
+    app.register_blueprint(signalid_bp)  # External signal ID enrichment
+    app.register_blueprint(wefax_bp)  # WeFax HF weather fax decoder
+    app.register_blueprint(morse_bp)  # CW/Morse code decoder
+    app.register_blueprint(radiosonde_bp)  # Radiosonde weather balloon tracking
+    app.register_blueprint(system_bp)  # System health monitoring
 
     # Initialize TSCM state with queue and lock from app
     import app as app_module

routes/acars.py

@@ -45,6 +45,7 @@ acars_last_message_time = None
 
 # Track which device is being used
 acars_active_device: int | None = None
+acars_active_sdr_type: str | None = None
 
 
 def find_acarsdec():
@@ -151,7 +152,7 @@ def stream_acars_output(process: subprocess.Popen, is_text_mode: bool = False) -
         logger.error(f"ACARS stream error: {e}")
         app_module.acars_queue.put({'type': 'error', 'message': str(e)})
     finally:
-        global acars_active_device
+        global acars_active_device, acars_active_sdr_type
         # Ensure process is terminated
         try:
             process.terminate()
@@ -167,8 +168,9 @@ def stream_acars_output(process: subprocess.Popen, is_text_mode: bool = False) -
             app_module.acars_process = None
         # Release SDR device
         if acars_active_device is not None:
-            app_module.release_sdr_device(acars_active_device)
+            app_module.release_sdr_device(acars_active_device, acars_active_sdr_type or 'rtlsdr')
             acars_active_device = None
+            acars_active_sdr_type = None
 
 
 @acars_bp.route('/tools')
@@ -200,7 +202,7 @@ def acars_status() -> Response:
 @acars_bp.route('/start', methods=['POST'])
 def start_acars() -> Response:
     """Start ACARS decoder."""
-    global acars_message_count, acars_last_message_time, acars_active_device
+    global acars_message_count, acars_last_message_time, acars_active_device, acars_active_sdr_type
 
     with app_module.acars_lock:
         if app_module.acars_process and app_module.acars_process.poll() is None:
@@ -227,9 +229,12 @@ def start_acars() -> Response:
     except ValueError as e:
         return jsonify({'status': 'error', 'message': str(e)}), 400
 
+    # Resolve SDR type for device selection
+    sdr_type_str = data.get('sdr_type', 'rtlsdr')
+
     # Check if device is available
     device_int = int(device)
-    error = app_module.claim_sdr_device(device_int, 'acars')
+    error = app_module.claim_sdr_device(device_int, 'acars', sdr_type_str)
     if error:
         return jsonify({
             'status': 'error',
@@ -238,6 +243,7 @@ def start_acars() -> Response:
         }), 409
 
     acars_active_device = device_int
+    acars_active_sdr_type = sdr_type_str
 
     # Get frequencies - use provided or defaults
     frequencies = data.get('frequencies', DEFAULT_ACARS_FREQUENCIES)
@@ -255,8 +261,6 @@ def start_acars() -> Response:
     acars_message_count = 0
     acars_last_message_time = None
 
-    # Resolve SDR type for device selection
-    sdr_type_str = data.get('sdr_type', 'rtlsdr')
     try:
         sdr_type = SDRType(sdr_type_str)
     except ValueError:
@@ -343,8 +347,9 @@ def start_acars() -> Response:
         if process.poll() is not None:
             # Process died - release device
             if acars_active_device is not None:
-                app_module.release_sdr_device(acars_active_device)
+                app_module.release_sdr_device(acars_active_device, acars_active_sdr_type or 'rtlsdr')
                 acars_active_device = None
+                acars_active_sdr_type = None
             stderr = ''
             if process.stderr:
                 stderr = process.stderr.read().decode('utf-8', errors='replace')
@@ -375,8 +380,9 @@ def start_acars() -> Response:
     except Exception as e:
         # Release device on failure
         if acars_active_device is not None:
-            app_module.release_sdr_device(acars_active_device)
+            app_module.release_sdr_device(acars_active_device, acars_active_sdr_type or 'rtlsdr')
             acars_active_device = None
+            acars_active_sdr_type = None
         logger.error(f"Failed to start ACARS decoder: {e}")
         return jsonify({'status': 'error', 'message': str(e)}), 500
 
@@ -384,7 +390,7 @@ def start_acars() -> Response:
 @acars_bp.route('/stop', methods=['POST'])
 def stop_acars() -> Response:
     """Stop ACARS decoder."""
-    global acars_active_device
+    global acars_active_device, acars_active_sdr_type
 
     with app_module.acars_lock:
         if not app_module.acars_process:
@@ -405,8 +411,9 @@ def stop_acars() -> Response:
 
     # Release device from registry
     if acars_active_device is not None:
-        app_module.release_sdr_device(acars_active_device)
+        app_module.release_sdr_device(acars_active_device, acars_active_sdr_type or 'rtlsdr')
         acars_active_device = None
+        acars_active_sdr_type = None
 
     return jsonify({'status': 'stopped'})
 

routes/adsb.py

@@ -72,6 +72,7 @@ adsb_last_message_time = None
 adsb_bytes_received = 0
 adsb_lines_received = 0
 adsb_active_device = None  # Track which device index is being used
+adsb_active_sdr_type: str | None = None
 _sbs_error_logged = False  # Suppress repeated connection error logs
 
 # Track ICAOs already looked up in aircraft database (avoid repeated lookups)
@@ -379,10 +380,62 @@ def parse_sbs_stream(service_addr):
             adsb_bytes_received = 0
             adsb_lines_received = 0
 
+            def flush_pending_updates(force: bool = False) -> None:
+                nonlocal last_update
+                if not pending_updates:
+                    return
+
+                now = time.time()
+                if not force and now - last_update < ADSB_UPDATE_INTERVAL:
+                    return
+
+                captured_at = datetime.now(timezone.utc)
+                for update_icao in tuple(pending_updates):
+                    if update_icao in app_module.adsb_aircraft:
+                        snapshot = app_module.adsb_aircraft[update_icao]
+                        _broadcast_adsb_update({
+                            'type': 'aircraft',
+                            **snapshot
+                        })
+                        adsb_snapshot_writer.enqueue({
+                            'captured_at': captured_at,
+                            'icao': update_icao,
+                            'callsign': snapshot.get('callsign'),
+                            'registration': snapshot.get('registration'),
+                            'type_code': snapshot.get('type_code'),
+                            'type_desc': snapshot.get('type_desc'),
+                            'altitude': snapshot.get('altitude'),
+                            'speed': snapshot.get('speed'),
+                            'heading': snapshot.get('heading'),
+                            'vertical_rate': snapshot.get('vertical_rate'),
+                            'lat': snapshot.get('lat'),
+                            'lon': snapshot.get('lon'),
+                            'squawk': snapshot.get('squawk'),
+                            'source_host': service_addr,
+                            'snapshot': snapshot,
+                        })
+                        # Geofence check
+                        _gf_lat = snapshot.get('lat')
+                        _gf_lon = snapshot.get('lon')
+                        if _gf_lat is not None and _gf_lon is not None:
+                            try:
+                                from utils.geofence import get_geofence_manager
+                                for _gf_evt in get_geofence_manager().check_position(
+                                    update_icao, 'aircraft', _gf_lat, _gf_lon,
+                                    {'callsign': snapshot.get('callsign'), 'altitude': snapshot.get('altitude')}
+                                ):
+                                    process_event('adsb', _gf_evt, 'geofence')
+                            except Exception:
+                                pass
+
+                pending_updates.clear()
+                last_update = now
+
             while adsb_using_service:
                 try:
                     data = sock.recv(SOCKET_BUFFER_SIZE).decode('utf-8', errors='ignore')
                     if not data:
+                        flush_pending_updates(force=True)
                         logger.warning("SBS connection closed (no data)")
                         break
                     adsb_bytes_received += len(data)
@@ -501,56 +554,40 @@ def parse_sbs_stream(service_addr):
                                         'squawk': sq, 'meaning': _EMERGENCY_SQUAWKS[sq],
                                     }, 'squawk_emergency')
 
+                        elif msg_type == '2' and len(parts) > 15:
+                            if parts[11]:
+                                try:
+                                    aircraft['altitude'] = int(float(parts[11]))
+                                except (ValueError, TypeError):
+                                    pass
+                            if parts[12]:
+                                try:
+                                    aircraft['speed'] = int(float(parts[12]))
+                                except (ValueError, TypeError):
+                                    pass
+                            if parts[13]:
+                                try:
+                                    aircraft['heading'] = int(float(parts[13]))
+                                except (ValueError, TypeError):
+                                    pass
+                            if parts[14] and parts[15]:
+                                try:
+                                    aircraft['lat'] = float(parts[14])
+                                    aircraft['lon'] = float(parts[15])
+                                except (ValueError, TypeError):
+                                    pass
+
                         app_module.adsb_aircraft.set(icao, aircraft)
                         pending_updates.add(icao)
                         adsb_messages_received += 1
                         adsb_last_message_time = time.time()
-
+                        flush_pending_updates()
-                        now = time.time()
-                        if now - last_update >= ADSB_UPDATE_INTERVAL:
-                            for update_icao in pending_updates:
-                                if update_icao in app_module.adsb_aircraft:
-                                    snapshot = app_module.adsb_aircraft[update_icao]
-                                    _broadcast_adsb_update({
-                                        'type': 'aircraft',
-                                        **snapshot
-                                    })
-                                    adsb_snapshot_writer.enqueue({
-                                        'captured_at': datetime.now(timezone.utc),
-                                        'icao': update_icao,
-                                        'callsign': snapshot.get('callsign'),
-                                        'registration': snapshot.get('registration'),
-                                        'type_code': snapshot.get('type_code'),
-                                        'type_desc': snapshot.get('type_desc'),
-                                        'altitude': snapshot.get('altitude'),
-                                        'speed': snapshot.get('speed'),
-                                        'heading': snapshot.get('heading'),
-                                        'vertical_rate': snapshot.get('vertical_rate'),
-                                        'lat': snapshot.get('lat'),
-                                        'lon': snapshot.get('lon'),
-                                        'squawk': snapshot.get('squawk'),
-                                        'source_host': service_addr,
-                                        'snapshot': snapshot,
-                                    })
-                                    # Geofence check
-                                    _gf_lat = snapshot.get('lat')
-                                    _gf_lon = snapshot.get('lon')
-                                    if _gf_lat is not None and _gf_lon is not None:
-                                        try:
-                                            from utils.geofence import get_geofence_manager
-                                            for _gf_evt in get_geofence_manager().check_position(
-                                                update_icao, 'aircraft', _gf_lat, _gf_lon,
-                                                {'callsign': snapshot.get('callsign'), 'altitude': snapshot.get('altitude')}
-                                            ):
-                                                process_event('adsb', _gf_evt, 'geofence')
-                                        except Exception:
-                                            pass
-                            pending_updates.clear()
-                            last_update = now
 
                 except socket.timeout:
+                    flush_pending_updates()
                     continue
 
+            flush_pending_updates(force=True)
             sock.close()
             adsb_connected = False
         except OSError as e:
@@ -638,7 +675,7 @@ def adsb_session():
 @adsb_bp.route('/start', methods=['POST'])
 def start_adsb():
     """Start ADS-B tracking."""
-    global adsb_using_service, adsb_active_device
+    global adsb_using_service, adsb_active_device, adsb_active_sdr_type
 
     with app_module.adsb_lock:
         if adsb_using_service:
@@ -649,7 +686,7 @@ def start_adsb():
                 'session': session
             }), 409
 
-    data = request.json or {}
+    data = request.get_json(silent=True) or {}
     start_source = data.get('source')
     started_by = request.remote_addr
 
@@ -721,6 +758,7 @@ def start_adsb():
         sdr_type = SDRType(sdr_type_str)
     except ValueError:
         sdr_type = SDRType.RTL_SDR
+        sdr_type_str = sdr_type.value
 
     # For RTL-SDR, use dump1090. For other hardware, need readsb with SoapySDR
     if sdr_type == SDRType.RTL_SDR:
@@ -751,7 +789,7 @@ def start_adsb():
 
     # Check if device is available before starting local dump1090
     device_int = int(device)
-    error = app_module.claim_sdr_device(device_int, 'adsb')
+    error = app_module.claim_sdr_device(device_int, 'adsb', sdr_type_str)
     if error:
         return jsonify({
             'status': 'error',
@@ -759,6 +797,10 @@ def start_adsb():
             'message': error
         }), 409
 
+    # Track claimed device immediately so stop_adsb() can always release it
+    adsb_active_device = device
+    adsb_active_sdr_type = sdr_type_str
+
     # Create device object and build command via abstraction layer
     sdr_device = SDRFactory.create_default_device(sdr_type, index=device)
     builder = SDRFactory.get_builder(sdr_type)
@@ -785,11 +827,24 @@ def start_adsb():
         )
         write_dump1090_pid(app_module.adsb_process.pid)
 
-        time.sleep(DUMP1090_START_WAIT)
+        # Poll for dump1090 readiness instead of blind sleep
+        dump1090_ready = False
+        poll_interval = 0.1
+        elapsed = 0.0
+        while elapsed < DUMP1090_START_WAIT:
+            if app_module.adsb_process.poll() is not None:
+                break  # Process exited early — handle below
+            if check_dump1090_service():
+                dump1090_ready = True
+                break
+            time.sleep(poll_interval)
+            elapsed += poll_interval
 
         if app_module.adsb_process.poll() is not None:
             # Process exited - release device and get error message
-            app_module.release_sdr_device(device_int)
+            app_module.release_sdr_device(device_int, sdr_type_str)
+            adsb_active_device = None
+            adsb_active_sdr_type = None
             stderr_output = ''
             if app_module.adsb_process.stderr:
                 try:
@@ -835,7 +890,6 @@ def start_adsb():
             })
 
         adsb_using_service = True
-        adsb_active_device = device  # Track which device is being used
         thread = threading.Thread(target=parse_sbs_stream, args=(f'localhost:{ADSB_SBS_PORT}',), daemon=True)
         thread.start()
 
@@ -855,15 +909,17 @@ def start_adsb():
         })
     except Exception as e:
         # Release device on failure
-        app_module.release_sdr_device(device_int)
+        app_module.release_sdr_device(device_int, sdr_type_str)
+        adsb_active_device = None
+        adsb_active_sdr_type = None
         return jsonify({'status': 'error', 'message': str(e)})
 
 
 @adsb_bp.route('/stop', methods=['POST'])
 def stop_adsb():
     """Stop ADS-B tracking."""
-    global adsb_using_service, adsb_active_device
+    global adsb_using_service, adsb_active_device, adsb_active_sdr_type
-    data = request.json or {}
+    data = request.get_json(silent=True) or {}
     stop_source = data.get('source')
     stopped_by = request.remote_addr
 
@@ -887,10 +943,11 @@ def stop_adsb():
 
         # Release device from registry
         if adsb_active_device is not None:
-            app_module.release_sdr_device(adsb_active_device)
+            app_module.release_sdr_device(adsb_active_device, adsb_active_sdr_type or 'rtlsdr')
 
         adsb_using_service = False
         adsb_active_device = None
+        adsb_active_sdr_type = None
 
     app_module.adsb_aircraft.clear()
     _looked_up_icaos.clear()
@@ -944,10 +1001,12 @@ def stream_adsb():
 @adsb_bp.route('/dashboard')
 def adsb_dashboard():
     """Popout ADS-B dashboard."""
+    embedded = request.args.get('embedded', 'false') == 'true'
     return render_template(
         'adsb_dashboard.html',
         shared_observer_location=SHARED_OBSERVER_LOCATION_ENABLED,
         adsb_auto_start=ADSB_AUTO_START,
+        embedded=embedded,
     )
 
 

routes/ais.py

@@ -44,6 +44,7 @@ ais_connected = False
 ais_messages_received = 0
 ais_last_message_time = None
 ais_active_device = None
+ais_active_sdr_type: str | None = None
 _ais_error_logged = True
 
 # Common installation paths for AIS-catcher
@@ -350,7 +351,7 @@ def ais_status():
 @ais_bp.route('/start', methods=['POST'])
 def start_ais():
     """Start AIS tracking."""
-    global ais_running, ais_active_device
+    global ais_running, ais_active_device, ais_active_sdr_type
 
     with app_module.ais_lock:
         if ais_running:
@@ -397,7 +398,7 @@ def start_ais():
 
     # Check if device is available
     device_int = int(device)
-    error = app_module.claim_sdr_device(device_int, 'ais')
+    error = app_module.claim_sdr_device(device_int, 'ais', sdr_type_str)
     if error:
         return jsonify({
             'status': 'error',
@@ -436,7 +437,7 @@ def start_ais():
 
         if app_module.ais_process.poll() is not None:
             # Release device on failure
-            app_module.release_sdr_device(device_int)
+            app_module.release_sdr_device(device_int, sdr_type_str)
             stderr_output = ''
             if app_module.ais_process.stderr:
                 try:
@@ -450,6 +451,7 @@ def start_ais():
 
         ais_running = True
         ais_active_device = device
+        ais_active_sdr_type = sdr_type_str
 
         # Start TCP parser thread
         thread = threading.Thread(target=parse_ais_stream, args=(tcp_port,), daemon=True)
@@ -463,7 +465,7 @@ def start_ais():
         })
     except Exception as e:
         # Release device on failure
-        app_module.release_sdr_device(device_int)
+        app_module.release_sdr_device(device_int, sdr_type_str)
         logger.error(f"Failed to start AIS-catcher: {e}")
         return jsonify({'status': 'error', 'message': str(e)}), 500
 
@@ -471,7 +473,7 @@ def start_ais():
 @ais_bp.route('/stop', methods=['POST'])
 def stop_ais():
     """Stop AIS tracking."""
-    global ais_running, ais_active_device
+    global ais_running, ais_active_device, ais_active_sdr_type
 
     with app_module.ais_lock:
         if app_module.ais_process:
@@ -490,10 +492,11 @@ def stop_ais():
 
         # Release device from registry
         if ais_active_device is not None:
-            app_module.release_sdr_device(ais_active_device)
+            app_module.release_sdr_device(ais_active_device, ais_active_sdr_type or 'rtlsdr')
 
         ais_running = False
         ais_active_device = None
+        ais_active_sdr_type = None
 
     app_module.ais_vessels.clear()
     return jsonify({'status': 'stopped'})
@@ -540,7 +543,9 @@ def get_vessel_dsc(mmsi: str):
 @ais_bp.route('/dashboard')
 def ais_dashboard():
     """Popout AIS dashboard."""
+    embedded = request.args.get('embedded', 'false') == 'true'
     return render_template(
         'ais_dashboard.html',
         shared_observer_location=SHARED_OBSERVER_LOCATION_ENABLED,
+        embedded=embedded,
     )

routes/analytics.py

@@ -1,528 +0,0 @@
-"""Analytics dashboard: cross-mode summary, activity sparklines, export, geofence CRUD."""
-
-from __future__ import annotations
-
-import csv
-import io
-import json
-from datetime import datetime, timezone
-from typing import Any
-
-from flask import Blueprint, Response, jsonify, request
-
-import app as app_module
-from utils.analytics import (
-    get_activity_tracker,
-    get_cross_mode_summary,
-    get_emergency_squawks,
-    get_mode_health,
-)
-from utils.alerts import get_alert_manager
-from utils.flight_correlator import get_flight_correlator
-from utils.geofence import get_geofence_manager
-from utils.temporal_patterns import get_pattern_detector
-
-analytics_bp = Blueprint('analytics', __name__, url_prefix='/analytics')
-
-
-# Map mode names to DataStore attribute(s)
-MODE_STORES: dict[str, list[str]] = {
-    'adsb': ['adsb_aircraft'],
-    'ais': ['ais_vessels'],
-    'wifi': ['wifi_networks', 'wifi_clients'],
-    'bluetooth': ['bt_devices'],
-    'dsc': ['dsc_messages'],
-}
-
-
-@analytics_bp.route('/summary')
-def analytics_summary():
-    """Return cross-mode counts, health, and emergency squawks."""
-    return jsonify({
-        'status': 'success',
-        'counts': get_cross_mode_summary(),
-        'health': get_mode_health(),
-        'squawks': get_emergency_squawks(),
-        'flight_messages': {
-            'acars': get_flight_correlator().acars_count,
-            'vdl2': get_flight_correlator().vdl2_count,
-        },
-    })
-
-
-@analytics_bp.route('/activity')
-def analytics_activity():
-    """Return sparkline arrays for each mode."""
-    tracker = get_activity_tracker()
-    return jsonify({
-        'status': 'success',
-        'sparklines': tracker.get_all_sparklines(),
-    })
-
-
-@analytics_bp.route('/squawks')
-def analytics_squawks():
-    """Return current emergency squawk codes from ADS-B."""
-    return jsonify({
-        'status': 'success',
-        'squawks': get_emergency_squawks(),
-    })
-
-
-@analytics_bp.route('/patterns')
-def analytics_patterns():
-    """Return detected temporal patterns."""
-    return jsonify({
-        'status': 'success',
-        'patterns': get_pattern_detector().get_all_patterns(),
-    })
-
-
-@analytics_bp.route('/target')
-def analytics_target():
-    """Search entities across multiple modes for a target-centric view."""
-    query = (request.args.get('q') or '').strip()
-    requested_limit = request.args.get('limit', default=120, type=int) or 120
-    limit = max(1, min(500, requested_limit))
-
-    if not query:
-        return jsonify({
-            'status': 'success',
-            'query': '',
-            'results': [],
-            'mode_counts': {},
-        })
-
-    needle = query.lower()
-    results: list[dict[str, Any]] = []
-    mode_counts: dict[str, int] = {}
-
-    def push(mode: str, entity_id: str, title: str, subtitle: str, last_seen: str | None = None) -> None:
-        if len(results) >= limit:
-            return
-        results.append({
-            'mode': mode,
-            'id': entity_id,
-            'title': title,
-            'subtitle': subtitle,
-            'last_seen': last_seen,
-        })
-        mode_counts[mode] = mode_counts.get(mode, 0) + 1
-
-    # ADS-B
-    for icao, aircraft in app_module.adsb_aircraft.items():
-        if not isinstance(aircraft, dict):
-            continue
-        fields = [
-            icao,
-            aircraft.get('icao'),
-            aircraft.get('hex'),
-            aircraft.get('callsign'),
-            aircraft.get('registration'),
-            aircraft.get('flight'),
-        ]
-        if not _matches_query(needle, fields):
-            continue
-        title = str(aircraft.get('callsign') or icao or 'Aircraft').strip()
-        subtitle = f"ICAO {aircraft.get('icao') or icao} | Alt {aircraft.get('altitude', '--')} | Speed {aircraft.get('speed', '--')}"
-        push('adsb', str(icao), title, subtitle, aircraft.get('lastSeen') or aircraft.get('last_seen'))
-        if len(results) >= limit:
-            break
-
-    # AIS
-    if len(results) < limit:
-        for mmsi, vessel in app_module.ais_vessels.items():
-            if not isinstance(vessel, dict):
-                continue
-            fields = [
-                mmsi,
-                vessel.get('mmsi'),
-                vessel.get('name'),
-                vessel.get('shipname'),
-                vessel.get('callsign'),
-                vessel.get('imo'),
-            ]
-            if not _matches_query(needle, fields):
-                continue
-            vessel_name = vessel.get('name') or vessel.get('shipname') or mmsi or 'Vessel'
-            subtitle = f"MMSI {vessel.get('mmsi') or mmsi} | Type {vessel.get('ship_type') or vessel.get('type') or '--'}"
-            push('ais', str(mmsi), str(vessel_name), subtitle, vessel.get('lastSeen') or vessel.get('last_seen'))
-            if len(results) >= limit:
-                break
-
-    # WiFi networks and clients
-    if len(results) < limit:
-        for bssid, net in app_module.wifi_networks.items():
-            if not isinstance(net, dict):
-                continue
-            fields = [bssid, net.get('bssid'), net.get('ssid'), net.get('vendor')]
-            if not _matches_query(needle, fields):
-                continue
-            title = str(net.get('ssid') or net.get('bssid') or bssid or 'WiFi Network')
-            subtitle = f"BSSID {net.get('bssid') or bssid} | CH {net.get('channel', '--')} | RSSI {net.get('signal', '--')}"
-            push('wifi', str(bssid), title, subtitle, net.get('lastSeen') or net.get('last_seen'))
-            if len(results) >= limit:
-                break
-
-    if len(results) < limit:
-        for client_mac, client in app_module.wifi_clients.items():
-            if not isinstance(client, dict):
-                continue
-            fields = [client_mac, client.get('mac'), client.get('bssid'), client.get('ssid'), client.get('vendor')]
-            if not _matches_query(needle, fields):
-                continue
-            title = str(client.get('mac') or client_mac or 'WiFi Client')
-            subtitle = f"BSSID {client.get('bssid') or '--'} | Probe {client.get('ssid') or '--'}"
-            push('wifi', str(client_mac), title, subtitle, client.get('lastSeen') or client.get('last_seen'))
-            if len(results) >= limit:
-                break
-
-    # Bluetooth
-    if len(results) < limit:
-        for address, dev in app_module.bt_devices.items():
-            if not isinstance(dev, dict):
-                continue
-            fields = [
-                address,
-                dev.get('address'),
-                dev.get('mac'),
-                dev.get('name'),
-                dev.get('manufacturer'),
-                dev.get('vendor'),
-            ]
-            if not _matches_query(needle, fields):
-                continue
-            title = str(dev.get('name') or dev.get('address') or address or 'Bluetooth Device')
-            subtitle = f"MAC {dev.get('address') or address} | RSSI {dev.get('rssi', '--')} | Vendor {dev.get('manufacturer') or dev.get('vendor') or '--'}"
-            push('bluetooth', str(address), title, subtitle, dev.get('lastSeen') or dev.get('last_seen'))
-            if len(results) >= limit:
-                break
-
-    # DSC recent messages
-    if len(results) < limit:
-        for msg_id, msg in app_module.dsc_messages.items():
-            if not isinstance(msg, dict):
-                continue
-            fields = [
-                msg_id,
-                msg.get('mmsi'),
-                msg.get('from_mmsi'),
-                msg.get('to_mmsi'),
-                msg.get('from_callsign'),
-                msg.get('to_callsign'),
-                msg.get('category'),
-            ]
-            if not _matches_query(needle, fields):
-                continue
-            title = str(msg.get('from_mmsi') or msg.get('mmsi') or msg_id or 'DSC Message')
-            subtitle = f"To {msg.get('to_mmsi') or '--'} | Cat {msg.get('category') or '--'} | Freq {msg.get('frequency') or '--'}"
-            push('dsc', str(msg_id), title, subtitle, msg.get('timestamp') or msg.get('lastSeen') or msg.get('last_seen'))
-            if len(results) >= limit:
-                break
-
-    return jsonify({
-        'status': 'success',
-        'query': query,
-        'results': results,
-        'mode_counts': mode_counts,
-    })
-
-
-@analytics_bp.route('/insights')
-def analytics_insights():
-    """Return actionable insight cards and top changes."""
-    counts = get_cross_mode_summary()
-    tracker = get_activity_tracker()
-    sparklines = tracker.get_all_sparklines()
-    squawks = get_emergency_squawks()
-    patterns = get_pattern_detector().get_all_patterns()
-    alerts = get_alert_manager().list_events(limit=120)
-
-    top_changes = _compute_mode_changes(sparklines)
-    busiest_mode, busiest_count = _get_busiest_mode(counts)
-    critical_1h = _count_recent_alerts(alerts, severities={'critical', 'high'}, max_age_seconds=3600)
-    recurring_emitters = sum(1 for p in patterns if float(p.get('confidence') or 0.0) >= 0.7)
-
-    cards = []
-    if top_changes:
-        lead = top_changes[0]
-        direction = 'up' if lead['delta'] >= 0 else 'down'
-        cards.append({
-            'id': 'fastest_change',
-            'title': 'Fastest Change',
-            'value': f"{lead['mode_label']} ({lead['signed_delta']})",
-            'label': 'last window vs prior',
-            'severity': 'high' if lead['delta'] > 0 else 'low',
-            'detail': f"Traffic is trending {direction} in {lead['mode_label']}.",
-        })
-    else:
-        cards.append({
-            'id': 'fastest_change',
-            'title': 'Fastest Change',
-            'value': 'Insufficient data',
-            'label': 'wait for activity history',
-            'severity': 'low',
-            'detail': 'Sparklines need more samples to score momentum.',
-        })
-
-    cards.append({
-        'id': 'busiest_mode',
-        'title': 'Busiest Mode',
-        'value': f"{busiest_mode} ({busiest_count})",
-        'label': 'current observed entities',
-        'severity': 'medium' if busiest_count > 0 else 'low',
-        'detail': 'Highest live entity count across monitoring modes.',
-    })
-    cards.append({
-        'id': 'critical_alerts',
-        'title': 'Critical Alerts (1h)',
-        'value': str(critical_1h),
-        'label': 'critical/high severities',
-        'severity': 'critical' if critical_1h > 0 else 'low',
-        'detail': 'Prioritize triage if this count is non-zero.',
-    })
-    cards.append({
-        'id': 'emergency_squawks',
-        'title': 'Emergency Squawks',
-        'value': str(len(squawks)),
-        'label': 'active ADS-B emergency codes',
-        'severity': 'critical' if squawks else 'low',
-        'detail': 'Immediate aviation anomalies currently visible.',
-    })
-    cards.append({
-        'id': 'recurring_emitters',
-        'title': 'Recurring Emitters',
-        'value': str(recurring_emitters),
-        'label': 'pattern confidence >= 0.70',
-        'severity': 'medium' if recurring_emitters > 0 else 'low',
-        'detail': 'Potentially stationary or periodic emitters detected.',
-    })
-
-    return jsonify({
-        'status': 'success',
-        'generated_at': datetime.now(timezone.utc).isoformat(),
-        'cards': cards,
-        'top_changes': top_changes[:5],
-    })
-
-
-def _compute_mode_changes(sparklines: dict[str, list[int]]) -> list[dict]:
-    mode_labels = {
-        'adsb': 'ADS-B',
-        'ais': 'AIS',
-        'wifi': 'WiFi',
-        'bluetooth': 'Bluetooth',
-        'dsc': 'DSC',
-        'acars': 'ACARS',
-        'vdl2': 'VDL2',
-        'aprs': 'APRS',
-        'meshtastic': 'Meshtastic',
-    }
-    rows = []
-    for mode, samples in (sparklines or {}).items():
-        if not isinstance(samples, list) or len(samples) < 4:
-            continue
-
-        window = max(2, min(12, len(samples) // 2))
-        recent = samples[-window:]
-        previous = samples[-(window * 2):-window]
-        if not previous:
-            continue
-
-        recent_avg = sum(recent) / len(recent)
-        prev_avg = sum(previous) / len(previous)
-        delta = round(recent_avg - prev_avg, 1)
-        rows.append({
-            'mode': mode,
-            'mode_label': mode_labels.get(mode, mode.upper()),
-            'delta': delta,
-            'signed_delta': ('+' if delta >= 0 else '') + str(delta),
-            'recent_avg': round(recent_avg, 1),
-            'previous_avg': round(prev_avg, 1),
-            'direction': 'up' if delta > 0 else ('down' if delta < 0 else 'flat'),
-        })
-
-    rows.sort(key=lambda r: abs(r['delta']), reverse=True)
-    return rows
-
-
-def _matches_query(needle: str, values: list[Any]) -> bool:
-    for value in values:
-        if value is None:
-            continue
-        if needle in str(value).lower():
-            return True
-    return False
-
-
-def _count_recent_alerts(alerts: list[dict], severities: set[str], max_age_seconds: int) -> int:
-    now = datetime.now(timezone.utc)
-    count = 0
-    for event in alerts:
-        sev = str(event.get('severity') or '').lower()
-        if sev not in severities:
-            continue
-        created_raw = event.get('created_at')
-        if not created_raw:
-            continue
-        try:
-            created = datetime.fromisoformat(str(created_raw).replace('Z', '+00:00'))
-        except ValueError:
-            continue
-        if created.tzinfo is None:
-            created = created.replace(tzinfo=timezone.utc)
-        age = (now - created).total_seconds()
-        if 0 <= age <= max_age_seconds:
-            count += 1
-    return count
-
-
-def _get_busiest_mode(counts: dict[str, int]) -> tuple[str, int]:
-    mode_labels = {
-        'adsb': 'ADS-B',
-        'ais': 'AIS',
-        'wifi': 'WiFi',
-        'bluetooth': 'Bluetooth',
-        'dsc': 'DSC',
-        'acars': 'ACARS',
-        'vdl2': 'VDL2',
-        'aprs': 'APRS',
-        'meshtastic': 'Meshtastic',
-    }
-    filtered = {k: int(v or 0) for k, v in (counts or {}).items() if k in mode_labels}
-    if not filtered:
-        return ('None', 0)
-    mode = max(filtered, key=filtered.get)
-    return (mode_labels.get(mode, mode.upper()), filtered[mode])
-
-
-@analytics_bp.route('/export/<mode>')
-def analytics_export(mode: str):
-    """Export current DataStore contents as JSON or CSV."""
-    fmt = request.args.get('format', 'json').lower()
-
-    if mode == 'sensor':
-        # Sensor doesn't use DataStore; return recent queue-based data
-        return jsonify({'status': 'success', 'data': [], 'message': 'Sensor data is stream-only'})
-
-    store_names = MODE_STORES.get(mode)
-    if not store_names:
-        return jsonify({'status': 'error', 'message': f'Unknown mode: {mode}'}), 400
-
-    all_items: list[dict] = []
-
-    # Try v2 scanners first for wifi/bluetooth
-    if mode == 'wifi':
-        try:
-            from utils.wifi.scanner import _scanner_instance as wifi_scanner
-            if wifi_scanner is not None:
-                for ap in wifi_scanner.access_points:
-                    all_items.append(ap.to_dict())
-                for client in wifi_scanner.clients:
-                    item = client.to_dict()
-                    item['_store'] = 'wifi_clients'
-                    all_items.append(item)
-        except Exception:
-            pass
-    elif mode == 'bluetooth':
-        try:
-            from utils.bluetooth.scanner import _scanner_instance as bt_scanner
-            if bt_scanner is not None:
-                for dev in bt_scanner.get_devices():
-                    all_items.append(dev.to_dict())
-        except Exception:
-            pass
-
-    # Fall back to legacy DataStores if v2 scanners yielded nothing
-    if not all_items:
-        for store_name in store_names:
-            store = getattr(app_module, store_name, None)
-            if store is None:
-                continue
-            for key, value in store.items():
-                item = dict(value) if isinstance(value, dict) else {'id': key, 'value': value}
-                item.setdefault('_store', store_name)
-                all_items.append(item)
-
-    if fmt == 'csv':
-        if not all_items:
-            output = ''
-        else:
-            # Collect all keys across items
-            fieldnames: list[str] = []
-            seen: set[str] = set()
-            for item in all_items:
-                for k in item:
-                    if k not in seen:
-                        fieldnames.append(k)
-                        seen.add(k)
-
-            buf = io.StringIO()
-            writer = csv.DictWriter(buf, fieldnames=fieldnames, extrasaction='ignore')
-            writer.writeheader()
-            for item in all_items:
-                # Serialize non-scalar values
-                row = {}
-                for k in fieldnames:
-                    v = item.get(k)
-                    if isinstance(v, (dict, list)):
-                        row[k] = json.dumps(v)
-                    else:
-                        row[k] = v
-                writer.writerow(row)
-            output = buf.getvalue()
-
-        response = Response(output, mimetype='text/csv')
-        response.headers['Content-Disposition'] = f'attachment; filename={mode}_export.csv'
-        return response
-
-    # Default: JSON
-    return jsonify({'status': 'success', 'mode': mode, 'count': len(all_items), 'data': all_items})
-
-
-# =========================================================================
-# Geofence CRUD
-# =========================================================================
-
-@analytics_bp.route('/geofences')
-def list_geofences():
-    return jsonify({
-        'status': 'success',
-        'zones': get_geofence_manager().list_zones(),
-    })
-
-
-@analytics_bp.route('/geofences', methods=['POST'])
-def create_geofence():
-    data = request.get_json() or {}
-    name = data.get('name')
-    lat = data.get('lat')
-    lon = data.get('lon')
-    radius_m = data.get('radius_m')
-
-    if not all([name, lat is not None, lon is not None, radius_m is not None]):
-        return jsonify({'status': 'error', 'message': 'name, lat, lon, radius_m are required'}), 400
-
-    try:
-        lat = float(lat)
-        lon = float(lon)
-        radius_m = float(radius_m)
-    except (TypeError, ValueError):
-        return jsonify({'status': 'error', 'message': 'lat, lon, radius_m must be numbers'}), 400
-
-    if not (-90 <= lat <= 90) or not (-180 <= lon <= 180):
-        return jsonify({'status': 'error', 'message': 'Invalid coordinates'}), 400
-    if radius_m <= 0:
-        return jsonify({'status': 'error', 'message': 'radius_m must be positive'}), 400
-
-    alert_on = data.get('alert_on', 'enter_exit')
-    zone_id = get_geofence_manager().add_zone(name, lat, lon, radius_m, alert_on)
-    return jsonify({'status': 'success', 'zone_id': zone_id})
-
-
-@analytics_bp.route('/geofences/<int:zone_id>', methods=['DELETE'])
-def delete_geofence(zone_id: int):
-    ok = get_geofence_manager().delete_zone(zone_id)
-    if not ok:
-        return jsonify({'status': 'error', 'message': 'Zone not found'}), 404
-    return jsonify({'status': 'success'})

routes/aprs.py

@@ -5,8 +5,10 @@ from __future__ import annotations
 import csv
 import json
 import os
+import pty
 import queue
 import re
+import select
 import shutil
 import subprocess
 import tempfile
@@ -14,7 +16,7 @@ import threading
 import time
 from datetime import datetime
 from subprocess import PIPE, STDOUT
-from typing import Generator, Optional
+from typing import Any, Generator, Optional
 
 from flask import Blueprint, jsonify, request, Response
 
@@ -35,6 +37,7 @@ aprs_bp = Blueprint('aprs', __name__, url_prefix='/aprs')
 
 # Track which SDR device is being used
 aprs_active_device: int | None = None
+aprs_active_sdr_type: str | None = None
 
 # APRS frequencies by region (MHz)
 APRS_FREQUENCIES = {
@@ -103,12 +106,35 @@ ADEVICE stdin null
 CHANNEL 0
 MYCALL N0CALL
 MODEM 1200
+FIX_BITS 1
+AGWPORT 0
+KISSPORT 0
 """
     with open(DIREWOLF_CONFIG_PATH, 'w') as f:
         f.write(config)
     return DIREWOLF_CONFIG_PATH
 
 
+def normalize_aprs_output_line(line: str) -> str:
+    """Normalize a decoder output line to raw APRS packet format.
+
+    Handles common decoder prefixes:
+    - multimon-ng: ``AFSK1200: ...``
+    - direwolf tags: ``[0.4] ...``, ``[0L] ...``, etc.
+    """
+    if not line:
+        return ''
+
+    normalized = line.strip()
+    if normalized.startswith('AFSK1200:'):
+        normalized = normalized[9:].strip()
+
+    # Strip one or more leading bracket tags emitted by decoders.
+    # Examples: [0.4], [0L], [NONE]
+    normalized = re.sub(r'^(?:\[[^\]]+\]\s*)+', '', normalized)
+    return normalized
+
+
 def parse_aprs_packet(raw_packet: str) -> Optional[dict]:
     """Parse APRS packet into structured data.
 
@@ -125,10 +151,15 @@ def parse_aprs_packet(raw_packet: str) -> Optional[dict]:
     - User-defined formats
     """
     try:
+        raw_packet = normalize_aprs_output_line(raw_packet)
+        if not raw_packet:
+            return None
+
         # Basic APRS packet format: CALLSIGN>PATH:DATA
         # Example: N0CALL-9>APRS,TCPIP*:@092345z4903.50N/07201.75W_090/000g005t077
 
-        match = re.match(r'^([A-Z0-9-]+)>([^:]+):(.+)$', raw_packet, re.IGNORECASE)
+        # Source callsigns can include tactical suffixes like "/1" on some stations.
+        match = re.match(r'^([A-Z0-9/\-]+)>([^:]+):(.+)$', raw_packet, re.IGNORECASE)
         if not match:
             return None
 
@@ -444,6 +475,109 @@ def parse_position(data: str) -> Optional[dict]:
 
             return result
 
+        # Legacy/no-decimal variant occasionally seen in degraded decodes:
+        # DDMMN/DDDMMW (symbol chars still present between/after coords).
+        nodot_match = re.match(
+            r'^(\d{2})(\d{2})([NS])(.)(\d{3})(\d{2})([EW])(.)?',
+            data
+        )
+        if nodot_match:
+            lat_deg = int(nodot_match.group(1))
+            lat_min = float(nodot_match.group(2))
+            lat_dir = nodot_match.group(3)
+            symbol_table = nodot_match.group(4)
+            lon_deg = int(nodot_match.group(5))
+            lon_min = float(nodot_match.group(6))
+            lon_dir = nodot_match.group(7)
+            symbol_code = nodot_match.group(8) or ''
+
+            lat = lat_deg + lat_min / 60.0
+            if lat_dir == 'S':
+                lat = -lat
+
+            lon = lon_deg + lon_min / 60.0
+            if lon_dir == 'W':
+                lon = -lon
+
+            result = {
+                'lat': round(lat, 6),
+                'lon': round(lon, 6),
+                'symbol': symbol_table + symbol_code,
+            }
+
+            remaining = data[13:] if len(data) > 13 else ''
+
+            cs_match = re.search(r'(\d{3})/(\d{3})', remaining)
+            if cs_match:
+                result['course'] = int(cs_match.group(1))
+                result['speed'] = int(cs_match.group(2))
+
+            alt_match = re.search(r'/A=(-?\d+)', remaining)
+            if alt_match:
+                result['altitude'] = int(alt_match.group(1))
+
+            return result
+
+        # Fallback: tolerate APRS ambiguity spaces in minute fields.
+        # Example: 4903.  N/07201.  W
+        if len(data) >= 18:
+            lat_field = data[0:7]
+            lat_dir = data[7]
+            symbol_table = data[8] if len(data) > 8 else ''
+            lon_field = data[9:17] if len(data) >= 17 else ''
+            lon_dir = data[17] if len(data) > 17 else ''
+            symbol_code = data[18] if len(data) > 18 else ''
+
+            if (
+                len(lat_field) == 7
+                and len(lon_field) == 8
+                and lat_dir in ('N', 'S')
+                and lon_dir in ('E', 'W')
+            ):
+                lat_deg_txt = lat_field[:2]
+                lat_min_txt = lat_field[2:].replace(' ', '0')
+                lon_deg_txt = lon_field[:3]
+                lon_min_txt = lon_field[3:].replace(' ', '0')
+
+                if (
+                    lat_deg_txt.isdigit()
+                    and lon_deg_txt.isdigit()
+                    and re.match(r'^\d{2}\.\d+$', lat_min_txt)
+                    and re.match(r'^\d{2}\.\d+$', lon_min_txt)
+                ):
+                    lat_deg = int(lat_deg_txt)
+                    lon_deg = int(lon_deg_txt)
+                    lat_min = float(lat_min_txt)
+                    lon_min = float(lon_min_txt)
+
+                    lat = lat_deg + lat_min / 60.0
+                    if lat_dir == 'S':
+                        lat = -lat
+
+                    lon = lon_deg + lon_min / 60.0
+                    if lon_dir == 'W':
+                        lon = -lon
+
+                    result = {
+                        'lat': round(lat, 6),
+                        'lon': round(lon, 6),
+                        'symbol': symbol_table + symbol_code,
+                    }
+
+                    # Keep same extension parsing behavior as primary branch.
+                    remaining = data[19:] if len(data) > 19 else ''
+
+                    cs_match = re.search(r'(\d{3})/(\d{3})', remaining)
+                    if cs_match:
+                        result['course'] = int(cs_match.group(1))
+                        result['speed'] = int(cs_match.group(2))
+
+                    alt_match = re.search(r'/A=(-?\d+)', remaining)
+                    if alt_match:
+                        result['altitude'] = int(alt_match.group(1))
+
+                    return result
+
     except Exception as e:
         logger.debug(f"Failed to parse position: {e}")
 
@@ -1309,19 +1443,23 @@ def should_send_meter_update(level: int) -> bool:
     return False
 
 
-def stream_aprs_output(rtl_process: subprocess.Popen, decoder_process: subprocess.Popen) -> None:
+def stream_aprs_output(master_fd: int, rtl_process: subprocess.Popen, decoder_process: subprocess.Popen) -> None:
     """Stream decoded APRS packets and audio level meter to queue.
 
-    This function reads from the decoder's stdout (text mode, line-buffered).
+    Reads from a PTY master fd to get line-buffered output from the decoder,
-    The decoder's stderr is merged into stdout (STDOUT) to avoid deadlocks.
+    avoiding the 15-minute pipe buffering delay. Uses select() + os.read()
-    rtl_fm's stderr is captured via PIPE with a monitor thread.
+    to poll the PTY (same pattern as pager.py).
 
     Outputs two types of messages to the queue:
     - type='aprs': Decoded APRS packets
     - type='meter': Audio level meter readings (rate-limited)
     """
     global aprs_packet_count, aprs_station_count, aprs_last_packet_time, aprs_stations
-    global _last_meter_time, _last_meter_level
+    global _last_meter_time, _last_meter_level, aprs_active_device, aprs_active_sdr_type
+
+    # Capture the device claimed by THIS session so the finally block only
+    # releases our own device, not one claimed by a subsequent start.
+    my_device = aprs_active_device
 
     # Reset meter state
     _last_meter_time = 0.0
@@ -1330,8 +1468,27 @@ def stream_aprs_output(rtl_process: subprocess.Popen, decoder_process: subproces
     try:
         app_module.aprs_queue.put({'type': 'status', 'status': 'started'})
 
-        # Read line-by-line in text mode. Empty string '' signals EOF.
+        # Read from PTY using select() for non-blocking reads.
-        for line in iter(decoder_process.stdout.readline, ''):
+        # PTY forces the decoder to line-buffer, so output arrives immediately
+        # instead of waiting for a full 4-8KB pipe buffer to fill.
+        buffer = ""
+        while True:
+            try:
+                ready, _, _ = select.select([master_fd], [], [], 1.0)
+            except Exception:
+                break
+
+            if ready:
+                try:
+                    data = os.read(master_fd, 1024)
+                    if not data:
+                        break
+                    buffer += data.decode('utf-8', errors='replace')
+                except OSError:
+                    break
+
+                while '\n' in buffer:
+                    line, buffer = buffer.split('\n', 1)
                     line = line.strip()
                     if not line:
                         continue
@@ -1348,13 +1505,8 @@ def stream_aprs_output(rtl_process: subprocess.Popen, decoder_process: subproces
                             app_module.aprs_queue.put(meter_msg)
                         continue  # Audio level lines are not packets
 
-            # multimon-ng prefixes decoded packets with "AFSK1200: "
+                    # Normalize decoder prefixes (multimon/direwolf) before parsing.
-            if line.startswith('AFSK1200:'):
+                    line = normalize_aprs_output_line(line)
-                line = line[9:].strip()
-
-            # direwolf often prefixes packets with "[0.4] " or similar audio level indicator
-            # Strip any leading bracket prefix like "[0.4] " before parsing
-            line = re.sub(r'^\[\d+\.\d+\]\s*', '', line)
 
                     # Skip non-packet lines (APRS format: CALL>PATH:DATA)
                     if '>' not in line or ':' not in line:
@@ -1370,20 +1522,24 @@ def stream_aprs_output(rtl_process: subprocess.Popen, decoder_process: subproces
                         if callsign and callsign not in aprs_stations:
                             aprs_station_count += 1
 
-                # Update station data
+                        # Update station data, preserving last known coordinates when
+                        # packets do not contain position fields.
                         if callsign:
+                            existing = aprs_stations.get(callsign, {})
+                            packet_lat = packet.get('lat')
+                            packet_lon = packet.get('lon')
                             aprs_stations[callsign] = {
                                 'callsign': callsign,
-                        'lat': packet.get('lat'),
+                                'lat': packet_lat if packet_lat is not None else existing.get('lat'),
-                        'lon': packet.get('lon'),
+                                'lon': packet_lon if packet_lon is not None else existing.get('lon'),
-                        'symbol': packet.get('symbol'),
+                                'symbol': packet.get('symbol') or existing.get('symbol'),
                                 'last_seen': packet.get('timestamp'),
                                 'packet_type': packet.get('packet_type'),
                             }
                             # Geofence check
-                    _aprs_lat = packet.get('lat')
+                            _aprs_lat = packet_lat
-                    _aprs_lon = packet.get('lon')
+                            _aprs_lon = packet_lon
-                    if _aprs_lat and _aprs_lon:
+                            if _aprs_lat is not None and _aprs_lon is not None:
                                 try:
                                     from utils.geofence import get_geofence_manager
                                     for _gf_evt in get_geofence_manager().check_position(
@@ -1416,7 +1572,10 @@ def stream_aprs_output(rtl_process: subprocess.Popen, decoder_process: subproces
         logger.error(f"APRS stream error: {e}")
         app_module.aprs_queue.put({'type': 'error', 'message': str(e)})
     finally:
-        global aprs_active_device
+        try:
+            os.close(master_fd)
+        except OSError:
+            pass
         app_module.aprs_queue.put({'type': 'status', 'status': 'stopped'})
         # Cleanup processes
         for proc in [rtl_process, decoder_process]:
@@ -1428,10 +1587,11 @@ def stream_aprs_output(rtl_process: subprocess.Popen, decoder_process: subproces
                     proc.kill()
                 except Exception:
                     pass
-        # Release SDR device
+        # Release SDR device — only if it's still ours (not reclaimed by a new start)
-        if aprs_active_device is not None:
+        if my_device is not None and aprs_active_device == my_device:
-            app_module.release_sdr_device(aprs_active_device)
+            app_module.release_sdr_device(my_device, aprs_active_sdr_type or 'rtlsdr')
             aprs_active_device = None
+            aprs_active_sdr_type = None
 
 
 @aprs_bp.route('/tools')
@@ -1478,11 +1638,29 @@ def get_stations() -> Response:
     })
 
 
+@aprs_bp.route('/data')
+def aprs_data() -> Response:
+    """Get APRS data snapshot for remote controller polling compatibility."""
+    running = False
+    if app_module.aprs_process:
+        running = app_module.aprs_process.poll() is None
+
+    return jsonify({
+        'status': 'success',
+        'running': running,
+        'stations': list(aprs_stations.values()),
+        'count': len(aprs_stations),
+        'packet_count': aprs_packet_count,
+        'station_count': aprs_station_count,
+        'last_packet_time': aprs_last_packet_time,
+    })
+
+
 @aprs_bp.route('/start', methods=['POST'])
 def start_aprs() -> Response:
     """Start APRS decoder."""
     global aprs_packet_count, aprs_station_count, aprs_last_packet_time, aprs_stations
-    global aprs_active_device
+    global aprs_active_device, aprs_active_sdr_type
 
     with app_module.aprs_lock:
         if app_module.aprs_process and app_module.aprs_process.poll() is None:
@@ -1531,7 +1709,7 @@ def start_aprs() -> Response:
             }), 400
 
     # Reserve SDR device to prevent conflicts with other modes
-    error = app_module.claim_sdr_device(device, 'aprs')
+    error = app_module.claim_sdr_device(device, 'aprs', sdr_type_str)
     if error:
         return jsonify({
             'status': 'error',
@@ -1539,6 +1717,7 @@ def start_aprs() -> Response:
             'message': error
         }), 409
     aprs_active_device = device
+    aprs_active_sdr_type = sdr_type_str
 
     # Get frequency for region
     region = data.get('region', 'north_america')
@@ -1580,8 +1759,9 @@ def start_aprs() -> Response:
             rtl_cmd = rtl_cmd[:-1] + ['-E', 'dc', '-A', 'fast', '-']
     except Exception as e:
         if aprs_active_device is not None:
-            app_module.release_sdr_device(aprs_active_device)
+            app_module.release_sdr_device(aprs_active_device, aprs_active_sdr_type or 'rtlsdr')
             aprs_active_device = None
+            aprs_active_sdr_type = None
         return jsonify({'status': 'error', 'message': f'Failed to build SDR command: {e}'}), 500
 
     # Build decoder command
@@ -1635,19 +1815,25 @@ def start_aprs() -> Response:
         rtl_stderr_thread = threading.Thread(target=monitor_rtl_stderr, daemon=True)
         rtl_stderr_thread.start()
 
+        # Create a pseudo-terminal for decoder output.  PTY forces the
+        # decoder to line-buffer its stdout, avoiding the 15-minute delay
+        # caused by full pipe buffering (~4-8KB) on small APRS packets.
+        master_fd, slave_fd = pty.openpty()
+
         # Start decoder with stdin wired to rtl_fm's stdout.
-        # Use text mode with line buffering for reliable line-by-line reading.
+        # stdout/stderr go to the PTY slave so output is line-buffered.
-        # Merge stderr into stdout to avoid blocking on unbuffered stderr.
         decoder_process = subprocess.Popen(
             decoder_cmd,
             stdin=rtl_process.stdout,
-            stdout=PIPE,
+            stdout=slave_fd,
-            stderr=STDOUT,
+            stderr=slave_fd,
-            text=True,
+            close_fds=True,
-            bufsize=1,
             start_new_session=True
         )
 
+        # Close slave fd in parent — decoder owns it now.
+        os.close(slave_fd)
+
         # Close rtl_fm's stdout in parent so decoder owns it exclusively.
         # This ensures proper EOF propagation when rtl_fm terminates.
         rtl_process.stdout.close()
@@ -1668,39 +1854,57 @@ def start_aprs() -> Response:
             if stderr_output:
                 error_msg += f': {stderr_output[:200]}'
             logger.error(error_msg)
+            try:
+                os.close(master_fd)
+            except OSError:
+                pass
             try:
                 decoder_process.kill()
             except Exception:
                 pass
             if aprs_active_device is not None:
-                app_module.release_sdr_device(aprs_active_device)
+                app_module.release_sdr_device(aprs_active_device, aprs_active_sdr_type or 'rtlsdr')
                 aprs_active_device = None
+                aprs_active_sdr_type = None
             return jsonify({'status': 'error', 'message': error_msg}), 500
 
         if decoder_process.poll() is not None:
-            # Decoder exited early - capture any output
+            # Decoder exited early - capture any output from PTY
-            error_output = decoder_process.stdout.read()[:500] if decoder_process.stdout else ''
+            error_output = ''
+            try:
+                ready, _, _ = select.select([master_fd], [], [], 0.5)
+                if ready:
+                    raw = os.read(master_fd, 500)
+                    error_output = raw.decode('utf-8', errors='replace')
+            except Exception:
+                pass
             error_msg = f'{decoder_name} failed to start'
             if error_output:
                 error_msg += f': {error_output}'
             logger.error(error_msg)
+            try:
+                os.close(master_fd)
+            except OSError:
+                pass
             try:
                 rtl_process.kill()
             except Exception:
                 pass
             if aprs_active_device is not None:
-                app_module.release_sdr_device(aprs_active_device)
+                app_module.release_sdr_device(aprs_active_device, aprs_active_sdr_type or 'rtlsdr')
                 aprs_active_device = None
+                aprs_active_sdr_type = None
             return jsonify({'status': 'error', 'message': error_msg}), 500
 
         # Store references for status checks and cleanup
         app_module.aprs_process = decoder_process
         app_module.aprs_rtl_process = rtl_process
+        app_module.aprs_master_fd = master_fd
 
         # Start background thread to read decoder output and push to queue
         thread = threading.Thread(
             target=stream_aprs_output,
-            args=(rtl_process, decoder_process),
+            args=(master_fd, rtl_process, decoder_process),
             daemon=True
         )
         thread.start()
@@ -1717,15 +1921,16 @@ def start_aprs() -> Response:
     except Exception as e:
         logger.error(f"Failed to start APRS decoder: {e}")
         if aprs_active_device is not None:
-            app_module.release_sdr_device(aprs_active_device)
+            app_module.release_sdr_device(aprs_active_device, aprs_active_sdr_type or 'rtlsdr')
             aprs_active_device = None
+            aprs_active_sdr_type = None
         return jsonify({'status': 'error', 'message': str(e)}), 500
 
 
 @aprs_bp.route('/stop', methods=['POST'])
 def stop_aprs() -> Response:
     """Stop APRS decoder."""
-    global aprs_active_device
+    global aprs_active_device, aprs_active_sdr_type
 
     with app_module.aprs_lock:
         processes_to_stop = []
@@ -1751,14 +1956,23 @@ def stop_aprs() -> Response:
             except Exception as e:
                 logger.error(f"Error stopping APRS process: {e}")
 
+        # Close PTY master fd
+        if hasattr(app_module, 'aprs_master_fd') and app_module.aprs_master_fd is not None:
+            try:
+                os.close(app_module.aprs_master_fd)
+            except OSError:
+                pass
+            app_module.aprs_master_fd = None
+
         app_module.aprs_process = None
         if hasattr(app_module, 'aprs_rtl_process'):
             app_module.aprs_rtl_process = None
 
         # Release SDR device
         if aprs_active_device is not None:
-            app_module.release_sdr_device(aprs_active_device)
+            app_module.release_sdr_device(aprs_active_device, aprs_active_sdr_type or 'rtlsdr')
             aprs_active_device = None
+            aprs_active_sdr_type = None
 
     return jsonify({'status': 'stopped'})
 

routes/bt_locate.py

@@ -109,9 +109,22 @@ def start_session():
         f"env={environment.name}, fallback=({fallback_lat}, {fallback_lon})"
     )
 
+    try:
         session = start_locate_session(
             target, environment, custom_exponent, fallback_lat, fallback_lon
         )
+    except RuntimeError as exc:
+        logger.warning(f"Unable to start BT Locate session: {exc}")
+        return jsonify({
+            'status': 'error',
+            'error': 'Bluetooth scanner could not be started. Check adapter permissions/capabilities.',
+        }), 503
+    except Exception as exc:
+        logger.exception(f"Unexpected error starting BT Locate session: {exc}")
+        return jsonify({
+            'status': 'error',
+            'error': 'Failed to start locate session',
+        }), 500
 
     return jsonify({
         'status': 'started',
@@ -140,7 +153,8 @@ def get_status():
             'target': None,
         })
 
-    return jsonify(session.get_status())
+    include_debug = str(request.args.get('debug', '')).lower() in ('1', 'true', 'yes')
+    return jsonify(session.get_status(include_debug=include_debug))
 
 
 @bt_locate_bp.route('/trail', methods=['GET'])

routes/dmr.py

@@ -1,753 +0,0 @@
-"""DMR / P25 / Digital Voice decoding routes."""
-
-from __future__ import annotations
-
-import os
-import queue
-import re
-import select
-import shutil
-import subprocess
-import threading
-import time
-from datetime import datetime
-from typing import Generator, Optional
-
-from flask import Blueprint, jsonify, request, Response
-
-import app as app_module
-from utils.logging import get_logger
-from utils.sse import sse_stream_fanout
-from utils.event_pipeline import process_event
-from utils.process import register_process, unregister_process
-from utils.validation import validate_frequency, validate_gain, validate_device_index, validate_ppm
-from utils.sdr import SDRFactory, SDRType
-from utils.constants import (
-    SSE_QUEUE_TIMEOUT,
-    SSE_KEEPALIVE_INTERVAL,
-    QUEUE_MAX_SIZE,
-)
-
-logger = get_logger('intercept.dmr')
-
-dmr_bp = Blueprint('dmr', __name__, url_prefix='/dmr')
-
-# ============================================
-# GLOBAL STATE
-# ============================================
-
-dmr_rtl_process: Optional[subprocess.Popen] = None
-dmr_dsd_process: Optional[subprocess.Popen] = None
-dmr_thread: Optional[threading.Thread] = None
-dmr_running = False
-dmr_has_audio = False  # True when ffmpeg available and dsd outputs audio
-dmr_lock = threading.Lock()
-dmr_queue: queue.Queue = queue.Queue(maxsize=QUEUE_MAX_SIZE)
-dmr_active_device: Optional[int] = None
-
-# Audio mux: the sole reader of dsd-fme stdout.  Fans out bytes to all
-# active ffmpeg stdin sinks when streaming clients are connected.
-# This prevents dsd-fme from blocking on stdout (which would also
-# freeze stderr / text data output).
-_ffmpeg_sinks: set[object] = set()
-_ffmpeg_sinks_lock = threading.Lock()
-
-VALID_PROTOCOLS = ['auto', 'dmr', 'p25', 'nxdn', 'dstar', 'provoice']
-
-# Classic dsd flags
-_DSD_PROTOCOL_FLAGS = {
-    'auto': [],
-    'dmr': ['-fd'],
-    'p25': ['-fp'],
-    'nxdn': ['-fn'],
-    'dstar': ['-fi'],
-    'provoice': ['-fv'],
-}
-
-# dsd-fme remapped several flags from classic DSD:
-#   -fs = DMR Simplex (NOT -fd which is D-STAR!),
-#   -fd = D-STAR (NOT DMR!), -fp = ProVoice (NOT P25),
-#   -fi = NXDN48 (NOT D-Star), -f1 = P25 Phase 1,
-#   -ft = XDMA multi-protocol decoder
-_DSD_FME_PROTOCOL_FLAGS = {
-    'auto': ['-fa'],       # Broad auto: P25 (P1/P2), DMR, D-STAR, YSF, X2-TDMA
-    'dmr': ['-fs'],        # DMR Simplex (-fd is D-STAR in dsd-fme!)
-    'p25': ['-ft'],        # P25 P1/P2 coverage (also includes DMR in dsd-fme)
-    'nxdn': ['-fn'],       # NXDN96
-    'dstar': ['-fd'],      # D-STAR (-fd in dsd-fme, NOT DMR!)
-    'provoice': ['-fp'],   # ProVoice (-fp in dsd-fme, not -fv)
-}
-
-# Modulation hints: force C4FM for protocols that use it, improving
-# sync reliability vs letting dsd-fme auto-detect modulation type.
-_DSD_FME_MODULATION = {
-    'dmr': ['-mc'],        # C4FM
-    'nxdn': ['-mc'],       # C4FM
-}
-
-# ============================================
-# HELPERS
-# ============================================
-
-
-def find_dsd() -> tuple[str | None, bool]:
-    """Find DSD (Digital Speech Decoder) binary.
-
-    Checks for dsd-fme first (common fork), then falls back to dsd.
-    Returns (path, is_fme) tuple.
-    """
-    path = shutil.which('dsd-fme')
-    if path:
-        return path, True
-    path = shutil.which('dsd')
-    if path:
-        return path, False
-    return None, False
-
-
-def find_rtl_fm() -> str | None:
-    """Find rtl_fm binary."""
-    return shutil.which('rtl_fm')
-
-
-def find_rx_fm() -> str | None:
-    """Find SoapySDR rx_fm binary."""
-    return shutil.which('rx_fm')
-
-
-def find_ffmpeg() -> str | None:
-    """Find ffmpeg for audio encoding."""
-    return shutil.which('ffmpeg')
-
-
-def parse_dsd_output(line: str) -> dict | None:
-    """Parse a line of DSD stderr output into a structured event.
-
-    Handles output from both classic ``dsd`` and ``dsd-fme`` which use
-    different formatting for talkgroup / source / voice frame lines.
-    """
-    line = line.strip()
-    if not line:
-        return None
-
-    # Skip DSD/dsd-fme startup banner lines (ASCII art, version info, etc.)
-    # Only filter lines that are purely decorative — dsd-fme uses box-drawing
-    # characters (│, ─) as column separators in DATA lines, so we must not
-    # discard lines that also contain alphanumeric content.
-    stripped_of_box = re.sub(r'[╔╗╚╝║═██▀▄╗╝╩╦╠╣╬│┤├┘└┐┌─┼█▓▒░\s]', '', line)
-    if not stripped_of_box:
-        return None
-    if re.match(r'^\s*(Build Version|MBElib|CODEC2|Audio (Out|In)|Decoding )', line):
-        return None
-
-    ts = datetime.now().strftime('%H:%M:%S')
-
-    # Sync detection: "Sync: +DMR (data)" or "Sync: +P25 Phase 1"
-    sync_match = re.match(r'Sync:\s*\+?(\S+.*)', line)
-    if sync_match:
-        return {
-            'type': 'sync',
-            'protocol': sync_match.group(1).strip(),
-            'timestamp': ts,
-        }
-
-    # Talkgroup and Source — check BEFORE slot so "Slot 1 Voice LC, TG: …"
-    # is captured as a call event rather than a bare slot event.
-    # Classic dsd:   "TG: 12345  Src: 67890"
-    # dsd-fme:       "TG: 12345, Src: 67890"  or  "Talkgroup: 12345, Source: 67890"
-    #                "TGT: 12345 | SRC: 67890" (pipe-delimited variant)
-    tg_match = re.search(
-        r'(?:TGT?|Talkgroup)[:\s]+(\d+)[,|│\s]+(?:Src|Source|SRC)[:\s]+(\d+)', line, re.IGNORECASE
-    )
-    if tg_match:
-        result = {
-            'type': 'call',
-            'talkgroup': int(tg_match.group(1)),
-            'source_id': int(tg_match.group(2)),
-            'timestamp': ts,
-        }
-        # Extract slot if present on the same line
-        slot_inline = re.search(r'Slot\s*(\d+)', line)
-        if slot_inline:
-            result['slot'] = int(slot_inline.group(1))
-        return result
-
-    # P25 NAC (Network Access Code) — check before voice/slot
-    nac_match = re.search(r'NAC[:\s]+([0-9A-Fa-f]+)', line)
-    if nac_match:
-        return {
-            'type': 'nac',
-            'nac': nac_match.group(1),
-            'timestamp': ts,
-        }
-
-    # Voice frame detection — check BEFORE bare slot match
-    # Classic dsd: "Voice" keyword in frame lines
-    # dsd-fme: "voice" or "Voice LC" or "VOICE" in output
-    if re.search(r'\bvoice\b', line, re.IGNORECASE):
-        result = {
-            'type': 'voice',
-            'detail': line,
-            'timestamp': ts,
-        }
-        slot_inline = re.search(r'Slot\s*(\d+)', line)
-        if slot_inline:
-            result['slot'] = int(slot_inline.group(1))
-        return result
-
-    # Bare slot info (only when line is *just* slot info, not voice/call)
-    slot_match = re.match(r'\s*Slot\s*(\d+)\s*$', line)
-    if slot_match:
-        return {
-            'type': 'slot',
-            'slot': int(slot_match.group(1)),
-            'timestamp': ts,
-        }
-
-    # dsd-fme status lines we can surface: "TDMA", "CACH", "PI", "BS", etc.
-    # Also catches "Closing", "Input", and other lifecycle lines.
-    # Forward as raw so the frontend can show decoder is alive.
-    return {
-        'type': 'raw',
-        'text': line[:200],
-        'timestamp': ts,
-    }
-
-
-_HEARTBEAT_INTERVAL = 3.0  # seconds between heartbeats when decoder is idle
-
-# 100ms of silence at 8kHz 16-bit mono = 1600 bytes
-_SILENCE_CHUNK = b'\x00' * 1600
-
-
-def _register_audio_sink(sink: object) -> None:
-    """Register an ffmpeg stdin sink for mux fanout."""
-    with _ffmpeg_sinks_lock:
-        _ffmpeg_sinks.add(sink)
-
-
-def _unregister_audio_sink(sink: object) -> None:
-    """Remove an ffmpeg stdin sink from mux fanout."""
-    with _ffmpeg_sinks_lock:
-        _ffmpeg_sinks.discard(sink)
-
-
-def _get_audio_sinks() -> tuple[object, ...]:
-    """Snapshot current audio sinks for lock-free iteration."""
-    with _ffmpeg_sinks_lock:
-        return tuple(_ffmpeg_sinks)
-
-
-def _stop_process(proc: Optional[subprocess.Popen]) -> None:
-    """Terminate and unregister a subprocess if present."""
-    if not proc:
-        return
-    if proc.poll() is None:
-        try:
-            proc.terminate()
-            proc.wait(timeout=2)
-        except Exception:
-            try:
-                proc.kill()
-            except Exception:
-                pass
-    unregister_process(proc)
-
-
-def _reset_runtime_state(*, release_device: bool) -> None:
-    """Reset process + runtime state and optionally release SDR ownership."""
-    global dmr_rtl_process, dmr_dsd_process
-    global dmr_running, dmr_has_audio, dmr_active_device
-
-    _stop_process(dmr_dsd_process)
-    _stop_process(dmr_rtl_process)
-    dmr_rtl_process = None
-    dmr_dsd_process = None
-    dmr_running = False
-    dmr_has_audio = False
-    with _ffmpeg_sinks_lock:
-        _ffmpeg_sinks.clear()
-
-    if release_device and dmr_active_device is not None:
-        app_module.release_sdr_device(dmr_active_device)
-        dmr_active_device = None
-
-
-def _dsd_audio_mux(dsd_stdout):
-    """Mux thread: sole reader of dsd-fme stdout.
-
-    Always drains dsd-fme's audio output to prevent the process from
-    blocking on stdout writes (which would also freeze stderr / text
-    data). When streaming clients are connected, forwards data to all
-    active ffmpeg stdin sinks with silence fill during voice gaps.
-    """
-    try:
-        while dmr_running:
-            ready, _, _ = select.select([dsd_stdout], [], [], 0.1)
-            if ready:
-                data = os.read(dsd_stdout.fileno(), 4096)
-                if not data:
-                    break
-                sinks = _get_audio_sinks()
-                for sink in sinks:
-                    try:
-                        sink.write(data)
-                        sink.flush()
-                    except (BrokenPipeError, OSError, ValueError):
-                        _unregister_audio_sink(sink)
-            else:
-                # No audio from decoder — feed silence if client connected
-                sinks = _get_audio_sinks()
-                for sink in sinks:
-                    try:
-                        sink.write(_SILENCE_CHUNK)
-                        sink.flush()
-                    except (BrokenPipeError, OSError, ValueError):
-                        _unregister_audio_sink(sink)
-    except (OSError, ValueError):
-        pass
-
-
-def _queue_put(event: dict):
-    """Put an event on the DMR queue, dropping oldest if full."""
-    try:
-        dmr_queue.put_nowait(event)
-    except queue.Full:
-        try:
-            dmr_queue.get_nowait()
-        except queue.Empty:
-            pass
-        try:
-            dmr_queue.put_nowait(event)
-        except queue.Full:
-            pass
-
-
-def stream_dsd_output(rtl_process: subprocess.Popen, dsd_process: subprocess.Popen):
-    """Read DSD stderr output and push parsed events to the queue.
-
-    Uses select() with a timeout so we can send periodic heartbeat
-    events while readline() would otherwise block indefinitely during
-    silence (no signal being decoded).
-    """
-    global dmr_running
-
-    try:
-        _queue_put({'type': 'status', 'text': 'started'})
-        last_heartbeat = time.time()
-
-        while dmr_running:
-            if dsd_process.poll() is not None:
-                break
-
-            # Wait up to 1s for data on stderr instead of blocking forever
-            ready, _, _ = select.select([dsd_process.stderr], [], [], 1.0)
-
-            if ready:
-                line = dsd_process.stderr.readline()
-                if not line:
-                    if dsd_process.poll() is not None:
-                        break
-                    continue
-
-                text = line.decode('utf-8', errors='replace').strip()
-                if not text:
-                    continue
-
-                logger.debug("DSD raw: %s", text)
-                parsed = parse_dsd_output(text)
-                if parsed:
-                    _queue_put(parsed)
-                last_heartbeat = time.time()
-            else:
-                # No stderr output — send heartbeat so frontend knows
-                # decoder is still alive and listening
-                now = time.time()
-                if now - last_heartbeat >= _HEARTBEAT_INTERVAL:
-                    _queue_put({
-                        'type': 'heartbeat',
-                        'timestamp': datetime.now().strftime('%H:%M:%S'),
-                    })
-                    last_heartbeat = now
-
-    except Exception as e:
-        logger.error(f"DSD stream error: {e}")
-    finally:
-        global dmr_active_device, dmr_rtl_process, dmr_dsd_process
-        global dmr_has_audio
-        dmr_running = False
-        dmr_has_audio = False
-        with _ffmpeg_sinks_lock:
-            _ffmpeg_sinks.clear()
-        # Capture exit info for diagnostics
-        rc = dsd_process.poll()
-        reason = 'stopped'
-        detail = ''
-        if rc is not None and rc != 0:
-            reason = 'crashed'
-            try:
-                remaining = dsd_process.stderr.read(1024)
-                if remaining:
-                    detail = remaining.decode('utf-8', errors='replace').strip()[:200]
-            except Exception:
-                pass
-            logger.warning(f"DSD process exited with code {rc}: {detail}")
-        # Cleanup decoder + demod processes
-        _stop_process(dsd_process)
-        _stop_process(rtl_process)
-        dmr_rtl_process = None
-        dmr_dsd_process = None
-        _queue_put({'type': 'status', 'text': reason, 'exit_code': rc, 'detail': detail})
-        # Release SDR device
-        if dmr_active_device is not None:
-            app_module.release_sdr_device(dmr_active_device)
-            dmr_active_device = None
-        logger.info("DSD stream thread stopped")
-
-
-# ============================================
-# API ENDPOINTS
-# ============================================
-
-@dmr_bp.route('/tools')
-def check_tools() -> Response:
-    """Check for required tools."""
-    dsd_path, _ = find_dsd()
-    rtl_fm = find_rtl_fm()
-    rx_fm = find_rx_fm()
-    ffmpeg = find_ffmpeg()
-    return jsonify({
-        'dsd': dsd_path is not None,
-        'rtl_fm': rtl_fm is not None,
-        'rx_fm': rx_fm is not None,
-        'ffmpeg': ffmpeg is not None,
-        'available': dsd_path is not None and (rtl_fm is not None or rx_fm is not None),
-        'protocols': VALID_PROTOCOLS,
-    })
-
-
-@dmr_bp.route('/start', methods=['POST'])
-def start_dmr() -> Response:
-    """Start digital voice decoding."""
-    global dmr_rtl_process, dmr_dsd_process, dmr_thread
-    global dmr_running, dmr_has_audio, dmr_active_device
-
-    dsd_path, is_fme = find_dsd()
-    if not dsd_path:
-        return jsonify({'status': 'error', 'message': 'dsd not found. Install dsd-fme or dsd.'}), 503
-
-    data = request.json or {}
-
-    try:
-        frequency = validate_frequency(data.get('frequency', 462.5625))
-        gain = int(validate_gain(data.get('gain', 40)))
-        device = validate_device_index(data.get('device', 0))
-        protocol = str(data.get('protocol', 'auto')).lower()
-        ppm = validate_ppm(data.get('ppm', 0))
-    except (ValueError, TypeError) as e:
-        return jsonify({'status': 'error', 'message': f'Invalid parameter: {e}'}), 400
-
-    sdr_type_str = str(data.get('sdr_type', 'rtlsdr')).lower()
-    try:
-        sdr_type = SDRType(sdr_type_str)
-    except ValueError:
-        sdr_type = SDRType.RTL_SDR
-
-    if protocol not in VALID_PROTOCOLS:
-        return jsonify({'status': 'error', 'message': f'Invalid protocol. Use: {", ".join(VALID_PROTOCOLS)}'}), 400
-
-    if sdr_type == SDRType.RTL_SDR:
-        if not find_rtl_fm():
-            return jsonify({'status': 'error', 'message': 'rtl_fm not found. Install rtl-sdr tools.'}), 503
-    else:
-        if not find_rx_fm():
-            return jsonify({
-                'status': 'error',
-                'message': f'rx_fm not found. Install SoapySDR tools for {sdr_type.value}.'
-            }), 503
-
-    # Clear stale queue
-    try:
-        while True:
-            dmr_queue.get_nowait()
-    except queue.Empty:
-        pass
-
-    # Reserve running state before we start claiming resources/processes
-    # so concurrent /start requests cannot race each other.
-    with dmr_lock:
-        if dmr_running:
-            return jsonify({'status': 'error', 'message': 'Already running'}), 409
-        dmr_running = True
-        dmr_has_audio = False
-
-    # Claim SDR device — use protocol name so the device panel shows
-    # "D-STAR", "P25", etc. instead of always "DMR"
-    mode_label = protocol.upper() if protocol != 'auto' else 'DMR'
-    error = app_module.claim_sdr_device(device, mode_label)
-    if error:
-        with dmr_lock:
-            dmr_running = False
-        return jsonify({'status': 'error', 'error_type': 'DEVICE_BUSY', 'message': error}), 409
-
-    dmr_active_device = device
-
-    # Build FM demodulation command via SDR abstraction.
-    try:
-        sdr_device = SDRFactory.create_default_device(sdr_type, index=device)
-        builder = SDRFactory.get_builder(sdr_type)
-        rtl_cmd = builder.build_fm_demod_command(
-            device=sdr_device,
-            frequency_mhz=frequency,
-            sample_rate=48000,
-            gain=float(gain) if gain > 0 else None,
-            ppm=int(ppm) if ppm != 0 else None,
-            modulation='fm',
-            squelch=None,
-            bias_t=bool(data.get('bias_t', False)),
-        )
-        if sdr_type == SDRType.RTL_SDR:
-            # Keep squelch fully open for digital bitstreams.
-            rtl_cmd.extend(['-l', '0'])
-    except Exception as e:
-        _reset_runtime_state(release_device=True)
-        return jsonify({'status': 'error', 'message': f'Failed to build SDR command: {e}'}), 500
-
-    # Build DSD command
-    # Audio output: pipe decoded audio (8kHz s16le PCM) to stdout for
-    # ffmpeg transcoding.  Both dsd-fme and classic dsd support '-o -'.
-    # If ffmpeg is unavailable, fall back to discarding audio.
-    ffmpeg_path = find_ffmpeg()
-    if ffmpeg_path:
-        audio_out = '-'
-    else:
-        audio_out = 'null' if is_fme else '-'
-        logger.warning("ffmpeg not found — audio streaming disabled, data-only mode")
-    dsd_cmd = [dsd_path, '-i', '-', '-o', audio_out]
-    if is_fme:
-        dsd_cmd.extend(_DSD_FME_PROTOCOL_FLAGS.get(protocol, []))
-        dsd_cmd.extend(_DSD_FME_MODULATION.get(protocol, []))
-        # Event log to stderr so we capture TG/Source/Voice data that
-        # dsd-fme may not output on stderr by default.
-        dsd_cmd.extend(['-J', '/dev/stderr'])
-        # Relax CRC checks for marginal signals — lets more frames
-        # through at the cost of occasional decode errors.
-        if data.get('relaxCrc', False):
-            dsd_cmd.append('-F')
-    else:
-        dsd_cmd.extend(_DSD_PROTOCOL_FLAGS.get(protocol, []))
-
-    try:
-        dmr_rtl_process = subprocess.Popen(
-            rtl_cmd,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-        )
-        register_process(dmr_rtl_process)
-
-        # DSD stdout → PIPE when ffmpeg available (audio pipeline),
-        # otherwise DEVNULL (data-only mode)
-        dsd_stdout = subprocess.PIPE if ffmpeg_path else subprocess.DEVNULL
-        dmr_dsd_process = subprocess.Popen(
-            dsd_cmd,
-            stdin=dmr_rtl_process.stdout,
-            stdout=dsd_stdout,
-            stderr=subprocess.PIPE,
-        )
-        register_process(dmr_dsd_process)
-
-        # Allow rtl_fm to send directly to dsd
-        dmr_rtl_process.stdout.close()
-
-        # Start mux thread: always drains dsd-fme stdout to prevent the
-        # process from blocking (which would freeze stderr / text data).
-        # ffmpeg is started lazily per-client in /dmr/audio/stream.
-        if ffmpeg_path and dmr_dsd_process.stdout:
-            dmr_has_audio = True
-            threading.Thread(
-                target=_dsd_audio_mux,
-                args=(dmr_dsd_process.stdout,),
-                daemon=True,
-            ).start()
-
-        time.sleep(0.3)
-
-        rtl_rc = dmr_rtl_process.poll()
-        dsd_rc = dmr_dsd_process.poll()
-        if rtl_rc is not None or dsd_rc is not None:
-            # Process died — capture stderr for diagnostics
-            rtl_err = ''
-            if dmr_rtl_process.stderr:
-                rtl_err = dmr_rtl_process.stderr.read().decode('utf-8', errors='replace')[:500]
-            dsd_err = ''
-            if dmr_dsd_process.stderr:
-                dsd_err = dmr_dsd_process.stderr.read().decode('utf-8', errors='replace')[:500]
-            logger.error(f"DSD pipeline died: rtl_fm rc={rtl_rc} err={rtl_err!r}, dsd rc={dsd_rc} err={dsd_err!r}")
-            # Terminate surviving processes and release resources.
-            _reset_runtime_state(release_device=True)
-            # Surface a clear error to the user
-            detail = rtl_err.strip() or dsd_err.strip()
-            if 'usb_claim_interface' in rtl_err or 'Failed to open' in rtl_err:
-                msg = f'SDR device {device} is busy — it may be in use by another mode or process. Try a different device.'
-            elif detail:
-                msg = f'Failed to start DSD pipeline: {detail}'
-            else:
-                msg = 'Failed to start DSD pipeline'
-            return jsonify({'status': 'error', 'message': msg}), 500
-
-        # Drain rtl_fm stderr in background to prevent pipe blocking
-        def _drain_rtl_stderr(proc):
-            try:
-                for line in proc.stderr:
-                    pass
-            except Exception:
-                pass
-
-        threading.Thread(target=_drain_rtl_stderr, args=(dmr_rtl_process,), daemon=True).start()
-
-        dmr_thread = threading.Thread(
-            target=stream_dsd_output,
-            args=(dmr_rtl_process, dmr_dsd_process),
-            daemon=True,
-        )
-        dmr_thread.start()
-
-        return jsonify({
-            'status': 'started',
-            'frequency': frequency,
-            'protocol': protocol,
-            'sdr_type': sdr_type.value,
-            'has_audio': dmr_has_audio,
-        })
-
-    except Exception as e:
-        logger.error(f"Failed to start DMR: {e}")
-        _reset_runtime_state(release_device=True)
-        return jsonify({'status': 'error', 'message': str(e)}), 500
-
-
-@dmr_bp.route('/stop', methods=['POST'])
-def stop_dmr() -> Response:
-    """Stop digital voice decoding."""
-    with dmr_lock:
-        _reset_runtime_state(release_device=True)
-
-    return jsonify({'status': 'stopped'})
-
-
-@dmr_bp.route('/status')
-def dmr_status() -> Response:
-    """Get DMR decoder status."""
-    return jsonify({
-        'running': dmr_running,
-        'device': dmr_active_device,
-        'has_audio': dmr_has_audio,
-    })
-
-
-@dmr_bp.route('/audio/stream')
-def stream_dmr_audio() -> Response:
-    """Stream decoded digital voice audio as WAV.
-
-    Starts a per-client ffmpeg encoder.  The global mux thread
-    (_dsd_audio_mux) forwards DSD audio to this ffmpeg's stdin while
-    the client is connected, and discards audio otherwise.  This avoids
-    the pipe-buffer deadlock that occurs when ffmpeg is started at
-    decoder launch (its stdout fills up before any HTTP client reads
-    it, back-pressuring the entire pipeline and freezing stderr/text
-    data output).
-    """
-    if not dmr_running or not dmr_has_audio:
-        return Response(b'', mimetype='audio/wav', status=204)
-
-    ffmpeg_path = find_ffmpeg()
-    if not ffmpeg_path:
-        return Response(b'', mimetype='audio/wav', status=503)
-
-    encoder_cmd = [
-        ffmpeg_path, '-hide_banner', '-loglevel', 'error',
-        '-fflags', 'nobuffer', '-flags', 'low_delay',
-        '-probesize', '32', '-analyzeduration', '0',
-        '-f', 's16le', '-ar', '8000', '-ac', '1', '-i', 'pipe:0',
-        '-acodec', 'pcm_s16le', '-ar', '44100', '-f', 'wav', 'pipe:1',
-    ]
-    audio_proc = subprocess.Popen(
-        encoder_cmd,
-        stdin=subprocess.PIPE,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-    )
-    # Drain ffmpeg stderr to prevent blocking
-    threading.Thread(
-        target=lambda p: [None for _ in p.stderr],
-        args=(audio_proc,), daemon=True,
-    ).start()
-
-    if audio_proc.stdin:
-        _register_audio_sink(audio_proc.stdin)
-
-    def generate():
-        try:
-            while dmr_running and audio_proc.poll() is None:
-                ready, _, _ = select.select([audio_proc.stdout], [], [], 2.0)
-                if ready:
-                    chunk = audio_proc.stdout.read(4096)
-                    if chunk:
-                        yield chunk
-                    else:
-                        break
-                else:
-                    if audio_proc.poll() is not None:
-                        break
-        except GeneratorExit:
-            pass
-        except Exception as e:
-            logger.error(f"DMR audio stream error: {e}")
-        finally:
-            # Disconnect mux → ffmpeg, then clean up
-            if audio_proc.stdin:
-                _unregister_audio_sink(audio_proc.stdin)
-            try:
-                audio_proc.stdin.close()
-            except Exception:
-                pass
-            try:
-                audio_proc.terminate()
-                audio_proc.wait(timeout=2)
-            except Exception:
-                try:
-                    audio_proc.kill()
-                except Exception:
-                    pass
-
-    return Response(
-        generate(),
-        mimetype='audio/wav',
-        headers={
-            'Content-Type': 'audio/wav',
-            'Cache-Control': 'no-cache, no-store',
-            'X-Accel-Buffering': 'no',
-            'Transfer-Encoding': 'chunked',
-        },
-    )
-
-
-@dmr_bp.route('/stream')
-def stream_dmr() -> Response:
-    """SSE stream for DMR decoder events."""
-    def _on_msg(msg: dict[str, Any]) -> None:
-        process_event('dmr', msg, msg.get('type'))
-
-    response = Response(
-        sse_stream_fanout(
-            source_queue=dmr_queue,
-            channel_key='dmr',
-            timeout=SSE_QUEUE_TIMEOUT,
-            keepalive_interval=SSE_KEEPALIVE_INTERVAL,
-            on_message=_on_msg,
-        ),
-        mimetype='text/event-stream',
-    )
-    response.headers['Cache-Control'] = 'no-cache'
-    response.headers['X-Accel-Buffering'] = 'no'
-    return response

routes/dsc.py

@@ -51,6 +51,7 @@ dsc_running = False
 
 # Track which device is being used
 dsc_active_device: int | None = None
+dsc_active_sdr_type: str | None = None
 
 
 def _get_dsc_decoder_path() -> str | None:
@@ -171,7 +172,7 @@ def stream_dsc_decoder(master_fd: int, decoder_process: subprocess.Popen) -> Non
             'error': str(e)
         })
     finally:
-        global dsc_active_device
+        global dsc_active_device, dsc_active_sdr_type
         try:
             os.close(master_fd)
         except OSError:
@@ -197,8 +198,9 @@ def stream_dsc_decoder(master_fd: int, decoder_process: subprocess.Popen) -> Non
             app_module.dsc_rtl_process = None
         # Release SDR device
         if dsc_active_device is not None:
-            app_module.release_sdr_device(dsc_active_device)
+            app_module.release_sdr_device(dsc_active_device, dsc_active_sdr_type or 'rtlsdr')
             dsc_active_device = None
+            dsc_active_sdr_type = None
 
 
 def _store_critical_alert(msg: dict) -> None:
@@ -331,10 +333,13 @@ def start_decoding() -> Response:
                 'message': str(e)
             }), 400
 
+        # Get SDR type from request
+        sdr_type_str = data.get('sdr_type', 'rtlsdr')
+
         # Check if device is available using centralized registry
-        global dsc_active_device
+        global dsc_active_device, dsc_active_sdr_type
         device_int = int(device)
-        error = app_module.claim_sdr_device(device_int, 'dsc')
+        error = app_module.claim_sdr_device(device_int, 'dsc', sdr_type_str)
         if error:
             return jsonify({
                 'status': 'error',
@@ -343,6 +348,7 @@ def start_decoding() -> Response:
             }), 409
 
         dsc_active_device = device_int
+        dsc_active_sdr_type = sdr_type_str
 
         # Clear queue
         while not app_module.dsc_queue.empty():
@@ -440,8 +446,9 @@ def start_decoding() -> Response:
                     pass
             # Release device on failure
             if dsc_active_device is not None:
-                app_module.release_sdr_device(dsc_active_device)
+                app_module.release_sdr_device(dsc_active_device, dsc_active_sdr_type or 'rtlsdr')
                 dsc_active_device = None
+                dsc_active_sdr_type = None
             return jsonify({
                 'status': 'error',
                 'message': f'Tool not found: {e.filename}'
@@ -458,8 +465,9 @@ def start_decoding() -> Response:
                     pass
             # Release device on failure
             if dsc_active_device is not None:
-                app_module.release_sdr_device(dsc_active_device)
+                app_module.release_sdr_device(dsc_active_device, dsc_active_sdr_type or 'rtlsdr')
                 dsc_active_device = None
+                dsc_active_sdr_type = None
             logger.error(f"Failed to start DSC decoder: {e}")
             return jsonify({
                 'status': 'error',
@@ -470,7 +478,7 @@ def start_decoding() -> Response:
 @dsc_bp.route('/stop', methods=['POST'])
 def stop_decoding() -> Response:
     """Stop DSC decoder."""
-    global dsc_running, dsc_active_device
+    global dsc_running, dsc_active_device, dsc_active_sdr_type
 
     with app_module.dsc_lock:
         if not app_module.dsc_process:
@@ -509,8 +517,9 @@ def stop_decoding() -> Response:
 
         # Release device from registry
         if dsc_active_device is not None:
-            app_module.release_sdr_device(dsc_active_device)
+            app_module.release_sdr_device(dsc_active_device, dsc_active_sdr_type or 'rtlsdr')
             dsc_active_device = None
+            dsc_active_sdr_type = None
 
         return jsonify({'status': 'stopped'})
 

routes/gps.py

@@ -68,6 +68,9 @@ def auto_connect_gps():
     # Check if already running
     reader = get_gps_reader()
     if reader and reader.is_running:
+        # Ensure stream callbacks are attached for this process.
+        reader.add_callback(_position_callback)
+        reader.add_sky_callback(_sky_callback)
         position = reader.position
         sky = reader.sky
         return jsonify({
@@ -211,9 +214,10 @@ def get_satellites():
 
     if not reader or not reader.is_running:
         return jsonify({
-            'status': 'error',
+            'status': 'waiting',
+            'running': False,
             'message': 'GPS client not running'
-        }), 400
+        })
 
     sky = reader.sky
     if sky:

routes/morse.py

@@ -0,0 +1,996 @@
+"""CW/Morse code decoder routes."""
+
+from __future__ import annotations
+
+import contextlib
+import queue
+import subprocess
+import tempfile
+import threading
+import time
+from pathlib import Path
+from typing import Any
+
+from flask import Blueprint, Response, jsonify, request
+
+import app as app_module
+from utils.event_pipeline import process_event
+from utils.logging import sensor_logger as logger
+from utils.morse import (
+    decode_morse_wav_file,
+    morse_decoder_thread,
+)
+from utils.process import register_process, safe_terminate, unregister_process
+from utils.sdr import SDRFactory, SDRType
+from utils.sse import sse_stream_fanout
+from utils.validation import (
+    validate_device_index,
+    validate_frequency,
+    validate_gain,
+    validate_ppm,
+)
+
+morse_bp = Blueprint('morse', __name__)
+
+
+class _FilteredQueue:
+    """Suppress decoder-thread 'stopped' events that race with route lifecycle."""
+
+    def __init__(self, inner: queue.Queue) -> None:
+        self._inner = inner
+
+    def put_nowait(self, item: Any) -> None:
+        if isinstance(item, dict) and item.get('type') == 'status' and item.get('status') == 'stopped':
+            return
+        self._inner.put_nowait(item)
+
+    def put(self, item: Any, **kwargs: Any) -> None:
+        if isinstance(item, dict) and item.get('type') == 'status' and item.get('status') == 'stopped':
+            return
+        self._inner.put(item, **kwargs)
+
+# Track which device is being used
+morse_active_device: int | None = None
+morse_active_sdr_type: str | None = None
+
+# Runtime lifecycle state.
+MORSE_IDLE = 'idle'
+MORSE_STARTING = 'starting'
+MORSE_RUNNING = 'running'
+MORSE_STOPPING = 'stopping'
+MORSE_ERROR = 'error'
+
+morse_state = MORSE_IDLE
+morse_state_message = 'Idle'
+morse_state_since = time.monotonic()
+morse_last_error = ''
+morse_runtime_config: dict[str, Any] = {}
+morse_session_id = 0
+
+morse_decoder_worker: threading.Thread | None = None
+morse_stderr_worker: threading.Thread | None = None
+morse_stop_event: threading.Event | None = None
+morse_control_queue: queue.Queue | None = None
+
+def _set_state(state: str, message: str = '', *, enqueue: bool = True, extra: dict[str, Any] | None = None) -> None:
+    """Update lifecycle state and optionally emit a status queue event."""
+    global morse_state, morse_state_message, morse_state_since
+    morse_state = state
+    morse_state_message = message or state
+    morse_state_since = time.monotonic()
+
+    if not enqueue:
+        return
+
+    payload: dict[str, Any] = {
+        'type': 'status',
+        'status': state,
+        'state': state,
+        'message': morse_state_message,
+        'session_id': morse_session_id,
+        'timestamp': time.strftime('%H:%M:%S'),
+    }
+    if extra:
+        payload.update(extra)
+    with contextlib.suppress(queue.Full):
+        app_module.morse_queue.put_nowait(payload)
+
+
+def _drain_queue(q: queue.Queue) -> None:
+    while not q.empty():
+        try:
+            q.get_nowait()
+        except queue.Empty:
+            break
+
+
+def _join_thread(worker: threading.Thread | None, timeout_s: float) -> bool:
+    if worker is None:
+        return True
+    worker.join(timeout=timeout_s)
+    return not worker.is_alive()
+
+
+def _close_pipe(pipe_obj: Any) -> None:
+    if pipe_obj is None:
+        return
+    with contextlib.suppress(Exception):
+        pipe_obj.close()
+
+
+def _queue_morse_event(payload: dict[str, Any]) -> None:
+    with contextlib.suppress(queue.Full):
+        app_module.morse_queue.put_nowait(payload)
+
+
+def _bool_value(value: Any, default: bool = False) -> bool:
+    if isinstance(value, bool):
+        return value
+    if value is None:
+        return default
+    text = str(value).strip().lower()
+    if text in {'1', 'true', 'yes', 'on'}:
+        return True
+    if text in {'0', 'false', 'no', 'off'}:
+        return False
+    return default
+
+
+def _float_value(value: Any, default: float) -> float:
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return float(default)
+
+
+def _validate_tone_freq(value: Any) -> float:
+    """Validate CW tone frequency (300-1200 Hz)."""
+    try:
+        freq = float(value)
+        if not 300 <= freq <= 1200:
+            raise ValueError('Tone frequency must be between 300 and 1200 Hz')
+        return freq
+    except (ValueError, TypeError) as e:
+        raise ValueError(f'Invalid tone frequency: {value}') from e
+
+
+def _validate_wpm(value: Any) -> int:
+    """Validate words per minute (5-50)."""
+    try:
+        wpm = int(value)
+        if not 5 <= wpm <= 50:
+            raise ValueError('WPM must be between 5 and 50')
+        return wpm
+    except (ValueError, TypeError) as e:
+        raise ValueError(f'Invalid WPM: {value}') from e
+
+
+def _validate_bandwidth(value: Any) -> int:
+    try:
+        bw = int(value)
+        if bw not in (50, 100, 200, 400):
+            raise ValueError('Bandwidth must be one of 50, 100, 200, 400 Hz')
+        return bw
+    except (TypeError, ValueError) as e:
+        raise ValueError(f'Invalid bandwidth: {value}') from e
+
+
+def _validate_threshold_mode(value: Any) -> str:
+    mode = str(value or 'auto').strip().lower()
+    if mode not in {'auto', 'manual'}:
+        raise ValueError('threshold_mode must be auto or manual')
+    return mode
+
+
+def _validate_wpm_mode(value: Any) -> str:
+    mode = str(value or 'auto').strip().lower()
+    if mode not in {'auto', 'manual'}:
+        raise ValueError('wpm_mode must be auto or manual')
+    return mode
+
+
+def _validate_threshold_multiplier(value: Any) -> float:
+    try:
+        multiplier = float(value)
+        if not 1.1 <= multiplier <= 8.0:
+            raise ValueError('threshold_multiplier must be between 1.1 and 8.0')
+        return multiplier
+    except (TypeError, ValueError) as e:
+        raise ValueError(f'Invalid threshold multiplier: {value}') from e
+
+
+def _validate_non_negative_float(value: Any, field_name: str) -> float:
+    try:
+        parsed = float(value)
+        if parsed < 0:
+            raise ValueError(f'{field_name} must be non-negative')
+        return parsed
+    except (TypeError, ValueError) as e:
+        raise ValueError(f'Invalid {field_name}: {value}') from e
+
+
+def _validate_signal_gate(value: Any) -> float:
+    try:
+        gate = float(value)
+        if not 0.0 <= gate <= 1.0:
+            raise ValueError('signal_gate must be between 0.0 and 1.0')
+        return gate
+    except (TypeError, ValueError) as e:
+        raise ValueError(f'Invalid signal gate: {value}') from e
+
+
+def _validate_detect_mode(value: Any) -> str:
+    """Validate detection mode ('goertzel' or 'envelope')."""
+    mode = str(value or 'goertzel').lower().strip()
+    if mode not in ('goertzel', 'envelope'):
+        raise ValueError("detect_mode must be 'goertzel' or 'envelope'")
+    return mode
+
+
+def _snapshot_live_resources() -> list[str]:
+    alive: list[str] = []
+    if morse_decoder_worker and morse_decoder_worker.is_alive():
+        alive.append('decoder_thread')
+    if morse_stderr_worker and morse_stderr_worker.is_alive():
+        alive.append('stderr_thread')
+    if app_module.morse_process and app_module.morse_process.poll() is None:
+        alive.append('rtl_process')
+    return alive
+
+
+@morse_bp.route('/morse/start', methods=['POST'])
+def start_morse() -> Response:
+    global morse_active_device, morse_active_sdr_type, morse_decoder_worker, morse_stderr_worker
+    global morse_stop_event, morse_control_queue, morse_runtime_config
+    global morse_last_error, morse_session_id
+
+    data = request.json or {}
+
+    # Validate detect_mode first — it determines frequency limits.
+    try:
+        detect_mode = _validate_detect_mode(data.get('detect_mode', 'goertzel'))
+    except ValueError as e:
+        return jsonify({'status': 'error', 'message': str(e)}), 400
+
+    freq_max = 1766.0 if detect_mode == 'envelope' else 30.0
+    try:
+        freq = validate_frequency(data.get('frequency', '14.060'), min_mhz=0.5, max_mhz=freq_max)
+        gain = validate_gain(data.get('gain', '0'))
+        ppm = validate_ppm(data.get('ppm', '0'))
+        device = validate_device_index(data.get('device', '0'))
+    except ValueError as e:
+        return jsonify({'status': 'error', 'message': str(e)}), 400
+
+    try:
+        tone_freq = _validate_tone_freq(data.get('tone_freq', '700'))
+        wpm = _validate_wpm(data.get('wpm', '15'))
+        bandwidth_hz = _validate_bandwidth(data.get('bandwidth_hz', '200'))
+        threshold_mode = _validate_threshold_mode(data.get('threshold_mode', 'auto'))
+        wpm_mode = _validate_wpm_mode(data.get('wpm_mode', 'auto'))
+        threshold_multiplier = _validate_threshold_multiplier(data.get('threshold_multiplier', '2.8'))
+        manual_threshold = _validate_non_negative_float(data.get('manual_threshold', '0'), 'manual threshold')
+        threshold_offset = _validate_non_negative_float(data.get('threshold_offset', '0'), 'threshold offset')
+        min_signal_gate = _validate_signal_gate(data.get('signal_gate', '0'))
+        auto_tone_track = _bool_value(data.get('auto_tone_track', True), True)
+        tone_lock = _bool_value(data.get('tone_lock', False), False)
+        wpm_lock = _bool_value(data.get('wpm_lock', False), False)
+    except ValueError as e:
+        return jsonify({'status': 'error', 'message': str(e)}), 400
+
+    sdr_type_str = data.get('sdr_type', 'rtlsdr')
+
+    with app_module.morse_lock:
+        if morse_state in {MORSE_STARTING, MORSE_RUNNING, MORSE_STOPPING}:
+            return jsonify({
+                'status': 'error',
+                'message': f'Morse decoder is {morse_state}',
+                'state': morse_state,
+            }), 409
+
+        device_int = int(device)
+        error = app_module.claim_sdr_device(device_int, 'morse', sdr_type_str)
+        if error:
+            return jsonify({
+                'status': 'error',
+                'error_type': 'DEVICE_BUSY',
+                'message': error,
+            }), 409
+
+        morse_active_device = device_int
+        morse_active_sdr_type = sdr_type_str
+        morse_last_error = ''
+        morse_session_id += 1
+
+        _drain_queue(app_module.morse_queue)
+        _set_state(MORSE_STARTING, 'Starting decoder...')
+
+    # Envelope mode (OOK/AM): use AM demod, higher sample rate for better
+    # envelope resolution.  Goertzel mode (HF CW): use USB demod.
+    if detect_mode == 'envelope':
+        sample_rate = 48000
+        modulation = 'am'
+    else:
+        sample_rate = 22050
+        modulation = 'usb'
+
+    bias_t = _bool_value(data.get('bias_t', False), False)
+
+    try:
+        sdr_type = SDRType(sdr_type_str)
+    except ValueError:
+        sdr_type = SDRType.RTL_SDR
+
+    requested_device_index = int(device)
+    active_device_index = requested_device_index
+    builder = SDRFactory.get_builder(sdr_type)
+
+    device_catalog: dict[int, dict[str, str]] = {}
+    candidate_device_indices: list[int] = [requested_device_index]
+    with contextlib.suppress(Exception):
+        detected_devices = SDRFactory.detect_devices()
+        same_type_devices = [d for d in detected_devices if d.sdr_type == sdr_type]
+        for d in same_type_devices:
+            device_catalog[d.index] = {
+                'name': str(d.name or f'SDR {d.index}'),
+                'serial': str(d.serial or 'Unknown'),
+            }
+        for d in sorted(same_type_devices, key=lambda dev: dev.index):
+            if d.index not in candidate_device_indices:
+                candidate_device_indices.append(d.index)
+
+    def _device_label(device_index: int) -> str:
+        meta = device_catalog.get(device_index, {})
+        serial = str(meta.get('serial') or 'Unknown')
+        name = str(meta.get('name') or f'SDR {device_index}')
+        return f'device {device_index} ({name}, SN: {serial})'
+
+    def _build_rtl_cmd(device_index: int, direct_sampling_mode: int | None) -> list[str]:
+        # Envelope mode tunes directly to center freq (no tone offset).
+        if detect_mode == 'envelope':
+            tuned_frequency_mhz = max(0.5, float(freq))
+        else:
+            tuned_frequency_mhz = max(0.5, float(freq) - (float(tone_freq) / 1_000_000.0))
+        sdr_device = SDRFactory.create_default_device(sdr_type, index=device_index)
+        fm_kwargs: dict[str, Any] = {
+            'device': sdr_device,
+            'frequency_mhz': tuned_frequency_mhz,
+            'sample_rate': sample_rate,
+            'gain': float(gain) if gain and gain != '0' else None,
+            'ppm': int(ppm) if ppm and ppm != '0' else None,
+            'modulation': modulation,
+            'bias_t': bias_t,
+        }
+        if direct_sampling_mode in (1, 2):
+            fm_kwargs['direct_sampling'] = int(direct_sampling_mode)
+
+        cmd = list(builder.build_fm_demod_command(**fm_kwargs))
+
+        if cmd and cmd[-1] != '-':
+            cmd.append('-')
+        return cmd
+
+    can_try_direct_sampling = bool(
+        sdr_type == SDRType.RTL_SDR
+        and detect_mode != 'envelope'  # direct sampling is HF-only
+        and float(freq) < 24.0
+    )
+    direct_sampling_attempts: list[int | None] = [2, 1, None] if can_try_direct_sampling else [None]
+
+    runtime_config: dict[str, Any] = {
+        'sample_rate': sample_rate,
+        'detect_mode': detect_mode,
+        'modulation': modulation,
+        'rf_frequency_mhz': float(freq),
+        'tuned_frequency_mhz': max(0.5, float(freq)) if detect_mode == 'envelope' else max(0.5, float(freq) - (float(tone_freq) / 1_000_000.0)),
+        'tone_freq': tone_freq,
+        'wpm': wpm,
+        'bandwidth_hz': bandwidth_hz,
+        'auto_tone_track': auto_tone_track,
+        'tone_lock': tone_lock,
+        'threshold_mode': threshold_mode,
+        'manual_threshold': manual_threshold,
+        'threshold_multiplier': threshold_multiplier,
+        'threshold_offset': threshold_offset,
+        'wpm_mode': wpm_mode,
+        'wpm_lock': wpm_lock,
+        'min_signal_gate': min_signal_gate,
+        'source': 'rtl_fm',
+        'requested_device': requested_device_index,
+        'active_device': active_device_index,
+        'device_serial': str(device_catalog.get(active_device_index, {}).get('serial') or 'Unknown'),
+        'candidate_devices': list(candidate_device_indices),
+    }
+
+    active_rtl_process: subprocess.Popen[bytes] | None = None
+    active_stop_event: threading.Event | None = None
+    active_control_queue: queue.Queue | None = None
+    active_decoder_thread: threading.Thread | None = None
+    active_stderr_thread: threading.Thread | None = None
+    rtl_process: subprocess.Popen[bytes] | None = None
+    stop_event: threading.Event | None = None
+    control_queue: queue.Queue | None = None
+    decoder_thread: threading.Thread | None = None
+    stderr_thread: threading.Thread | None = None
+
+    def _cleanup_attempt(
+        rtl_proc: subprocess.Popen[bytes] | None,
+        stop_evt: threading.Event | None,
+        control_q: queue.Queue | None,
+        decoder_worker: threading.Thread | None,
+        stderr_worker: threading.Thread | None,
+    ) -> None:
+        if stop_evt is not None:
+            stop_evt.set()
+        if control_q is not None:
+            with contextlib.suppress(queue.Full):
+                control_q.put_nowait({'cmd': 'shutdown'})
+
+        if rtl_proc is not None:
+            _close_pipe(getattr(rtl_proc, 'stdout', None))
+            _close_pipe(getattr(rtl_proc, 'stderr', None))
+
+        if rtl_proc is not None:
+            safe_terminate(rtl_proc, timeout=0.4)
+            unregister_process(rtl_proc)
+
+        _join_thread(decoder_worker, timeout_s=0.35)
+        _join_thread(stderr_worker, timeout_s=0.35)
+
+    full_cmd = ''
+    attempt_errors: list[str] = []
+
+    try:
+        startup_succeeded = False
+        for device_pos, candidate_device_index in enumerate(candidate_device_indices, start=1):
+            if candidate_device_index != active_device_index:
+                prev_device = active_device_index
+                claim_error = app_module.claim_sdr_device(candidate_device_index, 'morse', sdr_type_str)
+                if claim_error:
+                    msg = f'{_device_label(candidate_device_index)} unavailable: {claim_error}'
+                    attempt_errors.append(msg)
+                    logger.warning('Morse startup device fallback skipped: %s', msg)
+                    _queue_morse_event({'type': 'info', 'text': f'[morse] {msg}'})
+                    continue
+
+                if prev_device is not None:
+                    app_module.release_sdr_device(prev_device, morse_active_sdr_type or 'rtlsdr')
+                active_device_index = candidate_device_index
+                with app_module.morse_lock:
+                    morse_active_device = active_device_index
+
+                _queue_morse_event({
+                    'type': 'info',
+                    'text': (
+                        f'[morse] switching to {_device_label(active_device_index)} '
+                        f'({device_pos}/{len(candidate_device_indices)})'
+                    ),
+                })
+
+            runtime_config['active_device'] = active_device_index
+            runtime_config['device_serial'] = str(
+                device_catalog.get(active_device_index, {}).get('serial') or 'Unknown'
+            )
+            runtime_config.pop('startup_waiting', None)
+            runtime_config.pop('startup_warning', None)
+
+            for attempt_index, direct_sampling_mode in enumerate(direct_sampling_attempts, start=1):
+                rtl_process = None
+                stop_event = None
+                control_queue = None
+                decoder_thread = None
+                stderr_thread = None
+
+                rtl_cmd = _build_rtl_cmd(active_device_index, direct_sampling_mode)
+                direct_mode_label = direct_sampling_mode if direct_sampling_mode is not None else 'none'
+                full_cmd = ' '.join(rtl_cmd)
+                logger.info(
+                    'Morse decoder attempt device=%s (%s/%s) rf=%.6f tuned=%.6f direct_mode=%s (%s/%s): %s',
+                    active_device_index,
+                    device_pos,
+                    len(candidate_device_indices),
+                    float(freq),
+                    float(runtime_config.get('tuned_frequency_mhz', freq)),
+                    direct_mode_label,
+                    attempt_index,
+                    len(direct_sampling_attempts),
+                    full_cmd,
+                )
+                _queue_morse_event({'type': 'info', 'text': f'[cmd] {full_cmd}'})
+
+                rtl_process = subprocess.Popen(
+                    rtl_cmd,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    bufsize=0,
+                )
+                register_process(rtl_process)
+
+                stop_event = threading.Event()
+                control_queue = queue.Queue(maxsize=16)
+                pcm_ready_event = threading.Event()
+                stderr_lines: list[str] = []
+
+                def monitor_stderr(
+                    proc: subprocess.Popen[bytes] = rtl_process,
+                    proc_stop_event: threading.Event = stop_event,
+                    capture_lines: list[str] = stderr_lines,
+                ) -> None:
+                    stderr_stream = proc.stderr
+                    if stderr_stream is None:
+                        return
+                    try:
+                        while not proc_stop_event.is_set():
+                            line = stderr_stream.readline()
+                            if not line:
+                                if proc.poll() is not None:
+                                    break
+                                time.sleep(0.02)
+                                continue
+                            err_text = line.decode('utf-8', errors='replace').strip()
+                            if not err_text:
+                                continue
+                            if len(capture_lines) >= 40:
+                                del capture_lines[:10]
+                            capture_lines.append(err_text)
+                            _queue_morse_event({'type': 'info', 'text': f'[rtl_fm] {err_text}'})
+                    except (ValueError, OSError):
+                        return
+                    except Exception:
+                        return
+
+                stderr_thread = threading.Thread(target=monitor_stderr, daemon=True, name='morse-stderr')
+                stderr_thread.start()
+
+                if rtl_process.stdout is None:
+                    raise RuntimeError('rtl_fm stdout unavailable')
+
+                decoder_thread = threading.Thread(
+                    target=morse_decoder_thread,
+                    kwargs={
+                        'rtl_stdout': rtl_process.stdout,
+                        'output_queue': _FilteredQueue(app_module.morse_queue),
+                        'stop_event': stop_event,
+                        'sample_rate': sample_rate,
+                        'tone_freq': tone_freq,
+                        'wpm': wpm,
+                        'decoder_config': runtime_config,
+                        'control_queue': control_queue,
+                        'pcm_ready_event': pcm_ready_event,
+                    },
+                    daemon=True,
+                    name='morse-decoder',
+                )
+                decoder_thread.start()
+
+                startup_deadline = time.monotonic() + 4.0
+                startup_ok = False
+                startup_error = ''
+
+                while time.monotonic() < startup_deadline:
+                    if pcm_ready_event.is_set():
+                        startup_ok = True
+                        break
+                    if rtl_process.poll() is not None:
+                        startup_error = f'rtl_fm exited during startup (code {rtl_process.returncode})'
+                        break
+                    time.sleep(0.05)
+
+                if not startup_ok:
+                    if not startup_error:
+                        startup_error = 'No PCM samples received within startup timeout'
+                    if stderr_lines:
+                        startup_error = f'{startup_error}; stderr: {stderr_lines[-1]}'
+                    is_last_device = device_pos == len(candidate_device_indices)
+                    is_last_attempt = attempt_index == len(direct_sampling_attempts)
+                    if (
+                        is_last_device
+                        and is_last_attempt
+                        and rtl_process.poll() is None
+                    ):
+                        startup_ok = True
+                        runtime_config['startup_waiting'] = True
+                        runtime_config['startup_warning'] = startup_error
+                        logger.warning(
+                            'Morse startup continuing without PCM on %s: %s',
+                            _device_label(active_device_index),
+                            startup_error,
+                        )
+                        _queue_morse_event({
+                            'type': 'info',
+                            'text': '[morse] waiting for PCM stream...',
+                        })
+
+                if startup_ok:
+                    runtime_config['direct_sampling_mode'] = direct_sampling_mode
+                    runtime_config['direct_sampling'] = (
+                        int(direct_sampling_mode) if direct_sampling_mode is not None else 0
+                    )
+                    runtime_config['command'] = full_cmd
+                    runtime_config['active_device'] = active_device_index
+
+                    active_rtl_process = rtl_process
+                    active_stop_event = stop_event
+                    active_control_queue = control_queue
+                    active_decoder_thread = decoder_thread
+                    active_stderr_thread = stderr_thread
+                    startup_succeeded = True
+                    break
+
+                attempt_errors.append(
+                    f'{_device_label(active_device_index)} '
+                    f'attempt {attempt_index}/{len(direct_sampling_attempts)} '
+                    f'(source=rtl_fm direct_mode={direct_mode_label}): {startup_error}'
+                )
+                logger.warning('Morse startup attempt failed: %s', attempt_errors[-1])
+                _queue_morse_event({'type': 'info', 'text': f'[morse] startup attempt failed: {startup_error}'})
+
+                _cleanup_attempt(
+                    rtl_process,
+                    stop_event,
+                    control_queue,
+                    decoder_thread,
+                    stderr_thread,
+                )
+                rtl_process = None
+                stop_event = None
+                control_queue = None
+                decoder_thread = None
+                stderr_thread = None
+
+            if startup_succeeded:
+                break
+
+            if device_pos < len(candidate_device_indices):
+                next_device = candidate_device_indices[device_pos]
+                _queue_morse_event({
+                    'type': 'status',
+                    'state': MORSE_STARTING,
+                    'status': MORSE_STARTING,
+                    'message': (
+                        f'No PCM on {_device_label(active_device_index)}. '
+                        f'Trying {_device_label(next_device)}...'
+                    ),
+                    'session_id': morse_session_id,
+                    'timestamp': time.strftime('%H:%M:%S'),
+                })
+
+        if (
+            active_rtl_process is None
+            or active_stop_event is None
+            or active_control_queue is None
+            or active_decoder_thread is None
+            or active_stderr_thread is None
+        ):
+            msg = (
+                f'SDR capture started but no PCM stream was received from '
+                f'{_device_label(active_device_index)}.'
+            )
+            if attempt_errors:
+                msg += ' ' + ' | '.join(attempt_errors)
+            logger.error('Morse startup failed: %s', msg)
+            with app_module.morse_lock:
+                if morse_active_device is not None:
+                    app_module.release_sdr_device(morse_active_device, morse_active_sdr_type or 'rtlsdr')
+                    morse_active_device = None
+                    morse_active_sdr_type = None
+                morse_last_error = msg
+                _set_state(MORSE_ERROR, msg)
+                _set_state(MORSE_IDLE, 'Idle')
+            return jsonify({'status': 'error', 'message': msg}), 500
+
+        with app_module.morse_lock:
+            app_module.morse_process = active_rtl_process
+            app_module.morse_process._stop_decoder = active_stop_event
+            app_module.morse_process._decoder_thread = active_decoder_thread
+            app_module.morse_process._stderr_thread = active_stderr_thread
+            app_module.morse_process._control_queue = active_control_queue
+
+            morse_stop_event = active_stop_event
+            morse_control_queue = active_control_queue
+            morse_decoder_worker = active_decoder_thread
+            morse_stderr_worker = active_stderr_thread
+            morse_runtime_config = dict(runtime_config)
+            _set_state(MORSE_RUNNING, 'Listening')
+
+        return jsonify({
+            'status': 'started',
+            'state': MORSE_RUNNING,
+            'command': full_cmd,
+            'detect_mode': detect_mode,
+            'modulation': modulation,
+            'tone_freq': tone_freq,
+            'wpm': wpm,
+            'config': runtime_config,
+            'session_id': morse_session_id,
+        })
+
+    except FileNotFoundError as e:
+        _cleanup_attempt(
+            rtl_process if rtl_process is not None else active_rtl_process,
+            stop_event if stop_event is not None else active_stop_event,
+            control_queue if control_queue is not None else active_control_queue,
+            decoder_thread if decoder_thread is not None else active_decoder_thread,
+            stderr_thread if stderr_thread is not None else active_stderr_thread,
+        )
+        with app_module.morse_lock:
+            if morse_active_device is not None:
+                app_module.release_sdr_device(morse_active_device, morse_active_sdr_type or 'rtlsdr')
+                morse_active_device = None
+                morse_active_sdr_type = None
+            morse_last_error = f'Tool not found: {e.filename}'
+            _set_state(MORSE_ERROR, morse_last_error)
+            _set_state(MORSE_IDLE, 'Idle')
+        return jsonify({'status': 'error', 'message': morse_last_error}), 400
+
+    except Exception as e:
+        _cleanup_attempt(
+            rtl_process if rtl_process is not None else active_rtl_process,
+            stop_event if stop_event is not None else active_stop_event,
+            control_queue if control_queue is not None else active_control_queue,
+            decoder_thread if decoder_thread is not None else active_decoder_thread,
+            stderr_thread if stderr_thread is not None else active_stderr_thread,
+        )
+        with app_module.morse_lock:
+            if morse_active_device is not None:
+                app_module.release_sdr_device(morse_active_device, morse_active_sdr_type or 'rtlsdr')
+                morse_active_device = None
+                morse_active_sdr_type = None
+            morse_last_error = str(e)
+            _set_state(MORSE_ERROR, morse_last_error)
+            _set_state(MORSE_IDLE, 'Idle')
+        return jsonify({'status': 'error', 'message': str(e)}), 500
+
+
+@morse_bp.route('/morse/stop', methods=['POST'])
+def stop_morse() -> Response:
+    global morse_active_device, morse_active_sdr_type, morse_decoder_worker, morse_stderr_worker
+    global morse_stop_event, morse_control_queue
+
+    stop_started = time.perf_counter()
+
+    with app_module.morse_lock:
+        if morse_state == MORSE_STOPPING:
+            return jsonify({'status': 'stopping', 'state': MORSE_STOPPING}), 202
+
+        rtl_proc = app_module.morse_process
+        stop_event = morse_stop_event or getattr(rtl_proc, '_stop_decoder', None)
+        decoder_thread = morse_decoder_worker or getattr(rtl_proc, '_decoder_thread', None)
+        stderr_thread = morse_stderr_worker or getattr(rtl_proc, '_stderr_thread', None)
+        control_queue = morse_control_queue or getattr(rtl_proc, '_control_queue', None)
+        active_device = morse_active_device
+        active_sdr_type = morse_active_sdr_type
+
+        if (
+            not rtl_proc
+            and not stop_event
+            and not decoder_thread
+            and not stderr_thread
+        ):
+            _set_state(MORSE_IDLE, 'Idle', enqueue=False)
+            return jsonify({'status': 'not_running', 'state': MORSE_IDLE})
+
+        _set_state(MORSE_STOPPING, 'Stopping decoder...')
+
+        app_module.morse_process = None
+        morse_stop_event = None
+        morse_control_queue = None
+        morse_decoder_worker = None
+        morse_stderr_worker = None
+
+    cleanup_steps: list[str] = []
+
+    def _mark(step: str) -> None:
+        cleanup_steps.append(step)
+        logger.debug(f'[morse.stop] {step}')
+
+    _mark('enter stop')
+
+    if stop_event is not None:
+        stop_event.set()
+        _mark('stop_event set')
+
+    if control_queue is not None:
+        with contextlib.suppress(queue.Full):
+            control_queue.put_nowait({'cmd': 'shutdown'})
+        _mark('control_queue shutdown signal sent')
+
+    if rtl_proc is not None:
+        _close_pipe(getattr(rtl_proc, 'stdout', None))
+        _close_pipe(getattr(rtl_proc, 'stderr', None))
+        _mark('rtl_fm pipes closed')
+
+    if rtl_proc is not None:
+        safe_terminate(rtl_proc, timeout=0.6)
+        unregister_process(rtl_proc)
+        _mark('rtl_fm process terminated')
+
+    decoder_joined = _join_thread(decoder_thread, timeout_s=0.45)
+    stderr_joined = _join_thread(stderr_thread, timeout_s=0.45)
+    _mark(f'decoder thread joined={decoder_joined}')
+    _mark(f'stderr thread joined={stderr_joined}')
+
+    if active_device is not None:
+        app_module.release_sdr_device(active_device, active_sdr_type or 'rtlsdr')
+        _mark(f'SDR device {active_device} released')
+
+    stop_ms = round((time.perf_counter() - stop_started) * 1000.0, 1)
+    alive_after = []
+    if not decoder_joined:
+        alive_after.append('decoder_thread')
+    if not stderr_joined:
+        alive_after.append('stderr_thread')
+    if rtl_proc is not None and rtl_proc.poll() is None:
+        alive_after.append('rtl_process')
+
+    with app_module.morse_lock:
+        morse_active_device = None
+        morse_active_sdr_type = None
+        _set_state(MORSE_IDLE, 'Stopped', extra={
+            'stop_ms': stop_ms,
+            'cleanup_steps': cleanup_steps,
+            'alive': alive_after,
+        })
+
+    with contextlib.suppress(queue.Full):
+        app_module.morse_queue.put_nowait({
+            'type': 'status',
+            'status': 'stopped',
+            'state': MORSE_IDLE,
+            'stop_ms': stop_ms,
+            'cleanup_steps': cleanup_steps,
+            'alive': alive_after,
+            'timestamp': time.strftime('%H:%M:%S'),
+        })
+
+    if stop_ms > 500.0 or alive_after:
+        logger.warning(
+            '[morse.stop] slow/partial cleanup: stop_ms=%s alive=%s steps=%s',
+            stop_ms,
+            ','.join(alive_after) if alive_after else 'none',
+            '; '.join(cleanup_steps),
+        )
+    else:
+        logger.info('[morse.stop] cleanup complete in %sms', stop_ms)
+
+    return jsonify({
+        'status': 'stopped',
+        'state': MORSE_IDLE,
+        'stop_ms': stop_ms,
+        'alive': alive_after,
+        'cleanup_steps': cleanup_steps,
+    })
+
+
+@morse_bp.route('/morse/calibrate', methods=['POST'])
+def calibrate_morse() -> Response:
+    """Reset decoder threshold/timing estimators without restarting the process."""
+    with app_module.morse_lock:
+        if morse_state != MORSE_RUNNING or morse_control_queue is None:
+            return jsonify({
+                'status': 'not_running',
+                'state': morse_state,
+                'message': 'Morse decoder is not running',
+            }), 409
+
+        with contextlib.suppress(queue.Full):
+            morse_control_queue.put_nowait({'cmd': 'reset'})
+
+    with contextlib.suppress(queue.Full):
+        app_module.morse_queue.put_nowait({
+            'type': 'info',
+            'text': '[morse] Calibration reset requested',
+        })
+
+    return jsonify({'status': 'ok', 'state': morse_state})
+
+
+@morse_bp.route('/morse/decode-file', methods=['POST'])
+def decode_morse_file() -> Response:
+    """Decode Morse from an uploaded WAV file."""
+    if 'audio' not in request.files:
+        return jsonify({'status': 'error', 'message': 'No audio file provided'}), 400
+
+    audio_file = request.files['audio']
+    if not audio_file.filename:
+        return jsonify({'status': 'error', 'message': 'No file selected'}), 400
+
+    # Parse optional tuning/decoder parameters from form fields.
+    form = request.form or {}
+    try:
+        tone_freq = _validate_tone_freq(form.get('tone_freq', '700'))
+        wpm = _validate_wpm(form.get('wpm', '15'))
+        bandwidth_hz = _validate_bandwidth(form.get('bandwidth_hz', '200'))
+        threshold_mode = _validate_threshold_mode(form.get('threshold_mode', 'auto'))
+        wpm_mode = _validate_wpm_mode(form.get('wpm_mode', 'auto'))
+        threshold_multiplier = _validate_threshold_multiplier(form.get('threshold_multiplier', '2.8'))
+        manual_threshold = _validate_non_negative_float(form.get('manual_threshold', '0'), 'manual threshold')
+        threshold_offset = _validate_non_negative_float(form.get('threshold_offset', '0'), 'threshold offset')
+        signal_gate = _validate_signal_gate(form.get('signal_gate', '0'))
+        auto_tone_track = _bool_value(form.get('auto_tone_track', 'true'), True)
+        tone_lock = _bool_value(form.get('tone_lock', 'false'), False)
+        wpm_lock = _bool_value(form.get('wpm_lock', 'false'), False)
+    except ValueError as e:
+        return jsonify({'status': 'error', 'message': str(e)}), 400
+
+    with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as tmp:
+        audio_file.save(tmp.name)
+        tmp_path = Path(tmp.name)
+
+    try:
+        result = decode_morse_wav_file(
+            tmp_path,
+            sample_rate=8000,
+            tone_freq=tone_freq,
+            wpm=wpm,
+            bandwidth_hz=bandwidth_hz,
+            auto_tone_track=auto_tone_track,
+            tone_lock=tone_lock,
+            threshold_mode=threshold_mode,
+            manual_threshold=manual_threshold,
+            threshold_multiplier=threshold_multiplier,
+            threshold_offset=threshold_offset,
+            wpm_mode=wpm_mode,
+            wpm_lock=wpm_lock,
+            min_signal_gate=signal_gate,
+        )
+
+        text = str(result.get('text', ''))
+        raw = str(result.get('raw', ''))
+        metrics = result.get('metrics', {})
+
+        return jsonify({
+            'status': 'ok',
+            'text': text,
+            'raw': raw,
+            'char_count': len(text.replace(' ', '')),
+            'word_count': len([w for w in text.split(' ') if w]),
+            'metrics': metrics,
+        })
+    except Exception as e:
+        logger.error(f'Morse decode-file error: {e}')
+        return jsonify({'status': 'error', 'message': str(e)}), 500
+    finally:
+        with contextlib.suppress(Exception):
+            tmp_path.unlink(missing_ok=True)
+
+
+@morse_bp.route('/morse/status')
+def morse_status() -> Response:
+    with app_module.morse_lock:
+        running = (
+            app_module.morse_process is not None
+            and app_module.morse_process.poll() is None
+            and morse_state in {MORSE_RUNNING, MORSE_STARTING, MORSE_STOPPING}
+        )
+        since_ms = round((time.monotonic() - morse_state_since) * 1000.0, 1)
+        return jsonify({
+            'running': running,
+            'state': morse_state,
+            'message': morse_state_message,
+            'since_ms': since_ms,
+            'session_id': morse_session_id,
+            'config': morse_runtime_config,
+            'alive': _snapshot_live_resources(),
+            'error': morse_last_error,
+        })
+
+
+@morse_bp.route('/morse/stream')
+def morse_stream() -> Response:
+    def _on_msg(msg: dict[str, Any]) -> None:
+        process_event('morse', msg, msg.get('type'))
+
+    response = Response(
+        sse_stream_fanout(
+            source_queue=app_module.morse_queue,
+            channel_key='morse',
+            timeout=1.0,
+            keepalive_interval=30.0,
+            on_message=_on_msg,
+        ),
+        mimetype='text/event-stream',
+    )
+    response.headers['Cache-Control'] = 'no-cache'
+    response.headers['X-Accel-Buffering'] = 'no'
+    response.headers['Connection'] = 'keep-alive'
+    return response

routes/offline.py

@@ -11,8 +11,9 @@ offline_bp = Blueprint('offline', __name__, url_prefix='/offline')
 # Default offline settings
 OFFLINE_DEFAULTS = {
     'offline.enabled': False,
-    'offline.assets_source': 'cdn',
+    # Default to bundled assets/fonts to avoid third-party CDN privacy blocks.
-    'offline.fonts_source': 'cdn',
+    'offline.assets_source': 'local',
+    'offline.fonts_source': 'local',
     'offline.tile_provider': 'cartodb_dark_cyan',
     'offline.tile_server_url': ''
 }

routes/pager.py

@@ -34,6 +34,7 @@ pager_bp = Blueprint('pager', __name__)
 
 # Track which device is being used
 pager_active_device: int | None = None
+pager_active_sdr_type: str | None = None
 
 
 def parse_multimon_output(line: str) -> dict[str, str] | None:
@@ -108,6 +109,20 @@ def log_message(msg: dict[str, Any]) -> None:
         logger.error(f"Failed to log message: {e}")
 
 
+def _encode_scope_waveform(samples: tuple[int, ...], window_size: int = 256) -> list[int]:
+    """Compress recent PCM samples into a signed 8-bit waveform for SSE."""
+    if not samples:
+        return []
+
+    window = samples[-window_size:] if len(samples) > window_size else samples
+    waveform: list[int] = []
+    for sample in window:
+        # Convert int16 PCM to int8 range for lightweight transport.
+        packed = int(round(sample / 256))
+        waveform.append(max(-127, min(127, packed)))
+    return waveform
+
+
 def audio_relay_thread(
     rtl_stdout,
     multimon_stdin,
@@ -118,7 +133,7 @@ def audio_relay_thread(
 
     Reads raw 16-bit LE PCM from *rtl_stdout*, writes every chunk straight
     through to *multimon_stdin*, and every ~100 ms pushes an RMS / peak scope
-    event onto *output_queue*.
+    event plus a compact waveform sample onto *output_queue*.
     """
     CHUNK = 4096  # bytes – 2048 samples at 16-bit mono
     INTERVAL = 0.1  # seconds between scope updates
@@ -152,6 +167,7 @@ def audio_relay_thread(
                         'type': 'scope',
                         'rms': rms,
                         'peak': peak,
+                        'waveform': _encode_scope_waveform(samples),
                     })
                 except (struct.error, ValueError, queue.Full):
                     pass
@@ -205,7 +221,7 @@ def stream_decoder(master_fd: int, process: subprocess.Popen[bytes]) -> None:
     except Exception as e:
         app_module.output_queue.put({'type': 'error', 'text': str(e)})
     finally:
-        global pager_active_device
+        global pager_active_device, pager_active_sdr_type
         try:
             os.close(master_fd)
         except OSError:
@@ -234,13 +250,14 @@ def stream_decoder(master_fd: int, process: subprocess.Popen[bytes]) -> None:
             app_module.current_process = None
         # Release SDR device
         if pager_active_device is not None:
-            app_module.release_sdr_device(pager_active_device)
+            app_module.release_sdr_device(pager_active_device, pager_active_sdr_type or 'rtlsdr')
             pager_active_device = None
+            pager_active_sdr_type = None
 
 
 @pager_bp.route('/start', methods=['POST'])
 def start_decoding() -> Response:
-    global pager_active_device
+    global pager_active_device, pager_active_sdr_type
 
     with app_module.process_lock:
         if app_module.current_process:
@@ -269,10 +286,13 @@ def start_decoding() -> Response:
         rtl_tcp_host = data.get('rtl_tcp_host')
         rtl_tcp_port = data.get('rtl_tcp_port', 1234)
 
+        # Get SDR type early so we can pass it to claim/release
+        sdr_type_str = data.get('sdr_type', 'rtlsdr')
+
         # Claim local device if not using remote rtl_tcp
         if not rtl_tcp_host:
             device_int = int(device)
-            error = app_module.claim_sdr_device(device_int, 'pager')
+            error = app_module.claim_sdr_device(device_int, 'pager', sdr_type_str)
             if error:
                 return jsonify({
                     'status': 'error',
@@ -280,14 +300,16 @@ def start_decoding() -> Response:
                     'message': error
                 }), 409
             pager_active_device = device_int
+            pager_active_sdr_type = sdr_type_str
 
         # Validate protocols
         valid_protocols = ['POCSAG512', 'POCSAG1200', 'POCSAG2400', 'FLEX']
         protocols = data.get('protocols', valid_protocols)
         if not isinstance(protocols, list):
             if pager_active_device is not None:
-                app_module.release_sdr_device(pager_active_device)
+                app_module.release_sdr_device(pager_active_device, pager_active_sdr_type or 'rtlsdr')
                 pager_active_device = None
+                pager_active_sdr_type = None
             return jsonify({'status': 'error', 'message': 'Protocols must be a list'}), 400
         protocols = [p for p in protocols if p in valid_protocols]
         if not protocols:
@@ -312,8 +334,7 @@ def start_decoding() -> Response:
             elif proto == 'FLEX':
                 decoders.extend(['-a', 'FLEX'])
 
-        # Get SDR type and build command via abstraction layer
+        # Build command via SDR abstraction layer
-        sdr_type_str = data.get('sdr_type', 'rtlsdr')
         try:
             sdr_type = SDRType(sdr_type_str)
         except ValueError:
@@ -428,8 +449,9 @@ def start_decoding() -> Response:
                     pass
             # Release device on failure
             if pager_active_device is not None:
-                app_module.release_sdr_device(pager_active_device)
+                app_module.release_sdr_device(pager_active_device, pager_active_sdr_type or 'rtlsdr')
                 pager_active_device = None
+                pager_active_sdr_type = None
             return jsonify({'status': 'error', 'message': f'Tool not found: {e.filename}'})
         except Exception as e:
             # Kill orphaned rtl_fm process if it was started
@@ -443,14 +465,15 @@ def start_decoding() -> Response:
                     pass
             # Release device on failure
             if pager_active_device is not None:
-                app_module.release_sdr_device(pager_active_device)
+                app_module.release_sdr_device(pager_active_device, pager_active_sdr_type or 'rtlsdr')
                 pager_active_device = None
+                pager_active_sdr_type = None
             return jsonify({'status': 'error', 'message': str(e)})
 
 
 @pager_bp.route('/stop', methods=['POST'])
 def stop_decoding() -> Response:
-    global pager_active_device
+    global pager_active_device, pager_active_sdr_type
 
     with app_module.process_lock:
         if app_module.current_process:
@@ -487,8 +510,9 @@ def stop_decoding() -> Response:
 
             # Release device from registry
             if pager_active_device is not None:
-                app_module.release_sdr_device(pager_active_device)
+                app_module.release_sdr_device(pager_active_device, pager_active_sdr_type or 'rtlsdr')
                 pager_active_device = None
+                pager_active_sdr_type = None
 
             return jsonify({'status': 'stopped'})
 

routes/radiosonde.py

@@ -0,0 +1,682 @@
+"""Radiosonde weather balloon tracking routes.
+
+Uses radiosonde_auto_rx to automatically scan for and decode radiosonde
+telemetry (position, altitude, temperature, humidity, pressure) on the
+400-406 MHz band.  Telemetry arrives as JSON over UDP.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import queue
+import shutil
+import socket
+import subprocess
+import sys
+import threading
+import time
+from typing import Any
+
+from flask import Blueprint, Response, jsonify, request
+
+import app as app_module
+from utils.constants import (
+    MAX_RADIOSONDE_AGE_SECONDS,
+    PROCESS_TERMINATE_TIMEOUT,
+    RADIOSONDE_TERMINATE_TIMEOUT,
+    RADIOSONDE_UDP_PORT,
+    SSE_KEEPALIVE_INTERVAL,
+    SSE_QUEUE_TIMEOUT,
+)
+from utils.gps import is_gpsd_running
+from utils.logging import get_logger
+from utils.sdr import SDRFactory, SDRType
+from utils.sse import sse_stream_fanout
+from utils.validation import (
+    validate_device_index,
+    validate_gain,
+    validate_latitude,
+    validate_longitude,
+)
+
+logger = get_logger('intercept.radiosonde')
+
+radiosonde_bp = Blueprint('radiosonde', __name__, url_prefix='/radiosonde')
+
+# Track radiosonde state
+radiosonde_running = False
+radiosonde_active_device: int | None = None
+radiosonde_active_sdr_type: str | None = None
+
+# Active balloon data: serial -> telemetry dict
+radiosonde_balloons: dict[str, dict[str, Any]] = {}
+_balloons_lock = threading.Lock()
+
+# UDP listener socket reference (so /stop can close it)
+_udp_socket: socket.socket | None = None
+
+# Common installation paths for radiosonde_auto_rx
+AUTO_RX_PATHS = [
+    '/opt/radiosonde_auto_rx/auto_rx/auto_rx.py',
+    '/usr/local/bin/radiosonde_auto_rx',
+    '/opt/auto_rx/auto_rx.py',
+]
+
+
+def find_auto_rx() -> str | None:
+    """Find radiosonde_auto_rx script/binary."""
+    # Check PATH first
+    path = shutil.which('radiosonde_auto_rx')
+    if path:
+        return path
+    # Check common locations
+    for p in AUTO_RX_PATHS:
+        if os.path.isfile(p) and os.access(p, os.X_OK):
+            return p
+    # Check for Python script (not executable but runnable)
+    for p in AUTO_RX_PATHS:
+        if os.path.isfile(p):
+            return p
+    return None
+
+
+def generate_station_cfg(
+    freq_min: float = 400.0,
+    freq_max: float = 406.0,
+    gain: float = 40.0,
+    device_index: int = 0,
+    ppm: int = 0,
+    bias_t: bool = False,
+    udp_port: int = RADIOSONDE_UDP_PORT,
+    latitude: float = 0.0,
+    longitude: float = 0.0,
+    station_alt: float = 0.0,
+    gpsd_enabled: bool = False,
+) -> str:
+    """Generate a station.cfg for radiosonde_auto_rx and return the file path."""
+    cfg_dir = os.path.abspath(os.path.join('data', 'radiosonde'))
+    log_dir = os.path.join(cfg_dir, 'logs')
+    os.makedirs(log_dir, exist_ok=True)
+    cfg_path = os.path.join(cfg_dir, 'station.cfg')
+
+    # Full station.cfg based on radiosonde_auto_rx v1.8+ example config.
+    # All sections and keys included to avoid missing-key crashes.
+    cfg = f"""# Auto-generated by INTERCEPT for radiosonde_auto_rx
+
+[sdr]
+sdr_type = RTLSDR
+sdr_quantity = 1
+sdr_hostname = localhost
+sdr_port = 5555
+
+[sdr_1]
+device_idx = {device_index}
+ppm = {ppm}
+gain = {gain}
+bias = {str(bias_t)}
+
+[search_params]
+min_freq = {freq_min}
+max_freq = {freq_max}
+rx_timeout = 180
+only_scan = []
+never_scan = []
+always_scan = []
+always_decode = []
+
+[location]
+station_lat = {latitude}
+station_lon = {longitude}
+station_alt = {station_alt}
+gpsd_enabled = {str(gpsd_enabled)}
+gpsd_host = localhost
+gpsd_port = 2947
+
+[habitat]
+uploader_callsign = INTERCEPT
+upload_listener_position = False
+uploader_antenna = unknown
+
+[sondehub]
+sondehub_enabled = False
+sondehub_upload_rate = 15
+sondehub_contact_email = none@none.com
+
+[aprs]
+aprs_enabled = False
+aprs_user = N0CALL
+aprs_pass = 00000
+upload_rate = 30
+aprs_server = radiosondy.info
+aprs_port = 14580
+station_beacon_enabled = False
+station_beacon_rate = 30
+station_beacon_comment = radiosonde_auto_rx
+station_beacon_icon = /`
+aprs_object_id = <id>
+aprs_use_custom_object_id = False
+aprs_custom_comment = <type> <freq>
+
+[oziplotter]
+ozi_enabled = False
+ozi_update_rate = 5
+ozi_host = 127.0.0.1
+ozi_port = 8942
+payload_summary_enabled = True
+payload_summary_host = 127.0.0.1
+payload_summary_port = {udp_port}
+
+[email]
+email_enabled = False
+launch_notifications = True
+landing_notifications = True
+encrypted_sonde_notifications = True
+landing_range_threshold = 30
+landing_altitude_threshold = 1000
+error_notifications = False
+smtp_server = localhost
+smtp_port = 25
+smtp_authentication = None
+smtp_login = None
+smtp_password = None
+from = sonde@localhost
+to = none@none.com
+subject = Sonde launch detected
+
+[rotator]
+rotator_enabled = False
+update_rate = 30
+rotation_threshold = 5.0
+rotator_hostname = 127.0.0.1
+rotator_port = 4533
+rotator_homing_enabled = False
+rotator_homing_delay = 10
+rotator_home_azimuth = 0.0
+rotator_home_elevation = 0.0
+azimuth_only = False
+
+[logging]
+per_sonde_log = True
+save_system_log = False
+enable_debug_logging = False
+save_cal_data = False
+
+[web]
+web_host = 127.0.0.1
+web_port = 0
+archive_age = 120
+web_control = False
+web_password = none
+kml_refresh_rate = 10
+
+[debugging]
+save_detection_audio = False
+save_decode_audio = False
+save_decode_iq = False
+save_raw_hex = False
+
+[advanced]
+search_step = 800
+snr_threshold = 10
+max_peaks = 10
+min_distance = 1000
+scan_dwell_time = 20
+detect_dwell_time = 5
+scan_delay = 10
+quantization = 10000
+decoder_spacing_limit = 15000
+temporary_block_time = 120
+max_async_scan_workers = 4
+synchronous_upload = True
+payload_id_valid = 3
+sdr_fm_path = rtl_fm
+sdr_power_path = rtl_power
+ss_iq_path = ./ss_iq
+ss_power_path = ./ss_power
+
+[filtering]
+max_altitude = 50000
+max_radius_km = 1000
+min_radius_km = 0
+radius_temporary_block = False
+sonde_time_threshold = 3
+"""
+
+    with open(cfg_path, 'w') as f:
+        f.write(cfg)
+
+    logger.info(f"Generated station.cfg at {cfg_path}")
+    return cfg_path
+
+
+def parse_radiosonde_udp(udp_port: int) -> None:
+    """Thread function: listen for radiosonde_auto_rx UDP JSON telemetry."""
+    global radiosonde_running, _udp_socket
+
+    logger.info(f"Radiosonde UDP listener started on port {udp_port}")
+
+    try:
+        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        sock.bind(('0.0.0.0', udp_port))
+        sock.settimeout(2.0)
+        _udp_socket = sock
+    except OSError as e:
+        logger.error(f"Failed to bind UDP port {udp_port}: {e}")
+        return
+
+    while radiosonde_running:
+        try:
+            data, _addr = sock.recvfrom(4096)
+        except socket.timeout:
+            # Clean up stale balloons
+            _cleanup_stale_balloons()
+            continue
+        except OSError:
+            break
+
+        try:
+            msg = json.loads(data.decode('utf-8', errors='ignore'))
+        except (json.JSONDecodeError, UnicodeDecodeError):
+            continue
+
+        balloon = _process_telemetry(msg)
+        if balloon:
+            serial = balloon.get('id', '')
+            if serial:
+                with _balloons_lock:
+                    radiosonde_balloons[serial] = balloon
+                try:
+                    app_module.radiosonde_queue.put_nowait({
+                        'type': 'balloon',
+                        **balloon,
+                    })
+                except queue.Full:
+                    pass
+
+    try:
+        sock.close()
+    except OSError:
+        pass
+    _udp_socket = None
+    logger.info("Radiosonde UDP listener stopped")
+
+
+def _process_telemetry(msg: dict) -> dict | None:
+    """Extract relevant fields from a radiosonde_auto_rx UDP telemetry packet."""
+    # auto_rx broadcasts packets with a 'type' field
+    # Telemetry packets have type 'payload_summary' or individual sonde data
+    serial = msg.get('id') or msg.get('serial')
+    if not serial:
+        return None
+
+    balloon: dict[str, Any] = {'id': str(serial)}
+
+    # Sonde type (RS41, RS92, DFM, M10, etc.)
+    if 'type' in msg:
+        balloon['sonde_type'] = msg['type']
+    if 'subtype' in msg:
+        balloon['sonde_type'] = msg['subtype']
+
+    # Timestamp
+    if 'datetime' in msg:
+        balloon['datetime'] = msg['datetime']
+
+    # Position
+    for key in ('lat', 'latitude'):
+        if key in msg:
+            try:
+                balloon['lat'] = float(msg[key])
+            except (ValueError, TypeError):
+                pass
+            break
+    for key in ('lon', 'longitude'):
+        if key in msg:
+            try:
+                balloon['lon'] = float(msg[key])
+            except (ValueError, TypeError):
+                pass
+            break
+
+    # Altitude (metres)
+    if 'alt' in msg:
+        try:
+            balloon['alt'] = float(msg['alt'])
+        except (ValueError, TypeError):
+            pass
+
+    # Meteorological data
+    for field in ('temp', 'humidity', 'pressure'):
+        if field in msg:
+            try:
+                balloon[field] = float(msg[field])
+            except (ValueError, TypeError):
+                pass
+
+    # Velocity
+    if 'vel_h' in msg:
+        try:
+            balloon['vel_h'] = float(msg['vel_h'])
+        except (ValueError, TypeError):
+            pass
+    if 'vel_v' in msg:
+        try:
+            balloon['vel_v'] = float(msg['vel_v'])
+        except (ValueError, TypeError):
+            pass
+    if 'heading' in msg:
+        try:
+            balloon['heading'] = float(msg['heading'])
+        except (ValueError, TypeError):
+            pass
+
+    # GPS satellites
+    if 'sats' in msg:
+        try:
+            balloon['sats'] = int(msg['sats'])
+        except (ValueError, TypeError):
+            pass
+
+    # Battery voltage
+    if 'batt' in msg:
+        try:
+            balloon['batt'] = float(msg['batt'])
+        except (ValueError, TypeError):
+            pass
+
+    # Frequency
+    if 'freq' in msg:
+        try:
+            balloon['freq'] = float(msg['freq'])
+        except (ValueError, TypeError):
+            pass
+
+    balloon['last_seen'] = time.time()
+    return balloon
+
+
+def _cleanup_stale_balloons() -> None:
+    """Remove balloons not seen within the retention window."""
+    now = time.time()
+    with _balloons_lock:
+        stale = [
+            k for k, v in radiosonde_balloons.items()
+            if now - v.get('last_seen', 0) > MAX_RADIOSONDE_AGE_SECONDS
+        ]
+        for k in stale:
+            del radiosonde_balloons[k]
+
+
+@radiosonde_bp.route('/tools')
+def check_tools():
+    """Check for radiosonde decoding tools and hardware."""
+    auto_rx_path = find_auto_rx()
+    devices = SDRFactory.detect_devices()
+    has_rtlsdr = any(d.sdr_type == SDRType.RTL_SDR for d in devices)
+
+    return jsonify({
+        'auto_rx': auto_rx_path is not None,
+        'auto_rx_path': auto_rx_path,
+        'has_rtlsdr': has_rtlsdr,
+        'device_count': len(devices),
+    })
+
+
+@radiosonde_bp.route('/status')
+def radiosonde_status():
+    """Get radiosonde tracking status."""
+    process_running = False
+    if app_module.radiosonde_process:
+        process_running = app_module.radiosonde_process.poll() is None
+
+    with _balloons_lock:
+        balloon_count = len(radiosonde_balloons)
+        balloons_snapshot = dict(radiosonde_balloons)
+
+    return jsonify({
+        'tracking_active': radiosonde_running,
+        'active_device': radiosonde_active_device,
+        'balloon_count': balloon_count,
+        'balloons': balloons_snapshot,
+        'queue_size': app_module.radiosonde_queue.qsize(),
+        'auto_rx_path': find_auto_rx(),
+        'process_running': process_running,
+    })
+
+
+@radiosonde_bp.route('/start', methods=['POST'])
+def start_radiosonde():
+    """Start radiosonde tracking."""
+    global radiosonde_running, radiosonde_active_device, radiosonde_active_sdr_type
+
+    with app_module.radiosonde_lock:
+        if radiosonde_running:
+            return jsonify({
+                'status': 'already_running',
+                'message': 'Radiosonde tracking already active',
+            }), 409
+
+    data = request.json or {}
+
+    # Validate inputs
+    try:
+        gain = float(validate_gain(data.get('gain', '40')))
+        device = validate_device_index(data.get('device', '0'))
+    except ValueError as e:
+        return jsonify({'status': 'error', 'message': str(e)}), 400
+
+    freq_min = data.get('freq_min', 400.0)
+    freq_max = data.get('freq_max', 406.0)
+    try:
+        freq_min = float(freq_min)
+        freq_max = float(freq_max)
+        if not (380.0 <= freq_min <= 410.0) or not (380.0 <= freq_max <= 410.0):
+            raise ValueError("Frequency out of range")
+        if freq_min >= freq_max:
+            raise ValueError("Min frequency must be less than max")
+    except (ValueError, TypeError) as e:
+        return jsonify({'status': 'error', 'message': f'Invalid frequency range: {e}'}), 400
+
+    bias_t = data.get('bias_t', False)
+    ppm = int(data.get('ppm', 0))
+
+    # Validate optional location
+    latitude = 0.0
+    longitude = 0.0
+    if data.get('latitude') is not None and data.get('longitude') is not None:
+        try:
+            latitude = validate_latitude(data['latitude'])
+            longitude = validate_longitude(data['longitude'])
+        except ValueError:
+            latitude = 0.0
+            longitude = 0.0
+
+    # Check if gpsd is available for live position updates
+    gpsd_enabled = is_gpsd_running()
+
+    # Find auto_rx
+    auto_rx_path = find_auto_rx()
+    if not auto_rx_path:
+        return jsonify({
+            'status': 'error',
+            'message': 'radiosonde_auto_rx not found. Install from https://github.com/projecthorus/radiosonde_auto_rx',
+        }), 400
+
+    # Get SDR type
+    sdr_type_str = data.get('sdr_type', 'rtlsdr')
+
+    # Kill any existing process
+    if app_module.radiosonde_process:
+        try:
+            pgid = os.getpgid(app_module.radiosonde_process.pid)
+            os.killpg(pgid, 15)
+            app_module.radiosonde_process.wait(timeout=PROCESS_TERMINATE_TIMEOUT)
+        except (subprocess.TimeoutExpired, ProcessLookupError, OSError):
+            try:
+                pgid = os.getpgid(app_module.radiosonde_process.pid)
+                os.killpg(pgid, 9)
+            except (ProcessLookupError, OSError):
+                pass
+        app_module.radiosonde_process = None
+        logger.info("Killed existing radiosonde process")
+
+    # Claim SDR device
+    device_int = int(device)
+    error = app_module.claim_sdr_device(device_int, 'radiosonde', sdr_type_str)
+    if error:
+        return jsonify({
+            'status': 'error',
+            'error_type': 'DEVICE_BUSY',
+            'message': error,
+        }), 409
+
+    # Generate config
+    cfg_path = generate_station_cfg(
+        freq_min=freq_min,
+        freq_max=freq_max,
+        gain=gain,
+        device_index=device_int,
+        ppm=ppm,
+        bias_t=bias_t,
+        latitude=latitude,
+        longitude=longitude,
+        gpsd_enabled=gpsd_enabled,
+    )
+
+    # Build command - auto_rx -c expects a file path, not a directory
+    cfg_abs = os.path.abspath(cfg_path)
+    if auto_rx_path.endswith('.py'):
+        cmd = [sys.executable, auto_rx_path, '-c', cfg_abs]
+    else:
+        cmd = [auto_rx_path, '-c', cfg_abs]
+
+    # Set cwd to the auto_rx directory so 'from autorx.scan import ...' works
+    auto_rx_dir = os.path.dirname(os.path.abspath(auto_rx_path))
+
+    try:
+        logger.info(f"Starting radiosonde_auto_rx: {' '.join(cmd)}")
+        app_module.radiosonde_process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.PIPE,
+            start_new_session=True,
+            cwd=auto_rx_dir,
+        )
+
+        # Wait briefly for process to start
+        time.sleep(2.0)
+
+        if app_module.radiosonde_process.poll() is not None:
+            app_module.release_sdr_device(device_int, sdr_type_str)
+            stderr_output = ''
+            if app_module.radiosonde_process.stderr:
+                try:
+                    stderr_output = app_module.radiosonde_process.stderr.read().decode(
+                        'utf-8', errors='ignore'
+                    ).strip()
+                except Exception:
+                    pass
+            error_msg = 'radiosonde_auto_rx failed to start. Check SDR device connection.'
+            if stderr_output:
+                error_msg += f' Error: {stderr_output[:200]}'
+            return jsonify({'status': 'error', 'message': error_msg}), 500
+
+        radiosonde_running = True
+        radiosonde_active_device = device_int
+        radiosonde_active_sdr_type = sdr_type_str
+
+        # Clear stale data
+        with _balloons_lock:
+            radiosonde_balloons.clear()
+
+        # Start UDP listener thread
+        udp_thread = threading.Thread(
+            target=parse_radiosonde_udp,
+            args=(RADIOSONDE_UDP_PORT,),
+            daemon=True,
+        )
+        udp_thread.start()
+
+        return jsonify({
+            'status': 'started',
+            'message': 'Radiosonde tracking started',
+            'device': device,
+        })
+    except Exception as e:
+        app_module.release_sdr_device(device_int, sdr_type_str)
+        logger.error(f"Failed to start radiosonde_auto_rx: {e}")
+        return jsonify({'status': 'error', 'message': str(e)}), 500
+
+
+@radiosonde_bp.route('/stop', methods=['POST'])
+def stop_radiosonde():
+    """Stop radiosonde tracking."""
+    global radiosonde_running, radiosonde_active_device, radiosonde_active_sdr_type, _udp_socket
+
+    with app_module.radiosonde_lock:
+        if app_module.radiosonde_process:
+            try:
+                pgid = os.getpgid(app_module.radiosonde_process.pid)
+                os.killpg(pgid, 15)
+                app_module.radiosonde_process.wait(timeout=RADIOSONDE_TERMINATE_TIMEOUT)
+            except (subprocess.TimeoutExpired, ProcessLookupError, OSError):
+                try:
+                    pgid = os.getpgid(app_module.radiosonde_process.pid)
+                    os.killpg(pgid, 9)
+                except (ProcessLookupError, OSError):
+                    pass
+            app_module.radiosonde_process = None
+            logger.info("Radiosonde process stopped")
+
+        # Close UDP socket to unblock listener thread
+        if _udp_socket:
+            try:
+                _udp_socket.close()
+            except OSError:
+                pass
+            _udp_socket = None
+
+        # Release SDR device
+        if radiosonde_active_device is not None:
+            app_module.release_sdr_device(
+                radiosonde_active_device,
+                radiosonde_active_sdr_type or 'rtlsdr',
+            )
+
+        radiosonde_running = False
+        radiosonde_active_device = None
+        radiosonde_active_sdr_type = None
+
+    with _balloons_lock:
+        radiosonde_balloons.clear()
+
+    return jsonify({'status': 'stopped'})
+
+
+@radiosonde_bp.route('/stream')
+def stream_radiosonde():
+    """SSE stream for radiosonde telemetry."""
+    response = Response(
+        sse_stream_fanout(
+            source_queue=app_module.radiosonde_queue,
+            channel_key='radiosonde',
+            timeout=SSE_QUEUE_TIMEOUT,
+            keepalive_interval=SSE_KEEPALIVE_INTERVAL,
+        ),
+        mimetype='text/event-stream',
+    )
+    response.headers['Cache-Control'] = 'no-cache'
+    response.headers['X-Accel-Buffering'] = 'no'
+    return response
+
+
+@radiosonde_bp.route('/balloons')
+def get_balloons():
+    """Get current balloon data."""
+    with _balloons_lock:
+        return jsonify({
+            'status': 'success',
+            'count': len(radiosonde_balloons),
+            'balloons': dict(radiosonde_balloons),
+        })

routes/rtlamr.py

@@ -138,6 +138,8 @@ def start_rtlamr() -> Response:
         output_format = data.get('format', 'json')
         
         # Start rtl_tcp first
+        rtl_tcp_just_started = False
+        rtl_tcp_cmd_str = ''
         with rtl_tcp_lock:
             if not rtl_tcp_process:
                 logger.info("Starting rtl_tcp server...")
@@ -162,12 +164,8 @@ def start_rtlamr() -> Response:
                         stderr=subprocess.PIPE
                     )
                     register_process(rtl_tcp_process)
-
+                    rtl_tcp_just_started = True
-                    # Wait a moment for rtl_tcp to start
+                    rtl_tcp_cmd_str = ' '.join(rtl_tcp_cmd)
-                    time.sleep(3)
-                    
-                    logger.info(f"rtl_tcp started: {' '.join(rtl_tcp_cmd)}")
-                    app_module.rtlamr_queue.put({'type': 'info', 'text': f'rtl_tcp: {" ".join(rtl_tcp_cmd)}'})
                 except Exception as e:
                     logger.error(f"Failed to start rtl_tcp: {e}")
                     # Release SDR device on rtl_tcp failure
@@ -176,6 +174,12 @@ def start_rtlamr() -> Response:
                         rtlamr_active_device = None
                     return jsonify({'status': 'error', 'message': f'Failed to start rtl_tcp: {e}'}), 500
 
+        # Wait for rtl_tcp to start outside lock
+        if rtl_tcp_just_started:
+            time.sleep(3)
+            logger.info(f"rtl_tcp started: {rtl_tcp_cmd_str}")
+            app_module.rtlamr_queue.put({'type': 'info', 'text': f'rtl_tcp: {rtl_tcp_cmd_str}'})
+
         # Build rtlamr command
         cmd = [
             'rtlamr',
@@ -258,24 +262,33 @@ def start_rtlamr() -> Response:
 def stop_rtlamr() -> Response:
     global rtl_tcp_process, rtlamr_active_device
 
+    # Grab process refs inside locks, clear state, then terminate outside
+    rtlamr_proc = None
     with app_module.rtlamr_lock:
         if app_module.rtlamr_process:
-            app_module.rtlamr_process.terminate()
+            rtlamr_proc = app_module.rtlamr_process
-            try:
-                app_module.rtlamr_process.wait(timeout=2)
-            except subprocess.TimeoutExpired:
-                app_module.rtlamr_process.kill()
             app_module.rtlamr_process = None
 
+    if rtlamr_proc:
+        rtlamr_proc.terminate()
+        try:
+            rtlamr_proc.wait(timeout=2)
+        except subprocess.TimeoutExpired:
+            rtlamr_proc.kill()
+
     # Also stop rtl_tcp
+    tcp_proc = None
     with rtl_tcp_lock:
         if rtl_tcp_process:
-            rtl_tcp_process.terminate()
+            tcp_proc = rtl_tcp_process
-            try:
-                rtl_tcp_process.wait(timeout=2)
-            except subprocess.TimeoutExpired:
-                rtl_tcp_process.kill()
             rtl_tcp_process = None
+
+    if tcp_proc:
+        tcp_proc.terminate()
+        try:
+            tcp_proc.wait(timeout=2)
+        except subprocess.TimeoutExpired:
+            tcp_proc.kill()
         logger.info("rtl_tcp stopped")
 
     # Release device from registry

routes/satellite.py

@@ -166,9 +166,11 @@ def _fetch_iss_realtime(observer_lat: Optional[float] = None, observer_lon: Opti
 @satellite_bp.route('/dashboard')
 def satellite_dashboard():
     """Popout satellite tracking dashboard."""
+    embedded = request.args.get('embedded', 'false') == 'true'
     return render_template(
         'satellite_dashboard.html',
         shared_observer_location=SHARED_OBSERVER_LOCATION_ENABLED,
+        embedded=embedded,
     )
 
 
@@ -588,14 +590,14 @@ def list_tracked_satellites():
 def add_tracked_satellites_endpoint():
     """Add one or more tracked satellites."""
     global _tle_cache
-    data = request.json
+    data = request.get_json(silent=True)
     if not data:
         return jsonify({'status': 'error', 'message': 'No data provided'}), 400
 
     # Accept a single satellite dict or a list
     sat_list = data if isinstance(data, list) else [data]
 
-    added = 0
+    normalized: list[dict] = []
     for sat in sat_list:
         norad_id = str(sat.get('norad_id', sat.get('norad', '')))
         name = sat.get('name', '')
@@ -605,19 +607,46 @@ def add_tracked_satellites_endpoint():
         tle2 = sat.get('tle_line2', sat.get('tle2'))
         enabled = sat.get('enabled', True)
 
-        if add_tracked_satellite(norad_id, name, tle1, tle2, enabled):
+        normalized.append({
-            added += 1
+            'norad_id': norad_id,
+            'name': name,
+            'tle_line1': tle1,
+            'tle_line2': tle2,
+            'enabled': bool(enabled),
+            'builtin': False,
+        })
 
         # Also inject into TLE cache if we have TLE data
         if tle1 and tle2:
             cache_key = name.replace(' ', '-').upper()
             _tle_cache[cache_key] = (name, tle1, tle2)
 
-    return jsonify({
+    # Single inserts preserve previous behavior; list inserts use DB-level bulk path.
+    if len(normalized) == 1:
+        sat = normalized[0]
+        added = 1 if add_tracked_satellite(
+            sat['norad_id'],
+            sat['name'],
+            sat.get('tle_line1'),
+            sat.get('tle_line2'),
+            sat.get('enabled', True),
+            sat.get('builtin', False),
+        ) else 0
+    else:
+        added = bulk_add_tracked_satellites(normalized)
+
+    response_payload = {
         'status': 'success',
         'added': added,
-        'satellites': get_tracked_satellites(),
+        'processed': len(normalized),
-    })
+    }
+
+    # Returning all tracked satellites for very large imports can stall the UI.
+    include_satellites = request.args.get('include_satellites', '').lower() == 'true'
+    if include_satellites or len(normalized) <= 32:
+        response_payload['satellites'] = get_tracked_satellites()
+
+    return jsonify(response_payload)
 
 
 @satellite_bp.route('/tracked/<norad_id>', methods=['PUT'])

routes/sensor.py

@@ -3,12 +3,13 @@
 from __future__ import annotations
 
 import json
+import math
 import queue
 import subprocess
 import threading
 import time
 from datetime import datetime
-from typing import Generator
+from typing import Any, Generator
 
 from flask import Blueprint, jsonify, request, Response
 
@@ -27,12 +28,43 @@ sensor_bp = Blueprint('sensor', __name__)
 
 # Track which device is being used
 sensor_active_device: int | None = None
+sensor_active_sdr_type: str | None = None
 
 # RSSI history per device (model_id -> list of (timestamp, rssi))
 sensor_rssi_history: dict[str, list[tuple[float, float]]] = {}
 _MAX_RSSI_HISTORY = 60
 
 
+def _build_scope_waveform(rssi: float, snr: float, noise: float, points: int = 256) -> list[int]:
+    """Synthesize a compact waveform from rtl_433 level metrics."""
+    points = max(32, min(points, 512))
+
+    # rssi is usually negative; stronger signals are closer to 0 dBm.
+    rssi_norm = min(max(abs(rssi) / 40.0, 0.0), 1.0)
+    snr_norm = min(max((snr + 5.0) / 35.0, 0.0), 1.0)
+    noise_norm = min(max(abs(noise) / 40.0, 0.0), 1.0)
+
+    amplitude = max(0.06, min(1.0, (0.6 * rssi_norm + 0.4 * snr_norm) - (0.22 * noise_norm)))
+    cycles = 3.0 + (snr_norm * 8.0)
+    harmonic = 0.25 + (0.35 * snr_norm)
+    hiss = 0.08 + (0.18 * noise_norm)
+    phase = (time.monotonic() * (1.4 + (snr_norm * 2.2))) % (2.0 * math.pi)
+
+    waveform: list[int] = []
+    for i in range(points):
+        t = i / (points - 1)
+        base = math.sin((2.0 * math.pi * cycles * t) + phase)
+        overtone = math.sin((2.0 * math.pi * (cycles * 2.4) * t) + (phase * 0.7))
+        noise_wobble = math.sin((2.0 * math.pi * (cycles * 7.0) * t) + (phase * 2.1))
+
+        sample = amplitude * (base + (harmonic * overtone) + (hiss * noise_wobble))
+        sample /= (1.0 + harmonic + hiss)
+        packed = int(round(max(-1.0, min(1.0, sample)) * 127.0))
+        waveform.append(max(-127, min(127, packed)))
+
+    return waveform
+
+
 def stream_sensor_output(process: subprocess.Popen[bytes]) -> None:
     """Stream rtl_433 JSON output to queue."""
     try:
@@ -66,13 +98,21 @@ def stream_sensor_output(process: subprocess.Popen[bytes]) -> None:
                 noise = data.get('noise')
                 if rssi is not None or snr is not None:
                     try:
+                        rssi_value = float(rssi) if rssi is not None else 0.0
+                        snr_value = float(snr) if snr is not None else 0.0
+                        noise_value = float(noise) if noise is not None else 0.0
                         app_module.sensor_queue.put_nowait({
                             'type': 'scope',
-                            'rssi': rssi if rssi is not None else 0,
+                            'rssi': rssi_value,
-                            'snr': snr if snr is not None else 0,
+                            'snr': snr_value,
-                            'noise': noise if noise is not None else 0,
+                            'noise': noise_value,
+                            'waveform': _build_scope_waveform(
+                                rssi=rssi_value,
+                                snr=snr_value,
+                                noise=noise_value,
+                            ),
                         })
-                    except queue.Full:
+                    except (TypeError, ValueError, queue.Full):
                         pass
 
                 # Log if enabled
@@ -90,7 +130,7 @@ def stream_sensor_output(process: subprocess.Popen[bytes]) -> None:
     except Exception as e:
         app_module.sensor_queue.put({'type': 'error', 'text': str(e)})
     finally:
-        global sensor_active_device
+        global sensor_active_device, sensor_active_sdr_type
         # Ensure process is terminated
         try:
             process.terminate()
@@ -106,8 +146,9 @@ def stream_sensor_output(process: subprocess.Popen[bytes]) -> None:
             app_module.sensor_process = None
         # Release SDR device
         if sensor_active_device is not None:
-            app_module.release_sdr_device(sensor_active_device)
+            app_module.release_sdr_device(sensor_active_device, sensor_active_sdr_type or 'rtlsdr')
             sensor_active_device = None
+            sensor_active_sdr_type = None
 
 
 @sensor_bp.route('/sensor/status')
@@ -120,7 +161,7 @@ def sensor_status() -> Response:
 
 @sensor_bp.route('/start_sensor', methods=['POST'])
 def start_sensor() -> Response:
-    global sensor_active_device
+    global sensor_active_device, sensor_active_sdr_type
 
     with app_module.sensor_lock:
         if app_module.sensor_process:
@@ -141,10 +182,13 @@ def start_sensor() -> Response:
         rtl_tcp_host = data.get('rtl_tcp_host')
         rtl_tcp_port = data.get('rtl_tcp_port', 1234)
 
+        # Get SDR type early so we can pass it to claim/release
+        sdr_type_str = data.get('sdr_type', 'rtlsdr')
+
         # Claim local device if not using remote rtl_tcp
         if not rtl_tcp_host:
             device_int = int(device)
-            error = app_module.claim_sdr_device(device_int, 'sensor')
+            error = app_module.claim_sdr_device(device_int, 'sensor', sdr_type_str)
             if error:
                 return jsonify({
                     'status': 'error',
@@ -152,6 +196,7 @@ def start_sensor() -> Response:
                     'message': error
                 }), 409
             sensor_active_device = device_int
+            sensor_active_sdr_type = sdr_type_str
 
         # Clear queue
         while not app_module.sensor_queue.empty():
@@ -160,8 +205,7 @@ def start_sensor() -> Response:
             except queue.Empty:
                 break
 
-        # Get SDR type and build command via abstraction layer
+        # Build command via SDR abstraction layer
-        sdr_type_str = data.get('sdr_type', 'rtlsdr')
         try:
             sdr_type = SDRType(sdr_type_str)
         except ValueError:
@@ -238,20 +282,22 @@ def start_sensor() -> Response:
         except FileNotFoundError:
             # Release device on failure
             if sensor_active_device is not None:
-                app_module.release_sdr_device(sensor_active_device)
+                app_module.release_sdr_device(sensor_active_device, sensor_active_sdr_type or 'rtlsdr')
                 sensor_active_device = None
+                sensor_active_sdr_type = None
             return jsonify({'status': 'error', 'message': 'rtl_433 not found. Install with: brew install rtl_433'})
         except Exception as e:
             # Release device on failure
             if sensor_active_device is not None:
-                app_module.release_sdr_device(sensor_active_device)
+                app_module.release_sdr_device(sensor_active_device, sensor_active_sdr_type or 'rtlsdr')
                 sensor_active_device = None
+                sensor_active_sdr_type = None
             return jsonify({'status': 'error', 'message': str(e)})
 
 
 @sensor_bp.route('/stop_sensor', methods=['POST'])
 def stop_sensor() -> Response:
-    global sensor_active_device
+    global sensor_active_device, sensor_active_sdr_type
 
     with app_module.sensor_lock:
         if app_module.sensor_process:
@@ -264,8 +310,9 @@ def stop_sensor() -> Response:
 
             # Release device from registry
             if sensor_active_device is not None:
-                app_module.release_sdr_device(sensor_active_device)
+                app_module.release_sdr_device(sensor_active_device, sensor_active_sdr_type or 'rtlsdr')
                 sensor_active_device = None
+                sensor_active_sdr_type = None
 
             return jsonify({'status': 'stopped'})
 

routes/signalid.py

@@ -0,0 +1,352 @@
+"""Signal identification enrichment routes (SigID Wiki proxy lookup)."""
+
+from __future__ import annotations
+
+import json
+import time
+import urllib.parse
+import urllib.request
+from typing import Any
+
+from flask import Blueprint, Response, jsonify, request
+
+from utils.logging import get_logger
+
+logger = get_logger('intercept.signalid')
+
+signalid_bp = Blueprint('signalid', __name__, url_prefix='/signalid')
+
+SIGID_API_URL = 'https://www.sigidwiki.com/api.php'
+SIGID_USER_AGENT = 'INTERCEPT-SignalID/1.0'
+SIGID_TIMEOUT_SECONDS = 12
+SIGID_CACHE_TTL_SECONDS = 600
+
+_cache: dict[str, dict[str, Any]] = {}
+
+
+def _cache_get(key: str) -> Any | None:
+    entry = _cache.get(key)
+    if not entry:
+        return None
+    if time.time() >= entry['expires']:
+        _cache.pop(key, None)
+        return None
+    return entry['data']
+
+
+def _cache_set(key: str, data: Any, ttl_seconds: int = SIGID_CACHE_TTL_SECONDS) -> None:
+    _cache[key] = {
+        'data': data,
+        'expires': time.time() + ttl_seconds,
+    }
+
+
+def _fetch_api_json(params: dict[str, str]) -> dict[str, Any] | None:
+    query = urllib.parse.urlencode(params, doseq=True)
+    url = f'{SIGID_API_URL}?{query}'
+    req = urllib.request.Request(url, headers={'User-Agent': SIGID_USER_AGENT})
+    try:
+        with urllib.request.urlopen(req, timeout=SIGID_TIMEOUT_SECONDS) as resp:
+            payload = resp.read().decode('utf-8', errors='replace')
+        data = json.loads(payload)
+    except Exception as exc:
+        logger.warning('SigID API request failed: %s', exc)
+        return None
+    if isinstance(data, dict) and data.get('error'):
+        logger.warning('SigID API returned error: %s', data.get('error'))
+        return None
+    return data if isinstance(data, dict) else None
+
+
+def _ask_query(query: str) -> dict[str, Any] | None:
+    return _fetch_api_json({
+        'action': 'ask',
+        'query': query,
+        'format': 'json',
+    })
+
+
+def _search_query(search_text: str, limit: int) -> dict[str, Any] | None:
+    return _fetch_api_json({
+        'action': 'query',
+        'list': 'search',
+        'srsearch': search_text,
+        'srlimit': str(limit),
+        'format': 'json',
+    })
+
+
+def _to_float_list(values: Any) -> list[float]:
+    if not isinstance(values, list):
+        return []
+    out: list[float] = []
+    for value in values:
+        try:
+            out.append(float(value))
+        except (TypeError, ValueError):
+            continue
+    return out
+
+
+def _to_text_list(values: Any) -> list[str]:
+    if not isinstance(values, list):
+        return []
+    out: list[str] = []
+    for value in values:
+        text = str(value or '').strip()
+        if text:
+            out.append(text)
+    return out
+
+
+def _normalize_modes(values: list[str]) -> list[str]:
+    out: list[str] = []
+    for value in values:
+        for token in str(value).replace('/', ',').split(','):
+            mode = token.strip().upper()
+            if mode and mode not in out:
+                out.append(mode)
+    return out
+
+
+def _extract_matches_from_ask(data: dict[str, Any]) -> list[dict[str, Any]]:
+    results = data.get('query', {}).get('results', {})
+    if not isinstance(results, dict):
+        return []
+
+    matches: list[dict[str, Any]] = []
+    for title, entry in results.items():
+        if not isinstance(entry, dict):
+            continue
+
+        printouts = entry.get('printouts', {})
+        if not isinstance(printouts, dict):
+            printouts = {}
+
+        frequencies_hz = _to_float_list(printouts.get('Frequencies'))
+        frequencies_mhz = [round(v / 1e6, 6) for v in frequencies_hz if v > 0]
+
+        modes = _normalize_modes(_to_text_list(printouts.get('Mode')))
+        modulations = _normalize_modes(_to_text_list(printouts.get('Modulation')))
+
+        match = {
+            'title': str(entry.get('fulltext') or title),
+            'url': str(entry.get('fullurl') or ''),
+            'frequencies_mhz': frequencies_mhz,
+            'modes': modes,
+            'modulations': modulations,
+            'source': 'SigID Wiki',
+        }
+        matches.append(match)
+
+    return matches
+
+
+def _dedupe_matches(matches: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    deduped: dict[str, dict[str, Any]] = {}
+    for match in matches:
+        key = f"{match.get('title', '')}|{match.get('url', '')}"
+        if key not in deduped:
+            deduped[key] = match
+            continue
+
+        # Merge frequencies/modes/modulations from duplicates.
+        existing = deduped[key]
+        for field in ('frequencies_mhz', 'modes', 'modulations'):
+            base = existing.get(field, [])
+            extra = match.get(field, [])
+            if not isinstance(base, list):
+                base = []
+            if not isinstance(extra, list):
+                extra = []
+            merged = list(base)
+            for item in extra:
+                if item not in merged:
+                    merged.append(item)
+            existing[field] = merged
+    return list(deduped.values())
+
+
+def _rank_matches(
+    matches: list[dict[str, Any]],
+    *,
+    frequency_mhz: float,
+    modulation: str,
+) -> list[dict[str, Any]]:
+    target_hz = frequency_mhz * 1e6
+    wanted_mod = str(modulation or '').strip().upper()
+
+    def score(match: dict[str, Any]) -> tuple[int, float, str]:
+        score_value = 0
+        freqs_mhz = match.get('frequencies_mhz') or []
+        distances_hz: list[float] = []
+        for f_mhz in freqs_mhz:
+            try:
+                distances_hz.append(abs((float(f_mhz) * 1e6) - target_hz))
+            except (TypeError, ValueError):
+                continue
+        min_distance_hz = min(distances_hz) if distances_hz else 1e12
+
+        if min_distance_hz <= 100:
+            score_value += 120
+        elif min_distance_hz <= 1_000:
+            score_value += 90
+        elif min_distance_hz <= 10_000:
+            score_value += 70
+        elif min_distance_hz <= 100_000:
+            score_value += 40
+
+        if wanted_mod:
+            modes = [str(v).upper() for v in (match.get('modes') or [])]
+            modulations = [str(v).upper() for v in (match.get('modulations') or [])]
+            if wanted_mod in modes:
+                score_value += 25
+            if wanted_mod in modulations:
+                score_value += 25
+
+        title = str(match.get('title') or '')
+        title_lower = title.lower()
+        if 'unidentified' in title_lower or 'unknown' in title_lower:
+            score_value -= 10
+
+        return (score_value, min_distance_hz, title.lower())
+
+    ranked = sorted(matches, key=score, reverse=True)
+    for match in ranked:
+        try:
+            nearest = min(abs((float(f) * 1e6) - target_hz) for f in (match.get('frequencies_mhz') or []))
+            match['distance_hz'] = int(round(nearest))
+        except Exception:
+            match['distance_hz'] = None
+    return ranked
+
+
+def _format_freq_variants_mhz(freq_mhz: float) -> list[str]:
+    variants = [
+        f'{freq_mhz:.6f}'.rstrip('0').rstrip('.'),
+        f'{freq_mhz:.4f}'.rstrip('0').rstrip('.'),
+        f'{freq_mhz:.3f}'.rstrip('0').rstrip('.'),
+    ]
+    out: list[str] = []
+    for value in variants:
+        if value and value not in out:
+            out.append(value)
+    return out
+
+
+def _lookup_sigidwiki_matches(frequency_mhz: float, modulation: str, limit: int) -> dict[str, Any]:
+    all_matches: list[dict[str, Any]] = []
+    exact_queries: list[str] = []
+
+    for freq_token in _format_freq_variants_mhz(frequency_mhz):
+        query = (
+            f'[[Category:Signal]][[Frequencies::{freq_token} MHz]]'
+            f'|?Frequencies|?Mode|?Modulation|limit={max(10, limit * 2)}'
+        )
+        exact_queries.append(query)
+        data = _ask_query(query)
+        if data:
+            all_matches.extend(_extract_matches_from_ask(data))
+        if all_matches:
+            break
+
+    search_used = False
+    if not all_matches:
+        search_used = True
+        search_terms = [f'{frequency_mhz:.4f} MHz']
+        if modulation:
+            search_terms.insert(0, f'{frequency_mhz:.4f} MHz {modulation.upper()}')
+
+        seen_titles: set[str] = set()
+        for term in search_terms:
+            search_data = _search_query(term, max(5, min(limit * 2, 10)))
+            search_results = search_data.get('query', {}).get('search', []) if isinstance(search_data, dict) else []
+            if not isinstance(search_results, list) or not search_results:
+                continue
+
+            for item in search_results:
+                title = str(item.get('title') or '').strip()
+                if not title or title in seen_titles:
+                    continue
+                seen_titles.add(title)
+                page_query = f'[[{title}]]|?Frequencies|?Mode|?Modulation|limit=1'
+                page_data = _ask_query(page_query)
+                if page_data:
+                    all_matches.extend(_extract_matches_from_ask(page_data))
+                if len(all_matches) >= max(limit * 3, 12):
+                    break
+            if all_matches:
+                break
+
+    deduped = _dedupe_matches(all_matches)
+    ranked = _rank_matches(deduped, frequency_mhz=frequency_mhz, modulation=modulation)
+    return {
+        'matches': ranked[:limit],
+        'search_used': search_used,
+        'exact_queries': exact_queries,
+    }
+
+
+@signalid_bp.route('/sigidwiki', methods=['POST'])
+def sigidwiki_lookup() -> Response:
+    """Lookup likely signal types from SigID Wiki by tuned frequency."""
+    payload = request.get_json(silent=True) or {}
+
+    freq_raw = payload.get('frequency_mhz')
+    if freq_raw is None:
+        return jsonify({'status': 'error', 'message': 'frequency_mhz is required'}), 400
+
+    try:
+        frequency_mhz = float(freq_raw)
+    except (TypeError, ValueError):
+        return jsonify({'status': 'error', 'message': 'Invalid frequency_mhz'}), 400
+
+    if frequency_mhz <= 0:
+        return jsonify({'status': 'error', 'message': 'frequency_mhz must be positive'}), 400
+
+    modulation = str(payload.get('modulation') or '').strip().upper()
+    if modulation and len(modulation) > 16:
+        modulation = modulation[:16]
+
+    limit_raw = payload.get('limit', 8)
+    try:
+        limit = int(limit_raw)
+    except (TypeError, ValueError):
+        limit = 8
+    limit = max(1, min(limit, 20))
+
+    cache_key = f'{round(frequency_mhz, 6)}|{modulation}|{limit}'
+    cached = _cache_get(cache_key)
+    if cached is not None:
+        return jsonify({
+            'status': 'ok',
+            'source': 'sigidwiki',
+            'frequency_mhz': round(frequency_mhz, 6),
+            'modulation': modulation or None,
+            'cached': True,
+            **cached,
+        })
+
+    try:
+        lookup = _lookup_sigidwiki_matches(frequency_mhz, modulation, limit)
+    except Exception as exc:
+        logger.error('SigID lookup failed: %s', exc)
+        return jsonify({'status': 'error', 'message': 'SigID lookup failed'}), 502
+
+    response_payload = {
+        'matches': lookup.get('matches', []),
+        'match_count': len(lookup.get('matches', [])),
+        'search_used': bool(lookup.get('search_used')),
+        'exact_queries': lookup.get('exact_queries', []),
+    }
+    _cache_set(cache_key, response_payload)
+
+    return jsonify({
+        'status': 'ok',
+        'source': 'sigidwiki',
+        'frequency_mhz': round(frequency_mhz, 6),
+        'modulation': modulation or None,
+        'cached': False,
+        **response_payload,
+    })
+

routes/subghz.py

@@ -13,6 +13,7 @@ from flask import Blueprint, jsonify, request, Response, send_file
 from utils.logging import get_logger
 from utils.sse import sse_stream
 from utils.subghz import get_subghz_manager
+from utils.event_pipeline import process_event
 from utils.constants import (
     SUBGHZ_FREQ_MIN_MHZ,
     SUBGHZ_FREQ_MAX_MHZ,
@@ -34,6 +35,10 @@ _subghz_queue: queue.Queue = queue.Queue(maxsize=200)
 
 def _event_callback(event: dict) -> None:
     """Forward SubGhzManager events to the SSE queue."""
+    try:
+        process_event('subghz', event, event.get('type'))
+    except Exception:
+        pass
     try:
         _subghz_queue.put_nowait(event)
     except queue.Full:

routes/system.py

@@ -0,0 +1,583 @@
+"""System Health monitoring blueprint.
+
+Provides real-time system metrics (CPU, memory, disk, temperatures,
+network, battery, fans), active process status, SDR device enumeration,
+location, and weather data via SSE streaming and REST endpoints.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import os
+import platform
+import queue
+import socket
+import subprocess
+import threading
+import time
+from pathlib import Path
+from typing import Any
+
+from flask import Blueprint, Response, jsonify, request
+
+from utils.constants import SSE_KEEPALIVE_INTERVAL, SSE_QUEUE_TIMEOUT
+from utils.logging import sensor_logger as logger
+from utils.sse import sse_stream_fanout
+
+try:
+    import psutil
+
+    _HAS_PSUTIL = True
+except ImportError:
+    psutil = None  # type: ignore[assignment]
+    _HAS_PSUTIL = False
+
+try:
+    import requests as _requests
+except ImportError:
+    _requests = None  # type: ignore[assignment]
+
+system_bp = Blueprint('system', __name__, url_prefix='/system')
+
+# ---------------------------------------------------------------------------
+# Background metrics collector
+# ---------------------------------------------------------------------------
+
+_metrics_queue: queue.Queue = queue.Queue(maxsize=500)
+_collector_started = False
+_collector_lock = threading.Lock()
+_app_start_time: float | None = None
+
+# Weather cache
+_weather_cache: dict[str, Any] = {}
+_weather_cache_time: float = 0.0
+_WEATHER_CACHE_TTL = 600  # 10 minutes
+
+
+def _get_app_start_time() -> float:
+    """Return the application start timestamp from the main app module."""
+    global _app_start_time
+    if _app_start_time is None:
+        try:
+            import app as app_module
+
+            _app_start_time = getattr(app_module, '_app_start_time', time.time())
+        except Exception:
+            _app_start_time = time.time()
+    return _app_start_time
+
+
+def _get_app_version() -> str:
+    """Return the application version string."""
+    try:
+        from config import VERSION
+
+        return VERSION
+    except Exception:
+        return 'unknown'
+
+
+def _format_uptime(seconds: float) -> str:
+    """Format seconds into a human-readable uptime string."""
+    days = int(seconds // 86400)
+    hours = int((seconds % 86400) // 3600)
+    minutes = int((seconds % 3600) // 60)
+    parts = []
+    if days > 0:
+        parts.append(f'{days}d')
+    if hours > 0:
+        parts.append(f'{hours}h')
+    parts.append(f'{minutes}m')
+    return ' '.join(parts)
+
+
+def _collect_process_status() -> dict[str, bool]:
+    """Return running/stopped status for each decoder process.
+
+    Mirrors the logic in app.py health_check().
+    """
+    try:
+        import app as app_module
+
+        def _alive(attr: str) -> bool:
+            proc = getattr(app_module, attr, None)
+            if proc is None:
+                return False
+            try:
+                return proc.poll() is None
+            except Exception:
+                return False
+
+        processes: dict[str, bool] = {
+            'pager': _alive('current_process'),
+            'sensor': _alive('sensor_process'),
+            'adsb': _alive('adsb_process'),
+            'ais': _alive('ais_process'),
+            'acars': _alive('acars_process'),
+            'vdl2': _alive('vdl2_process'),
+            'aprs': _alive('aprs_process'),
+            'dsc': _alive('dsc_process'),
+            'morse': _alive('morse_process'),
+        }
+
+        # WiFi
+        try:
+            from app import _get_wifi_health
+
+            wifi_active, _, _ = _get_wifi_health()
+            processes['wifi'] = wifi_active
+        except Exception:
+            processes['wifi'] = False
+
+        # Bluetooth
+        try:
+            from app import _get_bluetooth_health
+
+            bt_active, _ = _get_bluetooth_health()
+            processes['bluetooth'] = bt_active
+        except Exception:
+            processes['bluetooth'] = False
+
+        # SubGHz
+        try:
+            from app import _get_subghz_active
+
+            processes['subghz'] = _get_subghz_active()
+        except Exception:
+            processes['subghz'] = False
+
+        return processes
+    except Exception:
+        return {}
+
+
+def _collect_throttle_flags() -> str | None:
+    """Read Raspberry Pi throttle flags via vcgencmd (Linux/Pi only)."""
+    try:
+        result = subprocess.run(
+            ['vcgencmd', 'get_throttled'],
+            capture_output=True,
+            text=True,
+            timeout=2,
+        )
+        if result.returncode == 0 and 'throttled=' in result.stdout:
+            return result.stdout.strip().split('=', 1)[1]
+    except Exception:
+        pass
+    return None
+
+
+def _collect_power_draw() -> float | None:
+    """Read power draw in watts from sysfs (Linux only)."""
+    try:
+        power_supply = Path('/sys/class/power_supply')
+        if not power_supply.exists():
+            return None
+        for supply_dir in power_supply.iterdir():
+            power_file = supply_dir / 'power_now'
+            if power_file.exists():
+                val = int(power_file.read_text().strip())
+                return round(val / 1_000_000, 2)  # microwatts to watts
+    except Exception:
+        pass
+    return None
+
+
+def _collect_metrics() -> dict[str, Any]:
+    """Gather a snapshot of system metrics."""
+    now = time.time()
+    start = _get_app_start_time()
+    uptime_seconds = round(now - start, 2)
+
+    metrics: dict[str, Any] = {
+        'type': 'system_metrics',
+        'timestamp': now,
+        'system': {
+            'hostname': socket.gethostname(),
+            'platform': platform.platform(),
+            'python': platform.python_version(),
+            'version': _get_app_version(),
+            'uptime_seconds': uptime_seconds,
+            'uptime_human': _format_uptime(uptime_seconds),
+        },
+        'processes': _collect_process_status(),
+    }
+
+    if _HAS_PSUTIL:
+        # CPU — overall + per-core + frequency
+        cpu_percent = psutil.cpu_percent(interval=None)
+        cpu_count = psutil.cpu_count() or 1
+        try:
+            load_1, load_5, load_15 = os.getloadavg()
+        except (OSError, AttributeError):
+            load_1 = load_5 = load_15 = 0.0
+
+        per_core = []
+        with contextlib.suppress(Exception):
+            per_core = psutil.cpu_percent(interval=None, percpu=True)
+
+        freq_data = None
+        with contextlib.suppress(Exception):
+            freq = psutil.cpu_freq()
+            if freq:
+                freq_data = {
+                    'current': round(freq.current, 0),
+                    'min': round(freq.min, 0),
+                    'max': round(freq.max, 0),
+                }
+
+        metrics['cpu'] = {
+            'percent': cpu_percent,
+            'count': cpu_count,
+            'load_1': round(load_1, 2),
+            'load_5': round(load_5, 2),
+            'load_15': round(load_15, 2),
+            'per_core': per_core,
+            'freq': freq_data,
+        }
+
+        # Memory
+        mem = psutil.virtual_memory()
+        metrics['memory'] = {
+            'total': mem.total,
+            'used': mem.used,
+            'available': mem.available,
+            'percent': mem.percent,
+        }
+
+        swap = psutil.swap_memory()
+        metrics['swap'] = {
+            'total': swap.total,
+            'used': swap.used,
+            'percent': swap.percent,
+        }
+
+        # Disk — usage + I/O counters
+        try:
+            disk = psutil.disk_usage('/')
+            metrics['disk'] = {
+                'total': disk.total,
+                'used': disk.used,
+                'free': disk.free,
+                'percent': disk.percent,
+                'path': '/',
+            }
+        except Exception:
+            metrics['disk'] = None
+
+        disk_io = None
+        with contextlib.suppress(Exception):
+            dio = psutil.disk_io_counters()
+            if dio:
+                disk_io = {
+                    'read_bytes': dio.read_bytes,
+                    'write_bytes': dio.write_bytes,
+                    'read_count': dio.read_count,
+                    'write_count': dio.write_count,
+                }
+        metrics['disk_io'] = disk_io
+
+        # Temperatures
+        try:
+            temps = psutil.sensors_temperatures()
+            if temps:
+                temp_data: dict[str, list[dict[str, Any]]] = {}
+                for chip, entries in temps.items():
+                    temp_data[chip] = [
+                        {
+                            'label': e.label or chip,
+                            'current': e.current,
+                            'high': e.high,
+                            'critical': e.critical,
+                        }
+                        for e in entries
+                    ]
+                metrics['temperatures'] = temp_data
+            else:
+                metrics['temperatures'] = None
+        except (AttributeError, Exception):
+            metrics['temperatures'] = None
+
+        # Fans
+        fans_data = None
+        with contextlib.suppress(Exception):
+            fans = psutil.sensors_fans()
+            if fans:
+                fans_data = {}
+                for chip, entries in fans.items():
+                    fans_data[chip] = [
+                        {'label': e.label or chip, 'current': e.current}
+                        for e in entries
+                    ]
+        metrics['fans'] = fans_data
+
+        # Battery
+        battery_data = None
+        with contextlib.suppress(Exception):
+            bat = psutil.sensors_battery()
+            if bat:
+                battery_data = {
+                    'percent': bat.percent,
+                    'plugged': bat.power_plugged,
+                    'secs_left': bat.secsleft if bat.secsleft != psutil.POWER_TIME_UNLIMITED else None,
+                }
+        metrics['battery'] = battery_data
+
+        # Network interfaces
+        net_ifaces: list[dict[str, Any]] = []
+        with contextlib.suppress(Exception):
+            addrs = psutil.net_if_addrs()
+            stats = psutil.net_if_stats()
+            for iface_name in sorted(addrs.keys()):
+                if iface_name == 'lo':
+                    continue
+                iface_info: dict[str, Any] = {'name': iface_name}
+                # Get addresses
+                for addr in addrs[iface_name]:
+                    if addr.family == socket.AF_INET:
+                        iface_info['ipv4'] = addr.address
+                    elif addr.family == socket.AF_INET6:
+                        iface_info.setdefault('ipv6', addr.address)
+                    elif addr.family == psutil.AF_LINK:
+                        iface_info['mac'] = addr.address
+                # Get stats
+                if iface_name in stats:
+                    st = stats[iface_name]
+                    iface_info['is_up'] = st.isup
+                    iface_info['speed'] = st.speed  # Mbps
+                    iface_info['mtu'] = st.mtu
+                net_ifaces.append(iface_info)
+        metrics['network'] = {'interfaces': net_ifaces}
+
+        # Network I/O counters (raw — JS computes deltas)
+        net_io = None
+        with contextlib.suppress(Exception):
+            counters = psutil.net_io_counters(pernic=True)
+            if counters:
+                net_io = {}
+                for nic, c in counters.items():
+                    if nic == 'lo':
+                        continue
+                    net_io[nic] = {
+                        'bytes_sent': c.bytes_sent,
+                        'bytes_recv': c.bytes_recv,
+                    }
+        metrics['network']['io'] = net_io
+
+        # Connection count
+        conn_count = 0
+        with contextlib.suppress(Exception):
+            conn_count = len(psutil.net_connections())
+        metrics['network']['connections'] = conn_count
+
+        # Boot time
+        boot_ts = None
+        with contextlib.suppress(Exception):
+            boot_ts = psutil.boot_time()
+        metrics['boot_time'] = boot_ts
+
+        # Power / throttle (Pi-specific)
+        metrics['power'] = {
+            'throttled': _collect_throttle_flags(),
+            'draw_watts': _collect_power_draw(),
+        }
+    else:
+        metrics['cpu'] = None
+        metrics['memory'] = None
+        metrics['swap'] = None
+        metrics['disk'] = None
+        metrics['disk_io'] = None
+        metrics['temperatures'] = None
+        metrics['fans'] = None
+        metrics['battery'] = None
+        metrics['network'] = None
+        metrics['boot_time'] = None
+        metrics['power'] = None
+
+    return metrics
+
+
+def _collector_loop() -> None:
+    """Background thread that pushes metrics onto the queue every 3 seconds."""
+    # Seed psutil's CPU measurement so the first real read isn't 0%.
+    if _HAS_PSUTIL:
+        with contextlib.suppress(Exception):
+            psutil.cpu_percent(interval=None)
+
+    while True:
+        try:
+            metrics = _collect_metrics()
+            # Non-blocking put — drop oldest if full
+            try:
+                _metrics_queue.put_nowait(metrics)
+            except queue.Full:
+                with contextlib.suppress(queue.Empty):
+                    _metrics_queue.get_nowait()
+                _metrics_queue.put_nowait(metrics)
+        except Exception as exc:
+            logger.debug('system metrics collection error: %s', exc)
+        time.sleep(3)
+
+
+def _ensure_collector() -> None:
+    """Start the background collector thread once."""
+    global _collector_started
+    if _collector_started:
+        return
+    with _collector_lock:
+        if _collector_started:
+            return
+        t = threading.Thread(target=_collector_loop, daemon=True, name='system-metrics-collector')
+        t.start()
+        _collector_started = True
+        logger.info('System metrics collector started')
+
+
+def _get_observer_location() -> dict[str, Any]:
+    """Get observer location from GPS state or config defaults."""
+    lat, lon, source = None, None, 'none'
+    gps_meta: dict[str, Any] = {}
+
+    # Try GPS via utils.gps
+    with contextlib.suppress(Exception):
+        from utils.gps import get_current_position
+
+        pos = get_current_position()
+        if pos and pos.fix_quality >= 2:
+            lat, lon, source = pos.latitude, pos.longitude, 'gps'
+            gps_meta['fix_quality'] = pos.fix_quality
+            gps_meta['satellites'] = pos.satellites
+            if pos.epx is not None and pos.epy is not None:
+                gps_meta['accuracy'] = round(max(pos.epx, pos.epy), 1)
+            if pos.altitude is not None:
+                gps_meta['altitude'] = round(pos.altitude, 1)
+
+    # Fall back to config env vars
+    if lat is None:
+        with contextlib.suppress(Exception):
+            from config import DEFAULT_LATITUDE, DEFAULT_LONGITUDE
+
+            if DEFAULT_LATITUDE != 0.0 or DEFAULT_LONGITUDE != 0.0:
+                lat, lon, source = DEFAULT_LATITUDE, DEFAULT_LONGITUDE, 'config'
+
+    # Fall back to hardcoded constants (London)
+    if lat is None:
+        with contextlib.suppress(Exception):
+            from utils.constants import DEFAULT_LATITUDE as CONST_LAT
+            from utils.constants import DEFAULT_LONGITUDE as CONST_LON
+
+            lat, lon, source = CONST_LAT, CONST_LON, 'default'
+
+    result: dict[str, Any] = {'lat': lat, 'lon': lon, 'source': source}
+    if gps_meta:
+        result['gps'] = gps_meta
+    return result
+
+
+# ---------------------------------------------------------------------------
+# Routes
+# ---------------------------------------------------------------------------
+
+
+@system_bp.route('/metrics')
+def get_metrics() -> Response:
+    """REST snapshot of current system metrics."""
+    _ensure_collector()
+    return jsonify(_collect_metrics())
+
+
+@system_bp.route('/stream')
+def stream_system() -> Response:
+    """SSE stream for real-time system metrics."""
+    _ensure_collector()
+
+    response = Response(
+        sse_stream_fanout(
+            source_queue=_metrics_queue,
+            channel_key='system',
+            timeout=SSE_QUEUE_TIMEOUT,
+            keepalive_interval=SSE_KEEPALIVE_INTERVAL,
+        ),
+        mimetype='text/event-stream',
+    )
+    response.headers['Cache-Control'] = 'no-cache'
+    response.headers['X-Accel-Buffering'] = 'no'
+    return response
+
+
+@system_bp.route('/sdr_devices')
+def get_sdr_devices() -> Response:
+    """Enumerate all connected SDR devices (on-demand, not every tick)."""
+    try:
+        from utils.sdr.detection import detect_all_devices
+
+        devices = detect_all_devices()
+        result = []
+        for d in devices:
+            result.append({
+                'type': d.sdr_type.value if hasattr(d.sdr_type, 'value') else str(d.sdr_type),
+                'index': d.index,
+                'name': d.name,
+                'serial': d.serial or '',
+                'driver': d.driver or '',
+            })
+        return jsonify({'devices': result})
+    except Exception as exc:
+        logger.warning('SDR device detection failed: %s', exc)
+        return jsonify({'devices': [], 'error': str(exc)})
+
+
+@system_bp.route('/location')
+def get_location() -> Response:
+    """Return observer location from GPS or config."""
+    return jsonify(_get_observer_location())
+
+
+@system_bp.route('/weather')
+def get_weather() -> Response:
+    """Proxy weather from wttr.in, cached for 10 minutes."""
+    global _weather_cache, _weather_cache_time
+
+    now = time.time()
+    if _weather_cache and (now - _weather_cache_time) < _WEATHER_CACHE_TTL:
+        return jsonify(_weather_cache)
+
+    lat = request.args.get('lat', type=float)
+    lon = request.args.get('lon', type=float)
+    if lat is None or lon is None:
+        loc = _get_observer_location()
+        lat, lon = loc.get('lat'), loc.get('lon')
+
+    if lat is None or lon is None:
+        return jsonify({'error': 'No location available'})
+
+    if _requests is None:
+        return jsonify({'error': 'requests library not available'})
+
+    try:
+        resp = _requests.get(
+            f'https://wttr.in/{lat},{lon}?format=j1',
+            timeout=5,
+            headers={'User-Agent': 'INTERCEPT-SystemHealth/1.0'},
+        )
+        resp.raise_for_status()
+        data = resp.json()
+
+        current = data.get('current_condition', [{}])[0]
+        weather = {
+            'temp_c': current.get('temp_C'),
+            'temp_f': current.get('temp_F'),
+            'condition': current.get('weatherDesc', [{}])[0].get('value', ''),
+            'humidity': current.get('humidity'),
+            'wind_mph': current.get('windspeedMiles'),
+            'wind_dir': current.get('winddir16Point'),
+            'feels_like_c': current.get('FeelsLikeC'),
+            'visibility': current.get('visibility'),
+            'pressure': current.get('pressure'),
+        }
+        _weather_cache = weather
+        _weather_cache_time = now
+        return jsonify(weather)
+    except Exception as exc:
+        logger.debug('Weather fetch failed: %s', exc)
+        return jsonify({'error': str(exc)})

routes/tscm.py

@@ -1345,7 +1345,7 @@ def _scan_rf_signals(
     sweep_ranges: list[dict] | None = None
 ) -> list[dict]:
     """
-    Scan for RF signals using SDR (rtl_power).
+    Scan for RF signals using SDR (rtl_power or hackrf_sweep).
 
     Scans common surveillance frequency bands:
     - 88-108 MHz: FM broadcast (potential FM bugs)
@@ -1375,38 +1375,49 @@ def _scan_rf_signals(
 
     logger.info(f"Starting RF scan (device={sdr_device})")
 
+    # Detect available SDR devices and sweep tools
     rtl_power_path = shutil.which('rtl_power')
-    if not rtl_power_path:
+    hackrf_sweep_path = shutil.which('hackrf_sweep')
-        logger.warning("rtl_power not found in PATH, RF scanning unavailable")
-        _emit_event('rf_status', {
-            'status': 'error',
-            'message': 'rtl_power not installed. Install rtl-sdr package for RF scanning.',
-        })
-        return signals
 
-    logger.info(f"Found rtl_power at: {rtl_power_path}")
+    sdr_type = None
+    sweep_tool_path = None
 
-    # Test if RTL-SDR device is accessible
-    rtl_test_path = shutil.which('rtl_test')
-    if rtl_test_path:
     try:
-            test_result = subprocess.run(
+        from utils.sdr import SDRFactory
-                [rtl_test_path, '-t'],
+        from utils.sdr.base import SDRType
-                capture_output=True,
+        devices = SDRFactory.detect_devices()
-                text=True,
+        rtlsdr_available = any(d.sdr_type == SDRType.RTL_SDR for d in devices)
-                timeout=5
+        hackrf_available = any(d.sdr_type == SDRType.HACKRF for d in devices)
-            )
+    except ImportError:
-            if 'No supported devices found' in test_result.stderr or test_result.returncode != 0:
+        rtlsdr_available = False
-                logger.warning("No RTL-SDR device found")
+        hackrf_available = False
+
+    # Pick the best available SDR + sweep tool combo
+    if rtlsdr_available and rtl_power_path:
+        sdr_type = 'rtlsdr'
+        sweep_tool_path = rtl_power_path
+        logger.info(f"Using RTL-SDR with rtl_power at: {rtl_power_path}")
+    elif hackrf_available and hackrf_sweep_path:
+        sdr_type = 'hackrf'
+        sweep_tool_path = hackrf_sweep_path
+        logger.info(f"Using HackRF with hackrf_sweep at: {hackrf_sweep_path}")
+    elif rtl_power_path:
+        # Tool exists but no device detected — try anyway (detection may have failed)
+        sdr_type = 'rtlsdr'
+        sweep_tool_path = rtl_power_path
+        logger.info(f"No SDR detected but rtl_power found, attempting RTL-SDR scan")
+    elif hackrf_sweep_path:
+        sdr_type = 'hackrf'
+        sweep_tool_path = hackrf_sweep_path
+        logger.info(f"No SDR detected but hackrf_sweep found, attempting HackRF scan")
+
+    if not sweep_tool_path:
+        logger.warning("No supported sweep tool found (rtl_power or hackrf_sweep)")
         _emit_event('rf_status', {
             'status': 'error',
-                    'message': 'No RTL-SDR device connected. Connect an RTL-SDR dongle for RF scanning.',
+            'message': 'No SDR sweep tool installed. Install rtl-sdr (rtl_power) or HackRF (hackrf_sweep) for RF scanning.',
         })
         return signals
-        except subprocess.TimeoutExpired:
-            pass  # Device might be busy, continue anyway
-        except Exception as e:
-            logger.debug(f"rtl_test check failed: {e}")
 
     # Define frequency bands to scan (in Hz)
     # Format: (start_freq, end_freq, bin_size, description)
@@ -1448,7 +1459,7 @@ def _scan_rf_signals(
 
     try:
         # Build device argument
-        device_arg = ['-d', str(sdr_device if sdr_device is not None else 0)]
+        device_idx = sdr_device if sdr_device is not None else 0
 
         # Scan each band and look for strong signals
         for start_freq, end_freq, bin_size, band_name in scan_bands:
@@ -1458,15 +1469,27 @@ def _scan_rf_signals(
             logger.info(f"Scanning {band_name} ({start_freq/1e6:.1f}-{end_freq/1e6:.1f} MHz)")
 
             try:
-                # Run rtl_power for a quick sweep of this band
+                # Build sweep command based on SDR type
+                if sdr_type == 'hackrf':
                     cmd = [
-                    rtl_power_path,
+                        sweep_tool_path,
+                        '-f', f'{int(start_freq / 1e6)}:{int(end_freq / 1e6)}',
+                        '-w', str(bin_size),
+                        '-1',  # Single sweep
+                    ]
+                    output_mode = 'stdout'
+                else:
+                    cmd = [
+                        sweep_tool_path,
                         '-f', f'{start_freq}:{end_freq}:{bin_size}',
                         '-g', '40',           # Gain
                         '-i', '1',            # Integration interval (1 second)
                         '-1',                 # Single shot mode
                         '-c', '20%',          # Crop 20% of edges
-                ] + device_arg + [tmp_path]
+                        '-d', str(device_idx),
+                        tmp_path,
+                    ]
+                    output_mode = 'file'
 
                 logger.debug(f"Running: {' '.join(cmd)}")
 
@@ -1478,9 +1501,14 @@ def _scan_rf_signals(
                 )
 
                 if result.returncode != 0:
-                    logger.warning(f"rtl_power returned {result.returncode}: {result.stderr}")
+                    logger.warning(f"{os.path.basename(sweep_tool_path)} returned {result.returncode}: {result.stderr}")
 
-                # Parse the CSV output
+                # For HackRF, write stdout CSV data to temp file for unified parsing
+                if output_mode == 'stdout' and result.stdout:
+                    with open(tmp_path, 'w') as f:
+                        f.write(result.stdout)
+
+                # Parse the CSV output (same format for both rtl_power and hackrf_sweep)
                 if os.path.exists(tmp_path) and os.path.getsize(tmp_path) > 0:
                     with open(tmp_path, 'r') as f:
                         for line in f:
@@ -1488,13 +1516,12 @@ def _scan_rf_signals(
                             if len(parts) >= 7:
                                 try:
                                     # CSV format: date, time, hz_low, hz_high, hz_step, samples, db_values...
-                                    hz_low = int(parts[2])
+                                    hz_low = int(parts[2].strip())
-                                    hz_high = int(parts[3])
+                                    hz_high = int(parts[3].strip())
-                                    hz_step = float(parts[4])
+                                    hz_step = float(parts[4].strip())
                                     db_values = [float(x) for x in parts[6:] if x.strip()]
 
                                     # Find peaks above noise floor
-                                    # RTL-SDR dongles have higher noise figures, so use permissive thresholds
                                     noise_floor = sum(db_values) / len(db_values) if db_values else -100
                                     threshold = noise_floor + 6  # Signal must be 6dB above noise
 

routes/vdl2.py

@@ -48,6 +48,7 @@ vdl2_last_message_time = None
 
 # Track which device is being used
 vdl2_active_device: int | None = None
+vdl2_active_sdr_type: str | None = None
 
 
 def find_dumpvdl2():
@@ -110,7 +111,7 @@ def stream_vdl2_output(process: subprocess.Popen, is_text_mode: bool = False) ->
         logger.error(f"VDL2 stream error: {e}")
         app_module.vdl2_queue.put({'type': 'error', 'message': str(e)})
     finally:
-        global vdl2_active_device
+        global vdl2_active_device, vdl2_active_sdr_type
         # Ensure process is terminated
         try:
             process.terminate()
@@ -126,8 +127,9 @@ def stream_vdl2_output(process: subprocess.Popen, is_text_mode: bool = False) ->
             app_module.vdl2_process = None
         # Release SDR device
         if vdl2_active_device is not None:
-            app_module.release_sdr_device(vdl2_active_device)
+            app_module.release_sdr_device(vdl2_active_device, vdl2_active_sdr_type or 'rtlsdr')
             vdl2_active_device = None
+            vdl2_active_sdr_type = None
 
 
 @vdl2_bp.route('/tools')
@@ -159,7 +161,7 @@ def vdl2_status() -> Response:
 @vdl2_bp.route('/start', methods=['POST'])
 def start_vdl2() -> Response:
     """Start VDL2 decoder."""
-    global vdl2_message_count, vdl2_last_message_time, vdl2_active_device
+    global vdl2_message_count, vdl2_last_message_time, vdl2_active_device, vdl2_active_sdr_type
 
     with app_module.vdl2_lock:
         if app_module.vdl2_process and app_module.vdl2_process.poll() is None:
@@ -186,9 +188,16 @@ def start_vdl2() -> Response:
     except ValueError as e:
         return jsonify({'status': 'error', 'message': str(e)}), 400
 
+    # Resolve SDR type for device selection
+    sdr_type_str = data.get('sdr_type', 'rtlsdr')
+    try:
+        sdr_type = SDRType(sdr_type_str)
+    except ValueError:
+        sdr_type = SDRType.RTL_SDR
+
     # Check if device is available
     device_int = int(device)
-    error = app_module.claim_sdr_device(device_int, 'vdl2')
+    error = app_module.claim_sdr_device(device_int, 'vdl2', sdr_type_str)
     if error:
         return jsonify({
             'status': 'error',
@@ -197,6 +206,7 @@ def start_vdl2() -> Response:
         }), 409
 
     vdl2_active_device = device_int
+    vdl2_active_sdr_type = sdr_type_str
 
     # Get frequencies - use provided or defaults
     # dumpvdl2 expects frequencies in Hz (integers)
@@ -215,13 +225,6 @@ def start_vdl2() -> Response:
     vdl2_message_count = 0
     vdl2_last_message_time = None
 
-    # Resolve SDR type for device selection
-    sdr_type_str = data.get('sdr_type', 'rtlsdr')
-    try:
-        sdr_type = SDRType(sdr_type_str)
-    except ValueError:
-        sdr_type = SDRType.RTL_SDR
-
     is_soapy = sdr_type not in (SDRType.RTL_SDR,)
 
     # Build dumpvdl2 command
@@ -281,8 +284,9 @@ def start_vdl2() -> Response:
         if process.poll() is not None:
             # Process died - release device
             if vdl2_active_device is not None:
-                app_module.release_sdr_device(vdl2_active_device)
+                app_module.release_sdr_device(vdl2_active_device, vdl2_active_sdr_type or 'rtlsdr')
                 vdl2_active_device = None
+                vdl2_active_sdr_type = None
             stderr = ''
             if process.stderr:
                 stderr = process.stderr.read().decode('utf-8', errors='replace')
@@ -313,8 +317,9 @@ def start_vdl2() -> Response:
     except Exception as e:
         # Release device on failure
         if vdl2_active_device is not None:
-            app_module.release_sdr_device(vdl2_active_device)
+            app_module.release_sdr_device(vdl2_active_device, vdl2_active_sdr_type or 'rtlsdr')
             vdl2_active_device = None
+            vdl2_active_sdr_type = None
         logger.error(f"Failed to start VDL2 decoder: {e}")
         return jsonify({'status': 'error', 'message': str(e)}), 500
 
@@ -322,7 +327,7 @@ def start_vdl2() -> Response:
 @vdl2_bp.route('/stop', methods=['POST'])
 def stop_vdl2() -> Response:
     """Stop VDL2 decoder."""
-    global vdl2_active_device
+    global vdl2_active_device, vdl2_active_sdr_type
 
     with app_module.vdl2_lock:
         if not app_module.vdl2_process:
@@ -343,8 +348,9 @@ def stop_vdl2() -> Response:
 
     # Release device from registry
     if vdl2_active_device is not None:
-        app_module.release_sdr_device(vdl2_active_device)
+        app_module.release_sdr_device(vdl2_active_device, vdl2_active_sdr_type or 'rtlsdr')
         vdl2_active_device = None
+        vdl2_active_sdr_type = None
 
     return jsonify({'status': 'stopped'})
 

routes/waterfall_websocket.py

@@ -1,12 +1,18 @@
 """WebSocket-based waterfall streaming with I/Q capture and server-side FFT."""
 
+from __future__ import annotations
+
 import json
 import queue
+import shutil
 import socket
 import subprocess
 import threading
 import time
+from contextlib import suppress
+from typing import Any
 
+import numpy as np
 from flask import Flask
 
 try:
@@ -17,18 +23,37 @@ except ImportError:
     Sock = None
 
 from utils.logging import get_logger
-from utils.process import safe_terminate, register_process, unregister_process
+from utils.process import register_process, safe_terminate, unregister_process
+from utils.sdr import SDRFactory, SDRType
+from utils.sdr.base import SDRCapabilities, SDRDevice
 from utils.waterfall_fft import (
     build_binary_frame,
     compute_power_spectrum,
     cu8_to_complex,
     quantize_to_uint8,
 )
-from utils.sdr import SDRFactory, SDRType
-from utils.sdr.base import SDRCapabilities, SDRDevice
 
 logger = get_logger('intercept.waterfall_ws')
 
+AUDIO_SAMPLE_RATE = 48000
+_shared_state_lock = threading.Lock()
+_shared_audio_queue: queue.Queue[bytes] = queue.Queue(maxsize=20)
+_shared_state: dict[str, Any] = {
+    'running': False,
+    'device': None,
+    'center_mhz': 0.0,
+    'span_mhz': 0.0,
+    'sample_rate': 0,
+    'monitor_enabled': False,
+    'monitor_freq_mhz': 0.0,
+    'monitor_modulation': 'wfm',
+    'monitor_squelch': 0,
+}
+# Generation counter to prevent stale WebSocket handlers from clobbering
+# shared state set by a newer handler (e.g. old handler's finally block
+# running after a new connection has already started capture).
+_capture_generation: int = 0
+
 # Maximum bandwidth per SDR type (Hz)
 MAX_BANDWIDTH = {
     SDRType.RTL_SDR: 2400000,
@@ -39,6 +64,261 @@ MAX_BANDWIDTH = {
 }
 
 
+def _clear_shared_audio_queue() -> None:
+    while True:
+        try:
+            _shared_audio_queue.get_nowait()
+        except queue.Empty:
+            break
+
+
+def _set_shared_capture_state(
+    *,
+    running: bool,
+    device: int | None = None,
+    center_mhz: float | None = None,
+    span_mhz: float | None = None,
+    sample_rate: int | None = None,
+    generation: int | None = None,
+) -> int:
+    """Update shared capture state.
+
+    Returns the current generation counter.  When *running* is True and
+    *generation* is None the counter is bumped; callers should capture
+    the returned value and pass it back when setting running=False so
+    that stale handlers cannot clobber a newer session.
+    """
+    global _capture_generation
+    with _shared_state_lock:
+        if not running and generation is not None:
+            # Only allow the matching generation to clear the state.
+            if generation != _capture_generation:
+                return _capture_generation
+        if running and generation is None:
+            _capture_generation += 1
+        _shared_state['running'] = bool(running)
+        _shared_state['device'] = device if running else None
+        if center_mhz is not None:
+            _shared_state['center_mhz'] = float(center_mhz)
+        if span_mhz is not None:
+            _shared_state['span_mhz'] = float(span_mhz)
+        if sample_rate is not None:
+            _shared_state['sample_rate'] = int(sample_rate)
+        if not running:
+            _shared_state['monitor_enabled'] = False
+        gen = _capture_generation
+    if not running:
+        _clear_shared_audio_queue()
+    return gen
+
+
+def _set_shared_monitor(
+    *,
+    enabled: bool,
+    frequency_mhz: float | None = None,
+    modulation: str | None = None,
+    squelch: int | None = None,
+) -> None:
+    was_enabled = False
+    freq_changed = False
+    with _shared_state_lock:
+        was_enabled = bool(_shared_state.get('monitor_enabled'))
+        _shared_state['monitor_enabled'] = bool(enabled)
+        if frequency_mhz is not None:
+            old_freq = float(_shared_state.get('monitor_freq_mhz', 0.0) or 0.0)
+            _shared_state['monitor_freq_mhz'] = float(frequency_mhz)
+            if abs(float(frequency_mhz) - old_freq) > 1e-6:
+                freq_changed = True
+        if modulation is not None:
+            _shared_state['monitor_modulation'] = str(modulation).lower().strip()
+        if squelch is not None:
+            _shared_state['monitor_squelch'] = max(0, min(100, int(squelch)))
+    if (was_enabled and not enabled) or (enabled and freq_changed):
+        _clear_shared_audio_queue()
+
+
+def get_shared_capture_status() -> dict[str, Any]:
+    with _shared_state_lock:
+        return {
+            'running': bool(_shared_state['running']),
+            'device': _shared_state['device'],
+            'center_mhz': float(_shared_state.get('center_mhz', 0.0) or 0.0),
+            'span_mhz': float(_shared_state.get('span_mhz', 0.0) or 0.0),
+            'sample_rate': int(_shared_state.get('sample_rate', 0) or 0),
+            'monitor_enabled': bool(_shared_state.get('monitor_enabled')),
+            'monitor_freq_mhz': float(_shared_state.get('monitor_freq_mhz', 0.0) or 0.0),
+            'monitor_modulation': str(_shared_state.get('monitor_modulation', 'wfm')),
+            'monitor_squelch': int(_shared_state.get('monitor_squelch', 0) or 0),
+        }
+
+
+def start_shared_monitor_from_capture(
+    *,
+    device: int,
+    frequency_mhz: float,
+    modulation: str,
+    squelch: int,
+) -> tuple[bool, str]:
+    with _shared_state_lock:
+        if not _shared_state['running']:
+            return False, 'Waterfall IQ stream not active'
+        if _shared_state['device'] != device:
+            return False, 'Waterfall stream is using a different SDR device'
+        _shared_state['monitor_enabled'] = True
+        _shared_state['monitor_freq_mhz'] = float(frequency_mhz)
+        _shared_state['monitor_modulation'] = str(modulation).lower().strip()
+        _shared_state['monitor_squelch'] = max(0, min(100, int(squelch)))
+    _clear_shared_audio_queue()
+    return True, 'started'
+
+
+def stop_shared_monitor_from_capture() -> None:
+    _set_shared_monitor(enabled=False)
+
+
+def read_shared_monitor_audio_chunk(timeout: float = 1.0) -> bytes | None:
+    with _shared_state_lock:
+        if not _shared_state['running'] or not _shared_state['monitor_enabled']:
+            return None
+    try:
+        return _shared_audio_queue.get(timeout=max(0.0, float(timeout)))
+    except queue.Empty:
+        return None
+
+
+def _snapshot_monitor_config() -> dict[str, Any] | None:
+    with _shared_state_lock:
+        if not (_shared_state['running'] and _shared_state['monitor_enabled']):
+            return None
+        return {
+            'center_mhz': float(_shared_state['center_mhz']),
+            'monitor_freq_mhz': float(_shared_state['monitor_freq_mhz']),
+            'modulation': str(_shared_state['monitor_modulation']),
+            'squelch': int(_shared_state['monitor_squelch']),
+        }
+
+
+def _push_shared_audio_chunk(chunk: bytes) -> None:
+    if not chunk:
+        return
+    if _shared_audio_queue.full():
+        with suppress(queue.Empty):
+            _shared_audio_queue.get_nowait()
+    with suppress(queue.Full):
+        _shared_audio_queue.put_nowait(chunk)
+
+
+def _demodulate_monitor_audio(
+    samples: np.ndarray,
+    sample_rate: int,
+    center_mhz: float,
+    monitor_freq_mhz: float,
+    modulation: str,
+    squelch: int,
+    rotator_phase: float = 0.0,
+) -> tuple[bytes | None, float]:
+    if samples.size < 32 or sample_rate <= 0:
+        return None, float(rotator_phase)
+
+    fs = float(sample_rate)
+    freq_offset_hz = (float(monitor_freq_mhz) - float(center_mhz)) * 1e6
+    nyquist = fs * 0.5
+    if abs(freq_offset_hz) > nyquist * 0.98:
+        return None, float(rotator_phase)
+
+    phase_inc = (2.0 * np.pi * freq_offset_hz) / fs
+    n = np.arange(samples.size, dtype=np.float64)
+    rotator = np.exp(-1j * (float(rotator_phase) + phase_inc * n)).astype(np.complex64)
+    next_phase = float((float(rotator_phase) + phase_inc * samples.size) % (2.0 * np.pi))
+    shifted = samples * rotator
+
+    mod = str(modulation or 'wfm').lower().strip()
+    target_bb = 220000.0 if mod == 'wfm' else 48000.0
+    pre_decim = max(1, int(fs // target_bb))
+    if pre_decim > 1:
+        usable = (shifted.size // pre_decim) * pre_decim
+        if usable < pre_decim:
+            return None, next_phase
+        shifted = shifted[:usable].reshape(-1, pre_decim).mean(axis=1)
+    fs1 = fs / pre_decim
+    if shifted.size < 16:
+        return None, next_phase
+
+    if mod in ('wfm', 'fm'):
+        audio = np.angle(shifted[1:] * np.conj(shifted[:-1])).astype(np.float32)
+    elif mod == 'am':
+        envelope = np.abs(shifted).astype(np.float32)
+        audio = envelope - float(np.mean(envelope))
+    elif mod == 'usb':
+        audio = np.real(shifted).astype(np.float32)
+    elif mod == 'lsb':
+        audio = -np.real(shifted).astype(np.float32)
+    else:
+        audio = np.real(shifted).astype(np.float32)
+
+    if audio.size < 8:
+        return None, next_phase
+
+    audio = audio - float(np.mean(audio))
+
+    if mod in ('fm', 'am', 'usb', 'lsb'):
+        taps = int(max(1, min(31, fs1 / 12000.0)))
+        if taps > 1:
+            kernel = np.ones(taps, dtype=np.float32) / float(taps)
+            audio = np.convolve(audio, kernel, mode='same')
+
+    out_len = int(audio.size * AUDIO_SAMPLE_RATE / fs1)
+    if out_len < 32:
+        return None, next_phase
+    x_old = np.linspace(0.0, 1.0, audio.size, endpoint=False, dtype=np.float32)
+    x_new = np.linspace(0.0, 1.0, out_len, endpoint=False, dtype=np.float32)
+    audio = np.interp(x_new, x_old, audio).astype(np.float32)
+
+    rms = float(np.sqrt(np.mean(audio * audio) + 1e-12))
+    level = min(100.0, rms * 450.0)
+    if squelch > 0 and level < float(squelch):
+        audio.fill(0.0)
+
+    peak = float(np.max(np.abs(audio))) if audio.size else 0.0
+    if peak > 0:
+        audio = audio * min(20.0, 0.85 / peak)
+
+    pcm = np.clip(audio, -1.0, 1.0)
+    return (pcm * 32767.0).astype(np.int16).tobytes(), next_phase
+
+
+def _parse_center_freq_mhz(payload: dict[str, Any]) -> float:
+    """Parse center frequency from mixed legacy/new payload formats."""
+    if payload.get('center_freq_mhz') is not None:
+        return float(payload['center_freq_mhz'])
+
+    if payload.get('center_freq_hz') is not None:
+        return float(payload['center_freq_hz']) / 1e6
+
+    raw = float(payload.get('center_freq', 100.0))
+    # Backward compatibility: some clients still send center_freq in Hz.
+    if raw > 100000:
+        return raw / 1e6
+    return raw
+
+
+def _parse_span_mhz(payload: dict[str, Any]) -> float:
+    """Parse display span in MHz from mixed payload formats."""
+    if payload.get('span_hz') is not None:
+        return float(payload['span_hz']) / 1e6
+    return float(payload.get('span_mhz', 2.0))
+
+
+def _pick_sample_rate(span_hz: int, caps: SDRCapabilities, sdr_type: SDRType) -> int:
+    """Pick a valid hardware sample rate nearest the requested span."""
+    valid_rates = sorted({int(r) for r in caps.sample_rates if int(r) > 0})
+    if valid_rates:
+        return min(valid_rates, key=lambda rate: abs(rate - span_hz))
+
+    max_bw = MAX_BANDWIDTH.get(sdr_type, 2400000)
+    return max(62500, min(span_hz, max_bw))
+
+
 def _resolve_sdr_type(sdr_type_str: str) -> SDRType:
     """Convert client sdr_type string to SDRType enum."""
     mapping = {
@@ -87,6 +367,12 @@ def init_waterfall_websocket(app: Flask):
         reader_thread = None
         stop_event = threading.Event()
         claimed_device = None
+        claimed_sdr_type = 'rtlsdr'
+        my_generation = None  # tracks which capture generation this handler owns
+        capture_center_mhz = 0.0
+        capture_start_freq = 0.0
+        capture_end_freq = 0.0
+        capture_span_mhz = 0.0
         # Queue for outgoing messages — only the main loop touches ws.send()
         send_queue = queue.Queue(maxsize=120)
 
@@ -105,7 +391,7 @@ def init_waterfall_websocket(app: Flask):
                         break
 
                 try:
-                    msg = ws.receive(timeout=0.1)
+                    msg = ws.receive(timeout=0.01)
                 except Exception as e:
                     err = str(e).lower()
                     if "closed" in err:
@@ -131,6 +417,10 @@ def init_waterfall_websocket(app: Flask):
                 cmd = data.get('cmd')
 
                 if cmd == 'start':
+                    shared_before = get_shared_capture_status()
+                    keep_monitor_enabled = bool(shared_before.get('monitor_enabled'))
+                    keep_monitor_modulation = str(shared_before.get('monitor_modulation', 'wfm'))
+                    keep_monitor_squelch = int(shared_before.get('monitor_squelch', 0) or 0)
                     # Stop any existing capture
                     was_restarting = iq_process is not None
                     stop_event.set()
@@ -141,8 +431,11 @@ def init_waterfall_websocket(app: Flask):
                         unregister_process(iq_process)
                         iq_process = None
                     if claimed_device is not None:
-                        app_module.release_sdr_device(claimed_device)
+                        app_module.release_sdr_device(claimed_device, claimed_sdr_type)
                         claimed_device = None
+                        claimed_sdr_type = 'rtlsdr'
+                    _set_shared_capture_state(running=False, generation=my_generation)
+                    my_generation = None
                     stop_event.clear()
                     # Flush stale frames from previous capture
                     while not send_queue.empty():
@@ -155,11 +448,20 @@ def init_waterfall_websocket(app: Flask):
                         time.sleep(0.5)
 
                     # Parse config
-                    center_freq = float(data.get('center_freq', 100.0))
+                    try:
-                    span_mhz = float(data.get('span_mhz', 2.0))
+                        center_freq_mhz = _parse_center_freq_mhz(data)
-                    gain = data.get('gain')
+                        requested_vfo_mhz = float(
-                    if gain is not None:
+                            data.get(
-                        gain = float(gain)
+                                'vfo_freq_mhz',
+                                data.get('frequency_mhz', center_freq_mhz),
+                            )
+                        )
+                        span_mhz = _parse_span_mhz(data)
+                        gain_raw = data.get('gain')
+                        if gain_raw is None or str(gain_raw).lower() == 'auto':
+                            gain = None
+                        else:
+                            gain = float(gain_raw)
                         device_index = int(data.get('device', 0))
                         sdr_type_str = data.get('sdr_type', 'rtlsdr')
                         fft_size = int(data.get('fft_size', 1024))
@@ -169,23 +471,55 @@ def init_waterfall_websocket(app: Flask):
                         if ppm is not None:
                             ppm = int(ppm)
                         bias_t = bool(data.get('bias_t', False))
+                        db_min = data.get('db_min')
+                        db_max = data.get('db_max')
+                        if db_min is not None:
+                            db_min = float(db_min)
+                        if db_max is not None:
+                            db_max = float(db_max)
+                    except (TypeError, ValueError) as exc:
+                        ws.send(json.dumps({
+                            'status': 'error',
+                            'message': f'Invalid waterfall configuration: {exc}',
+                        }))
+                        continue
 
-                    # Clamp FFT size to valid powers of 2
+                    # Clamp and normalize runtime settings
                     fft_size = max(256, min(8192, fft_size))
+                    fps = max(2, min(60, fps))
+                    avg_count = max(1, min(32, avg_count))
+                    if center_freq_mhz <= 0 or span_mhz <= 0:
+                        ws.send(json.dumps({
+                            'status': 'error',
+                            'message': 'center_freq_mhz and span_mhz must be > 0',
+                        }))
+                        continue
 
-                    # Resolve SDR type and bandwidth
+                    # Resolve SDR type and choose a valid sample rate
                     sdr_type = _resolve_sdr_type(sdr_type_str)
-                    max_bw = MAX_BANDWIDTH.get(sdr_type, 2400000)
+                    builder = SDRFactory.get_builder(sdr_type)
-                    span_hz = int(span_mhz * 1e6)
+                    caps = builder.get_capabilities()
-                    sample_rate = min(span_hz, max_bw)
+                    requested_span_hz = max(1000, int(span_mhz * 1e6))
+                    sample_rate = _pick_sample_rate(requested_span_hz, caps, sdr_type)
 
                     # Compute effective frequency range
                     effective_span_mhz = sample_rate / 1e6
-                    start_freq = center_freq - effective_span_mhz / 2
+                    start_freq = center_freq_mhz - effective_span_mhz / 2
-                    end_freq = center_freq + effective_span_mhz / 2
+                    end_freq = center_freq_mhz + effective_span_mhz / 2
+                    target_vfo_mhz = requested_vfo_mhz
+                    if not (start_freq <= target_vfo_mhz <= end_freq):
+                        target_vfo_mhz = center_freq_mhz
 
-                    # Claim the device
+                    # Claim the device (retry when restarting to allow
-                    claim_err = app_module.claim_sdr_device(device_index, 'waterfall')
+                    # the kernel time to release the USB handle).
+                    max_claim_attempts = 4 if was_restarting else 1
+                    claim_err = None
+                    for _claim_attempt in range(max_claim_attempts):
+                        claim_err = app_module.claim_sdr_device(device_index, 'waterfall', sdr_type_str)
+                        if not claim_err:
+                            break
+                        if _claim_attempt < max_claim_attempts - 1:
+                            time.sleep(0.4)
                     if claim_err:
                         ws.send(json.dumps({
                             'status': 'error',
@@ -194,41 +528,53 @@ def init_waterfall_websocket(app: Flask):
                         }))
                         continue
                     claimed_device = device_index
+                    claimed_sdr_type = sdr_type_str
 
                     # Build I/Q capture command
                     try:
-                        builder = SDRFactory.get_builder(sdr_type)
                         device = _build_dummy_device(device_index, sdr_type)
                         iq_cmd = builder.build_iq_capture_command(
                             device=device,
-                            frequency_mhz=center_freq,
+                            frequency_mhz=center_freq_mhz,
                             sample_rate=sample_rate,
                             gain=gain,
                             ppm=ppm,
                             bias_t=bias_t,
                         )
                     except NotImplementedError as e:
-                        app_module.release_sdr_device(device_index)
+                        app_module.release_sdr_device(device_index, sdr_type_str)
                         claimed_device = None
+                        claimed_sdr_type = 'rtlsdr'
                         ws.send(json.dumps({
                             'status': 'error',
                             'message': str(e),
                         }))
                         continue
 
+                    # Pre-flight: check the capture binary exists
+                    if not shutil.which(iq_cmd[0]):
+                        app_module.release_sdr_device(device_index, sdr_type_str)
+                        claimed_device = None
+                        claimed_sdr_type = 'rtlsdr'
+                        ws.send(json.dumps({
+                            'status': 'error',
+                            'message': f'Required tool "{iq_cmd[0]}" not found. Install SoapySDR tools (rx_sdr).',
+                        }))
+                        continue
+
                     # Spawn I/Q capture process (retry to handle USB release lag)
                     max_attempts = 3 if was_restarting else 1
                     try:
                         for attempt in range(max_attempts):
                             logger.info(
-                                f"Starting I/Q capture: {center_freq} MHz, "
+                                f"Starting I/Q capture: {center_freq_mhz:.6f} MHz, "
                                 f"span={effective_span_mhz:.1f} MHz, "
                                 f"sr={sample_rate}, fft={fft_size}"
                             )
                             iq_process = subprocess.Popen(
                                 iq_cmd,
                                 stdout=subprocess.PIPE,
-                                stderr=subprocess.DEVNULL,
+                                stderr=subprocess.PIPE,
                                 bufsize=0,
                             )
                             register_process(iq_process)
@@ -236,17 +582,23 @@ def init_waterfall_websocket(app: Flask):
                             # Brief check that process started
                             time.sleep(0.3)
                             if iq_process.poll() is not None:
+                                stderr_out = ''
+                                if iq_process.stderr:
+                                    with suppress(Exception):
+                                        stderr_out = iq_process.stderr.read().decode('utf-8', errors='replace').strip()
                                 unregister_process(iq_process)
                                 iq_process = None
                                 if attempt < max_attempts - 1:
                                     logger.info(
                                         f"I/Q process exited immediately, "
                                         f"retrying ({attempt + 1}/{max_attempts})..."
+                                        + (f" stderr: {stderr_out}" if stderr_out else "")
                                     )
                                     time.sleep(0.5)
                                     continue
+                                detail = f": {stderr_out}" if stderr_out else ""
                                 raise RuntimeError(
-                                    "I/Q capture process exited immediately"
+                                    f"I/Q capture process exited immediately{detail}"
                                 )
                             break  # Process started successfully
                     except Exception as e:
@@ -255,32 +607,62 @@ def init_waterfall_websocket(app: Flask):
                             safe_terminate(iq_process)
                             unregister_process(iq_process)
                             iq_process = None
-                        app_module.release_sdr_device(device_index)
+                        app_module.release_sdr_device(device_index, sdr_type_str)
                         claimed_device = None
+                        claimed_sdr_type = 'rtlsdr'
                         ws.send(json.dumps({
                             'status': 'error',
                             'message': f'Failed to start I/Q capture: {e}',
                         }))
                         continue
 
+                    capture_center_mhz = center_freq_mhz
+                    capture_start_freq = start_freq
+                    capture_end_freq = end_freq
+                    capture_span_mhz = effective_span_mhz
+
+                    my_generation = _set_shared_capture_state(
+                        running=True,
+                        device=device_index,
+                        center_mhz=center_freq_mhz,
+                        span_mhz=effective_span_mhz,
+                        sample_rate=sample_rate,
+                    )
+                    _set_shared_monitor(
+                        enabled=keep_monitor_enabled,
+                        frequency_mhz=target_vfo_mhz,
+                        modulation=keep_monitor_modulation,
+                        squelch=keep_monitor_squelch,
+                    )
+
                     # Send started confirmation
                     ws.send(json.dumps({
                         'status': 'started',
+                        'center_mhz': center_freq_mhz,
                         'start_freq': start_freq,
                         'end_freq': end_freq,
                         'fft_size': fft_size,
                         'sample_rate': sample_rate,
+                        'effective_span_mhz': effective_span_mhz,
+                        'db_min': db_min,
+                        'db_max': db_max,
+                        'vfo_freq_mhz': target_vfo_mhz,
                     }))
 
                     # Start reader thread — puts frames on queue, never calls ws.send()
                     def fft_reader(
                         proc, _send_q, stop_evt,
-                        _fft_size, _avg_count, _fps,
+                        _fft_size, _avg_count, _fps, _sample_rate,
-                        _start_freq, _end_freq,
+                        _start_freq, _end_freq, _center_mhz,
+                        _db_min=None, _db_max=None,
                     ):
                         """Read I/Q from subprocess, compute FFT, enqueue binary frames."""
-                        bytes_per_frame = _fft_size * _avg_count * 2
+                        required_fft_samples = _fft_size * _avg_count
+                        timeslice_samples = max(required_fft_samples, int(_sample_rate / max(1, _fps)))
+                        bytes_per_frame = timeslice_samples * 2
                         frame_interval = 1.0 / _fps
+                        monitor_rotator_phase = 0.0
+                        last_monitor_offset_hz = None
 
                         try:
                             while not stop_evt.is_set():
@@ -304,21 +686,51 @@ def init_waterfall_websocket(app: Flask):
 
                                 # Process FFT pipeline
                                 samples = cu8_to_complex(raw)
+                                fft_samples = samples[-required_fft_samples:] if len(samples) > required_fft_samples else samples
                                 power_db = compute_power_spectrum(
-                                    samples,
+                                    fft_samples,
                                     fft_size=_fft_size,
                                     avg_count=_avg_count,
                                 )
-                                quantized = quantize_to_uint8(power_db)
+                                quantized = quantize_to_uint8(
+                                    power_db,
+                                    db_min=_db_min,
+                                    db_max=_db_max,
+                                )
                                 frame = build_binary_frame(
                                     _start_freq, _end_freq, quantized,
                                 )
 
-                                try:
+                                # Drop frame if main loop cannot keep up.
+                                with suppress(queue.Full):
                                     _send_q.put_nowait(frame)
-                                except queue.Full:
+
-                                    # Drop frame if main loop can't keep up
+                                monitor_cfg = _snapshot_monitor_config()
-                                    pass
+                                if monitor_cfg:
+                                    center_mhz_cfg = float(monitor_cfg.get('center_mhz', _center_mhz))
+                                    monitor_mhz_cfg = float(monitor_cfg.get('monitor_freq_mhz', _center_mhz))
+                                    offset_hz = (monitor_mhz_cfg - center_mhz_cfg) * 1e6
+                                    if (
+                                        last_monitor_offset_hz is None
+                                        or abs(offset_hz - last_monitor_offset_hz) > 1.0
+                                    ):
+                                        monitor_rotator_phase = 0.0
+                                        last_monitor_offset_hz = offset_hz
+
+                                    audio_chunk, monitor_rotator_phase = _demodulate_monitor_audio(
+                                        samples=samples,
+                                        sample_rate=_sample_rate,
+                                        center_mhz=center_mhz_cfg,
+                                        monitor_freq_mhz=monitor_mhz_cfg,
+                                        modulation=monitor_cfg.get('modulation', 'wfm'),
+                                        squelch=int(monitor_cfg.get('squelch', 0)),
+                                        rotator_phase=monitor_rotator_phase,
+                                    )
+                                    if audio_chunk:
+                                        _push_shared_audio_chunk(audio_chunk)
+                                else:
+                                    monitor_rotator_phase = 0.0
+                                    last_monitor_offset_hz = None
 
                                 # Pace to target FPS
                                 elapsed = time.monotonic() - frame_start
@@ -333,13 +745,63 @@ def init_waterfall_websocket(app: Flask):
                         target=fft_reader,
                         args=(
                             iq_process, send_queue, stop_event,
-                            fft_size, avg_count, fps,
+                            fft_size, avg_count, fps, sample_rate,
-                            start_freq, end_freq,
+                            start_freq, end_freq, center_freq_mhz,
+                            db_min, db_max,
                         ),
                         daemon=True,
                     )
                     reader_thread.start()
 
+                elif cmd in ('tune', 'set_vfo'):
+                    if not iq_process or claimed_device is None or iq_process.poll() is not None:
+                        ws.send(json.dumps({
+                            'status': 'error',
+                            'message': 'Waterfall capture is not running',
+                        }))
+                        continue
+                    try:
+                        shared = get_shared_capture_status()
+                        vfo_freq_mhz = float(
+                            data.get(
+                                'vfo_freq_mhz',
+                                data.get('frequency_mhz', data.get('center_freq_mhz', capture_center_mhz)),
+                            )
+                        )
+                        squelch = int(data.get('squelch', shared.get('monitor_squelch', 0)))
+                        modulation = str(data.get('modulation', shared.get('monitor_modulation', 'wfm')))
+                    except (TypeError, ValueError) as exc:
+                        ws.send(json.dumps({
+                            'status': 'error',
+                            'message': f'Invalid tune request: {exc}',
+                        }))
+                        continue
+
+                    if not (capture_start_freq <= vfo_freq_mhz <= capture_end_freq):
+                        ws.send(json.dumps({
+                            'status': 'retune_required',
+                            'message': 'Frequency outside current capture span',
+                            'capture_start_freq': capture_start_freq,
+                            'capture_end_freq': capture_end_freq,
+                            'vfo_freq_mhz': vfo_freq_mhz,
+                        }))
+                        continue
+
+                    monitor_enabled = bool(shared.get('monitor_enabled'))
+                    _set_shared_monitor(
+                        enabled=monitor_enabled,
+                        frequency_mhz=vfo_freq_mhz,
+                        modulation=modulation,
+                        squelch=squelch,
+                    )
+                    ws.send(json.dumps({
+                        'status': 'tuned',
+                        'vfo_freq_mhz': vfo_freq_mhz,
+                        'start_freq': capture_start_freq,
+                        'end_freq': capture_end_freq,
+                        'center_mhz': capture_center_mhz,
+                    }))
+
                 elif cmd == 'stop':
                     stop_event.set()
                     if reader_thread and reader_thread.is_alive():
@@ -350,15 +812,19 @@ def init_waterfall_websocket(app: Flask):
                         unregister_process(iq_process)
                         iq_process = None
                     if claimed_device is not None:
-                        app_module.release_sdr_device(claimed_device)
+                        app_module.release_sdr_device(claimed_device, claimed_sdr_type)
                         claimed_device = None
+                        claimed_sdr_type = 'rtlsdr'
+                    _set_shared_capture_state(running=False, generation=my_generation)
+                    my_generation = None
                     stop_event.clear()
                     ws.send(json.dumps({'status': 'stopped'}))
 
         except Exception as e:
             logger.info(f"WebSocket waterfall closed: {e}")
         finally:
-            # Cleanup
+            # Cleanup — use generation guard so a stale handler cannot
+            # clobber shared state owned by a newer WS connection.
             stop_event.set()
             if reader_thread and reader_thread.is_alive():
                 reader_thread.join(timeout=2)
@@ -366,21 +832,16 @@ def init_waterfall_websocket(app: Flask):
                 safe_terminate(iq_process)
                 unregister_process(iq_process)
             if claimed_device is not None:
-                app_module.release_sdr_device(claimed_device)
+                app_module.release_sdr_device(claimed_device, claimed_sdr_type)
+            _set_shared_capture_state(running=False, generation=my_generation)
             # Complete WebSocket close handshake, then shut down the
             # raw socket so Werkzeug cannot write its HTTP 200 response
             # on top of the WebSocket stream (which browsers see as
             # "Invalid frame header").
-            try:
+            with suppress(Exception):
                 ws.close()
-            except Exception:
+            with suppress(Exception):
-                pass
-            try:
                 ws.sock.shutdown(socket.SHUT_RDWR)
-            except Exception:
+            with suppress(Exception):
-                pass
-            try:
                 ws.sock.close()
-            except Exception:
-                pass
             logger.info("WebSocket waterfall client disconnected")

routes/weather_sat.py

@@ -18,6 +18,7 @@ from utils.weather_sat import (
     is_weather_sat_available,
     CaptureProgress,
     WEATHER_SATELLITES,
+    DEFAULT_SAMPLE_RATE,
 )
 
 logger = get_logger('intercept.weather_sat')
@@ -40,6 +41,35 @@ def _progress_callback(progress: CaptureProgress) -> None:
             pass
 
 
+def _release_weather_sat_device(device_index: int) -> None:
+    """Release an SDR device only if weather-sat currently owns it."""
+    if device_index < 0:
+        return
+
+    try:
+        import app as app_module
+    except ImportError:
+        return
+
+    owner = None
+    get_status = getattr(app_module, 'get_sdr_device_status', None)
+    if callable(get_status):
+        try:
+            owner = get_status().get(device_index)
+        except Exception:
+            owner = None
+
+    if owner and owner != 'weather_sat':
+        logger.debug(
+            'Skipping SDR release for device %s owned by %s',
+            device_index,
+            owner,
+        )
+        return
+
+    app_module.release_sdr_device(device_index)
+
+
 @weather_sat_bp.route('/status')
 def get_status():
     """Get weather satellite decoder status.
@@ -152,18 +182,15 @@ def start_capture():
     decoder.set_callback(_progress_callback)
 
     def _release_device():
-        try:
+        _release_weather_sat_device(device_index)
-            import app as app_module
-            app_module.release_sdr_device(device_index)
-        except ImportError:
-            pass
 
     decoder.set_on_complete(_release_device)
 
-    success = decoder.start(
+    success, error_msg = decoder.start(
         satellite=satellite,
         device_index=device_index,
         gain=gain,
+        sample_rate=DEFAULT_SAMPLE_RATE,
         bias_t=bias_t,
     )
 
@@ -181,7 +208,7 @@ def start_capture():
         _release_device()
         return jsonify({
             'status': 'error',
-            'message': 'Failed to start capture'
+            'message': error_msg or 'Failed to start capture'
         }), 500
 
 
@@ -283,7 +310,7 @@ def test_decode():
     decoder.set_callback(_progress_callback)
     decoder.set_on_complete(None)
 
-    success = decoder.start_from_file(
+    success, error_msg = decoder.start_from_file(
         satellite=satellite,
         input_file=input_file,
         sample_rate=sample_rate,
@@ -302,7 +329,7 @@ def test_decode():
     else:
         return jsonify({
             'status': 'error',
-            'message': 'Failed to start file decode'
+            'message': error_msg or 'Failed to start file decode'
         }), 500
 
 
@@ -318,12 +345,7 @@ def stop_capture():
 
     decoder.stop()
 
-    # Release SDR device
+    _release_weather_sat_device(device_index)
-    try:
-        import app as app_module
-        app_module.release_sdr_device(device_index)
-    except ImportError:
-        pass
 
     return jsonify({'status': 'stopped'})
 

routes/wefax.py

@@ -0,0 +1,518 @@
+"""WeFax (Weather Fax) decoder routes.
+
+Provides endpoints for decoding HF weather fax transmissions from
+maritime/aviation weather services worldwide.
+"""
+
+from __future__ import annotations
+
+import queue
+
+from flask import Blueprint, Response, jsonify, request, send_file
+
+import app as app_module
+from utils.logging import get_logger
+from utils.sdr import SDRType
+from utils.sse import sse_stream_fanout
+from utils.validation import validate_frequency
+from utils.wefax import get_wefax_decoder
+from utils.wefax_stations import (
+    WEFAX_USB_ALIGNMENT_OFFSET_KHZ,
+    get_current_broadcasts,
+    get_station,
+    load_stations,
+    resolve_tuning_frequency_khz,
+)
+
+logger = get_logger('intercept.wefax')
+
+wefax_bp = Blueprint('wefax', __name__, url_prefix='/wefax')
+
+# SSE progress queue
+_wefax_queue: queue.Queue = queue.Queue(maxsize=100)
+
+# Track active SDR device
+wefax_active_device: int | None = None
+wefax_active_sdr_type: str | None = None
+
+
+def _progress_callback(data: dict) -> None:
+    """Callback to queue progress updates for SSE stream."""
+    global wefax_active_device, wefax_active_sdr_type
+
+    try:
+        _wefax_queue.put_nowait(data)
+    except queue.Full:
+        try:
+            _wefax_queue.get_nowait()
+            _wefax_queue.put_nowait(data)
+        except queue.Empty:
+            pass
+
+    # Ensure manually claimed SDR devices are always released when a
+    # decode session ends on its own (complete/error/stopped).
+    if (
+        isinstance(data, dict)
+        and data.get('type') == 'wefax_progress'
+        and data.get('status') in ('complete', 'error', 'stopped')
+        and wefax_active_device is not None
+    ):
+        app_module.release_sdr_device(wefax_active_device, wefax_active_sdr_type or 'rtlsdr')
+        wefax_active_device = None
+        wefax_active_sdr_type = None
+
+
+@wefax_bp.route('/status')
+def get_status():
+    """Get WeFax decoder status."""
+    decoder = get_wefax_decoder()
+    return jsonify({
+        'available': True,
+        'running': decoder.is_running,
+        'image_count': len(decoder.get_images()),
+    })
+
+
+@wefax_bp.route('/start', methods=['POST'])
+def start_decoder():
+    """Start WeFax decoder.
+
+    JSON body:
+        {
+            "frequency_khz": 4298,
+            "station": "NOJ",
+            "device": 0,
+            "gain": 40,
+            "ioc": 576,
+            "lpm": 120,
+            "direct_sampling": true,
+            "frequency_reference": "auto"  // auto, carrier, or dial
+        }
+    """
+    decoder = get_wefax_decoder()
+
+    if decoder.is_running:
+        return jsonify({
+            'status': 'already_running',
+            'message': 'WeFax decoder is already running',
+        })
+
+    # Clear queue
+    while not _wefax_queue.empty():
+        try:
+            _wefax_queue.get_nowait()
+        except queue.Empty:
+            break
+
+    data = request.get_json(silent=True) or {}
+
+    # Validate frequency (required)
+    frequency_khz = data.get('frequency_khz')
+    if frequency_khz is None:
+        return jsonify({
+            'status': 'error',
+            'message': 'frequency_khz is required',
+        }), 400
+
+    try:
+        frequency_khz = float(frequency_khz)
+        # WeFax operates on HF: 2-30 MHz (2000-30000 kHz)
+        freq_mhz = frequency_khz / 1000.0
+        validate_frequency(freq_mhz, min_mhz=2.0, max_mhz=30.0)
+    except (TypeError, ValueError) as e:
+        return jsonify({
+            'status': 'error',
+            'message': f'Invalid frequency: {e}',
+        }), 400
+
+    station = str(data.get('station', '')).strip()
+    device_index = data.get('device', 0)
+    gain = float(data.get('gain', 40.0))
+    ioc = int(data.get('ioc', 576))
+    lpm = int(data.get('lpm', 120))
+    direct_sampling = bool(data.get('direct_sampling', True))
+    frequency_reference = str(data.get('frequency_reference', 'auto')).strip().lower()
+
+    sdr_type_str = str(data.get('sdr_type', 'rtlsdr')).lower()
+    try:
+        sdr_type = SDRType(sdr_type_str)
+    except ValueError:
+        sdr_type = SDRType.RTL_SDR
+    if not frequency_reference:
+        frequency_reference = 'auto'
+
+    try:
+        tuned_frequency_khz, resolved_reference, usb_offset_applied = (
+            resolve_tuning_frequency_khz(
+                listed_frequency_khz=frequency_khz,
+                station_callsign=station,
+                frequency_reference=frequency_reference,
+            )
+        )
+        tuned_mhz = tuned_frequency_khz / 1000.0
+        validate_frequency(tuned_mhz, min_mhz=2.0, max_mhz=30.0)
+    except ValueError as e:
+        return jsonify({
+            'status': 'error',
+            'message': f'Invalid frequency settings: {e}',
+        }), 400
+
+    # Validate IOC and LPM
+    if ioc not in (288, 576):
+        return jsonify({
+            'status': 'error',
+            'message': 'IOC must be 288 or 576',
+        }), 400
+
+    if lpm not in (60, 120):
+        return jsonify({
+            'status': 'error',
+            'message': 'LPM must be 60 or 120',
+        }), 400
+
+    # Claim SDR device
+    global wefax_active_device, wefax_active_sdr_type
+    device_int = int(device_index)
+    error = app_module.claim_sdr_device(device_int, 'wefax', sdr_type_str)
+    if error:
+        return jsonify({
+            'status': 'error',
+            'error_type': 'DEVICE_BUSY',
+            'message': error,
+        }), 409
+
+    # Set callback and start
+    decoder.set_callback(_progress_callback)
+    success = decoder.start(
+        frequency_khz=tuned_frequency_khz,
+        station=station,
+        device_index=device_int,
+        gain=gain,
+        ioc=ioc,
+        lpm=lpm,
+        direct_sampling=direct_sampling,
+        sdr_type=sdr_type_str,
+    )
+
+    if success:
+        wefax_active_device = device_int
+        wefax_active_sdr_type = sdr_type_str
+        return jsonify({
+            'status': 'started',
+            'frequency_khz': frequency_khz,
+            'tuned_frequency_khz': tuned_frequency_khz,
+            'frequency_reference': resolved_reference,
+            'usb_offset_applied': usb_offset_applied,
+            'usb_offset_khz': (
+                WEFAX_USB_ALIGNMENT_OFFSET_KHZ if usb_offset_applied else 0.0
+            ),
+            'station': station,
+            'ioc': ioc,
+            'lpm': lpm,
+            'device': device_int,
+        })
+    else:
+        app_module.release_sdr_device(device_int, sdr_type_str)
+        return jsonify({
+            'status': 'error',
+            'message': 'Failed to start decoder',
+        }), 500
+
+
+@wefax_bp.route('/stop', methods=['POST'])
+def stop_decoder():
+    """Stop WeFax decoder."""
+    global wefax_active_device, wefax_active_sdr_type
+    decoder = get_wefax_decoder()
+    decoder.stop()
+
+    if wefax_active_device is not None:
+        app_module.release_sdr_device(wefax_active_device, wefax_active_sdr_type or 'rtlsdr')
+        wefax_active_device = None
+        wefax_active_sdr_type = None
+
+    return jsonify({'status': 'stopped'})
+
+
+@wefax_bp.route('/stream')
+def stream_progress():
+    """SSE stream of WeFax decode progress."""
+    response = Response(
+        sse_stream_fanout(
+            source_queue=_wefax_queue,
+            channel_key='wefax',
+            timeout=1.0,
+            keepalive_interval=30.0,
+        ),
+        mimetype='text/event-stream',
+    )
+    response.headers['Cache-Control'] = 'no-cache'
+    response.headers['X-Accel-Buffering'] = 'no'
+    response.headers['Connection'] = 'keep-alive'
+    return response
+
+
+@wefax_bp.route('/images')
+def list_images():
+    """Get list of decoded WeFax images."""
+    decoder = get_wefax_decoder()
+    images = decoder.get_images()
+
+    limit = request.args.get('limit', type=int)
+    if limit and limit > 0:
+        images = images[-limit:]
+
+    return jsonify({
+        'status': 'ok',
+        'images': [img.to_dict() for img in images],
+        'count': len(images),
+    })
+
+
+@wefax_bp.route('/images/<filename>')
+def get_image(filename: str):
+    """Get a decoded WeFax image file."""
+    decoder = get_wefax_decoder()
+
+    if not filename.replace('_', '').replace('-', '').replace('.', '').isalnum():
+        return jsonify({'status': 'error', 'message': 'Invalid filename'}), 400
+
+    if not filename.endswith('.png'):
+        return jsonify({'status': 'error', 'message': 'Only PNG files supported'}), 400
+
+    image_path = decoder._output_dir / filename
+    if not image_path.exists():
+        return jsonify({'status': 'error', 'message': 'Image not found'}), 404
+
+    return send_file(image_path, mimetype='image/png')
+
+
+@wefax_bp.route('/images/<filename>', methods=['DELETE'])
+def delete_image(filename: str):
+    """Delete a decoded WeFax image."""
+    decoder = get_wefax_decoder()
+
+    if not filename.replace('_', '').replace('-', '').replace('.', '').isalnum():
+        return jsonify({'status': 'error', 'message': 'Invalid filename'}), 400
+
+    if not filename.endswith('.png'):
+        return jsonify({'status': 'error', 'message': 'Only PNG files supported'}), 400
+
+    if decoder.delete_image(filename):
+        return jsonify({'status': 'ok'})
+    else:
+        return jsonify({'status': 'error', 'message': 'Image not found'}), 404
+
+
+@wefax_bp.route('/images', methods=['DELETE'])
+def delete_all_images():
+    """Delete all decoded WeFax images."""
+    decoder = get_wefax_decoder()
+    count = decoder.delete_all_images()
+    return jsonify({'status': 'ok', 'deleted': count})
+
+
+# ========================
+# Auto-Scheduler Endpoints
+# ========================
+
+
+def _scheduler_event_callback(event: dict) -> None:
+    """Forward scheduler events to the SSE queue."""
+    try:
+        _wefax_queue.put_nowait(event)
+    except queue.Full:
+        try:
+            _wefax_queue.get_nowait()
+            _wefax_queue.put_nowait(event)
+        except queue.Empty:
+            pass
+
+
+@wefax_bp.route('/schedule/enable', methods=['POST'])
+def enable_schedule():
+    """Enable auto-scheduling of WeFax broadcast captures.
+
+    JSON body:
+        {
+            "station": "NOJ",
+            "frequency_khz": 4298,
+            "device": 0,
+            "gain": 40,
+            "ioc": 576,
+            "lpm": 120,
+            "direct_sampling": true,
+            "frequency_reference": "auto"  // auto, carrier, or dial
+        }
+
+    Returns:
+        JSON with scheduler status.
+    """
+    from utils.wefax_scheduler import get_wefax_scheduler
+
+    data = request.get_json(silent=True) or {}
+
+    station = str(data.get('station', '')).strip()
+    if not station:
+        return jsonify({
+            'status': 'error',
+            'message': 'station is required',
+        }), 400
+
+    frequency_khz = data.get('frequency_khz')
+    if frequency_khz is None:
+        return jsonify({
+            'status': 'error',
+            'message': 'frequency_khz is required',
+        }), 400
+
+    try:
+        frequency_khz = float(frequency_khz)
+        freq_mhz = frequency_khz / 1000.0
+        validate_frequency(freq_mhz, min_mhz=2.0, max_mhz=30.0)
+    except (TypeError, ValueError) as e:
+        return jsonify({
+            'status': 'error',
+            'message': f'Invalid frequency: {e}',
+        }), 400
+
+    device = int(data.get('device', 0))
+    gain = float(data.get('gain', 40.0))
+    ioc = int(data.get('ioc', 576))
+    lpm = int(data.get('lpm', 120))
+    direct_sampling = bool(data.get('direct_sampling', True))
+    frequency_reference = str(data.get('frequency_reference', 'auto')).strip().lower()
+    if not frequency_reference:
+        frequency_reference = 'auto'
+
+    try:
+        tuned_frequency_khz, resolved_reference, usb_offset_applied = (
+            resolve_tuning_frequency_khz(
+                listed_frequency_khz=frequency_khz,
+                station_callsign=station,
+                frequency_reference=frequency_reference,
+            )
+        )
+        tuned_mhz = tuned_frequency_khz / 1000.0
+        validate_frequency(tuned_mhz, min_mhz=2.0, max_mhz=30.0)
+    except ValueError as e:
+        return jsonify({
+            'status': 'error',
+            'message': f'Invalid frequency settings: {e}',
+        }), 400
+
+    scheduler = get_wefax_scheduler()
+    scheduler.set_callbacks(_progress_callback, _scheduler_event_callback)
+
+    try:
+        result = scheduler.enable(
+            station=station,
+            frequency_khz=tuned_frequency_khz,
+            device=device,
+            gain=gain,
+            ioc=ioc,
+            lpm=lpm,
+            direct_sampling=direct_sampling,
+        )
+    except Exception:
+        logger.exception("Failed to enable WeFax scheduler")
+        return jsonify({
+            'status': 'error',
+            'message': 'Failed to enable scheduler',
+        }), 500
+
+    return jsonify({
+        'status': 'ok',
+        **result,
+        'frequency_khz': frequency_khz,
+        'tuned_frequency_khz': tuned_frequency_khz,
+        'frequency_reference': resolved_reference,
+        'usb_offset_applied': usb_offset_applied,
+        'usb_offset_khz': (
+            WEFAX_USB_ALIGNMENT_OFFSET_KHZ if usb_offset_applied else 0.0
+        ),
+    })
+
+
+@wefax_bp.route('/schedule/disable', methods=['POST'])
+def disable_schedule():
+    """Disable auto-scheduling."""
+    from utils.wefax_scheduler import get_wefax_scheduler
+
+    scheduler = get_wefax_scheduler()
+    result = scheduler.disable()
+    return jsonify(result)
+
+
+@wefax_bp.route('/schedule/status')
+def schedule_status():
+    """Get current scheduler state."""
+    from utils.wefax_scheduler import get_wefax_scheduler
+
+    scheduler = get_wefax_scheduler()
+    return jsonify(scheduler.get_status())
+
+
+@wefax_bp.route('/schedule/broadcasts')
+def schedule_broadcasts():
+    """List scheduled broadcasts."""
+    from utils.wefax_scheduler import get_wefax_scheduler
+
+    scheduler = get_wefax_scheduler()
+    broadcasts = scheduler.get_broadcasts()
+    return jsonify({
+        'status': 'ok',
+        'broadcasts': broadcasts,
+        'count': len(broadcasts),
+    })
+
+
+@wefax_bp.route('/schedule/skip/<broadcast_id>', methods=['POST'])
+def skip_broadcast(broadcast_id: str):
+    """Skip a scheduled broadcast."""
+    from utils.wefax_scheduler import get_wefax_scheduler
+
+    if not broadcast_id.replace('_', '').replace('-', '').isalnum():
+        return jsonify({
+            'status': 'error',
+            'message': 'Invalid broadcast ID',
+        }), 400
+
+    scheduler = get_wefax_scheduler()
+    if scheduler.skip_broadcast(broadcast_id):
+        return jsonify({'status': 'skipped', 'broadcast_id': broadcast_id})
+    else:
+        return jsonify({
+            'status': 'error',
+            'message': 'Broadcast not found or already processed',
+        }), 404
+
+
+@wefax_bp.route('/stations')
+def list_stations():
+    """Get all WeFax stations from the database."""
+    stations = load_stations()
+    return jsonify({
+        'status': 'ok',
+        'stations': stations,
+        'count': len(stations),
+    })
+
+
+@wefax_bp.route('/stations/<callsign>')
+def station_detail(callsign: str):
+    """Get station detail including current schedule info."""
+    station = get_station(callsign)
+    if not station:
+        return jsonify({
+            'status': 'error',
+            'message': f'Station {callsign} not found',
+        }), 404
+
+    current = get_current_broadcasts(callsign)
+
+    return jsonify({
+        'status': 'ok',
+        'station': station,
+        'current_broadcasts': current,
+    })

setup.sh

@@ -229,14 +229,11 @@ check_tools() {
   check_optional "dumpvdl2"    "VDL2 decoder" dumpvdl2
   check_required "AIS-catcher" "AIS vessel decoder" AIS-catcher aiscatcher
   check_optional "satdump" "Weather satellite decoder (NOAA/Meteor)" satdump
+  check_optional "auto_rx.py" "Radiosonde weather balloon decoder" auto_rx.py
   echo
   info "GPS:"
   check_required "gpsd" "GPS daemon" gpsd
 
-  echo
-  info "Digital Voice:"
-  check_optional "dsd" "Digital Speech Decoder (DMR/P25)" dsd dsd-fme
-
   echo
   info "Audio:"
   check_required "ffmpeg" "Audio encoder/decoder" ffmpeg
@@ -458,95 +455,6 @@ install_multimon_ng_from_source_macos() {
   )
 }
 
-install_dsd_from_source() {
-  info "Building DSD (Digital Speech Decoder) from source..."
-  info "This requires mbelib (vocoder library) as a prerequisite."
-
-  if [[ "$OS" == "macos" ]]; then
-    brew_install cmake
-    brew_install libsndfile
-    brew_install ncurses
-    brew_install fftw
-    brew_install codec2
-    brew_install librtlsdr
-    brew_install pulseaudio || true
-  else
-    apt_install build-essential git cmake libsndfile1-dev libpulse-dev \
-      libfftw3-dev liblapack-dev libncurses-dev librtlsdr-dev libcodec2-dev
-  fi
-
-  (
-    tmp_dir="$(mktemp -d)"
-    trap 'rm -rf "$tmp_dir"' EXIT
-
-    # Step 1: Build and install mbelib (required dependency)
-    info "Building mbelib (vocoder library)..."
-    git clone https://github.com/lwvmobile/mbelib.git "$tmp_dir/mbelib" >/dev/null 2>&1 \
-      || { warn "Failed to clone mbelib"; exit 1; }
-
-    cd "$tmp_dir/mbelib"
-    git checkout ambe_tones >/dev/null 2>&1 || true
-    mkdir -p build && cd build
-
-    if cmake .. >/dev/null 2>&1 && make -j "$(nproc 2>/dev/null || sysctl -n hw.ncpu)" >/dev/null 2>&1; then
-      if [[ "$OS" == "macos" ]]; then
-        if [[ -w /usr/local/lib ]]; then
-          make install >/dev/null 2>&1
-        else
-          refresh_sudo
-          $SUDO make install >/dev/null 2>&1
-        fi
-      else
-        $SUDO make install >/dev/null 2>&1
-        $SUDO ldconfig 2>/dev/null || true
-      fi
-      ok "mbelib installed"
-    else
-      warn "Failed to build mbelib. Cannot build DSD without it."
-      exit 1
-    fi
-
-    # Step 2: Build dsd-fme (or fall back to original dsd)
-    info "Building dsd-fme..."
-    git clone --depth 1 https://github.com/lwvmobile/dsd-fme.git "$tmp_dir/dsd-fme" >/dev/null 2>&1 \
-      || { warn "Failed to clone dsd-fme, trying original DSD...";
-           git clone --depth 1 https://github.com/szechyjs/dsd.git "$tmp_dir/dsd-fme" >/dev/null 2>&1 \
-             || { warn "Failed to clone DSD"; exit 1; }; }
-
-    cd "$tmp_dir/dsd-fme"
-    mkdir -p build && cd build
-
-    # On macOS, help cmake find Homebrew ncurses
-    local cmake_flags=""
-    if [[ "$OS" == "macos" ]]; then
-      local ncurses_prefix
-      ncurses_prefix="$(brew --prefix ncurses 2>/dev/null || echo /opt/homebrew/opt/ncurses)"
-      cmake_flags="-DCMAKE_PREFIX_PATH=$ncurses_prefix"
-    fi
-
-    info "Compiling DSD..."
-    if cmake .. $cmake_flags >/dev/null 2>&1 && make -j "$(nproc 2>/dev/null || sysctl -n hw.ncpu)" >/dev/null 2>&1; then
-      if [[ "$OS" == "macos" ]]; then
-        if [[ -w /usr/local/bin ]]; then
-          install -m 0755 dsd-fme /usr/local/bin/dsd 2>/dev/null || install -m 0755 dsd /usr/local/bin/dsd 2>/dev/null || true
-        else
-          refresh_sudo
-          $SUDO install -m 0755 dsd-fme /usr/local/bin/dsd 2>/dev/null || $SUDO install -m 0755 dsd /usr/local/bin/dsd 2>/dev/null || true
-        fi
-      else
-        $SUDO make install >/dev/null 2>&1 \
-          || $SUDO install -m 0755 dsd-fme /usr/local/bin/dsd 2>/dev/null \
-          || $SUDO install -m 0755 dsd /usr/local/bin/dsd 2>/dev/null \
-          || true
-        $SUDO ldconfig 2>/dev/null || true
-      fi
-      ok "DSD installed successfully"
-    else
-      warn "Failed to build DSD from source. DMR/P25 decoding will not be available."
-    fi
-  )
-}
-
 install_dump1090_from_source_macos() {
   info "dump1090 not available via Homebrew. Building from source..."
 
@@ -909,6 +817,53 @@ WRAPPER
   )
 }
 
+install_radiosonde_auto_rx() {
+  info "Installing radiosonde_auto_rx (weather balloon decoder)..."
+  local install_dir="/opt/radiosonde_auto_rx"
+  local project_dir="$(pwd)"
+
+  (
+    tmp_dir="$(mktemp -d)"
+    trap 'rm -rf "$tmp_dir"' EXIT
+
+    info "Cloning radiosonde_auto_rx..."
+    if ! git clone --depth 1 https://github.com/projecthorus/radiosonde_auto_rx.git "$tmp_dir/radiosonde_auto_rx"; then
+      warn "Failed to clone radiosonde_auto_rx"
+      exit 1
+    fi
+
+    info "Installing Python dependencies..."
+    cd "$tmp_dir/radiosonde_auto_rx/auto_rx"
+    # Use project venv pip to avoid PEP 668 externally-managed-environment errors
+    if [ -x "$project_dir/venv/bin/pip" ]; then
+      "$project_dir/venv/bin/pip" install --quiet -r requirements.txt || {
+        warn "Failed to install radiosonde_auto_rx Python dependencies"
+        exit 1
+      }
+    else
+      pip3 install --quiet --break-system-packages -r requirements.txt 2>/dev/null \
+        || pip3 install --quiet -r requirements.txt || {
+        warn "Failed to install radiosonde_auto_rx Python dependencies"
+        exit 1
+      }
+    fi
+
+    info "Building radiosonde_auto_rx C decoders..."
+    if ! bash build.sh; then
+      warn "Failed to build radiosonde_auto_rx decoders"
+      exit 1
+    fi
+
+    info "Installing to ${install_dir}..."
+    refresh_sudo
+    $SUDO mkdir -p "$install_dir/auto_rx"
+    $SUDO cp -r . "$install_dir/auto_rx/"
+    $SUDO chmod +x "$install_dir/auto_rx/auto_rx.py"
+
+    ok "radiosonde_auto_rx installed to ${install_dir}"
+  )
+}
+
 install_macos_packages() {
   need_sudo
 
@@ -941,19 +896,6 @@ install_macos_packages() {
   progress "SSTV decoder"
   ok "SSTV uses built-in pure Python decoder (no external tools needed)"
 
-  progress "Installing DSD (Digital Speech Decoder, optional)"
-  if ! cmd_exists dsd && ! cmd_exists dsd-fme; then
-    echo
-    info "DSD is used for DMR, P25, NXDN, and D-STAR digital voice decoding."
-    if ask_yes_no "Do you want to install DSD?"; then
-      install_dsd_from_source || warn "DSD build failed. DMR/P25 decoding will not be available."
-    else
-      warn "Skipping DSD installation. DMR/P25 decoding will not be available."
-    fi
-  else
-    ok "DSD already installed"
-  fi
-
   progress "Installing ffmpeg"
   brew_install ffmpeg
 
@@ -1018,6 +960,20 @@ install_macos_packages() {
     ok "SatDump already installed"
   fi
 
+  progress "Installing radiosonde_auto_rx (optional)"
+  if ! cmd_exists auto_rx.py && [ ! -f /opt/radiosonde_auto_rx/auto_rx/auto_rx.py ] \
+     || { [ -f /opt/radiosonde_auto_rx/auto_rx/auto_rx.py ] && [ ! -f /opt/radiosonde_auto_rx/auto_rx/dft_detect ]; }; then
+    echo
+    info "radiosonde_auto_rx is used for weather balloon (radiosonde) tracking."
+    if ask_yes_no "Do you want to install radiosonde_auto_rx?"; then
+      install_radiosonde_auto_rx || warn "radiosonde_auto_rx installation failed. Radiosonde tracking will not be available."
+    else
+      warn "Skipping radiosonde_auto_rx. You can install it later if needed."
+    fi
+  else
+    ok "radiosonde_auto_rx already installed"
+  fi
+
   progress "Installing aircrack-ng"
   brew_install aircrack-ng
 
@@ -1474,19 +1430,6 @@ install_debian_packages() {
   progress "SSTV decoder"
   ok "SSTV uses built-in pure Python decoder (no external tools needed)"
 
-  progress "Installing DSD (Digital Speech Decoder, optional)"
-  if ! cmd_exists dsd && ! cmd_exists dsd-fme; then
-    echo
-    info "DSD is used for DMR, P25, NXDN, and D-STAR digital voice decoding."
-    if ask_yes_no "Do you want to install DSD?"; then
-      install_dsd_from_source || warn "DSD build failed. DMR/P25 decoding will not be available."
-    else
-      warn "Skipping DSD installation. DMR/P25 decoding will not be available."
-    fi
-  else
-    ok "DSD already installed"
-  fi
-
   progress "Installing ffmpeg"
   apt_install ffmpeg
 
@@ -1604,6 +1547,20 @@ install_debian_packages() {
     ok "SatDump already installed"
   fi
 
+  progress "Installing radiosonde_auto_rx (optional)"
+  if ! cmd_exists auto_rx.py && [ ! -f /opt/radiosonde_auto_rx/auto_rx/auto_rx.py ] \
+     || { [ -f /opt/radiosonde_auto_rx/auto_rx/auto_rx.py ] && [ ! -f /opt/radiosonde_auto_rx/auto_rx/dft_detect ]; }; then
+    echo
+    info "radiosonde_auto_rx is used for weather balloon (radiosonde) tracking."
+    if ask_yes_no "Do you want to install radiosonde_auto_rx?"; then
+      install_radiosonde_auto_rx || warn "radiosonde_auto_rx installation failed. Radiosonde tracking will not be available."
+    else
+      warn "Skipping radiosonde_auto_rx. You can install it later if needed."
+    fi
+  else
+    ok "radiosonde_auto_rx already installed"
+  fi
+
   progress "Configuring udev rules"
   setup_udev_rules_debian
 

static/css/adsb_dashboard.css

@@ -893,6 +893,92 @@ body {
     display: block;
 }
 
+.map-crosshair-overlay {
+    position: absolute;
+    inset: 0;
+    pointer-events: none;
+    overflow: hidden;
+    z-index: 1200;
+    --crosshair-x-start: 100%;
+    --crosshair-y-start: 100%;
+    --crosshair-x-end: 50%;
+    --crosshair-y-end: 50%;
+    --crosshair-duration: 1500ms;
+}
+
+.map-crosshair-line {
+    position: absolute;
+    opacity: 0;
+    background: var(--accent-cyan);
+    box-shadow: none;
+    will-change: transform, opacity;
+}
+
+.map-crosshair-vertical {
+    top: 0;
+    bottom: 0;
+    width: 1px;
+    left: 0;
+    transform: translateX(var(--crosshair-x-start));
+}
+
+.map-crosshair-horizontal {
+    left: 0;
+    right: 0;
+    height: 1px;
+    top: 0;
+    transform: translateY(var(--crosshair-y-start));
+}
+
+.map-crosshair-overlay.active .map-crosshair-vertical {
+    animation: mapCrosshairSweepX var(--crosshair-duration) cubic-bezier(0.2, 0.85, 0.28, 1) forwards;
+}
+
+.map-crosshair-overlay.active .map-crosshair-horizontal {
+    animation: mapCrosshairSweepY var(--crosshair-duration) cubic-bezier(0.2, 0.85, 0.28, 1) forwards;
+}
+
+@keyframes mapCrosshairSweepX {
+    0% {
+        transform: translateX(var(--crosshair-x-start));
+        opacity: 0;
+    }
+    12% {
+        opacity: 1;
+    }
+    85% {
+        opacity: 1;
+    }
+    100% {
+        transform: translateX(var(--crosshair-x-end));
+        opacity: 0;
+    }
+}
+
+@keyframes mapCrosshairSweepY {
+    0% {
+        transform: translateY(var(--crosshair-y-start));
+        opacity: 0;
+    }
+    12% {
+        opacity: 1;
+    }
+    85% {
+        opacity: 1;
+    }
+    100% {
+        transform: translateY(var(--crosshair-y-end));
+        opacity: 0;
+    }
+}
+
+@media (prefers-reduced-motion: reduce) {
+    .map-crosshair-overlay.active .map-crosshair-vertical,
+    .map-crosshair-overlay.active .map-crosshair-horizontal {
+        animation-duration: 220ms;
+    }
+}
+
 /* Right sidebar - Mobile first */
 .sidebar {
     display: flex;
@@ -1160,7 +1246,7 @@ body {
 
 .control-group select {
     padding: 4px 8px;
-    background: rgba(0, 0, 0, 0.3);
+    background: var(--bg-dark);
     border: 1px solid rgba(74, 158, 255, 0.3);
     border-radius: 4px;
     color: var(--accent-cyan);

static/css/ais_dashboard.css

@@ -779,7 +779,7 @@ body {
 
 .control-group select {
     padding: 4px 8px;
-    background: rgba(0, 0, 0, 0.3);
+    background: var(--bg-dark);
     border: 1px solid rgba(74, 158, 255, 0.3);
     border-radius: 4px;
     color: var(--accent-cyan);

static/css/components/proximity-viz.css

@@ -13,13 +13,11 @@
 }
 
 .radar-device {
-    transition: transform 0.2s ease;
-    transform-origin: center center;
     cursor: pointer;
 }
 
-.radar-device:hover {
+.radar-device:hover .radar-dot {
-    transform: scale(1.2);
+    filter: brightness(1.5);
 }
 
 /* Invisible larger hit area to prevent hover flicker */

static/css/index.css

@@ -202,10 +202,38 @@ body {
 }
 
 .welcome-container {
+    position: relative;
     width: 90%;
     max-width: 900px;
     z-index: 1;
     animation: welcomeFadeIn 0.8s ease-out;
+    max-height: calc(100vh - 40px);
+    overflow: hidden;
+}
+
+.welcome-settings-btn {
+    position: absolute;
+    top: 12px;
+    right: 12px;
+    z-index: 2;
+    background: none;
+    border: none;
+    cursor: pointer;
+    padding: 6px;
+    border-radius: 6px;
+    color: var(--text-dim, rgba(255, 255, 255, 0.3));
+    transition: color 0.2s, background 0.2s;
+}
+
+.welcome-settings-btn:hover {
+    color: var(--accent-cyan, #00d4ff);
+    background: rgba(255, 255, 255, 0.05);
+}
+
+.welcome-settings-btn svg {
+    width: 20px;
+    height: 20px;
+    display: block;
 }
 
 @keyframes welcomeFadeIn {
@@ -232,6 +260,7 @@ body {
 
 .welcome-logo {
     animation: logoPulse 3s ease-in-out infinite;
+    will-change: filter;
 }
 
 @keyframes logoPulse {
@@ -332,6 +361,7 @@ body {
     padding: 20px;
     max-height: calc(100vh - 300px);
     overflow-y: auto;
+    scrollbar-gutter: stable;
 }
 
 .changelog-release {
@@ -1559,6 +1589,7 @@ header h1 .tagline {
     overflow: hidden;
     padding: 12px;
     position: relative;
+    flex-shrink: 0;
 }
 
 .section h3 {
@@ -1744,6 +1775,7 @@ header h1 .tagline {
 }
 
 .run-btn {
+    flex-shrink: 0;
     width: 100%;
     padding: 12px;
     background: var(--accent-green);
@@ -1781,6 +1813,7 @@ header h1 .tagline {
 }
 
 .stop-btn {
+    flex-shrink: 0;
     width: 100%;
     padding: 12px;
     background: var(--accent-red);
@@ -1802,6 +1835,14 @@ header h1 .tagline {
     box-shadow: 0 4px 12px rgba(239, 68, 68, 0.3);
 }
 
+@keyframes stop-btn-pulse {
+    0%, 100% { opacity: 1; box-shadow: 0 0 0 0 rgba(239,68,68,0); }
+    50%       { opacity: 0.75; box-shadow: 0 0 8px 2px rgba(239,68,68,0.45); }
+}
+.stop-btn {
+    animation: stop-btn-pulse 1.2s ease-in-out infinite;
+}
+
 .output-panel {
     background: var(--bg-primary);
     display: flex;
@@ -2172,6 +2213,10 @@ header h1 .tagline {
 }
 
 .control-btn {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    gap: 6px;
     padding: 6px 12px;
     background: transparent;
     border: 1px solid var(--border-color);
@@ -2182,6 +2227,14 @@ header h1 .tagline {
     letter-spacing: 1px;
     transition: all 0.2s ease;
     font-family: var(--font-sans);
+    line-height: 1.1;
+    white-space: nowrap;
+}
+
+.control-btn .icon {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
 }
 
 .control-btn:hover {

static/css/modes/analytics.css

@@ -1,500 +0,0 @@
-/* Analytics Dashboard Styles */
-
-/* Analytics is a sidebar-only mode — hide the output panel and expand the sidebar */
-@media (min-width: 1024px) {
-    .main-content.analytics-active {
-        grid-template-columns: 1fr !important;
-    }
-    .main-content.analytics-active > .output-panel {
-        display: none !important;
-    }
-    .main-content.analytics-active > .sidebar {
-        max-width: 100% !important;
-        width: 100% !important;
-    }
-    .main-content.analytics-active .sidebar-collapse-btn {
-        display: none !important;
-    }
-}
-
-@media (max-width: 1023px) {
-    .main-content.analytics-active > .output-panel {
-        display: none !important;
-    }
-}
-
-.analytics-grid {
-    display: grid;
-    grid-template-columns: repeat(auto-fill, minmax(140px, 1fr));
-    gap: var(--space-3, 12px);
-    margin-bottom: var(--space-4, 16px);
-}
-
-.analytics-insight-grid {
-    display: grid;
-    grid-template-columns: repeat(auto-fill, minmax(210px, 1fr));
-    gap: var(--space-3, 12px);
-}
-
-.analytics-insight-card {
-    background: var(--bg-card, #151f2b);
-    border: 1px solid var(--border-color, #1e2d3d);
-    border-radius: var(--radius-md, 8px);
-    padding: 10px;
-    display: flex;
-    flex-direction: column;
-    gap: 4px;
-}
-
-.analytics-insight-card.low {
-    border-color: rgba(90, 106, 122, 0.5);
-}
-
-.analytics-insight-card.medium {
-    border-color: rgba(74, 163, 255, 0.45);
-}
-
-.analytics-insight-card.high {
-    border-color: rgba(214, 168, 94, 0.55);
-}
-
-.analytics-insight-card.critical {
-    border-color: rgba(226, 93, 93, 0.65);
-}
-
-.analytics-insight-card .insight-title {
-    font-size: 10px;
-    text-transform: uppercase;
-    letter-spacing: 0.04em;
-    color: var(--text-dim, #5a6a7a);
-}
-
-.analytics-insight-card .insight-value {
-    font-size: 16px;
-    font-weight: 700;
-    color: var(--text-primary, #e0e6ed);
-    line-height: 1.2;
-}
-
-.analytics-insight-card .insight-label {
-    font-size: 10px;
-    color: var(--text-secondary, #9aabba);
-}
-
-.analytics-insight-card .insight-detail {
-    font-size: 10px;
-    color: var(--text-dim, #5a6a7a);
-}
-
-.analytics-top-changes {
-    margin-top: 12px;
-}
-
-.analytics-change-row {
-    display: flex;
-    align-items: center;
-    gap: 10px;
-    padding: 7px 0;
-    border-bottom: 1px solid var(--border-color, #1e2d3d);
-    font-size: 10px;
-}
-
-.analytics-change-row:last-child {
-    border-bottom: none;
-}
-
-.analytics-change-row .mode {
-    min-width: 84px;
-    color: var(--text-primary, #e0e6ed);
-    font-weight: 600;
-}
-
-.analytics-change-row .delta {
-    min-width: 48px;
-    font-family: var(--font-mono, monospace);
-}
-
-.analytics-change-row .delta.up {
-    color: var(--accent-green, #38c180);
-}
-
-.analytics-change-row .delta.down {
-    color: var(--accent-red, #e25d5d);
-}
-
-.analytics-change-row .delta.flat {
-    color: var(--text-dim, #5a6a7a);
-}
-
-.analytics-change-row .avg {
-    color: var(--text-dim, #5a6a7a);
-}
-
-.analytics-card {
-    background: var(--bg-card, #151f2b);
-    border: 1px solid var(--border-color, #1e2d3d);
-    border-radius: var(--radius-md, 8px);
-    padding: var(--space-3, 12px);
-    text-align: center;
-    transition: var(--transition-fast, 150ms ease);
-}
-
-.analytics-card:hover {
-    border-color: var(--accent-cyan, #4aa3ff);
-}
-
-.analytics-card .card-count {
-    font-size: var(--text-2xl, 24px);
-    font-weight: 700;
-    color: var(--text-primary, #e0e6ed);
-    line-height: 1.2;
-}
-
-.analytics-card .card-label {
-    font-size: var(--text-xs, 10px);
-    color: var(--text-dim, #5a6a7a);
-    text-transform: uppercase;
-    letter-spacing: 0.05em;
-    margin-top: var(--space-1, 4px);
-}
-
-.analytics-card .card-sparkline {
-    height: 24px;
-    margin-top: var(--space-2, 8px);
-}
-
-.analytics-card .card-sparkline svg {
-    width: 100%;
-    height: 100%;
-}
-
-.analytics-card .card-sparkline polyline {
-    fill: none;
-    stroke: var(--accent-cyan, #4aa3ff);
-    stroke-width: 1.5;
-    stroke-linecap: round;
-    stroke-linejoin: round;
-}
-
-/* Health indicators */
-.analytics-health {
-    display: flex;
-    flex-wrap: wrap;
-    gap: var(--space-2, 8px);
-    margin-bottom: var(--space-4, 16px);
-}
-
-.health-item {
-    display: flex;
-    align-items: center;
-    gap: var(--space-1, 4px);
-    font-size: var(--text-xs, 10px);
-    color: var(--text-dim, #5a6a7a);
-    text-transform: uppercase;
-}
-
-.health-dot {
-    width: 6px;
-    height: 6px;
-    border-radius: 50%;
-    background: var(--accent-red, #e25d5d);
-}
-
-.health-dot.running {
-    background: var(--accent-green, #38c180);
-}
-
-/* Emergency squawk panel */
-.squawk-emergency {
-    background: rgba(226, 93, 93, 0.1);
-    border: 1px solid var(--accent-red, #e25d5d);
-    border-radius: var(--radius-md, 8px);
-    padding: var(--space-3, 12px);
-    margin-bottom: var(--space-3, 12px);
-}
-
-.squawk-emergency .squawk-title {
-    color: var(--accent-red, #e25d5d);
-    font-weight: 700;
-    font-size: var(--text-sm, 12px);
-    text-transform: uppercase;
-    margin-bottom: var(--space-2, 8px);
-}
-
-.squawk-emergency .squawk-item {
-    font-size: var(--text-sm, 12px);
-    color: var(--text-primary, #e0e6ed);
-    padding: var(--space-1, 4px) 0;
-    border-bottom: 1px solid rgba(226, 93, 93, 0.2);
-}
-
-.squawk-emergency .squawk-item:last-child {
-    border-bottom: none;
-}
-
-/* Alert feed */
-.analytics-alert-feed {
-    max-height: 200px;
-    overflow-y: auto;
-    margin-bottom: var(--space-4, 16px);
-}
-
-.analytics-alert-item {
-    display: flex;
-    align-items: flex-start;
-    gap: var(--space-2, 8px);
-    padding: var(--space-2, 8px);
-    border-bottom: 1px solid var(--border-color, #1e2d3d);
-    font-size: var(--text-xs, 10px);
-}
-
-.analytics-alert-item .alert-severity {
-    padding: 1px 6px;
-    border-radius: var(--radius-sm, 4px);
-    font-weight: 600;
-    text-transform: uppercase;
-    font-size: 9px;
-    white-space: nowrap;
-}
-
-.alert-severity.critical { background: var(--accent-red, #e25d5d); color: #fff; }
-.alert-severity.high { background: var(--accent-orange, #d6a85e); color: #000; }
-.alert-severity.medium { background: var(--accent-cyan, #4aa3ff); color: #fff; }
-.alert-severity.low { background: var(--border-color, #1e2d3d); color: var(--text-dim, #5a6a7a); }
-
-/* Correlation panel */
-.analytics-correlation-pair {
-    display: flex;
-    align-items: center;
-    gap: var(--space-2, 8px);
-    padding: var(--space-2, 8px);
-    border-bottom: 1px solid var(--border-color, #1e2d3d);
-    font-size: var(--text-xs, 10px);
-}
-
-.analytics-correlation-pair .confidence-bar {
-    height: 4px;
-    background: var(--bg-secondary, #101823);
-    border-radius: 2px;
-    flex: 1;
-    max-width: 60px;
-}
-
-.analytics-correlation-pair .confidence-fill {
-    height: 100%;
-    background: var(--accent-green, #38c180);
-    border-radius: 2px;
-}
-
-.analytics-pattern-item {
-    padding: 8px;
-    border-bottom: 1px solid var(--border-color, #1e2d3d);
-    display: flex;
-    flex-direction: column;
-    gap: 4px;
-}
-
-.analytics-pattern-item:last-child {
-    border-bottom: none;
-}
-
-.analytics-pattern-item .pattern-main {
-    display: flex;
-    justify-content: space-between;
-    align-items: center;
-    gap: 8px;
-}
-
-.analytics-pattern-item .pattern-mode {
-    font-size: 10px;
-    font-weight: 600;
-    color: var(--text-primary, #e0e6ed);
-    text-transform: uppercase;
-    letter-spacing: 0.04em;
-}
-
-.analytics-pattern-item .pattern-device {
-    font-size: 10px;
-    color: var(--text-dim, #5a6a7a);
-    font-family: var(--font-mono, monospace);
-}
-
-.analytics-pattern-item .pattern-meta {
-    display: flex;
-    gap: 10px;
-    font-size: 10px;
-    color: var(--text-dim, #5a6a7a);
-    flex-wrap: wrap;
-}
-
-.analytics-pattern-item .pattern-confidence {
-    color: var(--accent-green, #38c180);
-    font-weight: 600;
-}
-
-/* Geofence zone list */
-.geofence-zone-item {
-    display: flex;
-    align-items: center;
-    justify-content: space-between;
-    padding: var(--space-2, 8px);
-    border-bottom: 1px solid var(--border-color, #1e2d3d);
-    font-size: var(--text-xs, 10px);
-}
-
-.geofence-zone-item .zone-name {
-    font-weight: 600;
-    color: var(--text-primary, #e0e6ed);
-}
-
-.geofence-zone-item .zone-radius {
-    color: var(--text-dim, #5a6a7a);
-}
-
-.geofence-zone-item .zone-delete {
-    cursor: pointer;
-    color: var(--accent-red, #e25d5d);
-    padding: 2px 6px;
-    border: 1px solid var(--accent-red, #e25d5d);
-    border-radius: var(--radius-sm, 4px);
-    background: transparent;
-    font-size: 9px;
-}
-
-/* Export controls */
-.export-controls {
-    display: flex;
-    gap: var(--space-2, 8px);
-    align-items: center;
-    flex-wrap: wrap;
-}
-
-.export-controls select,
-.export-controls button {
-    font-size: var(--text-xs, 10px);
-    padding: var(--space-1, 4px) var(--space-2, 8px);
-    background: var(--bg-card, #151f2b);
-    color: var(--text-primary, #e0e6ed);
-    border: 1px solid var(--border-color, #1e2d3d);
-    border-radius: var(--radius-sm, 4px);
-}
-
-.export-controls button {
-    cursor: pointer;
-    background: var(--accent-cyan, #4aa3ff);
-    color: #fff;
-    border-color: var(--accent-cyan, #4aa3ff);
-}
-
-.export-controls button:hover {
-    opacity: 0.9;
-}
-
-/* Section headers */
-.analytics-section-header {
-    font-size: var(--text-xs, 10px);
-    font-weight: 600;
-    color: var(--text-dim, #5a6a7a);
-    text-transform: uppercase;
-    letter-spacing: 0.05em;
-    margin-bottom: var(--space-2, 8px);
-    padding-bottom: var(--space-1, 4px);
-    border-bottom: 1px solid var(--border-color, #1e2d3d);
-}
-
-/* Empty state */
-.analytics-empty {
-    text-align: center;
-    color: var(--text-dim, #5a6a7a);
-    font-size: var(--text-xs, 10px);
-    padding: var(--space-4, 16px);
-    font-style: italic;
-}
-
-.analytics-target-toolbar,
-.analytics-replay-toolbar {
-    display: flex;
-    gap: 8px;
-    flex-wrap: wrap;
-    align-items: center;
-    margin-bottom: 10px;
-}
-
-.analytics-target-toolbar input {
-    flex: 1;
-    min-width: 220px;
-    background: var(--bg-card, #151f2b);
-    color: var(--text-primary, #e0e6ed);
-    border: 1px solid var(--border-color, #1e2d3d);
-    border-radius: 4px;
-    padding: 6px 8px;
-    font-size: 11px;
-}
-
-.analytics-target-toolbar button,
-.analytics-replay-toolbar button,
-.analytics-replay-toolbar select {
-    font-size: 10px;
-    padding: 5px 9px;
-    border-radius: 4px;
-    border: 1px solid var(--border-color, #1e2d3d);
-    background: var(--bg-card, #151f2b);
-    color: var(--text-primary, #e0e6ed);
-}
-
-.analytics-target-toolbar button,
-.analytics-replay-toolbar button {
-    cursor: pointer;
-    background: rgba(74, 163, 255, 0.2);
-    border-color: rgba(74, 163, 255, 0.45);
-}
-
-.analytics-target-summary {
-    font-size: 10px;
-    color: var(--text-dim, #5a6a7a);
-    margin-bottom: 8px;
-}
-
-.analytics-target-item,
-.analytics-replay-item {
-    border-bottom: 1px solid var(--border-color, #1e2d3d);
-    padding: 7px 0;
-    display: grid;
-    gap: 4px;
-}
-
-.analytics-target-item:last-child,
-.analytics-replay-item:last-child {
-    border-bottom: none;
-}
-
-.analytics-target-item .title,
-.analytics-replay-item .title {
-    display: flex;
-    align-items: center;
-    gap: 8px;
-    flex-wrap: wrap;
-    font-size: 11px;
-    color: var(--text-primary, #e0e6ed);
-    font-weight: 600;
-}
-
-.analytics-target-item .mode,
-.analytics-replay-item .mode {
-    font-size: 9px;
-    text-transform: uppercase;
-    letter-spacing: 0.05em;
-    border: 1px solid rgba(74, 163, 255, 0.35);
-    color: var(--accent-cyan, #4aa3ff);
-    border-radius: 4px;
-    padding: 1px 6px;
-}
-
-.analytics-target-item .meta,
-.analytics-replay-item .meta {
-    font-size: 10px;
-    color: var(--text-dim, #5a6a7a);
-    display: flex;
-    gap: 10px;
-    flex-wrap: wrap;
-}

static/css/modes/aprs.css

@@ -60,7 +60,7 @@
     gap: 4px;
 }
 .aprs-strip .strip-select {
-    background: rgba(0,0,0,0.3);
+    background: var(--bg-dark);
     border: 1px solid var(--border-color);
     color: var(--text-primary);
     padding: 4px 8px;

static/css/modes/bt_locate.css

@@ -266,7 +266,9 @@
     display: flex;
     flex-direction: column;
     gap: 8px;
-    height: 100%;
+    flex: 1;
+    min-height: 0;
+    overflow: hidden;
     padding: 8px;
 }
 
@@ -280,8 +282,8 @@
 }
 
 #btLocateMap {
-    width: 100%;
+    position: absolute;
-    height: 100%;
+    inset: 0;
     background: #1a1a2e;
 }
 
@@ -558,3 +560,69 @@
         font-size: 9px;
     }
 }
+
+/* ── Crosshair sweep animation ───────────────────────────────────── */
+.btl-crosshair-overlay {
+    position: absolute;
+    inset: 0;
+    pointer-events: none;
+    overflow: hidden;
+    z-index: 1200;
+    --btl-crosshair-x-start: 100%;
+    --btl-crosshair-y-start: 100%;
+    --btl-crosshair-x-end: 50%;
+    --btl-crosshair-y-end: 50%;
+    --btl-crosshair-duration: 1500ms;
+}
+
+.btl-crosshair-line {
+    position: absolute;
+    opacity: 0;
+    background: var(--accent-cyan);
+    will-change: transform, opacity;
+}
+
+.btl-crosshair-vertical {
+    top: 0;
+    bottom: 0;
+    width: 1px;
+    left: 0;
+    transform: translateX(var(--btl-crosshair-x-start));
+}
+
+.btl-crosshair-horizontal {
+    left: 0;
+    right: 0;
+    height: 1px;
+    top: 0;
+    transform: translateY(var(--btl-crosshair-y-start));
+}
+
+.btl-crosshair-overlay.active .btl-crosshair-vertical {
+    animation: btlCrosshairSweepX var(--btl-crosshair-duration) cubic-bezier(0.2, 0.85, 0.28, 1) forwards;
+}
+
+.btl-crosshair-overlay.active .btl-crosshair-horizontal {
+    animation: btlCrosshairSweepY var(--btl-crosshair-duration) cubic-bezier(0.2, 0.85, 0.28, 1) forwards;
+}
+
+@keyframes btlCrosshairSweepX {
+    0%   { transform: translateX(var(--btl-crosshair-x-start)); opacity: 0; }
+    12%  { opacity: 1; }
+    85%  { opacity: 1; }
+    100% { transform: translateX(var(--btl-crosshair-x-end));   opacity: 0; }
+}
+
+@keyframes btlCrosshairSweepY {
+    0%   { transform: translateY(var(--btl-crosshair-y-start)); opacity: 0; }
+    12%  { opacity: 1; }
+    85%  { opacity: 1; }
+    100% { transform: translateY(var(--btl-crosshair-y-end));   opacity: 0; }
+}
+
+@media (prefers-reduced-motion: reduce) {
+    .btl-crosshair-overlay.active .btl-crosshair-vertical,
+    .btl-crosshair-overlay.active .btl-crosshair-horizontal {
+        animation-duration: 220ms;
+    }
+}

static/css/modes/gps.css

@@ -140,14 +140,114 @@
 }
 
 .gps-skyview-canvas-wrap {
-    display: flex;
+    position: relative;
-    justify-content: center;
+    display: block;
-    align-items: center;
+    width: min(100%, 430px);
+    aspect-ratio: 1 / 1;
+    margin: 0 auto;
+    border: 1px solid var(--border-color);
+    border-radius: 6px;
+    background: var(--bg-primary);
+    overflow: hidden;
+}
+
+.gps-sky-globe {
+    position: absolute;
+    inset: 0;
+    width: 100%;
+    height: 100%;
 }
 
 #gpsSkyCanvas {
-    max-width: 100%;
+    position: absolute;
-    height: auto;
+    inset: 0;
+    display: none;
+    width: 100%;
+    height: 100%;
+    cursor: grab;
+    touch-action: none;
+}
+
+#gpsSkyCanvas:active {
+    cursor: grabbing;
+}
+
+.gps-sky-overlay {
+    position: absolute;
+    inset: 0;
+    display: none;
+    pointer-events: none;
+    font-family: var(--font-mono);
+}
+
+.gps-skyview-canvas-wrap.gps-sky-fallback .gps-sky-globe {
+    display: none;
+}
+
+.gps-skyview-canvas-wrap.gps-sky-fallback #gpsSkyCanvas,
+.gps-skyview-canvas-wrap.gps-sky-fallback .gps-sky-overlay {
+    display: block;
+}
+
+.gps-globe-sat-icon {
+    --sat-size: 18px;
+    --sat-color: #8ea6bd;
+    width: var(--sat-size);
+    height: var(--sat-size);
+    transform: translate(-50%, -50%);
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    border-radius: 50%;
+    border: 1px solid var(--sat-color);
+    background: radial-gradient(circle at 35% 30%, rgba(255, 255, 255, 0.22), rgba(7, 14, 23, 0.82) 72%);
+    box-shadow: 0 0 0 1px rgba(0, 0, 0, 0.35), 0 0 12px var(--sat-color);
+}
+
+.gps-globe-sat-icon img {
+    width: 76%;
+    height: 76%;
+    object-fit: contain;
+}
+
+.gps-globe-sat-icon.used {
+    opacity: 0.98;
+}
+
+.gps-globe-sat-icon.unused {
+    opacity: 0.72;
+    box-shadow: 0 0 0 1px rgba(0, 0, 0, 0.35), 0 0 6px var(--sat-color);
+}
+
+.gps-sky-label {
+    position: absolute;
+    transform: translate(-50%, -50%);
+    font-size: 9px;
+    letter-spacing: 0.2px;
+    text-shadow: 0 0 6px rgba(0, 0, 0, 0.9);
+    white-space: nowrap;
+}
+
+.gps-sky-label-cardinal {
+    font-weight: 700;
+    color: var(--text-secondary);
+    opacity: 0.85;
+}
+
+.gps-sky-label-sat {
+    font-weight: 600;
+}
+
+.gps-sky-label-sat.unused {
+    opacity: 0.75;
+}
+
+.gps-sky-hint {
+    margin-top: 8px;
+    font-size: 9px;
+    color: var(--text-dim);
+    text-transform: uppercase;
+    letter-spacing: 0.4px;
 }
 
 /* Position info panel */

static/css/modes/morse.css

@@ -0,0 +1,201 @@
+/* Morse Code / CW Decoder Styles */
+
+.morse-mode-help,
+.morse-help-text {
+    font-size: 11px;
+    color: var(--text-dim);
+}
+
+.morse-help-text {
+    margin-top: 4px;
+    display: block;
+}
+
+.morse-hf-note {
+    font-size: 11px;
+    color: #ffaa00;
+    line-height: 1.5;
+}
+
+.morse-presets {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 4px;
+}
+
+.morse-actions-row {
+    display: flex;
+    gap: 8px;
+    flex-wrap: wrap;
+}
+
+.morse-file-row {
+    display: flex;
+    gap: 8px;
+    align-items: center;
+    flex-wrap: wrap;
+}
+
+.morse-file-row input[type='file'] {
+    width: 100%;
+    max-width: 100%;
+}
+
+.morse-status {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    font-size: 12px;
+    color: var(--text-dim);
+}
+
+.morse-status #morseCharCount {
+    margin-left: auto;
+}
+
+.morse-ref-grid {
+    transition: max-height 0.3s ease, opacity 0.3s ease;
+    max-height: 560px;
+    opacity: 1;
+    overflow: hidden;
+    font-family: var(--font-mono);
+    font-size: 10px;
+    line-height: 1.8;
+    columns: 2;
+    column-gap: 12px;
+    color: var(--text-dim);
+}
+
+.morse-ref-grid.collapsed {
+    max-height: 0;
+    opacity: 0;
+}
+
+.morse-ref-toggle {
+    font-size: 10px;
+    color: var(--text-dim);
+}
+
+.morse-ref-divider {
+    margin-top: 4px;
+    border-top: 1px solid var(--border-color);
+    padding-top: 4px;
+}
+
+.morse-decoded-panel {
+    background: var(--bg-primary);
+    border: 1px solid var(--border-color);
+    border-radius: 6px;
+    padding: 12px;
+    min-height: 120px;
+    max-height: 400px;
+    overflow-y: auto;
+    font-family: var(--font-mono);
+    font-size: 18px;
+    line-height: 1.6;
+    color: var(--text-primary);
+    word-wrap: break-word;
+}
+
+.morse-decoded-panel:empty::before {
+    content: 'Decoded text will appear here...';
+    color: var(--text-dim);
+    font-size: 14px;
+    font-style: italic;
+}
+
+.morse-char {
+    display: inline;
+    animation: morseFadeIn 0.3s ease-out;
+    position: relative;
+}
+
+@keyframes morseFadeIn {
+    from {
+        opacity: 0;
+        color: var(--accent-cyan);
+    }
+    to {
+        opacity: 1;
+        color: var(--text-primary);
+    }
+}
+
+.morse-word-space {
+    display: inline;
+    width: 0.5em;
+}
+
+.morse-raw-panel {
+    margin-top: 8px;
+    padding: 8px;
+    border: 1px solid #1a1a2e;
+    border-radius: 4px;
+    background: #080812;
+}
+
+.morse-raw-label {
+    font-size: 10px;
+    letter-spacing: 0.08em;
+    text-transform: uppercase;
+    color: #667;
+    margin-bottom: 4px;
+}
+
+.morse-raw-text {
+    min-height: 30px;
+    max-height: 90px;
+    overflow-y: auto;
+    font-family: var(--font-mono);
+    font-size: 11px;
+    color: #8fd0ff;
+    white-space: pre-wrap;
+    word-break: break-word;
+}
+
+.morse-metrics-panel {
+    margin-top: 8px;
+    display: grid;
+    grid-template-columns: repeat(3, minmax(0, 1fr));
+    gap: 6px;
+    font-size: 10px;
+    color: #7a8694;
+}
+
+.morse-metrics-panel span {
+    padding: 4px 6px;
+    border-radius: 4px;
+    border: 1px solid #1a1a2e;
+    background: #080811;
+    font-family: var(--font-mono);
+}
+
+.morse-status-bar {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    font-size: 11px;
+    color: var(--text-dim);
+    padding: 6px 0;
+    border-top: 1px solid var(--border-color);
+    margin-top: 8px;
+    gap: 8px;
+    flex-wrap: wrap;
+}
+
+.morse-status-bar .status-item {
+    display: flex;
+    align-items: center;
+    gap: 4px;
+}
+
+@media (max-width: 768px) {
+    .morse-metrics-panel {
+        grid-template-columns: repeat(2, minmax(0, 1fr));
+    }
+
+    .morse-file-row {
+        flex-direction: column;
+        align-items: stretch;
+    }
+}

static/css/modes/radiosonde.css

@@ -0,0 +1,152 @@
+/* ============================================
+   RADIOSONDE MODE — Scoped Styles
+   ============================================ */
+
+/* Visuals container */
+.radiosonde-visuals-container {
+    display: flex;
+    flex-direction: column;
+    gap: 8px;
+    flex: 1;
+    min-height: 0;
+    overflow: hidden;
+    padding: 8px;
+}
+
+/* Map container */
+#radiosondeMapContainer {
+    flex: 1;
+    min-height: 300px;
+    border-radius: 6px;
+    border: 1px solid var(--border-color);
+    background: var(--bg-primary);
+}
+
+/* Card container below map */
+.radiosonde-card-container {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 8px;
+    max-height: 200px;
+    overflow-y: auto;
+    padding: 4px 0;
+}
+
+/* Individual balloon card */
+.radiosonde-card {
+    background: var(--bg-card, #1a1e2e);
+    border: 1px solid var(--border-color);
+    border-radius: 6px;
+    padding: 10px 12px;
+    cursor: pointer;
+    flex: 1 1 280px;
+    min-width: 260px;
+    max-width: 400px;
+    transition: border-color 0.2s ease, background 0.2s ease;
+}
+
+.radiosonde-card:hover {
+    border-color: var(--accent-cyan);
+    background: rgba(0, 204, 255, 0.04);
+}
+
+.radiosonde-card-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 8px;
+    padding-bottom: 6px;
+    border-bottom: 1px solid var(--border-color);
+}
+
+.radiosonde-serial {
+    font-family: var(--font-mono, 'JetBrains Mono', monospace);
+    font-size: 13px;
+    font-weight: 600;
+    color: var(--accent-cyan);
+    letter-spacing: 0.5px;
+}
+
+.radiosonde-type {
+    font-family: var(--font-mono, 'JetBrains Mono', monospace);
+    font-size: 10px;
+    font-weight: 600;
+    color: var(--text-dim);
+    background: rgba(255, 255, 255, 0.06);
+    padding: 2px 6px;
+    border-radius: 3px;
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+}
+
+/* Telemetry stat grid */
+.radiosonde-stats {
+    display: grid;
+    grid-template-columns: repeat(3, 1fr);
+    gap: 6px;
+}
+
+.radiosonde-stat {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    padding: 4px;
+}
+
+.radiosonde-stat-value {
+    font-family: var(--font-mono, 'JetBrains Mono', monospace);
+    font-size: 12px;
+    font-weight: 600;
+    color: var(--text-primary);
+    white-space: nowrap;
+}
+
+.radiosonde-stat-label {
+    font-size: 9px;
+    font-weight: 600;
+    color: var(--text-dim);
+    text-transform: uppercase;
+    letter-spacing: 0.8px;
+    margin-top: 2px;
+}
+
+/* Leaflet popup overrides for radiosonde */
+#radiosondeMapContainer .leaflet-popup-content-wrapper {
+    background: var(--bg-card, #1a1e2e);
+    color: var(--text-primary);
+    border: 1px solid var(--border-color);
+    border-radius: 6px;
+    font-family: var(--font-mono, 'JetBrains Mono', monospace);
+    font-size: 11px;
+}
+
+#radiosondeMapContainer .leaflet-popup-tip {
+    background: var(--bg-card, #1a1e2e);
+    border: 1px solid var(--border-color);
+}
+
+/* Scrollbar for card container */
+.radiosonde-card-container::-webkit-scrollbar {
+    width: 4px;
+}
+
+.radiosonde-card-container::-webkit-scrollbar-track {
+    background: transparent;
+}
+
+.radiosonde-card-container::-webkit-scrollbar-thumb {
+    background: var(--border-color);
+    border-radius: 2px;
+}
+
+/* Responsive: stack cards on narrow screens */
+@media (max-width: 600px) {
+    .radiosonde-card {
+        flex: 1 1 100%;
+        max-width: 100%;
+    }
+
+    .radiosonde-stats {
+        grid-template-columns: repeat(2, 1fr);
+    }
+}

static/css/modes/system.css

@@ -0,0 +1,579 @@
+/* System Health Mode Styles — Enhanced Dashboard */
+
+.sys-dashboard {
+    display: grid;
+    grid-template-columns: repeat(3, 1fr);
+    gap: 16px;
+    padding: 16px;
+    width: 100%;
+    box-sizing: border-box;
+}
+
+/* Group headers span full width */
+.sys-group-header {
+    grid-column: 1 / -1;
+    font-size: 10px;
+    font-weight: 700;
+    text-transform: uppercase;
+    letter-spacing: 0.12em;
+    color: var(--accent-cyan, #00d4ff);
+    border-bottom: 1px solid rgba(0, 212, 255, 0.2);
+    padding-bottom: 6px;
+    margin-top: 8px;
+}
+
+.sys-group-header:first-child {
+    margin-top: 0;
+}
+
+/* Cards */
+.sys-card {
+    background: var(--bg-card, #1a1a2e);
+    border: 1px solid var(--border-color, #2a2a4a);
+    border-radius: 6px;
+    padding: 16px;
+}
+
+.sys-card-wide {
+    grid-column: span 2;
+}
+
+.sys-card-full {
+    grid-column: 1 / -1;
+}
+
+.sys-card-header {
+    font-size: 11px;
+    font-weight: 700;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    color: var(--text-dim, #8888aa);
+    margin-bottom: 12px;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+}
+
+.sys-card-body {
+    font-size: 12px;
+    color: var(--text-primary, #e0e0ff);
+    font-family: var(--font-mono, 'JetBrains Mono', monospace);
+}
+
+.sys-card-detail {
+    font-size: 11px;
+    color: var(--text-dim, #8888aa);
+    margin-top: 4px;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+/* Metric Bars */
+.sys-metric-bar-wrap {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    margin-bottom: 6px;
+}
+
+.sys-metric-bar-label {
+    font-size: 10px;
+    color: var(--text-dim, #8888aa);
+    min-width: 40px;
+    text-transform: uppercase;
+}
+
+.sys-metric-bar {
+    flex: 1;
+    height: 8px;
+    background: var(--bg-primary, #0d0d1a);
+    border-radius: 4px;
+    overflow: hidden;
+}
+
+.sys-metric-bar-fill {
+    height: 100%;
+    border-radius: 4px;
+    transition: width 0.4s ease;
+}
+
+.sys-metric-bar-fill.ok {
+    background: var(--accent-green, #00ff88);
+}
+
+.sys-metric-bar-fill.warn {
+    background: var(--accent-yellow, #ffcc00);
+}
+
+.sys-metric-bar-fill.crit {
+    background: var(--accent-red, #ff3366);
+}
+
+.sys-metric-bar-value {
+    font-size: 12px;
+    font-weight: 700;
+    min-width: 36px;
+    text-align: right;
+    font-family: var(--font-mono, 'JetBrains Mono', monospace);
+}
+
+.sys-metric-na {
+    color: var(--text-dim, #8888aa);
+    font-style: italic;
+    font-size: 11px;
+}
+
+/* SVG Arc Gauge */
+.sys-gauge-wrap {
+    display: flex;
+    align-items: center;
+    gap: 16px;
+    margin-bottom: 12px;
+}
+
+.sys-gauge-arc {
+    position: relative;
+    width: 110px;
+    height: 110px;
+    flex-shrink: 0;
+}
+
+.sys-gauge-arc svg {
+    width: 100%;
+    height: 100%;
+}
+
+.sys-gauge-arc .arc-bg {
+    fill: none;
+    stroke: var(--bg-primary, #0d0d1a);
+    stroke-width: 8;
+    stroke-linecap: round;
+}
+
+.sys-gauge-arc .arc-fill {
+    fill: none;
+    stroke-width: 8;
+    stroke-linecap: round;
+    transition: stroke-dashoffset 0.6s ease, stroke 0.3s ease;
+    filter: drop-shadow(0 0 4px currentColor);
+}
+
+.sys-gauge-arc .arc-fill.ok { stroke: var(--accent-green, #00ff88); }
+.sys-gauge-arc .arc-fill.warn { stroke: var(--accent-yellow, #ffcc00); }
+.sys-gauge-arc .arc-fill.crit { stroke: var(--accent-red, #ff3366); }
+
+.sys-gauge-label {
+    position: absolute;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+    font-size: 22px;
+    font-weight: 700;
+    font-family: var(--font-mono, 'JetBrains Mono', monospace);
+    color: var(--text-primary, #e0e0ff);
+}
+
+.sys-gauge-details {
+    flex: 1;
+    font-size: 12px;
+}
+
+/* Per-core bars */
+.sys-core-bars {
+    display: flex;
+    gap: 4px;
+    align-items: flex-end;
+    height: 48px;
+    margin-top: 12px;
+}
+
+.sys-core-bar {
+    flex: 1;
+    background: var(--bg-primary, #0d0d1a);
+    border-radius: 3px;
+    position: relative;
+    min-width: 6px;
+    max-width: 32px;
+    height: 100%;
+}
+
+.sys-core-bar-fill {
+    position: absolute;
+    bottom: 0;
+    left: 0;
+    right: 0;
+    border-radius: 2px;
+    transition: height 0.4s ease, background 0.3s ease;
+}
+
+/* Temperature sparkline */
+.sys-sparkline-wrap {
+    margin: 8px 0;
+}
+
+.sys-sparkline-wrap svg {
+    width: 100%;
+    height: 40px;
+}
+
+.sys-sparkline-line {
+    fill: none;
+    stroke: var(--accent-cyan, #00d4ff);
+    stroke-width: 1.5;
+    filter: drop-shadow(0 0 2px rgba(0, 212, 255, 0.4));
+}
+
+.sys-sparkline-area {
+    fill: url(#sparkGradient);
+    opacity: 0.3;
+}
+
+.sys-temp-big {
+    font-size: 28px;
+    font-weight: 700;
+    font-family: var(--font-mono, 'JetBrains Mono', monospace);
+    color: var(--text-primary, #e0e0ff);
+    margin-bottom: 4px;
+}
+
+/* Network interface rows */
+.sys-net-iface {
+    padding: 6px 0;
+    border-bottom: 1px solid var(--border-color, #2a2a4a);
+}
+
+.sys-net-iface:last-child {
+    border-bottom: none;
+}
+
+.sys-net-iface-name {
+    font-weight: 700;
+    color: var(--accent-cyan, #00d4ff);
+    font-size: 11px;
+}
+
+.sys-net-iface-ip {
+    font-family: var(--font-mono, 'JetBrains Mono', monospace);
+    font-size: 12px;
+    color: var(--text-primary, #e0e0ff);
+}
+
+.sys-net-iface-detail {
+    font-size: 10px;
+    color: var(--text-dim, #8888aa);
+}
+
+/* Bandwidth arrows */
+.sys-bandwidth {
+    display: flex;
+    gap: 12px;
+    margin-top: 4px;
+    font-family: var(--font-mono, 'JetBrains Mono', monospace);
+    font-size: 11px;
+}
+
+.sys-bw-up {
+    color: var(--accent-green, #00ff88);
+}
+
+.sys-bw-down {
+    color: var(--accent-cyan, #00d4ff);
+}
+
+/* Globe container — compact vertical layout */
+.sys-location-inner {
+    display: flex;
+    flex-direction: column;
+    gap: 10px;
+    align-items: center;
+}
+
+.sys-globe-wrap {
+    width: 200px;
+    height: 200px;
+    flex-shrink: 0;
+    background: #000;
+    border-radius: 8px;
+    overflow: hidden;
+    position: relative;
+}
+
+.sys-location-details {
+    width: 100%;
+    display: flex;
+    flex-direction: column;
+    gap: 6px;
+}
+
+/* GPS status indicator */
+.sys-gps-status {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    font-size: 10px;
+    color: var(--text-dim, #8888aa);
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+}
+
+.sys-gps-dot {
+    display: inline-block;
+    width: 7px;
+    height: 7px;
+    border-radius: 50%;
+}
+
+.sys-gps-dot.fix-3d {
+    background: var(--accent-green, #00ff88);
+    box-shadow: 0 0 4px rgba(0, 255, 136, 0.4);
+}
+
+.sys-gps-dot.fix-2d {
+    background: var(--accent-yellow, #ffcc00);
+    box-shadow: 0 0 4px rgba(255, 204, 0, 0.4);
+}
+
+.sys-gps-dot.no-fix {
+    background: var(--text-dim, #555);
+}
+
+.sys-location-coords {
+    font-family: var(--font-mono, 'JetBrains Mono', monospace);
+    font-size: 13px;
+    color: var(--text-primary, #e0e0ff);
+}
+
+.sys-location-source {
+    font-size: 10px;
+    color: var(--text-dim, #8888aa);
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+}
+
+/* Weather overlay */
+.sys-weather {
+    margin-top: auto;
+    padding: 10px;
+    background: rgba(0, 0, 0, 0.3);
+    border-radius: 6px;
+    border: 1px solid var(--border-color, #2a2a4a);
+}
+
+.sys-weather-temp {
+    font-size: 24px;
+    font-weight: 700;
+    font-family: var(--font-mono, 'JetBrains Mono', monospace);
+    color: var(--text-primary, #e0e0ff);
+}
+
+.sys-weather-condition {
+    font-size: 12px;
+    color: var(--text-dim, #8888aa);
+    margin-top: 2px;
+}
+
+.sys-weather-detail {
+    font-size: 10px;
+    color: var(--text-dim, #8888aa);
+    margin-top: 2px;
+}
+
+/* Disk I/O indicators */
+.sys-disk-io {
+    display: flex;
+    gap: 16px;
+    margin-top: 8px;
+    font-family: var(--font-mono, 'JetBrains Mono', monospace);
+    font-size: 11px;
+}
+
+.sys-disk-io-read {
+    color: var(--accent-cyan, #00d4ff);
+}
+
+.sys-disk-io-write {
+    color: var(--accent-green, #00ff88);
+}
+
+/* Process grid — dot-matrix style */
+.sys-process-grid {
+    display: grid;
+    grid-template-columns: repeat(2, 1fr);
+    gap: 4px 12px;
+}
+
+.sys-process-item {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    padding: 3px 0;
+}
+
+.sys-process-name {
+    font-size: 12px;
+}
+
+.sys-process-dot {
+    display: inline-block;
+    width: 7px;
+    height: 7px;
+    border-radius: 50%;
+    flex-shrink: 0;
+}
+
+.sys-process-dot.running {
+    background: var(--accent-green, #00ff88);
+    box-shadow: 0 0 4px rgba(0, 255, 136, 0.4);
+}
+
+.sys-process-dot.stopped {
+    background: var(--text-dim, #555);
+}
+
+.sys-process-summary {
+    margin-top: 8px;
+    font-size: 11px;
+    color: var(--text-dim, #8888aa);
+}
+
+/* SDR Devices */
+.sys-sdr-device {
+    padding: 6px 0;
+    border-bottom: 1px solid var(--border-color, #2a2a4a);
+}
+
+.sys-sdr-device:last-child {
+    border-bottom: none;
+}
+
+.sys-rescan-btn {
+    font-size: 9px;
+    padding: 2px 8px;
+    background: transparent;
+    border: 1px solid var(--border-color, #2a2a4a);
+    color: var(--accent-cyan, #00d4ff);
+    border-radius: 3px;
+    cursor: pointer;
+    text-transform: uppercase;
+    letter-spacing: 0.04em;
+}
+
+.sys-rescan-btn:hover {
+    background: var(--bg-primary, #0d0d1a);
+}
+
+/* System info — vertical layout to fill card */
+.sys-info-grid {
+    display: flex;
+    flex-direction: column;
+    gap: 6px;
+    font-size: 12px;
+    color: var(--text-dim, #8888aa);
+}
+
+.sys-info-item {
+    display: flex;
+    justify-content: space-between;
+    padding: 2px 0;
+    border-bottom: 1px solid rgba(255, 255, 255, 0.04);
+}
+
+.sys-info-item:last-child {
+    border-bottom: none;
+}
+
+.sys-info-item strong {
+    color: var(--text-primary, #e0e0ff);
+    font-weight: 600;
+}
+
+/* Battery indicator */
+.sys-battery-inline {
+    display: inline-flex;
+    align-items: center;
+    gap: 4px;
+    font-size: 11px;
+}
+
+/* Sidebar Quick Grid */
+.sys-quick-grid {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 6px;
+}
+
+.sys-quick-item {
+    padding: 6px 8px;
+    background: var(--bg-primary, #0d0d1a);
+    border: 1px solid var(--border-color, #2a2a4a);
+    border-radius: 4px;
+    text-align: center;
+}
+
+.sys-quick-label {
+    display: block;
+    font-size: 9px;
+    color: var(--text-dim, #8888aa);
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    margin-bottom: 2px;
+}
+
+.sys-quick-value {
+    display: block;
+    font-size: 14px;
+    font-weight: 700;
+    font-family: var(--font-mono, 'JetBrains Mono', monospace);
+    color: var(--text-primary, #e0e0ff);
+}
+
+/* Color-coded quick values */
+.sys-val-ok {
+    color: var(--accent-green, #00ff88) !important;
+}
+
+.sys-val-warn {
+    color: var(--accent-yellow, #ffcc00) !important;
+}
+
+.sys-val-crit {
+    color: var(--accent-red, #ff3366) !important;
+}
+
+/* Responsive */
+@media (max-width: 768px) {
+    .sys-dashboard {
+        grid-template-columns: 1fr;
+        padding: 8px;
+        gap: 10px;
+    }
+
+    .sys-card-wide,
+    .sys-card-full {
+        grid-column: 1;
+    }
+
+    .sys-globe-wrap {
+        width: 100%;
+        height: 180px;
+    }
+
+    .sys-process-grid {
+        grid-template-columns: 1fr;
+    }
+}
+
+@media (max-width: 1024px) and (min-width: 769px) {
+    .sys-dashboard {
+        grid-template-columns: repeat(2, 1fr);
+    }
+
+    .sys-card-wide {
+        grid-column: span 2;
+    }
+
+    .sys-card-full {
+        grid-column: 1 / -1;
+    }
+}

static/css/modes/wefax.css

@@ -0,0 +1,687 @@
+/* ============================================
+   WeFax (Weather Fax) Mode Styles
+   Amber/gold theme (#ffaa00) for HF
+   ============================================ */
+
+/* Place WeFax sidebar panel above the shared SDR Device section
+   while keeping the collapse button at the very top. */
+#wefaxMode.active {
+    order: -1;
+}
+.sidebar:has(#wefaxMode.active) > .sidebar-collapse-btn {
+    order: -2;
+}
+
+/* --- Stats Strip --- */
+.wefax-stats-strip {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    padding: 8px 14px;
+    background: var(--bg-card, #0e1117);
+    border: 1px solid var(--border-color, #1e2a3a);
+    border-radius: 6px;
+    margin-bottom: 12px;
+    flex-wrap: wrap;
+}
+
+.wefax-strip-group {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+}
+
+.wefax-strip-status {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+}
+
+.wefax-strip-dot {
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+    background: #444;
+    flex-shrink: 0;
+}
+
+.wefax-strip-dot.scanning { background: #ffaa00; animation: wefax-pulse 1.5s ease-in-out infinite; }
+.wefax-strip-dot.phasing  { background: #ffcc44; animation: wefax-pulse 0.8s ease-in-out infinite; }
+.wefax-strip-dot.receiving { background: #00cc66; animation: wefax-pulse 1s ease-in-out infinite; }
+.wefax-strip-dot.complete { background: #00cc66; }
+.wefax-strip-dot.error    { background: #f44; }
+
+@keyframes wefax-pulse {
+    0%, 100% { opacity: 1; }
+    50% { opacity: 0.4; }
+}
+
+.wefax-strip-status-text {
+    font-family: var(--font-mono, 'JetBrains Mono', monospace);
+    font-size: 11px;
+    color: var(--text-primary, #e0e0e0);
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+}
+
+.wefax-strip-btn {
+    padding: 4px 12px;
+    border: 1px solid var(--border-color, #1e2a3a);
+    border-radius: 4px;
+    font-family: var(--font-mono, monospace);
+    font-size: 10px;
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+    cursor: pointer;
+    background: var(--bg-primary, #161b22);
+    color: var(--text-primary, #e0e0e0);
+    display: inline-flex;
+    align-items: center;
+    gap: 4px;
+    transition: all 0.15s ease;
+}
+
+.wefax-strip-btn.start { color: #ffaa00; border-color: #ffaa0044; }
+.wefax-strip-btn.start:hover { background: #ffaa0015; border-color: #ffaa00; }
+.wefax-strip-btn.start.wefax-strip-btn-error {
+    border-color: #ffaa00;
+    color: #ffaa00;
+    box-shadow: 0 0 8px rgba(255, 170, 0, 0.3);
+    animation: wefax-pulse 0.6s ease-in-out 3;
+}
+
+.wefax-strip-btn.stop { color: #f44; border-color: #f4444444; }
+.wefax-strip-btn.stop:hover { background: #f4441a; border-color: #f44; }
+
+.wefax-strip-divider {
+    width: 1px;
+    height: 20px;
+    background: var(--border-color, #1e2a3a);
+}
+
+.wefax-strip-stat {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    gap: 1px;
+}
+
+.wefax-strip-value {
+    font-family: var(--font-mono, monospace);
+    font-size: 13px;
+    font-weight: 600;
+    color: var(--text-primary, #e0e0e0);
+    font-variant-numeric: tabular-nums;
+}
+
+.wefax-strip-value.accent-amber { color: #ffaa00; }
+
+.wefax-strip-label {
+    font-family: var(--font-mono, monospace);
+    font-size: 8px;
+    color: var(--text-dim, #555);
+    text-transform: uppercase;
+    letter-spacing: 1px;
+}
+
+/* --- Schedule Toggle --- */
+.wefax-schedule-toggle {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    cursor: pointer;
+    font-size: 10px;
+    font-family: var(--font-mono, 'JetBrains Mono', monospace);
+    color: var(--text-dim, #666);
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+}
+
+.wefax-schedule-toggle input[type="checkbox"] {
+    width: 14px;
+    height: 14px;
+    cursor: pointer;
+    accent-color: #ffaa00;
+}
+
+.wefax-schedule-toggle input:checked + span {
+    color: #ffaa00;
+}
+
+/* --- Visuals Container --- */
+.wefax-visuals-container {
+    display: flex;
+    flex-direction: column;
+    gap: 0;
+    width: 100%;
+}
+
+/* --- Main Row --- */
+.wefax-main-row {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 12px;
+}
+
+/* --- Schedule Timeline --- */
+.wefax-schedule-panel {
+    background: var(--bg-card, #0e1117);
+    border: 1px solid var(--border-color, #1e2a3a);
+    border-radius: 6px;
+    margin-bottom: 12px;
+    overflow: hidden;
+}
+
+.wefax-schedule-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 8px 12px;
+    border-bottom: 1px solid var(--border-color, #1e2a3a);
+}
+
+.wefax-schedule-title {
+    font-family: var(--font-mono, monospace);
+    font-size: 11px;
+    text-transform: uppercase;
+    letter-spacing: 1px;
+    color: #ffaa00;
+}
+
+.wefax-schedule-list {
+    display: flex;
+    flex-direction: column;
+    max-height: 200px;
+    overflow-y: auto;
+}
+
+.wefax-schedule-entry {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    padding: 6px 12px;
+    border-bottom: 1px solid var(--border-color, #1e2a3a)11;
+    font-family: var(--font-mono, monospace);
+    font-size: 11px;
+}
+
+.wefax-schedule-entry:last-child { border-bottom: none; }
+
+.wefax-schedule-entry.active {
+    background: #ffaa0010;
+    border-left: 3px solid #ffaa00;
+}
+
+.wefax-schedule-entry.upcoming {
+    background: #ffaa0008;
+}
+
+.wefax-schedule-entry.past {
+    opacity: 0.4;
+}
+
+.wefax-schedule-time {
+    color: #ffaa00;
+    min-width: 45px;
+    font-variant-numeric: tabular-nums;
+}
+
+.wefax-schedule-content {
+    color: var(--text-primary, #e0e0e0);
+    flex: 1;
+}
+
+.wefax-schedule-badge {
+    font-size: 9px;
+    padding: 1px 6px;
+    border-radius: 3px;
+    background: var(--border-color, #1e2a3a);
+    color: var(--text-dim, #555);
+}
+
+.wefax-schedule-badge.live {
+    background: #ffaa0030;
+    color: #ffaa00;
+    font-weight: 600;
+}
+
+.wefax-schedule-badge.soon {
+    background: #ffaa0015;
+    color: #ffcc66;
+}
+
+.wefax-schedule-empty {
+    padding: 16px;
+    text-align: center;
+    color: var(--text-dim, #555);
+    font-size: 11px;
+    font-family: var(--font-mono, monospace);
+}
+
+/* --- Live Section --- */
+.wefax-live-section {
+    background: var(--bg-card, #0e1117);
+    border: 1px solid var(--border-color, #1e2a3a);
+    border-radius: 6px;
+    overflow: hidden;
+}
+
+.wefax-live-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 8px 12px;
+    border-bottom: 1px solid var(--border-color, #1e2a3a);
+}
+
+.wefax-live-title {
+    font-family: var(--font-mono, monospace);
+    font-size: 11px;
+    text-transform: uppercase;
+    letter-spacing: 1px;
+    color: #ffaa00;
+}
+
+.wefax-live-content {
+    padding: 12px;
+    min-height: 200px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.wefax-idle-state {
+    text-align: center;
+    color: var(--text-dim, #555);
+}
+
+.wefax-idle-state svg {
+    width: 48px;
+    height: 48px;
+    color: #ffaa0033;
+    margin-bottom: 12px;
+}
+
+.wefax-idle-state h4 {
+    margin: 0 0 4px;
+    color: var(--text-primary, #e0e0e0);
+    font-size: 13px;
+}
+
+.wefax-idle-state p {
+    margin: 0;
+    font-size: 11px;
+}
+
+.wefax-live-preview {
+    max-width: 100%;
+    max-height: 400px;
+    border-radius: 4px;
+    image-rendering: pixelated;
+}
+
+/* --- Gallery Section --- */
+.wefax-gallery-section {
+    background: var(--bg-card, #0e1117);
+    border: 1px solid var(--border-color, #1e2a3a);
+    border-radius: 6px;
+    overflow: hidden;
+}
+
+.wefax-gallery-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 8px 12px;
+    border-bottom: 1px solid var(--border-color, #1e2a3a);
+}
+
+.wefax-gallery-title {
+    font-family: var(--font-mono, monospace);
+    font-size: 11px;
+    text-transform: uppercase;
+    letter-spacing: 1px;
+    color: #ffaa00;
+}
+
+.wefax-gallery-controls {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+}
+
+.wefax-gallery-count {
+    font-family: var(--font-mono, monospace);
+    font-size: 11px;
+    color: var(--text-dim, #555);
+}
+
+.wefax-gallery-clear-btn {
+    font-family: var(--font-mono, monospace);
+    font-size: 9px;
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+    background: none;
+    border: 1px solid var(--border-color, #1e2a3a);
+    color: var(--text-dim, #555);
+    padding: 2px 8px;
+    border-radius: 3px;
+    cursor: pointer;
+}
+
+.wefax-gallery-clear-btn:hover {
+    border-color: #f44;
+    color: #f44;
+}
+
+.wefax-gallery-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(180px, 1fr));
+    gap: 8px;
+    padding: 10px;
+    max-height: 500px;
+    overflow-y: auto;
+}
+
+.wefax-gallery-empty {
+    padding: 24px;
+    text-align: center;
+    color: var(--text-dim, #555);
+    font-size: 11px;
+    font-family: var(--font-mono, monospace);
+    grid-column: 1 / -1;
+}
+
+.wefax-gallery-item {
+    position: relative;
+    background: var(--bg-primary, #161b22);
+    border: 1px solid var(--border-color, #1e2a3a);
+    border-radius: 4px;
+    overflow: hidden;
+}
+
+.wefax-gallery-item img {
+    width: 100%;
+    aspect-ratio: 4/3;
+    object-fit: cover;
+    cursor: pointer;
+    display: block;
+}
+
+.wefax-gallery-item img:hover {
+    opacity: 0.85;
+}
+
+.wefax-gallery-meta {
+    padding: 4px 6px;
+    display: flex;
+    flex-direction: column;
+    gap: 1px;
+    font-family: var(--font-mono, monospace);
+    font-size: 9px;
+    color: var(--text-dim, #555);
+}
+
+.wefax-gallery-actions {
+    position: absolute;
+    top: 4px;
+    right: 4px;
+    display: flex;
+    gap: 4px;
+    opacity: 0;
+    transition: opacity 0.15s;
+}
+
+.wefax-gallery-item:hover .wefax-gallery-actions {
+    opacity: 1;
+}
+
+.wefax-gallery-action {
+    width: 22px;
+    height: 22px;
+    border-radius: 3px;
+    border: none;
+    background: rgba(0, 0, 0, 0.7);
+    color: #ccc;
+    font-size: 14px;
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    text-decoration: none;
+}
+
+.wefax-gallery-action:hover { color: #fff; }
+.wefax-gallery-action.delete:hover { color: #f44; }
+
+/* --- Countdown Bar + Timeline --- */
+.wefax-countdown-bar {
+    display: flex;
+    align-items: center;
+    gap: 16px;
+    padding: 10px 16px;
+    background: var(--bg-secondary, #141820);
+    border: 1px solid var(--border-color, #1e2a3a);
+    border-radius: 6px;
+    margin-bottom: 12px;
+}
+
+.wefax-countdown-next {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    flex-shrink: 0;
+}
+
+.wefax-countdown-boxes {
+    display: flex;
+    gap: 4px;
+}
+
+.wefax-countdown-box {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    padding: 4px 8px;
+    background: var(--bg-primary, #0d1117);
+    border: 1px solid var(--border-color, #2a3040);
+    border-radius: 4px;
+    min-width: 40px;
+}
+
+.wefax-countdown-box.imminent {
+    border-color: #ffaa00;
+    box-shadow: 0 0 8px rgba(255, 170, 0, 0.2);
+}
+
+.wefax-countdown-box.active {
+    border-color: #ffaa00;
+    box-shadow: 0 0 8px rgba(255, 170, 0, 0.3);
+    animation: wefax-glow 1.5s ease-in-out infinite;
+}
+
+@keyframes wefax-glow {
+    0%, 100% { box-shadow: 0 0 8px rgba(255, 170, 0, 0.3); }
+    50% { box-shadow: 0 0 16px rgba(255, 170, 0, 0.5); }
+}
+
+.wefax-cd-value {
+    font-size: 16px;
+    font-weight: 700;
+    font-family: 'Roboto Condensed', 'Arial Narrow', sans-serif;
+    color: var(--text-primary, #e0e0e0);
+    line-height: 1;
+}
+
+.wefax-cd-unit {
+    font-size: 8px;
+    color: var(--text-dim, #666);
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+    margin-top: 2px;
+}
+
+.wefax-countdown-info {
+    display: flex;
+    flex-direction: column;
+    gap: 2px;
+}
+
+.wefax-countdown-content {
+    font-size: 12px;
+    font-weight: 600;
+    color: #ffaa00;
+    font-family: 'Roboto Condensed', 'Arial Narrow', sans-serif;
+}
+
+.wefax-countdown-detail {
+    font-size: 10px;
+    color: var(--text-dim, #666);
+    font-family: 'Roboto Condensed', 'Arial Narrow', sans-serif;
+}
+
+.wefax-timeline {
+    flex: 1;
+    position: relative;
+    height: 36px;
+    min-width: 200px;
+}
+
+.wefax-timeline-track {
+    position: absolute;
+    top: 4px;
+    left: 0;
+    right: 0;
+    height: 16px;
+    background: var(--bg-primary, #0d1117);
+    border: 1px solid var(--border-color, #2a3040);
+    border-radius: 3px;
+    overflow: hidden;
+}
+
+.wefax-timeline-broadcast {
+    position: absolute;
+    top: 0;
+    height: 100%;
+    background: rgba(255, 170, 0, 0.5);
+    border-radius: 2px;
+    cursor: default;
+    opacity: 0.8;
+    min-width: 2px;
+}
+
+.wefax-timeline-broadcast:hover {
+    opacity: 1;
+}
+
+.wefax-timeline-broadcast.active {
+    background: rgba(255, 170, 0, 0.85);
+    border: 1px solid #ffaa00;
+}
+
+.wefax-timeline-cursor {
+    position: absolute;
+    top: 2px;
+    width: 2px;
+    height: 20px;
+    background: #ff4444;
+    border-radius: 1px;
+    z-index: 2;
+}
+
+.wefax-timeline-labels {
+    position: absolute;
+    bottom: 0;
+    left: 0;
+    right: 0;
+    display: flex;
+    justify-content: space-between;
+    font-size: 8px;
+    color: var(--text-dim, #666);
+    font-family: 'Roboto Condensed', 'Arial Narrow', sans-serif;
+}
+
+/* --- Image Modal --- */
+.wefax-image-modal {
+    position: fixed;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    background: rgba(0, 0, 0, 0.9);
+    display: none;
+    align-items: center;
+    justify-content: center;
+    z-index: 10000;
+    padding: 40px;
+}
+
+.wefax-image-modal.show {
+    display: flex;
+}
+
+.wefax-image-modal img {
+    max-width: 100%;
+    max-height: 100%;
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+}
+
+.wefax-modal-toolbar {
+    position: absolute;
+    top: 20px;
+    right: 60px;
+    display: flex;
+    gap: 8px;
+    z-index: 1;
+}
+
+.wefax-modal-btn {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    font-family: var(--font-mono);
+    font-size: 10px;
+    padding: 6px 12px;
+    background: rgba(255, 255, 255, 0.1);
+    border: 1px solid rgba(255, 255, 255, 0.2);
+    border-radius: 4px;
+    color: white;
+    cursor: pointer;
+    transition: all 0.15s;
+    text-transform: uppercase;
+}
+
+.wefax-modal-btn:hover {
+    background: rgba(255, 255, 255, 0.2);
+}
+
+.wefax-modal-btn.delete:hover {
+    background: var(--accent-red, #ff3366);
+    border-color: var(--accent-red, #ff3366);
+}
+
+.wefax-modal-close {
+    position: absolute;
+    top: 20px;
+    right: 20px;
+    background: none;
+    border: none;
+    color: white;
+    font-size: 32px;
+    cursor: pointer;
+    opacity: 0.7;
+    transition: opacity 0.15s;
+    z-index: 1;
+}
+
+.wefax-modal-close:hover {
+    opacity: 1;
+}
+
+/* --- Responsive --- */
+@media (max-width: 768px) {
+    .wefax-main-row {
+        grid-template-columns: 1fr;
+    }
+}

static/icons/icon.svg

@@ -0,0 +1,20 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">
+  <!-- Background -->
+  <rect width="100" height="100" fill="#0a0a0f"/>
+
+  <!-- Signal brackets - left side -->
+  <path d="M15 30 Q5 50, 15 70" stroke="#00d4ff" stroke-width="4" fill="none" stroke-linecap="round" opacity="0.5"/>
+  <path d="M22 35 Q14 50, 22 65" stroke="#00d4ff" stroke-width="3.5" fill="none" stroke-linecap="round" opacity="0.7"/>
+  <path d="M29 40 Q23 50, 29 60" stroke="#00d4ff" stroke-width="3" fill="none" stroke-linecap="round"/>
+
+  <!-- Signal brackets - right side -->
+  <path d="M85 30 Q95 50, 85 70" stroke="#00d4ff" stroke-width="4" fill="none" stroke-linecap="round" opacity="0.5"/>
+  <path d="M78 35 Q86 50, 78 65" stroke="#00d4ff" stroke-width="3.5" fill="none" stroke-linecap="round" opacity="0.7"/>
+  <path d="M71 40 Q77 50, 71 60" stroke="#00d4ff" stroke-width="3" fill="none" stroke-linecap="round"/>
+
+  <!-- The 'i' letter -->
+  <circle cx="50" cy="22" r="7" fill="#00ff88"/>
+  <rect x="43" y="35" width="14" height="45" rx="2" fill="#00d4ff"/>
+  <rect x="36" y="35" width="28" height="5" rx="1" fill="#00d4ff"/>
+  <rect x="36" y="75" width="28" height="5" rx="1" fill="#00d4ff"/>
+</svg>

static/images/globe/satellite-icon.svg

@@ -0,0 +1,50 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 128 128" role="img" aria-labelledby="title desc">
+  <title id="title">Satellite</title>
+  <desc id="desc">Professional satellite icon with solar panels and body</desc>
+  <defs>
+    <linearGradient id="panelGradient" x1="0%" y1="0%" x2="100%" y2="100%">
+      <stop offset="0%" stop-color="#344a5f"/>
+      <stop offset="55%" stop-color="#233547"/>
+      <stop offset="100%" stop-color="#1a2734"/>
+    </linearGradient>
+    <linearGradient id="panelGrid" x1="0%" y1="0%" x2="0%" y2="100%">
+      <stop offset="0%" stop-color="#4f6a85" stop-opacity="0.7"/>
+      <stop offset="100%" stop-color="#2b3f53" stop-opacity="0.1"/>
+    </linearGradient>
+    <linearGradient id="bodyGradient" x1="0%" y1="0%" x2="100%" y2="100%">
+      <stop offset="0%" stop-color="#8ea0b2"/>
+      <stop offset="45%" stop-color="#6f8193"/>
+      <stop offset="100%" stop-color="#536475"/>
+    </linearGradient>
+    <linearGradient id="dishGradient" x1="0%" y1="0%" x2="100%" y2="100%">
+      <stop offset="0%" stop-color="#7e91a4"/>
+      <stop offset="100%" stop-color="#556779"/>
+    </linearGradient>
+  </defs>
+
+  <g stroke-linecap="round" stroke-linejoin="round">
+    <rect x="8" y="42" width="38" height="44" rx="2.5" fill="url(#panelGradient)" stroke="#607891" stroke-width="2"/>
+    <rect x="12" y="46" width="30" height="36" rx="1.5" fill="url(#panelGrid)" stroke="#405669" stroke-width="1.2"/>
+    <path d="M21 46v36M30 46v36M12 55h30M12 64h30M12 73h30" stroke="#4a6278" stroke-width="0.9" opacity="0.82"/>
+
+    <rect x="82" y="42" width="38" height="44" rx="2.5" fill="url(#panelGradient)" stroke="#607891" stroke-width="2"/>
+    <rect x="86" y="46" width="30" height="36" rx="1.5" fill="url(#panelGrid)" stroke="#405669" stroke-width="1.2"/>
+    <path d="M95 46v36M104 46v36M86 55h30M86 64h30M86 73h30" stroke="#4a6278" stroke-width="0.9" opacity="0.82"/>
+
+    <line x1="46" y1="64" x2="52" y2="64" stroke="#8fa4b9" stroke-width="3"/>
+    <line x1="76" y1="64" x2="82" y2="64" stroke="#8fa4b9" stroke-width="3"/>
+
+    <rect x="52" y="40" width="24" height="48" rx="4" fill="url(#bodyGradient)" stroke="#91a5b8" stroke-width="2"/>
+    <rect x="55" y="53" width="18" height="4" rx="1.5" fill="#d2dce6" opacity="0.48"/>
+    <rect x="55" y="62" width="18" height="4" rx="1.5" fill="#d2dce6" opacity="0.42"/>
+
+    <path d="M64 24c6 0 11 5 11 11s-5 11-11 11-11-5-11-11 5-11 11-11Z" fill="url(#dishGradient)" stroke="#95aac0" stroke-width="2"/>
+    <circle cx="64" cy="35" r="3.2" fill="#d7e2ed" opacity="0.7"/>
+    <path d="M58 26c2.2-2.4 9.8-2.4 12 0" fill="none" stroke="#a7b8c8" stroke-width="1.5"/>
+    <line x1="64" y1="46" x2="64" y2="51" stroke="#9fb2c6" stroke-width="2"/>
+
+    <path d="M57 88L64 101L71 88Z" fill="url(#dishGradient)" stroke="#8fa4b8" stroke-width="1.8"/>
+    <line x1="64" y1="101" x2="64" y2="108" stroke="#8fa4b8" stroke-width="2"/>
+    <circle cx="64" cy="110" r="2.8" fill="#b9c9d8"/>
+  </g>
+</svg>

static/js/components/activity-timeline.js

@@ -1,7 +1,7 @@
 /**
  * Activity Timeline Component
  * Reusable, configuration-driven timeline visualization for time-based metadata
- * Supports multiple modes: TSCM, Listening Post, Bluetooth, WiFi, Monitoring
+ * Supports multiple modes: TSCM, RF Receiver, Bluetooth, WiFi, Monitoring
  */
 
 const ActivityTimeline = (function() {
@@ -176,7 +176,7 @@ const ActivityTimeline = (function() {
      */
     function categorizeById(id, mode) {
         // RF frequency categorization
-        if (mode === 'rf' || mode === 'tscm' || mode === 'listening-post') {
+        if (mode === 'rf' || mode === 'tscm' || mode === 'waterfall') {
             const f = parseFloat(id);
             if (!isNaN(f)) {
                 if (f >= 2400 && f <= 2500) return '2.4 GHz wireless band';

static/js/components/proximity-radar.js

@@ -33,10 +33,7 @@ const ProximityRadar = (function() {
     let activeFilter = null;
     let onDeviceClick = null;
     let selectedDeviceKey = null;
-    let isHovered = false;
-    let renderPending = false;
     let renderTimer = null;
-    let interactionLockUntil = 0; // timestamp: suppress renders briefly after click
 
     /**
      * Initialize the radar component
@@ -128,28 +125,10 @@ const ProximityRadar = (function() {
             if (!deviceEl) return;
             const deviceKey = deviceEl.getAttribute('data-device-key');
             if (onDeviceClick && deviceKey) {
-                // Lock out re-renders briefly so the DOM stays stable after click
-                interactionLockUntil = Date.now() + 500;
                 onDeviceClick(deviceKey);
             }
         });
 
-        devicesGroup.addEventListener('mouseenter', (e) => {
-            if (e.target.closest('.radar-device')) {
-                isHovered = true;
-            }
-        }, true); // capture phase so we catch enter on child elements
-
-        devicesGroup.addEventListener('mouseleave', (e) => {
-            if (e.target.closest('.radar-device')) {
-                isHovered = false;
-                if (renderPending) {
-                    renderPending = false;
-                    renderDevices();
-                }
-            }
-        }, true);
-
         // Add sweep animation
         animateSweep();
     }
@@ -191,17 +170,10 @@ const ProximityRadar = (function() {
     function updateDevices(deviceList) {
         if (isPaused) return;
 
-        // Update device map
         deviceList.forEach(device => {
             devices.set(device.device_key, device);
         });
 
-        // Defer render while user is hovering or interacting to prevent DOM rebuild flicker
-        if (isHovered || Date.now() < interactionLockUntil) {
-            renderPending = true;
-            return;
-        }
-
         // Debounce rapid updates (e.g. per-device SSE events)
         if (renderTimer) clearTimeout(renderTimer);
         renderTimer = setTimeout(() => {
@@ -211,7 +183,9 @@ const ProximityRadar = (function() {
     }
 
     /**
-     * Render device dots on the radar
+     * Render device dots on the radar using in-place DOM updates.
+     * Elements are never destroyed and recreated — only their attributes and
+     * transforms are mutated — so hover state is never disturbed by a render.
      */
     function renderDevices() {
         const devicesGroup = svg.querySelector('.radar-devices');
@@ -219,6 +193,7 @@ const ProximityRadar = (function() {
 
         const center = CONFIG.size / 2;
         const maxRadius = center - CONFIG.padding;
+        const ns = 'http://www.w3.org/2000/svg';
 
         // Filter devices
         let visibleDevices = Array.from(devices.values());
@@ -234,69 +209,195 @@ const ProximityRadar = (function() {
             visibleDevices = visibleDevices.filter(d => !d.in_baseline);
         }
 
-        // Build SVG for each device
+        const visibleKeys = new Set(visibleDevices.map(d => d.device_key));
-        const dots = visibleDevices.map(device => {
-            // Calculate position
-            const { x, y, radius } = calculateDevicePosition(device, center, maxRadius);
 
-            // Calculate dot size based on confidence
+        // Remove elements for devices no longer in the visible set
+        devicesGroup.querySelectorAll('.radar-device-wrapper').forEach(el => {
+            if (!visibleKeys.has(el.getAttribute('data-device-key'))) {
+                el.remove();
+            }
+        });
+
+        // Sort weakest signal first so strongest renders on top (SVG z-order)
+        visibleDevices.sort((a, b) => (a.rssi_current || -100) - (b.rssi_current || -100));
+
+        // Compute all positions upfront so we can spread overlapping dots
+        const posMap = new Map();
+        visibleDevices.forEach(device => {
+            posMap.set(device.device_key, calculateDevicePosition(device, center, maxRadius));
+        });
+
+        // Spread dots that land too close together within the same band.
+        // minGapPx = diameter of largest possible hit area + 2px breathing room.
+        const maxHitArea = CONFIG.dotMaxSize + 4;
+        spreadOverlappingDots(Array.from(posMap.values()), center, maxHitArea * 2 + 2);
+
+        visibleDevices.forEach(device => {
+            const { x, y } = posMap.get(device.device_key);
             const confidence = device.distance_confidence || 0.5;
             const dotSize = CONFIG.dotMinSize + (CONFIG.dotMaxSize - CONFIG.dotMinSize) * confidence;
-
-            // Get color based on proximity band
             const color = getBandColor(device.proximity_band);
-
-            // Check if newly seen (pulse animation)
             const isNew = device.age_seconds < 5;
-            const pulseClass = isNew ? 'radar-dot-pulse' : '';
+            const isSelected = !!(selectedDeviceKey && device.device_key === selectedDeviceKey);
-            const isSelected = selectedDeviceKey && device.device_key === selectedDeviceKey;
+            const hitAreaSize = dotSize + 4;
+            const key = device.device_key;
 
-            // Hit area size (prevents hover flicker when scaling)
+            const existing = devicesGroup.querySelector(
-            const hitAreaSize = Math.max(dotSize * 2, 15);
+                `.radar-device-wrapper[data-device-key="${CSS.escape(key)}"]`
+            );
 
-            return `
+            if (existing) {
-                <g transform="translate(${x}, ${y})">
+                // ── In-place update: mutate attributes, never recreate ──
-                    <g class="radar-device ${pulseClass}${isSelected ? ' selected' : ''}" data-device-key="${escapeAttr(device.device_key)}"
+                existing.setAttribute('transform', `translate(${x}, ${y})`);
-                       style="cursor: pointer;">
-                        <!-- Invisible hit area to prevent hover flicker -->
-                        <circle class="radar-device-hitarea" r="${hitAreaSize}" fill="transparent" />
-                        ${isSelected ? `<circle class="radar-select-ring" r="${dotSize + 8}" fill="none" stroke="#00d4ff" stroke-width="2" stroke-opacity="0.8">
-                            <animate attributeName="r" values="${dotSize + 6};${dotSize + 10};${dotSize + 6}" dur="1.5s" repeatCount="indefinite"/>
-                            <animate attributeName="stroke-opacity" values="0.8;0.4;0.8" dur="1.5s" repeatCount="indefinite"/>
-                        </circle>` : ''}
-                        <circle r="${dotSize}" fill="${color}"
-                                fill-opacity="${isSelected ? 1 : 0.4 + confidence * 0.5}"
-                                stroke="${isSelected ? '#00d4ff' : color}" stroke-width="${isSelected ? 2 : 1}" />
-                        ${device.is_new && !isSelected ? `<circle r="${dotSize + 3}" fill="none" stroke="#3b82f6" stroke-width="1" stroke-dasharray="2,2" />` : ''}
-                        <title>${escapeHtml(device.name || device.address)} (${device.rssi_current || '--'} dBm)</title>
-                    </g>
-                </g>
-            `;
-        }).join('');
 
-        devicesGroup.innerHTML = dots;
+                const innerG = existing.querySelector('.radar-device');
+                if (innerG) {
+                    innerG.className.baseVal =
+                        `radar-device${isNew ? ' radar-dot-pulse' : ''}${isSelected ? ' selected' : ''}`;
+
+                    const hitArea = innerG.querySelector('.radar-device-hitarea');
+                    if (hitArea) hitArea.setAttribute('r', hitAreaSize);
+
+                    const dot = innerG.querySelector('.radar-dot');
+                    if (dot) {
+                        dot.setAttribute('r', dotSize);
+                        dot.setAttribute('fill', color);
+                        dot.setAttribute('fill-opacity', isSelected ? 1 : 0.4 + confidence * 0.5);
+                        dot.setAttribute('stroke', isSelected ? '#00d4ff' : color);
+                        dot.setAttribute('stroke-width', isSelected ? 2 : 1);
+                    }
+
+                    const title = innerG.querySelector('title');
+                    if (title) {
+                        title.textContent =
+                            `${escapeHtml(device.name || device.address)} (${device.rssi_current || '--'} dBm)`;
+                    }
+
+                    // Selection ring: add if newly selected, remove if deselected
+                    let ring = innerG.querySelector('.radar-select-ring');
+                    if (isSelected && !ring) {
+                        ring = buildSelectRing(ns, dotSize);
+                        const hitAreaEl = innerG.querySelector('.radar-device-hitarea');
+                        innerG.insertBefore(ring, hitAreaEl ? hitAreaEl.nextSibling : innerG.firstChild);
+                    } else if (!isSelected && ring) {
+                        ring.remove();
+                    }
+
+                    // New-device indicator ring
+                    let newRing = innerG.querySelector('.radar-new-ring');
+                    if (device.is_new && !isSelected) {
+                        if (!newRing) {
+                            newRing = document.createElementNS(ns, 'circle');
+                            newRing.classList.add('radar-new-ring');
+                            newRing.setAttribute('fill', 'none');
+                            newRing.setAttribute('stroke', '#3b82f6');
+                            newRing.setAttribute('stroke-width', '1');
+                            newRing.setAttribute('stroke-dasharray', '2,2');
+                            innerG.appendChild(newRing);
+                        }
+                        newRing.setAttribute('r', dotSize + 3);
+                    } else if (newRing) {
+                        newRing.remove();
+                    }
+                }
+            } else {
+                // ── Create new element ──
+                const wrapperG = document.createElementNS(ns, 'g');
+                wrapperG.classList.add('radar-device-wrapper');
+                wrapperG.setAttribute('data-device-key', key);
+                wrapperG.setAttribute('transform', `translate(${x}, ${y})`);
+
+                const innerG = document.createElementNS(ns, 'g');
+                innerG.classList.add('radar-device');
+                if (isNew) innerG.classList.add('radar-dot-pulse');
+                if (isSelected) innerG.classList.add('selected');
+                innerG.setAttribute('data-device-key', escapeAttr(key));
+                innerG.style.cursor = 'pointer';
+
+                const hitArea = document.createElementNS(ns, 'circle');
+                hitArea.classList.add('radar-device-hitarea');
+                hitArea.setAttribute('r', hitAreaSize);
+                hitArea.setAttribute('fill', 'transparent');
+                innerG.appendChild(hitArea);
+
+                if (isSelected) {
+                    innerG.appendChild(buildSelectRing(ns, dotSize));
+                }
+
+                const dot = document.createElementNS(ns, 'circle');
+                dot.classList.add('radar-dot');
+                dot.setAttribute('r', dotSize);
+                dot.setAttribute('fill', color);
+                dot.setAttribute('fill-opacity', isSelected ? 1 : 0.4 + confidence * 0.5);
+                dot.setAttribute('stroke', isSelected ? '#00d4ff' : color);
+                dot.setAttribute('stroke-width', isSelected ? 2 : 1);
+                innerG.appendChild(dot);
+
+                if (device.is_new && !isSelected) {
+                    const newRing = document.createElementNS(ns, 'circle');
+                    newRing.classList.add('radar-new-ring');
+                    newRing.setAttribute('r', dotSize + 3);
+                    newRing.setAttribute('fill', 'none');
+                    newRing.setAttribute('stroke', '#3b82f6');
+                    newRing.setAttribute('stroke-width', '1');
+                    newRing.setAttribute('stroke-dasharray', '2,2');
+                    innerG.appendChild(newRing);
+                }
+
+                const title = document.createElementNS(ns, 'title');
+                title.textContent =
+                    `${escapeHtml(device.name || device.address)} (${device.rssi_current || '--'} dBm)`;
+                innerG.appendChild(title);
+
+                wrapperG.appendChild(innerG);
+                devicesGroup.appendChild(wrapperG);
+            }
+        });
+    }
+
+    /**
+     * Build an animated SVG selection ring element
+     */
+    function buildSelectRing(ns, dotSize) {
+        const ring = document.createElementNS(ns, 'circle');
+        ring.classList.add('radar-select-ring');
+        ring.setAttribute('r', dotSize + 8);
+        ring.setAttribute('fill', 'none');
+        ring.setAttribute('stroke', '#00d4ff');
+        ring.setAttribute('stroke-width', '2');
+        ring.setAttribute('stroke-opacity', '0.8');
+
+        const animR = document.createElementNS(ns, 'animate');
+        animR.setAttribute('attributeName', 'r');
+        animR.setAttribute('values', `${dotSize + 6};${dotSize + 10};${dotSize + 6}`);
+        animR.setAttribute('dur', '1.5s');
+        animR.setAttribute('repeatCount', 'indefinite');
+        ring.appendChild(animR);
+
+        const animO = document.createElementNS(ns, 'animate');
+        animO.setAttribute('attributeName', 'stroke-opacity');
+        animO.setAttribute('values', '0.8;0.4;0.8');
+        animO.setAttribute('dur', '1.5s');
+        animO.setAttribute('repeatCount', 'indefinite');
+        ring.appendChild(animO);
+
+        return ring;
     }
 
     /**
      * Calculate device position on radar
      */
     function calculateDevicePosition(device, center, maxRadius) {
-        // Calculate radius based on proximity band/distance
+        // Position is band-only — the band is computed server-side from rssi_ema
+        // (already smoothed), so it changes infrequently and never jitters.
+        // Using raw estimated_distance_m caused constant micro-movement as RSSI
+        // fluctuated on every update cycle.
         let radiusRatio;
-        const band = device.proximity_band || 'unknown';
+        switch (device.proximity_band || 'unknown') {
-
-        if (device.estimated_distance_m != null) {
-            // Use actual distance (log scale)
-            const maxDistance = 15;
-            radiusRatio = Math.min(1, Math.log10(device.estimated_distance_m + 1) / Math.log10(maxDistance + 1));
-        } else {
-            // Use band-based positioning
-            switch (band) {
             case 'immediate': radiusRatio = 0.15; break;
-                case 'near': radiusRatio = 0.4; break;
+            case 'near':      radiusRatio = 0.40; break;
-                case 'far': radiusRatio = 0.7; break;
+            case 'far':       radiusRatio = 0.70; break;
-                default: radiusRatio = 0.9; break;
+            default:          radiusRatio = 0.90; break;
-            }
         }
 
         // Calculate angle based on device key hash (stable positioning)
@@ -306,7 +407,53 @@ const ProximityRadar = (function() {
         const x = center + Math.sin(angle) * radius;
         const y = center - Math.cos(angle) * radius;
 
-        return { x, y, radius };
+        return { x, y, angle, radius };
+    }
+
+    /**
+     * Spread dots within the same band that land too close together.
+     * Groups entries by radius, sorts by angle, then nudges neighbours
+     * apart until the arc gap between any two dots is at least minGapPx.
+     * Positions are updated in-place on the entry objects.
+     */
+    function spreadOverlappingDots(entries, center, minGapPx) {
+        const groups = new Map();
+        entries.forEach(e => {
+            const key = Math.round(e.radius);
+            if (!groups.has(key)) groups.set(key, []);
+            groups.get(key).push(e);
+        });
+
+        groups.forEach((group, r) => {
+            if (group.length < 2 || r < 1) return;
+            const minSep = minGapPx / r; // radians
+
+            group.sort((a, b) => a.angle - b.angle);
+
+            // Iterative push-apart (up to 8 passes)
+            for (let iter = 0; iter < 8; iter++) {
+                let moved = false;
+                for (let i = 0; i < group.length; i++) {
+                    const j = (i + 1) % group.length;
+                    let gap = group[j].angle - group[i].angle;
+                    if (gap < 0) gap += 2 * Math.PI;
+                    if (gap < minSep) {
+                        const push = (minSep - gap) / 2;
+                        group[i].angle -= push;
+                        group[j].angle += push;
+                        moved = true;
+                    }
+                }
+                if (!moved) break;
+            }
+
+            // Normalise angles back to [0, 2π) and recompute x/y
+            group.forEach(e => {
+                e.angle = ((e.angle % (2 * Math.PI)) + 2 * Math.PI) % (2 * Math.PI);
+                e.x = center + Math.sin(e.angle) * r;
+                e.y = center - Math.cos(e.angle) * r;
+            });
+        });
     }
 
     /**

static/js/components/signal-guess.js

@@ -289,19 +289,6 @@ const SignalGuess = (function() {
             regions: ['GLOBAL']
         },
 
-        // LoRaWAN
-        {
-            label: 'LoRaWAN / LoRa Device',
-            tags: ['iot', 'lora', 'lpwan', 'telemetry'],
-            description: 'LoRa long-range IoT device',
-            frequencyRanges: [[863000000, 870000000], [902000000, 928000000]],
-            modulationHints: ['LoRa', 'CSS', 'FSK'],
-            bandwidthRange: [125000, 500000],
-            baseScore: 11,
-            isBurstType: true,
-            regions: ['UK/EU', 'US']
-        },
-
         // Key Fob
         {
             label: 'Remote Control / Key Fob',

static/js/components/timeline-adapters/rf-adapter.js

@@ -1,7 +1,7 @@
 /**
  * RF Signal Timeline Adapter
  * Normalizes RF signal data for the Activity Timeline component
- * Used by: Listening Post, TSCM
+ * Used by: Spectrum Waterfall, TSCM
  */
 
 const RFTimelineAdapter = (function() {
@@ -158,12 +158,12 @@ const RFTimelineAdapter = (function() {
     }
 
     /**
-     * Create timeline configuration for Listening Post mode
+     * Create timeline configuration for spectrum waterfall mode.
      */
-    function getListeningPostConfig() {
+    function getWaterfallConfig() {
         return {
-            title: 'Signal Activity',
+            title: 'Spectrum Activity',
-            mode: 'listening-post',
+            mode: 'waterfall',
             visualMode: 'enriched',
             collapsed: false,
             showAnnotations: true,
@@ -188,6 +188,11 @@ const RFTimelineAdapter = (function() {
         };
     }
 
+    // Backward compatibility alias for legacy callers.
+    function getListeningPostConfig() {
+        return getWaterfallConfig();
+    }
+
     /**
      * Create timeline configuration for TSCM mode
      */
@@ -224,6 +229,7 @@ const RFTimelineAdapter = (function() {
         categorizeFrequency: categorizeFrequency,
 
         // Configuration presets
+        getWaterfallConfig: getWaterfallConfig,
         getListeningPostConfig: getListeningPostConfig,
         getTscmConfig: getTscmConfig,
 

static/js/core/alerts.js

@@ -7,6 +7,7 @@ const AlertCenter = (function() {
     let rules = [];
     let eventSource = null;
     let reconnectTimer = null;
+    let lastConnectionWarningAt = 0;
 
     function init() {
         loadRules();
@@ -31,7 +32,14 @@ const AlertCenter = (function() {
         };
 
         eventSource.onerror = function() {
-            console.warn('[Alerts] SSE connection error');
+            const now = Date.now();
+            const offline = (typeof window.isOffline === 'function' && window.isOffline()) ||
+                (typeof navigator !== 'undefined' && navigator.onLine === false);
+            const shouldLog = !offline && !document.hidden && (now - lastConnectionWarningAt) > 15000;
+            if (shouldLog) {
+                lastConnectionWarningAt = now;
+                console.warn('[Alerts] SSE connection error; retrying');
+            }
             if (reconnectTimer) clearTimeout(reconnectTimer);
             reconnectTimer = setTimeout(connect, 2500);
         };

static/js/core/app.js

@@ -98,7 +98,7 @@ function switchMode(mode) {
     const modeMap = {
         'pager': 'pager', 'sensor': '433', 'aircraft': 'aircraft',
         'satellite': 'satellite', 'wifi': 'wifi', 'bluetooth': 'bluetooth',
-        'listening': 'listening', 'meshtastic': 'meshtastic'
+        'meshtastic': 'meshtastic'
     };
     document.querySelectorAll('.mode-nav-btn').forEach(btn => {
         const label = btn.querySelector('.nav-label');
@@ -114,7 +114,6 @@ function switchMode(mode) {
     document.getElementById('satelliteMode').classList.toggle('active', mode === 'satellite');
     document.getElementById('wifiMode').classList.toggle('active', mode === 'wifi');
     document.getElementById('bluetoothMode').classList.toggle('active', mode === 'bluetooth');
-    document.getElementById('listeningPostMode').classList.toggle('active', mode === 'listening');
     document.getElementById('aprsMode')?.classList.toggle('active', mode === 'aprs');
     document.getElementById('tscmMode')?.classList.toggle('active', mode === 'tscm');
     document.getElementById('rtlamrMode')?.classList.toggle('active', mode === 'rtlamr');
@@ -143,7 +142,6 @@ function switchMode(mode) {
         'satellite': 'SATELLITE',
         'wifi': 'WIFI',
         'bluetooth': 'BLUETOOTH',
-        'listening': 'LISTENING POST',
         'tscm': 'TSCM',
         'aprs': 'APRS',
         'meshtastic': 'MESHTASTIC'
@@ -166,7 +164,6 @@ function switchMode(mode) {
     const showRadar = document.getElementById('adsbEnableMap')?.checked;
     document.getElementById('aircraftVisuals').style.display = (mode === 'aircraft' && showRadar) ? 'grid' : 'none';
     document.getElementById('satelliteVisuals').style.display = mode === 'satellite' ? 'block' : 'none';
-    document.getElementById('listeningPostVisuals').style.display = mode === 'listening' ? 'grid' : 'none';
 
     // Update output panel title based on mode
     const titles = {
@@ -176,7 +173,6 @@ function switchMode(mode) {
         'satellite': 'Satellite Monitor',
         'wifi': 'WiFi Scanner',
         'bluetooth': 'Bluetooth Scanner',
-        'listening': 'Listening Post',
         'meshtastic': 'Meshtastic Mesh Monitor'
     };
     document.getElementById('outputTitle').textContent = titles[mode] || 'Signal Monitor';
@@ -184,7 +180,7 @@ function switchMode(mode) {
     // Show/hide Device Intelligence for modes that use it
     const reconBtn = document.getElementById('reconBtn');
     const intelBtn = document.querySelector('[onclick="exportDeviceDB()"]');
-    if (mode === 'satellite' || mode === 'aircraft' || mode === 'listening') {
+    if (mode === 'satellite' || mode === 'aircraft') {
         document.getElementById('reconPanel').style.display = 'none';
         if (reconBtn) reconBtn.style.display = 'none';
         if (intelBtn) intelBtn.style.display = 'none';
@@ -198,7 +194,7 @@ function switchMode(mode) {
 
     // Show RTL-SDR device section for modes that use it
     document.getElementById('rtlDeviceSection').style.display =
-        (mode === 'pager' || mode === 'sensor' || mode === 'aircraft' || mode === 'listening') ? 'block' : 'none';
+        (mode === 'pager' || mode === 'sensor' || mode === 'aircraft') ? 'block' : 'none';
 
     // Toggle mode-specific tool status displays
     document.getElementById('toolStatusPager').style.display = (mode === 'pager') ? 'grid' : 'none';
@@ -207,7 +203,7 @@ function switchMode(mode) {
 
     // Hide waterfall and output console for modes with their own visualizations
     document.querySelector('.waterfall-container').style.display =
-        (mode === 'satellite' || mode === 'listening' || mode === 'aircraft' || mode === 'wifi' || mode === 'bluetooth' || mode === 'meshtastic' || mode === 'aprs' || mode === 'tscm' || mode === 'spystations') ? 'none' : 'block';
+        (mode === 'satellite' || mode === 'aircraft' || mode === 'wifi' || mode === 'bluetooth' || mode === 'meshtastic' || mode === 'aprs' || mode === 'tscm' || mode === 'spystations') ? 'none' : 'block';
     document.getElementById('output').style.display =
         (mode === 'satellite' || mode === 'aircraft' || mode === 'wifi' || mode === 'bluetooth' || mode === 'meshtastic' || mode === 'aprs' || mode === 'tscm' || mode === 'spystations') ? 'none' : 'block';
     document.querySelector('.status-bar').style.display = (mode === 'satellite' || mode === 'tscm' || mode === 'meshtastic' || mode === 'aprs' || mode === 'spystations') ? 'none' : 'flex';
@@ -226,11 +222,6 @@ function switchMode(mode) {
     } else if (mode === 'satellite') {
         if (typeof initPolarPlot === 'function') initPolarPlot();
         if (typeof initSatelliteList === 'function') initSatelliteList();
-    } else if (mode === 'listening') {
-        if (typeof checkScannerTools === 'function') checkScannerTools();
-        if (typeof checkAudioTools === 'function') checkAudioTools();
-        if (typeof populateScannerDeviceSelect === 'function') populateScannerDeviceSelect();
-        if (typeof populateAudioDeviceSelect === 'function') populateAudioDeviceSelect();
     } else if (mode === 'meshtastic') {
         if (typeof Meshtastic !== 'undefined' && Meshtastic.init) Meshtastic.init();
     }

static/js/core/cheat-sheets.js

@@ -0,0 +1,74 @@
+/* INTERCEPT Per-Mode Cheat Sheets */
+const CheatSheets = (function () {
+    'use strict';
+
+    const CONTENT = {
+        pager:       { title: 'Pager Decoder',           icon: '📟', hardware: 'RTL-SDR dongle',                          description: 'Decodes POCSAG and FLEX pager protocols via rtl_fm + multimon-ng.',          whatToExpect: 'Numeric and alphanumeric pager messages with address codes.',   tips: ['Try frequencies 152.240, 157.450, 462.9625 MHz', 'Gain 38–45 dB works well for most dongles', 'POCSAG 512/1200/2400 baud are common'] },
+        sensor:      { title: '433MHz Sensors',          icon: '🌡️', hardware: 'RTL-SDR dongle',                          description: 'Decodes 433MHz IoT sensors via rtl_433.',                                   whatToExpect: 'JSON events from weather stations, door sensors, car key fobs.', tips: ['Leave gain on AUTO', 'Walk around to discover hidden sensors', 'Protocol filter narrows false positives'] },
+        wifi:        { title: 'WiFi Scanner',            icon: '📡', hardware: 'WiFi adapter (monitor mode)',              description: 'Scans WiFi networks and clients via airodump-ng or nmcli.',                 whatToExpect: 'SSIDs, BSSIDs, channel, signal strength, encryption type.',    tips: ['Run airmon-ng check kill before monitoring', 'Proximity radar shows signal strength', 'TSCM baseline detects rogue APs'] },
+        bluetooth:   { title: 'Bluetooth Scanner',       icon: '🔵', hardware: 'Built-in or USB Bluetooth adapter',        description: 'Scans BLE and classic Bluetooth devices. Identifies trackers.',              whatToExpect: 'Device names, MACs, RSSI, manufacturer, tracker type.',        tips: ['Proximity radar shows device distance', 'Known tracker DB has 47K+ fingerprints', 'Use BT Locate to physically find a tracker'] },
+        bt_locate:   { title: 'BT Locate (SAR)',         icon: '🎯', hardware: 'Bluetooth adapter + optional GPS',         description: 'SAR Bluetooth locator. Tracks RSSI over time to triangulate position.', whatToExpect: 'RSSI chart, proximity band (IMMEDIATE/NEAR/FAR), GPS trail.',   tips: ['Handoff from Bluetooth mode to lock onto a device', 'Indoor n=3.0 gives better distance estimates', 'Follow the heat trail toward stronger signal'] },
+        meshtastic:  { title: 'Meshtastic',              icon: '🕸️', hardware: 'Meshtastic LoRa node (USB)',               description: 'Monitors Meshtastic LoRa mesh network messages and positions.',             whatToExpect: 'Text messages, node map, telemetry.',                          tips: ['Default channel must match your mesh', 'Long-Fast has best range', 'GPS nodes appear on map automatically'] },
+        adsb:        { title: 'ADS-B Aircraft',          icon: '✈️', hardware: 'RTL-SDR + 1090MHz antenna',               description: 'Tracks aircraft via ADS-B Mode S transponders using dump1090.',             whatToExpect: 'Flight numbers, positions, altitude, speed, squawk codes.',     tips: ['1090MHz — use a dedicated antenna', 'Emergency squawks: 7500 hijack, 7600 radio fail, 7700 emergency', 'Full Dashboard shows map view'] },
+        ais:         { title: 'AIS Vessels',             icon: '🚢', hardware: 'RTL-SDR + VHF antenna (162 MHz)',          description: 'Tracks marine vessels via AIS using AIS-catcher.',                         whatToExpect: 'MMSI, vessel names, positions, speed, heading, cargo type.',    tips: ['VHF antenna centered at 162MHz works best', 'DSC distress alerts appear in red', 'Coastline range ~40 nautical miles'] },
+        aprs:        { title: 'APRS',                    icon: '📻', hardware: 'RTL-SDR + VHF + direwolf',                description: 'Decodes APRS amateur packet radio via direwolf TNC modem.',                whatToExpect: 'Station positions, weather reports, messages, telemetry.',      tips: ['Primary APRS frequency: 144.390 MHz (North America)', 'direwolf must be running', 'Positions appear on the map'] },
+        satellite:   { title: 'Satellite Tracker',       icon: '🛰️', hardware: 'None (pass prediction only)',              description: 'Predicts satellite pass times using TLE data from CelesTrak.',              whatToExpect: 'Pass windows with AOS/LOS times, max elevation, bearing.',      tips: ['Set observer location in Settings', 'Plan ISS SSTV using pass times', 'TLEs auto-update every 24 hours'] },
+        sstv:        { title: 'ISS SSTV',                icon: '🖼️', hardware: 'RTL-SDR + 145MHz antenna',               description: 'Receives ISS SSTV images via slowrx.',                                    whatToExpect: 'Color images during ISS SSTV events (PD180 mode).',             tips: ['ISS SSTV: 145.800 MHz', 'Check ARISS for active event dates', 'ISS must be overhead — check pass times'] },
+        weathersat:  { title: 'Weather Satellites',      icon: '🌤️', hardware: 'RTL-SDR + 137MHz turnstile/QFH antenna',  description: 'Decodes NOAA APT and Meteor LRPT weather imagery via SatDump.',          whatToExpect: 'Infrared/visible cloud imagery.',                              tips: ['NOAA 15/18/19: 137.1–137.9 MHz APT', 'Meteor M2-3: 137.9 MHz LRPT', 'Use circular polarized antenna (QFH or turnstile)'] },
+        sstv_general:{ title: 'HF SSTV',                 icon: '📷', hardware: 'RTL-SDR + HF upconverter',                description: 'Receives HF SSTV transmissions.',                                          whatToExpect: 'Amateur radio images on 14.230 MHz (USB mode).',                tips: ['14.230 MHz USB is primary HF SSTV frequency', 'Scottie 1 and Martin 1 most common', 'Best during daylight hours'] },
+        gps:         { title: 'GPS Receiver',            icon: '🗺️', hardware: 'USB GPS receiver (NMEA)',                 description: 'Streams GPS position and feeds location to other modes.',                  whatToExpect: 'Lat/lon, altitude, speed, heading, satellite count.',          tips: ['BT Locate uses GPS for trail logging', 'Set observer location for satellite prediction', 'Verify a 3D fix before relying on altitude'] },
+        spaceweather:{ title: 'Space Weather',           icon: '☀️', hardware: 'None (NOAA/SpaceWeatherLive data)',        description: 'Monitors solar activity and geomagnetic storm indices.',                   whatToExpect: 'Kp index, solar flux, X-ray flare alerts, CME tracking.',      tips: ['High Kp (≥5) = geomagnetic storm', 'X-class flares cause HF radio blackouts', 'Check before HF or satellite operations'] },
+        tscm:        { title: 'TSCM Counter-Surveillance', icon: '🔍', hardware: 'WiFi + Bluetooth adapters',             description: 'Technical Surveillance Countermeasures — detects hidden devices.',        whatToExpect: 'RF baseline comparison, rogue device alerts, tracker detection.', tips: ['Take baseline in a known-clean environment', 'New strong signals = potential bug', 'Correlate WiFi + Bluetooth observations'] },
+        spystations: { title: 'Spy Stations',            icon: '🕵️', hardware: 'RTL-SDR + HF antenna',                   description: 'Database of known number stations, military, and diplomatic HF signals.', whatToExpect: 'Scheduled broadcasts, frequency database, tune-to links.',    tips: ['Numbers stations often broadcast on the hour', 'Use Spectrum Waterfall to tune directly', 'STANAG and HF mil signals are common'] },
+        websdr:      { title: 'WebSDR',                  icon: '🌐', hardware: 'None (uses remote SDR servers)',           description: 'Access remote WebSDR receivers worldwide for HF shortwave listening.', whatToExpect: 'Live audio from global HF receivers, waterfall display.',      tips: ['websdr.org lists available servers', 'Good for HF when local antenna is lacking', 'Use in-app player for seamless experience'] },
+        subghz:      { title: 'SubGHz Transceiver',      icon: '📡', hardware: 'HackRF One',                             description: 'Transmit and receive sub-GHz RF signals for IoT and industrial protocols.', whatToExpect: 'Raw signal capture, replay, and protocol analysis.',        tips: ['Only use on licensed frequencies', 'Capture mode records raw IQ for replay', 'Common: garage doors, keyfobs, 315/433/868/915 MHz'] },
+        rtlamr:      { title: 'Utility Meter Reader',    icon: '⚡', hardware: 'RTL-SDR dongle',                          description: 'Reads AMI/AMR smart utility meter broadcasts via rtlamr.',                whatToExpect: 'Meter IDs, consumption readings, interval data.',               tips: ['Most meters broadcast on 915 MHz', 'MSG types 5, 7, 13, 21 most common', 'Consumption data is read-only public broadcast'] },
+        waterfall:   { title: 'Spectrum Waterfall',      icon: '🌊', hardware: 'RTL-SDR or HackRF (WebSocket)',           description: 'Full-screen real-time FFT spectrum waterfall display.',                  whatToExpect: 'Color-coded signal intensity scrolling over time.',             tips: ['Turbo palette has best contrast for weak signals', 'Peak hold shows max power in red', 'Hover over waterfall to see frequency'] },
+    };
+
+    function show(mode) {
+        const data    = CONTENT[mode];
+        const modal   = document.getElementById('cheatSheetModal');
+        const content = document.getElementById('cheatSheetContent');
+        if (!modal || !content) return;
+
+        if (!data) {
+            content.innerHTML = `<p style="color:var(--text-dim); font-family:var(--font-mono);">No cheat sheet for: ${mode}</p>`;
+        } else {
+            content.innerHTML = `
+<div style="font-family:var(--font-mono, monospace);">
+  <div style="font-size:24px; margin-bottom:4px;">${data.icon}</div>
+  <h2 style="margin:0 0 8px; font-size:16px; color:var(--accent-cyan, #4aa3ff);">${data.title}</h2>
+  <div style="font-size:11px; color:var(--text-dim); margin-bottom:12px; border-bottom:1px solid rgba(255,255,255,0.08); padding-bottom:8px;">
+    Hardware: <span style="color:var(--text-secondary);">${data.hardware}</span>
+  </div>
+  <p style="font-size:12px; color:var(--text-secondary); margin:0 0 12px;">${data.description}</p>
+  <div style="margin-bottom:12px;">
+    <div style="font-size:10px; font-weight:700; text-transform:uppercase; letter-spacing:0.08em; color:var(--text-dim); margin-bottom:4px;">What to expect</div>
+    <p style="font-size:12px; color:var(--text-secondary); margin:0;">${data.whatToExpect}</p>
+  </div>
+  <div>
+    <div style="font-size:10px; font-weight:700; text-transform:uppercase; letter-spacing:0.08em; color:var(--text-dim); margin-bottom:6px;">Tips</div>
+    <ul style="margin:0; padding-left:16px; display:flex; flex-direction:column; gap:4px;">
+      ${data.tips.map(t => `<li style="font-size:11px; color:var(--text-secondary);">${t}</li>`).join('')}
+    </ul>
+  </div>
+</div>`;
+        }
+        modal.style.display = 'flex';
+    }
+
+    function hide() {
+        const modal = document.getElementById('cheatSheetModal');
+        if (modal) modal.style.display = 'none';
+    }
+
+    function showForCurrentMode() {
+        const mode = document.body.getAttribute('data-mode');
+        if (mode) show(mode);
+    }
+
+    return { show, hide, showForCurrentMode };
+})();
+
+window.CheatSheets = CheatSheets;

static/js/core/command-palette.js

@@ -12,8 +12,8 @@ const CommandPalette = (function() {
         { mode: 'pager', label: 'Pager' },
         { mode: 'sensor', label: '433MHz Sensors' },
         { mode: 'rtlamr', label: 'Meters' },
-        { mode: 'listening', label: 'Listening Post' },
         { mode: 'subghz', label: 'SubGHz' },
+        { mode: 'waterfall', label: 'Spectrum Waterfall' },
         { mode: 'aprs', label: 'APRS' },
         { mode: 'wifi', label: 'WiFi Scanner' },
         { mode: 'bluetooth', label: 'Bluetooth Scanner' },
@@ -24,9 +24,7 @@ const CommandPalette = (function() {
         { mode: 'sstv_general', label: 'HF SSTV' },
         { mode: 'gps', label: 'GPS' },
         { mode: 'meshtastic', label: 'Meshtastic' },
-        { mode: 'dmr', label: 'Digital Voice' },
         { mode: 'websdr', label: 'WebSDR' },
-        { mode: 'analytics', label: 'Analytics' },
         { mode: 'spaceweather', label: 'Space Weather' },
     ];
 
@@ -189,13 +187,39 @@ const CommandPalette = (function() {
                 title: 'View Aircraft Dashboard',
                 description: 'Open dedicated ADS-B dashboard page',
                 keyword: 'aircraft adsb dashboard',
-                run: () => { window.location.href = '/adsb/dashboard'; }
+                run: () => {
+                    if (window.InterceptNavPerf && typeof window.InterceptNavPerf.markStart === 'function') {
+                        window.InterceptNavPerf.markStart({
+                            targetPath: '/adsb/dashboard',
+                            trigger: 'command-palette',
+                            sourceMode: (typeof currentMode === 'string' && currentMode) ? currentMode : null,
+                            activeScans: (typeof getActiveScanSummary === 'function') ? getActiveScanSummary() : null,
+                        });
+                    }
+                    if (typeof stopActiveLocalScansForNavigation === 'function') {
+                        stopActiveLocalScansForNavigation();
+                    }
+                    window.location.href = '/adsb/dashboard';
+                }
             },
             {
                 title: 'View Vessel Dashboard',
                 description: 'Open dedicated AIS dashboard page',
                 keyword: 'vessel ais dashboard',
-                run: () => { window.location.href = '/ais/dashboard'; }
+                run: () => {
+                    if (window.InterceptNavPerf && typeof window.InterceptNavPerf.markStart === 'function') {
+                        window.InterceptNavPerf.markStart({
+                            targetPath: '/ais/dashboard',
+                            trigger: 'command-palette',
+                            sourceMode: (typeof currentMode === 'string' && currentMode) ? currentMode : null,
+                            activeScans: (typeof getActiveScanSummary === 'function') ? getActiveScanSummary() : null,
+                        });
+                    }
+                    if (typeof stopActiveLocalScansForNavigation === 'function') {
+                        stopActiveLocalScansForNavigation();
+                    }
+                    window.location.href = '/ais/dashboard';
+                }
             },
             {
                 title: 'Kill All Running Processes',

static/js/core/first-run-setup.js

@@ -130,7 +130,7 @@ const FirstRunSetup = (function() {
                     ['pager', 'Pager'],
                     ['sensor', '433MHz'],
                     ['rtlamr', 'Meters'],
-                    ['listening', 'Listening Post'],
+                    ['waterfall', 'Waterfall'],
                     ['wifi', 'WiFi'],
                     ['bluetooth', 'Bluetooth'],
                     ['bt_locate', 'BT Locate'],
@@ -139,7 +139,6 @@ const FirstRunSetup = (function() {
                     ['sstv', 'ISS SSTV'],
                     ['weathersat', 'Weather Sat'],
                     ['sstv_general', 'HF SSTV'],
-                    ['analytics', 'Analytics'],
                 ];
                 for (const [value, label] of modes) {
                     const opt = document.createElement('option');
@@ -150,7 +149,11 @@ const FirstRunSetup = (function() {
 
                 const savedDefaultMode = localStorage.getItem(DEFAULT_MODE_KEY);
                 if (savedDefaultMode) {
-                    modeSelectEl.value = savedDefaultMode;
+                    const normalizedMode = savedDefaultMode === 'listening' ? 'waterfall' : savedDefaultMode;
+                    modeSelectEl.value = normalizedMode;
+                    if (normalizedMode !== savedDefaultMode) {
+                        localStorage.setItem(DEFAULT_MODE_KEY, normalizedMode);
+                    }
                 }
 
                 actionsEl.appendChild(modeSelectEl);

static/js/core/global-nav.js

@@ -18,6 +18,18 @@
         if (menuLink) {
             event.preventDefault();
             event.stopPropagation();
+            try {
+                const target = new URL(menuLink.href, window.location.href);
+                if (window.InterceptNavPerf && typeof window.InterceptNavPerf.markStart === 'function') {
+                    window.InterceptNavPerf.markStart({
+                        targetPath: target.pathname,
+                        trigger: 'global-nav',
+                        sourceMode: document.body?.getAttribute('data-mode') || null,
+                    });
+                }
+            } catch (_) {
+                // Ignore malformed link targets.
+            }
             window.location.href = menuLink.href;
             return;
         }

static/js/core/keyboard-shortcuts.js

@@ -0,0 +1,72 @@
+/* INTERCEPT Keyboard Shortcuts — global hotkey handler + help modal */
+const KeyboardShortcuts = (function () {
+    'use strict';
+
+    const GUARD_SELECTOR = 'input, textarea, select, [contenteditable], .CodeMirror *';
+    let _handler = null;
+
+    function _handle(e) {
+        if (e.target.matches(GUARD_SELECTOR)) return;
+
+        if (e.altKey) {
+            switch (e.code) {
+                case 'KeyW': e.preventDefault(); window.switchMode && switchMode('waterfall');    break;
+                case 'KeyM': e.preventDefault(); window.VoiceAlerts && VoiceAlerts.toggleMute(); break;
+                case 'KeyS': e.preventDefault(); _toggleSidebar();                                break;
+                case 'KeyK': e.preventDefault(); showHelp();                                      break;
+                case 'KeyC': e.preventDefault(); window.CheatSheets && CheatSheets.showForCurrentMode(); break;
+                default:
+                    if (e.code >= 'Digit1' && e.code <= 'Digit9') {
+                        e.preventDefault();
+                        _switchToNthMode(parseInt(e.code.replace('Digit', '')) - 1);
+                    }
+            }
+        } else if (!e.ctrlKey && !e.metaKey) {
+            if (e.key === '?') { showHelp(); }
+            if (e.key === 'Escape') {
+                const kbModal = document.getElementById('kbShortcutsModal');
+                if (kbModal && kbModal.style.display !== 'none') { hideHelp(); return; }
+                const csModal = document.getElementById('cheatSheetModal');
+                if (csModal && csModal.style.display !== 'none') {
+                    window.CheatSheets && CheatSheets.hide(); return;
+                }
+            }
+        }
+    }
+
+    function _toggleSidebar() {
+        const mc = document.querySelector('.main-content');
+        if (mc) mc.classList.toggle('sidebar-collapsed');
+    }
+
+    function _switchToNthMode(n) {
+        if (!window.interceptModeCatalog) return;
+        const mode = document.body.getAttribute('data-mode');
+        if (!mode) return;
+        const catalog = window.interceptModeCatalog;
+        const entry = catalog[mode];
+        if (!entry) return;
+        const groupModes = Object.keys(catalog).filter(k => catalog[k].group === entry.group);
+        if (groupModes[n]) window.switchMode && switchMode(groupModes[n]);
+    }
+
+    function showHelp() {
+        const modal = document.getElementById('kbShortcutsModal');
+        if (modal) modal.style.display = 'flex';
+    }
+
+    function hideHelp() {
+        const modal = document.getElementById('kbShortcutsModal');
+        if (modal) modal.style.display = 'none';
+    }
+
+    function init() {
+        if (_handler) document.removeEventListener('keydown', _handler);
+        _handler = _handle;
+        document.addEventListener('keydown', _handler);
+    }
+
+    return { init, showHelp, hideHelp };
+})();
+
+window.KeyboardShortcuts = KeyboardShortcuts;

static/js/core/recordings.js

@@ -114,13 +114,7 @@ const RecordingUI = (function() {
 
     function openReplay(sessionId) {
         if (!sessionId) return;
-        localStorage.setItem('analyticsReplaySession', sessionId);
+        window.open(`/recordings/${sessionId}/download`, '_blank');
-        if (typeof hideSettings === 'function') hideSettings();
-        if (typeof switchMode === 'function') {
-            switchMode('analytics', { updateUrl: true });
-            return;
-        }
-        window.location.href = '/?mode=analytics';
     }
 
     function escapeHtml(str) {

static/js/core/run-state.js

@@ -2,7 +2,7 @@ const RunState = (function() {
     'use strict';
 
     const REFRESH_MS = 5000;
-    const CHIP_MODES = ['pager', 'sensor', 'wifi', 'bluetooth', 'adsb', 'ais', 'acars', 'vdl2', 'aprs', 'dsc', 'dmr', 'subghz'];
+    const CHIP_MODES = ['pager', 'sensor', 'wifi', 'bluetooth', 'adsb', 'ais', 'acars', 'vdl2', 'aprs', 'dsc', 'subghz'];
     const MODE_ALIASES = {
         bt: 'bluetooth',
         bt_locate: 'bluetooth',
@@ -21,7 +21,6 @@ const RunState = (function() {
         vdl2: 'VDL2',
         aprs: 'APRS',
         dsc: 'DSC',
-        dmr: 'DMR',
         subghz: 'SubGHz',
     };
 
@@ -93,8 +92,9 @@ const RunState = (function() {
             renderHealth(data);
         } catch (err) {
             renderHealth(null, err);
+            const transient = isTransientFailure(err);
             const now = Date.now();
-            if (typeof reportActionableError === 'function' && (now - lastErrorToastAt) > 30000) {
+            if (!transient && typeof reportActionableError === 'function' && (now - lastErrorToastAt) > 30000) {
                 lastErrorToastAt = now;
                 reportActionableError('Run State', err, { persistent: false });
             }
@@ -181,7 +181,6 @@ const RunState = (function() {
         if (normalized.includes('aprs')) return 'aprs';
         if (normalized.includes('dsc')) return 'dsc';
         if (normalized.includes('subghz')) return 'subghz';
-        if (normalized.includes('dmr')) return 'dmr';
         if (normalized.includes('433')) return 'sensor';
         return 'pager';
     }
@@ -216,6 +215,17 @@ const RunState = (function() {
         return String(err);
     }
 
+    function isTransientFailure(err) {
+        if (typeof window.isTransientOrOffline === 'function' && window.isTransientOrOffline(err)) {
+            return true;
+        }
+        if (typeof navigator !== 'undefined' && navigator.onLine === false) {
+            return true;
+        }
+        const text = extractMessage(err).toLowerCase();
+        return text.includes('failed to fetch') || text.includes('network') || text.includes('timeout');
+    }
+
     function getLastHealth() {
         return lastHealth;
     }

static/js/core/settings-manager.js

@@ -6,8 +6,8 @@ const Settings = {
     // Default settings
     defaults: {
         'offline.enabled': false,
-        'offline.assets_source': 'cdn',
+        'offline.assets_source': 'local',
-        'offline.fonts_source': 'cdn',
+        'offline.fonts_source': 'local',
         'offline.tile_provider': 'cartodb_dark_cyan',
         'offline.tile_server_url': ''
     },
@@ -98,24 +98,15 @@ const Settings = {
         localStorage.setItem('intercept_map_theme_pref', pref);
     },
 
-    /**
-     * Whether Cyber map theme should be considered active globally.
-     * @param {Object} [config]
-     * @returns {boolean}
-     */
-    _isCyberThemeEnabled(config) {
-        const resolvedConfig = config || this.getTileConfig();
-        return this._getMapThemeClass(resolvedConfig) === 'map-theme-cyber';
-    },
-
     /**
      * Toggle root class used for hard global Leaflet theming.
      * @param {Object} [config]
      */
     _syncRootMapThemeClass(config) {
         if (typeof document === 'undefined' || !document.documentElement) return;
-        const enabled = this._isCyberThemeEnabled(config);
+        const resolvedConfig = config || this.getTileConfig();
-        document.documentElement.classList.toggle('map-cyber-enabled', enabled);
+        const themeClass = this._getMapThemeClass(resolvedConfig);
+        document.documentElement.classList.toggle('map-cyber-enabled', themeClass === 'map-theme-cyber');
     },
 
     /**
@@ -381,6 +372,7 @@ const Settings = {
 
         container.classList.add(themeClass);
 
+        if (themeClass === 'map-theme-cyber') {
             if (container.style) {
                 container.style.background = '#020813';
             }
@@ -389,9 +381,10 @@ const Settings = {
                 tilePane.style.opacity = '1';
                 tilePane.style.willChange = 'filter';
             }
+        }
 
-        // Grid/glow overlays are rendered via CSS pseudo elements on
+        // Map overlays are rendered via CSS pseudo elements on
-        // `html.map-cyber-enabled .leaflet-container` for consistent stacking.
+        // `html.map-*-enabled .leaflet-container` for consistent stacking.
     },
 
     /**
@@ -1265,6 +1258,7 @@ function switchSettingsTab(tabName) {
     } else if (tabName === 'location') {
         loadObserverLocation();
     } else if (tabName === 'alerts') {
+        loadVoiceAlertConfig();
         if (typeof AlertCenter !== 'undefined') {
             AlertCenter.loadFeed();
         }
@@ -1277,6 +1271,64 @@ function switchSettingsTab(tabName) {
     }
 }
 
+/**
+ * Load voice alert configuration into Settings > Alerts tab
+ */
+function loadVoiceAlertConfig() {
+    if (typeof VoiceAlerts === 'undefined') return;
+    const cfg = VoiceAlerts.getConfig();
+
+    const pager   = document.getElementById('voiceCfgPager');
+    const tscm    = document.getElementById('voiceCfgTscm');
+    const tracker = document.getElementById('voiceCfgTracker');
+    const military = document.getElementById('voiceCfgAdsbMilitary');
+    const squawk  = document.getElementById('voiceCfgSquawk');
+    const rate    = document.getElementById('voiceCfgRate');
+    const pitch   = document.getElementById('voiceCfgPitch');
+    const rateVal = document.getElementById('voiceCfgRateVal');
+    const pitchVal = document.getElementById('voiceCfgPitchVal');
+
+    if (pager)    pager.checked    = cfg.streams.pager !== false;
+    if (tscm)     tscm.checked     = cfg.streams.tscm !== false;
+    if (tracker)  tracker.checked   = cfg.streams.bluetooth !== false;
+    if (military) military.checked  = cfg.streams.adsb_military !== false;
+    if (squawk)   squawk.checked    = cfg.streams.squawks !== false;
+    if (rate)     rate.value        = cfg.rate;
+    if (pitch)    pitch.value       = cfg.pitch;
+    if (rateVal)  rateVal.textContent  = cfg.rate;
+    if (pitchVal) pitchVal.textContent = cfg.pitch;
+
+    // Populate voice dropdown
+    VoiceAlerts.getAvailableVoices().then(function (voices) {
+        var sel = document.getElementById('voiceCfgVoice');
+        if (!sel) return;
+        sel.innerHTML = '<option value="">Default</option>' +
+            voices.filter(function (v) { return v.lang.startsWith('en'); }).map(function (v) {
+                return '<option value="' + v.name + '"' + (v.name === cfg.voiceName ? ' selected' : '') + '>' + v.name + '</option>';
+            }).join('');
+    });
+}
+
+function saveVoiceAlertConfig() {
+    if (typeof VoiceAlerts === 'undefined') return;
+    VoiceAlerts.setConfig({
+        rate:      parseFloat(document.getElementById('voiceCfgRate')?.value) || 1.1,
+        pitch:     parseFloat(document.getElementById('voiceCfgPitch')?.value) || 0.9,
+        voiceName: document.getElementById('voiceCfgVoice')?.value || '',
+        streams: {
+            pager:         !!document.getElementById('voiceCfgPager')?.checked,
+            tscm:          !!document.getElementById('voiceCfgTscm')?.checked,
+            bluetooth:     !!document.getElementById('voiceCfgTracker')?.checked,
+            adsb_military: !!document.getElementById('voiceCfgAdsbMilitary')?.checked,
+            squawks:       !!document.getElementById('voiceCfgSquawk')?.checked,
+        },
+    });
+}
+
+function testVoiceAlert() {
+    if (typeof VoiceAlerts !== 'undefined') VoiceAlerts.testVoice();
+}
+
 /**
  * Load API key status into the API Keys settings tab
  */

static/js/core/ui-feedback.js

@@ -208,9 +208,31 @@ const AppFeedback = (function() {
         return state;
     }
 
+    function isOffline() {
+        return typeof navigator !== 'undefined' && navigator.onLine === false;
+    }
+
+    function isTransientNetworkError(error) {
+        const text = String(extractMessage(error) || '').toLowerCase();
+        if (!text) return false;
+
+        return text.includes('networkerror') ||
+            text.includes('failed to fetch') ||
+            text.includes('network request failed') ||
+            text.includes('load failed') ||
+            text.includes('err_network_io_suspended') ||
+            text.includes('network io suspended') ||
+            text.includes('the network connection was lost') ||
+            text.includes('connection reset') ||
+            text.includes('timeout');
+    }
+
+    function isTransientOrOffline(error) {
+        return isOffline() || isTransientNetworkError(error);
+    }
+
     function isNetworkError(message) {
-        const text = String(message || '').toLowerCase();
+        return isTransientNetworkError(message);
-        return text.includes('networkerror') || text.includes('failed to fetch') || text.includes('timeout');
     }
 
     function isSettingsError(message) {
@@ -224,6 +246,9 @@ const AppFeedback = (function() {
         reportError,
         removeToast,
         renderCollectionState,
+        isOffline,
+        isTransientNetworkError,
+        isTransientOrOffline,
     };
 })();
 
@@ -243,6 +268,18 @@ window.renderCollectionState = function(container, options) {
     return AppFeedback.renderCollectionState(container, options);
 };
 
+window.isOffline = function() {
+    return AppFeedback.isOffline();
+};
+
+window.isTransientNetworkError = function(error) {
+    return AppFeedback.isTransientNetworkError(error);
+};
+
+window.isTransientOrOffline = function(error) {
+    return AppFeedback.isTransientOrOffline(error);
+};
+
 document.addEventListener('DOMContentLoaded', () => {
     AppFeedback.init();
 });

static/js/core/voice-alerts.js

@@ -0,0 +1,261 @@
+/* INTERCEPT Voice Alerts — Web Speech API queue with priority system */
+const VoiceAlerts = (function () {
+    'use strict';
+
+    const PRIORITY = { LOW: 0, MEDIUM: 1, HIGH: 2 };
+    let _enabled = true;
+    let _muted = false;
+    let _queue = [];
+    let _speaking = false;
+    let _sources = {};
+    const STORAGE_KEY = 'intercept-voice-muted';
+    const CONFIG_KEY  = 'intercept-voice-config';
+    const RATE_MIN = 0.5;
+    const RATE_MAX = 2.0;
+    const PITCH_MIN = 0.5;
+    const PITCH_MAX = 2.0;
+
+    // Default config
+    let _config = {
+        rate: 1.1,
+        pitch: 0.9,
+        voiceName: '',
+        streams: {
+            pager: true,
+            tscm: true,
+            bluetooth: true,
+            adsb_military: true,
+            squawks: true,
+        },
+    };
+
+    function _toNumberInRange(value, fallback, min, max) {
+        const n = Number(value);
+        if (!Number.isFinite(n)) return fallback;
+        return Math.min(max, Math.max(min, n));
+    }
+
+    function _normalizeConfig() {
+        _config.rate = _toNumberInRange(_config.rate, 1.1, RATE_MIN, RATE_MAX);
+        _config.pitch = _toNumberInRange(_config.pitch, 0.9, PITCH_MIN, PITCH_MAX);
+        _config.voiceName = typeof _config.voiceName === 'string' ? _config.voiceName : '';
+    }
+
+    function _isSpeechSupported() {
+        return !!(window.speechSynthesis && typeof window.SpeechSynthesisUtterance !== 'undefined');
+    }
+
+    function _showVoiceToast(title, message, type) {
+        if (typeof window.showAppToast === 'function') {
+            window.showAppToast(title, message, type || 'warning');
+        }
+    }
+
+    function _loadConfig() {
+        _muted = localStorage.getItem(STORAGE_KEY) === 'true';
+        try {
+            const stored = localStorage.getItem(CONFIG_KEY);
+            if (stored) {
+                const parsed = JSON.parse(stored);
+                _config.rate      = parsed.rate ?? _config.rate;
+                _config.pitch     = parsed.pitch ?? _config.pitch;
+                _config.voiceName = parsed.voiceName ?? _config.voiceName;
+                if (parsed.streams) {
+                    Object.assign(_config.streams, parsed.streams);
+                }
+            }
+        } catch (_) {}
+        _normalizeConfig();
+        _updateMuteButton();
+    }
+
+    function _updateMuteButton() {
+        const btn = document.getElementById('voiceMuteBtn');
+        if (!btn) return;
+        btn.classList.toggle('voice-muted', _muted);
+        btn.title = _muted ? 'Unmute voice alerts' : 'Mute voice alerts';
+        btn.style.opacity = _muted ? '0.4' : '1';
+    }
+
+    function _getVoice() {
+        if (!_config.voiceName) return null;
+        const voices = window.speechSynthesis ? speechSynthesis.getVoices() : [];
+        return voices.find(v => v.name === _config.voiceName) || null;
+    }
+
+    function _createUtterance(text) {
+        const utt = new SpeechSynthesisUtterance(text);
+        utt.rate = _toNumberInRange(_config.rate, 1.1, RATE_MIN, RATE_MAX);
+        utt.pitch = _toNumberInRange(_config.pitch, 0.9, PITCH_MIN, PITCH_MAX);
+        const voice = _getVoice();
+        if (voice) utt.voice = voice;
+        return utt;
+    }
+
+    function speak(text, priority) {
+        if (priority === undefined) priority = PRIORITY.MEDIUM;
+        if (!_enabled || _muted) return;
+        if (!window.speechSynthesis) return;
+        if (priority === PRIORITY.LOW && _speaking) return;
+        if (priority === PRIORITY.HIGH && _speaking) {
+            window.speechSynthesis.cancel();
+            _queue = [];
+            _speaking = false;
+        }
+        _queue.push({ text, priority });
+        if (!_speaking) _dequeue();
+    }
+
+    function _dequeue() {
+        if (_queue.length === 0) { _speaking = false; return; }
+        _speaking = true;
+        const item = _queue.shift();
+        const utt = _createUtterance(item.text);
+        utt.onend = () => { _speaking = false; _dequeue(); };
+        utt.onerror = () => { _speaking = false; _dequeue(); };
+        window.speechSynthesis.speak(utt);
+    }
+
+    function toggleMute() {
+        _muted = !_muted;
+        localStorage.setItem(STORAGE_KEY, _muted ? 'true' : 'false');
+        _updateMuteButton();
+        if (_muted && window.speechSynthesis) window.speechSynthesis.cancel();
+    }
+
+    function _openStream(url, handler, key) {
+        if (_sources[key]) return;
+        const es = new EventSource(url);
+        es.onmessage = handler;
+        es.onerror = () => { es.close(); delete _sources[key]; };
+        _sources[key] = es;
+    }
+
+    function _startStreams() {
+        if (!_enabled) return;
+
+        // Pager stream
+        if (_config.streams.pager) {
+            _openStream('/stream', (ev) => {
+                try {
+                    const d = JSON.parse(ev.data);
+                    if (d.address && d.message) {
+                        speak(`Pager message to ${d.address}: ${String(d.message).slice(0, 60)}`, PRIORITY.MEDIUM);
+                    }
+                } catch (_) {}
+            }, 'pager');
+        }
+
+        // TSCM stream
+        if (_config.streams.tscm) {
+            _openStream('/tscm/sweep/stream', (ev) => {
+                try {
+                    const d = JSON.parse(ev.data);
+                    if (d.threat_level && d.description) {
+                        speak(`TSCM alert: ${d.threat_level} — ${d.description}`, PRIORITY.HIGH);
+                    }
+                } catch (_) {}
+            }, 'tscm');
+        }
+
+        // Bluetooth stream — tracker detection only
+        if (_config.streams.bluetooth) {
+            _openStream('/api/bluetooth/stream', (ev) => {
+                try {
+                    const d = JSON.parse(ev.data);
+                    if (d.service_data && d.service_data.tracker_type) {
+                        speak(`Tracker detected: ${d.service_data.tracker_type}`, PRIORITY.HIGH);
+                    }
+                } catch (_) {}
+            }, 'bluetooth');
+        }
+
+    }
+
+    function _stopStreams() {
+        Object.values(_sources).forEach(es => { try { es.close(); } catch (_) {} });
+        _sources = {};
+    }
+
+    function init() {
+        _loadConfig();
+        if (_isSpeechSupported()) {
+            // Prime voices list early so user-triggered test calls are less likely to be silent.
+            speechSynthesis.getVoices();
+        }
+        _startStreams();
+    }
+
+    function setEnabled(val) {
+        _enabled = val;
+        if (!val) {
+            _stopStreams();
+            if (window.speechSynthesis) window.speechSynthesis.cancel();
+        } else {
+            _startStreams();
+        }
+    }
+
+    // ── Config API (used by Ops Center voice config panel) ─────────────
+
+    function getConfig() {
+        return JSON.parse(JSON.stringify(_config));
+    }
+
+    function setConfig(cfg) {
+        if (cfg.rate !== undefined)      _config.rate      = _toNumberInRange(cfg.rate, _config.rate, RATE_MIN, RATE_MAX);
+        if (cfg.pitch !== undefined)     _config.pitch     = _toNumberInRange(cfg.pitch, _config.pitch, PITCH_MIN, PITCH_MAX);
+        if (cfg.voiceName !== undefined) _config.voiceName = cfg.voiceName;
+        if (cfg.streams) Object.assign(_config.streams, cfg.streams);
+        _normalizeConfig();
+        localStorage.setItem(CONFIG_KEY, JSON.stringify(_config));
+        // Restart streams to apply per-stream toggle changes
+        _stopStreams();
+        _startStreams();
+    }
+
+    function getAvailableVoices() {
+        return new Promise(resolve => {
+            if (!window.speechSynthesis) { resolve([]); return; }
+            let voices = speechSynthesis.getVoices();
+            if (voices.length > 0) { resolve(voices); return; }
+            speechSynthesis.onvoiceschanged = () => {
+                resolve(speechSynthesis.getVoices());
+            };
+            // Timeout fallback
+            setTimeout(() => resolve(speechSynthesis.getVoices()), 500);
+        });
+    }
+
+    function testVoice(text) {
+        if (!_isSpeechSupported()) {
+            _showVoiceToast('Voice Unavailable', 'This browser does not support speech synthesis.', 'warning');
+            return;
+        }
+
+        // Make the test immediate and recover from a paused/stalled synthesis engine.
+        try {
+            speechSynthesis.getVoices();
+            if (speechSynthesis.paused) speechSynthesis.resume();
+            speechSynthesis.cancel();
+        } catch (_) {}
+
+        const utt = _createUtterance(text || 'Voice alert test. All systems nominal.');
+        let started = false;
+        utt.onstart = () => { started = true; };
+        utt.onerror = () => {
+            _showVoiceToast('Voice Test Failed', 'Speech synthesis failed to start. Check browser audio output.', 'warning');
+        };
+        speechSynthesis.speak(utt);
+
+        window.setTimeout(() => {
+            if (!started && !speechSynthesis.speaking && !speechSynthesis.pending) {
+                _showVoiceToast('No Voice Output', 'Test speech did not play. Verify browser audio and selected voice.', 'warning');
+            }
+        }, 1200);
+    }
+
+    return { init, speak, toggleMute, setEnabled, getConfig, setConfig, getAvailableVoices, testVoice, PRIORITY };
+})();
+
+window.VoiceAlerts = VoiceAlerts;

static/js/modes/analytics.js

@@ -1,549 +0,0 @@
-/**
- * Analytics Dashboard Module
- * Cross-mode summary, sparklines, alerts, correlations, target view, and replay.
- */
-const Analytics = (function () {
-    'use strict';
-
-    let refreshTimer = null;
-    let replayTimer = null;
-    let replaySessions = [];
-    let replayEvents = [];
-    let replayIndex = 0;
-
-    function init() {
-        refresh();
-        loadReplaySessions();
-        if (!refreshTimer) {
-            refreshTimer = setInterval(refresh, 5000);
-        }
-    }
-
-    function destroy() {
-        if (refreshTimer) {
-            clearInterval(refreshTimer);
-            refreshTimer = null;
-        }
-        pauseReplay();
-    }
-
-    function refresh() {
-        Promise.all([
-            fetch('/analytics/summary').then(r => r.json()).catch(() => null),
-            fetch('/analytics/activity').then(r => r.json()).catch(() => null),
-            fetch('/analytics/insights').then(r => r.json()).catch(() => null),
-            fetch('/analytics/patterns').then(r => r.json()).catch(() => null),
-            fetch('/alerts/events?limit=20').then(r => r.json()).catch(() => null),
-            fetch('/correlation').then(r => r.json()).catch(() => null),
-            fetch('/analytics/geofences').then(r => r.json()).catch(() => null),
-        ]).then(([summary, activity, insights, patterns, alerts, correlations, geofences]) => {
-            if (summary) renderSummary(summary);
-            if (activity) renderSparklines(activity.sparklines || {});
-            if (insights) renderInsights(insights);
-            if (patterns) renderPatterns(patterns.patterns || []);
-            if (alerts) renderAlerts(alerts.events || []);
-            if (correlations) renderCorrelations(correlations);
-            if (geofences) renderGeofences(geofences.zones || []);
-        });
-    }
-
-    function renderSummary(data) {
-        const counts = data.counts || {};
-        _setText('analyticsCountAdsb', counts.adsb || 0);
-        _setText('analyticsCountAis', counts.ais || 0);
-        _setText('analyticsCountWifi', counts.wifi || 0);
-        _setText('analyticsCountBt', counts.bluetooth || 0);
-        _setText('analyticsCountDsc', counts.dsc || 0);
-        _setText('analyticsCountAcars', counts.acars || 0);
-        _setText('analyticsCountVdl2', counts.vdl2 || 0);
-        _setText('analyticsCountAprs', counts.aprs || 0);
-        _setText('analyticsCountMesh', counts.meshtastic || 0);
-
-        const health = data.health || {};
-        const container = document.getElementById('analyticsHealth');
-        if (container) {
-            let html = '';
-            const modeLabels = {
-                pager: 'Pager', sensor: '433MHz', adsb: 'ADS-B', ais: 'AIS',
-                acars: 'ACARS', vdl2: 'VDL2', aprs: 'APRS', wifi: 'WiFi',
-                bluetooth: 'BT', dsc: 'DSC', meshtastic: 'Mesh'
-            };
-            for (const [mode, info] of Object.entries(health)) {
-                if (mode === 'sdr_devices') continue;
-                const running = info && info.running;
-                const label = modeLabels[mode] || mode;
-                html += '<div class="health-item"><span class="health-dot' + (running ? ' running' : '') + '"></span>' + _esc(label) + '</div>';
-            }
-            container.innerHTML = html;
-        }
-
-        const squawks = data.squawks || [];
-        const sqSection = document.getElementById('analyticsSquawkSection');
-        const sqList = document.getElementById('analyticsSquawkList');
-        if (sqSection && sqList) {
-            if (squawks.length > 0) {
-                sqSection.style.display = '';
-                sqList.innerHTML = squawks.map(s =>
-                    '<div class="squawk-item"><strong>' + _esc(s.squawk) + '</strong> ' +
-                    _esc(s.meaning) + ' - ' + _esc(s.callsign || s.icao) + '</div>'
-                ).join('');
-            } else {
-                sqSection.style.display = 'none';
-            }
-        }
-    }
-
-    function renderSparklines(sparklines) {
-        const map = {
-            adsb: 'analyticsSparkAdsb',
-            ais: 'analyticsSparkAis',
-            wifi: 'analyticsSparkWifi',
-            bluetooth: 'analyticsSparkBt',
-            dsc: 'analyticsSparkDsc',
-            acars: 'analyticsSparkAcars',
-            vdl2: 'analyticsSparkVdl2',
-            aprs: 'analyticsSparkAprs',
-            meshtastic: 'analyticsSparkMesh',
-        };
-
-        for (const [mode, elId] of Object.entries(map)) {
-            const el = document.getElementById(elId);
-            if (!el) continue;
-            const data = sparklines[mode] || [];
-            if (data.length < 2) {
-                el.innerHTML = '';
-                continue;
-            }
-            const max = Math.max(...data, 1);
-            const w = 100;
-            const h = 24;
-            const step = w / (data.length - 1);
-            const points = data.map((v, i) =>
-                (i * step).toFixed(1) + ',' + (h - (v / max) * (h - 2)).toFixed(1)
-            ).join(' ');
-            el.innerHTML = '<svg viewBox="0 0 ' + w + ' ' + h + '" preserveAspectRatio="none"><polyline points="' + points + '"/></svg>';
-        }
-    }
-
-    function renderInsights(data) {
-        const cards = data.cards || [];
-        const topChanges = data.top_changes || [];
-        const cardsEl = document.getElementById('analyticsInsights');
-        const changesEl = document.getElementById('analyticsTopChanges');
-
-        if (cardsEl) {
-            if (!cards.length) {
-                cardsEl.innerHTML = '<div class="analytics-empty">No insight data available</div>';
-            } else {
-                cardsEl.innerHTML = cards.map(c => {
-                    const sev = _esc(c.severity || 'low');
-                    const title = _esc(c.title || 'Insight');
-                    const value = _esc(c.value || '--');
-                    const label = _esc(c.label || '');
-                    const detail = _esc(c.detail || '');
-                    return '<div class="analytics-insight-card ' + sev + '">' +
-                        '<div class="insight-title">' + title + '</div>' +
-                        '<div class="insight-value">' + value + '</div>' +
-                        '<div class="insight-label">' + label + '</div>' +
-                        '<div class="insight-detail">' + detail + '</div>' +
-                        '</div>';
-                }).join('');
-            }
-        }
-
-        if (changesEl) {
-            if (!topChanges.length) {
-                changesEl.innerHTML = '<div class="analytics-empty">No change signals yet</div>';
-            } else {
-                changesEl.innerHTML = topChanges.map(item => {
-                    const mode = _esc(item.mode_label || item.mode || '');
-                    const deltaRaw = Number(item.delta || 0);
-                    const trendClass = deltaRaw > 0 ? 'up' : (deltaRaw < 0 ? 'down' : 'flat');
-                    const delta = _esc(item.signed_delta || String(deltaRaw));
-                    const recentAvg = _esc(item.recent_avg);
-                    const prevAvg = _esc(item.previous_avg);
-                    return '<div class="analytics-change-row">' +
-                        '<span class="mode">' + mode + '</span>' +
-                        '<span class="delta ' + trendClass + '">' + delta + '</span>' +
-                        '<span class="avg">avg ' + recentAvg + ' vs ' + prevAvg + '</span>' +
-                        '</div>';
-                }).join('');
-            }
-        }
-    }
-
-    function renderPatterns(patterns) {
-        const container = document.getElementById('analyticsPatternList');
-        if (!container) return;
-        if (!patterns || patterns.length === 0) {
-            container.innerHTML = '<div class="analytics-empty">No recurring patterns detected</div>';
-            return;
-        }
-
-        const modeLabels = {
-            adsb: 'ADS-B', ais: 'AIS', wifi: 'WiFi', bluetooth: 'Bluetooth',
-            dsc: 'DSC', acars: 'ACARS', vdl2: 'VDL2', aprs: 'APRS', meshtastic: 'Meshtastic',
-        };
-
-        const sorted = patterns
-            .slice()
-            .sort((a, b) => (b.confidence || 0) - (a.confidence || 0))
-            .slice(0, 20);
-
-        container.innerHTML = sorted.map(p => {
-            const confidencePct = Math.round((Number(p.confidence || 0)) * 100);
-            const mode = modeLabels[p.mode] || (p.mode || '--').toUpperCase();
-            const period = _humanPeriod(Number(p.period_seconds || 0));
-            const occurrences = Number(p.occurrences || 0);
-            const deviceId = _shortId(p.device_id || '--');
-            return '<div class="analytics-pattern-item">' +
-                '<div class="pattern-main">' +
-                '<span class="pattern-mode">' + _esc(mode) + '</span>' +
-                '<span class="pattern-device">' + _esc(deviceId) + '</span>' +
-                '</div>' +
-                '<div class="pattern-meta">' +
-                '<span>Period: ' + _esc(period) + '</span>' +
-                '<span>Hits: ' + _esc(occurrences) + '</span>' +
-                '<span class="pattern-confidence">' + _esc(confidencePct) + '%</span>' +
-                '</div>' +
-                '</div>';
-        }).join('');
-    }
-
-    function renderAlerts(events) {
-        const container = document.getElementById('analyticsAlertFeed');
-        if (!container) return;
-        if (!events || events.length === 0) {
-            container.innerHTML = '<div class="analytics-empty">No recent alerts</div>';
-            return;
-        }
-        container.innerHTML = events.slice(0, 20).map(e => {
-            const sev = e.severity || 'medium';
-            const title = e.title || e.event_type || 'Alert';
-            const time = e.created_at ? new Date(e.created_at).toLocaleTimeString() : '';
-            return '<div class="analytics-alert-item">' +
-                '<span class="alert-severity ' + _esc(sev) + '">' + _esc(sev) + '</span>' +
-                '<span>' + _esc(title) + '</span>' +
-                '<span style="margin-left:auto;color:var(--text-dim)">' + _esc(time) + '</span>' +
-                '</div>';
-        }).join('');
-    }
-
-    function renderCorrelations(data) {
-        const container = document.getElementById('analyticsCorrelations');
-        if (!container) return;
-        const pairs = (data && data.correlations) || [];
-        if (pairs.length === 0) {
-            container.innerHTML = '<div class="analytics-empty">No correlations detected</div>';
-            return;
-        }
-        container.innerHTML = pairs.slice(0, 20).map(p => {
-            const conf = Math.round((p.confidence || 0) * 100);
-            return '<div class="analytics-correlation-pair">' +
-                '<span>' + _esc(p.wifi_mac || '') + '</span>' +
-                '<span style="color:var(--text-dim)">&#8596;</span>' +
-                '<span>' + _esc(p.bt_mac || '') + '</span>' +
-                '<div class="confidence-bar"><div class="confidence-fill" style="width:' + conf + '%"></div></div>' +
-                '<span style="color:var(--text-dim)">' + conf + '%</span>' +
-                '</div>';
-        }).join('');
-    }
-
-    function renderGeofences(zones) {
-        const container = document.getElementById('analyticsGeofenceList');
-        if (!container) return;
-        if (!zones || zones.length === 0) {
-            container.innerHTML = '<div class="analytics-empty">No geofence zones defined</div>';
-            return;
-        }
-        container.innerHTML = zones.map(z =>
-            '<div class="geofence-zone-item">' +
-            '<span class="zone-name">' + _esc(z.name) + '</span>' +
-            '<span class="zone-radius">' + z.radius_m + 'm</span>' +
-            '<button class="zone-delete" onclick="Analytics.deleteGeofence(' + z.id + ')">DEL</button>' +
-            '</div>'
-        ).join('');
-    }
-
-    function addGeofence() {
-        const name = prompt('Zone name:');
-        if (!name) return;
-        const lat = parseFloat(prompt('Latitude:', '0'));
-        const lon = parseFloat(prompt('Longitude:', '0'));
-        const radius = parseFloat(prompt('Radius (meters):', '1000'));
-        if (isNaN(lat) || isNaN(lon) || isNaN(radius)) {
-            alert('Invalid input');
-            return;
-        }
-        fetch('/analytics/geofences', {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ name, lat, lon, radius_m: radius }),
-        })
-            .then(r => r.json())
-            .then(() => refresh());
-    }
-
-    function deleteGeofence(id) {
-        if (!confirm('Delete this geofence zone?')) return;
-        fetch('/analytics/geofences/' + id, { method: 'DELETE' })
-            .then(r => r.json())
-            .then(() => refresh());
-    }
-
-    function exportData(mode) {
-        const m = mode || (document.getElementById('exportMode') || {}).value || 'adsb';
-        const f = (document.getElementById('exportFormat') || {}).value || 'json';
-        window.open('/analytics/export/' + encodeURIComponent(m) + '?format=' + encodeURIComponent(f), '_blank');
-    }
-
-    function searchTarget() {
-        const input = document.getElementById('analyticsTargetQuery');
-        const summaryEl = document.getElementById('analyticsTargetSummary');
-        const q = (input && input.value || '').trim();
-        if (!q) {
-            if (summaryEl) summaryEl.textContent = 'Enter a search value to correlate entities';
-            renderTargetResults([]);
-            return;
-        }
-
-        fetch('/analytics/target?q=' + encodeURIComponent(q) + '&limit=120')
-            .then((r) => r.json())
-            .then((data) => {
-                const results = data.results || [];
-                if (summaryEl) {
-                    const modeCounts = data.mode_counts || {};
-                    const bits = Object.entries(modeCounts).map(([mode, count]) => `${mode}: ${count}`).join(' | ');
-                    summaryEl.textContent = `${results.length} results${bits ? ' | ' + bits : ''}`;
-                }
-                renderTargetResults(results);
-            })
-            .catch((err) => {
-                if (summaryEl) summaryEl.textContent = 'Search failed';
-                if (typeof reportActionableError === 'function') {
-                    reportActionableError('Target View Search', err, { onRetry: searchTarget });
-                }
-            });
-    }
-
-    function renderTargetResults(results) {
-        const container = document.getElementById('analyticsTargetResults');
-        if (!container) return;
-
-        if (!results || !results.length) {
-            container.innerHTML = '<div class="analytics-empty">No matching entities</div>';
-            return;
-        }
-
-        container.innerHTML = results.map((item) => {
-            const title = _esc(item.title || item.id || 'Entity');
-            const subtitle = _esc(item.subtitle || '');
-            const mode = _esc(item.mode || 'unknown');
-            const confidence = item.confidence != null ? `Confidence ${_esc(Math.round(Number(item.confidence) * 100))}%` : '';
-            const lastSeen = _esc(item.last_seen || '');
-            return '<div class="analytics-target-item">' +
-                '<div class="title"><span class="mode">' + mode + '</span><span>' + title + '</span></div>' +
-                '<div class="meta"><span>' + subtitle + '</span>' +
-                (lastSeen ? '<span>Last seen ' + lastSeen + '</span>' : '') +
-                (confidence ? '<span>' + confidence + '</span>' : '') +
-                '</div>' +
-                '</div>';
-        }).join('');
-    }
-
-    function loadReplaySessions() {
-        const select = document.getElementById('analyticsReplaySelect');
-        if (!select) return;
-
-        fetch('/recordings?limit=60')
-            .then((r) => r.json())
-            .then((data) => {
-                replaySessions = (data.recordings || []).filter((rec) => Number(rec.event_count || 0) > 0);
-
-                if (!replaySessions.length) {
-                    select.innerHTML = '<option value="">No recordings</option>';
-                    return;
-                }
-
-                select.innerHTML = replaySessions.map((rec) => {
-                    const label = `${rec.mode} | ${(rec.label || 'session')} | ${new Date(rec.started_at).toLocaleString()}`;
-                    return `<option value="${_esc(rec.id)}">${_esc(label)}</option>`;
-                }).join('');
-
-                const pendingReplay = localStorage.getItem('analyticsReplaySession');
-                if (pendingReplay && replaySessions.some((rec) => rec.id === pendingReplay)) {
-                    select.value = pendingReplay;
-                    localStorage.removeItem('analyticsReplaySession');
-                    loadReplay();
-                }
-            })
-            .catch((err) => {
-                if (typeof reportActionableError === 'function') {
-                    reportActionableError('Load Replay Sessions', err, { onRetry: loadReplaySessions });
-                }
-            });
-    }
-
-    function loadReplay() {
-        pauseReplay();
-        replayEvents = [];
-        replayIndex = 0;
-
-        const select = document.getElementById('analyticsReplaySelect');
-        const meta = document.getElementById('analyticsReplayMeta');
-        const timeline = document.getElementById('analyticsReplayTimeline');
-        if (!select || !meta || !timeline) return;
-
-        const id = select.value;
-        if (!id) {
-            meta.textContent = 'Select a recording';
-            timeline.innerHTML = '<div class="analytics-empty">No recording selected</div>';
-            return;
-        }
-
-        meta.textContent = 'Loading replay events...';
-
-        fetch('/recordings/' + encodeURIComponent(id) + '/events?limit=600')
-            .then((r) => r.json())
-            .then((data) => {
-                replayEvents = data.events || [];
-                replayIndex = 0;
-                if (!replayEvents.length) {
-                    meta.textContent = 'No events found in selected recording';
-                    timeline.innerHTML = '<div class="analytics-empty">No events to replay</div>';
-                    return;
-                }
-
-                const rec = replaySessions.find((s) => s.id === id);
-                const mode = rec ? rec.mode : (data.recording && data.recording.mode) || 'unknown';
-                meta.textContent = `${replayEvents.length} events loaded | mode ${mode}`;
-                renderReplayWindow();
-            })
-            .catch((err) => {
-                meta.textContent = 'Replay load failed';
-                if (typeof reportActionableError === 'function') {
-                    reportActionableError('Load Replay', err, { onRetry: loadReplay });
-                }
-            });
-    }
-
-    function playReplay() {
-        if (!replayEvents.length) {
-            loadReplay();
-            return;
-        }
-
-        if (replayTimer) return;
-
-        replayTimer = setInterval(() => {
-            if (replayIndex >= replayEvents.length - 1) {
-                pauseReplay();
-                return;
-            }
-            replayIndex += 1;
-            renderReplayWindow();
-        }, 260);
-    }
-
-    function pauseReplay() {
-        if (replayTimer) {
-            clearInterval(replayTimer);
-            replayTimer = null;
-        }
-    }
-
-    function stepReplay() {
-        if (!replayEvents.length) {
-            loadReplay();
-            return;
-        }
-
-        pauseReplay();
-        replayIndex = Math.min(replayIndex + 1, replayEvents.length - 1);
-        renderReplayWindow();
-    }
-
-    function renderReplayWindow() {
-        const timeline = document.getElementById('analyticsReplayTimeline');
-        const meta = document.getElementById('analyticsReplayMeta');
-        if (!timeline || !meta) return;
-
-        const total = replayEvents.length;
-        if (!total) {
-            timeline.innerHTML = '<div class="analytics-empty">No events to replay</div>';
-            return;
-        }
-
-        const start = Math.max(0, replayIndex - 15);
-        const end = Math.min(total, replayIndex + 20);
-        const windowed = replayEvents.slice(start, end);
-
-        timeline.innerHTML = windowed.map((row, i) => {
-            const absolute = start + i;
-            const active = absolute === replayIndex;
-            const eventType = _esc(row.event_type || 'event');
-            const mode = _esc(row.mode || '--');
-            const ts = _esc(row.timestamp ? new Date(row.timestamp).toLocaleTimeString() : '--');
-            const detail = summarizeReplayEvent(row.event || {});
-            return '<div class="analytics-replay-item" style="opacity:' + (active ? '1' : '0.65') + ';">' +
-                '<div class="title"><span class="mode">' + mode + '</span><span>' + eventType + '</span></div>' +
-                '<div class="meta"><span>' + ts + '</span><span>' + _esc(detail) + '</span></div>' +
-                '</div>';
-        }).join('');
-
-        meta.textContent = `Event ${replayIndex + 1}/${total}`;
-    }
-
-    function summarizeReplayEvent(event) {
-        if (!event || typeof event !== 'object') return 'No details';
-        if (event.callsign) return `Callsign ${event.callsign}`;
-        if (event.icao) return `ICAO ${event.icao}`;
-        if (event.ssid) return `SSID ${event.ssid}`;
-        if (event.bssid) return `BSSID ${event.bssid}`;
-        if (event.address) return `Address ${event.address}`;
-        if (event.name) return `Name ${event.name}`;
-        const keys = Object.keys(event);
-        if (!keys.length) return 'No fields';
-        return `${keys[0]}=${String(event[keys[0]]).slice(0, 40)}`;
-    }
-
-    function _setText(id, val) {
-        const el = document.getElementById(id);
-        if (el) el.textContent = val;
-    }
-
-    function _esc(s) {
-        if (typeof s !== 'string') s = String(s == null ? '' : s);
-        return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
-    }
-
-    function _shortId(value) {
-        const text = String(value || '');
-        if (text.length <= 18) return text;
-        return text.slice(0, 8) + '...' + text.slice(-6);
-    }
-
-    function _humanPeriod(seconds) {
-        if (!isFinite(seconds) || seconds <= 0) return '--';
-        if (seconds < 60) return Math.round(seconds) + 's';
-        const mins = seconds / 60;
-        if (mins < 60) return mins.toFixed(mins < 10 ? 1 : 0) + 'm';
-        const hours = mins / 60;
-        return hours.toFixed(hours < 10 ? 1 : 0) + 'h';
-    }
-
-    return {
-        init,
-        destroy,
-        refresh,
-        addGeofence,
-        deleteGeofence,
-        exportData,
-        searchTarget,
-        loadReplay,
-        playReplay,
-        pauseReplay,
-        stepReplay,
-        loadReplaySessions,
-    };
-})();

static/js/modes/bluetooth.js

@@ -946,17 +946,32 @@ const BluetoothMode = (function() {
 
     async function stopScan() {
         const isAgentMode = typeof currentAgent !== 'undefined' && currentAgent !== 'local';
+        const timeoutMs = isAgentMode ? 8000 : 2200;
+        const controller = (typeof AbortController !== 'undefined') ? new AbortController() : null;
+        const timeoutId = controller ? setTimeout(() => controller.abort(), timeoutMs) : null;
+
+        // Optimistic UI teardown keeps mode changes responsive.
+        setScanning(false);
+        stopEventStream();
 
         try {
             if (isAgentMode) {
-                await fetch(`/controller/agents/${currentAgent}/bluetooth/stop`, { method: 'POST' });
+                await fetch(`/controller/agents/${currentAgent}/bluetooth/stop`, {
+                    method: 'POST',
+                    ...(controller ? { signal: controller.signal } : {}),
+                });
             } else {
-                await fetch('/api/bluetooth/scan/stop', { method: 'POST' });
+                await fetch('/api/bluetooth/scan/stop', {
+                    method: 'POST',
+                    ...(controller ? { signal: controller.signal } : {}),
+                });
             }
-            setScanning(false);
-            stopEventStream();
         } catch (err) {
             console.error('Failed to stop scan:', err);
+        } finally {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
         }
     }
 
@@ -1758,8 +1773,18 @@ const BluetoothMode = (function() {
         // Getters
         getDevices: () => Array.from(devices.values()),
         isScanning: () => isScanning,
-        isShowAllAgents: () => showAllAgentsMode
+        isShowAllAgents: () => showAllAgentsMode,
+
+        // Lifecycle
+        destroy
     };
+
+    /**
+     * Destroy — close SSE stream and clear polling timers for clean mode switching.
+     */
+    function destroy() {
+        stopEventStream();
+    }
 })();
 
 // Global functions for onclick handlers

static/js/modes/bt_locate.js

@@ -31,12 +31,20 @@ const BtLocate = (function() {
     let movementHeadMarker = null;
     let strongestMarker = null;
     let confidenceCircle = null;
-    let heatmapEnabled = true;
+    let heatmapEnabled = false;
     let movementEnabled = true;
     let autoFollowEnabled = true;
     let smoothingEnabled = true;
     let lastRenderedDetectionKey = null;
     let pendingHeatSync = false;
+    let mapStabilizeTimer = null;
+    let modeActive = false;
+    let queuedDetection = null;
+    let queuedDetectionOptions = null;
+    let queuedDetectionTimer = null;
+    let lastDetectionRenderAt = 0;
+    let startRequestInFlight = false;
+    let crosshairResetTimer = null;
 
     const MAX_HEAT_POINTS = 1200;
     const MAX_TRAIL_POINTS = 1200;
@@ -44,6 +52,9 @@ const BtLocate = (function() {
     const OUTLIER_HARD_JUMP_METERS = 2000;
     const OUTLIER_SOFT_JUMP_METERS = 450;
     const OUTLIER_MAX_SPEED_MPS = 50;
+    const MAP_STABILIZE_INTERVAL_MS = 220;
+    const MAP_STABILIZE_ATTEMPTS = 8;
+    const MIN_DETECTION_RENDER_MS = 220;
     const OVERLAY_STORAGE_KEYS = {
         heatmap: 'btLocateHeatmapEnabled',
         movement: 'btLocateMovementEnabled',
@@ -63,6 +74,20 @@ const BtLocate = (function() {
             1.0: '#ef4444',
         },
     };
+    const BT_LOCATE_DEBUG = (() => {
+        try {
+            const params = new URLSearchParams(window.location.search || '');
+            return params.get('btlocate_debug') === '1' ||
+                localStorage.getItem('btLocateDebug') === 'true';
+        } catch (_) {
+            return false;
+        }
+    })();
+
+    function debugLog() {
+        if (!BT_LOCATE_DEBUG) return;
+        console.log.apply(console, arguments);
+    }
 
     function getMapContainer() {
         if (!map || typeof map.getContainer !== 'function') return null;
@@ -81,7 +106,71 @@ const BtLocate = (function() {
         return true;
     }
 
+    function statusUrl() {
+        try {
+            const params = new URLSearchParams(window.location.search || '');
+            const debugFlag = params.get('btlocate_debug') === '1' ||
+                localStorage.getItem('btLocateDebug') === 'true';
+            return debugFlag ? '/bt_locate/status?debug=1' : '/bt_locate/status';
+        } catch (_) {
+            return '/bt_locate/status';
+        }
+    }
+
+    function coerceLocation(lat, lon) {
+        const nLat = Number(lat);
+        const nLon = Number(lon);
+        if (!isFinite(nLat) || !isFinite(nLon)) return null;
+        if (nLat < -90 || nLat > 90 || nLon < -180 || nLon > 180) return null;
+        return { lat: nLat, lon: nLon };
+    }
+
+    function resolveFallbackLocation() {
+        try {
+            if (typeof ObserverLocation !== 'undefined' && ObserverLocation.getShared) {
+                const shared = ObserverLocation.getShared();
+                const normalized = coerceLocation(shared?.lat, shared?.lon);
+                if (normalized) return normalized;
+            }
+        } catch (_) {}
+
+        try {
+            const stored = localStorage.getItem('observerLocation');
+            if (stored) {
+                const parsed = JSON.parse(stored);
+                const normalized = coerceLocation(parsed?.lat, parsed?.lon);
+                if (normalized) return normalized;
+            }
+        } catch (_) {}
+
+        try {
+            const normalized = coerceLocation(
+                localStorage.getItem('observerLat'),
+                localStorage.getItem('observerLon')
+            );
+            if (normalized) return normalized;
+        } catch (_) {}
+
+        return coerceLocation(window.INTERCEPT_DEFAULT_LAT, window.INTERCEPT_DEFAULT_LON);
+    }
+
+    function setStartButtonBusy(busy) {
+        const startBtn = document.getElementById('btLocateStartBtn');
+        if (!startBtn) return;
+        if (busy) {
+            if (!startBtn.dataset.defaultLabel) {
+                startBtn.dataset.defaultLabel = startBtn.textContent || 'Start Locate';
+            }
+            startBtn.disabled = true;
+            startBtn.textContent = 'Starting...';
+            return;
+        }
+        startBtn.disabled = false;
+        startBtn.textContent = startBtn.dataset.defaultLabel || 'Start Locate';
+    }
+
     function init() {
+        modeActive = true;
         loadOverlayPreferences();
         syncOverlayControls();
 
@@ -99,6 +188,7 @@ const BtLocate = (function() {
                         Settings.createTileLayer().addTo(map);
                     }
                     flushPendingHeatSync();
+                    scheduleMapStabilization(10);
                 }, 150);
             }
             checkStatus();
@@ -113,15 +203,23 @@ const BtLocate = (function() {
                 zoom: 2,
                 zoomControl: true,
             });
+            let tileLayer = null;
             // Use tile provider from user settings
             if (typeof Settings !== 'undefined' && Settings.createTileLayer) {
-                Settings.createTileLayer().addTo(map);
+                tileLayer = Settings.createTileLayer();
+                tileLayer.addTo(map);
                 Settings.registerMap(map);
             } else {
-                L.tileLayer('https://{s}.basemaps.cartocdn.com/dark_all/{z}/{x}/{y}{r}.png', {
+                tileLayer = L.tileLayer('https://{s}.basemaps.cartocdn.com/dark_all/{z}/{x}/{y}{r}.png', {
                     maxZoom: 19,
                     attribution: '&copy; OSM &copy; CARTO'
-                }).addTo(map);
+                });
+                tileLayer.addTo(map);
+            }
+            if (tileLayer && typeof tileLayer.on === 'function') {
+                tileLayer.on('load', () => {
+                    scheduleMapStabilization(8);
+                });
             }
             ensureHeatLayer();
             syncMovementLayer();
@@ -129,10 +227,11 @@ const BtLocate = (function() {
             map.on('resize moveend zoomend', () => {
                 flushPendingHeatSync();
             });
-            setTimeout(() => {
+            requestAnimationFrame(() => {
                 safeInvalidateMap();
                 flushPendingHeatSync();
-            }, 100);
+                scheduleMapStabilization();
+            });
         }
 
         // Init RSSI chart canvas
@@ -146,7 +245,7 @@ const BtLocate = (function() {
     }
 
     function checkStatus() {
-        fetch('/bt_locate/status')
+        fetch(statusUrl())
             .then(r => r.json())
             .then(data => {
                 if (data.active) {
@@ -160,8 +259,21 @@ const BtLocate = (function() {
             .catch(() => {});
     }
 
+    function normalizeMacInput(value) {
+        const raw = (value || '').trim().toUpperCase().replace(/-/g, ':');
+        if (!raw) return '';
+        const compact = raw.replace(/[^0-9A-F]/g, '');
+        if (compact.length === 12) {
+            return compact.match(/.{1,2}/g).join(':');
+        }
+        return raw;
+    }
+
     function start() {
-        const mac = document.getElementById('btLocateMac')?.value.trim();
+        if (startRequestInFlight) {
+            return;
+        }
+        const mac = normalizeMacInput(document.getElementById('btLocateMac')?.value);
         const namePattern = document.getElementById('btLocateNamePattern')?.value.trim();
         const irk = document.getElementById('btLocateIrk')?.value.trim();
 
@@ -177,14 +289,13 @@ const BtLocate = (function() {
         if (handoffData?.last_known_rssi) body.last_known_rssi = handoffData.last_known_rssi;
 
         // Include user location as fallback when GPS unavailable
-        const userLat = localStorage.getItem('observerLat');
+        const fallbackLocation = resolveFallbackLocation();
-        const userLon = localStorage.getItem('observerLon');
+        if (fallbackLocation) {
-        if (userLat !== null && userLon !== null) {
+            body.fallback_lat = fallbackLocation.lat;
-            body.fallback_lat = parseFloat(userLat);
+            body.fallback_lon = fallbackLocation.lon;
-            body.fallback_lon = parseFloat(userLon);
         }
 
-        console.log('[BtLocate] Starting with body:', body);
+        debugLog('[BtLocate] Starting with body:', body);
 
         if (!body.mac_address && !body.name_pattern && !body.irk_hex &&
             !body.device_id && !body.device_key && !body.fingerprint_id) {
@@ -192,12 +303,27 @@ const BtLocate = (function() {
             return;
         }
 
+        startRequestInFlight = true;
+        setStartButtonBusy(true);
+
         fetch('/bt_locate/start', {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify(body),
         })
-            .then(r => r.json())
+            .then(async (r) => {
+                let data = null;
+                try {
+                    data = await r.json();
+                } catch (_) {
+                    data = {};
+                }
+                if (!r.ok || data.status !== 'started') {
+                    const message = data.error || data.message || ('HTTP ' + r.status);
+                    throw new Error(message);
+                }
+                return data;
+            })
             .then(data => {
                 if (data.status === 'started') {
                     sessionStartedAt = data.session?.started_at ? new Date(data.session.started_at).getTime() : Date.now();
@@ -209,23 +335,38 @@ const BtLocate = (function() {
                     updateScanStatus(data.session);
                     // Restore any existing trail (e.g. from a stop/start cycle)
                     restoreTrail();
+                    pollStatus();
                 }
             })
-            .catch(err => console.error('[BtLocate] Start error:', err));
+            .catch(err => {
+                console.error('[BtLocate] Start error:', err);
+                alert('BT Locate failed to start: ' + (err?.message || 'Unknown error'));
+                showIdleUI();
+            })
+            .finally(() => {
+                startRequestInFlight = false;
+                setStartButtonBusy(false);
+            });
     }
 
     function stop() {
-        fetch('/bt_locate/stop', { method: 'POST' })
+        // Update UI immediately — don't wait for the backend response.
-            .then(r => r.json())
+        if (queuedDetectionTimer) {
-            .then(() => {
+            clearTimeout(queuedDetectionTimer);
+            queuedDetectionTimer = null;
+        }
+        queuedDetection = null;
+        queuedDetectionOptions = null;
         showIdleUI();
         disconnectSSE();
         stopAudio();
-            })
+        // Notify backend asynchronously.
+        fetch('/bt_locate/stop', { method: 'POST' })
             .catch(err => console.error('[BtLocate] Stop error:', err));
     }
 
     function showActiveUI() {
+        setStartButtonBusy(false);
         const startBtn = document.getElementById('btLocateStartBtn');
         const stopBtn = document.getElementById('btLocateStopBtn');
         if (startBtn) startBtn.style.display = 'none';
@@ -234,6 +375,14 @@ const BtLocate = (function() {
     }
 
     function showIdleUI() {
+        startRequestInFlight = false;
+        setStartButtonBusy(false);
+        if (queuedDetectionTimer) {
+            clearTimeout(queuedDetectionTimer);
+            queuedDetectionTimer = null;
+        }
+        queuedDetection = null;
+        queuedDetectionOptions = null;
         const startBtn = document.getElementById('btLocateStartBtn');
         const stopBtn = document.getElementById('btLocateStopBtn');
         if (startBtn) startBtn.style.display = 'inline-block';
@@ -263,13 +412,13 @@ const BtLocate = (function() {
 
     function connectSSE() {
         if (eventSource) eventSource.close();
-        console.log('[BtLocate] Connecting SSE stream');
+        debugLog('[BtLocate] Connecting SSE stream');
         eventSource = new EventSource('/bt_locate/stream');
 
         eventSource.addEventListener('detection', function(e) {
             try {
                 const event = JSON.parse(e.data);
-                console.log('[BtLocate] Detection event:', event);
+                debugLog('[BtLocate] Detection event:', event);
                 handleDetection(event);
             } catch (err) {
                 console.error('[BtLocate] Parse error:', err);
@@ -282,7 +431,7 @@ const BtLocate = (function() {
         });
 
         eventSource.onerror = function() {
-            console.warn('[BtLocate] SSE error, polling fallback active');
+            debugLog('[BtLocate] SSE error, polling fallback active');
             if (eventSource && eventSource.readyState === EventSource.CLOSED) {
                 eventSource = null;
             }
@@ -290,6 +439,7 @@ const BtLocate = (function() {
 
         // Start polling fallback (catches data even if SSE fails)
         startPolling();
+        pollStatus();
     }
 
     function disconnectSSE() {
@@ -337,7 +487,7 @@ const BtLocate = (function() {
     }
 
     function pollStatus() {
-        fetch('/bt_locate/status')
+        fetch(statusUrl())
             .then(r => r.json())
             .then(data => {
                 if (!data.active) {
@@ -434,7 +584,42 @@ const BtLocate = (function() {
         }
     }
 
+    function flushQueuedDetection() {
+        if (!queuedDetection) return;
+        const event = queuedDetection;
+        const options = queuedDetectionOptions || {};
+        queuedDetection = null;
+        queuedDetectionOptions = null;
+        queuedDetectionTimer = null;
+        renderDetection(event, options);
+    }
+
     function handleDetection(event, options = {}) {
+        if (!modeActive) {
+            return;
+        }
+        const now = Date.now();
+        if (options.force || (now - lastDetectionRenderAt) >= MIN_DETECTION_RENDER_MS) {
+            if (queuedDetectionTimer) {
+                clearTimeout(queuedDetectionTimer);
+                queuedDetectionTimer = null;
+            }
+            queuedDetection = null;
+            queuedDetectionOptions = null;
+            renderDetection(event, options);
+            return;
+        }
+
+        // Keep only the freshest event while throttled.
+        queuedDetection = event;
+        queuedDetectionOptions = options;
+        if (!queuedDetectionTimer) {
+            queuedDetectionTimer = setTimeout(flushQueuedDetection, MIN_DETECTION_RENDER_MS);
+        }
+    }
+
+    function renderDetection(event, options = {}) {
+        lastDetectionRenderAt = Date.now();
         const d = event?.data || event;
         if (!d) return;
         const detectionKey = buildDetectionKey(d);
@@ -460,7 +645,7 @@ const BtLocate = (function() {
             try {
                 mapPointAdded = addMapMarker(d, { suppressFollow: options.suppressFollow === true });
             } catch (error) {
-                console.warn('[BtLocate] Map update skipped:', error);
+                debugLog('[BtLocate] Map update skipped:', error);
                 mapPointAdded = false;
             }
         }
@@ -518,12 +703,40 @@ const BtLocate = (function() {
         if (gpsCountEl) gpsCountEl.textContent = gpsPoints || 0;
     }
 
+    function triggerCrosshairAnimation(lat, lon) {
+        if (!map) return;
+        const overlay = document.getElementById('btLocateCrosshairOverlay');
+        if (!overlay) return;
+        const size = map.getSize();
+        const point = map.latLngToContainerPoint([lat, lon]);
+        const targetX = Math.max(0, Math.min(size.x, point.x));
+        const targetY = Math.max(0, Math.min(size.y, point.y));
+        const startX = size.x + 8;
+        const startY = size.y + 8;
+        const duration = 1500;
+        overlay.style.setProperty('--btl-crosshair-x-start', `${startX}px`);
+        overlay.style.setProperty('--btl-crosshair-y-start', `${startY}px`);
+        overlay.style.setProperty('--btl-crosshair-x-end', `${targetX}px`);
+        overlay.style.setProperty('--btl-crosshair-y-end', `${targetY}px`);
+        overlay.style.setProperty('--btl-crosshair-duration', `${duration}ms`);
+        overlay.classList.remove('active');
+        void overlay.offsetWidth;
+        overlay.classList.add('active');
+        if (crosshairResetTimer) clearTimeout(crosshairResetTimer);
+        crosshairResetTimer = setTimeout(() => {
+            overlay.classList.remove('active');
+            crosshairResetTimer = null;
+        }, duration + 100);
+    }
+
     function addMapMarker(point, options = {}) {
         if (!map || point.lat == null || point.lon == null) return false;
         const lat = Number(point.lat);
         const lon = Number(point.lon);
         if (!isFinite(lat) || !isFinite(lon)) return false;
         if (!shouldAcceptMapPoint(point, lat, lon)) return false;
+        const suppressFollow = options.suppressFollow === true;
+        const bulkLoad = options.bulkLoad === true;
 
         const trailPoint = normalizeTrailPoint(point, lat, lon);
         const band = (trailPoint.proximity_band || 'FAR').toLowerCase();
@@ -550,6 +763,7 @@ const BtLocate = (function() {
             'Time: ' + formatPointTimestamp(trailPoint.timestamp) +
             '</div>'
         );
+        marker.on('click', () => triggerCrosshairAnimation(lat, lon));
 
         trailPoints.push(trailPoint);
         mapMarkers.push(marker);
@@ -563,13 +777,17 @@ const BtLocate = (function() {
         if (heatPoints.length > MAX_HEAT_POINTS) {
             heatPoints.splice(0, heatPoints.length - MAX_HEAT_POINTS);
         }
+        if (bulkLoad) {
+            pendingHeatSync = true;
+            return true;
+        }
         syncHeatLayer();
 
         if (!isMapRenderable()) {
             safeInvalidateMap();
         }
         const canFollowMap = isMapRenderable();
-        if (autoFollowEnabled && !options.suppressFollow && canFollowMap) {
+        if (autoFollowEnabled && !suppressFollow && canFollowMap) {
             if (!gpsLocked) {
                 gpsLocked = true;
                 map.setView([lat, lon], Math.max(map.getZoom(), 16));
@@ -645,8 +863,13 @@ const BtLocate = (function() {
 
                 const gpsTrail = Array.isArray(trail.gps_trail) ? trail.gps_trail : [];
                 const allTrail = Array.isArray(trail.trail) ? trail.trail : [];
+                const recentGpsTrail = gpsTrail.slice(-MAX_TRAIL_POINTS);
 
-                gpsTrail.forEach(p => addMapMarker(p, { suppressFollow: true }));
+                recentGpsTrail.forEach(p => addMapMarker(p, {
+                    suppressFollow: true,
+                    bulkLoad: true,
+                }));
+                syncHeatLayer();
 
                 if (allTrail.length > 0) {
                     rssiHistory = allTrail.map(p => p.rssi).filter(v => typeof v === 'number' && isFinite(v)).slice(-MAX_RSSI_POINTS);
@@ -659,7 +882,7 @@ const BtLocate = (function() {
                     drawRssiChart();
                 }
 
-                updateStats(allTrail.length, gpsTrail.length);
+                updateStats(allTrail.length, recentGpsTrail.length);
 
                 if (trailPoints.length > 0 && map) {
                     const latestGps = trailPoints[trailPoints.length - 1];
@@ -675,6 +898,7 @@ const BtLocate = (function() {
                 syncStrongestMarker();
                 updateConfidenceLayer();
                 updateMovementStats();
+                scheduleMapStabilization(12);
             })
             .catch(() => {});
     }
@@ -853,7 +1077,7 @@ const BtLocate = (function() {
     }
 
     function ensureHeatLayer() {
-        if (!map || typeof L === 'undefined' || typeof L.heatLayer !== 'function') return;
+        if (!map || !heatmapEnabled || typeof L === 'undefined' || typeof L.heatLayer !== 'function') return;
         if (!heatLayer) {
             heatLayer = L.heatLayer([], HEAT_LAYER_OPTIONS);
         }
@@ -861,9 +1085,19 @@ const BtLocate = (function() {
 
     function syncHeatLayer() {
         if (!map) return;
+        if (!heatmapEnabled) {
+            if (heatLayer && map.hasLayer(heatLayer)) {
+                map.removeLayer(heatLayer);
+            }
+            pendingHeatSync = false;
+            return;
+        }
         ensureHeatLayer();
         if (!heatLayer) return;
-        if (!isMapContainerVisible()) {
+        if (!modeActive || !isMapContainerVisible()) {
+            if (map.hasLayer(heatLayer)) {
+                map.removeLayer(heatLayer);
+            }
             pendingHeatSync = true;
             return;
         }
@@ -874,6 +1108,13 @@ const BtLocate = (function() {
                 return;
             }
         }
+        if (!Array.isArray(heatPoints) || heatPoints.length === 0) {
+            if (map.hasLayer(heatLayer)) {
+                map.removeLayer(heatLayer);
+            }
+            pendingHeatSync = false;
+            return;
+        }
         try {
             heatLayer.setLatLngs(heatPoints);
             if (heatmapEnabled) {
@@ -889,10 +1130,52 @@ const BtLocate = (function() {
             if (map.hasLayer(heatLayer)) {
                 map.removeLayer(heatLayer);
             }
-            console.warn('[BtLocate] Heatmap redraw deferred:', error);
+            debugLog('[BtLocate] Heatmap redraw deferred:', error);
         }
     }
 
+    function setActiveMode(active) {
+        modeActive = !!active;
+        if (!map) return;
+
+        if (!modeActive) {
+            stopMapStabilization();
+            if (queuedDetectionTimer) {
+                clearTimeout(queuedDetectionTimer);
+                queuedDetectionTimer = null;
+            }
+            queuedDetection = null;
+            queuedDetectionOptions = null;
+            // Pause BT Locate frontend work when mode is hidden.
+            disconnectSSE();
+            if (heatLayer && map.hasLayer(heatLayer)) {
+                map.removeLayer(heatLayer);
+            }
+            pendingHeatSync = true;
+            return;
+        }
+
+        setTimeout(() => {
+            if (!modeActive) return;
+            safeInvalidateMap();
+            flushPendingHeatSync();
+            syncHeatLayer();
+            syncMovementLayer();
+            syncStrongestMarker();
+            updateConfidenceLayer();
+            scheduleMapStabilization(8);
+            checkStatus();
+        }, 80);
+
+        // A second pass after layout settles (sidebar/visual transitions).
+        setTimeout(() => {
+            if (!modeActive) return;
+            safeInvalidateMap();
+            flushPendingHeatSync();
+            syncHeatLayer();
+        }, 260);
+    }
+
     function isMapRenderable() {
         if (!map || !isMapContainerVisible()) return false;
         if (typeof map.getSize === 'function') {
@@ -908,6 +1191,45 @@ const BtLocate = (function() {
         return true;
     }
 
+    function stopMapStabilization() {
+        if (mapStabilizeTimer) {
+            clearInterval(mapStabilizeTimer);
+            mapStabilizeTimer = null;
+        }
+    }
+
+    function scheduleMapStabilization(attempts = MAP_STABILIZE_ATTEMPTS) {
+        if (!map) return;
+        stopMapStabilization();
+        let remaining = Math.max(1, Number(attempts) || MAP_STABILIZE_ATTEMPTS);
+
+        const tick = () => {
+            if (!map) {
+                stopMapStabilization();
+                return;
+            }
+            if (safeInvalidateMap()) {
+                flushPendingHeatSync();
+                syncMovementLayer();
+                syncStrongestMarker();
+                updateConfidenceLayer();
+                if (isMapRenderable()) {
+                    stopMapStabilization();
+                    return;
+                }
+            }
+            remaining -= 1;
+            if (remaining <= 0) {
+                stopMapStabilization();
+            }
+        };
+
+        tick();
+        if (map && !mapStabilizeTimer && !isMapRenderable()) {
+            mapStabilizeTimer = setInterval(tick, MAP_STABILIZE_INTERVAL_MS);
+        }
+    }
+
     function flushPendingHeatSync() {
         if (!pendingHeatSync) return;
         syncHeatLayer();
@@ -1306,7 +1628,7 @@ const BtLocate = (function() {
         if (typeof showNotification === 'function') {
             showNotification(title, message);
         } else {
-            console.log('[BtLocate] ' + title + ': ' + message);
+            debugLog('[BtLocate] ' + title + ': ' + message);
         }
     }
 
@@ -1397,7 +1719,7 @@ const BtLocate = (function() {
             // Resume must happen within a user gesture handler
             const ctx = audioCtx;
             ctx.resume().then(() => {
-                console.log('[BtLocate] AudioContext state:', ctx.state);
+                debugLog('[BtLocate] AudioContext state:', ctx.state);
                 // Confirmation beep so user knows audio is working
                 playTone(600, 0.08);
             });
@@ -1418,14 +1740,14 @@ const BtLocate = (function() {
             btn.classList.toggle('active', btn.dataset.env === env);
         });
         // Push to running session if active
-        fetch('/bt_locate/status').then(r => r.json()).then(data => {
+        fetch(statusUrl()).then(r => r.json()).then(data => {
             if (data.active) {
                 fetch('/bt_locate/environment', {
                     method: 'POST',
                     headers: { 'Content-Type': 'application/json' },
                     body: JSON.stringify({ environment: env }),
                 }).then(r => r.json()).then(res => {
-                    console.log('[BtLocate] Environment updated:', res);
+                    debugLog('[BtLocate] Environment updated:', res);
                 });
             }
         }).catch(() => {});
@@ -1442,7 +1764,7 @@ const BtLocate = (function() {
     }
 
     function handoff(deviceInfo) {
-        console.log('[BtLocate] Handoff received:', deviceInfo);
+        debugLog('[BtLocate] Handoff received:', deviceInfo);
         handoffData = deviceInfo;
 
         // Populate fields
@@ -1566,10 +1888,12 @@ const BtLocate = (function() {
             syncStrongestMarker();
             updateConfidenceLayer();
         }
+        scheduleMapStabilization(8);
     }
 
     return {
         init,
+        setActiveMode,
         start,
         stop,
         handoff,
@@ -1585,5 +1909,42 @@ const BtLocate = (function() {
         handleDetection,
         invalidateMap,
         fetchPairedIrks,
+        destroy,
     };
+
+    /**
+     * Destroy — close SSE stream and clear all timers for clean mode switching.
+     */
+    function destroy() {
+        if (eventSource) {
+            eventSource.close();
+            eventSource = null;
+        }
+        if (pollTimer) {
+            clearInterval(pollTimer);
+            pollTimer = null;
+        }
+        if (durationTimer) {
+            clearInterval(durationTimer);
+            durationTimer = null;
+        }
+        if (mapStabilizeTimer) {
+            clearInterval(mapStabilizeTimer);
+            mapStabilizeTimer = null;
+        }
+        if (queuedDetectionTimer) {
+            clearTimeout(queuedDetectionTimer);
+            queuedDetectionTimer = null;
+        }
+        if (crosshairResetTimer) {
+            clearTimeout(crosshairResetTimer);
+            crosshairResetTimer = null;
+        }
+        if (beepTimer) {
+            clearInterval(beepTimer);
+            beepTimer = null;
+        }
+    }
 })();
+
+window.BtLocate = BtLocate;

static/js/modes/dmr.js

@@ -1,852 +0,0 @@
-/**
- * Intercept - DMR / Digital Voice Mode
- * Decoding DMR, P25, NXDN, D-STAR digital voice protocols
- */
-
-// ============== STATE ==============
-let isDmrRunning = false;
-let dmrEventSource = null;
-let dmrCallCount = 0;
-let dmrSyncCount = 0;
-let dmrCallHistory = [];
-let dmrCurrentProtocol = '--';
-let dmrModeLabel = 'dmr';  // Protocol label for device reservation
-let dmrHasAudio = false;
-
-// ============== BOOKMARKS ==============
-let dmrBookmarks = [];
-const DMR_BOOKMARKS_KEY = 'dmrBookmarks';
-const DMR_SETTINGS_KEY = 'dmrSettings';
-const DMR_BOOKMARK_PROTOCOLS = new Set(['auto', 'dmr', 'p25', 'nxdn', 'dstar', 'provoice']);
-
-// ============== SYNTHESIZER STATE ==============
-let dmrSynthCanvas = null;
-let dmrSynthCtx = null;
-let dmrSynthBars = [];
-let dmrSynthAnimationId = null;
-let dmrSynthInitialized = false;
-let dmrActivityLevel = 0;
-let dmrActivityTarget = 0;
-let dmrEventType = 'idle';
-let dmrLastEventTime = 0;
-const DMR_BAR_COUNT = 48;
-const DMR_DECAY_RATE = 0.015;
-const DMR_BURST_SYNC = 0.6;
-const DMR_BURST_CALL = 0.85;
-const DMR_BURST_VOICE = 0.95;
-
-// ============== TOOLS CHECK ==============
-
-function checkDmrTools() {
-    fetch('/dmr/tools')
-        .then(r => r.json())
-        .then(data => {
-            const warning = document.getElementById('dmrToolsWarning');
-            const warningText = document.getElementById('dmrToolsWarningText');
-            if (!warning) return;
-
-            const selectedType = (typeof getSelectedSDRType === 'function')
-                ? getSelectedSDRType()
-                : 'rtlsdr';
-            const missing = [];
-            if (!data.dsd) missing.push('dsd (Digital Speech Decoder)');
-            if (selectedType === 'rtlsdr') {
-                if (!data.rtl_fm) missing.push('rtl_fm (RTL-SDR)');
-            } else if (!data.rx_fm) {
-                missing.push('rx_fm (SoapySDR demodulator)');
-            }
-            if (!data.ffmpeg) missing.push('ffmpeg (audio output — optional)');
-
-            if (missing.length > 0) {
-                warning.style.display = 'block';
-                if (warningText) warningText.textContent = missing.join(', ');
-            } else {
-                warning.style.display = 'none';
-            }
-
-            // Update audio panel availability
-            updateDmrAudioStatus(data.ffmpeg ? 'OFF' : 'UNAVAILABLE');
-        })
-        .catch(() => {});
-}
-
-// ============== START / STOP ==============
-
-function startDmr() {
-    const frequency = parseFloat(document.getElementById('dmrFrequency')?.value || 462.5625);
-    const protocol = document.getElementById('dmrProtocol')?.value || 'auto';
-    const gain = parseInt(document.getElementById('dmrGain')?.value || 40);
-    const ppm = parseInt(document.getElementById('dmrPPM')?.value || 0);
-    const relaxCrc = document.getElementById('dmrRelaxCrc')?.checked || false;
-    const device = typeof getSelectedDevice === 'function' ? getSelectedDevice() : 0;
-    const sdrType = (typeof getSelectedSDRType === 'function') ? getSelectedSDRType() : 'rtlsdr';
-
-    // Use protocol name for device reservation so panel shows "D-STAR", "P25", etc.
-    dmrModeLabel = protocol !== 'auto' ? protocol : 'dmr';
-
-    // Check device availability before starting
-    if (typeof checkDeviceAvailability === 'function' && !checkDeviceAvailability(dmrModeLabel)) {
-        return;
-    }
-
-    // Save settings to localStorage for persistence
-    try {
-        localStorage.setItem(DMR_SETTINGS_KEY, JSON.stringify({
-            frequency, protocol, gain, ppm, relaxCrc
-        }));
-    } catch (e) { /* localStorage unavailable */ }
-
-    fetch('/dmr/start', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ frequency, protocol, gain, device, ppm, relaxCrc, sdr_type: sdrType })
-    })
-    .then(r => r.json())
-    .then(data => {
-        if (data.status === 'started') {
-            isDmrRunning = true;
-            dmrCallCount = 0;
-            dmrSyncCount = 0;
-            dmrCallHistory = [];
-            updateDmrUI();
-            connectDmrSSE();
-            dmrEventType = 'idle';
-            dmrActivityTarget = 0.1;
-            dmrLastEventTime = Date.now();
-            if (!dmrSynthInitialized) initDmrSynthesizer();
-            updateDmrSynthStatus();
-            const statusEl = document.getElementById('dmrStatus');
-            if (statusEl) statusEl.textContent = 'DECODING';
-            if (typeof reserveDevice === 'function') {
-                reserveDevice(parseInt(device), dmrModeLabel);
-            }
-            // Start audio if available
-            dmrHasAudio = !!data.has_audio;
-            if (dmrHasAudio) startDmrAudio();
-            updateDmrAudioStatus(dmrHasAudio ? 'STREAMING' : 'UNAVAILABLE');
-            if (typeof showNotification === 'function') {
-                showNotification('Digital Voice', `Decoding ${frequency} MHz (${protocol.toUpperCase()})`);
-            }
-        } else if (data.status === 'error' && data.message === 'Already running') {
-            // Backend has an active session the frontend lost track of — resync
-            isDmrRunning = true;
-            updateDmrUI();
-            connectDmrSSE();
-            if (!dmrSynthInitialized) initDmrSynthesizer();
-            dmrEventType = 'idle';
-            dmrActivityTarget = 0.1;
-            dmrLastEventTime = Date.now();
-            updateDmrSynthStatus();
-            const statusEl = document.getElementById('dmrStatus');
-            if (statusEl) statusEl.textContent = 'DECODING';
-            if (typeof showNotification === 'function') {
-                showNotification('DMR', 'Reconnected to active session');
-            }
-        } else {
-            if (typeof showNotification === 'function') {
-                showNotification('Error', data.message || 'Failed to start DMR');
-            }
-        }
-    })
-    .catch(err => console.error('[DMR] Start error:', err));
-}
-
-function stopDmr() {
-    stopDmrAudio();
-    fetch('/dmr/stop', { method: 'POST' })
-    .then(r => r.json())
-    .then(() => {
-        isDmrRunning = false;
-        if (dmrEventSource) { dmrEventSource.close(); dmrEventSource = null; }
-        updateDmrUI();
-        dmrEventType = 'stopped';
-        dmrActivityTarget = 0;
-        updateDmrSynthStatus();
-        updateDmrAudioStatus('OFF');
-        const statusEl = document.getElementById('dmrStatus');
-        if (statusEl) statusEl.textContent = 'STOPPED';
-        if (typeof releaseDevice === 'function') {
-            releaseDevice(dmrModeLabel);
-        }
-    })
-    .catch(err => console.error('[DMR] Stop error:', err));
-}
-
-// ============== SSE STREAMING ==============
-
-function connectDmrSSE() {
-    if (dmrEventSource) dmrEventSource.close();
-    dmrEventSource = new EventSource('/dmr/stream');
-
-    dmrEventSource.onmessage = function(event) {
-        const msg = JSON.parse(event.data);
-        handleDmrMessage(msg);
-    };
-
-    dmrEventSource.onerror = function() {
-        if (isDmrRunning) {
-            setTimeout(connectDmrSSE, 2000);
-        }
-    };
-}
-
-function handleDmrMessage(msg) {
-    if (dmrSynthInitialized) dmrSynthPulse(msg.type);
-
-    if (msg.type === 'sync') {
-        dmrCurrentProtocol = msg.protocol || '--';
-        const protocolEl = document.getElementById('dmrActiveProtocol');
-        if (protocolEl) protocolEl.textContent = dmrCurrentProtocol;
-        const mainProtocolEl = document.getElementById('dmrMainProtocol');
-        if (mainProtocolEl) mainProtocolEl.textContent = dmrCurrentProtocol;
-        dmrSyncCount++;
-        const syncCountEl = document.getElementById('dmrSyncCount');
-        if (syncCountEl) syncCountEl.textContent = dmrSyncCount;
-    } else if (msg.type === 'call') {
-        dmrCallCount++;
-        const countEl = document.getElementById('dmrCallCount');
-        if (countEl) countEl.textContent = dmrCallCount;
-        const mainCountEl = document.getElementById('dmrMainCallCount');
-        if (mainCountEl) mainCountEl.textContent = dmrCallCount;
-
-        // Update current call display
-        const slotInfo = msg.slot != null ? `
-                <div style="display: flex; justify-content: space-between; margin-bottom: 4px;">
-                    <span style="color: var(--text-muted);">Slot</span>
-                    <span style="color: var(--accent-orange); font-family: var(--font-mono);">${msg.slot}</span>
-                </div>` : '';
-        const callEl = document.getElementById('dmrCurrentCall');
-        if (callEl) {
-            callEl.innerHTML = `
-                <div style="display: flex; justify-content: space-between; margin-bottom: 4px;">
-                    <span style="color: var(--text-muted);">Talkgroup</span>
-                    <span style="color: var(--accent-green); font-weight: bold; font-family: var(--font-mono);">${msg.talkgroup}</span>
-                </div>
-                <div style="display: flex; justify-content: space-between; margin-bottom: 4px;">
-                    <span style="color: var(--text-muted);">Source ID</span>
-                    <span style="color: var(--accent-cyan); font-family: var(--font-mono);">${msg.source_id}</span>
-                </div>${slotInfo}
-                <div style="display: flex; justify-content: space-between;">
-                    <span style="color: var(--text-muted);">Time</span>
-                    <span style="color: var(--text-primary);">${msg.timestamp}</span>
-                </div>
-            `;
-        }
-
-        // Add to history
-        dmrCallHistory.unshift({
-            talkgroup: msg.talkgroup,
-            source_id: msg.source_id,
-            protocol: dmrCurrentProtocol,
-            time: msg.timestamp,
-        });
-        if (dmrCallHistory.length > 50) dmrCallHistory.length = 50;
-        renderDmrHistory();
-
-    } else if (msg.type === 'slot') {
-        // Update slot info in current call
-    } else if (msg.type === 'raw') {
-        // Raw DSD output — triggers synthesizer activity via dmrSynthPulse
-    } else if (msg.type === 'heartbeat') {
-        // Decoder is alive and listening — keep synthesizer in listening state
-        if (isDmrRunning && dmrSynthInitialized) {
-            if (dmrEventType === 'idle' || dmrEventType === 'raw') {
-                dmrEventType = 'raw';
-                dmrActivityTarget = Math.max(dmrActivityTarget, 0.15);
-                dmrLastEventTime = Date.now();
-                updateDmrSynthStatus();
-            }
-        }
-    } else if (msg.type === 'status') {
-        const statusEl = document.getElementById('dmrStatus');
-        if (msg.text === 'started') {
-            if (statusEl) statusEl.textContent = 'DECODING';
-        } else if (msg.text === 'crashed') {
-            isDmrRunning = false;
-            stopDmrAudio();
-            updateDmrUI();
-            dmrEventType = 'stopped';
-            dmrActivityTarget = 0;
-            updateDmrSynthStatus();
-            updateDmrAudioStatus('OFF');
-            if (statusEl) statusEl.textContent = 'CRASHED';
-            if (typeof releaseDevice === 'function') releaseDevice(dmrModeLabel);
-            const detail = msg.detail || `Decoder exited (code ${msg.exit_code})`;
-            if (typeof showNotification === 'function') {
-                showNotification('DMR Error', detail);
-            }
-        } else if (msg.text === 'stopped') {
-            isDmrRunning = false;
-            stopDmrAudio();
-            updateDmrUI();
-            dmrEventType = 'stopped';
-            dmrActivityTarget = 0;
-            updateDmrSynthStatus();
-            updateDmrAudioStatus('OFF');
-            if (statusEl) statusEl.textContent = 'STOPPED';
-            if (typeof releaseDevice === 'function') releaseDevice(dmrModeLabel);
-        }
-    }
-}
-
-// ============== UI ==============
-
-function updateDmrUI() {
-    const startBtn = document.getElementById('startDmrBtn');
-    const stopBtn = document.getElementById('stopDmrBtn');
-    if (startBtn) startBtn.style.display = isDmrRunning ? 'none' : 'block';
-    if (stopBtn) stopBtn.style.display = isDmrRunning ? 'block' : 'none';
-}
-
-function renderDmrHistory() {
-    const container = document.getElementById('dmrHistoryBody');
-    if (!container) return;
-
-    const historyCountEl = document.getElementById('dmrHistoryCount');
-    if (historyCountEl) historyCountEl.textContent = `${dmrCallHistory.length} calls`;
-
-    if (dmrCallHistory.length === 0) {
-        container.innerHTML = '<tr><td colspan="4" style="padding: 10px; text-align: center; color: var(--text-muted);">No calls recorded</td></tr>';
-        return;
-    }
-
-    container.innerHTML = dmrCallHistory.slice(0, 20).map(call => `
-        <tr>
-            <td style="padding: 3px 6px; font-family: var(--font-mono);">${call.time}</td>
-            <td style="padding: 3px 6px; color: var(--accent-green);">${call.talkgroup}</td>
-            <td style="padding: 3px 6px; color: var(--accent-cyan);">${call.source_id}</td>
-            <td style="padding: 3px 6px;">${call.protocol}</td>
-        </tr>
-    `).join('');
-}
-
-// ============== SYNTHESIZER ==============
-
-function initDmrSynthesizer() {
-    dmrSynthCanvas = document.getElementById('dmrSynthCanvas');
-    if (!dmrSynthCanvas) return;
-
-    // Use the canvas element's own rendered size for the backing buffer
-    const rect = dmrSynthCanvas.getBoundingClientRect();
-    const w = Math.round(rect.width) || 600;
-    const h = Math.round(rect.height) || 70;
-    dmrSynthCanvas.width = w;
-    dmrSynthCanvas.height = h;
-
-    dmrSynthCtx = dmrSynthCanvas.getContext('2d');
-
-    dmrSynthBars = [];
-    for (let i = 0; i < DMR_BAR_COUNT; i++) {
-        dmrSynthBars[i] = { height: 2, targetHeight: 2, velocity: 0 };
-    }
-
-    dmrActivityLevel = 0;
-    dmrActivityTarget = 0;
-    dmrEventType = isDmrRunning ? 'idle' : 'stopped';
-    dmrSynthInitialized = true;
-
-    updateDmrSynthStatus();
-
-    if (dmrSynthAnimationId) cancelAnimationFrame(dmrSynthAnimationId);
-    drawDmrSynthesizer();
-}
-
-function drawDmrSynthesizer() {
-    if (!dmrSynthCtx || !dmrSynthCanvas) return;
-
-    const width = dmrSynthCanvas.width;
-    const height = dmrSynthCanvas.height;
-    const barWidth = (width / DMR_BAR_COUNT) - 2;
-    const now = Date.now();
-
-    // Clear canvas
-    dmrSynthCtx.fillStyle = 'rgba(0, 0, 0, 0.3)';
-    dmrSynthCtx.fillRect(0, 0, width, height);
-
-    // Decay activity toward target.  Window must exceed the backend
-    // heartbeat interval (3s) so the status doesn't flip-flop between
-    // LISTENING and IDLE on every heartbeat cycle.
-    const timeSinceEvent = now - dmrLastEventTime;
-    if (timeSinceEvent > 5000) {
-        // No events for 5s — decay target toward idle
-        dmrActivityTarget = Math.max(0, dmrActivityTarget - DMR_DECAY_RATE);
-        if (dmrActivityTarget < 0.1 && dmrEventType !== 'stopped') {
-            dmrEventType = 'idle';
-            updateDmrSynthStatus();
-        }
-    }
-
-    // Smooth approach to target
-    dmrActivityLevel += (dmrActivityTarget - dmrActivityLevel) * 0.08;
-
-    // Determine effective activity (idle breathing when stopped/idle)
-    let effectiveActivity = dmrActivityLevel;
-    if (dmrEventType === 'stopped') {
-        effectiveActivity = 0;
-    } else if (effectiveActivity < 0.1 && isDmrRunning) {
-        // Visible idle breathing — shows decoder is alive and listening
-        effectiveActivity = 0.12 + Math.sin(now / 1000) * 0.06;
-    }
-
-    // Ripple timing for sync events
-    const syncRippleAge = (dmrEventType === 'sync' && timeSinceEvent < 500) ? 1 - (timeSinceEvent / 500) : 0;
-    // Voice ripple overlay
-    const voiceRipple = (dmrEventType === 'voice') ? Math.sin(now / 60) * 0.15 : 0;
-
-    // Update bar targets and physics
-    for (let i = 0; i < DMR_BAR_COUNT; i++) {
-        const time = now / 200;
-        const wave1 = Math.sin(time + i * 0.3) * 0.2;
-        const wave2 = Math.sin(time * 1.7 + i * 0.5) * 0.15;
-        const randomAmount = 0.05 + effectiveActivity * 0.25;
-        const random = (Math.random() - 0.5) * randomAmount;
-
-        // Bell curve — center bars taller
-        const centerDist = Math.abs(i - DMR_BAR_COUNT / 2) / (DMR_BAR_COUNT / 2);
-        const centerBoost = 1 - centerDist * 0.5;
-
-        // Sync ripple: center-outward wave burst
-        let rippleBoost = 0;
-        if (syncRippleAge > 0) {
-            const ripplePos = (1 - syncRippleAge) * DMR_BAR_COUNT / 2;
-            const distFromRipple = Math.abs(i - DMR_BAR_COUNT / 2) - ripplePos;
-            rippleBoost = Math.max(0, 1 - Math.abs(distFromRipple) / 4) * syncRippleAge * 0.4;
-        }
-
-        const baseHeight = 0.1 + effectiveActivity * 0.55;
-        dmrSynthBars[i].targetHeight = Math.max(2,
-            (baseHeight + wave1 + wave2 + random + rippleBoost + voiceRipple) *
-            effectiveActivity * centerBoost * height
-        );
-
-        // Spring physics
-        const springStrength = effectiveActivity > 0.3 ? 0.15 : 0.1;
-        const diff = dmrSynthBars[i].targetHeight - dmrSynthBars[i].height;
-        dmrSynthBars[i].velocity += diff * springStrength;
-        dmrSynthBars[i].velocity *= 0.78;
-        dmrSynthBars[i].height += dmrSynthBars[i].velocity;
-        dmrSynthBars[i].height = Math.max(2, Math.min(height - 4, dmrSynthBars[i].height));
-    }
-
-    // Draw bars
-    for (let i = 0; i < DMR_BAR_COUNT; i++) {
-        const x = i * (barWidth + 2) + 1;
-        const barHeight = dmrSynthBars[i].height;
-        const y = (height - barHeight) / 2;
-
-        // HSL color by event type
-        let hue, saturation, lightness;
-        if (dmrEventType === 'voice' && timeSinceEvent < 3000) {
-            hue = 30;  // Orange
-            saturation = 85;
-            lightness = 40 + (barHeight / height) * 25;
-        } else if (dmrEventType === 'call' && timeSinceEvent < 3000) {
-            hue = 120; // Green
-            saturation = 80;
-            lightness = 35 + (barHeight / height) * 30;
-        } else if (dmrEventType === 'sync' && timeSinceEvent < 2000) {
-            hue = 185; // Cyan
-            saturation = 85;
-            lightness = 38 + (barHeight / height) * 25;
-        } else if (dmrEventType === 'stopped') {
-            hue = 220;
-            saturation = 20;
-            lightness = 18 + (barHeight / height) * 8;
-        } else {
-            // Idle / decayed
-            hue = 210;
-            saturation = 40;
-            lightness = 25 + (barHeight / height) * 15;
-        }
-
-        // Vertical gradient per bar
-        const gradient = dmrSynthCtx.createLinearGradient(x, y, x, y + barHeight);
-        gradient.addColorStop(0, `hsla(${hue}, ${saturation}%, ${lightness + 18}%, 0.85)`);
-        gradient.addColorStop(0.5, `hsla(${hue}, ${saturation}%, ${lightness}%, 1)`);
-        gradient.addColorStop(1, `hsla(${hue}, ${saturation}%, ${lightness + 18}%, 0.85)`);
-
-        dmrSynthCtx.fillStyle = gradient;
-        dmrSynthCtx.fillRect(x, y, barWidth, barHeight);
-
-        // Glow on tall bars
-        if (barHeight > height * 0.5 && effectiveActivity > 0.4) {
-            dmrSynthCtx.shadowColor = `hsla(${hue}, ${saturation}%, 60%, 0.5)`;
-            dmrSynthCtx.shadowBlur = 8;
-            dmrSynthCtx.fillRect(x, y, barWidth, barHeight);
-            dmrSynthCtx.shadowBlur = 0;
-        }
-    }
-
-    // Center line
-    dmrSynthCtx.strokeStyle = 'rgba(0, 212, 255, 0.15)';
-    dmrSynthCtx.lineWidth = 1;
-    dmrSynthCtx.beginPath();
-    dmrSynthCtx.moveTo(0, height / 2);
-    dmrSynthCtx.lineTo(width, height / 2);
-    dmrSynthCtx.stroke();
-
-    dmrSynthAnimationId = requestAnimationFrame(drawDmrSynthesizer);
-}
-
-function dmrSynthPulse(type) {
-    dmrLastEventTime = Date.now();
-
-    if (type === 'sync') {
-        dmrActivityTarget = Math.max(dmrActivityTarget, DMR_BURST_SYNC);
-        dmrEventType = 'sync';
-    } else if (type === 'call') {
-        dmrActivityTarget = DMR_BURST_CALL;
-        dmrEventType = 'call';
-    } else if (type === 'voice') {
-        dmrActivityTarget = DMR_BURST_VOICE;
-        dmrEventType = 'voice';
-    } else if (type === 'slot' || type === 'nac') {
-        dmrActivityTarget = Math.max(dmrActivityTarget, 0.5);
-    } else if (type === 'raw') {
-        // Any DSD output means the decoder is alive and processing
-        dmrActivityTarget = Math.max(dmrActivityTarget, 0.25);
-        if (dmrEventType === 'idle') dmrEventType = 'raw';
-    }
-    // keepalive and status don't change visuals
-
-    updateDmrSynthStatus();
-}
-
-function updateDmrSynthStatus() {
-    const el = document.getElementById('dmrSynthStatus');
-    if (!el) return;
-
-    const labels = {
-        stopped: 'STOPPED',
-        idle: 'IDLE',
-        raw: 'LISTENING',
-        sync: 'SYNC',
-        call: 'CALL',
-        voice: 'VOICE'
-    };
-    const colors = {
-        stopped: 'var(--text-muted)',
-        idle: 'var(--text-muted)',
-        raw: '#607d8b',
-        sync: '#00e5ff',
-        call: '#4caf50',
-        voice: '#ff9800'
-    };
-
-    el.textContent = labels[dmrEventType] || 'IDLE';
-    el.style.color = colors[dmrEventType] || 'var(--text-muted)';
-}
-
-function resizeDmrSynthesizer() {
-    if (!dmrSynthCanvas) return;
-    const rect = dmrSynthCanvas.getBoundingClientRect();
-    if (rect.width > 0) {
-        dmrSynthCanvas.width = Math.round(rect.width);
-        dmrSynthCanvas.height = Math.round(rect.height) || 70;
-    }
-}
-
-function stopDmrSynthesizer() {
-    if (dmrSynthAnimationId) {
-        cancelAnimationFrame(dmrSynthAnimationId);
-        dmrSynthAnimationId = null;
-    }
-}
-
-window.addEventListener('resize', resizeDmrSynthesizer);
-
-// ============== AUDIO ==============
-
-function startDmrAudio() {
-    const audioPlayer = document.getElementById('dmrAudioPlayer');
-    if (!audioPlayer) return;
-    const streamUrl = `/dmr/audio/stream?t=${Date.now()}`;
-    audioPlayer.src = streamUrl;
-    const volSlider = document.getElementById('dmrAudioVolume');
-    if (volSlider) audioPlayer.volume = volSlider.value / 100;
-
-    audioPlayer.onplaying = () => updateDmrAudioStatus('STREAMING');
-    audioPlayer.onerror = () => {
-        // Retry if decoder is still running (stream may have dropped)
-        if (isDmrRunning && dmrHasAudio) {
-            console.warn('[DMR] Audio stream error, retrying in 2s...');
-            updateDmrAudioStatus('RECONNECTING');
-            setTimeout(() => {
-                if (isDmrRunning && dmrHasAudio) startDmrAudio();
-            }, 2000);
-        } else {
-            updateDmrAudioStatus('OFF');
-        }
-    };
-
-    audioPlayer.play().catch(e => {
-        console.warn('[DMR] Audio autoplay blocked:', e);
-        if (typeof showNotification === 'function') {
-            showNotification('Audio Ready', 'Click the page or interact to enable audio playback');
-        }
-    });
-}
-
-function stopDmrAudio() {
-    const audioPlayer = document.getElementById('dmrAudioPlayer');
-    if (audioPlayer) {
-        audioPlayer.pause();
-        audioPlayer.src = '';
-    }
-    dmrHasAudio = false;
-}
-
-function setDmrAudioVolume(value) {
-    const audioPlayer = document.getElementById('dmrAudioPlayer');
-    if (audioPlayer) audioPlayer.volume = value / 100;
-}
-
-function updateDmrAudioStatus(status) {
-    const el = document.getElementById('dmrAudioStatus');
-    if (!el) return;
-    el.textContent = status;
-    const colors = {
-        'OFF': 'var(--text-muted)',
-        'STREAMING': 'var(--accent-green)',
-        'ERROR': 'var(--accent-red)',
-        'UNAVAILABLE': 'var(--text-muted)',
-    };
-    el.style.color = colors[status] || 'var(--text-muted)';
-}
-
-// ============== SETTINGS PERSISTENCE ==============
-
-function restoreDmrSettings() {
-    try {
-        const saved = localStorage.getItem(DMR_SETTINGS_KEY);
-        if (!saved) return;
-        const s = JSON.parse(saved);
-        const freqEl = document.getElementById('dmrFrequency');
-        const protoEl = document.getElementById('dmrProtocol');
-        const gainEl = document.getElementById('dmrGain');
-        const ppmEl = document.getElementById('dmrPPM');
-        const crcEl = document.getElementById('dmrRelaxCrc');
-        if (freqEl && s.frequency != null) freqEl.value = s.frequency;
-        if (protoEl && s.protocol) protoEl.value = s.protocol;
-        if (gainEl && s.gain != null) gainEl.value = s.gain;
-        if (ppmEl && s.ppm != null) ppmEl.value = s.ppm;
-        if (crcEl && s.relaxCrc != null) crcEl.checked = s.relaxCrc;
-    } catch (e) { /* localStorage unavailable */ }
-}
-
-// ============== BOOKMARKS ==============
-
-function loadDmrBookmarks() {
-    try {
-        const saved = localStorage.getItem(DMR_BOOKMARKS_KEY);
-        const parsed = saved ? JSON.parse(saved) : [];
-        if (!Array.isArray(parsed)) {
-            dmrBookmarks = [];
-        } else {
-            dmrBookmarks = parsed
-                .map((entry) => {
-                    const freq = Number(entry?.freq);
-                    if (!Number.isFinite(freq) || freq <= 0) return null;
-                    const protocol = sanitizeDmrBookmarkProtocol(entry?.protocol);
-                    const rawLabel = String(entry?.label || '').trim();
-                    const label = rawLabel || `${freq.toFixed(4)} MHz`;
-                    return {
-                        freq,
-                        protocol,
-                        label,
-                        added: entry?.added,
-                    };
-                })
-                .filter(Boolean);
-        }
-    } catch (e) {
-        dmrBookmarks = [];
-    }
-    renderDmrBookmarks();
-}
-
-function saveDmrBookmarks() {
-    try {
-        localStorage.setItem(DMR_BOOKMARKS_KEY, JSON.stringify(dmrBookmarks));
-    } catch (e) { /* localStorage unavailable */ }
-}
-
-function sanitizeDmrBookmarkProtocol(protocol) {
-    const value = String(protocol || 'auto').toLowerCase();
-    return DMR_BOOKMARK_PROTOCOLS.has(value) ? value : 'auto';
-}
-
-function addDmrBookmark() {
-    const freqInput = document.getElementById('dmrBookmarkFreq');
-    const labelInput = document.getElementById('dmrBookmarkLabel');
-    if (!freqInput) return;
-
-    const freq = parseFloat(freqInput.value);
-    if (isNaN(freq) || freq <= 0) {
-        if (typeof showNotification === 'function') {
-            showNotification('Invalid Frequency', 'Enter a valid frequency');
-        }
-        return;
-    }
-
-    const protocol = sanitizeDmrBookmarkProtocol(document.getElementById('dmrProtocol')?.value || 'auto');
-    const label = (labelInput?.value || '').trim() || `${freq.toFixed(4)} MHz`;
-
-    // Duplicate check
-    if (dmrBookmarks.some(b => b.freq === freq && b.protocol === protocol)) {
-        if (typeof showNotification === 'function') {
-            showNotification('Duplicate', 'This frequency/protocol is already bookmarked');
-        }
-        return;
-    }
-
-    dmrBookmarks.push({ freq, protocol, label, added: new Date().toISOString() });
-    saveDmrBookmarks();
-    renderDmrBookmarks();
-    freqInput.value = '';
-    if (labelInput) labelInput.value = '';
-
-    if (typeof showNotification === 'function') {
-        showNotification('Bookmark Added', `${freq.toFixed(4)} MHz saved`);
-    }
-}
-
-function addCurrentDmrFreqBookmark() {
-    const freqEl = document.getElementById('dmrFrequency');
-    const freqInput = document.getElementById('dmrBookmarkFreq');
-    if (freqEl && freqInput) {
-        freqInput.value = freqEl.value;
-    }
-    addDmrBookmark();
-}
-
-function removeDmrBookmark(index) {
-    dmrBookmarks.splice(index, 1);
-    saveDmrBookmarks();
-    renderDmrBookmarks();
-}
-
-function dmrQuickTune(freq, protocol) {
-    const freqEl = document.getElementById('dmrFrequency');
-    const protoEl = document.getElementById('dmrProtocol');
-    if (freqEl && Number.isFinite(freq)) freqEl.value = freq;
-    if (protoEl) protoEl.value = sanitizeDmrBookmarkProtocol(protocol);
-}
-
-function renderDmrBookmarks() {
-    const container = document.getElementById('dmrBookmarksList');
-    if (!container) return;
-
-    container.replaceChildren();
-
-    if (dmrBookmarks.length === 0) {
-        const emptyEl = document.createElement('div');
-        emptyEl.style.color = 'var(--text-muted)';
-        emptyEl.style.textAlign = 'center';
-        emptyEl.style.padding = '10px';
-        emptyEl.style.fontSize = '11px';
-        emptyEl.textContent = 'No bookmarks saved';
-        container.appendChild(emptyEl);
-        return;
-    }
-
-    dmrBookmarks.forEach((b, i) => {
-        const row = document.createElement('div');
-        row.style.display = 'flex';
-        row.style.justifyContent = 'space-between';
-        row.style.alignItems = 'center';
-        row.style.padding = '4px 6px';
-        row.style.background = 'rgba(0,0,0,0.2)';
-        row.style.borderRadius = '3px';
-        row.style.marginBottom = '3px';
-
-        const tuneBtn = document.createElement('button');
-        tuneBtn.type = 'button';
-        tuneBtn.style.cursor = 'pointer';
-        tuneBtn.style.color = 'var(--accent-cyan)';
-        tuneBtn.style.fontSize = '11px';
-        tuneBtn.style.flex = '1';
-        tuneBtn.style.background = 'none';
-        tuneBtn.style.border = 'none';
-        tuneBtn.style.textAlign = 'left';
-        tuneBtn.style.padding = '0';
-        tuneBtn.textContent = b.label;
-        tuneBtn.title = `${b.freq.toFixed(4)} MHz (${b.protocol.toUpperCase()})`;
-        tuneBtn.addEventListener('click', () => dmrQuickTune(b.freq, b.protocol));
-
-        const protocolEl = document.createElement('span');
-        protocolEl.style.color = 'var(--text-muted)';
-        protocolEl.style.fontSize = '9px';
-        protocolEl.style.margin = '0 6px';
-        protocolEl.textContent = b.protocol.toUpperCase();
-
-        const deleteBtn = document.createElement('button');
-        deleteBtn.type = 'button';
-        deleteBtn.style.background = 'none';
-        deleteBtn.style.border = 'none';
-        deleteBtn.style.color = 'var(--accent-red)';
-        deleteBtn.style.cursor = 'pointer';
-        deleteBtn.style.fontSize = '12px';
-        deleteBtn.style.padding = '0 4px';
-        deleteBtn.textContent = '\u00d7';
-        deleteBtn.addEventListener('click', () => removeDmrBookmark(i));
-
-        row.appendChild(tuneBtn);
-        row.appendChild(protocolEl);
-        row.appendChild(deleteBtn);
-        container.appendChild(row);
-    });
-}
-
-// ============== STATUS SYNC ==============
-
-function checkDmrStatus() {
-    fetch('/dmr/status')
-        .then(r => r.json())
-        .then(data => {
-            if (data.running && !isDmrRunning) {
-                // Backend is running but frontend lost track — resync
-                isDmrRunning = true;
-                updateDmrUI();
-                connectDmrSSE();
-                if (!dmrSynthInitialized) initDmrSynthesizer();
-                dmrEventType = 'idle';
-                dmrActivityTarget = 0.1;
-                dmrLastEventTime = Date.now();
-                updateDmrSynthStatus();
-                const statusEl = document.getElementById('dmrStatus');
-                if (statusEl) statusEl.textContent = 'DECODING';
-            } else if (!data.running && isDmrRunning) {
-                // Backend stopped but frontend didn't know
-                isDmrRunning = false;
-                if (dmrEventSource) { dmrEventSource.close(); dmrEventSource = null; }
-                updateDmrUI();
-                dmrEventType = 'stopped';
-                dmrActivityTarget = 0;
-                updateDmrSynthStatus();
-                const statusEl = document.getElementById('dmrStatus');
-                if (statusEl) statusEl.textContent = 'STOPPED';
-            }
-        })
-        .catch(() => {});
-}
-
-// ============== INIT ==============
-
-document.addEventListener('DOMContentLoaded', () => {
-    restoreDmrSettings();
-    loadDmrBookmarks();
-});
-
-// ============== EXPORTS ==============
-
-window.startDmr = startDmr;
-window.stopDmr = stopDmr;
-window.checkDmrTools = checkDmrTools;
-window.checkDmrStatus = checkDmrStatus;
-window.initDmrSynthesizer = initDmrSynthesizer;
-window.setDmrAudioVolume = setDmrAudioVolume;
-window.addDmrBookmark = addDmrBookmark;
-window.addCurrentDmrFreqBookmark = addCurrentDmrFreqBookmark;
-window.removeDmrBookmark = removeDmrBookmark;
-window.dmrQuickTune = dmrQuickTune;

static/js/modes/meshtastic.js

@@ -2295,7 +2295,8 @@ const Meshtastic = (function() {
         // Store & Forward
         showStoreForwardModal,
         requestStoreForward,
-        closeStoreForwardModal
+        closeStoreForwardModal,
+        destroy
     };
 
     /**
@@ -2306,6 +2307,13 @@ const Meshtastic = (function() {
             setTimeout(() => meshMap.invalidateSize(), 100);
         }
     }
+
+    /**
+     * Destroy — tear down SSE, timers, and event listeners for clean mode switching.
+     */
+    function destroy() {
+        stopStream();
+    }
 })();
 
 // Initialize when DOM is ready (will be called by selectMode)

static/js/modes/spy-stations.js

@@ -269,12 +269,10 @@ const SpyStations = (function() {
      */
     function tuneToStation(stationId, freqKhz) {
         const freqMhz = freqKhz / 1000;
-        sessionStorage.setItem('tuneFrequency', freqMhz.toString());
 
         // Find the station and determine mode
         const station = stations.find(s => s.id === stationId);
         const tuneMode = station ? getModeFromStation(station.mode) : 'usb';
-        sessionStorage.setItem('tuneMode', tuneMode);
 
         const stationName = station ? station.name : 'Station';
 
@@ -282,12 +280,18 @@ const SpyStations = (function() {
             showNotification('Tuning to ' + stationName, formatFrequency(freqKhz) + ' (' + tuneMode.toUpperCase() + ')');
         }
 
-        // Switch to listening post mode
+        // Switch to spectrum waterfall mode and tune after mode init.
-        if (typeof selectMode === 'function') {
+        if (typeof switchMode === 'function') {
-            selectMode('listening');
+            switchMode('waterfall');
-        } else if (typeof switchMode === 'function') {
+        } else if (typeof selectMode === 'function') {
-            switchMode('listening');
+            selectMode('waterfall');
         }
+
+        setTimeout(() => {
+            if (typeof Waterfall !== 'undefined' && typeof Waterfall.quickTune === 'function') {
+                Waterfall.quickTune(freqMhz, tuneMode);
+            }
+        }, 220);
     }
 
     /**
@@ -305,7 +309,7 @@ const SpyStations = (function() {
      * Check if we arrived from another page with a tune request
      */
     function checkTuneFrequency() {
-        // This is for the listening post to check - spy stations sets, listening post reads
+        // Reserved for cross-mode tune handoff behavior.
     }
 
     /**
@@ -445,7 +449,7 @@ const SpyStations = (function() {
                     <div class="signal-details-section">
                         <div class="signal-details-title">How to Listen</div>
                         <p style="color: var(--text-secondary); font-size: 12px; line-height: 1.6;">
-                            Click "Tune In" on any station to open the Listening Post with the frequency pre-configured.
+                            Click "Tune In" on any station to open Spectrum Waterfall with the frequency pre-configured.
                             Most number stations use USB (Upper Sideband) mode. You'll need an SDR capable of receiving
                             HF frequencies (typically 3-30 MHz) and an appropriate antenna.
                         </p>
@@ -511,6 +515,13 @@ const SpyStations = (function() {
         }
     }
 
+    /**
+     * Destroy — no-op placeholder for consistent lifecycle interface.
+     */
+    function destroy() {
+        // SpyStations has no background timers or streams to clean up.
+    }
+
     // Public API
     return {
         init,
@@ -520,7 +531,8 @@ const SpyStations = (function() {
         showDetails,
         closeDetails,
         showHelp,
-        closeHelp
+        closeHelp,
+        destroy
     };
 })();
 

static/js/modes/sstv-general.js

@@ -15,13 +15,21 @@ const SSTVGeneral = (function() {
     let sstvGeneralScopeCtx = null;
     let sstvGeneralScopeAnim = null;
     let sstvGeneralScopeHistory = [];
+    let sstvGeneralScopeWaveBuffer = [];
+    let sstvGeneralScopeDisplayWave = [];
     const SSTV_GENERAL_SCOPE_LEN = 200;
+    const SSTV_GENERAL_SCOPE_WAVE_BUFFER_LEN = 2048;
+    const SSTV_GENERAL_SCOPE_WAVE_INPUT_SMOOTH_ALPHA = 0.55;
+    const SSTV_GENERAL_SCOPE_WAVE_DISPLAY_SMOOTH_ALPHA = 0.22;
+    const SSTV_GENERAL_SCOPE_WAVE_IDLE_DECAY = 0.96;
     let sstvGeneralScopeRms = 0;
     let sstvGeneralScopePeak = 0;
     let sstvGeneralScopeTargetRms = 0;
     let sstvGeneralScopeTargetPeak = 0;
     let sstvGeneralScopeMsgBurst = 0;
     let sstvGeneralScopeTone = null;
+    let sstvGeneralScopeLastWaveAt = 0;
+    let sstvGeneralScopeLastInputSample = 0;
 
     /**
      * Initialize the SSTV General mode
@@ -205,20 +213,64 @@ const SSTVGeneral = (function() {
     /**
      * Initialize signal scope canvas
      */
+    function resizeSstvGeneralScopeCanvas(canvas) {
+        if (!canvas) return;
+        const rect = canvas.getBoundingClientRect();
+        const dpr = window.devicePixelRatio || 1;
+        const width = Math.max(1, Math.floor(rect.width * dpr));
+        const height = Math.max(1, Math.floor(rect.height * dpr));
+        if (canvas.width !== width || canvas.height !== height) {
+            canvas.width = width;
+            canvas.height = height;
+        }
+    }
+
+    function applySstvGeneralScopeData(scopeData) {
+        if (!scopeData || typeof scopeData !== 'object') return;
+
+        sstvGeneralScopeTargetRms = Number(scopeData.rms) || 0;
+        sstvGeneralScopeTargetPeak = Number(scopeData.peak) || 0;
+        if (scopeData.tone !== undefined) {
+            sstvGeneralScopeTone = scopeData.tone;
+        }
+
+        if (Array.isArray(scopeData.waveform) && scopeData.waveform.length) {
+            for (const packedSample of scopeData.waveform) {
+                const sample = Number(packedSample);
+                if (!Number.isFinite(sample)) continue;
+                const normalized = Math.max(-127, Math.min(127, sample)) / 127;
+                sstvGeneralScopeLastInputSample += (normalized - sstvGeneralScopeLastInputSample) * SSTV_GENERAL_SCOPE_WAVE_INPUT_SMOOTH_ALPHA;
+                sstvGeneralScopeWaveBuffer.push(sstvGeneralScopeLastInputSample);
+            }
+            if (sstvGeneralScopeWaveBuffer.length > SSTV_GENERAL_SCOPE_WAVE_BUFFER_LEN) {
+                sstvGeneralScopeWaveBuffer.splice(0, sstvGeneralScopeWaveBuffer.length - SSTV_GENERAL_SCOPE_WAVE_BUFFER_LEN);
+            }
+            sstvGeneralScopeLastWaveAt = performance.now();
+        }
+    }
+
     function initSstvGeneralScope() {
         const canvas = document.getElementById('sstvGeneralScopeCanvas');
         if (!canvas) return;
-        const rect = canvas.getBoundingClientRect();
+
-        canvas.width = rect.width * (window.devicePixelRatio || 1);
+        if (sstvGeneralScopeAnim) {
-        canvas.height = rect.height * (window.devicePixelRatio || 1);
+            cancelAnimationFrame(sstvGeneralScopeAnim);
+            sstvGeneralScopeAnim = null;
+        }
+
+        resizeSstvGeneralScopeCanvas(canvas);
         sstvGeneralScopeCtx = canvas.getContext('2d');
         sstvGeneralScopeHistory = new Array(SSTV_GENERAL_SCOPE_LEN).fill(0);
+        sstvGeneralScopeWaveBuffer = [];
+        sstvGeneralScopeDisplayWave = [];
         sstvGeneralScopeRms = 0;
         sstvGeneralScopePeak = 0;
         sstvGeneralScopeTargetRms = 0;
         sstvGeneralScopeTargetPeak = 0;
         sstvGeneralScopeMsgBurst = 0;
         sstvGeneralScopeTone = null;
+        sstvGeneralScopeLastWaveAt = 0;
+        sstvGeneralScopeLastInputSample = 0;
         drawSstvGeneralScope();
     }
 
@@ -228,12 +280,14 @@ const SSTVGeneral = (function() {
     function drawSstvGeneralScope() {
         const ctx = sstvGeneralScopeCtx;
         if (!ctx) return;
+
+        resizeSstvGeneralScopeCanvas(ctx.canvas);
         const W = ctx.canvas.width;
         const H = ctx.canvas.height;
         const midY = H / 2;
 
         // Phosphor persistence
-        ctx.fillStyle = 'rgba(5, 5, 16, 0.3)';
+        ctx.fillStyle = 'rgba(5, 5, 16, 0.26)';
         ctx.fillRect(0, 0, W, H);
 
         // Smooth towards target
@@ -256,32 +310,84 @@ const SSTVGeneral = (function() {
             ctx.beginPath(); ctx.moveTo(x, 0); ctx.lineTo(x, H); ctx.stroke();
         }
 
-        // Waveform
+        // Envelope
-        const stepX = W / (SSTV_GENERAL_SCOPE_LEN - 1);
+        const envStepX = W / (SSTV_GENERAL_SCOPE_LEN - 1);
-        ctx.strokeStyle = '#c080ff';
+        ctx.strokeStyle = 'rgba(168, 110, 255, 0.45)';
-        ctx.lineWidth = 1.5;
+        ctx.lineWidth = 1;
-        ctx.shadowColor = '#c080ff';
-        ctx.shadowBlur = 4;
-
-        // Upper half
         ctx.beginPath();
         for (let i = 0; i < sstvGeneralScopeHistory.length; i++) {
-            const x = i * stepX;
+            const x = i * envStepX;
-            const amp = sstvGeneralScopeHistory[i] * midY * 0.9;
+            const amp = sstvGeneralScopeHistory[i] * midY * 0.85;
             const y = midY - amp;
             if (i === 0) ctx.moveTo(x, y); else ctx.lineTo(x, y);
         }
         ctx.stroke();
-
-        // Lower half (mirror)
         ctx.beginPath();
         for (let i = 0; i < sstvGeneralScopeHistory.length; i++) {
-            const x = i * stepX;
+            const x = i * envStepX;
-            const amp = sstvGeneralScopeHistory[i] * midY * 0.9;
+            const amp = sstvGeneralScopeHistory[i] * midY * 0.85;
             const y = midY + amp;
             if (i === 0) ctx.moveTo(x, y); else ctx.lineTo(x, y);
         }
         ctx.stroke();
+
+        // Actual waveform trace
+        const waveformPointCount = Math.min(Math.max(120, Math.floor(W / 3.2)), 420);
+        if (sstvGeneralScopeWaveBuffer.length > 1) {
+            const waveIsFresh = (performance.now() - sstvGeneralScopeLastWaveAt) < 1000;
+            const sourceLen = sstvGeneralScopeWaveBuffer.length;
+            const sourceWindow = Math.min(sourceLen, 1536);
+            const sourceStart = sourceLen - sourceWindow;
+
+            if (sstvGeneralScopeDisplayWave.length !== waveformPointCount) {
+                sstvGeneralScopeDisplayWave = new Array(waveformPointCount).fill(0);
+            }
+
+            for (let i = 0; i < waveformPointCount; i++) {
+                const a = sourceStart + Math.floor((i / waveformPointCount) * sourceWindow);
+                const b = sourceStart + Math.floor(((i + 1) / waveformPointCount) * sourceWindow);
+                const start = Math.max(sourceStart, Math.min(sourceLen - 1, a));
+                const end = Math.max(start + 1, Math.min(sourceLen, b));
+
+                let sum = 0;
+                let count = 0;
+                for (let j = start; j < end; j++) {
+                    sum += sstvGeneralScopeWaveBuffer[j];
+                    count++;
+                }
+                const targetSample = count > 0 ? (sum / count) : 0;
+                sstvGeneralScopeDisplayWave[i] += (targetSample - sstvGeneralScopeDisplayWave[i]) * SSTV_GENERAL_SCOPE_WAVE_DISPLAY_SMOOTH_ALPHA;
+            }
+
+            ctx.strokeStyle = waveIsFresh ? '#c080ff' : 'rgba(192, 128, 255, 0.45)';
+            ctx.lineWidth = 1.7;
+            ctx.shadowColor = '#c080ff';
+            ctx.shadowBlur = waveIsFresh ? 6 : 2;
+
+            const stepX = waveformPointCount > 1 ? (W / (waveformPointCount - 1)) : W;
+            ctx.beginPath();
+            const firstY = midY - (sstvGeneralScopeDisplayWave[0] * midY * 0.9);
+            ctx.moveTo(0, firstY);
+            for (let i = 1; i < waveformPointCount - 1; i++) {
+                const x = i * stepX;
+                const y = midY - (sstvGeneralScopeDisplayWave[i] * midY * 0.9);
+                const nx = (i + 1) * stepX;
+                const ny = midY - (sstvGeneralScopeDisplayWave[i + 1] * midY * 0.9);
+                const cx = (x + nx) / 2;
+                const cy = (y + ny) / 2;
+                ctx.quadraticCurveTo(x, y, cx, cy);
+            }
+            const lastX = (waveformPointCount - 1) * stepX;
+            const lastY = midY - (sstvGeneralScopeDisplayWave[waveformPointCount - 1] * midY * 0.9);
+            ctx.lineTo(lastX, lastY);
+            ctx.stroke();
+
+            if (!waveIsFresh) {
+                for (let i = 0; i < sstvGeneralScopeDisplayWave.length; i++) {
+                    sstvGeneralScopeDisplayWave[i] *= SSTV_GENERAL_SCOPE_WAVE_IDLE_DECAY;
+                }
+            }
+        }
         ctx.shadowBlur = 0;
 
         // Peak indicator
@@ -317,8 +423,17 @@ const SSTVGeneral = (function() {
             else { toneLabel.textContent = 'QUIET'; toneLabel.style.color = '#444'; }
         }
         if (statusLabel) {
-            if (sstvGeneralScopeRms > 500) { statusLabel.textContent = 'SIGNAL'; statusLabel.style.color = '#0f0'; }
+            const waveIsFresh = (performance.now() - sstvGeneralScopeLastWaveAt) < 1000;
-            else { statusLabel.textContent = 'MONITORING'; statusLabel.style.color = '#555'; }
+            if (sstvGeneralScopeRms > 900 && waveIsFresh) {
+                statusLabel.textContent = 'DEMODULATING';
+                statusLabel.style.color = '#c080ff';
+            } else if (sstvGeneralScopeRms > 500) {
+                statusLabel.textContent = 'CARRIER';
+                statusLabel.style.color = '#e0b8ff';
+            } else {
+                statusLabel.textContent = 'QUIET';
+                statusLabel.style.color = '#555';
+            }
         }
 
         sstvGeneralScopeAnim = requestAnimationFrame(drawSstvGeneralScope);
@@ -330,6 +445,11 @@ const SSTVGeneral = (function() {
     function stopSstvGeneralScope() {
         if (sstvGeneralScopeAnim) { cancelAnimationFrame(sstvGeneralScopeAnim); sstvGeneralScopeAnim = null; }
         sstvGeneralScopeCtx = null;
+        sstvGeneralScopeWaveBuffer = [];
+        sstvGeneralScopeDisplayWave = [];
+        sstvGeneralScopeHistory = [];
+        sstvGeneralScopeLastWaveAt = 0;
+        sstvGeneralScopeLastInputSample = 0;
     }
 
     /**
@@ -353,9 +473,7 @@ const SSTVGeneral = (function() {
                 if (data.type === 'sstv_progress') {
                     handleProgress(data);
                 } else if (data.type === 'sstv_scope') {
-                    sstvGeneralScopeTargetRms = data.rms;
+                    applySstvGeneralScopeData(data);
-                    sstvGeneralScopeTargetPeak = data.peak;
-                    if (data.tone !== undefined) sstvGeneralScopeTone = data.tone;
                 }
             } catch (err) {
                 console.error('Failed to parse SSE message:', err);
@@ -740,6 +858,13 @@ const SSTVGeneral = (function() {
         }
     }
 
+    /**
+     * Destroy — close SSE stream and stop scope animation for clean mode switching.
+     */
+    function destroy() {
+        stopStream();
+    }
+
     // Public API
     return {
         init,
@@ -751,6 +876,7 @@ const SSTVGeneral = (function() {
         deleteImage,
         deleteAllImages,
         downloadImage,
-        selectPreset
+        selectPreset,
+        destroy
     };
 })();

static/js/modes/sstv.js

@@ -1373,8 +1373,21 @@ const SSTV = (function() {
         updateTLE,
         stopIssTracking,
         stopCountdown,
-        invalidateMap
+        invalidateMap,
+        destroy
     };
+
+    /**
+     * Destroy — close SSE stream and clear ISS tracking/countdown timers for clean mode switching.
+     */
+    function destroy() {
+        if (eventSource) {
+            eventSource.close();
+            eventSource = null;
+        }
+        stopIssTracking();
+        stopCountdown();
+    }
 })();
 
 // Initialize when DOM is ready (will be called by selectMode)

static/js/modes/system.js

@@ -0,0 +1,904 @@
+/**
+ * System Health – Enhanced Dashboard IIFE module
+ *
+ * Streams real-time system metrics via SSE with rich visualizations:
+ * SVG arc gauge, per-core bars, temperature sparkline, network bandwidth,
+ * disk I/O, 3D globe, weather, and process grid.
+ */
+const SystemHealth = (function () {
+    'use strict';
+
+    let eventSource = null;
+    let connected = false;
+    let lastMetrics = null;
+
+    // Temperature sparkline ring buffer (last 20 readings)
+    const SPARKLINE_SIZE = 20;
+    let tempHistory = [];
+
+    // Network I/O delta tracking
+    let prevNetIo = null;
+    let prevNetTimestamp = null;
+
+    // Disk I/O delta tracking
+    let prevDiskIo = null;
+    let prevDiskTimestamp = null;
+
+    // Location & weather state
+    let locationData = null;
+    let weatherData = null;
+    let weatherTimer = null;
+    let globeInstance = null;
+    let globeDestroyed = false;
+
+    const GLOBE_SCRIPT_URL = 'https://cdn.jsdelivr.net/npm/globe.gl@2.33.1/dist/globe.gl.min.js';
+    const GLOBE_TEXTURE_URL = '/static/images/globe/earth-dark.jpg';
+
+    // -----------------------------------------------------------------------
+    // Helpers
+    // -----------------------------------------------------------------------
+
+    function formatBytes(bytes) {
+        if (bytes == null) return '--';
+        var units = ['B', 'KB', 'MB', 'GB', 'TB'];
+        var i = 0;
+        var val = bytes;
+        while (val >= 1024 && i < units.length - 1) { val /= 1024; i++; }
+        return val.toFixed(1) + ' ' + units[i];
+    }
+
+    function formatRate(bytesPerSec) {
+        if (bytesPerSec == null) return '--';
+        return formatBytes(bytesPerSec) + '/s';
+    }
+
+    function barClass(pct) {
+        if (pct >= 85) return 'crit';
+        if (pct >= 60) return 'warn';
+        return 'ok';
+    }
+
+    function barHtml(pct, label) {
+        if (pct == null) return '<span class="sys-metric-na">N/A</span>';
+        var cls = barClass(pct);
+        var rounded = Math.round(pct);
+        return '<div class="sys-metric-bar-wrap">' +
+            (label ? '<span class="sys-metric-bar-label">' + label + '</span>' : '') +
+            '<div class="sys-metric-bar"><div class="sys-metric-bar-fill ' + cls + '" style="width:' + rounded + '%"></div></div>' +
+            '<span class="sys-metric-bar-value">' + rounded + '%</span>' +
+            '</div>';
+    }
+
+    function escHtml(s) {
+        var d = document.createElement('div');
+        d.textContent = s;
+        return d.innerHTML;
+    }
+
+    // -----------------------------------------------------------------------
+    // SVG Arc Gauge
+    // -----------------------------------------------------------------------
+
+    function arcGaugeSvg(pct) {
+        var radius = 36;
+        var cx = 45, cy = 45;
+        var startAngle = -225;
+        var endAngle = 45;
+        var totalAngle = endAngle - startAngle; // 270 degrees
+        var fillAngle = startAngle + (totalAngle * Math.min(pct, 100) / 100);
+
+        function polarToCart(angle) {
+            var r = angle * Math.PI / 180;
+            return { x: cx + radius * Math.cos(r), y: cy + radius * Math.sin(r) };
+        }
+
+        var bgStart = polarToCart(startAngle);
+        var bgEnd = polarToCart(endAngle);
+        var fillEnd = polarToCart(fillAngle);
+        var largeArcBg = totalAngle > 180 ? 1 : 0;
+        var fillArc = (fillAngle - startAngle) > 180 ? 1 : 0;
+        var cls = barClass(pct);
+
+        return '<svg viewBox="0 0 90 90">' +
+            '<path class="arc-bg" d="M ' + bgStart.x + ' ' + bgStart.y +
+            ' A ' + radius + ' ' + radius + ' 0 ' + largeArcBg + ' 1 ' + bgEnd.x + ' ' + bgEnd.y + '"/>' +
+            '<path class="arc-fill ' + cls + '" d="M ' + bgStart.x + ' ' + bgStart.y +
+            ' A ' + radius + ' ' + radius + ' 0 ' + fillArc + ' 1 ' + fillEnd.x + ' ' + fillEnd.y + '"/>' +
+            '</svg>';
+    }
+
+    // -----------------------------------------------------------------------
+    // Temperature Sparkline
+    // -----------------------------------------------------------------------
+
+    function sparklineSvg(values) {
+        if (!values || values.length < 2) return '';
+        var w = 200, h = 40;
+        var min = Math.min.apply(null, values);
+        var max = Math.max.apply(null, values);
+        var range = max - min || 1;
+        var step = w / (values.length - 1);
+
+        var points = values.map(function (v, i) {
+            var x = Math.round(i * step);
+            var y = Math.round(h - ((v - min) / range) * (h - 4) - 2);
+            return x + ',' + y;
+        });
+
+        var areaPoints = points.join(' ') + ' ' + w + ',' + h + ' 0,' + h;
+
+        return '<svg viewBox="0 0 ' + w + ' ' + h + '" preserveAspectRatio="none">' +
+            '<defs><linearGradient id="sparkGradient" x1="0" y1="0" x2="0" y2="1">' +
+            '<stop offset="0%" stop-color="var(--accent-cyan, #00d4ff)" stop-opacity="0.3"/>' +
+            '<stop offset="100%" stop-color="var(--accent-cyan, #00d4ff)" stop-opacity="0.0"/>' +
+            '</linearGradient></defs>' +
+            '<polygon class="sys-sparkline-area" points="' + areaPoints + '"/>' +
+            '<polyline class="sys-sparkline-line" points="' + points.join(' ') + '"/>' +
+            '</svg>';
+    }
+
+    // -----------------------------------------------------------------------
+    // Rendering — CPU Card
+    // -----------------------------------------------------------------------
+
+    function renderCpuCard(m) {
+        var el = document.getElementById('sysCardCpu');
+        if (!el) return;
+        var cpu = m.cpu;
+        if (!cpu) { el.innerHTML = '<div class="sys-card-body"><span class="sys-metric-na">psutil not available</span></div>'; return; }
+
+        var pct = Math.round(cpu.percent);
+        var coreHtml = '';
+        if (cpu.per_core && cpu.per_core.length) {
+            coreHtml = '<div class="sys-core-bars">';
+            cpu.per_core.forEach(function (c) {
+                var cls = barClass(c);
+                var h = Math.max(3, Math.round(c / 100 * 48));
+                coreHtml += '<div class="sys-core-bar"><div class="sys-core-bar-fill ' + cls +
+                    '" style="height:' + h + 'px;background:var(--accent-' +
+                    (cls === 'ok' ? 'green' : cls === 'warn' ? 'yellow' : 'red') +
+                    ', #00ff88)"></div></div>';
+            });
+            coreHtml += '</div>';
+        }
+
+        var freqHtml = '';
+        if (cpu.freq) {
+            var freqGhz = (cpu.freq.current / 1000).toFixed(2);
+            freqHtml = '<div class="sys-card-detail">Freq: ' + freqGhz + ' GHz</div>';
+        }
+
+        el.innerHTML =
+            '<div class="sys-card-header">CPU</div>' +
+            '<div class="sys-card-body">' +
+            '<div class="sys-gauge-wrap">' +
+            '<div class="sys-gauge-arc">' + arcGaugeSvg(pct) +
+            '<div class="sys-gauge-label">' + pct + '%</div></div>' +
+            '<div class="sys-gauge-details">' +
+            '<div class="sys-card-detail">Load: ' + cpu.load_1 + ' / ' + cpu.load_5 + ' / ' + cpu.load_15 + '</div>' +
+            '<div class="sys-card-detail">Cores: ' + cpu.count + '</div>' +
+            freqHtml +
+            '</div></div>' +
+            coreHtml +
+            '</div>';
+    }
+
+    // -----------------------------------------------------------------------
+    // Memory Card
+    // -----------------------------------------------------------------------
+
+    function renderMemoryCard(m) {
+        var el = document.getElementById('sysCardMemory');
+        if (!el) return;
+        var mem = m.memory;
+        if (!mem) { el.innerHTML = '<div class="sys-card-body"><span class="sys-metric-na">N/A</span></div>'; return; }
+        var swap = m.swap || {};
+        el.innerHTML =
+            '<div class="sys-card-header">Memory</div>' +
+            '<div class="sys-card-body">' +
+            barHtml(mem.percent, 'RAM') +
+            '<div class="sys-card-detail">' + formatBytes(mem.used) + ' / ' + formatBytes(mem.total) + '</div>' +
+            (swap.total > 0 ? barHtml(swap.percent, 'Swap') +
+                '<div class="sys-card-detail">' + formatBytes(swap.used) + ' / ' + formatBytes(swap.total) + '</div>' : '') +
+            '</div>';
+    }
+
+    // -----------------------------------------------------------------------
+    // Temperature & Power Card
+    // -----------------------------------------------------------------------
+
+    function _extractPrimaryTemp(temps) {
+        if (!temps) return null;
+        var preferred = ['cpu_thermal', 'coretemp', 'k10temp', 'acpitz', 'soc_thermal'];
+        for (var i = 0; i < preferred.length; i++) {
+            if (temps[preferred[i]] && temps[preferred[i]].length) return temps[preferred[i]][0];
+        }
+        for (var key in temps) {
+            if (temps[key] && temps[key].length) return temps[key][0];
+        }
+        return null;
+    }
+
+    function renderTempCard(m) {
+        var el = document.getElementById('sysCardTemp');
+        if (!el) return;
+
+        var temp = _extractPrimaryTemp(m.temperatures);
+        var html = '<div class="sys-card-header">Temperature &amp; Power</div><div class="sys-card-body">';
+
+        if (temp) {
+            // Update sparkline history
+            tempHistory.push(temp.current);
+            if (tempHistory.length > SPARKLINE_SIZE) tempHistory.shift();
+
+            html += '<div class="sys-temp-big">' + Math.round(temp.current) + '&deg;C</div>';
+            html += '<div class="sys-sparkline-wrap">' + sparklineSvg(tempHistory) + '</div>';
+
+            // Additional sensors
+            if (m.temperatures) {
+                for (var chip in m.temperatures) {
+                    m.temperatures[chip].forEach(function (s) {
+                        html += '<div class="sys-card-detail">' + escHtml(s.label) + ': ' + Math.round(s.current) + '&deg;C</div>';
+                    });
+                }
+            }
+        } else {
+            html += '<span class="sys-metric-na">No temperature sensors</span>';
+        }
+
+        // Fans
+        if (m.fans) {
+            for (var fChip in m.fans) {
+                m.fans[fChip].forEach(function (f) {
+                    html += '<div class="sys-card-detail">Fan ' + escHtml(f.label) + ': ' + f.current + ' RPM</div>';
+                });
+            }
+        }
+
+        // Battery
+        if (m.battery) {
+            html += '<div class="sys-card-detail" style="margin-top:8px">' +
+                'Battery: ' + Math.round(m.battery.percent) + '%' +
+                (m.battery.plugged ? ' (plugged)' : '') + '</div>';
+        }
+
+        // Throttle flags (Pi)
+        if (m.power && m.power.throttled) {
+            html += '<div class="sys-card-detail" style="color:var(--accent-yellow,#ffcc00)">Throttle: 0x' + m.power.throttled + '</div>';
+        }
+
+        // Power draw
+        if (m.power && m.power.draw_watts != null) {
+            html += '<div class="sys-card-detail">Power: ' + m.power.draw_watts + ' W</div>';
+        }
+
+        html += '</div>';
+        el.innerHTML = html;
+    }
+
+    // -----------------------------------------------------------------------
+    // Disk Card
+    // -----------------------------------------------------------------------
+
+    function renderDiskCard(m) {
+        var el = document.getElementById('sysCardDisk');
+        if (!el) return;
+        var disk = m.disk;
+        if (!disk) { el.innerHTML = '<div class="sys-card-header">Disk &amp; Storage</div><div class="sys-card-body"><span class="sys-metric-na">N/A</span></div>'; return; }
+
+        var html = '<div class="sys-card-header">Disk &amp; Storage</div><div class="sys-card-body">';
+        html += barHtml(disk.percent, '');
+        html += '<div class="sys-card-detail">' + formatBytes(disk.used) + ' / ' + formatBytes(disk.total) + '</div>';
+
+        // Disk I/O rates
+        if (m.disk_io && prevDiskIo && prevDiskTimestamp) {
+            var dt = (m.timestamp - prevDiskTimestamp);
+            if (dt > 0) {
+                var readRate = (m.disk_io.read_bytes - prevDiskIo.read_bytes) / dt;
+                var writeRate = (m.disk_io.write_bytes - prevDiskIo.write_bytes) / dt;
+                var readIops = Math.round((m.disk_io.read_count - prevDiskIo.read_count) / dt);
+                var writeIops = Math.round((m.disk_io.write_count - prevDiskIo.write_count) / dt);
+                html += '<div class="sys-disk-io">' +
+                    '<span class="sys-disk-io-read">R: ' + formatRate(Math.max(0, readRate)) + '</span>' +
+                    '<span class="sys-disk-io-write">W: ' + formatRate(Math.max(0, writeRate)) + '</span>' +
+                    '</div>';
+                html += '<div class="sys-card-detail">IOPS: ' + Math.max(0, readIops) + 'r / ' + Math.max(0, writeIops) + 'w</div>';
+            }
+        }
+
+        if (m.disk_io) {
+            prevDiskIo = m.disk_io;
+            prevDiskTimestamp = m.timestamp;
+        }
+
+        html += '</div>';
+        el.innerHTML = html;
+    }
+
+    // -----------------------------------------------------------------------
+    // Network Card
+    // -----------------------------------------------------------------------
+
+    function renderNetworkCard(m) {
+        var el = document.getElementById('sysCardNetwork');
+        if (!el) return;
+        var net = m.network;
+        if (!net) { el.innerHTML = '<div class="sys-card-header">Network</div><div class="sys-card-body"><span class="sys-metric-na">N/A</span></div>'; return; }
+
+        var html = '<div class="sys-card-header">Network</div><div class="sys-card-body">';
+
+        // Interfaces
+        var ifaces = net.interfaces || [];
+        if (ifaces.length === 0) {
+            html += '<span class="sys-metric-na">No interfaces</span>';
+        } else {
+            ifaces.forEach(function (iface) {
+                html += '<div class="sys-net-iface">';
+                html += '<div class="sys-net-iface-name">' + escHtml(iface.name) +
+                    (iface.is_up ? '' : ' <span style="color:var(--text-dim)">(down)</span>') + '</div>';
+                if (iface.ipv4) html += '<div class="sys-net-iface-ip">' + escHtml(iface.ipv4) + '</div>';
+                var details = [];
+                if (iface.mac) details.push('MAC: ' + iface.mac);
+                if (iface.speed) details.push(iface.speed + ' Mbps');
+                if (details.length) html += '<div class="sys-net-iface-detail">' + escHtml(details.join(' | ')) + '</div>';
+
+                // Bandwidth for this interface
+                if (net.io && net.io[iface.name] && prevNetIo && prevNetIo[iface.name] && prevNetTimestamp) {
+                    var dt = (m.timestamp - prevNetTimestamp);
+                    if (dt > 0) {
+                        var prev = prevNetIo[iface.name];
+                        var cur = net.io[iface.name];
+                        var upRate = (cur.bytes_sent - prev.bytes_sent) / dt;
+                        var downRate = (cur.bytes_recv - prev.bytes_recv) / dt;
+                        html += '<div class="sys-bandwidth">' +
+                            '<span class="sys-bw-up">&uarr; ' + formatRate(Math.max(0, upRate)) + '</span>' +
+                            '<span class="sys-bw-down">&darr; ' + formatRate(Math.max(0, downRate)) + '</span>' +
+                            '</div>';
+                    }
+                }
+
+                html += '</div>';
+            });
+        }
+
+        // Connection count
+        if (net.connections != null) {
+            html += '<div class="sys-card-detail" style="margin-top:8px">Connections: ' + net.connections + '</div>';
+        }
+
+        // Save for next delta
+        if (net.io) {
+            prevNetIo = net.io;
+            prevNetTimestamp = m.timestamp;
+        }
+
+        html += '</div>';
+        el.innerHTML = html;
+    }
+
+    // -----------------------------------------------------------------------
+    // Location & Weather Card
+    // -----------------------------------------------------------------------
+
+    function renderLocationCard() {
+        var el = document.getElementById('sysCardLocation');
+        if (!el) return;
+
+        // Preserve the globe DOM node if it already has a canvas
+        var existingGlobe = document.getElementById('sysGlobeContainer');
+        var savedGlobe = null;
+        if (existingGlobe && existingGlobe.querySelector('canvas')) {
+            savedGlobe = existingGlobe;
+            existingGlobe.parentNode.removeChild(existingGlobe);
+        }
+
+        var html = '<div class="sys-card-header">Location &amp; Weather</div><div class="sys-card-body">';
+        html += '<div class="sys-location-inner">';
+
+        // Globe placeholder (will be replaced with saved node or initialized fresh)
+        if (!savedGlobe) {
+            html += '<div class="sys-globe-wrap" id="sysGlobeContainer"></div>';
+        } else {
+            html += '<div id="sysGlobePlaceholder"></div>';
+        }
+
+        // Details below globe
+        html += '<div class="sys-location-details">';
+
+        if (locationData && locationData.lat != null) {
+            html += '<div class="sys-location-coords">' +
+                locationData.lat.toFixed(4) + '&deg;' + (locationData.lat >= 0 ? 'N' : 'S') + ', ' +
+                locationData.lon.toFixed(4) + '&deg;' + (locationData.lon >= 0 ? 'E' : 'W') + '</div>';
+
+            // GPS status indicator
+            if (locationData.source === 'gps' && locationData.gps) {
+                var gps = locationData.gps;
+                var fixLabel = gps.fix_quality === 3 ? '3D Fix' : '2D Fix';
+                var dotCls = gps.fix_quality === 3 ? 'fix-3d' : 'fix-2d';
+                html += '<div class="sys-gps-status">' +
+                    '<span class="sys-gps-dot ' + dotCls + '"></span> ' + fixLabel;
+                if (gps.satellites != null) html += ' &middot; ' + gps.satellites + ' sats';
+                if (gps.accuracy != null) html += ' &middot; &plusmn;' + gps.accuracy + 'm';
+                html += '</div>';
+            } else {
+                html += '<div class="sys-location-source">Source: ' + escHtml(locationData.source || 'unknown') + '</div>';
+            }
+        } else {
+            html += '<div class="sys-location-coords" style="color:var(--text-dim)">No location</div>';
+        }
+
+        // Weather
+        if (weatherData && !weatherData.error) {
+            html += '<div class="sys-weather">';
+            html += '<div class="sys-weather-temp">' + (weatherData.temp_c || '--') + '&deg;C</div>';
+            html += '<div class="sys-weather-condition">' + escHtml(weatherData.condition || '') + '</div>';
+            var details = [];
+            if (weatherData.humidity) details.push('Humidity: ' + weatherData.humidity + '%');
+            if (weatherData.wind_mph) details.push('Wind: ' + weatherData.wind_mph + ' mph ' + (weatherData.wind_dir || ''));
+            if (weatherData.feels_like_c) details.push('Feels like: ' + weatherData.feels_like_c + '°C');
+            details.forEach(function (d) {
+                html += '<div class="sys-weather-detail">' + escHtml(d) + '</div>';
+            });
+            html += '</div>';
+        } else if (weatherData && weatherData.error) {
+            html += '<div class="sys-weather"><div class="sys-weather-condition" style="color:var(--text-dim)">Weather unavailable</div></div>';
+        }
+
+        html += '</div>'; // .sys-location-details
+        html += '</div>'; // .sys-location-inner
+        html += '</div>';
+        el.innerHTML = html;
+
+        // Re-insert saved globe or initialize fresh
+        if (savedGlobe) {
+            var placeholder = document.getElementById('sysGlobePlaceholder');
+            if (placeholder) placeholder.parentNode.replaceChild(savedGlobe, placeholder);
+        } else {
+            requestAnimationFrame(function () { initGlobe(); });
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // Globe (reuses globe.gl from GPS mode)
+    // -----------------------------------------------------------------------
+
+    function ensureGlobeLibrary() {
+        return new Promise(function (resolve, reject) {
+            if (typeof window.Globe === 'function') { resolve(true); return; }
+
+            // Check if script already exists
+            var existing = document.querySelector(
+                'script[data-intercept-globe-src="' + GLOBE_SCRIPT_URL + '"], ' +
+                'script[src="' + GLOBE_SCRIPT_URL + '"]'
+            );
+            if (existing) {
+                if (existing.dataset.loaded === 'true') { resolve(true); return; }
+                if (existing.dataset.failed === 'true') { resolve(false); return; }
+                existing.addEventListener('load', function () { resolve(true); }, { once: true });
+                existing.addEventListener('error', function () { resolve(false); }, { once: true });
+                return;
+            }
+
+            var script = document.createElement('script');
+            script.src = GLOBE_SCRIPT_URL;
+            script.async = true;
+            script.crossOrigin = 'anonymous';
+            script.dataset.interceptGlobeSrc = GLOBE_SCRIPT_URL;
+            script.onload = function () { script.dataset.loaded = 'true'; resolve(true); };
+            script.onerror = function () { script.dataset.failed = 'true'; resolve(false); };
+            document.head.appendChild(script);
+        });
+    }
+
+    function initGlobe() {
+        var container = document.getElementById('sysGlobeContainer');
+        if (!container || globeDestroyed) return;
+
+        // Don't reinitialize if globe canvas is still alive in this container
+        if (globeInstance && container.querySelector('canvas')) return;
+
+        // Clear stale reference if canvas was destroyed by innerHTML replacement
+        if (globeInstance && !container.querySelector('canvas')) {
+            globeInstance = null;
+        }
+
+        ensureGlobeLibrary().then(function (ready) {
+            if (!ready || typeof window.Globe !== 'function' || globeDestroyed) return;
+
+            // Wait for layout — container may have 0 dimensions right after
+            // display:none is removed by switchMode(). Use RAF retry like GPS mode.
+            var attempts = 0;
+            function tryInit() {
+                if (globeDestroyed) return;
+                container = document.getElementById('sysGlobeContainer');
+                if (!container) return;
+
+                if ((!container.clientWidth || !container.clientHeight) && attempts < 8) {
+                    attempts++;
+                    requestAnimationFrame(tryInit);
+                    return;
+                }
+                if (!container.clientWidth || !container.clientHeight) return;
+
+                container.innerHTML = '';
+                container.style.background = 'radial-gradient(circle, rgba(10,20,40,0.9), rgba(2,4,8,0.98) 70%)';
+
+                try {
+                    globeInstance = window.Globe()(container)
+                        .backgroundColor('rgba(0,0,0,0)')
+                        .globeImageUrl(GLOBE_TEXTURE_URL)
+                        .showAtmosphere(true)
+                        .atmosphereColor('#3bb9ff')
+                        .atmosphereAltitude(0.12)
+                        .pointsData([])
+                        .pointRadius(0.8)
+                        .pointAltitude(0.01)
+                        .pointColor(function () { return '#00d4ff'; });
+
+                    var controls = globeInstance.controls();
+                    if (controls) {
+                        controls.autoRotate = true;
+                        controls.autoRotateSpeed = 0.5;
+                        controls.enablePan = false;
+                        controls.minDistance = 120;
+                        controls.maxDistance = 300;
+                    }
+
+                    // Size the globe
+                    globeInstance.width(container.clientWidth);
+                    globeInstance.height(container.clientHeight);
+
+                    updateGlobePosition();
+                } catch (e) {
+                    // Globe.gl / WebGL init failed — show static fallback
+                    container.innerHTML = '<div style="display:flex;align-items:center;justify-content:center;width:100%;height:100%;color:var(--text-dim);font-size:11px;">Globe unavailable</div>';
+                }
+            }
+            requestAnimationFrame(tryInit);
+        });
+    }
+
+    function updateGlobePosition() {
+        if (!globeInstance || !locationData || locationData.lat == null) return;
+
+        // Observer point
+        globeInstance.pointsData([{
+            lat: locationData.lat,
+            lng: locationData.lon,
+            size: 0.8,
+            color: '#00d4ff',
+        }]);
+
+        // Snap view
+        globeInstance.pointOfView({ lat: locationData.lat, lng: locationData.lon, altitude: 2.0 }, 1000);
+
+        // Stop auto-rotate when we have a fix
+        var controls = globeInstance.controls();
+        if (controls) controls.autoRotate = false;
+    }
+
+    function destroyGlobe() {
+        globeDestroyed = true;
+        if (globeInstance) {
+            var container = document.getElementById('sysGlobeContainer');
+            if (container) container.innerHTML = '';
+            globeInstance = null;
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // SDR Card
+    // -----------------------------------------------------------------------
+
+    function renderSdrCard(devices) {
+        var el = document.getElementById('sysCardSdr');
+        if (!el) return;
+        var html = '<div class="sys-card-header">SDR Devices <button class="sys-rescan-btn" onclick="SystemHealth.refreshSdr()">Rescan</button></div>';
+        html += '<div class="sys-card-body">';
+        if (!devices || !devices.length) {
+            html += '<span class="sys-metric-na">No devices found</span>';
+        } else {
+            devices.forEach(function (d) {
+                html += '<div class="sys-sdr-device">' +
+                    '<span class="sys-process-dot running"></span> ' +
+                    '<strong>' + escHtml(d.type) + ' #' + d.index + '</strong>' +
+                    '<div class="sys-card-detail">' + escHtml(d.name || 'Unknown') + '</div>' +
+                    (d.serial ? '<div class="sys-card-detail">S/N: ' + escHtml(d.serial) + '</div>' : '') +
+                    '</div>';
+            });
+        }
+        html += '</div>';
+        el.innerHTML = html;
+    }
+
+    // -----------------------------------------------------------------------
+    // Process Card
+    // -----------------------------------------------------------------------
+
+    function renderProcessCard(m) {
+        var el = document.getElementById('sysCardProcesses');
+        if (!el) return;
+        var procs = m.processes || {};
+        var keys = Object.keys(procs).sort();
+        var html = '<div class="sys-card-header">Active Processes</div><div class="sys-card-body">';
+        if (!keys.length) {
+            html += '<span class="sys-metric-na">No data</span>';
+        } else {
+            var running = 0, stopped = 0;
+            html += '<div class="sys-process-grid">';
+            keys.forEach(function (k) {
+                var isRunning = procs[k];
+                if (isRunning) running++; else stopped++;
+                var dotCls = isRunning ? 'running' : 'stopped';
+                var label = k.charAt(0).toUpperCase() + k.slice(1);
+                html += '<div class="sys-process-item">' +
+                    '<span class="sys-process-dot ' + dotCls + '"></span> ' +
+                    '<span class="sys-process-name">' + escHtml(label) + '</span>' +
+                    '</div>';
+            });
+            html += '</div>';
+            html += '<div class="sys-process-summary">' + running + ' running / ' + stopped + ' idle</div>';
+        }
+        html += '</div>';
+        el.innerHTML = html;
+    }
+
+    // -----------------------------------------------------------------------
+    // System Info Card
+    // -----------------------------------------------------------------------
+
+    function renderSystemInfoCard(m) {
+        var el = document.getElementById('sysCardInfo');
+        if (!el) return;
+        var sys = m.system || {};
+        var html = '<div class="sys-card-header">System Info</div><div class="sys-card-body"><div class="sys-info-grid">';
+
+        html += '<div class="sys-info-item"><strong>Host</strong><span>' + escHtml(sys.hostname || '--') + '</span></div>';
+        html += '<div class="sys-info-item"><strong>OS</strong><span>' + escHtml((sys.platform || '--').replace(/-with-glibc[\d.]+/, '')) + '</span></div>';
+        html += '<div class="sys-info-item"><strong>Python</strong><span>' + escHtml(sys.python || '--') + '</span></div>';
+        html += '<div class="sys-info-item"><strong>App</strong><span>v' + escHtml(sys.version || '--') + '</span></div>';
+        html += '<div class="sys-info-item"><strong>Uptime</strong><span>' + escHtml(sys.uptime_human || '--') + '</span></div>';
+
+        if (m.boot_time) {
+            var bootDate = new Date(m.boot_time * 1000);
+            html += '<div class="sys-info-item"><strong>Boot</strong><span>' + escHtml(bootDate.toLocaleString()) + '</span></div>';
+        }
+
+        if (m.network && m.network.connections != null) {
+            html += '<div class="sys-info-item"><strong>Connections</strong><span>' + m.network.connections + '</span></div>';
+        }
+
+        html += '</div></div>';
+        el.innerHTML = html;
+    }
+
+    // -----------------------------------------------------------------------
+    // Sidebar Updates
+    // -----------------------------------------------------------------------
+
+    function updateSidebarQuickStats(m) {
+        var cpuEl = document.getElementById('sysQuickCpu');
+        var tempEl = document.getElementById('sysQuickTemp');
+        var ramEl = document.getElementById('sysQuickRam');
+        var diskEl = document.getElementById('sysQuickDisk');
+
+        if (cpuEl) cpuEl.textContent = m.cpu ? Math.round(m.cpu.percent) + '%' : '--';
+        if (ramEl) ramEl.textContent = m.memory ? Math.round(m.memory.percent) + '%' : '--';
+        if (diskEl) diskEl.textContent = m.disk ? Math.round(m.disk.percent) + '%' : '--';
+
+        var temp = _extractPrimaryTemp(m.temperatures);
+        if (tempEl) tempEl.innerHTML = temp ? Math.round(temp.current) + '&deg;C' : '--';
+
+        // Color-code values
+        [cpuEl, ramEl, diskEl].forEach(function (el) {
+            if (!el) return;
+            var val = parseInt(el.textContent);
+            el.classList.remove('sys-val-ok', 'sys-val-warn', 'sys-val-crit');
+            if (!isNaN(val)) el.classList.add('sys-val-' + barClass(val));
+        });
+    }
+
+    function updateSidebarProcesses(m) {
+        var el = document.getElementById('sysProcessList');
+        if (!el) return;
+        var procs = m.processes || {};
+        var keys = Object.keys(procs).sort();
+        if (!keys.length) { el.textContent = 'No data'; return; }
+        var running = keys.filter(function (k) { return procs[k]; });
+        var stopped = keys.filter(function (k) { return !procs[k]; });
+        el.innerHTML =
+            (running.length ? '<span style="color: var(--accent-green, #00ff88);">' + running.length + ' running</span>' : '') +
+            (running.length && stopped.length ? ' &middot; ' : '') +
+            (stopped.length ? '<span style="color: var(--text-dim);">' + stopped.length + ' stopped</span>' : '');
+    }
+
+    function updateSidebarNetwork(m) {
+        var el = document.getElementById('sysQuickNet');
+        if (!el || !m.network) return;
+        var ifaces = m.network.interfaces || [];
+        var ips = [];
+        ifaces.forEach(function (iface) {
+            if (iface.ipv4 && iface.is_up) {
+                ips.push(iface.name + ': ' + iface.ipv4);
+            }
+        });
+        el.textContent = ips.length ? ips.join(', ') : '--';
+    }
+
+    function updateSidebarBattery(m) {
+        var section = document.getElementById('sysQuickBatterySection');
+        var el = document.getElementById('sysQuickBattery');
+        if (!section || !el) return;
+        if (m.battery) {
+            section.style.display = '';
+            el.textContent = Math.round(m.battery.percent) + '%' + (m.battery.plugged ? ' (plugged)' : '');
+        } else {
+            section.style.display = 'none';
+        }
+    }
+
+    function updateSidebarLocation() {
+        var el = document.getElementById('sysQuickLocation');
+        if (!el) return;
+        if (locationData && locationData.lat != null) {
+            el.textContent = locationData.lat.toFixed(4) + ', ' + locationData.lon.toFixed(4) + ' (' + locationData.source + ')';
+        } else {
+            el.textContent = 'No location';
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // Render all
+    // -----------------------------------------------------------------------
+
+    function renderAll(m) {
+        renderCpuCard(m);
+        renderMemoryCard(m);
+        renderTempCard(m);
+        renderDiskCard(m);
+        renderNetworkCard(m);
+        renderProcessCard(m);
+        renderSystemInfoCard(m);
+        updateSidebarQuickStats(m);
+        updateSidebarProcesses(m);
+        updateSidebarNetwork(m);
+        updateSidebarBattery(m);
+    }
+
+    // -----------------------------------------------------------------------
+    // Location & Weather Fetching
+    // -----------------------------------------------------------------------
+
+    function fetchLocation() {
+        fetch('/system/location')
+            .then(function (r) { return r.json(); })
+            .then(function (data) {
+                // If server only has default/none, check client-side saved location
+                if ((data.source === 'default' || data.source === 'none') &&
+                    window.ObserverLocation && ObserverLocation.getShared) {
+                    var shared = ObserverLocation.getShared();
+                    if (shared && shared.lat && shared.lon) {
+                        data.lat = shared.lat;
+                        data.lon = shared.lon;
+                        data.source = 'manual';
+                    }
+                }
+                locationData = data;
+                updateSidebarLocation();
+                renderLocationCard();
+                if (data.lat != null) fetchWeather();
+            })
+            .catch(function () {
+                renderLocationCard();
+            });
+    }
+
+    function fetchWeather() {
+        if (!locationData || locationData.lat == null) return;
+        fetch('/system/weather?lat=' + locationData.lat + '&lon=' + locationData.lon)
+            .then(function (r) { return r.json(); })
+            .then(function (data) {
+                weatherData = data;
+                renderLocationCard();
+            })
+            .catch(function () {});
+    }
+
+    // -----------------------------------------------------------------------
+    // SSE Connection
+    // -----------------------------------------------------------------------
+
+    function connect() {
+        if (eventSource) return;
+        eventSource = new EventSource('/system/stream');
+        eventSource.onmessage = function (e) {
+            try {
+                var data = JSON.parse(e.data);
+                if (data.type === 'keepalive') return;
+                lastMetrics = data;
+                renderAll(data);
+            } catch (_) { /* ignore parse errors */ }
+        };
+        eventSource.onopen = function () {
+            connected = true;
+        };
+        eventSource.onerror = function () {
+            connected = false;
+        };
+    }
+
+    function disconnect() {
+        if (eventSource) {
+            eventSource.close();
+            eventSource = null;
+        }
+        connected = false;
+    }
+
+    // -----------------------------------------------------------------------
+    // SDR Devices
+    // -----------------------------------------------------------------------
+
+    function refreshSdr() {
+        var sidebarEl = document.getElementById('sysSdrList');
+        if (sidebarEl) sidebarEl.innerHTML = 'Scanning&hellip;';
+
+        var cardEl = document.getElementById('sysCardSdr');
+        if (cardEl) cardEl.innerHTML = '<div class="sys-card-header">SDR Devices</div><div class="sys-card-body">Scanning&hellip;</div>';
+
+        fetch('/system/sdr_devices')
+            .then(function (r) { return r.json(); })
+            .then(function (data) {
+                var devices = data.devices || [];
+                renderSdrCard(devices);
+                // Update sidebar
+                if (sidebarEl) {
+                    if (!devices.length) {
+                        sidebarEl.innerHTML = '<span style="color: var(--text-dim);">No SDR devices found</span>';
+                    } else {
+                        var html = '';
+                        devices.forEach(function (d) {
+                            html += '<div style="margin-bottom: 4px;"><span class="sys-process-dot running"></span> ' +
+                                escHtml(d.type) + ' #' + d.index + ' &mdash; ' + escHtml(d.name || 'Unknown') + '</div>';
+                        });
+                        sidebarEl.innerHTML = html;
+                    }
+                }
+            })
+            .catch(function () {
+                if (sidebarEl) sidebarEl.innerHTML = '<span style="color: var(--accent-red, #ff3366);">Detection failed</span>';
+                renderSdrCard([]);
+            });
+    }
+
+    // -----------------------------------------------------------------------
+    // Public API
+    // -----------------------------------------------------------------------
+
+    function init() {
+        globeDestroyed = false;
+        connect();
+        refreshSdr();
+        fetchLocation();
+
+        // Refresh weather every 10 minutes
+        weatherTimer = setInterval(function () {
+            fetchWeather();
+        }, 600000);
+    }
+
+    function destroy() {
+        disconnect();
+        destroyGlobe();
+        if (weatherTimer) {
+            clearInterval(weatherTimer);
+            weatherTimer = null;
+        }
+    }
+
+    return {
+        init: init,
+        destroy: destroy,
+        refreshSdr: refreshSdr,
+    };
+})();

static/js/modes/weather-satellite.js

@@ -38,6 +38,40 @@ const WeatherSat = (function() {
         startCountdownTimer();
         checkSchedulerStatus();
         initGroundMap();
+
+        // Re-filter passes when satellite selection changes
+        const satSelect = document.getElementById('weatherSatSelect');
+        if (satSelect) {
+            satSelect.addEventListener('change', () => {
+                applyPassFilter();
+            });
+        }
+    }
+
+    /**
+     * Get passes filtered by the currently selected satellite.
+     */
+    function getFilteredPasses() {
+        const satSelect = document.getElementById('weatherSatSelect');
+        const selected = satSelect?.value;
+        if (!selected) return passes;
+        return passes.filter(p => p.satellite === selected);
+    }
+
+    /**
+     * Re-render passes, timeline, countdown and polar plot using filtered list.
+     */
+    function applyPassFilter() {
+        const filtered = getFilteredPasses();
+        selectedPassIndex = -1;
+        renderPasses(filtered);
+        renderTimeline(filtered);
+        updateCountdownFromPasses();
+        if (filtered.length > 0) {
+            selectPass(0);
+        } else {
+            updateGroundTrack(null);
+        }
     }
 
     /**
@@ -262,10 +296,13 @@ const WeatherSat = (function() {
      * Stop capture
      */
     async function stop() {
-        try {
+        // Optimistically update UI immediately so stop feels responsive,
-            await fetch('/weather-sat/stop', { method: 'POST' });
+        // even if the server takes time to terminate the process.
         isRunning = false;
         stopStream();
+        updateStatusUI('idle', 'Stopping...');
+        try {
+            await fetch('/weather-sat/stop', { method: 'POST' });
             updateStatusUI('idle', 'Stopped');
             showNotification('Weather Sat', 'Capture stopped');
         } catch (err) {
@@ -552,17 +589,8 @@ const WeatherSat = (function() {
 
             if (data.status === 'ok') {
                 passes = data.passes || [];
-                selectedPassIndex = -1;
+                // Apply satellite filter and render
-                renderPasses(passes);
+                applyPassFilter();
-                renderTimeline(passes);
-                updateCountdownFromPasses();
-                // Always select the first upcoming pass so the polar plot
-                // and ground track reflect the current list after every refresh.
-                if (passes.length > 0) {
-                    selectPass(0);
-                } else {
-                    updateGroundTrack(null);
-                }
             }
         } catch (err) {
             console.error('Failed to load passes:', err);
@@ -573,9 +601,10 @@ const WeatherSat = (function() {
      * Select a pass to display in polar plot and map
      */
     function selectPass(index) {
-        if (index < 0 || index >= passes.length) return;
+        const filtered = getFilteredPasses();
+        if (index < 0 || index >= filtered.length) return;
         selectedPassIndex = index;
-        const pass = passes[index];
+        const pass = filtered[index];
 
         // Highlight active card
         document.querySelectorAll('.wxsat-pass-card').forEach((card, i) => {
@@ -1028,8 +1057,9 @@ const WeatherSat = (function() {
     }
 
     function getSelectedPass() {
-        if (selectedPassIndex < 0 || selectedPassIndex >= passes.length) return null;
+        const filtered = getFilteredPasses();
-        return passes[selectedPassIndex];
+        if (selectedPassIndex < 0 || selectedPassIndex >= filtered.length) return null;
+        return filtered[selectedPassIndex];
     }
 
     function getSatellitePositionForPass(pass, atTime = new Date()) {
@@ -1141,8 +1171,9 @@ const WeatherSat = (function() {
         const now = new Date();
         let nextPass = null;
         let isActive = false;
+        const filtered = getFilteredPasses();
 
-        for (const pass of passes) {
+        for (const pass of filtered) {
             const start = parsePassDate(pass.startTimeISO);
             const end = parsePassDate(pass.endTimeISO);
             if (!start || !end) {

static/js/modes/websdr.js

@@ -9,6 +9,19 @@ let websdrMarkers = [];
 let websdrReceivers = [];
 let websdrInitialized = false;
 let websdrSpyStationsLoaded = false;
+let websdrMapType = null;
+let websdrGlobe = null;
+let websdrGlobePopup = null;
+let websdrSelectedReceiverIndex = null;
+let websdrGlobeScriptPromise = null;
+let websdrResizeObserver = null;
+let websdrResizeHooked = false;
+let websdrGlobeFallbackNotified = false;
+
+const WEBSDR_GLOBE_SCRIPT_URLS = [
+    'https://cdn.jsdelivr.net/npm/globe.gl@2.33.1/dist/globe.gl.min.js',
+];
+const WEBSDR_GLOBE_TEXTURE_URL = '/static/images/globe/earth-dark.jpg';
 
 // KiwiSDR audio state
 let kiwiWebSocket = null;
@@ -29,43 +42,37 @@ const KIWI_SAMPLE_RATE = 12000;
 
 async function initWebSDR() {
     if (websdrInitialized) {
-        if (websdrMap) {
+        setTimeout(invalidateWebSDRViewport, 100);
-            setTimeout(() => websdrMap.invalidateSize(), 100);
-        }
         return;
     }
 
     const mapEl = document.getElementById('websdrMap');
-    if (!mapEl || typeof L === 'undefined') return;
+    if (!mapEl) return;
 
-    // Calculate minimum zoom so tiles fill the container vertically
+    const globeReady = await ensureWebsdrGlobeLibrary();
-    const mapHeight = mapEl.clientHeight || 500;
-    const minZoom = Math.ceil(Math.log2(mapHeight / 256));
 
-    websdrMap = L.map('websdrMap', {
+    // Wait for a paint frame so the browser computes layout after the
-        center: [20, 0],
+    // display:flex change in switchMode.  Without this, Globe()(mapEl) can
-        zoom: Math.max(minZoom, 2),
+    // run before clientWidth/clientHeight are non-zero (especially when
-        minZoom: Math.max(minZoom, 2),
+    // scripts are served from cache and resolve before the first layout pass).
-        zoomControl: true,
+    await new Promise(resolve => requestAnimationFrame(resolve));
-        maxBounds: [[-85, -360], [85, 360]],
-        maxBoundsViscosity: 1.0,
-    });
 
-    if (typeof Settings !== 'undefined' && Settings.createTileLayer) {
+    // If the mode was switched away while scripts were loading, abort so
-        await Settings.init();
+    // websdrInitialized stays false and we retry cleanly next time.
-        Settings.createTileLayer().addTo(websdrMap);
+    if (!mapEl.clientWidth || !mapEl.clientHeight) return;
-        Settings.registerMap(websdrMap);
+
-    } else {
+    if (globeReady && initWebsdrGlobe(mapEl)) {
-        L.tileLayer('https://{s}.basemaps.cartocdn.com/dark_all/{z}/{x}/{y}{r}.png', {
+        websdrMapType = 'globe';
-            attribution: '© OpenStreetMap contributors © CARTO',
+    } else if (typeof L !== 'undefined' && await initWebsdrLeaflet(mapEl)) {
-            subdomains: 'abcd',
+        websdrMapType = 'leaflet';
-            maxZoom: 19,
+        if (!websdrGlobeFallbackNotified && typeof showNotification === 'function') {
-            className: 'tile-layer-cyan',
+            showNotification('WebSDR', '3D globe unavailable, using fallback map');
-        }).addTo(websdrMap);
+            websdrGlobeFallbackNotified = true;
+        }
+    } else {
+        console.error('[WEBSDR] Unable to initialize globe or map renderer');
+        return;
     }
-
-    // Match background to tile ocean color so any remaining edge is seamless
-    mapEl.style.background = '#1a1d29';
 
     websdrInitialized = true;
 
@@ -73,10 +80,12 @@ async function initWebSDR() {
         loadSpyStationPresets();
     }
 
+    setupWebsdrResizeHandling(mapEl);
+    if (websdrReceivers.length > 0) {
+        plotReceiversOnMap(websdrReceivers);
+    }
     [100, 300, 600, 1000].forEach(delay => {
-        setTimeout(() => {
+        setTimeout(invalidateWebSDRViewport, delay);
-            if (websdrMap) websdrMap.invalidateSize();
-        }, delay);
     });
 }
 
@@ -94,6 +103,8 @@ function searchReceivers(refresh) {
         .then(data => {
             if (data.status === 'success') {
                 websdrReceivers = data.receivers || [];
+                websdrSelectedReceiverIndex = null;
+                hideWebsdrGlobePopup();
                 renderReceiverList(websdrReceivers);
                 plotReceiversOnMap(websdrReceivers);
 
@@ -107,6 +118,11 @@ function searchReceivers(refresh) {
 // ============== MAP ==============
 
 function plotReceiversOnMap(receivers) {
+    if (websdrMapType === 'globe' && websdrGlobe) {
+        plotReceiversOnGlobe(receivers);
+        return;
+    }
+
     if (!websdrMap) return;
 
     websdrMarkers.forEach(m => websdrMap.removeLayer(m));
@@ -144,6 +160,396 @@ function plotReceiversOnMap(receivers) {
     }
 }
 
+async function ensureWebsdrGlobeLibrary() {
+    if (typeof window.Globe === 'function') return true;
+    if (!isWebglSupported()) return false;
+
+    if (!websdrGlobeScriptPromise) {
+        websdrGlobeScriptPromise = WEBSDR_GLOBE_SCRIPT_URLS
+            .reduce(
+                (promise, src) => promise.then(() => loadWebsdrScript(src)),
+                Promise.resolve()
+            )
+            .then(() => typeof window.Globe === 'function')
+            .catch((error) => {
+                console.warn('[WEBSDR] Failed to load globe scripts:', error);
+                return false;
+            });
+    }
+
+    const loaded = await websdrGlobeScriptPromise;
+    if (!loaded) {
+        websdrGlobeScriptPromise = null;
+    }
+    return loaded;
+}
+
+function loadWebsdrScript(src) {
+    const state = getSharedGlobeScriptState();
+    if (!state.promises[src]) {
+        state.promises[src] = loadSharedGlobeScript(src);
+    }
+    return state.promises[src].catch((error) => {
+        delete state.promises[src];
+        throw error;
+    });
+}
+
+function getSharedGlobeScriptState() {
+    const key = '__interceptGlobeScriptState';
+    if (!window[key]) {
+        window[key] = {
+            promises: Object.create(null),
+        };
+    }
+    return window[key];
+}
+
+function loadSharedGlobeScript(src) {
+    return new Promise((resolve, reject) => {
+        const selector = [
+            `script[data-intercept-globe-src="${src}"]`,
+            `script[data-websdr-src="${src}"]`,
+            `script[data-gps-globe-src="${src}"]`,
+            `script[src="${src}"]`,
+        ].join(', ');
+        const existing = document.querySelector(selector);
+
+        if (existing) {
+            if (existing.dataset.loaded === 'true') {
+                resolve();
+                return;
+            }
+            if (existing.dataset.failed === 'true') {
+                existing.remove();
+            } else {
+                existing.addEventListener('load', () => resolve(), { once: true });
+                existing.addEventListener('error', () => reject(new Error(`Failed to load ${src}`)), { once: true });
+                return;
+            }
+        }
+
+        const script = document.createElement('script');
+        script.src = src;
+        script.async = true;
+        script.crossOrigin = 'anonymous';
+        script.dataset.interceptGlobeSrc = src;
+        script.dataset.websdrSrc = src;
+        script.onload = () => {
+            script.dataset.loaded = 'true';
+            resolve();
+        };
+        script.onerror = () => {
+            script.dataset.failed = 'true';
+            reject(new Error(`Failed to load ${src}`));
+        };
+        document.head.appendChild(script);
+    });
+}
+
+function isWebglSupported() {
+    try {
+        const canvas = document.createElement('canvas');
+        return !!(canvas.getContext('webgl') || canvas.getContext('experimental-webgl'));
+    } catch (_) {
+        return false;
+    }
+}
+
+function initWebsdrGlobe(mapEl) {
+    if (typeof window.Globe !== 'function' || !isWebglSupported()) return false;
+
+    mapEl.innerHTML = '';
+    mapEl.style.background = 'radial-gradient(circle at 30% 20%, rgba(14, 42, 68, 0.9), rgba(4, 9, 16, 0.95) 58%, rgba(2, 4, 9, 0.98) 100%)';
+    mapEl.style.cursor = 'grab';
+
+    websdrGlobe = window.Globe()(mapEl)
+        .backgroundColor('rgba(0,0,0,0)')
+        .globeImageUrl(WEBSDR_GLOBE_TEXTURE_URL)
+        .showAtmosphere(true)
+        .atmosphereColor('#3bb9ff')
+        .atmosphereAltitude(0.17)
+        .pointRadius('radius')
+        .pointAltitude('altitude')
+        .pointColor('color')
+        .pointsTransitionDuration(250)
+        .pointLabel(point => point.label || '')
+        .onPointHover(point => {
+            mapEl.style.cursor = point ? 'pointer' : 'grab';
+        })
+        .onPointClick((point, event) => {
+            if (!point) return;
+            showWebsdrGlobePopup(point, event);
+        });
+
+    const controls = websdrGlobe.controls();
+    if (controls) {
+        controls.autoRotate = true;
+        controls.autoRotateSpeed = 0.25;
+        controls.enablePan = false;
+        controls.minDistance = 140;
+        controls.maxDistance = 380;
+        controls.rotateSpeed = 0.7;
+        controls.zoomSpeed = 0.8;
+    }
+
+    ensureWebsdrGlobePopup(mapEl);
+    resizeWebsdrGlobe();
+    return true;
+}
+
+async function initWebsdrLeaflet(mapEl) {
+    if (typeof L === 'undefined') return false;
+
+    mapEl.innerHTML = '';
+    const mapHeight = mapEl.clientHeight || 500;
+    const minZoom = Math.ceil(Math.log2(mapHeight / 256));
+
+    websdrMap = L.map('websdrMap', {
+        center: [20, 0],
+        zoom: Math.max(minZoom, 2),
+        minZoom: Math.max(minZoom, 2),
+        zoomControl: true,
+        maxBounds: [[-85, -360], [85, 360]],
+        maxBoundsViscosity: 1.0,
+    });
+
+    if (typeof Settings !== 'undefined' && Settings.createTileLayer) {
+        await Settings.init();
+        Settings.createTileLayer().addTo(websdrMap);
+        Settings.registerMap(websdrMap);
+    } else {
+        L.tileLayer('https://{s}.basemaps.cartocdn.com/dark_all/{z}/{x}/{y}{r}.png', {
+            attribution: '© OpenStreetMap contributors © CARTO',
+            subdomains: 'abcd',
+            maxZoom: 19,
+            className: 'tile-layer-cyan',
+        }).addTo(websdrMap);
+    }
+
+    mapEl.style.background = '#1a1d29';
+    return true;
+}
+
+function setupWebsdrResizeHandling(mapEl) {
+    if (typeof ResizeObserver !== 'undefined') {
+        if (websdrResizeObserver) {
+            websdrResizeObserver.disconnect();
+        }
+        websdrResizeObserver = new ResizeObserver(() => invalidateWebSDRViewport());
+        websdrResizeObserver.observe(mapEl);
+    }
+
+    if (!websdrResizeHooked) {
+        window.addEventListener('resize', invalidateWebSDRViewport);
+        window.addEventListener('orientationchange', () => setTimeout(invalidateWebSDRViewport, 120));
+        websdrResizeHooked = true;
+    }
+}
+
+function invalidateWebSDRViewport() {
+    if (websdrMapType === 'globe') {
+        resizeWebsdrGlobe();
+        return;
+    }
+    if (websdrMap && typeof websdrMap.invalidateSize === 'function') {
+        websdrMap.invalidateSize({ pan: false, animate: false });
+    }
+}
+
+function resizeWebsdrGlobe() {
+    if (!websdrGlobe) return;
+    const mapEl = document.getElementById('websdrMap');
+    if (!mapEl) return;
+
+    const width = mapEl.clientWidth;
+    const height = mapEl.clientHeight;
+    if (!width || !height) return;
+
+    websdrGlobe.width(width);
+    websdrGlobe.height(height);
+}
+
+function plotReceiversOnGlobe(receivers) {
+    if (!websdrGlobe) return;
+
+    const points = [];
+    receivers.forEach((rx, idx) => {
+        const lat = Number(rx.lat);
+        const lon = Number(rx.lon);
+        if (!Number.isFinite(lat) || !Number.isFinite(lon)) return;
+
+        const selected = idx === websdrSelectedReceiverIndex;
+        points.push({
+            lat: lat,
+            lng: lon,
+            receiverIndex: idx,
+            radius: selected ? 0.52 : 0.38,
+            altitude: selected ? 0.1 : 0.04,
+            color: selected ? '#00ff88' : (rx.available ? '#00d4ff' : '#5f6976'),
+            label: buildWebsdrPointLabel(rx, idx),
+        });
+    });
+
+    websdrGlobe.pointsData(points);
+
+    if (points.length > 0) {
+        if (websdrSelectedReceiverIndex != null) {
+            const selectedPoint = points.find(point => point.receiverIndex === websdrSelectedReceiverIndex);
+            if (selectedPoint) {
+                websdrGlobe.pointOfView({ lat: selectedPoint.lat, lng: selectedPoint.lng, altitude: 1.45 }, 900);
+                return;
+            }
+        }
+
+        const center = computeWebsdrGlobeCenter(points);
+        websdrGlobe.pointOfView(center, 900);
+    }
+}
+
+function computeWebsdrGlobeCenter(points) {
+    if (!points.length) return { lat: 20, lng: 0, altitude: 2.1 };
+
+    let x = 0;
+    let y = 0;
+    let z = 0;
+    points.forEach(point => {
+        const latRad = point.lat * Math.PI / 180;
+        const lonRad = point.lng * Math.PI / 180;
+        x += Math.cos(latRad) * Math.cos(lonRad);
+        y += Math.cos(latRad) * Math.sin(lonRad);
+        z += Math.sin(latRad);
+    });
+
+    const count = points.length;
+    x /= count;
+    y /= count;
+    z /= count;
+
+    const hyp = Math.sqrt((x * x) + (y * y));
+    const centerLat = Math.atan2(z, hyp) * 180 / Math.PI;
+    const centerLng = Math.atan2(y, x) * 180 / Math.PI;
+
+    let meanAngularDistance = 0;
+    const centerLatRad = centerLat * Math.PI / 180;
+    const centerLngRad = centerLng * Math.PI / 180;
+    points.forEach(point => {
+        const latRad = point.lat * Math.PI / 180;
+        const lonRad = point.lng * Math.PI / 180;
+        const cosAngle = (
+            (Math.sin(centerLatRad) * Math.sin(latRad)) +
+            (Math.cos(centerLatRad) * Math.cos(latRad) * Math.cos(lonRad - centerLngRad))
+        );
+        const safeCos = Math.max(-1, Math.min(1, cosAngle));
+        meanAngularDistance += Math.acos(safeCos) * 180 / Math.PI;
+    });
+    meanAngularDistance /= count;
+
+    const altitude = Math.min(2.9, Math.max(1.35, 1.35 + (meanAngularDistance / 45)));
+    return { lat: centerLat, lng: centerLng, altitude: altitude };
+}
+
+function ensureWebsdrGlobePopup(mapEl) {
+    if (websdrGlobePopup) {
+        if (websdrGlobePopup.parentElement !== mapEl) {
+            mapEl.appendChild(websdrGlobePopup);
+        }
+        return;
+    }
+
+    websdrGlobePopup = document.createElement('div');
+    websdrGlobePopup.id = 'websdrGlobePopup';
+    websdrGlobePopup.style.position = 'absolute';
+    websdrGlobePopup.style.minWidth = '220px';
+    websdrGlobePopup.style.maxWidth = '260px';
+    websdrGlobePopup.style.padding = '10px';
+    websdrGlobePopup.style.borderRadius = '8px';
+    websdrGlobePopup.style.border = '1px solid rgba(0, 212, 255, 0.35)';
+    websdrGlobePopup.style.background = 'rgba(5, 13, 20, 0.92)';
+    websdrGlobePopup.style.backdropFilter = 'blur(4px)';
+    websdrGlobePopup.style.boxShadow = '0 8px 24px rgba(0, 0, 0, 0.4)';
+    websdrGlobePopup.style.color = 'var(--text-primary)';
+    websdrGlobePopup.style.display = 'none';
+    websdrGlobePopup.style.zIndex = '20';
+    mapEl.appendChild(websdrGlobePopup);
+
+    if (!mapEl.dataset.websdrPopupHooked) {
+        mapEl.addEventListener('click', (event) => {
+            if (!websdrGlobePopup || websdrGlobePopup.style.display === 'none') return;
+            if (event.target.closest('#websdrGlobePopup')) return;
+            hideWebsdrGlobePopup();
+        });
+        mapEl.dataset.websdrPopupHooked = 'true';
+    }
+}
+
+function showWebsdrGlobePopup(point, event) {
+    if (!websdrGlobePopup || !point || point.receiverIndex == null) return;
+    const rx = websdrReceivers[point.receiverIndex];
+    if (!rx) return;
+
+    const mapEl = document.getElementById('websdrMap');
+    if (!mapEl) return;
+
+    websdrSelectedReceiverIndex = point.receiverIndex;
+    renderReceiverList(websdrReceivers);
+    plotReceiversOnGlobe(websdrReceivers);
+
+    websdrGlobePopup.innerHTML = `
+        <div style="display: flex; justify-content: space-between; align-items: start; gap: 10px; margin-bottom: 6px;">
+            <strong style="font-size: 12px; color: var(--accent-cyan);">${escapeHtmlWebsdr(rx.name)}</strong>
+            <button type="button" data-websdr-popup-close style="border: none; background: transparent; color: var(--text-muted); cursor: pointer; font-size: 14px; line-height: 1;">&times;</button>
+        </div>
+        ${rx.location ? `<div style="font-size: 10px; color: var(--text-secondary); margin-bottom: 3px;">${escapeHtmlWebsdr(rx.location)}</div>` : ''}
+        <div style="font-size: 10px; color: var(--text-muted); margin-bottom: 2px;">Antenna: ${escapeHtmlWebsdr(rx.antenna || 'Unknown')}</div>
+        <div style="font-size: 10px; color: var(--text-muted); margin-bottom: 10px;">Users: ${rx.users}/${rx.users_max}</div>
+        <button type="button" data-websdr-listen style="width: 100%; padding: 5px 10px; background: #00d4ff; color: #041018; border: none; border-radius: 4px; cursor: pointer; font-weight: 700;">Listen</button>
+    `;
+    websdrGlobePopup.style.display = 'block';
+
+    const rect = mapEl.getBoundingClientRect();
+    const x = event && Number.isFinite(event.clientX) ? (event.clientX - rect.left) : (rect.width / 2);
+    const y = event && Number.isFinite(event.clientY) ? (event.clientY - rect.top) : (rect.height / 2);
+    const popupWidth = 260;
+    const popupHeight = 155;
+    const left = Math.max(12, Math.min(rect.width - popupWidth - 12, x + 12));
+    const top = Math.max(12, Math.min(rect.height - popupHeight - 12, y + 12));
+    websdrGlobePopup.style.left = `${left}px`;
+    websdrGlobePopup.style.top = `${top}px`;
+
+    const closeBtn = websdrGlobePopup.querySelector('[data-websdr-popup-close]');
+    if (closeBtn) {
+        closeBtn.onclick = () => hideWebsdrGlobePopup();
+    }
+    const listenBtn = websdrGlobePopup.querySelector('[data-websdr-listen]');
+    if (listenBtn) {
+        listenBtn.onclick = () => selectReceiver(point.receiverIndex);
+    }
+
+    if (event && typeof event.stopPropagation === 'function') {
+        event.stopPropagation();
+    }
+}
+
+function hideWebsdrGlobePopup() {
+    if (websdrGlobePopup) {
+        websdrGlobePopup.style.display = 'none';
+    }
+}
+
+function buildWebsdrPointLabel(rx, idx) {
+    const location = rx.location ? escapeHtmlWebsdr(rx.location) : 'Unknown location';
+    const antenna = escapeHtmlWebsdr(rx.antenna || 'Unknown antenna');
+    return `
+        <div style="padding: 4px 6px; font-size: 11px; background: rgba(4, 12, 19, 0.9); border: 1px solid rgba(0,212,255,0.28); border-radius: 4px;">
+            <div style="color: #00d4ff; font-weight: 600;">${escapeHtmlWebsdr(rx.name)}</div>
+            <div style="color: #a5b1c3;">${location}</div>
+            <div style="color: #8f9fb3;">${antenna} · ${rx.users}/${rx.users_max}</div>
+            <div style="color: #7a899b; margin-top: 2px;">Receiver #${idx + 1}</div>
+        </div>
+    `;
+}
+
 // ============== RECEIVER LIST ==============
 
 function renderReceiverList(receivers) {
@@ -155,12 +561,16 @@ function renderReceiverList(receivers) {
         return;
     }
 
-    container.innerHTML = receivers.slice(0, 50).map((rx, idx) => `
+    container.innerHTML = receivers.slice(0, 50).map((rx, idx) => {
-        <div style="padding: 8px; border-bottom: 1px solid rgba(255,255,255,0.05); cursor: pointer; transition: background 0.2s;"
+        const selected = idx === websdrSelectedReceiverIndex;
-             onmouseover="this.style.background='rgba(0,212,255,0.05)'" onmouseout="this.style.background='transparent'"
+        const baseBg = selected ? 'rgba(0,212,255,0.14)' : 'transparent';
+        const hoverBg = selected ? 'rgba(0,212,255,0.18)' : 'rgba(0,212,255,0.05)';
+        return `
+        <div style="padding: 8px 8px 8px 10px; border-bottom: 1px solid rgba(255,255,255,0.05); cursor: pointer; transition: background 0.2s; border-left: 2px solid ${selected ? 'var(--accent-cyan)' : 'transparent'}; background: ${baseBg};"
+             onmouseover="this.style.background='${hoverBg}'" onmouseout="this.style.background='${baseBg}'"
              onclick="selectReceiver(${idx})">
             <div style="display: flex; justify-content: space-between; align-items: center;">
-                <strong style="font-size: 11px; color: var(--text-primary);">${escapeHtmlWebsdr(rx.name)}</strong>
+                <strong style="font-size: 11px; color: ${selected ? 'var(--accent-cyan)' : 'var(--text-primary)'};">${escapeHtmlWebsdr(rx.name)}</strong>
                 <span style="font-size: 9px; padding: 1px 6px; background: ${rx.available ? 'rgba(0,230,118,0.15)' : 'rgba(158,158,158,0.15)'}; color: ${rx.available ? '#00e676' : '#9e9e9e'}; border-radius: 3px;">${rx.users}/${rx.users_max}</span>
             </div>
             <div style="font-size: 9px; color: var(--text-muted); margin-top: 2px;">
@@ -168,7 +578,8 @@ function renderReceiverList(receivers) {
                 ${rx.distance_km !== undefined ? ` · ${rx.distance_km} km` : ''}
             </div>
         </div>
-    `).join('');
+    `;
+    }).join('');
 }
 
 // ============== SELECT RECEIVER ==============
@@ -180,14 +591,30 @@ function selectReceiver(index) {
     const freqKhz = parseFloat(document.getElementById('websdrFrequency')?.value || 7000);
     const mode = document.getElementById('websdrMode_select')?.value || 'am';
 
+    websdrSelectedReceiverIndex = index;
+    renderReceiverList(websdrReceivers);
+    focusReceiverOnMap(rx);
+    hideWebsdrGlobePopup();
+
     kiwiReceiverName = rx.name;
 
     // Connect via backend proxy
     connectToReceiver(rx.url, freqKhz, mode);
+}
 
-    // Highlight on map
+function focusReceiverOnMap(rx) {
-    if (websdrMap && rx.lat != null && rx.lon != null) {
+    const lat = Number(rx.lat);
-        websdrMap.setView([rx.lat, rx.lon], 6);
+    const lon = Number(rx.lon);
+    if (!Number.isFinite(lat) || !Number.isFinite(lon)) return;
+
+    if (websdrMapType === 'globe' && websdrGlobe) {
+        plotReceiversOnGlobe(websdrReceivers);
+        websdrGlobe.pointOfView({ lat: lat, lng: lon, altitude: 1.4 }, 900);
+        return;
+    }
+
+    if (websdrMap) {
+        websdrMap.setView([lat, lon], 6);
     }
 }
 
@@ -551,6 +978,8 @@ function tuneToSpyStation(stationId, freqKhz) {
         .then(data => {
             if (data.status === 'success') {
                 websdrReceivers = data.receivers || [];
+                websdrSelectedReceiverIndex = null;
+                hideWebsdrGlobePopup();
                 renderReceiverList(websdrReceivers);
                 plotReceiversOnMap(websdrReceivers);
 
@@ -576,6 +1005,15 @@ function escapeHtmlWebsdr(str) {
 
 // ============== EXPORTS ==============
 
+/**
+ * Destroy — disconnect audio and clear S-meter timer for clean mode switching.
+ */
+function destroyWebSDR() {
+    disconnectFromReceiver();
+}
+
+const WebSDR = { destroy: destroyWebSDR };
+
 window.initWebSDR = initWebSDR;
 window.searchReceivers = searchReceivers;
 window.selectReceiver = selectReceiver;
@@ -586,3 +1024,4 @@ window.disconnectFromReceiver = disconnectFromReceiver;
 window.tuneKiwi = tuneKiwi;
 window.tuneFromBar = tuneFromBar;
 window.setKiwiVolume = setKiwiVolume;
+window.WebSDR = WebSDR;

static/js/modes/wifi.js

@@ -590,20 +590,35 @@ const WiFiMode = (function() {
             eventSource = null;
         }
 
+        // Update UI immediately so mode transitions are responsive even if the
+        // backend needs extra time to terminate subprocesses.
+        setScanning(false);
+
         // Stop scan on server (local or agent)
         const isAgentMode = typeof currentAgent !== 'undefined' && currentAgent !== 'local';
+        const timeoutMs = isAgentMode ? 8000 : 2200;
+        const controller = (typeof AbortController !== 'undefined') ? new AbortController() : null;
+        const timeoutId = controller ? setTimeout(() => controller.abort(), timeoutMs) : null;
 
         try {
             if (isAgentMode) {
-                await fetch(`/controller/agents/${currentAgent}/wifi/stop`, { method: 'POST' });
+                await fetch(`/controller/agents/${currentAgent}/wifi/stop`, {
+                    method: 'POST',
+                    ...(controller ? { signal: controller.signal } : {}),
+                });
             } else if (scanMode === 'deep') {
-                await fetch(`${CONFIG.apiBase}/scan/stop`, { method: 'POST' });
+                await fetch(`${CONFIG.apiBase}/scan/stop`, {
+                    method: 'POST',
+                    ...(controller ? { signal: controller.signal } : {}),
+                });
             }
         } catch (error) {
             console.warn('[WiFiMode] Error stopping scan:', error);
+        } finally {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
         }
-
-        setScanning(false);
     }
 
     function setScanning(scanning, mode = null) {
@@ -1796,7 +1811,28 @@ const WiFiMode = (function() {
         onNetworkUpdate: (cb) => { onNetworkUpdate = cb; },
         onClientUpdate: (cb) => { onClientUpdate = cb; },
         onProbeRequest: (cb) => { onProbeRequest = cb; },
+
+        // Lifecycle
+        destroy,
     };
+
+    /**
+     * Destroy — close SSE stream and clear polling timers for clean mode switching.
+     */
+    function destroy() {
+        if (eventSource) {
+            eventSource.close();
+            eventSource = null;
+        }
+        if (pollTimer) {
+            clearInterval(pollTimer);
+            pollTimer = null;
+        }
+        if (agentPollTimer) {
+            clearInterval(agentPollTimer);
+            agentPollTimer = null;
+        }
+    }
 })();
 
 // Auto-initialize when DOM is ready

static/js/vendor/leaflet-heat.js

@@ -0,0 +1,297 @@
+/*
+ * Leaflet.heat — a tiny, fast Leaflet heatmap plugin
+ * https://github.com/Leaflet/Leaflet.heat
+ * (c) 2014, Vladimir Agafonkin
+ * MIT License
+ *
+ * Bundled local copy for INTERCEPT — avoids CDN dependency.
+ * Includes simpleheat (https://github.com/mourner/simpleheat), MIT License.
+ */
+
+// ---- simpleheat ----
+(function (global, factory) {
+    typeof define === 'function' && define.amd ? define(factory) :
+    typeof exports !== 'undefined' ? module.exports = factory() :
+    global.simpleheat = factory();
+}(this, function () {
+    'use strict';
+
+    function simpleheat(canvas) {
+        if (!(this instanceof simpleheat)) return new simpleheat(canvas);
+        this._canvas = canvas = typeof canvas === 'string' ? document.getElementById(canvas) : canvas;
+        this._ctx = canvas.getContext('2d');
+        this._width = canvas.width;
+        this._height = canvas.height;
+        this._max = 1;
+        this._data = [];
+    }
+
+    simpleheat.prototype = {
+        defaultRadius: 25,
+        defaultGradient: {
+            0.4: 'blue',
+            0.6: 'cyan',
+            0.7: 'lime',
+            0.8: 'yellow',
+            1.0: 'red'
+        },
+
+        data: function (data) {
+            this._data = data;
+            return this;
+        },
+
+        max: function (max) {
+            this._max = max;
+            return this;
+        },
+
+        add: function (point) {
+            this._data.push(point);
+            return this;
+        },
+
+        clear: function () {
+            this._data = [];
+            return this;
+        },
+
+        radius: function (r, blur) {
+            blur = blur === undefined ? 15 : blur;
+            var circle = this._circle = this._createCanvas(),
+                ctx = circle.getContext('2d'),
+                r2 = this._r = r + blur;
+            circle.width = circle.height = r2 * 2;
+            ctx.shadowOffsetX = ctx.shadowOffsetY = r2 * 2;
+            ctx.shadowBlur = blur;
+            ctx.shadowColor = 'black';
+            ctx.beginPath();
+            ctx.arc(-r2, -r2, r, 0, Math.PI * 2, true);
+            ctx.closePath();
+            ctx.fill();
+            return this;
+        },
+
+        resize: function () {
+            this._width  = this._canvas.width;
+            this._height = this._canvas.height;
+        },
+
+        gradient: function (grad) {
+            var canvas = this._createCanvas(),
+                ctx = canvas.getContext('2d'),
+                gradient = ctx.createLinearGradient(0, 0, 0, 256);
+            canvas.width = 1;
+            canvas.height = 256;
+            for (var i in grad) {
+                gradient.addColorStop(+i, grad[i]);
+            }
+            ctx.fillStyle = gradient;
+            ctx.fillRect(0, 0, 1, 256);
+            this._grad = ctx.getImageData(0, 0, 1, 256).data;
+            return this;
+        },
+
+        draw: function (minOpacity) {
+            if (!this._circle) this.radius(this.defaultRadius);
+            if (!this._grad)   this.gradient(this.defaultGradient);
+
+            var ctx = this._ctx;
+            ctx.clearRect(0, 0, this._width, this._height);
+
+            for (var i = 0, len = this._data.length, p; i < len; i++) {
+                p = this._data[i];
+                ctx.globalAlpha = Math.min(Math.max(p[2] / this._max, minOpacity === undefined ? 0.05 : minOpacity), 1);
+                ctx.drawImage(this._circle, p[0] - this._r, p[1] - this._r);
+            }
+
+            var colored = ctx.getImageData(0, 0, this._width, this._height);
+            this._colorize(colored.data, this._grad);
+            ctx.putImageData(colored, 0, 0);
+
+            return this;
+        },
+
+        _colorize: function (pixels, gradient) {
+            for (var i = 3, len = pixels.length, j; i < len; i += 4) {
+                j = pixels[i] * 4;
+                if (j) {
+                    pixels[i - 3] = gradient[j];
+                    pixels[i - 2] = gradient[j + 1];
+                    pixels[i - 1] = gradient[j + 2];
+                }
+            }
+        },
+
+        _createCanvas: function () {
+            if (typeof document !== 'undefined') {
+                return document.createElement('canvas');
+            }
+            return { getContext: function () {} };
+        }
+    };
+
+    return simpleheat;
+}));
+
+// ---- Leaflet.heat plugin ----
+(function () {
+    if (typeof L === 'undefined') return;
+
+    L.HeatLayer = (L.Layer ? L.Layer : L.Class).extend({
+        initialize: function (latlngs, options) {
+            this._latlngs = latlngs;
+            L.setOptions(this, options);
+        },
+
+        setLatLngs: function (latlngs) {
+            this._latlngs = latlngs;
+            return this.redraw();
+        },
+
+        addLatLng: function (latlng) {
+            this._latlngs.push(latlng);
+            return this.redraw();
+        },
+
+        setOptions: function (options) {
+            L.setOptions(this, options);
+            if (this._heat) this._updateOptions();
+            return this.redraw();
+        },
+
+        redraw: function () {
+            if (this._heat && !this._frame && this._map && !this._map._animating) {
+                this._frame = L.Util.requestAnimFrame(this._redraw, this);
+            }
+            return this;
+        },
+
+        onAdd: function (map) {
+            this._map = map;
+            if (!this._canvas) this._initCanvas();
+            if (this.options.pane) this.getPane().appendChild(this._canvas);
+            else map._panes.overlayPane.appendChild(this._canvas);
+            map.on('moveend', this._reset, this);
+            if (map.options.zoomAnimation && L.Browser.any3d) {
+                map.on('zoomanim', this._animateZoom, this);
+            }
+            this._reset();
+        },
+
+        onRemove: function (map) {
+            if (this.options.pane) this.getPane().removeChild(this._canvas);
+            else map.getPanes().overlayPane.removeChild(this._canvas);
+            map.off('moveend', this._reset, this);
+            if (map.options.zoomAnimation) {
+                map.off('zoomanim', this._animateZoom, this);
+            }
+        },
+
+        addTo: function (map) {
+            map.addLayer(this);
+            return this;
+        },
+
+        _initCanvas: function () {
+            var canvas = this._canvas = L.DomUtil.create('canvas', 'leaflet-heatmap-layer leaflet-layer');
+            var originProp = L.DomUtil.testProp(['transformOrigin', 'WebkitTransformOrigin', 'msTransformOrigin']);
+            canvas.style[originProp] = '50% 50%';
+            var size = this._map.getSize();
+            canvas.width  = size.x;
+            canvas.height = size.y;
+            var animated = this._map.options.zoomAnimation && L.Browser.any3d;
+            L.DomUtil.addClass(canvas, 'leaflet-zoom-' + (animated ? 'animated' : 'hide'));
+            this._heat = simpleheat(canvas);
+            this._updateOptions();
+        },
+
+        _updateOptions: function () {
+            this._heat.radius(this.options.radius || this._heat.defaultRadius, this.options.blur);
+            if (this.options.gradient) this._heat.gradient(this.options.gradient);
+            if (this.options.minOpacity) this._heat.minOpacity = this.options.minOpacity;
+        },
+
+        _reset: function () {
+            var topLeft = this._map.containerPointToLayerPoint([0, 0]);
+            L.DomUtil.setPosition(this._canvas, topLeft);
+            var size = this._map.getSize();
+            if (this._heat._width !== size.x) {
+                this._canvas.width  = this._heat._width  = size.x;
+            }
+            if (this._heat._height !== size.y) {
+                this._canvas.height = this._heat._height = size.y;
+            }
+            this._redraw();
+        },
+
+        _redraw: function () {
+            this._frame = null;
+            if (!this._map) return;
+            var data = [],
+                r    = this._heat._r,
+                size = this._map.getSize(),
+                bounds = new L.Bounds(L.point([-r, -r]), size.add([r, r])),
+                max  = this.options.max === undefined ? 1 : this.options.max,
+                maxZoom = this.options.maxZoom === undefined ? this._map.getMaxZoom() : this.options.maxZoom,
+                v   = 1 / Math.pow(2, Math.max(0, Math.min(maxZoom - this._map.getZoom(), 12))),
+                cellSize = r / 2,
+                grid = [],
+                panePos = this._map._getMapPanePos(),
+                offsetX = panePos.x % cellSize,
+                offsetY = panePos.y % cellSize,
+                i, len, p, cell, x, y, j, len2, k;
+
+            for (i = 0, len = this._latlngs.length; i < len; i++) {
+                p = this._map.latLngToContainerPoint(this._latlngs[i]);
+                if (bounds.contains(p)) {
+                    x = Math.floor((p.x - offsetX) / cellSize) + 2;
+                    y = Math.floor((p.y - offsetY) / cellSize) + 2;
+                    var alt = this._latlngs[i].alt !== undefined ? this._latlngs[i].alt :
+                              this._latlngs[i][2] !== undefined ? +this._latlngs[i][2] : 1;
+                    k = alt * v;
+                    grid[y] = grid[y] || [];
+                    cell = grid[y][x];
+                    if (!cell) {
+                        grid[y][x] = [p.x, p.y, k];
+                    } else {
+                        cell[0] = (cell[0] * cell[2] + p.x * k) / (cell[2] + k);
+                        cell[1] = (cell[1] * cell[2] + p.y * k) / (cell[2] + k);
+                        cell[2] += k;
+                    }
+                }
+            }
+
+            for (i = 0, len = grid.length; i < len; i++) {
+                if (grid[i]) {
+                    for (j = 0, len2 = grid[i].length; j < len2; j++) {
+                        cell = grid[i][j];
+                        if (cell) {
+                            data.push([
+                                Math.round(cell[0]),
+                                Math.round(cell[1]),
+                                Math.min(cell[2], max)
+                            ]);
+                        }
+                    }
+                }
+            }
+
+            this._heat.data(data).draw(this.options.minOpacity);
+        },
+
+        _animateZoom: function (e) {
+            var scale = this._map.getZoomScale(e.zoom),
+                offset = this._map._getCenterOffset(e.center)._multiplyBy(-scale).subtract(this._map._getMapPanePos());
+            if (L.DomUtil.setTransform) {
+                L.DomUtil.setTransform(this._canvas, offset, scale);
+            } else {
+                this._canvas.style[L.DomUtil.TRANSFORM] = L.DomUtil.getTranslateString(offset) + ' scale(' + scale + ')';
+            }
+        }
+    });
+
+    L.heatLayer = function (latlngs, options) {
+        return new L.HeatLayer(latlngs, options);
+    };
+}());

static/manifest.json

@@ -0,0 +1,27 @@
+{
+  "name": "INTERCEPT Signal Intelligence",
+  "short_name": "INTERCEPT",
+  "description": "Unified SIGINT platform for software-defined radio analysis",
+  "start_url": "/",
+  "scope": "/",
+  "display": "standalone",
+  "background_color": "#0b1118",
+  "theme_color": "#0b1118",
+  "icons": [
+    {
+      "src": "/static/icons/icon-192.png",
+      "sizes": "192x192",
+      "type": "image/png"
+    },
+    {
+      "src": "/static/icons/icon-512.png",
+      "sizes": "512x512",
+      "type": "image/png"
+    },
+    {
+      "src": "/static/icons/icon.svg",
+      "sizes": "any",
+      "type": "image/svg+xml"
+    }
+  ]
+}

static/sw.js

@@ -0,0 +1,122 @@
+/* INTERCEPT Service Worker — cache-first static, network-only for API/SSE/WS */
+const CACHE_NAME = 'intercept-v3';
+
+const NETWORK_ONLY_PREFIXES = [
+    '/stream', '/ws/', '/api/', '/gps/', '/wifi/', '/bluetooth/',
+    '/adsb/', '/ais/', '/acars/', '/aprs/', '/tscm/', '/satellite/',
+    '/meshtastic/', '/bt_locate/', '/receiver/', '/sensor/', '/pager/',
+    '/sstv/', '/weather-sat/', '/subghz/', '/rtlamr/', '/dsc/', '/vdl2/',
+    '/spy/', '/space-weather/', '/websdr/', '/analytics/', '/correlation/',
+    '/recordings/', '/controller/', '/ops/',
+];
+
+const STATIC_PREFIXES = [
+    '/static/css/',
+    '/static/js/',
+    '/static/icons/',
+    '/static/fonts/',
+];
+
+const CACHE_EXACT = ['/manifest.json'];
+
+function isHttpRequest(req) {
+    const url = new URL(req.url);
+    return url.protocol === 'http:' || url.protocol === 'https:';
+}
+
+function isNetworkOnly(req) {
+    if (req.method !== 'GET') return true;
+    const accept = req.headers.get('Accept') || '';
+    if (accept.includes('text/event-stream')) return true;
+    const url = new URL(req.url);
+    return NETWORK_ONLY_PREFIXES.some(p => url.pathname.startsWith(p));
+}
+
+function isStaticAsset(req) {
+    const url = new URL(req.url);
+    if (CACHE_EXACT.includes(url.pathname)) return true;
+    return STATIC_PREFIXES.some(p => url.pathname.startsWith(p));
+}
+
+function fallbackResponse(req, status = 503) {
+    const accept = req.headers.get('Accept') || '';
+    if (accept.includes('application/json')) {
+        return new Response(
+            JSON.stringify({ status: 'error', message: 'Network unavailable' }),
+            {
+                status,
+                headers: { 'Content-Type': 'application/json' },
+            }
+        );
+    }
+
+    if (accept.includes('text/event-stream')) {
+        return new Response('', {
+            status,
+            headers: { 'Content-Type': 'text/event-stream' },
+        });
+    }
+
+    return new Response('Offline', {
+        status,
+        headers: { 'Content-Type': 'text/plain; charset=utf-8' },
+    });
+}
+
+self.addEventListener('install', (e) => {
+    self.skipWaiting();
+});
+
+self.addEventListener('activate', (e) => {
+    e.waitUntil(
+        caches.keys().then(keys =>
+            Promise.all(keys.filter(k => k !== CACHE_NAME).map(k => caches.delete(k)))
+        ).then(() => self.clients.claim())
+    );
+});
+
+self.addEventListener('fetch', (e) => {
+    const req = e.request;
+
+    // Ignore non-HTTP(S) requests so extensions/browser-internal URLs are untouched.
+    if (!isHttpRequest(req)) {
+        return;
+    }
+
+    // Always bypass service worker for non-GET and streaming routes
+    if (isNetworkOnly(req)) {
+        e.respondWith(
+            fetch(req).catch(() => fallbackResponse(req, 503))
+        );
+        return;
+    }
+
+    // Cache-first for static assets
+    if (isStaticAsset(req)) {
+        e.respondWith(
+            caches.open(CACHE_NAME).then(cache =>
+                cache.match(req).then(cached => {
+                    if (cached) {
+                        // Revalidate in background
+                        fetch(req).then(res => {
+                            if (res && res.status === 200) cache.put(req, res.clone());
+                        }).catch(() => {});
+                        return cached;
+                    }
+                    return fetch(req).then(res => {
+                        if (res && res.status === 200) cache.put(req, res.clone());
+                        return res;
+                    }).catch(() => fallbackResponse(req, 504));
+                })
+            )
+        );
+        return;
+    }
+
+    // Network-first for HTML pages
+    e.respondWith(
+        fetch(req).catch(() =>
+            caches.match(req).then(cached => cached || new Response('Offline', { status: 503 }))
+        )
+    );
+});