Bump version to 2.14.0 and update changelog/documentation

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

.gitignore

@@ -10,17 +10,17 @@ venv/
 ENV/
 uv.lock
 
-# Logs
-*.log
-pager_messages.log
-
-# Local data
-downloads/
-pgdata/
-
-# Local data
-downloads/
-pgdata/
+# Logs
+*.log
+pager_messages.log
+
+# Local data
+downloads/
+pgdata/
+
+# Local data
+downloads/
+pgdata/
 
 # IDE
 .idea/
@@ -42,4 +42,15 @@ build/
 uv.lock
 *.db
 *.sqlite3
-intercept.db
+intercept.db
+
+# Instance folder (contains database with user data)
+instance/
+
+# Agent configs with real credentials (keep template only)
+intercept_agent_*.cfg
+!intercept_agent.cfg
+
+# Temporary files
+/tmp/
+*.tmp

CHANGELOG.md

@@ -2,6 +2,200 @@
 
 All notable changes to iNTERCEPT will be documented in this file.
 
+## [2.14.0] - 2026-02-06
+
+### Added
+- **DMR Digital Voice Decoder** - Decode DMR, P25, NXDN, and D-STAR protocols
+  - Integration with dsd-fme (Digital Speech Decoder - Florida Man Edition)
+  - Real-time SSE streaming of sync, call, voice, and slot events
+  - Call history table with talkgroup, source ID, and protocol tracking
+  - Protocol auto-detection or manual selection
+  - Pipeline error diagnostics with rtl_fm stderr capture
+- **DMR Visual Synthesizer** - Canvas-based signal activity visualization
+  - Spring-physics animated bars reacting to SSE decoder events
+  - Color-coded by event type: cyan (sync), green (call), orange (voice)
+  - Center-outward ripple bursts on sync events
+  - Smooth decay and idle breathing animation
+  - Responsive canvas with window resize handling
+- **HF SSTV General Mode** - Terrestrial slow-scan TV on shortwave frequencies
+  - Predefined HF SSTV frequencies (14.230, 21.340, 28.680 MHz, etc.)
+  - Modulation support for USB/LSB reception
+- **WebSDR Integration** - Remote HF/shortwave listening via WebSDR servers
+- **Listening Post Enhancements** - Improved signal scanner and audio handling
+
+### Fixed
+- APRS rtl_fm startup failure and SDR device conflicts
+- DSD voice decoder detection for dsd-fme and PulseAudio errors
+- dsd-fme protocol flags and ncurses disable for headless operation
+- dsd-fme audio output flag for pipeline compatibility
+- TSCM sweep scan resilience with per-device error isolation
+- TSCM WiFi detection using scanner singleton for device availability
+- TSCM correlation and cluster emission fixes
+- Detected Threats panel items now clickable to show device details
+- Proximity radar tooltip flicker on hover
+- Radar blip flicker by deferring renders during hover
+- ISS position API priority swap to avoid timeout delays
+- Updater settings panel error when updater.js is blocked
+- Missing scapy in optionals dependency group
+
+---
+
+## [2.13.1] - 2026-02-04
+
+### Added
+- **UI Overhaul** - Revamped styling with slate/cyan theme
+  - Switched app font to JetBrains Mono
+  - Global navigation bar across all dashboards
+  - Cyan-tinted map tiles as default
+- **Signal Scanner Rewrite** - Switched to rtl_power sweep for better coverage
+  - SNR column added to signal hits table
+  - SNR threshold control for power scan
+  - Improved sweep progress tracking and stability
+  - Frequency-based sweep display with range syncing
+- **Listening Post Audio** - WAV streaming with retry and fallback
+  - WebSocket audio fallback for listening
+  - User-initiated audio play prompt
+  - Audio pipeline restart for fresh stream headers
+
+### Fixed
+- WiFi connected clients panel now filters to selected AP instead of showing all clients
+- USB device contention when starting audio pipeline
+- Dual scrollbar issue on main dashboard
+- Controls bar alignment in dashboard pages
+- Mode query routing from dashboard nav
+
+---
+
+## [2.13.0] - 2026-02-04
+
+### Added
+- **WiFi Client Display** - Connected clients shown in AP detail drawer
+  - Real-time client updates via SSE streaming
+  - Probed SSID badges for connected clients
+  - Signal strength indicators and vendor identification
+- **Help Modal** - Keyboard shortcuts reference system
+- **Main Dashboard Button** - Quick navigation from any page
+- **Settings Modal** - Accessible from all dashboards
+
+### Changed
+- Dashboard CSS improvements and consistency fixes
+
+---
+
+## [2.12.1] - 2026-02-02
+
+### Added
+- **SDR Device Registry** - Prevents decoder conflicts between concurrent modes
+- **SDR Device Status Panel** - Shows connected SDR devices with ADS-B Bias-T toggle
+- **Real-time Doppler Tracking** - ISS SSTV reception with Doppler correction
+- **TCP Connection Support** - Meshtastic devices connectable over TCP
+- **Shared Observer Location** - Configurable shared location with auto-start options
+- **slowrx Source Build** - Fallback build for Debian/Ubuntu
+
+### Fixed
+- SDR device type not synced on page refresh
+- Meshtastic connection type not restored on page refresh
+- WiFi deep scan polling on agent with normalized scan_type value
+- Auto-detect RTL-SDR drivers and blacklist instead of prompting
+- TPMS pressure field mappings for 433MHz sensor display
+- Agent capabilities cache invalidation after monitor mode toggle
+
+---
+
+## [2.12.0] - 2026-01-29
+
+### Added
+- **ISS SSTV Decoder Mode** - Receive Slow Scan Television transmissions from the ISS
+  - Real-time ISS tracking globe with accurate position via N2YO API
+  - Leaflet world map showing ISS ground track and current position
+  - Location settings for ISS pass predictions
+  - Integration with satellite tracking TLE data
+- **GitHub Update Notifications** - Automatic new version alerts
+  - Checks for updates on app startup
+  - Unobtrusive notification when new releases are available
+  - Configurable check interval via settings
+- **Meshtastic Enhancements**
+  - QR code support for easy device sharing
+  - Telemetry display with battery, voltage, and environmental data
+  - Traceroute visualization for mesh network topology
+  - Improved node synchronization between map and top bar
+- **UI Improvements**
+  - New Space category for satellite and ISS-related modes
+  - Pulsating ring effect for tracked aircraft/vessels
+  - Map marker highlighting for selected aircraft in ADS-B
+  - Consolidated settings and dependencies into single modal
+- **Auto-Update TLE Data** - Satellite tracking data updates automatically on app startup
+- **GPS Auto-Connect** - AIS dashboard now connects to gpsd automatically
+
+### Changed
+- **Utility Meters** - Added device grouping by ID with consumption trends
+- **Utility Meters** - Device intelligence and manufacturer information display
+
+### Fixed
+- **SoapySDR** - Module detection on macOS with Homebrew
+- **dump1090** - Build failures in Docker containers
+- **dump1090** - Build failures on Kali Linux and newer GCC versions
+- **Flask** - Ensure Flask 3.0+ compatibility in setup script
+- **psycopg2** - Now optional for Flask/Werkzeug compatibility
+- **Bias-T** - Setting now properly passed to ADS-B and AIS dashboards
+- **Dark Mode Maps** - Removed CSS filter that was inverting dark tiles
+- **Map Tiles** - Fixed CARTO tile URLs and added cache-busting
+- **Meshtastic** - Traceroute button and dark mode map fixes
+- **ADS-B Dashboard** - Height adjustment to prevent bottom controls cutoff
+- **Audio Visualizer** - Now works without spectrum canvas
+
+---
+
+## [2.11.0] - 2026-01-28
+
+### Added
+- **Meshtastic Mesh Network Integration** - LoRa mesh communication support
+  - Connect to Meshtastic devices (Heltec, T-Beam, RAK) via USB/Serial
+  - Real-time message streaming via SSE
+  - Channel configuration with encryption key support
+  - Node information display with signal metrics (RSSI, SNR)
+  - Message history with up to 500 messages
+- **Ubertooth One BLE Scanner** - Advanced Bluetooth scanning
+  - Passive BLE packet capture across all 40 BLE channels
+  - Raw advertising payload access
+  - Integration with existing Bluetooth scanning modes
+  - Automatic detection of Ubertooth hardware
+- **Offline Mode** - Run iNTERCEPT without internet connectivity
+  - Bundled Leaflet 1.9.4 (JS, CSS, marker images)
+  - Bundled Chart.js 4.4.1
+  - Bundled Inter and JetBrains Mono fonts (woff2)
+  - Local asset status checking and validation
+- **Settings Modal** - New configuration interface accessible from navigation
+  - Offline tab: Toggle offline mode, configure asset sources
+  - Display tab: Theme and animation preferences
+  - About tab: Version info and links
+- **Multiple Map Tile Providers** - Choose from:
+  - OpenStreetMap (default)
+  - CartoDB Dark
+  - CartoDB Positron (light)
+  - ESRI World Imagery
+  - Custom tile server URL
+
+### Changed
+- **Dashboard Templates** - Conditional asset loading based on offline settings
+- **Bluetooth Scanner** - Added Ubertooth backend alongside BlueZ/DBus
+- **Dependencies** - Added meshtastic SDK to requirements.txt
+
+### Technical
+- Added `routes/meshtastic.py` for Meshtastic API endpoints
+- Added `utils/meshtastic.py` for device management
+- Added `utils/bluetooth/ubertooth_scanner.py` for Ubertooth support
+- Added `routes/offline.py` for offline mode API
+- Added `static/js/core/settings-manager.js` for client-side settings
+- Added `static/css/settings.css` for settings modal styles
+- Added `static/css/modes/meshtastic.css` for Meshtastic UI
+- Added `static/js/modes/meshtastic.js` for Meshtastic frontend
+- Added `templates/partials/modes/meshtastic.html` for Meshtastic mode
+- Added `templates/partials/settings-modal.html` for settings UI
+- Added `static/vendor/` directory structure for bundled assets
+
+---
+
 ## [2.10.0] - 2026-01-25
 
 ### Added

Dockerfile

@@ -63,11 +63,16 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     libcurl4-openssl-dev \
     zlib1g-dev \
     libzmq3-dev \
+    libpulse-dev \
+    libfftw3-dev \
+    liblapack-dev \
+    libcodec2-dev \
     # Build dump1090
     && cd /tmp \
     && git clone --depth 1 https://github.com/flightaware/dump1090.git \
     && cd dump1090 \
-    && make \
+    && sed -i 's/-Werror//g' Makefile \
+    && make BLADERF=no RTLSDR=yes \
     && cp dump1090 /usr/bin/dump1090-fa \
     && ln -s /usr/bin/dump1090-fa /usr/bin/dump1090 \
     && rm -rf /tmp/dump1090 \
@@ -108,6 +113,27 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     && make \
     && cp acarsdec /usr/bin/acarsdec \
     && rm -rf /tmp/acarsdec \
+    # 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
     && apt-get remove -y \
     build-essential \
@@ -123,6 +149,10 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     libcurl4-openssl-dev \
     zlib1g-dev \
     libzmq3-dev \
+    libpulse-dev \
+    libfftw3-dev \
+    liblapack-dev \
+    libcodec2-dev \
     && apt-get autoremove -y \
     && rm -rf /var/lib/apt/lists/*
 

README.md

@@ -31,12 +31,20 @@ Support the developer of this open-source project
 - **Aircraft Tracking** - ADS-B via dump1090 with real-time map and radar
 - **Vessel Tracking** - AIS ship tracking with VHF DSC distress monitoring
 - **ACARS Messaging** - Aircraft datalink messages via acarsdec
+- **DMR Digital Voice** - DMR/P25/NXDN/D-STAR decoding via dsd-fme with visual synthesizer
 - **Listening Post** - Frequency scanner with audio monitoring
+- **WebSDR** - Remote HF/shortwave listening via WebSDR servers
+- **ISS SSTV** - Receive slow-scan TV from the International Space Station
+- **HF SSTV** - Terrestrial SSTV on shortwave frequencies
 - **Satellite Tracking** - Pass prediction using TLE data
 - **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
+- **Bluetooth Scanning** - Device discovery and tracker detection (with Ubertooth support)
+- **TSCM** - Counter-surveillance with RF baseline comparison and threat detection
+- **Meshtastic** - LoRa mesh network integration
 - **Spy Stations** - Number stations and diplomatic HF network database
+- **Remote Agents** - Distributed SIGINT with remote sensor nodes
+- **Offline Mode** - Bundled assets for air-gapped/field deployments
 
 ---
 
@@ -71,6 +79,47 @@ The ADS-B history feature persists aircraft messages to Postgres for long-term a
 docker compose --profile history up -d
 ```
 
+Set the following environment variables (for example in a `.env` file):
+
+```bash
+INTERCEPT_ADSB_HISTORY_ENABLED=true
+INTERCEPT_ADSB_DB_HOST=adsb_db
+INTERCEPT_ADSB_DB_PORT=5432
+INTERCEPT_ADSB_DB_NAME=intercept_adsb
+INTERCEPT_ADSB_DB_USER=intercept
+INTERCEPT_ADSB_DB_PASSWORD=intercept
+```
+
+### Other ADS-B Settings
+
+Set these as environment variables for either local installs or Docker:
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `INTERCEPT_ADSB_AUTO_START` | `false` | Auto-start ADS-B tracking when the dashboard loads |
+| `INTERCEPT_SHARED_OBSERVER_LOCATION` | `true` | Share observer location across ADS-B/AIS/SSTV/Satellite modules |
+
+**Local install example**
+
+```bash
+INTERCEPT_ADSB_AUTO_START=true \
+INTERCEPT_SHARED_OBSERVER_LOCATION=false \
+python app.py
+```
+
+**Docker example (.env)**
+
+```bash
+INTERCEPT_ADSB_AUTO_START=true
+INTERCEPT_SHARED_OBSERVER_LOCATION=false
+```
+
+To store Postgres data on external storage, set `PGDATA_PATH` (defaults to `./pgdata`):
+
+```bash
+PGDATA_PATH=/mnt/usbpi1/intercept/pgdata
+```
+
 Then open **/adsb/history** for the reporting dashboard.
 
 ### Open the Interface
@@ -114,6 +163,7 @@ Most features work with a basic RTL-SDR dongle (RTL2832U + R820T2).
 ## Documentation
 
 - [Usage Guide](docs/USAGE.md) - Detailed instructions for each mode
+- [Distributed Agents](docs/DISTRIBUTED_AGENTS.md) - Remote sensor node deployment
 - [Hardware Guide](docs/HARDWARE.md) - SDR hardware and advanced setup
 - [Troubleshooting](docs/TROUBLESHOOTING.md) - Common issues and solutions
 - [Security](docs/SECURITY.md) - Network security and best practices

aircraft_db_meta.json

@@ -1,4 +1,4 @@
 {
-  "version": "2026-01-11_fae1348c",
-  "downloaded": "2026-01-12T15:55:42.769654Z"
+  "version": "2026-02-01_ba81b697",
+  "downloaded": "2026-02-04T17:06:54.806043Z"
 }

app.py

@@ -27,7 +27,7 @@ from typing import Any
 
 from flask import Flask, render_template, jsonify, send_file, Response, request,redirect, url_for, flash, session
 from werkzeug.security import check_password_hash
-from config import VERSION, CHANGELOG
+from config import VERSION, CHANGELOG, SHARED_OBSERVER_LOCATION_ENABLED
 from utils.dependencies import check_tool, check_all_dependencies, TOOL_DEPENDENCIES
 from utils.process import cleanup_stale_processes
 from utils.sdr import SDRFactory
@@ -38,6 +38,7 @@ from utils.constants import (
     MAX_BT_DEVICE_AGE_SECONDS,
     MAX_VESSEL_AGE_SECONDS,
     MAX_DSC_MESSAGE_AGE_SECONDS,
+    MAX_DEAUTH_ALERTS_AGE_SECONDS,
     QUEUE_MAX_SIZE,
 )
 import logging
@@ -91,6 +92,25 @@ def add_security_headers(response):
     return response
 
 
+# ============================================
+# CONTEXT PROCESSORS
+# ============================================
+
+@app.context_processor
+def inject_offline_settings():
+    """Inject offline settings into all templates."""
+    from utils.database import get_setting
+    return {
+        'offline_settings': {
+            'enabled': get_setting('offline.enabled', False),
+            'assets_source': get_setting('offline.assets_source', 'cdn'),
+            'fonts_source': get_setting('offline.fonts_source', 'cdn'),
+            'tile_provider': get_setting('offline.tile_provider', 'cartodb_dark_cyan'),
+            'tile_server_url': get_setting('offline.tile_server_url', '')
+        }
+    }
+
+
 # ============================================
 # GLOBAL PROCESS MANAGEMENT
 # ============================================
@@ -152,10 +172,21 @@ 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()
 
+# Deauth Attack Detection
+deauth_detector = None
+deauth_detector_queue = queue.Queue(maxsize=QUEUE_MAX_SIZE)
+deauth_detector_lock = threading.Lock()
+
 # ============================================
 # GLOBAL STATE DICTIONARIES
 # ============================================
@@ -185,6 +216,9 @@ ais_vessels = DataStore(max_age_seconds=MAX_VESSEL_AGE_SECONDS, name='ais_vessel
 # DSC (Digital Selective Calling) state - using DataStore for automatic cleanup
 dsc_messages = DataStore(max_age_seconds=MAX_DSC_MESSAGE_AGE_SECONDS, name='dsc_messages')
 
+# Deauth alerts - using DataStore for automatic cleanup
+deauth_alerts = DataStore(max_age_seconds=MAX_DEAUTH_ALERTS_AGE_SECONDS, name='deauth_alerts')
+
 # Satellite state
 satellite_passes = []  # Predicted satellite passes (not auto-cleaned, calculated)
 
@@ -196,6 +230,53 @@ cleanup_manager.register(bt_beacons)
 cleanup_manager.register(adsb_aircraft)
 cleanup_manager.register(ais_vessels)
 cleanup_manager.register(dsc_messages)
+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)
+sdr_device_registry: dict[int, str] = {}
+sdr_device_registry_lock = threading.Lock()
+
+
+def claim_sdr_device(device_index: int, mode_name: str) -> str | None:
+    """Claim an SDR device for a mode.
+
+    Args:
+        device_index: The SDR device index to claim
+        mode_name: Name of the mode claiming the device (e.g., 'sensor', 'rtlamr')
+
+    Returns:
+        Error message if device is in use, None if successfully claimed
+    """
+    with sdr_device_registry_lock:
+        if device_index in sdr_device_registry:
+            in_use_by = sdr_device_registry[device_index]
+            return f'SDR device {device_index} is in use by {in_use_by}. Stop {in_use_by} first or use a different device.'
+        sdr_device_registry[device_index] = mode_name
+        return None
+
+
+def release_sdr_device(device_index: int) -> None:
+    """Release an SDR device from the registry.
+
+    Args:
+        device_index: The SDR device index to release
+    """
+    with sdr_device_registry_lock:
+        sdr_device_registry.pop(device_index, None)
+
+
+def get_sdr_device_status() -> dict[int, str]:
+    """Get current SDR device allocations.
+
+    Returns:
+        Dictionary mapping device indices to mode names
+    """
+    with sdr_device_registry_lock:
+        return dict(sdr_device_registry)
 
 
 # ============================================
@@ -203,9 +284,18 @@ cleanup_manager.register(dsc_messages)
 # ============================================
 
 @app.before_request
-def require_login():
-    # Routes that don't require login (to avoid infinite redirect loop)
-    allowed_routes = ['login', 'static', 'favicon', 'health', 'health_check']
+def require_login():
+    # Routes that don't require login (to avoid infinite redirect loop)
+    allowed_routes = ['login', 'static', 'favicon', 'health', 'health_check']
+
+    # Allow audio streaming endpoints without session auth
+    if request.path.startswith('/listening/audio/'):
+        return None
+
+    # Controller API endpoints use API key auth, not session auth
+    # Allow agent push/pull endpoints without session login
+    if request.path.startswith('/controller/'):
+        return None  # Skip session check, controller routes handle their own auth
 
     # If user is not logged in and the current route is not allowed...
     if 'logged_in' not in session and request.endpoint not in allowed_routes:
@@ -255,7 +345,14 @@ def index() -> str:
         'rtlamr': check_tool('rtlamr')
     }
     devices = [d.to_dict() for d in SDRFactory.detect_devices()]
-    return render_template('index.html', tools=tools, devices=devices, version=VERSION, changelog=CHANGELOG)
+    return render_template(
+        'index.html',
+        tools=tools,
+        devices=devices,
+        version=VERSION,
+        changelog=CHANGELOG,
+        shared_observer_location=SHARED_OBSERVER_LOCATION_ENABLED,
+    )
 
 
 @app.route('/favicon.svg')
@@ -270,6 +367,22 @@ def get_devices() -> Response:
     return jsonify([d.to_dict() for d in devices])
 
 
+@app.route('/devices/status')
+def get_devices_status() -> Response:
+    """Get all SDR devices with usage status."""
+    devices = SDRFactory.detect_devices()
+    registry = get_sdr_device_status()
+
+    result = []
+    for device in devices:
+        d = device.to_dict()
+        d['in_use'] = device.index in registry
+        d['used_by'] = registry.get(device.index)
+        result.append(d)
+
+    return jsonify(result)
+
+
 @app.route('/devices/debug')
 def get_devices_debug() -> Response:
     """Get detailed SDR device detection diagnostics."""
@@ -528,6 +641,7 @@ def health_check() -> Response:
             'wifi': wifi_process is not None and (wifi_process.poll() is None if wifi_process else False),
             'bluetooth': bt_process is not None and (bt_process.poll() is None if bt_process else False),
             'dsc': dsc_process is not None and (dsc_process.poll() is None if dsc_process else False),
+            'dmr': dmr_process is not None and (dmr_process.poll() is None if dmr_process else False),
         },
         'data': {
             'aircraft_count': len(adsb_aircraft),
@@ -542,19 +656,22 @@ def health_check() -> Response:
 
 @app.route('/killall', methods=['POST'])
 def kill_all() -> Response:
-    """Kill all decoder and WiFi processes."""
+    """Kill all decoder, WiFi, and Bluetooth processes."""
     global current_process, sensor_process, wifi_process, adsb_process, ais_process, acars_process
-    global aprs_process, aprs_rtl_process, dsc_process, dsc_rtl_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
     from routes import adsb as adsb_module
     from routes import ais as ais_module
+    from utils.bluetooth import reset_bluetooth_scanner
 
     killed = []
     processes_to_kill = [
         'rtl_fm', 'multimon-ng', 'rtl_433',
         'airodump-ng', 'aireplay-ng', 'airmon-ng',
-        'dump1090', 'acarsdec', 'direwolf', 'AIS-catcher'
+        'dump1090', 'acarsdec', 'direwolf', 'AIS-catcher',
+        'hcitool', 'bluetoothctl', 'dsd'
     ]
 
     for proc in processes_to_kill:
@@ -598,6 +715,35 @@ 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:
+            try:
+                bt_process.terminate()
+                bt_process.wait(timeout=2)
+            except Exception:
+                try:
+                    bt_process.kill()
+                except Exception:
+                    pass
+        bt_process = None
+
+    # Reset Bluetooth v2 scanner
+    try:
+        reset_bluetooth_scanner()
+        killed.append('bluetooth_scanner')
+    except Exception:
+        pass
+
+    # Clear SDR device registry
+    with sdr_device_registry_lock:
+        sdr_device_registry.clear()
+
     return jsonify({'status': 'killed', 'processes': killed})
 
 
@@ -690,6 +836,22 @@ def main() -> None:
     from routes import register_blueprints
     register_blueprints(app)
 
+    # Update TLE data in background thread (non-blocking)
+    def update_tle_background():
+        try:
+            from routes.satellite import refresh_tle_data
+            print("Updating satellite TLE data from CelesTrak...")
+            updated = refresh_tle_data()
+            if updated:
+                print(f"TLE data updated for: {', '.join(updated)}")
+            else:
+                print("TLE update: No satellites updated (may be offline)")
+        except Exception as e:
+            print(f"TLE update failed (will use cached data): {e}")
+
+    tle_thread = threading.Thread(target=update_tle_background, daemon=True)
+    tle_thread.start()
+
     # Initialize WebSocket for audio streaming
     try:
         from routes.audio_websocket import init_audio_websocket
@@ -698,6 +860,14 @@ def main() -> None:
     except ImportError as e:
         print(f"WebSocket audio disabled (install flask-sock): {e}")
 
+    # Initialize KiwiSDR WebSocket audio proxy
+    try:
+        from routes.websdr import init_websdr_audio
+        init_websdr_audio(app)
+        print("KiwiSDR audio proxy enabled")
+    except ImportError as e:
+        print(f"KiwiSDR audio proxy disabled: {e}")
+
     print(f"Open http://localhost:{args.port} in your browser")
     print()
     print("Press Ctrl+C to stop")
@@ -710,4 +880,4 @@ def main() -> None:
         debug=args.debug,
         threaded=True,
         load_dotenv=False,
-    )
+    )

config.py

@@ -7,10 +7,76 @@ import os
 import sys
 
 # Application version
-VERSION = "2.10.0"
+VERSION = "2.14.0"
 
 # Changelog - latest release notes (shown on welcome screen)
 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",
+            "TSCM sweep resilience, WiFi detection, and correlation fixes",
+            "APRS rtl_fm startup and SDR device conflict fixes",
+        ]
+    },
+    {
+        "version": "2.13.1",
+        "date": "February 2026",
+        "highlights": [
+            "UI overhaul with slate/cyan theme and JetBrains Mono font",
+            "Signal scanner rewritten with rtl_power sweep and SNR filtering",
+            "Listening Post audio streaming via WAV with retry/fallback",
+            "WiFi connected clients panel now filters to selected AP",
+            "Global navigation bar across all dashboards",
+            "Fixed USB device contention when starting audio pipeline",
+        ]
+    },
+    {
+        "version": "2.13.0",
+        "date": "February 2026",
+        "highlights": [
+            "WiFi client display in AP detail drawer with real-time SSE updates",
+            "Help modal system with keyboard shortcuts reference",
+            "Global navbar and settings modal accessible from all dashboards",
+            "Probed SSID badges for connected clients",
+        ]
+    },
+    {
+        "version": "2.12.1",
+        "date": "February 2026",
+        "highlights": [
+            "SDR device registry to prevent decoder conflicts",
+            "SDR device status panel and ADS-B Bias-T toggle",
+            "Real-time Doppler tracking for ISS SSTV reception",
+            "TCP connection support for Meshtastic",
+            "Shared observer location with auto-start options",
+        ]
+    },
+    {
+        "version": "2.12.0",
+        "date": "January 2026",
+        "highlights": [
+            "ISS SSTV decoder with real-time ISS tracking globe",
+            "GitHub update notifications for new releases",
+            "Meshtastic QR code support and telemetry display",
+            "New Space category with reorganized UI",
+        ]
+    },
+    {
+        "version": "2.11.0",
+        "date": "January 2026",
+        "highlights": [
+            "Meshtastic LoRa mesh network integration",
+            "Ubertooth One BLE scanning support",
+            "Offline mode with bundled assets",
+            "Settings modal with tile provider configuration",
+        ]
+    },
     {
         "version": "2.10.0",
         "date": "January 2026",
@@ -51,16 +117,6 @@ CHANGELOG = [
             "Risk scoring and threat classification",
         ]
     },
-    {
-        "version": "2.7.0",
-        "date": "November 2025",
-        "highlights": [
-            "Multi-SDR hardware support via SoapySDR",
-            "LimeSDR, HackRF, Airspy, SDRplay support",
-            "Improved aircraft database with photo lookup",
-            "GPS auto-detection and integration",
-        ]
-    },
 ]
 
 
@@ -126,24 +182,33 @@ AIRODUMP_HEADER_LINES = _get_env_int('AIRODUMP_HEADER_LINES', 2)
 BT_SCAN_TIMEOUT = _get_env_int('BT_SCAN_TIMEOUT', 10)
 BT_UPDATE_INTERVAL = _get_env_float('BT_UPDATE_INTERVAL', 2.0)
 
-# ADS-B settings
-ADSB_SBS_PORT = _get_env_int('ADSB_SBS_PORT', 30003)
-ADSB_UPDATE_INTERVAL = _get_env_float('ADSB_UPDATE_INTERVAL', 1.0)
-ADSB_HISTORY_ENABLED = _get_env_bool('ADSB_HISTORY_ENABLED', False)
-ADSB_DB_HOST = _get_env('ADSB_DB_HOST', 'localhost')
-ADSB_DB_PORT = _get_env_int('ADSB_DB_PORT', 5432)
-ADSB_DB_NAME = _get_env('ADSB_DB_NAME', 'intercept_adsb')
-ADSB_DB_USER = _get_env('ADSB_DB_USER', 'intercept')
-ADSB_DB_PASSWORD = _get_env('ADSB_DB_PASSWORD', 'intercept')
-ADSB_HISTORY_BATCH_SIZE = _get_env_int('ADSB_HISTORY_BATCH_SIZE', 500)
-ADSB_HISTORY_FLUSH_INTERVAL = _get_env_float('ADSB_HISTORY_FLUSH_INTERVAL', 1.0)
-ADSB_HISTORY_QUEUE_SIZE = _get_env_int('ADSB_HISTORY_QUEUE_SIZE', 50000)
+# ADS-B settings
+ADSB_SBS_PORT = _get_env_int('ADSB_SBS_PORT', 30003)
+ADSB_UPDATE_INTERVAL = _get_env_float('ADSB_UPDATE_INTERVAL', 1.0)
+ADSB_AUTO_START = _get_env_bool('ADSB_AUTO_START', False)
+ADSB_HISTORY_ENABLED = _get_env_bool('ADSB_HISTORY_ENABLED', False)
+ADSB_DB_HOST = _get_env('ADSB_DB_HOST', 'localhost')
+ADSB_DB_PORT = _get_env_int('ADSB_DB_PORT', 5432)
+ADSB_DB_NAME = _get_env('ADSB_DB_NAME', 'intercept_adsb')
+ADSB_DB_USER = _get_env('ADSB_DB_USER', 'intercept')
+ADSB_DB_PASSWORD = _get_env('ADSB_DB_PASSWORD', 'intercept')
+ADSB_HISTORY_BATCH_SIZE = _get_env_int('ADSB_HISTORY_BATCH_SIZE', 500)
+ADSB_HISTORY_FLUSH_INTERVAL = _get_env_float('ADSB_HISTORY_FLUSH_INTERVAL', 1.0)
+ADSB_HISTORY_QUEUE_SIZE = _get_env_int('ADSB_HISTORY_QUEUE_SIZE', 50000)
+
+# Observer location settings
+SHARED_OBSERVER_LOCATION_ENABLED = _get_env_bool('SHARED_OBSERVER_LOCATION', True)
 
 # Satellite settings
 SATELLITE_UPDATE_INTERVAL = _get_env_int('SATELLITE_UPDATE_INTERVAL', 30)
 SATELLITE_TRAJECTORY_POINTS = _get_env_int('SATELLITE_TRAJECTORY_POINTS', 30)
 SATELLITE_ORBIT_MINUTES = _get_env_int('SATELLITE_ORBIT_MINUTES', 45)
 
+# Update checking
+GITHUB_REPO = _get_env('GITHUB_REPO', 'smittix/intercept')
+UPDATE_CHECK_ENABLED = _get_env_bool('UPDATE_CHECK_ENABLED', True)
+UPDATE_CHECK_INTERVAL_HOURS = _get_env_int('UPDATE_CHECK_INTERVAL_HOURS', 6)
+
 # Admin credentials
 ADMIN_USERNAME = _get_env('ADMIN_USERNAME', 'admin')
 ADMIN_PASSWORD = _get_env('ADMIN_PASSWORD', 'admin')

data/satellites.py

@@ -1,18 +1,29 @@
 # TLE data for satellite tracking (updated periodically)
+# To update: click "Update TLE" in satellite dashboard or SSTV mode
+# Data source: CelesTrak (celestrak.org)
 TLE_SATELLITES = {
     'ISS': ('ISS (ZARYA)',
-            '1 25544U 98067A   24001.00000000  .00000000  00000-0  00000-0 0  0000',
-            '2 25544  51.6400   0.0000 0000000   0.0000   0.0000 15.50000000000000'),
+            '1 25544U 98067A   25029.51432176  .00020818  00000+0  36919-3 0  9991',
+            '2 25544  51.6400 157.5640 0002671 123.5041 236.6291 15.49988902492099'),
+    'NOAA-15': ('NOAA 15',
+                '1 25338U 98030A   25028.84157420  .00000535  00000+0  26168-3 0  9999',
+                '2 25338  98.5676 356.1853 0009968 282.2567  77.7505 14.26225252390049'),
+    'NOAA-18': ('NOAA 18',
+                '1 28654U 05018A   25028.87364583  .00000454  00000+0  25082-3 0  9996',
+                '2 28654  98.8801  59.1618 0013609 281.7181  78.2479 14.13003043 24668'),
+    'NOAA-19': ('NOAA 19',
+                '1 33591U 09005A   25028.82370718  .00000425  00000+0  24556-3 0  9998',
+                '2 33591  99.0905  25.2347 0013428 265.3457  94.6190 14.13019285827447'),
     'NOAA-20': ('NOAA 20 (JPSS-1)',
-                '1 43013U 17073A   24001.00000000  .00000-0  00000-0  00000-0 0  0000',
-                '2 43013  98.7400   0.0000 0001000   0.0000   0.0000 14.19000000000000'),
+                '1 43013U 17073A   25028.83917428  .00000284  00000+0  15698-3 0  9995',
+                '2 43013  98.7104  59.9558 0001165 102.5891 257.5432 14.19571458378899'),
     'NOAA-21': ('NOAA 21 (JPSS-2)',
-                '1 54234U 22150A   24001.00000000  .00000-0  00000-0  00000-0 0  0000',
-                '2 54234  98.7100   0.0000 0001000   0.0000   0.0000 14.19000000000000'),
+                '1 54234U 22150A   25028.86292604  .00000268  00000+0  14911-3 0  9995',
+                '2 54234  98.7064  59.6648 0001271  88.4689 271.6646 14.19545810114699'),
     'METEOR-M2': ('METEOR-M 2',
-                  '1 40069U 14037A   24001.00000000  .00000-0  00000-0  00000-0 0  0000',
-                  '2 40069  98.5400   0.0000 0005000   0.0000   0.0000 14.21000000000000'),
+                  '1 40069U 14037A   25028.47802083  .00000099  00000+0  69422-4 0  9990',
+                  '2 40069  98.4752 356.8632 0003942 251.7291 108.3489 14.20719440555299'),
     'METEOR-M2-3': ('METEOR-M2 3',
-                    '1 57166U 23091A   24001.00000000  .00000-0  00000-0  00000-0 0  0000',
-                    '2 57166  98.7700   0.0000 0002000   0.0000   0.0000 14.23000000000000'),
+                    '1 57166U 23091A   25028.81539352  .00000157  00000+0  94432-4 0  9993',
+                    '2 57166  98.7690  91.9652 0001790 107.4859 252.6519 14.23646028 77844'),
 }

docker-compose.yml

@@ -36,6 +36,10 @@ services:
       # - INTERCEPT_ADSB_DB_NAME=intercept_adsb
       # - INTERCEPT_ADSB_DB_USER=intercept
       # - INTERCEPT_ADSB_DB_PASSWORD=intercept
+      # ADS-B auto-start on dashboard load (default false)
+      - INTERCEPT_ADSB_AUTO_START=${INTERCEPT_ADSB_AUTO_START:-false}
+      # Shared observer location across modules
+      - INTERCEPT_SHARED_OBSERVER_LOCATION=${INTERCEPT_SHARED_OBSERVER_LOCATION:-true}
     # Network mode for WiFi scanning (requires host network)
     # network_mode: host
     restart: unless-stopped
@@ -68,6 +72,10 @@ services:
       - INTERCEPT_ADSB_DB_NAME=intercept_adsb
       - INTERCEPT_ADSB_DB_USER=intercept
       - INTERCEPT_ADSB_DB_PASSWORD=intercept
+      # ADS-B auto-start on dashboard load (default false)
+      - INTERCEPT_ADSB_AUTO_START=${INTERCEPT_ADSB_AUTO_START:-false}
+      # Shared observer location across modules
+      - INTERCEPT_SHARED_OBSERVER_LOCATION=${INTERCEPT_SHARED_OBSERVER_LOCATION:-true}
     restart: unless-stopped
     healthcheck:
       test: ["CMD", "curl", "-sf", "http://localhost:5050/health"]

docs/CNAME

@@ -0,0 +1 @@
+www.intercept-sigint.com

docs/DISTRIBUTED_AGENTS.md

@@ -0,0 +1,506 @@
+# Intercept Distributed Agent System
+
+This document describes the distributed agent architecture that allows multiple remote sensor nodes to feed data into a central Intercept controller.
+
+## Overview
+
+The agent system uses a hub-and-spoke architecture where:
+- **Controller**: The main Intercept instance that aggregates data from multiple agents
+- **Agents**: Lightweight sensor nodes running on remote devices with SDR hardware
+
+```
+                    ┌─────────────────────────────────┐
+                    │      INTERCEPT CONTROLLER       │
+                    │         (port 5050)             │
+                    │                                 │
+                    │  - Web UI with agent selector   │
+                    │  - /controller/manage page      │
+                    │  - Multi-agent SSE stream       │
+                    │  - Push data storage            │
+                    └─────────────────────────────────┘
+                         ▲           ▲           ▲
+                         │           │           │
+              Push/Pull  │           │           │  Push/Pull
+                         │           │           │
+                    ┌────┴───┐  ┌────┴───┐  ┌────┴───┐
+                    │ Agent  │  │ Agent  │  │ Agent  │
+                    │  :8020 │  │  :8020 │  │  :8020 │
+                    │        │  │        │  │        │
+                    │[RTL-SDR]  │[HackRF] │  │[LimeSDR]
+                    └────────┘  └────────┘  └────────┘
+```
+
+## Quick Start
+
+### 1. Start the Controller
+
+The controller is the main Intercept application:
+
+```bash
+cd intercept
+python app.py
+# Runs on http://localhost:5050
+```
+
+### 2. Configure an Agent
+
+Create a config file on the remote machine:
+
+```ini
+# intercept_agent.cfg
+[agent]
+name = sensor-node-1
+port = 8020
+allowed_ips =
+allow_cors = false
+
+[controller]
+url = http://192.168.1.100:5050
+api_key = your-secret-key-here
+push_enabled = true
+push_interval = 5
+
+[modes]
+pager = true
+sensor = true
+adsb = true
+wifi = true
+bluetooth = true
+```
+
+### 3. Start the Agent
+
+```bash
+python intercept_agent.py --config intercept_agent.cfg
+# Runs on http://localhost:8020
+```
+
+### 4. Register the Agent
+
+Go to `http://controller:5050/controller/manage` and add the agent:
+- **Name**: sensor-node-1 (must match config)
+- **Base URL**: http://agent-ip:8020
+- **API Key**: your-secret-key-here (must match config)
+
+## Architecture
+
+### Data Flow
+
+The system supports two data flow patterns:
+
+#### Push (Agent → Controller)
+
+Agents automatically push captured data to the controller:
+
+1. Agent captures data (e.g., rtl_433 sensor readings)
+2. Data is queued in the `ControllerPushClient`
+3. Agent POSTs to `http://controller/controller/api/ingest`
+4. Controller validates API key and stores in `push_payloads` table
+5. Data is available via SSE stream at `/controller/stream/all`
+
+```
+Agent                           Controller
+  │                                 │
+  │  POST /controller/api/ingest    │
+  │  Header: X-API-Key: secret      │
+  │  Body: {agent_name, scan_type,  │
+  │         payload, timestamp}     │
+  │ ──────────────────────────────► │
+  │                                 │
+  │         200 OK                  │
+  │ ◄────────────────────────────── │
+```
+
+#### Pull (Controller → Agent)
+
+The controller can also pull data on-demand:
+
+1. User selects agent in UI dropdown
+2. User clicks "Start Listening"
+3. Controller proxies request to agent
+4. Agent starts the mode and returns status
+5. Controller polls agent for data
+
+```
+Browser                 Controller                    Agent
+   │                        │                           │
+   │ POST /controller/      │                           │
+   │   agents/1/sensor/start│                           │
+   │ ─────────────────────► │                           │
+   │                        │ POST /sensor/start        │
+   │                        │ ────────────────────────► │
+   │                        │                           │
+   │                        │      {status: started}    │
+   │                        │ ◄──────────────────────── │
+   │    {status: success}   │                           │
+   │ ◄───────────────────── │                           │
+```
+
+### Authentication
+
+API key authentication secures the push mechanism:
+
+1. Agent config specifies `api_key` in `[controller]` section
+2. Agent sends `X-API-Key` header with each push request
+3. Controller looks up agent by name in database
+4. Controller compares provided key with stored key
+5. Mismatched keys return 401 Unauthorized
+
+### Database Schema
+
+Two tables support the agent system:
+
+```sql
+-- Registered agents
+CREATE TABLE agents (
+    id INTEGER PRIMARY KEY,
+    name TEXT UNIQUE NOT NULL,
+    base_url TEXT NOT NULL,
+    api_key TEXT,
+    capabilities TEXT,      -- JSON: {pager: true, sensor: true, ...}
+    interfaces TEXT,        -- JSON: {devices: [...]}
+    gps_coords TEXT,        -- JSON: {lat, lon}
+    last_seen TIMESTAMP,
+    is_active BOOLEAN
+);
+
+-- Pushed data from agents
+CREATE TABLE push_payloads (
+    id INTEGER PRIMARY KEY,
+    agent_id INTEGER,
+    scan_type TEXT,         -- pager, sensor, adsb, wifi, etc.
+    payload TEXT,           -- JSON data
+    received_at TIMESTAMP,
+    FOREIGN KEY (agent_id) REFERENCES agents(id)
+);
+```
+
+## Agent REST API
+
+The agent exposes these endpoints:
+
+| Endpoint | Method | Description |
+|----------|--------|-------------|
+| `/health` | GET | Health check (returns `{status: "healthy"}`) |
+| `/capabilities` | GET | Available modes, devices, GPS status |
+| `/status` | GET | Running modes, uptime, push status |
+| `/{mode}/start` | POST | Start a mode (pager, sensor, adsb, etc.) |
+| `/{mode}/stop` | POST | Stop a mode |
+| `/{mode}/status` | GET | Mode-specific status |
+| `/{mode}/data` | GET | Current data snapshot |
+
+### Example: Start Sensor Mode
+
+```bash
+curl -X POST http://agent:8020/sensor/start \
+  -H "Content-Type: application/json" \
+  -d '{"frequency": 433.92, "device_index": 0}'
+```
+
+Response:
+```json
+{
+  "status": "started",
+  "mode": "sensor",
+  "command": "/usr/local/bin/rtl_433 -d 0 -f 433.92M -F json",
+  "gps_enabled": true
+}
+```
+
+### Example: Get Capabilities
+
+```bash
+curl http://agent:8020/capabilities
+```
+
+Response:
+```json
+{
+  "modes": {
+    "pager": true,
+    "sensor": true,
+    "adsb": true,
+    "wifi": true,
+    "bluetooth": true
+  },
+  "devices": [
+    {
+      "index": 0,
+      "name": "RTLSDRBlog, Blog V4",
+      "sdr_type": "rtlsdr",
+      "capabilities": {
+        "freq_min_mhz": 24.0,
+        "freq_max_mhz": 1766.0
+      }
+    }
+  ],
+  "gps": true,
+  "gps_position": {
+    "lat": 33.543,
+    "lon": -82.194,
+    "altitude": 70.0
+  },
+  "tool_details": {
+    "sensor": {
+      "name": "433MHz Sensors",
+      "ready": true,
+      "tools": {
+        "rtl_433": {"installed": true, "required": true}
+      }
+    }
+  }
+}
+```
+
+## Supported Modes
+
+All modes are fully implemented in the agent with the following tools and data formats:
+
+| Mode | Tool(s) | Data Format | Notes |
+|------|---------|-------------|-------|
+| `sensor` | rtl_433 | JSON readings | ISM band devices (433/868/915 MHz) |
+| `pager` | rtl_fm + multimon-ng | POCSAG/FLEX messages | Address, function, message content |
+| `adsb` | dump1090 | SBS-format aircraft | ICAO, callsign, position, altitude |
+| `ais` | AIS-catcher | JSON vessels | MMSI, position, speed, vessel info |
+| `acars` | acarsdec | JSON messages | Aircraft tail, label, message text |
+| `aprs` | rtl_fm + direwolf | APRS packets | Callsign, position, path |
+| `wifi` | airodump-ng | Networks + clients | BSSID, ESSID, signal, clients |
+| `bluetooth` | bluetoothctl | Device list | MAC, name, RSSI |
+| `rtlamr` | rtl_tcp + rtlamr | Meter readings | Meter ID, consumption data |
+| `dsc` | rtl_fm (+ dsc-decoder) | DSC messages | MMSI, distress category, position |
+| `tscm` | WiFi/BT analysis | Anomaly reports | New/rogue devices detected |
+| `satellite` | skyfield (TLE) | Pass predictions | No SDR required |
+| `listening_post` | rtl_fm scanner | Signal detections | Frequency, modulation |
+
+### Mode-Specific Notes
+
+**Listening Post**: Full FFT streaming isn't practical over HTTP. Instead, the agent provides:
+- Signal detection events when activity is found
+- Current scanning frequency
+- Activity log of detected signals
+
+**TSCM**: Analyzes WiFi and Bluetooth data for anomalies:
+- Builds baseline of known devices
+- Reports new/unknown devices as anomalies
+- No SDR required (uses WiFi/BT data)
+
+**Satellite**: Pure computational mode:
+- Calculates pass predictions from TLE data
+- Requires observer location (lat/lon)
+- No SDR required
+
+**Audio Modes**: Modes requiring real-time audio (airband, listening_post audio) are limited via agents. Use rtl_tcp for remote audio streaming instead.
+
+## Controller API
+
+### Agent Management
+
+| Endpoint | Method | Description |
+|----------|--------|-------------|
+| `/controller/agents` | GET | List all agents |
+| `/controller/agents` | POST | Register new agent |
+| `/controller/agents/{id}` | GET | Get agent details |
+| `/controller/agents/{id}` | DELETE | Remove agent |
+| `/controller/agents/{id}?refresh=true` | GET | Refresh agent capabilities |
+
+### Proxy Operations
+
+| Endpoint | Method | Description |
+|----------|--------|-------------|
+| `/controller/agents/{id}/{mode}/start` | POST | Start mode on agent |
+| `/controller/agents/{id}/{mode}/stop` | POST | Stop mode on agent |
+| `/controller/agents/{id}/{mode}/data` | GET | Get data from agent |
+
+### Push Ingestion
+
+| Endpoint | Method | Description |
+|----------|--------|-------------|
+| `/controller/api/ingest` | POST | Receive pushed data from agents |
+
+### SSE Streams
+
+| Endpoint | Description |
+|----------|-------------|
+| `/controller/stream/all` | Combined stream from all agents |
+
+## Frontend Integration
+
+### Agent Selector
+
+The main UI includes an agent dropdown in supported modes:
+
+```html
+<select id="agentSelect">
+    <option value="local">Local (This Device)</option>
+    <option value="1">● sensor-node-1</option>
+</select>
+```
+
+When an agent is selected:
+1. Device list updates to show agent's SDR devices
+2. Start/Stop commands route through controller proxy
+3. Data displays with agent name badge
+
+### Multi-Agent Mode
+
+Enable "Show All Agents" checkbox to:
+- Connect to `/controller/stream/all` SSE
+- Display combined data from all agents
+- Show agent name badge on each data item
+
+## GPS Integration
+
+Agents can include GPS coordinates with captured data:
+
+1. Agent connects to local `gpsd` daemon
+2. GPS position included in `/capabilities` and `/status`
+3. Each data snapshot includes `agent_gps` field
+4. Controller can use GPS for trilateration (multiple agents)
+
+## Configuration Reference
+
+### Agent Config (`intercept_agent.cfg`)
+
+```ini
+[agent]
+# Agent identity (must be unique across all agents)
+name = sensor-node-1
+
+# Port to listen on
+port = 8020
+
+# Restrict connections to specific IPs (comma-separated, empty = all)
+allowed_ips =
+
+# Enable CORS headers
+allow_cors = false
+
+[controller]
+# Controller URL (required for push)
+url = http://192.168.1.100:5050
+
+# API key for authentication
+api_key = your-secret-key
+
+# Enable automatic data push
+push_enabled = true
+
+# Push interval in seconds
+push_interval = 5
+
+[modes]
+# Enable/disable specific modes
+pager = true
+sensor = true
+adsb = true
+ais = true
+wifi = true
+bluetooth = true
+```
+
+## Troubleshooting
+
+### Agent not appearing in controller
+
+1. Check agent is running: `curl http://agent:8020/health`
+2. Verify agent is registered in `/controller/manage`
+3. Check API key matches between agent config and controller registration
+4. Check network connectivity between agent and controller
+
+### Push data not arriving
+
+1. Check agent status: `curl http://agent:8020/status`
+   - Verify `push_enabled: true` and `push_connected: true`
+2. Check controller logs for authentication errors
+3. Verify API key matches
+4. Check if mode is running and producing data
+
+### Mode won't start on agent
+
+1. Check capabilities: `curl http://agent:8020/capabilities`
+2. Verify required tools are installed (check `tool_details`)
+3. Check if SDR device is available (not in use by another process)
+
+### No data from sensor mode
+
+1. Verify rtl_433 is running: `ps aux | grep rtl_433`
+2. Check sensor status: `curl http://agent:8020/sensor/status`
+3. Note: Empty data is normal if no 433MHz devices are transmitting nearby
+
+## Security Considerations
+
+1. **API Keys**: Always use strong, unique API keys for each agent
+2. **Network**: Consider running agents on a private network or VPN
+3. **HTTPS**: For production, use HTTPS between agents and controller
+4. **Firewall**: Restrict agent ports to controller IP only
+5. **allowed_ips**: Use this config option to restrict agent connections
+
+## Dashboard Integration
+
+Agent support has been integrated into the following specialized dashboards:
+
+### ADS-B Dashboard (`/adsb/dashboard`)
+- Agent selector in header bar
+- Routes tracking start/stop through agent proxy when remote agent selected
+- Connects to multi-agent stream for data from remote agents
+- Displays agent badge on aircraft from remote sources
+- Updates observer location from agent's GPS coordinates
+
+### AIS Dashboard (`/ais/dashboard`)
+- Agent selector in header bar
+- Routes AIS and DSC mode operations through agent proxy
+- Connects to multi-agent stream for vessel data
+- Displays agent badge on vessels from remote sources
+- Updates observer location from agent's GPS coordinates
+
+### Main Dashboard (`/`)
+- Agent selector in sidebar
+- Supports sensor, pager, WiFi, Bluetooth modes via agents
+- SDR conflict detection with device-aware warnings
+- Real-time sync with agent's running mode state
+
+### Multi-SDR Agent Support
+
+For agents with multiple SDR devices, the system now tracks which device each mode is using:
+
+```json
+{
+  "running_modes": ["sensor", "adsb"],
+  "running_modes_detail": {
+    "sensor": {"device": 0, "started_at": "2024-01-15T10:30:00Z"},
+    "adsb": {"device": 1, "started_at": "2024-01-15T10:35:00Z"}
+  }
+}
+```
+
+This allows:
+- Smart conflict detection (only warns if same device is in use)
+- Display of which device each mode is using
+- Parallel operation of multiple SDR modes on multi-SDR agents
+
+### Agent Mode Warnings
+
+When an agent has SDR modes running, the UI displays:
+- Warning banner showing active modes with device numbers
+- Stop buttons for each running mode
+- Refresh button to re-sync with agent state
+
+### Pages Without Agent Support
+
+The following pages don't require SDR-based agent support:
+- **Satellite Dashboard** (`/satellite/dashboard`) - Uses TLE orbital calculations, no SDR
+- **History pages** - Display stored data, not live SDR streams
+
+## Files
+
+| File | Description |
+|------|-------------|
+| `intercept_agent.py` | Standalone agent server |
+| `intercept_agent.cfg` | Agent configuration template |
+| `routes/controller.py` | Controller API blueprint |
+| `utils/agent_client.py` | HTTP client for agents |
+| `utils/database.py` | Agent CRUD operations |
+| `static/js/core/agents.js` | Frontend agent management |
+| `templates/agents.html` | Agent management page |
+| `templates/adsb_dashboard.html` | ADS-B page with agent integration |
+| `templates/ais_dashboard.html` | AIS page with agent integration |

docs/FEATURES.md

@@ -38,22 +38,22 @@ Complete feature list for all modules.
 - **Source links** - references to priyom.org for detailed information
 - **Famous stations** - UVB-76 "The Buzzer", Cuban HM01, Israeli E17z
 
-## ADS-B Aircraft Tracking
-
-- **Real-time aircraft tracking** via dump1090 or rtl_adsb
-- **Full-screen dashboard** - dedicated popout with virtual radar scope
-- **Interactive Leaflet map** with OpenStreetMap tiles (dark-themed)
-- **Aircraft trails** - optional flight path history visualization
-- **Range rings** - distance reference circles from observer position
-- **Aircraft filtering** - show all, military only, civil only, or emergency only
-- **Marker clustering** - group nearby aircraft at lower zoom levels
-- **Reception statistics** - max range, message rate, busiest hour, total seen
-- **Persistent ADS-B history** - optional Postgres-backed message and snapshot storage
-- **History reporting dashboard** - session controls, aircraft timelines, and detail modal
-- **Observer location** - manual input or GPS geolocation
-- **Audio alerts** - notifications for military and emergency aircraft
-- **Emergency squawk highlighting** - visual alerts for 7500/7600/7700
-- **Aircraft details popup** - callsign, altitude, speed, heading, squawk, ICAO
+## ADS-B Aircraft Tracking
+
+- **Real-time aircraft tracking** via dump1090 or rtl_adsb
+- **Full-screen dashboard** - dedicated popout with virtual radar scope
+- **Interactive Leaflet map** with OpenStreetMap tiles (dark-themed)
+- **Aircraft trails** - optional flight path history visualization
+- **Range rings** - distance reference circles from observer position
+- **Aircraft filtering** - show all, military only, civil only, or emergency only
+- **Marker clustering** - group nearby aircraft at lower zoom levels
+- **Reception statistics** - max range, message rate, busiest hour, total seen
+- **Persistent ADS-B history** - optional Postgres-backed message and snapshot storage
+- **History reporting dashboard** - session controls, aircraft timelines, and detail modal
+- **Observer location** - manual input or GPS geolocation
+- **Audio alerts** - notifications for military and emergency aircraft
+- **Emergency squawk highlighting** - visual alerts for 7500/7600/7700
+- **Aircraft details popup** - callsign, altitude, speed, heading, squawk, ICAO
 
 <p align="center">
   <img src="/static/images/screenshots/screenshot_radar.png" alt="Screenshot">
@@ -165,6 +165,78 @@ Technical Surveillance Countermeasures (TSCM) screening for detecting wireless s
 - No cryptographic de-randomization
 - Passive screening only (no active probing by default)
 
+## Meshtastic Mesh Networks
+
+Integration with Meshtastic LoRa mesh networking devices for decentralized communication.
+
+### Device Support
+- **Heltec** - LoRa32 series
+- **T-Beam** - TTGO T-Beam with GPS
+- **RAK** - WisBlock series
+- Any Meshtastic-compatible device via USB/Serial
+
+### Features
+- **Real-time messaging** - Stream messages as they arrive
+- **Channel configuration** - Set encryption keys and channel names
+- **Node information** - View connected nodes with signal metrics
+- **Message history** - Up to 500 messages retained
+- **Signal quality** - RSSI and SNR for each message
+- **Hop tracking** - See message hop count
+
+### Requirements
+- Physical Meshtastic device connected via USB
+- Meshtastic Python SDK (`pip install meshtastic`)
+
+## Ubertooth One BLE Scanning
+
+Advanced Bluetooth Low Energy scanning using Ubertooth One hardware.
+
+### Capabilities
+- **40-channel scanning** - Capture BLE advertisements across all channels
+- **Raw payload access** - Full advertising data for analysis
+- **Passive sniffing** - No active scanning required
+- **MAC address extraction** - Public and random address types
+- **RSSI measurement** - Signal strength for proximity estimation
+
+### Integration
+- Works alongside standard BlueZ/DBus Bluetooth scanning
+- Automatically detected when ubertooth-btle is available
+- Falls back to standard adapter if Ubertooth not present
+
+### Requirements
+- Ubertooth One hardware
+- ubertooth-btle command-line tool installed
+- libubertooth library
+
+## Remote Agents (Distributed SIGINT)
+
+Deploy lightweight sensor nodes across multiple locations and aggregate data to a central controller.
+
+### Architecture
+- **Hub-and-spoke model** - Central controller with multiple remote agents
+- **Push and Pull modes** - Agents can push data automatically or respond to on-demand requests
+- **API key authentication** - Secure communication between agents and controller
+
+### Agent Features
+- **Standalone deployment** - Run on Raspberry Pi, mini PCs, or any Linux device with SDR
+- **All modes supported** - Pager, sensor, ADS-B, AIS, WiFi, Bluetooth, and more
+- **GPS integration** - Automatic location tagging from USB GPS receivers
+- **Multi-SDR support** - Run multiple modes simultaneously on agents with multiple SDRs
+- **Capability discovery** - Controller auto-detects available modes and devices
+
+### Controller Features
+- **Agent management UI** - Register, test, and remove agents from `/controller/manage`
+- **Real-time status** - Health monitoring with online/offline indicators
+- **Unified data stream** - Aggregate data from all agents via SSE
+- **Dashboard integration** - Agent selector in ADS-B, AIS, and main dashboards
+- **Device conflict detection** - Smart warnings when SDR is in use
+
+### Use Cases
+- **Wide-area monitoring** - Cover larger geographic areas with distributed sensors
+- **Remote installations** - Deploy sensors in locations without direct access
+- **Redundancy** - Multiple nodes for reliable coverage
+- **Triangulation** - Use multiple GPS-enabled agents for signal location
+
 ## User Interface
 
 - **Mode-specific header stats** - real-time badges showing key metrics per mode
@@ -186,6 +258,42 @@ Technical Surveillance Countermeasures (TSCM) screening for detecting wireless s
 | ? | Open help (when not typing) |
 | Escape | Close help/modals |
 
+## Offline Mode
+
+Run iNTERCEPT without internet connectivity by using bundled local assets.
+
+### Bundled Assets
+- **Leaflet 1.9.4** - Map library with marker images
+- **Chart.js 4.4.1** - Signal strength graphs
+- **Inter font** - Primary UI font (400, 500, 600, 700 weights)
+- **JetBrains Mono font** - Monospace/code font (400, 500, 600, 700 weights)
+
+### Settings Modal
+Access via the gear icon in the navigation bar:
+- **Offline Tab** - Toggle offline mode, configure asset sources (CDN vs local)
+- **Display Tab** - Theme and animation preferences
+- **About Tab** - Version info and links
+
+### Map Tile Providers
+Choose from multiple tile sources for maps:
+- **OpenStreetMap** - Default, general purpose
+- **CartoDB Dark** - Dark themed, matches UI
+- **CartoDB Positron** - Light themed
+- **ESRI World Imagery** - Satellite imagery
+- **Custom URL** - Connect to your own tile server (e.g., local OpenStreetMap tile cache)
+
+### Local Asset Status
+The settings modal shows availability status for each bundled asset:
+- Green "Available" badge when asset is present
+- Red "Missing" badge when asset is not found
+- Click "Check Assets" to refresh status
+
+### Use Cases
+- **Air-gapped environments** - Run on isolated networks
+- **Field deployments** - Operate without reliable internet
+- **Local tile servers** - Use pre-cached map tiles for specific regions
+- **Reduced latency** - Faster loading with local assets
+
 ## General
 
 - **Web-based interface** - no desktop app needed

docs/UI_GUIDE.md

@@ -0,0 +1,608 @@
+# iNTERCEPT UI Guide
+
+This guide documents the UI design system, components, and patterns used in iNTERCEPT.
+
+## Table of Contents
+
+1. [Design Tokens](#design-tokens)
+2. [Base Templates](#base-templates)
+3. [Navigation](#navigation)
+4. [Components](#components)
+5. [Adding a New Module Page](#adding-a-new-module-page)
+6. [Adding a New Dashboard](#adding-a-new-dashboard)
+
+---
+
+## Design Tokens
+
+All design tokens are defined in `static/css/core/variables.css`. Import this file first in any stylesheet.
+
+### Colors
+
+```css
+/* Backgrounds (layered depth) */
+--bg-primary: #0a0c10;      /* Darkest - page background */
+--bg-secondary: #0f1218;    /* Panels, sidebars */
+--bg-tertiary: #151a23;     /* Cards, elevated elements */
+--bg-card: #121620;         /* Card backgrounds */
+--bg-elevated: #1a202c;     /* Hover states, modals */
+
+/* Accent Colors */
+--accent-cyan: #4a9eff;     /* Primary action color */
+--accent-green: #22c55e;    /* Success, online status */
+--accent-red: #ef4444;      /* Error, danger, stop */
+--accent-orange: #f59e0b;   /* Warning */
+--accent-amber: #d4a853;    /* Secondary highlight */
+
+/* Text Hierarchy */
+--text-primary: #e8eaed;    /* Main content */
+--text-secondary: #9ca3af;  /* Secondary content */
+--text-dim: #4b5563;        /* Disabled, placeholder */
+--text-muted: #374151;      /* Barely visible */
+
+/* Status Colors */
+--status-online: #22c55e;
+--status-warning: #f59e0b;
+--status-error: #ef4444;
+--status-offline: #6b7280;
+```
+
+### Spacing Scale
+
+```css
+--space-1: 4px;
+--space-2: 8px;
+--space-3: 12px;
+--space-4: 16px;
+--space-5: 20px;
+--space-6: 24px;
+--space-8: 32px;
+--space-10: 40px;
+--space-12: 48px;
+--space-16: 64px;
+```
+
+### Typography
+
+```css
+/* Font Families */
+--font-sans: 'Inter', -apple-system, sans-serif;
+--font-mono: 'JetBrains Mono', monospace;
+
+/* Font Sizes */
+--text-xs: 10px;
+--text-sm: 12px;
+--text-base: 14px;
+--text-lg: 16px;
+--text-xl: 18px;
+--text-2xl: 20px;
+--text-3xl: 24px;
+--text-4xl: 30px;
+```
+
+### Border Radius
+
+```css
+--radius-sm: 4px;
+--radius-md: 6px;
+--radius-lg: 8px;
+--radius-xl: 12px;
+--radius-full: 9999px;
+```
+
+### Light Theme
+
+The design system supports light/dark themes via `data-theme` attribute:
+
+```html
+<html data-theme="dark">  <!-- or "light" -->
+```
+
+Toggle with JavaScript:
+```javascript
+document.documentElement.setAttribute('data-theme', 'light');
+```
+
+---
+
+## Base Templates
+
+### `templates/layout/base.html`
+
+The main base template for standard pages. Use for pages with sidebar + content layout.
+
+```html
+{% extends 'layout/base.html' %}
+
+{% block title %}My Page Title{% endblock %}
+
+{% block styles %}
+<link rel="stylesheet" href="{{ url_for('static', filename='css/my-page.css') }}">
+{% endblock %}
+
+{% block navigation %}
+{% set active_mode = 'mymode' %}
+{% include 'partials/nav.html' %}
+{% endblock %}
+
+{% block sidebar %}
+<div class="app-sidebar">
+    <!-- Sidebar content -->
+</div>
+{% endblock %}
+
+{% block content %}
+<div class="page-container">
+    <h1>Page Title</h1>
+    <!-- Page content -->
+</div>
+{% endblock %}
+
+{% block scripts %}
+<script>
+    // Page-specific JavaScript
+</script>
+{% endblock %}
+```
+
+### `templates/layout/base_dashboard.html`
+
+Extended base for full-screen dashboards (maps, visualizations).
+
+```html
+{% extends 'layout/base_dashboard.html' %}
+
+{% set active_mode = 'mydashboard' %}
+
+{% block dashboard_title %}MY DASHBOARD{% endblock %}
+
+{% block styles %}
+{{ super() }}
+<link rel="stylesheet" href="{{ url_for('static', filename='css/my_dashboard.css') }}">
+{% endblock %}
+
+{% block stats_strip %}
+<div class="stats-strip">
+    <!-- Stats bar content -->
+</div>
+{% endblock %}
+
+{% block dashboard_content %}
+<div class="dashboard-map-container">
+    <!-- Main visualization -->
+</div>
+<div class="dashboard-sidebar">
+    <!-- Sidebar panels -->
+</div>
+{% endblock %}
+```
+
+---
+
+## Navigation
+
+### Including Navigation
+
+```html
+{% set active_mode = 'pager' %}
+{% include 'partials/nav.html' %}
+```
+
+### Valid `active_mode` Values
+
+| Mode | Description |
+|------|-------------|
+| `pager` | Pager decoding |
+| `sensor` | 433MHz sensors |
+| `rtlamr` | Utility meters |
+| `adsb` | Aircraft tracking |
+| `ais` | Vessel tracking |
+| `aprs` | Amateur radio |
+| `wifi` | WiFi scanning |
+| `bluetooth` | Bluetooth scanning |
+| `tscm` | Counter-surveillance |
+| `satellite` | Satellite tracking |
+| `sstv` | ISS SSTV |
+| `listening` | Listening post |
+| `spystations` | Spy stations |
+| `meshtastic` | Mesh networking |
+
+### Navigation Groups
+
+The navigation is organized into groups:
+- **SDR / RF**: Pager, 433MHz, Meters, Aircraft, Vessels, APRS, Listening Post, Spy Stations, Meshtastic
+- **Wireless**: WiFi, Bluetooth
+- **Security**: TSCM
+- **Space**: Satellite, ISS SSTV
+
+---
+
+## Components
+
+### Card / Panel
+
+```html
+{% call card(title='PANEL TITLE', indicator=true, indicator_active=false) %}
+<p>Panel content here</p>
+{% endcall %}
+```
+
+Or manually:
+```html
+<div class="panel">
+    <div class="panel-header">
+        <span>PANEL TITLE</span>
+        <div class="panel-indicator active"></div>
+    </div>
+    <div class="panel-content">
+        <p>Content here</p>
+    </div>
+</div>
+```
+
+### Empty State
+
+```html
+{% include 'components/empty_state.html' with context %}
+{# Or with variables: #}
+{% with title='No data yet', description='Start scanning to see results', action_text='Start Scan', action_onclick='startScan()' %}
+{% include 'components/empty_state.html' %}
+{% endwith %}
+```
+
+### Loading State
+
+```html
+{# Inline spinner #}
+{% include 'components/loading.html' %}
+
+{# With text #}
+{% with text='Loading data...', size='lg' %}
+{% include 'components/loading.html' %}
+{% endwith %}
+
+{# Full overlay #}
+{% with overlay=true, text='Please wait...' %}
+{% include 'components/loading.html' %}
+{% endwith %}
+```
+
+### Status Badge
+
+```html
+{% with status='online', text='Connected', id='connectionStatus' %}
+{% include 'components/status_badge.html' %}
+{% endwith %}
+```
+
+Status values: `online`, `offline`, `warning`, `error`, `inactive`
+
+### Buttons
+
+```html
+<!-- Primary action -->
+<button class="btn btn-primary">Start Tracking</button>
+
+<!-- Secondary action -->
+<button class="btn btn-secondary">Cancel</button>
+
+<!-- Danger action -->
+<button class="btn btn-danger">Stop</button>
+
+<!-- Ghost/subtle -->
+<button class="btn btn-ghost">Settings</button>
+
+<!-- Sizes -->
+<button class="btn btn-primary btn-sm">Small</button>
+<button class="btn btn-primary btn-lg">Large</button>
+
+<!-- Icon button -->
+<button class="btn btn-icon btn-secondary">
+    <span class="icon">...</span>
+</button>
+```
+
+### Badges
+
+```html
+<span class="badge">Default</span>
+<span class="badge badge-primary">Primary</span>
+<span class="badge badge-success">Online</span>
+<span class="badge badge-warning">Warning</span>
+<span class="badge badge-danger">Error</span>
+```
+
+### Form Groups
+
+```html
+<div class="form-group">
+    <label for="frequency">Frequency (MHz)</label>
+    <input type="text" id="frequency" value="153.350">
+    <span class="form-help">Enter frequency in MHz</span>
+</div>
+
+<div class="form-group">
+    <label for="gain">Gain</label>
+    <select id="gain">
+        <option value="auto">Auto</option>
+        <option value="30">30 dB</option>
+    </select>
+</div>
+
+<label class="form-check">
+    <input type="checkbox" id="alerts">
+    <span>Enable alerts</span>
+</label>
+```
+
+### Stats Strip
+
+Used in dashboards for horizontal statistics display:
+
+```html
+<div class="stats-strip">
+    <div class="stats-strip-inner">
+        <div class="strip-stat">
+            <span class="strip-value" id="count">0</span>
+            <span class="strip-label">COUNT</span>
+        </div>
+        <div class="strip-divider"></div>
+        <div class="strip-status">
+            <div class="status-dot active" id="statusDot"></div>
+            <span id="statusText">TRACKING</span>
+        </div>
+        <div class="strip-time" id="utcTime">--:--:-- UTC</div>
+    </div>
+</div>
+```
+
+---
+
+## Adding a New Module Page
+
+### 1. Create the Route
+
+In `routes/mymodule.py`:
+
+```python
+from flask import Blueprint, render_template
+
+mymodule_bp = Blueprint('mymodule', __name__, url_prefix='/mymodule')
+
+@mymodule_bp.route('/dashboard')
+def dashboard():
+    return render_template('mymodule_dashboard.html',
+                          offline_settings=get_offline_settings())
+```
+
+### 2. Register the Blueprint
+
+In `routes/__init__.py`:
+
+```python
+from routes.mymodule import mymodule_bp
+app.register_blueprint(mymodule_bp)
+```
+
+### 3. Create the Template
+
+Option A: Simple page extending base.html
+```html
+{% extends 'layout/base.html' %}
+{% set active_mode = 'mymodule' %}
+
+{% block title %}My Module{% endblock %}
+
+{% block navigation %}
+{% include 'partials/nav.html' %}
+{% endblock %}
+
+{% block content %}
+<!-- Your content -->
+{% endblock %}
+```
+
+Option B: Full-screen dashboard
+```html
+{% extends 'layout/base_dashboard.html' %}
+{% set active_mode = 'mymodule' %}
+
+{% block dashboard_title %}MY MODULE{% endblock %}
+
+{% block dashboard_content %}
+<!-- Your dashboard content -->
+{% endblock %}
+```
+
+### 4. Add to Navigation
+
+In `templates/partials/nav.html`, add your module to the appropriate group:
+
+```html
+<button class="mode-nav-btn {% if active_mode == 'mymodule' %}active{% endif %}"
+        onclick="switchMode('mymodule')">
+    <span class="nav-icon icon"><!-- SVG icon --></span>
+    <span class="nav-label">My Module</span>
+</button>
+```
+
+Or if it's a dashboard link:
+```html
+<a href="/mymodule/dashboard"
+   class="mode-nav-btn {% if active_mode == 'mymodule' %}active{% endif %}"
+   style="text-decoration: none;">
+    <span class="nav-icon icon"><!-- SVG icon --></span>
+    <span class="nav-label">My Module</span>
+</a>
+```
+
+### 5. Create Stylesheet
+
+In `static/css/mymodule.css`:
+
+```css
+/**
+ * My Module Styles
+ */
+@import url('./core/variables.css');
+
+/* Your styles using design tokens */
+.mymodule-container {
+    background: var(--bg-secondary);
+    border: 1px solid var(--border-color);
+    border-radius: var(--radius-lg);
+    padding: var(--space-4);
+}
+```
+
+---
+
+## Adding a New Dashboard
+
+For full-screen dashboards like ADSB, AIS, or Satellite:
+
+### 1. Create the Template
+
+```html
+<!DOCTYPE html>
+<html lang="en" data-theme="dark">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>MY DASHBOARD // iNTERCEPT</title>
+    <link rel="icon" type="image/svg+xml" href="{{ url_for('static', filename='favicon.svg') }}">
+
+    <!-- Design tokens (required) -->
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/core/variables.css') }}">
+
+    <!-- Fonts -->
+    {% if offline_settings.fonts_source == 'local' %}
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/fonts-local.css') }}">
+    {% else %}
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=JetBrains+Mono:wght@400;500;600&display=swap" rel="stylesheet">
+    {% endif %}
+
+    <!-- External libraries if needed -->
+    <link rel="stylesheet" href="https://unpkg.com/leaflet@1.9.4/dist/leaflet.css" />
+    <script src="https://unpkg.com/leaflet@1.9.4/dist/leaflet.js"></script>
+
+    <!-- Dashboard styles -->
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/responsive.css') }}">
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/mydashboard.css') }}">
+</head>
+<body>
+    <!-- Background effects -->
+    <div class="radar-bg"></div>
+    <div class="scanline"></div>
+
+    <!-- Header -->
+    <header class="header">
+        <div class="logo">
+            <a href="/" style="color: inherit; text-decoration: none;">
+                MY DASHBOARD
+                <span>// iNTERCEPT</span>
+            </a>
+        </div>
+        <div class="status-bar">
+            <a href="#" onclick="history.back(); return false;" class="back-link">Back</a>
+            <a href="/" class="back-link">Main Dashboard</a>
+        </div>
+    </header>
+
+    <!-- Unified Navigation -->
+    {% set active_mode = 'mydashboard' %}
+    {% include 'partials/nav.html' %}
+
+    <!-- Stats Strip -->
+    <div class="stats-strip">
+        <!-- Stats content -->
+    </div>
+
+    <!-- Main Dashboard Content -->
+    <main class="dashboard">
+        <!-- Your dashboard layout -->
+    </main>
+
+    <script>
+        // Dashboard JavaScript
+    </script>
+</body>
+</html>
+```
+
+### 2. Create the Stylesheet
+
+```css
+/**
+ * My Dashboard Styles
+ */
+@import url('./core/variables.css');
+
+:root {
+    /* Dashboard-specific aliases */
+    --bg-dark: var(--bg-primary);
+    --bg-panel: var(--bg-secondary);
+    --bg-card: var(--bg-tertiary);
+    --grid-line: rgba(74, 158, 255, 0.08);
+}
+
+/* Your dashboard styles */
+```
+
+---
+
+## Best Practices
+
+### DO
+
+- Use design tokens for all colors, spacing, and typography
+- Include the nav partial on all pages for consistent navigation
+- Set `active_mode` before including the nav partial
+- Use semantic component classes (`btn`, `panel`, `badge`, etc.)
+- Support both light and dark themes
+- Test on mobile viewports
+
+### DON'T
+
+- Hardcode color values - use CSS variables
+- Create new color variations without adding to tokens
+- Duplicate navigation markup - use the partial
+- Skip the favicon and design tokens imports
+- Use inline styles for layout (use utility classes)
+
+---
+
+## File Structure
+
+```
+templates/
+├── layout/
+│   ├── base.html              # Standard page base
+│   └── base_dashboard.html    # Dashboard page base
+├── partials/
+│   ├── nav.html               # Unified navigation
+│   ├── page_header.html       # Page title component
+│   └── settings-modal.html    # Settings modal
+├── components/
+│   ├── card.html              # Panel/card component
+│   ├── empty_state.html       # Empty state placeholder
+│   ├── loading.html           # Loading spinner
+│   ├── stats_strip.html       # Stats bar component
+│   └── status_badge.html      # Status indicator
+├── index.html                 # Main dashboard
+├── adsb_dashboard.html        # Aircraft tracking
+├── ais_dashboard.html         # Vessel tracking
+└── satellite_dashboard.html   # Satellite tracking
+
+static/css/
+├── core/
+│   ├── variables.css          # Design tokens
+│   ├── base.css               # Reset & typography
+│   ├── components.css         # Component styles
+│   └── layout.css             # Layout styles
+├── index.css                  # Main dashboard styles
+├── adsb_dashboard.css         # Aircraft dashboard
+├── ais_dashboard.css          # Vessel dashboard
+├── satellite_dashboard.css    # Satellite dashboard
+└── responsive.css             # Responsive breakpoints
+```

docs/USAGE.md

@@ -61,16 +61,21 @@ INTERCEPT automatically detects known trackers:
 
 1. **Select Hardware** - Choose your SDR type (RTL-SDR uses dump1090, others use readsb)
 2. **Check Tools** - Ensure dump1090 or readsb is installed
-3. **Set Location** - Choose location source:
-   - **Manual Entry** - Type coordinates directly
-   - **Browser GPS** - Use browser's built-in geolocation (requires HTTPS)
-   - **USB GPS Dongle** - Connect a USB GPS receiver for continuous updates
-4. **Start Tracking** - Click "Start Tracking" to begin ADS-B reception
-5. **View Map** - Aircraft appear on the interactive Leaflet map
+3. **Set Location** - Choose location source:
+   - **Manual Entry** - Type coordinates directly
+   - **Browser GPS** - Use browser's built-in geolocation (requires HTTPS)
+   - **USB GPS Dongle** - Connect a USB GPS receiver for continuous updates
+   - **Shared Location** - By default, the observer location is shared across modules
+     (disable with `INTERCEPT_SHARED_OBSERVER_LOCATION=false`)
+4. **Start Tracking** - Click "Start Tracking" to begin ADS-B reception
+5. **View Map** - Aircraft appear on the interactive Leaflet map
 6. **Click Aircraft** - Click markers for detailed information
 7. **Display Options** - Toggle callsigns, altitude, trails, range rings, clustering
 8. **Filter Aircraft** - Use dropdown to show all, military, civil, or emergency only
-9. **Full Dashboard** - Click "Full Screen Dashboard" for dedicated radar view
+9. **Full Dashboard** - Click "Full Screen Dashboard" for dedicated radar view
+
+> Note: ADS-B auto-start is disabled by default. To enable auto-start on dashboard load,
+> set `INTERCEPT_ADSB_AUTO_START=true`.
 
 ### Emergency Squawks
 
@@ -96,12 +101,40 @@ Set the following environment variables (Docker recommended):
 | `INTERCEPT_ADSB_DB_USER` | `intercept` | Database user |
 | `INTERCEPT_ADSB_DB_PASSWORD` | `intercept` | Database password |
 
+### Other ADS-B Settings
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `INTERCEPT_ADSB_AUTO_START` | `false` | Auto-start ADS-B tracking when the dashboard loads |
+| `INTERCEPT_SHARED_OBSERVER_LOCATION` | `true` | Share observer location across ADS-B/AIS/SSTV/Satellite modules |
+
+**Local install example**
+
+```bash
+INTERCEPT_ADSB_AUTO_START=true \
+INTERCEPT_SHARED_OBSERVER_LOCATION=false \
+python app.py
+```
+
+**Docker example (.env)**
+
+```bash
+INTERCEPT_ADSB_AUTO_START=true
+INTERCEPT_SHARED_OBSERVER_LOCATION=false
+```
+
 ### Docker Setup
 
 `docker-compose.yml` includes an `adsb_db` service and a persistent volume for history storage:
 
 ```bash
-docker compose up -d
+docker compose --profile history up -d
+```
+
+To store Postgres data on external storage, set `PGDATA_PATH` (defaults to `./pgdata`):
+
+```bash
+PGDATA_PATH=/mnt/usbpi1/intercept/pgdata
 ```
 
 ### Using the History Dashboard
@@ -130,6 +163,58 @@ docker compose up -d
 3. Choose a category (Amateur, Weather, ISS, Starlink, etc.)
 4. Select satellites to add
 
+## Remote Agents (Distributed SIGINT)
+
+Deploy lightweight sensor nodes across multiple locations and aggregate data to a central controller.
+
+### Setting Up an Agent
+
+1. **Install INTERCEPT** on the remote machine
+2. **Create config file** (`intercept_agent.cfg`):
+   ```ini
+   [agent]
+   name = sensor-node-1
+   port = 8020
+
+   [controller]
+   url = http://192.168.1.100:5050
+   api_key = your-secret-key
+   push_enabled = true
+
+   [modes]
+   pager = true
+   sensor = true
+   adsb = true
+   ```
+3. **Start the agent**:
+   ```bash
+   python intercept_agent.py --config intercept_agent.cfg
+   ```
+
+### Registering Agents in the Controller
+
+1. Navigate to `/controller/manage` in the main INTERCEPT instance
+2. Enter agent details:
+   - **Name**: Must match config file (e.g., `sensor-node-1`)
+   - **Base URL**: Agent address (e.g., `http://192.168.1.50:8020`)
+   - **API Key**: Must match config file
+3. Click "Register Agent"
+4. Use "Test" to verify connectivity
+
+### Using Remote Agents
+
+Once registered, agents appear in mode dropdowns:
+
+1. **Select agent** from the dropdown in supported modes
+2. **Start mode** - Commands are proxied to the remote agent
+3. **View data** - Data streams back to your browser via SSE
+
+### Multi-Agent Streaming
+
+Enable "Show All Agents" to aggregate data from all registered agents simultaneously.
+
+For complete documentation, see [Distributed Agents Guide](DISTRIBUTED_AGENTS.md).
+
 ## Configuration
 
 INTERCEPT can be configured via environment variables:

docs/_config.yml

@@ -15,3 +15,4 @@ exclude:
   - USAGE.md
   - FEATURES.md
   - HARDWARE.md
+  - DISTRIBUTED_AGENTS.md

docs/index.html

@@ -18,6 +18,7 @@
                 <a href="#features">Features</a>
                 <a href="#screenshots">Screenshots</a>
                 <a href="#installation">Install</a>
+                <a href="https://github.com/smittix/intercept/blob/main/docs/DISTRIBUTED_AGENTS.md">Remote Agents</a>
                 <a href="https://github.com/smittix/intercept" class="nav-btn" target="_blank">GitHub</a>
             </div>
         </div>
@@ -34,7 +35,7 @@
             </div>
             <div class="hero-stats">
                 <div class="stat">
-                    <span class="stat-value">12+</span>
+                    <span class="stat-value">15+</span>
                     <span class="stat-label">Modes</span>
                 </div>
                 <div class="stat">
@@ -123,6 +124,30 @@
                     <h3>Spy Stations</h3>
                     <p>Number stations and diplomatic HF network database. Frequencies, schedules, and background info from priyom.org.</p>
                 </div>
+
+                <div class="feature-card">
+                    <div class="feature-icon">🌐</div>
+                    <h3>Remote Agents</h3>
+                    <p>Distributed signal intelligence with remote sensor nodes. Deploy agents across multiple locations and aggregate data to a central controller.</p>
+                </div>
+
+                <div class="feature-card">
+                    <div class="feature-icon">📴</div>
+                    <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">
+                    <div class="feature-icon">📡</div>
+                    <h3>Meshtastic</h3>
+                    <p>LoRa mesh network integration. Connect to Meshtastic devices for decentralized, long-range communication monitoring.</p>
+                </div>
+
+                <div class="feature-card">
+                    <div class="feature-icon">🖼️</div>
+                    <h3>ISS SSTV</h3>
+                    <p>Receive Slow Scan Television from the ISS. Real-time tracking globe, pass predictions, and image decoding.</p>
+                </div>
             </div>
         </div>
     </section>
@@ -161,6 +186,14 @@
                     <img src="images/tscm-detail.png" alt="Device Detail Dialog">
                     <span class="screenshot-label">Device Analysis</span>
                 </div>
+                <div class="screenshot-item">
+                    <img src="images/remote-agents.png" alt="Remote Agents Management">
+                    <span class="screenshot-label">Remote Agents</span>
+                </div>
+                <div class="screenshot-item">
+                    <img src="images/ais.png" alt="AIS Vessel Tracking">
+                    <span class="screenshot-label">AIS Vessel Tracking</span>
+                </div>
             </div>
         </div>
     </section>
@@ -255,7 +288,8 @@ docker compose up -d</code></pre>
                 <div class="footer-links">
                     <a href="https://github.com/smittix/intercept" target="_blank">GitHub</a>
                     <a href="https://discord.gg/EyeksEJmWE" target="_blank">Discord</a>
-                    <a href="USAGE.html">Documentation</a>
+                    <a href="https://github.com/smittix/intercept/blob/main/docs/USAGE.md">Documentation</a>
+                    <a href="https://github.com/smittix/intercept/blob/main/docs/DISTRIBUTED_AGENTS.md">Remote Agents</a>
                 </div>
             </div>
             <div class="footer-bottom">

intercept_agent.cfg

@@ -0,0 +1,59 @@
+# =============================================================================
+# INTERCEPT AGENT CONFIGURATION
+# =============================================================================
+# This file configures the Intercept remote agent.
+# Copy this file and customize for your deployment.
+
+[agent]
+# Agent name (used to identify this node in the controller)
+# Default: system hostname
+name = sensor-node-1
+
+# HTTP server port
+# Default: 8020
+port = 8020
+
+# Comma-separated list of allowed client IPs (empty = allow all)
+# Example: 192.168.1.100, 192.168.1.101, 10.0.0.0/8
+allowed_ips =
+
+# Enable CORS headers for browser-based clients
+# Default: false
+allow_cors = false
+
+
+[controller]
+# Controller URL for push mode
+# Example: http://192.168.1.100:5050
+url =
+
+# API key for controller authentication (shared secret)
+api_key =
+
+# Enable automatic push of scan data to controller
+# Default: false
+push_enabled = false
+
+# Push interval in seconds (minimum time between pushes)
+# Default: 5
+push_interval = 5
+
+
+[modes]
+# Enable/disable specific modes on this agent
+# Set to false to disable a mode even if tools are available
+# Default: all true
+
+pager = true
+sensor = true
+adsb = true
+ais = true
+acars = true
+aprs = true
+wifi = true
+bluetooth = true
+dsc = true
+rtlamr = true
+tscm = true
+satellite = true
+listening_post = true

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "intercept"
-version = "2.10.0"
+version = "2.14.0"
 description = "Signal Intelligence Platform - Pager/433MHz/ADS-B/Satellite/WiFi/Bluetooth"
 readme = "README.md"
 requires-python = ">=3.9"
@@ -26,13 +26,14 @@ classifiers = [
     "Topic :: System :: Networking :: Monitoring",
 ]
 dependencies = [
-    "flask>=2.0.0",
+    "flask>=3.0.0",
     "skyfield>=1.45",
     "pyserial>=3.5",
     "Werkzeug>=3.1.5",
     "flask-limiter>=2.5.4",
     "bleak>=0.21.0",
     "flask-sock",
+    "websocket-client>=1.6.0",
     "requests>=2.28.0",
 ]
 
@@ -52,6 +53,15 @@ dev = [
     "types-flask>=1.1.0",
 ]
 
+optionals = [
+    "scipy>=1.10.0",
+    "qrcode[pil]>=7.4",
+    "numpy>=1.24.0",
+    "meshtastic>=2.0.0",
+    "psycopg2-binary>=2.9.9",
+    "scapy>=2.4.5",
+]
+
 [project.scripts]
 intercept = "intercept:main"
 

requirements.txt

@@ -1,5 +1,5 @@
 # Core dependencies
-flask>=2.0.0
+flask>=3.0.0
 flask-limiter>=2.5.4
 requests>=2.28.0
 Werkzeug>=3.1.5
@@ -20,10 +20,21 @@ numpy>=1.24.0
 # GPS dongle support (optional - only needed for USB GPS receivers)
 pyserial>=3.5
 
+# Meshtastic mesh network support (optional - only needed for Meshtastic features)
+meshtastic>=2.0.0
+
+# Deauthentication attack detection (optional - for WiFi TSCM)
+scapy>=2.4.5
+
+# QR code generation for Meshtastic channels (optional)
+qrcode[pil]>=7.4
+
 # Development dependencies (install with: pip install -r requirements-dev.txt)
 # pytest>=7.0.0
 # pytest-cov>=4.0.0
 # ruff>=0.1.0
 # black>=23.0.0
 # mypy>=1.0.0
+# WebSocket support for in-app audio streaming (KiwiSDR, Listening Post)
 flask-sock
+websocket-client>=1.6.0

routes/__init__.py

@@ -19,8 +19,16 @@ def register_blueprints(app):
     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 .sstv_general import sstv_general_bp
+    from .dmr import dmr_bp
+    from .websdr import websdr_bp
 
     app.register_blueprint(pager_bp)
     app.register_blueprint(sensor_bp)
@@ -39,8 +47,16 @@ def register_blueprints(app):
     app.register_blueprint(settings_bp)
     app.register_blueprint(correlation_bp)
     app.register_blueprint(listening_post_bp)
+    app.register_blueprint(meshtastic_bp)
     app.register_blueprint(tscm_bp)
     app.register_blueprint(spy_stations_bp)
+    app.register_blueprint(controller_bp)  # Remote agent controller
+    app.register_blueprint(offline_bp)  # Offline mode settings
+    app.register_blueprint(updater_bp)  # GitHub update checking
+    app.register_blueprint(sstv_bp)  # ISS SSTV 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
 
     # Initialize TSCM state with queue and lock from app
     import app as app_module

routes/acars.py

@@ -43,6 +43,9 @@ DEFAULT_ACARS_FREQUENCIES = [
 acars_message_count = 0
 acars_last_message_time = None
 
+# Track which device is being used
+acars_active_device: int | None = None
+
 
 def find_acarsdec():
     """Find acarsdec binary."""
@@ -52,11 +55,13 @@ def find_acarsdec():
 def get_acarsdec_json_flag(acarsdec_path: str) -> str:
     """Detect which JSON output flag acarsdec supports.
 
-    Version 4.0+ uses -j for JSON stdout.
-    Version 3.x uses -o 4 for JSON stdout.
+    Different forks use different flags:
+    - TLeconte v4.0+: uses -j for JSON stdout
+    - TLeconte v3.x: uses -o 4 for JSON stdout
+    - f00b4r0 fork (DragonOS): uses --output json:file:- for JSON stdout
     """
     try:
-        # Get version by running acarsdec with no args (shows usage with version)
+        # Get help/version by running acarsdec with no args (shows usage)
         result = subprocess.run(
             [acarsdec_path],
             capture_output=True,
@@ -65,8 +70,15 @@ def get_acarsdec_json_flag(acarsdec_path: str) -> str:
         )
         output = result.stdout + result.stderr
 
-        # Parse version from output like "Acarsdec v4.3.1" or "Acarsdec/acarsserv 3.7"
         import re
+
+        # Check for f00b4r0 fork signature: uses --output instead of -j/-o
+        # f00b4r0's help shows "--output" for output configuration
+        if '--output' in output or 'json:file:' in output.lower():
+            logger.debug("Detected f00b4r0 acarsdec fork (--output syntax)")
+            return '--output'
+
+        # Parse version from output like "Acarsdec v4.3.1" or "Acarsdec/acarsserv 3.7"
         version_match = re.search(r'acarsdec[^\d]*v?(\d+)\.(\d+)', output, re.IGNORECASE)
         if version_match:
             major = int(version_match.group(1))
@@ -79,7 +91,7 @@ def get_acarsdec_json_flag(acarsdec_path: str) -> str:
     except Exception as e:
         logger.debug(f"Could not detect acarsdec version: {e}")
 
-    # Default to -j (modern standard for current builds from source)
+    # Default to -j (TLeconte modern standard)
     return '-j'
 
 
@@ -166,7 +178,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
+    global acars_message_count, acars_last_message_time, acars_active_device
 
     with app_module.acars_lock:
         if app_module.acars_process and app_module.acars_process.poll() is None:
@@ -193,6 +205,18 @@ def start_acars() -> Response:
     except ValueError as e:
         return jsonify({'status': 'error', 'message': str(e)}), 400
 
+    # Check if device is available
+    device_int = int(device)
+    error = app_module.claim_sdr_device(device_int, 'acars')
+    if error:
+        return jsonify({
+            'status': 'error',
+            'error_type': 'DEVICE_BUSY',
+            'message': error
+        }), 409
+
+    acars_active_device = device_int
+
     # Get frequencies - use provided or defaults
     frequencies = data.get('frequencies', DEFAULT_ACARS_FREQUENCIES)
     if isinstance(frequencies, str):
@@ -210,15 +234,20 @@ def start_acars() -> Response:
     acars_last_message_time = None
 
     # Build acarsdec command
-    # acarsdec -j -g <gain> -p <ppm> -r <device> <freq1> <freq2> ...
-    # Note: -j is JSON stdout (newer forks), -o 4 was the old syntax
-    # gain/ppm must come BEFORE -r
+    # Different forks have different syntax:
+    # - TLeconte v4+: acarsdec -j -g <gain> -p <ppm> -r <device> <freq1> <freq2> ...
+    # - TLeconte v3: acarsdec -o 4 -g <gain> -p <ppm> -r <device> <freq1> <freq2> ...
+    # - f00b4r0 (DragonOS): acarsdec --output json:file:- -g <gain> -p <ppm> -r <device> <freq1> ...
+    # Note: gain/ppm must come BEFORE -r
     json_flag = get_acarsdec_json_flag(acarsdec_path)
     cmd = [acarsdec_path]
-    if json_flag == '-j':
-        cmd.append('-j')         # JSON output (newer TLeconte fork)
+    if json_flag == '--output':
+        # f00b4r0 fork: --output json:file (no path = stdout)
+        cmd.extend(['--output', 'json:file'])
+    elif json_flag == '-j':
+        cmd.append('-j')         # JSON output (TLeconte v4+)
     else:
-        cmd.extend(['-o', '4'])  # JSON output (older versions)
+        cmd.extend(['-o', '4'])  # JSON output (TLeconte v3.x)
 
     # Add gain if not auto (must be before -r)
     if gain and str(gain) != '0':
@@ -228,8 +257,14 @@ def start_acars() -> Response:
     if ppm and str(ppm) != '0':
         cmd.extend(['-p', str(ppm)])
 
-    # Add device and frequencies (-r takes device, remaining args are frequencies)
-    cmd.extend(['-r', str(device)])
+    # Add device and frequencies
+    # f00b4r0 uses --rtlsdr <device>, TLeconte uses -r <device>
+    if json_flag == '--output':
+        # Use 3.2 MS/s sample rate for wider bandwidth (handles NA frequency span)
+        cmd.extend(['-m', '256'])
+        cmd.extend(['--rtlsdr', str(device)])
+    else:
+        cmd.extend(['-r', str(device)])
     cmd.extend(frequencies)
 
     logger.info(f"Starting ACARS decoder: {' '.join(cmd)}")
@@ -262,7 +297,10 @@ def start_acars() -> Response:
         time.sleep(PROCESS_START_WAIT)
 
         if process.poll() is not None:
-            # Process died
+            # Process died - release device
+            if acars_active_device is not None:
+                app_module.release_sdr_device(acars_active_device)
+                acars_active_device = None
             stderr = ''
             if process.stderr:
                 stderr = process.stderr.read().decode('utf-8', errors='replace')
@@ -290,6 +328,10 @@ 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)
+            acars_active_device = None
         logger.error(f"Failed to start ACARS decoder: {e}")
         return jsonify({'status': 'error', 'message': str(e)}), 500
 
@@ -297,6 +339,8 @@ def start_acars() -> Response:
 @acars_bp.route('/stop', methods=['POST'])
 def stop_acars() -> Response:
     """Stop ACARS decoder."""
+    global acars_active_device
+
     with app_module.acars_lock:
         if not app_module.acars_process:
             return jsonify({
@@ -314,6 +358,11 @@ def stop_acars() -> Response:
 
         app_module.acars_process = None
 
+    # Release device from registry
+    if acars_active_device is not None:
+        app_module.release_sdr_device(acars_active_device)
+        acars_active_device = None
+
     return jsonify({'status': 'stopped'})
 
 

routes/ais.py

@@ -15,6 +15,7 @@ from typing import Generator
 from flask import Blueprint, jsonify, request, Response, render_template
 
 import app as app_module
+from config import SHARED_OBSERVER_LOCATION_ENABLED
 from utils.logging import get_logger
 from utils.validation import validate_device_index, validate_gain
 from utils.sse import format_sse
@@ -163,10 +164,13 @@ def process_ais_message(msg: dict) -> dict | None:
     vessel = app_module.ais_vessels.get(mmsi) or {'mmsi': mmsi}
 
     # Extract common fields
-    if 'lat' in msg and 'lon' in msg:
+    # AIS-catcher JSON_FULL uses 'longitude'/'latitude', but some versions use 'lon'/'lat'
+    lat_val = msg.get('latitude') or msg.get('lat')
+    lon_val = msg.get('longitude') or msg.get('lon')
+    if lat_val is not None and lon_val is not None:
         try:
-            lat = float(msg['lat'])
-            lon = float(msg['lon'])
+            lat = float(lat_val)
+            lon = float(lon_val)
             # Validate coordinates (AIS uses 181 for unavailable)
             if -90 <= lat <= 90 and -180 <= lon <= 180:
                 vessel['lat'] = lat
@@ -366,6 +370,16 @@ def start_ais():
         app_module.ais_process = None
         logger.info("Killed existing AIS process")
 
+    # Check if device is available
+    device_int = int(device)
+    error = app_module.claim_sdr_device(device_int, 'ais')
+    if error:
+        return jsonify({
+            'status': 'error',
+            'error_type': 'DEVICE_BUSY',
+            'message': error
+        }), 409
+
     # Build command using SDR abstraction
     sdr_device = SDRFactory.create_default_device(sdr_type, index=device)
     builder = SDRFactory.get_builder(sdr_type)
@@ -396,6 +410,8 @@ def start_ais():
         time.sleep(2.0)
 
         if app_module.ais_process.poll() is not None:
+            # Release device on failure
+            app_module.release_sdr_device(device_int)
             stderr_output = ''
             if app_module.ais_process.stderr:
                 try:
@@ -421,6 +437,8 @@ def start_ais():
             'port': tcp_port
         })
     except Exception as e:
+        # Release device on failure
+        app_module.release_sdr_device(device_int)
         logger.error(f"Failed to start AIS-catcher: {e}")
         return jsonify({'status': 'error', 'message': str(e)}), 500
 
@@ -444,6 +462,11 @@ def stop_ais():
                     pass
             app_module.ais_process = None
             logger.info("AIS process stopped")
+
+        # Release device from registry
+        if ais_active_device is not None:
+            app_module.release_sdr_device(ais_active_device)
+
         ais_running = False
         ais_active_device = None
 
@@ -477,4 +500,7 @@ def stream_ais():
 @ais_bp.route('/dashboard')
 def ais_dashboard():
     """Popout AIS dashboard."""
-    return render_template('ais_dashboard.html')
+    return render_template(
+        'ais_dashboard.html',
+        shared_observer_location=SHARED_OBSERVER_LOCATION_ENABLED,
+    )

routes/aprs.py

@@ -13,7 +13,7 @@ import tempfile
 import threading
 import time
 from datetime import datetime
-from subprocess import DEVNULL, PIPE, STDOUT
+from subprocess import PIPE, STDOUT
 from typing import Generator, Optional
 
 from flask import Blueprint, jsonify, request, Response
@@ -31,6 +31,9 @@ from utils.constants import (
 
 aprs_bp = Blueprint('aprs', __name__, url_prefix='/aprs')
 
+# Track which SDR device is being used
+aprs_active_device: int | None = None
+
 # APRS frequencies by region (MHz)
 APRS_FREQUENCIES = {
     'north_america': '144.390',
@@ -1301,7 +1304,7 @@ def stream_aprs_output(rtl_process: subprocess.Popen, decoder_process: subproces
 
     This function reads from the decoder's stdout (text mode, line-buffered).
     The decoder's stderr is merged into stdout (STDOUT) to avoid deadlocks.
-    rtl_fm's stderr is sent to DEVNULL for the same reason.
+    rtl_fm's stderr is captured via PIPE with a monitor thread.
 
     Outputs two types of messages to the queue:
     - type='aprs': Decoded APRS packets
@@ -1383,6 +1386,7 @@ 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
         app_module.aprs_queue.put({'type': 'status', 'status': 'stopped'})
         # Cleanup processes
         for proc in [rtl_process, decoder_process]:
@@ -1394,6 +1398,10 @@ def stream_aprs_output(rtl_process: subprocess.Popen, decoder_process: subproces
                     proc.kill()
                 except Exception:
                     pass
+        # Release SDR device
+        if aprs_active_device is not None:
+            app_module.release_sdr_device(aprs_active_device)
+            aprs_active_device = None
 
 
 @aprs_bp.route('/tools')
@@ -1441,6 +1449,7 @@ def get_stations() -> Response:
 def start_aprs() -> Response:
     """Start APRS decoder."""
     global aprs_packet_count, aprs_station_count, aprs_last_packet_time, aprs_stations
+    global aprs_active_device
 
     with app_module.aprs_lock:
         if app_module.aprs_process and app_module.aprs_process.poll() is None:
@@ -1477,6 +1486,16 @@ def start_aprs() -> Response:
     except ValueError as e:
         return jsonify({'status': 'error', 'message': str(e)}), 400
 
+    # Reserve SDR device to prevent conflicts with other modes
+    error = app_module.reserve_sdr_device(device, 'APRS')
+    if error:
+        return jsonify({
+            'status': 'error',
+            'error_type': 'DEVICE_BUSY',
+            'message': error
+        }), 409
+    aprs_active_device = device
+
     # Get frequency for region
     region = data.get('region', 'north_america')
     frequency = APRS_FREQUENCIES.get(region, '144.390')
@@ -1552,15 +1571,25 @@ def start_aprs() -> Response:
 
     try:
         # Start rtl_fm with stdout piped to decoder.
-        # stderr goes to DEVNULL to prevent blocking (rtl_fm logs to stderr).
+        # stderr is captured via PIPE so errors are reported to the user.
         # NOTE: RTL-SDR Blog V4 may show offset-tuned frequency in logs - this is normal.
         rtl_process = subprocess.Popen(
             rtl_cmd,
             stdout=PIPE,
-            stderr=DEVNULL,
+            stderr=PIPE,
             start_new_session=True
         )
 
+        # Start a thread to monitor rtl_fm stderr for errors
+        def monitor_rtl_stderr():
+            for line in rtl_process.stderr:
+                err_text = line.decode('utf-8', errors='replace').strip()
+                if err_text:
+                    logger.debug(f"[RTL_FM] {err_text}")
+
+        rtl_stderr_thread = threading.Thread(target=monitor_rtl_stderr, daemon=True)
+        rtl_stderr_thread.start()
+
         # Start decoder with stdin wired to rtl_fm's stdout.
         # Use text mode with line buffering for reliable line-by-line reading.
         # Merge stderr into stdout to avoid blocking on unbuffered stderr.
@@ -1582,13 +1611,25 @@ def start_aprs() -> Response:
         time.sleep(PROCESS_START_WAIT)
 
         if rtl_process.poll() is not None:
-            # rtl_fm exited early - something went wrong
+            # rtl_fm exited early - capture stderr for diagnostics
+            stderr_output = ''
+            try:
+                remaining = rtl_process.stderr.read()
+                if remaining:
+                    stderr_output = remaining.decode('utf-8', errors='replace').strip()
+            except Exception:
+                pass
             error_msg = f'rtl_fm failed to start (exit code {rtl_process.returncode})'
+            if stderr_output:
+                error_msg += f': {stderr_output[:200]}'
             logger.error(error_msg)
             try:
                 decoder_process.kill()
             except Exception:
                 pass
+            if aprs_active_device is not None:
+                app_module.release_sdr_device(aprs_active_device)
+                aprs_active_device = None
             return jsonify({'status': 'error', 'message': error_msg}), 500
 
         if decoder_process.poll() is not None:
@@ -1602,6 +1643,9 @@ def start_aprs() -> Response:
                 rtl_process.kill()
             except Exception:
                 pass
+            if aprs_active_device is not None:
+                app_module.release_sdr_device(aprs_active_device)
+                aprs_active_device = None
             return jsonify({'status': 'error', 'message': error_msg}), 500
 
         # Store references for status checks and cleanup
@@ -1626,12 +1670,17 @@ 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)
+            aprs_active_device = 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
+
     with app_module.aprs_lock:
         processes_to_stop = []
 
@@ -1660,6 +1709,11 @@ def stop_aprs() -> Response:
         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)
+            aprs_active_device = None
+
     return jsonify({'status': 'stopped'})
 
 

routes/audio_websocket.py

@@ -228,9 +228,13 @@ def init_audio_websocket(app: Flask):
 
                 except TimeoutError:
                     pass
-                except Exception as e:
-                    if "timed out" not in str(e).lower():
-                        logger.error(f"WebSocket receive error: {e}")
+                except Exception as e:
+                    msg = str(e).lower()
+                    if "connection closed" in msg:
+                        logger.info("WebSocket closed by client")
+                        break
+                    if "timed out" not in msg:
+                        logger.error(f"WebSocket receive error: {e}")
 
                 # Stream audio data if active
                 if streaming and proc and proc.poll() is None:

routes/controller.py

@@ -0,0 +1,896 @@
+"""
+Controller routes for managing remote Intercept agents.
+
+This blueprint provides:
+- Agent CRUD operations
+- Proxy endpoints to forward requests to agents
+- Push data ingestion endpoint
+- Multi-agent SSE stream
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import queue
+import time
+from datetime import datetime, timezone
+from typing import Generator
+
+import requests
+
+from flask import Blueprint, jsonify, request, Response
+
+from utils.database import (
+    create_agent, get_agent, get_agent_by_name, list_agents,
+    update_agent, delete_agent, store_push_payload, get_recent_payloads
+)
+from utils.agent_client import (
+    AgentClient, AgentHTTPError, AgentConnectionError, create_client_from_agent
+)
+from utils.sse import format_sse
+from utils.trilateration import (
+    DeviceLocationTracker, PathLossModel, Trilateration,
+    AgentObservation, estimate_location_from_observations
+)
+
+logger = logging.getLogger('intercept.controller')
+
+controller_bp = Blueprint('controller', __name__, url_prefix='/controller')
+
+# Multi-agent data queue for combined SSE stream
+agent_data_queue: queue.Queue = queue.Queue(maxsize=1000)
+
+
+# =============================================================================
+# Agent CRUD
+# =============================================================================
+
+@controller_bp.route('/agents', methods=['GET'])
+def get_agents():
+    """List all registered agents."""
+    active_only = request.args.get('active_only', 'true').lower() == 'true'
+    agents = list_agents(active_only=active_only)
+
+    # Optionally refresh status for each agent
+    refresh = request.args.get('refresh', 'false').lower() == 'true'
+    if refresh:
+        for agent in agents:
+            try:
+                client = create_client_from_agent(agent)
+                agent['healthy'] = client.health_check()
+            except Exception:
+                agent['healthy'] = False
+
+    return jsonify({
+        'status': 'success',
+        'agents': agents,
+        'count': len(agents)
+    })
+
+
+@controller_bp.route('/agents', methods=['POST'])
+def register_agent():
+    """
+    Register a new remote agent.
+
+    Expected JSON body:
+    {
+        "name": "sensor-node-1",
+        "base_url": "http://192.168.1.50:8020",
+        "api_key": "optional-shared-secret",
+        "description": "Optional description"
+    }
+    """
+    data = request.json or {}
+
+    # Validate required fields
+    name = data.get('name', '').strip()
+    base_url = data.get('base_url', '').strip()
+
+    if not name:
+        return jsonify({'status': 'error', 'message': 'Agent name is required'}), 400
+    if not base_url:
+        return jsonify({'status': 'error', 'message': 'Base URL is required'}), 400
+
+    # Validate URL format
+    from urllib.parse import urlparse
+    try:
+        parsed = urlparse(base_url)
+        if parsed.scheme not in ('http', 'https'):
+            return jsonify({'status': 'error', 'message': 'URL must start with http:// or https://'}), 400
+        if not parsed.netloc:
+            return jsonify({'status': 'error', 'message': 'Invalid URL format'}), 400
+    except Exception:
+        return jsonify({'status': 'error', 'message': 'Invalid URL format'}), 400
+
+    # Check if agent already exists
+    existing = get_agent_by_name(name)
+    if existing:
+        return jsonify({
+            'status': 'error',
+            'message': f'Agent with name "{name}" already exists'
+        }), 409
+
+    # Try to connect and get capabilities
+    api_key = data.get('api_key', '').strip() or None
+    client = AgentClient(base_url, api_key=api_key)
+
+    capabilities = None
+    interfaces = None
+    try:
+        caps = client.get_capabilities()
+        capabilities = caps.get('modes', {})
+        interfaces = {'devices': caps.get('devices', [])}
+    except (AgentHTTPError, AgentConnectionError) as e:
+        logger.warning(f"Could not fetch capabilities from {base_url}: {e}")
+
+    # Create agent
+    try:
+        agent_id = create_agent(
+            name=name,
+            base_url=base_url,
+            api_key=api_key,
+            description=data.get('description'),
+            capabilities=capabilities,
+            interfaces=interfaces
+        )
+
+        # Update last_seen since we just connected
+        if capabilities is not None:
+            update_agent(agent_id, update_last_seen=True)
+
+        agent = get_agent(agent_id)
+        message = 'Agent registered successfully'
+        if capabilities is None:
+            message += ' (could not connect - agent may be offline)'
+        return jsonify({
+            'status': 'success',
+            'message': message,
+            'agent': agent
+        }), 201
+
+    except Exception as e:
+        logger.exception("Failed to create agent")
+        return jsonify({'status': 'error', 'message': str(e)}), 500
+
+
+@controller_bp.route('/agents/<int:agent_id>', methods=['GET'])
+def get_agent_detail(agent_id: int):
+    """Get details of a specific agent."""
+    agent = get_agent(agent_id)
+    if not agent:
+        return jsonify({'status': 'error', 'message': 'Agent not found'}), 404
+
+    # Optionally refresh from agent
+    refresh = request.args.get('refresh', 'false').lower() == 'true'
+    if refresh:
+        try:
+            client = create_client_from_agent(agent)
+            metadata = client.refresh_metadata()
+            if metadata['healthy']:
+                caps = metadata['capabilities'] or {}
+                # Store full interfaces structure (wifi, bt, sdr)
+                agent_interfaces = caps.get('interfaces', {})
+                # Fallback: also include top-level devices for backwards compatibility
+                if not agent_interfaces.get('sdr_devices') and caps.get('devices'):
+                    agent_interfaces['sdr_devices'] = caps.get('devices', [])
+                update_agent(
+                    agent_id,
+                    capabilities=caps.get('modes'),
+                    interfaces=agent_interfaces,
+                    update_last_seen=True
+                )
+                agent = get_agent(agent_id)
+                agent['healthy'] = True
+            else:
+                agent['healthy'] = False
+        except Exception:
+            agent['healthy'] = False
+
+    return jsonify({'status': 'success', 'agent': agent})
+
+
+@controller_bp.route('/agents/<int:agent_id>', methods=['PUT', 'PATCH'])
+def update_agent_detail(agent_id: int):
+    """Update an agent's details."""
+    agent = get_agent(agent_id)
+    if not agent:
+        return jsonify({'status': 'error', 'message': 'Agent not found'}), 404
+
+    data = request.json or {}
+
+    # Update allowed fields
+    update_agent(
+        agent_id,
+        base_url=data.get('base_url'),
+        description=data.get('description'),
+        api_key=data.get('api_key'),
+        is_active=data.get('is_active')
+    )
+
+    agent = get_agent(agent_id)
+    return jsonify({'status': 'success', 'agent': agent})
+
+
+@controller_bp.route('/agents/<int:agent_id>', methods=['DELETE'])
+def remove_agent(agent_id: int):
+    """Delete an agent."""
+    agent = get_agent(agent_id)
+    if not agent:
+        return jsonify({'status': 'error', 'message': 'Agent not found'}), 404
+
+    delete_agent(agent_id)
+    return jsonify({'status': 'success', 'message': 'Agent deleted'})
+
+
+@controller_bp.route('/agents/<int:agent_id>/refresh', methods=['POST'])
+def refresh_agent_metadata(agent_id: int):
+    """Refresh an agent's capabilities and status."""
+    agent = get_agent(agent_id)
+    if not agent:
+        return jsonify({'status': 'error', 'message': 'Agent not found'}), 404
+
+    try:
+        client = create_client_from_agent(agent)
+        metadata = client.refresh_metadata()
+
+        if metadata['healthy']:
+            caps = metadata['capabilities'] or {}
+            # Store full interfaces structure (wifi, bt, sdr)
+            agent_interfaces = caps.get('interfaces', {})
+            # Fallback: also include top-level devices for backwards compatibility
+            if not agent_interfaces.get('sdr_devices') and caps.get('devices'):
+                agent_interfaces['sdr_devices'] = caps.get('devices', [])
+            update_agent(
+                agent_id,
+                capabilities=caps.get('modes'),
+                interfaces=agent_interfaces,
+                update_last_seen=True
+            )
+            agent = get_agent(agent_id)
+            return jsonify({
+                'status': 'success',
+                'agent': agent,
+                'metadata': metadata
+            })
+        else:
+            return jsonify({
+                'status': 'error',
+                'message': 'Agent is not reachable'
+            }), 503
+
+    except (AgentHTTPError, AgentConnectionError) as e:
+        return jsonify({
+            'status': 'error',
+            'message': f'Failed to reach agent: {e}'
+        }), 503
+
+
+# =============================================================================
+# Agent Status - Get running state
+# =============================================================================
+
+@controller_bp.route('/agents/<int:agent_id>/status', methods=['GET'])
+def get_agent_status(agent_id: int):
+    """Get an agent's current status including running modes."""
+    agent = get_agent(agent_id)
+    if not agent:
+        return jsonify({'status': 'error', 'message': 'Agent not found'}), 404
+
+    try:
+        client = create_client_from_agent(agent)
+        status = client.get_status()
+        return jsonify({
+            'status': 'success',
+            'agent_id': agent_id,
+            'agent_name': agent['name'],
+            'agent_status': status
+        })
+    except (AgentHTTPError, AgentConnectionError) as e:
+        return jsonify({
+            'status': 'error',
+            'message': f'Failed to reach agent: {e}'
+        }), 503
+
+
+@controller_bp.route('/agents/health', methods=['GET'])
+def check_all_agents_health():
+    """
+    Check health of all registered agents in one call.
+
+    More efficient than checking each agent individually.
+    Returns health status, response time, and running modes for each agent.
+    """
+    agents_list = list_agents(active_only=True)
+    results = []
+
+    for agent in agents_list:
+        result = {
+            'id': agent['id'],
+            'name': agent['name'],
+            'healthy': False,
+            'response_time_ms': None,
+            'running_modes': [],
+            'error': None
+        }
+
+        try:
+            client = create_client_from_agent(agent)
+
+            # Time the health check
+            start_time = time.time()
+            is_healthy = client.health_check()
+            response_time = (time.time() - start_time) * 1000
+
+            result['healthy'] = is_healthy
+            result['response_time_ms'] = round(response_time, 1)
+
+            if is_healthy:
+                # Update last_seen in database
+                update_agent(agent['id'], update_last_seen=True)
+
+                # Also fetch running modes
+                try:
+                    status = client.get_status()
+                    result['running_modes'] = status.get('running_modes', [])
+                    result['running_modes_detail'] = status.get('running_modes_detail', {})
+                except Exception:
+                    pass  # Status fetch is optional
+
+        except AgentConnectionError as e:
+            result['error'] = f'Connection failed: {str(e)}'
+        except AgentHTTPError as e:
+            result['error'] = f'HTTP error: {str(e)}'
+        except Exception as e:
+            result['error'] = str(e)
+
+        results.append(result)
+
+    return jsonify({
+        'status': 'success',
+        'timestamp': datetime.now(timezone.utc).isoformat(),
+        'agents': results,
+        'total': len(results),
+        'healthy_count': sum(1 for r in results if r['healthy'])
+    })
+
+
+# =============================================================================
+# Proxy Operations - Forward requests to agents
+# =============================================================================
+
+@controller_bp.route('/agents/<int:agent_id>/<mode>/start', methods=['POST'])
+def proxy_start_mode(agent_id: int, mode: str):
+    """Start a mode on a remote agent."""
+    agent = get_agent(agent_id)
+    if not agent:
+        return jsonify({'status': 'error', 'message': 'Agent not found'}), 404
+
+    params = request.json or {}
+
+    try:
+        client = create_client_from_agent(agent)
+        result = client.start_mode(mode, params)
+
+        # Update last_seen
+        update_agent(agent_id, update_last_seen=True)
+
+        return jsonify({
+            'status': 'success',
+            'agent_id': agent_id,
+            'mode': mode,
+            'result': result
+        })
+
+    except AgentConnectionError as e:
+        return jsonify({
+            'status': 'error',
+            'message': f'Cannot connect to agent: {e}'
+        }), 503
+    except AgentHTTPError as e:
+        return jsonify({
+            'status': 'error',
+            'message': f'Agent error: {e}'
+        }), 502
+
+
+@controller_bp.route('/agents/<int:agent_id>/<mode>/stop', methods=['POST'])
+def proxy_stop_mode(agent_id: int, mode: str):
+    """Stop a mode on a remote agent."""
+    agent = get_agent(agent_id)
+    if not agent:
+        return jsonify({'status': 'error', 'message': 'Agent not found'}), 404
+
+    try:
+        client = create_client_from_agent(agent)
+        result = client.stop_mode(mode)
+
+        update_agent(agent_id, update_last_seen=True)
+
+        return jsonify({
+            'status': 'success',
+            'agent_id': agent_id,
+            'mode': mode,
+            'result': result
+        })
+
+    except AgentConnectionError as e:
+        return jsonify({
+            'status': 'error',
+            'message': f'Cannot connect to agent: {e}'
+        }), 503
+    except AgentHTTPError as e:
+        return jsonify({
+            'status': 'error',
+            'message': f'Agent error: {e}'
+        }), 502
+
+
+@controller_bp.route('/agents/<int:agent_id>/<mode>/status', methods=['GET'])
+def proxy_mode_status(agent_id: int, mode: str):
+    """Get mode status from a remote agent."""
+    agent = get_agent(agent_id)
+    if not agent:
+        return jsonify({'status': 'error', 'message': 'Agent not found'}), 404
+
+    try:
+        client = create_client_from_agent(agent)
+        result = client.get_mode_status(mode)
+
+        return jsonify({
+            'status': 'success',
+            'agent_id': agent_id,
+            'mode': mode,
+            'result': result
+        })
+
+    except (AgentHTTPError, AgentConnectionError) as e:
+        return jsonify({
+            'status': 'error',
+            'message': f'Agent error: {e}'
+        }), 502
+
+
+@controller_bp.route('/agents/<int:agent_id>/<mode>/data', methods=['GET'])
+def proxy_mode_data(agent_id: int, mode: str):
+    """Get current data from a remote agent."""
+    agent = get_agent(agent_id)
+    if not agent:
+        return jsonify({'status': 'error', 'message': 'Agent not found'}), 404
+
+    try:
+        client = create_client_from_agent(agent)
+        result = client.get_mode_data(mode)
+
+        # Tag data with agent info
+        result['agent_id'] = agent_id
+        result['agent_name'] = agent['name']
+
+        return jsonify({
+            'status': 'success',
+            'agent_id': agent_id,
+            'agent_name': agent['name'],
+            'mode': mode,
+            'data': result
+        })
+
+    except (AgentHTTPError, AgentConnectionError) as e:
+        return jsonify({
+            'status': 'error',
+            'message': f'Agent error: {e}'
+        }), 502
+
+
+@controller_bp.route('/agents/<int:agent_id>/<mode>/stream')
+def proxy_mode_stream(agent_id: int, mode: str):
+    """Proxy SSE stream from a remote agent."""
+    agent = get_agent(agent_id)
+    if not agent:
+        return jsonify({'status': 'error', 'message': 'Agent not found'}), 404
+
+    client = create_client_from_agent(agent)
+    query = request.query_string.decode('utf-8')
+    url = f"{client.base_url}/{mode}/stream"
+    if query:
+        url = f"{url}?{query}"
+
+    headers = {'Accept': 'text/event-stream'}
+    if agent.get('api_key'):
+        headers['X-API-Key'] = agent['api_key']
+
+    def generate() -> Generator[str, None, None]:
+        try:
+            with requests.get(url, headers=headers, stream=True, timeout=(5, 3600)) as resp:
+                resp.raise_for_status()
+                for chunk in resp.iter_content(chunk_size=1024):
+                    if not chunk:
+                        continue
+                    yield chunk.decode('utf-8', errors='ignore')
+        except Exception as e:
+            logger.error(f"SSE proxy error for agent {agent_id}/{mode}: {e}")
+            yield format_sse({
+                'type': 'error',
+                'message': str(e),
+                'agent_id': agent_id,
+                'mode': mode,
+            })
+
+    response = Response(generate(), mimetype='text/event-stream')
+    response.headers['Cache-Control'] = 'no-cache'
+    response.headers['X-Accel-Buffering'] = 'no'
+    response.headers['Connection'] = 'keep-alive'
+    return response
+
+
+@controller_bp.route('/agents/<int:agent_id>/wifi/monitor', methods=['POST'])
+def proxy_wifi_monitor(agent_id: int):
+    """Toggle monitor mode on a remote agent's WiFi interface."""
+    agent = get_agent(agent_id)
+    if not agent:
+        return jsonify({'status': 'error', 'message': 'Agent not found'}), 404
+
+    data = request.json or {}
+
+    try:
+        client = create_client_from_agent(agent)
+        result = client.post('/wifi/monitor', data)
+
+        # Refresh agent capabilities after monitor mode toggle so UI stays in sync
+        if result.get('status') == 'success':
+            try:
+                metadata = client.refresh_metadata()
+                if metadata.get('healthy'):
+                    caps = metadata.get('capabilities') or {}
+                    agent_interfaces = caps.get('interfaces', {})
+                    if not agent_interfaces.get('sdr_devices') and caps.get('devices'):
+                        agent_interfaces['sdr_devices'] = caps.get('devices', [])
+                    update_agent(
+                        agent_id,
+                        capabilities=caps.get('modes'),
+                        interfaces=agent_interfaces,
+                        update_last_seen=True
+                    )
+            except Exception:
+                pass  # Non-fatal if refresh fails
+
+        return jsonify({
+            'status': result.get('status', 'error'),
+            'agent_id': agent_id,
+            'agent_name': agent['name'],
+            'monitor_interface': result.get('monitor_interface'),
+            'message': result.get('message')
+        })
+
+    except AgentConnectionError as e:
+        return jsonify({
+            'status': 'error',
+            'message': f'Cannot connect to agent: {e}'
+        }), 503
+    except AgentHTTPError as e:
+        return jsonify({
+            'status': 'error',
+            'message': f'Agent error: {e}'
+        }), 502
+
+
+# =============================================================================
+# Push Data Ingestion
+# =============================================================================
+
+@controller_bp.route('/api/ingest', methods=['POST'])
+def ingest_push_data():
+    """
+    Receive pushed data from remote agents.
+
+    Expected JSON body:
+    {
+        "agent_name": "sensor-node-1",
+        "scan_type": "adsb",
+        "interface": "rtlsdr0",
+        "payload": {...},
+        "received_at": "2024-01-15T10:30:00Z"
+    }
+
+    Expected header:
+        X-API-Key: shared-secret (if agent has api_key configured)
+    """
+    data = request.json
+    if not data:
+        return jsonify({'status': 'error', 'message': 'No data provided'}), 400
+
+    agent_name = data.get('agent_name')
+    if not agent_name:
+        return jsonify({'status': 'error', 'message': 'agent_name required'}), 400
+
+    # Find agent
+    agent = get_agent_by_name(agent_name)
+    if not agent:
+        return jsonify({'status': 'error', 'message': 'Unknown agent'}), 401
+
+    # Validate API key if configured
+    if agent.get('api_key'):
+        provided_key = request.headers.get('X-API-Key', '')
+        if provided_key != agent['api_key']:
+            logger.warning(f"Invalid API key from agent {agent_name}")
+            return jsonify({'status': 'error', 'message': 'Invalid API key'}), 401
+
+    # Store payload
+    try:
+        payload_id = store_push_payload(
+            agent_id=agent['id'],
+            scan_type=data.get('scan_type', 'unknown'),
+            payload=data.get('payload', {}),
+            interface=data.get('interface'),
+            received_at=data.get('received_at')
+        )
+
+        # Emit to SSE stream
+        try:
+            agent_data_queue.put_nowait({
+                'type': 'agent_data',
+                'agent_id': agent['id'],
+                'agent_name': agent_name,
+                'scan_type': data.get('scan_type'),
+                'interface': data.get('interface'),
+                'payload': data.get('payload'),
+                'received_at': data.get('received_at') or datetime.now(timezone.utc).isoformat()
+            })
+        except queue.Full:
+            logger.warning("Agent data queue full, data may be lost")
+
+        return jsonify({
+            'status': 'accepted',
+            'payload_id': payload_id
+        }), 202
+
+    except Exception as e:
+        logger.exception("Failed to store push payload")
+        return jsonify({'status': 'error', 'message': str(e)}), 500
+
+
+@controller_bp.route('/api/payloads', methods=['GET'])
+def get_payloads():
+    """Get recent push payloads."""
+    agent_id = request.args.get('agent_id', type=int)
+    scan_type = request.args.get('scan_type')
+    limit = request.args.get('limit', 100, type=int)
+
+    payloads = get_recent_payloads(
+        agent_id=agent_id,
+        scan_type=scan_type,
+        limit=min(limit, 1000)
+    )
+
+    return jsonify({
+        'status': 'success',
+        'payloads': payloads,
+        'count': len(payloads)
+    })
+
+
+# =============================================================================
+# Multi-Agent SSE Stream
+# =============================================================================
+
+@controller_bp.route('/stream/all')
+def stream_all_agents():
+    """
+    Combined SSE stream for data from all agents.
+
+    This endpoint streams push data as it arrives from agents.
+    Each message is tagged with agent_id and agent_name.
+    """
+    def generate() -> Generator[str, None, None]:
+        last_keepalive = time.time()
+        keepalive_interval = 30.0
+
+        while True:
+            try:
+                msg = agent_data_queue.get(timeout=1.0)
+                last_keepalive = time.time()
+                yield format_sse(msg)
+            except queue.Empty:
+                now = time.time()
+                if now - last_keepalive >= keepalive_interval:
+                    yield format_sse({'type': 'keepalive'})
+                    last_keepalive = now
+
+    response = Response(generate(), mimetype='text/event-stream')
+    response.headers['Cache-Control'] = 'no-cache'
+    response.headers['X-Accel-Buffering'] = 'no'
+    response.headers['Connection'] = 'keep-alive'
+    return response
+
+
+# =============================================================================
+# Agent Management Page
+# =============================================================================
+
+@controller_bp.route('/manage')
+def agent_management_page():
+    """Render the agent management page."""
+    from flask import render_template
+    from config import VERSION
+    return render_template('agents.html', version=VERSION)
+
+
+@controller_bp.route('/monitor')
+def network_monitor_page():
+    """Render the network monitor page for multi-agent aggregated view."""
+    from flask import render_template
+    return render_template('network_monitor.html')
+
+
+# =============================================================================
+# Device Location Estimation (Trilateration)
+# =============================================================================
+
+# Global device location tracker
+device_tracker = DeviceLocationTracker(
+    trilateration=Trilateration(
+        path_loss_model=PathLossModel('outdoor'),
+        min_observations=2
+    ),
+    observation_window_seconds=120.0,  # 2 minute window
+    min_observations=2
+)
+
+
+@controller_bp.route('/api/location/observe', methods=['POST'])
+def add_location_observation():
+    """
+    Add an observation for device location estimation.
+
+    Expected JSON body:
+    {
+        "device_id": "AA:BB:CC:DD:EE:FF",
+        "agent_name": "sensor-node-1",
+        "agent_lat": 40.7128,
+        "agent_lon": -74.0060,
+        "rssi": -55,
+        "frequency_mhz": 2400  (optional)
+    }
+
+    Returns location estimate if enough data, null otherwise.
+    """
+    data = request.json or {}
+
+    required = ['device_id', 'agent_name', 'agent_lat', 'agent_lon', 'rssi']
+    for field in required:
+        if field not in data:
+            return jsonify({'status': 'error', 'message': f'Missing required field: {field}'}), 400
+
+    # Look up agent GPS from database if not provided
+    agent_lat = data.get('agent_lat')
+    agent_lon = data.get('agent_lon')
+
+    if agent_lat is None or agent_lon is None:
+        agent = get_agent_by_name(data['agent_name'])
+        if agent and agent.get('gps_coords'):
+            coords = agent['gps_coords']
+            agent_lat = coords.get('lat') or coords.get('latitude')
+            agent_lon = coords.get('lon') or coords.get('longitude')
+
+    if agent_lat is None or agent_lon is None:
+        return jsonify({
+            'status': 'error',
+            'message': 'Agent GPS coordinates required'
+        }), 400
+
+    estimate = device_tracker.add_observation(
+        device_id=data['device_id'],
+        agent_name=data['agent_name'],
+        agent_lat=float(agent_lat),
+        agent_lon=float(agent_lon),
+        rssi=float(data['rssi']),
+        frequency_mhz=data.get('frequency_mhz')
+    )
+
+    return jsonify({
+        'status': 'success',
+        'device_id': data['device_id'],
+        'location': estimate.to_dict() if estimate else None
+    })
+
+
+@controller_bp.route('/api/location/estimate', methods=['POST'])
+def estimate_location():
+    """
+    Estimate device location from provided observations.
+
+    Expected JSON body:
+    {
+        "observations": [
+            {"agent_lat": 40.7128, "agent_lon": -74.0060, "rssi": -55, "agent_name": "node-1"},
+            {"agent_lat": 40.7135, "agent_lon": -74.0055, "rssi": -70, "agent_name": "node-2"},
+            {"agent_lat": 40.7120, "agent_lon": -74.0050, "rssi": -62, "agent_name": "node-3"}
+        ],
+        "environment": "outdoor"  (optional: outdoor, indoor, free_space)
+    }
+    """
+    data = request.json or {}
+
+    observations = data.get('observations', [])
+    if len(observations) < 2:
+        return jsonify({
+            'status': 'error',
+            'message': 'At least 2 observations required'
+        }), 400
+
+    environment = data.get('environment', 'outdoor')
+
+    try:
+        result = estimate_location_from_observations(observations, environment)
+        return jsonify({
+            'status': 'success' if result else 'insufficient_data',
+            'location': result
+        })
+    except Exception as e:
+        logger.exception("Location estimation failed")
+        return jsonify({'status': 'error', 'message': str(e)}), 500
+
+
+@controller_bp.route('/api/location/<device_id>', methods=['GET'])
+def get_device_location(device_id: str):
+    """Get the latest location estimate for a device."""
+    estimate = device_tracker.get_location(device_id)
+
+    if not estimate:
+        return jsonify({
+            'status': 'not_found',
+            'device_id': device_id,
+            'location': None
+        })
+
+    return jsonify({
+        'status': 'success',
+        'device_id': device_id,
+        'location': estimate.to_dict()
+    })
+
+
+@controller_bp.route('/api/location/all', methods=['GET'])
+def get_all_locations():
+    """Get all current device location estimates."""
+    locations = device_tracker.get_all_locations()
+
+    return jsonify({
+        'status': 'success',
+        'count': len(locations),
+        'devices': {
+            device_id: estimate.to_dict()
+            for device_id, estimate in locations.items()
+        }
+    })
+
+
+@controller_bp.route('/api/location/near', methods=['GET'])
+def get_devices_near():
+    """
+    Find devices near a location.
+
+    Query params:
+        lat: latitude
+        lon: longitude
+        radius: radius in meters (default 100)
+    """
+    try:
+        lat = float(request.args.get('lat', 0))
+        lon = float(request.args.get('lon', 0))
+        radius = float(request.args.get('radius', 100))
+    except (ValueError, TypeError):
+        return jsonify({'status': 'error', 'message': 'Invalid coordinates'}), 400
+
+    results = device_tracker.get_devices_near(lat, lon, radius)
+
+    return jsonify({
+        'status': 'success',
+        'center': {'lat': lat, 'lon': lon},
+        'radius_meters': radius,
+        'count': len(results),
+        'devices': [
+            {'device_id': device_id, 'location': estimate.to_dict()}
+            for device_id, estimate in results
+        ]
+    })

routes/dmr.py

@@ -0,0 +1,403 @@
+"""DMR / P25 / Digital Voice decoding routes."""
+
+from __future__ import annotations
+
+import os
+import queue
+import re
+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 format_sse
+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_lock = threading.Lock()
+dmr_queue: queue.Queue = queue.Queue(maxsize=QUEUE_MAX_SIZE)
+dmr_active_device: Optional[int] = None
+
+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 uses different flag names
+_DSD_FME_PROTOCOL_FLAGS = {
+    'auto': ['-ft'],
+    'dmr': ['-fs'],
+    'p25': ['-f1'],
+    'nxdn': ['-fi'],
+    'dstar': [],
+    'provoice': ['-fp'],
+}
+
+# ============================================
+# 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 parse_dsd_output(line: str) -> dict | None:
+    """Parse a line of DSD stderr output into a structured event."""
+    line = line.strip()
+    if not line:
+        return None
+
+    # 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': datetime.now().strftime('%H:%M:%S'),
+        }
+
+    # Talkgroup and Source: "TG: 12345  Src: 67890"
+    tg_match = re.match(r'.*TG:\s*(\d+)\s+Src:\s*(\d+)', line)
+    if tg_match:
+        return {
+            'type': 'call',
+            'talkgroup': int(tg_match.group(1)),
+            'source_id': int(tg_match.group(2)),
+            'timestamp': datetime.now().strftime('%H:%M:%S'),
+        }
+
+    # Slot info: "Slot 1" or "Slot 2"
+    slot_match = re.match(r'.*Slot\s*(\d+)', line)
+    if slot_match:
+        return {
+            'type': 'slot',
+            'slot': int(slot_match.group(1)),
+            'timestamp': datetime.now().strftime('%H:%M:%S'),
+        }
+
+    # DMR voice frame
+    if 'Voice' in line or 'voice' in line:
+        return {
+            'type': 'voice',
+            'detail': line,
+            'timestamp': datetime.now().strftime('%H:%M:%S'),
+        }
+
+    # P25 NAC (Network Access Code)
+    nac_match = re.match(r'.*NAC:\s*(\w+)', line)
+    if nac_match:
+        return {
+            'type': 'nac',
+            'nac': nac_match.group(1),
+            'timestamp': datetime.now().strftime('%H:%M:%S'),
+        }
+
+    return None
+
+
+def stream_dsd_output(rtl_process: subprocess.Popen, dsd_process: subprocess.Popen):
+    """Read DSD stderr output and push parsed events to the queue."""
+    global dmr_running
+
+    try:
+        dmr_queue.put_nowait({'type': 'status', 'text': 'started'})
+
+        while dmr_running:
+            if dsd_process.poll() is not None:
+                break
+
+            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
+
+            parsed = parse_dsd_output(text)
+            if parsed:
+                try:
+                    dmr_queue.put_nowait(parsed)
+                except queue.Full:
+                    try:
+                        dmr_queue.get_nowait()
+                    except queue.Empty:
+                        pass
+                    try:
+                        dmr_queue.put_nowait(parsed)
+                    except queue.Full:
+                        pass
+
+    except Exception as e:
+        logger.error(f"DSD stream error: {e}")
+    finally:
+        dmr_running = False
+        try:
+            dmr_queue.put_nowait({'type': 'status', 'text': 'stopped'})
+        except queue.Full:
+            pass
+        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()
+    return jsonify({
+        'dsd': dsd_path is not None,
+        'rtl_fm': rtl_fm is not None,
+        'available': dsd_path is not None and rtl_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, dmr_running, dmr_active_device
+
+    with dmr_lock:
+        if dmr_running:
+            return jsonify({'status': 'error', 'message': 'Already running'}), 409
+
+    dsd_path, is_fme = find_dsd()
+    if not dsd_path:
+        return jsonify({'status': 'error', 'message': 'dsd not found. Install dsd-fme or dsd.'}), 503
+
+    rtl_fm_path = find_rtl_fm()
+    if not rtl_fm_path:
+        return jsonify({'status': 'error', 'message': 'rtl_fm not found. Install rtl-sdr tools.'}), 503
+
+    data = request.json or {}
+
+    try:
+        frequency = float(data.get('frequency', 462.5625))
+        gain = int(data.get('gain', 40))
+        device = int(data.get('device', 0))
+        protocol = str(data.get('protocol', 'auto')).lower()
+    except (ValueError, TypeError) as e:
+        return jsonify({'status': 'error', 'message': f'Invalid parameter: {e}'}), 400
+
+    if frequency <= 0:
+        return jsonify({'status': 'error', 'message': 'Frequency must be positive'}), 400
+
+    if protocol not in VALID_PROTOCOLS:
+        return jsonify({'status': 'error', 'message': f'Invalid protocol. Use: {", ".join(VALID_PROTOCOLS)}'}), 400
+
+    # Clear stale queue
+    try:
+        while True:
+            dmr_queue.get_nowait()
+    except queue.Empty:
+        pass
+
+    # Claim SDR device
+    error = app_module.claim_sdr_device(device, 'dmr')
+    if error:
+        return jsonify({'status': 'error', 'error_type': 'DEVICE_BUSY', 'message': error}), 409
+
+    dmr_active_device = device
+
+    freq_hz = int(frequency * 1e6)
+
+    # Build rtl_fm command (48kHz sample rate for DSD)
+    rtl_cmd = [
+        rtl_fm_path,
+        '-M', 'fm',
+        '-f', str(freq_hz),
+        '-s', '48000',
+        '-g', str(gain),
+        '-d', str(device),
+        '-l', '1',  # squelch level
+    ]
+
+    # Build DSD command
+    # Use -o - to send decoded audio to stdout (piped to DEVNULL)
+    # instead of PulseAudio which may not be available under sudo
+    dsd_cmd = [dsd_path, '-i', '-', '-o', '-']
+    if is_fme:
+        dsd_cmd.extend(_DSD_FME_PROTOCOL_FLAGS.get(protocol, []))
+    else:
+        dsd_cmd.extend(_DSD_PROTOCOL_FLAGS.get(protocol, []))
+
+    try:
+        dmr_rtl_process = subprocess.Popen(
+            rtl_cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+
+        dmr_dsd_process = subprocess.Popen(
+            dsd_cmd,
+            stdin=dmr_rtl_process.stdout,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.PIPE,
+        )
+
+        # Allow rtl_fm to send directly to dsd
+        dmr_rtl_process.stdout.close()
+
+        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}")
+            if dmr_active_device is not None:
+                app_module.release_sdr_device(dmr_active_device)
+                dmr_active_device = None
+            # Surface the most relevant error to the user
+            detail = rtl_err.strip() or dsd_err.strip()
+            msg = 'Failed to start DSD pipeline'
+            if detail:
+                msg += f': {detail}'
+            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_running = True
+        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,
+        })
+
+    except Exception as e:
+        logger.error(f"Failed to start DMR: {e}")
+        if dmr_active_device is not None:
+            app_module.release_sdr_device(dmr_active_device)
+            dmr_active_device = None
+        return jsonify({'status': 'error', 'message': str(e)}), 500
+
+
+@dmr_bp.route('/stop', methods=['POST'])
+def stop_dmr() -> Response:
+    """Stop digital voice decoding."""
+    global dmr_rtl_process, dmr_dsd_process, dmr_running, dmr_active_device
+
+    dmr_running = False
+
+    for proc in [dmr_dsd_process, dmr_rtl_process]:
+        if proc and proc.poll() is None:
+            try:
+                proc.terminate()
+                proc.wait(timeout=2)
+            except Exception:
+                try:
+                    proc.kill()
+                except Exception:
+                    pass
+
+    dmr_rtl_process = None
+    dmr_dsd_process = None
+
+    if dmr_active_device is not None:
+        app_module.release_sdr_device(dmr_active_device)
+        dmr_active_device = None
+
+    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,
+    })
+
+
+@dmr_bp.route('/stream')
+def stream_dmr() -> Response:
+    """SSE stream for DMR decoder events."""
+    def generate() -> Generator[str, None, None]:
+        last_keepalive = time.time()
+        while True:
+            try:
+                msg = dmr_queue.get(timeout=SSE_QUEUE_TIMEOUT)
+                last_keepalive = time.time()
+                yield format_sse(msg)
+            except queue.Empty:
+                now = time.time()
+                if now - last_keepalive >= SSE_KEEPALIVE_INTERVAL:
+                    yield format_sse({'type': 'keepalive'})
+                    last_keepalive = now
+
+    response = Response(generate(), mimetype='text/event-stream')
+    response.headers['Cache-Control'] = 'no-cache'
+    response.headers['X-Accel-Buffering'] = 'no'
+    return response

routes/dsc.py

@@ -47,6 +47,9 @@ dsc_bp = Blueprint('dsc', __name__, url_prefix='/dsc')
 # Module state (track if running independent of process state)
 dsc_running = False
 
+# Track which device is being used
+dsc_active_device: int | None = None
+
 
 def _get_dsc_decoder_path() -> str | None:
     """Get path to DSC decoder."""
@@ -309,21 +312,18 @@ def start_decoding() -> Response:
                 'message': str(e)
             }), 400
 
-        # Check if device is in use by AIS
-        try:
-            from routes import ais as ais_module
-            if hasattr(ais_module, 'ais_running') and ais_module.ais_running:
-                # AIS is running - check if same device
-                if hasattr(ais_module, 'ais_device') and str(ais_module.ais_device) == str(device):
-                    return jsonify({
-                        'status': 'error',
-                        'error_type': 'DEVICE_BUSY',
-                        'message': f'SDR device {device} is in use by AIS tracking',
-                        'suggestion': 'Use a different SDR device or stop AIS tracking first',
-                        'in_use_by': 'ais'
-                    }), 409
-        except ImportError:
-            pass
+        # Check if device is available using centralized registry
+        global dsc_active_device
+        device_int = int(device)
+        error = app_module.claim_sdr_device(device_int, 'dsc')
+        if error:
+            return jsonify({
+                'status': 'error',
+                'error_type': 'DEVICE_BUSY',
+                'message': error
+            }), 409
+
+        dsc_active_device = device_int
 
         # Clear queue
         while not app_module.dsc_queue.empty():
@@ -408,11 +408,19 @@ def start_decoding() -> Response:
             })
 
         except FileNotFoundError as e:
+            # Release device on failure
+            if dsc_active_device is not None:
+                app_module.release_sdr_device(dsc_active_device)
+                dsc_active_device = None
             return jsonify({
                 'status': 'error',
                 'message': f'Tool not found: {e.filename}'
             }), 400
         except Exception as e:
+            # Release device on failure
+            if dsc_active_device is not None:
+                app_module.release_sdr_device(dsc_active_device)
+                dsc_active_device = None
             logger.error(f"Failed to start DSC decoder: {e}")
             return jsonify({
                 'status': 'error',
@@ -423,7 +431,7 @@ def start_decoding() -> Response:
 @dsc_bp.route('/stop', methods=['POST'])
 def stop_decoding() -> Response:
     """Stop DSC decoder."""
-    global dsc_running
+    global dsc_running, dsc_active_device
 
     with app_module.dsc_lock:
         if not app_module.dsc_process:
@@ -460,6 +468,11 @@ def stop_decoding() -> Response:
         app_module.dsc_process = None
         app_module.dsc_rtl_process = None
 
+        # Release device from registry
+        if dsc_active_device is not None:
+            app_module.release_sdr_device(dsc_active_device)
+            dsc_active_device = None
+
         return jsonify({'status': 'stopped'})
 
 

routes/offline.py

@@ -0,0 +1,163 @@
+"""
+Offline mode routes - Asset management and settings for offline operation.
+"""
+
+from flask import Blueprint, jsonify, request
+from utils.database import get_setting, set_setting
+import os
+
+offline_bp = Blueprint('offline', __name__, url_prefix='/offline')
+
+# Default offline settings
+OFFLINE_DEFAULTS = {
+    'offline.enabled': False,
+    'offline.assets_source': 'cdn',
+    'offline.fonts_source': 'cdn',
+    'offline.tile_provider': 'cartodb_dark_cyan',
+    'offline.tile_server_url': ''
+}
+
+# Asset paths to check
+ASSET_PATHS = {
+    'leaflet': [
+        'static/vendor/leaflet/leaflet.js',
+        'static/vendor/leaflet/leaflet.css'
+    ],
+    'chartjs': [
+        'static/vendor/chartjs/chart.umd.min.js'
+    ],
+    'inter': [
+        'static/vendor/fonts/Inter-Regular.woff2',
+        'static/vendor/fonts/Inter-Medium.woff2',
+        'static/vendor/fonts/Inter-SemiBold.woff2',
+        'static/vendor/fonts/Inter-Bold.woff2'
+    ],
+    'jetbrains': [
+        'static/vendor/fonts/JetBrainsMono-Regular.woff2',
+        'static/vendor/fonts/JetBrainsMono-Medium.woff2',
+        'static/vendor/fonts/JetBrainsMono-SemiBold.woff2',
+        'static/vendor/fonts/JetBrainsMono-Bold.woff2'
+    ],
+    'leaflet_images': [
+        'static/vendor/leaflet/images/marker-icon.png',
+        'static/vendor/leaflet/images/marker-icon-2x.png',
+        'static/vendor/leaflet/images/marker-shadow.png',
+        'static/vendor/leaflet/images/layers.png',
+        'static/vendor/leaflet/images/layers-2x.png'
+    ]
+}
+
+
+def get_offline_settings():
+    """Get all offline settings with defaults."""
+    settings = {}
+    for key, default in OFFLINE_DEFAULTS.items():
+        settings[key] = get_setting(key, default)
+    return settings
+
+
+@offline_bp.route('/settings', methods=['GET'])
+def get_settings():
+    """Get current offline settings."""
+    settings = get_offline_settings()
+    return jsonify({
+        'status': 'success',
+        'settings': settings
+    })
+
+
+@offline_bp.route('/settings', methods=['POST'])
+def save_setting():
+    """Save an offline setting."""
+    data = request.get_json()
+    if not data or 'key' not in data or 'value' not in data:
+        return jsonify({'status': 'error', 'message': 'Missing key or value'}), 400
+
+    key = data['key']
+    value = data['value']
+
+    # Validate key is an allowed setting
+    if key not in OFFLINE_DEFAULTS:
+        return jsonify({'status': 'error', 'message': f'Unknown setting: {key}'}), 400
+
+    # Validate value type matches default
+    default_type = type(OFFLINE_DEFAULTS[key])
+    if not isinstance(value, default_type):
+        # Try to convert
+        try:
+            if default_type == bool:
+                value = str(value).lower() in ('true', '1', 'yes')
+            else:
+                value = default_type(value)
+        except (ValueError, TypeError):
+            return jsonify({
+                'status': 'error',
+                'message': f'Invalid value type for {key}'
+            }), 400
+
+    set_setting(key, value)
+
+    return jsonify({
+        'status': 'success',
+        'key': key,
+        'value': value
+    })
+
+
+@offline_bp.route('/status', methods=['GET'])
+def get_status():
+    """Check status of local assets."""
+    # Get the app root directory
+    app_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+    results = {}
+    all_available = True
+
+    for asset_name, paths in ASSET_PATHS.items():
+        available = True
+        missing = []
+        for path in paths:
+            full_path = os.path.join(app_root, path)
+            if not os.path.exists(full_path):
+                available = False
+                missing.append(path)
+
+        results[asset_name] = {
+            'available': available,
+            'missing': missing if not available else []
+        }
+
+        if not available:
+            all_available = False
+
+    return jsonify({
+        'status': 'success',
+        'all_available': all_available,
+        'assets': results,
+        'offline_enabled': get_setting('offline.enabled', False)
+    })
+
+
+@offline_bp.route('/check-asset', methods=['GET'])
+def check_asset():
+    """Check if a specific asset file exists."""
+    path = request.args.get('path', '')
+    if not path:
+        return jsonify({'status': 'error', 'message': 'Missing path parameter'}), 400
+
+    # Security: only allow checking within static/vendor
+    if not path.startswith('/static/vendor/'):
+        return jsonify({'status': 'error', 'message': 'Invalid path'}), 400
+
+    # Remove leading slash and construct full path
+    relative_path = path.lstrip('/')
+    app_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    full_path = os.path.join(app_root, relative_path)
+
+    exists = os.path.exists(full_path)
+
+    return jsonify({
+        'status': 'success',
+        'path': path,
+        'exists': exists
+    })

routes/pager.py

@@ -29,6 +29,9 @@ from utils.dependencies import get_tool_path
 
 pager_bp = Blueprint('pager', __name__)
 
+# Track which device is being used
+pager_active_device: int | None = None
+
 
 def parse_multimon_output(line: str) -> dict[str, str] | None:
     """Parse multimon-ng output line."""
@@ -155,6 +158,8 @@ def stream_decoder(master_fd: int, process: subprocess.Popen[bytes]) -> None:
 
 @pager_bp.route('/start', methods=['POST'])
 def start_decoding() -> Response:
+    global pager_active_device
+
     with app_module.process_lock:
         if app_module.current_process:
             return jsonify({'status': 'error', 'message': 'Already running'}), 409
@@ -178,10 +183,29 @@ def start_decoding() -> Response:
         except (ValueError, TypeError):
             return jsonify({'status': 'error', 'message': 'Invalid squelch value'}), 400
 
+        # Check for rtl_tcp (remote SDR) connection
+        rtl_tcp_host = data.get('rtl_tcp_host')
+        rtl_tcp_port = data.get('rtl_tcp_port', 1234)
+
+        # 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')
+            if error:
+                return jsonify({
+                    'status': 'error',
+                    'error_type': 'DEVICE_BUSY',
+                    'message': error
+                }), 409
+            pager_active_device = device_int
+
         # 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)
+                pager_active_device = 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:
@@ -213,10 +237,6 @@ def start_decoding() -> Response:
         except ValueError:
             sdr_type = SDRType.RTL_SDR
 
-        # Check for rtl_tcp (remote SDR) connection
-        rtl_tcp_host = data.get('rtl_tcp_host')
-        rtl_tcp_port = data.get('rtl_tcp_port', 1234)
-
         if rtl_tcp_host:
             # Validate and create network device
             try:
@@ -302,13 +322,23 @@ def start_decoding() -> Response:
             return jsonify({'status': 'started', 'command': full_cmd})
 
         except FileNotFoundError as e:
+            # Release device on failure
+            if pager_active_device is not None:
+                app_module.release_sdr_device(pager_active_device)
+                pager_active_device = None
             return jsonify({'status': 'error', 'message': f'Tool not found: {e.filename}'})
         except Exception as e:
+            # Release device on failure
+            if pager_active_device is not None:
+                app_module.release_sdr_device(pager_active_device)
+                pager_active_device = None
             return jsonify({'status': 'error', 'message': str(e)})
 
 
 @pager_bp.route('/stop', methods=['POST'])
 def stop_decoding() -> Response:
+    global pager_active_device
+
     with app_module.process_lock:
         if app_module.current_process:
             # Kill rtl_fm process first
@@ -337,6 +367,12 @@ def stop_decoding() -> Response:
                 app_module.current_process.kill()
 
             app_module.current_process = None
+
+            # Release device from registry
+            if pager_active_device is not None:
+                app_module.release_sdr_device(pager_active_device)
+                pager_active_device = None
+
             return jsonify({'status': 'stopped'})
 
         return jsonify({'status': 'not_running'})

routes/rtlamr.py

@@ -26,6 +26,9 @@ rtlamr_bp = Blueprint('rtlamr', __name__)
 rtl_tcp_process = None
 rtl_tcp_lock = threading.Lock()
 
+# Track which device is being used
+rtlamr_active_device: int | None = None
+
 
 def stream_rtlamr_output(process: subprocess.Popen[bytes]) -> None:
     """Stream rtlamr JSON output to queue."""
@@ -66,7 +69,7 @@ def stream_rtlamr_output(process: subprocess.Popen[bytes]) -> None:
 
 @rtlamr_bp.route('/start_rtlamr', methods=['POST'])
 def start_rtlamr() -> Response:
-    global rtl_tcp_process
+    global rtl_tcp_process, rtlamr_active_device
 
     with app_module.rtlamr_lock:
         if app_module.rtlamr_process:
@@ -83,6 +86,18 @@ def start_rtlamr() -> Response:
         except ValueError as e:
             return jsonify({'status': 'error', 'message': str(e)}), 400
 
+        # Check if device is available
+        device_int = int(device)
+        error = app_module.claim_sdr_device(device_int, 'rtlamr')
+        if error:
+            return jsonify({
+                'status': 'error',
+                'error_type': 'DEVICE_BUSY',
+                'message': error
+            }), 409
+
+        rtlamr_active_device = device_int
+
         # Clear queue
         while not app_module.rtlamr_queue.empty():
             try:
@@ -182,27 +197,33 @@ def start_rtlamr() -> Response:
             return jsonify({'status': 'started', 'command': full_cmd})
 
         except FileNotFoundError:
-            # If rtlamr fails, clean up rtl_tcp
+            # If rtlamr fails, clean up rtl_tcp and release device
             with rtl_tcp_lock:
                 if rtl_tcp_process:
                     rtl_tcp_process.terminate()
                     rtl_tcp_process.wait(timeout=2)
                     rtl_tcp_process = None
+            if rtlamr_active_device is not None:
+                app_module.release_sdr_device(rtlamr_active_device)
+                rtlamr_active_device = None
             return jsonify({'status': 'error', 'message': 'rtlamr not found. Install from https://github.com/bemasher/rtlamr'})
         except Exception as e:
-            # If rtlamr fails, clean up rtl_tcp
+            # If rtlamr fails, clean up rtl_tcp and release device
             with rtl_tcp_lock:
                 if rtl_tcp_process:
                     rtl_tcp_process.terminate()
                     rtl_tcp_process.wait(timeout=2)
                     rtl_tcp_process = None
+            if rtlamr_active_device is not None:
+                app_module.release_sdr_device(rtlamr_active_device)
+                rtlamr_active_device = None
             return jsonify({'status': 'error', 'message': str(e)})
 
 
 @rtlamr_bp.route('/stop_rtlamr', methods=['POST'])
 def stop_rtlamr() -> Response:
-    global rtl_tcp_process
-    
+    global rtl_tcp_process, rtlamr_active_device
+
     with app_module.rtlamr_lock:
         if app_module.rtlamr_process:
             app_module.rtlamr_process.terminate()
@@ -211,7 +232,7 @@ def stop_rtlamr() -> Response:
             except subprocess.TimeoutExpired:
                 app_module.rtlamr_process.kill()
             app_module.rtlamr_process = None
-    
+
     # Also stop rtl_tcp
     with rtl_tcp_lock:
         if rtl_tcp_process:
@@ -222,7 +243,12 @@ def stop_rtlamr() -> Response:
                 rtl_tcp_process.kill()
             rtl_tcp_process = None
             logger.info("rtl_tcp stopped")
-    
+
+    # Release device from registry
+    if rtlamr_active_device is not None:
+        app_module.release_sdr_device(rtlamr_active_device)
+        rtlamr_active_device = None
+
     return jsonify({'status': 'stopped'})
 
 

routes/satellite.py

@@ -3,13 +3,18 @@
 from __future__ import annotations
 
 import json
+import math
 import urllib.request
 from datetime import datetime, timedelta
-from typing import Any
+from typing import Any, Optional
 from urllib.parse import urlparse
 
+import requests
+
 from flask import Blueprint, jsonify, request, render_template, Response
 
+from config import SHARED_OBSERVER_LOCATION_ENABLED
+
 from data.satellites import TLE_SATELLITES
 from utils.logging import satellite_logger as logger
 from utils.validation import validate_latitude, validate_longitude, validate_hours, validate_elevation
@@ -26,10 +31,101 @@ ALLOWED_TLE_HOSTS = ['celestrak.org', 'celestrak.com', 'www.celestrak.org', 'www
 _tle_cache = dict(TLE_SATELLITES)
 
 
+def _fetch_iss_realtime(observer_lat: Optional[float] = None, observer_lon: Optional[float] = None) -> Optional[dict]:
+    """
+    Fetch real-time ISS position from external APIs.
+
+    Returns position data dict or None if all APIs fail.
+    """
+    iss_lat = None
+    iss_lon = None
+    iss_alt = 420  # Default altitude in km
+    source = None
+
+    # Try primary API: Where The ISS At
+    try:
+        response = requests.get('https://api.wheretheiss.at/v1/satellites/25544', timeout=5)
+        if response.status_code == 200:
+            data = response.json()
+            iss_lat = float(data['latitude'])
+            iss_lon = float(data['longitude'])
+            iss_alt = float(data.get('altitude', 420))
+            source = 'wheretheiss'
+    except Exception as e:
+        logger.debug(f"Where The ISS At API failed: {e}")
+
+    # Try fallback API: Open Notify
+    if iss_lat is None:
+        try:
+            response = requests.get('http://api.open-notify.org/iss-now.json', timeout=5)
+            if response.status_code == 200:
+                data = response.json()
+                if data.get('message') == 'success':
+                    iss_lat = float(data['iss_position']['latitude'])
+                    iss_lon = float(data['iss_position']['longitude'])
+                    source = 'open-notify'
+        except Exception as e:
+            logger.debug(f"Open Notify API failed: {e}")
+
+    if iss_lat is None:
+        return None
+
+    result = {
+        'satellite': 'ISS',
+        'lat': iss_lat,
+        'lon': iss_lon,
+        'altitude': iss_alt,
+        'source': source
+    }
+
+    # Calculate observer-relative data if location provided
+    if observer_lat is not None and observer_lon is not None:
+        # Earth radius in km
+        earth_radius = 6371
+
+        # Convert to radians
+        lat1 = math.radians(observer_lat)
+        lat2 = math.radians(iss_lat)
+        lon1 = math.radians(observer_lon)
+        lon2 = math.radians(iss_lon)
+
+        # Haversine for ground distance
+        dlat = lat2 - lat1
+        dlon = lon2 - lon1
+        a = math.sin(dlat/2)**2 + math.cos(lat1) * math.cos(lat2) * math.sin(dlon/2)**2
+        c = 2 * math.asin(math.sqrt(a))
+        ground_distance = earth_radius * c
+
+        # Calculate slant range
+        slant_range = math.sqrt(ground_distance**2 + iss_alt**2)
+
+        # Calculate elevation angle (simplified)
+        if ground_distance > 0:
+            elevation = math.degrees(math.atan2(iss_alt - (ground_distance**2 / (2 * earth_radius)), ground_distance))
+        else:
+            elevation = 90.0
+
+        # Calculate azimuth
+        y = math.sin(dlon) * math.cos(lat2)
+        x = math.cos(lat1) * math.sin(lat2) - math.sin(lat1) * math.cos(lat2) * math.cos(dlon)
+        azimuth = math.degrees(math.atan2(y, x))
+        azimuth = (azimuth + 360) % 360
+
+        result['elevation'] = round(elevation, 1)
+        result['azimuth'] = round(azimuth, 1)
+        result['distance'] = round(slant_range, 1)
+        result['visible'] = elevation > 0
+
+    return result
+
+
 @satellite_bp.route('/dashboard')
 def satellite_dashboard():
     """Popout satellite tracking dashboard."""
-    return render_template('satellite_dashboard.html')
+    return render_template(
+        'satellite_dashboard.html',
+        shared_observer_location=SHARED_OBSERVER_LOCATION_ENABLED,
+    )
 
 
 @satellite_bp.route('/predict', methods=['POST'])
@@ -239,6 +335,35 @@ def get_satellite_position():
     positions = []
 
     for sat_name in satellites:
+        # Special handling for ISS - use real-time API for accurate position
+        if sat_name == 'ISS':
+            iss_data = _fetch_iss_realtime(lat, lon)
+            if iss_data:
+                # Add orbit track if requested (using TLE for track prediction)
+                if include_track and 'ISS' in _tle_cache:
+                    try:
+                        tle_data = _tle_cache['ISS']
+                        satellite = EarthSatellite(tle_data[1], tle_data[2], tle_data[0], ts)
+                        orbit_track = []
+                        for minutes_offset in range(-45, 46, 1):
+                            t_point = ts.utc(now_dt + timedelta(minutes=minutes_offset))
+                            try:
+                                geo = satellite.at(t_point)
+                                sp = wgs84.subpoint(geo)
+                                orbit_track.append({
+                                    'lat': float(sp.latitude.degrees),
+                                    'lon': float(sp.longitude.degrees),
+                                    'past': minutes_offset < 0
+                                })
+                            except Exception:
+                                continue
+                        iss_data['track'] = orbit_track
+                    except Exception:
+                        pass
+                positions.append(iss_data)
+            continue
+
+        # Other satellites - use TLE data
         if sat_name not in _tle_cache:
             continue
 
@@ -292,56 +417,69 @@ def get_satellite_position():
     })
 
 
-@satellite_bp.route('/update-tle', methods=['POST'])
-def update_tle():
-    """Update TLE data from CelesTrak."""
+def refresh_tle_data() -> list:
+    """
+    Refresh TLE data from CelesTrak.
+
+    This can be called at startup or periodically to keep TLE data fresh.
+    Returns list of satellite names that were updated.
+    """
     global _tle_cache
 
-    try:
-        name_mappings = {
-            'ISS (ZARYA)': 'ISS',
-            'NOAA 15': 'NOAA-15',
-            'NOAA 18': 'NOAA-18',
-            'NOAA 19': 'NOAA-19',
-            'METEOR-M 2': 'METEOR-M2',
-            'METEOR-M2 3': 'METEOR-M2-3'
-        }
+    name_mappings = {
+        'ISS (ZARYA)': 'ISS',
+        'NOAA 15': 'NOAA-15',
+        'NOAA 18': 'NOAA-18',
+        'NOAA 19': 'NOAA-19',
+        'NOAA 20 (JPSS-1)': 'NOAA-20',
+        'NOAA 21 (JPSS-2)': 'NOAA-21',
+        'METEOR-M 2': 'METEOR-M2',
+        'METEOR-M2 3': 'METEOR-M2-3'
+    }
 
-        updated = []
+    updated = []
 
-        for group in ['stations', 'weather']:
-            url = f'https://celestrak.org/NORAD/elements/gp.php?GROUP={group}&FORMAT=tle'
-            try:
-                with urllib.request.urlopen(url, timeout=10) as response:
-                    content = response.read().decode('utf-8')
-                    lines = content.strip().split('\n')
+    for group in ['stations', 'weather', 'noaa']:
+        url = f'https://celestrak.org/NORAD/elements/gp.php?GROUP={group}&FORMAT=tle'
+        try:
+            with urllib.request.urlopen(url, timeout=15) as response:
+                content = response.read().decode('utf-8')
+                lines = content.strip().split('\n')
 
-                    i = 0
-                    while i + 2 < len(lines):
-                        name = lines[i].strip()
-                        line1 = lines[i + 1].strip()
-                        line2 = lines[i + 2].strip()
+                i = 0
+                while i + 2 < len(lines):
+                    name = lines[i].strip()
+                    line1 = lines[i + 1].strip()
+                    line2 = lines[i + 2].strip()
 
-                        if not (line1.startswith('1 ') and line2.startswith('2 ')):
-                            i += 1
-                            continue
+                    if not (line1.startswith('1 ') and line2.startswith('2 ')):
+                        i += 1
+                        continue
 
-                        internal_name = name_mappings.get(name, name)
+                    internal_name = name_mappings.get(name, name)
 
-                        if internal_name in _tle_cache:
-                            _tle_cache[internal_name] = (name, line1, line2)
+                    if internal_name in _tle_cache:
+                        _tle_cache[internal_name] = (name, line1, line2)
+                        if internal_name not in updated:
                             updated.append(internal_name)
 
-                        i += 3
-            except Exception as e:
-                logger.error(f"Error fetching {group}: {e}")
-                continue
+                    i += 3
+        except Exception as e:
+            logger.warning(f"Error fetching TLE group {group}: {e}")
+            continue
 
+    return updated
+
+
+@satellite_bp.route('/update-tle', methods=['POST'])
+def update_tle():
+    """Update TLE data from CelesTrak (API endpoint)."""
+    try:
+        updated = refresh_tle_data()
         return jsonify({
             'status': 'success',
             'updated': updated
         })
-
     except Exception as e:
         return jsonify({'status': 'error', 'message': str(e)})
 

routes/sensor.py

@@ -24,6 +24,9 @@ from utils.sdr import SDRFactory, SDRType
 
 sensor_bp = Blueprint('sensor', __name__)
 
+# Track which device is being used
+sensor_active_device: int | None = None
+
 
 def stream_sensor_output(process: subprocess.Popen[bytes]) -> None:
     """Stream rtl_433 JSON output to queue."""
@@ -64,6 +67,8 @@ def stream_sensor_output(process: subprocess.Popen[bytes]) -> None:
 
 @sensor_bp.route('/start_sensor', methods=['POST'])
 def start_sensor() -> Response:
+    global sensor_active_device
+
     with app_module.sensor_lock:
         if app_module.sensor_process:
             return jsonify({'status': 'error', 'message': 'Sensor already running'}), 409
@@ -79,6 +84,22 @@ def start_sensor() -> Response:
         except ValueError as e:
             return jsonify({'status': 'error', 'message': str(e)}), 400
 
+        # Check for rtl_tcp (remote SDR) connection
+        rtl_tcp_host = data.get('rtl_tcp_host')
+        rtl_tcp_port = data.get('rtl_tcp_port', 1234)
+
+        # 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')
+            if error:
+                return jsonify({
+                    'status': 'error',
+                    'error_type': 'DEVICE_BUSY',
+                    'message': error
+                }), 409
+            sensor_active_device = device_int
+
         # Clear queue
         while not app_module.sensor_queue.empty():
             try:
@@ -93,10 +114,6 @@ def start_sensor() -> Response:
         except ValueError:
             sdr_type = SDRType.RTL_SDR
 
-        # Check for rtl_tcp (remote SDR) connection
-        rtl_tcp_host = data.get('rtl_tcp_host')
-        rtl_tcp_port = data.get('rtl_tcp_port', 1234)
-
         if rtl_tcp_host:
             # Validate and create network device
             try:
@@ -155,13 +172,23 @@ def start_sensor() -> Response:
             return jsonify({'status': 'started', 'command': full_cmd})
 
         except FileNotFoundError:
+            # Release device on failure
+            if sensor_active_device is not None:
+                app_module.release_sdr_device(sensor_active_device)
+                sensor_active_device = 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)
+                sensor_active_device = None
             return jsonify({'status': 'error', 'message': str(e)})
 
 
 @sensor_bp.route('/stop_sensor', methods=['POST'])
 def stop_sensor() -> Response:
+    global sensor_active_device
+
     with app_module.sensor_lock:
         if app_module.sensor_process:
             app_module.sensor_process.terminate()
@@ -170,6 +197,12 @@ def stop_sensor() -> Response:
             except subprocess.TimeoutExpired:
                 app_module.sensor_process.kill()
             app_module.sensor_process = None
+
+            # Release device from registry
+            if sensor_active_device is not None:
+                app_module.release_sdr_device(sensor_active_device)
+                sensor_active_device = None
+
             return jsonify({'status': 'stopped'})
 
         return jsonify({'status': 'not_running'})

routes/sstv.py

@@ -0,0 +1,626 @@
+"""ISS SSTV (Slow-Scan Television) decoder routes.
+
+Provides endpoints for decoding SSTV images from the International Space Station.
+ISS SSTV events occur during special commemorations and typically transmit on 145.800 MHz FM.
+"""
+
+from __future__ import annotations
+
+import queue
+import time
+from pathlib import Path
+from typing import Generator
+
+from flask import Blueprint, jsonify, request, Response, send_file
+
+from utils.logging import get_logger
+from utils.sse import format_sse
+from utils.sstv import (
+    get_sstv_decoder,
+    is_sstv_available,
+    ISS_SSTV_FREQ,
+    DecodeProgress,
+    DopplerInfo,
+)
+
+logger = get_logger('intercept.sstv')
+
+sstv_bp = Blueprint('sstv', __name__, url_prefix='/sstv')
+
+# Queue for SSE progress streaming
+_sstv_queue: queue.Queue = queue.Queue(maxsize=100)
+
+
+def _progress_callback(progress: DecodeProgress) -> None:
+    """Callback to queue progress updates for SSE stream."""
+    try:
+        _sstv_queue.put_nowait(progress.to_dict())
+    except queue.Full:
+        try:
+            _sstv_queue.get_nowait()
+            _sstv_queue.put_nowait(progress.to_dict())
+        except queue.Empty:
+            pass
+
+
+@sstv_bp.route('/status')
+def get_status():
+    """
+    Get SSTV decoder status.
+
+    Returns:
+        JSON with decoder availability and current status.
+    """
+    available = is_sstv_available()
+    decoder = get_sstv_decoder()
+
+    result = {
+        'available': available,
+        'decoder': decoder.decoder_available,
+        'running': decoder.is_running,
+        'iss_frequency': ISS_SSTV_FREQ,
+        'image_count': len(decoder.get_images()),
+        'doppler_enabled': decoder.doppler_enabled,
+    }
+
+    # Include Doppler info if available
+    doppler_info = decoder.last_doppler_info
+    if doppler_info:
+        result['doppler'] = doppler_info.to_dict()
+
+    return jsonify(result)
+
+
+@sstv_bp.route('/start', methods=['POST'])
+def start_decoder():
+    """
+    Start SSTV decoder.
+
+    JSON body (optional):
+        {
+            "frequency": 145.800,  // Frequency in MHz (default: ISS 145.800)
+            "device": 0,           // RTL-SDR device index
+            "latitude": 40.7128,   // Observer latitude for Doppler correction
+            "longitude": -74.0060  // Observer longitude for Doppler correction
+        }
+
+    If latitude and longitude are provided, real-time Doppler shift compensation
+    will be enabled, which improves reception by tracking the ISS frequency shift
+    as it passes overhead (up to ±3.5 kHz at 145.800 MHz).
+
+    Returns:
+        JSON with start status.
+    """
+    if not is_sstv_available():
+        return jsonify({
+            'status': 'error',
+            'message': 'SSTV decoder not available. Install slowrx: apt install slowrx'
+        }), 400
+
+    decoder = get_sstv_decoder()
+
+    if decoder.is_running:
+        return jsonify({
+            'status': 'already_running',
+            'frequency': ISS_SSTV_FREQ,
+            'doppler_enabled': decoder.doppler_enabled
+        })
+
+    # Clear queue
+    while not _sstv_queue.empty():
+        try:
+            _sstv_queue.get_nowait()
+        except queue.Empty:
+            break
+
+    # Get parameters
+    data = request.get_json(silent=True) or {}
+    frequency = data.get('frequency', ISS_SSTV_FREQ)
+    device_index = data.get('device', 0)
+    latitude = data.get('latitude')
+    longitude = data.get('longitude')
+
+    # Validate frequency
+    try:
+        frequency = float(frequency)
+        if not (100 <= frequency <= 500):  # VHF range
+            return jsonify({
+                'status': 'error',
+                'message': 'Frequency must be between 100-500 MHz'
+            }), 400
+    except (TypeError, ValueError):
+        return jsonify({
+            'status': 'error',
+            'message': 'Invalid frequency'
+        }), 400
+
+    # Validate location if provided
+    if latitude is not None and longitude is not None:
+        try:
+            latitude = float(latitude)
+            longitude = float(longitude)
+            if not (-90 <= latitude <= 90):
+                return jsonify({
+                    'status': 'error',
+                    'message': 'Latitude must be between -90 and 90'
+                }), 400
+            if not (-180 <= longitude <= 180):
+                return jsonify({
+                    'status': 'error',
+                    'message': 'Longitude must be between -180 and 180'
+                }), 400
+        except (TypeError, ValueError):
+            return jsonify({
+                'status': 'error',
+                'message': 'Invalid latitude or longitude'
+            }), 400
+    else:
+        latitude = None
+        longitude = None
+
+    # Set callback and start
+    decoder.set_callback(_progress_callback)
+    success = decoder.start(
+        frequency=frequency,
+        device_index=device_index,
+        latitude=latitude,
+        longitude=longitude
+    )
+
+    if success:
+        result = {
+            'status': 'started',
+            'frequency': frequency,
+            'device': device_index,
+            'doppler_enabled': decoder.doppler_enabled
+        }
+
+        # Include initial Doppler info if available
+        if decoder.doppler_enabled and decoder.last_doppler_info:
+            result['doppler'] = decoder.last_doppler_info.to_dict()
+
+        return jsonify(result)
+    else:
+        return jsonify({
+            'status': 'error',
+            'message': 'Failed to start decoder'
+        }), 500
+
+
+@sstv_bp.route('/stop', methods=['POST'])
+def stop_decoder():
+    """
+    Stop SSTV decoder.
+
+    Returns:
+        JSON confirmation.
+    """
+    decoder = get_sstv_decoder()
+    decoder.stop()
+    return jsonify({'status': 'stopped'})
+
+
+@sstv_bp.route('/doppler')
+def get_doppler():
+    """
+    Get current Doppler shift information.
+
+    Returns real-time Doppler shift data if tracking is enabled.
+
+    Returns:
+        JSON with Doppler shift information.
+    """
+    decoder = get_sstv_decoder()
+
+    if not decoder.doppler_enabled:
+        return jsonify({
+            'status': 'disabled',
+            'message': 'Doppler tracking not enabled. Provide latitude/longitude when starting decoder.'
+        })
+
+    doppler_info = decoder.last_doppler_info
+    if not doppler_info:
+        return jsonify({
+            'status': 'unavailable',
+            'message': 'Doppler data not yet available'
+        })
+
+    return jsonify({
+        'status': 'ok',
+        'doppler': doppler_info.to_dict(),
+        'nominal_frequency_mhz': ISS_SSTV_FREQ,
+        'corrected_frequency_mhz': doppler_info.frequency_hz / 1_000_000
+    })
+
+
+@sstv_bp.route('/images')
+def list_images():
+    """
+    Get list of decoded SSTV images.
+
+    Query parameters:
+        limit: Maximum number of images to return (default: all)
+
+    Returns:
+        JSON with list of decoded images.
+    """
+    decoder = get_sstv_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)
+    })
+
+
+@sstv_bp.route('/images/<filename>')
+def get_image(filename: str):
+    """
+    Get a decoded SSTV image file.
+
+    Args:
+        filename: Image filename
+
+    Returns:
+        Image file or 404.
+    """
+    decoder = get_sstv_decoder()
+
+    # Security: only allow alphanumeric filenames with .png extension
+    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
+
+    # Find image in decoder's output directory
+    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')
+
+
+@sstv_bp.route('/stream')
+def stream_progress():
+    """
+    SSE stream of SSTV decode progress.
+
+    Provides real-time Server-Sent Events stream of decode progress.
+
+    Event format:
+        data: {"type": "sstv_progress", "status": "decoding", "mode": "PD120", ...}
+
+    Returns:
+        SSE stream (text/event-stream)
+    """
+    def generate() -> Generator[str, None, None]:
+        last_keepalive = time.time()
+        keepalive_interval = 30.0
+
+        while True:
+            try:
+                progress = _sstv_queue.get(timeout=1)
+                last_keepalive = time.time()
+                yield format_sse(progress)
+            except queue.Empty:
+                now = time.time()
+                if now - last_keepalive >= keepalive_interval:
+                    yield format_sse({'type': 'keepalive'})
+                    last_keepalive = now
+
+    response = Response(generate(), mimetype='text/event-stream')
+    response.headers['Cache-Control'] = 'no-cache'
+    response.headers['X-Accel-Buffering'] = 'no'
+    response.headers['Connection'] = 'keep-alive'
+    return response
+
+
+@sstv_bp.route('/iss-schedule')
+def iss_schedule():
+    """
+    Get ISS pass schedule for SSTV reception.
+
+    Calculates ISS passes directly using skyfield.
+
+    Query parameters:
+        latitude: Observer latitude (required)
+        longitude: Observer longitude (required)
+        hours: Hours to look ahead (default: 48)
+
+    Returns:
+        JSON with ISS pass schedule.
+    """
+    lat = request.args.get('latitude', type=float)
+    lon = request.args.get('longitude', type=float)
+    hours = request.args.get('hours', 48, type=int)
+
+    if lat is None or lon is None:
+        return jsonify({
+            'status': 'error',
+            'message': 'latitude and longitude parameters required'
+        }), 400
+
+    try:
+        from skyfield.api import load, wgs84, EarthSatellite
+        from skyfield.almanac import find_discrete
+        from datetime import timedelta
+        from data.satellites import TLE_SATELLITES
+
+        # Get ISS TLE
+        iss_tle = TLE_SATELLITES.get('ISS')
+        if not iss_tle:
+            return jsonify({
+                'status': 'error',
+                'message': 'ISS TLE data not available'
+            }), 500
+
+        ts = load.timescale()
+        satellite = EarthSatellite(iss_tle[1], iss_tle[2], iss_tle[0], ts)
+        observer = wgs84.latlon(lat, lon)
+
+        t0 = ts.now()
+        t1 = ts.utc(t0.utc_datetime() + timedelta(hours=hours))
+
+        def above_horizon(t):
+            diff = satellite - observer
+            topocentric = diff.at(t)
+            alt, _, _ = topocentric.altaz()
+            return alt.degrees > 0
+
+        above_horizon.step_days = 1/720
+
+        times, events = find_discrete(t0, t1, above_horizon)
+
+        passes = []
+        i = 0
+        while i < len(times):
+            if i < len(events) and events[i]:  # Rising
+                rise_time = times[i]
+                set_time = None
+
+                for j in range(i + 1, len(times)):
+                    if not events[j]:  # Setting
+                        set_time = times[j]
+                        i = j
+                        break
+                else:
+                    i += 1
+                    continue
+
+                if set_time is None:
+                    i += 1
+                    continue
+
+                # Calculate max elevation
+                max_el = 0
+                duration_seconds = (set_time.utc_datetime() - rise_time.utc_datetime()).total_seconds()
+                duration_minutes = int(duration_seconds / 60)
+
+                for k in range(30):
+                    frac = k / 29
+                    t_point = ts.utc(rise_time.utc_datetime() + timedelta(seconds=duration_seconds * frac))
+                    diff = satellite - observer
+                    topocentric = diff.at(t_point)
+                    alt, _, _ = topocentric.altaz()
+                    if alt.degrees > max_el:
+                        max_el = alt.degrees
+
+                if max_el >= 10:  # Min elevation filter
+                    passes.append({
+                        'satellite': 'ISS',
+                        'startTime': rise_time.utc_datetime().strftime('%Y-%m-%d %H:%M UTC'),
+                        'startTimeISO': rise_time.utc_datetime().isoformat(),
+                        'maxEl': round(max_el, 1),
+                        'duration': duration_minutes,
+                        'color': '#00ffff'
+                    })
+
+            i += 1
+
+        return jsonify({
+            'status': 'ok',
+            'passes': passes,
+            'count': len(passes),
+            'sstv_frequency': ISS_SSTV_FREQ,
+            'note': 'ISS SSTV events are not continuous. Check ARISS.org for scheduled events.'
+        })
+
+    except ImportError:
+        return jsonify({
+            'status': 'error',
+            'message': 'skyfield library not installed'
+        }), 503
+
+    except Exception as e:
+        logger.error(f"Error getting ISS schedule: {e}")
+        return jsonify({
+            'status': 'error',
+            'message': str(e)
+        }), 500
+
+
+@sstv_bp.route('/iss-position')
+def iss_position():
+    """
+    Get current ISS position from real-time API.
+
+    Uses the Open Notify API for accurate real-time position,
+    with fallback to "Where The ISS At" API.
+
+    Query parameters:
+        latitude: Observer latitude (optional, for elevation calc)
+        longitude: Observer longitude (optional, for elevation calc)
+
+    Returns:
+        JSON with ISS current position.
+    """
+    import requests
+    from datetime import datetime
+
+    observer_lat = request.args.get('latitude', type=float)
+    observer_lon = request.args.get('longitude', type=float)
+
+    # Try primary API: Where The ISS At
+    try:
+        response = requests.get('https://api.wheretheiss.at/v1/satellites/25544', timeout=5)
+        if response.status_code == 200:
+            data = response.json()
+            iss_lat = float(data['latitude'])
+            iss_lon = float(data['longitude'])
+
+            result = {
+                'status': 'ok',
+                'lat': iss_lat,
+                'lon': iss_lon,
+                'altitude': float(data.get('altitude', 420)),
+                'timestamp': datetime.utcnow().isoformat(),
+                'source': 'wheretheiss'
+            }
+
+            # Calculate observer-relative data if location provided
+            if observer_lat is not None and observer_lon is not None:
+                result.update(_calculate_observer_data(iss_lat, iss_lon, observer_lat, observer_lon))
+
+            return jsonify(result)
+    except Exception as e:
+        logger.warning(f"Where The ISS At API failed: {e}")
+
+    # Try fallback API: Open Notify
+    try:
+        response = requests.get('http://api.open-notify.org/iss-now.json', timeout=5)
+        if response.status_code == 200:
+            data = response.json()
+            if data.get('message') == 'success':
+                iss_lat = float(data['iss_position']['latitude'])
+                iss_lon = float(data['iss_position']['longitude'])
+
+                result = {
+                    'status': 'ok',
+                    'lat': iss_lat,
+                    'lon': iss_lon,
+                    'altitude': 420,  # Approximate ISS altitude in km
+                    'timestamp': datetime.utcnow().isoformat(),
+                    'source': 'open-notify'
+                }
+
+                # Calculate observer-relative data if location provided
+                if observer_lat is not None and observer_lon is not None:
+                    result.update(_calculate_observer_data(iss_lat, iss_lon, observer_lat, observer_lon))
+
+                return jsonify(result)
+    except Exception as e:
+        logger.warning(f"Open Notify API failed: {e}")
+
+    # Both APIs failed
+    return jsonify({
+        'status': 'error',
+        'message': 'Unable to fetch ISS position from real-time APIs'
+    }), 503
+
+
+def _calculate_observer_data(iss_lat: float, iss_lon: float, obs_lat: float, obs_lon: float) -> dict:
+    """Calculate elevation, azimuth, and distance from observer to ISS."""
+    import math
+
+    # ISS altitude in km
+    iss_alt_km = 420
+
+    # Earth radius in km
+    earth_radius = 6371
+
+    # Convert to radians
+    lat1 = math.radians(obs_lat)
+    lat2 = math.radians(iss_lat)
+    lon1 = math.radians(obs_lon)
+    lon2 = math.radians(iss_lon)
+
+    # Haversine for ground distance
+    dlat = lat2 - lat1
+    dlon = lon2 - lon1
+    a = math.sin(dlat/2)**2 + math.cos(lat1) * math.cos(lat2) * math.sin(dlon/2)**2
+    c = 2 * math.asin(math.sqrt(a))
+    ground_distance = earth_radius * c
+
+    # Calculate elevation angle (simplified)
+    # Using spherical geometry approximation
+    iss_height = iss_alt_km
+    slant_range = math.sqrt(ground_distance**2 + iss_height**2)
+
+    if ground_distance > 0:
+        elevation = math.degrees(math.atan2(iss_height - (ground_distance**2 / (2 * earth_radius)), ground_distance))
+    else:
+        elevation = 90.0
+
+    # Calculate azimuth
+    y = math.sin(dlon) * math.cos(lat2)
+    x = math.cos(lat1) * math.sin(lat2) - math.sin(lat1) * math.cos(lat2) * math.cos(dlon)
+    azimuth = math.degrees(math.atan2(y, x))
+    azimuth = (azimuth + 360) % 360
+
+    return {
+        'elevation': round(elevation, 1),
+        'azimuth': round(azimuth, 1),
+        'distance': round(slant_range, 1)
+    }
+
+
+@sstv_bp.route('/decode-file', methods=['POST'])
+def decode_file():
+    """
+    Decode SSTV from an uploaded audio file.
+
+    Expects multipart/form-data with 'audio' file field.
+
+    Returns:
+        JSON with decoded images.
+    """
+    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
+
+    # Save to temp file
+    import tempfile
+    with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as tmp:
+        audio_file.save(tmp.name)
+        tmp_path = tmp.name
+
+    try:
+        decoder = get_sstv_decoder()
+        images = decoder.decode_file(tmp_path)
+
+        return jsonify({
+            'status': 'ok',
+            'images': [img.to_dict() for img in images],
+            'count': len(images)
+        })
+
+    except Exception as e:
+        logger.error(f"Error decoding file: {e}")
+        return jsonify({
+            'status': 'error',
+            'message': str(e)
+        }), 500
+
+    finally:
+        # Clean up temp file
+        try:
+            Path(tmp_path).unlink()
+        except Exception:
+            pass

routes/sstv_general.py

@@ -0,0 +1,288 @@
+"""General SSTV (Slow-Scan Television) decoder routes.
+
+Provides endpoints for decoding terrestrial SSTV images on common HF/VHF/UHF
+frequencies used by amateur radio operators worldwide.
+"""
+
+from __future__ import annotations
+
+import queue
+import time
+from collections.abc import Generator
+from pathlib import Path
+
+from flask import Blueprint, Response, jsonify, request, send_file
+
+from utils.logging import get_logger
+from utils.sse import format_sse
+from utils.sstv import (
+    DecodeProgress,
+    get_general_sstv_decoder,
+)
+
+logger = get_logger('intercept.sstv_general')
+
+sstv_general_bp = Blueprint('sstv_general', __name__, url_prefix='/sstv-general')
+
+# Queue for SSE progress streaming
+_sstv_general_queue: queue.Queue = queue.Queue(maxsize=100)
+
+# Predefined SSTV frequencies
+SSTV_FREQUENCIES = [
+    {'band': '80 m', 'frequency': 3.845, 'modulation': 'lsb', 'notes': 'Common US SSTV calling frequency', 'type': 'Terrestrial HF'},
+    {'band': '80 m', 'frequency': 3.730, 'modulation': 'lsb', 'notes': 'Europe primary (analog/digital variants)', 'type': 'Terrestrial HF'},
+    {'band': '40 m', 'frequency': 7.171, 'modulation': 'lsb', 'notes': 'Common international/US/EU SSTV activity', 'type': 'Terrestrial HF'},
+    {'band': '40 m', 'frequency': 7.040, 'modulation': 'lsb', 'notes': 'Alternative US/Europe calling', 'type': 'Terrestrial HF'},
+    {'band': '30 m', 'frequency': 10.132, 'modulation': 'usb', 'notes': 'Narrowband SSTV (e.g., MP73-N digital)', 'type': 'Terrestrial HF'},
+    {'band': '20 m', 'frequency': 14.230, 'modulation': 'usb', 'notes': 'Most popular international SSTV frequency', 'type': 'Terrestrial HF'},
+    {'band': '20 m', 'frequency': 14.233, 'modulation': 'usb', 'notes': 'Digital SSTV calling / alternative activity', 'type': 'Terrestrial HF'},
+    {'band': '20 m', 'frequency': 14.240, 'modulation': 'usb', 'notes': 'Europe alternative', 'type': 'Terrestrial HF'},
+    {'band': '15 m', 'frequency': 21.340, 'modulation': 'usb', 'notes': 'International calling frequency', 'type': 'Terrestrial HF'},
+    {'band': '10 m', 'frequency': 28.680, 'modulation': 'usb', 'notes': 'International calling frequency', 'type': 'Terrestrial HF'},
+    {'band': '6 m', 'frequency': 50.950, 'modulation': 'usb', 'notes': 'SSTV calling (less common)', 'type': 'Terrestrial VHF'},
+    {'band': '2 m', 'frequency': 145.625, 'modulation': 'fm', 'notes': 'Australia/common simplex (FM sometimes used)', 'type': 'Terrestrial VHF'},
+    {'band': '70 cm', 'frequency': 433.775, 'modulation': 'fm', 'notes': 'Australia/common simplex', 'type': 'Terrestrial UHF'},
+]
+
+# Build a lookup for auto-detecting modulation from frequency
+_FREQ_MODULATION_MAP = {entry['frequency']: entry['modulation'] for entry in SSTV_FREQUENCIES}
+
+
+def _progress_callback(progress: DecodeProgress) -> None:
+    """Callback to queue progress updates for SSE stream."""
+    try:
+        _sstv_general_queue.put_nowait(progress.to_dict())
+    except queue.Full:
+        try:
+            _sstv_general_queue.get_nowait()
+            _sstv_general_queue.put_nowait(progress.to_dict())
+        except queue.Empty:
+            pass
+
+
+@sstv_general_bp.route('/frequencies')
+def get_frequencies():
+    """Return the predefined SSTV frequency table."""
+    return jsonify({
+        'status': 'ok',
+        'frequencies': SSTV_FREQUENCIES,
+    })
+
+
+@sstv_general_bp.route('/status')
+def get_status():
+    """Get general SSTV decoder status."""
+    decoder = get_general_sstv_decoder()
+
+    return jsonify({
+        'available': decoder.decoder_available is not None,
+        'decoder': decoder.decoder_available,
+        'running': decoder.is_running,
+        'image_count': len(decoder.get_images()),
+    })
+
+
+@sstv_general_bp.route('/start', methods=['POST'])
+def start_decoder():
+    """
+    Start general SSTV decoder.
+
+    JSON body:
+        {
+            "frequency": 14.230,     // Frequency in MHz (required)
+            "modulation": "usb",     // fm, usb, or lsb (auto-detected from frequency table if omitted)
+            "device": 0              // RTL-SDR device index
+        }
+    """
+    decoder = get_general_sstv_decoder()
+
+    if decoder.decoder_available is None:
+        return jsonify({
+            'status': 'error',
+            'message': 'SSTV decoder not available. Install slowrx: apt install slowrx',
+        }), 400
+
+    if decoder.is_running:
+        return jsonify({
+            'status': 'already_running',
+        })
+
+    # Clear queue
+    while not _sstv_general_queue.empty():
+        try:
+            _sstv_general_queue.get_nowait()
+        except queue.Empty:
+            break
+
+    data = request.get_json(silent=True) or {}
+    frequency = data.get('frequency')
+    modulation = data.get('modulation')
+    device_index = data.get('device', 0)
+
+    # Validate frequency
+    if frequency is None:
+        return jsonify({
+            'status': 'error',
+            'message': 'Frequency is required',
+        }), 400
+
+    try:
+        frequency = float(frequency)
+        if not (1 <= frequency <= 500):
+            return jsonify({
+                'status': 'error',
+                'message': 'Frequency must be between 1-500 MHz (HF requires upconverter for RTL-SDR)',
+            }), 400
+    except (TypeError, ValueError):
+        return jsonify({
+            'status': 'error',
+            'message': 'Invalid frequency',
+        }), 400
+
+    # Auto-detect modulation from frequency table if not specified
+    if not modulation:
+        modulation = _FREQ_MODULATION_MAP.get(frequency, 'usb')
+
+    # Validate modulation
+    if modulation not in ('fm', 'usb', 'lsb'):
+        return jsonify({
+            'status': 'error',
+            'message': 'Modulation must be fm, usb, or lsb',
+        }), 400
+
+    # Set callback and start
+    decoder.set_callback(_progress_callback)
+    success = decoder.start(
+        frequency=frequency,
+        device_index=device_index,
+        modulation=modulation,
+    )
+
+    if success:
+        return jsonify({
+            'status': 'started',
+            'frequency': frequency,
+            'modulation': modulation,
+            'device': device_index,
+        })
+    else:
+        return jsonify({
+            'status': 'error',
+            'message': 'Failed to start decoder',
+        }), 500
+
+
+@sstv_general_bp.route('/stop', methods=['POST'])
+def stop_decoder():
+    """Stop general SSTV decoder."""
+    decoder = get_general_sstv_decoder()
+    decoder.stop()
+    return jsonify({'status': 'stopped'})
+
+
+@sstv_general_bp.route('/images')
+def list_images():
+    """Get list of decoded SSTV images."""
+    decoder = get_general_sstv_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),
+    })
+
+
+@sstv_general_bp.route('/images/<filename>')
+def get_image(filename: str):
+    """Get a decoded SSTV image file."""
+    decoder = get_general_sstv_decoder()
+
+    # Security: only allow alphanumeric filenames with .png extension
+    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')
+
+
+@sstv_general_bp.route('/stream')
+def stream_progress():
+    """SSE stream of SSTV decode progress."""
+    def generate() -> Generator[str, None, None]:
+        last_keepalive = time.time()
+        keepalive_interval = 30.0
+
+        while True:
+            try:
+                progress = _sstv_general_queue.get(timeout=1)
+                last_keepalive = time.time()
+                yield format_sse(progress)
+            except queue.Empty:
+                now = time.time()
+                if now - last_keepalive >= keepalive_interval:
+                    yield format_sse({'type': 'keepalive'})
+                    last_keepalive = now
+
+    response = Response(generate(), mimetype='text/event-stream')
+    response.headers['Cache-Control'] = 'no-cache'
+    response.headers['X-Accel-Buffering'] = 'no'
+    response.headers['Connection'] = 'keep-alive'
+    return response
+
+
+@sstv_general_bp.route('/decode-file', methods=['POST'])
+def decode_file():
+    """Decode SSTV from an uploaded audio 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
+
+    import tempfile
+    with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as tmp:
+        audio_file.save(tmp.name)
+        tmp_path = tmp.name
+
+    try:
+        decoder = get_general_sstv_decoder()
+        images = decoder.decode_file(tmp_path)
+
+        return jsonify({
+            'status': 'ok',
+            'images': [img.to_dict() for img in images],
+            'count': len(images),
+        })
+
+    except Exception as e:
+        logger.error(f"Error decoding file: {e}")
+        return jsonify({
+            'status': 'error',
+            'message': str(e),
+        }), 500
+
+    finally:
+        try:
+            Path(tmp_path).unlink()
+        except Exception:
+            pass

routes/updater.py

@@ -0,0 +1,179 @@
+"""Updater routes - GitHub update checking and application updates."""
+
+from __future__ import annotations
+
+from flask import Blueprint, Response, jsonify, request
+
+from utils.logging import get_logger
+from utils.updater import (
+    check_for_updates,
+    dismiss_update,
+    get_update_status,
+    perform_update,
+    restart_application,
+)
+
+logger = get_logger('intercept.routes.updater')
+
+updater_bp = Blueprint('updater', __name__, url_prefix='/updater')
+
+
+@updater_bp.route('/check', methods=['GET'])
+def check_updates() -> Response:
+    """
+    Check for updates from GitHub.
+
+    Uses caching to avoid excessive API calls. Will only hit GitHub
+    if the cache is stale (default: 6 hours).
+
+    Query parameters:
+        force: Set to 'true' to bypass cache and check GitHub directly
+
+    Returns:
+        JSON with update status information
+    """
+    force = request.args.get('force', '').lower() == 'true'
+
+    try:
+        result = check_for_updates(force=force)
+        return jsonify(result)
+    except Exception as e:
+        logger.error(f"Error checking for updates: {e}")
+        return jsonify({
+            'success': False,
+            'error': str(e)
+        }), 500
+
+
+@updater_bp.route('/status', methods=['GET'])
+def update_status() -> Response:
+    """
+    Get current update status from cache.
+
+    This endpoint does NOT trigger a GitHub check - it only returns
+    cached data. Use /check to trigger a fresh check.
+
+    Returns:
+        JSON with cached update status
+    """
+    try:
+        result = get_update_status()
+        return jsonify(result)
+    except Exception as e:
+        logger.error(f"Error getting update status: {e}")
+        return jsonify({
+            'success': False,
+            'error': str(e)
+        }), 500
+
+
+@updater_bp.route('/update', methods=['POST'])
+def do_update() -> Response:
+    """
+    Perform a git pull to update the application.
+
+    Request body (JSON):
+        stash_changes: If true, stash local changes before pulling
+
+    Returns:
+        JSON with update result information
+    """
+    data = request.json or {}
+    stash_changes = data.get('stash_changes', False)
+
+    try:
+        result = perform_update(stash_changes=stash_changes)
+
+        if result.get('success'):
+            return jsonify(result)
+        else:
+            # Return appropriate status code based on error type
+            error = result.get('error', '')
+            if error == 'local_changes':
+                return jsonify(result), 409  # Conflict
+            elif error == 'merge_conflict':
+                return jsonify(result), 409
+            elif result.get('manual_update'):
+                return jsonify(result), 400
+            else:
+                return jsonify(result), 500
+
+    except Exception as e:
+        logger.error(f"Error performing update: {e}")
+        return jsonify({
+            'success': False,
+            'error': str(e)
+        }), 500
+
+
+@updater_bp.route('/dismiss', methods=['POST'])
+def dismiss_notification() -> Response:
+    """
+    Dismiss update notification for a specific version.
+
+    The notification will not be shown again until a newer version
+    is available.
+
+    Request body (JSON):
+        version: The version to dismiss notifications for
+
+    Returns:
+        JSON with success status
+    """
+    data = request.json or {}
+    version = data.get('version')
+
+    if not version:
+        return jsonify({
+            'success': False,
+            'error': 'Version is required'
+        }), 400
+
+    try:
+        result = dismiss_update(version)
+        return jsonify(result)
+    except Exception as e:
+        logger.error(f"Error dismissing update: {e}")
+        return jsonify({
+            'success': False,
+            'error': str(e)
+        }), 500
+
+
+@updater_bp.route('/restart', methods=['POST'])
+def restart_app() -> Response:
+    """
+    Restart the application.
+
+    This endpoint triggers a graceful restart of the application:
+    1. Stops all running decoder processes
+    2. Cleans up global state
+    3. Replaces the current process with a fresh instance
+
+    The response may not be received by the client since the process
+    is replaced immediately. Clients should poll /health until the
+    server responds again.
+
+    Returns:
+        JSON with restart status (may not be delivered)
+    """
+    import threading
+
+    logger.info("Restart requested via API")
+
+    # Send response before restarting
+    # Use a short delay to allow the response to be sent
+    def delayed_restart():
+        import time
+        time.sleep(0.5)  # Allow response to be sent
+        restart_application()
+
+    # Start restart in a background thread so we can return a response
+    restart_thread = threading.Thread(target=delayed_restart, daemon=False)
+    restart_thread.start()
+
+    return jsonify({
+        'success': True,
+        'message': 'Application is restarting. Please wait...',
+        'action': 'restart'
+    })

routes/websdr.py

@@ -0,0 +1,504 @@
+"""HF/Shortwave WebSDR Integration - KiwiSDR network access."""
+
+from __future__ import annotations
+
+import json
+import math
+import queue
+import re
+import struct
+import threading
+import time
+from typing import Optional
+
+from flask import Blueprint, Flask, jsonify, request, Response
+
+try:
+    from flask_sock import Sock
+    WEBSOCKET_AVAILABLE = True
+except ImportError:
+    WEBSOCKET_AVAILABLE = False
+
+from utils.kiwisdr import KiwiSDRClient, KIWI_SAMPLE_RATE, VALID_MODES, parse_host_port
+from utils.logging import get_logger
+
+logger = get_logger('intercept.websdr')
+
+websdr_bp = Blueprint('websdr', __name__, url_prefix='/websdr')
+
+# ============================================
+# RECEIVER CACHE
+# ============================================
+
+_receiver_cache: list[dict] = []
+_cache_lock = threading.Lock()
+_cache_timestamp: float = 0
+CACHE_TTL = 3600  # 1 hour
+
+
+def _parse_gps_coord(coord_str: str) -> Optional[float]:
+    """Parse a GPS coordinate string like '51.5074' or '(-33.87)' into a float."""
+    if not coord_str:
+        return None
+    # Remove parentheses and whitespace
+    cleaned = coord_str.strip().strip('()').strip()
+    try:
+        return float(cleaned)
+    except (ValueError, TypeError):
+        return None
+
+
+def _haversine(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
+    """Calculate distance in km between two GPS coordinates."""
+    R = 6371  # Earth radius in km
+    dlat = math.radians(lat2 - lat1)
+    dlon = math.radians(lon2 - lon1)
+    a = (math.sin(dlat / 2) ** 2 +
+         math.cos(math.radians(lat1)) * math.cos(math.radians(lat2)) *
+         math.sin(dlon / 2) ** 2)
+    c = 2 * math.asin(math.sqrt(a))
+    return R * c
+
+
+KIWI_DATA_URLS = [
+    'https://rx.skywavelinux.com/kiwisdr_com.js',
+    'http://rx.linkfanel.net/kiwisdr_com.js',
+]
+
+
+def _fetch_kiwi_receivers() -> list[dict]:
+    """Fetch the KiwiSDR receiver list from the public directory."""
+    import urllib.request
+    import json
+
+    receivers = []
+    raw = None
+
+    # Try each data source until one works
+    for data_url in KIWI_DATA_URLS:
+        try:
+            req = urllib.request.Request(data_url, headers={
+                'User-Agent': 'INTERCEPT-SIGINT/1.0',
+            })
+            with urllib.request.urlopen(req, timeout=20) as resp:
+                raw = resp.read().decode('utf-8', errors='replace')
+            if raw and len(raw) > 100:
+                logger.info(f"Fetched KiwiSDR data from {data_url}")
+                break
+            raw = None
+        except Exception as e:
+            logger.warning(f"Failed to fetch from {data_url}: {e}")
+            continue
+
+    if not raw:
+        logger.error("All KiwiSDR data sources failed")
+        return receivers
+
+    # The JS file contains: var kiwisdr_com = [ {...}, {...}, ... ];
+    # Extract the JSON array
+    match = re.search(r'var\s+kiwisdr_com\s*=\s*(\[.*\])\s*;?', raw, re.DOTALL)
+    if not match:
+        # Try bare array
+        match = re.search(r'(\[\s*\{.*\}\s*\])', raw, re.DOTALL)
+        if not match:
+            logger.warning("Could not find receiver array in KiwiSDR data")
+            return receivers
+
+    arr_str = match.group(1)
+
+    # Parse JSON
+    try:
+        raw_list = json.loads(arr_str)
+    except json.JSONDecodeError:
+        # Fix common JS → JSON issues (trailing commas)
+        fixed = re.sub(r',\s*}', '}', arr_str)
+        fixed = re.sub(r',\s*]', ']', fixed)
+        try:
+            raw_list = json.loads(fixed)
+        except json.JSONDecodeError:
+            logger.error("Failed to parse KiwiSDR JSON")
+            return receivers
+
+    for entry in raw_list:
+        if not isinstance(entry, dict):
+            continue
+
+        # Skip offline receivers
+        if entry.get('offline') == 'yes' or entry.get('status') != 'active':
+            continue
+
+        name = entry.get('name', 'Unknown')
+        url = entry.get('url', '')
+        gps = entry.get('gps', '')
+        antenna = entry.get('antenna', '')
+        location = entry.get('loc', '')
+
+        # Parse users (strings in actual data)
+        try:
+            users = int(entry.get('users', 0))
+        except (ValueError, TypeError):
+            users = 0
+        try:
+            users_max = int(entry.get('users_max', 4))
+        except (ValueError, TypeError):
+            users_max = 4
+
+        # Parse bands field: "0-30000000" (Hz) → freq_lo/freq_hi in kHz
+        bands_str = entry.get('bands', '0-30000000')
+        freq_lo = 0
+        freq_hi = 30000
+        if bands_str and '-' in str(bands_str):
+            try:
+                parts = str(bands_str).split('-')
+                freq_lo = int(parts[0]) / 1000  # Hz to kHz
+                freq_hi = int(parts[1]) / 1000  # Hz to kHz
+            except (ValueError, IndexError):
+                pass
+
+        # Parse GPS: "(51.317266, -2.950479)" format
+        lat, lon = None, None
+        if gps:
+            parts = str(gps).replace('(', '').replace(')', '').split(',')
+            if len(parts) >= 2:
+                lat = _parse_gps_coord(parts[0])
+                lon = _parse_gps_coord(parts[1])
+
+        if not url:
+            continue
+
+        # Ensure URL has protocol
+        if not url.startswith('http'):
+            url = 'http://' + url
+
+        receivers.append({
+            'name': name,
+            'url': url.rstrip('/'),
+            'lat': lat,
+            'lon': lon,
+            'location': location,
+            'users': users,
+            'users_max': users_max,
+            'antenna': antenna,
+            'bands': bands_str,
+            'freq_lo': freq_lo,
+            'freq_hi': freq_hi,
+            'available': users < users_max,
+        })
+
+    return receivers
+
+
+def get_receivers(force_refresh: bool = False) -> list[dict]:
+    """Get cached receiver list, refreshing if stale."""
+    global _receiver_cache, _cache_timestamp
+
+    with _cache_lock:
+        now = time.time()
+        if force_refresh or not _receiver_cache or (now - _cache_timestamp) > CACHE_TTL:
+            logger.info("Refreshing KiwiSDR receiver list...")
+            _receiver_cache = _fetch_kiwi_receivers()
+            _cache_timestamp = now
+            logger.info(f"Loaded {len(_receiver_cache)} KiwiSDR receivers")
+
+    return _receiver_cache
+
+
+# ============================================
+# API ENDPOINTS
+# ============================================
+
+@websdr_bp.route('/receivers')
+def list_receivers() -> Response:
+    """List KiwiSDR receivers, with optional filters."""
+    freq_khz = request.args.get('freq_khz', type=float)
+    available = request.args.get('available', type=str)
+    refresh = request.args.get('refresh', type=str)
+
+    receivers = get_receivers(force_refresh=(refresh == 'true'))
+
+    filtered = receivers
+    if available == 'true':
+        filtered = [r for r in filtered if r.get('available', True)]
+
+    if freq_khz is not None:
+        filtered = [
+            r for r in filtered
+            if r.get('freq_lo', 0) <= freq_khz <= r.get('freq_hi', 30000)
+        ]
+
+    return jsonify({
+        'status': 'success',
+        'receivers': filtered[:100],
+        'total': len(filtered),
+        'cached_total': len(receivers),
+    })
+
+
+@websdr_bp.route('/receivers/nearest')
+def nearest_receivers() -> Response:
+    """Find receivers nearest to a given location."""
+    lat = request.args.get('lat', type=float)
+    lon = request.args.get('lon', type=float)
+    freq_khz = request.args.get('freq_khz', type=float)
+
+    if lat is None or lon is None:
+        return jsonify({'status': 'error', 'message': 'lat and lon are required'}), 400
+
+    receivers = get_receivers()
+
+    # Filter by frequency if specified
+    if freq_khz is not None:
+        receivers = [
+            r for r in receivers
+            if r.get('freq_lo', 0) <= freq_khz <= r.get('freq_hi', 30000)
+        ]
+
+    # Calculate distances and sort
+    with_distance = []
+    for r in receivers:
+        if r.get('lat') is not None and r.get('lon') is not None:
+            dist = _haversine(lat, lon, r['lat'], r['lon'])
+            entry = dict(r)
+            entry['distance_km'] = round(dist, 1)
+            with_distance.append(entry)
+
+    with_distance.sort(key=lambda x: x['distance_km'])
+
+    return jsonify({
+        'status': 'success',
+        'receivers': with_distance[:10],
+    })
+
+
+@websdr_bp.route('/spy-station/<station_id>/receivers')
+def spy_station_receivers(station_id: str) -> Response:
+    """Find receivers that can tune to a spy station's frequency."""
+    try:
+        from routes.spy_stations import STATIONS
+    except ImportError:
+        return jsonify({'status': 'error', 'message': 'Spy stations module not available'}), 503
+
+    # Find the station
+    station = None
+    for s in STATIONS:
+        if s.get('id') == station_id:
+            station = s
+            break
+
+    if not station:
+        return jsonify({'status': 'error', 'message': 'Station not found'}), 404
+
+    # Get primary frequency
+    freq_khz = None
+    for f in station.get('frequencies', []):
+        if f.get('primary'):
+            freq_khz = f.get('freq_khz')
+            break
+    if freq_khz is None and station.get('frequencies'):
+        freq_khz = station['frequencies'][0].get('freq_khz')
+
+    if freq_khz is None:
+        return jsonify({'status': 'error', 'message': 'No frequency found for station'}), 404
+
+    receivers = get_receivers()
+
+    # Filter receivers that cover this frequency and are available
+    matching = [
+        r for r in receivers
+        if r.get('freq_lo', 0) <= freq_khz <= r.get('freq_hi', 30000) and r.get('available', True)
+    ]
+
+    return jsonify({
+        'status': 'success',
+        'station': {
+            'id': station['id'],
+            'name': station.get('name', ''),
+            'nickname': station.get('nickname', ''),
+            'freq_khz': freq_khz,
+            'mode': station.get('mode', 'USB'),
+        },
+        'receivers': matching[:20],
+        'total': len(matching),
+    })
+
+
+@websdr_bp.route('/status')
+def websdr_status() -> Response:
+    """Get WebSDR connection and cache status."""
+    return jsonify({
+        'status': 'ok',
+        'cached_receivers': len(_receiver_cache),
+        'cache_age_seconds': round(time.time() - _cache_timestamp, 0) if _cache_timestamp > 0 else None,
+        'cache_ttl': CACHE_TTL,
+        'audio_connected': _kiwi_client is not None and _kiwi_client.connected if _kiwi_client else False,
+    })
+
+
+# ============================================
+# KIWISDR AUDIO PROXY
+# ============================================
+
+_kiwi_client: Optional[KiwiSDRClient] = None
+_kiwi_lock = threading.Lock()
+_kiwi_audio_queue: queue.Queue = queue.Queue(maxsize=200)
+
+
+def _disconnect_kiwi() -> None:
+    """Disconnect active KiwiSDR client."""
+    global _kiwi_client
+    with _kiwi_lock:
+        if _kiwi_client:
+            _kiwi_client.disconnect()
+            _kiwi_client = None
+    # Drain audio queue
+    while not _kiwi_audio_queue.empty():
+        try:
+            _kiwi_audio_queue.get_nowait()
+        except queue.Empty:
+            break
+
+
+def _handle_kiwi_command(ws, cmd: str, data: dict) -> None:
+    """Handle a command from the browser client."""
+    global _kiwi_client
+
+    if cmd == 'connect':
+        receiver_url = data.get('url', '')
+        host = data.get('host', '')
+        port = int(data.get('port', 8073))
+        freq_khz = float(data.get('freq_khz', 7000))
+        mode = data.get('mode', 'am').lower()
+        password = data.get('password', '')
+
+        # Parse host/port from URL if provided
+        if receiver_url and not host:
+            host, port = parse_host_port(receiver_url)
+
+        if mode not in VALID_MODES:
+            ws.send(json.dumps({'type': 'error', 'message': f'Invalid mode: {mode}'}))
+            return
+
+        if not host or ';' in host or '&' in host or '|' in host:
+            ws.send(json.dumps({'type': 'error', 'message': 'Invalid host'}))
+            return
+
+        _disconnect_kiwi()
+
+        def on_audio(pcm_bytes, smeter):
+            # Package: 2 bytes smeter (big-endian int16) + PCM data
+            header = struct.pack('>h', smeter)
+            try:
+                _kiwi_audio_queue.put_nowait(header + pcm_bytes)
+            except queue.Full:
+                try:
+                    _kiwi_audio_queue.get_nowait()
+                except queue.Empty:
+                    pass
+                try:
+                    _kiwi_audio_queue.put_nowait(header + pcm_bytes)
+                except queue.Full:
+                    pass
+
+        def on_error(msg):
+            try:
+                ws.send(json.dumps({'type': 'error', 'message': msg}))
+            except Exception:
+                pass
+
+        def on_disconnect():
+            try:
+                ws.send(json.dumps({'type': 'disconnected'}))
+            except Exception:
+                pass
+
+        with _kiwi_lock:
+            _kiwi_client = KiwiSDRClient(
+                host=host, port=port,
+                on_audio=on_audio,
+                on_error=on_error,
+                on_disconnect=on_disconnect,
+                password=password,
+            )
+            success = _kiwi_client.connect(freq_khz, mode)
+
+        if success:
+            ws.send(json.dumps({
+                'type': 'connected',
+                'host': host,
+                'port': port,
+                'freq_khz': freq_khz,
+                'mode': mode,
+                'sample_rate': KIWI_SAMPLE_RATE,
+            }))
+        else:
+            ws.send(json.dumps({'type': 'error', 'message': 'Connection to KiwiSDR failed'}))
+            _disconnect_kiwi()
+
+    elif cmd == 'tune':
+        freq_khz = float(data.get('freq_khz', 0))
+        mode = data.get('mode', '').lower() or None
+
+        with _kiwi_lock:
+            if _kiwi_client and _kiwi_client.connected:
+                success = _kiwi_client.tune(
+                    freq_khz,
+                    mode or _kiwi_client.mode
+                )
+                if success:
+                    ws.send(json.dumps({
+                        'type': 'tuned',
+                        'freq_khz': freq_khz,
+                        'mode': mode or _kiwi_client.mode,
+                    }))
+                else:
+                    ws.send(json.dumps({'type': 'error', 'message': 'Retune failed'}))
+            else:
+                ws.send(json.dumps({'type': 'error', 'message': 'Not connected'}))
+
+    elif cmd == 'disconnect':
+        _disconnect_kiwi()
+        ws.send(json.dumps({'type': 'disconnected'}))
+
+
+def init_websdr_audio(app: Flask) -> None:
+    """Initialize WebSocket audio proxy for KiwiSDR. Called from app.py."""
+    if not WEBSOCKET_AVAILABLE:
+        logger.warning("flask-sock not installed, KiwiSDR audio proxy disabled")
+        return
+
+    sock = Sock(app)
+
+    @sock.route('/ws/kiwi-audio')
+    def kiwi_audio_stream(ws):
+        """WebSocket endpoint: proxy audio between browser and KiwiSDR."""
+        logger.info("KiwiSDR audio client connected")
+
+        try:
+            while True:
+                # Check for commands from browser
+                try:
+                    msg = ws.receive(timeout=0.005)
+                    if msg:
+                        data = json.loads(msg)
+                        cmd = data.get('cmd', '')
+                        _handle_kiwi_command(ws, cmd, data)
+                except TimeoutError:
+                    pass
+                except Exception as e:
+                    if 'closed' in str(e).lower():
+                        break
+                    if 'timed out' not in str(e).lower():
+                        logger.error(f"KiwiSDR WS receive error: {e}")
+
+                # Forward audio from KiwiSDR to browser
+                try:
+                    audio_data = _kiwi_audio_queue.get_nowait()
+                    ws.send(audio_data)
+                except queue.Empty:
+                    time.sleep(0.005)
+
+        except Exception as e:
+            logger.info(f"KiwiSDR WS closed: {e}")
+        finally:
+            _disconnect_kiwi()
+            logger.info("KiwiSDR audio client disconnected")

routes/wifi.py

@@ -1240,10 +1240,32 @@ def v2_get_networks():
 
 @wifi_bp.route('/v2/clients')
 def v2_get_clients():
-    """Get all discovered clients."""
+    """Get discovered clients with optional filtering."""
     try:
         scanner = get_wifi_scanner()
         clients = scanner.clients
+
+        # Filter by association status
+        associated = request.args.get('associated')
+        if associated == 'true':
+            clients = [c for c in clients if c.is_associated]
+        elif associated == 'false':
+            clients = [c for c in clients if not c.is_associated]
+
+        # Filter by associated BSSID
+        bssid = request.args.get('bssid')
+        if bssid:
+            clients = [c for c in clients if c.associated_bssid == bssid.upper()]
+
+        # Filter by minimum RSSI
+        min_rssi = request.args.get('min_rssi')
+        if min_rssi:
+            try:
+                min_rssi = int(min_rssi)
+                clients = [c for c in clients if c.rssi_current and c.rssi_current >= min_rssi]
+            except ValueError:
+                pass
+
         return jsonify({
             'clients': [c.to_dict() for c in clients],
             'total': len(clients),
@@ -1413,3 +1435,143 @@ def v2_clear_data():
     except Exception as e:
         logger.exception("Error clearing data")
         return jsonify({'error': str(e)}), 500
+
+
+# =============================================================================
+# V2 Deauth Detection Endpoints
+# =============================================================================
+
+@wifi_bp.route('/v2/deauth/status')
+def v2_deauth_status():
+    """
+    Get deauth detection status and recent alerts.
+
+    Returns:
+        - is_running: Whether deauth detector is active
+        - interface: Monitor interface being used
+        - stats: Detection statistics
+        - recent_alerts: Recent deauth alerts
+    """
+    try:
+        scanner = get_wifi_scanner()
+        detector = scanner.deauth_detector
+
+        if detector:
+            stats = detector.stats
+            alerts = detector.get_alerts(limit=50)
+        else:
+            stats = {
+                'is_running': False,
+                'interface': None,
+                'packets_captured': 0,
+                'alerts_generated': 0,
+            }
+            alerts = []
+
+        return jsonify({
+            'is_running': stats.get('is_running', False),
+            'interface': stats.get('interface'),
+            'started_at': stats.get('started_at'),
+            'stats': {
+                'packets_captured': stats.get('packets_captured', 0),
+                'alerts_generated': stats.get('alerts_generated', 0),
+                'active_trackers': stats.get('active_trackers', 0),
+            },
+            'recent_alerts': alerts,
+        })
+    except Exception as e:
+        logger.exception("Error getting deauth status")
+        return jsonify({'error': str(e)}), 500
+
+
+@wifi_bp.route('/v2/deauth/stream')
+def v2_deauth_stream():
+    """
+    SSE stream for real-time deauth alerts.
+
+    Events:
+        - deauth_alert: A deauth attack was detected
+        - deauth_detector_started: Detector started
+        - deauth_detector_stopped: Detector stopped
+        - deauth_error: An error occurred
+        - keepalive: Periodic keepalive
+    """
+    def generate():
+        last_keepalive = time.time()
+        keepalive_interval = SSE_KEEPALIVE_INTERVAL
+
+        while True:
+            try:
+                # Try to get from the dedicated deauth queue
+                msg = app_module.deauth_detector_queue.get(timeout=SSE_QUEUE_TIMEOUT)
+                last_keepalive = time.time()
+                yield format_sse(msg)
+            except queue.Empty:
+                now = time.time()
+                if now - last_keepalive >= keepalive_interval:
+                    yield format_sse({'type': 'keepalive'})
+                    last_keepalive = now
+
+    response = Response(generate(), mimetype='text/event-stream')
+    response.headers['Cache-Control'] = 'no-cache'
+    response.headers['X-Accel-Buffering'] = 'no'
+    response.headers['Connection'] = 'keep-alive'
+    return response
+
+
+@wifi_bp.route('/v2/deauth/alerts')
+def v2_deauth_alerts():
+    """
+    Get historical deauth alerts.
+
+    Query params:
+        - limit: Maximum number of alerts to return (default 100)
+    """
+    try:
+        limit = request.args.get('limit', 100, type=int)
+        limit = max(1, min(limit, 1000))  # Clamp between 1 and 1000
+
+        scanner = get_wifi_scanner()
+        alerts = scanner.get_deauth_alerts(limit=limit)
+
+        # Also include alerts from DataStore that might have been persisted
+        try:
+            stored_alerts = list(app_module.deauth_alerts.values())
+            # Merge and deduplicate by ID
+            alert_ids = {a.get('id') for a in alerts}
+            for alert in stored_alerts:
+                if alert.get('id') not in alert_ids:
+                    alerts.append(alert)
+            # Sort by timestamp descending
+            alerts.sort(key=lambda a: a.get('timestamp', 0), reverse=True)
+            alerts = alerts[:limit]
+        except Exception:
+            pass
+
+        return jsonify({
+            'alerts': alerts,
+            'count': len(alerts),
+        })
+    except Exception as e:
+        logger.exception("Error getting deauth alerts")
+        return jsonify({'error': str(e)}), 500
+
+
+@wifi_bp.route('/v2/deauth/clear', methods=['POST'])
+def v2_deauth_clear():
+    """Clear deauth alert history."""
+    try:
+        scanner = get_wifi_scanner()
+        scanner.clear_deauth_alerts()
+
+        # Clear the queue
+        while not app_module.deauth_detector_queue.empty():
+            try:
+                app_module.deauth_detector_queue.get_nowait()
+            except queue.Empty:
+                break
+
+        return jsonify({'status': 'cleared'})
+    except Exception as e:
+        logger.exception("Error clearing deauth alerts")
+        return jsonify({'error': str(e)}), 500

setup.sh

@@ -204,11 +204,16 @@ check_tools() {
   check_required "dump1090"    "ADS-B decoder" dump1090
   check_required "acarsdec"    "ACARS decoder" acarsdec
   check_required "AIS-catcher" "AIS vessel decoder" AIS-catcher aiscatcher
+  check_optional "slowrx"      "SSTV decoder (ISS images)" slowrx
 
   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
@@ -303,6 +308,10 @@ install_python_deps() {
   else
     ok "Python dependencies installed"
   fi
+
+  # Ensure Flask 3.0+ is installed (required for Werkzeug 3.x compatibility)
+  # System apt packages may have older Flask 2.x which is incompatible
+  python -m pip install --upgrade "flask>=3.0.0" >/dev/null 2>&1 || true
   echo
 }
 
@@ -381,6 +390,43 @@ install_rtlamr_from_source() {
   fi
 }
 
+install_slowrx_from_source_macos() {
+  info "slowrx not available via Homebrew. Building from source..."
+
+  # Ensure build dependencies are installed
+  brew_install fftw
+  brew_install libsndfile
+  brew_install gtk+3
+  brew_install pkg-config
+
+  (
+    tmp_dir="$(mktemp -d)"
+    trap 'rm -rf "$tmp_dir"' EXIT
+
+    info "Cloning slowrx..."
+    git clone --depth 1 https://github.com/windytan/slowrx.git "$tmp_dir/slowrx" >/dev/null 2>&1 \
+      || { warn "Failed to clone slowrx"; exit 1; }
+
+    cd "$tmp_dir/slowrx"
+    info "Compiling slowrx..."
+    # slowrx uses a plain Makefile, not CMake
+    local make_log
+    make_log=$(make 2>&1) || {
+      warn "make failed for slowrx:"
+      echo "$make_log" | tail -20
+      exit 1
+    }
+
+    # Install to /usr/local/bin
+    if [[ -w /usr/local/bin ]]; then
+      install -m 0755 slowrx /usr/local/bin/slowrx
+    else
+      sudo install -m 0755 slowrx /usr/local/bin/slowrx
+    fi
+    ok "slowrx installed successfully from source"
+  )
+}
+
 install_multimon_ng_from_source_macos() {
   info "multimon-ng not available via Homebrew. Building from source..."
 
@@ -412,8 +458,192 @@ 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
+          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
+          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..."
+
+  brew_install cmake
+  brew_install librtlsdr
+  brew_install pkg-config
+
+  (
+    tmp_dir="$(mktemp -d)"
+    trap 'rm -rf "$tmp_dir"' EXIT
+
+    info "Cloning FlightAware dump1090..."
+    git clone --depth 1 https://github.com/flightaware/dump1090.git "$tmp_dir/dump1090" >/dev/null 2>&1 \
+      || { warn "Failed to clone dump1090"; exit 1; }
+
+    cd "$tmp_dir/dump1090"
+    sed -i '' 's/-Werror//g' Makefile 2>/dev/null || true
+    info "Compiling dump1090..."
+    if make BLADERF=no RTLSDR=yes 2>&1 | tail -5; then
+      if [[ -w /usr/local/bin ]]; then
+        install -m 0755 dump1090 /usr/local/bin/dump1090
+      else
+        sudo install -m 0755 dump1090 /usr/local/bin/dump1090
+      fi
+      ok "dump1090 installed successfully from source"
+    else
+      warn "Failed to build dump1090. ADS-B decoding will not be available."
+    fi
+  )
+}
+
+install_acarsdec_from_source_macos() {
+  info "acarsdec not available via Homebrew. Building from source..."
+
+  brew_install cmake
+  brew_install librtlsdr
+  brew_install libsndfile
+  brew_install pkg-config
+
+  (
+    tmp_dir="$(mktemp -d)"
+    trap 'rm -rf "$tmp_dir"' EXIT
+
+    info "Cloning acarsdec..."
+    git clone --depth 1 https://github.com/TLeconte/acarsdec.git "$tmp_dir/acarsdec" >/dev/null 2>&1 \
+      || { warn "Failed to clone acarsdec"; exit 1; }
+
+    cd "$tmp_dir/acarsdec"
+    mkdir -p build && cd build
+
+    info "Compiling acarsdec..."
+    if cmake .. -Drtl=ON >/dev/null 2>&1 && make >/dev/null 2>&1; then
+      if [[ -w /usr/local/bin ]]; then
+        install -m 0755 acarsdec /usr/local/bin/acarsdec
+      else
+        sudo install -m 0755 acarsdec /usr/local/bin/acarsdec
+      fi
+      ok "acarsdec installed successfully from source"
+    else
+      warn "Failed to build acarsdec. ACARS decoding will not be available."
+    fi
+  )
+}
+
+install_aiscatcher_from_source_macos() {
+  info "AIS-catcher not available via Homebrew. Building from source..."
+
+  brew_install cmake
+  brew_install librtlsdr
+  brew_install curl
+  brew_install pkg-config
+
+  (
+    tmp_dir="$(mktemp -d)"
+    trap 'rm -rf "$tmp_dir"' EXIT
+
+    info "Cloning AIS-catcher..."
+    git clone --depth 1 https://github.com/jvde-github/AIS-catcher.git "$tmp_dir/AIS-catcher" >/dev/null 2>&1 \
+      || { warn "Failed to clone AIS-catcher"; exit 1; }
+
+    cd "$tmp_dir/AIS-catcher"
+    mkdir -p build && cd build
+
+    info "Compiling AIS-catcher..."
+    if cmake .. >/dev/null 2>&1 && make >/dev/null 2>&1; then
+      if [[ -w /usr/local/bin ]]; then
+        install -m 0755 AIS-catcher /usr/local/bin/AIS-catcher
+      else
+        sudo install -m 0755 AIS-catcher /usr/local/bin/AIS-catcher
+      fi
+      ok "AIS-catcher installed successfully from source"
+    else
+      warn "Failed to build AIS-catcher. AIS vessel tracking will not be available."
+    fi
+  )
+}
+
 install_macos_packages() {
-  TOTAL_STEPS=14
+  TOTAL_STEPS=17
   CURRENT_STEP=0
 
   progress "Checking Homebrew"
@@ -433,6 +663,22 @@ install_macos_packages() {
   progress "Installing direwolf (APRS decoder)"
   (brew_install direwolf) || warn "direwolf not available via Homebrew"
 
+  progress "Skipping slowrx (SSTV decoder)"
+  warn "slowrx requires ALSA (Linux-only) and cannot build on macOS. Skipping."
+
+  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
 
@@ -454,14 +700,22 @@ install_macos_packages() {
   fi
 
   progress "Installing dump1090"
-  (brew_install dump1090-mutability) || warn "dump1090 not available via Homebrew"
+  if ! cmd_exists dump1090; then
+    (brew_install dump1090-mutability) || install_dump1090_from_source_macos || warn "dump1090 not available"
+  else
+    ok "dump1090 already installed"
+  fi
 
   progress "Installing acarsdec"
-  (brew_install acarsdec) || warn "acarsdec not available via Homebrew"
+  if ! cmd_exists acarsdec; then
+    (brew_install acarsdec) || install_acarsdec_from_source_macos || warn "acarsdec not available"
+  else
+    ok "acarsdec already installed"
+  fi
 
   progress "Installing AIS-catcher"
   if ! cmd_exists AIS-catcher && ! cmd_exists aiscatcher; then
-    (brew_install aiscatcher) || warn "AIS-catcher not available via Homebrew"
+    (brew_install aiscatcher) || install_aiscatcher_from_source_macos || warn "AIS-catcher not available"
   else
     ok "AIS-catcher already installed"
   fi
@@ -478,6 +732,19 @@ install_macos_packages() {
   progress "Installing gpsd"
   brew_install gpsd
 
+  progress "Installing Ubertooth tools (optional)"
+  if ! cmd_exists ubertooth-btle; then
+    echo
+    info "Ubertooth is used for advanced Bluetooth packet sniffing with Ubertooth One hardware."
+    if ask_yes_no "Do you want to install Ubertooth tools?"; then
+      brew_install ubertooth || warn "Ubertooth not available via Homebrew"
+    else
+      warn "Skipping Ubertooth installation. You can install it later if needed."
+    fi
+  else
+    ok "Ubertooth already installed"
+  fi
+
   warn "macOS note: hcitool/hciconfig are Linux (BlueZ) utilities and often unavailable on macOS."
   info "TSCM BLE scanning uses bleak library (installed via pip) for manufacturer data detection."
   echo
@@ -536,6 +803,8 @@ install_dump1090_from_source_debian() {
       || { fail "Failed to clone FlightAware dump1090"; exit 1; }
 
     cd "$tmp_dir/dump1090"
+    # Remove -Werror to prevent build failures on newer GCC versions
+    sed -i 's/-Werror//g' Makefile 2>/dev/null || sed -i '' 's/-Werror//g' Makefile
     info "Compiling FlightAware dump1090..."
     if make BLADERF=no RTLSDR=yes >/dev/null 2>&1; then
       $SUDO install -m 0755 dump1090 /usr/local/bin/dump1090
@@ -543,17 +812,17 @@ install_dump1090_from_source_debian() {
       exit 0
     fi
 
-    warn "FlightAware build failed. Falling back to antirez/dump1090..."
+    warn "FlightAware build failed. Falling back to wiedehopf/readsb..."
     rm -rf "$tmp_dir/dump1090"
-    git clone --depth 1 https://github.com/antirez/dump1090.git "$tmp_dir/dump1090" >/dev/null 2>&1 \
-      || { fail "Failed to clone antirez dump1090"; exit 1; }
+    git clone --depth 1 https://github.com/wiedehopf/readsb.git "$tmp_dir/dump1090" >/dev/null 2>&1 \
+      || { fail "Failed to clone wiedehopf/readsb"; exit 1; }
 
     cd "$tmp_dir/dump1090"
-    info "Compiling antirez dump1090..."
-    make >/dev/null 2>&1 || { fail "Failed to build dump1090 from source (required)."; exit 1; }
+    info "Compiling readsb..."
+    make RTLSDR=yes >/dev/null 2>&1 || { fail "Failed to build readsb from source (required)."; exit 1; }
 
-    $SUDO install -m 0755 dump1090 /usr/local/bin/dump1090
-    ok "dump1090 installed successfully (antirez)."
+    $SUDO install -m 0755 readsb /usr/local/bin/dump1090
+    ok "dump1090 installed successfully (via readsb)."
   )
 }
 
@@ -613,6 +882,65 @@ install_aiscatcher_from_source_debian() {
   )
 }
 
+install_slowrx_from_source_debian() {
+  info "slowrx not available via APT. Building from source..."
+
+  # slowrx uses a simple Makefile, not CMake
+  apt_install build-essential git pkg-config \
+    libfftw3-dev libsndfile1-dev libgtk-3-dev libasound2-dev libpulse-dev
+
+  # Run in subshell to isolate EXIT trap
+  (
+    tmp_dir="$(mktemp -d)"
+    trap 'rm -rf "$tmp_dir"' EXIT
+
+    info "Cloning slowrx..."
+    git clone --depth 1 https://github.com/windytan/slowrx.git "$tmp_dir/slowrx" >/dev/null 2>&1 \
+      || { warn "Failed to clone slowrx"; exit 1; }
+
+    cd "$tmp_dir/slowrx"
+
+    info "Compiling slowrx..."
+    local make_log
+    make_log=$(make 2>&1) || {
+      warn "make failed for slowrx:"
+      echo "$make_log" | tail -20
+      warn "ISS SSTV decoding will not be available."
+      exit 1
+    }
+    $SUDO install -m 0755 slowrx /usr/local/bin/slowrx
+    ok "slowrx installed successfully."
+  )
+}
+
+install_ubertooth_from_source_debian() {
+  info "Building Ubertooth from source..."
+
+  apt_install build-essential git cmake libusb-1.0-0-dev pkg-config libbluetooth-dev
+
+  # Run in subshell to isolate EXIT trap
+  (
+    tmp_dir="$(mktemp -d)"
+    trap 'rm -rf "$tmp_dir"' EXIT
+
+    info "Cloning Ubertooth..."
+    git clone --depth 1 https://github.com/greatscottgadgets/ubertooth.git "$tmp_dir/ubertooth" >/dev/null 2>&1 \
+      || { warn "Failed to clone Ubertooth"; exit 1; }
+
+    cd "$tmp_dir/ubertooth/host"
+    mkdir -p build && cd build
+
+    info "Compiling Ubertooth..."
+    if cmake .. >/dev/null 2>&1 && make >/dev/null 2>&1; then
+      $SUDO make install >/dev/null 2>&1
+      $SUDO ldconfig
+      ok "Ubertooth installed successfully from source."
+    else
+      warn "Failed to build Ubertooth from source."
+    fi
+  )
+}
+
 install_rtlsdr_blog_drivers_debian() {
   # The RTL-SDR Blog drivers provide better support for:
   # - RTL-SDR Blog V4 (R828D tuner)
@@ -720,7 +1048,7 @@ install_debian_packages() {
     export NEEDRESTART_MODE=a
   fi
 
-  TOTAL_STEPS=19
+  TOTAL_STEPS=22
   CURRENT_STEP=0
 
   progress "Updating APT package lists"
@@ -764,19 +1092,9 @@ install_debian_packages() {
 
   progress "RTL-SDR Blog drivers"
   if cmd_exists rtl_test; then
-    info "RTL-SDR tools already installed."
-    if $IS_DRAGONOS; then
-      info "Skipping RTL-SDR Blog driver installation (DragonOS has working drivers)."
-    else
-      echo "RTL-SDR Blog drivers provide improved support for V4 dongles."
-      echo "Installing these will REPLACE your current RTL-SDR drivers."
-      if ask_yes_no "Install RTL-SDR Blog drivers?"; then
-        install_rtlsdr_blog_drivers_debian
-      else
-        ok "Keeping existing RTL-SDR drivers."
-      fi
-    fi
+    ok "RTL-SDR drivers already installed"
   else
+    info "RTL-SDR drivers not found, installing RTL-SDR Blog drivers..."
     install_rtlsdr_blog_drivers_debian
   fi
 
@@ -786,6 +1104,22 @@ install_debian_packages() {
   progress "Installing direwolf (APRS decoder)"
   apt_install direwolf || true
 
+  progress "Installing slowrx (SSTV decoder)"
+  apt_install slowrx || cmd_exists slowrx || install_slowrx_from_source_debian || warn "slowrx not available. ISS SSTV decoding will not be available."
+
+  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
 
@@ -818,6 +1152,19 @@ install_debian_packages() {
   progress "Installing Bluetooth tools"
   apt_install bluez bluetooth || true
 
+  progress "Installing Ubertooth tools (optional)"
+  if ! cmd_exists ubertooth-btle; then
+    echo
+    info "Ubertooth is used for advanced Bluetooth packet sniffing with Ubertooth One hardware."
+    if ask_yes_no "Do you want to install Ubertooth tools?"; then
+      apt_install libubertooth-dev ubertooth || install_ubertooth_from_source_debian
+    else
+      warn "Skipping Ubertooth installation. You can install it later if needed."
+    fi
+  else
+    ok "Ubertooth already installed"
+  fi
+
   progress "Installing SoapySDR"
   # Exclude xtrx-dkms - its kernel module fails to build on newer kernels (6.14+)
   # and causes apt to hang. Most users don't have XTRX hardware anyway.
@@ -862,11 +1209,12 @@ install_debian_packages() {
   setup_udev_rules_debian
 
   progress "Kernel driver configuration"
-  echo
   if $IS_DRAGONOS; then
     info "DragonOS already has RTL-SDR drivers configured correctly."
-    info "Skipping kernel driver blacklist (not needed)."
+  elif [[ -f /etc/modprobe.d/blacklist-rtlsdr.conf ]]; then
+    ok "DVB kernel drivers already blacklisted"
   else
+    echo
     echo "The DVB-T kernel drivers conflict with RTL-SDR userspace access."
     echo "Blacklisting them allows rtl_sdr tools to access the device."
     if ask_yes_no "Blacklist conflicting kernel drivers?"; then
@@ -956,3 +1304,7 @@ main() {
 }
 
 main "$@"
+
+# Clear traps before exiting to prevent spurious errors during cleanup
+trap - ERR EXIT
+exit 0

static/css/adsb_dashboard.css

@@ -5,27 +5,30 @@
 }
 
 :root {
-    --bg-dark: #0a0c10;
-    --bg-panel: #0f1218;
-    --bg-card: #151a23;
-    --border-color: #1f2937;
-    --border-glow: #4a9eff;
-    --text-primary: #e8eaed;
-    --text-secondary: #9ca3af;
-    --text-dim: #4b5563;
-    --accent-green: #22c55e;
-    --accent-cyan: #4a9eff;
-    --accent-orange: #f59e0b;
-    --accent-red: #ef4444;
-    --accent-yellow: #eab308;
-    --accent-amber: #d4a853;
-    --grid-line: rgba(74, 158, 255, 0.08);
-    --radar-cyan: #4a9eff;
-    --radar-bg: #0f1218;
+    --font-sans: 'IBM Plex Mono', 'Space Mono', ui-monospace, 'SF Mono', 'Consolas', 'Menlo', monospace;
+    --font-mono: 'IBM Plex Mono', 'Space Mono', ui-monospace, 'SF Mono', 'Consolas', 'Menlo', monospace;
+    --bg-dark: #0b1118;
+    --bg-panel: #101823;
+    --bg-card: #151f2b;
+    --border-color: #263246;
+    --border-glow: #4aa3ff;
+    --text-primary: #d7e0ee;
+    --text-secondary: #9fb0c7;
+    --text-dim: #6f7f94;
+    --accent-green: #38c180;
+    --accent-cyan: #4aa3ff;
+    --accent-orange: #d6a85e;
+    --accent-red: #e25d5d;
+    --accent-yellow: #e1c26b;
+    --accent-amber: #d6a85e;
+    --grid-line: rgba(74, 163, 255, 0.1);
+    --noise-image: url("data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20width='40'%20height='40'%20viewBox='0%200%2040%2040'%3E%3Cg%20fill='%23ffffff'%20fill-opacity='0.05'%3E%3Ccircle%20cx='3'%20cy='5'%20r='1'/%3E%3Ccircle%20cx='11'%20cy='9'%20r='1'/%3E%3Ccircle%20cx='18'%20cy='3'%20r='1'/%3E%3Ccircle%20cx='26'%20cy='12'%20r='1'/%3E%3Ccircle%20cx='34'%20cy='6'%20r='1'/%3E%3Ccircle%20cx='7'%20cy='19'%20r='1'/%3E%3Ccircle%20cx='15'%20cy='24'%20r='1'/%3E%3Ccircle%20cx='28'%20cy='22'%20r='1'/%3E%3Ccircle%20cx='36'%20cy='18'%20r='1'/%3E%3Ccircle%20cx='5'%20cy='33'%20r='1'/%3E%3Ccircle%20cx='19'%20cy='32'%20r='1'/%3E%3Ccircle%20cx='31'%20cy='34'%20r='1'/%3E%3C/g%3E%3C/svg%3E");
+    --radar-cyan: #4aa3ff;
+    --radar-bg: #101823;
 }
 
 body {
-    font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif;
+    font-family: var(--font-sans);
     background: var(--bg-dark);
     color: var(--text-primary);
     min-height: 100vh;
@@ -40,9 +43,10 @@ body {
     right: 0;
     bottom: 0;
     background-image:
+        var(--noise-image),
         linear-gradient(var(--grid-line) 1px, transparent 1px),
         linear-gradient(90deg, var(--grid-line) 1px, transparent 1px);
-    background-size: 50px 50px;
+    background-size: 40px 40px, 50px 50px, 50px 50px;
     pointer-events: none;
     z-index: 0;
 }
@@ -55,10 +59,12 @@ body {
     right: 0;
     height: 2px;
     background: linear-gradient(90deg, transparent, var(--accent-cyan), transparent);
+    color: var(--accent-cyan);
     animation: scan 6s linear infinite;
     pointer-events: none;
     z-index: 1000;
-    opacity: 0.3;
+    opacity: 0.25;
+    box-shadow: 0 0 8px currentColor;
 }
 
 @keyframes scan {
@@ -71,7 +77,7 @@ body {
     }
 }
 
-/* Header - Mobile first */
+/* Header */
 .header {
     position: relative;
     z-index: 10;
@@ -81,20 +87,31 @@ body {
     display: flex;
     justify-content: space-between;
     align-items: center;
-    flex-wrap: wrap;
-    gap: 8px;
+    flex-wrap: nowrap;
+    gap: 12px;
     min-height: 52px;
 }
 
+.header::after {
+    content: '';
+    position: absolute;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    height: 2px;
+    background: linear-gradient(90deg, transparent, var(--accent-cyan), transparent);
+    opacity: 0.6;
+    pointer-events: none;
+}
+
 @media (min-width: 768px) {
     .header {
         padding: 12px 20px;
-        flex-wrap: nowrap;
     }
 }
 
 .logo {
-    font-family: 'Inter', sans-serif;
+    font-family: var(--font-sans);
     font-size: 16px;
     font-weight: 700;
     letter-spacing: 2px;
@@ -126,14 +143,52 @@ body {
         letter-spacing: 2px;
     }
 }
-}
 
 .status-bar {
     display: flex;
-    gap: 20px;
+    gap: 12px;
     align-items: center;
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 11px;
+    flex-wrap: nowrap;
+}
+
+.agent-selector-compact {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+}
+
+.agent-selector-compact .agent-select-sm {
+    padding: 4px 8px;
+    background: var(--bg-card);
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+    color: var(--text-primary);
+    font-size: 11px;
+    font-family: var(--font-mono);
+}
+
+.agent-selector-compact .agent-status-dot {
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+    background: var(--accent-green);
+    box-shadow: 0 0 6px var(--accent-green);
+}
+
+.agent-selector-compact .agent-status-dot.offline {
+    background: var(--accent-red);
+    box-shadow: 0 0 6px var(--accent-red);
+}
+
+.agent-selector-compact .show-all-label {
+    display: flex;
+    align-items: center;
+    gap: 4px;
+    font-size: 11px;
+    color: var(--text-secondary);
+    cursor: pointer;
 }
 
 .status-dot {
@@ -172,15 +227,15 @@ body {
 }
 
 /* Main dashboard grid - Mobile first */
-/* Header ~55px + Stats strip ~36px = ~91px, using 95px for safety */
+/* Header ~52px + Nav 44px + Stats strip ~55px = ~151px, using 160px for safety */
 .dashboard {
     position: relative;
     z-index: 10;
     display: flex;
     flex-direction: column;
     gap: 0;
-    height: calc(100dvh - 95px);
-    height: calc(100vh - 95px); /* Fallback */
+    height: calc(100dvh - 160px);
+    height: calc(100vh - 160px); /* Fallback */
     min-height: 400px;
 }
 
@@ -216,7 +271,7 @@ body {
 @media (min-width: 1024px) {
     .acars-sidebar {
         display: flex;
-        max-height: calc(100dvh - 95px);
+        max-height: calc(100dvh - 160px);
     }
 }
 
@@ -624,7 +679,7 @@ body {
 }
 
 .telemetry-value {
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 12px;
     color: var(--accent-cyan);
 }
@@ -680,7 +735,7 @@ body {
 }
 
 .aircraft-icao {
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 9px;
     color: var(--text-secondary);
     background: rgba(74, 158, 255, 0.1);
@@ -700,7 +755,7 @@ body {
 }
 
 .aircraft-detail-value {
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     color: var(--accent-cyan);
     font-size: 11px;
 }
@@ -716,14 +771,31 @@ body {
     grid-column: 1 / -1;
     grid-row: 2;
     display: flex;
-    align-items: center;
+    align-items: stretch !important;
     flex-wrap: nowrap;
     gap: 8px;
     padding: 8px 15px;
     background: var(--bg-panel);
     border-top: 1px solid rgba(74, 158, 255, 0.3);
     font-size: 11px;
-    overflow-x: auto;
+    overflow: hidden;
+}
+
+.controls-bar > .control-group {
+    flex: 0 0 auto;
+    display: flex;
+    flex-direction: column;
+    justify-content: flex-start;
+    align-items: flex-start;
+    gap: 4px;
+    padding: 6px 10px;
+    background: rgba(74, 158, 255, 0.03);
+    border: 1px solid rgba(74, 158, 255, 0.1);
+    border-radius: 6px;
+}
+
+.controls-bar > .control-group > .control-group-items {
+    margin-top: auto;
 }
 
 .controls-bar label {
@@ -790,7 +862,7 @@ body {
     border: 1px solid rgba(74, 158, 255, 0.3);
     border-radius: 4px;
     color: var(--accent-cyan);
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 10px;
 }
 
@@ -801,7 +873,7 @@ body {
     border: 1px solid rgba(74, 158, 255, 0.3);
     border-radius: 4px;
     color: var(--accent-cyan);
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 10px;
 }
 
@@ -814,6 +886,24 @@ body {
     color: var(--accent-green);
 }
 
+/* Bias-T toggle styling */
+.bias-t-label {
+    display: flex;
+    align-items: center;
+    gap: 4px;
+    padding: 3px 8px;
+    background: linear-gradient(90deg, rgba(255, 100, 0, 0.15), rgba(255, 100, 0, 0.05));
+    border: 1px solid var(--accent-orange, #ff6400);
+    border-radius: 4px;
+    color: var(--accent-orange, #ff6400);
+    font-weight: 500;
+    font-size: 10px;
+}
+
+.bias-t-label input[type="checkbox"] {
+    accent-color: var(--accent-orange, #ff6400);
+}
+
 .control-group.airband-group {
     background: rgba(245, 158, 11, 0.05);
     border-color: rgba(245, 158, 11, 0.2);
@@ -861,7 +951,7 @@ body {
     border: none;
     background: var(--accent-green);
     color: #fff;
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 10px;
     font-weight: 600;
     text-transform: uppercase;
@@ -893,7 +983,7 @@ body {
     border: 1px solid rgba(74, 158, 255, 0.3);
     border-radius: 4px;
     color: var(--accent-cyan);
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 10px;
     cursor: pointer;
 }
@@ -903,10 +993,7 @@ body {
     background: var(--bg-dark) !important;
 }
 
-.leaflet-tile-pane,
-.leaflet-container .leaflet-tile-pane {
-    filter: invert(1) hue-rotate(180deg) brightness(0.8) contrast(1.2) !important;
-}
+/* Using actual dark tiles now - no filter needed */
 
 .leaflet-control-zoom a {
     background: var(--bg-panel) !important;
@@ -1008,7 +1095,7 @@ body {
     cursor: pointer;
     font-size: 11px;
     font-weight: 600;
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     display: flex;
     align-items: center;
     gap: 5px;
@@ -1042,7 +1129,7 @@ body {
 }
 
 .airband-status {
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 10px;
     padding: 0 8px;
     color: var(--text-muted);
@@ -1146,6 +1233,55 @@ body {
     50% { opacity: 0.5; transform: scale(0.8); }
 }
 
+/* ============================================
+   TRACKED AIRCRAFT PULSATING RING
+   ============================================ */
+.aircraft-marker.selected {
+    position: relative;
+}
+
+.tracking-ring {
+    position: absolute;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+    width: 40px;
+    height: 40px;
+    border: 2px solid var(--accent-cyan);
+    border-radius: 50%;
+    animation: tracking-pulse 1.5s ease-out infinite;
+    pointer-events: none;
+}
+
+.tracking-ring-inner {
+    position: absolute;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+    width: 28px;
+    height: 28px;
+    border: 1px solid var(--accent-cyan);
+    border-radius: 50%;
+    animation: tracking-pulse 1.5s ease-out infinite 0.3s;
+    pointer-events: none;
+}
+
+@keyframes tracking-pulse {
+    0% {
+        transform: translate(-50%, -50%) scale(0.8);
+        opacity: 1;
+        border-color: rgba(74, 158, 255, 1);
+    }
+    50% {
+        opacity: 0.6;
+    }
+    100% {
+        transform: translate(-50%, -50%) scale(1.8);
+        opacity: 0;
+        border-color: rgba(74, 158, 255, 0);
+    }
+}
+
 /* ============== MOBILE/TABLET FIXES ============== */
 @media (max-width: 1023px) {
     /* Dashboard - allow scrolling */
@@ -1153,7 +1289,7 @@ body {
         display: flex !important;
         flex-direction: column !important;
         height: auto !important;
-        min-height: calc(100dvh - 95px);
+        min-height: calc(100dvh - 160px);
         overflow-y: auto !important;
         overflow-x: hidden;
         -webkit-overflow-scrolling: touch;
@@ -1222,12 +1358,6 @@ body {
         padding: 6px 8px;
     }
 
-    /* Status bar - compact on mobile */
-    .status-bar {
-        flex-wrap: wrap;
-        gap: 6px;
-    }
-
     /* Strip time smaller on mobile */
     .strip-time {
         font-size: 10px;
@@ -1343,7 +1473,7 @@ body {
 }
 
 .strip-value {
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 14px;
     font-weight: 600;
     color: var(--accent-cyan);
@@ -1369,7 +1499,7 @@ body {
 }
 
 .strip-report-btn {
-    background: linear-gradient(135deg, var(--accent-cyan) 0%, #2563eb 100%);
+    background: linear-gradient(135deg, var(--accent-cyan) 0%, #2b6fb8 100%);
     border: none;
     color: white;
     padding: 8px 12px;
@@ -1481,7 +1611,7 @@ body {
 
 .report-grid span:nth-child(even) {
     color: var(--text-primary);
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
 }
 
 .report-highlights {
@@ -1672,7 +1802,7 @@ body {
 }
 
 .strip-btn.primary {
-    background: linear-gradient(135deg, var(--accent-cyan) 0%, #2563eb 100%);
+    background: linear-gradient(135deg, var(--accent-cyan) 0%, #2b6fb8 100%);
     border: none;
     color: white;
 }
@@ -1710,11 +1840,17 @@ body {
     box-shadow: 0 0 10px var(--accent-red);
 }
 
+.strip-status .status-dot.warn {
+    background: var(--accent-yellow, #ffcc00);
+    box-shadow: 0 0 10px var(--accent-yellow, #ffcc00);
+    animation: pulse 1.5s ease-in-out infinite;
+}
+
 .strip-time {
     font-size: 11px;
     font-weight: 500;
     color: var(--accent-cyan);
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     padding-left: 8px;
     border-left: 1px solid rgba(74, 158, 255, 0.2);
     white-space: nowrap;
@@ -1868,7 +2004,7 @@ body {
 }
 
 .squawk-code {
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-weight: 700;
     color: var(--accent-cyan);
     font-size: 12px;

static/css/adsb_history.css

@@ -5,38 +5,42 @@
 }
 
 :root {
-    --bg-dark: #0a0c10;
-    --bg-panel: #0f1218;
-    --bg-card: #141a24;
-    --border-color: #1f2937;
-    --border-glow: rgba(74, 158, 255, 0.6);
-    --text-primary: #e8eaed;
-    --text-secondary: #9ca3af;
-    --text-dim: #4b5563;
-    --accent-cyan: #4a9eff;
-    --accent-green: #22c55e;
-    --accent-amber: #d4a853;
-    --grid-line: rgba(74, 158, 255, 0.08);
+    --font-sans: 'IBM Plex Mono', 'Space Mono', ui-monospace, 'SF Mono', 'Consolas', 'Menlo', monospace;
+    --font-mono: 'IBM Plex Mono', 'Space Mono', ui-monospace, 'SF Mono', 'Consolas', 'Menlo', monospace;
+    --bg-dark: #0b1118;
+    --bg-panel: #101823;
+    --bg-card: #151f2b;
+    --border-color: #263246;
+    --border-glow: rgba(74, 163, 255, 0.4);
+    --text-primary: #d7e0ee;
+    --text-secondary: #9fb0c7;
+    --text-dim: #6f7f94;
+    --accent-cyan: #4aa3ff;
+    --accent-green: #38c180;
+    --accent-amber: #d6a85e;
+    --grid-line: rgba(74, 163, 255, 0.1);
+    --noise-image: url("data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20width='40'%20height='40'%20viewBox='0%200%2040%2040'%3E%3Cg%20fill='%23ffffff'%20fill-opacity='0.05'%3E%3Ccircle%20cx='3'%20cy='5'%20r='1'/%3E%3Ccircle%20cx='11'%20cy='9'%20r='1'/%3E%3Ccircle%20cx='18'%20cy='3'%20r='1'/%3E%3Ccircle%20cx='26'%20cy='12'%20r='1'/%3E%3Ccircle%20cx='34'%20cy='6'%20r='1'/%3E%3Ccircle%20cx='7'%20cy='19'%20r='1'/%3E%3Ccircle%20cx='15'%20cy='24'%20r='1'/%3E%3Ccircle%20cx='28'%20cy='22'%20r='1'/%3E%3Ccircle%20cx='36'%20cy='18'%20r='1'/%3E%3Ccircle%20cx='5'%20cy='33'%20r='1'/%3E%3Ccircle%20cx='19'%20cy='32'%20r='1'/%3E%3Ccircle%20cx='31'%20cy='34'%20r='1'/%3E%3C/g%3E%3C/svg%3E");
 }
 
 body {
-    font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif;
+    font-family: var(--font-sans);
     background: var(--bg-dark);
     color: var(--text-primary);
     min-height: 100vh;
 }
 
 .mono {
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
 }
 
 .radar-bg {
     position: fixed;
     inset: 0;
     background-image:
+        var(--noise-image),
         linear-gradient(var(--grid-line) 1px, transparent 1px),
         linear-gradient(90deg, var(--grid-line) 1px, transparent 1px);
-    background-size: 50px 50px;
+    background-size: 40px 40px, 50px 50px, 50px 50px;
     pointer-events: none;
     z-index: 0;
 }
@@ -48,10 +52,12 @@ body {
     right: 0;
     height: 2px;
     background: linear-gradient(90deg, transparent, var(--accent-cyan), transparent);
+    color: var(--accent-cyan);
     animation: scan 6s linear infinite;
     pointer-events: none;
     z-index: 1;
-    opacity: 0.3;
+    opacity: 0.25;
+    box-shadow: 0 0 8px currentColor;
 }
 
 @keyframes scan {
@@ -72,6 +78,18 @@ body {
     gap: 12px;
 }
 
+.header::after {
+    content: '';
+    position: absolute;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    height: 2px;
+    background: linear-gradient(90deg, transparent, var(--accent-cyan), transparent);
+    opacity: 0.6;
+    pointer-events: none;
+}
+
 .logo {
     font-size: 18px;
     font-weight: 700;
@@ -91,7 +109,7 @@ body {
     display: flex;
     align-items: center;
     gap: 12px;
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 11px;
 }
 
@@ -268,7 +286,7 @@ body {
 }
 
 .status-pill {
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 11px;
     padding: 8px 12px;
     border-radius: 999px;
@@ -306,7 +324,7 @@ body {
 }
 
 .panel-meta {
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 11px;
     color: var(--accent-cyan);
 }
@@ -347,7 +365,7 @@ body {
 }
 
 .mono {
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
 }
 
 .empty-row td,

static/css/agents.css

@@ -0,0 +1,331 @@
+/*
+ * Agents Management CSS
+ * Styles for the remote agent management interface
+ * Inherits CSS variables from core/variables.css
+ */
+
+/* Agent indicator in navigation */
+.agent-indicator {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    padding: 6px 12px;
+    background: rgba(0, 212, 255, 0.1);
+    border: 1px solid rgba(0, 212, 255, 0.3);
+    border-radius: 20px;
+    cursor: pointer;
+    transition: all 0.2s;
+}
+
+.agent-indicator:hover {
+    background: rgba(0, 212, 255, 0.2);
+    border-color: var(--accent-cyan);
+}
+
+.agent-indicator-dot {
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+    background: var(--accent-green);
+    box-shadow: 0 0 6px var(--accent-green);
+}
+
+.agent-indicator-dot.remote {
+    background: var(--accent-cyan);
+    box-shadow: 0 0 6px var(--accent-cyan);
+}
+
+.agent-indicator-dot.multiple {
+    background: var(--accent-orange);
+    box-shadow: 0 0 6px var(--accent-orange);
+}
+
+.agent-indicator-label {
+    font-size: 11px;
+    color: var(--text-primary);
+    font-family: var(--font-mono);
+}
+
+.agent-indicator-count {
+    font-size: 10px;
+    padding: 2px 6px;
+    background: rgba(0, 212, 255, 0.2);
+    border-radius: 10px;
+    color: var(--accent-cyan);
+}
+
+/* Agent selector dropdown */
+.agent-selector {
+    position: relative;
+}
+
+.agent-selector-dropdown {
+    position: absolute;
+    top: 100%;
+    right: 0;
+    margin-top: 8px;
+    min-width: 280px;
+    background: var(--bg-secondary);
+    border: 1px solid var(--border-color);
+    border-radius: 8px;
+    box-shadow: 0 4px 20px rgba(0, 0, 0, 0.5);
+    z-index: 1000;
+    display: none;
+}
+
+.agent-selector-dropdown.show {
+    display: block;
+}
+
+.agent-selector-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 12px 15px;
+    border-bottom: 1px solid var(--border-color);
+}
+
+.agent-selector-header h4 {
+    margin: 0;
+    font-size: 12px;
+    color: var(--accent-cyan);
+    text-transform: uppercase;
+    letter-spacing: 1px;
+}
+
+.agent-selector-manage {
+    font-size: 11px;
+    color: var(--accent-cyan);
+    text-decoration: none;
+}
+
+.agent-selector-manage:hover {
+    text-decoration: underline;
+}
+
+.agent-selector-list {
+    max-height: 300px;
+    overflow-y: auto;
+}
+
+.agent-selector-item {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    padding: 10px 15px;
+    cursor: pointer;
+    transition: background 0.2s;
+    border-bottom: 1px solid var(--border-color);
+}
+
+.agent-selector-item:last-child {
+    border-bottom: none;
+}
+
+.agent-selector-item:hover {
+    background: rgba(0, 212, 255, 0.1);
+}
+
+.agent-selector-item.selected {
+    background: rgba(0, 212, 255, 0.15);
+    border-left: 3px solid var(--accent-cyan);
+}
+
+.agent-selector-item.local {
+    border-left: 3px solid var(--accent-green);
+}
+
+.agent-selector-item-status {
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+    flex-shrink: 0;
+}
+
+.agent-selector-item-status.online {
+    background: var(--accent-green);
+}
+
+.agent-selector-item-status.offline {
+    background: var(--accent-red);
+}
+
+.agent-selector-item-info {
+    flex: 1;
+    min-width: 0;
+}
+
+.agent-selector-item-name {
+    font-size: 13px;
+    color: var(--text-primary);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.agent-selector-item-url {
+    font-size: 10px;
+    color: var(--text-secondary);
+    font-family: var(--font-mono);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.agent-selector-item-check {
+    color: var(--accent-green);
+    opacity: 0;
+}
+
+.agent-selector-item.selected .agent-selector-item-check {
+    opacity: 1;
+}
+
+/* Agent badge in data displays */
+.agent-badge {
+    display: inline-flex;
+    align-items: center;
+    gap: 4px;
+    padding: 2px 8px;
+    font-size: 10px;
+    background: rgba(0, 212, 255, 0.1);
+    color: var(--accent-cyan);
+    border-radius: 10px;
+    font-family: var(--font-mono);
+}
+
+.agent-badge.local,
+.agent-badge.agent-local {
+    background: rgba(0, 255, 136, 0.1);
+    color: var(--accent-green);
+}
+
+.agent-badge.agent-remote {
+    background: rgba(0, 212, 255, 0.1);
+    color: var(--accent-cyan);
+}
+
+/* WiFi table agent column */
+.wifi-networks-table .col-agent {
+    width: 100px;
+    text-align: center;
+}
+
+.wifi-networks-table th.col-agent {
+    font-size: 10px;
+}
+
+/* Bluetooth table agent column */
+.bt-devices-table .col-agent {
+    width: 100px;
+    text-align: center;
+}
+
+.agent-badge-dot {
+    width: 6px;
+    height: 6px;
+    border-radius: 50%;
+    background: currentColor;
+}
+
+/* Agent column in data tables */
+.data-table .agent-col {
+    width: 120px;
+    max-width: 120px;
+}
+
+/* Multi-agent stream indicator */
+.multi-agent-indicator {
+    position: fixed;
+    bottom: 20px;
+    left: 20px;
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    padding: 8px 12px;
+    background: var(--bg-secondary);
+    border: 1px solid var(--border-color);
+    border-radius: 20px;
+    font-size: 11px;
+    color: var(--text-secondary);
+    z-index: 100;
+}
+
+.multi-agent-indicator.active {
+    border-color: var(--accent-cyan);
+    color: var(--accent-cyan);
+}
+
+.multi-agent-indicator-pulse {
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+    background: var(--accent-cyan);
+    animation: pulse 2s infinite;
+}
+
+@keyframes pulse {
+    0%, 100% { opacity: 1; transform: scale(1); }
+    50% { opacity: 0.5; transform: scale(0.8); }
+}
+
+/* Agent connection status toast */
+.agent-toast {
+    position: fixed;
+    top: 80px;
+    right: 20px;
+    padding: 10px 15px;
+    background: var(--bg-secondary);
+    border: 1px solid var(--border-color);
+    border-radius: 6px;
+    font-size: 12px;
+    z-index: 1001;
+    animation: slideInRight 0.3s ease;
+}
+
+.agent-toast.connected {
+    border-color: var(--accent-green);
+    color: var(--accent-green);
+}
+
+.agent-toast.disconnected {
+    border-color: var(--accent-red);
+    color: var(--accent-red);
+}
+
+@keyframes slideInRight {
+    from {
+        transform: translateX(100%);
+        opacity: 0;
+    }
+    to {
+        transform: translateX(0);
+        opacity: 1;
+    }
+}
+
+/* Responsive adjustments */
+@media (max-width: 768px) {
+    .agent-indicator {
+        padding: 4px 8px;
+    }
+
+    .agent-indicator-label {
+        display: none;
+    }
+
+    .agent-selector-dropdown {
+        position: fixed;
+        top: auto;
+        bottom: 0;
+        left: 0;
+        right: 0;
+        margin: 0;
+        border-radius: 16px 16px 0 0;
+        max-height: 60vh;
+    }
+
+    .agents-grid {
+        grid-template-columns: 1fr;
+    }
+}

static/css/ais_dashboard.css

@@ -8,27 +8,30 @@
 }
 
 :root {
-    --bg-dark: #0a0c10;
-    --bg-panel: #0f1218;
-    --bg-card: #151a23;
-    --border-color: #1f2937;
-    --border-glow: #4a9eff;
-    --text-primary: #e8eaed;
-    --text-secondary: #9ca3af;
-    --text-dim: #4b5563;
-    --accent-green: #22c55e;
-    --accent-cyan: #4a9eff;
-    --accent-orange: #f59e0b;
-    --accent-red: #ef4444;
-    --accent-yellow: #eab308;
-    --accent-amber: #d4a853;
-    --grid-line: rgba(74, 158, 255, 0.08);
-    --radar-cyan: #4a9eff;
-    --radar-bg: #0f1218;
+    --font-sans: 'IBM Plex Mono', 'Space Mono', ui-monospace, 'SF Mono', 'Consolas', 'Menlo', monospace;
+    --font-mono: 'IBM Plex Mono', 'Space Mono', ui-monospace, 'SF Mono', 'Consolas', 'Menlo', monospace;
+    --bg-dark: #0b1118;
+    --bg-panel: #101823;
+    --bg-card: #151f2b;
+    --border-color: #263246;
+    --border-glow: #4aa3ff;
+    --text-primary: #d7e0ee;
+    --text-secondary: #9fb0c7;
+    --text-dim: #6f7f94;
+    --accent-green: #38c180;
+    --accent-cyan: #4aa3ff;
+    --accent-orange: #d6a85e;
+    --accent-red: #e25d5d;
+    --accent-yellow: #e1c26b;
+    --accent-amber: #d6a85e;
+    --grid-line: rgba(74, 163, 255, 0.1);
+    --noise-image: url("data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20width='40'%20height='40'%20viewBox='0%200%2040%2040'%3E%3Cg%20fill='%23ffffff'%20fill-opacity='0.05'%3E%3Ccircle%20cx='3'%20cy='5'%20r='1'/%3E%3Ccircle%20cx='11'%20cy='9'%20r='1'/%3E%3Ccircle%20cx='18'%20cy='3'%20r='1'/%3E%3Ccircle%20cx='26'%20cy='12'%20r='1'/%3E%3Ccircle%20cx='34'%20cy='6'%20r='1'/%3E%3Ccircle%20cx='7'%20cy='19'%20r='1'/%3E%3Ccircle%20cx='15'%20cy='24'%20r='1'/%3E%3Ccircle%20cx='28'%20cy='22'%20r='1'/%3E%3Ccircle%20cx='36'%20cy='18'%20r='1'/%3E%3Ccircle%20cx='5'%20cy='33'%20r='1'/%3E%3Ccircle%20cx='19'%20cy='32'%20r='1'/%3E%3Ccircle%20cx='31'%20cy='34'%20r='1'/%3E%3C/g%3E%3C/svg%3E");
+    --radar-cyan: #4aa3ff;
+    --radar-bg: #101823;
 }
 
 body {
-    font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif;
+    font-family: var(--font-sans);
     background: var(--bg-dark);
     color: var(--text-primary);
     min-height: 100vh;
@@ -43,9 +46,10 @@ body {
     right: 0;
     bottom: 0;
     background-image:
+        var(--noise-image),
         linear-gradient(var(--grid-line) 1px, transparent 1px),
         linear-gradient(90deg, var(--grid-line) 1px, transparent 1px);
-    background-size: 50px 50px;
+    background-size: 40px 40px, 50px 50px, 50px 50px;
     pointer-events: none;
     z-index: 0;
 }
@@ -58,10 +62,12 @@ body {
     right: 0;
     height: 2px;
     background: linear-gradient(90deg, transparent, var(--accent-cyan), transparent);
+    color: var(--accent-cyan);
     animation: scan 6s linear infinite;
     pointer-events: none;
     z-index: 1000;
-    opacity: 0.3;
+    opacity: 0.25;
+    box-shadow: 0 0 8px currentColor;
 }
 
 @keyframes scan {
@@ -89,6 +95,18 @@ body {
     min-height: 52px;
 }
 
+.header::after {
+    content: '';
+    position: absolute;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    height: 2px;
+    background: linear-gradient(90deg, transparent, var(--accent-cyan), transparent);
+    opacity: 0.6;
+    pointer-events: none;
+}
+
 @media (min-width: 768px) {
     .header {
         padding: 12px 20px;
@@ -97,7 +115,7 @@ body {
 }
 
 .logo {
-    font-family: 'Inter', sans-serif;
+    font-family: var(--font-sans);
     font-size: 16px;
     font-weight: 700;
     letter-spacing: 2px;
@@ -132,10 +150,49 @@ body {
 
 .status-bar {
     display: flex;
-    gap: 20px;
+    gap: 12px;
     align-items: center;
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 11px;
+    flex-wrap: nowrap;
+}
+
+.agent-selector-compact {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+}
+
+.agent-selector-compact .agent-select-sm {
+    padding: 4px 8px;
+    background: var(--bg-card);
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+    color: var(--text-primary);
+    font-size: 11px;
+    font-family: var(--font-mono);
+}
+
+.agent-selector-compact .agent-status-dot {
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+    background: var(--accent-green);
+    box-shadow: 0 0 6px var(--accent-green);
+}
+
+.agent-selector-compact .agent-status-dot.offline {
+    background: var(--accent-red);
+    box-shadow: 0 0 6px var(--accent-red);
+}
+
+.agent-selector-compact .show-all-label {
+    display: flex;
+    align-items: center;
+    gap: 4px;
+    font-size: 11px;
+    color: var(--text-secondary);
+    cursor: pointer;
 }
 
 .back-link {
@@ -183,7 +240,7 @@ body {
 }
 
 .strip-value {
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 14px;
     font-weight: 600;
     color: var(--accent-cyan);
@@ -287,7 +344,7 @@ body {
     font-size: 11px;
     font-weight: 500;
     color: var(--accent-cyan);
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     padding-left: 8px;
     border-left: 1px solid rgba(74, 158, 255, 0.2);
     white-space: nowrap;
@@ -314,20 +371,21 @@ body {
 }
 
 .strip-btn.primary {
-    background: linear-gradient(135deg, var(--accent-cyan) 0%, #2563eb 100%);
+    background: linear-gradient(135deg, var(--accent-cyan) 0%, #2b6fb8 100%);
     border: none;
     color: white;
 }
 
 /* Main dashboard grid - Mobile first */
+/* Header ~52px + Nav 44px + Stats strip ~55px = ~151px, using 160px for safety */
 .dashboard {
     position: relative;
     z-index: 10;
     display: flex;
     flex-direction: column;
     gap: 0;
-    height: calc(100dvh - 95px);
-    height: calc(100vh - 95px);
+    height: calc(100dvh - 160px);
+    height: calc(100vh - 160px);
     min-height: 400px;
 }
 
@@ -367,13 +425,10 @@ body {
 /* Leaflet overrides - Dark map styling */
 .leaflet-container {
     background: var(--bg-dark) !important;
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
 }
 
-.leaflet-tile-pane,
-.leaflet-container .leaflet-tile-pane {
-    filter: invert(1) hue-rotate(180deg) brightness(0.8) contrast(1.2) !important;
-}
+/* Using actual dark tiles now - no filter needed */
 
 .leaflet-control-zoom a {
     background: var(--bg-panel) !important;
@@ -441,7 +496,7 @@ body {
     padding: 10px 15px;
     background: rgba(74, 158, 255, 0.05);
     border-bottom: 1px solid rgba(74, 158, 255, 0.1);
-    font-family: 'Orbitron', 'JetBrains Mono', monospace;
+    font-family: 'Orbitron', 'Space Mono', monospace;
     font-size: 11px;
     font-weight: 500;
     letter-spacing: 2px;
@@ -495,9 +550,8 @@ body {
 }
 
 .no-vessel-icon {
-    font-size: 36px;
     margin-bottom: 10px;
-    opacity: 0.5;
+    color: var(--accent-cyan);
 }
 
 .vessel-header {
@@ -508,11 +562,13 @@ body {
 }
 
 .vessel-icon {
-    font-size: 32px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
 }
 
 .vessel-name {
-    font-family: 'Orbitron', 'JetBrains Mono', monospace;
+    font-family: 'Orbitron', 'Space Mono', monospace;
     font-size: 16px;
     font-weight: 700;
     color: var(--accent-cyan);
@@ -520,7 +576,7 @@ body {
 }
 
 .vessel-mmsi {
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 10px;
     color: var(--text-secondary);
     background: rgba(74, 158, 255, 0.1);
@@ -550,7 +606,7 @@ body {
 }
 
 .detail-value {
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 12px;
     color: var(--accent-cyan);
 }
@@ -595,7 +651,10 @@ body {
 }
 
 .vessel-item-icon {
-    font-size: 20px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    width: 24px;
 }
 
 .vessel-item-info {
@@ -603,20 +662,20 @@ body {
 }
 
 .vessel-item-name {
-    font-family: 'Orbitron', 'JetBrains Mono', monospace;
+    font-family: 'Orbitron', 'Space Mono', monospace;
     font-size: 12px;
     font-weight: 600;
     color: var(--accent-cyan);
 }
 
 .vessel-item-type {
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 9px;
     color: var(--text-secondary);
 }
 
 .vessel-item-speed {
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 11px;
     color: var(--accent-cyan);
     text-align: right;
@@ -627,14 +686,31 @@ body {
     grid-column: 1 / -1;
     grid-row: 2;
     display: flex;
-    align-items: center;
+    align-items: stretch !important;
     flex-wrap: nowrap;
     gap: 8px;
     padding: 8px 15px;
     background: var(--bg-panel);
     border-top: 1px solid rgba(74, 158, 255, 0.3);
     font-size: 11px;
-    overflow-x: auto;
+    overflow: hidden;
+}
+
+.controls-bar > .control-group {
+    flex: 0 0 auto;
+    display: flex;
+    flex-direction: column;
+    justify-content: flex-start;
+    align-items: flex-start;
+    gap: 4px;
+    padding: 6px 10px;
+    background: rgba(74, 158, 255, 0.03);
+    border: 1px solid rgba(74, 158, 255, 0.1);
+    border-radius: 6px;
+}
+
+.controls-bar > .control-group > .control-group-items {
+    margin-top: auto;
 }
 
 .control-group {
@@ -686,7 +762,7 @@ body {
     border: 1px solid rgba(74, 158, 255, 0.3);
     border-radius: 4px;
     color: var(--accent-cyan);
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 10px;
 }
 
@@ -697,7 +773,7 @@ body {
     border: 1px solid rgba(74, 158, 255, 0.3);
     border-radius: 4px;
     color: var(--accent-cyan);
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 10px;
 }
 
@@ -716,7 +792,7 @@ body {
     border: none;
     background: var(--accent-green);
     color: #fff;
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 10px;
     font-weight: 600;
     text-transform: uppercase;
@@ -747,19 +823,61 @@ body {
     border: none;
 }
 
-.vessel-marker-inner {
-    width: 24px;
-    height: 24px;
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    font-size: 18px;
-    filter: drop-shadow(0 0 2px rgba(0,0,0,0.8));
-    transition: transform 0.3s ease;
+.vessel-marker svg {
+    transition: filter 0.2s ease;
 }
 
-.vessel-marker.selected .vessel-marker-inner {
-    filter: drop-shadow(0 0 6px var(--accent-cyan));
+.vessel-marker.selected svg {
+    filter: drop-shadow(0 0 8px rgba(255,255,255,0.8)) !important;
+}
+
+/* ============================================
+   TRACKED VESSEL PULSATING RING
+   ============================================ */
+.vessel-marker.selected {
+    position: relative;
+}
+
+.tracking-ring {
+    position: absolute;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+    width: 40px;
+    height: 40px;
+    border: 2px solid var(--accent-cyan);
+    border-radius: 50%;
+    animation: tracking-pulse 1.5s ease-out infinite;
+    pointer-events: none;
+}
+
+.tracking-ring-inner {
+    position: absolute;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+    width: 28px;
+    height: 28px;
+    border: 1px solid var(--accent-cyan);
+    border-radius: 50%;
+    animation: tracking-pulse 1.5s ease-out infinite 0.3s;
+    pointer-events: none;
+}
+
+@keyframes tracking-pulse {
+    0% {
+        transform: translate(-50%, -50%) scale(0.8);
+        opacity: 1;
+        border-color: rgba(74, 158, 255, 1);
+    }
+    50% {
+        opacity: 0.6;
+    }
+    100% {
+        transform: translate(-50%, -50%) scale(1.8);
+        opacity: 0;
+        border-color: rgba(74, 158, 255, 0);
+    }
 }
 
 /* Range rings */
@@ -791,7 +909,7 @@ body {
         display: flex !important;
         flex-direction: column !important;
         height: auto !important;
-        min-height: calc(100dvh - 95px);
+        min-height: calc(100dvh - 160px);
         overflow-y: auto !important;
         overflow-x: hidden;
         -webkit-overflow-scrolling: touch;
@@ -961,7 +1079,7 @@ body {
     padding: 6px 12px;
     background: rgba(0, 0, 0, 0.2);
     border-bottom: 1px solid rgba(245, 158, 11, 0.1);
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 9px;
 }
 
@@ -1036,7 +1154,7 @@ body {
 }
 
 .dsc-message-category {
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 9px;
     font-weight: 700;
     text-transform: uppercase;
@@ -1053,13 +1171,13 @@ body {
 }
 
 .dsc-message-time {
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 9px;
     color: var(--text-dim);
 }
 
 .dsc-message-mmsi {
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 11px;
     color: var(--accent-orange);
 }
@@ -1077,7 +1195,7 @@ body {
 }
 
 .dsc-message-pos {
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 9px;
     color: var(--text-secondary);
 }
@@ -1105,7 +1223,7 @@ body {
 }
 
 .dsc-distress-alert .dsc-alert-header {
-    font-family: 'Orbitron', 'JetBrains Mono', monospace;
+    font-family: 'Orbitron', 'Space Mono', monospace;
     font-size: 24px;
     font-weight: 700;
     color: var(--accent-red);
@@ -1114,7 +1232,7 @@ body {
 }
 
 .dsc-distress-alert .dsc-alert-mmsi {
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 16px;
     color: var(--accent-cyan);
     margin-bottom: 8px;
@@ -1134,7 +1252,7 @@ body {
 }
 
 .dsc-distress-alert .dsc-alert-position {
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 14px;
     color: var(--accent-cyan);
     margin-bottom: 16px;
@@ -1145,7 +1263,7 @@ body {
     border: none;
     color: white;
     padding: 10px 24px;
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 12px;
     font-weight: 600;
     text-transform: uppercase;
@@ -1204,3 +1322,33 @@ body {
         font-size: 18px;
     }
 }
+
+/* GPS Indicator */
+.gps-indicator {
+    display: inline-flex;
+    align-items: center;
+    gap: 4px;
+    padding: 2px 8px;
+    background: rgba(34, 197, 94, 0.15);
+    border: 1px solid #22c55e;
+    border-radius: 12px;
+    font-size: 10px;
+    font-weight: 600;
+    color: #22c55e;
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+    margin-left: 10px;
+}
+
+.gps-indicator .gps-dot {
+    width: 6px;
+    height: 6px;
+    background: #22c55e;
+    border-radius: 50%;
+    animation: gps-pulse 2s ease-in-out infinite;
+}
+
+@keyframes gps-pulse {
+    0%, 100% { opacity: 1; transform: scale(1); }
+    50% { opacity: 0.5; transform: scale(0.8); }
+}

static/css/components/function-strip.css

@@ -0,0 +1,371 @@
+/* Function Strip (Action Bar) - Shared across modes
+ * Based on APRS strip pattern, reusable for Pager, Sensor, Bluetooth, WiFi, TSCM, etc.
+ */
+
+.function-strip {
+    background: linear-gradient(180deg, var(--bg-panel) 0%, var(--bg-dark) 100%);
+    border: 1px solid var(--border-color);
+    border-radius: 6px;
+    padding: 8px 12px;
+    margin-bottom: 10px;
+    overflow: visible;
+    min-height: 44px;
+}
+
+.function-strip-inner {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    min-width: max-content;
+}
+
+/* Stats */
+.function-strip .strip-stat {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    padding: 6px 10px;
+    background: rgba(74, 158, 255, 0.05);
+    border: 1px solid rgba(74, 158, 255, 0.15);
+    border-radius: 4px;
+    min-width: 55px;
+}
+
+.function-strip .strip-stat:hover {
+    background: rgba(74, 158, 255, 0.1);
+    border-color: rgba(74, 158, 255, 0.3);
+}
+
+.function-strip .strip-value {
+    font-family: var(--font-mono);
+    font-size: 14px;
+    font-weight: 600;
+    color: var(--accent-cyan);
+    line-height: 1.2;
+}
+
+.function-strip .strip-label {
+    font-size: 8px;
+    font-weight: 600;
+    color: var(--text-dim);
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+    margin-top: 1px;
+}
+
+.function-strip .strip-divider {
+    width: 1px;
+    height: 28px;
+    background: var(--border-color);
+    margin: 0 4px;
+}
+
+/* Signal stat coloring */
+.function-strip .signal-stat.good .strip-value { color: var(--accent-green); }
+.function-strip .signal-stat.warning .strip-value { color: var(--accent-yellow); }
+.function-strip .signal-stat.poor .strip-value { color: var(--accent-red); }
+
+/* Controls */
+.function-strip .strip-control {
+    display: flex;
+    align-items: center;
+    gap: 4px;
+}
+
+.function-strip .strip-select {
+    background: rgba(0,0,0,0.3);
+    border: 1px solid var(--border-color);
+    color: var(--text-primary);
+    padding: 4px 8px;
+    border-radius: 4px;
+    font-size: 10px;
+    cursor: pointer;
+}
+
+.function-strip .strip-select:hover {
+    border-color: var(--accent-cyan);
+}
+
+.function-strip .strip-select:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+}
+
+.function-strip .strip-input-label {
+    font-size: 9px;
+    color: var(--text-muted);
+    font-weight: 600;
+}
+
+.function-strip .strip-input {
+    background: rgba(0,0,0,0.3);
+    border: 1px solid var(--border-color);
+    color: var(--text-primary);
+    padding: 4px 6px;
+    border-radius: 4px;
+    font-size: 10px;
+    width: 50px;
+    text-align: center;
+}
+
+.function-strip .strip-input:hover,
+.function-strip .strip-input:focus {
+    border-color: var(--accent-cyan);
+    outline: none;
+}
+
+.function-strip .strip-input:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+}
+
+/* Wider input for frequency values */
+.function-strip .strip-input.wide {
+    width: 70px;
+}
+
+/* Tool Status Indicators */
+.function-strip .strip-tools {
+    display: flex;
+    gap: 4px;
+}
+
+.function-strip .strip-tool {
+    font-size: 9px;
+    font-weight: 600;
+    padding: 3px 6px;
+    border-radius: 3px;
+    background: rgba(255, 59, 48, 0.2);
+    color: var(--accent-red);
+    border: 1px solid rgba(255, 59, 48, 0.3);
+}
+
+.function-strip .strip-tool.ok {
+    background: rgba(0, 255, 136, 0.1);
+    color: var(--accent-green);
+    border-color: rgba(0, 255, 136, 0.3);
+}
+
+.function-strip .strip-tool.warn {
+    background: rgba(255, 193, 7, 0.2);
+    color: var(--accent-yellow);
+    border-color: rgba(255, 193, 7, 0.3);
+}
+
+/* Buttons */
+.function-strip .strip-btn {
+    background: rgba(74, 158, 255, 0.1);
+    border: 1px solid rgba(74, 158, 255, 0.2);
+    color: var(--text-primary);
+    padding: 6px 12px;
+    border-radius: 4px;
+    font-size: 10px;
+    font-weight: 600;
+    cursor: pointer;
+    transition: all 0.2s;
+    white-space: nowrap;
+}
+
+.function-strip .strip-btn:hover:not(:disabled) {
+    background: rgba(74, 158, 255, 0.2);
+    border-color: rgba(74, 158, 255, 0.4);
+}
+
+.function-strip .strip-btn.primary {
+    background: linear-gradient(135deg, var(--accent-green) 0%, #10b981 100%);
+    border: none;
+    color: #000;
+}
+
+.function-strip .strip-btn.primary:hover:not(:disabled) {
+    filter: brightness(1.1);
+}
+
+.function-strip .strip-btn.stop {
+    background: linear-gradient(135deg, var(--accent-red) 0%, #dc2626 100%);
+    border: none;
+    color: #fff;
+}
+
+.function-strip .strip-btn.stop:hover:not(:disabled) {
+    filter: brightness(1.1);
+}
+
+.function-strip .strip-btn:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+}
+
+/* Status indicator */
+.function-strip .strip-status {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    padding: 4px 8px;
+    background: rgba(0,0,0,0.2);
+    border-radius: 4px;
+    font-size: 10px;
+    font-weight: 600;
+    color: var(--text-secondary);
+}
+
+.function-strip .status-dot {
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+    background: var(--text-muted);
+}
+
+.function-strip .status-dot.inactive {
+    background: var(--text-muted);
+}
+
+.function-strip .status-dot.active,
+.function-strip .status-dot.scanning,
+.function-strip .status-dot.decoding {
+    background: var(--accent-cyan);
+    animation: strip-pulse 1.5s ease-in-out infinite;
+}
+
+.function-strip .status-dot.listening,
+.function-strip .status-dot.tracking,
+.function-strip .status-dot.receiving {
+    background: var(--accent-green);
+    animation: strip-pulse 1.5s ease-in-out infinite;
+}
+
+.function-strip .status-dot.sweeping {
+    background: var(--accent-orange);
+    animation: strip-pulse 1s ease-in-out infinite;
+}
+
+.function-strip .status-dot.error {
+    background: var(--accent-red);
+}
+
+@keyframes strip-pulse {
+    0%, 100% { opacity: 1; box-shadow: 0 0 4px 2px currentColor; }
+    50% { opacity: 0.6; box-shadow: none; }
+}
+
+/* Time display */
+.function-strip .strip-time {
+    font-family: var(--font-mono);
+    font-size: 10px;
+    color: var(--text-muted);
+    padding: 4px 8px;
+    background: rgba(0,0,0,0.2);
+    border-radius: 4px;
+    white-space: nowrap;
+}
+
+/* Mode-specific accent colors */
+.function-strip.pager-strip .strip-stat {
+    background: rgba(255, 193, 7, 0.05);
+    border-color: rgba(255, 193, 7, 0.15);
+}
+.function-strip.pager-strip .strip-stat:hover {
+    background: rgba(255, 193, 7, 0.1);
+    border-color: rgba(255, 193, 7, 0.3);
+}
+.function-strip.pager-strip .strip-value {
+    color: var(--accent-yellow);
+}
+
+.function-strip.sensor-strip .strip-stat {
+    background: rgba(0, 255, 136, 0.05);
+    border-color: rgba(0, 255, 136, 0.15);
+}
+.function-strip.sensor-strip .strip-stat:hover {
+    background: rgba(0, 255, 136, 0.1);
+    border-color: rgba(0, 255, 136, 0.3);
+}
+.function-strip.sensor-strip .strip-value {
+    color: var(--accent-green);
+}
+
+.function-strip.bt-strip .strip-stat {
+    background: rgba(0, 122, 255, 0.05);
+    border-color: rgba(0, 122, 255, 0.15);
+}
+.function-strip.bt-strip .strip-stat:hover {
+    background: rgba(0, 122, 255, 0.1);
+    border-color: rgba(0, 122, 255, 0.3);
+}
+.function-strip.bt-strip .strip-value {
+    color: #0a84ff;
+}
+
+.function-strip.wifi-strip .strip-stat {
+    background: rgba(255, 149, 0, 0.05);
+    border-color: rgba(255, 149, 0, 0.15);
+}
+.function-strip.wifi-strip .strip-stat:hover {
+    background: rgba(255, 149, 0, 0.1);
+    border-color: rgba(255, 149, 0, 0.3);
+}
+.function-strip.wifi-strip .strip-value {
+    color: var(--accent-orange);
+}
+
+.function-strip.tscm-strip {
+    margin-top: 4px; /* Extra clearance to prevent top clipping */
+}
+
+.function-strip.tscm-strip .strip-stat {
+    background: rgba(255, 59, 48, 0.15);
+    border: 1px solid rgba(255, 59, 48, 0.4);
+}
+.function-strip.tscm-strip .strip-stat:hover {
+    background: rgba(255, 59, 48, 0.25);
+    border-color: rgba(255, 59, 48, 0.6);
+}
+.function-strip.tscm-strip .strip-value {
+    color: #ef4444; /* Explicit red color */
+}
+.function-strip.tscm-strip .strip-label {
+    color: #9ca3af; /* Explicit light gray */
+}
+.function-strip.tscm-strip .strip-select {
+    color: #e8eaed; /* Explicit white for selects */
+    background: rgba(0, 0, 0, 0.4);
+}
+.function-strip.tscm-strip .strip-btn {
+    color: #e8eaed; /* Explicit white for buttons */
+}
+.function-strip.tscm-strip .strip-tool {
+    color: #e8eaed; /* Explicit white for tool indicators */
+}
+.function-strip.tscm-strip .strip-time,
+.function-strip.tscm-strip .strip-status span {
+    color: #9ca3af; /* Explicit gray for status/time */
+}
+
+.function-strip.rtlamr-strip .strip-stat {
+    background: rgba(175, 82, 222, 0.05);
+    border-color: rgba(175, 82, 222, 0.15);
+}
+.function-strip.rtlamr-strip .strip-stat:hover {
+    background: rgba(175, 82, 222, 0.1);
+    border-color: rgba(175, 82, 222, 0.3);
+}
+.function-strip.rtlamr-strip .strip-value {
+    color: #af52de;
+}
+
+.function-strip.listening-strip .strip-stat {
+    background: rgba(74, 158, 255, 0.05);
+    border-color: rgba(74, 158, 255, 0.15);
+}
+.function-strip.listening-strip .strip-stat:hover {
+    background: rgba(74, 158, 255, 0.1);
+    border-color: rgba(74, 158, 255, 0.3);
+}
+.function-strip.listening-strip .strip-value {
+    color: var(--accent-cyan);
+}
+
+/* Threat-colored stats for TSCM */
+.function-strip .strip-stat.threat-high .strip-value { color: var(--accent-red); }
+.function-strip .strip-stat.threat-review .strip-value { color: var(--accent-orange); }
+.function-strip .strip-stat.threat-info .strip-value { color: var(--accent-cyan); }

static/css/components/proximity-viz.css

@@ -14,10 +14,18 @@
 
 .radar-device {
     transition: transform 0.2s ease;
+    transform-origin: center center;
+    cursor: pointer;
 }
 
 .radar-device:hover {
-    transform: scale(1.3);
+    transform: scale(1.2);
+}
+
+/* Invisible larger hit area to prevent hover flicker */
+.radar-device-hitarea {
+    fill: transparent;
+    pointer-events: all;
 }
 
 .radar-dot-pulse circle:first-child {

static/css/components/toast.css

@@ -0,0 +1,626 @@
+/**
+ * Toast Notification System
+ * Reusable toast notifications for update alerts and other messages
+ */
+
+/* ============================================
+   TOAST CONTAINER
+   ============================================ */
+#toastContainer {
+    position: fixed;
+    bottom: 20px;
+    right: 20px;
+    z-index: 10001;
+    display: flex;
+    flex-direction: column;
+    gap: 12px;
+    pointer-events: none;
+}
+
+#toastContainer > * {
+    pointer-events: auto;
+}
+
+/* ============================================
+   UPDATE TOAST
+   ============================================ */
+.update-toast {
+    display: flex;
+    background: var(--bg-card, #121620);
+    border: 1px solid var(--border-color, #1f2937);
+    border-radius: 8px;
+    box-shadow: 0 8px 32px rgba(0, 0, 0, 0.4);
+    max-width: 340px;
+    overflow: hidden;
+    opacity: 0;
+    transform: translateX(100%);
+    transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+}
+
+.update-toast.show {
+    opacity: 1;
+    transform: translateX(0);
+}
+
+.update-toast-indicator {
+    width: 4px;
+    background: var(--accent-green, #22c55e);
+    flex-shrink: 0;
+}
+
+.update-toast-content {
+    flex: 1;
+    padding: 14px 16px;
+}
+
+.update-toast-header {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    margin-bottom: 8px;
+}
+
+.update-toast-icon {
+    color: var(--accent-green, #22c55e);
+    display: flex;
+    align-items: center;
+}
+
+.update-toast-icon svg {
+    width: 18px;
+    height: 18px;
+}
+
+.update-toast-title {
+    font-size: 13px;
+    font-weight: 600;
+    color: var(--text-primary, #e8eaed);
+    flex: 1;
+}
+
+.update-toast-close {
+    background: none;
+    border: none;
+    color: var(--text-dim, #4b5563);
+    font-size: 20px;
+    line-height: 1;
+    cursor: pointer;
+    padding: 0;
+    margin: -4px;
+    transition: color 0.15s;
+}
+
+.update-toast-close:hover {
+    color: var(--text-secondary, #9ca3af);
+}
+
+.update-toast-body {
+    font-size: 12px;
+    color: var(--text-secondary, #9ca3af);
+    margin-bottom: 12px;
+}
+
+.update-toast-body strong {
+    color: var(--accent-cyan, #4a9eff);
+}
+
+.update-toast-actions {
+    display: flex;
+    gap: 8px;
+}
+
+.update-toast-btn {
+    font-family: inherit;
+    font-size: 11px;
+    font-weight: 500;
+    padding: 6px 12px;
+    border-radius: 4px;
+    border: none;
+    cursor: pointer;
+    transition: all 0.15s;
+}
+
+.update-toast-btn-primary {
+    background: var(--accent-green, #22c55e);
+    color: #000;
+}
+
+.update-toast-btn-primary:hover {
+    background: #34d673;
+}
+
+.update-toast-btn-secondary {
+    background: var(--bg-secondary, #0f1218);
+    color: var(--text-secondary, #9ca3af);
+    border: 1px solid var(--border-color, #1f2937);
+}
+
+.update-toast-btn-secondary:hover {
+    background: var(--bg-tertiary, #151a23);
+    border-color: var(--border-light, #374151);
+}
+
+/* ============================================
+   UPDATE MODAL
+   ============================================ */
+.update-modal-overlay {
+    position: fixed;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    background: rgba(0, 0, 0, 0.7);
+    backdrop-filter: blur(4px);
+    z-index: 10002;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    opacity: 0;
+    visibility: hidden;
+    transition: all 0.2s ease;
+}
+
+.update-modal-overlay.show {
+    opacity: 1;
+    visibility: visible;
+}
+
+.update-modal {
+    background: var(--bg-card, #121620);
+    border: 1px solid var(--border-color, #1f2937);
+    border-radius: 12px;
+    width: 90%;
+    max-width: 520px;
+    max-height: 85vh;
+    display: flex;
+    flex-direction: column;
+    box-shadow: 0 20px 60px rgba(0, 0, 0, 0.5);
+    transform: scale(0.95);
+    transition: transform 0.2s ease;
+}
+
+.update-modal-overlay.show .update-modal {
+    transform: scale(1);
+}
+
+.update-modal-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 16px 20px;
+    border-bottom: 1px solid var(--border-color, #1f2937);
+}
+
+.update-modal-title {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    font-size: 16px;
+    font-weight: 600;
+    color: var(--text-primary, #e8eaed);
+}
+
+.update-modal-icon {
+    color: var(--accent-green, #22c55e);
+    display: flex;
+}
+
+.update-modal-icon svg {
+    width: 22px;
+    height: 22px;
+}
+
+.update-modal-close {
+    background: none;
+    border: none;
+    color: var(--text-dim, #4b5563);
+    font-size: 24px;
+    line-height: 1;
+    cursor: pointer;
+    padding: 4px;
+    transition: color 0.15s;
+}
+
+.update-modal-close:hover {
+    color: var(--accent-red, #ef4444);
+}
+
+.update-modal-body {
+    padding: 20px;
+    overflow-y: auto;
+    flex: 1;
+}
+
+/* Version Info */
+.update-version-info {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 16px;
+    padding: 16px;
+    background: var(--bg-secondary, #0f1218);
+    border-radius: 8px;
+    margin-bottom: 20px;
+}
+
+.update-version-current,
+.update-version-latest {
+    text-align: center;
+}
+
+.update-version-label {
+    display: block;
+    font-size: 10px;
+    font-weight: 500;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    color: var(--text-dim, #4b5563);
+    margin-bottom: 4px;
+}
+
+.update-version-value {
+    font-family: var(--font-mono);
+    font-size: 18px;
+    font-weight: 600;
+    color: var(--text-secondary, #9ca3af);
+}
+
+.update-version-new {
+    color: var(--accent-green, #22c55e);
+}
+
+.update-version-arrow {
+    color: var(--text-dim, #4b5563);
+}
+
+.update-version-arrow svg {
+    width: 20px;
+    height: 20px;
+}
+
+/* Sections */
+.update-section {
+    margin-bottom: 20px;
+}
+
+.update-section-title {
+    font-size: 11px;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    color: var(--text-dim, #4b5563);
+    margin-bottom: 10px;
+}
+
+.update-release-notes {
+    font-size: 13px;
+    color: var(--text-secondary, #9ca3af);
+    background: var(--bg-secondary, #0f1218);
+    border: 1px solid var(--border-color, #1f2937);
+    border-radius: 6px;
+    padding: 14px;
+    max-height: 200px;
+    overflow-y: auto;
+    line-height: 1.6;
+}
+
+.update-release-notes h2,
+.update-release-notes h3,
+.update-release-notes h4 {
+    color: var(--text-primary, #e8eaed);
+    margin: 16px 0 8px 0;
+    font-size: 14px;
+}
+
+.update-release-notes h2:first-child,
+.update-release-notes h3:first-child,
+.update-release-notes h4:first-child {
+    margin-top: 0;
+}
+
+.update-release-notes ul {
+    margin: 8px 0;
+    padding-left: 20px;
+}
+
+.update-release-notes li {
+    margin: 4px 0;
+}
+
+.update-release-notes code {
+    font-family: var(--font-mono);
+    font-size: 11px;
+    background: var(--bg-tertiary, #151a23);
+    padding: 2px 6px;
+    border-radius: 3px;
+    color: var(--accent-cyan, #4a9eff);
+}
+
+.update-release-notes p {
+    margin: 8px 0;
+}
+
+/* Warning */
+.update-warning {
+    display: flex;
+    gap: 12px;
+    padding: 14px;
+    background: rgba(245, 158, 11, 0.1);
+    border: 1px solid rgba(245, 158, 11, 0.3);
+    border-radius: 6px;
+    margin-bottom: 16px;
+}
+
+.update-warning-icon {
+    color: var(--accent-orange, #f59e0b);
+    flex-shrink: 0;
+}
+
+.update-warning-icon svg {
+    width: 20px;
+    height: 20px;
+}
+
+.update-warning-text {
+    font-size: 12px;
+    color: var(--text-secondary, #9ca3af);
+}
+
+.update-warning-text strong {
+    display: block;
+    color: var(--accent-orange, #f59e0b);
+    margin-bottom: 4px;
+}
+
+.update-warning-text p {
+    margin: 0;
+}
+
+/* Options */
+.update-options {
+    margin-bottom: 16px;
+}
+
+.update-option {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    font-size: 12px;
+    color: var(--text-secondary, #9ca3af);
+    cursor: pointer;
+}
+
+.update-option input[type="checkbox"] {
+    width: 16px;
+    height: 16px;
+    accent-color: var(--accent-cyan, #4a9eff);
+}
+
+/* Progress */
+.update-progress {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 12px;
+    padding: 20px;
+    font-size: 13px;
+    color: var(--text-secondary, #9ca3af);
+}
+
+.update-progress-spinner {
+    width: 20px;
+    height: 20px;
+    border: 2px solid var(--border-color, #1f2937);
+    border-top-color: var(--accent-cyan, #4a9eff);
+    border-radius: 50%;
+    animation: updateSpin 0.8s linear infinite;
+}
+
+@keyframes updateSpin {
+    to { transform: rotate(360deg); }
+}
+
+/* Results */
+.update-result {
+    display: flex;
+    gap: 12px;
+    padding: 14px;
+    border-radius: 6px;
+    margin-top: 16px;
+}
+
+.update-result-icon {
+    flex-shrink: 0;
+}
+
+.update-result-icon svg {
+    width: 20px;
+    height: 20px;
+}
+
+.update-result-text {
+    font-size: 12px;
+    line-height: 1.5;
+}
+
+.update-result-text code {
+    font-family: var(--font-mono);
+    font-size: 11px;
+    background: rgba(0, 0, 0, 0.2);
+    padding: 2px 6px;
+    border-radius: 3px;
+    display: inline-block;
+    word-break: break-all;
+}
+
+.update-result-success {
+    background: rgba(34, 197, 94, 0.1);
+    border: 1px solid rgba(34, 197, 94, 0.3);
+}
+
+.update-result-success .update-result-icon {
+    color: var(--accent-green, #22c55e);
+}
+
+.update-result-success .update-result-text {
+    color: var(--accent-green, #22c55e);
+}
+
+.update-result-error {
+    background: rgba(239, 68, 68, 0.1);
+    border: 1px solid rgba(239, 68, 68, 0.3);
+}
+
+.update-result-error .update-result-icon {
+    color: var(--accent-red, #ef4444);
+}
+
+.update-result-error .update-result-text {
+    color: var(--text-secondary, #9ca3af);
+}
+
+.update-result-error .update-result-text strong {
+    color: var(--accent-red, #ef4444);
+}
+
+.update-result-warning {
+    background: rgba(245, 158, 11, 0.1);
+    border: 1px solid rgba(245, 158, 11, 0.3);
+}
+
+.update-result-warning .update-result-icon {
+    color: var(--accent-orange, #f59e0b);
+}
+
+.update-result-warning .update-result-text {
+    color: var(--text-secondary, #9ca3af);
+}
+
+.update-result-warning .update-result-text strong {
+    color: var(--accent-orange, #f59e0b);
+}
+
+.update-result-info {
+    background: rgba(74, 158, 255, 0.1);
+    border: 1px solid rgba(74, 158, 255, 0.3);
+}
+
+.update-result-info .update-result-icon {
+    color: var(--accent-cyan, #4a9eff);
+}
+
+.update-result-info .update-result-text {
+    color: var(--text-secondary, #9ca3af);
+}
+
+/* Footer */
+.update-modal-footer {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 14px 20px;
+    border-top: 1px solid var(--border-color, #1f2937);
+    background: var(--bg-secondary, #0f1218);
+    border-radius: 0 0 12px 12px;
+}
+
+.update-modal-link {
+    display: inline-flex;
+    align-items: center;
+    gap: 6px;
+    font-size: 12px;
+    color: var(--text-dim, #4b5563);
+    text-decoration: none;
+    transition: color 0.15s;
+}
+
+.update-modal-link:hover {
+    color: var(--accent-cyan, #4a9eff);
+}
+
+.update-modal-actions {
+    display: flex;
+    gap: 10px;
+}
+
+.update-modal-btn {
+    font-family: inherit;
+    font-size: 12px;
+    font-weight: 500;
+    padding: 8px 16px;
+    border-radius: 6px;
+    border: none;
+    cursor: pointer;
+    transition: all 0.15s;
+}
+
+.update-modal-btn:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+}
+
+.update-modal-btn-primary {
+    background: var(--accent-green, #22c55e);
+    color: #000;
+}
+
+.update-modal-btn-primary:hover:not(:disabled) {
+    background: #34d673;
+}
+
+.update-modal-btn-secondary {
+    background: var(--bg-tertiary, #151a23);
+    color: var(--text-secondary, #9ca3af);
+    border: 1px solid var(--border-color, #1f2937);
+}
+
+.update-modal-btn-secondary:hover:not(:disabled) {
+    background: var(--bg-elevated, #1a202c);
+    border-color: var(--border-light, #374151);
+}
+
+/* ============================================
+   RESPONSIVE
+   ============================================ */
+@media (max-width: 480px) {
+    #toastContainer {
+        bottom: 10px;
+        right: 10px;
+        left: 10px;
+    }
+
+    .update-toast {
+        max-width: none;
+    }
+
+    .update-modal {
+        width: 95%;
+        max-height: 90vh;
+    }
+
+    .update-version-info {
+        flex-direction: column;
+        gap: 10px;
+    }
+
+    .update-version-arrow {
+        transform: rotate(90deg);
+    }
+
+    .update-modal-footer {
+        flex-direction: column;
+        gap: 12px;
+    }
+
+    .update-modal-link {
+        order: 2;
+    }
+
+    .update-modal-actions {
+        width: 100%;
+    }
+
+    .update-modal-btn {
+        flex: 1;
+    }
+}

static/css/core/base.css

@@ -0,0 +1,431 @@
+/**
+ * INTERCEPT Base Styles
+ * Reset, typography, and foundational element styles
+ * Requires: variables.css to be imported first
+ */
+
+/* ============================================
+   CSS RESET
+   ============================================ */
+*,
+*::before,
+*::after {
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0;
+}
+
+html {
+    -webkit-text-size-adjust: 100%;
+    -moz-tab-size: 4;
+    tab-size: 4;
+}
+
+body {
+    font-family: var(--font-sans);
+    font-size: var(--text-base);
+    line-height: var(--leading-normal);
+    color: var(--text-primary);
+    background-color: var(--bg-primary);
+    background-image:
+        var(--noise-image),
+        radial-gradient(circle at 15% 0%, var(--grid-dot), transparent 45%),
+        linear-gradient(180deg, var(--grid-dot), transparent 35%),
+        linear-gradient(var(--grid-line) 1px, transparent 1px),
+        linear-gradient(90deg, var(--grid-line) 1px, transparent 1px);
+    background-size: 40px 40px, auto, auto, 48px 48px, 48px 48px;
+    background-attachment: fixed;
+    min-height: 100vh;
+    -webkit-font-smoothing: antialiased;
+    -moz-osx-font-smoothing: grayscale;
+}
+
+/* ============================================
+   TYPOGRAPHY
+   ============================================ */
+h1, h2, h3, h4, h5, h6 {
+    font-weight: var(--font-semibold);
+    line-height: var(--leading-tight);
+    color: var(--text-primary);
+    letter-spacing: 0.01em;
+}
+
+h1 { font-size: var(--text-4xl); }
+h2 { font-size: var(--text-3xl); }
+h3 { font-size: var(--text-2xl); }
+h4 { font-size: var(--text-xl); }
+h5 { font-size: var(--text-lg); }
+h6 { font-size: var(--text-base); }
+
+p {
+    margin-bottom: var(--space-4);
+}
+
+a {
+    color: var(--accent-cyan);
+    text-decoration: none;
+    transition: color var(--transition-fast);
+}
+
+a:hover {
+    color: var(--accent-cyan-hover);
+}
+
+a:focus-visible {
+    outline: 2px solid var(--border-focus);
+    outline-offset: 2px;
+}
+
+strong, b {
+    font-weight: var(--font-semibold);
+}
+
+small {
+    font-size: var(--text-sm);
+}
+
+code, kbd, pre, samp {
+    font-family: var(--font-mono);
+    font-size: 0.9em;
+}
+
+code {
+    background: var(--bg-elevated);
+    border: 1px solid var(--border-color);
+    padding: 2px 6px;
+    border-radius: var(--radius-sm);
+}
+
+pre {
+    background: var(--bg-elevated);
+    border: 1px solid var(--border-color);
+    padding: var(--space-4);
+    border-radius: var(--radius-md);
+    overflow-x: auto;
+}
+
+pre code {
+    background: none;
+    padding: 0;
+}
+
+/* ============================================
+   FORM ELEMENTS
+   ============================================ */
+button,
+input,
+select,
+textarea {
+    font-family: inherit;
+    font-size: inherit;
+    line-height: inherit;
+    color: inherit;
+}
+
+button {
+    cursor: pointer;
+    border: none;
+    background: none;
+}
+
+button:disabled {
+    cursor: not-allowed;
+    opacity: 0.5;
+}
+
+input,
+select,
+textarea {
+    background: var(--bg-secondary);
+    border: 1px solid var(--border-color);
+    border-radius: var(--radius-md);
+    padding: var(--space-2) var(--space-3);
+    color: var(--text-primary);
+    transition: border-color var(--transition-fast), box-shadow var(--transition-fast);
+}
+
+input:focus,
+select:focus,
+textarea:focus {
+    outline: none;
+    border-color: var(--accent-cyan);
+    box-shadow: 0 0 0 2px var(--accent-cyan-dim);
+}
+
+input::placeholder,
+textarea::placeholder {
+    color: var(--text-dim);
+}
+
+select {
+    cursor: pointer;
+    appearance: none;
+    background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' viewBox='0 0 24 24' fill='none' stroke='%239fb0c7' stroke-width='2'%3E%3Cpolyline points='6 9 12 15 18 9'/%3E%3C/svg%3E");
+    background-repeat: no-repeat;
+    background-position: right 8px center;
+    padding-right: 28px;
+}
+
+input[type="checkbox"],
+input[type="radio"] {
+    width: 16px;
+    height: 16px;
+    padding: 0;
+    cursor: pointer;
+    accent-color: var(--accent-cyan);
+}
+
+label {
+    display: block;
+    font-size: var(--text-sm);
+    font-weight: var(--font-medium);
+    color: var(--text-secondary);
+    margin-bottom: var(--space-1);
+}
+
+/* ============================================
+   TABLES
+   ============================================ */
+table {
+    width: 100%;
+    border-collapse: collapse;
+    font-size: var(--text-sm);
+}
+
+th,
+td {
+    padding: var(--space-2) var(--space-3);
+    text-align: left;
+    border-bottom: 1px solid var(--border-color);
+}
+
+th {
+    font-weight: var(--font-semibold);
+    color: var(--text-secondary);
+    background: var(--bg-tertiary);
+    text-transform: uppercase;
+    font-size: var(--text-xs);
+    letter-spacing: 0.05em;
+}
+
+tr:hover td {
+    background: var(--bg-elevated);
+}
+
+/* ============================================
+   LISTS
+   ============================================ */
+ul, ol {
+    padding-left: var(--space-6);
+    margin-bottom: var(--space-4);
+}
+
+li {
+    margin-bottom: var(--space-1);
+}
+
+/* ============================================
+   UTILITY CLASSES
+   ============================================ */
+
+/* Text colors */
+.text-primary { color: var(--text-primary); }
+.text-secondary { color: var(--text-secondary); }
+.text-muted { color: var(--text-muted); }
+.text-cyan { color: var(--accent-cyan); }
+.text-green { color: var(--accent-green); }
+.text-red { color: var(--accent-red); }
+.text-orange { color: var(--accent-orange); }
+.text-amber { color: var(--accent-amber); }
+
+/* Font utilities */
+.font-mono { font-family: var(--font-mono); }
+.font-medium { font-weight: var(--font-medium); }
+.font-semibold { font-weight: var(--font-semibold); }
+.font-bold { font-weight: var(--font-bold); }
+
+/* Text sizes */
+.text-xs { font-size: var(--text-xs); }
+.text-sm { font-size: var(--text-sm); }
+.text-base { font-size: var(--text-base); }
+.text-lg { font-size: var(--text-lg); }
+.text-xl { font-size: var(--text-xl); }
+
+/* Display */
+.hidden { display: none !important; }
+.block { display: block; }
+.inline-block { display: inline-block; }
+.flex { display: flex; }
+.inline-flex { display: inline-flex; }
+.grid { display: grid; }
+
+/* Flexbox */
+.items-center { align-items: center; }
+.justify-center { justify-content: center; }
+.justify-between { justify-content: space-between; }
+.flex-1 { flex: 1; }
+.gap-1 { gap: var(--space-1); }
+.gap-2 { gap: var(--space-2); }
+.gap-3 { gap: var(--space-3); }
+.gap-4 { gap: var(--space-4); }
+
+/* Spacing */
+.m-0 { margin: 0; }
+.mt-2 { margin-top: var(--space-2); }
+.mt-4 { margin-top: var(--space-4); }
+.mb-2 { margin-bottom: var(--space-2); }
+.mb-4 { margin-bottom: var(--space-4); }
+.p-2 { padding: var(--space-2); }
+.p-3 { padding: var(--space-3); }
+.p-4 { padding: var(--space-4); }
+
+/* Borders */
+.rounded { border-radius: var(--radius-md); }
+.rounded-lg { border-radius: var(--radius-lg); }
+.border { border: 1px solid var(--border-color); }
+
+/* Truncate text */
+.truncate {
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+/* Screen reader only */
+.sr-only {
+    position: absolute;
+    width: 1px;
+    height: 1px;
+    padding: 0;
+    margin: -1px;
+    overflow: hidden;
+    clip: rect(0, 0, 0, 0);
+    white-space: nowrap;
+    border: 0;
+}
+
+/* ============================================
+   SCROLLBAR STYLING
+   ============================================ */
+::-webkit-scrollbar {
+    width: 8px;
+    height: 8px;
+}
+
+::-webkit-scrollbar-track {
+    background: var(--bg-secondary);
+}
+
+::-webkit-scrollbar-thumb {
+    background: var(--border-light);
+    border-radius: var(--radius-full);
+}
+
+::-webkit-scrollbar-thumb:hover {
+    background: var(--text-dim);
+}
+
+/* Firefox scrollbar */
+* {
+    scrollbar-width: thin;
+    scrollbar-color: var(--border-light) var(--bg-secondary);
+}
+
+/* ============================================
+   SELECTION
+   ============================================ */
+::selection {
+    background: var(--accent-cyan-dim);
+    color: var(--text-primary);
+}
+
+/* ============================================
+   UX POLISH - TRANSITIONS & INTERACTIONS
+   ============================================ */
+
+/* Smooth page transitions */
+html {
+    scroll-behavior: smooth;
+}
+
+/* Better focus ring for all interactive elements */
+:focus-visible {
+    outline: 2px solid var(--accent-cyan);
+    outline-offset: 2px;
+}
+
+/* Remove focus ring for mouse users */
+:focus:not(:focus-visible) {
+    outline: none;
+}
+
+/* Active state feedback */
+button:active:not(:disabled),
+a:active,
+[role="button"]:active {
+    transform: scale(0.98);
+}
+
+/* Smooth transitions for all interactive elements */
+button,
+a,
+input,
+select,
+textarea,
+[role="button"] {
+    transition:
+        color var(--transition-fast),
+        background-color var(--transition-fast),
+        border-color var(--transition-fast),
+        box-shadow var(--transition-fast),
+        transform var(--transition-fast),
+        opacity var(--transition-fast);
+}
+
+/* Subtle hover lift effect for cards and panels */
+.card:hover,
+.panel:hover {
+    box-shadow: var(--shadow-md);
+}
+
+/* Link underline on hover */
+a:hover {
+    text-decoration: underline;
+    text-underline-offset: 2px;
+}
+
+/* Skip link for accessibility */
+.skip-link {
+    position: absolute;
+    top: -40px;
+    left: 0;
+    background: var(--accent-cyan);
+    color: var(--bg-primary);
+    padding: var(--space-2) var(--space-4);
+    z-index: 9999;
+    transition: top var(--transition-fast);
+}
+
+.skip-link:focus {
+    top: 0;
+}
+
+/* Reduced motion preference */
+@media (prefers-reduced-motion: reduce) {
+    *,
+    *::before,
+    *::after {
+        animation-duration: 0.01ms !important;
+        animation-iteration-count: 1 !important;
+        transition-duration: 0.01ms !important;
+        scroll-behavior: auto !important;
+    }
+}
+
+/* High contrast mode support */
+@media (prefers-contrast: high) {
+    :root {
+        --border-color: #4b5563;
+        --text-secondary: #d1d5db;
+    }
+}

static/css/core/components.css

@@ -0,0 +1,842 @@
+/**
+ * INTERCEPT UI Components
+ * Reusable component styles for buttons, cards, badges, etc.
+ * Requires: variables.css and base.css
+ */
+
+/* ============================================
+   BUTTONS
+   ============================================ */
+
+/* Base button */
+.btn {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    gap: var(--space-2);
+    padding: var(--space-2) var(--space-4);
+    font-size: var(--text-sm);
+    font-weight: var(--font-medium);
+    border-radius: var(--radius-md);
+    border: 1px solid transparent;
+    cursor: pointer;
+    transition: all var(--transition-fast);
+    white-space: nowrap;
+    text-decoration: none;
+    font-family: var(--font-mono);
+    text-transform: uppercase;
+    letter-spacing: 0.06em;
+}
+
+.btn:focus-visible {
+    outline: 2px solid var(--border-focus);
+    outline-offset: 2px;
+}
+
+.btn:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+}
+
+/* Button variants */
+.btn-primary {
+    background: var(--accent-cyan);
+    color: var(--text-inverse);
+    border-color: var(--accent-cyan);
+    box-shadow: inset 0 0 0 1px rgba(255, 255, 255, 0.08);
+}
+
+.btn-primary:hover:not(:disabled) {
+    background: var(--accent-cyan-hover);
+    border-color: var(--accent-cyan-hover);
+}
+
+.btn-secondary {
+    background: var(--bg-secondary);
+    color: var(--text-primary);
+    border-color: var(--border-color);
+}
+
+.btn-secondary:hover:not(:disabled) {
+    background: var(--bg-tertiary);
+    border-color: var(--border-light);
+}
+
+.btn-ghost {
+    background: transparent;
+    color: var(--text-secondary);
+    border-color: var(--border-color);
+}
+
+.btn-ghost:hover:not(:disabled) {
+    background: var(--bg-elevated);
+    color: var(--text-primary);
+}
+
+.btn-danger {
+    background: var(--accent-red);
+    color: white;
+    border-color: var(--accent-red);
+}
+
+.btn-danger:hover:not(:disabled) {
+    background: #dc2626;
+    border-color: #dc2626;
+}
+
+.btn-success {
+    background: var(--accent-green);
+    color: white;
+    border-color: var(--accent-green);
+}
+
+.btn-success:hover:not(:disabled) {
+    background: #16a34a;
+    border-color: #16a34a;
+}
+
+/* Button sizes */
+.btn-sm {
+    padding: var(--space-1) var(--space-2);
+    font-size: var(--text-xs);
+}
+
+.btn-lg {
+    padding: var(--space-3) var(--space-6);
+    font-size: var(--text-base);
+}
+
+/* Icon button */
+.btn-icon {
+    padding: var(--space-2);
+    width: 36px;
+    height: 36px;
+}
+
+.btn-icon.btn-sm {
+    width: 28px;
+    height: 28px;
+    padding: var(--space-1);
+}
+
+/* ============================================
+   CARDS / PANELS
+   ============================================ */
+.card {
+    background: linear-gradient(180deg, var(--bg-card) 0%, var(--bg-secondary) 100%);
+    border: 1px solid var(--border-color);
+    border-radius: var(--radius-lg);
+    overflow: hidden;
+    box-shadow: var(--shadow-sm);
+}
+
+.card-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: var(--space-3) var(--space-4);
+    border-bottom: 1px solid var(--border-color);
+    background: var(--bg-secondary);
+    position: relative;
+}
+
+.card-header-title {
+    font-size: var(--text-xs);
+    font-weight: var(--font-semibold);
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    color: var(--text-secondary);
+}
+
+.card-body {
+    padding: var(--space-4);
+}
+
+.card-footer {
+    padding: var(--space-3) var(--space-4);
+    border-top: 1px solid var(--border-color);
+    background: var(--bg-secondary);
+}
+
+/* Panel variant (used in dashboards) */
+.panel {
+    background: linear-gradient(180deg, var(--bg-card) 0%, var(--bg-secondary) 100%);
+    border: 1px solid var(--border-color);
+    border-radius: var(--radius-lg);
+    overflow: hidden;
+    box-shadow: var(--shadow-sm);
+}
+
+@supports (clip-path: polygon(0 0)) {
+    .card,
+    .panel {
+        --notch-size: 6px;
+        border-radius: 0;
+        clip-path: polygon(
+            var(--notch-size) 0,
+            calc(100% - var(--notch-size)) 0,
+            100% var(--notch-size),
+            100% calc(100% - var(--notch-size)),
+            calc(100% - var(--notch-size)) 100%,
+            var(--notch-size) 100%,
+            0 calc(100% - var(--notch-size)),
+            0 var(--notch-size)
+        );
+    }
+}
+
+.panel-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: var(--space-2) var(--space-3);
+    border-bottom: 1px solid var(--border-color);
+    background: linear-gradient(180deg, var(--bg-elevated) 0%, var(--bg-secondary) 100%);
+    font-size: var(--text-xs);
+    font-weight: var(--font-semibold);
+    text-transform: uppercase;
+    letter-spacing: 0.1em;
+    color: var(--text-secondary);
+    position: relative;
+}
+
+.card-header::before,
+.panel-header::before {
+    content: '';
+    position: absolute;
+    top: 0;
+    left: var(--space-3);
+    width: 36px;
+    height: 2px;
+    background: var(--accent-cyan);
+    opacity: 0.7;
+}
+
+.panel-indicator {
+    width: 8px;
+    height: 8px;
+    border-radius: var(--radius-full);
+    background: var(--status-offline);
+}
+
+.panel-indicator.active {
+    background: var(--status-online);
+    box-shadow: 0 0 8px var(--status-online);
+}
+
+.panel-content {
+    padding: var(--space-3);
+}
+
+/* ============================================
+   BADGES
+   ============================================ */
+.badge {
+    display: inline-flex;
+    align-items: center;
+    gap: var(--space-1);
+    padding: 2px var(--space-2);
+    font-size: var(--text-xs);
+    font-weight: var(--font-medium);
+    border-radius: var(--radius-full);
+    background: var(--bg-tertiary);
+    color: var(--text-secondary);
+    border: 1px solid var(--border-color);
+}
+
+.badge-primary {
+    background: var(--accent-cyan-dim);
+    color: var(--accent-cyan);
+}
+
+.badge-success {
+    background: var(--accent-green-dim);
+    color: var(--accent-green);
+}
+
+.badge-warning {
+    background: var(--accent-orange-dim);
+    color: var(--accent-orange);
+}
+
+.badge-danger {
+    background: var(--accent-red-dim);
+    color: var(--accent-red);
+}
+
+/* ============================================
+   DATA TAGS
+   ============================================ */
+.data-tag {
+    display: inline-flex;
+    align-items: center;
+    gap: var(--space-1);
+    padding: 2px var(--space-2);
+    font-size: 10px;
+    font-family: var(--font-mono);
+    text-transform: uppercase;
+    letter-spacing: 0.12em;
+    border-radius: var(--radius-sm);
+    border: 1px solid var(--border-color);
+    background: var(--bg-tertiary);
+    color: var(--text-secondary);
+    box-shadow: inset 0 0 0 1px var(--border-glow);
+}
+
+.data-tag--accent {
+    border-color: var(--accent-cyan);
+    color: var(--accent-cyan);
+    background: var(--accent-cyan-dim);
+}
+
+.data-tag--warning {
+    border-color: var(--accent-amber);
+    color: var(--accent-amber);
+    background: var(--accent-amber-dim);
+}
+
+.data-tag--success {
+    border-color: var(--accent-green);
+    color: var(--accent-green);
+    background: var(--accent-green-dim);
+}
+
+.data-tag--danger {
+    border-color: var(--accent-red);
+    color: var(--accent-red);
+    background: var(--accent-red-dim);
+}
+
+/* ============================================
+   STATUS INDICATORS
+   ============================================ */
+.status-dot {
+    width: 8px;
+    height: 8px;
+    border-radius: var(--radius-full);
+    background: var(--status-offline);
+    flex-shrink: 0;
+}
+
+.status-dot.online,
+.status-dot.active {
+    background: var(--status-online);
+    box-shadow: 0 0 4px var(--status-online);
+}
+
+.status-dot.warning {
+    background: var(--status-warning);
+    box-shadow: 0 0 4px var(--status-warning);
+}
+
+.status-dot.error,
+.status-dot.offline {
+    background: var(--status-error);
+}
+
+.status-dot.inactive {
+    background: var(--status-offline);
+}
+
+/* Pulse animation for active status */
+.status-dot.pulse {
+    animation: statusPulse 2s ease-in-out infinite;
+}
+
+@keyframes statusPulse {
+    0%, 100% { opacity: 1; }
+    50% { opacity: 0.5; }
+}
+
+/* ============================================
+   EMPTY STATE
+   ============================================ */
+.empty-state {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    padding: var(--space-8) var(--space-4);
+    text-align: center;
+    color: var(--text-muted);
+}
+
+.empty-state-icon {
+    width: 48px;
+    height: 48px;
+    margin-bottom: var(--space-4);
+    opacity: 0.5;
+}
+
+.empty-state-title {
+    font-size: var(--text-base);
+    font-weight: var(--font-medium);
+    color: var(--text-secondary);
+    margin-bottom: var(--space-2);
+}
+
+.empty-state-description {
+    font-size: var(--text-sm);
+    color: var(--text-dim);
+    max-width: 300px;
+}
+
+.empty-state-action {
+    margin-top: var(--space-4);
+}
+
+/* ============================================
+   LOADING STATES
+   ============================================ */
+.spinner {
+    width: 20px;
+    height: 20px;
+    border: 2px solid var(--border-color);
+    border-top-color: var(--accent-cyan);
+    border-radius: var(--radius-full);
+    animation: spin 0.8s linear infinite;
+}
+
+.spinner-sm {
+    width: 14px;
+    height: 14px;
+    border-width: 2px;
+}
+
+.spinner-lg {
+    width: 32px;
+    height: 32px;
+    border-width: 3px;
+}
+
+@keyframes spin {
+    to { transform: rotate(360deg); }
+}
+
+/* Loading overlay */
+.loading-overlay {
+    position: absolute;
+    inset: 0;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background: var(--bg-overlay);
+    z-index: var(--z-modal);
+}
+
+/* Skeleton loader */
+.skeleton {
+    background: linear-gradient(
+        90deg,
+        var(--bg-tertiary) 25%,
+        var(--bg-elevated) 50%,
+        var(--bg-tertiary) 75%
+    );
+    background-size: 200% 100%;
+    animation: shimmer 1.5s infinite;
+    border-radius: var(--radius-sm);
+}
+
+@keyframes shimmer {
+    0% { background-position: 200% 0; }
+    100% { background-position: -200% 0; }
+}
+
+/* ============================================
+   STATS STRIP
+   ============================================ */
+.stats-strip {
+    display: flex;
+    align-items: center;
+    background: var(--bg-secondary);
+    border-bottom: 1px solid var(--border-color);
+    padding: 0 var(--space-4);
+    height: var(--stats-strip-height);
+    overflow-x: auto;
+    gap: var(--space-1);
+}
+
+.strip-stat {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    padding: 0 var(--space-3);
+    min-width: fit-content;
+}
+
+.strip-value {
+    font-family: var(--font-mono);
+    font-size: var(--text-sm);
+    font-weight: var(--font-semibold);
+    color: var(--accent-cyan);
+    line-height: 1;
+}
+
+.strip-label {
+    font-size: 9px;
+    color: var(--text-dim);
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    line-height: 1;
+    margin-top: 2px;
+}
+
+.strip-divider {
+    width: 1px;
+    height: 20px;
+    background: var(--border-color);
+    margin: 0 var(--space-2);
+}
+
+/* ============================================
+   FORM GROUPS
+   ============================================ */
+.form-group {
+    margin-bottom: var(--space-4);
+}
+
+.form-group label {
+    display: block;
+    margin-bottom: var(--space-1);
+    font-size: var(--text-sm);
+    font-weight: var(--font-medium);
+    color: var(--text-secondary);
+}
+
+.form-group input,
+.form-group select,
+.form-group textarea {
+    width: 100%;
+}
+
+.form-help {
+    margin-top: var(--space-1);
+    font-size: var(--text-xs);
+    color: var(--text-dim);
+}
+
+.form-error {
+    margin-top: var(--space-1);
+    font-size: var(--text-xs);
+    color: var(--accent-red);
+}
+
+/* Inline checkbox/radio */
+.form-check {
+    display: flex;
+    align-items: center;
+    gap: var(--space-2);
+    cursor: pointer;
+}
+
+.form-check input {
+    width: auto;
+}
+
+.form-check label {
+    margin-bottom: 0;
+    cursor: pointer;
+}
+
+/* ============================================
+   ALERTS / TOASTS
+   ============================================ */
+.alert {
+    display: flex;
+    align-items: flex-start;
+    gap: var(--space-3);
+    padding: var(--space-3) var(--space-4);
+    border-radius: var(--radius-md);
+    border: 1px solid;
+    font-size: var(--text-sm);
+}
+
+.alert-info {
+    background: var(--accent-cyan-dim);
+    border-color: var(--accent-cyan);
+    color: var(--accent-cyan);
+}
+
+.alert-success {
+    background: var(--accent-green-dim);
+    border-color: var(--accent-green);
+    color: var(--accent-green);
+}
+
+.alert-warning {
+    background: var(--accent-orange-dim);
+    border-color: var(--accent-orange);
+    color: var(--accent-orange);
+}
+
+.alert-danger {
+    background: var(--accent-red-dim);
+    border-color: var(--accent-red);
+    color: var(--accent-red);
+}
+
+/* ============================================
+   TOOLTIPS
+   ============================================ */
+[data-tooltip] {
+    position: relative;
+}
+
+[data-tooltip]::after {
+    content: attr(data-tooltip);
+    position: absolute;
+    bottom: 100%;
+    left: 50%;
+    transform: translateX(-50%);
+    padding: var(--space-1) var(--space-2);
+    background: var(--bg-elevated);
+    color: var(--text-primary);
+    font-size: var(--text-xs);
+    border-radius: var(--radius-sm);
+    white-space: nowrap;
+    opacity: 0;
+    visibility: hidden;
+    transition: opacity var(--transition-fast), visibility var(--transition-fast);
+    z-index: var(--z-tooltip);
+    pointer-events: none;
+    margin-bottom: var(--space-1);
+    box-shadow: var(--shadow-md);
+}
+
+[data-tooltip]:hover::after {
+    opacity: 1;
+    visibility: visible;
+}
+
+/* ============================================
+   ICONS
+   ============================================ */
+.icon {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    width: 20px;
+    height: 20px;
+    flex-shrink: 0;
+}
+
+.icon svg {
+    width: 100%;
+    height: 100%;
+}
+
+.icon--sm {
+    width: 16px;
+    height: 16px;
+}
+
+.icon--lg {
+    width: 24px;
+    height: 24px;
+}
+
+/* ============================================
+   SECTION HEADERS
+   ============================================ */
+.section-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    margin-bottom: var(--space-4);
+    padding-bottom: var(--space-2);
+    border-bottom: 1px solid var(--border-color);
+}
+
+.section-title {
+    font-size: var(--text-sm);
+    font-weight: var(--font-semibold);
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    color: var(--text-secondary);
+    position: relative;
+    padding-left: var(--space-3);
+}
+
+.section-title::before {
+    content: '';
+    position: absolute;
+    left: 0;
+    top: 50%;
+    width: 2px;
+    height: 6px;
+    background: var(--accent-cyan);
+    transform: translateY(-50%);
+    opacity: 0.7;
+    box-shadow: 0 6px 0 var(--accent-cyan);
+}
+
+/* ============================================
+   DIVIDERS
+   ============================================ */
+.divider {
+    height: 1px;
+    background-image: repeating-linear-gradient(
+        90deg,
+        var(--border-light),
+        var(--border-light) 6px,
+        transparent 6px,
+        transparent 12px
+    );
+    margin: var(--space-4) 0;
+}
+
+.divider-vertical {
+    width: 1px;
+    height: 100%;
+    background-image: repeating-linear-gradient(
+        180deg,
+        var(--border-light),
+        var(--border-light) 6px,
+        transparent 6px,
+        transparent 12px
+    );
+    margin: 0 var(--space-3);
+}
+
+/* ============================================
+   UX POLISH - ENHANCED INTERACTIONS
+   ============================================ */
+
+/* Button hover lift */
+.btn:hover:not(:disabled) {
+    box-shadow: 0 0 0 1px var(--border-light);
+}
+
+.btn:active:not(:disabled) {
+    box-shadow: inset 0 0 0 1px var(--border-light);
+}
+
+/* Card/Panel hover effects */
+.card,
+.panel {
+    transition:
+        box-shadow var(--transition-base),
+        border-color var(--transition-base),
+        transform var(--transition-base);
+}
+
+.card:hover,
+.panel:hover {
+    border-color: var(--border-light);
+}
+
+/* Stats strip value highlight on hover */
+.strip-stat {
+    transition: background-color var(--transition-fast);
+    border-radius: var(--radius-sm);
+    cursor: default;
+}
+
+.strip-stat:hover {
+    background: var(--bg-tertiary);
+}
+
+/* Status dot pulse animation */
+.status-dot.online,
+.status-dot.active {
+    animation: statusGlow 2s ease-in-out infinite;
+}
+
+@keyframes statusGlow {
+    0%, 100% {
+        box-shadow: 0 0 4px var(--status-online);
+    }
+    50% {
+        box-shadow: 0 0 8px var(--status-online), 0 0 12px var(--status-online);
+    }
+}
+
+/* Badge hover effect */
+.badge {
+    transition: transform var(--transition-fast), box-shadow var(--transition-fast);
+}
+
+.badge:hover {
+    transform: scale(1.02);
+}
+
+/* Alert entrance animation */
+.alert {
+    animation: alertSlideIn 0.3s ease-out;
+}
+
+@keyframes alertSlideIn {
+    from {
+        opacity: 0;
+        transform: translateY(-10px);
+    }
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
+}
+
+/* Loading spinner smooth appearance */
+.spinner {
+    animation: spin 0.8s linear infinite, fadeIn 0.3s ease-out;
+}
+
+@keyframes fadeIn {
+    from { opacity: 0; }
+    to { opacity: 1; }
+}
+
+/* Input focus glow */
+input:focus,
+select:focus,
+textarea:focus {
+    border-color: var(--accent-cyan);
+    box-shadow: 0 0 0 2px var(--accent-cyan-dim);
+}
+
+/* Nav item active indicator */
+.nav-item,
+.mode-nav-btn,
+.mobile-nav-btn {
+    position: relative;
+}
+
+.nav-item.active::after,
+.mode-nav-btn.active::after,
+.mobile-nav-btn.active::after {
+    content: '';
+    position: absolute;
+    left: 12%;
+    right: 12%;
+    bottom: 2px;
+    height: 1px;
+    background: linear-gradient(90deg, transparent, var(--accent-cyan), transparent);
+    opacity: 0.75;
+    animation: railPulse 2.6s ease-in-out infinite;
+}
+
+@keyframes railPulse {
+    0%, 100% { opacity: 0.45; }
+    50% { opacity: 0.9; }
+}
+
+/* Smooth tooltip appearance */
+[data-tooltip]::after {
+    transition:
+        opacity var(--transition-fast),
+        visibility var(--transition-fast),
+        transform var(--transition-fast);
+    transform: translateX(-50%) translateY(-4px);
+}
+
+[data-tooltip]:hover::after {
+    transform: translateX(-50%) translateY(0);
+}
+
+/* Disabled state with better visual feedback */
+:disabled,
+.disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+    filter: grayscale(30%);
+}

static/css/core/variables.css

@@ -0,0 +1,207 @@
+/**
+ * INTERCEPT Design Tokens
+ * Single source of truth for colors, spacing, typography, and effects
+ * Import this file FIRST in any stylesheet that needs design tokens
+ */
+
+:root {
+    /* ============================================
+       COLOR PALETTE - Dark Theme (Default)
+       ============================================ */
+
+    /* Backgrounds - layered depth system */
+    --bg-primary: #0b1118;
+    --bg-secondary: #101823;
+    --bg-tertiary: #151f2b;
+    --bg-card: #121a25;
+    --bg-elevated: #1b2734;
+    --bg-overlay: rgba(8, 13, 20, 0.75);
+
+    /* Background aliases for components */
+    --bg-dark: var(--bg-primary);
+    --bg-panel: var(--bg-secondary);
+
+    /* Accent colors */
+    --accent-cyan: #4aa3ff;
+    --accent-cyan-dim: rgba(74, 163, 255, 0.16);
+    --accent-cyan-hover: #6bb3ff;
+    --accent-green: #38c180;
+    --accent-green-dim: rgba(56, 193, 128, 0.18);
+    --accent-red: #e25d5d;
+    --accent-red-dim: rgba(226, 93, 93, 0.16);
+    --accent-orange: #d6a85e;
+    --accent-orange-dim: rgba(214, 168, 94, 0.16);
+    --accent-amber: #d6a85e;
+    --accent-amber-dim: rgba(214, 168, 94, 0.18);
+    --accent-yellow: #e1c26b;
+    --accent-purple: #8f7bd6;
+
+    /* Text hierarchy */
+    --text-primary: #d7e0ee;
+    --text-secondary: #9fb0c7;
+    --text-dim: #6f7f94;
+    --text-muted: #445266;
+    --text-inverse: #0b1118;
+
+    /* Borders */
+    --border-color: #263246;
+    --border-light: #354458;
+    --border-glow: rgba(74, 163, 255, 0.25);
+    --border-focus: var(--accent-cyan);
+
+    /* Status colors */
+    --status-online: #38c180;
+    --status-warning: #d6a85e;
+    --status-error: #e25d5d;
+    --status-offline: #6f7f94;
+    --status-info: #4aa3ff;
+
+    /* Subtle grid/pattern */
+    --grid-line: rgba(74, 163, 255, 0.1);
+    --grid-dot: rgba(255, 255, 255, 0.03);
+    --noise-image: url("data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20width='40'%20height='40'%20viewBox='0%200%2040%2040'%3E%3Cg%20fill='%23ffffff'%20fill-opacity='0.05'%3E%3Ccircle%20cx='3'%20cy='5'%20r='1'/%3E%3Ccircle%20cx='11'%20cy='9'%20r='1'/%3E%3Ccircle%20cx='18'%20cy='3'%20r='1'/%3E%3Ccircle%20cx='26'%20cy='12'%20r='1'/%3E%3Ccircle%20cx='34'%20cy='6'%20r='1'/%3E%3Ccircle%20cx='7'%20cy='19'%20r='1'/%3E%3Ccircle%20cx='15'%20cy='24'%20r='1'/%3E%3Ccircle%20cx='28'%20cy='22'%20r='1'/%3E%3Ccircle%20cx='36'%20cy='18'%20r='1'/%3E%3Ccircle%20cx='5'%20cy='33'%20r='1'/%3E%3Ccircle%20cx='19'%20cy='32'%20r='1'/%3E%3Ccircle%20cx='31'%20cy='34'%20r='1'/%3E%3C/g%3E%3C/svg%3E");
+
+    /* ============================================
+       SPACING SCALE
+       ============================================ */
+    --space-1: 4px;
+    --space-2: 8px;
+    --space-3: 12px;
+    --space-4: 16px;
+    --space-5: 20px;
+    --space-6: 24px;
+    --space-8: 32px;
+    --space-10: 40px;
+    --space-12: 48px;
+    --space-16: 64px;
+
+    /* ============================================
+       TYPOGRAPHY
+       ============================================ */
+    --font-sans: 'IBM Plex Mono', 'Space Mono', ui-monospace, 'SF Mono', 'Consolas', 'Menlo', monospace;
+    --font-mono: 'IBM Plex Mono', 'Space Mono', ui-monospace, 'SF Mono', 'Consolas', 'Menlo', monospace;
+
+    /* Font sizes */
+    --text-xs: 10px;
+    --text-sm: 12px;
+    --text-base: 14px;
+    --text-lg: 16px;
+    --text-xl: 18px;
+    --text-2xl: 20px;
+    --text-3xl: 24px;
+    --text-4xl: 30px;
+
+    /* Font weights */
+    --font-normal: 400;
+    --font-medium: 500;
+    --font-semibold: 600;
+    --font-bold: 700;
+
+    /* Line heights */
+    --leading-tight: 1.25;
+    --leading-normal: 1.5;
+    --leading-relaxed: 1.75;
+
+    /* ============================================
+       BORDERS & RADIUS
+       ============================================ */
+    --radius-sm: 3px;
+    --radius-md: 4px;
+    --radius-lg: 6px;
+    --radius-xl: 8px;
+    --radius-full: 9999px;
+
+    /* ============================================
+       SHADOWS
+       ============================================ */
+    --shadow-sm: 0 1px 1px rgba(0, 0, 0, 0.35);
+    --shadow-md: 0 4px 8px rgba(0, 0, 0, 0.35);
+    --shadow-lg: 0 12px 18px rgba(0, 0, 0, 0.45);
+    --shadow-glow: 0 0 18px rgba(74, 163, 255, 0.16);
+
+    /* ============================================
+       TRANSITIONS
+       ============================================ */
+    --transition-fast: 150ms ease;
+    --transition-base: 200ms ease;
+    --transition-slow: 300ms ease;
+
+    /* ============================================
+       Z-INDEX SCALE
+       ============================================ */
+    --z-base: 0;
+    --z-dropdown: 100;
+    --z-sticky: 200;
+    --z-fixed: 300;
+    --z-modal-backdrop: 400;
+    --z-modal: 500;
+    --z-toast: 600;
+    --z-tooltip: 700;
+
+    /* ============================================
+       LAYOUT
+       ============================================ */
+    --header-height: 60px;
+    --nav-height: 44px;
+    --sidebar-width: 280px;
+    --stats-strip-height: 36px;
+    --content-max-width: 1400px;
+}
+
+/* ============================================
+   LIGHT THEME OVERRIDES
+   ============================================ */
+[data-theme="light"] {
+    --bg-primary: #f4f7fb;
+    --bg-secondary: #e9eef5;
+    --bg-tertiary: #dde5f0;
+    --bg-card: #ffffff;
+    --bg-elevated: #f1f4f9;
+    --bg-overlay: rgba(244, 247, 251, 0.92);
+
+    /* Background aliases for components */
+    --bg-dark: var(--bg-primary);
+    --bg-panel: var(--bg-secondary);
+
+    --accent-cyan: #1f5fa8;
+    --accent-cyan-dim: rgba(31, 95, 168, 0.12);
+    --accent-cyan-hover: #2c73bf;
+    --accent-green: #1f8a57;
+    --accent-green-dim: rgba(31, 138, 87, 0.12);
+    --accent-red: #c74444;
+    --accent-red-dim: rgba(199, 68, 68, 0.12);
+    --accent-orange: #b5863a;
+    --accent-orange-dim: rgba(181, 134, 58, 0.12);
+    --accent-amber: #b5863a;
+    --accent-amber-dim: rgba(181, 134, 58, 0.12);
+
+    --text-primary: #122034;
+    --text-secondary: #3a4a5f;
+    --text-dim: #6b7c93;
+    --text-muted: #aab6c8;
+    --text-inverse: #f4f7fb;
+
+    --border-color: #d1d9e6;
+    --border-light: #c1ccdb;
+    --border-glow: rgba(31, 95, 168, 0.12);
+
+    --grid-line: rgba(31, 95, 168, 0.14);
+    --grid-dot: rgba(12, 18, 24, 0.06);
+    --noise-image: url("data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20width='40'%20height='40'%20viewBox='0%200%2040%2040'%3E%3Cg%20fill='%23000000'%20fill-opacity='0.05'%3E%3Ccircle%20cx='3'%20cy='5'%20r='1'/%3E%3Ccircle%20cx='11'%20cy='9'%20r='1'/%3E%3Ccircle%20cx='18'%20cy='3'%20r='1'/%3E%3Ccircle%20cx='26'%20cy='12'%20r='1'/%3E%3Ccircle%20cx='34'%20cy='6'%20r='1'/%3E%3Ccircle%20cx='7'%20cy='19'%20r='1'/%3E%3Ccircle%20cx='15'%20cy='24'%20r='1'/%3E%3Ccircle%20cx='28'%20cy='22'%20r='1'/%3E%3Ccircle%20cx='36'%20cy='18'%20r='1'/%3E%3Ccircle%20cx='5'%20cy='33'%20r='1'/%3E%3Ccircle%20cx='19'%20cy='32'%20r='1'/%3E%3Ccircle%20cx='31'%20cy='34'%20r='1'/%3E%3C/g%3E%3C/svg%3E");
+
+    --shadow-sm: 0 1px 2px rgba(0, 0, 0, 0.05);
+    --shadow-md: 0 4px 6px rgba(0, 0, 0, 0.1);
+    --shadow-lg: 0 10px 15px rgba(0, 0, 0, 0.15);
+    --shadow-glow: 0 0 18px rgba(31, 95, 168, 0.1);
+}
+
+/* ============================================
+   REDUCED MOTION
+   ============================================ */
+@media (prefers-reduced-motion: reduce) {
+    :root {
+        --transition-fast: 0ms;
+        --transition-base: 0ms;
+        --transition-slow: 0ms;
+    }
+}

static/css/fonts-local.css

@@ -0,0 +1,18 @@
+/* Local font declarations for offline mode */
+
+/* Space Mono - Console font */
+@font-face {
+    font-family: 'Space Mono';
+    font-style: normal;
+    font-weight: 400;
+    font-display: swap;
+    src: url('/static/vendor/fonts/SpaceMono-Regular.woff2') format('woff2');
+}
+
+@font-face {
+    font-family: 'Space Mono';
+    font-style: normal;
+    font-weight: 700;
+    font-display: swap;
+    src: url('/static/vendor/fonts/SpaceMono-Bold.woff2') format('woff2');
+}

static/css/global-nav.css

@@ -0,0 +1,439 @@
+/* ============================================
+   Global Navigation Styles
+   Shared across all pages using nav.html
+   ============================================ */
+
+/* Icon base (kept lightweight for nav usage) */
+.icon {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    width: 18px;
+    height: 18px;
+    flex-shrink: 0;
+}
+
+.icon svg {
+    width: 100%;
+    height: 100%;
+}
+
+.icon--sm {
+    width: 14px;
+    height: 14px;
+}
+
+/* Mode Navigation Bar */
+.mode-nav {
+    display: none;
+    background: linear-gradient(180deg, rgba(17, 22, 32, 0.92), rgba(15, 20, 28, 0.88));
+    border-bottom: 1px solid var(--border-color, #202833);
+    padding: 0 20px;
+    position: relative;
+    z-index: 100;
+    backdrop-filter: blur(10px);
+}
+
+@media (min-width: 1024px) {
+    .mode-nav {
+        display: flex;
+        align-items: center;
+        gap: 8px;
+        height: 44px;
+    }
+}
+
+.mode-nav-label {
+    font-size: 9px;
+    color: var(--text-secondary, #b7c1cf);
+    text-transform: uppercase;
+    letter-spacing: 1px;
+    margin-right: 8px;
+    font-weight: 500;
+    font-family: var(--font-mono);
+}
+
+.mode-nav-divider {
+    width: 1px;
+    height: 24px;
+    background: var(--border-color, #202833);
+    margin: 0 12px;
+}
+
+.mode-nav-btn {
+    display: inline-flex;
+    align-items: center;
+    gap: 6px;
+    padding: 8px 14px;
+    background: transparent;
+    border: 1px solid transparent;
+    border-radius: 6px;
+    color: var(--text-secondary, #b7c1cf);
+    font-family: var(--font-sans);
+    font-size: 11px;
+    font-weight: 500;
+    cursor: pointer;
+    transition: all 0.15s ease;
+    text-decoration: none;
+}
+
+.mode-nav-btn .nav-label {
+    text-transform: uppercase;
+    letter-spacing: 0.08em;
+    font-family: var(--font-mono);
+    font-size: 10px;
+}
+
+.mode-nav-btn:hover {
+    background: rgba(27, 36, 51, 0.8);
+    color: var(--text-primary, #e7ebf2);
+    border-color: var(--border-color, #202833);
+}
+
+.mode-nav-btn.active {
+    background: rgba(27, 36, 51, 0.9);
+    color: var(--text-primary, #e7ebf2);
+    border-color: var(--accent-cyan, #4d7dbf);
+    box-shadow: inset 0 -2px 0 var(--accent-cyan, #4d7dbf);
+}
+
+.mode-nav-btn.active .nav-icon {
+    color: var(--accent-cyan, #4d7dbf);
+}
+
+.mode-nav-actions {
+    display: flex;
+    align-items: center;
+    gap: 16px;
+}
+
+.nav-action-btn {
+    display: inline-flex;
+    align-items: center;
+    gap: 6px;
+    padding: 8px 14px;
+    background: rgba(24, 31, 44, 0.85);
+    border: 1px solid var(--border-light, #2b3645);
+    border-radius: 6px;
+    color: var(--text-primary, #e7ebf2);
+    font-family: var(--font-sans);
+    font-size: 11px;
+    font-weight: 500;
+    text-decoration: none;
+    cursor: pointer;
+    transition: all 0.15s ease;
+}
+
+.nav-action-btn .nav-label {
+    text-transform: uppercase;
+    letter-spacing: 0.08em;
+    font-family: var(--font-mono);
+    font-size: 10px;
+}
+
+.nav-action-btn:hover {
+    background: rgba(27, 36, 51, 0.95);
+    color: var(--text-primary, #e7ebf2);
+    box-shadow: 0 8px 16px rgba(5, 9, 15, 0.35);
+    border-color: var(--accent-cyan, #4d7dbf);
+}
+
+/* Dropdown Navigation */
+.mode-nav-dropdown {
+    position: relative;
+}
+
+.mode-nav-dropdown-btn {
+    display: inline-flex;
+    align-items: center;
+    gap: 8px;
+    padding: 8px 14px;
+    background: transparent;
+    border: 1px solid transparent;
+    border-radius: 6px;
+    color: var(--text-secondary, #b7c1cf);
+    font-family: var(--font-sans);
+    font-size: 11px;
+    font-weight: 500;
+    cursor: pointer;
+    transition: all 0.15s ease;
+}
+
+.mode-nav-dropdown-btn .nav-label {
+    text-transform: uppercase;
+    letter-spacing: 0.08em;
+    font-family: var(--font-mono);
+    font-size: 10px;
+}
+
+.mode-nav-dropdown-btn .dropdown-arrow {
+    width: 12px;
+    height: 12px;
+    margin-left: 4px;
+    transition: transform 0.2s ease;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.mode-nav-dropdown-btn .dropdown-arrow svg {
+    width: 100%;
+    height: 100%;
+}
+
+.mode-nav-dropdown-btn:hover {
+    background: rgba(27, 36, 51, 0.8);
+    color: var(--text-primary, #e7ebf2);
+    border-color: var(--border-color, #202833);
+}
+
+.mode-nav-dropdown.open .mode-nav-dropdown-btn {
+    background: rgba(27, 36, 51, 0.9);
+    color: var(--text-primary, #e7ebf2);
+    border-color: var(--border-color, #202833);
+}
+
+.mode-nav-dropdown.open .dropdown-arrow {
+    transform: rotate(180deg);
+}
+
+.mode-nav-dropdown.has-active .mode-nav-dropdown-btn {
+    background: rgba(27, 36, 51, 0.9);
+    color: var(--text-primary, #e7ebf2);
+    border-color: var(--accent-cyan, #4d7dbf);
+    box-shadow: inset 0 -2px 0 var(--accent-cyan, #4d7dbf);
+}
+
+.mode-nav-dropdown.has-active .mode-nav-dropdown-btn .nav-icon {
+    color: var(--accent-cyan, #4d7dbf);
+}
+
+.mode-nav-dropdown-menu {
+    position: absolute;
+    top: 100%;
+    left: 0;
+    margin-top: 4px;
+    min-width: 180px;
+    background: rgba(16, 22, 32, 0.98);
+    border: 1px solid var(--border-color, #202833);
+    border-radius: 8px;
+    box-shadow: 0 16px 36px rgba(5, 9, 15, 0.55);
+    opacity: 0;
+    visibility: hidden;
+    transform: translateY(-8px);
+    transition: all 0.15s ease;
+    z-index: 1000;
+    padding: 6px;
+}
+
+.mode-nav-dropdown.open .mode-nav-dropdown-menu {
+    opacity: 1;
+    visibility: visible;
+    transform: translateY(0);
+}
+
+.mode-nav-dropdown-menu .mode-nav-btn {
+    width: 100%;
+    justify-content: flex-start;
+    padding: 10px 12px;
+    border-radius: 6px;
+}
+
+.mode-nav-dropdown-menu .mode-nav-btn:hover {
+    background: rgba(27, 36, 51, 0.85);
+}
+
+.mode-nav-dropdown-menu .mode-nav-btn.active {
+    background: rgba(27, 36, 51, 0.95);
+    color: var(--text-primary, #e7ebf2);
+    box-shadow: inset 0 -2px 0 var(--accent-cyan, #4d7dbf);
+}
+
+/* Nav Bar Utilities */
+.nav-utilities {
+    display: none;
+    align-items: center;
+    gap: 12px;
+    margin-left: auto;
+    flex-shrink: 0;
+}
+
+@media (min-width: 1024px) {
+    .nav-utilities {
+        display: flex;
+    }
+}
+
+.nav-clock {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    font-family: var(--font-mono);
+    font-size: 11px;
+    flex-shrink: 0;
+    white-space: nowrap;
+}
+
+.nav-clock .utc-label {
+    font-size: 9px;
+    color: var(--text-dim, #8a97a8);
+    text-transform: uppercase;
+    letter-spacing: 1px;
+}
+
+.nav-clock .utc-time {
+    color: var(--accent-cyan, #4d7dbf);
+    font-weight: 600;
+}
+
+.nav-divider {
+    width: 1px;
+    height: 20px;
+    background: var(--border-color, #202833);
+}
+
+.nav-tools {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    flex-shrink: 0;
+}
+
+.nav-tool-btn {
+    width: 28px;
+    height: 28px;
+    min-width: 28px;
+    border-radius: 6px;
+    background: rgba(20, 33, 53, 0.6);
+    border: 1px solid rgba(77, 125, 191, 0.12);
+    color: var(--text-secondary, #b7c1cf);
+    font-size: 14px;
+    font-weight: bold;
+    cursor: pointer;
+    transition: all 0.15s ease;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.nav-tool-btn:hover {
+    background: rgba(27, 36, 51, 0.9);
+    border-color: var(--accent-cyan, #4d7dbf);
+    color: var(--accent-cyan, #4d7dbf);
+    box-shadow: 0 6px 14px rgba(5, 9, 15, 0.35);
+}
+
+/* Position relative needed for absolute positioned icon children */
+.nav-tool-btn {
+    position: relative;
+}
+
+.mode-nav-btn:focus-visible,
+.mode-nav-dropdown-btn:focus-visible,
+.nav-action-btn:focus-visible,
+.nav-tool-btn:focus-visible {
+    outline: 2px solid var(--accent-cyan, #4d7dbf);
+    outline-offset: 2px;
+}
+
+/* Nav tool button SVG sizing and styling */
+.nav-tool-btn svg {
+    width: 14px;
+    height: 14px;
+    stroke: currentColor;
+}
+
+.nav-tool-btn .icon {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.nav-tool-btn .icon svg {
+    width: 14px;
+    height: 14px;
+    stroke: currentColor;
+}
+
+/* Theme toggle icon states */
+.nav-tool-btn .icon-sun,
+.nav-tool-btn .icon-moon {
+    position: absolute;
+    transition: opacity 0.2s, transform 0.2s;
+}
+
+.nav-tool-btn .icon-sun {
+    opacity: 0;
+    transform: rotate(-90deg);
+}
+
+.nav-tool-btn .icon-moon {
+    opacity: 1;
+    transform: rotate(0deg);
+}
+
+[data-theme="light"] .nav-tool-btn .icon-sun {
+    opacity: 1;
+    transform: rotate(0deg);
+}
+
+[data-theme="light"] .nav-tool-btn .icon-moon {
+    opacity: 0;
+    transform: rotate(90deg);
+}
+
+/* Effects/animations toggle icon states */
+.nav-tool-btn .icon-effects-off {
+    display: none;
+}
+
+[data-animations="off"] .nav-tool-btn .icon-effects-on {
+    display: none;
+}
+
+[data-animations="off"] .nav-tool-btn .icon-effects-off {
+    display: flex;
+}
+
+/* Main Dashboard Button in Nav */
+a.nav-dashboard-btn,
+a.nav-dashboard-btn:link,
+a.nav-dashboard-btn:visited {
+    display: inline-flex !important;
+    align-items: center;
+    gap: 6px;
+    padding: 6px 12px;
+    border-radius: 6px;
+    background: rgba(20, 33, 53, 0.6) !important;
+    border: 1px solid rgba(77, 125, 191, 0.12) !important;
+    color: #b7c1cf !important;
+    font-size: 11px;
+    font-weight: 500;
+    cursor: pointer;
+    transition: all 0.15s ease;
+    white-space: nowrap;
+    text-decoration: none !important;
+}
+
+a.nav-dashboard-btn:hover {
+    background: rgba(27, 36, 51, 0.9) !important;
+    border-color: #4d7dbf !important;
+    color: #4d7dbf !important;
+    box-shadow: 0 6px 14px rgba(5, 9, 15, 0.35);
+}
+
+.nav-dashboard-btn .icon {
+    width: 14px;
+    height: 14px;
+}
+
+.nav-dashboard-btn .icon svg {
+    width: 100%;
+    height: 100%;
+    stroke: currentColor;
+}
+
+.nav-dashboard-btn .nav-label {
+    font-family: var(--font-mono, 'JetBrains Mono', monospace);
+    letter-spacing: 0.5px;
+}

static/css/help-modal.css

@@ -0,0 +1,184 @@
+/**
+ * Help Modal Styles
+ * Shared across all pages that include the help modal partial
+ */
+
+.help-modal {
+    display: none;
+    position: fixed;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    background: rgba(0, 0, 0, 0.85);
+    z-index: 10000;
+    overflow-y: auto;
+    padding: 40px 20px;
+}
+
+.help-modal.active {
+    display: block;
+}
+
+.help-content {
+    max-width: 800px;
+    margin: 0 auto;
+    background: var(--bg-card, var(--bg-secondary, #0f1218));
+    border: 1px solid var(--border-color, #1f2937);
+    border-radius: 8px;
+    padding: 30px;
+    position: relative;
+}
+
+.help-content h2 {
+    color: var(--accent-cyan, #4a9eff);
+    margin-bottom: 20px;
+    font-size: 24px;
+    letter-spacing: 2px;
+}
+
+.help-content h3 {
+    color: var(--text-primary, #e8eaed);
+    margin: 25px 0 15px 0;
+    font-size: 14px;
+    text-transform: uppercase;
+    letter-spacing: 1px;
+    border-bottom: 1px solid var(--border-color, #1f2937);
+    padding-bottom: 8px;
+}
+
+.help-close {
+    position: absolute;
+    top: 15px;
+    right: 15px;
+    background: none;
+    border: none;
+    color: var(--text-dim, #4b5563);
+    font-size: 24px;
+    cursor: pointer;
+    transition: color 0.2s;
+}
+
+.help-close:hover {
+    color: var(--accent-red, #ef4444);
+}
+
+.help-modal .icon-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
+    gap: 12px;
+    margin: 15px 0;
+}
+
+.help-modal .icon-item {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    padding: 10px;
+    background: var(--bg-primary, #0a0c10);
+    border: 1px solid var(--border-color, #1f2937);
+    border-radius: 4px;
+    font-size: 12px;
+}
+
+.help-modal .icon-item .icon {
+    font-size: 18px;
+    width: 30px;
+    text-align: center;
+}
+
+.help-modal .icon-item .desc {
+    color: var(--text-secondary, #9ca3af);
+}
+
+.help-modal .tip-list {
+    list-style: none;
+    padding: 0;
+    margin: 15px 0;
+}
+
+.help-modal .tip-list li {
+    padding: 8px 0;
+    padding-left: 20px;
+    position: relative;
+    color: var(--text-secondary, #9ca3af);
+    font-size: 13px;
+    border-bottom: 1px solid var(--border-color, #1f2937);
+}
+
+.help-modal .tip-list li:last-child {
+    border-bottom: none;
+}
+
+.help-modal .tip-list li::before {
+    content: '\203A';
+    position: absolute;
+    left: 0;
+    color: var(--accent-cyan, #4a9eff);
+    font-weight: bold;
+}
+
+.help-tabs {
+    display: flex;
+    gap: 0;
+    margin-bottom: 20px;
+    border: 1px solid var(--border-color, #1f2937);
+    border-radius: 4px;
+    overflow: hidden;
+}
+
+.help-tab {
+    flex: 1;
+    padding: 10px;
+    background: var(--bg-primary, #0a0c10);
+    border: none;
+    color: var(--text-secondary, #9ca3af);
+    cursor: pointer;
+    font-size: 11px;
+    text-transform: uppercase;
+    letter-spacing: 1px;
+    transition: all 0.15s ease;
+    position: relative;
+}
+
+.help-tab:not(:last-child) {
+    border-right: 1px solid var(--border-color, #1f2937);
+}
+
+.help-tab:hover {
+    background: var(--bg-tertiary, #151a23);
+    color: var(--text-primary, #e8eaed);
+}
+
+.help-tab.active {
+    background: var(--bg-tertiary, #151a23);
+    color: var(--accent-cyan, #4a9eff);
+}
+
+.help-tab.active::after {
+    content: '';
+    position: absolute;
+    bottom: 0;
+    left: 0;
+    right: 0;
+    height: 2px;
+    background: var(--accent-cyan, #4a9eff);
+}
+
+.help-section {
+    display: none;
+}
+
+.help-section.active {
+    display: block;
+}
+
+/* Ensure code tags are styled */
+.help-modal code {
+    background: var(--bg-tertiary, #151a23);
+    padding: 2px 6px;
+    border-radius: 3px;
+    font-family: var(--font-mono, 'JetBrains Mono', monospace);
+    font-size: 11px;
+    color: var(--accent-cyan, #4a9eff);
+}

static/css/login.css

@@ -37,7 +37,7 @@
 
 /* Typography */
 .landing-title {
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 2.2rem;
     font-weight: 700;
     letter-spacing: 0.4em;
@@ -48,7 +48,7 @@
 }
 
 .landing-tagline {
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     color: var(--accent-cyan);
     font-size: 0.9rem;
     letter-spacing: 0.15em;
@@ -71,7 +71,7 @@
 
 /* Hacker Style Error */
 .flash-error {
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 10px;
     color: var(--accent-red);
     background: rgba(239, 68, 68, 0.1);
@@ -94,7 +94,7 @@
     color: var(--accent-cyan);
     padding: 12px;
     margin-bottom: 15px;
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 11px;
     outline: none;
     box-sizing: border-box; /* Crucial for visibility */
@@ -106,7 +106,7 @@
     border: 2px solid var(--accent-cyan);
     color: var(--accent-cyan);
     padding: 15px;
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-weight: 600;
     letter-spacing: 3px;
     cursor: pointer;
@@ -116,7 +116,7 @@
 
 .landing-version {
     margin-top: 25px;
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 10px;
     color: rgba(255, 255, 255, 0.3);
     letter-spacing: 2px;

static/css/modes/aprs.css

@@ -1,328 +1,328 @@
-/* APRS Function Bar (Stats Strip) Styles */
-.aprs-strip {
-    background: linear-gradient(180deg, var(--bg-panel) 0%, var(--bg-dark) 100%);
-    border: 1px solid var(--border-color);
-    border-radius: 6px;
-    padding: 6px 12px;
-    margin-bottom: 10px;
-    overflow-x: auto;
-}
-.aprs-strip-inner {
-    display: flex;
-    align-items: center;
-    gap: 8px;
-    min-width: max-content;
-}
-.aprs-strip .strip-stat {
-    display: flex;
-    flex-direction: column;
-    align-items: center;
-    padding: 4px 10px;
-    background: rgba(74, 158, 255, 0.05);
-    border: 1px solid rgba(74, 158, 255, 0.15);
-    border-radius: 4px;
-    min-width: 55px;
-}
-.aprs-strip .strip-stat:hover {
-    background: rgba(74, 158, 255, 0.1);
-    border-color: rgba(74, 158, 255, 0.3);
-}
-.aprs-strip .strip-value {
-    font-family: 'JetBrains Mono', monospace;
-    font-size: 14px;
-    font-weight: 600;
-    color: var(--accent-cyan);
-    line-height: 1.2;
-}
-.aprs-strip .strip-label {
-    font-size: 8px;
-    font-weight: 600;
-    color: var(--text-dim);
-    text-transform: uppercase;
-    letter-spacing: 0.5px;
-    margin-top: 1px;
-}
-.aprs-strip .strip-divider {
-    width: 1px;
-    height: 28px;
-    background: var(--border-color);
-    margin: 0 4px;
-}
-/* Signal stat coloring */
-.aprs-strip .signal-stat.good .strip-value { color: var(--accent-green); }
-.aprs-strip .signal-stat.warning .strip-value { color: var(--accent-yellow); }
-.aprs-strip .signal-stat.poor .strip-value { color: var(--accent-red); }
-
-/* Controls */
-.aprs-strip .strip-control {
-    display: flex;
-    align-items: center;
-    gap: 4px;
-}
-.aprs-strip .strip-select {
-    background: rgba(0,0,0,0.3);
-    border: 1px solid var(--border-color);
-    color: var(--text-primary);
-    padding: 4px 8px;
-    border-radius: 4px;
-    font-size: 10px;
-    cursor: pointer;
-}
-.aprs-strip .strip-select:hover {
-    border-color: var(--accent-cyan);
-}
-.aprs-strip .strip-input-label {
-    font-size: 9px;
-    color: var(--text-muted);
-    font-weight: 600;
-}
-.aprs-strip .strip-input {
-    background: rgba(0,0,0,0.3);
-    border: 1px solid var(--border-color);
-    color: var(--text-primary);
-    padding: 4px 6px;
-    border-radius: 4px;
-    font-size: 10px;
-    width: 50px;
-    text-align: center;
-}
-.aprs-strip .strip-input:hover,
-.aprs-strip .strip-input:focus {
-    border-color: var(--accent-cyan);
-    outline: none;
-}
-
-/* Tool Status Indicators */
-.aprs-strip .strip-tools {
-    display: flex;
-    gap: 4px;
-}
-.aprs-strip .strip-tool {
-    font-size: 9px;
-    font-weight: 600;
-    padding: 3px 6px;
-    border-radius: 3px;
-    background: rgba(255, 59, 48, 0.2);
-    color: var(--accent-red);
-    border: 1px solid rgba(255, 59, 48, 0.3);
-}
-.aprs-strip .strip-tool.ok {
-    background: rgba(0, 255, 136, 0.1);
-    color: var(--accent-green);
-    border-color: rgba(0, 255, 136, 0.3);
-}
-
-/* Buttons */
-.aprs-strip .strip-btn {
-    background: rgba(74, 158, 255, 0.1);
-    border: 1px solid rgba(74, 158, 255, 0.2);
-    color: var(--text-primary);
-    padding: 6px 12px;
-    border-radius: 4px;
-    font-size: 10px;
-    font-weight: 600;
-    cursor: pointer;
-    transition: all 0.2s;
-    white-space: nowrap;
-}
-.aprs-strip .strip-btn:hover:not(:disabled) {
-    background: rgba(74, 158, 255, 0.2);
-    border-color: rgba(74, 158, 255, 0.4);
-}
-.aprs-strip .strip-btn.primary {
-    background: linear-gradient(135deg, var(--accent-green) 0%, #10b981 100%);
-    border: none;
-    color: #000;
-}
-.aprs-strip .strip-btn.primary:hover:not(:disabled) {
-    filter: brightness(1.1);
-}
-.aprs-strip .strip-btn.stop {
-    background: linear-gradient(135deg, var(--accent-red) 0%, #dc2626 100%);
-    border: none;
-    color: #fff;
-}
-.aprs-strip .strip-btn.stop:hover:not(:disabled) {
-    filter: brightness(1.1);
-}
-.aprs-strip .strip-btn:disabled {
-    opacity: 0.5;
-    cursor: not-allowed;
-}
-
-/* Status indicator */
-.aprs-strip .strip-status {
-    display: flex;
-    align-items: center;
-    gap: 6px;
-    padding: 4px 8px;
-    background: rgba(0,0,0,0.2);
-    border-radius: 4px;
-    font-size: 10px;
-    font-weight: 600;
-    color: var(--text-secondary);
-}
-.aprs-strip .status-dot {
-    width: 8px;
-    height: 8px;
-    border-radius: 50%;
-    background: var(--text-muted);
-}
-.aprs-strip .status-dot.listening {
-    background: var(--accent-cyan);
-    animation: aprs-strip-pulse 1.5s ease-in-out infinite;
-}
-.aprs-strip .status-dot.tracking {
-    background: var(--accent-green);
-    animation: aprs-strip-pulse 1.5s ease-in-out infinite;
-}
-.aprs-strip .status-dot.error {
-    background: var(--accent-red);
-}
-@keyframes aprs-strip-pulse {
-    0%, 100% { opacity: 1; box-shadow: 0 0 4px 2px currentColor; }
-    50% { opacity: 0.6; box-shadow: none; }
-}
-
-/* Time display */
-.aprs-strip .strip-time {
-    font-family: 'JetBrains Mono', monospace;
-    font-size: 10px;
-    color: var(--text-muted);
-    padding: 4px 8px;
-    background: rgba(0,0,0,0.2);
-    border-radius: 4px;
-    white-space: nowrap;
-}
-
-/* APRS Status Bar Styles (Sidebar - legacy) */
-.aprs-status-bar {
-    margin-top: 12px;
-    padding: 10px;
-    background: rgba(0,0,0,0.3);
-    border: 1px solid var(--border-color);
-    border-radius: 4px;
-}
-.aprs-status-indicator {
-    display: flex;
-    align-items: center;
-    gap: 8px;
-    margin-bottom: 8px;
-}
-.aprs-status-dot {
-    width: 10px;
-    height: 10px;
-    border-radius: 50%;
-    background: var(--text-muted);
-}
-.aprs-status-dot.standby { background: var(--text-muted); }
-.aprs-status-dot.listening {
-    background: var(--accent-cyan);
-    animation: aprs-pulse 1.5s ease-in-out infinite;
-}
-.aprs-status-dot.tracking { background: var(--accent-green); }
-.aprs-status-dot.error { background: var(--accent-red); }
-@keyframes aprs-pulse {
-    0%, 100% { opacity: 1; box-shadow: 0 0 0 0 rgba(74, 158, 255, 0.7); }
-    50% { opacity: 0.6; box-shadow: 0 0 8px 4px rgba(74, 158, 255, 0.3); }
-}
-.aprs-status-text {
-    font-size: 10px;
-    font-weight: bold;
-    letter-spacing: 1px;
-}
-.aprs-status-stats {
-    display: flex;
-    flex-wrap: wrap;
-    gap: 8px;
-    font-size: 9px;
-}
-.aprs-stat {
-    color: var(--text-secondary);
-}
-.aprs-stat-label {
-    color: var(--text-muted);
-}
-
-/* Signal Meter Styles */
-.aprs-signal-meter {
-    margin-top: 12px;
-    padding: 10px;
-    background: rgba(0,0,0,0.3);
-    border: 1px solid var(--border-color);
-    border-radius: 4px;
-}
-.aprs-meter-header {
-    display: flex;
-    align-items: center;
-    gap: 8px;
-    margin-bottom: 8px;
-}
-.aprs-meter-label {
-    font-size: 10px;
-    font-weight: bold;
-    letter-spacing: 1px;
-    color: var(--text-secondary);
-}
-.aprs-meter-value {
-    font-size: 12px;
-    font-weight: bold;
-    font-family: monospace;
-    color: var(--accent-cyan);
-    min-width: 24px;
-}
-.aprs-meter-burst {
-    font-size: 9px;
-    font-weight: bold;
-    color: var(--accent-yellow);
-    background: rgba(255, 193, 7, 0.2);
-    padding: 2px 6px;
-    border-radius: 3px;
-    animation: burst-flash 0.3s ease-out;
-}
-@keyframes burst-flash {
-    0% { opacity: 1; transform: scale(1.1); }
-    100% { opacity: 1; transform: scale(1); }
-}
-.aprs-meter-bar-container {
-    position: relative;
-    height: 16px;
-    background: rgba(0,0,0,0.4);
-    border-radius: 3px;
-    overflow: hidden;
-    margin-bottom: 4px;
-}
-.aprs-meter-bar {
-    height: 100%;
-    width: 0%;
-    background: linear-gradient(90deg,
-        var(--accent-green) 0%,
-        var(--accent-cyan) 50%,
-        var(--accent-yellow) 75%,
-        var(--accent-red) 100%
-    );
-    border-radius: 3px;
-    transition: width 0.1s ease-out;
-}
-.aprs-meter-bar.no-signal {
-    opacity: 0.3;
-}
-.aprs-meter-ticks {
-    display: flex;
-    justify-content: space-between;
-    font-size: 8px;
-    color: var(--text-muted);
-    padding: 0 2px;
-}
-.aprs-meter-status {
-    font-size: 9px;
-    color: var(--text-muted);
-    text-align: center;
-    margin-top: 6px;
-}
-.aprs-meter-status.active {
-    color: var(--accent-green);
-}
-.aprs-meter-status.no-signal {
-    color: var(--accent-yellow);
-}
+/* APRS Function Bar (Stats Strip) Styles */
+.aprs-strip {
+    background: linear-gradient(180deg, var(--bg-panel) 0%, var(--bg-dark) 100%);
+    border: 1px solid var(--border-color);
+    border-radius: 6px;
+    padding: 6px 12px;
+    margin-bottom: 10px;
+    overflow-x: auto;
+}
+.aprs-strip-inner {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    min-width: max-content;
+}
+.aprs-strip .strip-stat {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    padding: 4px 10px;
+    background: rgba(74, 158, 255, 0.05);
+    border: 1px solid rgba(74, 158, 255, 0.15);
+    border-radius: 4px;
+    min-width: 55px;
+}
+.aprs-strip .strip-stat:hover {
+    background: rgba(74, 158, 255, 0.1);
+    border-color: rgba(74, 158, 255, 0.3);
+}
+.aprs-strip .strip-value {
+    font-family: var(--font-mono);
+    font-size: 14px;
+    font-weight: 600;
+    color: var(--accent-cyan);
+    line-height: 1.2;
+}
+.aprs-strip .strip-label {
+    font-size: 8px;
+    font-weight: 600;
+    color: var(--text-dim);
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+    margin-top: 1px;
+}
+.aprs-strip .strip-divider {
+    width: 1px;
+    height: 28px;
+    background: var(--border-color);
+    margin: 0 4px;
+}
+/* Signal stat coloring */
+.aprs-strip .signal-stat.good .strip-value { color: var(--accent-green); }
+.aprs-strip .signal-stat.warning .strip-value { color: var(--accent-yellow); }
+.aprs-strip .signal-stat.poor .strip-value { color: var(--accent-red); }
+
+/* Controls */
+.aprs-strip .strip-control {
+    display: flex;
+    align-items: center;
+    gap: 4px;
+}
+.aprs-strip .strip-select {
+    background: rgba(0,0,0,0.3);
+    border: 1px solid var(--border-color);
+    color: var(--text-primary);
+    padding: 4px 8px;
+    border-radius: 4px;
+    font-size: 10px;
+    cursor: pointer;
+}
+.aprs-strip .strip-select:hover {
+    border-color: var(--accent-cyan);
+}
+.aprs-strip .strip-input-label {
+    font-size: 9px;
+    color: var(--text-muted);
+    font-weight: 600;
+}
+.aprs-strip .strip-input {
+    background: rgba(0,0,0,0.3);
+    border: 1px solid var(--border-color);
+    color: var(--text-primary);
+    padding: 4px 6px;
+    border-radius: 4px;
+    font-size: 10px;
+    width: 50px;
+    text-align: center;
+}
+.aprs-strip .strip-input:hover,
+.aprs-strip .strip-input:focus {
+    border-color: var(--accent-cyan);
+    outline: none;
+}
+
+/* Tool Status Indicators */
+.aprs-strip .strip-tools {
+    display: flex;
+    gap: 4px;
+}
+.aprs-strip .strip-tool {
+    font-size: 9px;
+    font-weight: 600;
+    padding: 3px 6px;
+    border-radius: 3px;
+    background: rgba(255, 59, 48, 0.2);
+    color: var(--accent-red);
+    border: 1px solid rgba(255, 59, 48, 0.3);
+}
+.aprs-strip .strip-tool.ok {
+    background: rgba(0, 255, 136, 0.1);
+    color: var(--accent-green);
+    border-color: rgba(0, 255, 136, 0.3);
+}
+
+/* Buttons */
+.aprs-strip .strip-btn {
+    background: rgba(74, 158, 255, 0.1);
+    border: 1px solid rgba(74, 158, 255, 0.2);
+    color: var(--text-primary);
+    padding: 6px 12px;
+    border-radius: 4px;
+    font-size: 10px;
+    font-weight: 600;
+    cursor: pointer;
+    transition: all 0.2s;
+    white-space: nowrap;
+}
+.aprs-strip .strip-btn:hover:not(:disabled) {
+    background: rgba(74, 158, 255, 0.2);
+    border-color: rgba(74, 158, 255, 0.4);
+}
+.aprs-strip .strip-btn.primary {
+    background: linear-gradient(135deg, var(--accent-green) 0%, #10b981 100%);
+    border: none;
+    color: #000;
+}
+.aprs-strip .strip-btn.primary:hover:not(:disabled) {
+    filter: brightness(1.1);
+}
+.aprs-strip .strip-btn.stop {
+    background: linear-gradient(135deg, var(--accent-red) 0%, #dc2626 100%);
+    border: none;
+    color: #fff;
+}
+.aprs-strip .strip-btn.stop:hover:not(:disabled) {
+    filter: brightness(1.1);
+}
+.aprs-strip .strip-btn:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+}
+
+/* Status indicator */
+.aprs-strip .strip-status {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    padding: 4px 8px;
+    background: rgba(0,0,0,0.2);
+    border-radius: 4px;
+    font-size: 10px;
+    font-weight: 600;
+    color: var(--text-secondary);
+}
+.aprs-strip .status-dot {
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+    background: var(--text-muted);
+}
+.aprs-strip .status-dot.listening {
+    background: var(--accent-cyan);
+    animation: aprs-strip-pulse 1.5s ease-in-out infinite;
+}
+.aprs-strip .status-dot.tracking {
+    background: var(--accent-green);
+    animation: aprs-strip-pulse 1.5s ease-in-out infinite;
+}
+.aprs-strip .status-dot.error {
+    background: var(--accent-red);
+}
+@keyframes aprs-strip-pulse {
+    0%, 100% { opacity: 1; box-shadow: 0 0 4px 2px currentColor; }
+    50% { opacity: 0.6; box-shadow: none; }
+}
+
+/* Time display */
+.aprs-strip .strip-time {
+    font-family: var(--font-mono);
+    font-size: 10px;
+    color: var(--text-muted);
+    padding: 4px 8px;
+    background: rgba(0,0,0,0.2);
+    border-radius: 4px;
+    white-space: nowrap;
+}
+
+/* APRS Status Bar Styles (Sidebar - legacy) */
+.aprs-status-bar {
+    margin-top: 12px;
+    padding: 10px;
+    background: rgba(0,0,0,0.3);
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+}
+.aprs-status-indicator {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    margin-bottom: 8px;
+}
+.aprs-status-dot {
+    width: 10px;
+    height: 10px;
+    border-radius: 50%;
+    background: var(--text-muted);
+}
+.aprs-status-dot.standby { background: var(--text-muted); }
+.aprs-status-dot.listening {
+    background: var(--accent-cyan);
+    animation: aprs-pulse 1.5s ease-in-out infinite;
+}
+.aprs-status-dot.tracking { background: var(--accent-green); }
+.aprs-status-dot.error { background: var(--accent-red); }
+@keyframes aprs-pulse {
+    0%, 100% { opacity: 1; box-shadow: 0 0 0 0 rgba(74, 158, 255, 0.7); }
+    50% { opacity: 0.6; box-shadow: 0 0 8px 4px rgba(74, 158, 255, 0.3); }
+}
+.aprs-status-text {
+    font-size: 10px;
+    font-weight: bold;
+    letter-spacing: 1px;
+}
+.aprs-status-stats {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 8px;
+    font-size: 9px;
+}
+.aprs-stat {
+    color: var(--text-secondary);
+}
+.aprs-stat-label {
+    color: var(--text-muted);
+}
+
+/* Signal Meter Styles */
+.aprs-signal-meter {
+    margin-top: 12px;
+    padding: 10px;
+    background: rgba(0,0,0,0.3);
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+}
+.aprs-meter-header {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    margin-bottom: 8px;
+}
+.aprs-meter-label {
+    font-size: 10px;
+    font-weight: bold;
+    letter-spacing: 1px;
+    color: var(--text-secondary);
+}
+.aprs-meter-value {
+    font-size: 12px;
+    font-weight: bold;
+    font-family: monospace;
+    color: var(--accent-cyan);
+    min-width: 24px;
+}
+.aprs-meter-burst {
+    font-size: 9px;
+    font-weight: bold;
+    color: var(--accent-yellow);
+    background: rgba(255, 193, 7, 0.2);
+    padding: 2px 6px;
+    border-radius: 3px;
+    animation: burst-flash 0.3s ease-out;
+}
+@keyframes burst-flash {
+    0% { opacity: 1; transform: scale(1.1); }
+    100% { opacity: 1; transform: scale(1); }
+}
+.aprs-meter-bar-container {
+    position: relative;
+    height: 16px;
+    background: rgba(0,0,0,0.4);
+    border-radius: 3px;
+    overflow: hidden;
+    margin-bottom: 4px;
+}
+.aprs-meter-bar {
+    height: 100%;
+    width: 0%;
+    background: linear-gradient(90deg,
+        var(--accent-green) 0%,
+        var(--accent-cyan) 50%,
+        var(--accent-yellow) 75%,
+        var(--accent-red) 100%
+    );
+    border-radius: 3px;
+    transition: width 0.1s ease-out;
+}
+.aprs-meter-bar.no-signal {
+    opacity: 0.3;
+}
+.aprs-meter-ticks {
+    display: flex;
+    justify-content: space-between;
+    font-size: 8px;
+    color: var(--text-muted);
+    padding: 0 2px;
+}
+.aprs-meter-status {
+    font-size: 9px;
+    color: var(--text-muted);
+    text-align: center;
+    margin-top: 6px;
+}
+.aprs-meter-status.active {
+    color: var(--accent-green);
+}
+.aprs-meter-status.no-signal {
+    color: var(--accent-yellow);
+}

static/css/modes/spy-stations.css

@@ -27,7 +27,7 @@
 }
 
 .spy-stations-title {
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 14px;
     font-weight: 600;
     color: var(--text-primary);
@@ -101,7 +101,7 @@
 }
 
 .spy-station-name {
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 14px;
     font-weight: 600;
     color: var(--text-primary);
@@ -117,7 +117,7 @@
 
 /* Type Badge */
 .spy-station-badge {
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 9px;
     font-weight: 600;
     text-transform: uppercase;
@@ -173,7 +173,7 @@
 }
 
 .spy-meta-mode {
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 10px;
     color: var(--accent-orange);
 }
@@ -186,7 +186,7 @@
 }
 
 .spy-freq-list {
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 11px;
     color: var(--accent-cyan);
     line-height: 1.6;
@@ -199,7 +199,7 @@
 }
 
 .spy-freq-item {
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 11px;
     color: var(--accent-cyan);
     background: var(--bg-secondary);
@@ -236,7 +236,7 @@
 }
 
 .spy-freq-select {
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 10px;
     padding: 6px 8px;
     background: var(--bg-secondary);
@@ -273,7 +273,7 @@
     display: inline-flex;
     align-items: center;
     gap: 6px;
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 11px;
     font-weight: 600;
     text-transform: uppercase;

static/css/modes/sstv-general.css

@@ -0,0 +1,477 @@
+/**
+ * SSTV General Mode Styles
+ * Terrestrial Slow-Scan Television decoder interface
+ */
+
+/* ============================================
+   MODE VISIBILITY
+   ============================================ */
+#sstvGeneralMode.active {
+    display: block !important;
+}
+
+/* ============================================
+   VISUALS CONTAINER
+   ============================================ */
+.sstv-general-visuals-container {
+    display: flex;
+    flex-direction: column;
+    gap: 12px;
+    padding: 12px;
+    min-height: 0;
+    flex: 1;
+    height: 100%;
+    overflow: hidden;
+}
+
+/* ============================================
+   STATS STRIP
+   ============================================ */
+.sstv-general-stats-strip {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    padding: 8px 14px;
+    background: var(--bg-card);
+    border: 1px solid var(--border-color);
+    border-radius: 8px;
+    flex-wrap: wrap;
+    flex-shrink: 0;
+}
+
+.sstv-general-strip-group {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+}
+
+.sstv-general-strip-status {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+}
+
+.sstv-general-strip-dot {
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+    flex-shrink: 0;
+}
+
+.sstv-general-strip-dot.idle {
+    background: var(--text-dim);
+}
+
+.sstv-general-strip-dot.listening {
+    background: var(--accent-yellow);
+    animation: sstv-general-pulse 1s infinite;
+}
+
+.sstv-general-strip-dot.decoding {
+    background: var(--accent-cyan);
+    box-shadow: 0 0 6px var(--accent-cyan);
+    animation: sstv-general-pulse 0.5s infinite;
+}
+
+.sstv-general-strip-status-text {
+    font-family: var(--font-mono);
+    font-size: 10px;
+    color: var(--text-secondary);
+    text-transform: uppercase;
+}
+
+.sstv-general-strip-btn {
+    font-family: var(--font-mono);
+    font-size: 10px;
+    padding: 5px 12px;
+    border: none;
+    border-radius: 4px;
+    cursor: pointer;
+    text-transform: uppercase;
+    font-weight: 600;
+    transition: all 0.15s ease;
+}
+
+.sstv-general-strip-btn.start {
+    background: var(--accent-cyan);
+    color: var(--bg-primary);
+}
+
+.sstv-general-strip-btn.start:hover {
+    background: var(--accent-cyan-bright, #00d4ff);
+}
+
+.sstv-general-strip-btn.stop {
+    background: var(--accent-red, #ff3366);
+    color: white;
+}
+
+.sstv-general-strip-btn.stop:hover {
+    background: #ff1a53;
+}
+
+.sstv-general-strip-divider {
+    width: 1px;
+    height: 24px;
+    background: var(--border-color);
+}
+
+.sstv-general-strip-stat {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    gap: 2px;
+    min-width: 50px;
+}
+
+.sstv-general-strip-value {
+    font-family: var(--font-mono);
+    font-size: 12px;
+    font-weight: 600;
+    color: var(--text-primary);
+}
+
+.sstv-general-strip-value.accent-cyan {
+    color: var(--accent-cyan);
+}
+
+.sstv-general-strip-label {
+    font-family: var(--font-mono);
+    font-size: 8px;
+    color: var(--text-dim);
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+}
+
+/* ============================================
+   MAIN ROW (Live Decode + Gallery)
+   ============================================ */
+.sstv-general-main-row {
+    display: flex;
+    flex-direction: row;
+    gap: 12px;
+    flex: 1;
+    min-height: 0;
+    overflow: hidden;
+}
+
+/* ============================================
+   LIVE DECODE SECTION
+   ============================================ */
+.sstv-general-live-section {
+    background: var(--bg-card);
+    border: 1px solid var(--border-color);
+    border-radius: 8px;
+    overflow: hidden;
+    display: flex;
+    flex-direction: column;
+    flex: 1;
+    min-width: 300px;
+}
+
+.sstv-general-live-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 10px 14px;
+    background: rgba(0, 0, 0, 0.2);
+    border-bottom: 1px solid var(--border-color);
+}
+
+.sstv-general-live-title {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    font-family: var(--font-mono);
+    font-size: 12px;
+    font-weight: 600;
+    color: var(--text-primary);
+}
+
+.sstv-general-live-title svg {
+    color: var(--accent-cyan);
+}
+
+.sstv-general-live-content {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    padding: 16px;
+    min-height: 0;
+}
+
+.sstv-general-canvas-container {
+    position: relative;
+    background: #000;
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+    overflow: hidden;
+}
+
+.sstv-general-decode-info {
+    width: 100%;
+    margin-top: 12px;
+    display: flex;
+    flex-direction: column;
+    gap: 8px;
+}
+
+.sstv-general-mode-label {
+    font-family: var(--font-mono);
+    font-size: 11px;
+    color: var(--accent-cyan);
+    text-align: center;
+}
+
+.sstv-general-progress-bar {
+    width: 100%;
+    height: 4px;
+    background: var(--bg-secondary);
+    border-radius: 2px;
+    overflow: hidden;
+}
+
+.sstv-general-progress-bar .progress {
+    height: 100%;
+    background: linear-gradient(90deg, var(--accent-cyan), var(--accent-green));
+    border-radius: 2px;
+    transition: width 0.3s ease;
+}
+
+.sstv-general-status-message {
+    font-family: var(--font-mono);
+    font-size: 10px;
+    color: var(--text-dim);
+    text-align: center;
+}
+
+/* Idle state */
+.sstv-general-idle-state {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    text-align: center;
+    padding: 40px 20px;
+    color: var(--text-dim);
+}
+
+.sstv-general-idle-state svg {
+    width: 64px;
+    height: 64px;
+    opacity: 0.3;
+    margin-bottom: 16px;
+}
+
+.sstv-general-idle-state h4 {
+    font-size: 14px;
+    color: var(--text-secondary);
+    margin-bottom: 8px;
+}
+
+.sstv-general-idle-state p {
+    font-size: 12px;
+    max-width: 250px;
+}
+
+/* ============================================
+   GALLERY SECTION
+   ============================================ */
+.sstv-general-gallery-section {
+    background: var(--bg-card);
+    border: 1px solid var(--border-color);
+    border-radius: 8px;
+    overflow: hidden;
+    display: flex;
+    flex-direction: column;
+    flex: 1.5;
+    min-width: 300px;
+}
+
+.sstv-general-gallery-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 10px 14px;
+    background: rgba(0, 0, 0, 0.2);
+    border-bottom: 1px solid var(--border-color);
+}
+
+.sstv-general-gallery-title {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    font-family: var(--font-mono);
+    font-size: 12px;
+    font-weight: 600;
+    color: var(--text-primary);
+}
+
+.sstv-general-gallery-count {
+    font-family: var(--font-mono);
+    font-size: 10px;
+    color: var(--accent-cyan);
+    background: var(--bg-secondary);
+    padding: 2px 8px;
+    border-radius: 10px;
+}
+
+.sstv-general-gallery-grid {
+    flex: 1;
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
+    gap: 12px;
+    padding: 12px;
+    overflow-y: auto;
+    align-content: start;
+}
+
+.sstv-general-image-card {
+    background: var(--bg-secondary);
+    border: 1px solid var(--border-color);
+    border-radius: 6px;
+    overflow: hidden;
+    transition: all 0.15s ease;
+    cursor: pointer;
+}
+
+.sstv-general-image-card:hover {
+    border-color: var(--accent-cyan);
+    transform: translateY(-2px);
+    box-shadow: 0 4px 12px rgba(0, 212, 255, 0.2);
+}
+
+.sstv-general-image-preview {
+    width: 100%;
+    aspect-ratio: 4/3;
+    object-fit: cover;
+    background: #000;
+    display: block;
+}
+
+.sstv-general-image-info {
+    padding: 8px 10px;
+    border-top: 1px solid var(--border-color);
+}
+
+.sstv-general-image-mode {
+    font-family: var(--font-mono);
+    font-size: 10px;
+    font-weight: 600;
+    color: var(--accent-cyan);
+    margin-bottom: 4px;
+}
+
+.sstv-general-image-timestamp {
+    font-family: var(--font-mono);
+    font-size: 9px;
+    color: var(--text-dim);
+}
+
+/* Empty gallery state */
+.sstv-general-gallery-empty {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    padding: 60px 20px;
+    text-align: center;
+    color: var(--text-dim);
+    grid-column: 1 / -1;
+}
+
+.sstv-general-gallery-empty svg {
+    width: 48px;
+    height: 48px;
+    opacity: 0.3;
+    margin-bottom: 12px;
+}
+
+/* ============================================
+   IMAGE MODAL
+   ============================================ */
+.sstv-general-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;
+}
+
+.sstv-general-image-modal.show {
+    display: flex;
+}
+
+.sstv-general-image-modal img {
+    max-width: 100%;
+    max-height: 100%;
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+}
+
+.sstv-general-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;
+}
+
+.sstv-general-modal-close:hover {
+    opacity: 1;
+}
+
+/* ============================================
+   RESPONSIVE
+   ============================================ */
+@media (max-width: 1024px) {
+    .sstv-general-main-row {
+        flex-direction: column;
+        overflow-y: auto;
+    }
+
+    .sstv-general-live-section {
+        max-width: none;
+        min-height: 350px;
+    }
+
+    .sstv-general-gallery-section {
+        min-height: 300px;
+    }
+}
+
+@media (max-width: 768px) {
+    .sstv-general-stats-strip {
+        padding: 8px 12px;
+        gap: 8px;
+        flex-wrap: wrap;
+    }
+
+    .sstv-general-strip-divider {
+        display: none;
+    }
+
+    .sstv-general-gallery-grid {
+        grid-template-columns: repeat(auto-fill, minmax(150px, 1fr));
+        gap: 8px;
+        padding: 8px;
+    }
+}
+
+@keyframes sstv-general-pulse {
+    0%, 100% { opacity: 1; }
+    50% { opacity: 0.4; }
+}

static/css/modes/sstv.css

@@ -0,0 +1,876 @@
+/**
+ * SSTV Mode Styles
+ * ISS Slow-Scan Television decoder interface
+ */
+
+/* ============================================
+   MODE VISIBILITY
+   ============================================ */
+#sstvMode.active {
+    display: block !important;
+}
+
+/* ============================================
+   VISUALS CONTAINER
+   ============================================ */
+.sstv-visuals-container {
+    display: flex;
+    flex-direction: column;
+    gap: 12px;
+    padding: 12px;
+    min-height: 0;
+    flex: 1;
+    height: 100%;
+    overflow: hidden;
+}
+
+/* ============================================
+   MAIN ROW (Live Decode + Gallery)
+   ============================================ */
+.sstv-main-row {
+    display: flex;
+    flex-direction: row;
+    gap: 12px;
+    flex: 1;
+    min-height: 0;
+    overflow: hidden;
+}
+
+/* ============================================
+   STATS STRIP
+   ============================================ */
+.sstv-stats-strip {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    padding: 8px 14px;
+    background: var(--bg-card);
+    border: 1px solid var(--border-color);
+    border-radius: 8px;
+    flex-wrap: wrap;
+    flex-shrink: 0;
+}
+
+.sstv-strip-group {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+}
+
+.sstv-strip-status {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+}
+
+.sstv-strip-dot {
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+    flex-shrink: 0;
+}
+
+.sstv-strip-dot.idle {
+    background: var(--text-dim);
+}
+
+.sstv-strip-dot.listening {
+    background: var(--accent-yellow);
+    animation: pulse 1s infinite;
+}
+
+.sstv-strip-dot.decoding {
+    background: var(--accent-cyan);
+    box-shadow: 0 0 6px var(--accent-cyan);
+    animation: pulse 0.5s infinite;
+}
+
+.sstv-strip-status-text {
+    font-family: var(--font-mono);
+    font-size: 10px;
+    color: var(--text-secondary);
+    text-transform: uppercase;
+}
+
+.sstv-strip-btn {
+    font-family: var(--font-mono);
+    font-size: 10px;
+    padding: 5px 12px;
+    border: none;
+    border-radius: 4px;
+    cursor: pointer;
+    text-transform: uppercase;
+    font-weight: 600;
+    transition: all 0.15s ease;
+}
+
+.sstv-strip-btn.start {
+    background: var(--accent-cyan);
+    color: var(--bg-primary);
+}
+
+.sstv-strip-btn.start:hover {
+    background: var(--accent-cyan-bright, #00d4ff);
+}
+
+.sstv-strip-btn.stop {
+    background: var(--accent-red, #ff3366);
+    color: white;
+}
+
+.sstv-strip-btn.stop:hover {
+    background: #ff1a53;
+}
+
+.sstv-strip-divider {
+    width: 1px;
+    height: 24px;
+    background: var(--border-color);
+}
+
+.sstv-strip-stat {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    gap: 2px;
+    min-width: 50px;
+}
+
+.sstv-strip-value {
+    font-family: var(--font-mono);
+    font-size: 12px;
+    font-weight: 600;
+    color: var(--text-primary);
+}
+
+.sstv-strip-value.accent-cyan {
+    color: var(--accent-cyan);
+}
+
+.sstv-strip-label {
+    font-family: var(--font-mono);
+    font-size: 8px;
+    color: var(--text-dim);
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+}
+
+/* Location inputs in strip */
+.sstv-strip-location {
+    display: flex;
+    align-items: center;
+    gap: 4px;
+}
+
+.sstv-loc-input {
+    width: 70px;
+    padding: 4px 6px;
+    font-family: var(--font-mono);
+    font-size: 10px;
+    background: var(--bg-secondary);
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+    color: var(--text-primary);
+    text-align: right;
+}
+
+.sstv-loc-input:focus {
+    outline: none;
+    border-color: var(--accent-cyan);
+}
+
+.sstv-strip-btn.gps {
+    display: flex;
+    align-items: center;
+    gap: 4px;
+    background: var(--bg-tertiary);
+    color: var(--text-secondary);
+    border: 1px solid var(--border-color);
+}
+
+.sstv-strip-btn.gps:hover {
+    background: var(--accent-green);
+    color: #000;
+    border-color: var(--accent-green);
+}
+
+.sstv-strip-btn.update-tle {
+    display: flex;
+    align-items: center;
+    gap: 4px;
+    background: var(--bg-tertiary);
+    color: var(--text-secondary);
+    border: 1px solid var(--border-color);
+}
+
+.sstv-strip-btn.update-tle:hover {
+    background: var(--accent-orange);
+    color: #000;
+    border-color: var(--accent-orange);
+}
+
+/* ============================================
+   LIVE DECODE SECTION
+   ============================================ */
+.sstv-live-section {
+    background: var(--bg-card);
+    border: 1px solid var(--border-color);
+    border-radius: 8px;
+    overflow: hidden;
+    display: flex;
+    flex-direction: column;
+    flex: 1;
+    min-width: 300px;
+}
+
+.sstv-live-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 10px 14px;
+    background: rgba(0, 0, 0, 0.2);
+    border-bottom: 1px solid var(--border-color);
+}
+
+.sstv-live-title {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    font-family: var(--font-mono);
+    font-size: 12px;
+    font-weight: 600;
+    color: var(--text-primary);
+}
+
+.sstv-live-title svg {
+    color: var(--accent-cyan);
+}
+
+.sstv-live-content {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    padding: 16px;
+    min-height: 0;
+}
+
+.sstv-canvas-container {
+    position: relative;
+    background: #000;
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+    overflow: hidden;
+}
+
+#sstvCanvas {
+    display: block;
+    image-rendering: pixelated;
+}
+
+.sstv-decode-info {
+    width: 100%;
+    margin-top: 12px;
+    display: flex;
+    flex-direction: column;
+    gap: 8px;
+}
+
+.sstv-mode-label {
+    font-family: var(--font-mono);
+    font-size: 11px;
+    color: var(--accent-cyan);
+    text-align: center;
+}
+
+.sstv-progress-bar {
+    width: 100%;
+    height: 4px;
+    background: var(--bg-secondary);
+    border-radius: 2px;
+    overflow: hidden;
+}
+
+.sstv-progress-bar .progress {
+    height: 100%;
+    background: linear-gradient(90deg, var(--accent-cyan), var(--accent-green));
+    border-radius: 2px;
+    transition: width 0.3s ease;
+}
+
+.sstv-status-message {
+    font-family: var(--font-mono);
+    font-size: 10px;
+    color: var(--text-dim);
+    text-align: center;
+}
+
+/* Idle state */
+.sstv-idle-state {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    text-align: center;
+    padding: 40px 20px;
+    color: var(--text-dim);
+}
+
+.sstv-idle-state svg {
+    width: 64px;
+    height: 64px;
+    opacity: 0.3;
+    margin-bottom: 16px;
+}
+
+.sstv-idle-state h4 {
+    font-size: 14px;
+    color: var(--text-secondary);
+    margin-bottom: 8px;
+}
+
+.sstv-idle-state p {
+    font-size: 12px;
+    max-width: 250px;
+}
+
+/* ============================================
+   GALLERY SECTION
+   ============================================ */
+.sstv-gallery-section {
+    background: var(--bg-card);
+    border: 1px solid var(--border-color);
+    border-radius: 8px;
+    overflow: hidden;
+    display: flex;
+    flex-direction: column;
+    flex: 1.5;
+    min-width: 300px;
+}
+
+.sstv-gallery-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 10px 14px;
+    background: rgba(0, 0, 0, 0.2);
+    border-bottom: 1px solid var(--border-color);
+}
+
+.sstv-gallery-title {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    font-family: var(--font-mono);
+    font-size: 12px;
+    font-weight: 600;
+    color: var(--text-primary);
+}
+
+.sstv-gallery-count {
+    font-family: var(--font-mono);
+    font-size: 10px;
+    color: var(--accent-cyan);
+    background: var(--bg-secondary);
+    padding: 2px 8px;
+    border-radius: 10px;
+}
+
+.sstv-gallery-grid {
+    flex: 1;
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
+    gap: 12px;
+    padding: 12px;
+    overflow-y: auto;
+    align-content: start;
+}
+
+.sstv-image-card {
+    background: var(--bg-secondary);
+    border: 1px solid var(--border-color);
+    border-radius: 6px;
+    overflow: hidden;
+    transition: all 0.15s ease;
+    cursor: pointer;
+}
+
+.sstv-image-card:hover {
+    border-color: var(--accent-cyan);
+    transform: translateY(-2px);
+    box-shadow: 0 4px 12px rgba(0, 212, 255, 0.2);
+}
+
+.sstv-image-preview {
+    width: 100%;
+    aspect-ratio: 4/3;
+    object-fit: cover;
+    background: #000;
+    display: block;
+}
+
+.sstv-image-info {
+    padding: 8px 10px;
+    border-top: 1px solid var(--border-color);
+}
+
+.sstv-image-mode {
+    font-family: var(--font-mono);
+    font-size: 10px;
+    font-weight: 600;
+    color: var(--accent-cyan);
+    margin-bottom: 4px;
+}
+
+.sstv-image-timestamp {
+    font-family: var(--font-mono);
+    font-size: 9px;
+    color: var(--text-dim);
+}
+
+/* Empty gallery state */
+.sstv-gallery-empty {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    padding: 60px 20px;
+    text-align: center;
+    color: var(--text-dim);
+    grid-column: 1 / -1;
+}
+
+.sstv-gallery-empty svg {
+    width: 48px;
+    height: 48px;
+    opacity: 0.3;
+    margin-bottom: 12px;
+}
+
+/* ============================================
+   TOP ROW (Map + Countdown)
+   ============================================ */
+.sstv-top-row {
+    display: flex;
+    gap: 12px;
+    height: 220px;
+    flex-shrink: 0;
+}
+
+/* ============================================
+   ISS MAP ROW
+   ============================================ */
+.sstv-map-row {
+    flex: 1.5;
+    min-width: 0;
+    height: 100%;
+}
+
+.sstv-map-container {
+    position: relative;
+    background: var(--bg-card);
+    border: 1px solid var(--border-color);
+    border-radius: 8px;
+    overflow: hidden;
+    height: 100%;
+}
+
+.sstv-iss-map {
+    width: 100%;
+    height: 100%;
+    background: #0a1628;
+}
+
+.sstv-map-overlay {
+    position: absolute;
+    bottom: 0;
+    left: 0;
+    right: 0;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 8px 12px;
+    background: linear-gradient(transparent, rgba(0, 0, 0, 0.8));
+    pointer-events: none;
+    z-index: 1000;
+}
+
+.sstv-map-info {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    font-family: var(--font-mono);
+}
+
+.sstv-map-label {
+    font-size: 10px;
+    font-weight: bold;
+    color: #ffcc00;
+    background: rgba(255, 204, 0, 0.2);
+    padding: 2px 6px;
+    border-radius: 3px;
+}
+
+.sstv-map-coords {
+    font-size: 11px;
+    color: var(--accent-cyan);
+}
+
+.sstv-map-alt {
+    font-size: 10px;
+    color: var(--text-secondary);
+}
+
+.sstv-pass-info {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    font-family: var(--font-mono);
+}
+
+.sstv-pass-label {
+    font-size: 9px;
+    color: var(--text-dim);
+    text-transform: uppercase;
+}
+
+.sstv-pass-value {
+    font-size: 11px;
+    color: var(--text-primary);
+}
+
+/* ============================================
+   ISS MAP MARKER
+   ============================================ */
+.sstv-iss-marker {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+}
+
+.sstv-iss-dot {
+    width: 16px;
+    height: 16px;
+    background: #ffcc00;
+    border: 2px solid #fff;
+    border-radius: 50%;
+    box-shadow: 0 0 15px rgba(255, 204, 0, 0.8), 0 0 30px rgba(255, 204, 0, 0.4);
+    animation: iss-pulse 2s ease-in-out infinite;
+}
+
+.sstv-iss-label {
+    font-family: var(--font-mono);
+    font-size: 10px;
+    font-weight: bold;
+    color: #ffcc00;
+    text-shadow: 0 0 3px rgba(0, 0, 0, 0.8), 0 0 6px rgba(0, 0, 0, 0.5);
+    margin-top: 2px;
+}
+
+@keyframes iss-pulse {
+    0%, 100% {
+        box-shadow: 0 0 15px rgba(255, 204, 0, 0.8), 0 0 30px rgba(255, 204, 0, 0.4);
+    }
+    50% {
+        box-shadow: 0 0 25px rgba(255, 204, 0, 1), 0 0 50px rgba(255, 204, 0, 0.6);
+    }
+}
+
+/* Override Leaflet default marker styles */
+.leaflet-marker-icon.sstv-iss-marker {
+    background: transparent;
+    border: none;
+}
+
+/* ============================================
+   COUNTDOWN PANEL
+   ============================================ */
+.sstv-countdown-panel {
+    flex: 1;
+    min-width: 280px;
+    max-width: 380px;
+    background: var(--bg-card);
+    border: 1px solid var(--border-color);
+    border-radius: 8px;
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
+    height: 100%;
+}
+
+.sstv-countdown-header {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    padding: 10px 14px;
+    background: rgba(0, 0, 0, 0.2);
+    border-bottom: 1px solid var(--border-color);
+    font-family: var(--font-mono);
+    font-size: 12px;
+    font-weight: 600;
+    color: var(--text-primary);
+}
+
+.sstv-countdown-header svg {
+    color: var(--accent-cyan);
+}
+
+.sstv-countdown-body {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    padding: 12px;
+    gap: 10px;
+}
+
+.sstv-countdown-timer {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    gap: 4px;
+}
+
+.sstv-countdown-value {
+    font-family: var(--font-mono);
+    font-size: 28px;
+    font-weight: 700;
+    color: var(--accent-cyan);
+    letter-spacing: 2px;
+    text-shadow: 0 0 20px rgba(0, 212, 255, 0.3);
+}
+
+.sstv-countdown-value.imminent {
+    color: var(--accent-green);
+    text-shadow: 0 0 20px rgba(0, 255, 136, 0.4);
+    animation: countdown-pulse 1s ease-in-out infinite;
+}
+
+.sstv-countdown-value.active {
+    color: var(--accent-yellow);
+    text-shadow: 0 0 20px rgba(255, 204, 0, 0.4);
+    animation: countdown-pulse 0.5s ease-in-out infinite;
+}
+
+@keyframes countdown-pulse {
+    0%, 100% { opacity: 1; }
+    50% { opacity: 0.7; }
+}
+
+.sstv-countdown-label {
+    font-family: var(--font-mono);
+    font-size: 10px;
+    color: var(--text-dim);
+    text-transform: uppercase;
+    letter-spacing: 1px;
+}
+
+.sstv-countdown-details {
+    display: grid;
+    grid-template-columns: repeat(2, 1fr);
+    gap: 6px 12px;
+    width: 100%;
+    padding: 10px;
+    background: var(--bg-secondary);
+    border-radius: 6px;
+}
+
+.sstv-countdown-detail {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    gap: 2px;
+}
+
+.sstv-detail-label {
+    font-family: var(--font-mono);
+    font-size: 8px;
+    color: var(--text-dim);
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+}
+
+.sstv-detail-value {
+    font-family: var(--font-mono);
+    font-size: 12px;
+    font-weight: 600;
+    color: var(--text-primary);
+}
+
+.sstv-countdown-status {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 6px;
+    padding: 8px 14px;
+    background: rgba(0, 0, 0, 0.15);
+    border-top: 1px solid var(--border-color);
+    font-family: var(--font-mono);
+    font-size: 9px;
+    color: var(--text-dim);
+    text-transform: uppercase;
+}
+
+.sstv-countdown-status .sstv-status-dot {
+    width: 6px;
+    height: 6px;
+    border-radius: 50%;
+    background: var(--text-dim);
+}
+
+.sstv-countdown-status.has-pass .sstv-status-dot {
+    background: var(--accent-cyan);
+}
+
+.sstv-countdown-status.imminent .sstv-status-dot {
+    background: var(--accent-green);
+    animation: pulse 1s infinite;
+}
+
+.sstv-countdown-status.active .sstv-status-dot {
+    background: var(--accent-yellow);
+    box-shadow: 0 0 8px var(--accent-yellow);
+    animation: pulse 0.5s infinite;
+}
+
+/* ============================================
+   IMAGE MODAL
+   ============================================ */
+.sstv-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;
+}
+
+.sstv-image-modal.show {
+    display: flex;
+}
+
+.sstv-image-modal img {
+    max-width: 100%;
+    max-height: 100%;
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+}
+
+.sstv-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;
+}
+
+.sstv-modal-close:hover {
+    opacity: 1;
+}
+
+/* ============================================
+   RESPONSIVE
+   ============================================ */
+@media (max-width: 1024px) {
+    .sstv-main-row {
+        flex-direction: column;
+        overflow-y: auto;
+    }
+
+    .sstv-live-section {
+        max-width: none;
+        min-height: 350px;
+    }
+
+    .sstv-gallery-section {
+        min-height: 300px;
+    }
+}
+
+@media (max-width: 1024px) {
+    .sstv-top-row {
+        flex-direction: column;
+        height: auto;
+    }
+
+    .sstv-map-row {
+        flex: none;
+        height: 180px;
+    }
+
+    .sstv-countdown-panel {
+        min-width: auto;
+        max-width: none;
+        height: auto;
+    }
+
+    .sstv-countdown-value {
+        font-size: 24px;
+    }
+
+    .sstv-iss-map {
+        height: 180px;
+    }
+
+    .sstv-map-overlay {
+        flex-direction: column;
+        align-items: flex-start;
+        gap: 4px;
+    }
+}
+
+@media (max-width: 768px) {
+    .sstv-stats-strip {
+        padding: 8px 12px;
+        gap: 8px;
+        flex-wrap: wrap;
+    }
+
+    .sstv-strip-divider {
+        display: none;
+    }
+
+    .sstv-strip-location {
+        flex-wrap: wrap;
+    }
+
+    .sstv-loc-input {
+        width: 55px;
+    }
+
+    .sstv-gallery-grid {
+        grid-template-columns: repeat(auto-fill, minmax(150px, 1fr));
+        gap: 8px;
+        padding: 8px;
+    }
+
+    .sstv-iss-map {
+        height: 150px;
+    }
+
+    .sstv-map-info {
+        gap: 8px;
+    }
+
+    .sstv-map-overlay {
+        padding: 6px 10px;
+    }
+}
+
+@keyframes pulse {
+    0%, 100% { opacity: 1; }
+    50% { opacity: 0.4; }
+}

static/css/satellite_dashboard.css

@@ -5,25 +5,28 @@
 }
 
 :root {
-    --bg-dark: #0a0c10;
-    --bg-panel: #0f1218;
-    --bg-card: #151a23;
-    --border-color: #1f2937;
-    --border-glow: #4a9eff;
-    --text-primary: #e8eaed;
-    --text-secondary: #9ca3af;
-    --text-dim: #4b5563;
-    --accent-cyan: #4a9eff;
-    --accent-green: #22c55e;
-    --accent-orange: #f59e0b;
-    --accent-red: #ef4444;
-    --accent-purple: #a855f7;
-    --accent-amber: #d4a853;
-    --grid-line: rgba(74, 158, 255, 0.08);
+    --font-sans: 'IBM Plex Mono', 'Space Mono', ui-monospace, 'SF Mono', 'Consolas', 'Menlo', monospace;
+    --font-mono: 'IBM Plex Mono', 'Space Mono', ui-monospace, 'SF Mono', 'Consolas', 'Menlo', monospace;
+    --bg-dark: #0b1118;
+    --bg-panel: #101823;
+    --bg-card: #151f2b;
+    --border-color: #263246;
+    --border-glow: #4aa3ff;
+    --text-primary: #d7e0ee;
+    --text-secondary: #9fb0c7;
+    --text-dim: #6f7f94;
+    --accent-cyan: #4aa3ff;
+    --accent-green: #38c180;
+    --accent-orange: #d6a85e;
+    --accent-red: #e25d5d;
+    --accent-purple: #8f7bd6;
+    --accent-amber: #d6a85e;
+    --grid-line: rgba(74, 163, 255, 0.1);
+    --noise-image: url("data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20width='40'%20height='40'%20viewBox='0%200%2040%2040'%3E%3Cg%20fill='%23ffffff'%20fill-opacity='0.05'%3E%3Ccircle%20cx='3'%20cy='5'%20r='1'/%3E%3Ccircle%20cx='11'%20cy='9'%20r='1'/%3E%3Ccircle%20cx='18'%20cy='3'%20r='1'/%3E%3Ccircle%20cx='26'%20cy='12'%20r='1'/%3E%3Ccircle%20cx='34'%20cy='6'%20r='1'/%3E%3Ccircle%20cx='7'%20cy='19'%20r='1'/%3E%3Ccircle%20cx='15'%20cy='24'%20r='1'/%3E%3Ccircle%20cx='28'%20cy='22'%20r='1'/%3E%3Ccircle%20cx='36'%20cy='18'%20r='1'/%3E%3Ccircle%20cx='5'%20cy='33'%20r='1'/%3E%3Ccircle%20cx='19'%20cy='32'%20r='1'/%3E%3Ccircle%20cx='31'%20cy='34'%20r='1'/%3E%3C/g%3E%3C/svg%3E");
 }
 
 body {
-    font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif;
+    font-family: var(--font-sans);
     background: var(--bg-dark);
     color: var(--text-primary);
     min-height: 100vh;
@@ -38,9 +41,10 @@ body {
     right: 0;
     bottom: 0;
     background-image:
+        var(--noise-image),
         linear-gradient(var(--grid-line) 1px, transparent 1px),
         linear-gradient(90deg, var(--grid-line) 1px, transparent 1px);
-    background-size: 50px 50px;
+    background-size: 40px 40px, 50px 50px, 50px 50px;
     animation: gridMove 20s linear infinite;
     pointer-events: none;
     z-index: 0;
@@ -62,12 +66,14 @@ body {
     top: 0;
     left: 0;
     right: 0;
-    height: 4px;
+    height: 2px;
     background: linear-gradient(90deg, transparent, var(--accent-cyan), transparent);
-    animation: scan 3s linear infinite;
+    color: var(--accent-cyan);
+    animation: scan 6s linear infinite;
     pointer-events: none;
     z-index: 1000;
-    opacity: 0.5;
+    opacity: 0.25;
+    box-shadow: 0 0 8px currentColor;
 }
 
 @keyframes scan {
@@ -92,8 +98,20 @@ body {
     align-items: center;
 }
 
+.header::after {
+    content: '';
+    position: absolute;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    height: 2px;
+    background: linear-gradient(90deg, transparent, var(--accent-cyan), transparent);
+    opacity: 0.6;
+    pointer-events: none;
+}
+
 .logo {
-    font-family: 'Inter', sans-serif;
+    font-family: var(--font-sans);
     font-size: 20px;
     font-weight: 700;
     letter-spacing: 3px;
@@ -142,7 +160,7 @@ body {
     border: 1px solid rgba(0, 212, 255, 0.3);
     border-radius: 4px;
     padding: 4px 10px;
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 11px;
 }
 
@@ -162,10 +180,45 @@ body {
 
 .status-bar {
     display: flex;
-    gap: 20px;
+    gap: 12px;
     align-items: center;
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 11px;
+    flex-wrap: nowrap;
+}
+
+.location-selector {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+}
+
+.location-selector .location-label {
+    color: var(--text-secondary);
+    font-size: 10px;
+}
+
+.location-selector .location-select {
+    padding: 4px 8px;
+    background: var(--bg-card);
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+    color: var(--text-primary);
+    font-size: 11px;
+    font-family: var(--font-mono);
+}
+
+.location-selector .location-status-dot {
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+    background: var(--accent-green);
+    box-shadow: 0 0 6px var(--accent-green);
+}
+
+.location-selector .location-status-dot.offline {
+    background: var(--accent-red);
+    box-shadow: 0 0 6px var(--accent-red);
 }
 
 .status-item {
@@ -211,6 +264,7 @@ body {
 }
 
 /* Main dashboard grid */
+/* Header ~52px + Nav 44px = ~96px, using 100px for safety */
 .dashboard {
     position: relative;
     z-index: 10;
@@ -218,7 +272,7 @@ body {
     grid-template-columns: 1fr 1fr 340px;
     grid-template-rows: 1fr auto;
     gap: 0;
-    height: calc(100vh - 60px);
+    height: calc(100vh - 100px);
     min-height: 500px;
 }
 
@@ -457,7 +511,7 @@ body {
 }
 
 .telemetry-value {
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 12px;
     color: var(--accent-cyan);
 }
@@ -543,7 +597,7 @@ body {
 }
 
 .pass-time {
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
 }
 
 /* Bottom controls bar */
@@ -579,7 +633,7 @@ body {
     border: 1px solid rgba(0, 212, 255, 0.3);
     border-radius: 4px;
     color: var(--accent-cyan);
-    font-family: 'JetBrains Mono', monospace;
+    font-family: var(--font-mono);
     font-size: 11px;
 }
 
@@ -626,10 +680,7 @@ body {
     background: var(--bg-dark) !important;
 }
 
-.leaflet-tile-pane,
-.leaflet-container .leaflet-tile-pane {
-    filter: invert(1) hue-rotate(180deg) brightness(0.8) contrast(1.2) !important;
-}
+/* Using actual dark tiles now - no filter needed */
 
 .leaflet-control-zoom a {
     background: var(--bg-panel) !important;
@@ -699,7 +750,7 @@ body {
         display: flex;
         flex-direction: column;
         height: auto;
-        min-height: calc(100vh - 60px);
+        min-height: calc(100vh - 100px);
     }
 
     .polar-container,
@@ -751,4 +802,4 @@ body.embedded .panel {
 
 body.embedded .controls-bar {
     padding: 10px 15px;
-}
+}

static/css/settings.css

@@ -0,0 +1,449 @@
+/* Settings Modal Styles */
+
+.settings-modal {
+    display: none;
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background: rgba(0, 0, 0, 0.85);
+    z-index: 10000;
+    overflow-y: auto;
+    backdrop-filter: blur(4px);
+}
+
+.settings-modal.active {
+    display: flex;
+    justify-content: center;
+    align-items: flex-start;
+    padding: 40px 20px;
+}
+
+.settings-content {
+    background: var(--bg-dark, #0a0a0f);
+    border: 1px solid var(--border-color, #1a1a2e);
+    border-radius: 8px;
+    max-width: 600px;
+    width: 100%;
+    position: relative;
+    box-shadow: 0 20px 60px rgba(0, 0, 0, 0.5);
+}
+
+.settings-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 16px 20px;
+    border-bottom: 1px solid var(--border-color, #1a1a2e);
+}
+
+.settings-header h2 {
+    margin: 0;
+    font-size: 16px;
+    font-weight: 600;
+    color: var(--text-primary, #e0e0e0);
+    display: flex;
+    align-items: center;
+    gap: 8px;
+}
+
+.settings-header h2 .icon {
+    width: 20px;
+    height: 20px;
+    color: var(--accent-cyan, #00d4ff);
+}
+
+.settings-close {
+    background: none;
+    border: none;
+    color: var(--text-muted, #666);
+    font-size: 24px;
+    cursor: pointer;
+    padding: 4px;
+    line-height: 1;
+    transition: color 0.2s;
+}
+
+.settings-close:hover {
+    color: var(--accent-red, #ff4444);
+}
+
+/* Settings Tabs */
+.settings-tabs {
+    display: flex;
+    border-bottom: 1px solid var(--border-color, #1a1a2e);
+    padding: 0 20px;
+    gap: 4px;
+}
+
+.settings-tab {
+    background: none;
+    border: none;
+    padding: 12px 16px;
+    color: var(--text-muted, #666);
+    font-size: 13px;
+    font-weight: 500;
+    cursor: pointer;
+    position: relative;
+    transition: color 0.2s;
+}
+
+.settings-tab:hover {
+    color: var(--text-primary, #e0e0e0);
+}
+
+.settings-tab.active {
+    color: var(--accent-cyan, #00d4ff);
+}
+
+.settings-tab.active::after {
+    content: '';
+    position: absolute;
+    bottom: -1px;
+    left: 0;
+    right: 0;
+    height: 2px;
+    background: var(--accent-cyan, #00d4ff);
+}
+
+/* Settings Sections */
+.settings-section {
+    display: none;
+    padding: 20px;
+}
+
+.settings-section.active {
+    display: block;
+}
+
+.settings-group {
+    margin-bottom: 24px;
+}
+
+.settings-group:last-child {
+    margin-bottom: 0;
+}
+
+.settings-group-title {
+    font-size: 11px;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+    color: var(--text-muted, #666);
+    margin-bottom: 12px;
+}
+
+/* Settings Row */
+.settings-row {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 12px 0;
+    border-bottom: 1px solid rgba(255, 255, 255, 0.05);
+}
+
+.settings-row:last-child {
+    border-bottom: none;
+}
+
+.settings-label {
+    display: flex;
+    flex-direction: column;
+    gap: 2px;
+}
+
+.settings-label-text {
+    font-size: 13px;
+    color: var(--text-primary, #e0e0e0);
+}
+
+.settings-label-desc {
+    font-size: 11px;
+    color: var(--text-muted, #666);
+}
+
+/* Toggle Switch */
+.toggle-switch {
+    position: relative;
+    width: 44px;
+    height: 24px;
+    flex-shrink: 0;
+}
+
+.toggle-switch input {
+    opacity: 0;
+    width: 0;
+    height: 0;
+}
+
+.toggle-slider {
+    position: absolute;
+    cursor: pointer;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    background-color: var(--bg-tertiary, #1a1a2e);
+    border: 1px solid var(--border-color, #2a2a3e);
+    transition: 0.3s;
+    border-radius: 24px;
+}
+
+.toggle-slider:before {
+    position: absolute;
+    content: "";
+    height: 18px;
+    width: 18px;
+    left: 2px;
+    bottom: 2px;
+    background-color: var(--text-muted, #666);
+    transition: 0.3s;
+    border-radius: 50%;
+}
+
+.toggle-switch input:checked + .toggle-slider {
+    background-color: var(--accent-cyan, #00d4ff);
+    border-color: var(--accent-cyan, #00d4ff);
+}
+
+.toggle-switch input:checked + .toggle-slider:before {
+    transform: translateX(20px);
+    background-color: white;
+}
+
+.toggle-switch input:focus + .toggle-slider {
+    box-shadow: 0 0 0 2px rgba(0, 212, 255, 0.3);
+}
+
+/* Select Dropdown */
+.settings-select {
+    background: var(--bg-tertiary, #1a1a2e);
+    border: 1px solid var(--border-color, #2a2a3e);
+    border-radius: 4px;
+    padding: 8px 12px;
+    font-size: 13px;
+    color: var(--text-primary, #e0e0e0);
+    min-width: 160px;
+    cursor: pointer;
+    appearance: none;
+    background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' viewBox='0 0 24 24' fill='none' stroke='%23666' stroke-width='2'%3E%3Cpolyline points='6 9 12 15 18 9'/%3E%3C/svg%3E");
+    background-repeat: no-repeat;
+    background-position: right 8px center;
+    padding-right: 32px;
+}
+
+.settings-select:focus {
+    outline: none;
+    border-color: var(--accent-cyan, #00d4ff);
+}
+
+/* Text Input */
+.settings-input {
+    background: var(--bg-tertiary, #1a1a2e);
+    border: 1px solid var(--border-color, #2a2a3e);
+    border-radius: 4px;
+    padding: 8px 12px;
+    font-size: 13px;
+    color: var(--text-primary, #e0e0e0);
+    width: 200px;
+}
+
+.settings-input:focus {
+    outline: none;
+    border-color: var(--accent-cyan, #00d4ff);
+}
+
+.settings-input::placeholder {
+    color: var(--text-muted, #666);
+}
+
+/* Asset Status */
+.asset-status {
+    display: flex;
+    flex-direction: column;
+    gap: 8px;
+    margin-top: 12px;
+    padding: 12px;
+    background: var(--bg-secondary, #0f0f1a);
+    border-radius: 6px;
+}
+
+.asset-status-row {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    font-size: 12px;
+}
+
+.asset-name {
+    color: var(--text-muted, #888);
+}
+
+.asset-badge {
+    padding: 2px 8px;
+    border-radius: 10px;
+    font-size: 10px;
+    font-weight: 500;
+    text-transform: uppercase;
+}
+
+.asset-badge.available {
+    background: rgba(0, 255, 136, 0.15);
+    color: var(--accent-green, #00ff88);
+}
+
+.asset-badge.missing {
+    background: rgba(255, 68, 68, 0.15);
+    color: var(--accent-red, #ff4444);
+}
+
+.asset-badge.checking {
+    background: rgba(255, 170, 0, 0.15);
+    color: var(--accent-orange, #ffaa00);
+}
+
+/* Check Assets Button */
+.check-assets-btn {
+    background: var(--bg-tertiary, #1a1a2e);
+    border: 1px solid var(--border-color, #2a2a3e);
+    color: var(--text-primary, #e0e0e0);
+    padding: 8px 16px;
+    border-radius: 4px;
+    font-size: 12px;
+    cursor: pointer;
+    margin-top: 12px;
+    transition: all 0.2s;
+}
+
+.check-assets-btn:hover {
+    border-color: var(--accent-cyan, #00d4ff);
+    color: var(--accent-cyan, #00d4ff);
+}
+
+.check-assets-btn:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+}
+
+/* GPS Detection Spinner */
+.detecting-spinner {
+    display: inline-block;
+    width: 12px;
+    height: 12px;
+    border: 2px solid currentColor;
+    border-top-color: transparent;
+    border-radius: 50%;
+    animation: detecting-spin 0.8s linear infinite;
+    vertical-align: middle;
+    margin-right: 6px;
+}
+
+@keyframes detecting-spin {
+    to { transform: rotate(360deg); }
+}
+
+/* About Section */
+.about-info {
+    font-size: 13px;
+    color: var(--text-muted, #888);
+    line-height: 1.6;
+}
+
+.about-info p {
+    margin: 0 0 12px 0;
+}
+
+.about-info a {
+    color: var(--accent-cyan, #00d4ff);
+    text-decoration: none;
+}
+
+.about-info a:hover {
+    text-decoration: underline;
+}
+
+.about-version {
+    font-family: var(--font-mono);
+    color: var(--accent-cyan, #00d4ff);
+}
+
+/* Donate Button */
+.donate-btn {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    padding: 10px 20px;
+    background: linear-gradient(135deg, var(--accent-amber, #d4a853) 0%, var(--accent-orange, #f59e0b) 100%);
+    border: none;
+    border-radius: 6px;
+    color: #000;
+    font-size: 13px;
+    font-weight: 600;
+    text-decoration: none;
+    cursor: pointer;
+    transition: all 0.2s ease;
+    box-shadow: 0 2px 8px rgba(212, 168, 83, 0.3);
+}
+
+.donate-btn:hover {
+    transform: translateY(-1px);
+    box-shadow: 0 4px 12px rgba(212, 168, 83, 0.4);
+    filter: brightness(1.1);
+}
+
+.donate-btn:active {
+    transform: translateY(0);
+}
+
+/* Tile Provider Custom URL */
+.custom-url-row {
+    margin-top: 8px;
+    padding-top: 8px;
+}
+
+.custom-url-row .settings-input {
+    width: 100%;
+}
+
+/* Info Callout */
+.settings-info {
+    background: rgba(0, 212, 255, 0.1);
+    border: 1px solid rgba(0, 212, 255, 0.2);
+    border-radius: 6px;
+    padding: 12px;
+    margin-top: 16px;
+    font-size: 12px;
+    color: var(--text-muted, #888);
+}
+
+.settings-info strong {
+    color: var(--accent-cyan, #00d4ff);
+}
+
+/* Map tile variants */
+.tile-layer-cyan {
+    filter: sepia(0.35) hue-rotate(185deg) saturate(1.75) brightness(1.06) contrast(1.05);
+}
+
+/* Responsive */
+@media (max-width: 640px) {
+    .settings-modal.active {
+        padding: 20px 10px;
+    }
+
+    .settings-content {
+        max-width: 100%;
+    }
+
+    .settings-row {
+        flex-direction: column;
+        align-items: flex-start;
+        gap: 8px;
+    }
+
+    .settings-select,
+    .settings-input {
+        width: 100%;
+    }
+}

static/js/components/consumption-sparkline.js

@@ -0,0 +1,235 @@
+/**
+ * Consumption Sparkline Component
+ * SVG-based visualization for meter consumption deltas
+ * Adapted from RSSISparkline pattern
+ */
+
+const ConsumptionSparkline = (function() {
+    'use strict';
+
+    // Default configuration
+    const DEFAULT_CONFIG = {
+        width: 100,
+        height: 28,
+        maxSamples: 20,
+        strokeWidth: 1.5,
+        showGradient: true,
+        barMode: true  // Use bars instead of line for consumption
+    };
+
+    // Color thresholds for consumption deltas
+    // Green = normal/expected, Yellow = elevated, Red = spike
+    const DELTA_COLORS = {
+        normal: '#22c55e',    // Green
+        elevated: '#eab308',  // Yellow
+        spike: '#ef4444'      // Red
+    };
+
+    /**
+     * Classify a delta value relative to the average
+     * @param {number} delta - The delta value
+     * @param {number} avgDelta - Average delta for comparison
+     * @returns {string} - 'normal', 'elevated', or 'spike'
+     */
+    function classifyDelta(delta, avgDelta) {
+        if (avgDelta === 0 || isNaN(avgDelta)) {
+            return delta === 0 ? 'normal' : 'elevated';
+        }
+        const ratio = Math.abs(delta) / Math.abs(avgDelta);
+        if (ratio <= 1.5) return 'normal';
+        if (ratio <= 3) return 'elevated';
+        return 'spike';
+    }
+
+    /**
+     * Get color for a delta value
+     */
+    function getDeltaColor(delta, avgDelta) {
+        const classification = classifyDelta(delta, avgDelta);
+        return DELTA_COLORS[classification];
+    }
+
+    /**
+     * Create sparkline SVG for consumption deltas
+     * @param {Array<{timestamp, delta}>} deltas - Array of delta objects
+     * @param {Object} config - Configuration options
+     * @returns {string} - SVG HTML string
+     */
+    function createSparklineSvg(deltas, config = {}) {
+        const cfg = { ...DEFAULT_CONFIG, ...config };
+        const { width, height, strokeWidth, showGradient, barMode } = cfg;
+
+        if (!deltas || deltas.length < 1) {
+            return createEmptySparkline(width, height);
+        }
+
+        // Extract just the delta values
+        const values = deltas.map(d => d.delta);
+
+        // Calculate statistics for color classification
+        const avgDelta = values.reduce((a, b) => a + b, 0) / values.length;
+        const maxDelta = Math.max(...values.map(Math.abs), 1);
+
+        if (barMode) {
+            return createBarSparkline(values, avgDelta, maxDelta, cfg);
+        }
+
+        return createLineSparkline(values, avgDelta, maxDelta, cfg);
+    }
+
+    /**
+     * Create bar-style sparkline (better for discrete readings)
+     */
+    function createBarSparkline(values, avgDelta, maxDelta, cfg) {
+        const { width, height } = cfg;
+        const barCount = Math.min(values.length, cfg.maxSamples);
+        const displayValues = values.slice(-barCount);
+
+        const barWidth = Math.max(3, (width / barCount) - 1);
+        const barGap = 1;
+
+        let bars = '';
+        displayValues.forEach((val, i) => {
+            const normalizedHeight = (Math.abs(val) / maxDelta) * (height - 4);
+            const barHeight = Math.max(2, normalizedHeight);
+            const x = i * (barWidth + barGap);
+            const y = height - barHeight - 2;
+            const color = getDeltaColor(val, avgDelta);
+
+            bars += `<rect x="${x.toFixed(1)}" y="${y.toFixed(1)}"
+                          width="${barWidth.toFixed(1)}" height="${barHeight.toFixed(1)}"
+                          fill="${color}" rx="1" opacity="0.85"/>`;
+        });
+
+        return `
+            <svg class="consumption-sparkline-svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}">
+                <line x1="0" y1="${height - 2}" x2="${width}" y2="${height - 2}"
+                      stroke="#333" stroke-width="1" opacity="0.3"/>
+                ${bars}
+            </svg>
+        `;
+    }
+
+    /**
+     * Create line-style sparkline
+     */
+    function createLineSparkline(values, avgDelta, maxDelta, cfg) {
+        const { width, height, strokeWidth, showGradient } = cfg;
+        const displayValues = values.slice(-cfg.maxSamples);
+
+        if (displayValues.length < 2) {
+            return createEmptySparkline(width, height);
+        }
+
+        // Normalize values to 0-1 range
+        const normalized = displayValues.map(v => Math.abs(v) / maxDelta);
+
+        // Calculate path
+        const stepX = width / (normalized.length - 1);
+        let pathD = '';
+        let areaD = '';
+        const points = [];
+
+        normalized.forEach((val, i) => {
+            const x = i * stepX;
+            const y = height - (val * (height - 4)) - 2;
+            points.push({ x, y, value: displayValues[i] });
+
+            if (i === 0) {
+                pathD = `M${x.toFixed(1)},${y.toFixed(1)}`;
+                areaD = `M${x.toFixed(1)},${height} L${x.toFixed(1)},${y.toFixed(1)}`;
+            } else {
+                pathD += ` L${x.toFixed(1)},${y.toFixed(1)}`;
+                areaD += ` L${x.toFixed(1)},${y.toFixed(1)}`;
+            }
+        });
+
+        areaD += ` L${width},${height} Z`;
+
+        // Get color based on latest value
+        const latestValue = displayValues[displayValues.length - 1];
+        const strokeColor = getDeltaColor(latestValue, avgDelta);
+        const gradientId = `consumption-gradient-${Math.random().toString(36).substr(2, 9)}`;
+
+        let gradientDef = '';
+        if (showGradient) {
+            gradientDef = `
+                <defs>
+                    <linearGradient id="${gradientId}" x1="0%" y1="0%" x2="0%" y2="100%">
+                        <stop offset="0%" style="stop-color:${strokeColor};stop-opacity:0.3"/>
+                        <stop offset="100%" style="stop-color:${strokeColor};stop-opacity:0.05"/>
+                    </linearGradient>
+                </defs>
+            `;
+        }
+
+        return `
+            <svg class="consumption-sparkline-svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}">
+                ${gradientDef}
+                ${showGradient ? `<path d="${areaD}" fill="url(#${gradientId})" />` : ''}
+                <path d="${pathD}" fill="none" stroke="${strokeColor}" stroke-width="${strokeWidth}"
+                      stroke-linecap="round" stroke-linejoin="round" />
+                <circle cx="${points[points.length - 1].x}" cy="${points[points.length - 1].y}"
+                        r="2.5" fill="${strokeColor}" class="sparkline-dot" />
+            </svg>
+        `;
+    }
+
+    /**
+     * Create empty sparkline placeholder
+     */
+    function createEmptySparkline(width, height) {
+        return `
+            <svg class="consumption-sparkline-svg consumption-sparkline-empty" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}">
+                <line x1="0" y1="${height / 2}" x2="${width}" y2="${height / 2}"
+                      stroke="#444" stroke-width="1" stroke-dasharray="3,3" />
+                <text x="${width / 2}" y="${height / 2 + 4}" text-anchor="middle"
+                      fill="#555" font-size="9" font-family="monospace">Collecting...</text>
+            </svg>
+        `;
+    }
+
+    /**
+     * Create sparkline with summary stats
+     * @param {Array} deltas - Delta history
+     * @param {Object} options - Display options
+     * @returns {string} - HTML string
+     */
+    function createSparklineWithStats(deltas, options = {}) {
+        const svg = createSparklineSvg(deltas, options);
+
+        if (!deltas || deltas.length < 2) {
+            return `<div class="consumption-sparkline-wrapper">${svg}</div>`;
+        }
+
+        // Calculate trend
+        const recentDeltas = deltas.slice(-5);
+        const avgRecent = recentDeltas.reduce((a, d) => a + d.delta, 0) / recentDeltas.length;
+        const trend = avgRecent > 0 ? 'up' : avgRecent < 0 ? 'down' : 'stable';
+        const trendIcon = trend === 'up' ? '&#8593;' : trend === 'down' ? '&#8595;' : '&#8596;';
+        const trendColor = trend === 'up' ? '#22c55e' : trend === 'down' ? '#ef4444' : '#888';
+
+        return `
+            <div class="consumption-sparkline-wrapper">
+                ${svg}
+                <span class="consumption-trend" style="color: ${trendColor}" title="Recent trend">
+                    ${trendIcon}
+                </span>
+            </div>
+        `;
+    }
+
+    // Public API
+    return {
+        createSparklineSvg,
+        createEmptySparkline,
+        createSparklineWithStats,
+        classifyDelta,
+        getDeltaColor,
+        DEFAULT_CONFIG,
+        DELTA_COLORS
+    };
+})();
+
+// Make globally available
+window.ConsumptionSparkline = ConsumptionSparkline;

static/js/components/meter-aggregator.js

@@ -0,0 +1,278 @@
+/**
+ * Meter Aggregator Component
+ * Client-side aggregation for rtlamr meter readings
+ * Groups readings by meter ID and tracks consumption history
+ */
+
+const MeterAggregator = (function() {
+    'use strict';
+
+    // Configuration
+    const CONFIG = {
+        maxHistoryAge: 60 * 60 * 1000,  // 60 minutes
+        maxHistoryLength: 50,            // Max readings to keep per meter
+        rateWindowMs: 30 * 60 * 1000     // 30 minutes for rate calculation
+    };
+
+    // Storage for aggregated meters
+    // Map<meterId, MeterData>
+    const meters = new Map();
+
+    /**
+     * MeterData structure:
+     * {
+     *   id: string,
+     *   type: string,
+     *   utility: string,
+     *   manufacturer: string,
+     *   firstSeen: number (timestamp),
+     *   lastSeen: number (timestamp),
+     *   readingCount: number,
+     *   latestReading: object (full reading data),
+     *   history: Array<{timestamp, consumption, raw}>,
+     *   delta: number | null (change from previous reading),
+     *   rate: number | null (units per hour)
+     * }
+     */
+
+    /**
+     * Ingest a new meter reading
+     * @param {Object} data - The raw meter reading data
+     * @returns {Object} - { meter: MeterData, isNew: boolean }
+     */
+    function ingest(data) {
+        const msgData = data.Message || {};
+        const meterId = String(msgData.ID || data.id || 'Unknown');
+        const timestamp = Date.now();
+        const consumption = msgData.Consumption !== undefined ? msgData.Consumption : data.consumption;
+
+        // Get meter type info if available
+        const meterInfo = typeof getMeterTypeInfo === 'function'
+            ? getMeterTypeInfo(msgData.EndpointType, data.Type)
+            : { utility: 'Unknown', manufacturer: 'Unknown' };
+
+        const existing = meters.get(meterId);
+        const isNew = !existing;
+
+        if (isNew) {
+            // Create new meter entry
+            const meter = {
+                id: meterId,
+                type: data.Type || 'Unknown',
+                utility: meterInfo.utility,
+                manufacturer: meterInfo.manufacturer,
+                firstSeen: timestamp,
+                lastSeen: timestamp,
+                readingCount: 1,
+                latestReading: data,
+                history: [{
+                    timestamp: timestamp,
+                    consumption: consumption,
+                    raw: data
+                }],
+                delta: null,
+                rate: null
+            };
+            meters.set(meterId, meter);
+            return { meter, isNew: true };
+        }
+
+        // Update existing meter
+        const previousConsumption = existing.history.length > 0
+            ? existing.history[existing.history.length - 1].consumption
+            : null;
+
+        // Add to history
+        existing.history.push({
+            timestamp: timestamp,
+            consumption: consumption,
+            raw: data
+        });
+
+        // Prune old history
+        pruneHistory(existing);
+
+        // Calculate delta (change from previous reading)
+        if (previousConsumption !== null && consumption !== undefined && consumption !== null) {
+            existing.delta = consumption - previousConsumption;
+        } else {
+            existing.delta = null;
+        }
+
+        // Calculate rate (units per hour)
+        existing.rate = calculateRate(existing);
+
+        // Update meter data
+        existing.lastSeen = timestamp;
+        existing.readingCount++;
+        existing.latestReading = data;
+        existing.type = data.Type || existing.type;
+        if (meterInfo.utility !== 'Unknown') existing.utility = meterInfo.utility;
+        if (meterInfo.manufacturer !== 'Unknown') existing.manufacturer = meterInfo.manufacturer;
+
+        return { meter: existing, isNew: false };
+    }
+
+    /**
+     * Prune history older than maxHistoryAge and beyond maxHistoryLength
+     */
+    function pruneHistory(meter) {
+        const cutoff = Date.now() - CONFIG.maxHistoryAge;
+
+        // Remove old entries
+        meter.history = meter.history.filter(h => h.timestamp >= cutoff);
+
+        // Limit length
+        if (meter.history.length > CONFIG.maxHistoryLength) {
+            meter.history = meter.history.slice(-CONFIG.maxHistoryLength);
+        }
+    }
+
+    /**
+     * Calculate consumption rate over the rate window
+     * @returns {number|null} Units per hour, or null if insufficient data
+     */
+    function calculateRate(meter) {
+        if (meter.history.length < 2) return null;
+
+        const now = Date.now();
+        const windowStart = now - CONFIG.rateWindowMs;
+
+        // Find readings within the rate window
+        const recentHistory = meter.history.filter(h => h.timestamp >= windowStart);
+        if (recentHistory.length < 2) return null;
+
+        const oldest = recentHistory[0];
+        const newest = recentHistory[recentHistory.length - 1];
+
+        // Need both to have valid consumption values
+        if (oldest.consumption === undefined || oldest.consumption === null ||
+            newest.consumption === undefined || newest.consumption === null) {
+            return null;
+        }
+
+        const consumptionDiff = newest.consumption - oldest.consumption;
+        const timeDiffHours = (newest.timestamp - oldest.timestamp) / (1000 * 60 * 60);
+
+        if (timeDiffHours <= 0) return null;
+
+        return consumptionDiff / timeDiffHours;
+    }
+
+    /**
+     * Get consumption deltas for sparkline display
+     * @returns {Array<{timestamp, delta}>}
+     */
+    function getConsumptionDeltas(meter) {
+        const deltas = [];
+        for (let i = 1; i < meter.history.length; i++) {
+            const prev = meter.history[i - 1];
+            const curr = meter.history[i];
+            if (prev.consumption !== undefined && prev.consumption !== null &&
+                curr.consumption !== undefined && curr.consumption !== null) {
+                deltas.push({
+                    timestamp: curr.timestamp,
+                    delta: curr.consumption - prev.consumption
+                });
+            }
+        }
+        return deltas;
+    }
+
+    /**
+     * Get a meter by ID
+     * @param {string} id
+     * @returns {Object|null}
+     */
+    function getMeter(id) {
+        return meters.get(String(id)) || null;
+    }
+
+    /**
+     * Get all meters
+     * @returns {Array<Object>}
+     */
+    function getAllMeters() {
+        return Array.from(meters.values());
+    }
+
+    /**
+     * Get meter count
+     * @returns {number}
+     */
+    function getCount() {
+        return meters.size;
+    }
+
+    /**
+     * Clear all aggregated data
+     */
+    function clear() {
+        meters.clear();
+    }
+
+    /**
+     * Get time since last reading for a meter
+     * @param {Object} meter
+     * @returns {string}
+     */
+    function getTimeSinceLastReading(meter) {
+        const diff = Date.now() - meter.lastSeen;
+        const seconds = Math.floor(diff / 1000);
+        if (seconds < 60) return 'Just now';
+        const minutes = Math.floor(seconds / 60);
+        if (minutes < 60) return `${minutes} minute${minutes !== 1 ? 's' : ''} ago`;
+        const hours = Math.floor(minutes / 60);
+        return `${hours} hour${hours !== 1 ? 's' : ''} ago`;
+    }
+
+    /**
+     * Format rate for display
+     * @param {number|null} rate
+     * @returns {string}
+     */
+    function formatRate(rate) {
+        if (rate === null || rate === undefined || isNaN(rate)) {
+            return '--';
+        }
+        // Format based on magnitude
+        const absRate = Math.abs(rate);
+        if (absRate >= 100) {
+            return rate.toFixed(0) + '/hr';
+        } else if (absRate >= 1) {
+            return rate.toFixed(1) + '/hr';
+        } else {
+            return rate.toFixed(2) + '/hr';
+        }
+    }
+
+    /**
+     * Format delta for display
+     * @param {number|null} delta
+     * @returns {string}
+     */
+    function formatDelta(delta) {
+        if (delta === null || delta === undefined || isNaN(delta)) {
+            return '--';
+        }
+        const sign = delta >= 0 ? '+' : '';
+        return sign + delta.toLocaleString();
+    }
+
+    // Public API
+    return {
+        ingest,
+        getMeter,
+        getAllMeters,
+        getCount,
+        clear,
+        getConsumptionDeltas,
+        getTimeSinceLastReading,
+        formatRate,
+        formatDelta,
+        CONFIG
+    };
+})();
+
+// Make globally available
+window.MeterAggregator = MeterAggregator;

static/js/components/proximity-radar.js

@@ -33,6 +33,9 @@ const ProximityRadar = (function() {
     let activeFilter = null;
     let onDeviceClick = null;
     let selectedDeviceKey = null;
+    let isHovered = false;
+    let renderPending = false;
+    let renderTimer = null;
 
     /**
      * Initialize the radar component
@@ -162,8 +165,18 @@ const ProximityRadar = (function() {
             devices.set(device.device_key, device);
         });
 
-        // Apply filter and render
-        renderDevices();
+        // Defer render while user is hovering to prevent DOM rebuild flicker
+        if (isHovered) {
+            renderPending = true;
+            return;
+        }
+
+        // Debounce rapid updates (e.g. per-device SSE events)
+        if (renderTimer) clearTimeout(renderTimer);
+        renderTimer = setTimeout(() => {
+            renderTimer = null;
+            renderDevices();
+        }, 200);
     }
 
     /**
@@ -207,25 +220,32 @@ const ProximityRadar = (function() {
             const pulseClass = isNew ? 'radar-dot-pulse' : '';
             const isSelected = selectedDeviceKey && device.device_key === selectedDeviceKey;
 
+            // Hit area size (prevents hover flicker when scaling)
+            const hitAreaSize = Math.max(dotSize * 2, 15);
+
             return `
-                <g class="radar-device ${pulseClass}${isSelected ? ' selected' : ''}" data-device-key="${escapeAttr(device.device_key)}"
-                   transform="translate(${x}, ${y})" style="cursor: pointer;">
-                    ${isSelected ? `<circle 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 transform="translate(${x}, ${y})">
+                    <g class="radar-device ${pulseClass}${isSelected ? ' selected' : ''}" data-device-key="${escapeAttr(device.device_key)}"
+                       style="cursor: pointer;">
+                        <!-- Invisible hit area to prevent hover flicker -->
+                        <circle class="radar-device-hitarea" r="${hitAreaSize}" fill="transparent" />
+                        ${isSelected ? `<circle 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;
 
-        // Attach click handlers
+        // Attach event handlers
         devicesGroup.querySelectorAll('.radar-device').forEach(el => {
             el.addEventListener('click', (e) => {
                 const deviceKey = el.getAttribute('data-device-key');
@@ -233,6 +253,14 @@ const ProximityRadar = (function() {
                     onDeviceClick(deviceKey);
                 }
             });
+            el.addEventListener('mouseenter', () => { isHovered = true; });
+            el.addEventListener('mouseleave', () => {
+                isHovered = false;
+                if (renderPending) {
+                    renderPending = false;
+                    renderDevices();
+                }
+            });
         });
     }
 

static/js/components/signal-cards.js

@@ -988,6 +988,84 @@ const SignalCards = (function() {
         return card;
     }
 
+    /**
+     * Build HTML for all meter detail fields from raw message data
+     */
+    function buildMeterDetailsHtml(msg, seenCount) {
+        let html = '';
+        const rawMessage = msg.rawMessage || {};
+
+        // Add device intelligence info at the top
+        if (msg.utility && msg.utility !== 'Unknown') {
+            html += `
+                <div class="signal-advanced-item">
+                    <span class="signal-advanced-label">Utility Type</span>
+                    <span class="signal-advanced-value">${escapeHtml(msg.utility)}</span>
+                </div>
+            `;
+        }
+        if (msg.manufacturer && msg.manufacturer !== 'Unknown') {
+            html += `
+                <div class="signal-advanced-item">
+                    <span class="signal-advanced-label">Manufacturer</span>
+                    <span class="signal-advanced-value">${escapeHtml(msg.manufacturer)}</span>
+                </div>
+            `;
+        }
+
+        // Display all fields from the raw rtlamr message
+        for (const [key, value] of Object.entries(rawMessage)) {
+            if (value === null || value === undefined) continue;
+
+            // Format the label (convert camelCase/PascalCase to spaces)
+            const label = key.replace(/([A-Z])/g, ' $1').replace(/^./, s => s.toUpperCase()).trim();
+
+            // Format the value based on type
+            let displayValue;
+            if (Array.isArray(value)) {
+                // For arrays like DifferentialConsumptionIntervals, show count and values
+                if (value.length > 10) {
+                    displayValue = `[${value.length} values] ${value.slice(0, 5).join(', ')}...`;
+                } else {
+                    displayValue = value.join(', ');
+                }
+            } else if (typeof value === 'object') {
+                displayValue = JSON.stringify(value);
+            } else if (key === 'Consumption') {
+                displayValue = `${value.toLocaleString()} units`;
+            } else {
+                displayValue = String(value);
+            }
+
+            html += `
+                <div class="signal-advanced-item">
+                    <span class="signal-advanced-label">${escapeHtml(label)}</span>
+                    <span class="signal-advanced-value">${escapeHtml(displayValue)}</span>
+                </div>
+            `;
+        }
+
+        // Add message type if not in raw message
+        if (!rawMessage.Type && msg.type) {
+            html += `
+                <div class="signal-advanced-item">
+                    <span class="signal-advanced-label">Message Type</span>
+                    <span class="signal-advanced-value">${escapeHtml(msg.type)}</span>
+                </div>
+            `;
+        }
+
+        // Add seen count
+        html += `
+            <div class="signal-advanced-item">
+                <span class="signal-advanced-label">Seen</span>
+                <span class="signal-advanced-value">${seenCount} time${seenCount > 1 ? 's' : ''}</span>
+            </div>
+        `;
+
+        return html;
+    }
+
     /**
      * Create a utility meter (rtlamr) card
      */
@@ -1006,19 +1084,24 @@ const SignalCards = (function() {
         const stats = getAddressStats('meter', msg.id);
         const seenCount = stats ? stats.count : 1;
 
-        // Determine meter type color
+        // Determine meter type color based on utility type
         let meterTypeClass = 'electric';
+        const utility = (msg.utility || '').toLowerCase();
         const meterType = (msg.type || '').toLowerCase();
-        if (meterType.includes('gas')) {
+        if (utility === 'gas' || meterType.includes('gas')) {
             meterTypeClass = 'gas';
-        } else if (meterType.includes('water')) {
+        } else if (utility === 'water' || meterType.includes('water') || meterType.includes('r900')) {
             meterTypeClass = 'water';
         }
 
+        // Format utility display
+        const utilityDisplay = msg.utility && msg.utility !== 'Unknown' ? msg.utility : null;
+        const manufacturerDisplay = msg.manufacturer && msg.manufacturer !== 'Unknown' ? msg.manufacturer : null;
+
         card.innerHTML = `
             <div class="signal-card-header">
                 <div class="signal-card-badges">
-                    <span class="signal-proto-badge meter ${meterTypeClass}">${escapeHtml(msg.type || 'Meter')}</span>
+                    <span class="signal-proto-badge meter ${meterTypeClass}">${escapeHtml(utilityDisplay || msg.type || 'Meter')}</span>
                     <span class="signal-freq-badge">ID: ${escapeHtml(msg.id || 'N/A')}</span>
                 </div>
                 ${status !== 'baseline' ? `
@@ -1030,7 +1113,8 @@ const SignalCards = (function() {
             </div>
             <div class="signal-card-body">
                 <div class="signal-meta-row">
-                    ${msg.endpoint_type ? `<span class="signal-msg-type">${escapeHtml(msg.endpoint_type)}</span>` : ''}
+                    ${manufacturerDisplay ? `<span class="signal-msg-type">${escapeHtml(manufacturerDisplay)}</span>` : ''}
+                    ${msg.type ? `<span class="signal-msg-type" style="opacity: 0.7">${escapeHtml(msg.type)}</span>` : ''}
                     ${seenCount > 1 ? `<span class="signal-seen-count">×${seenCount}</span>` : ''}
                     <span class="signal-timestamp" data-timestamp="${escapeHtml(msg.timestamp)}">${escapeHtml(relativeTime)}</span>
                 </div>
@@ -1060,30 +1144,7 @@ const SignalCards = (function() {
                         <div class="signal-advanced-section">
                             <div class="signal-advanced-title">Meter Details</div>
                             <div class="signal-advanced-grid">
-                                <div class="signal-advanced-item">
-                                    <span class="signal-advanced-label">Meter ID</span>
-                                    <span class="signal-advanced-value">${escapeHtml(msg.id || 'N/A')}</span>
-                                </div>
-                                <div class="signal-advanced-item">
-                                    <span class="signal-advanced-label">Type</span>
-                                    <span class="signal-advanced-value">${escapeHtml(msg.type || 'Unknown')}</span>
-                                </div>
-                                ${msg.endpoint_type ? `
-                                <div class="signal-advanced-item">
-                                    <span class="signal-advanced-label">Endpoint</span>
-                                    <span class="signal-advanced-value">${escapeHtml(msg.endpoint_type)}</span>
-                                </div>
-                                ` : ''}
-                                ${msg.endpoint_id ? `
-                                <div class="signal-advanced-item">
-                                    <span class="signal-advanced-label">Endpoint ID</span>
-                                    <span class="signal-advanced-value">${escapeHtml(msg.endpoint_id)}</span>
-                                </div>
-                                ` : ''}
-                                <div class="signal-advanced-item">
-                                    <span class="signal-advanced-label">Seen</span>
-                                    <span class="signal-advanced-value">${seenCount} time${seenCount > 1 ? 's' : ''}</span>
-                                </div>
+                                ${buildMeterDetailsHtml(msg, seenCount)}
                             </div>
                         </div>
                     </div>
@@ -1094,6 +1155,303 @@ const SignalCards = (function() {
         return card;
     }
 
+    /**
+     * Create an aggregated utility meter card (grouped by meter ID)
+     * Shows consumption history, sparkline, delta, and rate
+     * @param {Object} meter - Aggregated meter data from MeterAggregator
+     * @param {Object} options - Optional configuration
+     * @returns {HTMLElement}
+     */
+    function createAggregatedMeterCard(meter, options = {}) {
+        const status = meter.readingCount === 1 ? 'new' : 'baseline';
+        const relativeTime = MeterAggregator.getTimeSinceLastReading(meter);
+
+        const card = document.createElement('article');
+        card.className = 'signal-card meter-aggregated';
+        card.dataset.status = status;
+        card.dataset.type = 'meter';
+        card.dataset.protocol = meter.type || 'unknown';
+        card.dataset.meterId = meter.id;
+        card.id = 'metercard_' + meter.id;
+
+        // Determine meter type color
+        let meterTypeClass = 'electric';
+        const utility = (meter.utility || '').toLowerCase();
+        const meterType = (meter.type || '').toLowerCase();
+        if (utility === 'gas' || meterType.includes('gas')) {
+            meterTypeClass = 'gas';
+        } else if (utility === 'water' || meterType.includes('water') || meterType.includes('r900')) {
+            meterTypeClass = 'water';
+        }
+
+        // Format utility display
+        const utilityDisplay = meter.utility && meter.utility !== 'Unknown' ? meter.utility : null;
+        const manufacturerDisplay = meter.manufacturer && meter.manufacturer !== 'Unknown' ? meter.manufacturer : null;
+
+        // Get consumption deltas for sparkline
+        const deltas = typeof MeterAggregator !== 'undefined'
+            ? MeterAggregator.getConsumptionDeltas(meter)
+            : [];
+
+        // Create sparkline
+        const sparklineHtml = typeof ConsumptionSparkline !== 'undefined'
+            ? ConsumptionSparkline.createSparklineSvg(deltas, { width: 100, height: 28 })
+            : '<span class="meter-sparkline-placeholder">--</span>';
+
+        // Format delta and rate
+        const deltaFormatted = MeterAggregator.formatDelta(meter.delta);
+        const rateFormatted = MeterAggregator.formatRate(meter.rate);
+        const deltaClass = meter.delta === null ? '' : (meter.delta >= 0 ? 'positive' : 'negative');
+
+        // Get latest consumption
+        const latestConsumption = meter.history.length > 0
+            ? meter.history[meter.history.length - 1].consumption
+            : null;
+
+        card.innerHTML = `
+            <div class="signal-card-header">
+                <div class="signal-card-badges">
+                    <span class="signal-proto-badge meter ${meterTypeClass}">${escapeHtml(utilityDisplay || meter.type || 'Meter')}</span>
+                    <span class="signal-freq-badge">ID: ${escapeHtml(meter.id || 'N/A')}</span>
+                    ${meter.readingCount > 1 ? `<span class="signal-seen-count">&times;${meter.readingCount}</span>` : ''}
+                </div>
+                ${status === 'new' ? `
+                <span class="signal-status-pill" data-status="new">
+                    <span class="status-dot"></span>
+                    New
+                </span>
+                ` : ''}
+            </div>
+            <div class="signal-card-body">
+                <div class="signal-meta-row">
+                    ${manufacturerDisplay ? `<span class="signal-msg-type">${escapeHtml(manufacturerDisplay)}</span>` : ''}
+                    ${meter.type ? `<span class="signal-msg-type" style="opacity: 0.7">${escapeHtml(meter.type)}</span>` : ''}
+                    <span class="signal-timestamp meter-last-seen" data-timestamp="${meter.lastSeen}">${escapeHtml(relativeTime)}</span>
+                </div>
+                <div class="meter-aggregated-grid">
+                    <div class="meter-aggregated-col consumption-col">
+                        <span class="meter-aggregated-label">Consumption</span>
+                        <span class="meter-aggregated-value consumption-value">${latestConsumption !== null ? latestConsumption.toLocaleString() : '--'}</span>
+                        <span class="meter-delta ${deltaClass}" title="Change from previous reading">${deltaFormatted}</span>
+                    </div>
+                    <div class="meter-aggregated-col trend-col">
+                        <span class="meter-aggregated-label">Trend</span>
+                        <div class="meter-sparkline-container">
+                            ${sparklineHtml}
+                        </div>
+                    </div>
+                    <div class="meter-aggregated-col rate-col">
+                        <span class="meter-aggregated-label">Rate</span>
+                        <span class="meter-rate-value">${rateFormatted}</span>
+                    </div>
+                </div>
+            </div>
+            <div class="signal-card-footer">
+                <button class="signal-advanced-toggle" onclick="SignalCards.toggleAdvanced(this)">
+                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                        <path d="M6 9l6 6 6-6"/>
+                    </svg>
+                    Details
+                </button>
+                <div class="signal-card-actions">
+                    <button class="signal-action-btn" onclick="SignalCards.muteAddress('${escapeHtml(meter.id)}')">Mute</button>
+                </div>
+            </div>
+            <div class="signal-advanced-panel">
+                <div class="signal-advanced-inner">
+                    <div class="signal-advanced-content">
+                        <div class="signal-advanced-section">
+                            <div class="signal-advanced-title">Meter Details</div>
+                            <div class="signal-advanced-grid">
+                                ${buildAggregatedMeterDetailsHtml(meter)}
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        `;
+
+        return card;
+    }
+
+    /**
+     * Update an existing aggregated meter card in place
+     * @param {HTMLElement} card - The card element to update
+     * @param {Object} meter - Updated meter data from MeterAggregator
+     */
+    function updateAggregatedMeterCard(card, meter) {
+        if (!card || !meter) return;
+
+        // Update timestamp
+        const relativeTime = MeterAggregator.getTimeSinceLastReading(meter);
+        const timestampEl = card.querySelector('.meter-last-seen');
+        if (timestampEl) {
+            timestampEl.dataset.timestamp = meter.lastSeen;
+            timestampEl.textContent = relativeTime;
+        }
+
+        // Update seen count badge
+        const seenCountEl = card.querySelector('.signal-seen-count');
+        if (seenCountEl) {
+            seenCountEl.innerHTML = `&times;${meter.readingCount}`;
+        } else if (meter.readingCount > 1) {
+            // Add seen count if it doesn't exist
+            const badges = card.querySelector('.signal-card-badges');
+            if (badges) {
+                const countSpan = document.createElement('span');
+                countSpan.className = 'signal-seen-count';
+                countSpan.innerHTML = `&times;${meter.readingCount}`;
+                badges.appendChild(countSpan);
+            }
+        }
+
+        // Remove "new" status pill after first update
+        if (meter.readingCount > 1) {
+            card.dataset.status = 'baseline';
+            const statusPill = card.querySelector('.signal-status-pill[data-status="new"]');
+            if (statusPill) {
+                statusPill.remove();
+            }
+        }
+
+        // Update consumption value
+        const latestConsumption = meter.history.length > 0
+            ? meter.history[meter.history.length - 1].consumption
+            : null;
+        const consumptionEl = card.querySelector('.consumption-value');
+        if (consumptionEl) {
+            consumptionEl.textContent = latestConsumption !== null ? latestConsumption.toLocaleString() : '--';
+        }
+
+        // Update delta
+        const deltaEl = card.querySelector('.meter-delta');
+        if (deltaEl) {
+            const deltaFormatted = MeterAggregator.formatDelta(meter.delta);
+            deltaEl.textContent = deltaFormatted;
+            deltaEl.classList.remove('positive', 'negative');
+            if (meter.delta !== null) {
+                deltaEl.classList.add(meter.delta >= 0 ? 'positive' : 'negative');
+            }
+        }
+
+        // Update sparkline
+        const sparklineContainer = card.querySelector('.meter-sparkline-container');
+        if (sparklineContainer && typeof ConsumptionSparkline !== 'undefined') {
+            const deltas = MeterAggregator.getConsumptionDeltas(meter);
+            sparklineContainer.innerHTML = ConsumptionSparkline.createSparklineSvg(deltas, { width: 100, height: 28 });
+        }
+
+        // Update rate
+        const rateEl = card.querySelector('.meter-rate-value');
+        if (rateEl) {
+            rateEl.textContent = MeterAggregator.formatRate(meter.rate);
+        }
+
+        // Update details panel
+        const detailsGrid = card.querySelector('.signal-advanced-grid');
+        if (detailsGrid) {
+            detailsGrid.innerHTML = buildAggregatedMeterDetailsHtml(meter);
+        }
+
+        // Add subtle update animation
+        card.classList.add('meter-updated');
+        setTimeout(() => card.classList.remove('meter-updated'), 300);
+    }
+
+    /**
+     * Build HTML for aggregated meter detail fields
+     * @param {Object} meter - Aggregated meter data
+     * @returns {string} - HTML string
+     */
+    function buildAggregatedMeterDetailsHtml(meter) {
+        let html = '';
+        const latestReading = meter.latestReading || {};
+        const rawMessage = latestReading.Message || {};
+
+        // Add device intelligence info at the top
+        if (meter.utility && meter.utility !== 'Unknown') {
+            html += `
+                <div class="signal-advanced-item">
+                    <span class="signal-advanced-label">Utility Type</span>
+                    <span class="signal-advanced-value">${escapeHtml(meter.utility)}</span>
+                </div>
+            `;
+        }
+        if (meter.manufacturer && meter.manufacturer !== 'Unknown') {
+            html += `
+                <div class="signal-advanced-item">
+                    <span class="signal-advanced-label">Manufacturer</span>
+                    <span class="signal-advanced-value">${escapeHtml(meter.manufacturer)}</span>
+                </div>
+            `;
+        }
+
+        // Add aggregation stats
+        html += `
+            <div class="signal-advanced-item">
+                <span class="signal-advanced-label">Total Readings</span>
+                <span class="signal-advanced-value">${meter.readingCount}</span>
+            </div>
+            <div class="signal-advanced-item">
+                <span class="signal-advanced-label">First Seen</span>
+                <span class="signal-advanced-value">${new Date(meter.firstSeen).toLocaleTimeString()}</span>
+            </div>
+        `;
+
+        // Add rate info if available
+        if (meter.rate !== null) {
+            html += `
+                <div class="signal-advanced-item">
+                    <span class="signal-advanced-label">Consumption Rate</span>
+                    <span class="signal-advanced-value">${MeterAggregator.formatRate(meter.rate)}</span>
+                </div>
+            `;
+        }
+
+        // Display fields from the raw rtlamr message
+        for (const [key, value] of Object.entries(rawMessage)) {
+            if (value === null || value === undefined) continue;
+
+            // Format the label
+            const label = key.replace(/([A-Z])/g, ' $1').replace(/^./, s => s.toUpperCase()).trim();
+
+            // Format the value
+            let displayValue;
+            if (Array.isArray(value)) {
+                if (value.length > 10) {
+                    displayValue = `[${value.length} values] ${value.slice(0, 5).join(', ')}...`;
+                } else {
+                    displayValue = value.join(', ');
+                }
+            } else if (typeof value === 'object') {
+                displayValue = JSON.stringify(value);
+            } else if (key === 'Consumption') {
+                displayValue = `${value.toLocaleString()} units`;
+            } else {
+                displayValue = String(value);
+            }
+
+            html += `
+                <div class="signal-advanced-item">
+                    <span class="signal-advanced-label">${escapeHtml(label)}</span>
+                    <span class="signal-advanced-value">${escapeHtml(displayValue)}</span>
+                </div>
+            `;
+        }
+
+        // Add message type if not in raw message
+        if (!rawMessage.Type && meter.type) {
+            html += `
+                <div class="signal-advanced-item">
+                    <span class="signal-advanced-label">Message Type</span>
+                    <span class="signal-advanced-value">${escapeHtml(meter.type)}</span>
+                </div>
+            `;
+        }
+
+        return html;
+    }
+
     /**
      * Toggle advanced panel on a card
      */
@@ -1885,6 +2243,8 @@ const SignalCards = (function() {
         createSensorCard,
         createAcarsCard,
         createMeterCard,
+        createAggregatedMeterCard,
+        updateAggregatedMeterCard,
 
         // Signal classification
         SignalClassification,

static/js/core/global-nav.js

@@ -0,0 +1,48 @@
+(() => {
+    const dropdowns = Array.from(document.querySelectorAll('.mode-nav-dropdown'));
+    if (!dropdowns.length) return;
+
+    const closeAll = () => {
+        dropdowns.forEach((dropdown) => dropdown.classList.remove('open'));
+    };
+
+    const openDropdown = (dropdown) => {
+        if (!dropdown.classList.contains('open')) {
+            closeAll();
+            dropdown.classList.add('open');
+        }
+    };
+
+    document.addEventListener('click', (event) => {
+        const menuLink = event.target.closest('.mode-nav-dropdown-menu a');
+        if (menuLink) {
+            event.preventDefault();
+            event.stopPropagation();
+            window.location.href = menuLink.href;
+            return;
+        }
+
+        const button = event.target.closest('.mode-nav-dropdown-btn');
+        if (button) {
+            event.preventDefault();
+            const dropdown = button.closest('.mode-nav-dropdown');
+            if (!dropdown) return;
+            if (dropdown.classList.contains('open')) {
+                dropdown.classList.remove('open');
+            } else {
+                openDropdown(dropdown);
+            }
+            return;
+        }
+
+        if (!event.target.closest('.mode-nav-dropdown')) {
+            closeAll();
+        }
+    });
+
+    document.addEventListener('keydown', (event) => {
+        if (event.key === 'Escape') {
+            closeAll();
+        }
+    });
+})();

static/js/core/observer-location.js

@@ -0,0 +1,103 @@
+// Shared observer location helper for map-based modules.
+// Default: shared location enabled unless explicitly disabled via config.
+window.ObserverLocation = (function() {
+    const DEFAULT_LOCATION = { lat: 51.5074, lon: -0.1278 };
+    const SHARED_KEY = 'observerLocation';
+    const AIS_KEY = 'ais_observerLocation';
+    const LEGACY_LAT_KEY = 'observerLat';
+    const LEGACY_LON_KEY = 'observerLon';
+
+    function isSharedEnabled() {
+        return window.INTERCEPT_SHARED_OBSERVER_LOCATION !== false;
+    }
+
+    function normalize(lat, lon) {
+        const latNum = parseFloat(lat);
+        const lonNum = parseFloat(lon);
+        if (Number.isNaN(latNum) || Number.isNaN(lonNum)) return null;
+        if (latNum < -90 || latNum > 90 || lonNum < -180 || lonNum > 180) return null;
+        return { lat: latNum, lon: lonNum };
+    }
+
+    function parseLocation(raw) {
+        if (!raw) return null;
+        try {
+            const parsed = JSON.parse(raw);
+            if (parsed && parsed.lat !== undefined && parsed.lon !== undefined) {
+                return normalize(parsed.lat, parsed.lon);
+            }
+        } catch (e) {}
+        return null;
+    }
+
+    function readKey(key) {
+        return parseLocation(localStorage.getItem(key));
+    }
+
+    function readLegacyLatLon() {
+        const lat = localStorage.getItem(LEGACY_LAT_KEY);
+        const lon = localStorage.getItem(LEGACY_LON_KEY);
+        if (!lat || !lon) return null;
+        return normalize(lat, lon);
+    }
+
+    function getShared() {
+        const current = readKey(SHARED_KEY);
+        if (current) return current;
+
+        const legacy = readKey(AIS_KEY) || readLegacyLatLon();
+        if (legacy) {
+            setShared(legacy);
+            return legacy;
+        }
+        return { ...DEFAULT_LOCATION };
+    }
+
+    function setShared(location, options = {}) {
+        if (!location) return;
+        localStorage.setItem(SHARED_KEY, JSON.stringify(location));
+        if (options.updateLegacy !== false) {
+            localStorage.setItem(LEGACY_LAT_KEY, location.lat.toString());
+            localStorage.setItem(LEGACY_LON_KEY, location.lon.toString());
+        }
+    }
+
+    function getForModule(moduleKey, options = {}) {
+        if (isSharedEnabled()) {
+            return getShared();
+        }
+        if (moduleKey) {
+            const moduleLocation = readKey(moduleKey);
+            if (moduleLocation) return moduleLocation;
+        }
+        if (options.fallbackToLatLon) {
+            const legacy = readLegacyLatLon();
+            if (legacy) return legacy;
+        }
+        return { ...DEFAULT_LOCATION };
+    }
+
+    function setForModule(moduleKey, location, options = {}) {
+        if (!location) return;
+        if (isSharedEnabled()) {
+            setShared(location, options);
+            return;
+        }
+        if (moduleKey) {
+            localStorage.setItem(moduleKey, JSON.stringify(location));
+        } else if (options.fallbackToLatLon) {
+            localStorage.setItem(LEGACY_LAT_KEY, location.lat.toString());
+            localStorage.setItem(LEGACY_LON_KEY, location.lon.toString());
+        }
+    }
+
+    return {
+        isSharedEnabled,
+        getShared,
+        setShared,
+        getForModule,
+        setForModule,
+        normalize,
+        DEFAULT_LOCATION: { ...DEFAULT_LOCATION }
+    };
+})();

static/js/core/settings-manager.js

@@ -0,0 +1,926 @@
+/**
+ * Settings Manager - Handles offline mode and application settings
+ */
+
+const Settings = {
+    // Default settings
+    defaults: {
+        'offline.enabled': false,
+        'offline.assets_source': 'cdn',
+        'offline.fonts_source': 'cdn',
+        'offline.tile_provider': 'cartodb_dark_cyan',
+        'offline.tile_server_url': ''
+    },
+
+    // Tile provider configurations
+    tileProviders: {
+        openstreetmap: {
+            url: 'https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png',
+            attribution: '&copy; <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors',
+            subdomains: 'abc'
+        },
+        cartodb_dark: {
+            url: 'https://cartodb-basemaps-{s}.global.ssl.fastly.net/dark_all/{z}/{x}/{y}.png',
+            attribution: '&copy; <a href="https://www.openstreetmap.org/copyright">OSM</a> &copy; <a href="https://carto.com/">CARTO</a>',
+            subdomains: 'abcd'
+        },
+        cartodb_dark_cyan: {
+            url: 'https://cartodb-basemaps-{s}.global.ssl.fastly.net/dark_all/{z}/{x}/{y}.png',
+            attribution: '&copy; <a href="https://www.openstreetmap.org/copyright">OSM</a> &copy; <a href="https://carto.com/">CARTO</a>',
+            subdomains: 'abcd',
+            options: {
+                className: 'tile-layer-cyan'
+            }
+        },
+        cartodb_light: {
+            url: 'https://cartodb-basemaps-{s}.global.ssl.fastly.net/light_all/{z}/{x}/{y}.png',
+            attribution: '&copy; <a href="https://www.openstreetmap.org/copyright">OSM</a> &copy; <a href="https://carto.com/">CARTO</a>',
+            subdomains: 'abcd'
+        },
+        esri_world: {
+            url: 'https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}',
+            attribution: 'Tiles &copy; Esri &mdash; Source: Esri, i-cubed, USDA, USGS, AEX, GeoEye, Getmapping, Aerogrid, IGN, IGP, UPR-EGP, and the GIS User Community',
+            subdomains: null
+        }
+    },
+
+    // Registry of maps that can be updated
+    _registeredMaps: [],
+
+    // Current settings cache
+    _cache: {},
+
+    /**
+     * Initialize settings - load from server/localStorage
+     */
+    async init() {
+        try {
+            const response = await fetch('/offline/settings');
+            if (response.ok) {
+                const data = await response.json();
+                this._cache = { ...this.defaults, ...data.settings };
+            } else {
+                // Fall back to localStorage
+                this._loadFromLocalStorage();
+            }
+        } catch (e) {
+            console.warn('Failed to load settings from server, using localStorage:', e);
+            this._loadFromLocalStorage();
+        }
+
+        this._updateUI();
+        return this._cache;
+    },
+
+    /**
+     * Load settings from localStorage
+     */
+    _loadFromLocalStorage() {
+        const stored = localStorage.getItem('intercept_settings');
+        if (stored) {
+            try {
+                this._cache = { ...this.defaults, ...JSON.parse(stored) };
+            } catch (e) {
+                this._cache = { ...this.defaults };
+            }
+        } else {
+            this._cache = { ...this.defaults };
+        }
+    },
+
+    /**
+     * Save a setting to server and localStorage
+     */
+    async _save(key, value) {
+        this._cache[key] = value;
+
+        // Save to localStorage as backup
+        localStorage.setItem('intercept_settings', JSON.stringify(this._cache));
+
+        // Save to server
+        try {
+            await fetch('/offline/settings', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ key, value })
+            });
+        } catch (e) {
+            console.warn('Failed to save setting to server:', e);
+        }
+    },
+
+    /**
+     * Get a setting value
+     */
+    get(key) {
+        return this._cache[key] ?? this.defaults[key];
+    },
+
+    /**
+     * Toggle offline mode master switch
+     */
+    async toggleOfflineMode(enabled) {
+        await this._save('offline.enabled', enabled);
+
+        if (enabled) {
+            // When enabling offline mode, also switch assets and fonts to local
+            await this._save('offline.assets_source', 'local');
+            await this._save('offline.fonts_source', 'local');
+        }
+
+        this._updateUI();
+        this._showReloadPrompt();
+    },
+
+    /**
+     * Set asset source (cdn or local)
+     */
+    async setAssetSource(source) {
+        await this._save('offline.assets_source', source);
+        this._showReloadPrompt();
+    },
+
+    /**
+     * Set fonts source (cdn or local)
+     */
+    async setFontsSource(source) {
+        await this._save('offline.fonts_source', source);
+        this._showReloadPrompt();
+    },
+
+    /**
+     * Set tile provider
+     */
+    async setTileProvider(provider) {
+        await this._save('offline.tile_provider', provider);
+
+        // Show/hide custom URL input
+        const customRow = document.getElementById('customTileUrlRow');
+        if (customRow) {
+            customRow.style.display = provider === 'custom' ? 'block' : 'none';
+        }
+
+        // If not custom and we have a map, update tiles immediately
+        if (provider !== 'custom') {
+            this._updateMapTiles();
+        }
+    },
+
+    /**
+     * Set custom tile server URL
+     */
+    async setCustomTileUrl(url) {
+        await this._save('offline.tile_server_url', url);
+        this._updateMapTiles();
+    },
+
+    /**
+     * Get current tile configuration
+     */
+    getTileConfig() {
+        const provider = this.get('offline.tile_provider');
+
+        if (provider === 'custom') {
+            const customUrl = this.get('offline.tile_server_url');
+            return {
+                url: customUrl || 'https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png',
+                attribution: 'Custom Tile Server',
+                subdomains: 'abc'
+            };
+        }
+
+        return this.tileProviders[provider] || this.tileProviders.cartodb_dark;
+    },
+
+    /**
+     * Register a map to receive tile updates when settings change
+     * @param {L.Map} map - Leaflet map instance
+     */
+    registerMap(map) {
+        if (map && typeof map.eachLayer === 'function' && !this._registeredMaps.includes(map)) {
+            this._registeredMaps.push(map);
+        }
+    },
+
+    /**
+     * Unregister a map
+     * @param {L.Map} map - Leaflet map instance
+     */
+    unregisterMap(map) {
+        const idx = this._registeredMaps.indexOf(map);
+        if (idx > -1) {
+            this._registeredMaps.splice(idx, 1);
+        }
+    },
+
+    /**
+     * Create a tile layer using current settings
+     * @returns {L.TileLayer} Configured tile layer
+     */
+    createTileLayer() {
+        const config = this.getTileConfig();
+        const options = {
+            attribution: config.attribution,
+            maxZoom: 19,
+            ...(config.options || {})
+        };
+        if (config.subdomains) {
+            options.subdomains = config.subdomains;
+        }
+        return L.tileLayer(config.url, options);
+    },
+
+    /**
+     * Check if local assets are available
+     */
+    async checkAssets() {
+        const assets = {
+            leaflet: [
+                '/static/vendor/leaflet/leaflet.js',
+                '/static/vendor/leaflet/leaflet.css'
+            ],
+            chartjs: [
+                '/static/vendor/chartjs/chart.umd.min.js'
+            ],
+            inter: [
+                '/static/vendor/fonts/Inter-Regular.woff2'
+            ],
+            jetbrains: [
+                '/static/vendor/fonts/JetBrainsMono-Regular.woff2'
+            ]
+        };
+
+        const results = {};
+
+        for (const [name, urls] of Object.entries(assets)) {
+            const statusEl = document.getElementById(`status${name.charAt(0).toUpperCase() + name.slice(1)}`);
+            if (statusEl) {
+                statusEl.textContent = 'Checking...';
+                statusEl.className = 'asset-badge checking';
+            }
+
+            let available = true;
+            for (const url of urls) {
+                try {
+                    const response = await fetch(url, { method: 'HEAD' });
+                    if (!response.ok) {
+                        available = false;
+                        break;
+                    }
+                } catch (e) {
+                    available = false;
+                    break;
+                }
+            }
+
+            results[name] = available;
+
+            if (statusEl) {
+                statusEl.textContent = available ? 'Available' : 'Missing';
+                statusEl.className = `asset-badge ${available ? 'available' : 'missing'}`;
+            }
+        }
+
+        return results;
+    },
+
+    /**
+     * Update UI elements to reflect current settings
+     */
+    _updateUI() {
+        // Offline mode toggle
+        const offlineEnabled = document.getElementById('offlineEnabled');
+        if (offlineEnabled) {
+            offlineEnabled.checked = this.get('offline.enabled');
+        }
+
+        // Assets source
+        const assetsSource = document.getElementById('assetsSource');
+        if (assetsSource) {
+            assetsSource.value = this.get('offline.assets_source');
+        }
+
+        // Fonts source
+        const fontsSource = document.getElementById('fontsSource');
+        if (fontsSource) {
+            fontsSource.value = this.get('offline.fonts_source');
+        }
+
+        // Tile provider
+        const tileProvider = document.getElementById('tileProvider');
+        if (tileProvider) {
+            tileProvider.value = this.get('offline.tile_provider');
+        }
+
+        // Custom tile URL
+        const customTileUrl = document.getElementById('customTileUrl');
+        if (customTileUrl) {
+            customTileUrl.value = this.get('offline.tile_server_url') || '';
+        }
+
+        // Show/hide custom URL row
+        const customRow = document.getElementById('customTileUrlRow');
+        if (customRow) {
+            customRow.style.display = this.get('offline.tile_provider') === 'custom' ? 'block' : 'none';
+        }
+    },
+
+    /**
+     * Update map tiles on all known maps
+     */
+    _updateMapTiles() {
+        // Combine registered maps with common window map variables
+        const windowMaps = [
+            window.map,
+            window.leafletMap,
+            window.aprsMap,
+            window.radarMap,
+            window.vesselMap,
+            window.groundMap,
+            window.groundTrackMap,
+            window.meshMap,
+            window.issMap
+        ].filter(m => m && typeof m.eachLayer === 'function');
+
+        // Combine with registered maps, removing duplicates
+        const allMaps = [...new Set([...this._registeredMaps, ...windowMaps])];
+
+        if (allMaps.length === 0) return;
+
+        const config = this.getTileConfig();
+
+        allMaps.forEach(map => {
+            // Remove existing tile layers
+            map.eachLayer(layer => {
+                if (layer instanceof L.TileLayer) {
+                    map.removeLayer(layer);
+                }
+            });
+
+            // Add new tile layer
+            const options = {
+                attribution: config.attribution,
+                maxZoom: 19,
+                ...(config.options || {})
+            };
+            if (config.subdomains) {
+                options.subdomains = config.subdomains;
+            }
+
+            L.tileLayer(config.url, options).addTo(map);
+        });
+    },
+
+    /**
+     * Show reload prompt
+     */
+    _showReloadPrompt() {
+        // Create or update reload prompt
+        let prompt = document.getElementById('settingsReloadPrompt');
+        if (!prompt) {
+            prompt = document.createElement('div');
+            prompt.id = 'settingsReloadPrompt';
+            prompt.style.cssText = `
+                position: fixed;
+                bottom: 20px;
+                right: 20px;
+                background: var(--bg-dark, #0a0a0f);
+                border: 1px solid var(--accent-cyan, #00d4ff);
+                border-radius: 8px;
+                padding: 12px 16px;
+                display: flex;
+                align-items: center;
+                gap: 12px;
+                z-index: 10001;
+                box-shadow: 0 4px 20px rgba(0, 0, 0, 0.5);
+            `;
+            prompt.innerHTML = `
+                <span style="color: var(--text-primary, #e0e0e0); font-size: 13px;">
+                    Reload to apply changes
+                </span>
+                <button onclick="location.reload()" style="
+                    background: var(--accent-cyan, #00d4ff);
+                    border: none;
+                    color: #000;
+                    padding: 6px 12px;
+                    border-radius: 4px;
+                    font-size: 12px;
+                    font-weight: 500;
+                    cursor: pointer;
+                ">Reload</button>
+                <button onclick="this.parentElement.remove()" style="
+                    background: none;
+                    border: none;
+                    color: var(--text-muted, #666);
+                    font-size: 18px;
+                    cursor: pointer;
+                    padding: 0 4px;
+                ">&times;</button>
+            `;
+            document.body.appendChild(prompt);
+        }
+    }
+};
+
+// Settings modal functions
+function showSettings() {
+    const modal = document.getElementById('settingsModal');
+    if (modal) {
+        modal.classList.add('active');
+        Settings.init().then(() => {
+            Settings.checkAssets();
+        });
+    }
+}
+
+function hideSettings() {
+    const modal = document.getElementById('settingsModal');
+    if (modal) {
+        modal.classList.remove('active');
+    }
+}
+
+function switchSettingsTab(tabName) {
+    // Update tab buttons
+    document.querySelectorAll('.settings-tab').forEach(tab => {
+        tab.classList.toggle('active', tab.dataset.tab === tabName);
+    });
+
+    // Update sections
+    document.querySelectorAll('.settings-section').forEach(section => {
+        section.classList.toggle('active', section.id === `settings-${tabName}`);
+    });
+
+    // Load tools/dependencies when that tab is selected
+    if (tabName === 'tools') {
+        loadSettingsTools();
+    }
+}
+
+/**
+ * Load tool dependencies into settings modal
+ */
+function loadSettingsTools() {
+    const content = document.getElementById('settingsToolsContent');
+    if (!content) return;
+
+    content.innerHTML = '<div style="text-align: center; padding: 30px; color: var(--text-dim);">Loading dependencies...</div>';
+
+    fetch('/dependencies')
+        .then(r => r.json())
+        .then(data => {
+            if (data.status !== 'success') {
+                content.innerHTML = '<div style="color: var(--accent-red);">Error loading dependencies</div>';
+                return;
+            }
+
+            let html = '';
+            let totalMissing = 0;
+
+            for (const [modeKey, mode] of Object.entries(data.modes)) {
+                const statusColor = mode.ready ? 'var(--accent-green)' : 'var(--accent-red)';
+                const statusIcon = mode.ready ? '✓' : '✗';
+
+                html += `
+                    <div style="background: var(--bg-tertiary); border-radius: 6px; padding: 12px; margin-bottom: 10px; border-left: 3px solid ${statusColor};">
+                        <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 8px;">
+                            <span style="font-weight: 600; color: var(--accent-cyan); font-size: 13px;">${mode.name}</span>
+                            <span style="color: ${statusColor}; font-size: 11px; font-weight: bold;">${statusIcon} ${mode.ready ? 'Ready' : 'Missing'}</span>
+                        </div>
+                        <div style="display: grid; gap: 6px;">
+                `;
+
+                for (const [toolName, tool] of Object.entries(mode.tools)) {
+                    const installed = tool.installed;
+                    const dotColor = installed ? 'var(--accent-green)' : 'var(--accent-red)';
+                    const requiredBadge = tool.required ? '<span style="background: var(--accent-orange); color: #000; padding: 1px 4px; border-radius: 3px; font-size: 9px; margin-left: 4px;">REQ</span>' : '';
+
+                    if (!installed) totalMissing++;
+
+                    let installCmd = '';
+                    if (tool.install) {
+                        if (tool.install.pip) {
+                            installCmd = tool.install.pip;
+                        } else if (data.pkg_manager && tool.install[data.pkg_manager]) {
+                            installCmd = tool.install[data.pkg_manager];
+                        } else if (tool.install.manual) {
+                            installCmd = tool.install.manual;
+                        }
+                    }
+
+                    html += `
+                        <div style="display: flex; align-items: center; gap: 8px; padding: 6px 8px; background: var(--bg-secondary); border-radius: 4px; font-size: 11px;">
+                            <span style="color: ${dotColor}; font-size: 12px;">●</span>
+                            <div style="flex: 1; min-width: 0;">
+                                <span style="font-weight: 500;">${toolName}${requiredBadge}</span>
+                                <div style="font-size: 10px; color: var(--text-dim); white-space: nowrap; overflow: hidden; text-overflow: ellipsis;">${tool.description}</div>
+                            </div>
+                            ${!installed && installCmd ? `
+                                <code style="font-size: 9px; background: var(--bg-tertiary); padding: 2px 6px; border-radius: 3px; max-width: 150px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap;" title="${installCmd}">${installCmd}</code>
+                            ` : ''}
+                            <span style="font-size: 10px; color: ${dotColor}; font-weight: bold; min-width: 45px; text-align: right;">${installed ? 'OK' : 'MISSING'}</span>
+                        </div>
+                    `;
+                }
+
+                html += '</div></div>';
+            }
+
+            // Summary at top
+            const summaryHtml = `
+                <div style="background: ${totalMissing > 0 ? 'rgba(255, 100, 0, 0.1)' : 'rgba(0, 255, 100, 0.1)'}; border: 1px solid ${totalMissing > 0 ? 'var(--accent-orange)' : 'var(--accent-green)'}; border-radius: 6px; padding: 10px 12px; margin-bottom: 12px;">
+                    <div style="font-size: 13px; font-weight: bold; color: ${totalMissing > 0 ? 'var(--accent-orange)' : 'var(--accent-green)'};">
+                        ${totalMissing > 0 ? '⚠️ ' + totalMissing + ' tool(s) not found' : '✓ All tools installed'}
+                    </div>
+                    <div style="font-size: 11px; color: var(--text-dim); margin-top: 3px;">
+                        OS: ${data.os} | Package Manager: ${data.pkg_manager}
+                    </div>
+                </div>
+            `;
+
+            content.innerHTML = summaryHtml + html;
+        })
+        .catch(err => {
+            content.innerHTML = '<div style="color: var(--accent-red);">Error loading dependencies: ' + err.message + '</div>';
+        });
+}
+
+// Initialize settings on page load
+document.addEventListener('DOMContentLoaded', () => {
+    Settings.init();
+});
+
+// =============================================================================
+// Location Settings Functions
+// =============================================================================
+
+/**
+ * Load and display current observer location
+ */
+function loadObserverLocation() {
+    let lat = localStorage.getItem('observerLat');
+    let lon = localStorage.getItem('observerLon');
+    if (window.ObserverLocation && ObserverLocation.isSharedEnabled()) {
+        const shared = ObserverLocation.getShared();
+        lat = shared.lat.toString();
+        lon = shared.lon.toString();
+    }
+
+    const latInput = document.getElementById('observerLatInput');
+    const lonInput = document.getElementById('observerLonInput');
+    const currentLatDisplay = document.getElementById('currentLatDisplay');
+    const currentLonDisplay = document.getElementById('currentLonDisplay');
+
+    if (latInput && lat) latInput.value = lat;
+    if (lonInput && lon) lonInput.value = lon;
+
+    if (currentLatDisplay) {
+        currentLatDisplay.textContent = lat ? parseFloat(lat).toFixed(4) + '°' : 'Not set';
+    }
+    if (currentLonDisplay) {
+        currentLonDisplay.textContent = lon ? parseFloat(lon).toFixed(4) + '°' : 'Not set';
+    }
+
+    // Sync dashboard-specific location keys for backward compatibility
+    if (lat && lon) {
+        const locationObj = JSON.stringify({ lat: parseFloat(lat), lon: parseFloat(lon) });
+        if (!localStorage.getItem('observerLocation')) {
+            localStorage.setItem('observerLocation', locationObj);
+        }
+        if (!localStorage.getItem('ais_observerLocation')) {
+            localStorage.setItem('ais_observerLocation', locationObj);
+        }
+    }
+}
+
+/**
+ * Detect location using gpsd (USB GPS) or browser geolocation as fallback
+ */
+function detectLocationGPS(btn) {
+    const latInput = document.getElementById('observerLatInput');
+    const lonInput = document.getElementById('observerLonInput');
+
+    // Show loading state with visual feedback
+    const originalText = btn.innerHTML;
+    btn.innerHTML = '<span class="detecting-spinner"></span> Detecting...';
+    btn.disabled = true;
+    btn.style.opacity = '0.7';
+
+    // Helper to restore button state
+    function restoreButton() {
+        btn.innerHTML = originalText;
+        btn.disabled = false;
+        btn.style.opacity = '';
+    }
+
+    // Helper to set location values
+    function setLocation(lat, lon, source) {
+        if (latInput) latInput.value = parseFloat(lat).toFixed(4);
+        if (lonInput) lonInput.value = parseFloat(lon).toFixed(4);
+        restoreButton();
+        if (typeof showNotification === 'function') {
+            showNotification('Location', `Coordinates set from ${source}`);
+        }
+    }
+
+    // First, try gpsd (USB GPS device)
+    fetch('/gps/position')
+        .then(response => response.json())
+        .then(data => {
+            if (data.status === 'ok' && data.position && data.position.latitude != null) {
+                // Got valid position from gpsd
+                setLocation(data.position.latitude, data.position.longitude, 'GPS device');
+            } else if (data.status === 'waiting') {
+                // gpsd connected but no fix yet - show message and try browser
+                if (typeof showNotification === 'function') {
+                    showNotification('GPS', 'GPS device connected but no fix yet. Trying browser location...');
+                }
+                useBrowserGeolocation();
+            } else {
+                // gpsd not available, try browser geolocation
+                useBrowserGeolocation();
+            }
+        })
+        .catch(() => {
+            // gpsd request failed, try browser geolocation
+            useBrowserGeolocation();
+        });
+
+    // Fallback to browser geolocation
+    function useBrowserGeolocation() {
+        if (!navigator.geolocation) {
+            restoreButton();
+            if (typeof showNotification === 'function') {
+                showNotification('Location', 'No GPS available (gpsd not running, browser GPS unavailable)');
+            } else {
+                alert('No GPS available');
+            }
+            return;
+        }
+
+        navigator.geolocation.getCurrentPosition(
+            (pos) => {
+                setLocation(pos.coords.latitude, pos.coords.longitude, 'browser');
+            },
+            (err) => {
+                restoreButton();
+                let message = 'Failed to get location';
+                if (err.code === 1) message = 'Location access denied';
+                else if (err.code === 2) message = 'Location unavailable';
+                else if (err.code === 3) message = 'Location request timed out';
+
+                if (typeof showNotification === 'function') {
+                    showNotification('Location', message);
+                } else {
+                    alert(message);
+                }
+            },
+            { enableHighAccuracy: true, timeout: 10000 }
+        );
+    }
+}
+
+/**
+ * Save observer location to localStorage
+ */
+function saveObserverLocation() {
+    const latInput = document.getElementById('observerLatInput');
+    const lonInput = document.getElementById('observerLonInput');
+
+    const lat = parseFloat(latInput?.value);
+    const lon = parseFloat(lonInput?.value);
+
+    if (isNaN(lat) || lat < -90 || lat > 90) {
+        if (typeof showNotification === 'function') {
+            showNotification('Location', 'Invalid latitude (must be -90 to 90)');
+        } else {
+            alert('Invalid latitude (must be -90 to 90)');
+        }
+        return;
+    }
+
+    if (isNaN(lon) || lon < -180 || lon > 180) {
+        if (typeof showNotification === 'function') {
+            showNotification('Location', 'Invalid longitude (must be -180 to 180)');
+        } else {
+            alert('Invalid longitude (must be -180 to 180)');
+        }
+        return;
+    }
+
+    if (window.ObserverLocation && ObserverLocation.isSharedEnabled()) {
+        ObserverLocation.setShared({ lat, lon });
+    } else {
+        localStorage.setItem('observerLat', lat.toString());
+        localStorage.setItem('observerLon', lon.toString());
+    }
+
+    // Also update dashboard-specific location keys for ADS-B and AIS
+    const locationObj = JSON.stringify({ lat: lat, lon: lon });
+    localStorage.setItem('observerLocation', locationObj);      // ADS-B dashboard
+    localStorage.setItem('ais_observerLocation', locationObj);  // AIS dashboard
+
+    // Update display
+    const currentLatDisplay = document.getElementById('currentLatDisplay');
+    const currentLonDisplay = document.getElementById('currentLonDisplay');
+    if (currentLatDisplay) currentLatDisplay.textContent = lat.toFixed(4) + '°';
+    if (currentLonDisplay) currentLonDisplay.textContent = lon.toFixed(4) + '°';
+
+    if (typeof showNotification === 'function') {
+        showNotification('Location', 'Observer location saved');
+    }
+
+    if (window.observerLocation) {
+        window.observerLocation.lat = lat;
+        window.observerLocation.lon = lon;
+    }
+
+    // Refresh SSTV ISS schedule if available
+    if (typeof SSTV !== 'undefined' && typeof SSTV.loadIssSchedule === 'function') {
+        SSTV.loadIssSchedule();
+    }
+}
+
+// =============================================================================
+// Update Settings Functions
+// =============================================================================
+
+/**
+ * Check for updates manually from settings panel
+ */
+async function checkForUpdatesManual() {
+    const content = document.getElementById('updateStatusContent');
+    if (!content) return;
+
+    if (typeof Updater === 'undefined') {
+        content.innerHTML = `<div style="color: var(--text-dim); padding: 10px;">Update checking is unavailable. If you use a content blocker, try allowing <code>updater.js</code> to load.</div>`;
+        return;
+    }
+
+    content.innerHTML = '<div style="text-align: center; padding: 20px; color: var(--text-dim);">Checking for updates...</div>';
+
+    try {
+        const data = await Updater.checkNow();
+        renderUpdateStatus(data);
+    } catch (error) {
+        content.innerHTML = `<div style="color: var(--accent-red); padding: 10px;">Error checking for updates: ${error.message}</div>`;
+    }
+}
+
+/**
+ * Load update status when tab is opened
+ */
+async function loadUpdateStatus() {
+    const content = document.getElementById('updateStatusContent');
+    if (!content) return;
+
+    if (typeof Updater === 'undefined') {
+        content.innerHTML = `<div style="color: var(--text-dim); padding: 10px;">Update checking is unavailable. If you use a content blocker, try allowing <code>updater.js</code> to load.</div>`;
+        return;
+    }
+
+    try {
+        const data = await Updater.getStatus();
+        renderUpdateStatus(data);
+    } catch (error) {
+        content.innerHTML = `<div style="color: var(--accent-red); padding: 10px;">Error loading update status: ${error.message}</div>`;
+    }
+}
+
+/**
+ * Render update status in settings panel
+ */
+function renderUpdateStatus(data) {
+    const content = document.getElementById('updateStatusContent');
+    if (!content) return;
+
+    if (!data.success) {
+        content.innerHTML = `<div style="color: var(--accent-red); padding: 10px;">Error: ${data.error || 'Unknown error'}</div>`;
+        return;
+    }
+
+    if (data.disabled) {
+        content.innerHTML = `
+            <div style="padding: 15px; background: var(--bg-tertiary); border-radius: 6px; text-align: center;">
+                <div style="color: var(--text-dim); font-size: 13px;">Update checking is disabled</div>
+            </div>
+        `;
+        return;
+    }
+
+    if (!data.checked) {
+        content.innerHTML = `
+            <div style="padding: 15px; background: var(--bg-tertiary); border-radius: 6px; text-align: center;">
+                <div style="color: var(--text-dim); font-size: 13px;">No update check performed yet</div>
+                <div style="font-size: 11px; color: var(--text-dim); margin-top: 5px;">Click "Check Now" to check for updates</div>
+            </div>
+        `;
+        return;
+    }
+
+    const statusColor = data.update_available ? 'var(--accent-green)' : 'var(--text-dim)';
+    const statusText = data.update_available ? 'Update Available' : 'Up to Date';
+    const statusIcon = data.update_available
+        ? '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" width="20" height="20"><path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"/><polyline points="7 10 12 15 17 10"/><line x1="12" y1="15" x2="12" y2="3"/></svg>'
+        : '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" width="20" height="20"><path d="M22 11.08V12a10 10 0 1 1-5.93-9.14"/><polyline points="22 4 12 14.01 9 11.01"/></svg>';
+
+    let html = `
+        <div style="padding: 15px; background: var(--bg-tertiary); border-radius: 6px; border-left: 3px solid ${statusColor};">
+            <div style="display: flex; align-items: center; gap: 10px; margin-bottom: 12px;">
+                <span style="color: ${statusColor};">${statusIcon}</span>
+                <span style="font-weight: 600; color: ${statusColor};">${statusText}</span>
+            </div>
+            <div style="display: grid; gap: 8px; font-size: 12px;">
+                <div style="display: flex; justify-content: space-between;">
+                    <span style="color: var(--text-dim);">Current Version</span>
+                    <span style="font-family: 'Space Mono', monospace; color: var(--text-primary);">v${data.current_version}</span>
+                </div>
+                <div style="display: flex; justify-content: space-between;">
+                    <span style="color: var(--text-dim);">Latest Version</span>
+                    <span style="font-family: 'Space Mono', monospace; color: ${data.update_available ? 'var(--accent-green)' : 'var(--text-primary)'};">v${data.latest_version}</span>
+                </div>
+                ${data.last_check ? `
+                <div style="display: flex; justify-content: space-between;">
+                    <span style="color: var(--text-dim);">Last Checked</span>
+                    <span style="color: var(--text-secondary);">${formatLastCheck(data.last_check)}</span>
+                </div>
+                ` : ''}
+            </div>
+            ${data.update_available ? `
+            <button onclick="Updater.showUpdateModal()" style="
+                margin-top: 12px;
+                width: 100%;
+                padding: 8px;
+                background: var(--accent-green);
+                color: #000;
+                border: none;
+                border-radius: 4px;
+                font-size: 12px;
+                font-weight: 500;
+                cursor: pointer;
+            ">View Update Details</button>
+            ` : ''}
+        </div>
+    `;
+
+    content.innerHTML = html;
+}
+
+/**
+ * Format last check timestamp
+ */
+function formatLastCheck(isoString) {
+    try {
+        const date = new Date(isoString);
+        const now = new Date();
+        const diffMs = now - date;
+        const diffMins = Math.floor(diffMs / 60000);
+        const diffHours = Math.floor(diffMs / 3600000);
+
+        if (diffMins < 1) return 'Just now';
+        if (diffMins < 60) return `${diffMins} min ago`;
+        if (diffHours < 24) return `${diffHours} hour${diffHours > 1 ? 's' : ''} ago`;
+        return date.toLocaleDateString();
+    } catch (e) {
+        return isoString;
+    }
+}
+
+/**
+ * Toggle update checking
+ */
+async function toggleUpdateCheck(enabled) {
+    // This would require adding a setting to disable update checks
+    // For now, just store in localStorage
+    localStorage.setItem('intercept_update_check_enabled', enabled ? 'true' : 'false');
+
+    if (!enabled && typeof Updater !== 'undefined') {
+        Updater.destroy();
+    } else if (enabled && typeof Updater !== 'undefined') {
+        Updater.init();
+    }
+}
+
+// Extend switchSettingsTab to load update status
+const _originalSwitchSettingsTab = typeof switchSettingsTab !== 'undefined' ? switchSettingsTab : null;
+
+function switchSettingsTab(tabName) {
+    // Update tab buttons
+    document.querySelectorAll('.settings-tab').forEach(tab => {
+        tab.classList.toggle('active', tab.dataset.tab === tabName);
+    });
+
+    // Update sections
+    document.querySelectorAll('.settings-section').forEach(section => {
+        section.classList.toggle('active', section.id === `settings-${tabName}`);
+    });
+
+    // Load content based on tab
+    if (tabName === 'tools') {
+        loadSettingsTools();
+    } else if (tabName === 'updates') {
+        loadUpdateStatus();
+    } else if (tabName === 'location') {
+        loadObserverLocation();
+    }
+}

static/js/core/updater.js

@@ -0,0 +1,498 @@
+/**
+ * Updater Module - GitHub update checking and notification system
+ */
+
+const Updater = {
+    // State
+    _checkInterval: null,
+    _toastElement: null,
+    _modalElement: null,
+    _updateData: null,
+
+    // Configuration
+    CHECK_INTERVAL_MS: 6 * 60 * 60 * 1000, // 6 hours in milliseconds
+
+    /**
+     * Initialize the updater module
+     */
+    init() {
+        // Create toast container if it doesn't exist
+        this._ensureToastContainer();
+
+        // Check for updates on page load
+        this.checkForUpdates();
+
+        // Set up periodic checks
+        this._checkInterval = setInterval(() => {
+            this.checkForUpdates();
+        }, this.CHECK_INTERVAL_MS);
+    },
+
+    /**
+     * Ensure toast container exists in DOM
+     */
+    _ensureToastContainer() {
+        if (!document.getElementById('toastContainer')) {
+            const container = document.createElement('div');
+            container.id = 'toastContainer';
+            document.body.appendChild(container);
+        }
+    },
+
+    /**
+     * Check for updates from the server
+     * @param {boolean} force - Bypass cache and check GitHub directly
+     */
+    async checkForUpdates(force = false) {
+        try {
+            const url = force ? '/updater/check?force=true' : '/updater/check';
+            const response = await fetch(url);
+            const data = await response.json();
+
+            if (data.success && data.show_notification) {
+                this._updateData = data;
+                this.showUpdateToast(data);
+            }
+
+            return data;
+        } catch (error) {
+            console.warn('Failed to check for updates:', error);
+            return { success: false, error: error.message };
+        }
+    },
+
+    /**
+     * Get cached update status without triggering a check
+     */
+    async getStatus() {
+        try {
+            const response = await fetch('/updater/status');
+            return await response.json();
+        } catch (error) {
+            console.warn('Failed to get update status:', error);
+            return { success: false, error: error.message };
+        }
+    },
+
+    /**
+     * Show update toast notification
+     * @param {Object} data - Update data from server
+     */
+    showUpdateToast(data) {
+        // Remove existing toast if present
+        this.hideToast();
+
+        const toast = document.createElement('div');
+        toast.className = 'update-toast';
+        toast.innerHTML = `
+            <div class="update-toast-indicator"></div>
+            <div class="update-toast-content">
+                <div class="update-toast-header">
+                    <span class="update-toast-icon">
+                        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                            <path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"/>
+                            <polyline points="7 10 12 15 17 10"/>
+                            <line x1="12" y1="15" x2="12" y2="3"/>
+                        </svg>
+                    </span>
+                    <span class="update-toast-title">Update Available</span>
+                    <button class="update-toast-close" onclick="Updater.dismissUpdate()">&times;</button>
+                </div>
+                <div class="update-toast-body">
+                    Version <strong>${data.latest_version}</strong> is ready
+                </div>
+                <div class="update-toast-actions">
+                    <button class="update-toast-btn update-toast-btn-primary" onclick="Updater.showUpdateModal()">
+                        View Details
+                    </button>
+                    <button class="update-toast-btn update-toast-btn-secondary" onclick="Updater.hideToast()">
+                        Later
+                    </button>
+                </div>
+            </div>
+        `;
+
+        const container = document.getElementById('toastContainer');
+        if (container) {
+            container.appendChild(toast);
+        } else {
+            document.body.appendChild(toast);
+        }
+
+        this._toastElement = toast;
+
+        // Trigger animation
+        requestAnimationFrame(() => {
+            toast.classList.add('show');
+        });
+    },
+
+    /**
+     * Hide the update toast
+     */
+    hideToast() {
+        if (this._toastElement) {
+            this._toastElement.classList.remove('show');
+            setTimeout(() => {
+                if (this._toastElement && this._toastElement.parentNode) {
+                    this._toastElement.parentNode.removeChild(this._toastElement);
+                }
+                this._toastElement = null;
+            }, 300);
+        }
+    },
+
+    /**
+     * Dismiss update notification for this version
+     */
+    async dismissUpdate() {
+        this.hideToast();
+
+        if (this._updateData && this._updateData.latest_version) {
+            try {
+                await fetch('/updater/dismiss', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ version: this._updateData.latest_version })
+                });
+            } catch (error) {
+                console.warn('Failed to dismiss update:', error);
+            }
+        }
+    },
+
+    /**
+     * Show the full update modal with details
+     */
+    showUpdateModal() {
+        this.hideToast();
+
+        if (!this._updateData) {
+            console.warn('No update data available');
+            return;
+        }
+
+        // Remove existing modal if present
+        this.hideModal();
+
+        const data = this._updateData;
+        const releaseNotes = this._formatReleaseNotes(data.release_notes || 'No release notes available.');
+
+        const modal = document.createElement('div');
+        modal.className = 'update-modal-overlay';
+        modal.onclick = (e) => {
+            if (e.target === modal) this.hideModal();
+        };
+
+        modal.innerHTML = `
+            <div class="update-modal">
+                <div class="update-modal-header">
+                    <div class="update-modal-title">
+                        <span class="update-modal-icon">
+                            <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                                <path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"/>
+                                <polyline points="7 10 12 15 17 10"/>
+                                <line x1="12" y1="15" x2="12" y2="3"/>
+                            </svg>
+                        </span>
+                        Update Available
+                    </div>
+                    <button class="update-modal-close" onclick="Updater.hideModal()">&times;</button>
+                </div>
+                <div class="update-modal-body">
+                    <div class="update-version-info">
+                        <div class="update-version-current">
+                            <span class="update-version-label">Current</span>
+                            <span class="update-version-value">v${data.current_version}</span>
+                        </div>
+                        <div class="update-version-arrow">
+                            <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                                <line x1="5" y1="12" x2="19" y2="12"/>
+                                <polyline points="12 5 19 12 12 19"/>
+                            </svg>
+                        </div>
+                        <div class="update-version-latest">
+                            <span class="update-version-label">Latest</span>
+                            <span class="update-version-value update-version-new">v${data.latest_version}</span>
+                        </div>
+                    </div>
+
+                    <div class="update-section">
+                        <div class="update-section-title">Release Notes</div>
+                        <div class="update-release-notes">${releaseNotes}</div>
+                    </div>
+
+                    <div class="update-warning" id="updateWarning" style="display: none;">
+                        <div class="update-warning-icon">
+                            <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                                <path d="m21.73 18-8-14a2 2 0 0 0-3.48 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3Z"/>
+                                <line x1="12" y1="9" x2="12" y2="13"/>
+                                <line x1="12" y1="17" x2="12.01" y2="17"/>
+                            </svg>
+                        </div>
+                        <div class="update-warning-text">
+                            <strong>Local changes detected</strong>
+                            <p id="updateWarningText"></p>
+                        </div>
+                    </div>
+
+                    <div class="update-options" id="updateOptions" style="display: none;">
+                        <label class="update-option">
+                            <input type="checkbox" id="stashChanges">
+                            <span>Stash local changes before updating</span>
+                        </label>
+                    </div>
+
+                    <div class="update-progress" id="updateProgress" style="display: none;">
+                        <div class="update-progress-spinner"></div>
+                        <span id="updateProgressText">Updating...</span>
+                    </div>
+
+                    <div class="update-result" id="updateResult" style="display: none;"></div>
+                </div>
+                <div class="update-modal-footer">
+                    <a href="${data.release_url || '#'}" target="_blank" class="update-modal-link" ${!data.release_url ? 'style="display:none"' : ''}>
+                        View on GitHub
+                        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" width="14" height="14">
+                            <path d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6"/>
+                            <polyline points="15 3 21 3 21 9"/>
+                            <line x1="10" y1="14" x2="21" y2="3"/>
+                        </svg>
+                    </a>
+                    <div class="update-modal-actions">
+                        <button class="update-modal-btn update-modal-btn-secondary" onclick="Updater.hideModal()">
+                            Cancel
+                        </button>
+                        <button class="update-modal-btn update-modal-btn-primary" id="updateNowBtn" onclick="Updater.performUpdate()">
+                            Update Now
+                        </button>
+                    </div>
+                </div>
+            </div>
+        `;
+
+        document.body.appendChild(modal);
+        this._modalElement = modal;
+
+        // Trigger animation
+        requestAnimationFrame(() => {
+            modal.classList.add('show');
+        });
+    },
+
+    /**
+     * Hide the update modal
+     */
+    hideModal() {
+        if (this._modalElement) {
+            this._modalElement.classList.remove('show');
+            setTimeout(() => {
+                if (this._modalElement && this._modalElement.parentNode) {
+                    this._modalElement.parentNode.removeChild(this._modalElement);
+                }
+                this._modalElement = null;
+            }, 200);
+        }
+    },
+
+    /**
+     * Perform the update
+     */
+    async performUpdate() {
+        const progressEl = document.getElementById('updateProgress');
+        const progressText = document.getElementById('updateProgressText');
+        const resultEl = document.getElementById('updateResult');
+        const updateBtn = document.getElementById('updateNowBtn');
+        const warningEl = document.getElementById('updateWarning');
+        const optionsEl = document.getElementById('updateOptions');
+        const stashCheckbox = document.getElementById('stashChanges');
+
+        // Show progress
+        if (progressEl) progressEl.style.display = 'flex';
+        if (progressText) progressText.textContent = 'Checking repository status...';
+        if (updateBtn) updateBtn.disabled = true;
+        if (resultEl) resultEl.style.display = 'none';
+
+        try {
+            const stashChanges = stashCheckbox ? stashCheckbox.checked : false;
+
+            if (progressText) progressText.textContent = 'Fetching and applying updates...';
+
+            const response = await fetch('/updater/update', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ stash_changes: stashChanges })
+            });
+
+            const data = await response.json();
+
+            if (progressEl) progressEl.style.display = 'none';
+
+            if (data.success) {
+                this._showResult(resultEl, true, data);
+            } else {
+                // Handle specific error cases
+                if (data.error === 'local_changes') {
+                    if (warningEl) {
+                        warningEl.style.display = 'flex';
+                        const warningText = document.getElementById('updateWarningText');
+                        if (warningText) {
+                            warningText.textContent = data.message;
+                        }
+                    }
+                    if (optionsEl) optionsEl.style.display = 'block';
+                    if (updateBtn) updateBtn.disabled = false;
+                } else if (data.manual_update) {
+                    this._showResult(resultEl, false, data, true);
+                } else {
+                    this._showResult(resultEl, false, data);
+                }
+            }
+        } catch (error) {
+            if (progressEl) progressEl.style.display = 'none';
+            this._showResult(resultEl, false, { error: error.message });
+        }
+    },
+
+    /**
+     * Show update result
+     */
+    _showResult(resultEl, success, data, isManual = false) {
+        if (!resultEl) return;
+
+        resultEl.style.display = 'block';
+
+        if (success) {
+            if (data.updated) {
+                let message = '<strong>Update successful!</strong><br>Please restart the application to complete the update.';
+
+                if (data.requirements_changed) {
+                    message += '<br><br><strong>Dependencies changed!</strong> Run:<br><code>pip install -r requirements.txt</code>';
+                }
+
+                resultEl.className = 'update-result update-result-success';
+                resultEl.innerHTML = `
+                    <div class="update-result-icon">
+                        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                            <path d="M22 11.08V12a10 10 0 1 1-5.93-9.14"/>
+                            <polyline points="22 4 12 14.01 9 11.01"/>
+                        </svg>
+                    </div>
+                    <div class="update-result-text">${message}</div>
+                `;
+            } else {
+                resultEl.className = 'update-result update-result-info';
+                resultEl.innerHTML = `
+                    <div class="update-result-icon">
+                        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                            <circle cx="12" cy="12" r="10"/>
+                            <line x1="12" y1="16" x2="12" y2="12"/>
+                            <line x1="12" y1="8" x2="12.01" y2="8"/>
+                        </svg>
+                    </div>
+                    <div class="update-result-text">${data.message || 'Already up to date.'}</div>
+                `;
+            }
+        } else {
+            if (isManual) {
+                resultEl.className = 'update-result update-result-warning';
+                resultEl.innerHTML = `
+                    <div class="update-result-icon">
+                        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                            <path d="m21.73 18-8-14a2 2 0 0 0-3.48 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3Z"/>
+                            <line x1="12" y1="9" x2="12" y2="13"/>
+                            <line x1="12" y1="17" x2="12.01" y2="17"/>
+                        </svg>
+                    </div>
+                    <div class="update-result-text">
+                        <strong>Manual update required</strong><br>
+                        ${data.message || 'Please download the latest release from GitHub.'}
+                    </div>
+                `;
+            } else {
+                resultEl.className = 'update-result update-result-error';
+                resultEl.innerHTML = `
+                    <div class="update-result-icon">
+                        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                            <circle cx="12" cy="12" r="10"/>
+                            <line x1="15" y1="9" x2="9" y2="15"/>
+                            <line x1="9" y1="9" x2="15" y2="15"/>
+                        </svg>
+                    </div>
+                    <div class="update-result-text">
+                        <strong>Update failed</strong><br>
+                        ${data.message || data.error || 'An error occurred during the update.'}
+                        ${data.details ? '<br><code style="font-size: 10px; margin-top: 8px; display: block;">' + data.details.substring(0, 200) + '</code>' : ''}
+                    </div>
+                `;
+            }
+        }
+    },
+
+    /**
+     * Format release notes (basic markdown to HTML)
+     */
+    _formatReleaseNotes(notes) {
+        if (!notes) return '<p>No release notes available.</p>';
+
+        // Escape HTML
+        let html = notes
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;');
+
+        // Convert markdown-style formatting
+        html = html
+            // Headers
+            .replace(/^### (.+)$/gm, '<h4>$1</h4>')
+            .replace(/^## (.+)$/gm, '<h3>$1</h3>')
+            .replace(/^# (.+)$/gm, '<h2>$1</h2>')
+            // Bold
+            .replace(/\*\*(.+?)\*\*/g, '<strong>$1</strong>')
+            // Italic
+            .replace(/\*(.+?)\*/g, '<em>$1</em>')
+            // Code
+            .replace(/`(.+?)`/g, '<code>$1</code>')
+            // Lists
+            .replace(/^- (.+)$/gm, '<li>$1</li>')
+            .replace(/^(\d+)\. (.+)$/gm, '<li>$2</li>')
+            // Paragraphs
+            .replace(/\n\n/g, '</p><p>')
+            // Line breaks
+            .replace(/\n/g, '<br>');
+
+        // Wrap list items
+        html = html.replace(/(<li>.*<\/li>)+/g, '<ul>$&</ul>');
+
+        return '<p>' + html + '</p>';
+    },
+
+    /**
+     * Manual trigger for settings panel
+     */
+    async checkNow() {
+        return await this.checkForUpdates(true);
+    },
+
+    /**
+     * Clean up on page unload
+     */
+    destroy() {
+        if (this._checkInterval) {
+            clearInterval(this._checkInterval);
+            this._checkInterval = null;
+        }
+        this.hideToast();
+        this.hideModal();
+    }
+};
+
+// Initialize on DOM ready
+document.addEventListener('DOMContentLoaded', () => {
+    Updater.init();
+});
+
+// Clean up on page unload
+window.addEventListener('beforeunload', () => {
+    Updater.destroy();
+});

static/js/modes/bluetooth.js

@@ -9,6 +9,7 @@ const BluetoothMode = (function() {
     // State
     let isScanning = false;
     let eventSource = null;
+    let agentPollTimer = null;  // Polling fallback for agent mode
     let devices = new Map();
     let baselineSet = false;
     let baselineCount = 0;
@@ -36,6 +37,47 @@ const BluetoothMode = (function() {
     // Device list filter
     let currentDeviceFilter = 'all';
 
+    // Agent support
+    let showAllAgentsMode = false;
+    let lastAgentId = null;
+
+    /**
+     * Get API base URL, routing through agent proxy if agent is selected.
+     */
+    function getApiBase() {
+        if (typeof currentAgent !== 'undefined' && currentAgent !== 'local') {
+            return `/controller/agents/${currentAgent}`;
+        }
+        return '';
+    }
+
+    /**
+     * Get current agent name for tagging data.
+     */
+    function getCurrentAgentName() {
+        if (typeof currentAgent === 'undefined' || currentAgent === 'local') {
+            return 'Local';
+        }
+        if (typeof agents !== 'undefined') {
+            const agent = agents.find(a => a.id == currentAgent);
+            return agent ? agent.name : `Agent ${currentAgent}`;
+        }
+        return `Agent ${currentAgent}`;
+    }
+
+    /**
+     * Check for agent mode conflicts before starting scan.
+     */
+    function checkAgentConflicts() {
+        if (typeof currentAgent === 'undefined' || currentAgent === 'local') {
+            return true;
+        }
+        if (typeof checkAgentModeConflict === 'function') {
+            return checkAgentModeConflict('bluetooth');
+        }
+        return true;
+    }
+
     /**
      * Initialize the Bluetooth mode
      */
@@ -526,8 +568,37 @@ const BluetoothMode = (function() {
      */
     async function checkCapabilities() {
         try {
-            const response = await fetch('/api/bluetooth/capabilities');
-            const data = await response.json();
+            const isAgentMode = typeof currentAgent !== 'undefined' && currentAgent !== 'local';
+            let data;
+
+            if (isAgentMode) {
+                // Fetch capabilities from agent via controller proxy
+                const response = await fetch(`/controller/agents/${currentAgent}?refresh=true`);
+                const agentData = await response.json();
+
+                if (agentData.agent && agentData.agent.capabilities) {
+                    const agentCaps = agentData.agent.capabilities;
+                    const agentInterfaces = agentData.agent.interfaces || {};
+
+                    // Build BT-compatible capabilities object
+                    data = {
+                        available: agentCaps.bluetooth || false,
+                        adapters: (agentInterfaces.bt_adapters || []).map(adapter => ({
+                            id: adapter.id || adapter.name || adapter,
+                            name: adapter.name || adapter,
+                            powered: adapter.powered !== false
+                        })),
+                        issues: [],
+                        preferred_backend: 'auto'
+                    };
+                    console.log('[BT] Agent capabilities:', data);
+                } else {
+                    data = { available: false, adapters: [], issues: ['Agent does not support Bluetooth'] };
+                }
+            } else {
+                const response = await fetch('/api/bluetooth/capabilities');
+                data = await response.json();
+            }
 
             if (!data.available) {
                 showCapabilityWarning(['Bluetooth not available on this system']);
@@ -579,10 +650,17 @@ const BluetoothMode = (function() {
 
     async function checkScanStatus() {
         try {
-            const response = await fetch('/api/bluetooth/scan/status');
-            const data = await response.json();
+            const isAgentMode = typeof currentAgent !== 'undefined' && currentAgent !== 'local';
+            const endpoint = isAgentMode
+                ? `/controller/agents/${currentAgent}/bluetooth/status`
+                : '/api/bluetooth/scan/status';
 
-            if (data.is_scanning) {
+            const response = await fetch(endpoint);
+            const responseData = await response.json();
+            // Handle agent response format (may be nested in 'result')
+            const data = isAgentMode && responseData.result ? responseData.result : responseData;
+
+            if (data.is_scanning || data.running) {
                 setScanning(true);
                 startEventStream();
             }
@@ -599,32 +677,60 @@ const BluetoothMode = (function() {
     }
 
     async function startScan() {
+        // Check for agent mode conflicts
+        if (!checkAgentConflicts()) {
+            return;
+        }
+
         const adapter = adapterSelect?.value || '';
         const mode = scanModeSelect?.value || 'auto';
         const transport = transportSelect?.value || 'auto';
         const duration = parseInt(durationInput?.value || '0', 10);
         const minRssi = parseInt(minRssiInput?.value || '-100', 10);
 
+        const isAgentMode = typeof currentAgent !== 'undefined' && currentAgent !== 'local';
+
         try {
-            const response = await fetch('/api/bluetooth/scan/start', {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({
-                    mode: mode,
-                    adapter_id: adapter || undefined,
-                    duration_s: duration > 0 ? duration : undefined,
-                    transport: transport,
-                    rssi_threshold: minRssi
-                })
-            });
+            let response;
+            if (isAgentMode) {
+                // Route through agent proxy
+                response = await fetch(`/controller/agents/${currentAgent}/bluetooth/start`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        mode: mode,
+                        adapter_id: adapter || undefined,
+                        duration_s: duration > 0 ? duration : undefined,
+                        transport: transport,
+                        rssi_threshold: minRssi
+                    })
+                });
+            } else {
+                response = await fetch('/api/bluetooth/scan/start', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        mode: mode,
+                        adapter_id: adapter || undefined,
+                        duration_s: duration > 0 ? duration : undefined,
+                        transport: transport,
+                        rssi_threshold: minRssi
+                    })
+                });
+            }
 
             const data = await response.json();
 
-            if (data.status === 'started' || data.status === 'already_scanning') {
+            // Handle controller proxy response format (agent response is nested in 'result')
+            const scanResult = isAgentMode && data.result ? data.result : data;
+
+            if (scanResult.status === 'started' || scanResult.status === 'already_scanning') {
                 setScanning(true);
                 startEventStream();
+            } else if (scanResult.status === 'error') {
+                showErrorMessage(scanResult.message || 'Failed to start scan');
             } else {
-                showErrorMessage(data.message || 'Failed to start scan');
+                showErrorMessage(scanResult.message || 'Failed to start scan');
             }
 
         } catch (err) {
@@ -634,8 +740,14 @@ const BluetoothMode = (function() {
     }
 
     async function stopScan() {
+        const isAgentMode = typeof currentAgent !== 'undefined' && currentAgent !== 'local';
+
         try {
-            await fetch('/api/bluetooth/scan/stop', { method: 'POST' });
+            if (isAgentMode) {
+                await fetch(`/controller/agents/${currentAgent}/bluetooth/stop`, { method: 'POST' });
+            } else {
+                await fetch('/api/bluetooth/scan/stop', { method: 'POST' });
+            }
             setScanning(false);
             stopEventStream();
         } catch (err) {
@@ -680,27 +792,84 @@ const BluetoothMode = (function() {
     function startEventStream() {
         if (eventSource) eventSource.close();
 
-        eventSource = new EventSource('/api/bluetooth/stream');
+        const isAgentMode = typeof currentAgent !== 'undefined' && currentAgent !== 'local';
+        const agentName = getCurrentAgentName();
+        let streamUrl;
 
-        eventSource.addEventListener('device_update', (e) => {
-            try {
-                const device = JSON.parse(e.data);
-                handleDeviceUpdate(device);
-            } catch (err) {
-                console.error('Failed to parse device update:', err);
-            }
-        });
+        if (isAgentMode) {
+            // Use multi-agent stream for remote agents
+            streamUrl = '/controller/stream/all';
+            console.log('[BT] Starting multi-agent event stream...');
+        } else {
+            streamUrl = '/api/bluetooth/stream';
+            console.log('[BT] Starting local event stream...');
+        }
 
-        eventSource.addEventListener('scan_started', (e) => {
-            setScanning(true);
-        });
+        eventSource = new EventSource(streamUrl);
 
-        eventSource.addEventListener('scan_stopped', (e) => {
-            setScanning(false);
-        });
+        if (isAgentMode) {
+            // Handle multi-agent stream
+            eventSource.onmessage = (e) => {
+                try {
+                    const data = JSON.parse(e.data);
+
+                    // Skip keepalive and non-bluetooth data
+                    if (data.type === 'keepalive') return;
+                    if (data.scan_type !== 'bluetooth') return;
+
+                    // Filter by current agent if not in "show all" mode
+                    if (!showAllAgentsMode && typeof agents !== 'undefined') {
+                        const currentAgentObj = agents.find(a => a.id == currentAgent);
+                        if (currentAgentObj && data.agent_name && data.agent_name !== currentAgentObj.name) {
+                            return;
+                        }
+                    }
+
+                    // Transform multi-agent payload to device updates
+                    if (data.payload && data.payload.devices) {
+                        Object.values(data.payload.devices).forEach(device => {
+                            device._agent = data.agent_name || 'Unknown';
+                            handleDeviceUpdate(device);
+                        });
+                    }
+                } catch (err) {
+                    console.error('Failed to parse multi-agent event:', err);
+                }
+            };
+
+            // Also start polling as fallback (in case push isn't enabled on agent)
+            startAgentPolling();
+        } else {
+            // Handle local stream
+            eventSource.addEventListener('device_update', (e) => {
+                try {
+                    const device = JSON.parse(e.data);
+                    device._agent = 'Local';
+                    handleDeviceUpdate(device);
+                } catch (err) {
+                    console.error('Failed to parse device update:', err);
+                }
+            });
+
+            eventSource.addEventListener('scan_started', (e) => {
+                setScanning(true);
+            });
+
+            eventSource.addEventListener('scan_stopped', (e) => {
+                setScanning(false);
+            });
+        }
 
         eventSource.onerror = () => {
             console.warn('Bluetooth SSE connection error');
+            if (isScanning) {
+                // Attempt to reconnect
+                setTimeout(() => {
+                    if (isScanning) {
+                        startEventStream();
+                    }
+                }, 3000);
+            }
         };
     }
 
@@ -709,6 +878,54 @@ const BluetoothMode = (function() {
             eventSource.close();
             eventSource = null;
         }
+        if (agentPollTimer) {
+            clearInterval(agentPollTimer);
+            agentPollTimer = null;
+        }
+    }
+
+    /**
+     * Start polling agent data as fallback when push isn't enabled.
+     * This polls the controller proxy endpoint for agent data.
+     */
+    function startAgentPolling() {
+        if (agentPollTimer) return;
+
+        const pollInterval = 3000;  // 3 seconds
+        console.log('[BT] Starting agent polling fallback...');
+
+        agentPollTimer = setInterval(async () => {
+            if (!isScanning) {
+                clearInterval(agentPollTimer);
+                agentPollTimer = null;
+                return;
+            }
+
+            try {
+                const response = await fetch(`/controller/agents/${currentAgent}/bluetooth/data`);
+                if (!response.ok) return;
+
+                const result = await response.json();
+                const data = result.data || result;
+
+                // Process devices from polling response
+                if (data && data.devices) {
+                    const agentName = getCurrentAgentName();
+                    Object.values(data.devices).forEach(device => {
+                        device._agent = agentName;
+                        handleDeviceUpdate(device);
+                    });
+                } else if (data && Array.isArray(data)) {
+                    const agentName = getCurrentAgentName();
+                    data.forEach(device => {
+                        device._agent = agentName;
+                        handleDeviceUpdate(device);
+                    });
+                }
+            } catch (err) {
+                console.debug('[BT] Agent poll error:', err);
+            }
+        }, pollInterval);
     }
 
     function handleDeviceUpdate(device) {
@@ -876,6 +1093,7 @@ const BluetoothMode = (function() {
         const trackerType = device.tracker_type;
         const trackerConfidence = device.tracker_confidence;
         const riskScore = device.risk_score || 0;
+        const agentName = device._agent || 'Local';
 
         // Calculate RSSI bar width (0-100%)
         // RSSI typically ranges from -100 (weak) to -30 (very strong)
@@ -929,6 +1147,10 @@ const BluetoothMode = (function() {
         let secondaryParts = [addr];
         if (mfr) secondaryParts.push(mfr);
         secondaryParts.push('Seen ' + seenCount + '×');
+        // Add agent name if not Local
+        if (agentName !== 'Local') {
+            secondaryParts.push('<span class="agent-badge agent-remote" style="font-size:8px;padding:1px 4px;">' + escapeHtml(agentName) + '</span>');
+        }
         const secondaryInfo = secondaryParts.join(' · ');
 
         // Row border color - highlight trackers in red/orange
@@ -1019,6 +1241,112 @@ const BluetoothMode = (function() {
 
     function showErrorMessage(message) {
         console.error('[BT] Error:', message);
+        if (typeof showNotification === 'function') {
+            showNotification('Bluetooth Error', message, 'error');
+        }
+    }
+
+    function showInfo(message) {
+        console.log('[BT]', message);
+        if (typeof showNotification === 'function') {
+            showNotification('Bluetooth', message, 'info');
+        }
+    }
+
+    // ==========================================================================
+    // Agent Handling
+    // ==========================================================================
+
+    /**
+     * Handle agent change - refresh adapters and optionally clear data.
+     */
+    function handleAgentChange() {
+        const currentAgentId = typeof currentAgent !== 'undefined' ? currentAgent : 'local';
+
+        // Check if agent actually changed
+        if (lastAgentId === currentAgentId) return;
+
+        console.log('[BT] Agent changed from', lastAgentId, 'to', currentAgentId);
+
+        // Stop any running scan
+        if (isScanning) {
+            stopScan();
+        }
+
+        // Clear existing data when switching agents (unless "Show All" is enabled)
+        if (!showAllAgentsMode) {
+            clearData();
+            showInfo(`Switched to ${getCurrentAgentName()} - previous data cleared`);
+        }
+
+        // Refresh capabilities for new agent
+        checkCapabilities();
+
+        lastAgentId = currentAgentId;
+    }
+
+    /**
+     * Clear all collected data.
+     */
+    function clearData() {
+        devices.clear();
+        resetStats();
+
+        if (deviceContainer) {
+            deviceContainer.innerHTML = '';
+        }
+
+        updateDeviceCount();
+        updateProximityZones();
+        updateRadar();
+    }
+
+    /**
+     * Toggle "Show All Agents" mode.
+     */
+    function toggleShowAllAgents(enabled) {
+        showAllAgentsMode = enabled;
+        console.log('[BT] Show all agents mode:', enabled);
+
+        if (enabled) {
+            // If currently scanning, switch to multi-agent stream
+            if (isScanning && eventSource) {
+                eventSource.close();
+                startEventStream();
+            }
+            showInfo('Showing Bluetooth devices from all agents');
+        } else {
+            // Filter to current agent only
+            filterToCurrentAgent();
+        }
+    }
+
+    /**
+     * Filter devices to only show those from current agent.
+     */
+    function filterToCurrentAgent() {
+        const agentName = getCurrentAgentName();
+        const toRemove = [];
+
+        devices.forEach((device, deviceId) => {
+            if (device._agent && device._agent !== agentName) {
+                toRemove.push(deviceId);
+            }
+        });
+
+        toRemove.forEach(deviceId => devices.delete(deviceId));
+
+        // Re-render device list
+        if (deviceContainer) {
+            deviceContainer.innerHTML = '';
+            devices.forEach(device => renderDevice(device));
+        }
+
+        updateDeviceCount();
+        updateStatsFromDevices();
+        updateVisualizationPanels();
+        updateProximityZones();
+        updateRadar();
     }
 
     // Public API
@@ -1033,8 +1361,16 @@ const BluetoothMode = (function() {
         selectDevice,
         clearSelection,
         copyAddress,
+
+        // Agent handling
+        handleAgentChange,
+        clearData,
+        toggleShowAllAgents,
+
+        // Getters
         getDevices: () => Array.from(devices.values()),
-        isScanning: () => isScanning
+        isScanning: () => isScanning,
+        isShowAllAgents: () => showAllAgentsMode
     };
 })();
 

static/js/modes/dmr.js

@@ -0,0 +1,454 @@
+/**
+ * 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 = '--';
+
+// ============== 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 missing = [];
+            if (!data.dsd) missing.push('dsd (Digital Speech Decoder)');
+            if (!data.rtl_fm) missing.push('rtl_fm (RTL-SDR)');
+
+            if (missing.length > 0) {
+                warning.style.display = 'block';
+                if (warningText) warningText.textContent = missing.join(', ');
+            } else {
+                warning.style.display = 'none';
+            }
+        })
+        .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 device = typeof getSelectedDevice === 'function' ? getSelectedDevice() : 0;
+
+    fetch('/dmr/start', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ frequency, protocol, gain, device })
+    })
+    .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 showNotification === 'function') {
+                showNotification('DMR', `Decoding ${frequency} MHz (${protocol.toUpperCase()})`);
+            }
+        } else {
+            if (typeof showNotification === 'function') {
+                showNotification('Error', data.message || 'Failed to start DMR');
+            }
+        }
+    })
+    .catch(err => console.error('[DMR] Start error:', err));
+}
+
+function stopDmr() {
+    fetch('/dmr/stop', { method: 'POST' })
+    .then(r => r.json())
+    .then(() => {
+        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(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 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>
+                <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 === 'status') {
+        const statusEl = document.getElementById('dmrStatus');
+        if (statusEl) {
+            statusEl.textContent = msg.text === 'started' ? 'DECODING' : 'IDLE';
+        }
+        if (msg.text === 'stopped') {
+            isDmrRunning = false;
+            updateDmrUI();
+        }
+    }
+}
+
+// ============== 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
+    const timeSinceEvent = now - dmrLastEventTime;
+    if (timeSinceEvent > 2000) {
+        // No events for 2s — decay target toward idle
+        dmrActivityTarget = Math.max(0, dmrActivityTarget - DMR_DECAY_RATE);
+        if (dmrActivityTarget < 0.05 && 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.05 && isDmrRunning) {
+        // Gentle idle breathing
+        effectiveActivity = 0.05 + Math.sin(now / 800) * 0.035;
+    }
+
+    // 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);
+    }
+    // keepalive and status don't change visuals
+
+    updateDmrSynthStatus();
+}
+
+function updateDmrSynthStatus() {
+    const el = document.getElementById('dmrSynthStatus');
+    if (!el) return;
+
+    const labels = {
+        stopped: 'STOPPED',
+        idle: 'IDLE',
+        sync: 'SYNC',
+        call: 'CALL',
+        voice: 'VOICE'
+    };
+    const colors = {
+        stopped: 'var(--text-muted)',
+        idle: 'var(--text-muted)',
+        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);
+
+// ============== EXPORTS ==============
+
+window.startDmr = startDmr;
+window.stopDmr = stopDmr;
+window.checkDmrTools = checkDmrTools;
+window.initDmrSynthesizer = initDmrSynthesizer;

static/js/modes/spy-stations.js

@@ -84,7 +84,7 @@ const SpyStations = (function() {
             modeContainer.innerHTML = modes.map(m => `
                 <label class="inline-checkbox">
                     <input type="checkbox" data-mode="${m}" checked onchange="SpyStations.applyFilters()">
-                    <span style="font-family: 'JetBrains Mono', monospace; font-size: 10px;">${m}</span>
+                    <span style="font-family: 'Space Mono', monospace; font-size: 10px;">${m}</span>
                 </label>
             `).join('');
         }

static/js/modes/sstv-general.js

@@ -0,0 +1,410 @@
+/**
+ * SSTV General Mode
+ * Terrestrial Slow-Scan Television decoder interface
+ */
+
+const SSTVGeneral = (function() {
+    // State
+    let isRunning = false;
+    let eventSource = null;
+    let images = [];
+    let currentMode = null;
+    let progress = 0;
+
+    /**
+     * Initialize the SSTV General mode
+     */
+    function init() {
+        checkStatus();
+        loadImages();
+    }
+
+    /**
+     * Select a preset frequency from the dropdown
+     */
+    function selectPreset(value) {
+        if (!value) return;
+
+        const parts = value.split('|');
+        const freq = parseFloat(parts[0]);
+        const mod = parts[1];
+
+        const freqInput = document.getElementById('sstvGeneralFrequency');
+        const modSelect = document.getElementById('sstvGeneralModulation');
+
+        if (freqInput) freqInput.value = freq;
+        if (modSelect) modSelect.value = mod;
+
+        // Update strip display
+        const stripFreq = document.getElementById('sstvGeneralStripFreq');
+        const stripMod = document.getElementById('sstvGeneralStripMod');
+        if (stripFreq) stripFreq.textContent = freq.toFixed(3);
+        if (stripMod) stripMod.textContent = mod.toUpperCase();
+    }
+
+    /**
+     * Check current decoder status
+     */
+    async function checkStatus() {
+        try {
+            const response = await fetch('/sstv-general/status');
+            const data = await response.json();
+
+            if (!data.available) {
+                updateStatusUI('unavailable', 'Decoder not installed');
+                showStatusMessage('SSTV decoder not available. Install slowrx: apt install slowrx', 'warning');
+                return;
+            }
+
+            if (data.running) {
+                isRunning = true;
+                updateStatusUI('listening', 'Listening...');
+                startStream();
+            } else {
+                updateStatusUI('idle', 'Idle');
+            }
+
+            updateImageCount(data.image_count || 0);
+        } catch (err) {
+            console.error('Failed to check SSTV General status:', err);
+        }
+    }
+
+    /**
+     * Start SSTV decoder
+     */
+    async function start() {
+        const freqInput = document.getElementById('sstvGeneralFrequency');
+        const modSelect = document.getElementById('sstvGeneralModulation');
+        const deviceSelect = document.getElementById('deviceSelect');
+
+        const frequency = parseFloat(freqInput?.value || '14.230');
+        const modulation = modSelect?.value || 'usb';
+        const device = parseInt(deviceSelect?.value || '0', 10);
+
+        updateStatusUI('connecting', 'Starting...');
+
+        try {
+            const response = await fetch('/sstv-general/start', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ frequency, modulation, device })
+            });
+
+            const data = await response.json();
+
+            if (data.status === 'started' || data.status === 'already_running') {
+                isRunning = true;
+                updateStatusUI('listening', `${frequency} MHz ${modulation.toUpperCase()}`);
+                startStream();
+                showNotification('SSTV', `Listening on ${frequency} MHz ${modulation.toUpperCase()}`);
+
+                // Update strip
+                const stripFreq = document.getElementById('sstvGeneralStripFreq');
+                const stripMod = document.getElementById('sstvGeneralStripMod');
+                if (stripFreq) stripFreq.textContent = frequency.toFixed(3);
+                if (stripMod) stripMod.textContent = modulation.toUpperCase();
+            } else {
+                updateStatusUI('idle', 'Start failed');
+                showStatusMessage(data.message || 'Failed to start decoder', 'error');
+            }
+        } catch (err) {
+            console.error('Failed to start SSTV General:', err);
+            updateStatusUI('idle', 'Error');
+            showStatusMessage('Connection error: ' + err.message, 'error');
+        }
+    }
+
+    /**
+     * Stop SSTV decoder
+     */
+    async function stop() {
+        try {
+            await fetch('/sstv-general/stop', { method: 'POST' });
+            isRunning = false;
+            stopStream();
+            updateStatusUI('idle', 'Stopped');
+            showNotification('SSTV', 'Decoder stopped');
+        } catch (err) {
+            console.error('Failed to stop SSTV General:', err);
+        }
+    }
+
+    /**
+     * Update status UI elements
+     */
+    function updateStatusUI(status, text) {
+        const dot = document.getElementById('sstvGeneralStripDot');
+        const statusText = document.getElementById('sstvGeneralStripStatus');
+        const startBtn = document.getElementById('sstvGeneralStartBtn');
+        const stopBtn = document.getElementById('sstvGeneralStopBtn');
+
+        if (dot) {
+            dot.className = 'sstv-general-strip-dot';
+            if (status === 'listening' || status === 'detecting') {
+                dot.classList.add('listening');
+            } else if (status === 'decoding') {
+                dot.classList.add('decoding');
+            } else {
+                dot.classList.add('idle');
+            }
+        }
+
+        if (statusText) {
+            statusText.textContent = text || status;
+        }
+
+        if (startBtn && stopBtn) {
+            if (status === 'listening' || status === 'decoding') {
+                startBtn.style.display = 'none';
+                stopBtn.style.display = 'inline-block';
+            } else {
+                startBtn.style.display = 'inline-block';
+                stopBtn.style.display = 'none';
+            }
+        }
+
+        // Update live content area
+        const liveContent = document.getElementById('sstvGeneralLiveContent');
+        if (liveContent) {
+            if (status === 'idle' || status === 'unavailable') {
+                liveContent.innerHTML = renderIdleState();
+            }
+        }
+    }
+
+    /**
+     * Render idle state HTML
+     */
+    function renderIdleState() {
+        return `
+            <div class="sstv-general-idle-state">
+                <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5">
+                    <rect x="3" y="3" width="18" height="18" rx="2"/>
+                    <circle cx="12" cy="12" r="3"/>
+                    <path d="M3 9h2M19 9h2M3 15h2M19 15h2"/>
+                </svg>
+                <h4>SSTV Decoder</h4>
+                <p>Select a frequency and click Start to listen for SSTV transmissions</p>
+            </div>
+        `;
+    }
+
+    /**
+     * Start SSE stream
+     */
+    function startStream() {
+        if (eventSource) {
+            eventSource.close();
+        }
+
+        eventSource = new EventSource('/sstv-general/stream');
+
+        eventSource.onmessage = (e) => {
+            try {
+                const data = JSON.parse(e.data);
+                if (data.type === 'sstv_progress') {
+                    handleProgress(data);
+                }
+            } catch (err) {
+                console.error('Failed to parse SSE message:', err);
+            }
+        };
+
+        eventSource.onerror = () => {
+            console.warn('SSTV General SSE error, will reconnect...');
+            setTimeout(() => {
+                if (isRunning) startStream();
+            }, 3000);
+        };
+    }
+
+    /**
+     * Stop SSE stream
+     */
+    function stopStream() {
+        if (eventSource) {
+            eventSource.close();
+            eventSource = null;
+        }
+    }
+
+    /**
+     * Handle progress update
+     */
+    function handleProgress(data) {
+        currentMode = data.mode || currentMode;
+        progress = data.progress || 0;
+
+        if (data.status === 'decoding') {
+            updateStatusUI('decoding', `Decoding ${currentMode || 'image'}...`);
+            renderDecodeProgress(data);
+        } else if (data.status === 'complete' && data.image) {
+            images.unshift(data.image);
+            updateImageCount(images.length);
+            renderGallery();
+            showNotification('SSTV', 'New image decoded!');
+            updateStatusUI('listening', 'Listening...');
+        } else if (data.status === 'detecting') {
+            updateStatusUI('listening', data.message || 'Listening...');
+        }
+    }
+
+    /**
+     * Render decode progress in live area
+     */
+    function renderDecodeProgress(data) {
+        const liveContent = document.getElementById('sstvGeneralLiveContent');
+        if (!liveContent) return;
+
+        liveContent.innerHTML = `
+            <div class="sstv-general-canvas-container">
+                <canvas id="sstvGeneralCanvas" width="320" height="256"></canvas>
+            </div>
+            <div class="sstv-general-decode-info">
+                <div class="sstv-general-mode-label">${data.mode || 'Detecting mode...'}</div>
+                <div class="sstv-general-progress-bar">
+                    <div class="progress" style="width: ${data.progress || 0}%"></div>
+                </div>
+                <div class="sstv-general-status-message">${data.message || 'Decoding...'}</div>
+            </div>
+        `;
+    }
+
+    /**
+     * Load decoded images
+     */
+    async function loadImages() {
+        try {
+            const response = await fetch('/sstv-general/images');
+            const data = await response.json();
+
+            if (data.status === 'ok') {
+                images = data.images || [];
+                updateImageCount(images.length);
+                renderGallery();
+            }
+        } catch (err) {
+            console.error('Failed to load SSTV General images:', err);
+        }
+    }
+
+    /**
+     * Update image count display
+     */
+    function updateImageCount(count) {
+        const countEl = document.getElementById('sstvGeneralImageCount');
+        const stripCount = document.getElementById('sstvGeneralStripImageCount');
+
+        if (countEl) countEl.textContent = count;
+        if (stripCount) stripCount.textContent = count;
+    }
+
+    /**
+     * Render image gallery
+     */
+    function renderGallery() {
+        const gallery = document.getElementById('sstvGeneralGallery');
+        if (!gallery) return;
+
+        if (images.length === 0) {
+            gallery.innerHTML = `
+                <div class="sstv-general-gallery-empty">
+                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                        <rect x="3" y="3" width="18" height="18" rx="2"/>
+                        <circle cx="8.5" cy="8.5" r="1.5"/>
+                        <polyline points="21 15 16 10 5 21"/>
+                    </svg>
+                    <p>No images decoded yet</p>
+                </div>
+            `;
+            return;
+        }
+
+        gallery.innerHTML = images.map(img => `
+            <div class="sstv-general-image-card" onclick="SSTVGeneral.showImage('${escapeHtml(img.url)}')">
+                <img src="${escapeHtml(img.url)}" alt="SSTV Image" class="sstv-general-image-preview" loading="lazy">
+                <div class="sstv-general-image-info">
+                    <div class="sstv-general-image-mode">${escapeHtml(img.mode || 'Unknown')}</div>
+                    <div class="sstv-general-image-timestamp">${formatTimestamp(img.timestamp)}</div>
+                </div>
+            </div>
+        `).join('');
+    }
+
+    /**
+     * Show full-size image in modal
+     */
+    function showImage(url) {
+        let modal = document.getElementById('sstvGeneralImageModal');
+        if (!modal) {
+            modal = document.createElement('div');
+            modal.id = 'sstvGeneralImageModal';
+            modal.className = 'sstv-general-image-modal';
+            modal.innerHTML = `
+                <button class="sstv-general-modal-close" onclick="SSTVGeneral.closeImage()">&times;</button>
+                <img src="" alt="SSTV Image">
+            `;
+            modal.addEventListener('click', (e) => {
+                if (e.target === modal) closeImage();
+            });
+            document.body.appendChild(modal);
+        }
+
+        modal.querySelector('img').src = url;
+        modal.classList.add('show');
+    }
+
+    /**
+     * Close image modal
+     */
+    function closeImage() {
+        const modal = document.getElementById('sstvGeneralImageModal');
+        if (modal) modal.classList.remove('show');
+    }
+
+    /**
+     * Format timestamp for display
+     */
+    function formatTimestamp(isoString) {
+        if (!isoString) return '--';
+        try {
+            const date = new Date(isoString);
+            return date.toLocaleString();
+        } catch {
+            return isoString;
+        }
+    }
+
+    /**
+     * Escape HTML for safe display
+     */
+    function escapeHtml(text) {
+        if (!text) return '';
+        const div = document.createElement('div');
+        div.textContent = text;
+        return div.innerHTML;
+    }
+
+    /**
+     * Show status message
+     */
+    function showStatusMessage(message, type) {
+        if (typeof showNotification === 'function') {
+            showNotification('SSTV', message);
+        } else {
+            console.log(`[SSTV General ${type}] ${message}`);
+        }
+    }
+
+    // Public API
+    return {
+        init,
+        start,
+        stop,
+        loadImages,
+        showImage,
+        closeImage,
+        selectPreset
+    };
+})();

static/js/modes/sstv.js

@@ -0,0 +1,978 @@
+/**
+ * SSTV Mode
+ * ISS Slow-Scan Television decoder interface
+ */
+
+const SSTV = (function() {
+    // State
+    let isRunning = false;
+    let eventSource = null;
+    let images = [];
+    let currentMode = null;
+    let progress = 0;
+    let issMap = null;
+    let issMarker = null;
+    let issTrackLine = null;
+    let issPosition = null;
+    let issUpdateInterval = null;
+    let countdownInterval = null;
+    let nextPassData = null;
+
+    // ISS frequency
+    const ISS_FREQ = 145.800;
+
+    /**
+     * Initialize the SSTV mode
+     */
+    function init() {
+        checkStatus();
+        loadImages();
+        loadLocationInputs();
+        loadIssSchedule();
+        initMap();
+        startIssTracking();
+        startCountdown();
+    }
+
+    /**
+     * Load location into input fields
+     */
+    function loadLocationInputs() {
+        const latInput = document.getElementById('sstvObsLat');
+        const lonInput = document.getElementById('sstvObsLon');
+
+        let storedLat = localStorage.getItem('observerLat');
+        let storedLon = localStorage.getItem('observerLon');
+        if (window.ObserverLocation && ObserverLocation.isSharedEnabled()) {
+            const shared = ObserverLocation.getShared();
+            storedLat = shared.lat.toString();
+            storedLon = shared.lon.toString();
+        }
+
+        if (latInput && storedLat) latInput.value = storedLat;
+        if (lonInput && storedLon) lonInput.value = storedLon;
+
+        // Add change handlers to save and refresh
+        if (latInput) latInput.addEventListener('change', saveLocationFromInputs);
+        if (lonInput) lonInput.addEventListener('change', saveLocationFromInputs);
+    }
+
+    /**
+     * Save location from input fields
+     */
+    function saveLocationFromInputs() {
+        const latInput = document.getElementById('sstvObsLat');
+        const lonInput = document.getElementById('sstvObsLon');
+
+        const lat = parseFloat(latInput?.value);
+        const lon = parseFloat(lonInput?.value);
+
+        if (!isNaN(lat) && lat >= -90 && lat <= 90 &&
+            !isNaN(lon) && lon >= -180 && lon <= 180) {
+            if (window.ObserverLocation && ObserverLocation.isSharedEnabled()) {
+                ObserverLocation.setShared({ lat, lon });
+            } else {
+                localStorage.setItem('observerLat', lat.toString());
+                localStorage.setItem('observerLon', lon.toString());
+            }
+            loadIssSchedule(); // Refresh pass predictions
+        }
+    }
+
+    /**
+     * Use GPS to get location
+     */
+    function useGPS(btn) {
+        if (!navigator.geolocation) {
+            showNotification('SSTV', 'GPS not available in this browser');
+            return;
+        }
+
+        const originalText = btn.innerHTML;
+        btn.innerHTML = '<span style="opacity: 0.7;">...</span>';
+        btn.disabled = true;
+
+        navigator.geolocation.getCurrentPosition(
+            (pos) => {
+                const latInput = document.getElementById('sstvObsLat');
+                const lonInput = document.getElementById('sstvObsLon');
+
+                const lat = pos.coords.latitude.toFixed(4);
+                const lon = pos.coords.longitude.toFixed(4);
+
+                if (latInput) latInput.value = lat;
+                if (lonInput) lonInput.value = lon;
+
+                if (window.ObserverLocation && ObserverLocation.isSharedEnabled()) {
+                    ObserverLocation.setShared({ lat: parseFloat(lat), lon: parseFloat(lon) });
+                } else {
+                    localStorage.setItem('observerLat', lat);
+                    localStorage.setItem('observerLon', lon);
+                }
+
+                btn.innerHTML = originalText;
+                btn.disabled = false;
+
+                showNotification('SSTV', 'Location updated from GPS');
+                loadIssSchedule();
+            },
+            (err) => {
+                btn.innerHTML = originalText;
+                btn.disabled = false;
+
+                let msg = 'Failed to get location';
+                if (err.code === 1) msg = 'Location access denied';
+                else if (err.code === 2) msg = 'Location unavailable';
+                showNotification('SSTV', msg);
+            },
+            { enableHighAccuracy: true, timeout: 10000 }
+        );
+    }
+
+    /**
+     * Update TLE data from CelesTrak
+     */
+    async function updateTLE(btn) {
+        const originalText = btn.innerHTML;
+        btn.innerHTML = '<span style="opacity: 0.7;">Updating...</span>';
+        btn.disabled = true;
+
+        try {
+            const response = await fetch('/satellite/update-tle', { method: 'POST' });
+            const data = await response.json();
+
+            if (data.status === 'success') {
+                showNotification('SSTV', `TLE updated: ${data.updated?.length || 0} satellites`);
+                loadIssSchedule(); // Refresh predictions with new TLE
+            } else {
+                showNotification('SSTV', data.message || 'TLE update failed');
+            }
+        } catch (err) {
+            console.error('TLE update error:', err);
+            showNotification('SSTV', 'Failed to update TLE');
+        }
+
+        btn.innerHTML = originalText;
+        btn.disabled = false;
+    }
+
+    /**
+     * Initialize Leaflet map for ISS tracking
+     */
+    async function initMap() {
+        const mapContainer = document.getElementById('sstvIssMap');
+        if (!mapContainer || issMap) return;
+
+        // Create map
+        issMap = L.map('sstvIssMap', {
+            center: [0, 0],
+            zoom: 1,
+            minZoom: 1,
+            maxZoom: 6,
+            zoomControl: true,
+            attributionControl: false,
+            worldCopyJump: true
+        });
+        window.issMap = issMap;
+
+        // Add tile layer using settings manager if available
+        if (typeof Settings !== 'undefined') {
+            // Wait for settings to load from server before applying tiles
+            await Settings.init();
+            Settings.createTileLayer().addTo(issMap);
+            Settings.registerMap(issMap);
+        } else {
+            // Fallback to dark theme tiles
+            L.tileLayer('https://{s}.basemaps.cartocdn.com/dark_all/{z}/{x}/{y}{r}.png', {
+                maxZoom: 19,
+                className: 'tile-layer-cyan'
+            }).addTo(issMap);
+        }
+
+        // Create ISS icon
+        const issIcon = L.divIcon({
+            className: 'sstv-iss-marker',
+            html: `<div class="sstv-iss-dot"></div><div class="sstv-iss-label">ISS</div>`,
+            iconSize: [40, 40],
+            iconAnchor: [20, 20]
+        });
+
+        // Create ISS marker (will be positioned when we get data)
+        issMarker = L.marker([0, 0], { icon: issIcon }).addTo(issMap);
+
+        // Create ground track line
+        issTrackLine = L.polyline([], {
+            color: '#00d4ff',
+            weight: 2,
+            opacity: 0.6,
+            dashArray: '5, 5'
+        }).addTo(issMap);
+    }
+
+    /**
+     * Start ISS position tracking
+     */
+    function startIssTracking() {
+        updateIssPosition();
+        // Update every 5 seconds
+        if (issUpdateInterval) clearInterval(issUpdateInterval);
+        issUpdateInterval = setInterval(updateIssPosition, 5000);
+    }
+
+    /**
+     * Stop ISS tracking
+     */
+    function stopIssTracking() {
+        if (issUpdateInterval) {
+            clearInterval(issUpdateInterval);
+            issUpdateInterval = null;
+        }
+    }
+
+    /**
+     * Start countdown timer
+     */
+    function startCountdown() {
+        if (countdownInterval) clearInterval(countdownInterval);
+        countdownInterval = setInterval(updateCountdown, 1000);
+        updateCountdown();
+    }
+
+    /**
+     * Stop countdown timer
+     */
+    function stopCountdown() {
+        if (countdownInterval) {
+            clearInterval(countdownInterval);
+            countdownInterval = null;
+        }
+    }
+
+    /**
+     * Update countdown display
+     */
+    function updateCountdown() {
+        const valueEl = document.getElementById('sstvCountdownValue');
+        const labelEl = document.getElementById('sstvCountdownLabel');
+        const statusEl = document.getElementById('sstvCountdownStatus');
+
+        if (!nextPassData || !nextPassData.startTimestamp) {
+            if (valueEl) {
+                valueEl.textContent = '--:--:--';
+                valueEl.className = 'sstv-countdown-value';
+            }
+            if (labelEl) {
+                const hasLocation = localStorage.getItem('observerLat') !== null;
+                labelEl.textContent = hasLocation ? 'No passes in 48h' : 'Set location';
+            }
+            if (statusEl) {
+                statusEl.className = 'sstv-countdown-status';
+                statusEl.innerHTML = '<span class="sstv-status-dot"></span><span>Waiting for pass data...</span>';
+            }
+            return;
+        }
+
+        const now = Date.now();
+        const startTime = nextPassData.startTimestamp;
+        const endTime = nextPassData.endTimestamp || (startTime + (nextPassData.durationMinutes || 10) * 60 * 1000);
+        const diff = startTime - now;
+
+        if (now >= startTime && now < endTime) {
+            // Pass is currently active
+            const remaining = endTime - now;
+            const mins = Math.floor(remaining / 60000);
+            const secs = Math.floor((remaining % 60000) / 1000);
+
+            if (valueEl) {
+                valueEl.textContent = `${mins.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`;
+                valueEl.className = 'sstv-countdown-value active';
+            }
+            if (labelEl) labelEl.textContent = 'Pass in progress!';
+            if (statusEl) {
+                statusEl.className = 'sstv-countdown-status active';
+                statusEl.innerHTML = '<span class="sstv-status-dot"></span><span>ISS overhead now!</span>';
+            }
+        } else if (diff > 0) {
+            // Countdown to next pass
+            const hours = Math.floor(diff / 3600000);
+            const mins = Math.floor((diff % 3600000) / 60000);
+            const secs = Math.floor((diff % 60000) / 1000);
+
+            if (valueEl) {
+                if (hours > 0) {
+                    valueEl.textContent = `${hours}:${mins.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`;
+                } else {
+                    valueEl.textContent = `${mins.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`;
+                }
+
+                // Highlight when pass is imminent (< 5 minutes)
+                if (diff < 300000) {
+                    valueEl.className = 'sstv-countdown-value imminent';
+                } else {
+                    valueEl.className = 'sstv-countdown-value';
+                }
+            }
+
+            if (labelEl) {
+                if (diff < 60000) {
+                    labelEl.textContent = 'Starting soon!';
+                } else if (diff < 300000) {
+                    labelEl.textContent = 'Get ready!';
+                } else if (diff < 3600000) {
+                    labelEl.textContent = 'Until next pass';
+                } else {
+                    labelEl.textContent = 'Until next pass';
+                }
+            }
+
+            if (statusEl) {
+                if (diff < 300000) {
+                    statusEl.className = 'sstv-countdown-status imminent';
+                    statusEl.innerHTML = '<span class="sstv-status-dot"></span><span>Pass imminent!</span>';
+                } else {
+                    statusEl.className = 'sstv-countdown-status has-pass';
+                    statusEl.innerHTML = '<span class="sstv-status-dot"></span><span>Next pass scheduled</span>';
+                }
+            }
+        } else {
+            // Pass has ended, need to refresh schedule
+            loadIssSchedule();
+        }
+    }
+
+    /**
+     * Update countdown panel details
+     */
+    function updateCountdownDetails(pass) {
+        const startEl = document.getElementById('sstvPassStart');
+        const maxElEl = document.getElementById('sstvPassMaxEl');
+        const durationEl = document.getElementById('sstvPassDuration');
+        const directionEl = document.getElementById('sstvPassDirection');
+
+        if (!pass) {
+            if (startEl) startEl.textContent = '--:--';
+            if (maxElEl) maxElEl.textContent = '--°';
+            if (durationEl) durationEl.textContent = '-- min';
+            if (directionEl) directionEl.textContent = '--';
+            return;
+        }
+
+        if (startEl) startEl.textContent = pass.startTime || '--:--';
+        if (maxElEl) maxElEl.textContent = (pass.maxEl || '--') + '°';
+        if (durationEl) durationEl.textContent = (pass.duration || '--') + ' min';
+        if (directionEl) directionEl.textContent = pass.direction || (pass.azStart ? getDirection(pass.azStart) : '--');
+    }
+
+    /**
+     * Get compass direction from azimuth
+     */
+    function getDirection(azimuth) {
+        if (azimuth === undefined || azimuth === null) return '--';
+        const directions = ['N', 'NNE', 'NE', 'ENE', 'E', 'ESE', 'SE', 'SSE', 'S', 'SSW', 'SW', 'WSW', 'W', 'WNW', 'NW', 'NNW'];
+        const index = Math.round(azimuth / 22.5) % 16;
+        return directions[index];
+    }
+
+    /**
+     * Fetch current ISS position
+     */
+    async function updateIssPosition() {
+        const storedLat = localStorage.getItem('observerLat') || '51.5074';
+        const storedLon = localStorage.getItem('observerLon') || '-0.1278';
+
+        try {
+            const url = `/sstv/iss-position?latitude=${storedLat}&longitude=${storedLon}`;
+            const response = await fetch(url);
+            const data = await response.json();
+
+            if (data.status === 'ok') {
+                issPosition = data;
+                updateIssDisplay();
+                updateMap();
+                console.log('ISS position updated:', data.lat.toFixed(1), data.lon.toFixed(1));
+            } else {
+                console.warn('ISS position error:', data.message);
+            }
+        } catch (err) {
+            console.error('Failed to get ISS position:', err);
+        }
+    }
+
+    /**
+     * Update ISS position display
+     */
+    function updateIssDisplay() {
+        if (!issPosition) return;
+
+        const latEl = document.getElementById('sstvIssLat');
+        const lonEl = document.getElementById('sstvIssLon');
+        const altEl = document.getElementById('sstvIssAlt');
+
+        if (latEl) latEl.textContent = issPosition.lat.toFixed(1) + '°';
+        if (lonEl) lonEl.textContent = issPosition.lon.toFixed(1) + '°';
+        if (altEl) altEl.textContent = Math.round(issPosition.altitude);
+    }
+
+    /**
+     * Update map with ISS position
+     */
+    function updateMap() {
+        if (!issMap || !issPosition) return;
+
+        const lat = issPosition.lat;
+        const lon = issPosition.lon;
+
+        // Update marker position
+        if (issMarker) {
+            issMarker.setLatLng([lat, lon]);
+        }
+
+        // Calculate and draw ground track
+        if (issTrackLine) {
+            const trackPoints = [];
+            const inclination = 51.6; // ISS orbital inclination in degrees
+
+            // Generate orbit track points
+            for (let offset = -180; offset <= 180; offset += 3) {
+                let trackLon = lon + offset;
+
+                // Normalize longitude
+                while (trackLon > 180) trackLon -= 360;
+                while (trackLon < -180) trackLon += 360;
+
+                // Calculate latitude based on orbital inclination
+                const phase = (offset / 360) * 2 * Math.PI;
+                const currentPhase = Math.asin(Math.max(-1, Math.min(1, lat / inclination)));
+                let trackLat = inclination * Math.sin(phase + currentPhase);
+
+                // Clamp to valid range
+                trackLat = Math.max(-inclination, Math.min(inclination, trackLat));
+
+                trackPoints.push([trackLat, trackLon]);
+            }
+
+            // Split track at antimeridian to avoid line across map
+            const segments = [];
+            let currentSegment = [];
+
+            for (let i = 0; i < trackPoints.length; i++) {
+                if (i > 0) {
+                    const prevLon = trackPoints[i - 1][1];
+                    const currLon = trackPoints[i][1];
+                    if (Math.abs(currLon - prevLon) > 180) {
+                        // Crossed antimeridian
+                        if (currentSegment.length > 0) {
+                            segments.push(currentSegment);
+                        }
+                        currentSegment = [];
+                    }
+                }
+                currentSegment.push(trackPoints[i]);
+            }
+            if (currentSegment.length > 0) {
+                segments.push(currentSegment);
+            }
+
+            // Use only the longest segment or combine if needed
+            issTrackLine.setLatLngs(segments.length > 0 ? segments : []);
+        }
+
+        // Pan map to follow ISS
+        issMap.panTo([lat, lon], { animate: true, duration: 0.5 });
+    }
+
+    /**
+     * Check current decoder status
+     */
+    async function checkStatus() {
+        try {
+            const response = await fetch('/sstv/status');
+            const data = await response.json();
+
+            if (!data.available) {
+                updateStatusUI('unavailable', 'Decoder not installed');
+                showStatusMessage('SSTV decoder not available. Install slowrx: apt install slowrx', 'warning');
+                return;
+            }
+
+            if (data.running) {
+                isRunning = true;
+                updateStatusUI('listening', 'Listening...');
+                startStream();
+            } else {
+                updateStatusUI('idle', 'Idle');
+            }
+
+            // Update image count
+            updateImageCount(data.image_count || 0);
+        } catch (err) {
+            console.error('Failed to check SSTV status:', err);
+        }
+    }
+
+    /**
+     * Start SSTV decoder
+     */
+    async function start() {
+        const freqInput = document.getElementById('sstvFrequency');
+        // Use the global SDR device selector
+        const deviceSelect = document.getElementById('deviceSelect');
+
+        const frequency = parseFloat(freqInput?.value || ISS_FREQ);
+        const device = parseInt(deviceSelect?.value || '0', 10);
+
+        updateStatusUI('connecting', 'Starting...');
+
+        try {
+            const response = await fetch('/sstv/start', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ frequency, device })
+            });
+
+            const data = await response.json();
+
+            if (data.status === 'started' || data.status === 'already_running') {
+                isRunning = true;
+                updateStatusUI('listening', `${frequency} MHz`);
+                startStream();
+                showNotification('SSTV', `Listening on ${frequency} MHz`);
+            } else {
+                updateStatusUI('idle', 'Start failed');
+                showStatusMessage(data.message || 'Failed to start decoder', 'error');
+            }
+        } catch (err) {
+            console.error('Failed to start SSTV:', err);
+            updateStatusUI('idle', 'Error');
+            showStatusMessage('Connection error: ' + err.message, 'error');
+        }
+    }
+
+    /**
+     * Stop SSTV decoder
+     */
+    async function stop() {
+        try {
+            await fetch('/sstv/stop', { method: 'POST' });
+            isRunning = false;
+            stopStream();
+            updateStatusUI('idle', 'Stopped');
+            showNotification('SSTV', 'Decoder stopped');
+        } catch (err) {
+            console.error('Failed to stop SSTV:', err);
+        }
+    }
+
+    /**
+     * Update status UI elements
+     */
+    function updateStatusUI(status, text) {
+        const dot = document.getElementById('sstvStripDot');
+        const statusText = document.getElementById('sstvStripStatus');
+        const startBtn = document.getElementById('sstvStartBtn');
+        const stopBtn = document.getElementById('sstvStopBtn');
+
+        if (dot) {
+            dot.className = 'sstv-strip-dot';
+            if (status === 'listening' || status === 'detecting') {
+                dot.classList.add('listening');
+            } else if (status === 'decoding') {
+                dot.classList.add('decoding');
+            } else {
+                dot.classList.add('idle');
+            }
+        }
+
+        if (statusText) {
+            statusText.textContent = text || status;
+        }
+
+        if (startBtn && stopBtn) {
+            if (status === 'listening' || status === 'decoding') {
+                startBtn.style.display = 'none';
+                stopBtn.style.display = 'inline-block';
+            } else {
+                startBtn.style.display = 'inline-block';
+                stopBtn.style.display = 'none';
+            }
+        }
+
+        // Update live content area
+        const liveContent = document.getElementById('sstvLiveContent');
+        if (liveContent) {
+            if (status === 'idle' || status === 'unavailable') {
+                liveContent.innerHTML = renderIdleState();
+            }
+        }
+    }
+
+    /**
+     * Render idle state HTML
+     */
+    function renderIdleState() {
+        return `
+            <div class="sstv-idle-state">
+                <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5">
+                    <rect x="3" y="3" width="18" height="18" rx="2"/>
+                    <circle cx="12" cy="12" r="3"/>
+                    <path d="M3 9h2M19 9h2M3 15h2M19 15h2"/>
+                </svg>
+                <h4>ISS SSTV Decoder</h4>
+                <p>Click Start to listen for SSTV transmissions on 145.800 MHz</p>
+            </div>
+        `;
+    }
+
+    /**
+     * Start SSE stream
+     */
+    function startStream() {
+        if (eventSource) {
+            eventSource.close();
+        }
+
+        eventSource = new EventSource('/sstv/stream');
+
+        eventSource.onmessage = (e) => {
+            try {
+                const data = JSON.parse(e.data);
+                if (data.type === 'sstv_progress') {
+                    handleProgress(data);
+                }
+            } catch (err) {
+                console.error('Failed to parse SSE message:', err);
+            }
+        };
+
+        eventSource.onerror = () => {
+            console.warn('SSTV SSE error, will reconnect...');
+            setTimeout(() => {
+                if (isRunning) startStream();
+            }, 3000);
+        };
+    }
+
+    /**
+     * Stop SSE stream
+     */
+    function stopStream() {
+        if (eventSource) {
+            eventSource.close();
+            eventSource = null;
+        }
+    }
+
+    /**
+     * Handle progress update
+     */
+    function handleProgress(data) {
+        currentMode = data.mode || currentMode;
+        progress = data.progress || 0;
+
+        // Update status based on decode state
+        if (data.status === 'decoding') {
+            updateStatusUI('decoding', `Decoding ${currentMode || 'image'}...`);
+            renderDecodeProgress(data);
+        } else if (data.status === 'complete' && data.image) {
+            // New image decoded
+            images.unshift(data.image);
+            updateImageCount(images.length);
+            renderGallery();
+            showNotification('SSTV', 'New image decoded!');
+            updateStatusUI('listening', 'Listening...');
+        } else if (data.status === 'detecting') {
+            updateStatusUI('listening', data.message || 'Listening...');
+        }
+    }
+
+    /**
+     * Render decode progress in live area
+     */
+    function renderDecodeProgress(data) {
+        const liveContent = document.getElementById('sstvLiveContent');
+        if (!liveContent) return;
+
+        liveContent.innerHTML = `
+            <div class="sstv-canvas-container">
+                <canvas id="sstvCanvas" width="320" height="256"></canvas>
+            </div>
+            <div class="sstv-decode-info">
+                <div class="sstv-mode-label">${data.mode || 'Detecting mode...'}</div>
+                <div class="sstv-progress-bar">
+                    <div class="progress" style="width: ${data.progress || 0}%"></div>
+                </div>
+                <div class="sstv-status-message">${data.message || 'Decoding...'}</div>
+            </div>
+        `;
+    }
+
+    /**
+     * Load decoded images
+     */
+    async function loadImages() {
+        try {
+            const response = await fetch('/sstv/images');
+            const data = await response.json();
+
+            if (data.status === 'ok') {
+                images = data.images || [];
+                updateImageCount(images.length);
+                renderGallery();
+            }
+        } catch (err) {
+            console.error('Failed to load SSTV images:', err);
+        }
+    }
+
+    /**
+     * Update image count display
+     */
+    function updateImageCount(count) {
+        const countEl = document.getElementById('sstvImageCount');
+        const stripCount = document.getElementById('sstvStripImageCount');
+
+        if (countEl) countEl.textContent = count;
+        if (stripCount) stripCount.textContent = count;
+    }
+
+    /**
+     * Render image gallery
+     */
+    function renderGallery() {
+        const gallery = document.getElementById('sstvGallery');
+        if (!gallery) return;
+
+        if (images.length === 0) {
+            gallery.innerHTML = `
+                <div class="sstv-gallery-empty">
+                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                        <rect x="3" y="3" width="18" height="18" rx="2"/>
+                        <circle cx="8.5" cy="8.5" r="1.5"/>
+                        <polyline points="21 15 16 10 5 21"/>
+                    </svg>
+                    <p>No images decoded yet</p>
+                </div>
+            `;
+            return;
+        }
+
+        gallery.innerHTML = images.map(img => `
+            <div class="sstv-image-card" onclick="SSTV.showImage('${escapeHtml(img.url)}')">
+                <img src="${escapeHtml(img.url)}" alt="SSTV Image" class="sstv-image-preview" loading="lazy">
+                <div class="sstv-image-info">
+                    <div class="sstv-image-mode">${escapeHtml(img.mode || 'Unknown')}</div>
+                    <div class="sstv-image-timestamp">${formatTimestamp(img.timestamp)}</div>
+                </div>
+            </div>
+        `).join('');
+    }
+
+    /**
+     * Load ISS pass schedule
+     */
+    async function loadIssSchedule() {
+        // Try to get user's location from settings
+        const storedLat = localStorage.getItem('observerLat');
+        const storedLon = localStorage.getItem('observerLon');
+
+        // Check if location is actually set
+        const hasLocation = storedLat !== null && storedLon !== null;
+        const lat = storedLat || 51.5074;
+        const lon = storedLon || -0.1278;
+
+        try {
+            const response = await fetch(`/sstv/iss-schedule?latitude=${lat}&longitude=${lon}&hours=48`);
+            const data = await response.json();
+
+            if (data.status === 'ok' && data.passes && data.passes.length > 0) {
+                const pass = data.passes[0];
+                // Parse the pass data to get timestamps
+                nextPassData = parsePassData(pass);
+                updateCountdownDetails(pass);
+                updateCountdown();
+            } else {
+                nextPassData = null;
+                updateCountdownDetails(null);
+                updateCountdown();
+            }
+        } catch (err) {
+            console.error('Failed to load ISS schedule:', err);
+            nextPassData = null;
+            updateCountdownDetails(null);
+            updateCountdown();
+        }
+    }
+
+    /**
+     * Parse pass data to extract timestamps
+     */
+    function parsePassData(pass) {
+        if (!pass) return null;
+
+        let startTimestamp = null;
+        let endTimestamp = null;
+        const durationMinutes = parseInt(pass.duration) || 10;
+
+        // Try to parse the startTime
+        if (pass.startTimestamp) {
+            // If timestamp is provided directly
+            startTimestamp = pass.startTimestamp;
+        } else if (pass.startTime) {
+            // Parse time string (format: "HH:MM" or "HH:MM:SS" or with date)
+            startTimestamp = parseTimeString(pass.startTime, pass.date);
+        }
+
+        if (startTimestamp) {
+            endTimestamp = startTimestamp + durationMinutes * 60 * 1000;
+        }
+
+        return {
+            startTimestamp,
+            endTimestamp,
+            durationMinutes,
+            maxEl: pass.maxEl,
+            azStart: pass.azStart
+        };
+    }
+
+    /**
+     * Parse time string to timestamp
+     */
+    function parseTimeString(timeStr, dateStr) {
+        if (!timeStr) return null;
+
+        // Try to parse as a full datetime string first (e.g., "2026-01-30 03:01 UTC")
+        // Remove UTC suffix for parsing
+        const cleanedStr = timeStr.replace(' UTC', '').replace('UTC', '');
+
+        // Try full datetime parse
+        let parsed = new Date(cleanedStr);
+        if (!isNaN(parsed.getTime())) {
+            return parsed.getTime();
+        }
+
+        // Try with T separator (ISO format)
+        parsed = new Date(cleanedStr.replace(' ', 'T'));
+        if (!isNaN(parsed.getTime())) {
+            return parsed.getTime();
+        }
+
+        // Fallback: parse as time only (HH:MM or HH:MM:SS)
+        const now = new Date();
+        let targetDate = new Date();
+
+        // If a date string is provided
+        if (dateStr) {
+            const parsedDate = new Date(dateStr);
+            if (!isNaN(parsedDate)) {
+                targetDate = parsedDate;
+            }
+        }
+
+        // Parse time (HH:MM or HH:MM:SS format)
+        const timeParts = cleanedStr.split(':');
+        if (timeParts.length >= 2) {
+            const hours = parseInt(timeParts[0]);
+            const minutes = parseInt(timeParts[1]);
+            const seconds = timeParts.length > 2 ? parseInt(timeParts[2]) : 0;
+
+            if (!isNaN(hours) && !isNaN(minutes)) {
+                targetDate.setHours(hours, minutes, seconds, 0);
+
+                // If the time is in the past, assume it's tomorrow
+                if (targetDate.getTime() < now.getTime() && !dateStr) {
+                    targetDate.setDate(targetDate.getDate() + 1);
+                }
+
+                return targetDate.getTime();
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Show full-size image in modal
+     */
+    function showImage(url) {
+        let modal = document.getElementById('sstvImageModal');
+        if (!modal) {
+            modal = document.createElement('div');
+            modal.id = 'sstvImageModal';
+            modal.className = 'sstv-image-modal';
+            modal.innerHTML = `
+                <button class="sstv-modal-close" onclick="SSTV.closeImage()">&times;</button>
+                <img src="" alt="SSTV Image">
+            `;
+            modal.addEventListener('click', (e) => {
+                if (e.target === modal) closeImage();
+            });
+            document.body.appendChild(modal);
+        }
+
+        modal.querySelector('img').src = url;
+        modal.classList.add('show');
+    }
+
+    /**
+     * Close image modal
+     */
+    function closeImage() {
+        const modal = document.getElementById('sstvImageModal');
+        if (modal) modal.classList.remove('show');
+    }
+
+    /**
+     * Format timestamp for display
+     */
+    function formatTimestamp(isoString) {
+        if (!isoString) return '--';
+        try {
+            const date = new Date(isoString);
+            return date.toLocaleString();
+        } catch {
+            return isoString;
+        }
+    }
+
+    /**
+     * Escape HTML for safe display
+     */
+    function escapeHtml(text) {
+        if (!text) return '';
+        const div = document.createElement('div');
+        div.textContent = text;
+        return div.innerHTML;
+    }
+
+    /**
+     * Show status message
+     */
+    function showStatusMessage(message, type) {
+        if (typeof showNotification === 'function') {
+            showNotification('SSTV', message);
+        } else {
+            console.log(`[SSTV ${type}] ${message}`);
+        }
+    }
+
+    // Public API
+    return {
+        init,
+        start,
+        stop,
+        loadImages,
+        loadIssSchedule,
+        showImage,
+        closeImage,
+        useGPS,
+        updateTLE,
+        stopIssTracking,
+        stopCountdown
+    };
+})();
+
+// Initialize when DOM is ready (will be called by selectMode)
+document.addEventListener('DOMContentLoaded', function() {
+    // Initialization happens via selectMode when SSTV mode is activated
+});

static/js/modes/websdr.js

@@ -0,0 +1,573 @@
+/**
+ * Intercept - WebSDR Mode
+ * HF/Shortwave KiwiSDR Network Integration with In-App Audio
+ */
+
+// ============== STATE ==============
+let websdrMap = null;
+let websdrMarkers = [];
+let websdrReceivers = [];
+let websdrInitialized = false;
+let websdrSpyStationsLoaded = false;
+
+// KiwiSDR audio state
+let kiwiWebSocket = null;
+let kiwiAudioContext = null;
+let kiwiScriptProcessor = null;
+let kiwiGainNode = null;
+let kiwiAudioBuffer = [];
+let kiwiConnected = false;
+let kiwiCurrentFreq = 0;
+let kiwiCurrentMode = 'am';
+let kiwiSmeter = 0;
+let kiwiSmeterInterval = null;
+let kiwiReceiverName = '';
+
+const KIWI_SAMPLE_RATE = 12000;
+
+// ============== INITIALIZATION ==============
+
+function initWebSDR() {
+    if (websdrInitialized) {
+        if (websdrMap) {
+            setTimeout(() => websdrMap.invalidateSize(), 100);
+        }
+        return;
+    }
+
+    const mapEl = document.getElementById('websdrMap');
+    if (!mapEl || typeof L === 'undefined') return;
+
+    websdrMap = L.map('websdrMap', {
+        center: [30, 0],
+        zoom: 2,
+        zoomControl: true,
+    });
+
+    L.tileLayer('https://{s}.basemaps.cartocdn.com/dark_all/{z}/{x}/{y}{r}.png', {
+        attribution: '© OpenStreetMap contributors © CARTO',
+        subdomains: 'abcd',
+        maxZoom: 19,
+    }).addTo(websdrMap);
+
+    websdrInitialized = true;
+
+    if (!websdrSpyStationsLoaded) {
+        loadSpyStationPresets();
+    }
+
+    [100, 300, 600, 1000].forEach(delay => {
+        setTimeout(() => {
+            if (websdrMap) websdrMap.invalidateSize();
+        }, delay);
+    });
+}
+
+// ============== RECEIVER SEARCH ==============
+
+function searchReceivers(refresh) {
+    const freqKhz = parseFloat(document.getElementById('websdrFrequency')?.value || 0);
+
+    let url = '/websdr/receivers?available=true';
+    if (freqKhz > 0) url += `&freq_khz=${freqKhz}`;
+    if (refresh) url += '&refresh=true';
+
+    fetch(url)
+        .then(r => r.json())
+        .then(data => {
+            if (data.status === 'success') {
+                websdrReceivers = data.receivers || [];
+                renderReceiverList(websdrReceivers);
+                plotReceiversOnMap(websdrReceivers);
+
+                const countEl = document.getElementById('websdrReceiverCount');
+                if (countEl) countEl.textContent = `${websdrReceivers.length} found`;
+                const sidebarCount = document.getElementById('websdrSidebarCount');
+                if (sidebarCount) sidebarCount.textContent = websdrReceivers.length;
+            }
+        })
+        .catch(err => console.error('[WEBSDR] Search error:', err));
+}
+
+// ============== MAP ==============
+
+function plotReceiversOnMap(receivers) {
+    if (!websdrMap) return;
+
+    websdrMarkers.forEach(m => websdrMap.removeLayer(m));
+    websdrMarkers = [];
+
+    receivers.forEach((rx, idx) => {
+        if (rx.lat == null || rx.lon == null) return;
+
+        const marker = L.circleMarker([rx.lat, rx.lon], {
+            radius: 6,
+            fillColor: rx.available ? '#00d4ff' : '#666',
+            color: rx.available ? '#00d4ff' : '#666',
+            weight: 1,
+            opacity: 0.8,
+            fillOpacity: 0.6,
+        });
+
+        marker.bindPopup(`
+            <div style="font-size: 12px; min-width: 200px;">
+                <strong>${escapeHtmlWebsdr(rx.name)}</strong><br>
+                ${rx.location ? `<span style="color: #aaa;">${escapeHtmlWebsdr(rx.location)}</span><br>` : ''}
+                <span style="color: #888;">Antenna: ${escapeHtmlWebsdr(rx.antenna || 'Unknown')}</span><br>
+                <span style="color: #888;">Users: ${rx.users}/${rx.users_max}</span><br>
+                <button onclick="selectReceiver(${idx})" style="margin-top: 6px; padding: 4px 12px; background: #00d4ff; color: #000; border: none; border-radius: 3px; cursor: pointer; font-weight: bold;">Listen</button>
+            </div>
+        `);
+
+        marker.addTo(websdrMap);
+        websdrMarkers.push(marker);
+    });
+
+    if (websdrMarkers.length > 0) {
+        const group = L.featureGroup(websdrMarkers);
+        websdrMap.fitBounds(group.getBounds(), { padding: [30, 30] });
+    }
+}
+
+// ============== RECEIVER LIST ==============
+
+function renderReceiverList(receivers) {
+    const container = document.getElementById('websdrReceiverList');
+    if (!container) return;
+
+    if (receivers.length === 0) {
+        container.innerHTML = '<div style="color: var(--text-muted); text-align: center; padding: 20px;">No receivers found</div>';
+        return;
+    }
+
+    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;"
+             onmouseover="this.style.background='rgba(0,212,255,0.05)'" onmouseout="this.style.background='transparent'"
+             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>
+                <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;">
+                ${rx.location ? escapeHtmlWebsdr(rx.location) + ' · ' : ''}${escapeHtmlWebsdr(rx.antenna || '')}
+                ${rx.distance_km !== undefined ? ` · ${rx.distance_km} km` : ''}
+            </div>
+        </div>
+    `).join('');
+}
+
+// ============== SELECT RECEIVER ==============
+
+function selectReceiver(index) {
+    const rx = websdrReceivers[index];
+    if (!rx) return;
+
+    const freqKhz = parseFloat(document.getElementById('websdrFrequency')?.value || 7000);
+    const mode = document.getElementById('websdrMode_select')?.value || 'am';
+
+    kiwiReceiverName = rx.name;
+
+    // Connect via backend proxy
+    connectToReceiver(rx.url, freqKhz, mode);
+
+    // Highlight on map
+    if (websdrMap && rx.lat != null && rx.lon != null) {
+        websdrMap.setView([rx.lat, rx.lon], 6);
+    }
+}
+
+// ============== KIWISDR AUDIO CONNECTION ==============
+
+function connectToReceiver(receiverUrl, freqKhz, mode) {
+    // Disconnect if already connected
+    if (kiwiWebSocket) {
+        disconnectFromReceiver();
+    }
+
+    const proto = location.protocol === 'https:' ? 'wss:' : 'ws:';
+    const wsUrl = `${proto}//${location.host}/ws/kiwi-audio`;
+
+    kiwiWebSocket = new WebSocket(wsUrl);
+    kiwiWebSocket.binaryType = 'arraybuffer';
+
+    kiwiWebSocket.onopen = () => {
+        kiwiWebSocket.send(JSON.stringify({
+            cmd: 'connect',
+            url: receiverUrl,
+            freq_khz: freqKhz,
+            mode: mode,
+        }));
+        updateKiwiUI('connecting');
+    };
+
+    kiwiWebSocket.onmessage = (event) => {
+        if (typeof event.data === 'string') {
+            const msg = JSON.parse(event.data);
+            handleKiwiStatus(msg);
+        } else {
+            handleKiwiAudio(event.data);
+        }
+    };
+
+    kiwiWebSocket.onclose = () => {
+        kiwiConnected = false;
+        updateKiwiUI('disconnected');
+    };
+
+    kiwiWebSocket.onerror = () => {
+        updateKiwiUI('disconnected');
+    };
+}
+
+function handleKiwiStatus(msg) {
+    switch (msg.type) {
+        case 'connected':
+            kiwiConnected = true;
+            kiwiCurrentFreq = msg.freq_khz;
+            kiwiCurrentMode = msg.mode;
+            initKiwiAudioContext(msg.sample_rate || KIWI_SAMPLE_RATE);
+            updateKiwiUI('connected');
+            break;
+        case 'tuned':
+            kiwiCurrentFreq = msg.freq_khz;
+            kiwiCurrentMode = msg.mode;
+            updateKiwiUI('connected');
+            break;
+        case 'error':
+            console.error('[KIWI] Error:', msg.message);
+            if (typeof showNotification === 'function') {
+                showNotification('WebSDR', msg.message);
+            }
+            updateKiwiUI('error');
+            break;
+        case 'disconnected':
+            kiwiConnected = false;
+            cleanupKiwiAudio();
+            updateKiwiUI('disconnected');
+            break;
+    }
+}
+
+function handleKiwiAudio(arrayBuffer) {
+    if (arrayBuffer.byteLength < 4) return;
+
+    // First 2 bytes: S-meter (big-endian int16)
+    const view = new DataView(arrayBuffer);
+    kiwiSmeter = view.getInt16(0, false);
+
+    // Remaining bytes: PCM 16-bit signed LE
+    const pcmData = new Int16Array(arrayBuffer, 2);
+
+    // Convert to float32 [-1, 1] for Web Audio API
+    const float32 = new Float32Array(pcmData.length);
+    for (let i = 0; i < pcmData.length; i++) {
+        float32[i] = pcmData[i] / 32768.0;
+    }
+
+    // Add to playback buffer (limit buffer size to ~2s)
+    kiwiAudioBuffer.push(float32);
+    const maxChunks = Math.ceil((KIWI_SAMPLE_RATE * 2) / 512);
+    while (kiwiAudioBuffer.length > maxChunks) {
+        kiwiAudioBuffer.shift();
+    }
+}
+
+function initKiwiAudioContext(sampleRate) {
+    cleanupKiwiAudio();
+
+    kiwiAudioContext = new (window.AudioContext || window.webkitAudioContext)({
+        sampleRate: sampleRate,
+    });
+
+    // Resume if suspended (autoplay policy)
+    if (kiwiAudioContext.state === 'suspended') {
+        kiwiAudioContext.resume();
+    }
+
+    // ScriptProcessorNode: pulls audio from buffer
+    kiwiScriptProcessor = kiwiAudioContext.createScriptProcessor(2048, 0, 1);
+    kiwiScriptProcessor.onaudioprocess = (e) => {
+        const output = e.outputBuffer.getChannelData(0);
+        let offset = 0;
+
+        while (offset < output.length && kiwiAudioBuffer.length > 0) {
+            const chunk = kiwiAudioBuffer[0];
+            const needed = output.length - offset;
+            const available = chunk.length;
+
+            if (available <= needed) {
+                output.set(chunk, offset);
+                offset += available;
+                kiwiAudioBuffer.shift();
+            } else {
+                output.set(chunk.subarray(0, needed), offset);
+                kiwiAudioBuffer[0] = chunk.subarray(needed);
+                offset += needed;
+            }
+        }
+
+        // Fill remaining with silence
+        while (offset < output.length) {
+            output[offset++] = 0;
+        }
+    };
+
+    // Volume control
+    kiwiGainNode = kiwiAudioContext.createGain();
+    const savedVol = localStorage.getItem('kiwiVolume');
+    kiwiGainNode.gain.value = savedVol !== null ? parseFloat(savedVol) / 100 : 0.8;
+    const volValue = Math.round(kiwiGainNode.gain.value * 100);
+    ['kiwiVolume', 'kiwiBarVolume'].forEach(id => {
+        const el = document.getElementById(id);
+        if (el) el.value = volValue;
+    });
+
+    kiwiScriptProcessor.connect(kiwiGainNode);
+    kiwiGainNode.connect(kiwiAudioContext.destination);
+
+    // S-meter display updates
+    if (kiwiSmeterInterval) clearInterval(kiwiSmeterInterval);
+    kiwiSmeterInterval = setInterval(updateSmeterDisplay, 200);
+}
+
+function disconnectFromReceiver() {
+    if (kiwiWebSocket && kiwiWebSocket.readyState === WebSocket.OPEN) {
+        kiwiWebSocket.send(JSON.stringify({ cmd: 'disconnect' }));
+    }
+    cleanupKiwiAudio();
+    if (kiwiWebSocket) {
+        kiwiWebSocket.close();
+        kiwiWebSocket = null;
+    }
+    kiwiConnected = false;
+    kiwiReceiverName = '';
+    updateKiwiUI('disconnected');
+}
+
+function cleanupKiwiAudio() {
+    if (kiwiSmeterInterval) {
+        clearInterval(kiwiSmeterInterval);
+        kiwiSmeterInterval = null;
+    }
+    if (kiwiScriptProcessor) {
+        kiwiScriptProcessor.disconnect();
+        kiwiScriptProcessor = null;
+    }
+    if (kiwiGainNode) {
+        kiwiGainNode.disconnect();
+        kiwiGainNode = null;
+    }
+    if (kiwiAudioContext) {
+        kiwiAudioContext.close().catch(() => {});
+        kiwiAudioContext = null;
+    }
+    kiwiAudioBuffer = [];
+    kiwiSmeter = 0;
+}
+
+function tuneKiwi(freqKhz, mode) {
+    if (!kiwiWebSocket || !kiwiConnected) return;
+    kiwiWebSocket.send(JSON.stringify({
+        cmd: 'tune',
+        freq_khz: freqKhz,
+        mode: mode || kiwiCurrentMode,
+    }));
+}
+
+function tuneFromBar() {
+    const freq = parseFloat(document.getElementById('kiwiBarFrequency')?.value || 0);
+    const mode = document.getElementById('kiwiBarMode')?.value || kiwiCurrentMode;
+    if (freq > 0) {
+        tuneKiwi(freq, mode);
+        // Also update sidebar frequency
+        const freqInput = document.getElementById('websdrFrequency');
+        if (freqInput) freqInput.value = freq;
+    }
+}
+
+function setKiwiVolume(value) {
+    if (kiwiGainNode) {
+        kiwiGainNode.gain.value = value / 100;
+        localStorage.setItem('kiwiVolume', value);
+    }
+    // Sync both volume sliders
+    ['kiwiVolume', 'kiwiBarVolume'].forEach(id => {
+        const el = document.getElementById(id);
+        if (el && el.value !== String(value)) el.value = value;
+    });
+}
+
+// ============== S-METER ==============
+
+function updateSmeterDisplay() {
+    // KiwiSDR S-meter: value in 0.1 dBm units (e.g., -730 = -73 dBm = S9)
+    const dbm = kiwiSmeter / 10;
+    let sUnit;
+    if (dbm >= -73) {
+        const over = Math.round((dbm + 73));
+        sUnit = over > 0 ? `S9+${over}` : 'S9';
+    } else {
+        sUnit = `S${Math.max(0, Math.round((dbm + 127) / 6))}`;
+    }
+
+    const pct = Math.min(100, Math.max(0, (dbm + 127) / 1.27));
+
+    // Update both sidebar and bar S-meter displays
+    ['kiwiSmeterBar', 'kiwiBarSmeter'].forEach(id => {
+        const el = document.getElementById(id);
+        if (el) el.style.width = pct + '%';
+    });
+    ['kiwiSmeterValue', 'kiwiBarSmeterValue'].forEach(id => {
+        const el = document.getElementById(id);
+        if (el) el.textContent = sUnit;
+    });
+}
+
+// ============== UI UPDATES ==============
+
+function updateKiwiUI(state) {
+    const statusEl = document.getElementById('kiwiStatus');
+    const controlsBar = document.getElementById('kiwiAudioControls');
+    const disconnectBtn = document.getElementById('kiwiDisconnectBtn');
+    const receiverNameEl = document.getElementById('kiwiReceiverName');
+    const freqDisplay = document.getElementById('kiwiFreqDisplay');
+    const barReceiverName = document.getElementById('kiwiBarReceiverName');
+    const barFreq = document.getElementById('kiwiBarFrequency');
+    const barMode = document.getElementById('kiwiBarMode');
+
+    if (state === 'connected') {
+        if (statusEl) {
+            statusEl.textContent = 'CONNECTED';
+            statusEl.style.color = 'var(--accent-green)';
+        }
+        if (controlsBar) controlsBar.style.display = 'block';
+        if (disconnectBtn) disconnectBtn.style.display = 'block';
+        if (receiverNameEl) {
+            receiverNameEl.textContent = kiwiReceiverName;
+            receiverNameEl.style.display = 'block';
+        }
+        if (freqDisplay) freqDisplay.textContent = kiwiCurrentFreq + ' kHz';
+        if (barReceiverName) barReceiverName.textContent = kiwiReceiverName;
+        if (barFreq) barFreq.value = kiwiCurrentFreq;
+        if (barMode) barMode.value = kiwiCurrentMode;
+    } else if (state === 'connecting') {
+        if (statusEl) {
+            statusEl.textContent = 'CONNECTING...';
+            statusEl.style.color = 'var(--accent-orange)';
+        }
+    } else if (state === 'error') {
+        if (statusEl) {
+            statusEl.textContent = 'ERROR';
+            statusEl.style.color = 'var(--accent-red)';
+        }
+    } else {
+        // disconnected
+        if (statusEl) {
+            statusEl.textContent = 'DISCONNECTED';
+            statusEl.style.color = 'var(--text-muted)';
+        }
+        if (controlsBar) controlsBar.style.display = 'none';
+        if (disconnectBtn) disconnectBtn.style.display = 'none';
+        if (receiverNameEl) receiverNameEl.style.display = 'none';
+        if (freqDisplay) freqDisplay.textContent = '--- kHz';
+        // Reset both S-meter displays (sidebar + bar)
+        ['kiwiSmeterBar', 'kiwiBarSmeter'].forEach(id => {
+            const el = document.getElementById(id);
+            if (el) el.style.width = '0%';
+        });
+        ['kiwiSmeterValue', 'kiwiBarSmeterValue'].forEach(id => {
+            const el = document.getElementById(id);
+            if (el) el.textContent = 'S0';
+        });
+    }
+}
+
+// ============== SPY STATION PRESETS ==============
+
+function loadSpyStationPresets() {
+    fetch('/spy-stations/stations')
+        .then(r => r.json())
+        .then(data => {
+            websdrSpyStationsLoaded = true;
+            const container = document.getElementById('websdrSpyPresets');
+            if (!container) return;
+
+            const stations = data.stations || data || [];
+            if (!Array.isArray(stations) || stations.length === 0) {
+                container.innerHTML = '<div style="color: var(--text-muted); text-align: center; padding: 10px;">No stations available</div>';
+                return;
+            }
+
+            container.innerHTML = stations.slice(0, 30).map(s => {
+                const primaryFreq = s.frequencies?.find(f => f.primary) || s.frequencies?.[0];
+                const freqKhz = primaryFreq?.freq_khz || 0;
+                return `
+                    <div style="padding: 6px 4px; border-bottom: 1px solid rgba(255,255,255,0.05); cursor: pointer; display: flex; justify-content: space-between; align-items: center;"
+                         onclick="tuneToSpyStation('${escapeHtmlWebsdr(s.id)}', ${freqKhz})"
+                         onmouseover="this.style.background='rgba(0,212,255,0.05)'" onmouseout="this.style.background='transparent'">
+                        <div>
+                            <span style="color: var(--accent-cyan); font-weight: bold;">${escapeHtmlWebsdr(s.name)}</span>
+                            <span style="color: var(--text-muted); font-size: 9px; margin-left: 4px;">${escapeHtmlWebsdr(s.nickname || '')}</span>
+                        </div>
+                        <span style="color: var(--accent-orange); font-family: var(--font-mono); font-size: 10px;">${freqKhz} kHz</span>
+                    </div>
+                `;
+            }).join('');
+        })
+        .catch(err => {
+            console.error('[WEBSDR] Failed to load spy station presets:', err);
+        });
+}
+
+function tuneToSpyStation(stationId, freqKhz) {
+    const freqInput = document.getElementById('websdrFrequency');
+    if (freqInput) freqInput.value = freqKhz;
+
+    // If already connected, just retune
+    if (kiwiConnected) {
+        const mode = document.getElementById('websdrMode_select')?.value || kiwiCurrentMode;
+        tuneKiwi(freqKhz, mode);
+        return;
+    }
+
+    // Otherwise, search for receivers at this frequency
+    fetch(`/websdr/spy-station/${encodeURIComponent(stationId)}/receivers`)
+        .then(r => r.json())
+        .then(data => {
+            if (data.status === 'success') {
+                websdrReceivers = data.receivers || [];
+                renderReceiverList(websdrReceivers);
+                plotReceiversOnMap(websdrReceivers);
+
+                const countEl = document.getElementById('websdrReceiverCount');
+                if (countEl) countEl.textContent = `${websdrReceivers.length} for ${data.station?.name || stationId}`;
+
+                if (typeof showNotification === 'function' && data.station) {
+                    showNotification('WebSDR', `Found ${websdrReceivers.length} receivers for ${data.station.name} at ${freqKhz} kHz`);
+                }
+            }
+        })
+        .catch(err => console.error('[WEBSDR] Spy station receivers error:', err));
+}
+
+// ============== UTILITIES ==============
+
+function escapeHtmlWebsdr(str) {
+    if (!str) return '';
+    const div = document.createElement('div');
+    div.textContent = str;
+    return div.innerHTML;
+}
+
+// ============== EXPORTS ==============
+
+window.initWebSDR = initWebSDR;
+window.searchReceivers = searchReceivers;
+window.selectReceiver = selectReceiver;
+window.tuneToSpyStation = tuneToSpyStation;
+window.loadSpyStationPresets = loadSpyStationPresets;
+window.connectToReceiver = connectToReceiver;
+window.disconnectFromReceiver = disconnectFromReceiver;
+window.tuneKiwi = tuneKiwi;
+window.tuneFromBar = tuneFromBar;
+window.setKiwiVolume = setKiwiVolume;

static/js/modes/wifi.js

@@ -28,6 +28,47 @@ const WiFiMode = (function() {
         maxProbes: 1000,
     };
 
+    // ==========================================================================
+    // Agent Support
+    // ==========================================================================
+
+    /**
+     * Get the API base URL, routing through agent proxy if agent is selected.
+     */
+    function getApiBase() {
+        if (typeof currentAgent !== 'undefined' && currentAgent !== 'local') {
+            return `/controller/agents/${currentAgent}/wifi/v2`;
+        }
+        return CONFIG.apiBase;
+    }
+
+    /**
+     * Get the current agent name for tagging data.
+     */
+    function getCurrentAgentName() {
+        if (typeof currentAgent === 'undefined' || currentAgent === 'local') {
+            return 'Local';
+        }
+        if (typeof agents !== 'undefined') {
+            const agent = agents.find(a => a.id == currentAgent);
+            return agent ? agent.name : `Agent ${currentAgent}`;
+        }
+        return `Agent ${currentAgent}`;
+    }
+
+    /**
+     * Check for agent mode conflicts before starting WiFi scan.
+     */
+    function checkAgentConflicts() {
+        if (typeof currentAgent === 'undefined' || currentAgent === 'local') {
+            return true;
+        }
+        if (typeof checkAgentModeConflict === 'function') {
+            return checkAgentModeConflict('wifi');
+        }
+        return true;
+    }
+
     // ==========================================================================
     // State
     // ==========================================================================
@@ -36,6 +77,7 @@ const WiFiMode = (function() {
     let scanMode = 'quick'; // 'quick' or 'deep'
     let eventSource = null;
     let pollTimer = null;
+    let agentPollTimer = null;
 
     // Data stores
     let networks = new Map(); // bssid -> network
@@ -49,6 +91,10 @@ const WiFiMode = (function() {
     let currentFilter = 'all';
     let currentSort = { field: 'rssi', order: 'desc' };
 
+    // Agent state
+    let showAllAgentsMode = false;  // Show combined results from all agents
+    let lastAgentId = null;  // Track agent switches
+
     // Capabilities
     let capabilities = null;
 
@@ -154,11 +200,43 @@ const WiFiMode = (function() {
 
     async function checkCapabilities() {
         try {
-            const response = await fetch(`${CONFIG.apiBase}/capabilities`);
-            if (!response.ok) throw new Error('Failed to fetch capabilities');
+            const isAgentMode = typeof currentAgent !== 'undefined' && currentAgent !== 'local';
+            let response;
 
-            capabilities = await response.json();
-            console.log('[WiFiMode] Capabilities:', capabilities);
+            if (isAgentMode) {
+                // Fetch capabilities from agent via controller proxy
+                response = await fetch(`/controller/agents/${currentAgent}?refresh=true`);
+                if (!response.ok) throw new Error('Failed to fetch agent capabilities');
+
+                const data = await response.json();
+                // Extract WiFi capabilities from agent data
+                if (data.agent && data.agent.capabilities) {
+                    const agentCaps = data.agent.capabilities;
+                    const agentInterfaces = data.agent.interfaces || {};
+
+                    // Build WiFi-compatible capabilities object
+                    capabilities = {
+                        can_quick_scan: agentCaps.wifi || false,
+                        can_deep_scan: agentCaps.wifi || false,
+                        interfaces: (agentInterfaces.wifi_interfaces || []).map(iface => ({
+                            name: iface.name || iface,
+                            supports_monitor: iface.supports_monitor !== false
+                        })),
+                        default_interface: agentInterfaces.default_wifi || null,
+                        preferred_quick_tool: 'agent',
+                        issues: []
+                    };
+                    console.log('[WiFiMode] Agent capabilities:', capabilities);
+                } else {
+                    throw new Error('Agent does not support WiFi mode');
+                }
+            } else {
+                // Local capabilities
+                response = await fetch(`${CONFIG.apiBase}/capabilities`);
+                if (!response.ok) throw new Error('Failed to fetch capabilities');
+                capabilities = await response.json();
+                console.log('[WiFiMode] Local capabilities:', capabilities);
+            }
 
             updateCapabilityUI();
             populateInterfaceSelect();
@@ -282,17 +360,34 @@ const WiFiMode = (function() {
     async function startQuickScan() {
         if (isScanning) return;
 
+        // Check for agent mode conflicts
+        if (!checkAgentConflicts()) {
+            return;
+        }
+
         console.log('[WiFiMode] Starting quick scan...');
         setScanning(true, 'quick');
 
         try {
             const iface = elements.interfaceSelect?.value || null;
+            const isAgentMode = typeof currentAgent !== 'undefined' && currentAgent !== 'local';
+            const agentName = getCurrentAgentName();
 
-            const response = await fetch(`${CONFIG.apiBase}/scan/quick`, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ interface: iface }),
-            });
+            let response;
+            if (isAgentMode) {
+                // Route through agent proxy
+                response = await fetch(`/controller/agents/${currentAgent}/wifi/start`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ interface: iface, scan_type: 'quick' }),
+                });
+            } else {
+                response = await fetch(`${CONFIG.apiBase}/scan/quick`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ interface: iface }),
+                });
+            }
 
             if (!response.ok) {
                 const error = await response.json();
@@ -302,20 +397,26 @@ const WiFiMode = (function() {
             const result = await response.json();
             console.log('[WiFiMode] Quick scan complete:', result);
 
+            // Handle controller proxy response format (agent response is nested in 'result')
+            const scanResult = isAgentMode && result.result ? result.result : result;
+
             // Check for error first
-            if (result.error) {
-                console.error('[WiFiMode] Quick scan error from server:', result.error);
-                showError(result.error);
+            if (scanResult.error || scanResult.status === 'error') {
+                console.error('[WiFiMode] Quick scan error from server:', scanResult.error || scanResult.message);
+                showError(scanResult.error || scanResult.message || 'Quick scan failed');
                 setScanning(false);
                 return;
             }
 
+            // Handle agent response format
+            let accessPoints = scanResult.access_points || scanResult.networks || [];
+
             // Check if we got results
-            if (!result.access_points || result.access_points.length === 0) {
+            if (accessPoints.length === 0) {
                 // No error but no results
                 let msg = 'Quick scan found no networks in range.';
-                if (result.warnings && result.warnings.length > 0) {
-                    msg += ' Warnings: ' + result.warnings.join('; ');
+                if (scanResult.warnings && scanResult.warnings.length > 0) {
+                    msg += ' Warnings: ' + scanResult.warnings.join('; ');
                 }
                 console.warn('[WiFiMode] ' + msg);
                 showError(msg + ' Try Deep Scan with monitor mode.');
@@ -323,13 +424,18 @@ const WiFiMode = (function() {
                 return;
             }
 
+            // Tag results with agent source
+            accessPoints.forEach(ap => {
+                ap._agent = agentName;
+            });
+
             // Show any warnings even on success
-            if (result.warnings && result.warnings.length > 0) {
-                console.warn('[WiFiMode] Quick scan warnings:', result.warnings);
+            if (scanResult.warnings && scanResult.warnings.length > 0) {
+                console.warn('[WiFiMode] Quick scan warnings:', scanResult.warnings);
             }
 
             // Process results
-            processQuickScanResult(result);
+            processQuickScanResult({ ...scanResult, access_points: accessPoints });
 
             // For quick scan, we're done after one scan
             // But keep polling if user wants continuous updates
@@ -346,6 +452,11 @@ const WiFiMode = (function() {
     async function startDeepScan() {
         if (isScanning) return;
 
+        // Check for agent mode conflicts
+        if (!checkAgentConflicts()) {
+            return;
+        }
+
         console.log('[WiFiMode] Starting deep scan...');
         setScanning(true, 'deep');
 
@@ -353,24 +464,55 @@ const WiFiMode = (function() {
             const iface = elements.interfaceSelect?.value || null;
             const band = document.getElementById('wifiBand')?.value || 'all';
             const channel = document.getElementById('wifiChannel')?.value || null;
+            const isAgentMode = typeof currentAgent !== 'undefined' && currentAgent !== 'local';
 
-            const response = await fetch(`${CONFIG.apiBase}/scan/start`, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({
-                    interface: iface,
-                    band: band === 'abg' ? 'all' : band === 'bg' ? '2.4' : '5',
-                    channel: channel ? parseInt(channel) : null,
-                }),
-            });
+            let response;
+            if (isAgentMode) {
+                // Route through agent proxy
+                response = await fetch(`/controller/agents/${currentAgent}/wifi/start`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        interface: iface,
+                        scan_type: 'deep',
+                        band: band === 'abg' ? 'all' : band === 'bg' ? '2.4' : '5',
+                        channel: channel ? parseInt(channel) : null,
+                    }),
+                });
+            } else {
+                response = await fetch(`${CONFIG.apiBase}/scan/start`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        interface: iface,
+                        band: band === 'abg' ? 'all' : band === 'bg' ? '2.4' : '5',
+                        channel: channel ? parseInt(channel) : null,
+                    }),
+                });
+            }
 
             if (!response.ok) {
                 const error = await response.json();
                 throw new Error(error.error || 'Failed to start deep scan');
             }
 
-            // Start SSE stream for real-time updates
+            // Check for agent error in response
+            if (isAgentMode) {
+                const result = await response.json();
+                const scanResult = result.result || result;
+                if (scanResult.status === 'error') {
+                    throw new Error(scanResult.message || 'Agent failed to start deep scan');
+                }
+                console.log('[WiFiMode] Agent deep scan started:', scanResult);
+            }
+
+            // Start SSE stream for real-time updates (works with push-enabled agents)
             startEventStream();
+
+            // Also start polling for agent data (works without push enabled)
+            if (isAgentMode) {
+                startAgentDeepScanPolling();
+            }
         } catch (error) {
             console.error('[WiFiMode] Deep scan error:', error);
             showError(error.message);
@@ -387,19 +529,26 @@ const WiFiMode = (function() {
             pollTimer = null;
         }
 
+        // Stop agent polling
+        stopAgentDeepScanPolling();
+
         // Close event stream
         if (eventSource) {
             eventSource.close();
             eventSource = null;
         }
 
-        // Stop deep scan on server
-        if (scanMode === 'deep') {
-            try {
+        // Stop scan on server (local or agent)
+        const isAgentMode = typeof currentAgent !== 'undefined' && currentAgent !== 'local';
+
+        try {
+            if (isAgentMode) {
+                await fetch(`/controller/agents/${currentAgent}/wifi/stop`, { method: 'POST' });
+            } else if (scanMode === 'deep') {
                 await fetch(`${CONFIG.apiBase}/scan/stop`, { method: 'POST' });
-            } catch (error) {
-                console.warn('[WiFiMode] Error stopping scan:', error);
             }
+        } catch (error) {
+            console.warn('[WiFiMode] Error stopping scan:', error);
         }
 
         setScanning(false);
@@ -431,15 +580,31 @@ const WiFiMode = (function() {
 
     async function checkScanStatus() {
         try {
-            const response = await fetch(`${CONFIG.apiBase}/scan/status`);
+            const isAgentMode = typeof currentAgent !== 'undefined' && currentAgent !== 'local';
+            const endpoint = isAgentMode
+                ? `/controller/agents/${currentAgent}/wifi/status`
+                : `${CONFIG.apiBase}/scan/status`;
+
+            const response = await fetch(endpoint);
             if (!response.ok) return;
 
-            const status = await response.json();
+            const data = await response.json();
+            // Handle agent response format (may be nested in 'result')
+            const status = isAgentMode && data.result ? data.result : data;
 
-            if (status.is_scanning) {
-                setScanning(true, status.scan_mode);
-                if (status.scan_mode === 'deep') {
+            if (status.is_scanning || status.running) {
+                // Agent returns scan_type in params, local returns scan_mode
+                // Normalize: agent may return 'deepscan' or 'deep', UI expects 'deep' or 'quick'
+                let detectedMode = status.scan_mode || (status.params && status.params.scan_type) || 'deep';
+                if (detectedMode === 'deepscan') detectedMode = 'deep';
+
+                setScanning(true, detectedMode);
+                if (detectedMode === 'deep') {
                     startEventStream();
+                    // Also start polling for agent mode (works without push enabled)
+                    if (isAgentMode) {
+                        startAgentDeepScanPolling();
+                    }
                 } else {
                     startQuickScanPolling();
                 }
@@ -508,6 +673,76 @@ const WiFiMode = (function() {
         });
     }
 
+    // ==========================================================================
+    // Agent Deep Scan Polling (fallback when push is not enabled)
+    // ==========================================================================
+
+    function startAgentDeepScanPolling() {
+        if (agentPollTimer) return;
+
+        console.log('[WiFiMode] Starting agent deep scan polling...');
+
+        agentPollTimer = setInterval(async () => {
+            if (!isScanning || scanMode !== 'deep') {
+                clearInterval(agentPollTimer);
+                agentPollTimer = null;
+                return;
+            }
+
+            const isAgentMode = typeof currentAgent !== 'undefined' && currentAgent !== 'local';
+            if (!isAgentMode) {
+                clearInterval(agentPollTimer);
+                agentPollTimer = null;
+                return;
+            }
+
+            try {
+                const response = await fetch(`/controller/agents/${currentAgent}/wifi/data`);
+                if (!response.ok) return;
+
+                const result = await response.json();
+                if (result.status !== 'success' || !result.data) return;
+
+                const data = result.data.data || result.data;
+                const agentName = result.agent_name || 'Remote';
+
+                // Process networks
+                if (data.networks && Array.isArray(data.networks)) {
+                    data.networks.forEach(net => {
+                        net._agent = agentName;
+                        handleStreamEvent({
+                            type: 'network_update',
+                            network: net
+                        });
+                    });
+                }
+
+                // Process clients
+                if (data.clients && Array.isArray(data.clients)) {
+                    data.clients.forEach(client => {
+                        client._agent = agentName;
+                        handleStreamEvent({
+                            type: 'client_update',
+                            client: client
+                        });
+                    });
+                }
+
+                console.debug(`[WiFiMode] Agent poll: ${data.networks?.length || 0} networks, ${data.clients?.length || 0} clients`);
+
+            } catch (error) {
+                console.debug('[WiFiMode] Agent poll error:', error);
+            }
+        }, 2000); // Poll every 2 seconds
+    }
+
+    function stopAgentDeepScanPolling() {
+        if (agentPollTimer) {
+            clearInterval(agentPollTimer);
+            agentPollTimer = null;
+        }
+    }
+
     // ==========================================================================
     // SSE Event Stream
     // ==========================================================================
@@ -517,8 +752,20 @@ const WiFiMode = (function() {
             eventSource.close();
         }
 
-        console.log('[WiFiMode] Starting event stream...');
-        eventSource = new EventSource(`${CONFIG.apiBase}/stream`);
+        const isAgentMode = typeof currentAgent !== 'undefined' && currentAgent !== 'local';
+        const agentName = getCurrentAgentName();
+        let streamUrl;
+
+        if (isAgentMode) {
+            // Use multi-agent stream for remote agents
+            streamUrl = '/controller/stream/all';
+            console.log('[WiFiMode] Starting multi-agent event stream...');
+        } else {
+            streamUrl = `${CONFIG.apiBase}/stream`;
+            console.log('[WiFiMode] Starting local event stream...');
+        }
+
+        eventSource = new EventSource(streamUrl);
 
         eventSource.onopen = () => {
             console.log('[WiFiMode] Event stream connected');
@@ -527,7 +774,46 @@ const WiFiMode = (function() {
         eventSource.onmessage = (event) => {
             try {
                 const data = JSON.parse(event.data);
-                handleStreamEvent(data);
+
+                // For multi-agent stream, filter and transform data
+                if (isAgentMode) {
+                    // Skip keepalive and non-wifi data
+                    if (data.type === 'keepalive') return;
+                    if (data.scan_type !== 'wifi') return;
+
+                    // Filter by current agent if not in "show all" mode
+                    if (!showAllAgentsMode && typeof agents !== 'undefined') {
+                        const currentAgentObj = agents.find(a => a.id == currentAgent);
+                        if (currentAgentObj && data.agent_name && data.agent_name !== currentAgentObj.name) {
+                            return;
+                        }
+                    }
+
+                    // Transform multi-agent payload to stream event format
+                    if (data.payload && data.payload.networks) {
+                        data.payload.networks.forEach(net => {
+                            net._agent = data.agent_name || 'Unknown';
+                            handleStreamEvent({
+                                type: 'network_update',
+                                network: net
+                            });
+                        });
+                    }
+                    if (data.payload && data.payload.clients) {
+                        data.payload.clients.forEach(client => {
+                            client._agent = data.agent_name || 'Unknown';
+                            handleStreamEvent({
+                                type: 'client_update',
+                                client: client
+                            });
+                        });
+                    }
+                } else {
+                    // Local stream - tag with local
+                    if (data.network) data.network._agent = 'Local';
+                    if (data.client) data.client._agent = 'Local';
+                    handleStreamEvent(data);
+                }
             } catch (error) {
                 console.debug('[WiFiMode] Event parse error:', error);
             }
@@ -593,6 +879,7 @@ const WiFiMode = (function() {
         updateNetworkRow(network);
         updateStats();
         updateProximityRadar();
+        updateChannelChart();
 
         if (onNetworkUpdate) onNetworkUpdate(network);
     }
@@ -601,6 +888,9 @@ const WiFiMode = (function() {
         clients.set(client.mac, client);
         updateStats();
 
+        // Update client display if this client belongs to the selected network
+        updateClientInList(client);
+
         if (onClientUpdate) onClientUpdate(client);
     }
 
@@ -745,6 +1035,10 @@ const WiFiMode = (function() {
         const hiddenBadge = network.is_hidden ? '<span class="badge badge-hidden">Hidden</span>' : '';
         const newBadge = network.is_new ? '<span class="badge badge-new">New</span>' : '';
 
+        // Agent source badge
+        const agentName = network._agent || 'Local';
+        const agentClass = agentName === 'Local' ? 'agent-local' : 'agent-remote';
+
         return `
             <tr class="wifi-network-row ${network.bssid === selectedNetwork ? 'selected' : ''}"
                 data-bssid="${escapeHtml(network.bssid)}"
@@ -762,6 +1056,9 @@ const WiFiMode = (function() {
                     <span class="security-badge ${securityClass}">${escapeHtml(network.security)}</span>
                 </td>
                 <td class="col-clients">${network.client_count || 0}</td>
+                <td class="col-agent">
+                    <span class="agent-badge ${agentClass}">${escapeHtml(agentName)}</span>
+                </td>
             </tr>
         `;
     }
@@ -842,6 +1139,9 @@ const WiFiMode = (function() {
 
         // Show the drawer
         elements.detailDrawer.classList.add('open');
+
+        // Fetch and display clients for this network
+        fetchClientsForNetwork(network.bssid);
     }
 
     function closeDetail() {
@@ -854,6 +1154,130 @@ const WiFiMode = (function() {
         });
     }
 
+    // ==========================================================================
+    // Client Display
+    // ==========================================================================
+
+    async function fetchClientsForNetwork(bssid) {
+        if (!elements.detailClientList) return;
+
+        try {
+            const isAgentMode = typeof currentAgent !== 'undefined' && currentAgent !== 'local';
+            let response;
+
+            if (isAgentMode) {
+                // Route through agent proxy
+                response = await fetch(`/controller/agents/${currentAgent}/wifi/v2/clients?bssid=${encodeURIComponent(bssid)}&associated=true`);
+            } else {
+                response = await fetch(`${CONFIG.apiBase}/clients?bssid=${encodeURIComponent(bssid)}&associated=true`);
+            }
+
+            if (!response.ok) {
+                // Hide client list on error
+                elements.detailClientList.style.display = 'none';
+                return;
+            }
+
+            const data = await response.json();
+            // Handle agent response format (may be nested in 'result')
+            const result = isAgentMode && data.result ? data.result : data;
+            const clientList = result.clients || [];
+
+            if (clientList.length > 0) {
+                renderClientList(clientList, bssid);
+                elements.detailClientList.style.display = 'block';
+            } else {
+                elements.detailClientList.style.display = 'none';
+            }
+        } catch (error) {
+            console.debug('[WiFiMode] Error fetching clients:', error);
+            elements.detailClientList.style.display = 'none';
+        }
+    }
+
+    function renderClientList(clientList, bssid) {
+        const container = elements.detailClientList?.querySelector('.wifi-client-list');
+        const countBadge = document.getElementById('wifiClientCountBadge');
+
+        if (!container) return;
+
+        // Update count badge
+        if (countBadge) {
+            countBadge.textContent = clientList.length;
+        }
+
+        // Render client cards
+        container.innerHTML = clientList.map(client => {
+            const rssi = client.rssi_current;
+            const signalClass = rssi >= -50 ? 'signal-strong' :
+                               rssi >= -70 ? 'signal-medium' :
+                               rssi >= -85 ? 'signal-weak' : 'signal-very-weak';
+
+            // Format last seen time
+            const lastSeen = client.last_seen ? formatTime(client.last_seen) : '--';
+
+            // Build probed SSIDs badges
+            let probesHtml = '';
+            if (client.probed_ssids && client.probed_ssids.length > 0) {
+                const probes = client.probed_ssids.slice(0, 5); // Show max 5
+                probesHtml = `
+                    <div class="wifi-client-probes">
+                        ${probes.map(ssid => `<span class="wifi-client-probe-badge">${escapeHtml(ssid)}</span>`).join('')}
+                        ${client.probed_ssids.length > 5 ? `<span class="wifi-client-probe-badge">+${client.probed_ssids.length - 5}</span>` : ''}
+                    </div>
+                `;
+            }
+
+            return `
+                <div class="wifi-client-card" data-mac="${escapeHtml(client.mac)}">
+                    <div class="wifi-client-identity">
+                        <span class="wifi-client-mac">${escapeHtml(client.mac)}</span>
+                        <span class="wifi-client-vendor">${escapeHtml(client.vendor || 'Unknown vendor')}</span>
+                        ${probesHtml}
+                    </div>
+                    <div class="wifi-client-signal">
+                        <span class="wifi-client-rssi ${signalClass}">${rssi !== null && rssi !== undefined ? rssi + ' dBm' : '--'}</span>
+                        <span class="wifi-client-lastseen">${lastSeen}</span>
+                    </div>
+                </div>
+            `;
+        }).join('');
+    }
+
+    function updateClientInList(client) {
+        // Check if this client belongs to the currently selected network
+        if (!selectedNetwork || client.associated_bssid !== selectedNetwork) {
+            return;
+        }
+
+        const container = elements.detailClientList?.querySelector('.wifi-client-list');
+        if (!container) return;
+
+        const existingCard = container.querySelector(`[data-mac="${client.mac}"]`);
+
+        if (existingCard) {
+            // Update existing card's RSSI and last seen
+            const rssiEl = existingCard.querySelector('.wifi-client-rssi');
+            const lastSeenEl = existingCard.querySelector('.wifi-client-lastseen');
+
+            if (rssiEl && client.rssi_current !== null && client.rssi_current !== undefined) {
+                const rssi = client.rssi_current;
+                const signalClass = rssi >= -50 ? 'signal-strong' :
+                                   rssi >= -70 ? 'signal-medium' :
+                                   rssi >= -85 ? 'signal-weak' : 'signal-very-weak';
+                rssiEl.textContent = rssi + ' dBm';
+                rssiEl.className = 'wifi-client-rssi ' + signalClass;
+            }
+
+            if (lastSeenEl && client.last_seen) {
+                lastSeenEl.textContent = formatTime(client.last_seen);
+            }
+        } else {
+            // New client for this network - re-fetch the full list
+            fetchClientsForNetwork(selectedNetwork);
+        }
+    }
+
     // ==========================================================================
     // Statistics
     // ==========================================================================
@@ -997,9 +1421,15 @@ const WiFiMode = (function() {
         return Object.values(stats).filter(s => s.ap_count > 0 || [1, 6, 11, 36, 40, 44, 48, 149, 153, 157, 161, 165].includes(s.channel));
     }
 
-    function updateChannelChart(band = '2.4') {
+    function updateChannelChart(band) {
         if (typeof ChannelChart === 'undefined') return;
 
+        // Use the currently active band tab if no band specified
+        if (!band) {
+            const activeTab = elements.channelBandTabs && elements.channelBandTabs.querySelector('.channel-band-tab.active');
+            band = activeTab ? activeTab.dataset.band : '2.4';
+        }
+
         // Recalculate channel stats from networks if needed
         if (channelStats.length === 0 && networks.size > 0) {
             channelStats = calculateChannelStats();
@@ -1071,6 +1501,126 @@ const WiFiMode = (function() {
         }
     }
 
+    // ==========================================================================
+    // Agent Handling
+    // ==========================================================================
+
+    /**
+     * Handle agent change - refresh interfaces and optionally clear data.
+     * Called when user selects a different agent.
+     */
+    function handleAgentChange() {
+        const currentAgentId = typeof currentAgent !== 'undefined' ? currentAgent : 'local';
+
+        // Check if agent actually changed
+        if (lastAgentId === currentAgentId) return;
+
+        console.log('[WiFiMode] Agent changed from', lastAgentId, 'to', currentAgentId);
+
+        // Stop UI polling only - don't stop the actual scan on the agent
+        // The agent should continue running independently
+        if (isScanning) {
+            stopAgentDeepScanPolling();
+            if (pollTimer) {
+                clearInterval(pollTimer);
+                pollTimer = null;
+            }
+            if (eventSource) {
+                eventSource.close();
+                eventSource = null;
+            }
+            setScanning(false);
+        }
+
+        // Clear existing data when switching agents (unless "Show All" is enabled)
+        if (!showAllAgentsMode) {
+            clearData();
+            showInfo(`Switched to ${getCurrentAgentName()} - previous data cleared`);
+        }
+
+        // Refresh capabilities for new agent
+        checkCapabilities();
+
+        // Check if new agent already has a scan running
+        checkScanStatus();
+
+        lastAgentId = currentAgentId;
+    }
+
+    /**
+     * Clear all collected data.
+     */
+    function clearData() {
+        networks.clear();
+        clients.clear();
+        probeRequests = [];
+        channelStats = [];
+        recommendations = [];
+
+        updateNetworkTable();
+        updateStats();
+        updateProximityRadar();
+        updateChannelChart();
+    }
+
+    /**
+     * Toggle "Show All Agents" mode.
+     * When enabled, displays combined WiFi results from all agents.
+     */
+    function toggleShowAllAgents(enabled) {
+        showAllAgentsMode = enabled;
+        console.log('[WiFiMode] Show all agents mode:', enabled);
+
+        if (enabled) {
+            // If currently scanning, switch to multi-agent stream
+            if (isScanning && eventSource) {
+                eventSource.close();
+                startEventStream();
+            }
+            showInfo('Showing WiFi networks from all agents');
+        } else {
+            // Filter to current agent only
+            filterToCurrentAgent();
+        }
+    }
+
+    /**
+     * Filter networks to only show those from current agent.
+     */
+    function filterToCurrentAgent() {
+        const agentName = getCurrentAgentName();
+        const toRemove = [];
+
+        networks.forEach((network, bssid) => {
+            if (network._agent && network._agent !== agentName) {
+                toRemove.push(bssid);
+            }
+        });
+
+        toRemove.forEach(bssid => networks.delete(bssid));
+
+        // Also filter clients
+        const clientsToRemove = [];
+        clients.forEach((client, mac) => {
+            if (client._agent && client._agent !== agentName) {
+                clientsToRemove.push(mac);
+            }
+        });
+        clientsToRemove.forEach(mac => clients.delete(mac));
+
+        updateNetworkTable();
+        updateStats();
+        updateProximityRadar();
+    }
+
+    /**
+     * Refresh WiFi interfaces from current agent.
+     * Called when agent changes.
+     */
+    async function refreshInterfaces() {
+        await checkCapabilities();
+    }
+
     // ==========================================================================
     // Public API
     // ==========================================================================
@@ -1086,12 +1636,19 @@ const WiFiMode = (function() {
         exportData,
         checkCapabilities,
 
+        // Agent handling
+        handleAgentChange,
+        clearData,
+        toggleShowAllAgents,
+        refreshInterfaces,
+
         // Getters
         getNetworks: () => Array.from(networks.values()),
         getClients: () => Array.from(clients.values()),
         getProbes: () => [...probeRequests],
         isScanning: () => isScanning,
         getScanMode: () => scanMode,
+        isShowAllAgents: () => showAllAgentsMode,
 
         // Callbacks
         onNetworkUpdate: (cb) => { onNetworkUpdate = cb; },

static/vendor/chartjs/chartjs-adapter-date-fns.bundle.min.js

@@ -0,0 +1,124 @@
+/*!
+ * chartjs-adapter-date-fns v3.0.0 - Lightweight date adapter for Chart.js
+ * Uses native Date parsing (no external dependencies)
+ */
+(function() {
+  'use strict';
+  const FORMATS = {
+    datetime: 'MMM d, yyyy, h:mm:ss a',
+    millisecond: 'h:mm:ss.SSS a',
+    second: 'h:mm:ss a',
+    minute: 'h:mm a',
+    hour: 'ha',
+    day: 'MMM d',
+    week: 'PP',
+    month: 'MMM yyyy',
+    quarter: "'Q'Q - yyyy",
+    year: 'yyyy'
+  };
+
+  function formatDate(date, fmt) {
+    const d = new Date(date);
+    if (isNaN(d.getTime())) return '';
+    const h = d.getHours();
+    const m = d.getMinutes();
+    const s = d.getSeconds();
+    const ms = d.getMilliseconds();
+    const months = ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'];
+    const ampm = h >= 12 ? 'PM' : 'AM';
+    const h12 = h % 12 || 12;
+
+    switch(fmt) {
+      case 'h:mm:ss.SSS a':
+        return `${h12}:${String(m).padStart(2,'0')}:${String(s).padStart(2,'0')}.${String(ms).padStart(3,'0')} ${ampm}`;
+      case 'h:mm:ss a':
+        return `${h12}:${String(m).padStart(2,'0')}:${String(s).padStart(2,'0')} ${ampm}`;
+      case 'h:mm a':
+        return `${h12}:${String(m).padStart(2,'0')} ${ampm}`;
+      case 'ha':
+        return `${h12}${ampm}`;
+      case 'MMM d':
+        return `${months[d.getMonth()]} ${d.getDate()}`;
+      case 'MMM yyyy':
+        return `${months[d.getMonth()]} ${d.getFullYear()}`;
+      case 'yyyy':
+        return `${d.getFullYear()}`;
+      default:
+        return `${months[d.getMonth()]} ${d.getDate()}, ${d.getFullYear()}, ${h12}:${String(m).padStart(2,'0')}:${String(s).padStart(2,'0')} ${ampm}`;
+    }
+  }
+
+  const UNITS = ['millisecond','second','minute','hour','day','week','month','quarter','year'];
+  const UNIT_MS = {
+    millisecond: 1,
+    second: 1000,
+    minute: 60000,
+    hour: 3600000,
+    day: 86400000,
+    week: 604800000,
+    month: 2592000000,
+    quarter: 7776000000,
+    year: 31536000000
+  };
+
+  if (typeof Chart !== 'undefined' && Chart._adapters && Chart._adapters._date) {
+    const adapter = Chart._adapters._date;
+    adapter.override({
+      _id: 'date-fns-lite',
+      formats: function() { return FORMATS; },
+      parse: function(value) {
+        if (value === null || value === undefined) return null;
+        if (typeof value === 'number') return value;
+        const d = new Date(value);
+        return isNaN(d.getTime()) ? null : d.getTime();
+      },
+      format: function(time, fmt) {
+        return formatDate(time, fmt);
+      },
+      add: function(time, amount, unit) {
+        const d = new Date(time);
+        switch(unit) {
+          case 'millisecond': d.setTime(d.getTime() + amount); break;
+          case 'second': d.setSeconds(d.getSeconds() + amount); break;
+          case 'minute': d.setMinutes(d.getMinutes() + amount); break;
+          case 'hour': d.setHours(d.getHours() + amount); break;
+          case 'day': d.setDate(d.getDate() + amount); break;
+          case 'week': d.setDate(d.getDate() + amount * 7); break;
+          case 'month': d.setMonth(d.getMonth() + amount); break;
+          case 'quarter': d.setMonth(d.getMonth() + amount * 3); break;
+          case 'year': d.setFullYear(d.getFullYear() + amount); break;
+        }
+        return d.getTime();
+      },
+      diff: function(max, min, unit) {
+        return (max - min) / (UNIT_MS[unit] || 1);
+      },
+      startOf: function(time, unit) {
+        const d = new Date(time);
+        switch(unit) {
+          case 'second': d.setMilliseconds(0); break;
+          case 'minute': d.setSeconds(0,0); break;
+          case 'hour': d.setMinutes(0,0,0); break;
+          case 'day': d.setHours(0,0,0,0); break;
+          case 'week': d.setHours(0,0,0,0); d.setDate(d.getDate() - d.getDay()); break;
+          case 'month': d.setHours(0,0,0,0); d.setDate(1); break;
+          case 'quarter': d.setHours(0,0,0,0); d.setMonth(d.getMonth() - d.getMonth() % 3, 1); break;
+          case 'year': d.setHours(0,0,0,0); d.setMonth(0,1); break;
+        }
+        return d.getTime();
+      },
+      endOf: function(time, unit) {
+        const d = new Date(time);
+        switch(unit) {
+          case 'second': d.setMilliseconds(999); break;
+          case 'minute': d.setSeconds(59,999); break;
+          case 'hour': d.setMinutes(59,59,999); break;
+          case 'day': d.setHours(23,59,59,999); break;
+          case 'month': d.setMonth(d.getMonth()+1,0); d.setHours(23,59,59,999); break;
+          case 'year': d.setMonth(11,31); d.setHours(23,59,59,999); break;
+        }
+        return d.getTime();
+      }
+    });
+  }
+})();